public void Bind(GLShaderProgram shaderProgram)
{
shaderProgram.SetUniform("uMatHasDiffuse", HasDiffuseTexture);
if (HasDiffuseTexture)
{
DiffuseTexture.Bind();
}
shaderProgram.SetUniform("uMatAmbient", Ambient);
shaderProgram.SetUniform("uMatDiffuse", Diffuse);
shaderProgram.SetUniform("uMatSpecular", Specular);
shaderProgram.SetUniform("uMatEmissive", Emissive);
shaderProgram.SetUniform("uMatHasAlphaTransparency", HasAlphaTransparency);
if (RenderWireframe)
{
GL.PolygonMode(MaterialFace.FrontAndBack, PolygonMode.Line);
}
if (!EnableBackfaceCulling)
{
GL.Disable(EnableCap.CullFace);
}
}
public void Bind()
{
// load shaders here when we have them
// GL 1.X pipeline
if (DiffuseName == string.Empty)
{
GL.Disable(EnableCap.Texture2D);
}
else
{
GL.Enable(EnableCap.Texture2D);
if (DiffuseTexture == null)
{
DiffuseName = string.Empty;
GL.Disable(EnableCap.Texture2D);
}
else
{
DiffuseTexture.Bind();
}
}
GL.Color4(DiffuseColor);
}
private bool mDisposed; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!mDisposed)
{
if (disposing)
{
DiffuseTexture?.Dispose();
}
mDisposed = true;
}
}
public override IEnumerable <Object> FetchDependencies(ISerializedFile file, bool isLog = false)
{
foreach (Object asset in base.FetchDependencies(file, isLog))
{
yield return(asset);
}
yield return(DiffuseTexture.FetchDependency(file, isLog, ToLogString, DiffuseTextureName));
yield return(NormalMapTexture.FetchDependency(file, isLog, ToLogString, NormalMapTextureName));
yield return(MaskMapTexture.FetchDependency(file, isLog, ToLogString, MaskMapTextureName));
}
public override void Read(AssetReader reader)
{
base.Read(reader);
DiffuseTexture.Read(reader);
NormalMapTexture.Read(reader);
MaskMapTexture.Read(reader);
TileSize.Read(reader);
TileOffset.Read(reader);
Specular.Read(reader);
Metallic = reader.ReadSingle();
Smoothness = reader.ReadSingle();
NormalScale = reader.ReadSingle();
DiffuseRemapMin.Read(reader);
DiffuseRemapMax.Read(reader);
MaskMapRemapMin.Read(reader);
MaskMapRemapMax.Read(reader);
}
protected override YAMLMappingNode ExportYAMLRoot(IExportContainer container)
{
YAMLMappingNode node = base.ExportYAMLRoot(container);
node.Add(DiffuseTextureName, DiffuseTexture.ExportYAML(container));
node.Add(NormalMapTextureName, NormalMapTexture.ExportYAML(container));
node.Add(MaskMapTextureName, MaskMapTexture.ExportYAML(container));
node.Add(TileSizeName, TileSize.ExportYAML(container));
node.Add(TileOffsetName, TileOffset.ExportYAML(container));
node.Add(SpecularName, Specular.ExportYAML(container));
node.Add(MetallicName, Metallic);
node.Add(SmoothnessName, Smoothness);
node.Add(NormalScaleName, NormalScale);
node.Add(DiffuseRemapMinName, DiffuseRemapMin.ExportYAML(container));
node.Add(DiffuseRemapMaxName, DiffuseRemapMax.ExportYAML(container));
node.Add(MaskMapRemapMinName, MaskMapRemapMin.ExportYAML(container));
node.Add(MaskMapRemapMaxName, MaskMapRemapMax.ExportYAML(container));
return(node);
}
public void Dispose()
{
if (IndexBuffer != null)
{
IndexBuffer.Dispose();
}
if (VertexBuffer != null)
{
VertexBuffer.Dispose();
}
if (VertexDecl != null)
{
VertexDecl.Dispose();
}
if (DiffuseTexture != null)
{
DiffuseTexture.Dispose();
}
if (NormalTexture != null)
{
NormalTexture.Dispose();
}
}
internal virtual void SyncChanges()
{
// if (Shader == null)
// Shader = new Shader("Shaders/forward.vert", "Shaders/forward.frag");
// if (DefGeometryShader == null)
// DefGeometryShader = new Shader("Shaders/deferred-gbuffer.vert", "Shaders/deferred-gbuffer.frag");
// if (ShadowShader == null)
// ShadowShader = new Shader("Shaders/shadow-directional.vert", "Shaders/shadow-directional.frag", "Shaders/shadow-directional.geom");
// if (CubeShadowShader == null)
// CubeShadowShader = new Shader("Shaders/shadow-cube.vert", "Shaders/shadow-cube.frag", "Shaders/shadow-cube.geom");
DiffuseTexture?.Sync();
SpecularTexture?.Sync();
if (RendererMaterial == null)
{
RendererMaterial = new RendererMaterial();
if (Shader == null)
{
Shader = new Shader("Shaders/forward.vert", "Shaders/forward.frag");
}
if (DefGeometryShader == null)
{
DefGeometryShader = new Shader("Shaders/deferred-gbuffer.vert", "Shaders/deferred-gbuffer.frag");
}
if (DiffuseTexture != null || SpecularTexture != null)
{
Defines.Add("USE_VERTEX_UV", "1");
}
if (UseVertexColor)
{
Defines.Add("USE_VERTEX_COLOR", "1");
}
if (ReceiveShadow && Renderer.Current.UseShadows)
{
Defines.Add("USE_SHADOW", "1");
}
RendererMaterial.Shader = new RendererShader(Shader.VertexShaderPath, Shader.FragmentShaderPath, Shader.GeometryShaderPath, true, Defines);
RendererMaterial.DefGeometryShader = new RendererShader(DefGeometryShader.VertexShaderPath, DefGeometryShader.FragmentShaderPath, DefGeometryShader.GeometryShaderPath, true, Defines);
RendererMaterial.CreateShaders();
}
var mat = RendererMaterial;
if (DiffuseTexture == null)
{
mat.DiffuseMap = InternalTextureManager.White;
mat.DiffuseColor = Color;
}
else
{
mat.DiffuseMap = DiffuseTexture.RendererTexture;
mat.DiffuseColor = Color;
}
if (SpecularTexture == null)
{
mat.SpecularMap = InternalTextureManager.White;
mat.SpecularStrength = SpecularStrength;
}
else
{
mat.SpecularMap = SpecularTexture.RendererTexture;
mat.SpecularStrength = 1.0f;
}
mat.CastShadow = CastShadow;
mat.Ambient = Ambient;
mat.Shininess = Shininess;
mat.UseVertexColor = UseVertexColor;
var pipelineType = PipelineType;
if (pipelineType == PipelineType.Default)
{
if (UseTransparency || !ReceiveShadow)
{
pipelineType = PipelineType.Forward;
}
}
switch (pipelineType)
{
case PipelineType.Default:
mat.RenderPipeline = RenderContext.Current.PrimaryRenderPipeline;
break;
case PipelineType.Forward:
mat.RenderPipeline = RenderContext.Current.GetPipeline <ForwardRenderPipeline>();
break;
case PipelineType.Deferred:
mat.RenderPipeline = RenderContext.Current.GetPipeline <DeferredRenderPipeline>();
break;
case PipelineType.Screen:
mat.RenderPipeline = RenderContext.Current.GetPipeline <ScreenPipeline>();
break;
}
foreach (var param in Parameters.Values)
{
if (param.HasChanges)
{
param.HasChanges = false;
switch (param.Type)
{
case ParamterType.Bool:
mat.Shader.SetBool(param.Name, (bool)param.Value);
mat.DefGeometryShader.SetBool(param.Name, (bool)param.Value);
break;
case ParamterType.Int:
mat.Shader.SetInt(param.Name, (int)param.Value);
mat.DefGeometryShader.SetInt(param.Name, (int)param.Value);
break;
case ParamterType.Float:
mat.Shader.SetFloat(param.Name, (float)param.Value);
mat.DefGeometryShader.SetFloat(param.Name, (float)param.Value);
break;
case ParamterType.Vector2:
mat.Shader.SetVector2(param.Name, (Vector2)param.Value);
mat.DefGeometryShader.SetVector2(param.Name, (Vector2)param.Value);
break;
case ParamterType.Vector3:
mat.Shader.SetVector3(param.Name, (Vector3)param.Value);
mat.DefGeometryShader.SetVector3(param.Name, (Vector3)param.Value);
break;
case ParamterType.Vector4:
mat.Shader.SetVector4(param.Name, (Vector4)param.Value);
mat.DefGeometryShader.SetVector4(param.Name, (Vector4)param.Value);
break;
case ParamterType.Matrix4:
mat.Shader.SetMatrix4(param.Name, (Matrix4)param.Value);
mat.DefGeometryShader.SetMatrix4(param.Name, (Matrix4)param.Value);
break;
}
}
}
}
