| public SetColor ( int nameID, Color color ) : void | ||
| nameID | int | Property name ID, use Shader.PropertyToID to get it. |
| color | Color | Color value to set. |
| return | void | |
void Start () {
if(PlayerPrefs.GetInt(Application.loadedLevelName + "Door" + id) == 0){
open = false;
}else{
open = true;
}
mat = GetComponent<MeshRenderer>().material;
if(bodenschalter.Length == 1){
onColor = bodenschalter[0].onColor;
offColor = bodenschalter[0].offColor;
}
if(open){
mat.SetColor("_Color", onColor);
}else{
mat.SetColor("_Color", offColor);
}
switch(openDirection){
case DoorDirection.UP: endpos = transform.position + transform.up*openDistance*5.5f; break;
case DoorDirection.DOWN: endpos = transform.position - transform.up*openDistance*5.5f; break;
case DoorDirection.LEFT: endpos = transform.position - transform.right*openDistance*5.5f; break;
case DoorDirection.FWD: endpos = transform.position + transform.forward*openDistance*5.5f; break;
case DoorDirection.BWD: endpos = transform.position - transform.forward*openDistance*5.5f; break;
default: endpos = transform.position + transform.right*openDistance*5.5f; break;
}
startpos = transform.position;
}
void Awake()
{
material = new Material(Shader.Find("Hidden/ChannelMixer"));
material.SetColor("_R", RGB[0, 0]);
material.SetColor("_G", RGB[0, 1]);
material.SetColor("_B", RGB[0, 2]);
}
void Start()
{
var granny = GameObject.Find("Granny");
if (granny != null)
{
grannyCollider = granny.GetComponent<Collider2D>();
itemUse = granny.GetComponent<ItemUse>();
}
var spriteRenderer = GetComponent<SpriteRenderer>();
if (materials == null)
{
var effectsCount = Enum.GetNames(typeof(Effect)).Length;
materials = new Material[effectsCount];
materials[0] = spriteRenderer.material;
for (int i = 1; i < effectsCount; i++)
{
var randomMaterial = new Material(spriteRenderer.material);
randomMaterial.SetColor("_ColorR", Utils.RandomHueColor());
randomMaterial.SetColor("_ColorG", Utils.RandomHueColor());
randomMaterial.SetColor("_ColorB", Color.white);
materials[i] = randomMaterial;
}
}
spriteRenderer.material = getMaterial(PillEffect);
}
//ball is destoryed because it got stuck in the wall
void BallDestroy()
{
Material particleColor = new Material(shotColor);
if (colorShot == 0)//if ball is green increase greenshots by one
{
gVar.greenShots++;
particleColor.SetColor("_EmissionColor", GREEN);
}
else if (colorShot == 1)
{
gVar.redShots++;
particleColor.SetColor("_EmissionColor", RED);
}
else if (colorShot == 2)
{
gVar.blueShots++;
particleColor.SetColor("_EmissionColor", BLUE);
}
else if (colorShot == 3)
{
gVar.purpleShots++;
particleColor.SetColor("_EmissionColor", PURPLE);
}
GameObject particles = (GameObject)Instantiate(ballParticleSystem, this.GetComponent<Transform>().position, Quaternion.identity);
particles.GetComponent<Renderer>().material = particleColor;
Destroy(particles, 0.5f);
Destroy(gameObject);
}
void Awake()
{
material = new Material( Shader.Find("Hidden/Gradient") );
material.SetColor("_ColorA", colorA);
material.SetColor("_ColorB", colorB);
material.SetColor("_ColorC", colorC);
}
private void GenerateWireframeMeshsAndMaterials() {
foreach (MeshNMaterial subObj in subObjects) {
//添加AmazingWireframeGenerator
subObj.gameObject.AddComponent<TheAmazingWireframeGenerator>();
for (int i = 0;i < subObj.originalMaterials.Length;i++) {
Material wireframeNoTexMat = new Material(
Shader.Find("VacuumShaders/The Amazing Wireframe/Unlit/NoTex"));
wireframeNoTexMat.SetColor("_Color", subObj.originalMaterials[i].GetColor("_Color"));
wireframeNoTexMat.EnableKeyword("V_WIRE_ANTIALIASING_ON");
wireframeNoTexMat.EnableKeyword("V_WIRE_LIGHT_ON");
subObj.wireframeNoTexMaterials[i] = wireframeNoTexMat;
Material wireframeTexMat = new Material(
Shader.Find("VacuumShaders/The Amazing Wireframe/Deferred/Bumped Specular"));
wireframeTexMat.SetColor("_Color", subObj.originalMaterials[i].GetColor("_Color"));
if (subObj.originalMaterials[i].HasProperty("_SpecColor"))
wireframeTexMat.SetColor("_SpecColor", subObj.originalMaterials[i].GetColor("_SpecColor"));
if (subObj.originalMaterials[i].HasProperty("_Shininess"))
wireframeTexMat.SetFloat("_Shininess", subObj.originalMaterials[i].GetFloat("_Shininess"));
wireframeTexMat.SetTexture("_MainTex", subObj.originalMaterials[i].GetTexture("_MainTex"));
if (subObj.originalMaterials[i].HasProperty("_BumpMap"))
wireframeTexMat.SetTexture("_BumpMap", subObj.originalMaterials[i].GetTexture("_BumpMap"));
wireframeTexMat.EnableKeyword("V_WIRE_ANTIALIASING_ON");
wireframeTexMat.EnableKeyword("V_WIRE_LIGHT_ON");
subObj.wireframeTexMaterials[i] = wireframeTexMat;
}
}
}
public PathController(QueryTool tool)
{
queryTool = tool;
currentHighlightType = HighlightType.None;
Config.instance.eventConfigChanged += () => { OnConfigChanged(); };
Log.info("Load Line Material...");
Color red = new Color(1, 0, 0);
Color gold = new Color(1, 0.9f, 0);
string lineShader = ResourceLoader.loadResourceString("Materials/Shaders/TransparentVertexLit.shader");
lineMaterial = new Material(lineShader);
lineMaterial.color = red;
lineMaterial.SetColor("_Emission", red);
lineMaterial.SetColor("_SpecColor", Color.black); //Disable shine effect
lineMaterial.mainTexture = ResourceLoader.loadTexture("Materials/NewSkin.png");
lineMaterial.renderQueue = 100;
lineMaterialHighlight = new Material(lineMaterial);
lineMaterialHighlight.color = gold;
lineMaterialHighlight.SetColor("_Emission", gold);
lineMaterial.renderQueue = 101;
Texture pin = ResourceLoader.loadTexture("Materials/Pin.png");
activeSegmentIndicator = Billboard.Create(Billboard.CreateSpriteMaterial(pin, Color.green));
vehicleIndicator = Billboard.CreateSpriteMaterial(pin, red);
vehicleIndicatorHighlight = Billboard.CreateSpriteMaterial(pin, gold);
Log.debug("PathController initialized");
}
IEnumerator Test( Material mat, Color newColor )
{
Color orgColor = mat.GetColor("_EmissionColor");
mat.SetColor("_EmissionColor", newColor);
yield return new WaitForSeconds(0.5f);
mat.SetColor("_EmissionColor", orgColor);
}
// Use this for initialization
void Start()
{
//countdown = transform.parent.parent.GetComponent<Countdown>();
countdown = transform.parent.GetComponent<Countdown>();
renderer = GetComponent<Renderer>();
material = renderer.material;
if (red) {
material.SetColor("_EmissionColor", Color.grey);
myColor = Color.red;
signal = Countdown.signal.RED;
}
if (yellow) {
material.SetColor("_EmissionColor", Color.grey);
myColor = Color.yellow;
signal = Countdown.signal.YELLOW;
}
if (green) {
material.SetColor("_EmissionColor", Color.grey);
myColor = Color.green;
signal = Countdown.signal.GREEN;
}
material.SetFloat("_EmissionScaleUI", 0.1f);
}
/// <summary>
/// Changes the color of the given material
/// </summary>
/// <param name="material"></param>
/// <param name="color"></param>
public IEnumerator ChangeColor(Material material, Color color, float seconds)
{
Color currentColor = material.GetColor("_EmissionColor");
material.SetColor("_EmissionColor", color);
yield return new WaitForSeconds(seconds);
// Reset color to initial one
if (seconds > 0) { material.SetColor("_EmissionColor", currentColor); }
}
public void Start()
{
fxRes = GetComponent<IndieEffects>();
mat = new Material(shader);
mat.SetColor("_Lift", Lift);
mat.SetFloat("_LiftB", Mathf.Clamp(LiftBright, 0f, 2f));
mat.SetColor("_Gamma", Gamma);
mat.SetFloat("_GammaB", Mathf.Clamp(GammaBright, 0f, 2f));
mat.SetColor("_Gain", Gain);
mat.SetFloat("_GainB", Mathf.Clamp(GainBright, 0f, 2f));
}
// Update is called once per frame
IEnumerator attackobject() {
yield return new WaitForEndOfFrame();
mat = transform.GetChild(0).gameObject.GetComponent<MeshRenderer>().material;
while (true)
{
mat.SetColor("_TintColor",new Color(0.3f,0.3f,0.3f));
yield return new WaitForSeconds(Random.value/10);
mat.SetColor("_TintColor", new Color(0.5f, 0.5f, 0.5f));
yield return new WaitForSeconds(Random.value);
}
}
private void ConfigMaterial(MmdMaterial mmdMaterial, MmdUnityConfig config, UnityEngine.Material material, Texture mainTexture)
{
material.SetColor("_Color", mmdMaterial.DiffuseColor);
material.SetFloat("_Opacity", mmdMaterial.DiffuseColor.a);
material.SetColor("_AmbColor", mmdMaterial.AmbientColor);
material.SetColor("_SpecularColor", mmdMaterial.SpecularColor);
material.SetFloat("_Shininess", mmdMaterial.Shiness);
material.SetFloat("_OutlineWidth", mmdMaterial.EdgeSize);
material.SetColor("_OutlineColor", mmdMaterial.EdgeColor);
if (mainTexture != null)
{
material.mainTexture = mainTexture;
material.mainTextureScale = new Vector2(1, 1);
}
if (mmdMaterial.SubTextureType != MmdMaterial.SubTextureTypeEnum.MatSubTexOff)
{
var additionalTexture =
mmdMaterial.SubTexture == null ? null : _textureLoader.LoadTexture(mmdMaterial.SubTexture);
if (additionalTexture != null)
{
additionalTexture.wrapMode = TextureWrapMode.Clamp;
switch (mmdMaterial.SubTextureType)
{
case MmdMaterial.SubTextureTypeEnum.MatSubTexSpa:
material.SetTexture("_SphereAddTex", additionalTexture);
material.SetTextureScale("_SphereAddTex", new Vector2(1, 1));
break;
case MmdMaterial.SubTextureTypeEnum.MatSubTexSph:
material.SetTexture("_SphereMulTex", additionalTexture);
material.SetTextureScale("_SphereMulTex", new Vector2(1, 1));
break;
}
}
}
RefreshShaderKeywords(mmdMaterial, config, material);
var toonTexture = _textureLoader.LoadTexture(mmdMaterial.Toon);
if (toonTexture != null)
{
toonTexture.wrapMode = TextureWrapMode.Clamp;
material.SetTexture("_ToonTex", toonTexture);
material.SetTextureScale("_ToonTex", new Vector2(1, 1));
}
}
protected IEnumerator _FadeOut(Material m, float time)
{
var c = m.GetColor(Outline);
var startAlpha = c.a;
var start = Time.time;
var end = start + time;
while(Time.time <= end) {
var progress = Mathf.InverseLerp(start, end, Time.time);
var alpha = Mathf.Lerp(startAlpha, 0, progress);
m.SetColor(Outline, SetAlpha(c, alpha));
yield return new WaitForEndOfFrame();
}
m.SetColor(Outline, SetAlpha(c, 0));
_fadingOut.Remove(m);
}
//fades the buttons in as well
IEnumerator FadeIn(Material material, float fadeSpeed)
{
Color tempColor = material.color;
tempColor.a = 0;
material.SetColor ("_Color", tempColor);
while (material.color.a < 1) {
tempColor.a += fadeSpeed;
material.SetColor ("_Color", tempColor);
yield return null;
}
}
void Start () {
mat = GetComponentInChildren<MeshRenderer>().material;
if(bodenschalter.Length > 0){
onColor = bodenschalter[0].onColor;
offColor = bodenschalter[0].offColor;
}
if(on){
mat.SetColor("_Color", onColor);
}else{
mat.SetColor("_Color", offColor);
}
}
/// <summary>
///
/// </summary>
void Update()
{
// editor force show
if (m_ForceShow)
{
Show();
}
else
{
// always fade out muzzleflash if it is visible
if (m_Color.a > 0.0f)
{
m_Color.a -= m_FadeSpeed * (Time.deltaTime * 60.0f);
if (m_Light != null)
{
m_Light.intensity = m_LightIntensity * (m_Color.a * 2.0f); // sync light intensity to muzzleflash alpha
}
}
}
if (m_Material != null)
{
m_Material.SetColor("_TintColor", m_Color); // // TODO:will affect all muzzleflashes using this material in the scene (!)
}
if (m_Color.a < 0.01f)
{
m_Renderer.enabled = false;
if (m_Light != null)
{
m_Light.enabled = false;
}
}
}
public void SetCurrentToTo()
{
if (_material = material)
{
_material.SetColor(propertyID, to);
}
}
public void SetCurrentToFrom()
{
if (_material = material)
{
_material.SetColor(propertyID, from);
}
}
void LateUpdate()
{
var mouse = Mouse.current;
if (Cam == null || mouse == null || !mouse.leftButton.wasPressedThisFrame)
{
return;
}
var position = new Vector3(mouse.position.x.ReadValue(), mouse.position.y.ReadValue());
var screenPointToRay = Cam.ScreenPointToRay(position);
var rayInput = new RaycastInput
{
Start = screenPointToRay.origin,
End = screenPointToRay.GetPoint(RAYCAST_DISTANCE),
Filter = CollisionFilter.Default
};
if (!physicsWorld.CastRay(rayInput, out RaycastHit hit))
{
return;
}
var selectedEntity = physicsWorld.Bodies[hit.RigidBodyIndex].Entity;
var renderMesh = entityManager.GetSharedComponentData <RenderMesh>(selectedEntity);
var mat = new UnityEngine.Material(renderMesh.material);
mat.SetColor("_BaseColor", UnityEngine.Random.ColorHSV());
renderMesh.material = mat;
entityManager.SetSharedComponentData(selectedEntity, renderMesh);
}
public override void Restore()
{
if (null == m_Material)
{
return;
}
// end if
if (!string.IsNullOrEmpty(m_property))
{
m_Material.SetColor(m_property, m_beginColor);
}
else if (m_propertyID != -1)
{
m_Material.SetColor(m_propertyID, m_beginColor);
} // end if
}
static public int SetColor(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
if (matchType(l, argc, 2, typeof(int), typeof(UnityEngine.Color)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
UnityEngine.Color a2;
checkType(l, 3, out a2);
self.SetColor(a1, a2);
pushValue(l, true);
return(1);
}
else if (matchType(l, argc, 2, typeof(string), typeof(UnityEngine.Color)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
UnityEngine.Color a2;
checkType(l, 3, out a2);
self.SetColor(a1, a2);
pushValue(l, true);
return(1);
}
pushValue(l, false);
LuaDLL.lua_pushstring(l, "No matched override function to call");
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public IEnumerator PlayLaserEffect(float effectDuration, Vector3 impactPos)
{
#if FULL_DEBUG
if(!laser)
{
Debug.LogError("Line renderer null");
}
#endif
laser.SetPosition(0, transform.position);
laser.SetPosition(1, impactPos);
float distance = Vector3.Distance(transform.position, impactPos);
renderer.materials[0].mainTextureScale.Set(distance / uvLength, renderer.materials[0].mainTextureScale.y) ;
mat = laser.renderer.material;
float currentTime = 0.0f;
while(currentTime<=1.0f)
{
//lerp colour
mat.SetColor("_TintColor", Color.Lerp(startColour, endColour, currentTime));
//lerp size
float newSize = Mathf.Lerp(startWidth, endWidth, currentTime);
laser.SetWidth(newSize, newSize);
currentTime += Time.deltaTime / effectDuration;
yield return null;
}
}
IEnumerator Grow()
{
float f = 0;
float t = 0;
Vector3 originalScale = transform.localScale;
Vector3 targetScale = originalScale * EndScale;
Material originalMaterial = new Material(renderer.material);
Color originalColor = originalMaterial.GetColor("_TintColor");
Color targetColor = new Color(originalColor.r, originalColor.g, originalColor.b, 0F);
renderer.material = originalMaterial;
while (f <= duration)
{
t = f / duration;
transform.localScale = Vector3.Lerp(originalScale, targetScale, t);
originalMaterial.SetColor("_TintColor", Color.Lerp(originalColor, targetColor, t));
f += Time.deltaTime;
yield return new WaitForEndOfFrame();
}
if (mode == FXmode.DestroyAtEnd)
Destroy(gameObject);
else if (mode == FXmode.Loop)
Play();
}
// Use this for initialization
void Start()
{
hold = GetComponent<Renderer>().material;
plCol = (gameMan = GameObject.FindGameObjectWithTag("Manager").GetComponent<GameManager>()).pColor[playerNum];
hold.SetColor("_Color", plCol + (Color.white * .2f));
}
// Use this for initialization
void Start()
{
mat = GetComponent<Renderer> ().material;
mat.SetColor ("_EnergyColor", energyColor);
mat.SetFloat ("_Visibility", visibility);
mat.SetFloat ("_CollisionTime", -99f); // To ensure that animation is already "over" by the time we start.
}
/// <summary>
///
/// </summary>
/// <param name="lineMaterial"></param>
/// <param name="color"></param>
/// <param name="source"></param>
/// <param name="destination"></param>
public static void BoxDrawing(Material lineMaterial, Color color, float width, float height, Vector3 position)
{
lineMaterial.SetColor("_TintColor", color);
lineMaterial.SetPass(0);
GL.Begin(GL.LINES);
// upper width line
GL.Vertex3(position.x - width / 2, position.y, position.z + height / 2);
GL.Vertex3(position.x + width / 2, position.y, position.z + height / 2);
// right height line
GL.Vertex3(position.x + width / 2, position.y, position.z + height / 2);
GL.Vertex3(position.x + width / 2, position.y, position.z - height / 2);
// lower width line
GL.Vertex3(position.x + width / 2, position.y, position.z - height / 2);
GL.Vertex3(position.x - width / 2, position.y, position.z - height / 2);
//height lines
GL.Vertex3(position.x - width / 2, position.y, position.z - height / 2);
GL.Vertex3(position.x - width / 2, position.y, position.z + height / 2);
GL.End();
}
/// <summary>
/// Copy Shader properties from source to destination material.
/// </summary>
/// <param name="source"></param>
/// <returns></returns>
public static void CopyMaterialProperties(Material source, Material destination)
{
MaterialProperty[] source_prop = MaterialEditor.GetMaterialProperties(new Material[] { source });
for (int i = 0; i < source_prop.Length; i++)
{
int property_ID = Shader.PropertyToID(source_prop[i].name);
if (destination.HasProperty(property_ID))
{
//Debug.Log(source_prop[i].name + " Type:" + ShaderUtil.GetPropertyType(source.shader, i));
switch (ShaderUtil.GetPropertyType(source.shader, i))
{
case ShaderUtil.ShaderPropertyType.Color:
destination.SetColor(property_ID, source.GetColor(property_ID));
break;
case ShaderUtil.ShaderPropertyType.Float:
destination.SetFloat(property_ID, source.GetFloat(property_ID));
break;
case ShaderUtil.ShaderPropertyType.Range:
destination.SetFloat(property_ID, source.GetFloat(property_ID));
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
destination.SetTexture(property_ID, source.GetTexture(property_ID));
break;
case ShaderUtil.ShaderPropertyType.Vector:
destination.SetVector(property_ID, source.GetVector(property_ID));
break;
}
}
}
}
public override void AssignNewShaderToMaterial(Material material, Shader oldShader, Shader newShader)
{
if (material.HasProperty("_Emission"))
{
material.SetColor("_EmissionColor", material.GetColor("_Emission"));
}
base.AssignNewShaderToMaterial(material, oldShader, newShader);
if ((oldShader == null) || !oldShader.name.Contains("Legacy Shaders/"))
{
SetupMaterialWithBlendMode(material, (BlendMode) ((int) material.GetFloat("_Mode")));
}
else
{
BlendMode opaque = BlendMode.Opaque;
if (oldShader.name.Contains("/Transparent/Cutout/"))
{
opaque = BlendMode.Cutout;
}
else if (oldShader.name.Contains("/Transparent/"))
{
opaque = BlendMode.Fade;
}
material.SetFloat("_Mode", (float) opaque);
Material[] mats = new Material[] { material };
this.DetermineWorkflow(MaterialEditor.GetMaterialProperties(mats));
MaterialChanged(material, this.m_WorkflowMode);
}
}
// Use this for initialization
void Start ()
{
holder = new GameObject();
holder.transform.parent = this.transform;
holder.transform.localPosition = Vector3.zero;
pointer = GameObject.CreatePrimitive(PrimitiveType.Cube);
pointer.transform.parent = holder.transform;
pointer.transform.localScale = new Vector3(thickness, thickness, 100f);
pointer.transform.localPosition = new Vector3(0f, 0f, 50f);
BoxCollider collider = pointer.GetComponent<BoxCollider>();
if (addRigidBody)
{
if (collider)
{
collider.isTrigger = true;
}
Rigidbody rigidBody = pointer.AddComponent<Rigidbody>();
rigidBody.isKinematic = true;
}
else
{
if(collider)
{
Object.Destroy(collider);
}
}
Material newMaterial = new Material(Shader.Find("Unlit/Color"));
newMaterial.SetColor("_Color", color);
pointer.GetComponent<MeshRenderer>().material = newMaterial;
}
void LateUpdate()
{
if (!Input.GetMouseButtonDown(0) || Cam == null)
{
return;
}
var screenPointToRay = Cam.ScreenPointToRay(Input.mousePosition);
var rayInput = new RaycastInput
{
Start = screenPointToRay.origin,
End = screenPointToRay.GetPoint(RAYCAST_DISTANCE),
Filter = CollisionFilter.Default
};
if (!physicsWorld.CastRay(rayInput, out RaycastHit hit))
{
return;
}
var selectedEntity = physicsWorld.Bodies[hit.RigidBodyIndex].Entity;
var renderMesh = entityManager.GetSharedComponentData <RenderMesh>(selectedEntity);
var mat = new UnityEngine.Material(renderMesh.material);
mat.SetColor("_Color", UnityEngine.Random.ColorHSV());
renderMesh.material = mat;
entityManager.SetSharedComponentData(selectedEntity, renderMesh);
}
/// <summary>
/// Draws a circle thingy.
/// </summary>
/// <param name="lineMaterial">The line material.</param>
/// <param name="color">The color.</param>
/// <param name="iteration">The iteration.</param>
/// <param name="radius">The radius.</param>
/// <param name="s">The s.</param>
/// <param name="q">The q.</param>
public static void CircleDrawing(Material lineMaterial, Color color, int iteration, float radius, Vector3 source, Quaternion rotatiom)
{
lineMaterial.SetColor("_TintColor", color);
lineMaterial.SetPass(0);
GL.Begin(GL.LINES);
for (int i = 1; i <= iteration + 1; i++)
{
float dg = i;
float n = iteration;
Vector3 v = Vector3.zero;
v.x = radius * Mathf.Cos((dg / n) * Mathf.PI * 2);
v.z = radius * Mathf.Sin((dg / n) * Mathf.PI * 2);
v = rotatiom * v;
Vector3 v1 = new Vector3(v.x + source.x, v.y + source.y, v.z + source.z);
GL.Vertex3(v1.x, v1.y, v1.z);
if (i != 1 && i != iteration + 1)
{
GL.Vertex3(v.x + source.x, v.y + source.y, v.z + source.z);
}
}
GL.End();
}
float gr = (1.0f + Mathf.Sqrt(5.0f)) / 2.0f; //golen ratio (a+b is to a as a is to b)
#endregion Fields
#region Methods
void Start()
{
Nose = GameObject.Find("Nose");
Nose.AddComponent<MeshFilter>();
Nose.AddComponent<MeshRenderer>();
noseMesh = GetComponent<MeshFilter>().mesh;//attach mesh to nose
noseMesh.Clear();
noseMesh.vertices = new Vector3[] {//construct pyramid for nose
new Vector3( gr, 1, 0),
new Vector3( gr-1, -gr*0.6f, -gr*0.75f),
new Vector3( gr-1, -gr*0.6f, gr*0.75f),
new Vector3( gr*1.5f, -gr*0.6f, 0)};
List<int> noseTrianglesIndices = new List<int>() {//arrange triangles
0, 1, 2,
0, 3, 1,
0, 2, 3,
1, 3, 2};
noseMesh.triangles = noseTrianglesIndices.ToArray();
//Set Colour
Material material = new Material(Shader.Find("Standard"));
Color fleshtone = new Color(10, 205, 180);
material.SetColor("fleshtone", fleshtone);
Nose.GetComponent<Renderer>().material = material;
noseMesh.RecalculateBounds();
noseMesh.RecalculateNormals();
noseMesh.Optimize();
}
static int SetColor(IntPtr L)
{
try
{
int count = LuaDLL.lua_gettop(L);
if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(int), typeof(UnityEngine.Color)))
{
UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1);
int arg0 = (int)LuaDLL.lua_tonumber(L, 2);
UnityEngine.Color arg1 = ToLua.ToColor(L, 3);
obj.SetColor(arg0, arg1);
return(0);
}
else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(string), typeof(UnityEngine.Color)))
{
UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1);
string arg0 = ToLua.ToString(L, 2);
UnityEngine.Color arg1 = ToLua.ToColor(L, 3);
obj.SetColor(arg0, arg1);
return(0);
}
else
{
return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Material.SetColor"));
}
}
catch (Exception e)
{
return(LuaDLL.toluaL_exception(L, e));
}
}
protected void SetGenericMaterialProperty(Material destination, string property_name, object value)
{
try{
ShaderUtil.ShaderPropertyType type = GetPropertyType(destination, property_name);
switch(type)
{
case ShaderUtil.ShaderPropertyType.Color:
destination.SetColor(property_name, value.UnityBridgeObjectToColor());
break;
case ShaderUtil.ShaderPropertyType.Range:
case ShaderUtil.ShaderPropertyType.Float:
destination.SetFloat(property_name, value.UnityBridgeObjectToFloat());
break;
case ShaderUtil.ShaderPropertyType.Vector:
destination.SetVector(property_name, value.UnityBridgeObjectToVector());
break;
case ShaderUtil.ShaderPropertyType.TexEnv:
destination.SetTexture(property_name, TextureManager.Instance.ResolveMap( destination.name + "_" + property_name, value));
break;
default:
Debug.Log("Unknown shader type " + type.ToString());
break;
}
}
catch(KeyNotFoundException e)
{
Debug.Log(e.Message);
}
}
// Called by the camera to apply the image effect
void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (!mat) {
// Use the color detection shader
var shader = Shader.Find ("Custom/ColorDetect");
mat = new Material (shader);
mat.hideFlags = HideFlags.HideAndDontSave;
// Set up threshold and shading colors
mat.SetColor("_ThresholdColor", thresholdColor);
mat.SetColor("_ShadingColor", shadingColor);
}
//mat is the material containing your shader
Graphics.Blit(source,destination,mat);
}
static public int SetColor(IntPtr l)
{
try{
if (matchType(l, 2, typeof(System.String), typeof(UnityEngine.Color)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
UnityEngine.Color a2;
checkType(l, 3, out a2);
self.SetColor(a1, a2);
return(0);
}
else if (matchType(l, 2, typeof(System.Int32), typeof(UnityEngine.Color)))
{
UnityEngine.Material self = (UnityEngine.Material)checkSelf(l);
System.Int32 a1;
checkType(l, 2, out a1);
UnityEngine.Color a2;
checkType(l, 3, out a2);
self.SetColor(a1, a2);
return(0);
}
LuaDLL.luaL_error(l, "No matched override function to call");
return(0);
}
catch (Exception e) {
LuaDLL.luaL_error(l, e.ToString());
return(0);
}
}
public static void Color(UnityEngine.Material material, string name, Color[] array)
{
for (int i = 0; i < array.Length; i++)
{
material.SetColor(name + i.ToString(), array[i]);
}
}
// Use this for initialization
void Start()
{
myMaterial = gameObject.transform.Find("button").GetComponent<Renderer>().material;
myMaterial.SetColor ("_Color", Color.green);
cannonScript = GameObject.Find("Cannon").GetComponent<cannon>();
Debug.Log ("cannonScript = " + cannonScript);
}
public UnityEngine.Material CreateMaterial(PbrMaterial vpxMaterial, TableBehavior table, StringBuilder debug = null)
{
var unityMaterial = new UnityEngine.Material(GetShader())
{
name = vpxMaterial.Id
};
// apply some basic manipulations to the color. this just makes very
// very white colors be clipped to 0.8204 aka 204/255 is 0.8
// this is to give room to lighting values. so there is more modulation
// of brighter colors when being lit without blow outs too soon.
var col = vpxMaterial.Color.ToUnityColor();
if (vpxMaterial.Color.IsGray() && col.grayscale > 0.8)
{
debug?.AppendLine("Color manipulation performed, brightness reduced.");
col.r = col.g = col.b = 0.8f;
}
// alpha for color depending on blend mode
ApplyBlendMode(unityMaterial, vpxMaterial.MapBlendMode);
if (vpxMaterial.MapBlendMode == BlendMode.Translucent)
{
col.a = Mathf.Min(1, Mathf.Max(0, vpxMaterial.Opacity));
}
unityMaterial.SetColor(BaseColor, col);
// validate IsMetal. if true, set the metallic value.
// found VPX authors setting metallic as well as translucent at the
// same time, which does not render correctly in unity so we have
// to check if this value is true and also if opacity <= 1.
if (vpxMaterial.IsMetal && (!vpxMaterial.IsOpacityActive || vpxMaterial.Opacity >= 1))
{
unityMaterial.SetFloat(Metallic, 1f);
debug?.AppendLine("Metallic set to 1.");
}
// roughness / glossiness
unityMaterial.SetFloat(Smoothness, vpxMaterial.Roughness);
// map
if (table != null && vpxMaterial.HasMap)
{
unityMaterial.SetTexture(BaseMap, table.GetTexture(vpxMaterial.Map.Name));
}
// normal map
if (table != null && vpxMaterial.HasNormalMap)
{
unityMaterial.EnableKeyword("_NORMALMAP");
unityMaterial.SetTexture(BumpMap, table.GetTexture(vpxMaterial.NormalMap.Name)
);
}
return(unityMaterial);
}
//public float Duration = 2.0f;
void Update()
{
Renderer renderer = GetComponent <Renderer> ();
UnityEngine.Material mat = renderer.material;
float emission = mini + Mathf.PingPong(Time.time * TimeMultiplier, maxi - mini);
//float emission = Mathf.PingPong (Time.time, 1.0f);
Color baseColor = Color.white; //Replace this with whatever you want for your base color at emission level '1'
Color finalColor = baseColor * Mathf.LinearToGammaSpace(emission);
mat.SetColor("_EmissionColor", finalColor);
}
private UnityEngine.Material LoadMaterial(glTFLoader.Schema.Material material)
{
string techniqueID = material.Technique;
if (techniqueID != null)
{
LoadTechnique(m_model.Techniques[techniqueID]);
}
UnityEngine.Material res = new UnityEngine.Material(UnityEngine.Shader.Find(" Diffuse"));
res.name = material.Name;
if (material.Values != null)
{
if (material.Values.ContainsKey("ambient"))
{
JArray ambientArray = material.Values["ambient"] as JArray;
int[] ambient = ambientArray.ToObject <int[]>();
res.SetColor("_Color", ArrayConverter.ToColor(ambient));
}
if (material.Values.ContainsKey("emission"))
{
JArray emissionArray = material.Values["emission"] as JArray;
int[] emission = emissionArray.ToObject <int[]>();
res.SetColor("_EmissionColor", ArrayConverter.ToColor(emission));
}
if (material.Values.ContainsKey("diffuse"))
{
if (material.Values["diffuse"] is string)
{
string diffuseTextureID = material.Values["diffuse"] as string;
Texture2D texture = LoadTexture(m_model.Textures[diffuseTextureID]);
res.mainTexture = texture;
}
}
}
return(res);
}
public Material MergeMaterials(PbrMaterial vpxMaterial, Material texturedMaterial)
{
var nonTexturedMaterial = CreateMaterial(vpxMaterial, null);
var mergedMaterial = new Material(GetShader());
mergedMaterial.CopyPropertiesFromMaterial(texturedMaterial);
mergedMaterial.name = nonTexturedMaterial.name;
mergedMaterial.SetColor(BaseColor, nonTexturedMaterial.GetColor(BaseColor));
mergedMaterial.SetFloat(Metallic, nonTexturedMaterial.GetFloat(Metallic));
mergedMaterial.SetFloat(Smoothness, nonTexturedMaterial.GetFloat(Smoothness));
return(mergedMaterial);
}
public Body(double m, float r, float x, float y, float z, string id, Color color = default(Color))
{
mass = m;
radius = 10 * r;
volume = (4 / 3) * pi * (r * r * r);
density = mass / volume;
xPos = x;
yPos = y;
zPos = z;
accelerationX = 0;
accelerationY = 0;
accelerationZ = 0;
ID = id;
appearance = GameObject.CreatePrimitive(PrimitiveType.Sphere);
appearance.transform.position = new Vector3(xPos / 100, yPos / 100, zPos / 100);
appearance.transform.localScale = new Vector3((10 * 2 * r) / 100, (10 * 2 * r) / 100, (10 * 2 * r) / 100);
rigidBody = appearance.AddComponent <Rigidbody>();
rigidBody.detectCollisions = false;
trail = appearance.AddComponent <TrailRenderer>();
trail.time = 5;
trail.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
trail.receiveShadows = false;
trail.widthMultiplier = 5;
UnityEngine.Material mat = new UnityEngine.Material(Shader.Find("Standard"));
if (color == default(Color))
{
color = Color.gray;
isStar = 0;
}
else
{
isStar = 1;
mat.EnableKeyword("_EMISSION");
mat.SetColor("_EmissionColor", new Color(255, 187, 0));
//mat.EnableKeyword("_EMISSION");
//mat.SetColor("_EmissionColor", new Color(255, 187, 0));
}
mat.color = color;
appearance.GetComponent <Renderer>().material = mat;
//Apply texture
/*UnityEngine.Material mater = Earth;
* mater.EnableKeyword("_EMISSION");
* mater.SetColor("_EmissionColor", new Color(255, 187, 0));
* appearance.GetComponent<Renderer>().material = mater;*/
}
internal void SetBoardState(GameCell[] Field)
{
if (!_inited)
{
Debug.LogError($"View has not been inited!");
return;
}
if (Field.Length != _changeableObjects.Count)
{
Debug.LogError($"Different dimensions!");
return;
}
var cells = new NativeArray <GameCell>(_changeableObjects.Count, Allocator.TempJob);
var indexes = new NativeArray <int>(_changeableObjects.Count, Allocator.TempJob);
var colors = new NativeArray <Color>(_changeableObjects.Count, Allocator.TempJob);
for (int i = 0; i < cells.Length; i++)
{
cells[i] = Field[i];
indexes[i] = i;
colors[i] = _changeableObjects[i].Color;
}
var job = new CellChanger()
{
Cells = cells,
Indexes = indexes,
Colors = colors,
};
var jobHandler = job.Schedule(_changeableObjects.Count, 10);
jobHandler.Complete();
for (int i = 0; i < _changeableObjects.Count; i++)
{
var renderMesh = _entityManager.GetSharedComponentData <RenderMesh>(_changeableObjects[i].Entity);
var mat = new UnityEngine.Material(renderMesh.material);
mat.SetColor("_Color", colors[i]);
renderMesh.material = mat;
_entityManager.SetSharedComponentData(_changeableObjects[i].Entity, renderMesh);
}
cells.Dispose();
colors.Dispose();
indexes.Dispose();
}
// マテリアルの登録
private UnityEngine.Material EntryMaterial(int i)
{
UnityEngine.Material mat = new UnityEngine.Material(Shader.Find("VertexLit"));
Material source = matList.materials[i];
Texture tex = null;
// テクスチャを貼る
if (source.TextureFileName != "")
{
tex = AssetDatabase.LoadAssetAtPath(folderPath + source.TextureFileName, typeof(Texture)) as Texture;
mat.mainTexture = tex;
mat.SetTextureScale("_MainTex", new Vector2(1, -1));
}
mat.color = source.DiffuseColor;
mat.SetColor("_SpecColor", source.SpecularColor);
mat.SetColor("_Emission", source.EmissionColor);
mat.SetFloat("_Shiness", source.Specularity);
mat.name = this.fileName + "_" + source.Name;
AssetDatabase.CreateAsset(mat, folderPath + "Materials/" + mat.name + ".asset");
return(mat);
}
public ResourceObject Parse(ByteBuffer bb)
{
Schema.Material _material = Schema.Material.GetRootAsMaterial(bb);
ResourceObjectMaterial result = new ResourceObjectMaterial(_material.Shader);
UnityEngine.Material material = result.Unity3dObject as UnityEngine.Material;
material.name = _material.Name;
for (int i = 0; i < _material.PropertiesLength; i++)
{
Schema.ShaderProperty p = _material.GetProperties(i);
switch (p.Type)
{
case ShaderPropertyType.Float:
case ShaderPropertyType.Range:
{
Schema.ShaderPropertyFloat f = p.GetValue <Schema.ShaderPropertyFloat>(fObj);
material.SetFloat(p.Names, f.Value);
}
break;
case ShaderPropertyType.Color:
{
Schema.ShaderPropertyColor c = p.GetValue <Schema.ShaderPropertyColor>(cObj);
material.SetColor(p.Names, new UnityEngine.Color(c.Color.R, c.Color.G, c.Color.B, c.Color.A));
}
break;
case ShaderPropertyType.Vector:
{
Schema.ShaderPropertyVector v = p.GetValue <Schema.ShaderPropertyVector>(vObj);
material.SetVector(p.Names, new Vector4(v.Vector.X, v.Vector.Y, v.Vector.Z, v.Vector.W));
}
break;
case ShaderPropertyType.TexEnv:
{
Schema.ShaderPropertyTexture t = p.GetValue <Schema.ShaderPropertyTexture>(tObj);
material.SetTextureOffset(p.Names, new Vector2(t.Offset.X, t.Offset.Y));
material.SetTextureScale(p.Names, new Vector2(t.Scale.X, t.Scale.Y));
result.AddTexture(t.Name, p.Names);
}
break;
}
}
return(result);
}
public UnityEngine.Material CreateMaterial()
{
var material = new UnityEngine.Material(GetShader());
var texture = new Texture2D(512, 512, TextureFormat.RGBA32, true)
{
name = "BallDebugTexture"
};
texture.LoadImage(Resource.BallDebug.Data);
material.SetTexture(BaseMap, texture);
material.SetColor(BaseColor, Color.white);
material.SetFloat(Metallic, 0.85f);
material.SetFloat(Smoothness, 0.75f);
return(material);
}
private UnityEngine.Material CreateMaterialFromXml(XElement xml)
{
// Does this material support alpha color key?
string htmlColor = ImportUtils.GetAttributeAsString(xml, "alphaColorKey", "");
bool usesDepthShader = ImportUtils.GetAttributeAsBoolean(xml, "usesDepthShaders", false);
// Determine which shader we sould be using
string shaderName = "Tiled2Unity/";
// Are we using depth shaders?
if (usesDepthShader)
{
shaderName += "Depth";
}
else
{
shaderName += "Default";
}
// Are we using color key shaders?
Color?keyColor = null;
if (!String.IsNullOrEmpty(htmlColor))
{
shaderName += " Color Key";
// Sometimes Tiled saves out color without the leading # but we expect it to be there
if (!htmlColor.StartsWith("#"))
{
htmlColor = "#" + htmlColor;
}
byte r = byte.Parse(htmlColor.Substring(1, 2), System.Globalization.NumberStyles.HexNumber);
byte g = byte.Parse(htmlColor.Substring(3, 2), System.Globalization.NumberStyles.HexNumber);
byte b = byte.Parse(htmlColor.Substring(5, 2), System.Globalization.NumberStyles.HexNumber);
keyColor = new Color32(r, g, b, 255);
}
UnityEngine.Material material = new UnityEngine.Material(UnityEngine.Shader.Find(shaderName));
if (keyColor.HasValue)
{
material.SetColor("_AlphaColorKey", keyColor.Value);
}
return(material);
}
public static void SetObjectEmissionColor(GameObject obj, Color col)
{
Renderer r = obj.GetComponent <Renderer>();
if (r)
{
UMaterial material = new UMaterial(r.sharedMaterial);
if (material.HasProperty("_EmissionColor"))
{
material.SetColor("_EmissionColor", col);
obj.GetComponent <Renderer>().sharedMaterial = material;
}
else
{
U.Object.Destroy(material);
}
}
}
// This is a hack for GI. PVR looks in the shader for a texture named "_MainTex" to extract the opacity of the material for baking. In the same manner, "_Cutoff" and "_Color" are also necessary.
// Since we don't have those parameters in our shaders we need to provide a "fake" useless version of them with the right values for the GI to work.
private static void SetupMainTexForAlphaTestGI(UnityEngine.Material unityMaterial, string colorMapPropertyName, string colorPropertyName)
{
if (unityMaterial.HasProperty(colorMapPropertyName))
{
var mainTex = unityMaterial.GetTexture(colorMapPropertyName);
unityMaterial.SetTexture(MainTex, mainTex);
}
if (unityMaterial.HasProperty(colorPropertyName))
{
var color = unityMaterial.GetColor(colorPropertyName);
unityMaterial.SetColor(Color, color);
}
if (unityMaterial.HasProperty("_AlphaCutoff"))
{
var cutoff = unityMaterial.GetFloat(AlphaCutoff);
unityMaterial.SetFloat(Cutoff, cutoff);
}
}
public void ChangeMaterial(string name, Color color = default(Color), float rate = 0)
{
AssetUtil.LoadAssetAsync(name,
(pathOrAddress, uObj, userData) =>
{
UnityEngine.Material cMaterial = uObj as UnityEngine.Material;
cMaterial.SetColor("_Frenel", color);
/// 变化范围1-0-1-0-1...
cMaterial.SetFloat("_Fre", 1);
cMaterial.SetFloat("_Vertex", 0);
if (m_MeshRenderer)
{
m_MeshRenderer.material = cMaterial;
if (rate > 0)
{
m_Rate = rate;
}
}
}
);
}
private static void CreateSingleMat(Material mat)
{
string strRes = mat.uuid.Replace("/", "");
UnityEngine.Color color = GetColour(mat);
// Create a simple material asset
var material = new UnityEngine.Material(Shader.Find("Standard"));
material.SetColor("_Color", color);
string path = "Assets/Resources/" + strRes + ".mat";
var myType = AssetDatabase.LoadAssetAtPath(path, typeof(UnityEngine.Material)) as UnityEngine.Material;
if (myType == null)
{
AssetDatabase.CreateAsset(material, path);
}
else
{
myType.SetColor("_Color", color);
}
}
protected virtual UnityEngine.Material CreateMaterial(Material def, bool useVertexColors)
{
if (def.ContentsWithVC == null || def.ContentsWithoutVC == null)
{
Shader shader;
// get the shader to use for this material
try
{
if (def.PbrMetallicRoughness != null)
{
shader = _shaderCache[MaterialType.PbrMetallicRoughness];
}
else if (_root.ExtensionsUsed != null && _root.ExtensionsUsed.Contains("KHR_materials_common") &&
def.CommonConstant != null)
{
shader = _shaderCache[MaterialType.CommonConstant];
}
else
{
shader = _shaderCache[MaterialType.PbrMetallicRoughness];
}
}
catch (KeyNotFoundException e)
{
Debug.LogWarningFormat("No shader supplied for type of glTF material {0}, using Standard fallback", def.Name);
shader = Shader.Find("Standard");
}
shader.maximumLOD = MaximumLod;
var material = new UnityEngine.Material(shader);
if (def.AlphaMode == AlphaMode.MASK)
{
material.SetOverrideTag("RenderType", "TransparentCutout");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.EnableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
material.SetFloat("_Cutoff", (float)def.AlphaCutoff);
}
else if (def.AlphaMode == AlphaMode.BLEND)
{
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.EnableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
}
else
{
material.SetOverrideTag("RenderType", "Opaque");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.DisableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = -1;
}
if (def.DoubleSided)
{
material.SetInt("_Cull", (int)CullMode.Off);
}
else
{
material.SetInt("_Cull", (int)CullMode.Back);
}
if (def.PbrMetallicRoughness != null)
{
var pbr = def.PbrMetallicRoughness;
material.SetColor("_Color", pbr.BaseColorFactor);
if (pbr.BaseColorTexture != null)
{
var texture = pbr.BaseColorTexture.Index.Value;
material.SetTexture("_MainTex", CreateTexture(texture));
}
material.SetFloat("_Metallic", (float)pbr.MetallicFactor);
if (pbr.MetallicRoughnessTexture != null)
{
var texture = pbr.MetallicRoughnessTexture.Index.Value;
material.SetTexture("_MetallicRoughnessMap", CreateTexture(texture));
}
material.SetFloat("_Roughness", (float)pbr.RoughnessFactor);
}
if (def.CommonConstant != null)
{
material.SetColor("_AmbientFactor", def.CommonConstant.AmbientFactor);
if (def.CommonConstant.LightmapTexture != null)
{
material.EnableKeyword("LIGHTMAP_ON");
var texture = def.CommonConstant.LightmapTexture.Index.Value;
material.SetTexture("_LightMap", CreateTexture(texture));
material.SetInt("_LightUV", def.CommonConstant.LightmapTexture.TexCoord);
}
material.SetColor("_LightFactor", def.CommonConstant.LightmapFactor);
}
if (def.NormalTexture != null)
{
var texture = def.NormalTexture.Index.Value;
material.SetTexture("_BumpMap", CreateTexture(texture));
material.SetFloat("_BumpScale", (float)def.NormalTexture.Scale);
}
if (def.OcclusionTexture != null)
{
var texture = def.OcclusionTexture.Index;
material.SetFloat("_OcclusionStrength", (float)def.OcclusionTexture.Strength);
if (def.PbrMetallicRoughness != null &&
def.PbrMetallicRoughness.MetallicRoughnessTexture != null &&
def.PbrMetallicRoughness.MetallicRoughnessTexture.Index.Id == texture.Id)
{
material.EnableKeyword("OCC_METAL_ROUGH_ON");
}
else
{
material.SetTexture("_OcclusionMap", CreateTexture(texture.Value));
}
}
if (def.EmissiveTexture != null)
{
var texture = def.EmissiveTexture.Index.Value;
material.EnableKeyword("EMISSION_MAP_ON");
material.SetTexture("_EmissionMap", CreateTexture(texture));
material.SetInt("_EmissionUV", def.EmissiveTexture.TexCoord);
}
material.SetColor("_EmissionColor", def.EmissiveFactor);
def.ContentsWithoutVC = material;
def.ContentsWithVC = new UnityEngine.Material(material);
def.ContentsWithVC.EnableKeyword("VERTEX_COLOR_ON");
}
return(def.GetContents(useVertexColors));
}
protected virtual MaterialCacheData CreateMaterial(GLTF.Schema.Material def, int materialIndex)
{
MaterialCacheData materialWrapper = null;
if (materialIndex < 0 || _assetCache.MaterialCache[materialIndex] == null)
{
Shader shader;
// get the shader to use for this material
try
{
if (_root.ExtensionsUsed != null && _root.ExtensionsUsed.Contains("KHR_materials_pbrSpecularGlossiness"))
{
shader = _shaderCache[MaterialType.KHR_materials_pbrSpecularGlossiness];
}
else if (def.PbrMetallicRoughness != null)
{
shader = _shaderCache[MaterialType.PbrMetallicRoughness];
}
else if (_root.ExtensionsUsed != null && _root.ExtensionsUsed.Contains("KHR_materials_common") &&
def.CommonConstant != null)
{
shader = _shaderCache[MaterialType.CommonConstant];
}
else
{
shader = _shaderCache[MaterialType.PbrMetallicRoughness];
}
}
catch (KeyNotFoundException)
{
Debug.LogWarningFormat("No shader supplied for type of glTF material {0}, using Standard fallback", def.Name);
shader = Shader.Find("Standard");
}
shader.maximumLOD = MaximumLod;
var material = new UnityEngine.Material(shader);
if (def.AlphaMode == AlphaMode.MASK)
{
material.SetOverrideTag("RenderType", "TransparentCutout");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.EnableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
material.SetFloat("_Cutoff", (float)def.AlphaCutoff);
}
else if (def.AlphaMode == AlphaMode.BLEND)
{
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.EnableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
}
else
{
material.SetOverrideTag("RenderType", "Opaque");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.DisableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = -1;
}
if (def.DoubleSided)
{
material.SetInt("_Cull", (int)CullMode.Off);
}
else
{
material.SetInt("_Cull", (int)CullMode.Back);
}
if (def.PbrMetallicRoughness != null)
{
var pbr = def.PbrMetallicRoughness;
material.SetColor("_Color", pbr.BaseColorFactor.ToUnityColor());
if (pbr.BaseColorTexture != null)
{
var textureDef = pbr.BaseColorTexture.Index.Value;
material.SetTexture("_MainTex", CreateTexture(textureDef));
ApplyTextureTransform(pbr.BaseColorTexture, material, "_MainTex");
}
material.SetFloat("_Metallic", (float)pbr.MetallicFactor);
if (pbr.MetallicRoughnessTexture != null)
{
var texture = pbr.MetallicRoughnessTexture.Index.Value;
material.SetTexture("_MetallicRoughnessMap", CreateTexture(texture));
ApplyTextureTransform(pbr.MetallicRoughnessTexture, material, "_MetallicRoughnessMap");
}
material.SetFloat("_Roughness", (float)pbr.RoughnessFactor);
}
if (_root.ExtensionsUsed != null && _root.ExtensionsUsed.Contains(KHR_materials_pbrSpecularGlossinessExtensionFactory.EXTENSION_NAME))
{
KHR_materials_pbrSpecularGlossinessExtension specGloss = def.Extensions[KHR_materials_pbrSpecularGlossinessExtensionFactory.EXTENSION_NAME] as KHR_materials_pbrSpecularGlossinessExtension;
if (specGloss.DiffuseTexture != null)
{
var texture = specGloss.DiffuseTexture.Index.Value;
material.SetTexture("_MainTex", CreateTexture(texture));
ApplyTextureTransform(specGloss.DiffuseTexture, material, "_MainTex");
}
else
{
material.SetColor("_Color", specGloss.DiffuseFactor.ToUnityColor());
}
if (specGloss.SpecularGlossinessTexture != null)
{
var texture = specGloss.SpecularGlossinessTexture.Index.Value;
material.SetTexture("_SpecGlossMap", CreateTexture(texture));
material.EnableKeyword("_SPECGLOSSMAP");
ApplyTextureTransform(specGloss.SpecularGlossinessTexture, material, "_SpecGlossMap");
}
else
{
material.SetVector("_SpecColor", specGloss.SpecularFactor.ToUnityVector3());
material.SetFloat("_Glossiness", (float)specGloss.GlossinessFactor);
}
}
if (def.CommonConstant != null)
{
material.SetColor("_AmbientFactor", def.CommonConstant.AmbientFactor.ToUnityColor());
if (def.CommonConstant.LightmapTexture != null)
{
material.EnableKeyword("LIGHTMAP_ON");
var texture = def.CommonConstant.LightmapTexture.Index.Value;
material.SetTexture("_LightMap", CreateTexture(texture));
material.SetInt("_LightUV", def.CommonConstant.LightmapTexture.TexCoord);
ApplyTextureTransform(def.CommonConstant.LightmapTexture, material, "_LightMap");
}
material.SetColor("_LightFactor", def.CommonConstant.LightmapFactor.ToUnityColor());
}
if (def.NormalTexture != null)
{
var texture = def.NormalTexture.Index.Value;
material.SetTexture("_BumpMap", CreateTexture(texture));
material.SetFloat("_BumpScale", (float)def.NormalTexture.Scale);
material.EnableKeyword("_NORMALMAP");
ApplyTextureTransform(def.NormalTexture, material, "_BumpMap");
}
if (def.OcclusionTexture != null)
{
var texture = def.OcclusionTexture.Index;
material.SetFloat("_OcclusionStrength", (float)def.OcclusionTexture.Strength);
if (def.PbrMetallicRoughness != null &&
def.PbrMetallicRoughness.MetallicRoughnessTexture != null &&
def.PbrMetallicRoughness.MetallicRoughnessTexture.Index.Id == texture.Id)
{
material.EnableKeyword("OCC_METAL_ROUGH_ON");
}
else
{
material.SetTexture("_OcclusionMap", CreateTexture(texture.Value));
ApplyTextureTransform(def.OcclusionTexture, material, "_OcclusionMap");
}
}
if (def.EmissiveTexture != null)
{
var texture = def.EmissiveTexture.Index.Value;
material.EnableKeyword("EMISSION_MAP_ON");
material.EnableKeyword("_EMISSION");
material.SetTexture("_EmissionMap", CreateTexture(texture));
material.SetInt("_EmissionUV", def.EmissiveTexture.TexCoord);
ApplyTextureTransform(def.EmissiveTexture, material, "_EmissionMap");
}
material.SetColor("_EmissionColor", def.EmissiveFactor.ToUnityColor());
materialWrapper = new MaterialCacheData
{
UnityMaterial = material,
UnityMaterialWithVertexColor = new UnityEngine.Material(material),
GLTFMaterial = def
};
materialWrapper.UnityMaterialWithVertexColor.EnableKeyword("VERTEX_COLOR_ON");
if (materialIndex > 0)
{
_assetCache.MaterialCache[materialIndex] = materialWrapper;
}
}
return(materialIndex > 0 ? _assetCache.MaterialCache[materialIndex] : materialWrapper);
}
private void WriteUiforms <TValue>(EditorImporter importer, UnityEngine.Material material, SeinMaterialUniform <TValue>[] uniforms)
{
foreach (SeinMaterialUniform <TValue> uniform in uniforms)
{
var name = uniform.name;
switch (uniform.type)
{
case (ESeinMaterialUniformType.FLOAT):
material.SetFloat(name, (uniform as SeinMaterialUniformFloat).value);
break;
case (ESeinMaterialUniformType.INT):
material.SetInt(name, (uniform as SeinMaterialUniformInt).value);
break;
case (ESeinMaterialUniformType.SAMPLER_2D):
var tex = importer.GetTexture((uniform as SeinMaterialUniformTexture).id.Id);
material.SetTexture(name, tex);
break;
// todo: support cubemap
case (ESeinMaterialUniformType.SAMPLER_CUBE):
break;
case (ESeinMaterialUniformType.FLOAT_VEC2):
var fv2 = (uniform as SeinMaterialUniformFloatVec2).value;
material.SetFloatArray(name, new List <float> {
fv2.x, fv2.y
});
break;
case (ESeinMaterialUniformType.FLOAT_VEC3):
var fv3 = (uniform as SeinMaterialUniformFloatVec3).value;
material.SetFloatArray(name, new List <float> {
fv3.x, fv3.y, fv3.z
});
break;
case (ESeinMaterialUniformType.FLOAT_VEC4):
if (uniform.GetType() == typeof(SeinMaterialUniformColor))
{
material.SetColor(name, (uniform as SeinMaterialUniformColor).value);
}
material.SetVector(name, (uniform as SeinMaterialUniformFloatVec4).value);
break;
case (ESeinMaterialUniformType.FLOAT_MAT2):
material.SetMatrix(name, (uniform as SeinMaterialUniformFloatMat2).value);
break;
case (ESeinMaterialUniformType.FLOAT_MAT3):
material.SetMatrix(name, (uniform as SeinMaterialUniformFloatMat3).value);
break;
case (ESeinMaterialUniformType.FLOAT_MAT4):
material.SetMatrix(name, (uniform as SeinMaterialUniformFloatMat4).value);
break;
default:
break;
}
}
}
private UnityEngine.Material CreateMaterial(Material def, bool useVertexColors)
{
UnityEngine.Material material = new UnityEngine.Material(useVertexColors ? ColorMaterial : NoColorMaterial);
material.shader.maximumLOD = MaximumLod;
if (def.AlphaMode == AlphaMode.MASK)
{
material.SetOverrideTag("RenderType", "TransparentCutout");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.EnableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest;
material.SetFloat("_Cutoff", (float)def.AlphaCutoff);
}
else if (def.AlphaMode == AlphaMode.BLEND)
{
material.SetOverrideTag("RenderType", "Transparent");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
material.SetInt("_ZWrite", 0);
material.DisableKeyword("_ALPHATEST_ON");
material.EnableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent;
}
else
{
material.SetOverrideTag("RenderType", "Opaque");
material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
material.SetInt("_ZWrite", 1);
material.DisableKeyword("_ALPHATEST_ON");
material.DisableKeyword("_ALPHABLEND_ON");
material.DisableKeyword("_ALPHAPREMULTIPLY_ON");
material.renderQueue = -1;
}
if (def.DoubleSided)
{
material.SetInt("_Cull", (int)CullMode.Off);
}
else
{
material.SetInt("_Cull", (int)CullMode.Back);
}
if (useVertexColors)
{
material.EnableKeyword("VERTEX_COLOR_ON");
}
if (def.PbrMetallicRoughness != null)
{
var pbr = def.PbrMetallicRoughness;
material.SetColor("_Color", pbr.BaseColorFactor);
if (pbr.BaseColorTexture != null)
{
var texture = pbr.BaseColorTexture.Index.Value;
material.SetTexture("_MainTex", _imageCache[texture.Source.Value]);
}
material.SetFloat("_Metallic", (float)pbr.MetallicFactor);
if (pbr.MetallicRoughnessTexture != null)
{
var texture = pbr.MetallicRoughnessTexture.Index.Value;
material.SetTexture("_MetallicRoughnessMap", _imageCache[texture.Source.Value]);
}
material.SetFloat("_Roughness", (float)pbr.RoughnessFactor);
}
if (def.CommonConstant != null)
{
material.SetColor("_AmbientFactor", def.CommonConstant.AmbientFactor);
if (def.CommonConstant.LightmapTexture != null)
{
material.EnableKeyword("LIGHTMAP_ON");
var texture = def.CommonConstant.LightmapTexture.Index.Value;
material.SetTexture("_LightMap", _imageCache[texture.Source.Value]);
material.SetInt("_LightUV", def.CommonConstant.LightmapTexture.TexCoord);
}
material.SetColor("_LightFactor", def.CommonConstant.LightmapFactor);
}
if (def.NormalTexture != null)
{
var texture = def.NormalTexture.Index.Value;
material.EnableKeyword("_NORMALMAP");
material.SetTexture("_BumpMap", _imageCache[texture.Source.Value]);
material.SetFloat("_BumpScale", (float)def.NormalTexture.Scale);
}
else
{
material.SetTexture("_BumpMap", null);
material.DisableKeyword("_NORMALMAP");
}
if (def.OcclusionTexture != null)
{
var texture = def.OcclusionTexture.Index;
material.SetFloat("_OcclusionStrength", (float)def.OcclusionTexture.Strength);
if (def.PbrMetallicRoughness != null &&
def.PbrMetallicRoughness.MetallicRoughnessTexture.Index.Id == texture.Id)
{
material.EnableKeyword("OCC_METAL_ROUGH_ON");
}
else
{
material.SetTexture("_OcclusionMap", _imageCache[texture.Value.Source.Value]);
}
}
if (def.EmissiveTexture != null)
{
var texture = def.EmissiveTexture.Index.Value;
material.EnableKeyword("_EMISSION");
material.EnableKeyword("EMISSION_MAP_ON");
material.SetTexture("_EmissionMap", _imageCache[texture.Source.Value]);
material.SetInt("_EmissionUV", def.EmissiveTexture.TexCoord);
}
material.SetColor("_EmissionColor", def.EmissiveFactor);
return(material);
}
void Update()
{
if (DoSetCloneState)
{
SetCloneState(CloneStateToSet);
DoSetCloneState = false;
}
if (UpdateCloneAmount)
{
SetCloneAmount(CloneCount);
UpdateCloneAmount = false;
}
if (DisableKinectUpdate)
{
UserMeshVisualizer.Instance.BlockKinectUpdate = true;
UserMeshVisualizer.Instance.DisableMeshUpdate = true;
DisableKinectUpdate = false;
}
else if (EnableKinectUpdate)
{
UserMeshVisualizer.Instance.BlockKinectUpdate = false;
UserMeshVisualizer.Instance.DisableMeshUpdate = false;
EnableKinectUpdate = false;
}
else if (DisableUserRender)
{
GameObject.Find("UserMesh").GetComponent <MeshRenderer>().enabled = false;
DisableUserRender = false;
}
else if (EnableUserRender)
{
GameObject.Find("UserMesh").GetComponent <MeshRenderer>().enabled = true;
// GameObject.Find("OutputQuad").GetComponent<MeshRenderer>().enabled = true;
EnableUserRender = false;
}
else if (ActivateClones)
{
EnableKinectUpdate = true;
EnableUserRender = true;
ParticleSceneController.Instance.OneFiveNineOut = true;
MidiManager.Instance.ShowClones();
if (GameObject.Find("LightPlane") != null)
{
GameObject.Find("LightPlane").SetActive(false);
}
var baseOutputQuad = GameObject.Find("OutputQuad");
var effector = baseOutputQuad.GetComponent <TrackerOutputEffector>();
effector.RefreshEveryFrame = true;
ActivateClones = false;
}
else if (CycleCloneColours)
{
CycleColours();
}
if (ActivateRainOutroState)
{
var baseOutputQuad = GameObject.Find("OutputQuad");
var effector = baseOutputQuad.GetComponent <TrackerOutputEffector>();
effector.CloneColourPosition = 3;
effector.RefreshCloneColours();
AirSticksNoteOnCyclesColours = false;
}
if (SillhouetteOff)
{
var baseOutputQuad = GameObject.Find("OutputQuad");
var renderer = baseOutputQuad.GetComponent <Renderer>();
renderer.material.SetColor("_TintColor", new Color(0, 0, 0, 0));
var effector = baseOutputQuad.GetComponent <TrackerOutputEffector>();
effector.CloneDistance = 0.005f;
ActivateRainOutroState = false;
SillhouetteOff = false;
}
if (ActivateCloneIntroState)
{
var baseOutputQuad = GameObject.Find("OutputQuad");
var effector = baseOutputQuad.GetComponent <TrackerOutputEffector>();
effector.CloneColourPosition = 1;
effector.RefreshCloneColours();
AirSticksNoteOnCyclesColours = false;
ActivateCloneIntroState = false;
}
if (RemoveAllClones)
{
var baseOutputQuad = GameObject.Find("OutputQuad");
var children = baseOutputQuad.GetComponentsInChildren <Transform>();
foreach (var child in children)
{
if (child.gameObject != baseOutputQuad)
{
Destroy(child.gameObject);
}
}
var effector = baseOutputQuad.GetComponent <TrackerOutputEffector>();
effector.LeftHandClones.Clear();
effector.RightHandClones.Clear();
RemoveAllClones = false;
effector.RefreshEveryFrame = false;
}
if (FadeOutStart)
{
FadeOutStartTime = Time.time;
FadingOut = true;
FadeOutMaterial = OutputQuad.GetComponent <MeshRenderer>().material;
FadeOutStart = false;
}
if (FadingOut)
{
var position = (Time.time - FadeOutStartTime) / FadeOutLength;
if (position >= 1)
{
position = 1;
FadingOut = false;
}
var v = 1 - position;
FadeOutMaterial.SetColor("_TintColor", Color.HSVToRGB(0, 0, v));
}
}
protected virtual void CreateUnityMaterial(GLTF.Schema.Material def, int materialIndex)
{
Extension specularGlossinessExtension = null;
bool isSpecularPBR = def.Extensions != null && def.Extensions.TryGetValue("KHR_materials_pbrSpecularGlossiness", out specularGlossinessExtension);
Shader shader = isSpecularPBR ? Shader.Find("Standard (Specular setup)") : Shader.Find("Standard");
var material = new UnityEngine.Material(shader);
material.hideFlags = HideFlags.DontUnloadUnusedAsset; // Avoid material to be deleted while being built
material.name = def.Name;
//Transparency
if (def.AlphaMode == AlphaMode.MASK)
{
GLTFUtils.SetupMaterialWithBlendMode(material, GLTFUtils.BlendMode.Cutout);
material.SetFloat("_Mode", 1);
material.SetFloat("_Cutoff", (float)def.AlphaCutoff);
}
else if (def.AlphaMode == AlphaMode.BLEND)
{
GLTFUtils.SetupMaterialWithBlendMode(material, GLTFUtils.BlendMode.Fade);
material.SetFloat("_Mode", 3);
}
if (def.NormalTexture != null)
{
var texture = def.NormalTexture.Index.Id;
Texture2D normalTexture = getTexture(texture) as Texture2D;
//Automatically set it to normal map
TextureImporter im = AssetImporter.GetAtPath(AssetDatabase.GetAssetPath(normalTexture)) as TextureImporter;
im.textureType = TextureImporterType.NormalMap;
im.SaveAndReimport();
material.SetTexture("_BumpMap", getTexture(texture));
material.SetFloat("_BumpScale", (float)def.NormalTexture.Scale);
}
if (def.EmissiveTexture != null)
{
material.EnableKeyword("EMISSION_MAP_ON");
var texture = def.EmissiveTexture.Index.Id;
material.SetTexture("_EmissionMap", getTexture(texture));
material.SetInt("_EmissionUV", def.EmissiveTexture.TexCoord);
}
// PBR channels
if (specularGlossinessExtension != null)
{
KHR_materials_pbrSpecularGlossinessExtension pbr = (KHR_materials_pbrSpecularGlossinessExtension)specularGlossinessExtension;
material.SetColor("_Color", pbr.DiffuseFactor.ToUnityColor().gamma);
if (pbr.DiffuseTexture != null)
{
var texture = pbr.DiffuseTexture.Index.Id;
material.SetTexture("_MainTex", getTexture(texture));
}
if (pbr.SpecularGlossinessTexture != null)
{
var texture = pbr.SpecularGlossinessTexture.Index.Id;
material.SetTexture("_SpecGlossMap", getTexture(texture));
material.SetFloat("_GlossMapScale", (float)pbr.GlossinessFactor);
material.SetFloat("_Glossiness", (float)pbr.GlossinessFactor);
}
else
{
material.SetFloat("_Glossiness", (float)pbr.GlossinessFactor);
}
Vector3 specularVec3 = pbr.SpecularFactor.ToUnityVector3();
material.SetColor("_SpecColor", new Color(specularVec3.x, specularVec3.y, specularVec3.z, 1.0f));
if (def.OcclusionTexture != null)
{
var texture = def.OcclusionTexture.Index.Id;
material.SetFloat("_OcclusionStrength", (float)def.OcclusionTexture.Strength);
material.SetTexture("_OcclusionMap", getTexture(texture));
}
GLTFUtils.SetMaterialKeywords(material, GLTFUtils.WorkflowMode.Specular);
}
else if (def.PbrMetallicRoughness != null)
{
var pbr = def.PbrMetallicRoughness;
material.SetColor("_Color", pbr.BaseColorFactor.ToUnityColor().gamma);
if (pbr.BaseColorTexture != null)
{
var texture = pbr.BaseColorTexture.Index.Id;
material.SetTexture("_MainTex", getTexture(texture));
}
material.SetFloat("_Metallic", (float)pbr.MetallicFactor);
material.SetFloat("_Glossiness", 1.0f - (float)pbr.RoughnessFactor);
if (pbr.MetallicRoughnessTexture != null)
{
var texture = pbr.MetallicRoughnessTexture.Index.Id;
UnityEngine.Texture2D inputTexture = getTexture(texture) as Texture2D;
List <Texture2D> splitTextures = splitMetalRoughTexture(inputTexture, def.OcclusionTexture != null, (float)pbr.MetallicFactor, (float)pbr.RoughnessFactor);
material.SetTexture("_MetallicGlossMap", splitTextures[0]);
if (def.OcclusionTexture != null)
{
material.SetFloat("_OcclusionStrength", (float)def.OcclusionTexture.Strength);
material.SetTexture("_OcclusionMap", splitTextures[1]);
}
}
GLTFUtils.SetMaterialKeywords(material, GLTFUtils.WorkflowMode.Metallic);
}
material.SetColor("_EmissionColor", def.EmissiveFactor.ToUnityColor().gamma);
material = _assetManager.saveMaterial(material, materialIndex);
_assetManager._parsedMaterials.Add(material);
material.hideFlags = HideFlags.None;
}
public UnityEngine.Material CreateMaterial(PbrMaterial vpxMaterial, TableBehavior table, StringBuilder debug = null)
{
var unityMaterial = new UnityEngine.Material(GetShader())
{
name = vpxMaterial.Id
};
// apply some basic manipulations to the color. this just makes very
// very white colors be clipped to 0.8204 aka 204/255 is 0.8
// this is to give room to lighting values. so there is more modulation
// of brighter colors when being lit without blow outs too soon.
var col = vpxMaterial.Color.ToUnityColor();
if (vpxMaterial.Color.IsGray() && col.grayscale > 0.8)
{
debug?.AppendLine("Color manipulation performed, brightness reduced.");
col.r = col.g = col.b = 0.8f;
}
// alpha for color depending on blend mode
ApplyBlendMode(unityMaterial, vpxMaterial.MapBlendMode);
if (vpxMaterial.MapBlendMode == Engine.VPT.BlendMode.Translucent)
{
col.a = Mathf.Min(1, Mathf.Max(0, vpxMaterial.Opacity));
}
unityMaterial.SetColor(BaseColor, col);
// validate IsMetal. if true, set the metallic value.
// found VPX authors setting metallic as well as translucent at the
// same time, which does not render correctly in unity so we have
// to check if this value is true and also if opacity <= 1.
if (vpxMaterial.IsMetal && (!vpxMaterial.IsOpacityActive || vpxMaterial.Opacity >= 1))
{
unityMaterial.SetFloat(Metallic, 1f);
debug?.AppendLine("Metallic set to 1.");
}
// roughness / glossiness
unityMaterial.SetFloat(Smoothness, vpxMaterial.Roughness);
// map
if (table != null && vpxMaterial.HasMap)
{
unityMaterial.SetTexture(BaseColorMap, table.GetTexture(vpxMaterial.Map.Name));
}
// normal map
if (table != null && vpxMaterial.HasNormalMap)
{
unityMaterial.EnableKeyword("_NORMALMAP");
unityMaterial.EnableKeyword("_NORMALMAP_TANGENT_SPACE");
unityMaterial.SetInt(NormalMapSpace, 0); // 0 = TangentSpace, 1 = ObjectSpace
unityMaterial.SetFloat(NormalScale, 0f); // TODO FIXME: setting the scale to 0 for now. anything above 0 makes the entire unity editor window become black which is more likely a unity bug
unityMaterial.SetTexture(NormalMap, table.GetTexture(vpxMaterial.NormalMap.Name));
}
// GI hack. This is a necessary step, see respective code in BaseUnlitGUI.cs of the HDRP source
SetupMainTexForAlphaTestGI(unityMaterial, "_BaseColorMap", "_BaseColor");
return(unityMaterial);
}
