piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-15 13:57:57 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity
20a8e9c872
dolphin/Source/Core/VideoCommon/UberShaderVertex.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

551 lines
23 KiB
C++
Raw Normal View History

ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// Copyright 2015 Dolphin Emulator Project
treewide: convert GPLv2+ license info to SPDX tags SPDX standardizes how source code conveys its copyright and licensing information. See https://spdx.github.io/spdx-spec/1-rationale/ . SPDX tags are adopted in many large projects, including things like the Linux kernel.
2021-07-04 19:22:19 -06:00
// SPDX-License-Identifier: GPL-2.0-or-later
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
#include "VideoCommon/UberShaderVertex.h"
VideoCommon/ShaderGenCommon: Make template functions regular functions These are only ever used with ShaderCode instances and nothing else. Given that, we can convert these helper functions to expect that type of object as an argument and remove the need for templates, improving compiler throughput a marginal amount, as the template instantiation process doesn't need to be performed. We can also move the definitions of these functions into the cpp file, which allows us to remove a few inclusions from the ShaderGenCommon header. This uncovered a few instances of indirect inclusions being relied upon in other source files. One other benefit is this allows changes to be made to the definitions of the functions without needing to recompile all translation units that make use of these functions, making change testing a little quicker. Moving the definitions into the cpp file also allows us to completely hide DefineOutputMember() from external view, given it's only ever used inside of GenerateVSOutputMembers().
2019-12-22 11:40:40 -07:00
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
#include "VideoCommon/DriverDetails.h"
#include "VideoCommon/NativeVertexFormat.h"
#include "VideoCommon/UberShaderCommon.h"
#include "VideoCommon/VertexShaderGen.h"
VideoCommon/ShaderGenCommon: Make template functions regular functions These are only ever used with ShaderCode instances and nothing else. Given that, we can convert these helper functions to expect that type of object as an argument and remove the need for templates, improving compiler throughput a marginal amount, as the template instantiation process doesn't need to be performed. We can also move the definitions of these functions into the cpp file, which allows us to remove a few inclusions from the ShaderGenCommon header. This uncovered a few instances of indirect inclusions being relied upon in other source files. One other benefit is this allows changes to be made to the definitions of the functions without needing to recompile all translation units that make use of these functions, making change testing a little quicker. Moving the definitions into the cpp file also allows us to completely hide DefineOutputMember() from external view, given it's only ever used inside of GenerateVSOutputMembers().
2019-12-22 11:40:40 -07:00
#include "VideoCommon/VideoCommon.h"
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
#include "VideoCommon/XFMemory.h"
namespace UberShader
{
VertexShaderUid GetVertexShaderUid()
{
VertexShaderUid out;
VideoCommon: Remove unnecessary memset on ShaderUid instances. Zero-initialization zeroes out all members and padding bits, so this is safe to do. While we're at it, also add static assertions that enforce the necessary requirements of a UID type explicitly within the ShaderUid class. This way, we can remove several memset calls around the shader generation code that makes sure the underlying UID data is zeroed out. Now our ShaderUid class enforces this for us, so we don't need to care about it at the usage sites.
2019-05-29 23:05:06 -06:00
vertex_ubershader_uid_data* const uid_data = out.GetUidData();
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
uid_data->num_texgens = xfmem.numTexGen.numTexGens;
VideoCommon: Remove unnecessary memset on ShaderUid instances. Zero-initialization zeroes out all members and padding bits, so this is safe to do. While we're at it, also add static assertions that enforce the necessary requirements of a UID type explicitly within the ShaderUid class. This way, we can remove several memset calls around the shader generation code that makes sure the underlying UID data is zeroed out. Now our ShaderUid class enforces this for us, so we don't need to care about it at the usage sites.
2019-05-29 23:05:06 -06:00
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
return out;
}
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode& out);
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
ShaderCode GenVertexShader(APIType api_type, const ShaderHostConfig& host_config,
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
const vertex_ubershader_uid_data* uid_data)
{
const bool msaa = host_config.msaa;
const bool ssaa = host_config.ssaa;
const bool per_pixel_lighting = host_config.per_pixel_lighting;
const bool vertex_rounding = host_config.vertex_rounding;
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
const u32 num_texgen = uid_data->num_texgens;
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderCode out;
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("// Vertex UberShader\n\n");
out.Write("{}", s_lighting_struct);
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// uniforms
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
if (api_type == APIType::OpenGL || api_type == APIType::Vulkan)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("UBO_BINDING(std140, 2) uniform VSBlock {{\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
else
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("cbuffer VSBlock {{\n");
out.Write("{}", s_shader_uniforms);
out.Write("}};\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("struct VS_OUTPUT {{\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
GenerateVSOutputMembers(out, api_type, num_texgen, host_config, "");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("}};\n\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
WriteUberShaderCommonHeader(out, api_type, host_config);
Ubershaders: Support per-pixel lighting
2017-07-27 04:52:20 -06:00
WriteLightingFunction(out);
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
if (api_type == APIType::OpenGL || api_type == APIType::Vulkan)
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("ATTRIBUTE_LOCATION({}) in float4 rawpos;\n", SHADER_POSITION_ATTRIB);
out.Write("ATTRIBUTE_LOCATION({}) in uint4 posmtx;\n", SHADER_POSMTX_ATTRIB);
out.Write("ATTRIBUTE_LOCATION({}) in float3 rawnorm0;\n", SHADER_NORM0_ATTRIB);
out.Write("ATTRIBUTE_LOCATION({}) in float3 rawnorm1;\n", SHADER_NORM1_ATTRIB);
out.Write("ATTRIBUTE_LOCATION({}) in float3 rawnorm2;\n", SHADER_NORM2_ATTRIB);
out.Write("ATTRIBUTE_LOCATION({}) in float4 rawcolor0;\n", SHADER_COLOR0_ATTRIB);
out.Write("ATTRIBUTE_LOCATION({}) in float4 rawcolor1;\n", SHADER_COLOR1_ATTRIB);
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
for (int i = 0; i < 8; ++i)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("ATTRIBUTE_LOCATION({}) in float3 rawtex{};\n", SHADER_TEXTURE0_ATTRIB + i, i);
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
if (host_config.backend_geometry_shaders)
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VARYING_LOCATION(0) out VertexData {{\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
GenerateVSOutputMembers(out, api_type, num_texgen, host_config,
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
GetInterpolationQualifier(msaa, ssaa, true, false));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("}} vs;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
else
{
// Let's set up attributes
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
u32 counter = 0;
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VARYING_LOCATION({}) {} out float4 colors_0;\n", counter++,
GetInterpolationQualifier(msaa, ssaa));
out.Write("VARYING_LOCATION({}) {} out float4 colors_1;\n", counter++,
GetInterpolationQualifier(msaa, ssaa));
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
for (u32 i = 0; i < num_texgen; ++i)
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VARYING_LOCATION({}) {} out float3 tex{};\n", counter++,
GetInterpolationQualifier(msaa, ssaa), i);
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
}
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
if (!host_config.fast_depth_calc)
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VARYING_LOCATION({}) {} out float4 clipPos;\n", counter++,
GetInterpolationQualifier(msaa, ssaa));
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
}
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
if (per_pixel_lighting)
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VARYING_LOCATION({}) {} out float3 Normal;\n", counter++,
GetInterpolationQualifier(msaa, ssaa));
out.Write("VARYING_LOCATION({}) {} out float3 WorldPos;\n", counter++,
GetInterpolationQualifier(msaa, ssaa));
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("void main()\n{{\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
else // D3D
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VS_OUTPUT main(\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// inputs
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" float3 rawnorm0 : NORMAL0,\n"
" float3 rawnorm1 : NORMAL1,\n"
" float3 rawnorm2 : NORMAL2,\n"
" float4 rawcolor0 : COLOR0,\n"
" float4 rawcolor1 : COLOR1,\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
for (int i = 0; i < 8; ++i)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" float3 rawtex{} : TEXCOORD{},\n", i, i);
out.Write(" uint posmtx : BLENDINDICES,\n");
out.Write(" float4 rawpos : POSITION) {{\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("VS_OUTPUT o;\n"
"\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// Transforms
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("// Position matrix\n"
"float4 P0;\n"
"float4 P1;\n"
"float4 P2;\n"
"\n"
"// Normal matrix\n"
"float3 N0;\n"
"float3 N1;\n"
"float3 N2;\n"
"\n"
"if ((components & {}u) != 0u) {{// VB_HAS_POSMTXIDX\n",
VB_HAS_POSMTXIDX);
out.Write(" // Vertex format has a per-vertex matrix\n"
" int posidx = int(posmtx.r);\n"
" P0 = " I_TRANSFORMMATRICES "[posidx];\n"
" P1 = " I_TRANSFORMMATRICES "[posidx+1];\n"
" P2 = " I_TRANSFORMMATRICES "[posidx+2];\n"
"\n"
" int normidx = posidx >= 32 ? (posidx - 32) : posidx;\n"
" N0 = " I_NORMALMATRICES "[normidx].xyz;\n"
" N1 = " I_NORMALMATRICES "[normidx+1].xyz;\n"
" N2 = " I_NORMALMATRICES "[normidx+2].xyz;\n"
"}} else {{\n"
" // One shared matrix\n"
" P0 = " I_POSNORMALMATRIX "[0];\n"
" P1 = " I_POSNORMALMATRIX "[1];\n"
" P2 = " I_POSNORMALMATRIX "[2];\n"
" N0 = " I_POSNORMALMATRIX "[3].xyz;\n"
" N1 = " I_POSNORMALMATRIX "[4].xyz;\n"
" N2 = " I_POSNORMALMATRIX "[5].xyz;\n"
"}}\n"
"\n"
"float4 pos = float4(dot(P0, rawpos), dot(P1, rawpos), dot(P2, rawpos), 1.0);\n"
"o.pos = float4(dot(" I_PROJECTION "[0], pos), dot(" I_PROJECTION
"[1], pos), dot(" I_PROJECTION "[2], pos), dot(" I_PROJECTION "[3], pos));\n"
"\n"
"// Only the first normal gets normalized (TODO: why?)\n"
"float3 _norm0 = float3(0.0, 0.0, 0.0);\n"
"if ((components & {}u) != 0u) // VB_HAS_NRM0\n",
VB_HAS_NRM0);
out.Write(
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
" _norm0 = normalize(float3(dot(N0, rawnorm0), dot(N1, rawnorm0), dot(N2, rawnorm0)));\n"
"\n"
"float3 _norm1 = float3(0.0, 0.0, 0.0);\n"
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
"if ((components & {}u) != 0u) // VB_HAS_NRM1\n",
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
VB_HAS_NRM1);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" _norm1 = float3(dot(N0, rawnorm1), dot(N1, rawnorm1), dot(N2, rawnorm1));\n"
"\n"
"float3 _norm2 = float3(0.0, 0.0, 0.0);\n"
"if ((components & {}u) != 0u) // VB_HAS_NRM2\n",
VB_HAS_NRM2);
out.Write(" _norm2 = float3(dot(N0, rawnorm2), dot(N1, rawnorm2), dot(N2, rawnorm2));\n"
"\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// Hardware Lighting
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
out.Write("// xfmem.numColorChans controls the number of color channels available to TEV,\n"
"// but we still need to generate all channels here, as it can be used in texgen.\n"
"// Cel-damage is an example of this.\n"
"float4 vertex_color_0, vertex_color_1;\n"
"\n");
out.Write("// To use color 1, the vertex descriptor must have color 0 and 1.\n"
"// If color 1 is present but not color 0, it is used for lighting channel 0.\n"
Fix vertex ubershader GLES compile errors Regression from 51724c1.
2020-11-23 03:42:41 -07:00
"bool use_color_1 = ((components & {0}u) == {0}u); // VB_HAS_COL0 | VB_HAS_COL1\n",
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
VB_HAS_COL0 | VB_HAS_COL1);
Fix vertex ubershader GLES compile errors Regression from 51724c1.
2020-11-23 03:42:41 -07:00
out.Write("for (uint color = 0u; color < {}u; color++) {{\n", NUM_XF_COLOR_CHANNELS);
out.Write(" if ((color == 0u || use_color_1) && (components & ({}u << color)) != 0u) {{\n",
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
VB_HAS_COL0);
Hack to hide debug cubes in Super Mario Sunshine ... while not breaking other games.
2021-02-22 20:03:06 -07:00
out.Write(" // Use color0 for channel 0, and color1 for channel 1 if both colors 0 and 1 are "
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
"present.\n"
" if (color == 0u)\n"
" vertex_color_0 = rawcolor0;\n"
" else\n"
" vertex_color_1 = rawcolor1;\n"
Fix vertex ubershader GLES compile errors Regression from 51724c1.
2020-11-23 03:42:41 -07:00
" }} else if (color == 0u && (components & {}u) != 0u) {{\n",
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
VB_HAS_COL1);
out.Write(" // Use color1 for channel 0 if color0 is not present.\n"
" vertex_color_0 = rawcolor1;\n"
" }} else {{\n"
" if (color == 0u)\n"
Hack to hide debug cubes in Super Mario Sunshine ... while not breaking other games.
2021-02-22 20:03:06 -07:00
" vertex_color_0 = missing_color_value;\n"
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
" else\n"
Hack to hide debug cubes in Super Mario Sunshine ... while not breaking other games.
2021-02-22 20:03:06 -07:00
" vertex_color_1 = missing_color_value;\n"
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
" }}\n"
"}}\n"
"\n");
WriteVertexLighting(out, api_type, "pos.xyz", "_norm0", "vertex_color_0", "vertex_color_1",
"o.colors_0", "o.colors_1");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// Texture Coordinates
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
if (num_texgen > 0)
GenVertexShaderTexGens(api_type, num_texgen, out);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("if (xfmem_numColorChans == 0u) {{\n"
" if ((components & {}u) != 0u)\n"
" o.colors_0 = rawcolor0;\n"
" else\n"
" o.colors_1 = float4(1.0, 1.0, 1.0, 1.0);\n"
"}}\n",
VB_HAS_COL0);
out.Write("if (xfmem_numColorChans < 2u) {{\n"
" if ((components & {}u) != 0u)\n"
" o.colors_0 = rawcolor1;\n"
" else\n"
" o.colors_1 = float4(1.0, 1.0, 1.0, 1.0);\n"
"}}\n",
VB_HAS_COL1);
LightingShaderGen: Always calculate lighting for both color channels Cel-damage uses the color from the lighting stage of the vertex pipeline as texture coordinates, but sets numColorChans to zero. We now calculate the colors in all cases, but override the color before writing it from the vertex shader if numColorChans is set to a lower value.
2017-11-21 01:54:11 -07:00
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
if (!host_config.fast_depth_calc)
{
// clipPos/w needs to be done in pixel shader, not here
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.clipPos = o.pos;\n");
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
}
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
Ubershaders: Support per-pixel lighting
2017-07-27 04:52:20 -06:00
if (per_pixel_lighting)
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.Normal = _norm0;\n"
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
"o.WorldPos = pos.xyz;\n"
"// Pass through the vertex colors unmodified so we can evaluate the lighting\n"
"// in the same manner.\n");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("if ((components & {}u) != 0u) // VB_HAS_COL0\n"
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
" o.colors_0 = vertex_color_0;\n",
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
VB_HAS_COL0);
out.Write("if ((components & {}u) != 0u) // VB_HAS_COL1\n"
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
" o.colors_1 = vertex_color_1;\n",
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
VB_HAS_COL1);
Ubershaders: Support per-pixel lighting
2017-07-27 04:52:20 -06:00
}
LightingShaderGen: Always calculate lighting for both color channels Cel-damage depends on lighting being calculated for the first channel even though there is no color in the vertex format (defaults to the material color). If lighting for the channel is not enabled, the vertex will use the default color as before. The default value of the color is determined by the number of elements in the vertex format. This fixes the grey cubes in Super Mario Sunshine. If the color channel count is zero, we set the color to black before the end of the vertex shader. It's possible that this would be undefined behavior on hardware if a vertex color index that was greater than the channel count was used within TEV.
2017-01-29 05:38:48 -07:00
else
{
out.Write("// The number of colors available to TEV is determined by numColorChans.\n"
"// We have to provide the fields to match the interface, so set to zero\n"
"// if it's not enabled.\n"
"if (xfmem_numColorChans == 0u)\n"
" o.colors_0 = float4(0.0, 0.0, 0.0, 0.0);\n"
"if (xfmem_numColorChans <= 1u)\n"
" o.colors_1 = float4(0.0, 0.0, 0.0, 0.0);\n"
"\n");
}
Ubershaders: Support per-pixel lighting
2017-07-27 04:52:20 -06:00
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// If we can disable the incorrect depth clipping planes using depth clamping, then we can do
// our own depth clipping and calculate the depth range before the perspective divide if
// necessary.
if (host_config.backend_depth_clamp)
{
// Since we're adjusting z for the depth range before the perspective divide, we have to do our
// own clipping. We want to clip so that -w <= z <= 0, which matches the console -1..0 range.
// We adjust our depth value for clipping purposes to match the perspective projection in the
// software backend, which is a hack to fix Sonic Adventure and Unleashed games.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("float clipDepth = o.pos.z * (1.0 - 1e-7);\n"
"float clipDist0 = clipDepth + o.pos.w;\n" // Near: z < -w
"float clipDist1 = -clipDepth;\n"); // Far: z > 0
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
if (host_config.backend_geometry_shaders)
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.clipDist0 = clipDist0;\n"
"o.clipDist1 = clipDist1;\n");
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
}
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
// Write the true depth value. If the game uses depth textures, then the pixel shader will
// override it with the correct values if not then early z culling will improve speed.
// There are two different ways to do this, when the depth range is oversized, we process
// the depth range in the vertex shader, if not we let the host driver handle it.
//
// Adjust z for the depth range. We're using an equation which incorperates a depth inversion,
// so we can map the console -1..0 range to the 0..1 range used in the depth buffer.
// We have to handle the depth range in the vertex shader instead of after the perspective
// divide, because some games will use a depth range larger than what is allowed by the
// graphics API. These large depth ranges will still be clipped to the 0..1 range, so these
// games effectively add a depth bias to the values written to the depth buffer.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.pos.z = o.pos.w * " I_PIXELCENTERCORRECTION ".w - "
"o.pos.z * " I_PIXELCENTERCORRECTION ".z;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
if (!host_config.backend_clip_control)
{
// If the graphics API doesn't support a depth range of 0..1, then we need to map z to
// the -1..1 range. Unfortunately we have to use a substraction, which is a lossy floating-point
// operation that can introduce a round-trip error.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.pos.z = o.pos.z * 2.0 - o.pos.w;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
// Correct for negative viewports by mirroring all vertices. We need to negate the height here,
// since the viewport height is already negated by the render backend.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.pos.xy *= sign(" I_PIXELCENTERCORRECTION ".xy * float2(1.0, -1.0));\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// The console GPU places the pixel center at 7/12 in screen space unless
// antialiasing is enabled, while D3D and OpenGL place it at 0.5. This results
// in some primitives being placed one pixel too far to the bottom-right,
// which in turn can be critical if it happens for clear quads.
// Hence, we compensate for this pixel center difference so that primitives
// get rasterized correctly.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.pos.xy = o.pos.xy - o.pos.w * " I_PIXELCENTERCORRECTION ".xy;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
if (vertex_rounding)
{
// By now our position is in clip space. However, higher resolutions than the Wii outputs
// cause an additional pixel offset. Due to a higher pixel density we need to correct this
// by converting our clip-space position into the Wii's screen-space.
// Acquire the right pixel and then convert it back.
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("if (o.pos.w == 1.0f)\n"
"{{\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("\tfloat ss_pixel_x = ((o.pos.x + 1.0f) * (" I_VIEWPORT_SIZE ".x * 0.5f));\n"
"\tfloat ss_pixel_y = ((o.pos.y + 1.0f) * (" I_VIEWPORT_SIZE ".y * 0.5f));\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("\tss_pixel_x = round(ss_pixel_x);\n"
"\tss_pixel_y = round(ss_pixel_y);\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("\to.pos.x = ((ss_pixel_x / (" I_VIEWPORT_SIZE ".x * 0.5f)) - 1.0f);\n"
"\to.pos.y = ((ss_pixel_y / (" I_VIEWPORT_SIZE ".y * 0.5f)) - 1.0f);\n"
"}}\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
if (api_type == APIType::OpenGL || api_type == APIType::Vulkan)
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
{
ShaderGen: Don't use interface blocks on Vulkan without GS Doing so causes the Adreno driver to choke and spew errors about too many output locations/components, when clearly we're under the limit.
2019-01-23 01:12:13 -07:00
if (host_config.backend_geometry_shaders)
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
{
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
AssignVSOutputMembers(out, "vs", "o", num_texgen, host_config);
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
else
{
// TODO: Pass interface blocks between shader stages even if geometry shaders
// are not supported, however that will require at least OpenGL 3.2 support.
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
for (u32 i = 0; i < num_texgen; ++i)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("tex{}.xyz = o.tex{};\n", i, i);
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
if (!host_config.fast_depth_calc)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("clipPos = o.clipPos;\n");
Ubershaders: Support per-pixel lighting
2017-07-27 04:52:20 -06:00
if (per_pixel_lighting)
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("Normal = o.Normal;\n"
"WorldPos = o.WorldPos;\n");
Ubershaders: Support per-pixel lighting
2017-07-27 04:52:20 -06:00
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("colors_0 = o.colors_0;\n"
"colors_1 = o.colors_1;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
if (host_config.backend_depth_clamp)
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("gl_ClipDistance[0] = clipDist0;\n"
"gl_ClipDistance[1] = clipDist1;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
// Vulkan NDC space has Y pointing down (right-handed NDC space).
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
if (api_type == APIType::Vulkan)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("gl_Position = float4(o.pos.x, -o.pos.y, o.pos.z, o.pos.w);\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
else
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("gl_Position = o.pos;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
else // D3D
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("return o;\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("}}\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
return out;
}
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
static void GenVertexShaderTexGens(APIType api_type, u32 num_texgen, ShaderCode& out)
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
{
// The HLSL compiler complains that the output texture coordinates are uninitialized when trying
// to dynamically index them.
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
for (u32 i = 0; i < num_texgen; i++)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("o.tex{} = float3(0.0, 0.0, 0.0);\n", i);
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("// Texture coordinate generation\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
if (num_texgen == 1)
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("{{ const uint texgen = 0u;\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
}
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
else
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
{
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write("{}for (uint texgen = 0u; texgen < {}u; texgen++) {{\n",
api_type == APIType::D3D ? "[loop] " : "", num_texgen);
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" // Texcoord transforms\n");
out.Write(" float4 coord = float4(0.0, 0.0, 1.0, 1.0);\n"
" uint texMtxInfo = xfmem_texMtxInfo(texgen);\n");
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
out.Write(" switch ({}) {{\n", BitfieldExtract<&TexMtxInfo::sourcerow>("texMtxInfo"));
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", SourceRow::Geom);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" coord.xyz = rawpos.xyz;\n");
out.Write(" break;\n\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", SourceRow::Normal);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
" coord.xyz = ((components & {}u /* VB_HAS_NRM0 */) != 0u) ? rawnorm0.xyz : coord.xyz;",
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
VB_HAS_NRM0);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" break;\n\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", SourceRow::BinormalT);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
" coord.xyz = ((components & {}u /* VB_HAS_NRM1 */) != 0u) ? rawnorm1.xyz : coord.xyz;",
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
VB_HAS_NRM1);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" break;\n\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", SourceRow::BinormalB);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
" coord.xyz = ((components & {}u /* VB_HAS_NRM2 */) != 0u) ? rawnorm2.xyz : coord.xyz;",
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
VB_HAS_NRM2);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" break;\n\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
for (u32 i = 0; i < 8; i++)
{
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", static_cast<SourceRow>(static_cast<u32>(SourceRow::Tex0) + i));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
" coord = ((components & {}u /* VB_HAS_UV{} */) != 0u) ? float4(rawtex{}.x, rawtex{}.y, "
ShaderGen: Use consistent variable names for texture coordinates
2017-07-26 09:01:25 -06:00
"1.0, 1.0) : coord;\n",
VB_HAS_UV0 << i, i, i, i);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" break;\n\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" }}\n"
"\n");
out.Write(" // Input form of AB11 sets z element to 1.0\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" if ({} == {:s}) // inputform == AB11\n",
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
BitfieldExtract<&TexMtxInfo::inputform>("texMtxInfo"), TexInputForm::AB11);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" coord.z = 1.0f;\n"
"\n");
out.Write(" // first transformation\n");
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
out.Write(" uint texgentype = {};\n", BitfieldExtract<&TexMtxInfo::texgentype>("texMtxInfo"));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" float3 output_tex;\n"
" switch (texgentype)\n"
" {{\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", TexGenType::EmbossMap);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" {{\n");
out.Write(" uint light = {};\n",
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
BitfieldExtract<&TexMtxInfo::embosslightshift>("texMtxInfo"));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" uint source = {};\n",
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
BitfieldExtract<&TexMtxInfo::embosssourceshift>("texMtxInfo"));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" switch (source) {{\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
for (u32 i = 0; i < num_texgen; i++)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" case {}u: output_tex.xyz = o.tex{}; break;\n", i, i);
out.Write(" default: output_tex.xyz = float3(0.0, 0.0, 0.0); break;\n"
" }}\n");
out.Write(" if ((components & {}u) != 0u) {{ // VB_HAS_NRM1 | VB_HAS_NRM2\n",
VB_HAS_NRM1 | VB_HAS_NRM2); // Should this be VB_HAS_NRM1 | VB_HAS_NRM2
out.Write(" float3 ldir = normalize(" I_LIGHTS "[light].pos.xyz - pos.xyz);\n"
" output_tex.xyz += float3(dot(ldir, _norm1), dot(ldir, _norm2), 0.0);\n"
" }}\n"
" }}\n"
" break;\n\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", TexGenType::Color0);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" output_tex.xyz = float3(o.colors_0.x, o.colors_0.y, 1.0);\n"
" break;\n\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", TexGenType::Color1);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" output_tex.xyz = float3(o.colors_1.x, o.colors_1.y, 1.0);\n"
" break;\n\n");
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" case {:s}:\n", TexGenType::Regular);
out.Write(" default:\n"
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
" {{\n");
out.Write(" if ((components & ({}u /* VB_HAS_TEXMTXIDX0 */ << texgen)) != 0u) {{\n",
VB_HAS_TEXMTXIDX0);
out.Write(" // This is messy, due to dynamic indexing of the input texture coordinates.\n"
" // Hopefully the compiler will unroll this whole loop anyway and the switch.\n"
" int tmp = 0;\n"
" switch (texgen) {{\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
for (u32 i = 0; i < num_texgen; i++)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" case {}u: tmp = int(rawtex{}.z); break;\n", i, i);
out.Write(" }}\n"
"\n");
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
out.Write(" if ({} == {:s}) {{\n", BitfieldExtract<&TexMtxInfo::projection>("texMtxInfo"),
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
TexSize::STQ);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" output_tex.xyz = float3(dot(coord, " I_TRANSFORMMATRICES "[tmp]),\n"
" dot(coord, " I_TRANSFORMMATRICES "[tmp + 1]),\n"
" dot(coord, " I_TRANSFORMMATRICES "[tmp + 2]));\n"
" }} else {{\n"
" output_tex.xyz = float3(dot(coord, " I_TRANSFORMMATRICES "[tmp]),\n"
" dot(coord, " I_TRANSFORMMATRICES "[tmp + 1]),\n"
" 1.0);\n"
" }}\n"
" }} else {{\n");
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
out.Write(" if ({} == {:s}) {{\n", BitfieldExtract<&TexMtxInfo::projection>("texMtxInfo"),
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
TexSize::STQ);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" output_tex.xyz = float3(dot(coord, " I_TEXMATRICES "[3u * texgen]),\n"
" dot(coord, " I_TEXMATRICES "[3u * texgen + 1u]),\n"
" dot(coord, " I_TEXMATRICES "[3u * texgen + 2u]));\n"
" }} else {{\n"
" output_tex.xyz = float3(dot(coord, " I_TEXMATRICES "[3u * texgen]),\n"
" dot(coord, " I_TEXMATRICES "[3u * texgen + 1u]),\n"
" 1.0);\n"
" }}\n"
" }}\n"
" }}\n"
" break;\n\n"
" }}\n"
"\n");
out.Write(" if (xfmem_dualTexInfo != 0u) {{\n");
out.Write(" uint postMtxInfo = xfmem_postMtxInfo(texgen);");
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
out.Write(" uint base_index = {};\n", BitfieldExtract<&PostMtxInfo::index>("postMtxInfo"));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" float4 P0 = " I_POSTTRANSFORMMATRICES "[base_index & 0x3fu];\n"
" float4 P1 = " I_POSTTRANSFORMMATRICES "[(base_index + 1u) & 0x3fu];\n"
" float4 P2 = " I_POSTTRANSFORMMATRICES "[(base_index + 2u) & 0x3fu];\n"
"\n");
Change BitfieldExtract to use a pointer to the bitfield member
2021-04-10 20:34:20 -06:00
out.Write(" if ({} != 0u)\n", BitfieldExtract<&PostMtxInfo::normalize>("postMtxInfo"));
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" output_tex.xyz = normalize(output_tex.xyz);\n"
"\n"
" // multiply by postmatrix\n"
" output_tex.xyz = float3(dot(P0.xyz, output_tex.xyz) + P0.w,\n"
" dot(P1.xyz, output_tex.xyz) + P1.w,\n"
" dot(P2.xyz, output_tex.xyz) + P2.w);\n"
" }}\n\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
// When q is 0, the GameCube appears to have a special case
// This can be seen in devkitPro's neheGX Lesson08 example for Wii
// Makes differences in Rogue Squadron 3 (Hoth sky) and The Last Story (shadow culling)
Convert XFMemory to BitField and enum class Additionally a new ClipDisable union has been added (though it is not currently used by Dolphin).
2021-02-10 17:01:42 -07:00
out.Write(" if (texgentype == {:s} && output_tex.z == 0.0)\n", TexGenType::Regular);
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
" output_tex.xy = clamp(output_tex.xy / 2.0f, float2(-1.0f,-1.0f), float2(1.0f,1.0f));\n"
"\n");
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" // Hopefully GPUs that can support dynamic indexing will optimize this.\n");
out.Write(" switch (texgen) {{\n");
UberShaderVertex: Migrate over to fmt Continues migration of the shader generators over to fmt. With this, all that's left to move over are the pixel shaders (regular and ubershader variants)
2020-10-20 07:00:39 -06:00
for (u32 i = 0; i < num_texgen; i++)
ShaderGenCommon: Rename WriteFmt() to Write() Now that we've converted all of the shader generators over to using fmt, we can drop the old Write() member function and perform a rename operation on the WriteFmt() to turn it into the new Write() function. All changes within this are the removal of a <cstdarg> header, since the previous printf-based Write() required it, and renaming. No functional changes are made at all.
2020-11-09 00:23:32 -07:00
out.Write(" case {}u: o.tex{} = output_tex; break;\n", i, i);
out.Write(" }}\n"
"}}\n");
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
}
void EnumerateVertexShaderUids(const std::function<void(const VertexShaderUid&)>& callback)
{
VertexShaderUid uid;
for (u32 texgens = 0; texgens <= 8; texgens++)
{
VideoCommon: Remove unnecessary memset on ShaderUid instances. Zero-initialization zeroes out all members and padding bits, so this is safe to do. While we're at it, also add static assertions that enforce the necessary requirements of a UID type explicitly within the ShaderUid class. This way, we can remove several memset calls around the shader generation code that makes sure the underlying UID data is zeroed out. Now our ShaderUid class enforces this for us, so we don't need to care about it at the usage sites.
2019-05-29 23:05:06 -06:00
vertex_ubershader_uid_data* const vuid = uid.GetUidData();
ShaderGen: Implement vertex ubershaders
2017-07-19 23:25:27 -06:00
vuid->num_texgens = texgens;
callback(uid);
}
}
ShaderGen: Omit some unused varyings when possible Removes the clipPos varying unless slow-depth is used, and the clipDistance varyings if geometry shaders are not used.
2019-01-23 01:11:17 -07:00
} // namespace UberShader
Reference in New Issue Copy Permalink