cnq3/code/shadercomp/shadercomp.cpp
2024-01-19 23:57:40 +01:00

443 lines
13 KiB
C++

/*
===========================================================================
Copyright (C) 2022-2024 Gian 'myT' Schellenbaum
This file is part of Challenge Quake 3 (CNQ3).
Challenge Quake 3 is free software; you can redistribute it
and/or modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
Challenge Quake 3 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Challenge Quake 3. If not, see <https://www.gnu.org/licenses/>.
===========================================================================
*/
// compiles core shaders as byte code to be embedded into the CNQ3 client
#include <Windows.h>
#include <stdarg.h>
#include <stdio.h>
#include <assert.h>
#include <shlwapi.h>
#include <sal.h>
#include "../renderer/grp_uber_shaders.h"
char repoPath[MAX_PATH];
char outputPath[MAX_PATH];
char bin2headerPath[MAX_PATH];
char dxcPath[MAX_PATH];
const char* targetVS = "vs_6_0";
const char* targetPS = "ps_6_0";
const char* targetCS = "cs_6_0";
#define PS(Data) #Data,
const char* uberShaderPixelStates[] =
{
UBER_SHADER_PS_LIST(PS)
};
#undef PS
// -Zi embeds debug info
// -Qembed_debug embeds debug info in shader container
// -Vn header variable name
// -WX warnings as errors
// -O3 or -O0 optimization level
// -Wno-warning disables the warning
const char* va(_Printf_format_string_ const char* format, ...)
{
static char string[64][32000];
static int index = 0;
char* buf = string[index++ & 63];
va_list argptr;
va_start(argptr, format);
vsprintf(buf, format, argptr);
va_end(argptr);
return buf;
}
struct ShaderArgs
{
const char* headerPath;
const char* shaderPath;
const char* entryPoint;
const char* targetProfile;
};
const char* OutputPath(const char* path)
{
return va("%s\\%s", outputPath, path);
}
const char* HeaderVariable(const char* name)
{
// the output variable isn't declared static, polluting the global namespace...
return va("\"static %s\"", name);
}
void CompileShader(const ShaderArgs& args, int extraCount = 0, const char** extras = NULL)
{
static char temp[4096];
const char* headerPath = va("%s\\%s", outputPath, args.headerPath);
// -Ges: Enable strict mode
// -Gis: Force IEEE strictness
// -Zi: Embed debug info
// -Qembed_debug: Embed debug info in shader container
strcpy(temp, va("%s -Fh %s -E %s -T %s -WX -Ges -Gis -Zi -Qembed_debug",
dxcPath, headerPath, args.entryPoint, args.targetProfile));
for(int i = 0; i < extraCount; ++i)
{
strcat(temp, " ");
strcat(temp, extras[i]);
}
strcat(temp, " ");
strcat(temp, args.shaderPath);
printf("%s\n", temp);
system(temp);
}
struct SMAAArgs
{
const char* headerPath;
const char* shaderPath;
const char* presetMacro;
const char* variableName;
bool vertexShader;
};
void CompileSMAAShader(const SMAAArgs& smaaArgs)
{
const char* extras[] =
{
"-Vn", HeaderVariable(smaaArgs.variableName),
smaaArgs.presetMacro,
smaaArgs.vertexShader ? "-D SMAA_INCLUDE_VS=1" : "-D SMAA_INCLUDE_PS=1",
"-D SMAA_HLSL_5_1=1",
"-D SMAA_RT_METRICS=rtMetrics"
};
ShaderArgs args;
args.entryPoint = smaaArgs.vertexShader ? "vs" : "ps";
args.headerPath = smaaArgs.headerPath;
args.shaderPath = smaaArgs.shaderPath;
args.targetProfile = smaaArgs.vertexShader ? targetVS : targetPS;
CompileShader(args, _countof(extras), extras);
}
void ProcessSMAAShadersForPreset(const char* presetName, const char* presetMacro)
{
SMAAArgs args;
args.presetMacro = presetMacro;
for(int pass = 0; pass < 3; ++pass)
{
for(int ps = 0; ps < 2; ++ps)
{
args.headerPath = va("smaa_%s_%d_%s.h", presetName, pass + 1, ps ? "ps" : "vs");
args.shaderPath = va("smaa_%d.hlsl", pass + 1);
args.variableName = va("%s_%d_%s", presetName, pass + 1, ps ? "ps" : "vs");
args.vertexShader = ps == 0;
CompileSMAAShader(args);
}
}
}
void CompileSMAAShaders()
{
ProcessSMAAShadersForPreset("low", "-D SMAA_PRESET_LOW=1");
ProcessSMAAShadersForPreset("medium", "-D SMAA_PRESET_MEDIUM=1");
ProcessSMAAShadersForPreset("high", "-D SMAA_PRESET_HIGH=1");
ProcessSMAAShadersForPreset("ultra", "-D SMAA_PRESET_ULTRA=1");
}
void CompileGraphics(const char* headerPath, const char* shaderPath, const char* varName)
{
const char* vsHeaderRelPath = va("%s.vs.h", shaderPath);
const char* psHeaderRelPath = va("%s.ps.h", shaderPath);
const char* vsHeaderPath = OutputPath(vsHeaderRelPath);
const char* psHeaderPath = OutputPath(psHeaderRelPath);
const char* vsExtras[] =
{
"-D", "VERTEX_SHADER=1",
"-Vn", HeaderVariable(va("g_%s_vs", varName))
};
const char* psExtras[] =
{
"-D", "PIXEL_SHADER=1",
"-Vn", HeaderVariable(va("g_%s_ps", varName))
};
ShaderArgs args;
args.entryPoint = "vs";
args.headerPath = vsHeaderRelPath;
args.shaderPath = shaderPath;
args.targetProfile = targetVS;
CompileShader(args, _countof(vsExtras), vsExtras);
args.entryPoint = "ps";
args.headerPath = psHeaderRelPath;
args.shaderPath = shaderPath;
args.targetProfile = targetPS;
CompileShader(args, _countof(psExtras), psExtras);
const char* outHeaderPath = OutputPath(headerPath);
system(va("type %s %s > %s", vsHeaderPath, psHeaderPath, outHeaderPath));
system(va("del %s", vsHeaderPath));
system(va("del %s", psHeaderPath));
}
void CompileVertexShader(const char* headerPath, const char* shaderPath, const char* varName)
{
const char* extras[] =
{
"-D", "VERTEX_SHADER=1",
"-Vn", HeaderVariable(va("g_%s_vs", varName))
};
ShaderArgs args;
args.entryPoint = "vs";
args.headerPath = headerPath;
args.shaderPath = shaderPath;
args.targetProfile = targetVS;
CompileShader(args, _countof(extras), extras);
}
void CompilePixelShader(const char* headerPath, const char* shaderPath, const char* varName)
{
const char* extras[] =
{
"-D", "PIXEL_SHADER=1",
"-Vn", HeaderVariable(va("g_%s_ps", varName))
};
ShaderArgs args;
args.entryPoint = "ps";
args.headerPath = headerPath;
args.shaderPath = shaderPath;
args.targetProfile = targetPS;
CompileShader(args, _countof(extras), extras);
}
void CompileCompute(const char* headerPath, const char* shaderPath, const char* varName)
{
const char* extras[] =
{
"-D", "COMPUTE_SHADER=1",
"-Vn", HeaderVariable(va("g_%s_cs", varName))
};
ShaderArgs args;
args.entryPoint = "cs";
args.headerPath = headerPath;
args.shaderPath = shaderPath;
args.targetProfile = targetCS;
CompileShader(args, _countof(extras), extras);
}
void CompileUberVS(const char* headerPath, const char* shaderPath, int stageCount)
{
const char* extras[] =
{
"-D", "VERTEX_SHADER=1",
"-D", va("STAGE_COUNT=%d", stageCount),
"-Vn", HeaderVariable(va("g_vs_%d", stageCount))
};
ShaderArgs args;
args.entryPoint = "vs";
args.headerPath = headerPath;
args.shaderPath = shaderPath;
args.targetProfile = targetVS;
CompileShader(args, _countof(extras), extras);
}
void CompileUberPS(const char* stateString)
{
UberPixelShaderState state;
if(!ParseUberPixelShaderState(state, stateString))
{
fprintf(stderr, "ParseUberPixelShaderState failed!\n");
exit(666);
}
const char* extras[16];
int extraCount = 0;
extras[extraCount++] = va("-Vn %s", HeaderVariable(va("g_ps_%s", stateString)));
extras[extraCount++] = "-D USE_INCLUDES=1";
extras[extraCount++] = "-D PIXEL_SHADER=1";
if(state.globalState & UBERPS_DITHER_BIT)
{
extras[extraCount++] = "-D DITHER=1";
}
if(state.globalState & UBERPS_DEPTHFADE_BIT)
{
extras[extraCount++] = "-D DEPTH_FADE=1";
}
extras[extraCount++] = va("-D STAGE_COUNT=%d", state.stageCount);
for(int s = 0; s < state.stageCount; ++s)
{
extras[extraCount++] = va("-D STAGE%d_BITS=0x%X", s, state.stageStates[s]);
}
ShaderArgs args;
args.entryPoint = "ps";
args.headerPath = va("uber_shader_ps_%s.h", stateString);
args.shaderPath = "uber_shader.hlsl";
args.targetProfile = targetPS;
CompileShader(args, extraCount, extras);
}
const char* Canonicalize(const char* path)
{
static char canonPath[MAX_PATH];
PathCanonicalizeA(canonPath, path);
return canonPath;
}
void InitDirectory(const char* dirName)
{
const char* rendererPath = va("%s\\code\\renderer", repoPath);
const char* cd = Canonicalize(va("%s\\shaders\\%s", rendererPath, dirName));
SetCurrentDirectoryA(cd);
const char* out = Canonicalize(va("%s\\compshaders\\%s", rendererPath, dirName));
strcpy(outputPath, out);
CreateDirectoryA(outputPath, NULL);
system(va("del %s\\*.h", outputPath));
system(va("del %s\\*.temp", outputPath));
}
void ProcessGRP()
{
InitDirectory("grp");
targetVS = "vs_6_0";
targetPS = "ps_6_0";
targetCS = "cs_6_0";
CompileGraphics("post_gamma.h", "post_gamma.hlsl", "post");
CompileGraphics("post_inverse_gamma.h", "post_inverse_gamma.hlsl", "post_inverse");
CompileGraphics("imgui.h", "imgui.hlsl", "imgui");
CompileGraphics("nuklear.h", "nuklear.hlsl", "nuklear");
CompileGraphics("ui.h", "ui.hlsl", "ui");
CompileGraphics("depth_pre_pass.h", "depth_pre_pass.hlsl", "zpp");
CompileGraphics("dynamic_light.h", "dynamic_light.hlsl", "dl");
CompileVertexShader("fog.h", "fog_inside.hlsl", "fog");
CompilePixelShader("fog_inside.h", "fog_inside.hlsl", "fog_inside");
CompilePixelShader("fog_outside.h", "fog_outside.hlsl", "fog_outside");
CompileCompute("mip_1.h", "mip_1.hlsl", "mip_1");
CompileCompute("mip_2.h", "mip_2.hlsl", "mip_2");
CompileCompute("mip_3.h", "mip_3.hlsl", "mip_3");
CompileSMAAShaders();
system(va("type %s\\smaa*.h > %s\\complete_smaa.h", outputPath, outputPath));
// type combines all files into one
system(va("type ..\\common\\state_bits.h.hlsli ..\\common\\blend.hlsli shared.hlsli uber_shader.hlsl > %s\\uber_shader.temp", outputPath));
system(va("%s --output %s\\uber_shader.h --hname uber_shader_string %s\\uber_shader.temp", bin2headerPath, outputPath, outputPath));
system(va("del %s\\uber_shader.temp", outputPath));
for(int i = 0; i < 8; ++i)
{
CompileUberVS(va("uber_shader_vs_%i.h", i + 1), "uber_shader.hlsl", i + 1);
}
system(va("type %s\\uber_shader_vs_*.h > %s\\complete_uber_vs.h", outputPath, outputPath));
system(va("del %s\\uber_shader_vs_*.h", outputPath));
for(int i = 0; i < _countof(uberShaderPixelStates); ++i)
{
CompileUberPS(uberShaderPixelStates[i]);
}
system(va("type %s\\uber_shader_ps_*.h > %s\\complete_uber_ps.h", outputPath, outputPath));
system(va("del %s\\uber_shader_ps_*.h", outputPath));
}
void ProcessCRP()
{
InitDirectory("crp");
targetVS = "vs_6_6";
targetPS = "ps_6_6";
targetCS = "cs_6_6";
CompileVertexShader("fullscreen.h", "fullscreen.hlsl", "fullscreen");
CompilePixelShader("blit.h", "blit.hlsl", "blit");
CompileGraphics("ui.h", "ui.hlsl", "ui");
CompileGraphics("imgui.h", "imgui.hlsl", "imgui");
CompileGraphics("nuklear.h", "nuklear.hlsl", "nuklear");
CompileCompute("mip_1.h", "mip_1.hlsl", "mip_1");
CompileCompute("mip_2.h", "mip_2.hlsl", "mip_2");
CompileCompute("mip_3.h", "mip_3.hlsl", "mip_3");
CompileGraphics("prepass.h", "prepass.hlsl", "prepass");
CompileGraphics("opaque.h", "opaque.hlsl", "opaque");
CompileGraphics("transp_draw.h", "transp_draw.hlsl", "transp_draw");
CompilePixelShader("transp_resolve.h", "transp_resolve.hlsl", "transp_resolve");
CompilePixelShader("tone_map.h", "tone_map.hlsl", "tone_map");
CompilePixelShader("tone_map_inverse.h", "tone_map_inverse.hlsl", "tone_map_inverse");
CompilePixelShader("accumdof_accum.h", "accumdof_accum.hlsl", "accum");
CompilePixelShader("accumdof_norm.h", "accumdof_norm.hlsl", "norm");
CompilePixelShader("accumdof_debug.h", "accumdof_debug.hlsl", "debug");
CompileCompute("gatherdof_split.h", "gatherdof_split.hlsl", "split");
CompileCompute("gatherdof_coc_tile_gen.h", "gatherdof_coc_tile_gen.hlsl", "coc_tile_gen");
CompileCompute("gatherdof_coc_tile_max.h", "gatherdof_coc_tile_max.hlsl", "coc_tile_max");
CompileCompute("gatherdof_blur.h", "gatherdof_blur.hlsl", "blur");
CompileCompute("gatherdof_fill.h", "gatherdof_fill.hlsl", "fill");
CompilePixelShader("gatherdof_combine.h", "gatherdof_combine.hlsl", "combine");
CompilePixelShader("gatherdof_debug.h", "gatherdof_debug.hlsl", "debug");
CompileGraphics("fog_inside.h", "fog_inside.hlsl", "inside");
CompileGraphics("fog_outside.h", "fog_outside.hlsl", "outside");
CompilePixelShader("magnifier.h", "magnifier.hlsl", "magnifier");
}
int main(int /*argc*/, const char** argv)
{
char dirPath[MAX_PATH];
strcpy(dirPath, argv[0]);
int l = strlen(dirPath);
while(l-- > 0)
{
if(dirPath[l] == '/' || dirPath[l] == '\\')
{
dirPath[l] = '\0';
break;
}
}
strcpy(repoPath, Canonicalize(va("%s\\..\\..", dirPath)));
strcpy(bin2headerPath, Canonicalize(va("%s\\tools\\bin2header.exe", repoPath)));
char* path = getenv("DXCPATH");
if(path != NULL)
{
strcpy(dxcPath, path);
}
else
{
strcpy(dxcPath, "dxc.exe");
}
system(va("%s --version", dxcPath));
ProcessGRP();
ProcessCRP();
return 0;
}