/// <summary>
/// Returns the in parameters for a ShaderEffect, depending on the given ShaderEffectProps.
/// </summary>
/// <param name="effectProps">The ShaderEffectProps.</param>
/// <returns></returns>
public static string InParams(ShaderEffectProps effectProps)
{
var pxIn = new List <string>
{
GLSL.CreateIn(GLSL.Type.Vec3, VaryingNameDeclarations.ViewDirection),
GLSL.CreateIn(GLSL.Type.Vec4, VaryingNameDeclarations.Position),
GLSL.CreateIn(GLSL.Type.Vec3, VaryingNameDeclarations.CameraPosition)
};
if (effectProps.MeshProbs.HasColors)
{
pxIn.Add(GLSL.CreateIn(GLSL.Type.Vec3, VaryingNameDeclarations.Color));
}
if (effectProps.MeshProbs.HasNormals)
{
pxIn.Add(GLSL.CreateIn(GLSL.Type.Vec3, VaryingNameDeclarations.Normal));
}
if (effectProps.MeshProbs.HasTangents && effectProps.MeshProbs.HasBiTangents)
{
pxIn.Add(GLSL.CreateIn(GLSL.Type.Vec4, VaryingNameDeclarations.Tangent));
pxIn.Add(GLSL.CreateIn(GLSL.Type.Vec3, VaryingNameDeclarations.Bitangent));
}
if (effectProps.MeshProbs.HasUVs)
{
pxIn.Add(GLSL.CreateIn(GLSL.Type.Vec2, VaryingNameDeclarations.TextureCoordinates));
}
return(string.Join("\n", pxIn));
}
/// <summary>
/// Creates a ShaderEffectComponent from a MaterialComponent
/// </summary>
/// <param name="fxProps">The shader effect properties</param>
/// <param name="wc">Only pass over a WeightComponent if you use bone animations in the current node (usage: pass currentNode.GetWeights())</param>
/// <returns></returns>
/// <exception cref="Exception"></exception>
public static ShaderEffect MakeShaderEffectFromShaderEffectProps(ShaderEffectProps fxProps, Weight wc = null)
{
fxProps.MeshProbs = AnalyzeMesh(null);
var vs = CreateVertexShader(wc, fxProps);
var ps = CreatePixelShader(fxProps);
var effectParameters = AssembleEffectParamers(fxProps);
if (string.IsNullOrEmpty(vs) || string.IsNullOrEmpty(ps))
{
throw new Exception("Material could not be evaluated or be built!");
}
var ret = new ShaderEffect(new[]
{
new EffectPassDeclaration
{
VS = vs,
PS = ps,
StateSet = new RenderStateSet
{
ZEnable = true,
AlphaBlendEnable = true,
SourceBlend = Blend.SourceAlpha,
DestinationBlend = Blend.InverseSourceAlpha,
BlendOperation = BlendOperation.Add,
}
}
},
effectParameters
);
return(ret);
}
/// <summary>
/// Returns the pre defined Fusee uniform parameters of a vertex shader, depending on the given ShaderEffectProps.
/// </summary>
/// <param name="effectProps">The ShaderEffectProps.</param>
/// <returns></returns>
public static string FuseeUniforms(ShaderEffectProps effectProps)
{
var uniforms = new List <string>
{
GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.ModelView),
GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.ModelViewProjection)
};
if (effectProps.MeshProbs.HasNormals)
{
uniforms.Add(GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.ITModelView));
}
if (effectProps.MatProbs.HasSpecular && !effectProps.MeshProbs.HasWeightMap)
{
uniforms.Add(GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.IModelView));
}
if (effectProps.MeshProbs.HasWeightMap)
{
uniforms.Add(GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.View));
uniforms.Add(GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.Projection));
uniforms.Add(GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.IModelView));
uniforms.Add(GLSL.CreateUniform(GLSL.Type.Mat4, UniformNameDeclarations.Bones + "[" + HeaderShard.BoneDefineVar + "]"));
}
return(string.Join("\n", uniforms));
}
/// <summary>
/// Lighting Main method for forward rendering.
/// </summary>
/// <param name="effectProps">The <see cref="ShaderEffectProps"/> which function as a basis to build the correct lighting method.</param>
/// <returns></returns>
public static string ForwardLighting(ShaderEffectProps effectProps)
{
string fragColorAlpha = effectProps.MatProbs.HasAlbedo ? $"{UniformNameDeclarations.AlbedoColor}.w" : "1.0";
var fragMainBody = new List <string>
{
$"vec4 result = vec4(0,0,0,0);",
$"vec3 ambient = ambientLighting(0.2, {UniformNameDeclarations.AlbedoColor});",
$"for(int i = 0; i < {LightingShard.NumberOfLightsForward};i++)",
"{",
"if(allLights[i].isActive == 0) continue;",
"vec3 currentPosition = allLights[i].position;",
"vec4 currentIntensities = allLights[i].intensities;",
"vec3 currentConeDirection = allLights[i].direction;",
"float currentAttenuation = allLights[i].maxDistance;",
"float currentStrength = allLights[i].strength;",
"float currentOuterConeAngle = allLights[i].outerConeAngle;",
"float currentInnerConeAngle = allLights[i].innerConeAngle;",
"int currentLightType = allLights[i].lightType; ",
"result.rgb += ApplyLight(currentPosition, currentIntensities, currentConeDirection, ",
"currentAttenuation, currentStrength, currentOuterConeAngle, currentInnerConeAngle, currentLightType);",
"}",
effectProps.MatProbs.HasAlbedoTexture ? $"oFragmentColor = vec4(ambient + result.rgb, mix({UniformNameDeclarations.AlbedoColor}.a, texture({UniformNameDeclarations.AlbedoTexture}, {VaryingNameDeclarations.TextureCoordinates}).a, {UniformNameDeclarations.AlbedoMix}));" : $"oFragmentColor = vec4(result.rgb + ambient, {UniformNameDeclarations.AlbedoColor}.a);",
};
return(ShaderShardUtil.MainMethod(fragMainBody));
}
/// <summary>
/// Returns all uniforms, as they are given in the <see cref="MaterialProps"/> object.
/// </summary>
/// <param name="effectProps">The ShaderEffectProps.</param>
/// <returns></returns>
public static string MaterialPropsUniforms(ShaderEffectProps effectProps)
{
var matPropUnifroms = new List <string>();
if (effectProps.MatProbs.HasSpecular)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Vec4, UniformNameDeclarations.SpecularColor));
if (effectProps.MatType == MaterialType.MaterialPbr)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.RoughnessValue));
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.FresnelReflectance));
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.DiffuseFraction));
}
else if (effectProps.MatType == MaterialType.Standard)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.SpecularShininess));
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.SpecularIntensity));
}
}
if (effectProps.MatProbs.HasAlbedo)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Vec4, UniformNameDeclarations.AlbedoColor));
}
if (effectProps.MatProbs.HasEmissive)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Vec4, UniformNameDeclarations.EmissiveColor));
}
//Textures
if (effectProps.MatProbs.HasNormalMap)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Sampler2D, UniformNameDeclarations.NormalMap));
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.NormalMapIntensity));
}
if (effectProps.MatProbs.HasAlbedoTexture)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Sampler2D, UniformNameDeclarations.AlbedoTexture));
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.AlbedoMix));
}
if (effectProps.MatProbs.HasEmissiveTexture)
{
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Sampler2D, UniformNameDeclarations.EmissiveTexture));
matPropUnifroms.Add(GLSL.CreateUniform(GLSL.Type.Float, UniformNameDeclarations.EmissiveMix));
}
return(string.Join("\n", matPropUnifroms));
}
/// <summary>
/// Creates the in (with prefix "fu") and out parameters of the vertex shader, depending on the given ShaderEffectProps.
/// </summary>
/// <param name="effectProps">>The ShaderEffectProps.</param>
/// <returns></returns>
public static string InAndOutParams(ShaderEffectProps effectProps)
{
var vertProps = new List <string>
{
GLSL.CreateOut(GLSL.Type.Vec3, VaryingNameDeclarations.CameraPosition),
GLSL.CreateOut(GLSL.Type.Vec4, VaryingNameDeclarations.Position)
};
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec3, UniformNameDeclarations.Vertex));
if (effectProps.MeshProbs.HasTangents && effectProps.MeshProbs.HasBiTangents)
{
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec4, UniformNameDeclarations.TangentAttribName));
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec3, UniformNameDeclarations.BitangentAttribName));
vertProps.Add(GLSL.CreateOut(GLSL.Type.Vec4, VaryingNameDeclarations.Tangent));
vertProps.Add(GLSL.CreateOut(GLSL.Type.Vec3, VaryingNameDeclarations.Bitangent));
}
if (effectProps.MatProbs.HasSpecular)
{
vertProps.Add(GLSL.CreateOut(GLSL.Type.Vec3, VaryingNameDeclarations.ViewDirection));
}
if (effectProps.MeshProbs.HasWeightMap)
{
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec4, UniformNameDeclarations.BoneIndex));
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec4, UniformNameDeclarations.BoneWeight));
}
if (effectProps.MeshProbs.HasNormals)
{
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec3, UniformNameDeclarations.Normal));
vertProps.Add(GLSL.CreateOut(GLSL.Type.Vec3, VaryingNameDeclarations.Normal));
}
if (effectProps.MeshProbs.HasUVs)
{
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec2, UniformNameDeclarations.TextureCoordinates));
vertProps.Add(GLSL.CreateOut(GLSL.Type.Vec2, VaryingNameDeclarations.TextureCoordinates));
}
if (effectProps.MeshProbs.HasColors)
{
vertProps.Add(GLSL.CreateIn(GLSL.Type.Vec4, UniformNameDeclarations.Color));
vertProps.Add(GLSL.CreateOut(GLSL.Type.Vec4, VaryingNameDeclarations.Color));
}
return(string.Join("\n", vertProps));
}
private static string CreateProtoPixelShader(ShaderEffectProps effectProps)
{
var protoPixelShader = new List <string>
{
HeaderShard.Version300Es,
HeaderShard.EsPrecisionHighpFloat,
FragPropertiesShard.InParams(effectProps),
FragPropertiesShard.FuseeMatrixUniforms(),
FragPropertiesShard.MaterialPropsUniforms(effectProps),
};
return(string.Join("\n", protoPixelShader));
}
private static string CreateVertexShader(Weight wc, ShaderEffectProps effectProps)
{
var vertexShader = new List <string>
{
HeaderShard.Version300Es,
HeaderShard.DefineBones(effectProps, wc),
VertPropertiesShard.FuseeUniforms(effectProps),
VertPropertiesShard.InAndOutParams(effectProps),
};
// Main
vertexShader.Add(VertMainShard.VertexMain(effectProps));
return(string.Join("\n", vertexShader));
}
/// <summary>
/// Collects all lighting methods, dependent on what is defined in the given <see cref="ShaderEffectProps"/> and the LightingCalculationMethod.
/// </summary>
/// <param name="effectProps">The ShaderEffectProps.</param>
public static string AssembleLightingMethods(ShaderEffectProps effectProps)
{
var lighting = new List <string>
{
AttenuationPointComponent(),
AttenuationConeComponent(),
AmbientComponent()
};
//Adds methods to the PS that calculate the single light components (ambient, diffuse, specular)
switch (effectProps.MatType)
{
case MaterialType.Standard:
if (effectProps.MatProbs.HasAlbedo)
{
lighting.Add(DiffuseComponent());
}
if (effectProps.MatProbs.HasSpecular)
{
lighting.Add(SpecularComponent());
}
break;
case MaterialType.MaterialPbr:
if (effectProps.MatProbs.HasAlbedo)
{
lighting.Add(DiffuseComponent());
}
if (effectProps.MatProbs.HasSpecular)
{
lighting.Add(PbrSpecularComponent());
}
break;
default:
throw new ArgumentOutOfRangeException($"Material Type unknown or incorrect: {effectProps.MatType}");
}
lighting.Add(ApplyLightForward(effectProps));
return(string.Join("\n", lighting));
}
private static string CreatePixelShader(ShaderEffectProps effectProps)
{
var pixelShader = new List <string>
{
HeaderShard.Version300Es,
HeaderShard.EsPrecisionHighpFloat,
LightingShard.LightStructDeclaration,
FragPropertiesShard.InParams(effectProps),
FragPropertiesShard.FuseeMatrixUniforms(),
FragPropertiesShard.MaterialPropsUniforms(effectProps),
FragPropertiesShard.FixedNumberLightArray,
FragPropertiesShard.ColorOut(),
LightingShard.AssembleLightingMethods(effectProps)
};
//Calculates the lighting for all lights by using the above method
pixelShader.Add(FragMainShard.ForwardLighting(effectProps));
return(string.Join("\n", pixelShader));
}
/// <summary>
/// Creates the main method for the vertex shader, used in forward rendering.
/// The naming of the out parameters is the same as in the <see cref="VertPropertiesShard"/>.
/// </summary>
/// <param name="effectProps">The <see cref="ShaderEffectProps"/> is the basis to decide, which calculations need to be made. E.g. do we have a weight map? If so, adjust the gl_Position.</param>
/// <returns></returns>
public static string VertexMain(ShaderEffectProps effectProps)
{
var vertMainBody = new List <string>
{
"gl_PointSize = 10.0;"
};
if (effectProps.MeshProbs.HasNormals && effectProps.MeshProbs.HasWeightMap)
{
vertMainBody.Add("vec4 newVertex;");
vertMainBody.Add("vec4 newNormal;");
vertMainBody.Add(
$"newVertex = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.x)] * vec4({UniformNameDeclarations.Vertex}, 1.0) ) * {UniformNameDeclarations.BoneWeight}.x ;");
vertMainBody.Add(
$"newNormal = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.x)] * vec4({UniformNameDeclarations.Normal}, 0.0)) * {UniformNameDeclarations.BoneWeight}.x;");
vertMainBody.Add(
$"newVertex = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.y)] * vec4({UniformNameDeclarations.Vertex}, 1.0)) * {UniformNameDeclarations.BoneWeight}.y + newVertex;");
vertMainBody.Add(
$"newNormal = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.y)] * vec4({UniformNameDeclarations.Normal}, 0.0)) * {UniformNameDeclarations.BoneWeight}.y + newNormal;");
vertMainBody.Add(
$"newVertex = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.z)] * vec4({UniformNameDeclarations.Vertex}, 1.0)) * {UniformNameDeclarations.BoneWeight}.z + newVertex;");
vertMainBody.Add(
$"newNormal = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.z)] * vec4({UniformNameDeclarations.Normal}, 0.0)) * {UniformNameDeclarations.BoneWeight}.z + newNormal;");
vertMainBody.Add(
$"newVertex = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.w)] * vec4({UniformNameDeclarations.Vertex}, 1.0)) * {UniformNameDeclarations.BoneWeight}.w + newVertex;");
vertMainBody.Add(
$"newNormal = ({UniformNameDeclarations.Bones}[int({UniformNameDeclarations.BoneIndex}.w)] * vec4({UniformNameDeclarations.Normal}, 0.0)) * {UniformNameDeclarations.BoneWeight}.w + newNormal;");
// At this point the normal is in World space - transform back to model space
vertMainBody.Add($"{VaryingNameDeclarations.Normal} = mat3({UniformNameDeclarations.ITModelView}) * newNormal.xyz;");
}
if (effectProps.MatProbs.HasSpecular)
{
vertMainBody.Add($"vec3 vCamPos = {UniformNameDeclarations.IModelView}[3].xyz;");
vertMainBody.Add(effectProps.MeshProbs.HasWeightMap
? $"{VaryingNameDeclarations.ViewDirection} = normalize({VaryingNameDeclarations.CameraPosition} - vec3(newVertex));"
: $"{VaryingNameDeclarations.ViewDirection} = normalize({VaryingNameDeclarations.CameraPosition} - {UniformNameDeclarations.Vertex});");
}
if (effectProps.MeshProbs.HasUVs)
{
vertMainBody.Add($"{VaryingNameDeclarations.TextureCoordinates} = fuUV;");
}
if (effectProps.MeshProbs.HasNormals && !effectProps.MeshProbs.HasWeightMap)
{
vertMainBody.Add($"{VaryingNameDeclarations.Normal} = normalize(mat3({UniformNameDeclarations.ITModelView}) * {UniformNameDeclarations.Normal});");
}
vertMainBody.Add($"{VaryingNameDeclarations.Position} = ({UniformNameDeclarations.ModelView} * vec4({UniformNameDeclarations.Vertex}, 1.0));");
if (effectProps.MeshProbs.HasTangents && effectProps.MeshProbs.HasBiTangents)
{
vertMainBody.Add($"{VaryingNameDeclarations.Tangent} = {UniformNameDeclarations.TangentAttribName};");
vertMainBody.Add($"{VaryingNameDeclarations.Bitangent} = {UniformNameDeclarations.BitangentAttribName};");
}
vertMainBody.Add(effectProps.MeshProbs.HasWeightMap
? $"gl_Position = {UniformNameDeclarations.ModelViewProjection} * vec4(vec3(newVertex), 1.0);"
: $"gl_Position = {UniformNameDeclarations.ModelViewProjection} * vec4({UniformNameDeclarations.Vertex}, 1.0);");
return(ShaderShardUtil.MainMethod(vertMainBody));
}
/// <summary>
/// Wraps all the lighting methods into a single one.
/// </summary>
public static string ApplyLightForward(ShaderEffectProps effectProps)
{
var bumpNormals = new List <string>
{
"///////////////// Normal mapping, tangent space ///////////////////",
$"vec3 N = ((texture({UniformNameDeclarations.NormalMap}, {VaryingNameDeclarations.TextureCoordinates}).rgb * 2.0) - 1.0f) * vec3({UniformNameDeclarations.NormalMapIntensity}, {UniformNameDeclarations.NormalMapIntensity}, 1.0);",
$"N = (N.x * vec3({VaryingNameDeclarations.Tangent})) + (N.y * {VaryingNameDeclarations.Bitangent}) + (N.z * {VaryingNameDeclarations.Normal});",
"N = normalize(N);"
};
var normals = new List <string>
{
$"vec3 N = normalize({VaryingNameDeclarations.Normal});"
};
var fragToLightDirAndLightInit = new List <string>
{
"vec3 L = vec3(0.0, 0.0, 0.0);",
"if(lightType == 1){L = -normalize(direction);}",
"else",
"{",
$" L = normalize(position - {VaryingNameDeclarations.Position}.xyz);",
"}",
$"vec3 V = normalize(-{VaryingNameDeclarations.Position}.xyz);",
"if(lightType == 3) {",
" L = normalize(vec3(0.0,0.0,-1.0));",
"}",
$"vec2 o_texcoords = {VaryingNameDeclarations.TextureCoordinates};",
"",
"vec3 Idif = vec3(0);",
"vec3 Ispe = vec3(0);",
""
};
var applyLightParams = new List <string>();
applyLightParams.AddRange(effectProps.MatProbs.HasNormalMap ? bumpNormals : normals);
applyLightParams.AddRange(fragToLightDirAndLightInit);
if (effectProps.MatProbs.HasAlbedo)
{
//TODO: Test alpha blending between diffuse and texture
if (effectProps.MatProbs.HasAlbedoTexture)
{
applyLightParams.Add(
$"vec3 blendedCol = mix({UniformNameDeclarations.AlbedoColor}.rgb, texture({UniformNameDeclarations.AlbedoTexture}, {VaryingNameDeclarations.TextureCoordinates}).rgb, {UniformNameDeclarations.AlbedoMix});" +
$"Idif = blendedCol * diffuseLighting(N, L) * intensities.rgb;");
}
else
{
applyLightParams.Add($"Idif = vec3({UniformNameDeclarations.AlbedoColor}.rgb * intensities.rgb * diffuseLighting(N, L));");
}
}
if (effectProps.MatProbs.HasSpecular)
{
if (effectProps.MatType == MaterialType.Standard)
{
applyLightParams.Add($"float specularTerm = specularLighting(N, L, V, {UniformNameDeclarations.SpecularShininess});");
applyLightParams.Add($"Ispe = vec3(({ UniformNameDeclarations.SpecularColor}.rgb * { UniformNameDeclarations.SpecularIntensity} *intensities.rgb) *specularTerm);");
}
else if (effectProps.MatType == MaterialType.MaterialPbr)
{
applyLightParams.Add($"float k = 1.0 - {UniformNameDeclarations.DiffuseFraction};");
applyLightParams.Add("float specular = specularLighting(N, L, V, k);");
applyLightParams.Add($"Ispe = intensities.rgb * {UniformNameDeclarations.SpecularColor}.rgb * (k + specular * (1.0 - k));");
}
}
var pointLight = new List <string>
{
$"float att = attenuationPointComponent({VaryingNameDeclarations.Position}.xyz, position, maxDistance);",
"lighting = (Idif * att) + (Ispe * att);",
"lighting *= strength;"
};
//No attenuation!
var parallelLight = new List <string>
{
"lighting = Idif + Ispe;",
"lighting *= strength;"
};
var spotLight = new List <string>
{
$"float att = attenuationPointComponent({VaryingNameDeclarations.Position}.xyz, position, maxDistance) * attenuationConeComponent(direction, L, innerConeAngle, outerConeAngle);",
"lighting = (Idif * att) + (Ispe * att);",
"lighting *= strength;"
};
// - Disable GammaCorrection for better colors
/*var gammaCorrection = new List<string>()
* {
* "vec3 gamma = vec3(1.0/2.2);",
* "result = pow(result, gamma);"
* };*/
var methodBody = new List <string>();
methodBody.AddRange(applyLightParams);
methodBody.Add("vec3 lighting = vec3(0);");
methodBody.Add("");
//methodBody.AddRange(attenuation);
methodBody.Add("if(lightType == 0) // PointLight");
methodBody.Add("{");
methodBody.AddRange(pointLight);
methodBody.Add("}");
methodBody.Add("else if(lightType == 1 || lightType == 3) // ParallelLight or LegacyLight");
methodBody.Add("{");
methodBody.AddRange(parallelLight);
methodBody.Add("}");
methodBody.Add("else if(lightType == 2) // SpotLight");
methodBody.Add("{");
methodBody.AddRange(spotLight);
methodBody.Add("}");
methodBody.Add("");
//methodBody.AddRange(gammaCorrection); // - Disable GammaCorrection for better colors
methodBody.Add("");
methodBody.Add("return lighting;");
return(GLSL.CreateMethod(GLSL.Type.Vec3, "ApplyLight",
new[]
{
GLSL.CreateVar(GLSL.Type.Vec3, "position"), GLSL.CreateVar(GLSL.Type.Vec4, "intensities"),
GLSL.CreateVar(GLSL.Type.Vec3, "direction"), GLSL.CreateVar(GLSL.Type.Float, "maxDistance"),
GLSL.CreateVar(GLSL.Type.Float, "strength"), GLSL.CreateVar(GLSL.Type.Float, "outerConeAngle"),
GLSL.CreateVar(GLSL.Type.Float, "innerConeAngle"), GLSL.CreateVar(GLSL.Type.Int, "lightType"),
}, methodBody));
}
private static IEnumerable <EffectParameterDeclaration> AssembleEffectParamers(ShaderEffectProps fxProps)
{
var effectParameters = new List <EffectParameterDeclaration>();
if (fxProps.MatProbs.HasAlbedo)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.AlbedoColor,
Value = fxProps.MatValues.AlbedoColor
});
if (fxProps.MatValues.AlbedoTexture != null)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.AlbedoMix,
Value = fxProps.MatValues.AlbedoMix
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.AlbedoTexture,
Value = LoadTexture(fxProps.MatValues.AlbedoTexture)
});
}
}
if (fxProps.MatProbs.HasSpecular)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.SpecularColor,
Value = fxProps.MatValues.SpecularColor
});
if (fxProps.MatType == MaterialType.Standard)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.SpecularShininess,
Value = fxProps.MatValues.SpecularShininess
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.SpecularIntensity,
Value = fxProps.MatValues.SpecularIntensity
});
if (fxProps.MatValues.SpecularTexture != null)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.SpecularMix,
Value = fxProps.MatValues.SpecularMix
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.SpecularTexture,
Value = LoadTexture(fxProps.MatValues.SpecularTexture)
});
}
}
else if (fxProps.MatType == MaterialType.MaterialPbr)
{
var mcPbr = fxProps.MatValues;
var delta = 0.0000001f;
var diffuseFractionDelta = 0.99999f; //The value of the diffuse fraction is (incorrectly) the "Metallic" value of the Principled BSDF Material. If it is zero the result here will be by far to bright.
var roughness = mcPbr.RoughnessValue + delta; // always float, never int!
var fresnel = mcPbr.FresnelReflectance + delta;
var df = mcPbr.DiffuseFraction == 0 ? diffuseFractionDelta : mcPbr.DiffuseFraction + delta;
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.RoughnessValue,
Value = roughness
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.FresnelReflectance,
Value = fresnel
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.DiffuseFraction,
Value = df
});
}
}
if (fxProps.MatProbs.HasEmissive)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.EmissiveColor,
Value = fxProps.MatValues.EmissiveColor
});
if (fxProps.MatValues.EmissiveTexture != null)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.EmissiveMix,
Value = fxProps.MatValues.EmissiveMix
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.EmissiveTexture,
Value = LoadTexture(fxProps.MatValues.EmissiveTexture)
});
}
}
if (fxProps.MatProbs.HasNormalMap)
{
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.NormalMapIntensity,
Value = fxProps.MatValues.NormalMapIntensity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.NormalMap,
Value = LoadTexture(fxProps.MatValues.NormalMap)
});
}
for (var i = 0; i < LightingShard.NumberOfLightsForward; i++)
{
if (!LightingShard.LightPararamStringsAllLights.ContainsKey(i))
{
LightingShard.LightPararamStringsAllLights.Add(i, new LightParamStrings(i));
}
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].PositionViewSpace,
Value = new float3(0, 0, -1.0f)
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].Intensities,
Value = float4.Zero
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].MaxDistance,
Value = 0.0f
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].Strength,
Value = 0.0f
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].OuterAngle,
Value = 0.0f
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].InnerAngle,
Value = 0.0f
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].Direction,
Value = float3.Zero
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].LightType,
Value = 1
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].IsActive,
Value = 1
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].IsCastingShadows,
Value = 0
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = LightingShard.LightPararamStringsAllLights[i].Bias,
Value = 0f
});
}
// FUSEE_ PARAMS
// TODO: Just add the necessary ones!
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.Model,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.ModelView,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.ModelViewProjection,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.ITModelView,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.IModelView,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.ITView,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.View,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.Projection,
Value = float4x4.Identity
});
effectParameters.Add(new EffectParameterDeclaration
{
Name = UniformNameDeclarations.BonesArray,
Value = new[] { float4x4.Identity }
});
return(effectParameters);
}
/// <summary>
/// Build a complex shader by specifying the <see cref="ShaderEffectProps"/> explicitly.
/// </summary>
/// <param name="fxProps">The ShaderEffectProps to use (including values)</param>
/// <returns></returns>
public static ShaderEffect MakeShaderEffect(ShaderEffectProps fxProps)
{
return(MakeShaderEffectFromShaderEffectProps(fxProps));
}
/// <summary>
/// Build a complex shader by specifying the <see cref="ShaderEffectProps"/> explicitly.
/// </summary>
/// <param name="fxProps">The ShaderEffectProps to use (including values)</param>
/// <returns>a new ShaderEffectProtoPixel</returns>
public static ShaderEffectProtoPixel MakeShaderEffectProto(ShaderEffectProps fxProps)
{
return(MakeShaderEffectFromShaderEffectPropsProto(fxProps));
}
/// <summary>
/// The main method for rendering into a G-Buffer object.
/// </summary>
/// <param name="effectProps">The ShaderEffectProps.</param>
/// <returns></returns>
public static string RenderToGBuffer(ShaderEffectProps effectProps)
{
var fragMainBody = new List <string>();
var ssaoString = "Ssao";
for (int i = 0; i < UniformNameDeclarations.DeferredRenderTextures.Count; i++)
{
var texName = UniformNameDeclarations.DeferredRenderTextures[i];
if (texName == ssaoString)
{
continue;
}
switch (i)
{
case (int)RenderTargetTextureTypes.Position:
fragMainBody.Add($"{texName} = vec4({VaryingNameDeclarations.Position});");
break;
case (int)RenderTargetTextureTypes.Albedo:
if (effectProps.MatProbs.HasAlbedoTexture)
{
fragMainBody.Add($"{texName} = vec4(mix({UniformNameDeclarations.AlbedoColor}.xyz, texture({UniformNameDeclarations.AlbedoTexture}, {VaryingNameDeclarations.TextureCoordinates}).xyz, {UniformNameDeclarations.AlbedoMix}), 1.0);");
}
else
{
fragMainBody.Add($"{texName} = vec4({UniformNameDeclarations.AlbedoColor}.xyz, 1.0);");
}
break;
case (int)RenderTargetTextureTypes.Normal:
fragMainBody.Add($"{texName} = vec4(normalize({VaryingNameDeclarations.Normal}.xyz), 1.0);");
break;
case (int)RenderTargetTextureTypes.Depth:
fragMainBody.Add($"{texName} = vec4(gl_FragCoord.z, gl_FragCoord.z, gl_FragCoord.z, 1.0);");
break;
case (int)RenderTargetTextureTypes.Specular:
{
if (effectProps.MatProbs.HasSpecular)
{
if (effectProps.MatType == MaterialType.MaterialPbr)
{
fragMainBody.Add($"{texName} = vec4({UniformNameDeclarations.RoughnessValue}, {UniformNameDeclarations.FresnelReflectance}, {UniformNameDeclarations.DiffuseFraction}, 1.0);");
}
else if (effectProps.MatType == MaterialType.Standard)
{
fragMainBody.Add($"{texName} = vec4({UniformNameDeclarations.SpecularIntensity}, {UniformNameDeclarations.SpecularShininess}/256.0, 1.0, 1.0);");
}
}
else
{
fragMainBody.Add($"{texName} = vec4(0.0, 0.0, 1.0, 1.0);");
}
break;
}
}
}
return(ShaderShardUtil.MainMethod(fragMainBody));
}
