kc3-lang/angle/src/compiler/translator/TextureFunctionHLSL.h

• Show log

  Commit

• Hash : a977acc8
  Author :
  Date : 2018-09-19T12:46:05
  

  ES31: Support translating textureGather into HLSL - Part I
  
  This patch is the first one in the series of supporting GLSL texture
  function textureGather/textureGatherOffset on D3D11.
  
  According to ESSL 3.1 SPEC (Chapter 8.9.3, Page 130), the definition
  of textureGather on sampler2D is:
      gvec4 textureGather (gsampler2D sampler, vec2 P[, int comp])
  
  The parameter "comp" is optional, and if it is specified, the value
  of "comp" must be a constant integer expression with a value of 0, 1,
  2, or 3, identifying the x, y, z, or w postswizzled component of the
  four-component vector lookup result for each texel, respectively. If
  comp is not specified, it is treated as 0.
  
  According to the definition above, textureGather is equivalent to
  Texture2D.Gather[Red|Green|Blue|Alpha] in HLSL, where we can use a
  switch-case expression to choose the right HLSL texture function.
  
  The features listed here will be implemented in the following patches:
  1. Support textureGatherOffset
  2. Support textureGather[Offset] on isamplers and usamplers
  3. Support textureGather[Offset] on textures when swizzle is on
  4. Support textureGather[Offset] on shadow samplers
  
  BUG=angleproject:2826
  TEST=dEQP-GLES31.functional.texture.gather.basic.2d.rgba8.*
       dEQP-GLES31.functional.texture.gather.basic.cube.rgba8.*
       (without texture_swizzle)
       dEQP-GLES31.functional.texture.gather.basic.2d_array.rgba8.*
       (without texture_swizzle)
  
  Change-Id: Iff2ed4f8b65dad613cb0bafdfd19f8f0528e832c
  Reviewed-on: https://chromium-review.googlesource.com/1232980
  Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
  Reviewed-by: Corentin Wallez <cwallez@chromium.org>
  

Download

• src/compiler/translator/TextureFunctionHLSL.h

• //
  // Copyright (c) 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // TextureFunctionHLSL: Class for writing implementations of ESSL texture functions into HLSL
  // output. Some of the implementations are straightforward and just call the HLSL equivalent of the
  // ESSL texture function, others do more work to emulate ESSL texture sampling or size query
  // behavior.
  //
  
  #ifndef COMPILER_TRANSLATOR_TEXTUREFUNCTIONHLSL_H_
  #define COMPILER_TRANSLATOR_TEXTUREFUNCTIONHLSL_H_
  
  #include <set>
  
  #include "compiler/translator/BaseTypes.h"
  #include "compiler/translator/Common.h"
  #include "compiler/translator/InfoSink.h"
  #include "GLSLANG/ShaderLang.h"
  
  namespace sh
  {
  
  class TextureFunctionHLSL final : angle::NonCopyable
  {
    public:
      struct TextureFunction
      {
          // See ESSL 3.00.6 section 8.8 for reference about what the different methods below do.
          enum Method
          {
              IMPLICIT,  // Mipmap LOD determined implicitly (standard lookup)
              BIAS,
              LOD,
              LOD0,
              LOD0BIAS,
              SIZE,  // textureSize()
              FETCH,
              GRAD,
              GATHER
          };
  
          ImmutableString name() const;
  
          bool operator<(const TextureFunction &rhs) const;
  
          const char *getReturnType() const;
  
          TBasicType sampler;
          int coords;
          bool proj;
          bool offset;
          Method method;
      };
  
      // Returns the name of the texture function implementation to call.
      // The name that's passed in is the name of the GLSL texture function that it should implement.
      ImmutableString useTextureFunction(const ImmutableString &name,
                                         TBasicType samplerType,
                                         int coords,
                                         size_t argumentCount,
                                         bool lod0,
                                         sh::GLenum shaderType);
  
      void textureFunctionHeader(TInfoSinkBase &out,
                                 const ShShaderOutput outputType,
                                 bool getDimensionsIgnoresBaseLevel);
  
    private:
      typedef std::set<TextureFunction> TextureFunctionSet;
      TextureFunctionSet mUsesTexture;
  };
  
  }  // namespace sh
  
  #endif  // COMPILER_TRANSLATOR_TEXTUREFUNCTIONHLSL_H_
  

Download