diff options
Diffstat (limited to 'Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp')
| -rw-r--r-- | Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp | 1504 |
1 files changed, 1504 insertions, 0 deletions
diff --git a/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp b/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp new file mode 100644 index 0000000..4752142 --- /dev/null +++ b/Runtime/GfxDevice/d3d11/ShaderGeneratorD3D11.cpp @@ -0,0 +1,1504 @@ +#include "UnityPrefix.h" +#include "ShaderGeneratorD3D11.h" +#include "FixedFunctionStateD3D11.h" +#include "ConstantBuffersD3D11.h" +#include "D3D11Context.h" +#include "Runtime/GfxDevice/GpuProgram.h" +#include "External/shaderlab/Library/TextureBinding.h" +#include "Runtime/GfxDevice/GfxDevice.h" +#include "D3D11ByteCode.h" + +#define DEBUG_D3D11_FF_SHADERS (!UNITY_RELEASE && 0) +#define DEBUG_D3D11_COMPARE_WITH_HLSL (DEBUG_D3D11_FF_SHADERS && 0) + +ConstantBuffersD3D11& GetD3D11ConstantBuffers (GfxDevice& device); + + +// --- Debugging --------------------------------------------------------------------------------- + + +#if DEBUG_D3D11_FF_SHADERS + +#include "Runtime/GfxDevice/d3d11/D3D11Compiler.h" +#if UNITY_WINRT +#include "PlatformDependent/MetroPlayer/MetroUtils.h" +#endif + +static D3D11Compiler s_Compiler; + +static bool HasD3D11Compiler() +{ + static bool initialized = false; + if (!initialized) + { + //s_Compiler.Initialize (kD3D11CompilerDLL); + const char* dllName = kD3D11CompilerDLL; + s_Compiler.compileFunc = NULL; + s_Compiler.stripShaderFunc = NULL; + s_Compiler.reflectFunc = NULL; + s_Compiler.disassembleFunc = NULL; + s_Compiler.createBlobFunc = NULL; + + #if UNITY_WINRT + HMODULE dll = LoadPackagedLibrary (ConvertToWindowsPath(dllName)->Data(), 0); + #else + HMODULE dll = LoadLibraryA (dllName); + #endif + if (dll) + { + s_Compiler.compileFunc = (D3D11Compiler::D3DCompileFunc) GetProcAddress (dll, "D3DCompile"); + s_Compiler.stripShaderFunc = (D3D11Compiler::D3DStripShaderFunc) GetProcAddress (dll, "D3DStripShader"); + s_Compiler.reflectFunc = (D3D11Compiler::D3DReflectFunc) GetProcAddress (dll, "D3DReflect"); + s_Compiler.disassembleFunc = (D3D11Compiler::D3DDisassembleFunc) GetProcAddress (dll, "D3DDisassemble"); + s_Compiler.createBlobFunc = (D3D11Compiler::D3DCreateBlobFunc) GetProcAddress (dll, "D3DCreateBlob"); + } + } + return s_Compiler.IsValid(); +} + +#endif // #if DEBUG_D3D11_FF_SHADERS + + +#if DEBUG_D3D11_COMPARE_WITH_HLSL + +enum D3DCOMPILER_STRIP_FLAGS +{ + D3DCOMPILER_STRIP_REFLECTION_DATA = 1, + D3DCOMPILER_STRIP_DEBUG_INFO = 2, + D3DCOMPILER_STRIP_TEST_BLOBS = 4, + D3DCOMPILER_STRIP_FORCE_DWORD = 0x7fffffff, +}; + +#define D3D_DISASM_ENABLE_COLOR_CODE 1 +#define D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS 2 +#define D3D_DISASM_ENABLE_INSTRUCTION_NUMBERING 4 +#define D3D_DISASM_ENABLE_INSTRUCTION_CYCLE 8 + +static void DebugCompileHLSLShaderD3D11 (const std::string& source, bool vertex) +{ + if (!HasD3D11Compiler()) + return; + + ID3D10Blob* shader = NULL; + ID3D10Blob* errors; + Assert (s_Compiler.compileFunc); + HRESULT hr = s_Compiler.compileFunc ( + source.c_str(), + source.size(), + "source", + NULL, + NULL, + "main", + gGraphicsCaps.d3d11.featureLevel < kDX11Level10_0 + ? (vertex ? "vs_4_0_level_9_3" : "ps_4_0_level_9_3") + : (vertex ? "vs_4_0" : "ps_4_0"), + 0, + 0, + &shader, + &errors); + + if (FAILED(hr)) + { + printf_console ("Failed to compile D3D11 shader:\n%s\n", source.c_str()); + if (errors) + { + std::string msg (reinterpret_cast<const char*>(errors->GetBufferPointer()), errors->GetBufferSize()); + printf_console ("\nErrors:\n%s\n", msg.c_str()); + errors->Release(); + } + else + { + printf_console ("\nErrors unknown!\n"); + } + AssertString ("Failed to compile fixed function D3D11 shader"); + return; + } + + if (shader && s_Compiler.stripShaderFunc) + { + ID3D10Blob* strippedShader = NULL; + + hr = s_Compiler.stripShaderFunc (shader->GetBufferPointer(), shader->GetBufferSize(), D3DCOMPILER_STRIP_REFLECTION_DATA | D3DCOMPILER_STRIP_DEBUG_INFO | D3DCOMPILER_STRIP_TEST_BLOBS, &strippedShader); + if (SUCCEEDED(hr)) + { + SAFE_RELEASE(shader); + shader = strippedShader; + } + } + + SAFE_RELEASE(errors); + + if (shader && s_Compiler.disassembleFunc) + { + ID3D10Blob* disasm = NULL; + hr = s_Compiler.disassembleFunc (shader->GetBufferPointer(), shader->GetBufferSize(), D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS, NULL, &disasm); + if (SUCCEEDED(hr) && disasm) + { + printf_console ("disasm:\n%s\n\n", disasm->GetBufferPointer()); + } + SAFE_RELEASE(disasm); + } + + SAFE_RELEASE(shader); +} + +static inline void AddToStringList (std::string& str, const char* s) +{ + if (!str.empty()) + str += ','; + str += s; +} + +#endif // #if DEBUG_D3D11_COMPARE_WITH_HLSL + + + +// --- Constant buffers & utilities -------------------------------------------------------------- + + +static const char* kD3D11VertexCB = "UnityFFVertex"; +static const char* kD3D11PixelCB = "UnityFFPixel"; + +enum { + k11VertexMVP = 0, + k11VertexMV = 4, + k11VertexColor = 8, + k11VertexAmbient = 9, + k11VertexLightColor = 10, + k11VertexLightPos = 18, + k11VertexLightAtten = 26, + k11VertexLightSpot = 34, + k11VertexMatDiffuse = 42, + k11VertexMatAmbient = 43, + k11VertexMatSpec = 44, + k11VertexMatEmission = 45, + k11VertexTex = 46, + k11VertexFog = 62, + k11VertexSize = 63, + k11VertexPosOffset9x = k11VertexSize+1, +}; +//k11VertexPosOffset9x will be used like that: +// mad oPos.xy, v0.w, c63, v0 +// mov oPos.zw, v0 + +#if DEBUG_D3D11_COMPARE_WITH_HLSL +static const char* kD3D11VertexPrefix = + "cbuffer UnityFFVertex {\n" + " float4x4 ff_matrix_mvp;\n" // 0 + " float4x4 ff_matrix_mv;\n" // 4 + " float4 ff_vec_color;\n" // 8 + " float4 ff_vec_ambient;\n" // 9 + " float4 ff_light_color[8];\n" // 10 + " float4 ff_light_pos[8];\n" // 18 + " float4 ff_light_atten[8];\n" // 26 + " float4 ff_light_spot[8];\n" // 34 + " float4 ff_mat_diffuse;\n" // 42 + " float4 ff_mat_ambient;\n" // 43 + " float4 ff_mat_spec;\n" // 44 + " float4 ff_mat_emission;\n" // 45 + " float4x4 ff_matrix_tex[4];\n" // 46 + " float4 ff_fog;\n" // 62 + "};\n"; // 62 +#endif // #if DEBUG_D3D11_COMPARE_WITH_HLSL + + +enum { + k11PixelColors = 0, + k11PixelAlphaRef = 8, + k11PixelFog = 9, + k11PixelSize = 10 +}; +#if DEBUG_D3D11_COMPARE_WITH_HLSL +static const char* kD3D11PixelPrefix = +"cbuffer UnityFFPixel {\n" +" float4 ff_vec_colors[8];\n" // 0 +" float ff_alpha_ref;\n" // 8 +" float4 ff_fog;\n" // 9 +"};\n" +"float4 main (\n "; +#endif // # if DEBUG_D3D11_COMPARE_WITH_HLSL + + +static void* BuildShaderD3D11 (DXBCBuilder* builder, size_t& outSize) +{ + Assert(builder); + + void* dxbc = dxb_build (builder, outSize); + Assert(dxbc); + dxb_destroy (builder); + + #if DEBUG_D3D11_FF_SHADERS + if (HasD3D11Compiler() && s_Compiler.disassembleFunc) + { + ID3D10Blob* disasm = NULL; + HRESULT hr = s_Compiler.disassembleFunc (dxbc, outSize, D3D_DISASM_ENABLE_DEFAULT_VALUE_PRINTS, NULL, &disasm); + if (SUCCEEDED(hr) && disasm) + { + printf_console ("disasm dxbc:\n%s\n\n", disasm->GetBufferPointer()); + } + SAFE_RELEASE(disasm); + } + #endif + + return dxbc; +} + + +// --- VERTEX program ---------------------------------------------------------------------------- + + +static void EmitMatrixMul(DXBCBuilderStream& bld, int cbIndex, char srcType, int srcIndex, char dstType, int dstIndex, int tmpIndex, bool wAlways1) +{ + bld.op(kSM4Op_MUL).reg('r',tmpIndex).swz(srcType,srcIndex,kSM4SwzRepY).swz('c',cbIndex+1); + bld.op(kSM4Op_MAD).reg('r',tmpIndex).swz('c',cbIndex+0).swz(srcType,srcIndex,kSM4SwzRepX).swz('r',tmpIndex); + bld.op(kSM4Op_MAD).reg('r',tmpIndex).swz('c',cbIndex+2).swz(srcType,srcIndex,kSM4SwzRepZ).swz('r',tmpIndex); + if (!wAlways1) + bld.op(kSM4Op_MAD).reg(dstType,dstIndex).swz('c',cbIndex+3).swz(srcType,srcIndex,kSM4SwzRepW).swz('r',tmpIndex); + else + bld.op(kSM4Op_ADD).reg(dstType,dstIndex).swz('c',cbIndex+3).swz('r',tmpIndex); +} + + +void* BuildVertexShaderD3D11 (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, BuiltinShaderParamIndices& matrices, size_t& outSize) +{ + ShaderLab::FastPropertyName cbName; cbName.SetName(kD3D11VertexCB); + GetD3D11ConstantBuffers(GetRealGfxDevice()).SetCBInfo (cbName.index, k11VertexSize*16); + params.m_CBID = cbName.index; params.m_CBSize = k11VertexSize*16; + + DXBCBuilder* builder = dxb_create(4, 0, kSM4Shader_Vertex); + DXBCBuilderStream bld(builder); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string helpers, inputs, outputs, code; + #endif + + bool hasLights = (state.lightingEnabled && state.lightCount > 0); + + bool eyePositionRequired = + hasLights || + (state.fogMode != kFogDisabled); + bool eyeNormalRequired = hasLights; + bool viewDirRequired = hasLights && state.specularEnabled; + bool eyeReflRequired = false; + { + UInt64 texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + UInt32 uvSource = texSources & 0xF; + if (uvSource == kTexSourceEyeLinear) + eyePositionRequired = true; + if (uvSource == kTexSourceCubeNormal) + eyeNormalRequired = true; + if (uvSource == kTexSourceCubeReflect || uvSource == kTexSourceSphereMap) + eyeReflRequired = viewDirRequired = eyePositionRequired = eyeNormalRequired = true; + texSources >>= 4; + } + } + if (eyePositionRequired || eyeNormalRequired || eyeReflRequired) + { + matrices.mat[kShaderInstanceMatMV].gpuIndex = k11VertexMV*16; + matrices.mat[kShaderInstanceMatMV].rows = 4; + matrices.mat[kShaderInstanceMatMV].cols = 4; + matrices.mat[kShaderInstanceMatMV].cbID = params.m_CBID; + } + + dxb_dcl_cb(builder, 0, k11VertexSize); + + int inputRegCounter = 0, outputRegCounter = 0, tempRegCounter = 0; + int inPosReg = 0, inColorReg = 0, inNormalReg = 0; + int inUVReg[8] = {0}; + int outColor0Reg = 0, outColor1Reg = 0, outPosReg = 0; + int outUVReg[8] = {0}; + int eyePosReg = 0, eyeNormalReg = 0, viewDirReg = 0, eyeReflReg = 0, lcolorReg = 0, specColorReg = 0; + + dxb_dcl_input(builder, "POSITION", 0, inPosReg = inputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float4 vertex : POSITION"); + #endif + + // color = Vertex or uniform color + char inColorType; + if (state.useUniformInsteadOfVertexColor) + { + params.AddVectorParam (k11VertexColor*16, 4, kShaderVecFFColor); + inColorType = 'c'; + inColorReg = k11VertexColor; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float4 color = ff_vec_color;\n"; + #endif + } + else + { + inColorType = 'v'; + dxb_dcl_input(builder, "COLOR", 0, inColorReg = inputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float4 vertexColor : COLOR"); + code += "float4 color = vertexColor;\n"; + #endif + } + + // eyePos = eye position + if (eyePositionRequired) + { + eyePosReg = tempRegCounter++; + EmitMatrixMul (bld, k11VertexMV, 'v',inPosReg, 'r',eyePosReg, eyePosReg, false); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 eyePos = mul (ff_matrix_mv, vertex).xyz;\n"; + #endif + } + + // eyeNormal = normalize(normalMatrix * normal) + if (eyeNormalRequired) + { + dxb_dcl_input(builder, "NORMAL", 0, inNormalReg = inputRegCounter++, 0x7); + eyeNormalReg = tempRegCounter++; + // mul + bld.op(kSM4Op_MUL).reg('r',eyeNormalReg,7).swz('v',inNormalReg,kSM4SwzRepY).swz('c',k11VertexMV+1); + bld.op(kSM4Op_MAD).reg('r',eyeNormalReg,7).swz('c',k11VertexMV+0).swz('v',inNormalReg,kSM4SwzRepX).swz('r',eyeNormalReg); + bld.op(kSM4Op_MAD).reg('r',eyeNormalReg,7).swz('c',k11VertexMV+2).swz('v',inNormalReg,kSM4SwzRepZ).swz('r',eyeNormalReg); + // normalize + bld.op(kSM4Op_DP3).reg('r',eyeNormalReg,8).swz('r',eyeNormalReg,kSM4SwzNone).swz('r',eyeNormalReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',eyeNormalReg,8).swz('r',eyeNormalReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',eyeNormalReg,7).swz('r',eyeNormalReg,kSM4SwzRepW).swz('r',eyeNormalReg,kSM4SwzXYZX); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float3 normal : NORMAL"); + code += "float3 eyeNormal = normalize (mul ((float3x3)ff_matrix_mv, normal).xyz);\n"; //@TODO: proper normal matrix + #endif + } + + // view dir + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 viewDir = 0.0;"; + #endif + if (viewDirRequired) + { + // viewDir = normalized vertex-to-eye + viewDirReg = tempRegCounter++; + // -normalize + bld.op(kSM4Op_DP3).reg('r',viewDirReg,8).swz('r',eyePosReg,kSM4SwzNone).swz('r',eyePosReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',viewDirReg,8).swz('r',viewDirReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',viewDirReg,7).swz('r',viewDirReg,kSM4SwzRepW).swz('r',eyePosReg,kSM4SwzXYZX,true); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "viewDir = -normalize (eyePos);\n"; + #endif + } + + // eyeRefl + if (eyeReflRequired) + { + DebugAssert (viewDirRequired); + // eyeRefl = reflection vector, 2*dot(V,N)*N-V + eyeReflReg = tempRegCounter++; + bld.op(kSM4Op_DP3).reg('r',eyeReflReg,8).swz('r',viewDirReg,kSM4SwzNone).swz('r',eyeNormalReg,kSM4SwzNone); + bld.op(kSM4Op_ADD).reg('r',eyeReflReg,8).swz('r',eyeReflReg,kSM4SwzRepW).swz('r',eyeReflReg,kSM4SwzRepW); + bld.op(kSM4Op_MAD).reg('r',eyeReflReg,7).swz('r',eyeReflReg,kSM4SwzRepW).swz('r',eyeNormalReg,kSM4SwzXYZX).swz('r',viewDirReg,kSM4SwzXYZX,true); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 eyeRefl = 2.0f * dot (viewDir, eyeNormal) * eyeNormal - viewDir;\n"; + #endif + } + + // Lighting + if (state.lightingEnabled) + { + char ambientType, diffuseType, emissionType; + int ambientReg, diffuseReg, emissionReg; + if (state.colorMaterial==kColorMatAmbientAndDiffuse) + { + ambientType = diffuseType = inColorType; + ambientReg = diffuseReg = inColorReg; + } + else + { + ambientType = diffuseType = 'c'; + ambientReg = k11VertexMatAmbient; + diffuseReg = k11VertexMatDiffuse; + } + if (state.colorMaterial==kColorMatEmission) + { + emissionType = inColorType; + emissionReg = inColorReg; + } + else + { + emissionType = 'c'; + emissionReg = k11VertexMatEmission; + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string ambientColor = (state.colorMaterial==kColorMatAmbientAndDiffuse) ? "color" : "ff_mat_ambient"; + std::string diffuseColor = (state.colorMaterial==kColorMatAmbientAndDiffuse) ? "color" : "ff_mat_diffuse"; + std::string emissionColor = (state.colorMaterial==kColorMatEmission) ? "color" : "ff_mat_emission"; + #endif + + params.AddVectorParam (k11VertexAmbient*16, 4, kShaderVecLightModelAmbient); + params.AddVectorParam (k11VertexMatAmbient*16, 4, kShaderVecFFMatAmbient); + params.AddVectorParam (k11VertexMatDiffuse*16, 4, kShaderVecFFMatDiffuse); + params.AddVectorParam (k11VertexMatSpec*16, 4, kShaderVecFFMatSpecular); + params.AddVectorParam (k11VertexMatEmission*16, 4, kShaderVecFFMatEmission); + + lcolorReg = tempRegCounter++; + bld.op(kSM4Op_MAD).reg('r',lcolorReg,7).swz(ambientType,ambientReg,kSM4SwzXYZX).swz('c',k11VertexAmbient,kSM4SwzXYZX).swz(emissionType,emissionReg,kSM4SwzXYZX); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float3 lcolor = " + emissionColor + ".rgb + " + ambientColor + ".rgb * ff_vec_ambient.rgb;\n"; + code += "float3 specColor = 0.0;\n"; + if (state.lightCount > 0) + { + helpers += "float3 computeLighting (int idx, float3 dirToLight, float3 eyeNormal, float3 viewDir, float4 diffuseColor, float atten, inout float3 specColor) {\n"; + helpers += " float NdotL = max(dot(eyeNormal, dirToLight), 0.0);\n"; + helpers += " float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb;\n"; + if (state.specularEnabled) + { + helpers += " if (NdotL > 0.0) {\n"; + helpers += " float3 h = normalize(dirToLight + viewDir);\n"; + helpers += " float HdotN = max(dot(eyeNormal, h), 0.0);\n"; + helpers += " float sp = saturate(pow(HdotN, ff_mat_spec.w));\n"; + helpers += " specColor += atten * sp * ff_light_color[idx].rgb;\n"; + helpers += " }\n"; + } + helpers += " return color * atten;\n"; + helpers += "}\n"; + + helpers += "float3 computeSpotLight(int idx, float3 eyePosition, float3 eyeNormal, float3 viewDir, float4 diffuseColor, inout float3 specColor) {\n"; + helpers += " float3 dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w;\n"; + helpers += " float distSqr = dot(dirToLight, dirToLight);\n"; + helpers += " float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr);\n"; + helpers += " if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0;\n"; // set to 0 if outside of range + helpers += " dirToLight *= rsqrt(distSqr);\n"; + + helpers += " float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0);\n"; + helpers += " float spotAtt = (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y;\n"; + helpers += " spotAtt = saturate(spotAtt);\n"; + helpers += " return min (computeLighting (idx, dirToLight, eyeNormal, viewDir, diffuseColor, att*spotAtt, specColor), 1.0);\n"; + helpers += "}\n"; + } + #endif // DEBUG_D3D11_COMPARE_WITH_HLSL + + if (state.specularEnabled) + { + specColorReg = tempRegCounter++; + bld.op(kSM4Op_MOV).reg('r',specColorReg,7).float4(0,0,0,0); + } + + for (int i = 0; i < state.lightCount; ++i) + { + params.AddVectorParam ((k11VertexLightPos+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Position+i)); + params.AddVectorParam ((k11VertexLightAtten+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Atten+i)); + params.AddVectorParam ((k11VertexLightColor+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0Diffuse+i)); + params.AddVectorParam ((k11VertexLightSpot+i)*16, 4, BuiltinShaderVectorParam(kShaderVecLight0SpotDirection+i)); + + Assert(eyePositionRequired); + Assert(eyeNormalRequired); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "lcolor += computeSpotLight(" + IntToString(i) + ", eyePos, eyeNormal, viewDir, " + diffuseColor + ", specColor);\n"; + #endif + + int ldirReg = tempRegCounter; + int miscReg = tempRegCounter+1; + int diffReg = tempRegCounter+2; + + // + // attenuation + + // float3 dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w; + // float distSqr = dot(dirToLight, dirToLight); + // float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr); + // if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0; + // dirToLight *= rsqrt(distSqr); + // float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0); + // float spotAtt = (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y; + // spotAtt = saturate(spotAtt); + + // dirToLight = ff_light_pos[idx].xyz - eyePosition * ff_light_pos[idx].w + bld.op(kSM4Op_MAD).reg('r',ldirReg,7).swz('r',eyePosReg,kSM4SwzXYZX,true).swz('c',k11VertexLightPos+i,kSM4SwzRepW).swz('c',k11VertexLightPos+i,kSM4SwzXYZX); + // normalize, distSqr in miscReg.w + bld.op(kSM4Op_DP3).reg('r',miscReg,8).swz('r',ldirReg,kSM4SwzNone).swz('r',ldirReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',ldirReg,8).swz('r',miscReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',ldirReg,7).swz('r',ldirReg,kSM4SwzRepW).swz('r',ldirReg,kSM4SwzXYZX); + + // miscReg.z = float rho = max(dot(dirToLight, ff_light_spot[idx].xyz), 0.0) + bld.op(kSM4Op_DP3).reg('r',miscReg,4).swz('r',ldirReg,kSM4SwzNone).swz('c',k11VertexLightSpot+i,kSM4SwzNone); + bld.op(kSM4Op_MAX).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).float1(0.0f); + // miscReg.z = spotAtt = saturate ( (rho - ff_light_atten[idx].x) * ff_light_atten[idx].y ) + bld.op(kSM4Op_ADD).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).swz('c',k11VertexLightAtten+i,kSM4SwzRepX,true); + bld.op_sat(kSM4Op_MUL,miscReg).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).swz('c',k11VertexLightAtten+i,kSM4SwzRepY); + + // miscReg.y = float att = 1.0 / (1.0 + ff_light_atten[idx].z * distSqr) + bld.op(kSM4Op_MAD).reg('r',miscReg,2).swz('c',k11VertexLightAtten+i,kSM4SwzRepZ).swz('r',miscReg,kSM4SwzRepW).float1(1.0f); + bld.noAutoSM2(); + bld.op(kSM4Op_DIV).reg('r',miscReg,2).float4(1,1,1,1).swz('r',miscReg,kSM4SwzRepY); + bld.op2(kSM2Op_RCP).reg2('r',miscReg,2).swz2('r',miscReg,kSM4SwzRepY); + bld.autoSM2(); + + // miscReg.y = att * spotAtt + bld.op(kSM4Op_MUL).reg('r',miscReg,2).swz('r',miscReg,kSM4SwzRepY).swz('r',miscReg,kSM4SwzRepZ); + // if (ff_light_pos[idx].w != 0 && distSqr > ff_light_atten[idx].w) att = 0.0 + bld.noAutoSM2(); + bld.op(kSM4Op_LT).reg('r',miscReg,1).swz('c',k11VertexLightAtten+i,kSM4SwzRepW).swz('r',miscReg,kSM4SwzRepW); + bld.op(kSM4Op_NE).reg('r',miscReg,4).swz('c',k11VertexLightPos+i,kSM4SwzRepW).float1(0.0); + bld.op(kSM4Op_AND).reg('r',miscReg,1).swz('r',miscReg,kSM4SwzRepX).swz('r',miscReg,kSM4SwzRepZ); + bld.op(kSM4Op_MOVC).reg('r',miscReg,2).swz('r',miscReg,kSM4SwzRepX).float1(0.0).swz('r',miscReg,kSM4SwzRepY); + //SM2 + bld.op2(kSM2Op_SLT).reg2('r',miscReg,1).swz2('c',k11VertexLightAtten+i,kSM4SwzRepW).swz2('r',miscReg,kSM4SwzRepW); + bld.op2(kSM2Op_MUL).reg2('r',miscReg,4).swz2('c',k11VertexLightPos+i,kSM4SwzRepW).swz2('c',k11VertexLightPos+i,kSM4SwzRepW); + bld.op2(kSM2Op_SLT).reg2('r',miscReg,4).swz2('r',miscReg,kSM4SwzRepZ,true).swz2('r',miscReg,kSM4SwzRepZ); + bld.op2(kSM2Op_MUL).reg2('r',miscReg,1).swz2('r',miscReg,kSM4SwzRepX).swz2('r',miscReg,kSM4SwzRepZ); + bld.op2(kSM2Op_MAD).reg2('r',miscReg,2).swz2('r',miscReg,kSM4SwzRepX).swz2('r',miscReg,kSM4SwzRepY,true).swz2('r',miscReg,kSM4SwzRepY); + bld.autoSM2(); + + // + // diffuse + + // float NdotL = max(dot(eyeNormal, dirToLight), 0.0); + // float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb; + // lcolor += color * atten + + // miscReg.z = float NdotL = max(dot(eyeNormal, dirToLight), 0.0) + bld.op(kSM4Op_DP3).reg('r',miscReg,4).swz('r',eyeNormalReg,kSM4SwzNone).swz('r',ldirReg,kSM4SwzNone); + bld.op(kSM4Op_MAX).reg('r',miscReg,4).swz('r',miscReg,kSM4SwzRepZ).float1(0.0f); + // diffReg.xyz = float3 color = NdotL * diffuseColor.rgb * ff_light_color[idx].rgb + bld.op(kSM4Op_MUL).reg('r',diffReg,7).swz('r',miscReg,kSM4SwzRepZ).swz(diffuseType,diffuseReg,kSM4SwzXYZX); + bld.op(kSM4Op_MUL).reg('r',diffReg,7).swz('r',diffReg,kSM4SwzXYZX).swz('c',k11VertexLightColor+i,kSM4SwzXYZX); + // diffReg.xyz = saturate(color*atten, 1) + bld.op_sat(kSM4Op_MUL,diffReg).reg('r',diffReg,7).swz('r',diffReg,kSM4SwzXYZX).swz('r',miscReg,kSM4SwzRepY); + // lcolor += diffReg + bld.op(kSM4Op_ADD).reg('r',lcolorReg,7).swz('r',lcolorReg,kSM4SwzXYZX).swz('r',diffReg,kSM4SwzXYZX); + + // + // specular + + if (state.specularEnabled) + { + // if (NdotL > 0.0) { + // float3 h = normalize(dirToLight + viewDir); + // float HdotN = max(dot(eyeNormal, h), 0.0); + // float sp = saturate(pow(HdotN, ff_mat_spec.w)); + // specColor += atten * sp * ff_light_color[idx].rgb; + // } + + // ldirReg.xyz = h = normalize(dirToLight + viewDir) + bld.op(kSM4Op_ADD).reg('r',ldirReg,7).swz('r',ldirReg,kSM4SwzXYZX).swz('r',viewDirReg,kSM4SwzXYZX); + bld.op(kSM4Op_DP3).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzNone).swz('r',ldirReg,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',ldirReg,7).swz('r',ldirReg,kSM4SwzXYZX).swz('r',ldirReg,kSM4SwzRepW); + // ldirReg.w = HdotN = max(dot(eyeNormal,h),0) + bld.op(kSM4Op_DP3).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzNone).swz('r',eyeNormalReg,kSM4SwzNone); + bld.op(kSM4Op_MAX).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).float1(0.0f); + // float sp = saturate(pow(HdotN, ff_mat_spec.w)) + bld.op(kSM4Op_LOG).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).swz('c',k11VertexMatSpec,kSM4SwzRepW); + bld.op(kSM4Op_EXP).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW); + bld.op(kSM4Op_MIN).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).float1(1.0f); + // atten * sp * ff_light_color[idx].rgb + bld.op(kSM4Op_MUL).reg('r',ldirReg,8).swz('r',ldirReg,kSM4SwzRepW).swz('r',miscReg,kSM4SwzRepY); + bld.op(kSM4Op_MUL).reg('r',diffReg,7).swz('r',ldirReg,kSM4SwzRepW).swz('c',k11VertexLightColor+i,kSM4SwzXYZX); + // nuke specular if NdotL <= 0 + bld.op(kSM4Op_LT).reg('r',miscReg,1).float1(0.0).swz('r',miscReg,kSM4SwzRepZ); + bld.noAutoSM2(); + bld.op(kSM4Op_AND).reg('r',diffReg,7).swz('r',diffReg,kSM4SwzXYZX).swz('r',miscReg,kSM4SwzRepX); + bld.op2(kSM2Op_MUL).reg2('r',diffReg,7).swz2('r',diffReg,kSM4SwzXYZX).swz2('r',miscReg,kSM4SwzRepX); + bld.autoSM2(); + // specColor += computed spec color + bld.op(kSM4Op_ADD).reg('r',specColorReg,7).swz('r',specColorReg,kSM4SwzXYZX).swz('r',diffReg,kSM4SwzXYZX); + } + } + + bld.op(kSM4Op_MOV).reg('r',lcolorReg,8).swz(diffuseType,diffuseReg,kSM4SwzRepW); + inColorReg = lcolorReg; + inColorType = 'r'; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "color.rgb = lcolor.rgb;\n"; + code += "color.a = " + diffuseColor + ".a;\n"; + #endif + + if (state.specularEnabled) + { + bld.op(kSM4Op_MUL).reg('r',specColorReg,7).swz('r',specColorReg,kSM4SwzXYZX).swz('c',k11VertexMatSpec,kSM4SwzXYZX); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "specColor *= ff_mat_spec.rgb;\n"; + #endif + } + } + + // Output final color + dxb_dcl_output(builder, "COLOR", 0, outColor0Reg = outputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float4 ocolor : COLOR0"); + #endif + + bld.op_sat(kSM4Op_MOV,tempRegCounter).reg('o',outColor0Reg).swz(inColorType,inColorReg); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ocolor = saturate(color);\n"; + #endif + + if (state.lightingEnabled && state.specularEnabled) + { + dxb_dcl_output(builder, "COLOR", 1, outColor1Reg = outputRegCounter++, 0x7); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float3 ospec : COLOR1"); + #endif + + bld.op_sat(kSM4Op_MOV,tempRegCounter).reg('o',outColor1Reg,7).swz('r',specColorReg,kSM4SwzXYZX); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ospec = saturate(specColor);\n"; + #endif + } + + // we don't need temporary registers from lighting calculations anymore after this point + if (state.lightingEnabled) + --tempRegCounter; + + + // Pass & transform texture coordinates + UInt32 gotInputs = 0; + UInt32 gotOutputs = 0; + UInt64 texSources = state.texUnitSources; + for (int i = 0; i < state.texUnitCount; i++) + { + matrices.mat[kShaderInstanceMatTexture0+i].gpuIndex = (k11VertexTex+i*4)*16; + matrices.mat[kShaderInstanceMatTexture0+i].rows = 4; + matrices.mat[kShaderInstanceMatTexture0+i].cols = 4; + matrices.mat[kShaderInstanceMatTexture0+i].cbID = params.m_CBID; + + std::string iname = IntToString(i); + dxb_dcl_output(builder, "TEXCOORD", i, outUVReg[i] = outputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, ("out float4 ouv" + iname + " : TEXCOORD" + iname).c_str()); + #endif + + UInt32 uvSource = texSources & 0xF; + if (uvSource >= kTexSourceUV0 && uvSource <= kTexSourceUV7) + { + unsigned uv = uvSource-kTexSourceUV0; + std::string uvStr = IntToString(uv); + if (!(gotInputs & (1<<uv))) + { + dxb_dcl_input(builder, "TEXCOORD", uv, inUVReg[uv] = inputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, ("float4 uv"+uvStr+" : TEXCOORD"+uvStr).c_str()); + #endif + gotInputs |= (1<<uv); + } + EmitMatrixMul (bld, k11VertexTex+4*i, 'v',inUVReg[uv], 'o',outUVReg[i], tempRegCounter, false); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname + "], uv"+uvStr+");\n"; + #endif + } + else if (uvSource == kTexSourceSphereMap) + { + // m = 2*sqrt(Rx*Rx + Ry*Ry + (Rz+1)*(Rz+1)) + // SPHR = Rx/m + 0.5, Ry/m + 0.5 + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(\n"; + code += " eyeRefl.xy / (2.0*sqrt(eyeRefl.x*eyeRefl.x + eyeRefl.y*eyeRefl.y + (eyeRefl.z+1)*(eyeRefl.z+1))) + 0.5,\n"; + code += " 0,1));\n"; + #endif + + // HLSL generates code like: + // dp2 r0.w, r0.xyxx, r0.xyxx + // add r0.z, r0.z, l(1.0) + // mad r0.z, r0.z, r0.z, r0.w + // sqrt r0.z, r0.z + // add r0.z, r0.z, r0.z + // div r0.xy, r0.xyxx, r0.zzzz + // add r0.xy, r0.xyxx, l(0.5, 0.5, 0.0, 0.0) +#if 0 + bld.op(kSM4Op_DP2).reg('r',tempRegCounter,8).swz('r',eyeReflReg,kSM4SwzXYXX).swz('r',eyeReflReg,kSM4SwzXYXX); + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,4).swz('r',eyeReflReg,kSM4SwzRepZ).float1(1.0); + bld.op(kSM4Op_MAD).reg('r',tempRegCounter,4).swz('r',tempRegCounter,kSM4SwzRepZ).swz('r',tempRegCounter,kSM4SwzRepZ).swz('r',tempRegCounter,kSM4SwzRepW); + bld.op(kSM4Op_SQRT).reg('r',tempRegCounter,4).swz('r',tempRegCounter,kSM4SwzRepZ); + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,4).swz('r',tempRegCounter,kSM4SwzRepZ).swz('r',tempRegCounter,kSM4SwzRepZ); + bld.op(kSM4Op_DIV).reg('r',tempRegCounter,3).swz('r',eyeReflReg,kSM4SwzXYXX).swz('r',tempRegCounter,kSM4SwzRepZ); + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,3).swz('r',tempRegCounter,kSM4SwzXYXX).float4(0.5f,0.5f,0,0); +#else + //SM2 compatible + bld.op(kSM4Op_ADD).reg('r',tempRegCounter,7).swz('r',eyeReflReg,kSM4SwzXYZX).float4(0.0f,0.0f,1.0f,0.0f); + bld.op(kSM4Op_DP3).reg('r',tempRegCounter,8).swz('r',tempRegCounter,kSM4SwzNone).swz('r',tempRegCounter,kSM4SwzNone); + bld.op(kSM4Op_RSQ).reg('r',tempRegCounter,8).swz('r',tempRegCounter,kSM4SwzRepW); + bld.op(kSM4Op_MUL).reg('r',tempRegCounter,8).swz('r',tempRegCounter,kSM4SwzRepW).float4(0.5f,0.5f,0.5f,0.5f); + bld.op(kSM4Op_MAD).reg('r',tempRegCounter,3).swz('r',eyeReflReg,kSM4SwzXYXX).swz('r',tempRegCounter,kSM4SwzRepW).float4(0.5f,0.5f,0.5f,0.5f); +#endif + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',tempRegCounter, 'o',outUVReg[i], tempRegCounter+1, true); + } + else if (uvSource == kTexSourceObject) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'v',inPosReg, 'o',outUVReg[i], tempRegCounter, false); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], vertex);\n"; + #endif + } + else if (uvSource == kTexSourceEyeLinear) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',eyePosReg, 'o',outUVReg[i], tempRegCounter, true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(eyePos,1.0));\n"; + #endif + } + else if (uvSource == kTexSourceCubeNormal) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',eyeNormalReg, 'o',outUVReg[i], tempRegCounter, true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(eyeNormal,1.0));\n"; + #endif + } + else if (uvSource == kTexSourceCubeReflect) + { + EmitMatrixMul (bld, k11VertexTex+4*i, 'r',eyeReflReg, 'o',outUVReg[i], tempRegCounter, true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = mul(ff_matrix_tex["+iname +"], float4(eyeRefl,1.0));\n"; + #endif + } + else + { + AssertString("Unknown texgen mode"); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ouv"+iname + " = 0.5;\n"; + #endif + } + texSources >>= 4; + } + + // fog if we have a spare varying + if (state.fogMode != kFogDisabled && outputRegCounter < 8) + { + Assert(eyePositionRequired); + int outFogReg; + dxb_dcl_output(builder, "FOG", 0, outFogReg = outputRegCounter++, 0x1); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float ofog : FOG0"); + #endif + + params.AddVectorParam (k11VertexFog*16, 4, kShaderVecFFFogParams); + + int fogReg = tempRegCounter++; + + // fogCoord = length(eyePosition.xyz), for radial fog + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float fogCoord = length(eyePos.xyz);\n"; + #endif + + bld.op(kSM4Op_DP3).reg('r',fogReg,1).swz('r',eyePosReg,kSM4SwzNone).swz('r',eyePosReg,kSM4SwzNone); +#if 0 + bld.op(kSM4Op_SQRT).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX); +#else + //SM2 compatible + bld.op(kSM4Op_RSQ).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX); + bld.op(kSM4Op_RCP).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX); +#endif + if (state.fogMode == kFogLinear) + { + // fogParams.z * fogCoord + fogParams.w + bld.op_sat(kSM4Op_MAD,tempRegCounter).reg('o',outFogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('c',k11VertexFog,kSM4SwzRepZ).swz('c',k11VertexFog,kSM4SwzRepW); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ofog = saturate(fogCoord * ff_fog.z + ff_fog.w);\n"; + #endif + } + else if (state.fogMode == kFogExp) + { + // fogArg = fogParams.y * fogCoord + // exp2(-fogArg) + bld.op(kSM4Op_MUL).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('c',k11VertexFog,kSM4SwzRepY); + bld.op_sat(kSM4Op_EXP,tempRegCounter).reg('o',outFogReg,1).swz('r',fogReg,kSM4SwzRepX,true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "ofog = saturate(exp2(-(fogCoord * ff_fog.y)));\n"; + #endif + } + else if (state.fogMode == kFogExp2) + { + // fogArg = fogParams.y * fogCoord + // exp2(-fogArg*fogArg) + bld.op(kSM4Op_MUL).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('c',k11VertexFog,kSM4SwzRepY); + bld.op(kSM4Op_MUL).reg('r',fogReg,1).swz('r',fogReg,kSM4SwzRepX).swz('r',fogReg,kSM4SwzRepX); + bld.op_sat(kSM4Op_EXP,tempRegCounter).reg('o',outFogReg,1).swz('r',fogReg,kSM4SwzRepX,true); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "fogCoord = fogCoord * ff_fog.y;\n"; + code += "ofog = saturate(exp2(-fogCoord * fogCoord));\n"; + #endif + } + --tempRegCounter; + } + + dxb_dcl_output(builder, "SV_POSITION", 0, outPosReg = outputRegCounter++); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (outputs, "out float4 overtex : SV_POSITION"); + #endif + + // Vertex transformation + matrices.mat[kShaderInstanceMatMVP].gpuIndex = k11VertexMVP*16; + matrices.mat[kShaderInstanceMatMVP].rows = 4; + matrices.mat[kShaderInstanceMatMVP].cols = 4; + matrices.mat[kShaderInstanceMatMVP].cbID = params.m_CBID; + bld.op(kSM4Op_MUL).reg('r',0).swz('v',inPosReg,kSM4SwzRepY).swz('c',k11VertexMVP+1); + bld.op(kSM4Op_MAD).reg('r',0).swz('c',k11VertexMVP+0).swz('v',inPosReg,kSM4SwzRepX).swz('r',0); + bld.op(kSM4Op_MAD).reg('r',0).swz('c',k11VertexMVP+2).swz('v',inPosReg,kSM4SwzRepZ).swz('r',0); + bld.op(kSM4Op_MAD).reg('r',0).swz('c',k11VertexMVP+3).swz('v',inPosReg,kSM4SwzRepW).swz('r',0); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "overtex = mul (ff_matrix_mvp, vertex);\n"; + #endif + + //correct output pos with Vertex Shader position offset + //mad oPos.xy, v0.w, c63, v0 + bld.op2(kSM2Op_MAD).reg2('o',outPosReg,3).swz2('r',0,kSM4SwzRepW).swz2('c',k11VertexPosOffset9x).swz2('r',0); + //mov oPos.zw, v0 + bld.op2(kSM2Op_MOV).reg2('o',outPosReg,12).swz2('r',0); + + //copy output pos for sm40 + bld.noAutoSM2(); + bld.op(kSM4Op_MOV).reg('o',outPosReg).swz('r',0); + bld.autoSM2(); + + bld.op(kSM4Op_RET); + + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string src = + kD3D11VertexPrefix + + helpers + '\n' + + "void main (\n " + + inputs + ",\n " + + outputs + ") {\n" + + code + "\n}"; + printf_console ("d3d11 FF VS HLSL:\n%s\n", src.c_str()); + DebugCompileHLSLShaderD3D11 (src, true); + #endif + + + void* blob = BuildShaderD3D11 (builder, outSize); + return blob; +} + + +// --- FRAGMENT program ---------------------------------------------------------------------------- + +enum CombinerWriteMask { kCombWriteRGBA, kCombWriteRGB, kCombWriteA }; + +static bool EmitCombinerMath11 ( + int stage, + UInt32 combiner, + CombinerWriteMask writeMaskMode, + int texUnitCount, + DXBCBuilderStream& bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , std::string& code + #endif +) +{ + Assert (texUnitCount < 10 && stage < 10); + + combiner::Source sources[3]; + combiner::Operand operands[3]; + combiner::Operation op; + int scale; + combiner::DecodeTextureCombinerDescriptor (combiner, op, sources, operands, scale, true); + + // dot3 and dot3rgba write into RGBA; alpha combiner is always ignored + if (op == combiner::kOpDot3RGB || op == combiner::kOpDot3RGBA) + { + if (writeMaskMode == kCombWriteA) + return false; + writeMaskMode = kCombWriteRGBA; + } + + unsigned tmpIdx = 1; + + bool usedConstant = false; + char regFile[3]; + unsigned regIdx[3]; + unsigned regSrcAlphaSwz[3]; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string reg[3]; + #endif + for (int r = 0; r < 3; ++r) + { + combiner::Source source = sources[r]; + regSrcAlphaSwz[r] = kSM4SwzRepW; + if (stage == 0 && source == combiner::kSrcPrevious) + source = combiner::kSrcPrimaryColor; // first stage, "previous" the same as "primary" + switch (source) + { + case combiner::kSrcPrimaryColor: + regFile[r] = 'v'; regIdx[r] = 0; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = "icolor"; + #endif + break; + case combiner::kSrcPrevious: + regFile[r] = 'r'; regIdx[r] = 0; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = "col"; + #endif + break; + case combiner::kSrcTexture: + regFile[r] = 'r'; regIdx[r] = 1; tmpIdx = 2; + regSrcAlphaSwz[r] = kSM4SwzRepW; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = "tex"; + #endif + break; + case combiner::kSrcConstant: + usedConstant |= true; regFile[r] = 'c'; regIdx[r] = stage; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + reg[r] = std::string("ff_vec_colors[") + char('0'+stage) + ']'; + #endif + break; + default: + AssertString("unknown source"); //reg[r] = "foo"; + } + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + const char* writeMask = ""; + #endif + unsigned writeMaskBin = 0xF; // rgba + if (writeMaskMode == kCombWriteRGB) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + writeMask = ".rgb"; + #endif + writeMaskBin = 0x7; // rgb + } + else if (writeMaskMode == kCombWriteA) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + writeMask = ".a"; + #endif + writeMaskBin = 0x8; // a + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + const char* regSwizzle[3]; + #endif + unsigned regSwizzleBin[3]; + for (int r = 0; r < 3; ++r) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + regSwizzle[r] = ""; + #endif + regSwizzleBin[r] = kSM4SwzNone; + // 1-x: into tmpN and use that + if (operands[r] == combiner::kOperOneMinusSrcColor || operands[r] == combiner::kOperOneMinusSrcAlpha) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("tmp")+char('0'+r)+" = 1.0 - " + reg[r]+regSwizzle[r] + ";\n"; + reg[r] = std::string("tmp")+char('0'+r); + #endif + bld.op(kSM4Op_ADD).reg('r', tmpIdx, writeMaskBin).swz(regFile[r], regIdx[r], regSwizzleBin[r], true).float1(1.0f); + regFile[r] = 'r'; + regIdx[r] = tmpIdx; + ++tmpIdx; + } + // replicate alpha swizzle? + if (operands[r] == combiner::kOperSrcAlpha || operands[r] == combiner::kOperOneMinusSrcAlpha) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + regSwizzle[r] = ".a"; + #endif + regSwizzleBin[r] = kSM4SwzRepW; + } + } + switch (op) + { + case combiner::kOpReplace: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + ";\n"; + #endif + bld.op(kSM4Op_MOV).reg('r', 0, writeMaskBin).swz(regFile[0], regIdx[0], regSwizzleBin[0]); + break; + case combiner::kOpModulate: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_MUL); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + break; + case combiner::kOpAdd: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " + " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + break; + case combiner::kOpAddSigned: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " + " + reg[1]+regSwizzle[1] + " - 0.5;\n"; + #endif + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(-.5f,-.5f,-.5f,-.5f); + break; + case combiner::kOpSubtract: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " - " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1], true); + break; + case combiner::kOpLerp: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = lerp (" + reg[1]+regSwizzle[1] + ", " + reg[0]+regSwizzle[0] + ", " + reg[2]+ ".a);\n"; + #endif + // tmp = r0-r1 + // res = tmp * r2 + r1 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1], true); + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', tmpIdx); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + ++tmpIdx; + break; + case combiner::kOpDot3RGB: + DebugAssert(writeMaskMode == kCombWriteRGBA); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col.rgb = 4.0 * dot ((") + reg[0]+regSwizzle[0] + ")-0.5, (" + reg[1]+regSwizzle[1] + ")-0.5);\n"; + code += std::string("col.a = ") + reg[0]+".a;\n"; + #endif + + // tmp+0 = r0-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp+1 = r1-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+1, writeMaskBin); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp0.rgb = dp4(tmp+0, tmp+1) + bld.op(kSM4Op_DP3); + bld.reg('r', 0, 0x7); + bld.swz('r', tmpIdx+0); + bld.swz('r', tmpIdx+1); + // tmp0.rgb *= 4 + bld.op(kSM4Op_MUL); + bld.reg('r', 0, 0x7); + bld.swz('r', 0); + bld.float4(4.0f,4.0f,4.0f,4.0f); + // tmp0.a = r0.a + bld.op(kSM4Op_MOV); + bld.reg('r', 0, 0x8); + bld.swz(regFile[0], regIdx[0], kSM4SwzRepW); + tmpIdx += 2; + break; + case combiner::kOpDot3RGBA: + DebugAssert(writeMaskMode == kCombWriteRGBA); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = 4.0 * dot ((" + reg[0]+regSwizzle[0] + ")-0.5, (" + reg[1]+regSwizzle[1] + ")-0.5);\n"; + #endif + // tmp+0 = r0-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp+1 = r1-0.5 + bld.op(kSM4Op_ADD); + bld.reg('r', tmpIdx+1, writeMaskBin); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.float4(-.5f,-.5f,-.5f,-.5f); + // tmp0 = dp4(tmp+0, tmp+1) + bld.op(kSM4Op_DP3); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', tmpIdx+0); + bld.swz('r', tmpIdx+1); + // tmp0 *= 4 + bld.op(kSM4Op_MUL); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(4.0f,4.0f,4.0f,4.0f); + tmpIdx += 2; + break; + case combiner::kOpMulAdd: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[2]+".a + " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + break; + case combiner::kOpMulSub: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[2]+".a - " + reg[1]+regSwizzle[1] + ";\n"; + #endif + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1], true); + break; + case combiner::kOpMulAddSigned: + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + " * " + reg[2]+".a + " + reg[1]+regSwizzle[1] + " - 0.5;\n"; + #endif + bld.op(kSM4Op_MAD); + bld.reg('r', 0, writeMaskBin); + bld.swz(regFile[0], regIdx[0], regSwizzleBin[0]); + bld.swz(regFile[2], regIdx[2], regSrcAlphaSwz[2]); + bld.swz(regFile[1], regIdx[1], regSwizzleBin[1]); + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(-.5f,-.5f,-.5f,-.5f); + break; + default: + AssertString ("Unknown combiner op!"); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col")+writeMask + " = " + reg[0]+regSwizzle[0] + ";\n"; + #endif + break; + } + + // scale + if (scale > 1) + { + DebugAssert (scale == 2 || scale == 4); + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("col *= ") + char('0'+scale) + ".0;\n"; + #endif + if (scale == 2) + { + bld.op(kSM4Op_ADD); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.swz('r', 0); + } + else if (scale == 4) + { + bld.op(kSM4Op_MUL); + bld.reg('r', 0, writeMaskBin); + bld.swz('r', 0); + bld.float4(4.0f,4.0f,4.0f,4.0f); + } + } + + return usedConstant; +} + +void* BuildFragmentShaderD3D11 (const FixedFunctionStateD3D11& state, FixedFunctionProgramD3D11::ValueParameters& params, size_t& outSize) +{ + ShaderLab::FastPropertyName cbName; cbName.SetName(kD3D11PixelCB); + GetD3D11ConstantBuffers(GetRealGfxDevice()).SetCBInfo (cbName.index, k11PixelSize*16); + params.m_CBID = cbName.index; params.m_CBSize = k11PixelSize*16; + + DXBCBuilder* builder = dxb_create(4, 0, kSM4Shader_Pixel); + DXBCBuilderStream bld(builder); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + std::string textures, inputs, code; + #endif + + dxb_dcl_output(builder, "SV_Target", 0, 0); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float4 icolor : COLOR0"); + #endif + int inputRegCounter = 0; + dxb_dcl_input(builder, "COLOR", 0, inputRegCounter++); + + if (state.lightingEnabled && state.specularEnabled) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float3 ispec : COLOR1"); + #endif + dxb_dcl_input(builder, "COLOR", 1, inputRegCounter++, 0x7); + } + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float4 col;\n"; + #endif + + if (state.texUnitCount == 0) + { + // No combiners is special case: output primary color + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "col = icolor;\n"; + #endif + bld.op(kSM4Op_MOV).reg('r', 0).swz('v', 0); + + // BUG, using for ex., + // SubShader { Pass { Color (1,0,0,0) } } + // produces white color instead of red on IvyBridge UltraBook + } + else + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "float4 tex, tmp0, tmp1, tmp2;\n"; + #endif + for (int i = 0; i < state.texUnitCount; i++) + { + std::string iname = IntToString(i); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, ("float4 iuv"+iname + " : TEXCOORD"+iname).c_str()); + textures += "SamplerState ff_smp"+iname + " : register(s"+iname+");\n"; + #endif + + // sample the texture into tmp1 + if (state.texUnit3D & (1<<i)) // 3D + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0x7); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "Texture3D ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xyz);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURE3D); + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('v', inputRegCounter, kSM4SwzXYZX).swz('t', i).reg('s', i); + } + else if (state.texUnitCube & (1<<i)) // cubemap + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0x7); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "TextureCube ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xyz);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURECUBE); + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('v', inputRegCounter, kSM4SwzXYZX).swz('t', i).reg('s', i); + } + else if (state.texUnitProjected & (1<<i)) // projected sample + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0xB); // xyw mask + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "Texture2D ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xy / iuv"+iname + ".w);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURE2D); + + // SM4: use DIV; Intel IvyBridge seems to prefer that + bld.noAutoSM2(); + bld.op(kSM4Op_DIV).reg('r', 1, 0x3).swz('v', inputRegCounter, kSM4SwzXYXX).swz('v', inputRegCounter, kSM4SwzRepW); + bld.autoSM2(); + + // SM2: use RCP+MUL + bld.op2(kSM2Op_RCP).reg2('r', 1, 8).swz2('v', inputRegCounter, kSM4SwzRepW); + bld.op2(kSM2Op_MUL).reg2('r', 1, 0x3).swz2('v', inputRegCounter, kSM4SwzXYXX).swz2('r',1, kSM4SwzRepW); + + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('r', 1, kSM4SwzXYXX).swz('t', i).reg('s', i); + } + else // regular sample + { + dxb_dcl_input(builder, "TEXCOORD", i, inputRegCounter,0x3); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + textures += "Texture2D ff_tex"+iname + " : register(t"+iname+");\n"; + code += "tex = ff_tex"+iname + ".Sample(ff_smp"+iname + ", iuv"+iname + ".xy);\n"; + #endif + + dxb_dcl_tex(builder, i, kSM4Target_TEXTURE2D); + bld.op(kSM4Op_SAMPLE).reg('r', 1).swz('v', inputRegCounter, kSM4SwzXYXX).swz('t', i).reg('s', i); + } + + // emit color & alpha combiners; result in tmp0 + UInt32 colorComb = state.texUnitColorCombiner[i]; + UInt32 alphaComb = state.texUnitAlphaCombiner[i]; + bool usedConstant = false; + if (colorComb == alphaComb) + { + usedConstant |= EmitCombinerMath11 (i, colorComb, kCombWriteRGBA, state.texUnitCount, bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , code + #endif + ); + } + else + { + usedConstant |= EmitCombinerMath11 (i, colorComb, kCombWriteRGB, state.texUnitCount, bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , code + #endif + ); + usedConstant |= EmitCombinerMath11 (i, alphaComb, kCombWriteA, state.texUnitCount, bld + #if DEBUG_D3D11_COMPARE_WITH_HLSL + , code + #endif + ); + } + + if (usedConstant) + params.AddVectorParam ((k11PixelColors+i)*16, 4, BuiltinShaderVectorParam(kShaderVecFFTextureEnvColor0+i)); + ++inputRegCounter; + } + } + + // alpha test + if (state.alphaTest != kFuncDisabled && state.alphaTest != kFuncAlways) + { + params.AddVectorParam (k11PixelAlphaRef*16, 1, kShaderVecFFAlphaTestRef); + if (state.alphaTest == kFuncNever) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "discard;\n"; + #endif + bld.op(kSM4Op_DISCARD).float1(-1); // int is not sm20 compatible; old comment: HLSL emits 'l(-1)' for plain discard; with the value being integer -1 (all bits set) + } + else + { + // Reverse logic because we're using here 'discard' + #if DEBUG_D3D11_COMPARE_WITH_HLSL + static const char* kCmpOps[] = + { + "", // kFuncDisabled + "", // kFuncNever + ">=", // kFuncLess + "!=", // kFuncEqual + ">", // kFuncLEqual + "<=", // kFuncGreater + "==", // kFuncNotEqual + "<", // kFuncGEqual + "", // kFuncAlways + }; + #endif // #if DEBUG_D3D11_COMPARE_WITH_HLSL + static SM4Opcode kCmpOpcodes[] = + { + kSM4Op_ADD, // kFuncDisabled + kSM4Op_ADD, // kFuncNever + kSM4Op_GE, // kFuncLess + kSM4Op_NE, // kFuncEqual + kSM4Op_LT, // kFuncLEqual + kSM4Op_GE, // kFuncGreater + kSM4Op_EQ, // kFuncNotEqual + kSM4Op_LT, // kFuncGEqual + kSM4Op_ADD, // kFuncAlways + }; + static bool kCmpOrder[] = + { + false, // kFuncDisabled + false, // kFuncNever + true, // kFuncLess + true, // kFuncEqual + false, // kFuncLEqual + false, // kFuncGreater + true, // kFuncNotEqual + true, // kFuncGEqual + false, // kFuncAlways + }; + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += std::string("if (col.a ") + kCmpOps[state.alphaTest] + " ff_alpha_ref) discard;\n"; + #endif + + bld.noAutoSM2(); + bld.op(kCmpOpcodes[state.alphaTest]).reg('r', 1, 0x1); + if (kCmpOrder[state.alphaTest]) + { + bld.swz('r', 0, kSM4SwzRepW); + bld.swz('c', k11PixelAlphaRef, kSM4SwzRepX); + } + else + { + bld.swz('c', k11PixelAlphaRef, kSM4SwzRepX); + bld.swz('r', 0, kSM4SwzRepW); + } + bld.op(kSM4Op_DISCARD).reg('r', 1, 1); + bld.autoSM2(); + + //SM20 + static float bConst[][2] = + { + {0,0}, + {0,0}, + + {0,-1}, + {0,-1}, + {-1,0}, + {0,-1}, + {-1,0}, + {-1,0}, + + {0,0}, + }; + static bool bRefSign[] = + { + false, + false, + + false, + true, + true, + true, + true, + false, + false, + }; + + bld.op2(kSM2Op_ADD). + reg2('r',1,1). + swz2('c',k11PixelAlphaRef, kSM4SwzRepX,bRefSign[state.alphaTest]). + swz2('r', 0, kSM4SwzRepW,!bRefSign[state.alphaTest]); + if (state.alphaTest == kFuncEqual || state.alphaTest == kFuncNotEqual) + bld.op2(kSM2Op_MUL).reg2('r',1,1).swz2('r',1,kSM4SwzRepX).swz2('r',1,kSM4SwzRepX); + bld.op2(kSM2Op_CMP).reg2('r',1). + swz2('r',1,kSM4SwzRepX,state.alphaTest == kFuncEqual || state.alphaTest == kFuncNotEqual). + float1_2(bConst[state.alphaTest][0]). + float1_2(bConst[state.alphaTest][1]); + bld.op2(kSM2Op_TEXKILL).reg2('r', 1); + } + } + + // add specular + if (state.lightingEnabled && state.specularEnabled) + { + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "col.rgb += ispec;\n"; + #endif + // add r0.xyz, r0.xyz, v1.xyz + bld.op(kSM4Op_ADD).reg('r', 0, 0x7).swz('r', 0, kSM4SwzXYZX).swz('v', 1, kSM4SwzXYZX); + } + + // fog + if (state.fogMode != kFogDisabled && inputRegCounter < 8) + { + int fogVar = inputRegCounter; + dxb_dcl_input(builder, "FOG", 0, fogVar, 0x1); + params.AddVectorParam (k11PixelFog*16, 4, kShaderVecFFFogColor); + // color.rgb = lerp (fogColor.rgb, color.rgb, fogVar) = + // (color.rgb-fogColor.rgb) * fogVar + fogColor.rgb + bld.op(kSM4Op_ADD).reg('r',0,7).swz('r',0,kSM4SwzXYZX).swz('c',k11PixelFog,kSM4SwzXYZX, true); + bld.op(kSM4Op_MAD).reg('r',0,7).swz('r',0,kSM4SwzXYZX).swz('v',fogVar,kSM4SwzRepX).swz('c',k11PixelFog,kSM4SwzXYZX); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + AddToStringList (inputs, "float ifog : FOG"); + code += "col.rgb = lerp (ff_fog.rgb, col.rgb, ifog);\n"; + #endif + } + + if (params.HasVectorParams()) + dxb_dcl_cb(builder, 0, k11PixelSize); + + // mov o0.xyzw, r0.xyzw + bld.op(kSM4Op_MOV).reg('o', 0).swz('r', 0); + // ret + bld.op(kSM4Op_RET); + + #if DEBUG_D3D11_COMPARE_WITH_HLSL + code += "return col;\n"; + std::string src = textures + kD3D11PixelPrefix + inputs + ") : SV_TARGET {\n" + code + "\n}"; + printf_console ("d3d11 FF PS HLSL:\n%s\n", src.c_str()); + DebugCompileHLSLShaderD3D11 (src, false); + #endif + + void* blob = BuildShaderD3D11 (builder, outSize); + return blob; +} |