#include "CFluidPlaneShader.hpp" namespace urde { static boo::ObjToken s_vtxFmt; static boo::ObjToken s_vtxFmtTess; static const char* VS = "struct VertData\n" "{\n" " float4 posIn : POSITION;\n" " float4 normalIn : NORMAL0;\n" " float4 binormalIn : NORMAL1;\n" " float4 tangentIn : NORMAL2;\n" " float4 colorIn : COLOR;\n" "};\n" "\n" "cbuffer FluidPlaneUniform : register(b0)\n" "{\n" " float4x4 mv;\n" " float4x4 mvNorm;\n" " float4x4 proj;\n" " float4x4 texMtxs[6];\n" "};\n" "\n" "struct VertToFrag\n" "{\n" " float4 pos : SV_Position;\n" " float4 mvPos : POSITION;\n" " float4 mvNorm : NORMAL;\n" " float4 mvBinorm : BINORMAL;\n" " float4 mvTangent : TANGENT;\n" " float4 color : COLOR;\n" " float2 uvs[7] : UV;\n" "};\n" "\n" "VertToFrag main(in VertData v)\n" "{\n" " VertToFrag vtf;\n" " float4 pos = float4(v.posIn.xyz, 1.0);\n" " float4 normalIn = v.normalIn;\n" " vtf.mvPos = mul(mv, pos);\n" " vtf.pos = mul(proj, vtf.mvPos);\n" " vtf.mvNorm = mul(mvNorm, v.normalIn);\n" " vtf.mvBinorm = mul(mvNorm, v.binormalIn);\n" " vtf.mvTangent = mul(mvNorm, v.tangentIn);\n" " vtf.color = float4(v.colorIn.xyz, 1.0);\n" " vtf.uvs[0] = mul(texMtxs[0], pos).xy;\n" " vtf.uvs[1] = mul(texMtxs[1], pos).xy;\n" " vtf.uvs[2] = mul(texMtxs[2], pos).xy;\n" "%s" // Additional TCGs here " return vtf;\n" "}\n"; static const char* TessVS = "struct VertData\n" "{\n" " float4 posIn : POSITION;\n" " float4 outerLevelsIn : UV0;\n" " float2 innerLevelsIn : UV1;\n" "};\n" "\n" "struct VertToControl\n" "{\n" " float4 minMaxPos : POSITION;\n" " float4 outerLevels : OUTERLEVELS;\n" " float2 innerLevels : INNERLEVELS;\n" "};\n" "\n" "VertToControl main(in VertData v)\n" "{\n" " VertToControl vtc;\n" " vtc.minMaxPos = v.posIn;\n" " vtc.outerLevels = v.outerLevelsIn;\n" " vtc.innerLevels = v.innerLevelsIn;\n" " return vtc;\n" "}\n"; static const char* TessCS = "struct VertToControl\n" "{\n" " float4 minMaxPos : POSITION;\n" " float4 outerLevels : OUTERLEVELS;\n" " float2 innerLevels : INNERLEVELS;\n" "};\n" "\n" "struct ControlToEvaluation\n" "{\n" " float4 minMaxPos : POSITION;\n" " float outerLevels[4] : SV_TessFactor;\n" " float innerLevels[2] : SV_InsideTessFactor;\n" "};\n" "\n" "struct ControlPoint\n" "{};\n" "\n" "ControlToEvaluation patchmain(InputPatch vtc, uint id : SV_PrimitiveID)\n" "{\n" " ControlToEvaluation cte;\n" " cte.minMaxPos = vtc[id].minMaxPos;\n" " for (int i=0 ; i<4 ; ++i)\n" " cte.outerLevels[i] = vtc[id].outerLevels[i];\n" " for (int i=0 ; i<2 ; ++i)\n" " cte.innerLevels[i] = vtc[id].innerLevels[i];\n" " return cte;\n" "}\n" "\n" "[domain(\"quad\")]\n" "[partitioning(\"integer\")]\n" "[outputtopology(\"triangle_cw\")]\n" "[outputcontrolpoints(1)]\n" "[patchconstantfunc(\"patchmain\")]\n" "ControlPoint main(InputPatch vtc, uint i : SV_OutputControlPointID, uint id : SV_PrimitiveID)\n" "{\n" " ControlPoint pt;\n" " return pt;\n" "}\n"; static const char* TessES = "struct Ripple\n" "{\n" " float4 center; // time, distFalloff\n" " float4 params; // amplitude, lookupPhase, lookupTime\n" "};\n" "\n" "cbuffer FluidPlaneUniform : register(b0)\n" "{\n" " float4x4 mv;\n" " float4x4 mvNorm;\n" " float4x4 proj;\n" " float4x4 texMtxs[6];\n" " Ripple ripples[20];\n" " float4 colorMul;\n" " float rippleNormResolution;\n" "};\n" "\n" "struct VertToFrag\n" "{\n" " float4 pos : SV_Position;\n" " float4 mvPos : POSITION;\n" " float4 mvNorm : NORMAL;\n" " float4 mvBinorm : BINORMAL;\n" " float4 mvTangent : TANGENT;\n" " float4 color : COLOR;\n" " float2 uvs[7] : UV;\n" "};\n" "\n" "struct ControlToEvaluation\n" "{\n" " float4 minMaxPos : POSITION;\n" " float outerLevels[4] : SV_TessFactor;\n" " float innerLevels[2] : SV_InsideTessFactor;\n" "};\n" "\n" "struct ControlPoint\n" "{};\n" "\n" "Texture2D RippleMap : register(t%d);\n" "SamplerState samp : register(s2);\n" "\n" "static const float PI_X2 = 6.283185307179586;\n" "\n" "static void ApplyRipple(in Ripple ripple, in float2 pos, inout float height)\n" "{\n" " float dist = length(ripple.center.xy - pos);\n" " float rippleV = RippleMap.SampleLevel(samp, float2(dist * ripple.center.w, ripple.center.z), 0.0).r;\n" " height += rippleV * ripple.params.x * sin((dist * ripple.params.y + ripple.params.z) * PI_X2);\n" "}\n" "\n" "[domain(\"quad\")]\n" "VertToFrag main(in ControlToEvaluation cte, in float2 TessCoord : SV_DomainLocation,\n" " const OutputPatch bezpatch)\n" "{\n" " float2 posIn = float2(lerp(cte.minMaxPos.x, cte.minMaxPos.z, TessCoord.x),\n" " lerp(cte.minMaxPos.y, cte.minMaxPos.w, TessCoord.y));\n" " float height = 0.0;\n" " float upHeight = 0.0;\n" " float downHeight = 0.0;\n" " float rightHeight = 0.0;\n" " float leftHeight = 0.0;\n" " for (int i=0 ; i<20 ; ++i)\n" " {\n" " ApplyRipple(ripples[i], posIn, height);\n" " ApplyRipple(ripples[i], posIn + float2(0.0, rippleNormResolution), upHeight);\n" " ApplyRipple(ripples[i], posIn - float2(0.0, rippleNormResolution), downHeight);\n" " ApplyRipple(ripples[i], posIn + float2(rippleNormResolution, 0.0), rightHeight);\n" " ApplyRipple(ripples[i], posIn - float2(rippleNormResolution, 0.0), leftHeight);\n" " }\n" " float4 normalIn = float4(normalize(float3((leftHeight - rightHeight),\n" " (downHeight - upHeight),\n" " rippleNormResolution)), 1.0);\n" " float4 binormalIn = float4(normalIn.x, normalIn.z, -normalIn.y, 1.0);\n" " float4 tangentIn = float4(normalIn.z, normalIn.y, -normalIn.x, 1.0);\n" " float4 pos = float4(posIn, height, 1.0);\n" " VertToFrag vtf;\n" " vtf.mvPos = mul(mv, pos);\n" " vtf.pos = mul(proj, vtf.mvPos);\n" " vtf.mvNorm = mul(mvNorm, normalIn);\n" " vtf.mvBinorm = mul(mvNorm, binormalIn);\n" " vtf.mvTangent = mul(mvNorm, tangentIn);\n" " vtf.color = max(height, 0.0) * colorMul;\n" " vtf.color.a = 1.0;\n" " vtf.uvs[0] = mul(texMtxs[0], pos).xy;\n" " vtf.uvs[1] = mul(texMtxs[1], pos).xy;\n" " vtf.uvs[2] = mul(texMtxs[2], pos).xy;\n" "%s\n" // Additional TCGs here " return vtf;\n" "}\n"; static const char* FS = "struct Light\n" "{\n" " float4 pos;\n" " float4 dir;\n" " float4 color;\n" " float4 linAtt;\n" " float4 angAtt;\n" "};\n" "struct Fog\n" // Reappropriated for indirect texture scaling "{\n" " int mode;\n" " float4 color;\n" " float indScale;\n" " float start;\n" "};\n" "\n" "cbuffer LightingUniform : register(b2)\n" "{\n" " Light lights[" _XSTR(URDE_MAX_LIGHTS) "];\n" " float4 ambient;\n" " float4 kColor0;\n" " float4 kColor1;\n" " float4 kColor2;\n" " float4 kColor3;\n" " Fog fog;\n" "};\n" "\n" "static float4 LightingFunc(float3 mvPosIn, float3 mvNormIn)\n" "{\n" " float4 ret = ambient;\n" " \n" " for (int i=0 ; i<" _XSTR(URDE_MAX_LIGHTS) " ; ++i)\n" " {\n" " float3 delta = mvPosIn - lights[i].pos.xyz;\n" " float dist = length(delta);\n" " float angDot = clamp(dot(normalize(delta), lights[i].dir.xyz), 0.0, 1.0);\n" " float att = 1.0 / (lights[i].linAtt[2] * dist * dist +\n" " lights[i].linAtt[1] * dist +\n" " lights[i].linAtt[0]);\n" " float angAtt = lights[i].angAtt[2] * angDot * angDot +\n" " lights[i].angAtt[1] * angDot +\n" " lights[i].angAtt[0];\n" " ret += lights[i].color * clamp(angAtt, 0.0, 1.0) * att * clamp(dot(normalize(-delta), mvNormIn), 0.0, 1.0);\n" " }\n" " \n" " return ret;\n" "}\n" "\n" "struct VertToFrag\n" "{\n" " float4 pos : SV_Position;\n" " float4 mvPos : POSITION;\n" " float4 mvNorm : NORMAL;\n" " float4 mvBinorm : BINORMAL;\n" " float4 mvTangent : TANGENT;\n" " float4 color : COLOR;\n" " float2 uvs[7] : UV;\n" "};\n" "\n" "SamplerState samp : register(s0);\n" "%s" // Textures here "float4 main(in VertToFrag vtf) : SV_Target0\n" "{\n" " float4 lighting = LightingFunc(vtf.mvPos.xyz, normalize(vtf.mvNorm.xyz));\n" " float4 colorOut;\n" "%s" // Combiner expression here " return colorOut;\n" "}\n"; static const char* FSDoor = "struct Light\n" "{\n" " float4 pos;\n" " float4 dir;\n" " float4 color;\n" " float4 linAtt;\n" " float4 angAtt;\n" "};\n" "struct Fog\n" // Reappropriated for indirect texture scaling "{\n" " int mode;\n" " float4 color;\n" " float indScale;\n" " float start;\n" "};\n" "\n" "cbuffer LightingUniform : register(b2)\n" "{\n" " Light lights[" _XSTR(URDE_MAX_LIGHTS) "];\n" " float4 ambient;\n" " float4 kColor0;\n" " float4 kColor1;\n" " float4 kColor2;\n" " float4 kColor3;\n" " Fog fog;\n" "};\n" "struct VertToFrag\n" "{\n" " float4 pos : SV_Position;\n" " float4 mvPos : POSITION;\n" " float4 mvNorm : NORMAL;\n" " float4 mvBinorm : BINORMAL;\n" " float4 mvTangent : TANGENT;\n" " float4 color : COLOR;\n" " float2 uvs[7] : UV;\n" "};\n" "\n" "SamplerState samp : register(s0);\n" "%s" // Textures here "float4 main(in VertToFrag vtf) : SV_Target0\n" "{\n" " float4 colorOut;\n" "%s" // Combiner expression here " return colorOut;\n" "}\n"; CFluidPlaneShader::ShaderPair CFluidPlaneShader::BuildShader(boo::D3DDataFactory::Context& ctx, const SFluidPlaneShaderInfo& info) { if (!s_vtxFmt) { boo::VertexElementDescriptor elements[] = { {nullptr, nullptr, boo::VertexSemantic::Position4}, {nullptr, nullptr, boo::VertexSemantic::Normal4, 0}, {nullptr, nullptr, boo::VertexSemantic::Normal4, 1}, {nullptr, nullptr, boo::VertexSemantic::Normal4, 2}, {nullptr, nullptr, boo::VertexSemantic::Color} }; s_vtxFmt = ctx.newVertexFormat(5, elements); } std::string additionalTCGs; std::string textures; std::string combiner; int nextTex = 0; int nextTCG = 3; int nextMtx = 4; int bumpMapUv, envBumpMapUv, envMapUv, lightmapUv; if (info.m_hasPatternTex1) textures += hecl::Format("Texture2D patternTex1 : register(t%d);\n", nextTex++); if (info.m_hasPatternTex2) textures += hecl::Format("Texture2D patternTex2 : register(t%d);\n", nextTex++); if (info.m_hasColorTex) textures += hecl::Format("Texture2D colorTex : register(t%d);\n", nextTex++); if (info.m_hasBumpMap) textures += hecl::Format("Texture2D bumpMap : register(t%d);\n", nextTex++); if (info.m_hasEnvMap) textures += hecl::Format("Texture2D envMap : register(t%d);\n", nextTex++); if (info.m_hasEnvBumpMap) textures += hecl::Format("Texture2D envBumpMap : register(t%d);\n", nextTex++); if (info.m_hasLightmap) textures += hecl::Format("Texture2D lightMap : register(t%d);\n", nextTex++); if (info.m_hasBumpMap) { bumpMapUv = nextTCG; additionalTCGs += hecl::Format(" vtf.uvs[%d] = mul(texMtxs[0], pos).xy;\n", nextTCG++); } if (info.m_hasEnvBumpMap) { envBumpMapUv = nextTCG; additionalTCGs += hecl::Format(" vtf.uvs[%d] = mul(texMtxs[3], float4(normalIn.xyz, 1.0)).xy;\n", nextTCG++); } if (info.m_hasEnvMap) { envMapUv = nextTCG; additionalTCGs += hecl::Format(" vtf.uvs[%d] = mul(texMtxs[%d], pos).xy;\n", nextTCG++, nextMtx++); } if (info.m_hasLightmap) { lightmapUv = nextTCG; additionalTCGs += hecl::Format(" vtf.uvs[%d] = mul(texMtxs[%d], pos).xy;\n", nextTCG++, nextMtx++); } switch (info.m_type) { case EFluidType::NormalWater: case EFluidType::PhazonFluid: case EFluidType::Four: if (info.m_hasLightmap) { combiner += hecl::Format(" float4 lightMapTexel = lightMap.Sample(samp, vtf.uvs[%d]);\n", lightmapUv); // 0: Tex4TCG, Tex4, doubleLightmapBlend ? NULL : GX_COLOR1A1 // ZERO, TEX, KONST, doubleLightmapBlend ? ZERO : RAS // Output reg 2 // KColor 2 if (info.m_doubleLightmapBlend) { // 1: Tex4TCG2, Tex4, GX_COLOR1A1 // C2, TEX, KONST, RAS // Output reg 2 // KColor 3 // Tex * K2 + Lighting combiner += " lighting += lerp(lightMapTexel * kColor2, lightMapTexel, kColor3);\n"; } else { // mix(Tex * K2, Tex, K3) + Lighting combiner += " lighting += lightMapTexel * kColor2;\n"; } } // Next: Tex0TCG, Tex0, GX_COLOR1A1 // ZERO, TEX, KONST, RAS // Output reg prev // KColor 0 // Next: Tex1TCG, Tex1, GX_COLOR0A0 // ZERO, TEX, PREV, RAS // Output reg prev // Next: Tex2TCG, Tex2, GX_COLOR1A1 // ZERO, TEX, hasTex4 ? C2 : RAS, PREV // Output reg prev // (Tex0 * kColor0 + Lighting) * Tex1 + VertColor + Tex2 * Lighting if (info.m_hasPatternTex2) { if (info.m_hasPatternTex1) combiner += " colorOut = (patternTex1.Sample(samp, vtf.uvs[0]) * kColor0 + lighting) *\n" " patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; else combiner += " colorOut = lighting * patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; } else { combiner += " colorOut = vtf.color;\n"; } if (info.m_hasColorTex && !info.m_hasEnvMap && info.m_hasEnvBumpMap) { // Make previous stage indirect, mtx0 combiner += hecl::Format(" float2 indUvs = (envBumpMap.Sample(samp, vtf.uvs[%d]).ra - float2(0.5, 0.5)) *\n" " float2(fog.indScale, -fog.indScale);\n", envBumpMapUv); combiner += " colorOut += colorTex.Sample(samp, indUvs + vtf.uvs[2]) * lighting;\n"; } else if (info.m_hasEnvMap) { // Next: envTCG, envTex, NULL // PREV, TEX, KONST, ZERO // Output reg prev // KColor 1 // Make previous stage indirect, mtx0 if (info.m_hasColorTex) combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]) * lighting;\n"; combiner += hecl::Format(" float2 indUvs = (envBumpMap.Sample(samp, vtf.uvs[%d]).ra - float2(0.5, 0.5)) *\n" " float2(fog.indScale, -fog.indScale);\n", envBumpMapUv); combiner += hecl::Format(" colorOut = lerp(colorOut, envMap.Sample(samp, indUvs + vtf.uvs[%d]), kColor1);\n", envMapUv); } else if (info.m_hasColorTex) { combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]) * lighting;\n"; } break; case EFluidType::PoisonWater: if (info.m_hasLightmap) { combiner += hecl::Format(" float4 lightMapTexel = lightMap.Sample(samp, vtf.uvs[%d]);\n", lightmapUv); // 0: Tex4TCG, Tex4, doubleLightmapBlend ? NULL : GX_COLOR1A1 // ZERO, TEX, KONST, doubleLightmapBlend ? ZERO : RAS // Output reg 2 // KColor 2 if (info.m_doubleLightmapBlend) { // 1: Tex4TCG2, Tex4, GX_COLOR1A1 // C2, TEX, KONST, RAS // Output reg 2 // KColor 3 // Tex * K2 + Lighting combiner += " lighting += lerp(lightMapTexel * kColor2, lightMapTexel, kColor3);\n"; } else { // mix(Tex * K2, Tex, K3) + Lighting combiner += " lighting += lightMapTexel * kColor2;\n"; } } // Next: Tex0TCG, Tex0, GX_COLOR1A1 // ZERO, TEX, KONST, RAS // Output reg prev // KColor 0 // Next: Tex1TCG, Tex1, GX_COLOR0A0 // ZERO, TEX, PREV, RAS // Output reg prev // Next: Tex2TCG, Tex2, GX_COLOR1A1 // ZERO, TEX, hasTex4 ? C2 : RAS, PREV // Output reg prev // (Tex0 * kColor0 + Lighting) * Tex1 + VertColor + Tex2 * Lighting if (info.m_hasPatternTex2) { if (info.m_hasPatternTex1) combiner += " colorOut = (patternTex1.Sample(samp, vtf.uvs[0]) * kColor0 + lighting) *\n" " patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; else combiner += " colorOut = lighting * patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; } else { combiner += " colorOut = vtf.color;\n"; } if (info.m_hasColorTex) { if (info.m_hasEnvBumpMap) { // Make previous stage indirect, mtx0 combiner += hecl::Format(" float2 indUvs = (envBumpMap.Sample(samp, vtf.uvs[%d]).ra - float2(0.5, 0.5)) *\n" " float2(fog.indScale, -fog.indScale);\n", envBumpMapUv); combiner += " colorOut += colorTex.Sample(samp, indUvs + vtf.uvs[2]) * lighting;\n"; } else { combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]) * lighting;\n"; } } break; case EFluidType::Lava: // 0: Tex0TCG, Tex0, GX_COLOR0A0 // ZERO, TEX, KONST, RAS // Output reg prev // KColor 0 // 1: Tex1TCG, Tex1, GX_COLOR0A0 // ZERO, TEX, PREV, RAS // Output reg prev // 2: Tex2TCG, Tex2, NULL // ZERO, TEX, ONE, PREV // Output reg prev // (Tex0 * kColor0 + VertColor) * Tex1 + VertColor + Tex2 if (info.m_hasPatternTex2) { if (info.m_hasPatternTex1) combiner += " colorOut = (patternTex1.Sample(samp, vtf.uvs[0]) * kColor0 + vtf.color) *\n" " patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; else combiner += " colorOut = vtf.color * patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; } else { combiner += " colorOut = vtf.color;\n"; } if (info.m_hasColorTex) combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]);\n"; if (info.m_hasBumpMap) { // 3: bumpMapTCG, bumpMap, NULL // ZERO, TEX, ONE, HALF // Output reg 0, no clamp, no bias // 4: bumpMapTCG2, bumpMap, NULL // ZERO, TEX, ONE, C0 // Output reg 0, subtract, clamp, no bias combiner += " float3 lightVec = lights[3].pos.xyz - vtf.mvPos.xyz;\n" " float lx = dot(vtf.mvTangent.xyz, lightVec);\n" " float ly = dot(vtf.mvBinorm.xyz, lightVec);\n"; combiner += hecl::Format(" float4 emboss1 = bumpMap.Sample(samp, vtf.uvs[%d]) + float4(0.5);\n" " float4 emboss2 = bumpMap.Sample(samp, vtf.uvs[%d] + float2(lx, ly));\n", bumpMapUv, bumpMapUv); // 5: NULL, NULL, NULL // ZERO, PREV, C0, ZERO // Output reg prev, scale 2, clamp // colorOut * clamp(emboss1 + 0.5 - emboss2, 0.0, 1.0) * 2.0 combiner += "colorOut *= clamp((emboss1 + float4(0.5) - emboss2) * float4(2.0), float4(0.0), float4(1.0));\n"; } break; case EFluidType::ThickLava: // 0: Tex0TCG, Tex0, GX_COLOR0A0 // ZERO, TEX, KONST, RAS // Output reg prev // KColor 0 // 1: Tex1TCG, Tex1, GX_COLOR0A0 // ZERO, TEX, PREV, RAS // Output reg prev // 2: Tex2TCG, Tex2, NULL // ZERO, TEX, ONE, PREV // Output reg prev // (Tex0 * kColor0 + VertColor) * Tex1 + VertColor + Tex2 if (info.m_hasPatternTex2) { if (info.m_hasPatternTex1) combiner += " colorOut = (patternTex1.Sample(samp, vtf.uvs[0]) * kColor0 + vtf.color) *\n" " patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; else combiner += " colorOut = vtf.color * patternTex2.Sample(samp, vtf.uvs[1]) + vtf.color;\n"; } else { combiner += " colorOut = vtf.color;\n"; } if (info.m_hasColorTex) combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]);\n"; if (info.m_hasBumpMap) { // 3: bumpMapTCG, bumpMap, NULL // ZERO, TEX, PREV, ZERO // Output reg prev, scale 2 combiner += hecl::Format(" float4 emboss1 = bumpMap.Sample(samp, vtf.uvs[%d]) + float4(0.5);\n", bumpMapUv); combiner += "colorOut *= emboss1 * float4(2.0);\n"; } break; } combiner += " colorOut.a = kColor0.a;\n"; char *finalVS, *finalFS; asprintf(&finalVS, VS, additionalTCGs.c_str()); asprintf(&finalFS, FS, textures.c_str(), combiner.c_str()); auto regular = ctx.newShaderPipeline(finalVS, finalFS, nullptr, nullptr, nullptr, s_vtxFmt, info.m_additive ? boo::BlendFactor::One : boo::BlendFactor::SrcAlpha, info.m_additive ? boo::BlendFactor::One : boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, boo::ZTest::LEqual, false, true, false, boo::CullMode::None); boo::ObjToken tessellation; if (info.m_tessellation) { if (!s_vtxFmtTess) { boo::VertexElementDescriptor elements[] = { {nullptr, nullptr, boo::VertexSemantic::Position4}, {nullptr, nullptr, boo::VertexSemantic::UV4, 0}, {nullptr, nullptr, boo::VertexSemantic::UV4, 1} }; s_vtxFmtTess = ctx.newVertexFormat(3, elements); } char *finalESs; asprintf(&finalESs, TessES, nextTex, additionalTCGs.c_str()); tessellation = ctx.newTessellationShaderPipeline( TessVS, finalFS, TessCS, finalESs, nullptr, nullptr, nullptr, nullptr, nullptr, s_vtxFmtTess, info.m_additive ? boo::BlendFactor::One : boo::BlendFactor::SrcAlpha, info.m_additive ? boo::BlendFactor::One : boo::BlendFactor::InvSrcAlpha, 1, boo::ZTest::LEqual, false, true, false, boo::CullMode::None); free(finalESs); } free(finalVS); free(finalFS); return {regular, tessellation}; } CFluidPlaneShader::ShaderPair CFluidPlaneShader::BuildShader(boo::D3DDataFactory::Context& ctx, const SFluidPlaneDoorShaderInfo& info) { if (!s_vtxFmt) { boo::VertexElementDescriptor elements[] = { {nullptr, nullptr, boo::VertexSemantic::Position4}, {nullptr, nullptr, boo::VertexSemantic::Normal4, 0}, {nullptr, nullptr, boo::VertexSemantic::Normal4, 1}, {nullptr, nullptr, boo::VertexSemantic::Normal4, 2}, {nullptr, nullptr, boo::VertexSemantic::Color} }; s_vtxFmt = ctx.newVertexFormat(5, elements); } std::string additionalTCGs; std::string textures; std::string combiner; int nextTex = 0; if (info.m_hasPatternTex1) textures += hecl::Format("Texture2D patternTex1 : register(t%d);\n", nextTex++); if (info.m_hasPatternTex2) textures += hecl::Format("Texture2D patternTex2 : register(t%d);\n", nextTex++); if (info.m_hasColorTex) textures += hecl::Format("Texture2D colorTex : register(t%d);\n", nextTex++); // Tex0 * kColor0 * Tex1 + Tex2 if (info.m_hasPatternTex1 && info.m_hasPatternTex2) { combiner += " colorOut = patternTex1.Sample(samp, vtf.uvs[0]) * kColor0 *\n" " patternTex2.Sample(samp, vtf.uvs[1]);\n"; } else { combiner += " colorOut = float4(0.0);\n"; } if (info.m_hasColorTex) { combiner += " colorOut += colorTex.Sample(samp, vtf.uvs[2]);\n"; } combiner += " colorOut.a = kColor0.a;\n"; char *finalVS, *finalFS; asprintf(&finalVS, VS, additionalTCGs.c_str()); asprintf(&finalFS, FSDoor, textures.c_str(), combiner.c_str()); auto ret = ctx.newShaderPipeline(finalVS, finalFS, nullptr, nullptr, nullptr, s_vtxFmt, boo::BlendFactor::SrcAlpha, boo::BlendFactor::InvSrcAlpha, boo::Primitive::TriStrips, boo::ZTest::LEqual, false, true, false, boo::CullMode::None); free(finalVS); free(finalFS); return {ret, {}}; } template <> void CFluidPlaneShader::_Shutdown() { s_vtxFmt.reset(); s_vtxFmtTess.reset(); } CFluidPlaneShader::BindingPair CFluidPlaneShader::BuildBinding(boo::D3DDataFactory::Context& ctx, const ShaderPair& pipeline) { boo::ObjToken ubufs[] = { m_uniBuf.get(), m_uniBuf.get(), m_uniBuf.get() }; boo::PipelineStage ubufStages[] = { boo::PipelineStage::Vertex, boo::PipelineStage::Vertex, boo::PipelineStage::Fragment }; size_t ubufOffs[] = {0, 0, 1280}; size_t ubufSizes[] = {1280, 1280, sizeof(CModelShaders::LightingUniform)}; size_t texCount = 0; boo::ObjToken texs[8] = {}; if (m_patternTex1) texs[texCount++] = m_patternTex1->GetBooTexture(); if (m_patternTex2) texs[texCount++] = m_patternTex2->GetBooTexture(); if (m_colorTex) texs[texCount++] = m_colorTex->GetBooTexture(); if (m_bumpMap) texs[texCount++] = m_bumpMap->GetBooTexture(); if (m_envMap) texs[texCount++] = m_envMap->GetBooTexture(); if (m_envBumpMap) texs[texCount++] = m_envBumpMap->GetBooTexture(); if (m_lightmap) texs[texCount++] = m_lightmap->GetBooTexture(); auto regular = ctx.newShaderDataBinding(pipeline.m_regular, s_vtxFmt, m_vbo.get(), nullptr, nullptr, 3, ubufs, ubufStages, ubufOffs, ubufSizes, texCount, texs, nullptr, nullptr); boo::ObjToken tessellation; if (pipeline.m_tessellation) { texs[texCount++] = m_rippleMap.get(); tessellation = ctx.newShaderDataBinding(pipeline.m_tessellation, s_vtxFmtTess, m_pvbo.get(), nullptr, nullptr, 3, ubufs, ubufStages, ubufOffs, ubufSizes, texCount, texs, nullptr, nullptr); } return {regular, tessellation}; } }