shader changes & screen quads

src/engine/main.cpp

@@ -98,6 +98,10 @@ void FileChangeCheck(HANDLE dirHandle, FileChangeType changeType, const wchar_t*
             {
                 if (compName == nullptr || compName[0] == 0 || wcscmp(notifyData->FileName, compName) == 0)
                 {
+                    char buf[1024]{0};
+                    wcstombs(buf, notifyData->FileName, sizeof(buf));
+                    printf("file change of type %u: %s\n", changeType, buf);
+
                     FileChangeNotification notif;
                     wcscpy(notif.FileName, notifyData->FileName);
                     if (changeType == FileChangeType::DLL)
@@ -106,23 +110,25 @@ void FileChangeCheck(HANDLE dirHandle, FileChangeType changeType, const wchar_t*
                     }
                     else if (changeType == FileChangeType::Shader)
                     {
-                        std::system("shadercompile.bat > shadercompile.log");
+                        printf("shader source change!\n");
+                        std::system("powershell.exe .\\shadercompile.ps1 > shadercompile.log");
                         Sleep(1000);
                         std::ifstream shaderLogFile("shadercompile.log");
                         if (shaderLogFile.is_open())
                         {
                             shaderLogFile.seekg(0, std::ios::end);
-                            uint32_t size = bx::min(BX_COUNTOF(Shared.Dev.ShaderLog), shaderLogFile.tellg());
+                            uint32_t size = bx::min(BX_COUNTOF(Shared.Dev.ShaderLog) - 1, shaderLogFile.tellg());
                             shaderLogFile.seekg(0);
                             shaderLogFile.read(Shared.Dev.ShaderLog, size);
                             shaderLogFile.close();
+                            Shared.Dev.ShaderLog[size] = 0;
                         }
                     }
                     else if (changeType == FileChangeType::CompiledShader)
                     {
+                        printf("compiled shader change!\n");
                         DevData.FileWatcher.ShaderQueue.push(&notif);
                     }
-                    printf("detected file change of type %u!\n", changeType);
                 }
             }
 

src/game/Level.cpp

@@ -325,7 +325,7 @@ namespace Game
             UIPlacedCards[i] = level.UIQuads.New();
             auto& quad = level.UIQuads.Get(UIPlacedCards[i]);
             quad.EData.ModelH = GameRendering::Get().GetModelHandleFromPath("models/plane.glb");
-            quad.EData.MaterialHandle = EMaterial::Default;
+            quad.EData.MaterialHandle = EMaterial::UI;
             quad.EData.Visible = false;
         }
         IsSetup = true;
@@ -349,7 +349,7 @@ namespace Game
 
                 bool IsValid = Puzzle::IsValid(card.RefCard);
                 tile.EData.Visible = true;
-                quad.EData.Visible = true;
+                quad.EData.Visible = IsValid;
 
                 tile.EData.ModelH = IsValid ? staticCards[card.RefCard.Idx].ModelHandle : staticCards[0].ModelHandle;
                 Vec3 cardPos = {
@@ -368,7 +368,9 @@ namespace Game
                 Vec3 fw = {camTransform.M.M[2], camTransform.M.M[6], camTransform.M.M[10]};
                 Vec3 pos = camTransform.GetPosition() * -1;
                 pos += fw;
+                pos += Vec3{cardPos.x, cardPos.z, 0.0f} * 0.025f;
                 quad.EData.Transform.SetPosition(pos);
+                quad.EData.Transform.Scale = {0.1f, 0.1f, 0.1f};
                 quad.EData.Transform.Rotation = camTransform.Rotation.Inverse();
                 quad.EData.Transform.Rotate(Vec3{bx::kPi * 0.5f, 0.0f, 0.0f});
             }

src/game/rendering/Rendering.cpp

@@ -377,8 +377,7 @@ namespace Game
         Textures[0].SamplerHandle = DefaultSampler;
         LoadModels(Models, ModelCount);
 
-        Materials[(uint16_t)EMaterial::Default] =
-            Material::LoadFromShader("vert", "frag", MainViewID, Textures[0].Handle, Textures[0].SamplerHandle);
+        ReloadShaders();
         imguiCreate();
         SetImguiStyle();
 
@@ -439,26 +438,17 @@ namespace Game
         FileChangeNotification* shaderChange = nullptr;
         if (shared.Dev.ChangedShaderCount > 0)
         {
+            char buf[1024]{0};
+            for (int32_t i = 0; i < shared.Dev.ChangedShaderCount; ++i)
+            {
+                wcstombs(buf, shared.Dev.ChangedShaders[i].FileName, sizeof(buf));
+                LOG("Changed: %s", buf);
+            }
             shared.Dev.ChangedShaderCount = 0;
 
             // TODO: when to destroy shader?
             // TODO: only reload changed shaders
-            bgfx::ShaderHandle vertexShader = loadShader("vert");
-            bgfx::ShaderHandle fragmentShader = loadShader("frag");
-            if (isValid(vertexShader) && isValid(fragmentShader))
-            {
-                bgfx::ProgramHandle newProgram = bgfx::createProgram(vertexShader, fragmentShader, true);
-                if (isValid(newProgram))
-                {
-                    Materials[(uint16_t)EMaterial::Default].Shader = newProgram;
-                    LastShaderLoadTime = GetInstance().Time.Now;
-                }
-                else
-                {
-                    LOG_WARN("Failed to load shader!");
-                    LastShaderLoadTime = -1.0f;
-                }
-            }
+            ReloadShaders();
         }
     }
 
@@ -697,6 +687,14 @@ namespace Game
         ImGui::End();
     }
 
+    void GameRendering::ReloadShaders()
+    {
+        Materials[(uint16_t)EMaterial::Default] = Material::LoadFromShader(
+            "dither/vert", "dither/frag", MainViewID, Textures[0].Handle, Textures[0].SamplerHandle);
+        Materials[(uint16_t)EMaterial::UI] = Material::LoadFromShader(
+            "normal/vert", "normal/frag", MainViewID, Textures[0].Handle, Textures[0].SamplerHandle);
+    }
+
     void GameRendering::Update()
     {
         ZoneScopedN("Rendering");

src/game/rendering/Rendering.h

@@ -125,6 +125,7 @@ namespace Game
         void Update();
         void HandleEvents();
         void RenderDebugUI();
+        void ReloadShaders();
         void Shutdown();
         Generated::ModelHandle GetModelHandleFromPath(const char* path);
     };

src/game/shaders/dither/frag.sc

@@ -3,7 +3,7 @@ $input v_normal
 $input v_uv0
 $input v_wpos
 
-#include "common.sh"
+#include "../common.sh"
 
 SAMPLER2D(s_texColor, 0);
 SAMPLER3D(s_ditherSampler, 1);
@@ -107,4 +107,5 @@ void main()
 	float3 ditheredColor = dither(brightness, v_uv0);
 	float3 finalColor = mix(u_baseColor, texColor, ditheredColor);
 	gl_FragColor = vec4(finalColor, 1.0);
+	
 }

src/game/shaders/dither/vert.sc

@@ -1,7 +1,7 @@
 $input a_position, a_normal, a_color0, a_texcoord0
 $output v_color0, v_normal, v_uv0, v_wpos
 
-#include "common.sh"
+#include "../common.sh"
 
 void main()
 {

src/game/shaders/normal/frag.sc

@@ -0,0 +1,112 @@
+$input v_color0
+$input v_normal
+$input v_uv0
+$input v_wpos
+
+#include "../common.sh"
+
+SAMPLER2D(s_texColor, 0);
+SAMPLER3D(s_ditherSampler, 1);
+SAMPLER2D(s_rampSampler, 2);
+uniform vec4 u_time;
+uniform vec4 u_testColor;
+uniform vec4 u_texInfo;
+uniform vec4 u_baseColor;
+
+float calcBrightness(vec3 lightPos, vec3 vertPos, vec3 normal)
+{
+	vec3 lightDir = normalize(lightPos - vertPos);
+	float diffuse = max(0.0, dot(lightDir, normal));
+	return diffuse * clamp(1.0 - distance(lightPos, vertPos) * 0.01, 0.0, 1.0);
+}
+
+float calcBrightnessDirectional(vec3 sunDir, vec3 normal)
+{
+	return max(0.0, dot(sunDir, normal));
+}
+
+vec3 desaturate(vec3 color)
+{
+	return vec3_splat(dot(color, vec3(0.33, 0.34, 0.33)));
+}
+
+float dither(float brightness, vec2 inputUv)
+{
+	float globalScale = 8;
+	
+	// constants
+	float xRes = u_texInfo.z;
+	float dotsPerSide = xRes / 16;
+	float dotsTotal = dotsPerSide * dotsPerSide;
+	float invXRes = 1 / xRes;
+	float zRes = dotsTotal;
+	float invZRes = 1 / zRes;
+	
+	float2 rampLookupUv = vec2((0.5 * invXRes + (1 - invXRes) * brightness), 0.5);
+	float brightnessCurve = texture2D(s_rampSampler, rampLookupUv).r;
+	
+	// Magic dot frequency calculation
+	float2 dx = ddx(inputUv);
+	float2 dy = ddy(inputUv);
+	float2x2 mat = float2x2(dx, dy);
+	float4 vectorized = float4(dx, dy);
+	float qq = dot(vectorized, vectorized);
+	float rr = determinant(mat);
+	float discriminantSqr = max(0.0, qq*qq - 4.0*rr*rr);
+	float discriminant = sqrt(discriminantSqr);	
+	float2 freq = sqrt(float2(qq + discriminant, qq - discriminant) / 2.0);
+
+	// Figuring out how many dots we want
+	float scaleExp = exp2(globalScale);
+	float spacing = freq.y * scaleExp;
+	spacing *= dotsPerSide * 0.125;
+
+	float brightnessSpacingMultiplier = pow(brightnessCurve * 2 + 0.001, -(1 - 0.5));
+	// float brightnessSpacingMultiplier = 1;
+	spacing *= brightnessSpacingMultiplier;
+	
+	float spacingLog = log2(spacing);
+	int patternScaleLevel = floor(spacingLog);
+	float patternFractional = spacingLog - patternScaleLevel;
+	vec2 uv = inputUv / exp2(patternScaleLevel);
+	
+	// patternFractional *= patternFractional;
+	// patternFractional = smoothstep(0, 1, patternFractional);
+	float subLayer = lerp(0.25 * dotsTotal, dotsTotal, 1 - patternFractional);
+	subLayer = (subLayer - 0.5) * invZRes;
+	
+	float pattern = texture3D(s_ditherSampler, vec3(uv, subLayer)).r;	
+	
+	float contrast = 2 * scaleExp * brightnessSpacingMultiplier * 0.1;
+	contrast *= pow(freq.y / freq.x, 1.0);
+	float baseVal = lerp(0.5, brightness, saturate(1.05 / (1 + contrast)));
+	float threshold = 1 - brightnessCurve + 0.6;
+	
+	return saturate((pattern - threshold) * contrast + baseVal);
+}
+
+void main()
+{
+	// setup
+	float testRadius = 30.0;
+	float testSpeed = 1.0;
+	vec3 testOffset = vec3(0.0, 0.0, 50.0);
+	float3 lightPos = vec3(sin(u_time.x * testSpeed) * testRadius, 5.0, cos(u_time.x * testSpeed) * testRadius);
+	vec3 texColor = u_testColor.x > 0.1 ? u_testColor.xyz : texture2D(s_texColor, v_uv0).xyz;
+
+	// lighting
+	// float brightness = calcBrightness(lightPos, v_wpos, v_normal);
+	float brightness = lerp(0.5, 0.9, calcBrightnessDirectional(vec3(0.5, 0.3, 1.0), v_normal));
+	// float brightness = 0.5;
+	// brightness = lerp(0.2, 1.0, sin(u_time.x) * 0.5 + 0.5);
+
+	float r = dither(brightness * texColor.r, v_uv0);
+	float g = dither(brightness * texColor.g, v_uv0);
+	float b = dither(brightness * texColor.b, v_uv0);
+	// float3 finalColor = vec3(r, g, b);
+	float3 ditheredColor = dither(brightness, v_uv0);
+	float3 finalColor = mix(u_baseColor, texColor, ditheredColor);
+	gl_FragColor = vec4(finalColor, 1.0);
+	gl_FragColor = vec4(texColor, 1.0);
+	
+}

src/game/shaders/normal/varying.def.sc

@@ -0,0 +1,9 @@
+vec4 v_color0    : COLOR0    = vec4(1.0, 1.0, 0.0, 1.0);
+vec3 v_normal    : NORMAL    = vec3(0.0, 0.0, 1.0);
+vec2 v_uv0       : TEXCOORD0 = vec2(0.0, 0.0);
+vec3 v_wpos      : TEXCOORD1 = vec3(0.0, 0.0, 0.0);
+
+vec3 a_position  : POSITION;
+vec3 a_normal    : NORMAL;
+vec4 a_color0    : COLOR0;
+vec2 a_texcoord0 : TEXCOORD0;

src/game/shaders/normal/vert.sc

@@ -0,0 +1,13 @@
+$input a_position, a_normal, a_color0, a_texcoord0
+$output v_color0, v_normal, v_uv0, v_wpos
+
+#include "../common.sh"
+
+void main()
+{
+	gl_Position = mul(u_modelViewProj, vec4(a_position, 1.0));
+	v_color0 = a_color0;
+	v_uv0 = a_texcoord0;
+	v_wpos = mul(u_model[0], vec4(a_position, 1.0)).xyz;
+	v_normal = normalize(mul(u_model[0], a_normal));
+}

src/shadercompile.bat

@@ -1,6 +0,0 @@
-.\cmake-build\shaderc.exe -f .\game\shaders\vert.sc -o .\game\compiled-shaders\dx11\vert.bin -i .\dependency\bgfx.cmake\bgfx\src\ --type v --platform windows --profile s_5_0
-.\cmake-build\shaderc.exe -f .\game\shaders\frag.sc -o .\game\compiled-shaders\dx11\frag.bin -i .\dependency\bgfx.cmake\bgfx\src\ --type f --platform windows --profile s_5_0
-.\cmake-build\shaderc.exe -f .\game\shaders\vert.sc -o .\game\compiled-shaders\glsl\vert.bin -i .\dependency\bgfx.cmake\bgfx\src\ --type v --platform windows --profile 430
-.\cmake-build\shaderc.exe -f .\game\shaders\frag.sc -o .\game\compiled-shaders\glsl\frag.bin -i .\dependency\bgfx.cmake\bgfx\src\ --type f --platform windows --profile 430
-.\cmake-build\shaderc.exe -f .\game\shaders\vert.sc -o .\game\compiled-shaders\spirv\vert.bin -i .\dependency\bgfx.cmake\bgfx\src\ --type v --platform windows --profile spirv16-13
-.\cmake-build\shaderc.exe -f .\game\shaders\frag.sc -o .\game\compiled-shaders\spirv\frag.bin -i .\dependency\bgfx.cmake\bgfx\src\ --type f --platform windows --profile spirv16-13

src/shadercompile.ps1

@@ -0,0 +1,20 @@
+$shadercPath = ".\cmake-build\shaderc.exe"
+$shadersDir = ".\game\shaders"
+$outputBaseDir = ".\game\compiled-shaders"
+$includeDir = ".\dependency\bgfx.cmake\bgfx\src"
+
+function Process-Directory {
+  param ([string]$DirectoryFull, [string]$DirectoryName)
+  Write-Host "Dir: $DirectoryName"
+  $outDir = "$outputBaseDir\dx11\$DirectoryName"
+  New-Item -ItemType Directory -Path $outDir -Force -ErrorAction Stop | Out-Null
+  Write-Host "Frag"
+  & $shadercPath -f "$DirectoryFull\vert.sc" -o "$outDir\vert.bin" -i $includeDir --type v --platform windows --profile s_5_0
+  Write-Host "Vert"
+  & $shadercPath -f "$DirectoryFull\frag.sc" -o "$outDir\frag.bin" -i $includeDir --type f --platform windows --profile s_5_0
+}
+
+$subdirectories = Get-ChildItem -Path $shadersDir -Directory -Recurse -ErrorAction Stop
+foreach ($subdirectory in $subdirectories) {
+  Process-Directory -DirectoryFull $subdirectory.FullName -DirectoryName $subdirectory.Name
+}