void Update()
{
time += Time.deltaTime * AnimateSpeed;
float value = Mathf.Sin(time) * RangeValue + Mathf.Cos(randomValue + time * 0.7f) * RangeValue;
RendererMaterial.SetFloat(TextureProperty, value + PropertyInitValue);
}
internal RendererMaterial GetMaterial(int materialId)
{
if (materialId >= Materials.Count)
{
return(RendererMaterial.GetDefault());
}
return(Materials[materialId]);
}
void Start()
{
GetRendererMaterial();
Color newColor = Color.HSVToRGB(Random.Range(HueRange.x, HueRange.y), Random.Range(SaturationRange.x, SaturationRange.y), Random.Range(ValueRange.x, ValueRange.y));
newColor.a = Random.Range(AlphaRange.x, AlphaRange.y);
RendererMaterial.SetColor(TextureProperty, newColor);
}
public InternalMesh(Mesh meshData, RendererMaterial material)
{
SetMesh(meshData);
if (material == null)
{
throw new InvalidOperationException();
}
Materials.Add(material);
}
private void Update()
{
Color newColor = RendererMaterial.GetColor(shaderParamName);
newColor = FColorMethods.ChangeColorAlpha(newColor, newColor.a - Time.deltaTime * FadeSpeed);
RendererMaterial.SetColor(shaderParamName, newColor);
if (newColor.a <= 0f)
{
GameObject.Destroy(gameObject);
}
}
public override void Init()
{
if (Mesh == null)
{
return;
}
if (Mesh.Materials.Any(m => m.CastShadow))
{
UsePipeline <PointShadowRenderPipeline>();
UsePipeline <DirectionalShadowRenderPipeline>();
}
if (PrimaryRenderPipeline == null)
{
PrimaryRenderPipeline = Context.PrimaryRenderPipeline;
}
if (_MaterialTmp != null)
{
Mesh.Material = _MaterialTmp;
_MaterialTmp = null;
}
if (Mesh.Materials.All(m => m.RenderPipeline == null))
{
UsePipeline(PrimaryRenderPipeline);
}
VaoList.Clear();
if (Mesh.HasData)
{
foreach (var materialId in Mesh.MaterialIds)
{
var m = Mesh.GetMaterial(materialId);
UsePipeline(m.RenderPipeline);
m.CreateShaders();
var data = Mesh.GetMeshData(materialId);
var vao = new VertexArrayObject(data.BindLayoutToShader(m.Shader));
vao.SetData(data);
VaoList.Add(new VertexArrayObjectMaterial
{
Vao = vao,
Material = m,
});
}
}
}
/// <summary>
/// Tiling material to given parameters and scale of game object's transform.
/// </summary>
private void TileMaterialToScale()
{
if (RendererMaterial == null || ObjectRenderer == null)
{
return;
}
Vector2 newScale = ScaleValues;
newScale.x *= transform.localScale.x;
newScale.y *= transform.localScale.z;
RendererMaterial.SetTextureScale("_MainTex", newScale);
ObjectRenderer.material = RendererMaterial;
}
public StaticInternalMesh(Mesh meshData, RendererMaterial material) : base(meshData, material)
{
}
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;
}
}
}
}
void Update()
{
Vector2 newOffset = RendererMaterial.GetTextureOffset(TextureProperty) + OffsetSpeed * Time.deltaTime;
RendererMaterial.SetTextureOffset(TextureProperty, newOffset);
}
public void SetMaterial(string name, RendererMaterial material)
{
material.WriteToShader(name, this);
}
