diff --git a/base/renderprogs/ambient_lighting.pixel b/base/renderprogs/ambient_lighting.pixel new file mode 100644 index 00000000..46ac16b3 --- /dev/null +++ b/base/renderprogs/ambient_lighting.pixel @@ -0,0 +1,97 @@ +/* +=========================================================================== + +Doom 3 BFG Edition GPL Source Code +Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. +Copyright (C) 2013-2015 Robert Beckebans + +This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code"). + +Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with Doom 3 BFG Edition Source Code. If not, see . + +In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below. + +If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA. + +=========================================================================== +*/ + +#include "renderprogs/global.inc" + +uniform sampler2D samp0 : register(s0); // texture 1 is the per-surface bump map +uniform sampler2D samp1 : register(s1); // texture 2 is the light falloff texture +uniform sampler2D samp2 : register(s2); // texture 3 is the light projection texture +uniform sampler2D samp3 : register(s3); // texture 4 is the per-surface diffuse map +uniform sampler2D samp4 : register(s4); // texture 5 is the per-surface specular map + +struct PS_IN { + half4 position : VPOS; + half4 texcoord0 : TEXCOORD0_centroid; + half4 texcoord1 : TEXCOORD1_centroid; +// half4 texcoord2 : TEXCOORD2_centroid; +// half4 texcoord3 : TEXCOORD3_centroid; + half4 texcoord4 : TEXCOORD4_centroid; + half4 texcoord5 : TEXCOORD5_centroid; + half4 texcoord6 : TEXCOORD6_centroid; + half4 color : COLOR0; +}; + +struct PS_OUT { + half4 color : COLOR; +}; + +void main( PS_IN fragment, out PS_OUT result ) { + half4 bumpMap = tex2D( samp0, fragment.texcoord1.xy ); +// half4 lightFalloff = idtex2Dproj( samp1, fragment.texcoord2 ); +// half4 lightProj = idtex2Dproj( samp2, fragment.texcoord3 ); + half4 YCoCG = tex2D( samp3, fragment.texcoord4.xy ); + half4 specMap = tex2D( samp4, fragment.texcoord5.xy ); + + half3 lightVector = normalize( fragment.texcoord0.xyz ); + half3 diffuseMap = ConvertYCoCgToRGB( YCoCG ); + + half3 localNormal; +#if defined(USE_NORMAL_FMT_RGB8) + localNormal.xy = bumpMap.rg - 0.5; +#else + localNormal.xy = bumpMap.wy - 0.5; +#endif + localNormal.z = sqrt( abs( dot( localNormal.xy, localNormal.xy ) - 0.25 ) ); + localNormal = normalize( localNormal ); + + const half specularPower = 10.0f; + half hDotN = dot3( normalize( fragment.texcoord6.xyz ), localNormal ); + // RB: added abs + half3 specularContribution = _half3( pow( abs( hDotN ), specularPower ) ); + + half3 diffuseColor = diffuseMap * rpDiffuseModifier.xyz * 1.5f; + half3 specularColor = specMap.xyz * specularContribution * rpSpecularModifier.xyz; + + // RB: http://developer.valvesoftware.com/wiki/Half_Lambert + float halfLdotN = dot3( localNormal, lightVector ) * 0.5 + 0.5; + halfLdotN *= halfLdotN; + + // traditional very dark Lambert light model used in Doom 3 + float ldotN = dot3( localNormal, lightVector ); + + half3 lightColor = rpAmbientColor.rgb; + + half rim = 1.0f - saturate( hDotN ); + half rimPower = 8.0; + half3 rimColor = half3( 0.125 ) * 1.2 * lightColor * pow( rim, rimPower ); + + //result.color.rgb = localNormal.xyz * 0.5 + 0.5; + result.color.xyz = ( diffuseColor + specularColor ) * halfLdotN * lightColor + rimColor; + result.color.w = 1.0; +} diff --git a/base/renderprogs/ambient_lighting.vertex b/base/renderprogs/ambient_lighting.vertex new file mode 100644 index 00000000..c6473cd7 --- /dev/null +++ b/base/renderprogs/ambient_lighting.vertex @@ -0,0 +1,199 @@ +/* +=========================================================================== + +Doom 3 BFG Edition GPL Source Code +Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company. +Copyright (C) 2013-2015 Robert Beckebans + +This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code"). + +Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with Doom 3 BFG Edition Source Code. If not, see . + +In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below. + +If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA. + +=========================================================================== +*/ + +#include "renderprogs/global.inc" + +#if defined( USE_GPU_SKINNING ) +uniform matrices_ubo { float4 matrices[408]; }; +#endif + +struct VS_IN { + float4 position : POSITION; + float2 texcoord : TEXCOORD0; + float4 normal : NORMAL; + float4 tangent : TANGENT; + float4 color : COLOR0; + float4 color2 : COLOR1; +}; + +struct VS_OUT { + float4 position : POSITION; + float4 texcoord0 : TEXCOORD0; + float4 texcoord1 : TEXCOORD1; +// float4 texcoord2 : TEXCOORD2; +// float4 texcoord3 : TEXCOORD3; + float4 texcoord4 : TEXCOORD4; + float4 texcoord5 : TEXCOORD5; + float4 texcoord6 : TEXCOORD6; + float4 color : COLOR0; +}; + +void main( VS_IN vertex, out VS_OUT result ) { + + float4 vNormal = vertex.normal * 2.0 - 1.0; + float4 vTangent = vertex.tangent * 2.0 - 1.0; + float3 vBitangent = cross( vNormal.xyz, vTangent.xyz ) * vTangent.w; + +#if defined( USE_GPU_SKINNING ) + //-------------------------------------------------------------- + // GPU transformation of the normal / tangent / bitangent + // + // multiplying with 255.1 give us the same result and is faster than floor( w * 255 + 0.5 ) + //-------------------------------------------------------------- + const float w0 = vertex.color2.x; + const float w1 = vertex.color2.y; + const float w2 = vertex.color2.z; + const float w3 = vertex.color2.w; + + float4 matX, matY, matZ; // must be float4 for vec4 + int joint = int(vertex.color.x * 255.1 * 3.0); + matX = matrices[int(joint+0)] * w0; + matY = matrices[int(joint+1)] * w0; + matZ = matrices[int(joint+2)] * w0; + + joint = int(vertex.color.y * 255.1 * 3.0); + matX += matrices[int(joint+0)] * w1; + matY += matrices[int(joint+1)] * w1; + matZ += matrices[int(joint+2)] * w1; + + joint = int(vertex.color.z * 255.1 * 3.0); + matX += matrices[int(joint+0)] * w2; + matY += matrices[int(joint+1)] * w2; + matZ += matrices[int(joint+2)] * w2; + + joint = int(vertex.color.w * 255.1 * 3.0); + matX += matrices[int(joint+0)] * w3; + matY += matrices[int(joint+1)] * w3; + matZ += matrices[int(joint+2)] * w3; + + float3 normal; + normal.x = dot3( matX, vNormal ); + normal.y = dot3( matY, vNormal ); + normal.z = dot3( matZ, vNormal ); + normal = normalize( normal ); + + float3 tangent; + tangent.x = dot3( matX, vTangent ); + tangent.y = dot3( matY, vTangent ); + tangent.z = dot3( matZ, vTangent ); + tangent = normalize( tangent ); + + float3 bitangent; + bitangent.x = dot3( matX, vBitangent ); + bitangent.y = dot3( matY, vBitangent ); + bitangent.z = dot3( matZ, vBitangent ); + bitangent = normalize( bitangent ); + + float4 modelPosition; + modelPosition.x = dot4( matX, vertex.position ); + modelPosition.y = dot4( matY, vertex.position ); + modelPosition.z = dot4( matZ, vertex.position ); + modelPosition.w = 1.0; + +#else + float4 modelPosition = vertex.position; + float3 normal = vNormal.xyz; + float3 tangent = vTangent.xyz; + float3 bitangent = vBitangent.xyz; +#endif + + result.position.x = dot4( modelPosition, rpMVPmatrixX ); + result.position.y = dot4( modelPosition, rpMVPmatrixY ); + result.position.z = dot4( modelPosition, rpMVPmatrixZ ); + result.position.w = dot4( modelPosition, rpMVPmatrixW ); + + float4 defaultTexCoord = float4( 0.0f, 0.5f, 0.0f, 1.0f ); + + //calculate vector to light + //float4 toLight = rpLocalLightOrigin; + float4 toLight = normalize( float4( 0.0f, 0.5f, 1.0f, 1.0f ) ); + + //-------------------------------------------------------------- + + //result.texcoord0 is the direction to the light in tangent space + result.texcoord0.x = dot3( tangent, toLight ); + result.texcoord0.y = dot3( bitangent, toLight ); + result.texcoord0.z = dot3( normal, toLight ); + result.texcoord0.w = 1.0f; + + //textures 1 takes the base coordinates by the texture matrix + result.texcoord1 = defaultTexCoord; + result.texcoord1.x = dot4( vertex.texcoord.xy, rpBumpMatrixS ); + result.texcoord1.y = dot4( vertex.texcoord.xy, rpBumpMatrixT ); + + //# texture 2 has one texgen + //result.texcoord2 = defaultTexCoord; + //result.texcoord2.x = dot4( vertex.position, rpLightFalloffS ); + + //# texture 3 has three texgens + //result.texcoord3.x = dot4( vertex.position, rpLightProjectionS ); + //result.texcoord3.y = dot4( vertex.position, rpLightProjectionT ); + //result.texcoord3.z = 0.0f; + //result.texcoord3.w = dot4( vertex.position, rpLightProjectionQ ); + + //# textures 4 takes the base coordinates by the texture matrix + result.texcoord4 = defaultTexCoord; + result.texcoord4.x = dot4( vertex.texcoord.xy, rpDiffuseMatrixS ); + result.texcoord4.y = dot4( vertex.texcoord.xy, rpDiffuseMatrixT ); + + //# textures 5 takes the base coordinates by the texture matrix + result.texcoord5 = defaultTexCoord; + result.texcoord5.x = dot4( vertex.texcoord.xy, rpSpecularMatrixS ); + result.texcoord5.y = dot4( vertex.texcoord.xy, rpSpecularMatrixT ); + + //# texture 6's texcoords will be the halfangle in texture space + + //# calculate normalized vector to light in R0 + toLight = normalize( toLight ); + + //# calculate normalized vector to viewer in R1 + float4 toView = normalize( rpLocalViewOrigin - modelPosition ); + + //# add together to become the half angle vector in object space (non-normalized) + float4 halfAngleVector = toLight + toView; + + //# put into texture space + result.texcoord6.x = dot3( tangent, halfAngleVector ); + result.texcoord6.y = dot3( bitangent, halfAngleVector ); + result.texcoord6.z = dot3( normal, halfAngleVector ); + result.texcoord6.w = 1.0f; + +#if defined( USE_GPU_SKINNING ) + // for joint transformation of the tangent space, we use color and + // color2 for weighting information, so hopefully there aren't any + // effects that need vertex color... + result.color = float4( 1.0f, 1.0f, 1.0f, 1.0f ); +#else + //# generate the vertex color, which can be 1.0, color, or 1.0 - color + //# for 1.0 : env[16] = 0, env[17] = 1 + //# for color : env[16] = 1, env[17] = 0 + //# for 1.0-color : env[16] = -1, env[17] = 1 + result.color = ( swizzleColor( vertex.color ) * rpVertexColorModulate ) + rpVertexColorAdd; +#endif +} \ No newline at end of file diff --git a/neo/renderer/RenderBackend.cpp b/neo/renderer/RenderBackend.cpp index 9370b798..21fea207 100644 --- a/neo/renderer/RenderBackend.cpp +++ b/neo/renderer/RenderBackend.cpp @@ -5836,7 +5836,7 @@ void idRenderBackend::PostProcess( const void* data ) /* * The shader has three passes, chained together as follows: * - * |input|------------------· + * |input|------------------� * v | * [ SMAA*EdgeDetection ] | * v | @@ -5846,7 +5846,7 @@ void idRenderBackend::PostProcess( const void* data ) * v | * |blendTex| | * v | - * [ SMAANeighborhoodBlending ] <------· + * [ SMAANeighborhoodBlending ] <------� * v * |output| */ diff --git a/neo/renderer/RenderProgs_embedded.h b/neo/renderer/RenderProgs_embedded.h index 110faced..457dc176 100644 --- a/neo/renderer/RenderProgs_embedded.h +++ b/neo/renderer/RenderProgs_embedded.h @@ -396,7 +396,7 @@ static const cgShaderDef_t cg_renderprogs[] = " *\n" " * The shader has three passes, chained together as follows:\n" " *\n" - " * |input|------------------·\n" + " * |input|------------------�\n" " * v |\n" " * [ SMAA*EdgeDetection ] |\n" " * v |\n" @@ -406,7 +406,7 @@ static const cgShaderDef_t cg_renderprogs[] = " * v |\n" " * |blendTex| |\n" " * v |\n" - " * [ SMAANeighborhoodBlending ] <------·\n" + " * [ SMAANeighborhoodBlending ] <------�\n" " * v\n" " * |output|\n" " *\n" @@ -1794,7 +1794,7 @@ static const cgShaderDef_t cg_renderprogs[] = "}\n" "\n" "// Fresnel term F( v, h )\n" - "// Fnone( v, h ) = F(0°) = specularColor\n" + "// Fnone( v, h ) = F(0�) = specularColor\n" "half3 Fresnel_Schlick( half3 specularColor, half vdotH )\n" "{\n" " return specularColor + ( 1.0 - specularColor ) * pow( 1.0 - vdotH, 5.0 );\n" @@ -8279,7 +8279,7 @@ static const cgShaderDef_t cg_renderprogs[] = " const half roughness = specMapSRGB.r;\n" " const half glossiness = 1.0 - roughness;\n" "\n" - " // the vast majority of real-world materials (anything not metal or gems) have F(0°)\n" + " // the vast majority of real-world materials (anything not metal or gems) have F(0�)\n" " // values in a very narrow range (~0.02 - 0.08)\n" " \n" " // approximate non-metals with linear RGB 0.04 which is 0.08 * 0.5 (default in UE4)\n" @@ -9364,7 +9364,7 @@ static const cgShaderDef_t cg_renderprogs[] = " const half roughness = specMapSRGB.r;\n" " const half glossiness = 1.0 - roughness;\n" "\n" - " // the vast majority of real-world materials (anything not metal or gems) have F(0°)\n" + " // the vast majority of real-world materials (anything not metal or gems) have F(0�)\n" " // values in a very narrow range (~0.02 - 0.08)\n" " \n" " // approximate non-metals with linear RGB 0.04 which is 0.08 * 0.5 (default in UE4)\n"