772 lines
35 KiB
HLSL
772 lines
35 KiB
HLSL
#ifndef UNITY_DEBUG_MIPMAP_STREAMING_INCLUDED
|
|
#define UNITY_DEBUG_MIPMAP_STREAMING_INCLUDED
|
|
|
|
#include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Debug.hlsl"
|
|
|
|
// Indices for Mipmap Debug Legend Strings
|
|
#define _kNotStreamingIndex 0
|
|
#define _kStreamingIndex 1
|
|
#define _kStreamingManuallyIndex 2
|
|
#define _kStatusNoTextureIndex 3
|
|
#define _kStatusWarningIndex 4
|
|
#define _kStatusUnknownIndex 5
|
|
#define _kStatusStreamerDisabledIndex 6
|
|
#define _kStatusMessageNoMipMapIndex 7
|
|
#define _kStatusMessageNotSetToStreamIndex 8
|
|
#define _kStatusMessageNoAsyncIndex 9
|
|
#define _kStatusMessageTerrainIndex 10
|
|
#define _kStatusNoTexturesIndex 11
|
|
#define _kStatusSomeTexturesHaveIssues 12
|
|
#define _kStatusAllTexturesAreStreaming 13
|
|
#define _kStatusAllTexturesAreStreamingSomeManually 14
|
|
#define _kStatusNoTexturesAreStreaming 15
|
|
#define _kStatusSomeTexturesAreStreaming 16
|
|
#define _kStatusSomeTexturesAreStreamingSomeManually 17
|
|
|
|
#define _kNoMipCountIndex 18
|
|
#define _kTooManyMipsIndex 19
|
|
|
|
#define _kHighPixelDensityIndex 20
|
|
#define _kLowPixelDensityIndex 21
|
|
|
|
#define _kLowPriorityIndex 22
|
|
#define _kHighPriorityIndex 23
|
|
|
|
#define _kBudgetSavingMips 24
|
|
#define _kBudgetSavingMipsWithCache 25
|
|
#define _kBudgetNothingSaved 26
|
|
#define _kBudgetMissingMips 27
|
|
|
|
#define _kRecentlyUpdated 28
|
|
#define _kNotRecentlyUpdated 29
|
|
|
|
static const uint kMipmapDebugLegendStrings[][32] =
|
|
{
|
|
// Status
|
|
{13, 'N','o','t',' ','s','t','r','e','a','m','i','n','g','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{ 9, 'S','t','r','e','a','m','i','n','g','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{31, 'S','t','r','e','a','m','i','n','g',' ','(','m','a','n','u','a','l','l','y',' ','v','i','a',' ','s','c','r','i','p','t',')'},
|
|
{18, 'N','o',' ','t','e','x','t','u','r','e',' ','i','n',' ','s','l','o','t','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{ 7, 'W','a','r','n','i','n','g','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{21, 'U','n','k','n','o','w','n',' ','(','n','o',' ','r','e','n','d','e','r','e','r',')','.','.','.','.','.','.','.','.','.','.'},
|
|
{24, 'T','e','x','t','u','r','e','S','t','r','e','a','m','e','r',' ','d','i','s','a','b','l','e','d','.','.','.','.','.','.','.'},
|
|
{19, 'N','o',' ','m','i','p','m','a','p',' ','g','e','n','e','r','a','t','e','d','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{21, 'S','t','r','e','a','m','i','n','g',' ','n','o','t',' ','e','n','a','b','l','e','d','.','.','.','.','.','.','.','.','.','.'},
|
|
{19, 'C','a','n','n','o','t',' ','s','t','r','e','a','m',' ','a','s','y','n','c','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{ 7, 'T','e','r','r','a','i','n','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
|
|
{23, 'N','o',' ','t','e','x','t','u','r','e','s',' ','o','n',' ','m','a','t','e','r','i','a','l','.','.','.','.','.','.','.','.'},
|
|
{15, 'I','s','s','u','e','s',' ','d','e','t','e','c','t','e','d','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{13, 'A','l','l',' ','s','t','r','e','a','m','i','n','g','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{29, 'A','l','l',' ','s','t','r','e','a','m','i','n','g',' ','(','s','o','m','e',' ','m','a','n','u','a','l','l','y',')','.','.'},
|
|
{21, 'N','o',' ','t','e','x','t','u','r','e','s',' ','s','t','r','e','a','m','i','n','g','.','.','.','.','.','.','.','.','.','.'},
|
|
{14, 'S','o','m','e',' ','s','t','r','e','a','m','i','n','g','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{30, 'S','o','m','e',' ','s','t','r','e','a','m','i','n','g',' ','(','s','o','m','e',' ','m','a','n','u','a','l','l','y',')','.'},
|
|
|
|
// MipCount
|
|
{16, 'I','n','v','a','l','i','d',' ','m','i','p','C','o','u','n','t','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{26, 'M','o','r','e',' ','t','h','a','n',' ','1','4',' ','m','i','p','s',' ','u','p','l','o','a','d','e','d','.','.','.','.','.'},
|
|
|
|
// Ratio
|
|
{18, 'H','i','g','h',' ','p','i','x','e','l',' ','d','e','n','s','i','t','y','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{17, 'L','o','w',' ','p','i','x','e','l',' ','d','e','n','s','i','t','y','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
|
|
// Priorities
|
|
{10, 'L','o','w',' ','(','-','1','2','8',')','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{10, 'H','i','g','h',' ','(','1','2','7',')','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
|
|
// Performance
|
|
{10, 'M','i','p','s',' ','s','a','v','e','d','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{31, 'M','i','p','s',' ','s','a','v','e','d',' ','(','s','o','m','e',' ','c','a','c','h','e','d',' ','o','n',' ','G','P','U',')'},
|
|
{30, 'N','o',' ','s','a','v','i','n','g','s',' ','(','a','l','l',' ','m','i','p','s',' ','r','e','q','u','i','r','e','d',')','.'},
|
|
{30, 'N','o','t',' ','a','l','l',' ','r','e','q','u','i','r','e','d',' ','m','i','p','s',' ','u','p','l','o','a','d','e','d','.'},
|
|
|
|
// RecentlyUpdated
|
|
{13, 'J','u','s','t',' ','s','t','r','e','a','m','e','d','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.','.'},
|
|
{21, 'N','o','t',' ','r','e','c','e','n','t','l','y',' ','s','t','r','e','a','m','e','d','.','.','.','.','.','.','.','.','.','.'},
|
|
};
|
|
|
|
void DrawString(int stringIdx, uint2 unormCoord, float3 textColor, uint2 textLocation, bool alignRight, inout float3 outputColor)
|
|
{
|
|
const uint stringSize = kMipmapDebugLegendStrings[stringIdx][0];
|
|
const int direction = alignRight ? -1 : 1;
|
|
uint i = alignRight ? stringSize : 1;
|
|
|
|
[fastopt] for (; alignRight ? i > 0 : i <= stringSize; i += direction)
|
|
DrawCharacter(kMipmapDebugLegendStrings[stringIdx][i], textColor, unormCoord, textLocation, outputColor.rgb, direction);
|
|
}
|
|
|
|
void DrawString(int stringIdx, uint2 unormCoord, float3 textColor, uint2 textLocation, inout float3 outputColor)
|
|
{
|
|
DrawString(stringIdx, unormCoord, textColor, textLocation, false, outputColor);
|
|
}
|
|
|
|
// mipInfo :
|
|
// x = quality settings maxLevelReduction
|
|
// y = original mip count for texture (if it has not been set, it's not a streamed texture)
|
|
// z = desired on screen mip level
|
|
// w = 0
|
|
uint GetMaxLevelReduction(float4 mipInfo) { return max(1, uint(mipInfo.x)); } // Always has a minimum value of 1.
|
|
uint GetTextureAssetMipCount(float4 mipInfo) { return uint(mipInfo.y); }
|
|
uint GetDesiredMipLevel(float4 mipInfo) { return uint(mipInfo.z); }
|
|
|
|
// Mipmap Debug Status Codes found in StreamInfo.z (Per-Texture)
|
|
#define kMipmapDebugStatusCodeNotSet 0 // No status code has been set by the streamer
|
|
#define kMipmapDebugStatusCodeStreamerDisabled 1 // Not streaming: streamer disabled
|
|
#define kMipmapDebugStatusCodeNoTexture 2 // Nothing there, empty slot
|
|
#define kMipmapDebugStatusCodeNoMipMap 3 // Not streaming: no mips
|
|
#define kMipmapDebugStatusCodeNotSetToStream 4 // Not streaming: streaming not enabled for this texture
|
|
#define kMipmapDebugStatusCodeNoAsync 5 // Not streaming: cannot asyncStream
|
|
#define kMipmapDebugStatusCodeTerrain 6 // Not streaming: terrain
|
|
#define kMipmapDebugStatusCodeInvalidStreamingIndex 7 // Not streaming: invalid streaming index (issue at Unity side?)
|
|
#define kMipmapDebugStatusCodeManuallyRequested 8 // Streaming manually through script (RequestedMipmapLevel)
|
|
|
|
// Mipmap Debug Status Code Flags found in StreamInfo.z (Per-Material)
|
|
#define kMipmapDebugStatusCodeFlagNoTexturesSet 0 // No textures have been set on the material, all slots are empty
|
|
#define kMipmapDebugStatusCodeFlagHasStreamingTextures 1 // 1 or more textures assigned to the material are streaming
|
|
#define kMipmapDebugStatusCodeFlagHasNonStreamingTextures 2 // 1 or more textures assigned to the material aren't streaming
|
|
#define kMipmapDebugStatusCodeFlagHasTexturesWithIssues 4 // 1 or more textures assigned to the material have issues preventing them from streaming
|
|
#define kMipmapDebugStatusCodeFlagHasManualRequests 8 // 1 or more textures assigned to the material are streaming manually through script (RequestedMipmapLevel)
|
|
|
|
// streamInfo :
|
|
// x = streaming priority
|
|
// y = time stamp of the latest texture upload
|
|
// z = streaming status
|
|
// w = 0
|
|
int GetStreamingPriority(float4 streamInfo) { return int(streamInfo.x);}
|
|
float GetUpdateTimestamp(float4 streamInfo) { return streamInfo.y;}
|
|
bool IsStreaming(float4 streamInfo) { return streamInfo.z < 0 || (int)streamInfo.z == kMipmapDebugStatusCodeManuallyRequested; } // if manually set, that's also streaming
|
|
int GetStatusCode(float4 streamInfo, bool perMaterial) { return perMaterial ? (int)streamInfo.z >> 4 : (int)streamInfo.z & 0xF;} // 0-15 are reserved for per-texture codes
|
|
|
|
#define kMipmapDebugLowPixelDensity float3(0.049, 0.32, 0.751)
|
|
#define kMipmapDebugHighPixelDensity float3(0.982, 0.32, 0)
|
|
|
|
float3 GetDebugMipRatioColor(float value)
|
|
{
|
|
if (value > 0.5)
|
|
return lerp(float3(0.5, 0.5, 0.5), kMipmapDebugHighPixelDensity, 2 * value - 1);
|
|
else
|
|
return lerp(kMipmapDebugLowPixelDensity, float3(0.5, 0.5, 0.5), 2 * value);
|
|
}
|
|
|
|
float3 GetMipLevelColor(float2 uv, float4 texelSize)
|
|
{
|
|
// Push down into colors list to "optimal level" in following table.
|
|
// .zw is texture width,height so *2 is down one mip, *4 is down two mips
|
|
texelSize.zw *= 4.0;
|
|
|
|
float mipLevel = ComputeTextureLOD(uv, texelSize.zw);
|
|
mipLevel = clamp(mipLevel, 0.0, 5.0 - 0.0001);
|
|
|
|
return GetDebugMipRatioColor(mipLevel / 5.0);
|
|
}
|
|
|
|
float3 GetDebugMipColor(float3 originalColor, float4 texelSize, float2 uv)
|
|
{
|
|
// https://aras-p.info/blog/2011/05/03/a-way-to-visualize-mip-levels/
|
|
return GetMipLevelColor(uv, texelSize);
|
|
}
|
|
|
|
#define kMipmapDebugTooManyMips float3(0.194, 0.007, 0.034)
|
|
#define kMipmapDebugInvalidMipCount float3(0.716, 0.066, 0.9)
|
|
|
|
float3 GetDebugMipCountColor(uint mipCount, out bool needsHatching)
|
|
{
|
|
needsHatching = false;
|
|
|
|
if (mipCount == 0 || mipCount > 14)
|
|
{
|
|
needsHatching = true;
|
|
return mipCount == 0 ? kMipmapDebugInvalidMipCount : kMipmapDebugTooManyMips;
|
|
}
|
|
|
|
const float3 colors[14] = {
|
|
float3(0.349, 0.782, 0.965),
|
|
float3(0.188, 0.933, 0.847),
|
|
float3(0.034, 0.9, 0.442),
|
|
float3(0.027, 0.878, 0.035),
|
|
float3(0.4, 0.858, 0.023),
|
|
float3(0.694, 0.929, 0.047),
|
|
float3(1.0, 0.982, 0.072),
|
|
float3(0.996, 0.843, 0.039),
|
|
float3(0.991, 0.687, 0.004),
|
|
float3(0.988, 0.510, 0.004),
|
|
float3(0.982, 0.320, 0.0),
|
|
float3(0.992, 0.184, 0.016),
|
|
float3(1.0, 0.051, 0.029),
|
|
float3(1.0, 0.043, 0.180)
|
|
};
|
|
|
|
return colors[mipCount - 1];
|
|
}
|
|
|
|
float3 GetDebugMipCountHatchingColor(uint mipCount)
|
|
{
|
|
if (mipCount == 0 || mipCount > 14)
|
|
return float3(0.9, 0.9, 0.9);
|
|
else
|
|
return float3(0.1, 0.1, 0.1);
|
|
}
|
|
|
|
|
|
#define kMipmapDebugBudgetSavingMips float3(0.036, 0.9, 0.442)
|
|
#define kMipmapDebugBudgetMissing float3(1.0, 0.053, 0.029)
|
|
#define kMipmapDebugBudgetFullResolution float3(0.5, 0.5, 0.5)
|
|
#define kMipMapDebugStatusColorNotStreaming float3(0.0, 0.007, 0.731)
|
|
|
|
float3 GetDebugStreamingMipColor(uint mipCount, float4 mipInfo, float4 streamInfo, out bool needsHatching)
|
|
{
|
|
needsHatching = false;
|
|
|
|
if (!IsStreaming(streamInfo))
|
|
return kMipMapDebugStatusColorNotStreaming;
|
|
|
|
if (mipCount == 0)
|
|
return float3(1.0, 0.0, 1.0); // Magenta if mip count invalid
|
|
|
|
const uint originalTextureMipCount = GetTextureAssetMipCount(mipInfo);
|
|
const uint mipCountDesired = uint(originalTextureMipCount)-GetDesiredMipLevel(mipInfo);
|
|
const uint maxLevelReduction = GetMaxLevelReduction(mipInfo);
|
|
|
|
const float3 colorNeutral = float3(0.5, 0.5, 0.5);
|
|
if (mipCount < mipCountDesired)
|
|
{
|
|
const int missingMips = mipCountDesired - mipCount;
|
|
const float missingRatio = float(missingMips) / float(maxLevelReduction);
|
|
|
|
// red tones when not at the desired mip level (reduction due to budget). Full red means no more mips were allowed to be discarded
|
|
return lerp(colorNeutral, kMipmapDebugBudgetMissing, missingRatio);
|
|
}
|
|
else if (mipCountDesired < originalTextureMipCount)
|
|
{
|
|
const int savedMips = originalTextureMipCount - mipCountDesired;
|
|
const float savedRatio = float(savedMips) / float(maxLevelReduction);
|
|
|
|
// green tones when we require less mips than the original texture. Full green means we've dropped as many mips as allowed
|
|
if (mipCount > mipCountDesired) // some mips were cached
|
|
{
|
|
needsHatching = true;
|
|
return lerp(colorNeutral, kMipmapDebugBudgetSavingMips, savedRatio);
|
|
}
|
|
else
|
|
return lerp(colorNeutral, kMipmapDebugBudgetSavingMips, savedRatio);
|
|
}
|
|
else // so, (mipCount >= originalTextureMipCount)
|
|
{
|
|
return kMipmapDebugBudgetFullResolution;
|
|
}
|
|
}
|
|
|
|
#define kMipMapDebugStatusColorStreaming float3(0.036, 0.9, 0.442)
|
|
#define kMipMapDebugStatusColorUnknown float3(0.349, 0.782, 0.965)
|
|
#define kMipMapDebugStatusColorNoTexture float3(0.982, 0.320, 0)
|
|
#define kMipMapDebugStatusColorWarning float3(1.0, 0.982, 0.072)
|
|
|
|
float3 GetDebugStreamingStatusColor(float4 streamInfo, out bool needsHatching)
|
|
{
|
|
needsHatching = false;
|
|
|
|
if (IsStreaming(streamInfo))
|
|
{
|
|
if (GetStatusCode(streamInfo, false) == kMipmapDebugStatusCodeManuallyRequested)
|
|
needsHatching = true;
|
|
return kMipMapDebugStatusColorStreaming;
|
|
}
|
|
|
|
int statusCode = GetStatusCode(streamInfo, false);
|
|
switch(statusCode)
|
|
{
|
|
case kMipmapDebugStatusCodeNoTexture:
|
|
return kMipMapDebugStatusColorNoTexture;
|
|
case kMipmapDebugStatusCodeStreamerDisabled:
|
|
case kMipmapDebugStatusCodeNoMipMap:
|
|
case kMipmapDebugStatusCodeNotSetToStream:
|
|
return kMipMapDebugStatusColorNotStreaming;
|
|
case kMipmapDebugStatusCodeNoAsync:
|
|
case kMipmapDebugStatusCodeTerrain:
|
|
return kMipMapDebugStatusColorWarning;
|
|
case kMipmapDebugStatusCodeInvalidStreamingIndex:
|
|
return float3(1.0, 0.0, 1.0);
|
|
case kMipmapDebugStatusCodeNotSet:
|
|
default:
|
|
return kMipMapDebugStatusColorUnknown;
|
|
}
|
|
}
|
|
|
|
#define kMipMapDebugMaterialStatusColorSomeStreaming float3(0.018, 0.454, 0.587)
|
|
|
|
float3 GetDebugPerMaterialStreamingStatusColor(float4 streamInfo, out bool needsHatching)
|
|
{
|
|
needsHatching = false;
|
|
|
|
int statusCode = GetStatusCode(streamInfo, true);
|
|
if (statusCode == kMipmapDebugStatusCodeFlagNoTexturesSet)
|
|
return kMipMapDebugStatusColorNoTexture;
|
|
|
|
const bool hasStreamingTextures = (statusCode & kMipmapDebugStatusCodeFlagHasStreamingTextures) != 0;
|
|
const bool hasNonStreamingTextures = (statusCode & kMipmapDebugStatusCodeFlagHasNonStreamingTextures) != 0;
|
|
const bool hasTexturesWithIssues = (statusCode & kMipmapDebugStatusCodeFlagHasTexturesWithIssues) != 0;
|
|
const bool hasManualRequests = (statusCode & kMipmapDebugStatusCodeFlagHasManualRequests) != 0;
|
|
|
|
if(hasTexturesWithIssues)
|
|
{
|
|
return kMipMapDebugStatusColorWarning;
|
|
}
|
|
|
|
// at this point, there are no issues to report
|
|
if(hasStreamingTextures && !hasNonStreamingTextures)
|
|
{
|
|
needsHatching = hasManualRequests;
|
|
return kMipMapDebugStatusColorStreaming;
|
|
}
|
|
else if(hasNonStreamingTextures && !hasStreamingTextures)
|
|
{
|
|
return kMipMapDebugStatusColorNotStreaming;
|
|
}
|
|
else
|
|
{
|
|
// mix of streaming and non-streaming
|
|
needsHatching = hasManualRequests;
|
|
return kMipMapDebugMaterialStatusColorSomeStreaming;
|
|
}
|
|
}
|
|
|
|
float3 GetDebugMipPriorityColor(float value)
|
|
{
|
|
const float3 kMipMapDebugLowPriorityColor = float3(0.982, 0.32, 0);
|
|
const float3 kMipMapDebugHighPriorityColor = float3(0.4, 0.858, 0.023);
|
|
|
|
if(value < 0.5)
|
|
return lerp(kMipMapDebugLowPriorityColor, float3(0.5, 0.5, 0.5), 2 * value);
|
|
else
|
|
return lerp(float3(0.5, 0.5, 0.5), kMipMapDebugHighPriorityColor, 2 * (value - 0.5));
|
|
}
|
|
|
|
float3 GetDebugStreamingPriorityColor(float4 streamInfo)
|
|
{
|
|
if (!IsStreaming(streamInfo))
|
|
return kMipMapDebugStatusColorNotStreaming;
|
|
|
|
const int textureStreamingPriority = GetStreamingPriority(streamInfo);
|
|
const float priorityValue = (textureStreamingPriority + 128) / 255.0;
|
|
return GetDebugMipPriorityColor(priorityValue);
|
|
}
|
|
|
|
float3 GetDebugMipRecentlyUpdatedColor(float value)
|
|
{
|
|
const float3 kRecentlyUpdatedColor = float3(0.194, 0.007, 0.034);
|
|
return lerp(kRecentlyUpdatedColor, float3(0.766, 0.766, 0.766), value);
|
|
}
|
|
|
|
float3 GetDebugStreamingRecentlyUpdatedColor(float currentTime, float cooldownTime, bool perMaterial, float4 streamInfo)
|
|
{
|
|
if (!perMaterial && !IsStreaming(streamInfo))
|
|
return kMipMapDebugStatusColorNotStreaming;
|
|
|
|
if (perMaterial)
|
|
{
|
|
// The other per-material status codes don't really matter here (users visualize these in the status view).
|
|
// Even if there are slots with issues, as long as there is one slot with a streaming texture, we can visualize
|
|
// recent updates here.
|
|
int statusCode = GetStatusCode(streamInfo, true);
|
|
const bool hasStreamingTextures = (statusCode & kMipmapDebugStatusCodeFlagHasStreamingTextures) != 0;
|
|
if (!hasStreamingTextures)
|
|
return kMipMapDebugStatusColorNotStreaming; // nothing there, all slots are empty
|
|
}
|
|
|
|
const float timeSinceUpdate = currentTime - GetUpdateTimestamp(streamInfo);
|
|
const float ratio = clamp(timeSinceUpdate / cooldownTime, 0.0, 1.0);
|
|
return GetDebugMipRecentlyUpdatedColor(ratio);
|
|
}
|
|
|
|
float3 GetDebugMipColorIncludingMipReduction(float3 originalColor, uint mipCount, float4 texelSize, float2 uv, float4 mipInfo)
|
|
{
|
|
const uint originalTextureMipCount = GetTextureAssetMipCount(mipInfo);
|
|
if (originalTextureMipCount != 0)
|
|
{
|
|
// Mip count has been reduced but the texelSize was not updated to take that into account
|
|
const uint mipReductionLevel = originalTextureMipCount - mipCount;
|
|
const uint mipReductionFactor = 1U << mipReductionLevel;
|
|
if (mipReductionFactor)
|
|
{
|
|
const float oneOverMipReductionFactor = 1.0 / mipReductionFactor;
|
|
// texelSize.xy *= mipReductionRatio; // Unused in GetDebugMipColor so lets not re-calculate it
|
|
texelSize.zw *= oneOverMipReductionFactor;
|
|
}
|
|
}
|
|
return GetDebugMipColor(originalColor, texelSize, uv);
|
|
}
|
|
|
|
void HatchColor(uint2 unormCoord, real3 hatchingColor, inout real3 color)
|
|
{
|
|
const uint spacing = 8;
|
|
const uint thickness = 3;
|
|
if((unormCoord.x + unormCoord.y) % spacing < thickness)
|
|
color = hatchingColor;
|
|
}
|
|
|
|
void HatchColor(uint2 unormCoord, inout real3 color)
|
|
{
|
|
HatchColor(unormCoord, real3(0.1, 0.1, 0.1), color);
|
|
}
|
|
|
|
// Legend configuration
|
|
static const float _kLegendBarPaddingHorizontal = 20.0;
|
|
static const float _kLegendBarPaddingBottom = 20.0;
|
|
static const float _kLegendBarHeight = 20.0;
|
|
static const float _kLegendBarBorderThickness = 4.0;
|
|
|
|
static const float _kLegendPaddingBottom = 5.0;
|
|
static const float _kLegendMargin = 5.0;
|
|
static const float _kLegendEntryBlockSize = 15.0;
|
|
static const float _kLegendEntryBlockBorderSize = 1.0;
|
|
static const float _kLegendBorderSize = 2.0;
|
|
static const float _kLegendPaddingTextRight = 10.0;
|
|
|
|
void DrawLegendEntry(uint2 unormCoord, uint stringIndex, int code, float3 entryColor, bool hatched, real3 hatchingColor, inout uint2 pos, inout real3 outputColor)
|
|
{
|
|
const float3 borderColor = float3(1,1,1);
|
|
const float3 lightTextColor = float3(0.90, 0.90, 0.90);
|
|
const float3 darkTextColor = float3(0.10, 0.10, 0.10);
|
|
|
|
uint2 blockBottom = pos;
|
|
uint2 blockTop = blockBottom + uint2(_kLegendEntryBlockSize, _kLegendEntryBlockSize);
|
|
|
|
if (all(unormCoord > blockBottom) && all(unormCoord < blockTop))
|
|
{
|
|
if (all(unormCoord > blockBottom + uint(_kLegendEntryBlockBorderSize)) && all(unormCoord < blockTop - uint(_kLegendEntryBlockBorderSize)))
|
|
{
|
|
outputColor = entryColor;
|
|
|
|
if (hatched)
|
|
HatchColor(unormCoord, hatchingColor, outputColor);
|
|
|
|
if (code != -1)
|
|
{
|
|
bool invertColor = (code == kMipmapDebugStatusCodeNotSet || code == kMipmapDebugStatusCodeNoTexture || code == kMipmapDebugStatusCodeNoAsync || code == kMipmapDebugStatusCodeTerrain);
|
|
|
|
// draw "bold"
|
|
UNITY_LOOP for (uint i = 0; i < 4; ++i)
|
|
{
|
|
const bool isFont = SampleDebugFontNumber2Digits(unormCoord - pos + uint2(i % 2, i / 2), code);
|
|
UNITY_FLATTEN if (isFont)
|
|
{
|
|
outputColor = invertColor ? darkTextColor : lightTextColor;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
outputColor = borderColor;
|
|
}
|
|
|
|
uint2 textLocation = pos + uint2(_kLegendEntryBlockSize + _kLegendPaddingTextRight, 0);
|
|
DrawString(stringIndex, unormCoord, lightTextColor, textLocation, outputColor);
|
|
|
|
pos.y -= _kLegendEntryBlockSize + _kLegendMargin;
|
|
}
|
|
|
|
// Drawing a legend entry with an status code (no hatching)
|
|
void DrawLegendEntry(uint2 unormCoord, uint stringIndex, int code, float3 entryColor, inout uint2 pos, inout real3 outputColor)
|
|
{
|
|
DrawLegendEntry(unormCoord, stringIndex, code, entryColor, false, real3(0.1, 0.1, 0.1), pos, outputColor);
|
|
}
|
|
|
|
// Drawing a legend entry with just a color (no status code)
|
|
void DrawLegendEntry(uint2 unormCoord, uint stringIndex, float3 entryColor, real3 hatchingColor, inout uint2 pos, inout real3 outputColor)
|
|
{
|
|
DrawLegendEntry(unormCoord, stringIndex, -1, entryColor, true, hatchingColor, pos, outputColor);
|
|
}
|
|
|
|
// Drawing a legend entry with just a color (no status code)
|
|
void DrawLegendEntry(uint2 unormCoord, uint stringIndex, float3 entryColor, bool hatched, inout uint2 pos, inout real3 outputColor)
|
|
{
|
|
DrawLegendEntry(unormCoord, stringIndex, -1, entryColor, hatched, real3(0.1, 0.1, 0.1), pos, outputColor);
|
|
}
|
|
|
|
// Drawing a legend entry without hatching or status code
|
|
void DrawLegendEntry(uint2 unormCoord, uint stringIndex, float3 entryColor, inout uint2 pos, inout real3 outputColor)
|
|
{
|
|
DrawLegendEntry(unormCoord, stringIndex, -1, entryColor, false, real3(0.1, 0.1, 0.1), pos, outputColor);
|
|
}
|
|
|
|
void DrawLegendBackground(float2 texCoord, float4 screenSize, int numEntries, inout real3 color, out uint2 initialEntryPos)
|
|
{
|
|
const int largestStringSize = 31;
|
|
const int requiredWidth = largestStringSize * DEBUG_FONT_TEXT_SCALE_WIDTH + _kLegendPaddingTextRight + _kLegendEntryBlockSize + 2 * _kLegendMargin;
|
|
const int requiredHeight = numEntries * (_kLegendEntryBlockSize + _kLegendMargin) + _kLegendMargin;
|
|
|
|
// Screen space (fixed x, fixed y, rel x, rel y)
|
|
const int heightOfLegendBar = _kLegendBarPaddingBottom + _kLegendBarHeight + _kLegendBarBorderThickness;
|
|
const float4 legendPosition = float4(screenSize.x - requiredWidth - _kLegendBarPaddingHorizontal, heightOfLegendBar + _kLegendPaddingBottom, 0, 0);
|
|
const float4 legendSize = float4(requiredWidth, requiredHeight, 0, 0);
|
|
const float4 legendBorderThickness = float4(_kLegendBorderSize, _kLegendBorderSize, 0, 0);
|
|
const float4 legendWithBorderPosition = legendPosition - legendBorderThickness;
|
|
const float4 legendWithBorderSize = legendSize + 2 * legendBorderThickness;
|
|
|
|
// Screen UV space
|
|
const float2 legendPositionUV = legendPosition.xy * screenSize.zw + legendPosition.zw;
|
|
const float2 legendSizeUV = legendSize.xy * screenSize.zw + legendSize.zw;
|
|
const float2 legendWithBorderPositionUV = legendWithBorderPosition.xy * screenSize.zw + legendWithBorderPosition.zw;
|
|
const float2 legendWithBorderSizeUV = legendWithBorderSize.xy * screenSize.zw + legendWithBorderSize.zw;
|
|
|
|
// Legend (with border) space
|
|
const float2 legendBorderCoord = (texCoord - legendWithBorderPositionUV) / legendWithBorderSizeUV;
|
|
const float2 legendCoord = (texCoord - legendPositionUV) / legendSizeUV;
|
|
|
|
// Draw Legend border
|
|
if (all(legendBorderCoord >= 0) && all(legendBorderCoord <= 1))
|
|
color = real3(0.1, 0.1, 0.1);
|
|
|
|
// Draw Legend background
|
|
if (all(legendCoord >= 0) && all(legendCoord <= 1))
|
|
color = real3(0.022, 0.022, 0.022);
|
|
|
|
initialEntryPos = uint2(legendPosition.xy) + uint2(_kLegendMargin, requiredHeight - _kLegendMargin - _kLegendEntryBlockSize);
|
|
}
|
|
|
|
void DrawLegendBar(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
// Screen space (fixed x, fixed y, rel x, rel y)
|
|
const float4 legendBarPosition = float4(_kLegendBarPaddingHorizontal, _kLegendBarPaddingBottom, 0, 0);
|
|
const float4 legendBarSize = float4(-_kLegendBarPaddingHorizontal * 2, _kLegendBarHeight, 1, 0);
|
|
const float4 legendBarBorderThickness = float4(_kLegendBarBorderThickness, _kLegendBarBorderThickness, 0, 0);
|
|
const float4 legendBarWithBorderPosition = legendBarPosition - legendBarBorderThickness;
|
|
const float4 legendBarWithBorderSize = legendBarSize + 2 * legendBarBorderThickness;
|
|
|
|
// Screen UV space
|
|
const float2 legendBarWithBorderPositionUV = legendBarWithBorderPosition.xy * screenSize.zw + legendBarWithBorderPosition.zw;
|
|
const float2 legendBarWithBorderSizeUV = legendBarWithBorderSize.xy * screenSize.zw + legendBarWithBorderSize.zw;
|
|
|
|
// Legend bar (with border) space
|
|
const float2 legendBarBorderCoord = (texCoord - legendBarWithBorderPositionUV) / legendBarWithBorderSizeUV;
|
|
|
|
// Draw legend bar (still to be filled later)
|
|
if (all(legendBarBorderCoord >= 0) && all(legendBarBorderCoord <= 1))
|
|
color = real3(0.1, 0.1, 0.1);
|
|
}
|
|
|
|
bool InsideLegendBar(float2 texCoord, float4 screenSize, out float xCoord)
|
|
{
|
|
// Screen space (fixed x, fixed y, rel x, rel y)
|
|
const float4 legendBarPosition = float4(_kLegendBarPaddingHorizontal, _kLegendBarPaddingBottom, 0, 0);
|
|
const float4 legendBarSize = float4(-_kLegendBarPaddingHorizontal * 2, _kLegendBarHeight, 1, 0);
|
|
|
|
// Screen UV space
|
|
const float2 legendBarPositionUV = legendBarPosition.xy * screenSize.zw + legendBarPosition.zw;
|
|
const float2 legendBarSizeUV = legendBarSize.xy * screenSize.zw + legendBarSize.zw;
|
|
|
|
// Legend bar space
|
|
const float2 legendBarCoord = (texCoord - legendBarPositionUV) / legendBarSizeUV;
|
|
|
|
// Check if inside the legend bar (and fill in the "legend bar space" horizontal coordinate)
|
|
xCoord = legendBarCoord.x;
|
|
return all(legendBarCoord >= 0) && all(legendBarCoord <= 1);
|
|
}
|
|
|
|
void DrawLabelBarBackground(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
// Screen space (fixed x, fixed y, rel x, rel y)
|
|
const float4 labelBarPosition = float4(_kLegendBarPaddingHorizontal, 0, 0, 0);
|
|
const float4 labelBarSize = float4(-_kLegendBarPaddingHorizontal * 2, _kLegendBarPaddingBottom - _kLegendBarBorderThickness, 1, 0);
|
|
|
|
// Screen UV space
|
|
const float2 labelBarPositionUV = labelBarPosition.xy * screenSize.zw + labelBarPosition.zw;
|
|
const float2 labelBarSizeUV = labelBarSize.xy * screenSize.zw + labelBarSize.zw;
|
|
|
|
// Label bar space
|
|
const float2 labelBarCoord = (texCoord - labelBarPositionUV) / labelBarSizeUV;
|
|
|
|
// Draw label bar background
|
|
if (all(labelBarCoord >= 0) && all(labelBarCoord <= 1))
|
|
color = real3(0.022, 0.022, 0.022);
|
|
}
|
|
|
|
void DrawTwoValueLabelBar(uint2 unormCoord, float4 screenSize, uint leftStringId, uint rightStringId, inout real3 color)
|
|
{
|
|
const float3 textColor = float3(1,1,1);
|
|
|
|
// Draw left and right labels
|
|
const uint2 startPosition = uint2(_kLegendBarPaddingHorizontal, 0);
|
|
const uint2 endPosition = uint2(screenSize.x - _kLegendBarPaddingHorizontal - DEBUG_FONT_TEXT_SCALE_WIDTH, 0);
|
|
|
|
DrawString(leftStringId, unormCoord, textColor, startPosition, color);
|
|
DrawString(rightStringId, unormCoord, textColor, endPosition, true, color);
|
|
}
|
|
|
|
void DrawUniformlySpreadValues(uint2 unormCoord, float4 screenSize, uint numValues, uint startValue, inout real3 color)
|
|
{
|
|
const float bucketWidth = (screenSize.x - 2 * _kLegendBarPaddingHorizontal) / numValues;
|
|
|
|
for (uint i = 0; i < numValues; ++i)
|
|
{
|
|
const uint bucketLabel = uint(i + startValue);
|
|
const uint labelOffset = bucketLabel < 10 ? DEBUG_FONT_TEXT_SCALE_WIDTH / 2 : DEBUG_FONT_TEXT_SCALE_WIDTH;
|
|
const uint2 labelStartCoord = uint2(_kLegendBarPaddingHorizontal + i * bucketWidth + bucketWidth / 2 - labelOffset, 0);
|
|
|
|
const uint2 pixCoord = unormCoord - labelStartCoord;
|
|
if (SampleDebugFontNumberAllDigits(pixCoord, bucketLabel))
|
|
color = real3(1, 1, 1);
|
|
}
|
|
}
|
|
|
|
|
|
// Legend drawing functions
|
|
// ------------------------
|
|
|
|
void DrawMipCountLegend(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
const real maxMipCount = 14;
|
|
|
|
// Draw legend
|
|
uint2 pos;
|
|
DrawLegendBackground(texCoord, screenSize, 2, color, pos);
|
|
DrawLegendEntry(unormCoord, _kNoMipCountIndex, kMipmapDebugInvalidMipCount, float3(0.9, 0.9, 0.9), pos, color);
|
|
DrawLegendEntry(unormCoord, _kTooManyMipsIndex, kMipmapDebugTooManyMips, float3(0.9, 0.9, 0.9), pos, color);
|
|
|
|
// Draw legend bar
|
|
DrawLegendBar(texCoord, screenSize, color);
|
|
|
|
float xCoord;
|
|
if (InsideLegendBar(texCoord, screenSize, xCoord))
|
|
{
|
|
// Compute bucket index
|
|
const int bucket = ceil(xCoord * maxMipCount);
|
|
bool needsHatching;
|
|
color = GetDebugMipCountColor(bucket, needsHatching);
|
|
if (needsHatching)
|
|
// no need to get the hatching color (to keep in sync with rendering), it's always dark anyway inside the legend bar
|
|
HatchColor(unormCoord, color);
|
|
}
|
|
|
|
DrawLabelBarBackground(texCoord, screenSize, color);
|
|
DrawUniformlySpreadValues(unormCoord, screenSize, maxMipCount, 1, color);
|
|
}
|
|
|
|
void DrawMipRatioLegend(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
|
|
// Draw legend bar
|
|
DrawLegendBar(texCoord, screenSize, color);
|
|
|
|
float xCoord;
|
|
if (InsideLegendBar(texCoord, screenSize, xCoord))
|
|
color = GetDebugMipRatioColor(xCoord);
|
|
|
|
// Text labels
|
|
DrawLabelBarBackground(texCoord, screenSize, color);
|
|
DrawTwoValueLabelBar(unormCoord, screenSize, _kLowPixelDensityIndex, _kHighPixelDensityIndex, color);
|
|
}
|
|
|
|
void DrawMipPriorityLegend(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
|
|
// Draw the legend
|
|
uint2 pos;
|
|
DrawLegendBackground(texCoord, screenSize, 1, color, pos);
|
|
DrawLegendEntry(unormCoord, _kNotStreamingIndex, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
|
|
// Draw legend bar
|
|
DrawLegendBar(texCoord, screenSize, color);
|
|
|
|
float xCoord;
|
|
if (InsideLegendBar(texCoord, screenSize, xCoord))
|
|
color = GetDebugMipPriorityColor(xCoord);
|
|
|
|
// Text labels
|
|
DrawLabelBarBackground(texCoord, screenSize, color);
|
|
DrawTwoValueLabelBar(unormCoord, screenSize, _kLowPriorityIndex, _kHighPriorityIndex, color);
|
|
}
|
|
|
|
void DrawMipRecentlyUpdatedLegend(float2 texCoord, float4 screenSize, bool perMaterial, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
|
|
// Draw the legend
|
|
uint2 pos;
|
|
DrawLegendBackground(texCoord, screenSize, 1, color, pos);
|
|
if(perMaterial)
|
|
DrawLegendEntry(unormCoord, _kStatusNoTexturesAreStreaming, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
else
|
|
DrawLegendEntry(unormCoord, _kNotStreamingIndex, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
|
|
// Draw legend bar
|
|
DrawLegendBar(texCoord, screenSize, color);
|
|
|
|
float xCoord;
|
|
if (InsideLegendBar(texCoord, screenSize, xCoord))
|
|
color = GetDebugMipRecentlyUpdatedColor(xCoord);
|
|
|
|
// Text labels
|
|
DrawLabelBarBackground(texCoord, screenSize, color);
|
|
DrawTwoValueLabelBar(unormCoord, screenSize, _kRecentlyUpdated, _kNotRecentlyUpdated, color);
|
|
}
|
|
|
|
void DrawMipStreamingStatusLegend(float2 texCoord, float4 screenSize, bool needsStatusCodes, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
|
|
// Draw the legend
|
|
uint2 pos;
|
|
const int numEntries = needsStatusCodes ? 11 : 6;
|
|
DrawLegendBackground(texCoord, screenSize, numEntries, color, pos);
|
|
|
|
DrawLegendEntry(unormCoord, _kStatusNoTextureIndex, kMipMapDebugStatusColorNoTexture, pos, color);
|
|
DrawLegendEntry(unormCoord, _kNotStreamingIndex, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
if (needsStatusCodes)
|
|
{
|
|
DrawLegendEntry(unormCoord, _kStatusStreamerDisabledIndex, kMipmapDebugStatusCodeStreamerDisabled, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusMessageNoMipMapIndex, kMipmapDebugStatusCodeNoMipMap, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusMessageNotSetToStreamIndex, kMipmapDebugStatusCodeNotSetToStream, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
}
|
|
DrawLegendEntry(unormCoord, _kStreamingIndex, kMipMapDebugStatusColorStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStreamingManuallyIndex, kMipMapDebugStatusColorStreaming, true, pos, color);
|
|
|
|
DrawLegendEntry(unormCoord, _kStatusWarningIndex, kMipMapDebugStatusColorWarning, pos, color);
|
|
if (needsStatusCodes)
|
|
{
|
|
DrawLegendEntry(unormCoord, _kStatusMessageNoAsyncIndex, kMipmapDebugStatusCodeNoAsync, kMipMapDebugStatusColorWarning, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusMessageTerrainIndex, kMipmapDebugStatusCodeTerrain, kMipMapDebugStatusColorWarning, pos, color);
|
|
}
|
|
|
|
DrawLegendEntry(unormCoord, _kStatusUnknownIndex, kMipMapDebugStatusColorUnknown, pos, color);
|
|
}
|
|
|
|
void DrawMipStreamingStatusPerMaterialLegend(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
|
|
// Draw the legend
|
|
uint2 pos;
|
|
DrawLegendBackground(texCoord, screenSize, 7, color, pos);
|
|
|
|
DrawLegendEntry(unormCoord, _kStatusNoTexturesIndex, kMipMapDebugStatusColorNoTexture, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusNoTexturesAreStreaming, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusSomeTexturesAreStreaming, kMipMapDebugMaterialStatusColorSomeStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusSomeTexturesAreStreamingSomeManually, kMipMapDebugMaterialStatusColorSomeStreaming, true, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusAllTexturesAreStreaming, kMipMapDebugStatusColorStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusAllTexturesAreStreamingSomeManually, kMipMapDebugStatusColorStreaming, true, pos, color);
|
|
DrawLegendEntry(unormCoord, _kStatusSomeTexturesHaveIssues, kMipMapDebugStatusColorWarning, pos, color);
|
|
}
|
|
|
|
void DrawTextureStreamingPerformanceLegend(float2 texCoord, float4 screenSize, inout real3 color)
|
|
{
|
|
const uint2 unormCoord = texCoord * screenSize.xy;
|
|
|
|
// Draw the legend
|
|
uint2 pos;
|
|
DrawLegendBackground(texCoord, screenSize, 5, color, pos);
|
|
|
|
DrawLegendEntry(unormCoord, _kNotStreamingIndex, kMipMapDebugStatusColorNotStreaming, pos, color);
|
|
DrawLegendEntry(unormCoord, _kBudgetSavingMips, kMipmapDebugBudgetSavingMips, pos, color);
|
|
DrawLegendEntry(unormCoord, _kBudgetSavingMipsWithCache, kMipmapDebugBudgetSavingMips, true, pos, color);
|
|
DrawLegendEntry(unormCoord, _kBudgetNothingSaved, kMipmapDebugBudgetFullResolution, pos, color);
|
|
DrawLegendEntry(unormCoord, _kBudgetMissingMips, kMipmapDebugBudgetMissing, pos, color);
|
|
}
|
|
|
|
#endif // UNITY_DEBUG_MIPMAP_STREAMING_INCLUDED
|