zdoom/gzdoom
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom.git synced 2025-03-13 22:42:07 +00:00
Code Issues Projects Releases Packages Wiki Activity

Fix misc shader related issues

Browse source
This commit is contained in:
Magnus Norddahl 2023-04-06 19:36:58 +02:00 committed by Christoph Oelckers
parent 3b93dd3d7e
commit f11318ff99
16 changed files with 159 additions and 209 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

40
src/common/rendering/hwrenderer/data/hw_shaderpatcher.cpp
View file

@ -269,43 +269,3 @@ FString RemoveLayoutLocationDecl(FString code, const char *inoutkeyword)
return code;
}
/////////////////////////////////////////////////////////////////////////////
// Note: the MaterialShaderIndex enum in gl_shader.h needs to be updated whenever this array is modified.
const FDefaultShader defaultshaders[] =
{
{"Default", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Warp 1", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_warp1.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Warp 2", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_warp2.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Specular", "shaders/scene/material_spec.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_specular.glsl", "#define SPECULAR\n#define NORMALMAP\n"},
{"PBR", "shaders/scene/material_pbr.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_pbr.glsl", "#define PBR\n#define NORMALMAP\n"},
{"Paletted", "shaders/scene/material_paletted.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_nolights.glsl", "#define PALETTE_EMULATION\n"},
{"No Texture", "shaders/scene/material_notexture.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", "#define NO_LAYERS\n"},
{"Basic Fuzz", "shaders/scene/material_fuzz_standard.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Smooth Fuzz", "shaders/scene/material_fuzz_smooth.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Swirly Fuzz", "shaders/scene/material_fuzz_swirly.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Translucent Fuzz", "shaders/scene/material_fuzz_smoothtranslucent.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Jagged Fuzz", "shaders/scene/material_fuzz_jagged.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Noise Fuzz", "shaders/scene/material_fuzz_noise.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Smooth Noise Fuzz", "shaders/scene/material_fuzz_smoothnoise.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Software Fuzz", "shaders/scene/material_fuzz_software.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{nullptr,nullptr,nullptr,nullptr}
};
const FEffectShader effectshaders[] =
{
{ "fogboundary", "shaders/scene/frag_fogboundary.glsl", nullptr, nullptr, nullptr, "#define NO_ALPHATEST\n" },
{ "spheremap", "shaders/scene/frag_surface.glsl", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", "#define SPHEREMAP\n#define NO_ALPHATEST\n" },
{ "burn", "shaders/scene/frag_burn.glsl", nullptr, nullptr, nullptr, "#define SIMPLE\n#define NO_ALPHATEST\n" },
{ "stencil", "shaders/scene/frag_stencil.glsl", nullptr, nullptr, nullptr, "#define SIMPLE\n#define NO_ALPHATEST\n" },
};
int DFrameBuffer::GetShaderCount()
{
int i;
for (i = 0; defaultshaders[i].ShaderName != nullptr; i++);
return MAX_PASS_TYPES * (countof(defaultshaders) - 1 + usershaders.Size() + MAX_EFFECTS + SHADER_NoTexture);
}

23
src/common/rendering/hwrenderer/data/hw_shaderpatcher.h
View file

@ -7,26 +7,3 @@
FString RemoveLegacyUserUniforms(FString code);
FString RemoveSamplerBindings(FString code, TArray<std::pair<FString, int>> &samplerstobind); // For GL 3.3 compatibility which cannot declare sampler bindings in the sampler source.
FString RemoveLayoutLocationDecl(FString code, const char *inoutkeyword);
struct FDefaultShader
{
const char * ShaderName;
const char * material_lump;
const char * mateffect_lump;
const char * lightmodel_lump;
const char * Defines;
};
struct FEffectShader
{
const char *ShaderName;
const char *fp1;
const char *fp2;
const char *fp3;
const char *fp4;
const char *defines;
};
extern const FDefaultShader defaultshaders[];
extern const FEffectShader effectshaders[];

1
src/common/rendering/v_video.h
View file

@ -163,7 +163,6 @@ public:
virtual void InitializeState() = 0; // For stuff that needs 'screen' set.
virtual bool IsVulkan() { return false; }
virtual bool IsPoly() { return false; }
virtual int GetShaderCount();
virtual bool CompileNextShader() { return true; }
void SetAABBTree(hwrenderer::LevelAABBTree * tree)
{

13
src/common/rendering/vulkan/renderer/vk_renderstate.cpp
View file

@ -248,6 +248,14 @@ void VkRenderState::ApplyRenderPass(int dt)
pipelineKey.ShaderKey.AlphaTest = mAlphaThreshold >= 0.f;
}
int uTextureMode = GetTextureModeAndFlags((mMaterial.mMaterial && mMaterial.mMaterial->Source()->isHardwareCanvas()) ? TM_OPAQUE : TM_NORMAL);
pipelineKey.ShaderKey.TextureMode = uTextureMode & 0xffff;
pipelineKey.ShaderKey.ClampY = (uTextureMode & TEXF_ClampY) != 0;
pipelineKey.ShaderKey.Brightmap = (uTextureMode & TEXF_Brightmap) != 0;
pipelineKey.ShaderKey.Detailmap = (uTextureMode & TEXF_Detailmap) != 0;
pipelineKey.ShaderKey.Glowmap = (uTextureMode & TEXF_Glowmap) != 0;
pipelineKey.ShaderKey.Simple2D = (mFogEnabled == 2);
// Is this the one we already have?
bool inRenderPass = mCommandBuffer;
bool changingPipeline = (!inRenderPass) || (pipelineKey != mPipelineKey);
@ -371,12 +379,7 @@ void VkRenderState::ApplyPushConstants()
}
}
int tempTM = TM_NORMAL;
if (mMaterial.mMaterial && mMaterial.mMaterial->Source()->isHardwareCanvas())
tempTM = TM_OPAQUE;
mPushConstants.uFogEnabled = fogset;
mPushConstants.uTextureMode = GetTextureModeAndFlags(tempTM);
mPushConstants.uLightDist = mLightParms[0];
mPushConstants.uLightFactor = mLightParms[1];
mPushConstants.uFogDensity = mLightParms[2];

79
src/common/rendering/vulkan/shaders/vk_shader.cpp
View file

@ -53,21 +53,69 @@ VkShaderProgram* VkShaderManager::Get(const VkShaderKey& k, EPassType passType)
if (!program.frag)
{
const char* mainvp = "shaders/scene/vert_main.glsl";
const char* mainfp = "shaders/scene/frag_surface.glsl";
const char* mainfp = "shaders/scene/frag_main.glsl";
if (key.SpecialEffect != EFF_NONE)
{
struct FEffectShader
{
const char* ShaderName;
const char* fp1;
const char* fp2;
const char* fp3;
const char* fp4;
const char* defines;
};
static const FEffectShader effectshaders[] =
{
{ "fogboundary", "shaders/scene/frag_fogboundary.glsl", nullptr, nullptr, nullptr, "#define NO_ALPHATEST\n" },
{ "spheremap", "shaders/scene/frag_main.glsl", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", "#define SPHEREMAP\n#define NO_ALPHATEST\n" },
{ "burn", "shaders/scene/frag_burn.glsl", nullptr, nullptr, nullptr, "#define SIMPLE\n#define NO_ALPHATEST\n" },
{ "stencil", "shaders/scene/frag_stencil.glsl", nullptr, nullptr, nullptr, "#define SIMPLE\n#define NO_ALPHATEST\n" },
};
const auto& desc = effectshaders[key.SpecialEffect];
program.vert = LoadVertShader(desc.ShaderName, mainvp, desc.defines);
program.frag = LoadFragShader(desc.ShaderName, desc.fp1, desc.fp2, desc.fp3, desc.fp4, desc.defines, true, key.GBufferPass);
program.frag = LoadFragShader(desc.ShaderName, desc.fp1, desc.fp2, desc.fp3, desc.fp4, desc.defines, key);
}
else
{
struct FDefaultShader
{
const char* ShaderName;
const char* material_lump;
const char* mateffect_lump;
const char* lightmodel_lump;
const char* Defines;
};
// Note: the MaterialShaderIndex enum needs to be updated whenever this array is modified.
static const FDefaultShader defaultshaders[] =
{
{"Default", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Warp 1", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_warp1.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Warp 2", "shaders/scene/material_default.glsl", "shaders/scene/mateffect_warp2.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Specular", "shaders/scene/material_spec.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_specular.glsl", "#define SPECULAR\n#define NORMALMAP\n"},
{"PBR", "shaders/scene/material_pbr.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_pbr.glsl", "#define PBR\n#define NORMALMAP\n"},
{"Paletted", "shaders/scene/material_paletted.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_nolights.glsl", "#define PALETTE_EMULATION\n"},
{"No Texture", "shaders/scene/material_notexture.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", "#define NO_LAYERS\n"},
{"Basic Fuzz", "shaders/scene/material_fuzz_standard.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Smooth Fuzz", "shaders/scene/material_fuzz_smooth.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Swirly Fuzz", "shaders/scene/material_fuzz_swirly.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Translucent Fuzz", "shaders/scene/material_fuzz_smoothtranslucent.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Jagged Fuzz", "shaders/scene/material_fuzz_jagged.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Noise Fuzz", "shaders/scene/material_fuzz_noise.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Smooth Noise Fuzz", "shaders/scene/material_fuzz_smoothnoise.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{"Software Fuzz", "shaders/scene/material_fuzz_software.glsl", "shaders/scene/mateffect_default.glsl", "shaders/scene/lightmodel_normal.glsl", ""},
{nullptr,nullptr,nullptr,nullptr}
};
if (key.EffectState < FIRST_USER_SHADER)
{
const auto& desc = defaultshaders[key.EffectState];
program.vert = LoadVertShader(desc.ShaderName, mainvp, desc.Defines);
program.frag = LoadFragShader(desc.ShaderName, mainfp, desc.material_lump, desc.mateffect_lump, desc.lightmodel_lump, desc.Defines, key.AlphaTest, key.GBufferPass);
program.frag = LoadFragShader(desc.ShaderName, mainfp, desc.material_lump, desc.mateffect_lump, desc.lightmodel_lump, desc.Defines, key);
}
else
{
@ -76,7 +124,7 @@ VkShaderProgram* VkShaderManager::Get(const VkShaderKey& k, EPassType passType)
FString defines = defaultshaders[desc.shaderType].Defines + desc.defines;
program.vert = LoadVertShader(name, mainvp, defines);
program.frag = LoadFragShader(name, mainfp, desc.shader, defaultshaders[desc.shaderType].mateffect_lump, defaultshaders[desc.shaderType].lightmodel_lump, defines, key.AlphaTest, key.GBufferPass);
program.frag = LoadFragShader(name, mainfp, desc.shader, defaultshaders[desc.shaderType].mateffect_lump, defaultshaders[desc.shaderType].lightmodel_lump, defines, key);
}
}
}
@ -115,7 +163,7 @@ std::unique_ptr<VulkanShader> VkShaderManager::LoadVertShader(FString shadername
.Create(shadername.GetChars(), fb->device.get());
}
std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump, const char *defines, bool alphatest, bool gbufferpass)
std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *light_lump, const char *defines, const VkShaderKey& key)
{
FString definesBlock;
definesBlock << defines << "\n";
@ -126,8 +174,25 @@ std::unique_ptr<VulkanShader> VkShaderManager::LoadFragShader(FString shadername
definesBlock << "#define NPOT_EMULATION\n";
#endif
if (!fb->device->EnabledFeatures.Features.shaderClipDistance) definesBlock << "#define NO_CLIPDISTANCE_SUPPORT\n";
if (!alphatest) definesBlock << "#define NO_ALPHATEST\n";
if (gbufferpass) definesBlock << "#define GBUFFER_PASS\n";
if (!key.AlphaTest) definesBlock << "#define NO_ALPHATEST\n";
if (key.GBufferPass) definesBlock << "#define GBUFFER_PASS\n";
if (key.Simple2D) definesBlock << "#define SIMPLE2D\n";
if (key.ClampY) definesBlock << "#define TEXF_ClampY\n";
if (key.Brightmap) definesBlock << "#define TEXF_Brightmap\n";
if (key.Detailmap) definesBlock << "#define TEXF_Detailmap\n";
if (key.Glowmap) definesBlock << "#define TEXF_Glowmap\n";
switch (key.TextureMode)
{
case TM_STENCIL: definesBlock << "#define TM_STENCIL\n"; break;
case TM_OPAQUE: definesBlock << "#define TM_OPAQUE\n"; break;
case TM_INVERSE: definesBlock << "#define TM_INVERSE\n"; break;
case TM_ALPHATEXTURE: definesBlock << "#define TM_ALPHATEXTURE\n"; break;
case TM_CLAMPY: definesBlock << "#define TM_CLAMPY\n"; break;
case TM_INVERTOPAQUE: definesBlock << "#define TM_INVERTOPAQUE\n"; break;
case TM_FOGLAYER: definesBlock << "#define TM_FOGLAYER\n"; break;
}
FString layoutBlock;
layoutBlock << LoadPrivateShaderLump("shaders/scene/layout_shared.glsl").GetChars() << "\n";

2
src/common/rendering/vulkan/shaders/vk_shader.h
View file

@ -115,7 +115,7 @@ public:
private:
std::unique_ptr<VulkanShader> LoadVertShader(FString shadername, const char *vert_lump, const char *defines);
std::unique_ptr<VulkanShader> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *lightmodel_lump, const char *defines, bool alphatest, bool gbufferpass);
std::unique_ptr<VulkanShader> LoadFragShader(FString shadername, const char *frag_lump, const char *material_lump, const char* mateffect_lump, const char *lightmodel_lump, const char *defines, const VkShaderKey& key);
ShaderIncludeResult OnInclude(FString headerName, FString includerName, size_t depth, bool system);

25
wadsrc/static/shaders/scene/frag_2d.glsl
View file

@ -1,25 +0,0 @@
void main()
{
#ifdef NO_CLIPDISTANCE_SUPPORT
if (ClipDistanceA.x < 0 || ClipDistanceA.y < 0 || ClipDistanceA.z < 0 || ClipDistanceA.w < 0 || ClipDistanceB.x < 0) discard;
#endif
Material material = CreateMaterial();
vec4 frag = material.Base;
#ifndef NO_ALPHATEST
if (frag.a <= uAlphaThreshold) discard;
#endif
// simple 2D (uses the fog color to add a color overlay)
frag = frag * ProcessLight(material, vColor);
frag.rgb = frag.rgb + uFogColor.rgb;
FragColor = frag;
#ifdef GBUFFER_PASS
FragFog = vec4(AmbientOcclusionColor(), 1.0);
FragNormal = vec4(vEyeNormal.xyz * 0.5 + 0.5, 1.0);
#endif
}

27
wadsrc/static/shaders/scene/frag_2d_stencil.glsl
View file

@ -1,27 +0,0 @@
void main()
{
#ifdef NO_CLIPDISTANCE_SUPPORT
if (ClipDistanceA.x < 0 || ClipDistanceA.y < 0 || ClipDistanceA.z < 0 || ClipDistanceA.w < 0 || ClipDistanceB.x < 0) discard;
#endif
Material material = CreateMaterial();
vec4 frag = material.Base;
#ifndef NO_ALPHATEST
if (frag.a <= uAlphaThreshold) discard;
#endif
float gray = grayscale(frag);
vec4 cm = (uObjectColor + gray * (uAddColor - uObjectColor)) * 2;
frag = vec4(clamp(cm.rgb, 0.0, 1.0), frag.a);
frag = frag * ProcessLight(material, vColor);
frag.rgb = frag.rgb + uFogColor.rgb;
FragColor = frag;
#ifdef GBUFFER_PASS
FragFog = vec4(AmbientOcclusionColor(), 1.0);
FragNormal = vec4(vEyeNormal.xyz * 0.5 + 0.5, 1.0);
#endif
}

54
wadsrc/static/shaders/scene/frag_main.glsl Normal file
View file

@ -0,0 +1,54 @@
void main()
{
#ifdef NO_CLIPDISTANCE_SUPPORT
if (ClipDistanceA.x < 0 || ClipDistanceA.y < 0 || ClipDistanceA.z < 0 || ClipDistanceA.w < 0 || ClipDistanceB.x < 0) discard;
#endif
Material material = CreateMaterial();
vec4 frag = material.Base;
#ifndef NO_ALPHATEST
if (frag.a <= uAlphaThreshold) discard;
#endif
#ifdef SIMPLE2D // uses the fog color to add a color overlay
#ifdef TM_FOGLAYER
float gray = grayscale(frag);
vec4 cm = (uObjectColor + gray * (uAddColor - uObjectColor)) * 2;
frag = vec4(clamp(cm.rgb, 0.0, 1.0), frag.a);
frag.rgb = frag.rgb + uFogColor.rgb;
#else
frag.rgb = frag.rgb + uFogColor.rgb;
#endif
#else
#ifdef TM_FOGLAYER
float fogdist = 0.0;
float fogfactor = 0.0;
// calculate fog factor
if (uFogEnabled != 0)
{
if (uFogEnabled == 1 || uFogEnabled == -1)
{
fogdist = max(16.0, pixelpos.w);
}
else
{
fogdist = max(16.0, distance(pixelpos.xyz, uCameraPos.xyz));
}
fogfactor = exp2 (uFogDensity * fogdist);
}
frag = vec4(uFogColor.rgb, (1.0 - fogfactor) * frag.a * 0.75 * vColor.a);
#else
frag = getLightColor(material);
#endif
#endif
FragColor = frag;
#ifdef GBUFFER_PASS
FragFog = vec4(AmbientOcclusionColor(), 1.0);
FragNormal = vec4(vEyeNormal.xyz * 0.5 + 0.5, 1.0);
#endif
}

22
wadsrc/static/shaders/scene/frag_surface.glsl
View file

@ -1,22 +0,0 @@
void main()
{
#ifdef NO_CLIPDISTANCE_SUPPORT
if (ClipDistanceA.x < 0 || ClipDistanceA.y < 0 || ClipDistanceA.z < 0 || ClipDistanceA.w < 0 || ClipDistanceB.x < 0) discard;
#endif
Material material = CreateMaterial();
vec4 frag = material.Base;
#ifndef NO_ALPHATEST
if (frag.a <= uAlphaThreshold) discard;
#endif
frag = getLightColor(material);
FragColor = frag;
#ifdef GBUFFER_PASS
FragFog = vec4(AmbientOcclusionColor(), 1.0);
FragNormal = vec4(vEyeNormal.xyz * 0.5 + 0.5, 1.0);
#endif
}

39
wadsrc/static/shaders/scene/frag_surface_stencil.glsl
View file

@ -1,39 +0,0 @@
void main()
{
#ifdef NO_CLIPDISTANCE_SUPPORT
if (ClipDistanceA.x < 0 || ClipDistanceA.y < 0 || ClipDistanceA.z < 0 || ClipDistanceA.w < 0 || ClipDistanceB.x < 0) discard;
#endif
Material material = CreateMaterial();
vec4 frag = material.Base;
#ifndef NO_ALPHATEST
if (frag.a <= uAlphaThreshold) discard;
#endif
float fogdist = 0.0;
float fogfactor = 0.0;
// calculate fog factor
if (uFogEnabled != 0)
{
if (uFogEnabled == 1 || uFogEnabled == -1)
{
fogdist = max(16.0, pixelpos.w);
}
else
{
fogdist = max(16.0, distance(pixelpos.xyz, uCameraPos.xyz));
}
fogfactor = exp2 (uFogDensity * fogdist);
}
frag = vec4(uFogColor.rgb, (1.0 - fogfactor) * frag.a * 0.75 * vColor.a);
FragColor = frag;
#ifdef GBUFFER_PASS
FragFog = vec4(AmbientOcclusionColor(), 1.0);
FragNormal = vec4(vEyeNormal.xyz * 0.5 + 0.5, 1.0);
#endif
}

4
wadsrc/static/shaders/scene/includes.glsl
View file

@ -1,5 +1,9 @@
#ifndef SIMPLE
#include "shaders/scene/material.glsl"
#include "shaders/scene/lightmodel.glsl"
#include "shaders/scene/light_shadow.glsl"
#include "shaders/scene/light_spot.glsl"
#endif

5
wadsrc/static/shaders/scene/layout_frag.glsl
View file

@ -1,12 +1,15 @@
layout(location = 0) in vec4 vTexCoord;
layout(location = 1) in vec4 vColor;
layout(location = 9) in vec3 vLightmap;
#ifndef SIMPLE
layout(location = 2) in vec4 pixelpos;
layout(location = 3) in vec3 glowdist;
layout(location = 4) in vec3 gradientdist;
layout(location = 5) in vec4 vWorldNormal;
layout(location = 6) in vec4 vEyeNormal;
layout(location = 9) in vec3 vLightmap;
#endif
#ifdef NO_CLIPDISTANCE_SUPPORT
layout(location = 7) in vec4 ClipDistanceA;

2
wadsrc/static/shaders/scene/layout_shared.glsl
View file

@ -100,7 +100,7 @@ layout(set = 2, binding = 11) uniform sampler2D texture12;
// This must match the PushConstants struct
layout(push_constant) uniform PushConstants
{
int uTextureMode;
int padding0; // was uTextureMode;
float uAlphaThreshold;
vec2 uClipSplit;

16
wadsrc/static/shaders/scene/material.glsl
View file

@ -21,11 +21,6 @@ void SetupMaterial(inout Material mat);
vec3 ProcessMaterialLight(Material material, vec3 color);
vec2 GetTexCoord();
// These get Or'ed into uTextureMode because it only uses its 3 lowermost bits.
const int TEXF_Brightmap = 0x10000;
const int TEXF_Detailmap = 0x20000;
const int TEXF_Glowmap = 0x40000;
Material CreateMaterial()
{
Material material;
@ -58,16 +53,17 @@ void SetMaterialProps(inout Material material, vec2 texCoord)
// OpenGL doesn't care, but Vulkan pukes all over the place if these texture samplings are included in no-texture shaders, even though never called.
#ifndef NO_LAYERS
if ((uTextureMode & TEXF_Brightmap) != 0)
#if defined(TEXF_Brightmap)
material.Bright = desaturate(texture(brighttexture, texCoord.st));
#endif
if ((uTextureMode & TEXF_Detailmap) != 0)
{
#if defined(TEXF_Detailmap)
vec4 Detail = texture(detailtexture, texCoord.st * uDetailParms.xy) * uDetailParms.z;
material.Base.rgb *= Detail.rgb;
}
#endif
if ((uTextureMode & TEXF_Glowmap) != 0)
#if defined(TEXF_Glowmap)
material.Glow = desaturate(texture(glowtexture, texCoord.st));
#endif
#endif
}

16
wadsrc/static/shaders/scene/material_gettexel.glsl
View file

@ -10,25 +10,27 @@ vec4 getTexel(vec2 st)
vec4 texel = texture(tex, st);
// Apply texture modes
#if (uTextureMode & 0xffff) == 1 // TM_STENCIL
#if defined(TM_STENCIL)
texel.rgb = vec3(1.0,1.0,1.0);
#elif (uTextureMode & 0xffff) == 2 // TM_OPAQUE
#elif defined(TM_OPAQUE)
texel.a = 1.0;
#elif (uTextureMode & 0xffff) == 3 // TM_INVERSE
#elif defined(TM_INVERSE)
texel = vec4(1.0-texel.r, 1.0-texel.b, 1.0-texel.g, texel.a);
#elif (uTextureMode & 0xffff) == 3 // TM_ALPHATEXTURE
#elif defined(TM_ALPHATEXTURE)
float gray = grayscale(texel);
texel = vec4(1.0, 1.0, 1.0, gray*texel.a);
#elif (uTextureMode & 0xffff) == 5 // TM_CLAMPY
#elif defined(TM_CLAMPY)
if (st.t < 0.0 || st.t > 1.0)
{
texel.a = 0.0;
}
#elif (uTextureMode & 0xffff) == 6 // TM_OPAQUEINVERSE
#elif defined(TM_INVERTOPAQUE)
texel = vec4(1.0-texel.r, 1.0-texel.b, 1.0-texel.g, 1.0);
#elif defined(TM_FOGLAYER)
return texel;
#endif
#if (uTextureMode & 0x80000) == 0x80000 // TEXF_ClampY
#if defined(TEXF_ClampY)
if (st.t < 0.0 || st.t > 1.0)
{
texel.a = 0.0;