public override int GetHashCode()
{
int result = 0;
if (SplatTexutre != null)
{
for (int i = 0; i < SplatTexutre.Length; i++)
{
result ^= SplatTexutre[i].GetHashCode() + 1;
}
}
if (MaterialTexture != null)
{
for (int i = 0; i < MaterialTexture.Length; i++)
{
if (MaterialTexture[i] != null)
{
result ^= MaterialTexture[i].GetHashCode() + 1;
}
}
}
return(GetType().GetHashCode() ^
(XMesh != null ? XMesh.GetHashCode() : 1) ^
(Mesh != null ? Mesh.GetHashCode() : 1) ^
(Texture != null ? Texture.GetHashCode() : 1) ^
(SkinnedMesh != null ? SkinnedMesh.GetHashCode() : 1) ^
(BaseTexture != null ? BaseTexture.GetHashCode() : 1) ^
(SpecularTexture != null ? SpecularTexture.GetHashCode() : 1) ^
result);
}
public override Vector3 F(ShadeRec sr, Vector3 wo, Vector3 wi)
{
Vector3 L = Vector3.Zero();
float ndotwi = Vector3.Dot(sr.Normal, wi);
Vector3 r = -wi + 2.0f * sr.Normal * ndotwi;
float rdotwo = Vector3.Dot(r, wo);
if (rdotwo > 0.0)
{
L = ReflectionCoefficient * SpecularTexture.GetColor(sr) * MathUtil.Pow(rdotwo, Exponent);
}
return(L);
}
public override Vector3 Sample_F(ShadeRec sr, Vector3 wo, ref Vector3 wi, ref float pdf)
{
float ndotwo = Vector3.Dot(sr.Normal, wo);
Vector3 r = -wo + 2.0f * sr.Normal * ndotwo; // direction of mirror reflection
Vector3 w = r;
Vector3 u = Vector3.Cross(new Vector3(0.00424f, 1, 0.00764f), w);
u.Normalize();
Vector3 v = Vector3.Cross(u, w);
Vector3 sp = Sampler.SampleHemisphere();
wi = sp.X * u + sp.Y * v + sp.Z * w; // reflected ray direction
if (Vector3.Dot(sr.Normal, wi) < 0.0) // reflected ray is below tangent plane
{
wi = -sp.X * u - sp.Y * v + sp.Z * w;
}
float phong_lobe = MathUtil.Pow(Vector3.Dot(r, wi), Exponent);
pdf = phong_lobe * (Vector3.Dot(sr.Normal, wi));
return(ReflectionCoefficient * SpecularTexture.GetColor(sr) * phong_lobe);
}
public bool Use()
{
var prg = GetShaderProgram();
if (lastUserProgram == null)
{
lastUserProgram = ShaderProgram.Current;
}
ShaderProgram.SwitchResult res = prg.Use();
//prg.SetUniform("MaterialIndex", BufferOffset);
prg.SetUniform("IsTessellatedTerrain", Type == MaterialType.TessellatedTerrain);
prg.SetUniform("TessellationMultiplier", TessellationMultiplier);
prg.SetUniform("InvertUVy", InvertUVy);
prg.SetUniform("IsBillboard", IsBillboard);
prg.SetUniform("SpecularColor", SpecularColor);
prg.SetUniform("DiffuseColor", DiffuseColor);
prg.SetUniform("ParallaxHeightMultiplier", ParallaxHeightMultiplier);
prg.SetUniform("Roughness", Roughness);
prg.SetUniform("Alpha", Alpha);
prg.SetUniform("NormalTexEnabled", NormalsTexture != null);
prg.SetUniform("BumpTexEnabled", BumpTexture != null);
prg.SetUniform("AlphaTexEnabled", AlphaTexture != null);
prg.SetUniform("RoughnessTexEnabled", RoughnessTexture != null);
prg.SetUniform("DiffuseTexEnabled", DiffuseTexture != null);
prg.SetUniform("SpecularTexEnabled", SpecularTexture != null);
if (NormalsTexture != null)
{
NormalsTexture.Use(prg.getConstInt("normalsTexBind"));
}
if (BumpTexture != null)
{
BumpTexture.Use(prg.getConstInt("bumpTexBind"));
}
if (AlphaTexture != null)
{
AlphaTexture.Use(prg.getConstInt("alphaTexBind"));
}
if (RoughnessTexture != null)
{
RoughnessTexture.Use(prg.getConstInt("roughnessTexBind"));
}
if (DiffuseTexture != null)
{
DiffuseTexture.Use(prg.getConstInt("diffuseTexBind"));
}
if (SpecularTexture != null)
{
SpecularTexture.Use(prg.getConstInt("specularTexBind"));
}
return(true);
}
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;
}
}
}
}
public override void Read(AssetReader reader)
{
base.Read(reader);
Fog = reader.ReadBoolean();
if (IsAlign(reader.Version))
{
reader.AlignStream(AlignType.Align4);
}
FogColor.Read(reader);
if (IsReadFogMode(reader.Version))
{
FogMode = (FogMode)reader.ReadInt32();
}
FogDensity = reader.ReadSingle();
if (IsReadLinearFogStart(reader.Version))
{
LinearFogStart = reader.ReadSingle();
LinearFogEnd = reader.ReadSingle();
}
AmbientSkyColor.Read(reader);
if (IsReadAmbientEquatorColor(reader.Version))
{
AmbientEquatorColor.Read(reader);
AmbientGroundColor.Read(reader);
AmbientIntensity = reader.ReadSingle();
}
if (IsReadAmbientProbe(reader.Version, reader.Flags))
{
if (IsReadAmbientProbeFirst(reader.Version))
{
AmbientProbe.Read(reader);
}
}
if (IsReadAmbientSkyboxLight(reader.Version))
{
AmbientSkyboxLight.Read(reader);
}
if (IsReadAmbientMode(reader.Version))
{
AmbientMode = (AmbientMode)reader.ReadInt32();
if (IsReadCreateAmbientLight(reader.Version))
{
CreateAmbientLight = reader.ReadBoolean();
}
reader.AlignStream(AlignType.Align4);
}
if (IsReadSubtractiveShadowColor(reader.Version))
{
SubtractiveShadowColor.Read(reader);
}
SkyboxMaterial.Read(reader);
HaloStrength = reader.ReadSingle();
FlareStrength = reader.ReadSingle();
if (IsReadFlareFadeSpeed(reader.Version))
{
FlareFadeSpeed = reader.ReadSingle();
}
if (IsReadPixelLightCount(reader.Version))
{
PixelLightCount = reader.ReadInt32();
}
HaloTexture.Read(reader);
if (IsReadAmbientLightScale(reader.Version))
{
AmbientLightScale = reader.ReadSingle();
}
if (IsReadSpecularTex(reader.Version))
{
SpecularTexture.Read(reader);
}
SpotCookie.Read(reader);
if (IsReadDefaultReflectionMode(reader.Version))
{
DefaultReflectionMode = reader.ReadInt32();
}
if (IsReadDefaultReflectionResolution(reader.Version))
{
DefaultReflectionResolution = reader.ReadInt32();
ReflectionBounces = reader.ReadInt32();
ReflectionIntensity = reader.ReadSingle();
}
if (IsReadCustomReflection(reader.Version))
{
CustomReflection.Read(reader);
}
if (IsReadAmbientProbe(reader.Version, reader.Flags))
{
if (!IsReadAmbientProbeFirst(reader.Version))
{
AmbientProbe.Read(reader);
}
}
if (IsReadAmbientProbeInGamma(reader.Version, reader.Flags))
{
AmbientProbeInGamma.Read(reader);
}
if (IsReadGeneratedSkyboxReflection(reader.Version, reader.Flags))
{
GeneratedSkyboxReflection.Read(reader);
}
if (IsReadSun(reader.Version))
{
Sun.Read(reader);
}
if (IsReadIndirectSpecularColor(reader.Version))
{
IndirectSpecularColor.Read(reader);
}
if (IsReadUseRadianceAmbientProbe(reader.Version))
{
UseRadianceAmbientProbe = reader.ReadBoolean();
}
}