public Vector4 PS(PixelInput input)
{
Vector3 diffuseColor;
Vector3 specularColor;
DoLighting(
Global_LightingConstantsPS,
input.WorldPosition,
input.WorldNormal,
Vector3.One,
Vector3.One,
Vector3.Zero,
0,
GlobalConstantsShared.CameraPosition,
false,
out diffuseColor,
out specularColor);
var textureColor = SampleBlendedTextures(input.UV);
var cloudColor = GetCloudColor(Global_CloudTexture, Sampler, input.CloudUV);
var macroTextureUV = GetMacroTextureUV(input.WorldPosition);
var macroTextureColor = Sample(MacroTexture, Sampler, macroTextureUV).XYZ();
return(new Vector4(
diffuseColor * textureColor * cloudColor * macroTextureColor,
1));
}
public Vector4 PS(PixelInput input)
{
var textureColor = ShaderBuiltins.Sample(Texture, Sampler, input.UV);
textureColor *= input.Color;
return(textureColor);
}
public Vector4 PS(PixelInput input)
{
var uv = input.UV0;
uv.Y = 1 - uv.Y;
var tangentToWorldSpace = new Matrix4x4(
input.WorldTangent.X, input.WorldTangent.Y, input.WorldTangent.Z, 0,
input.WorldBinormal.X, input.WorldBinormal.Y, input.WorldBinormal.Z, 0,
input.WorldNormal.X, input.WorldNormal.Y, input.WorldNormal.Z, 0,
0, 0, 0, 1);
var tangentSpaceNormal = (Sample(NormalMap, Sampler, uv).XYZ() * 2) - Vector3.One;
tangentSpaceNormal = new Vector3(tangentSpaceNormal.XY() * MaterialConstants.BumpScale, tangentSpaceNormal.Z);
tangentSpaceNormal = Vector3.Normalize(tangentSpaceNormal);
var worldSpaceNormal = TransformNormal(tangentSpaceNormal, tangentToWorldSpace);
Vector3 diffuseColor;
Vector3 specularColor;
DoLighting(
Global_LightingConstantsPS,
input.WorldPosition,
worldSpaceNormal,
MaterialConstants.AmbientColor.XYZ(),
MaterialConstants.DiffuseColor.XYZ(),
MaterialConstants.SpecularColor.XYZ(),
MaterialConstants.SpecularExponent,
GlobalConstantsShared.CameraPosition,
false, //TODO: true,
out diffuseColor,
out specularColor);
var diffuseTextureColor = Sample(DiffuseTexture, Sampler, uv);
if (MaterialConstants.AlphaTestEnable == 1)
{
if (FailsAlphaTest(diffuseTextureColor.W))
{
Discard();
}
}
var objectColor = diffuseTextureColor.XYZ() * diffuseColor;
objectColor += specularColor;
var cloudColor = GetCloudColor(Global_CloudTexture, Sampler, input.CloudUV);
objectColor *= cloudColor;
return(new Vector4(
objectColor,
MaterialConstants.DiffuseColor.W * diffuseTextureColor.W));
}
public Vector4 PS(PixelInput input)
{
var texColor = Sample(ParticleTexture, Sampler, input.TexCoords);
texColor = new Vector4(
texColor.XYZ() * input.Color,
texColor.W * input.Alpha);
// TODO: Alpha test
return(texColor);
}
public Vector4 PS(PixelInput input)
{
var textureColor = ShaderBuiltins.Sample(Texture, Sampler, input.UV);
if (ShaderGen.ShaderBuiltins.Abs(textureColor.W) < 0.1)
{
ShaderGen.ShaderBuiltins.Discard();
}
textureColor *= input.Color;
return(textureColor);
}
public Vector4 PS(PixelInput input)
{
var uv =
(input.UV0 * MaterialConstants.TexCoordTransform_0.XY()) +
(GlobalConstantsShared.TimeInSeconds * MaterialConstants.TexCoordTransform_0.ZW());
var color = new Vector4(MaterialConstants.ColorEmissive.XYZ(), 1);
color *= Sample(Texture_0, Sampler, uv);
var cloudColor = GetCloudColor(Global_CloudTexture, Sampler, input.CloudUV);
color = new Vector4(color.XYZ() * cloudColor, color.W);
// TODO: Fog.
return(color);
}
public Vector4 FS(PixelInput input)
{
float alphaMapSample = Sample(AlphaMap, AlphaMapSampler, input.TexCoord).X;
if (alphaMapSample == 0)
{
Discard();
}
Vector4 surfaceColor = Sample(SurfaceTexture, RegularSampler, input.TexCoord);
Vector4 ambientLight = new Vector4(.4f, .4f, .4f, 1f);
// Point Diffuse
Vector4 pointDiffuse = new Vector4(0, 0, 0, 1);
Vector4 pointSpec = new Vector4(0, 0, 0, 1);
for (int i = 0; i < PointLights.NumActiveLights; i++)
{
PointLightInfo pli = PointLights.PointLights[i];
Vector3 lightDir = Vector3.Normalize(pli.Position - input.Position_WorldSpace);
float intensity = Saturate(Vector3.Dot(input.Normal, lightDir));
float lightDistance = Vector3.Distance(pli.Position, input.Position_WorldSpace);
intensity = Saturate(intensity * (1 - (lightDistance / pli.Range)));
pointDiffuse += intensity * new Vector4(pli.Color, 1) * surfaceColor;
// Specular
Vector3 vertexToEye0 = Vector3.Normalize(CameraInfo.CameraPosition_WorldSpace - input.Position_WorldSpace);
Vector3 lightReflect0 = Vector3.Normalize(Vector3.Reflect(lightDir, input.Normal));
float specularFactor0 = Vector3.Dot(vertexToEye0, lightReflect0);
if (specularFactor0 > 0)
{
specularFactor0 = Pow(Abs(specularFactor0), MaterialProperties.SpecularPower);
pointSpec += (1 - (lightDistance / pli.Range)) * (new Vector4(pli.Color * MaterialProperties.SpecularIntensity * specularFactor0, 1.0f));
}
}
pointDiffuse = Saturate(pointDiffuse);
pointSpec = Saturate(pointSpec);
// Directional light calculations
//re-homogenize position after interpolation
input.LightPosition /= input.LightPosition.W;
input.LightPosition.W = 1;
// if position is not visible to the light - dont illuminate it
// results in hard light frustum
if (input.LightPosition.X < -1.0f || input.LightPosition.X > 1.0f ||
input.LightPosition.Y < -1.0f || input.LightPosition.Y > 1.0f ||
input.LightPosition.Z < 0.0f || input.LightPosition.Z > 1.0f)
{
return(WithAlpha((ambientLight * surfaceColor) + pointDiffuse + pointSpec, surfaceColor.X));
}
// transform clip space coords to texture space coords (-1:1 to 0:1)
input.LightPosition.X = input.LightPosition.X / 2 + 0.5f;
input.LightPosition.Y = input.LightPosition.Y / -2 + 0.5f;
Vector3 L = -1 * Vector3.Normalize(LightInfo.LightDir);
float diffuseFactor = Vector3.Dot(Vector3.Normalize(input.Normal), L);
float cosTheta = Clamp(diffuseFactor, 0, 1);
float bias = 0.0005f * Tan(Acos(cosTheta));
bias = Clamp(bias, 0, 0.01f);
input.LightPosition.Z -= bias;
//sample shadow map - point sampler
float ShadowMapDepth = Sample(ShadowMap, ShadowMapSampler, new Vector2(input.LightPosition.X, input.LightPosition.Y)).X;
//if clip space z value greater than shadow map value then pixel is in shadow
if (ShadowMapDepth < input.LightPosition.Z)
{
return(WithAlpha((ambientLight * surfaceColor) + pointDiffuse + pointSpec, surfaceColor.X));
}
//otherwise calculate ilumination at fragment
diffuseFactor = Clamp(diffuseFactor, 0, 1);
Vector4 specularColor = new Vector4(0, 0, 0, 0);
Vector3 vertexToEye = Vector3.Normalize(CameraInfo.CameraPosition_WorldSpace - input.Position_WorldSpace);
Vector3 lightReflect = Vector3.Normalize(Vector3.Reflect(LightInfo.LightDir, input.Normal));
Vector3 lightColor = new Vector3(1, 1, 1);
float specularFactor = Vector3.Dot(vertexToEye, lightReflect);
if (specularFactor > 0)
{
specularFactor = Pow(Abs(specularFactor), MaterialProperties.SpecularPower);
specularColor = new Vector4(lightColor * MaterialProperties.SpecularIntensity * specularFactor, 1.0f);
}
return(WithAlpha(specularColor + (ambientLight * surfaceColor)
+ (diffuseFactor * surfaceColor) + pointDiffuse + pointSpec, surfaceColor.X));
}
public Vector4 PS(PixelInput input)
{
//LightingParameters lightingParams;
//lightingParams.WorldPosition = input.WorldPosition;
//lightingParams.WorldNormal = input.WorldNormal;
//lightingParams.MaterialAmbient = MaterialConstants.Material.Ambient;
//lightingParams.MaterialDiffuse = MaterialConstants.Material.Diffuse;
//lightingParams.MaterialSpecular = MaterialConstants.Material.Specular;
//lightingParams.MaterialShininess = MaterialConstants.Material.Shininess;
Vector3 diffuseColor;
Vector3 specularColor;
DoLighting(
Global_LightingConstantsPS,
input.WorldPosition,
input.WorldNormal,
MaterialConstants.Material.Ambient,
MaterialConstants.Material.Diffuse,
MaterialConstants.Material.Specular,
MaterialConstants.Material.Shininess,
GlobalConstantsShared.CameraPosition,
true,
out diffuseColor,
out specularColor);
Vector4 diffuseTextureColor;
if (MaterialConstants.Shading.TexturingEnabled == 1)
{
var v = CalculateViewVector(GlobalConstantsShared.CameraPosition, input.WorldPosition);
diffuseTextureColor = SampleTexture(
input.WorldNormal, input.UV0, input.ScreenPosition.XY(),
MaterialConstants.Material.TextureMappingStage0,
Texture0,
v);
if (MaterialConstants.NumTextureStages > 1)
{
var secondaryTextureColor = SampleTexture(
input.WorldNormal, input.UV1, input.ScreenPosition.XY(),
MaterialConstants.Material.TextureMappingStage1,
Texture1,
v);
switch (MaterialConstants.Shading.SecondaryTextureColorBlend)
{
case 1: // SECONDARY_TEXTURE_BLEND_DETAIL
diffuseTextureColor = new Vector4(
secondaryTextureColor.XYZ(),
diffuseTextureColor.W);
break;
case 2: // SECONDARY_TEXTURE_BLEND_SCALE
diffuseTextureColor = new Vector4(
diffuseTextureColor.XYZ() * secondaryTextureColor.XYZ(),
diffuseTextureColor.W);
break;
case 3: // SECONDARY_TEXTURE_BLEND_INV_SCALE
diffuseTextureColor = new Vector4(
(Vector3.One - diffuseTextureColor.XYZ()) * secondaryTextureColor.XYZ(),
diffuseTextureColor.W);
break;
case 4: // SECONDARY_TEXTURE_BLEND_DETAIL_BLEND
// (otherAlpha)*local + (~otherAlpha)*other
diffuseTextureColor = new Vector4(
(secondaryTextureColor.X * diffuseTextureColor.XYZ()) + ((1 - secondaryTextureColor.X) * secondaryTextureColor.XYZ()),
diffuseTextureColor.W);
break;
}
switch (MaterialConstants.Shading.SecondaryTextureAlphaBlend)
{
case 1: // SECONDARY_TEXTURE_BLEND_DETAIL
diffuseTextureColor.W = secondaryTextureColor.W;
break;
case 2: // SECONDARY_TEXTURE_BLEND_SCALE:
diffuseTextureColor.W *= secondaryTextureColor.W;
break;
case 3: // SECONDARY_TEXTURE_BLEND_INV_SCALE
diffuseTextureColor.W += (1 - diffuseTextureColor.W) * secondaryTextureColor.W;
break;
}
}
if (MaterialConstants.Shading.AlphaTest == 1)
{
if (FailsAlphaTest(diffuseTextureColor.W))
{
Discard();
}
}
}
else
{
diffuseTextureColor = Vector4.One;
}
var totalObjectLighting = Saturate(diffuseColor + MaterialConstants.Material.Emissive);
var objectColor = diffuseTextureColor.XYZ();
switch (MaterialConstants.Shading.DiffuseLightingType)
{
case 1: // DIFFUSE_LIGHTING_MODULATE
objectColor *= totalObjectLighting;
break;
case 2: // DIFFUSE_LIGHTING_ADD
objectColor += totalObjectLighting;
break;
}
if (MaterialConstants.Shading.SpecularEnabled == 1)
{
objectColor += specularColor;
}
var cloudColor = GetCloudColor(
Global_CloudTexture,
Sampler,
input.CloudUV);
return(new Vector4(
objectColor * cloudColor,
MaterialConstants.Material.Opacity * diffuseTextureColor.W));
}
public Vector4 PS(PixelInput input)
{
DoLighting(
Global_LightingConstantsPS,
input.WorldPosition,
input.WorldNormal,
MaterialConstants.Material.Ambient,
MaterialConstants.Material.Diffuse,
MaterialConstants.Material.Specular,
MaterialConstants.Material.Shininess,
GlobalConstantsShared.CameraPosition,
true,
out var diffuseColor,
out var specularColor);
Vector4 diffuseTextureColor;
if (MaterialConstants.Shading.TexturingEnabled == 1u)
{
var v = CalculateViewVector(GlobalConstantsShared.CameraPosition, input.WorldPosition);
diffuseTextureColor = SampleTexture(
input.WorldNormal, input.UV0, input.ScreenPosition.XY(),
MaterialConstants.Material.TextureMappingStage0,
Texture0,
v);
if (MaterialConstants.NumTextureStages > 1u)
{
var secondaryTextureColor = SampleTexture(
input.WorldNormal, input.UV1, input.ScreenPosition.XY(),
MaterialConstants.Material.TextureMappingStage1,
Texture1,
v);
switch (MaterialConstants.Shading.SecondaryTextureColorBlend)
{
case SecondaryTextureBlend.Detail:
diffuseTextureColor = new Vector4(
secondaryTextureColor.XYZ(),
diffuseTextureColor.W);
break;
case SecondaryTextureBlend.Scale:
diffuseTextureColor = new Vector4(
diffuseTextureColor.XYZ() * secondaryTextureColor.XYZ(),
diffuseTextureColor.W);
break;
case SecondaryTextureBlend.InvScale:
diffuseTextureColor = new Vector4(
(Vector3.One - diffuseTextureColor.XYZ()) * secondaryTextureColor.XYZ(),
diffuseTextureColor.W);
break;
case SecondaryTextureBlend.DetailBlend:
// (otherAlpha)*local + (~otherAlpha)*other
diffuseTextureColor = new Vector4(
(secondaryTextureColor.X * diffuseTextureColor.XYZ()) + ((1 - secondaryTextureColor.X) * secondaryTextureColor.XYZ()),
diffuseTextureColor.W);
break;
}
switch (MaterialConstants.Shading.SecondaryTextureAlphaBlend)
{
case SecondaryTextureBlend.Detail:
diffuseTextureColor.W = secondaryTextureColor.W;
break;
case SecondaryTextureBlend.Scale:
diffuseTextureColor.W *= secondaryTextureColor.W;
break;
case SecondaryTextureBlend.InvScale:
diffuseTextureColor.W += (1 - diffuseTextureColor.W) * secondaryTextureColor.W;
break;
}
}
if (MaterialConstants.Shading.AlphaTest == 1u)
{
if (FailsAlphaTest(diffuseTextureColor.W))
{
Discard();
}
}
}
else
{
diffuseTextureColor = Vector4.One;
}
var totalObjectLighting = Saturate(diffuseColor + MaterialConstants.Material.Emissive);
var objectColor = diffuseTextureColor.XYZ();
switch (MaterialConstants.Shading.DiffuseLightingType)
{
case DiffuseLightingType.Modulate:
objectColor *= totalObjectLighting;
break;
case DiffuseLightingType.Add:
objectColor += totalObjectLighting;
break;
}
if (MaterialConstants.Shading.SpecularEnabled == 1u)
{
objectColor += specularColor;
}
var cloudColor = GetCloudColor(
Global_CloudTexture,
Sampler,
input.CloudUV);
return(new Vector4(
objectColor * cloudColor,
MaterialConstants.Material.Opacity * diffuseTextureColor.W));
}
public Vector4 FS(PixelInput input)
{
Vector4 surfaceColor = Sample(SurfaceTexture, RegularSampler, input.TexCoord);
Vector4 ambientLight = new Vector4(0.3f, 0.3f, 0.3f, 1f);
Vector3 lightDir = -LightInfo.Direction;
Vector4 directionalColor = ambientLight * surfaceColor;
float shadowBias = 0.0005f;
float lightIntensity = 0f;
// Specular color
Vector4 directionalSpecColor = new Vector4();
Vector3 vertexToEye = Vector3.Normalize(CameraInfo.CameraPosition_WorldSpace - input.Position_WorldSpace);
Vector3 lightReflect = Vector3.Normalize(Vector3.Reflect(LightInfo.Direction, input.Normal));
float specularFactor = Vector3.Dot(vertexToEye, lightReflect);
if (specularFactor > 0)
{
specularFactor = Pow(Abs(specularFactor), MaterialProperties.SpecularPower);
directionalSpecColor = new Vector4(LightInfo.Color.XYZ() * MaterialProperties.SpecularIntensity * specularFactor, 1.0f);
}
// Directional light influence
float depthTest = input.FragDepth;
Vector2 shadowCoords_0 = ClipToTextureCoordinates(input.LightPosition1);
Vector2 shadowCoords_1 = ClipToTextureCoordinates(input.LightPosition2);
Vector2 shadowCoords_2 = ClipToTextureCoordinates(input.LightPosition3);
float lightDepthValues_0 = input.LightPosition1.Z / input.LightPosition1.W;
float lightDepthValues_1 = input.LightPosition2.Z / input.LightPosition2.W;
float lightDepthValues_2 = input.LightPosition3.Z / input.LightPosition3.W;
int shadowIndex = 3;
Vector2 shadowCoords = Vector2.Zero;
float lightDepthValue = 0;
if ((depthTest < DepthLimits.NearLimit) && InRange(shadowCoords_0.X, 0, 1) && InRange(shadowCoords_0.Y, 0, 1))
{
shadowIndex = 0;
shadowCoords = shadowCoords_0;
lightDepthValue = lightDepthValues_0;
}
else if ((depthTest < DepthLimits.MidLimit) && InRange(shadowCoords_1.X, 0, 1) && InRange(shadowCoords_1.Y, 0, 1))
{
shadowIndex = 1;
shadowCoords = shadowCoords_1;
lightDepthValue = lightDepthValues_1;
}
else if (depthTest < DepthLimits.FarLimit && InRange(shadowCoords_2.X, 0, 1) && InRange(shadowCoords_2.Y, 0, 1))
{
shadowIndex = 2;
shadowCoords = shadowCoords_2;
lightDepthValue = lightDepthValues_2;
}
if (shadowIndex != 3)
{
// We are within one of the shadow maps.
float shadowMapDepth = SampleDepthMap(shadowIndex, shadowCoords);
float biasedDistToLight = (lightDepthValue - shadowBias);
if (biasedDistToLight < shadowMapDepth)
{
// In light (no occluders between light and fragment).
lightIntensity = Saturate(Vector3.Dot(input.Normal, lightDir));
if (lightIntensity > 0.0f)
{
directionalColor = surfaceColor * (lightIntensity * LightInfo.Color);
}
}
else
{
// In shadow.
directionalColor = ambientLight * surfaceColor;
directionalSpecColor = Vector4.Zero;
}
}
else
{
// We are outside of all shadow maps. Pretend like the object is not shadowed.
lightIntensity = Saturate(Vector3.Dot(input.Normal, lightDir));
if (lightIntensity > 0.0f)
{
directionalColor = surfaceColor * lightIntensity * LightInfo.Color;
}
}
// Point lights
Vector4 pointDiffuse = new Vector4(0, 0, 0, 1);
Vector4 pointSpec = new Vector4(0, 0, 0, 1);
for (int i = 0; i < PointLights.NumActiveLights; i++)
{
PointLightInfo pli = PointLights.PointLights[i];
Vector3 ptLightDir = Vector3.Normalize(pli.Position - input.Position_WorldSpace);
float intensity = Saturate(Vector3.Dot(input.Normal, ptLightDir));
float lightDistance = Vector3.Distance(pli.Position, input.Position_WorldSpace);
intensity = Saturate(intensity * (1 - (lightDistance / pli.Range)));
pointDiffuse += intensity * new Vector4(pli.Color, 1) * surfaceColor;
// Specular
Vector3 vertexToEye0 = Vector3.Normalize(CameraInfo.CameraPosition_WorldSpace - input.Position_WorldSpace);
Vector3 lightReflect0 = Vector3.Normalize(Vector3.Reflect(ptLightDir, input.Normal));
float specularFactor0 = Vector3.Dot(vertexToEye0, lightReflect0);
if (specularFactor0 > 0)
{
specularFactor0 = Pow(Abs(specularFactor0), MaterialProperties.SpecularPower);
pointSpec += (1 - (lightDistance / pli.Range)) * (new Vector4(pli.Color * MaterialProperties.SpecularIntensity * specularFactor0, 1.0f));
}
}
return(Saturate(directionalSpecColor + directionalColor + pointSpec + pointDiffuse));
}
public Vector4 FragFunc(PixelInput input)
{
return(mapTexture.Sample(texSampler, input.UV));
}
public Vector4 FragFunc(PixelInput input)
{
return(getColor(input.Color, 1) * getOtherColor());
}
