HX-PGS-AIM-Android/Library/PackageCache/com.unity.render-pipelines..../ShaderLibrary/GraniteShaderLibBase.hlsl

#ifndef GRA_HLSL_3
#define GRA_HLSL_3 0
#endif

#ifndef GRA_HLSL_4
#define GRA_HLSL_4 0
#endif

#ifndef GRA_HLSL_5
#define GRA_HLSL_5 0
#endif

#ifndef GRA_GLSL_120
#define GRA_GLSL_120 0
#endif

#ifndef GRA_GLSL_130
#define GRA_GLSL_130 0
#endif

#ifndef GRA_GLSL_330
#define GRA_GLSL_330 0
#endif

#ifndef GRA_VERTEX_SHADER
#define GRA_VERTEX_SHADER 0
#endif

#ifndef GRA_PIXEL_SHADER
#define GRA_PIXEL_SHADER 0
#endif

#ifndef GRA_HQ_CUBEMAPPING
#define GRA_HQ_CUBEMAPPING 0
#endif

#ifndef GRA_DEBUG_TILES
#define GRA_DEBUG_TILES 0
#endif

#ifndef GRA_BGRA
#define GRA_BGRA 0
#endif

#ifndef GRA_ROW_MAJOR
#define GRA_ROW_MAJOR 1
#endif

#ifndef GRA_DEBUG
#define GRA_DEBUG 1
#endif

#ifndef GRA_64BIT_RESOLVER
#define GRA_64BIT_RESOLVER 0
#endif

#ifndef GRA_RWTEXTURE2D_SCALE
#define GRA_RWTEXTURE2D_SCALE 16
#endif

#ifndef GRA_DISABLE_TEX_LOAD
#define GRA_DISABLE_TEX_LOAD 0
#endif

#ifndef GRA_PACK_RESOLVE_OUTPUT
#define GRA_PACK_RESOLVE_OUTPUT 1
#endif

// Temp workaround for some platforms's lack of unorm.
#ifdef GRA_NO_UNORM
    #define GRA_UNORM
#else
    #define GRA_UNORM unorm
#endif

#ifndef GRA_TEXTURE_ARRAY_SUPPORT
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1) || (GRA_GLSL_330 == 1)
        #define GRA_TEXTURE_ARRAY_SUPPORT 1
    #else
        #define GRA_TEXTURE_ARRAY_SUPPORT 0
    #endif
#endif

#define GRA_HLSL_FAMILY ((GRA_HLSL_3 == 1) || (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1))
#define GRA_GLSL_FAMILY ((GRA_GLSL_120 == 1) || (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1))

#if GRA_HLSL_FAMILY
    #define gra_Float2 float2
    #define gra_Float3 float3
    #define gra_Float4 float4
    #define gra_Int3 int3
    #define gra_Float4x4 float4x4
    #define gra_Unroll [unroll]
    #define gra_Branch [branch]
#elif GRA_GLSL_FAMILY
    #if (GRA_VERTEX_SHADER == 0) && (GRA_PIXEL_SHADER ==0)
        #error GLSL requires knowledge of the shader stage! Neither GRA_VERTEX_SHADER or GRA_PIXEL_SHADER are defined!
    #else
        #define gra_Float2 vec2
        #define gra_Float3 vec3
        #define gra_Float4 vec4
        #define gra_Int3 ivec3
        #define gra_Float4x4 mat4
        #define gra_Unroll
        #define gra_Branch
        #if (GRA_VERTEX_SHADER == 1)
            #define ddx
            #define ddy
        #elif (GRA_PIXEL_SHADER == 1)
            #define ddx dFdx
            #define ddy dFdy
        #endif
        #define frac fract
        #define lerp mix
        /** This is not correct (http://stackoverflow.com/questions/7610631/glsl-mod-vs-hlsl-fmod) but it is for our case */
        #define fmod mod
    #endif
#else
    #error unknown shader architecture
#endif

#if (GRA_DISABLE_TEX_LOAD!=1)
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1) || (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1)
        #define GRA_LOAD_INSTR 1
    #else
        #define GRA_LOAD_INSTR 0
    #endif
#else
    #define GRA_LOAD_INSTR 0
#endif

/**
    a cross API texture handle
*/
#if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
    struct GraniteTranslationTexture
    {
        SamplerState Sampler;
        Texture2D Texture;
    };
    struct GraniteCacheTexture
    {
        SamplerState Sampler;

        #if GRA_TEXTURE_ARRAY_SUPPORT
            Texture2DArray TextureArray;
        #else
            Texture2D Texture;
        #endif
    };
#elif (GRA_HLSL_3 == 1) || (GRA_GLSL_120 == 1) || (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1)
    #define GraniteTranslationTexture sampler2D

    #if GRA_TEXTURE_ARRAY_SUPPORT
        #define GraniteCacheTexture sampler2DArray
    #else
        #define GraniteCacheTexture sampler2D
    #endif

#else
    #error unknow shader archtecture
#endif

/**
        Struct defining the constant buffer for each streaming texture.
        Use IStreamingTexture::GetConstantBuffer to fill this struct.
*/
struct GraniteStreamingTextureConstantBuffer
{
    #define _grStreamingTextureCBSize 2
    gra_Float4 data[_grStreamingTextureCBSize];
};

/**
        Struct defining the constant buffer for each cube streaming texture.
        Use multiple calls to IStreamingTexture::GetConstantBuffer this struct (one call for each face).
    */
struct GraniteStreamingTextureCubeConstantBuffer
{
    #define _grStreamingTextureCubeCBSize 6
    GraniteStreamingTextureConstantBuffer data[_grStreamingTextureCubeCBSize];
};

/**
        Struct defining the constant buffer for each tileset.
        Use ITileSet::GetConstantBuffer to fill this struct.
*/
struct GraniteTilesetConstantBuffer
{
    #define _grTilesetCBSize 2
    gra_Float4x4 data[_grTilesetCBSize];
};

/**
        Utility struct used by the shaderlib to wrap up all required constant buffers needed to perform a VT lookup/sample.
    */
struct GraniteConstantBuffers
{
    GraniteTilesetConstantBuffer                        tilesetBuffer;
    GraniteStreamingTextureConstantBuffer   streamingTextureBuffer;
};

/**
        Utility struct used by the shaderlib to wrap up all required constant buffers needed to perform a Cube VT lookup/sample.
    */
struct GraniteCubeConstantBuffers
{
    GraniteTilesetConstantBuffer                                tilesetBuffer;
    GraniteStreamingTextureCubeConstantBuffer   streamingTextureCubeBuffer;
};

/**
    The Granite lookup data for the different sampling functions.
*/

// Granite lookup data for automatic mip level selecting sampling
struct GraniteLookupData
{
    gra_Float4 translationTableData;
    gra_Float2 textureCoordinates;
    gra_Float2 dX;
    gra_Float2 dY;
};

// Granite lookup data for explicit level-of-detail sampling
struct GraniteLODLookupData
{
    gra_Float4 translationTableData;
    gra_Float2 textureCoordinates;
    float cacheLevel;
};
//@IGNORE_END

// public interface

/*
    END OF PUBLIC INTERFACE
    Everything below this point should be treated as private to GraniteShaderLib.h
*/

//@INSERT_DEFINES
#define gra_TilesetBuffer grCB.tilesetBuffer
#define gra_TilesetBufferInternal  tsCB.data[0]
#define gra_TilesetCacheBuffer  tsCB.data[1]

#define gra_StreamingTextureCB grCB.streamingTextureBuffer
#define gra_StreamingTextureCubeCB grCB.streamingTextureCubeBuffer

#define gra_Transform grCB.streamingTextureBuffer.data[0]
#define gra_CubeTransform grCB.streamingTextureCubeBuffer.data

#define gra_StreamingTextureTransform grSTCB.data[0]
#define gra_StreamingTextureInfo grSTCB.data[1]

#define gra_NumLevels gra_StreamingTextureInfo.x
#define gra_AssetWidthRcp gra_StreamingTextureInfo.y
#define gra_AssetHeightRcp gra_StreamingTextureInfo.z

#if GRA_ROW_MAJOR == 1

    #define gra_TranslationTableBias            gra_TilesetBufferInternal[0][0]
    #define gra_MaxAnisotropyLog2               gra_TilesetBufferInternal[1][0]
    #define gra_CalcMiplevelDeltaScale      gra_Float2(gra_TilesetBufferInternal[2][0], gra_TilesetBufferInternal[3][0])
    #define gra_CalcMiplevelDeltaScaleX     gra_TilesetBufferInternal[2][0]
    #define gra_CalcMiplevelDeltaScaleY     gra_TilesetBufferInternal[3][0]
    #define gra_LodBiasPow2                             gra_TilesetBufferInternal[0][1]
    #define gra_TrilinearOffset                         gra_TilesetBufferInternal[0][2]
    #define gra_TileContentInTiles              gra_Float2(gra_TilesetBufferInternal[0][2], gra_TilesetBufferInternal[1][2])
    #define gra_Level0NumTilesX                     gra_TilesetBufferInternal[0][3]
    #define gra_NumTilesYScale                      gra_TilesetBufferInternal[1][3]
    #define gra_TextureMagic                            gra_TilesetBufferInternal[2][3]
    #define gra_TextureId                               gra_TilesetBufferInternal[3][3]

    #define gra_RcpCacheInTiles(l)              gra_Float2(gra_TilesetCacheBuffer[0][l], gra_TilesetCacheBuffer[1][l])
    #define gra_BorderPixelsRcpCache(l)     gra_Float2(gra_TilesetCacheBuffer[2][l], gra_TilesetCacheBuffer[3][l])

#else

    #define gra_TranslationTableBias            gra_TilesetBufferInternal[0][0]
    #define gra_MaxAnisotropyLog2               gra_TilesetBufferInternal[0][1]
    #define gra_CalcMiplevelDeltaScale      gra_Float2(gra_TilesetBufferInternal[0][2], gra_TilesetBufferInternal[0][3])
    #define gra_CalcMiplevelDeltaScaleX     gra_TilesetBufferInternal[0][2]
    #define gra_CalcMiplevelDeltaScaleY     gra_TilesetBufferInternal[0][3]
    #define gra_LodBiasPow2                             gra_TilesetBufferInternal[1][0]
    #define gra_TrilinearOffset                         gra_TilesetBufferInternal[2][0]
    #define gra_TileContentInTiles              gra_Float2(gra_TilesetBufferInternal[2][0], gra_TilesetBufferInternal[2][1])
    #define gra_Level0NumTilesX                     gra_TilesetBufferInternal[3][0]
    #define gra_NumTilesYScale                      gra_TilesetBufferInternal[3][1]
    #define gra_TextureMagic                            gra_TilesetBufferInternal[3][2]
    #define gra_TextureId                               gra_TilesetBufferInternal[3][3]

    #define gra_RcpCacheInTiles(l)              gra_Float2(gra_TilesetCacheBuffer[l][0], gra_TilesetCacheBuffer[l][1])
    #define gra_BorderPixelsRcpCache(l)     gra_Float2(gra_TilesetCacheBuffer[l][2], gra_TilesetCacheBuffer[l][3])

#endif

#if (GRA_GLSL_120==1)
    // Extension needed for texture2DLod
    //extension GL_ARB_shader_texture_lod : enable
    // Extensions needed fot texture2DGrad
    //extension GL_EXT_gpu_shader4 : enable
    // Extensions needed for bit manipulation
    //extension GL_ARB_shader_bit_encoding : enable
#endif


#if (GRA_TEXTURE_ARRAY_SUPPORT==1)
    gra_Float4 GranitePrivate_SampleArray(in GraniteCacheTexture tex, in gra_Float3 texCoord)
    {
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
        return tex.TextureArray.Sample(tex.Sampler, texCoord);
    #elif (GRA_GLSL_330 == 1)
        return texture(tex, texCoord);
    #else
        #error using unsupported function
    #endif
    }

    gra_Float4 GranitePrivate_SampleGradArray(in GraniteCacheTexture tex, in gra_Float3 texCoord, in gra_Float2 dX, in gra_Float2 dY)
    {
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
        return tex.TextureArray.SampleGrad(tex.Sampler,texCoord,dX,dY);
    #elif (GRA_GLSL_330 == 1)
        return textureGrad(tex, texCoord, dX, dY);
    #else
        #error using unsupported function
    #endif
    }

    gra_Float4 GranitePrivate_SampleLevelArray(in GraniteCacheTexture tex, in gra_Float3 texCoord, in float level)
    {
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
        return tex.TextureArray.SampleLevel(tex.Sampler, texCoord, level);
    #elif (GRA_GLSL_330 == 1)
        return textureLod(tex, texCoord, level);
    #else
        #error using unsupported function
    #endif
    }
#else
    gra_Float4 GranitePrivate_Sample(in GraniteCacheTexture tex, in gra_Float2 texCoord)
    {
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
        return tex.Texture.Sample(tex.Sampler,texCoord);
    #elif (GRA_HLSL_3 == 1)
        return tex2D(tex,texCoord);
    #elif (GRA_GLSL_120 == 1) || (GRA_GLSL_130 == 1)
        return texture2D(tex, texCoord);
    #elif (GRA_GLSL_330 == 1)
        return texture(tex, texCoord);
    #endif
    }

    gra_Float4 GranitePrivate_SampleLevel(in GraniteCacheTexture tex, in gra_Float2 texCoord, in float level)
    {
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
        return tex.Texture.SampleLevel(tex.Sampler, texCoord, level);
    #elif (GRA_HLSL_3 == 1)
        return tex2Dlod(tex,gra_Float4(texCoord,0.0,level));
    #elif (GRA_GLSL_120 == 1)
        return texture2DLod(tex, texCoord, level);
    #elif (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1)
        return textureLod(tex, texCoord, level);
    #endif
    }

    gra_Float4 GranitePrivate_SampleGrad(in GraniteCacheTexture tex, in gra_Float2 texCoord, in gra_Float2 dX, in gra_Float2 dY)
    {
    #if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
        return tex.Texture.SampleGrad(tex.Sampler,texCoord,dX,dY);
    #elif (GRA_HLSL_3 == 1)
        return tex2D(tex,texCoord,dX,dY);
    #elif (GRA_GLSL_120 == 1)
        return texture2DGrad(tex, texCoord, dX, dY);
    #elif (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1)
        return textureGrad(tex, texCoord, dX, dY);
    #endif
    }
#endif //#if (GRA_TEXTURE_ARRAY_SUPPORT==1)

#if (GRA_LOAD_INSTR==1)
gra_Float4 GranitePrivate_Load(in GraniteTranslationTexture tex, in gra_Int3 location)
{
#if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
    return tex.Texture.Load(location);
#elif (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1)
    return texelFetch(tex, location.xy, location.z);
#elif (GRA_HLSL_3 == 1) || (GRA_GLSL_120 == 1)
    #error using unsupported function
#endif
}
#endif

//work-around shader compiler bug
//compiler gets confused with GranitePrivate_SampleLevel taking a GraniteCacheTexture as argument when array support is disabled
//Without array support, GraniteCacheTexture and GraniteTranslationTexture are the same (but still different types!)
//compiler is confused (ERR_AMBIGUOUS_FUNCTION_CALL). Looks like somebody is over enthusiastic optimizing...
gra_Float4 GranitePrivate_SampleLevel_Translation(in GraniteTranslationTexture tex, in gra_Float2 texCoord, in float level)
{
#if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
    return tex.Texture.SampleLevel(tex.Sampler, texCoord, level);
#elif (GRA_HLSL_3 == 1)
    return tex2Dlod(tex,gra_Float4(texCoord,0.0,level));
#elif (GRA_GLSL_120 == 1)
    return texture2DLod(tex, texCoord, level);
#elif (GRA_GLSL_130 == 1) || (GRA_GLSL_330 == 1)
    return textureLod(tex, texCoord, level);
#endif
}

float GranitePrivate_Saturate(in float value)
{
#if GRA_HLSL_FAMILY
    return saturate(value);
#elif GRA_GLSL_FAMILY
    return clamp(value, 0.0f, 1.0f);
#endif
}

#if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1) || (GRA_GLSL_330 == 1)
uint GranitePrivate_FloatAsUint(float value)
{
#if (GRA_HLSL_5 == 1) || (GRA_HLSL_4 == 1)
    return asuint(value);
#elif (GRA_GLSL_330 == 1)
    return floatBitsToUint(value);
#endif
}
#endif

float GranitePrivate_Pow2(uint exponent)
{
#if GRA_HLSL_FAMILY
    return pow(2.0, exponent);
#else
    return pow(2.0, float(exponent));
#endif
}

gra_Float2 GranitePrivate_RepeatUV(in gra_Float2 uv, in GraniteStreamingTextureConstantBuffer grSTCB)
{
    return frac(uv);
}

gra_Float2 GranitePrivate_UdimUV(in gra_Float2 uv, in GraniteStreamingTextureConstantBuffer grSTCB)
{
    return uv;
}

gra_Float2 GranitePrivate_ClampUV(in gra_Float2 uv, in GraniteStreamingTextureConstantBuffer grSTCB)
{
  gra_Float2 epsilon2 = gra_Float2(gra_AssetWidthRcp, gra_AssetHeightRcp);
  return clamp(uv, epsilon2, gra_Float2(1,1) - epsilon2);
}

gra_Float2 GranitePrivate_MirrorUV(in gra_Float2 uv, in GraniteStreamingTextureConstantBuffer grSTCB)
{
    gra_Float2 t = frac(uv*0.5)*2.0;
    gra_Float2 l = gra_Float2(1.0,1.0);
    return l-abs(t-l);
}

// function definitons for private functions
gra_Float4 GranitePrivate_PackTileId(in gra_Float2 tileXY, in float level, in float textureID);

gra_Float4 Granite_DebugPackedTileId64(in gra_Float4 PackedTile)
{
#if GRA_64BIT_RESOLVER
    gra_Float4 output;

    const float scale = 1.0f / 65535.0f;
    gra_Float4 temp = PackedTile / scale;

    output.x = fmod(temp.x, 256.0f);
    output.y = floor(temp.x / 256.0f) + fmod(temp.y, 16.0f) * 16.0f;
    output.z = floor(temp.y / 16.0f);
    output.w = temp.z + temp.a * 16.0f;

    return gra_Float4
    (
        (float)output.x / 255.0f,
        (float)output.y / 255.0f,
        (float)output.z / 255.0f,
        (float)output.w / 255.0f
    );
#else
    return PackedTile;
#endif
}

gra_Float3 Granite_UnpackNormal(in gra_Float4 PackedNormal, float scale)
{
    gra_Float2 reconstructed = gra_Float2(PackedNormal.x * PackedNormal.a, PackedNormal.y) * 2.0f - 1.0f;
    reconstructed *= scale;
    float z = sqrt(1.0f - GranitePrivate_Saturate(dot(reconstructed, reconstructed)));
    return gra_Float3(reconstructed, z);
}

gra_Float3 Granite_UnpackNormal(in gra_Float4 PackedNormal)
{
    return Granite_UnpackNormal(PackedNormal, 1.0);
}

#if GRA_HLSL_FAMILY
GraniteTilesetConstantBuffer Granite_ApplyResolutionOffset(in GraniteTilesetConstantBuffer INtsCB, in float resolutionOffsetPow2)
{
    GraniteTilesetConstantBuffer tsCB = INtsCB;
    gra_LodBiasPow2 *= resolutionOffsetPow2;
    //resolutionOffsetPow2 *= resolutionOffsetPow2; //Square it before multiplying it in below
    gra_CalcMiplevelDeltaScaleX *= resolutionOffsetPow2;
    gra_CalcMiplevelDeltaScaleY *= resolutionOffsetPow2;
    return tsCB;
}

GraniteTilesetConstantBuffer Granite_SetMaxAnisotropy(in GraniteTilesetConstantBuffer INtsCB, in float maxAnisotropyLog2)
{
    GraniteTilesetConstantBuffer tsCB = INtsCB;
    gra_MaxAnisotropyLog2 = min(gra_MaxAnisotropyLog2, maxAnisotropyLog2);
    return tsCB;
}
#else
void Granite_ApplyResolutionOffset(inout GraniteTilesetConstantBuffer tsCB, in float resolutionOffsetPow2)
{
    gra_LodBiasPow2 *= resolutionOffsetPow2;
    //resolutionOffsetPow2 *= resolutionOffsetPow2; //Square it before multiplying it in below
    gra_CalcMiplevelDeltaScaleX *= resolutionOffsetPow2;
    gra_CalcMiplevelDeltaScaleY *= resolutionOffsetPow2;
}

void Granite_SetMaxAnisotropy(inout GraniteTilesetConstantBuffer tsCB, in float maxAnisotropyLog2)
{
    gra_MaxAnisotropyLog2 = min(gra_MaxAnisotropyLog2, maxAnisotropyLog2);
}
#endif

gra_Float2 Granite_Transform(in GraniteStreamingTextureConstantBuffer grSTCB, in gra_Float2 textureCoord)
{
    return textureCoord * gra_StreamingTextureTransform.zw  + gra_StreamingTextureTransform.xy;
}

gra_Float4 Granite_MergeResolveOutputs(in gra_Float4 resolve0, in gra_Float4 resolve1, in gra_Float2 pixelLocation)
{
    gra_Float2 screenPos = frac(pixelLocation * 0.5f);
    bool dither = (screenPos.x != screenPos.y);
    return (dither) ? resolve0 : resolve1;
}

gra_Float4 Granite_PackTileId(in gra_Float4 unpackedTileID)
{
    return GranitePrivate_PackTileId(unpackedTileID.xy, unpackedTileID.z, unpackedTileID.w);
}

#if (GRA_HLSL_5 == 1)
void Granite_DitherResolveOutput(in gra_Float4 resolve, in RWTexture2D<GRA_UNORM gra_Float4> resolveTexture, in gra_Float2 screenPos, in float alpha)
{
    const uint2 pixelPos = int2(screenPos);
    const uint2 pixelLocation = pixelPos % GRA_RWTEXTURE2D_SCALE;
    bool dither = (pixelLocation.x  == 0) && (pixelLocation.y  == 0);
    uint2 writePos = pixelPos / GRA_RWTEXTURE2D_SCALE;

    if ( alpha == 0 )
    {
        dither = false;
    }
    else if (alpha != 1.0)
    {
        // Do a 4x4 dither patern so alternating pixels resolve to the first or the second texture
        gra_Float2 pixelLocationAlpha = frac(screenPos * 0.25f); // We don't scale after the frac so this will give coords 0, 0.25, 0.5, 0.75
        int pixelId = (int)(pixelLocationAlpha.y * 16 + pixelLocationAlpha.x * 4); //faster as a dot2 ?

        // Clamp
        // This ensures that for example alpha=0.95 still resolves some tiles of the surfaces behind it
        // and alpha=0.05 still resolves some tiles of this surface
        alpha = min(max(alpha, 0.0625), 0.9375);

        // Modern hardware supports array indexing with per pixel varying indexes
        // on old hardware this will be expanded to a conditional tree by the compiler
        const float thresholdMaxtrix[16] = {    1.0f / 17.0f, 9.0f / 17.0f, 3.0f / 17.0f, 11.0f / 17.0f,
                                                    13.0f / 17.0f,  5.0f / 17.0f, 15.0f / 17.0f, 7.0f / 17.0f,
                                                    4.0f / 17.0f, 12.0f / 17.0f, 2.0f / 17.0f, 10.0f / 17.0f,
                                                    16.0f / 17.0f, 8.0f / 17.0f, 14.0f / 17.0f, 6.0f / 17.0f};
        float threshold = thresholdMaxtrix[pixelId];

        if (alpha < threshold)
        {
            dither = false;
        }
    }

    gra_Branch if (dither)
    {
#if (GRA_PACK_RESOLVE_OUTPUT==0)
        resolveTexture[writePos] = Granite_PackTileId(resolve);
#else
        resolveTexture[writePos] = resolve;
#endif
    }
}
#endif

float GranitePrivate_CalcMiplevelAnisotropic(in GraniteTilesetConstantBuffer tsCB, in GraniteStreamingTextureConstantBuffer grSTCB, in gra_Float2 ddxTc, in gra_Float2 ddyTc)
{
    // Calculate the required mipmap level, this uses a similar
    // formula as the GL spec.
    // To reduce sqrt's and log2's we do some stuff in squared space here and further below in log space
    // i.e. we wait with the sqrt untill we can do it for 'free' later during the log2

  ddxTc *= gra_CalcMiplevelDeltaScale;
  ddyTc *= gra_CalcMiplevelDeltaScale;

  float lenDxSqr = dot(ddxTc, ddxTc);
    float lenDySqr = dot(ddyTc, ddyTc);
    float dMaxSqr = max(lenDxSqr, lenDySqr);
    float dMinSqr = min(lenDxSqr, lenDySqr);

    // Calculate mipmap levels directly from sqared distances. This uses log2(sqrt(x)) = 0.5 * log2(x) to save some sqrt's
    float maxLevel = 0.5 * log2( dMaxSqr );
    float minLevel = 0.5 * log2( dMinSqr );

    // Calculate the log2 of the anisotropy and clamp it by the max supported. This uses log2(a/b) = log2(a)-log2(b) and min(log(a),log(b)) = log(min(a,b))
    float anisoLog2 = maxLevel - minLevel;
    anisoLog2 = min( anisoLog2, gra_MaxAnisotropyLog2 );

    // Adjust for anisotropy & clamp to level 0
    float result = max(maxLevel - anisoLog2 - 0.5f, 0.0f); //Subtract 0.5 to compensate for trilinear mipmapping

    // Added clamping to avoid "hot pink" on small tilesets that try to sample past the 1x1 tile miplevel
    // This happens if you for example import a relatively small texture and zoom out
    return min(result, gra_NumLevels);
}

float GranitePrivate_CalcMiplevelLinear(in  GraniteTilesetConstantBuffer tsCB, in GraniteStreamingTextureConstantBuffer grSTCB, in gra_Float2 ddxTc, in gra_Float2 ddyTc)
{
    // Calculate the required mipmap level, this uses a similar
    // formula as the GL spec.
    // To reduce sqrt's and log2's we do some stuff in squared space here and further below in log space
    // i.e. we wait with the sqrt untill we can do it for 'free' later during the log2

  ddxTc *= gra_CalcMiplevelDeltaScale;
  ddyTc *= gra_CalcMiplevelDeltaScale;

    float lenDxSqr = dot(ddxTc, ddxTc);
    float lenDySqr = dot(ddyTc, ddyTc);
    float dMaxSqr = max(lenDxSqr, lenDySqr);

    // Calculate mipmap levels directly from squared distances. This uses log2(sqrt(x)) = 0.5 * log2(x) to save some sqrt's
    float maxLevel = 0.5 * log2(dMaxSqr) - 0.5f;  //Subtract 0.5 to compensate for trilinear mipmapping

    return clamp(maxLevel, 0.0f, gra_NumLevels);
}

gra_Float4 GranitePrivate_PackTileId(in gra_Float2 tileXY, in float level, in float textureID)
{
#if GRA_64BIT_RESOLVER == 0
    gra_Float4 resultBits;

    resultBits.x = fmod(tileXY.x, 256.0f);
    resultBits.y = floor(tileXY.x / 256.0f) + fmod(tileXY.y, 32.0f) * 8.0f;
    resultBits.z = floor(tileXY.y / 32.0f) + fmod(level, 4.0f) * 64.0f;
    resultBits.w = floor(level / 4.0f) + textureID * 4.0f;

    const float scale = 1.0f / 255.0f;

#if GRA_BGRA == 0
    return scale * gra_Float4
    (
        float(resultBits.x),
        float(resultBits.y),
        float(resultBits.z),
        float(resultBits.w)
    );
#else
    return scale * gra_Float4
    (
        float(resultBits.z),
        float(resultBits.y),
        float(resultBits.x),
        float(resultBits.w)
    );
#endif
#else
    const float scale = 1.0f / 65535.0f;
    return gra_Float4(tileXY.x, tileXY.y, level, textureID) * scale;
#endif

}

gra_Float4 GranitePrivate_UnpackTileId(in gra_Float4 packedTile)
{
    gra_Float4 swiz;
#if GRA_BGRA == 0
    swiz = packedTile;
#else
    swiz = packedTile.zyxw;
#endif
    swiz *= 255.0f;

    float tileX = swiz.x + fmod(swiz.y, 16.0f) * 256.0f;
    float tileY = floor(swiz.y / 16.0f) + swiz.z * 16.0f;
    float level = fmod(swiz.w, 16.0f);
    float tex   = floor(swiz.w /  16.0f);

    return gra_Float4(tileX, tileY, level, tex);
}

gra_Float3 GranitePrivate_TranslateCoord(in GraniteTilesetConstantBuffer tsCB, in gra_Float2 inputTexCoord, in gra_Float4 translationData, in int layer, out gra_Float2 numPagesOnLevel)
{
    // The translation table contains uint32_t values so we have to get to the individual bits of the float data
    uint data = GranitePrivate_FloatAsUint(translationData[layer]);

    // Slice Index: 7 bits, Cache X: 10 bits, Cache Y: 10 bits, Tile Level: 4 bits
    uint slice  = (data >> 24u) & 0x7Fu;
    uint cacheX = (data >> 14u) & 0x3FFu;
    uint cacheY = (data >> 4u) & 0x3FFu;
    uint revLevel = data & 0xFu;

    gra_Float2 numTilesOnLevel;
    numTilesOnLevel.x = GranitePrivate_Pow2(revLevel);
    numTilesOnLevel.y = numTilesOnLevel.x * gra_NumTilesYScale;

    gra_Float2 tileTexCoord = frac(inputTexCoord * numTilesOnLevel);

    gra_Float2 tileTexCoordCache = tileTexCoord * gra_TileContentInTiles + gra_Float2(cacheX, cacheY);
    gra_Float3 final = gra_Float3(tileTexCoordCache * gra_RcpCacheInTiles(layer) + gra_BorderPixelsRcpCache(layer), slice);

    numPagesOnLevel = numTilesOnLevel * gra_TileContentInTiles * gra_RcpCacheInTiles(layer);

    return final;
}

gra_Float4 GranitePrivate_DrawDebugTiles(in gra_Float4 sourceColor, in gra_Float2 textureCoord, in gra_Float2 numPagesOnLevel)
{
    // Calculate the border values
    gra_Float2 cacheOffs = frac(textureCoord * numPagesOnLevel);
    float borderTemp = max(cacheOffs.x, 1.0-cacheOffs.x);
    borderTemp = max(max(cacheOffs.y, 1.0-cacheOffs.y), borderTemp);
    float border = smoothstep(0.98, 0.99, borderTemp);

    // White
    gra_Float4 borderColor = gra_Float4(1,1,1,1);

    //Lerp it over the source color
    return lerp(sourceColor, borderColor, border);
}

gra_Float4 GranitePrivate_MakeResolveOutput(in GraniteTilesetConstantBuffer tsCB, in gra_Float2 tileXY, in float level)
{
#if GRA_PACK_RESOLVE_OUTPUT
    return GranitePrivate_PackTileId(tileXY, level, gra_TextureId);
#else
    return gra_Float4(tileXY, level, gra_TextureId);
#endif
}

gra_Float4 GranitePrivate_ResolverPixel(in GraniteTilesetConstantBuffer tsCB, in gra_Float2 inputTexCoord, in float LOD)
{
    float level = floor(LOD + 0.5f);

    // Number of tiles on level zero
    gra_Float2 level0NumTiles;
    level0NumTiles.x = gra_Level0NumTilesX;
    level0NumTiles.y = gra_Level0NumTilesX * gra_NumTilesYScale;

    // Calculate xy of the tiles to load
    gra_Float2 virtualTilesUv = floor(inputTexCoord * level0NumTiles * pow(0.5, level));

    return GranitePrivate_MakeResolveOutput(tsCB, virtualTilesUv, level);
}

void GranitePrivate_CalculateCubemapCoordinates(in gra_Float3 inputTexCoord, in gra_Float3 dVx, in gra_Float3 dVy, in GraniteStreamingTextureCubeConstantBuffer transforms, out int faceIdx, out gra_Float2 texCoord, out gra_Float2 dX, out gra_Float2 dY)
{
    gra_Float2 contTexCoord;
    gra_Float3 derivX;
    gra_Float3 derivY;

    float majorAxis;
    if (abs(inputTexCoord.z) >= abs(inputTexCoord.x) && abs(inputTexCoord.z) >= abs(inputTexCoord.y))
    {
        // Z major axis
        if(inputTexCoord.z < 0.0)
        {
            faceIdx = 5;
            texCoord.x = -inputTexCoord.x;
        }
        else
        {
            faceIdx = 4;
            texCoord.x = inputTexCoord.x;
        }
        texCoord.y = -inputTexCoord.y;
        majorAxis = inputTexCoord.z;

        contTexCoord = gra_Float2(inputTexCoord.x, inputTexCoord.y);
        derivX = gra_Float3(dVx.x, dVx.y, dVx.z);
        derivY = gra_Float3(dVy.x, dVy.y, dVy.z);
    }
    else if (abs(inputTexCoord.y) >= abs(inputTexCoord.x))
    {
        // Y major axis
        if(inputTexCoord.y < 0.0)
        {
            faceIdx = 3;
            texCoord.y = -inputTexCoord.z;
        }
        else
        {
            faceIdx = 2;
            texCoord.y = inputTexCoord.z;
        }
        texCoord.x = inputTexCoord.x;
        majorAxis = inputTexCoord.y;

        contTexCoord = gra_Float2(inputTexCoord.x, inputTexCoord.z);
        derivX = gra_Float3(dVx.x, dVx.z, dVx.y);
        derivY = gra_Float3(dVy.x, dVy.z, dVy.y);
    }
    else
    {
        // X major axis
        if(inputTexCoord.x < 0.0)
        {
            faceIdx = 1;
            texCoord.x = inputTexCoord.z;
        }
        else
        {
            faceIdx = 0;
            texCoord.x = -inputTexCoord.z;
        }
        texCoord.y = -inputTexCoord.y;
        majorAxis = inputTexCoord.x;

        contTexCoord = gra_Float2(inputTexCoord.z, inputTexCoord.y);
        derivX = gra_Float3(dVx.z, dVx.y, dVx.x);
        derivY = gra_Float3(dVy.z, dVy.y, dVy.x);
    }
    texCoord = (texCoord + majorAxis) / (2.0 * abs(majorAxis));

#if GRA_HQ_CUBEMAPPING
    dX = /*contTexCoord **/ ((contTexCoord + derivX.xy) / ( 2.0 * (majorAxis + derivX.z)) - (contTexCoord / (2.0 * majorAxis)));
    dY = /*contTexCoord **/ ((contTexCoord + derivY.xy) / ( 2.0 * (majorAxis + derivY.z)) - (contTexCoord / (2.0 * majorAxis)));
#else
    dX = ((/*contTexCoord **/ derivX.xy) / (2.0 * abs(majorAxis)));
    dY = ((/*contTexCoord **/ derivY.xy) / (2.0 * abs(majorAxis)));
#endif

    // Now scale the derivatives with the texture transform scale
    dX *= transforms.data[faceIdx].data[0].zw;
    dY *= transforms.data[faceIdx].data[0].zw;
}

// Auto-level
void GranitePrivate_CalculateCubemapCoordinates(in gra_Float3 inputTexCoord, in GraniteStreamingTextureCubeConstantBuffer transforms, out int faceIdx, out gra_Float2 texCoord, out gra_Float2 dX, out gra_Float2 dY)
{
    gra_Float3 dVx = ddx(inputTexCoord);
    gra_Float3 dVy = ddy(inputTexCoord);

    GranitePrivate_CalculateCubemapCoordinates(inputTexCoord, dVx, dVy, transforms, faceIdx, texCoord, dX, dY);
}

gra_Float2 Granite_GetTextureDimensions(in GraniteStreamingTextureConstantBuffer grSTCB)
{
    return gra_Float2(1.0 / gra_AssetWidthRcp, 1.0 / gra_AssetHeightRcp); //TODO(ddebaets) use HLSL rcp here
}