<CORE>/ShaderLibrary/VirtualTexturing.hlsl full source
#include "GraniteShaderLibBase.hlsl"
#define VtAddressMode_Wrap 0
#define VtAddressMode_Clamp 1
#define VtAddressMode_Udim 2
#define VtFilter_Anisotropic 0
#define VtLevel_Automatic 0
#define VtLevel_Lod 1
#define VtLevel_Bias 2
#define VtLevel_Derivatives 3
#define VtUvSpace_Regular 0
#define VtUvSpace_PreTransformed 1
#define VtSampleQuality_Low 0
#define VtSampleQuality_High 1
struct VtInputParameters
{
float2 uv;
float lodOrOffset;
float2 dx;
float2 dy;
int addressMode;
int filterMode;
int levelMode;
int uvMode;
int sampleQuality;
int enableGlobalMipBias;
};
int VirtualTexturingLookup(
in GraniteConstantBuffers grCB,
in GraniteTranslationTexture translationTable,
in VtInputParameters input,
out GraniteLookupData graniteLookupData,
out float4 resolveResult
)
{
GraniteStreamingTextureConstantBuffer grSTCB = grCB.streamingTextureBuffer;
GraniteTilesetConstantBuffer tsCB = grCB.tilesetBuffer;
float2 texCoord = input.uv;
float2 dx;
float2 dy;
float mipLevel; //interger
if (input.levelMode == VtLevel_Automatic)
{
dx = ddx(texCoord);
dy = ddy(texCoord);
}
else if (input.levelMode == VtLevel_Bias)
{
// We can't simply add the bias after the mip-calculation since the derivatives
// are also used when sampling the cache so make sure we apply bias by scaling derivatives
if ( input.sampleQuality == VtSampleQuality_High )
{
float offsetPow2 = pow(2.0f, input.lodOrOffset);
dx = ddx(texCoord) * offsetPow2;
dy = ddy(texCoord) * offsetPow2;
}
// In low quality we don't care about cache derivatives and will add the bias later
else
{
dx = ddx(texCoord);
dy = ddy(texCoord);
}
}
else if (input.levelMode == VtLevel_Derivatives)
{
dx = input.dx;
dy = input.dy;
}
else /*input.levelMode == VtLevel_Lod*/
{
//gra_TrilinearOffset ensures we do round-nearest for no-trilinear and
//round-floor for trilinear.
float clampedLevel = clamp(input.lodOrOffset + gra_TrilinearOffset, 0.0f, gra_NumLevels);
mipLevel = floor(clampedLevel);
dx = float2(frac(clampedLevel), 0.0f); // trilinear blend ratio
dy = float2(0.0f,0.0f);
}
// Transform the derivatives to atlas space if needed
if (input.uvMode == VtUvSpace_Regular && input.levelMode != VtLevel_Lod)
{
dx = gra_Transform.zw * dx;
dy = gra_Transform.zw * dy;
}
if (input.levelMode != VtLevel_Lod)
{
#ifdef VT_GLOBAL_MIP_BIAS_MULTIPLIER
if (input.enableGlobalMipBias)
{
dx *= VT_GLOBAL_MIP_BIAS_MULTIPLIER;
dy *= VT_GLOBAL_MIP_BIAS_MULTIPLIER;
}
#endif
mipLevel = GranitePrivate_CalcMiplevelAnisotropic(grCB.tilesetBuffer, grCB.streamingTextureBuffer, dx, dy);
// Simply add it here derivatives are wrong from this point onwards but not used anymore
if ( input.sampleQuality == VtSampleQuality_Low && input.levelMode == VtLevel_Bias)
{
mipLevel += input.lodOrOffset;
// GranitePrivate_CalcMiplevelAnisotropic will already clamp between 0 gra_NumLevels
// But we need to do it again here. The alternative is modifying dx,dy before passing to
// GranitePrivate_CalcMiplevelAnisotropic adding a pow2 + 4 fmuls so probably
// the exra clamp is more appropriate here.
mipLevel = clamp(mipLevel, 0.0f, gra_NumLevels);
}
mipLevel = floor(mipLevel + 0.5f); //round nearest
}
// Apply clamp/wrap mode if needed and transform into atlas space
// If the user passes in pre-transformed texture coords clamping and wrapping should be handled by the user
if (input.uvMode == VtUvSpace_Regular)
{
if (input.addressMode == VtAddressMode_Wrap)
{
texCoord = frac(input.uv);
}
else if (input.addressMode == VtAddressMode_Clamp)
{
float2 epsilon2 = float2(gra_AssetWidthRcp, gra_AssetHeightRcp);
texCoord = clamp(input.uv, epsilon2, float2(1,1) - epsilon2);
}
else if (input.addressMode == VtAddressMode_Udim)
{
// not modified (i.e outside of the 0-1 range, atlas transform below will take care of it)
texCoord = input.uv;
}
texCoord = Granite_Transform(gra_StreamingTextureCB, texCoord);
}
// calculate resolver data
float2 level0NumTiles = float2(gra_Level0NumTilesX, gra_Level0NumTilesX*gra_NumTilesYScale);
float2 virtualTilesUv = floor(texCoord * level0NumTiles * pow(0.5, mipLevel));
resolveResult = GranitePrivate_MakeResolveOutput(tsCB, virtualTilesUv, mipLevel);
float4 translationTableData;
if (input.levelMode != VtLevel_Lod)
{
// Look up the physical page indexes and the number of pages on the mipmap
// level of the page in the translation texture
// Note: this is equal for both anisotropic and linear sampling
// We could use a sample bias here for 'auto' mip level detection
#if (GRA_LOAD_INSTR==0)
translationTableData = GranitePrivate_SampleLevel_Translation(translationTable, texCoord, mipLevel);
#else
translationTableData = GranitePrivate_Load(translationTable, gra_Int3(virtualTilesUv, mipLevel));
#endif
}
else
{
// Look up the physical page indexes and the number of pages on the mipmap
// level of the page in the translation texture
// Note: this is equal for both anisotropic and linear sampling
// We could use a sample bias here for 'auto' mip level detection
#if (GRA_LOAD_INSTR==0)
translationTableData = GranitePrivate_SampleLevel_Translation(translationTable, texCoord, mipLevel);
#else
translationTableData = GranitePrivate_Load(translationTable, gra_Int3(virtualTilesUv, mipLevel));
#endif
}
graniteLookupData.translationTableData = translationTableData;
graniteLookupData.textureCoordinates = texCoord;
graniteLookupData.dX = dx;
graniteLookupData.dY = dy;
return 1;
}
int VirtualTexturingSample(
in GraniteTilesetConstantBuffer tsCB,
in GraniteLookupData graniteLookupData,
in GraniteCacheTexture cacheTexture,
in int layer,
in int levelMode,
in int quality,
out float4 result)
{
// Convert from pixels to [0-1] and look up in the physical page texture
float2 deltaScale;
float3 cacheCoord = GranitePrivate_TranslateCoord(tsCB, graniteLookupData.textureCoordinates, graniteLookupData.translationTableData, layer, deltaScale);
if ( levelMode != VtLevel_Lod )
{
if ( quality == VtSampleQuality_Low )
{
// This leads to small artefacts at tile borders but is generally not noticable unless the texture
// is greatly magnified
result = GranitePrivate_SampleArray(cacheTexture, cacheCoord);
}
else /* quality == VtSampleQuality_High */
{
deltaScale *= gra_LodBiasPow2;
// Calculate the delta scale this works by first converting the [0-1] texcoord deltas to
// pixel deltas on the current mip level, then dividing by the cache size to convert to [0-1] cache deltas
float2 sampDeltaX = graniteLookupData.dX*deltaScale;
float2 sampDeltaY = graniteLookupData.dY*deltaScale;
result = GranitePrivate_SampleGradArray(cacheTexture, cacheCoord, sampDeltaX, sampDeltaY);
}
}
else
{
result = GranitePrivate_SampleLevelArray(cacheTexture, cacheCoord, graniteLookupData.dX.x);
}
return 1;
}