private static void SetBlendState(RMaterial meshMaterial, MatlAttribute a)
{
var blendState = (MatlAttribute.MatlBlendState)a.DataObject;
// TODO: Does "src factor" toggle something in the shader?
meshMaterial.BlendSrc = BlendingFactor.One;
if (blendState.Unk1 == 0)
{
meshMaterial.BlendSrc = BlendingFactor.Zero;
}
if (blendState.BlendFactor2 == 1)
{
meshMaterial.BlendDst = BlendingFactor.One;
}
else if (blendState.BlendFactor2 == 2)
{
meshMaterial.BlendDst = BlendingFactor.SrcAlpha;
}
else if (blendState.BlendFactor2 == 6)
{
meshMaterial.BlendDst = BlendingFactor.OneMinusSrcAlpha;
}
// TODO: Do both need to be set?
meshMaterial.UseAlphaSampleCoverage = blendState.Unk7 == 1 || blendState.Unk8 == 1;
}
private static void SetSamplerInformation(RMaterial material, MatlAttribute a)
{
var samplerStruct = (MatlAttribute.MatlSampler)a.DataObject;
SamplerObject sampler = new SamplerObject
{
TextureWrapS = MatlToGl.GetWrapMode(samplerStruct.WrapS),
TextureWrapT = MatlToGl.GetWrapMode(samplerStruct.WrapT),
TextureWrapR = MatlToGl.GetWrapMode(samplerStruct.WrapR),
MagFilter = MatlToGl.GetMagFilter(samplerStruct.MagFilter),
MinFilter = MatlToGl.GetMinFilter(samplerStruct.MinFilter)
};
GL.SamplerParameter(sampler.Id, SamplerParameterName.TextureLodBias, samplerStruct.LodBias);
if (samplerStruct.Unk6 == 2 && RenderSettings.Instance.EnableExperimental)
{
GL.SamplerParameter(sampler.Id, SamplerParameterName.TextureMaxAnisotropyExt, (float)samplerStruct.MaxAnisotropy);
}
else
{
GL.SamplerParameter(sampler.Id, SamplerParameterName.TextureMaxAnisotropyExt, 1.0f);
}
material.samplerByParamId[a.ParamId] = sampler;
}
private static void SetTextureParameter(RMaterial meshMaterial, MatlAttribute a)
{
// Don't make texture names case sensitive.
var textureName = ((MatlAttribute.MatlString)a.DataObject).Text.ToLower();
meshMaterial.textureNameByParamId[a.ParamId] = textureName;
}
private static void SetRasterizerState(RMaterial meshMaterial, MatlAttribute a)
{
var rasterizerState = (MatlAttribute.MatlRasterizerState)a.DataObject;
meshMaterial.DepthBias = rasterizerState.DepthBias;
meshMaterial.CullMode = MatlToGl.GetCullMode(rasterizerState.CullMode);
}
public void SetMaterialUniforms(Shader shader, RMaterial previousMaterial)
{
// TODO: This code could be moved to the constructor.
if (genericMaterial == null || shouldUpdateTextures)
{
genericMaterial = CreateGenericMaterial();
shouldUpdateTextures = true;
}
if (uniformBlock == null)
{
uniformBlock = new UniformBlock(shader, "MaterialParams")
{
BlockBinding = 1
};
SetMaterialParams(uniformBlock);
}
if (shouldUpdateUniformBlock)
{
SetMaterialParams(uniformBlock);
shouldUpdateUniformBlock = false;
}
// This needs to be updated more than once.
AddDebugParams(uniformBlock);
// Update the uniform values.
genericMaterial.SetShaderUniforms(shader, previousMaterial?.genericMaterial);
uniformBlock.BindBlock(shader);
}
private static void SetBlendState(RMaterial meshMaterial, MatlAttribute.MatlBlendState blendState)
{
meshMaterial.SourceColor = blendState.SourceColor.ToOpenTk();
meshMaterial.DestinationColor = blendState.DestinationColor.ToOpenTk();
meshMaterial.EnableAlphaSampleCoverage = blendState.EnableAlphaSampleToCoverage != 0;
}
private static void SetRasterizerState(RMaterial meshMaterial, MatlAttribute.MatlRasterizerState rasterizerState)
{
meshMaterial.DepthBias = rasterizerState.DepthBias;
meshMaterial.CullMode = rasterizerState.CullMode.ToOpenTk();
meshMaterial.EnableFaceCulling = rasterizerState.CullMode != MatlCullMode.None;
meshMaterial.FillMode = rasterizerState.FillMode.ToOpenTk();
}
public static RMaterial CreateMaterial(MatlEntry currentEntry, int index, Dictionary <string, RTexture> textureByName)
{
RMaterial meshMaterial = new RMaterial(currentEntry.MaterialLabel, currentEntry.ShaderLabel, index)
{
TextureByName = textureByName
};
foreach (var pair in currentEntry.GetTextures())
{
// Don't make texture names case sensitive.
meshMaterial.UpdateTexture(pair.Key, pair.Value.ToLower());
}
foreach (var pair in currentEntry.GetFloats())
{
meshMaterial.UpdateFloat(pair.Key, pair.Value);
}
foreach (var pair in currentEntry.GetVectors())
{
meshMaterial.UpdateVec4(pair.Key, pair.Value.ToOpenTk());
}
foreach (var pair in currentEntry.GetBools())
{
meshMaterial.UpdateBoolean(pair.Key, pair.Value);
}
foreach (var pair in currentEntry.GetSamplers())
{
meshMaterial.UpdateSampler(pair.Key, pair.Value.ToSamplerData());
}
foreach (var pair in currentEntry.GetRasterizerStates())
{
SetRasterizerState(meshMaterial, pair.Value);
}
foreach (var pair in currentEntry.GetBlendStates())
{
SetBlendState(meshMaterial, pair.Value);
}
return(meshMaterial);
}
public static RMaterial CreateMaterial(MatlEntry currentEntry, int index, Dictionary <string, RTexture> textureByName)
{
RMaterial meshMaterial = new RMaterial()
{
MaterialLabel = currentEntry.MaterialLabel,
ShaderLabel = currentEntry.ShaderLabel,
Index = index,
TextureByName = textureByName
};
foreach (MatlAttribute attribute in currentEntry.Attributes)
{
if (attribute.DataObject == null)
{
continue;
}
switch (attribute.DataType)
{
case MatlEnums.ParamDataType.String:
SetTextureParameter(meshMaterial, attribute);
break;
case MatlEnums.ParamDataType.Vector4:
var vec4 = (MatlAttribute.MatlVector4)attribute.DataObject;
meshMaterial.vec4ByParamId[attribute.ParamId] = new Vector4(vec4.X, vec4.Y, vec4.Z, vec4.W);
break;
case MatlEnums.ParamDataType.Boolean:
// Convert to vec4 to use with rendering.
// Use cyan to differentiate with no value (blue).
bool boolValue = (bool)attribute.DataObject;
meshMaterial.boolByParamId[attribute.ParamId] = boolValue;
break;
case MatlEnums.ParamDataType.Float:
float floatValue = (float)attribute.DataObject;
meshMaterial.floatByParamId[attribute.ParamId] = floatValue;
break;
case MatlEnums.ParamDataType.BlendState:
SetBlendState(meshMaterial, attribute);
break;
case MatlEnums.ParamDataType.RasterizerState:
SetRasterizerState(meshMaterial, attribute);
break;
}
}
foreach (MatlAttribute a in currentEntry.Attributes)
{
if (a.DataObject == null || a.DataType != MatlEnums.ParamDataType.Sampler)
{
continue;
}
SetSamplerInformation(meshMaterial, a);
}
return(meshMaterial);
}
