private EnableKeyword ( string keyword ) : void | ||
keyword | string | |
return | void |
/// <summary> /// Initializes the primary mesh material. /// Note: for good explanation of Renderer.materials see http://answers.unity3d.com/questions/228744/material-versus-shared-material.html /// </summary> /// <param name="material">The material.</param> private void InitializePrimaryMeshMaterial(Material material) { if (!material.IsKeywordEnabled(UnityConstants.StdShader_RenderModeKeyword_FadeTransparency)) { material.EnableKeyword(UnityConstants.StdShader_RenderModeKeyword_FadeTransparency); } if (!material.IsKeywordEnabled(UnityConstants.StdShader_MapKeyword_Metallic)) { material.EnableKeyword(UnityConstants.StdShader_MapKeyword_Metallic); } /******************************************************************************************* * These values were set when I wasn't using the metal material's MetallicMap, opting * instead to set these. UNCLEAR Why I don't know, but not using the MatallicMap kept the * colors from showing up on the element unless the shader tab was clicked in the inspector. * * if (material.GetFloat(UnityConstants.StdShader_Property_MetallicFloat) != 0.25F) { * material.SetFloat(UnityConstants.StdShader_Property_MetallicFloat, 0.25F); * } * if (material.GetFloat(UnityConstants.StdShader_Property_SmoothnessFloat) != 0.4F) { * material.SetFloat(UnityConstants.StdShader_Property_SmoothnessFloat, 0.4F); * } *******************************************************************************************/ if (!material.IsKeywordEnabled(UnityConstants.StdShader_MapKeyword_Normal)) { material.EnableKeyword(UnityConstants.StdShader_MapKeyword_Normal); } if (material.GetFloat(UnityConstants.StdShader_Property_NormalScaleFloat) != 1.25F) { material.SetFloat(UnityConstants.StdShader_Property_NormalScaleFloat, 1.25F); } }
private void SetColorRange(Material material) { switch (ColorRange) { case TOD_ColorRangeType.Auto: if (Components.Camera && Components.Camera.HDR) { material.EnableKeyword("HDR"); material.DisableKeyword("LDR"); } else { material.DisableKeyword("HDR"); material.EnableKeyword("LDR"); } break; case TOD_ColorRangeType.HDR: material.EnableKeyword("HDR"); material.DisableKeyword("LDR"); break; case TOD_ColorRangeType.LDR: material.DisableKeyword("HDR"); material.EnableKeyword("LDR"); break; } }
public override Material CloneMaterial(Material src, int nth) { Material m = new Material(src); m.SetInt("g_batch_begin", nth * m_instances_par_batch); m.SetBuffer("particles", m_world.GetParticleBuffer()); if (m_hdr) { m.SetInt("_SrcBlend", (int)BlendMode.One); m.SetInt("_DstBlend", (int)BlendMode.One); } else { m.SetInt("_SrcBlend", (int)BlendMode.DstColor); m.SetInt("_DstBlend", (int)BlendMode.Zero); } if(m_enable_shadow) { m.EnableKeyword("ENABLE_SHADOW"); switch (m_sample) { case Sample.Fast: m.EnableKeyword("QUALITY_FAST"); break; case Sample.Medium: m.EnableKeyword("QUALITY_MEDIUM"); break; case Sample.High: m.EnableKeyword("QUALITY_HIGH"); break; } } return m; }
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; } } }
private void SetColorSpace(Material material) { switch (ColorSpace) { case TOD_ColorSpaceType.Auto: if (QualitySettings.activeColorSpace == UnityEngine.ColorSpace.Linear) { material.EnableKeyword("LINEAR"); material.DisableKeyword("GAMMA"); } else { material.DisableKeyword("LINEAR"); material.EnableKeyword("GAMMA"); } break; case TOD_ColorSpaceType.Linear: material.EnableKeyword("LINEAR"); material.DisableKeyword("GAMMA"); break; case TOD_ColorSpaceType.Gamma: material.DisableKeyword("LINEAR"); material.EnableKeyword("GAMMA"); break; } }
private static UnityEngine.Material CreateMaterial(EditorMaterial editorMat) { bool doubleSided = editorMat.PolygonType.HasFlag(PolyType.DOUBLESIDED); bool transparent = editorMat.PolygonType.HasFlag(PolyType.TRANS); bool water = editorMat.PolygonType.HasFlag(PolyType.WATER); bool glow = editorMat.PolygonType.HasFlag(PolyType.GLOW); bool lava = editorMat.PolygonType.HasFlag(PolyType.LAVA); bool fall = editorMat.PolygonType.HasFlag(PolyType.FALL); UnityEngine.Material mat; if (doubleSided && transparent) { mat = MaterialsDatabase.ArxMatDoubleSidedTransparent; } else if (doubleSided) { mat = MaterialsDatabase.ArxMatDoubleSided; } else if (transparent) { mat = MaterialsDatabase.ArxMatTransparent; } else { mat = MaterialsDatabase.ArxMat; } mat = UnityEngine.Object.Instantiate(mat); mat.name = editorMat.TexturePath; mat.mainTexture = LevelEditor.TextureDatabase[editorMat.TexturePath]; if (transparent) {//transparents look better with point filtering //TODO: check transval if (mat.mainTexture != null) { mat.mainTexture.filterMode = FilterMode.Point;//should do this on an instance of the tex, but that would break the caching.. ughhhh TODO!!! } } //The following keywords cause scrolling of the texture etc, so its done using shader variants if (water) { mat.EnableKeyword("WATER"); } if (lava) { mat.EnableKeyword("LAVA"); } if (glow) { mat.EnableKeyword("GLOW"); } if (fall) { mat.EnableKeyword("FALL"); } return(mat); }
private void RefreshDrawSelfShadowKeyword(bool drawSelfshadow, UnityEngine.Material material) { if (drawSelfshadow) { material.EnableKeyword("SELFSHADOW_ON"); material.DisableKeyword("SELFSHADOW_OFF"); } else { material.DisableKeyword("SELFSHADOW_ON"); material.EnableKeyword("SELFSHADOW_OFF"); } }
private void InitializePrimaryMeshMaterial(Material material) { // no need to enable RenderingMode.Opaque as it is the default // for now, color is green if (material.IsKeywordEnabled(UnityConstants.StdShader_MapKeyword_Metallic)) { material.EnableKeyword(UnityConstants.StdShader_MapKeyword_Metallic); } material.SetFloat(UnityConstants.StdShader_Property_MetallicFloat, Constants.ZeroF); material.SetFloat(UnityConstants.StdShader_Property_SmoothnessFloat, 0.20F); if (!material.IsKeywordEnabled(UnityConstants.StdShader_MapKeyword_Normal)) { material.EnableKeyword(UnityConstants.StdShader_MapKeyword_Normal); } material.SetFloat(UnityConstants.StdShader_Property_NormalScaleFloat, 1F); }
public static void SetMaterialRenderingMode(Material material, StandardShaderRenderingMode mode) { switch (mode) { case StandardShaderRenderingMode.Opaque: material.SetOverrideTag("RenderType", ""); 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; break; case StandardShaderRenderingMode.Cutout: 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 = 2450; break; case StandardShaderRenderingMode.Fade: 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 = 3000; break; case StandardShaderRenderingMode.Transparent: material.SetOverrideTag("RenderType", "Transparent"); material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One); material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); material.SetInt("_ZWrite", 0); material.DisableKeyword("_ALPHATEST_ON"); material.DisableKeyword("_ALPHABLEND_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = 3000; break; } }
private Material MakeMaterial() { Material newMaterial = new Material(Shader.Find("Standard")); newMaterial.SetFloat("_Mode", 1.0f); newMaterial.EnableKeyword("_ALPHATEST_ON"); newMaterial.EnableKeyword("_NORMALMAP"); newMaterial.SetTexture("_BumpMap", AssetDatabase.LoadAssetAtPath<Texture>("Assets/Sprites/Frogs/" + referencePath + "/Processed/" + referencePath.Replace(" ", "") + spriteName + "_NORMALS.png")); //newMaterial.SetTexture("_SpecGlossMap", AssetDatabase.LoadAssetAtPath<Texture>("Assets/Sprites/Frogs/" + referencePath + "/Processed/" + referencePath.Replace(" ", "") + spriteName + "_SPECULAR.png")); newMaterial.SetTexture("_ParallaxMap", AssetDatabase.LoadAssetAtPath<Texture>("Assets/Sprites/Frogs/" + referencePath + "/Processed/" + referencePath.Replace(" ", "") + spriteName + "_DEPTH.png")); newMaterial.SetTexture("_OcclusionMap", AssetDatabase.LoadAssetAtPath<Texture>("Assets/Sprites/Frogs/" + referencePath + "/Processed/" + referencePath.Replace(" ", "") + spriteName + "_OCCLUSION.png")); newMaterial.SetFloat("_Glossiness", 0); AssetDatabase.CreateAsset(newMaterial, "Assets/Sprites/Frogs/" + referencePath + "/" + referencePath.Replace(" ", "") + spriteName + ".mat"); return AssetDatabase.LoadAssetAtPath<Material>("Assets/Sprites/Frogs/" + referencePath + "/" + referencePath.Replace(" ", "") + spriteName + ".mat"); }
IEnumerator Start() { foreach (var r in GetComponentsInChildren<Renderer>()) { renderers.Add(r); originalMaterials[r] = r.sharedMaterial; var material = new Material(r.material); material.SetFloat("_Mode", 2); 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 = 3000; r.material = material; } for (float t = 0; t < 1f; t += Time.deltaTime) { if (!UpdateRenderers(t)) { yield break; } yield return null; } foreach (var r in renderers) { if (r) { r.material = originalMaterials[r]; } } Destroy(this); }
static void SetKeyword(Material m, string keyword, bool state) { if (state) m.EnableKeyword(keyword); else m.DisableKeyword(keyword); }
protected override RenderQueue?ApplyTransmission( ref Color baseColorLinear, IGltfReadable gltf, Transmission transmission, Material material, RenderQueue?renderQueue ) { if (supportsCameraOpaqueTexture) { if (transmission.transmissionFactor > 0f) { material.EnableKeyword("TRANSMISSION"); material.SetFloat(transmissionFactorPropId, transmission.transmissionFactor); renderQueue = RenderQueue.Transparent; if (TrySetTexture(transmission.transmissionTexture, material, transmissionTexturePropId, gltf)) { } } return(renderQueue); } return(base.ApplyTransmission( ref baseColorLinear, gltf, transmission, material, renderQueue )); }
public static void SetupMaterialWithBlendMode(Material material, BlendMode blendMode) { switch (blendMode) { case BlendMode.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.renderQueue = -1; break; case BlendMode.Cutout: 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.renderQueue = 2450; break; case BlendMode.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.renderQueue = 3000; break; } }
public static void SetAlphaModeMask(UnityEngine.Material material) { material.SetFloat(modePropId, (int)StandardShaderMode.Cutout); material.SetOverrideTag("RenderType", "TransparentCutout"); material.EnableKeyword("_ALPHATEST_ON"); material.renderQueue = 2450; }
protected override RenderQueue?ApplyTransmission( ref Color baseColorLinear, ref Texture[] textures, ref Image[] schemaImages, ref Dictionary <int, Texture2D>[] imageVariants, Transmission transmission, Material material, RenderQueue?renderQueue ) { if (supportsCameraOpaqueTexture) { if (transmission.transmissionFactor > 0f) { material.EnableKeyword("TRANSMISSION"); material.SetFloat(transmissionFactorPropId, transmission.transmissionFactor); renderQueue = RenderQueue.Transparent; if (TrySetTexture(transmission.transmissionTexture, material, transmissionTexturePropId, ref textures, ref schemaImages, ref imageVariants)) { } } return(renderQueue); } return(base.ApplyTransmission( ref baseColorLinear, ref textures, ref schemaImages, ref imageVariants, transmission, material, renderQueue )); }
static void TrySetTextureTransform( Schema.TextureInfo textureInfo, UnityEngine.Material material, int propertyId ) { if (textureInfo.extensions != null && textureInfo.extensions.KHR_texture_transform != null) { var tt = textureInfo.extensions.KHR_texture_transform; if (tt.texCoord != 0) { Debug.LogError("Multiple UV sets are not supported!"); } if (tt.offset != null) { material.SetTextureOffset(propertyId, new Vector2(tt.offset[0], 1 - tt.offset[1])); } if (tt.rotation != 0) { float cos = Mathf.Cos(tt.rotation); float sin = Mathf.Sin(tt.rotation); material.SetVector(StandardShaderHelper.mainTexRotatePropId, new Vector4(cos, -sin, sin, cos)); material.EnableKeyword(StandardShaderHelper.KW_UV_ROTATION); } if (tt.scale != null) { material.SetTextureScale(propertyId, new Vector2(tt.scale[0], -tt.scale[1])); } } }
private static void TrySetTextureTransform( Schema.TextureInfo textureInfo, UnityEngine.Material material, int propertyId, bool flipY = false ) { // Scale (x,y) and Transform (z,w) float4 textureST = new float4( 1, 1, // scale 0, 0 // transform ); if (textureInfo.extensions != null && textureInfo.extensions.KHR_texture_transform != null) { var tt = textureInfo.extensions.KHR_texture_transform; if (tt.texCoord != 0) { Debug.LogError(ERROR_MULTI_UVS); } float cos = 1; float sin = 0; if (tt.offset != null) { textureST.z = tt.offset[0]; textureST.w = 1 - tt.offset[1]; } if (tt.scale != null) { textureST.x = tt.scale[0]; textureST.y = tt.scale[1]; } if (tt.rotation != 0) { cos = math.cos(tt.rotation); sin = math.sin(tt.rotation); var newRot = new Vector2(textureST.x * sin, textureST.y * -sin); material.SetVector(mainTexRotation, newRot); textureST.x *= cos; textureST.y *= cos; material.EnableKeyword(KW_UV_ROTATION); textureST.z -= newRot.y; // move offset to move rotation point (horizontally) } textureST.w -= textureST.y * cos; // move offset to move flip axis point (vertically) } if (flipY) { textureST.z = 1 - textureST.z; // flip offset in Y textureST.y = -textureST.y; // flip scale in Y } material.SetVector(mainTexScaleTransform, textureST); }
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); }
void Start() { material = GetComponentInChildren<Renderer>().material; material.EnableKeyword("_EMISSION"); timer = 0f; t = 0f; }
public static void SetShaderBlendMode(BlendMode blendMode, ref Material material) { switch (blendMode) { case BlendMode.Opaque: material.SetFloat("_Mode", (float)BlendMode.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; break; case BlendMode.Cutout: material.SetFloat("_Mode", (float)BlendMode.Cutout); 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 = 2450; break; case BlendMode.Fade: material.SetFloat("_Mode", (float)BlendMode.Fade); 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 = 3000; break; case BlendMode.Transparent: material.SetFloat("_Mode", (float)BlendMode.Transparent); material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One); material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); material.SetInt("_ZWrite", 0); material.DisableKeyword("_ALPHATEST_ON"); material.DisableKeyword("_ALPHABLEND_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = 3000; break; } }
protected override void SetShaderModeBlend(Schema.Material gltfMaterial, Material material) { material.SetOverrideTag(TAG_RENDER_TYPE, TAG_RENDER_TYPE_TRANSPARENT); material.EnableKeyword(KW_SURFACE_TYPE_TRANSPARENT); material.EnableKeyword(KW_DISABLE_SSR_TRANSPARENT); material.EnableKeyword(KW_ENABLE_FOG_ON_TRANSPARENT); material.SetShaderPassEnabled(k_ShaderPassTransparentDepthPrepass, false); material.SetShaderPassEnabled(k_ShaderPassTransparentDepthPostpass, false); material.SetShaderPassEnabled(k_ShaderPassTransparentBackface, false); material.SetShaderPassEnabled(k_ShaderPassRayTracingPrepass, false); material.SetShaderPassEnabled(k_ShaderPassDepthOnlyPass, false); material.SetFloat(srcBlendPropId, (int)BlendMode.SrcAlpha); //5 material.SetFloat(dstBlendPropId, (int)BlendMode.OneMinusSrcAlpha); //10 material.SetFloat(k_ZTestGBufferPropId, (int)CompareFunction.Equal); //3 material.SetFloat(k_AlphaDstBlendPropId, (int)BlendMode.OneMinusSrcAlpha); //10 material.SetFloat(k_Surface, 1); material.SetFloat(zWritePropId, 0); }
protected virtual void SetAlphaModeMask(Schema.Material gltfMaterial, Material material) { material.SetFloat(cutoffPropId, gltfMaterial.alphaCutoff); #if USING_HDRP_10_OR_NEWER || USING_URP_12_OR_NEWER material.EnableKeyword(KW_ALPHATEST_ON); material.SetOverrideTag(TAG_RENDER_TYPE, TAG_RENDER_TYPE_CUTOUT); material.SetFloat(k_ZTestGBufferPropId, (int)CompareFunction.Equal); //3 #endif }
public static void SetAlphaModeBlend(UnityEngine.Material material) { material.SetFloat(modePropId, (int)StandardShaderMode.Transparent); material.SetFloat(dstBlendPropId, 10); material.SetOverrideTag("RenderType", "Transparent"); material.DisableKeyword("_ALPHATEST_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = 3000; }
private static void ApplyBlendMode(UnityEngine.Material unityMaterial, BlendMode blendMode) { switch (blendMode) { case BlendMode.Opaque: unityMaterial.SetFloat(Mode, 0); unityMaterial.SetInt(SrcBlend, (int)UnityEngine.Rendering.BlendMode.One); unityMaterial.SetInt(DstBlend, (int)UnityEngine.Rendering.BlendMode.Zero); unityMaterial.SetInt(ZWrite, 1); unityMaterial.DisableKeyword("_ALPHATEST_ON"); unityMaterial.DisableKeyword("_ALPHABLEND_ON"); unityMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON"); unityMaterial.renderQueue = -1; break; case BlendMode.Cutout: unityMaterial.SetFloat(Mode, 1); unityMaterial.SetInt(SrcBlend, (int)UnityEngine.Rendering.BlendMode.One); unityMaterial.SetInt(DstBlend, (int)UnityEngine.Rendering.BlendMode.Zero); unityMaterial.SetInt(ZWrite, 1); unityMaterial.EnableKeyword("_ALPHATEST_ON"); unityMaterial.DisableKeyword("_ALPHABLEND_ON"); unityMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON"); unityMaterial.renderQueue = 2450; break; case BlendMode.Translucent: unityMaterial.SetFloat(Mode, 3); unityMaterial.SetInt(SrcBlend, (int)UnityEngine.Rendering.BlendMode.One); unityMaterial.SetInt(DstBlend, (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); //!!!!!!! this is normally switched off but somehow enabling it seems to resolve so many issues.. keep an eye out for weirld opacity issues //unityMaterial.SetInt("_ZWrite", 0); unityMaterial.SetInt(ZWrite, 1); unityMaterial.DisableKeyword("_ALPHATEST_ON"); unityMaterial.DisableKeyword("_ALPHABLEND_ON"); unityMaterial.EnableKeyword("_ALPHAPREMULTIPLY_ON"); unityMaterial.renderQueue = 3000; break; default: throw new ArgumentOutOfRangeException(); } }
public void EnsureKeyword(Material material, string name, bool enabled) { if (enabled != material.IsKeywordEnabled(name)) { if (enabled) material.EnableKeyword(name); else material.DisableKeyword(name); } }
private void setMaterialToFade(Material m) { m.SetFloat("_Mode", 2); m.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha); m.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); m.SetInt("_ZWrite", 0); m.DisableKeyword("_ALPHATEST_ON"); m.EnableKeyword("_ALPHABLEND_ON"); m.DisableKeyword("_ALPHAPREMULTIPLY_ON"); m.renderQueue = 3000; }
protected void SetKeywordState(UnityEngine.Material material, string keyword, bool activate) { if (activate) { material.EnableKeyword(keyword); } else { material.DisableKeyword(keyword); } }
void Transparent(Material material) { material.SetFloat("_Mode", 3); material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One); material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); material.SetInt("_ZWrite", 0); material.DisableKeyword("_ALPHATEST_ON"); material.DisableKeyword("_ALPHABLEND_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = 3000; }
public static void SetTransparent(Material material) { 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.DisableKeyword("_ALPHABLEND_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = 3000; }
/// <summary> /// sets rendering mode of 'material' to transparent /// </summary> public static void MakeMaterialTransparent(UnityEngine.Material material) { material.SetFloat("_Mode", 2); 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 = 3000; }
static void TrySetTextureTransform( Schema.TextureInfo textureInfo, UnityEngine.Material material, int propertyId, bool flipY = false ) { Vector2 offset = Vector2.zero; Vector2 scale = Vector2.one; if (textureInfo.extensions != null && textureInfo.extensions.KHR_texture_transform != null) { var tt = textureInfo.extensions.KHR_texture_transform; if (tt.texCoord != 0) { Debug.LogError("Multiple UV sets are not supported!"); } float cos = 1; float sin = 0; if (tt.offset != null) { offset.x = tt.offset[0]; offset.y = 1 - tt.offset[1]; } if (tt.scale != null) { scale.x = tt.scale[0]; scale.y = tt.scale[1]; material.SetTextureScale(propertyId, scale); } if (tt.rotation != 0) { cos = Mathf.Cos(tt.rotation); sin = Mathf.Sin(tt.rotation); material.SetVector(StandardShaderHelper.mainTexRotatePropId, new Vector4(cos, sin, -sin, cos)); material.EnableKeyword(StandardShaderHelper.KW_UV_ROTATION); offset.x += scale.y * sin; } offset.y -= scale.y * cos; material.SetTextureOffset(propertyId, offset); } if (flipY) { offset.y = 1 - offset.y; scale.y = -scale.y; } material.SetTextureOffset(propertyId, offset); material.SetTextureScale(propertyId, scale); }
protected void SetKeyword(UnityEngine.Material material, bool b, int keywordIndex) { if (b && _keywords != null && _keywords.Length > keywordIndex && _keywords.Length > 0) { CleanKeywords(material); material.EnableKeyword(_keywords[keywordIndex]); } else { CleanKeywords(material); } }
public static void SetAlphaModeBlend(UnityEngine.Material material) { material.SetFloat(modePropId, (int)StandardShaderMode.Transparent); material.SetOverrideTag("RenderType", "Transparent"); material.SetInt(srcBlendPropId, (int)UnityEngine.Rendering.BlendMode.SrcAlpha); //5 material.SetInt(dstBlendPropId, (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); //10 material.SetInt(zWritePropId, 0); material.DisableKeyword("_ALPHATEST_ON"); material.EnableKeyword("_ALPHABLEND_ON"); material.DisableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.Transparent; //3000 }
void Start() { Material m = new Material(Shader.Find("Custom/StandardDepthBuffer")); m.SetFloat("_Mode", 2); m.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha); m.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); m.SetInt("_ZWrite", 0); m.DisableKeyword("_ALPHATEST_ON"); m.EnableKeyword("_ALPHABLEND_ON"); m.DisableKeyword("_ALPHAPREMULTIPLY_ON"); m.renderQueue = 3000; }
public static void SetAlphaModeMask(UnityEngine.Material material, Schema.Material gltfMaterial) { material.SetFloat(modePropId, (int)StandardShaderMode.Cutout); material.SetOverrideTag("RenderType", "TransparentCutout"); material.SetInt(srcBlendPropId, (int)UnityEngine.Rendering.BlendMode.One); material.SetInt(dstBlendPropId, (int)UnityEngine.Rendering.BlendMode.Zero); material.SetInt(zWritePropId, 1); material.EnableKeyword("_ALPHATEST_ON"); material.DisableKeyword("_ALPHABLEND_ON"); material.DisableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = (int)UnityEngine.Rendering.RenderQueue.AlphaTest; //2450 material.SetFloat(cutoffPropId, gltfMaterial.alphaCutoff); }
void ApplyTransparent(Color col) { rend = this.gameObject.GetComponent<Renderer>().material; rend.SetFloat("_Mode", 3f); rend.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One); rend.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); rend.SetInt("_ZWrite", 0); rend.DisableKeyword("_ALPHATEST_ON"); rend.DisableKeyword("_ALPHABLEND_ON"); rend.EnableKeyword("_ALPHAPREMULTIPLY_ON"); rend.renderQueue = 3000; StartCoroutine(colorLerp1(rend.GetColor("_Color"), col)); }
Material CreateMaterial(Color emissionColor) { Material m = new Material(outlineBufferShader); m.SetColor("_Color", emissionColor); m.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha); m.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); m.SetInt("_ZWrite", 0); m.DisableKeyword("_ALPHATEST_ON"); m.EnableKeyword("_ALPHABLEND_ON"); m.DisableKeyword("_ALPHAPREMULTIPLY_ON"); m.renderQueue = 3000; return m; }
static public int EnableKeyword(IntPtr l) { try { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.String a1; checkType(l, 2, out a1); self.EnableKeyword(a1); pushValue(l, true); return(1); } catch (Exception e) { return(error(l, e)); } }
private void SetCloudQuality(Material material) { switch (CloudQuality) { case TOD_CloudQualityType.Fastest: material.EnableKeyword("FASTEST"); material.DisableKeyword("DENSITY"); material.DisableKeyword("BUMPED"); break; case TOD_CloudQualityType.Density: material.DisableKeyword("FASTEST"); material.EnableKeyword("DENSITY"); material.DisableKeyword("BUMPED"); break; case TOD_CloudQualityType.Bumped: material.DisableKeyword("FASTEST"); material.DisableKeyword("DENSITY"); material.EnableKeyword("BUMPED"); break; } }
static public int EnableKeyword(IntPtr l) { try { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.String a1; checkType(l, 2, out a1); self.EnableKeyword(a1); return(0); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
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;*/ }
static int EnableKeyword(IntPtr L) { try { ToLua.CheckArgsCount(L, 2); UnityEngine.Material obj = (UnityEngine.Material)ToLua.CheckObject(L, 1, typeof(UnityEngine.Material)); string arg0 = ToLua.CheckString(L, 2); obj.EnableKeyword(arg0); return(0); } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
public static Material GetMaterial(ObjectType objectType, RenderMode renderMode, BlendMode blendMode) { if (blendMode == BlendMode.Normal) { if (objectType == ObjectType.MeshDefault) { var mat = new Material(Shader.Find("Diffuse")); mat.hideFlags = HideFlags.HideAndDontSave; return mat; } else if (objectType == ObjectType.SpriteDefault) { var mat = new Material(Shader.Find("Sprites/Default")); mat.hideFlags = HideFlags.HideAndDontSave; return mat; } else if (objectType == ObjectType.ParticleDefault) { var mat = new Material(Shader.Find("Particles/Additive")); mat.hideFlags = HideFlags.HideAndDontSave; return mat; } else return null; } // Framebuffer won't work in the editor, so fallback to Grab mode. if (Application.isEditor && renderMode == RenderMode.Framebuffer) renderMode = RenderMode.Grab; // Disable caching for mesh and particle materials, as they are sharing them. if (objectType != ObjectType.MeshDefault && objectType != ObjectType.ParticleDefault && cachedMaterials.ContainsKey(objectType) && cachedMaterials[objectType].ContainsKey(renderMode) && cachedMaterials[objectType][renderMode].ContainsKey(blendMode)) return cachedMaterials[objectType][renderMode][blendMode]; else { var mat = new Material(Resources.Load<Shader>(string.Format("BlendModes/{0}/{1}", objectType, renderMode))); mat.hideFlags = HideFlags.HideAndDontSave; mat.EnableKeyword("BM" + blendMode.ToString()); if (!cachedMaterials.ContainsKey(objectType)) cachedMaterials.Add(objectType, new Dictionary<RenderMode, Dictionary<BlendMode, Material>>()); if (!cachedMaterials[objectType].ContainsKey(renderMode)) cachedMaterials[objectType].Add(renderMode, new Dictionary<BlendMode, Material>()); if (!cachedMaterials[objectType][renderMode].ContainsKey(blendMode)) cachedMaterials[objectType][renderMode].Add(blendMode, mat); return mat; } }
private void Start() { theLight = GetComponent<Light>(); mRend = GetComponent<MeshRenderer>(); normalMaterial = mRend.material; normalMaterial.EnableKeyword("_EMISSION"); _currentColor = normalMaterial.GetColor("_Color"); //print (_currentColor); _newColor.w = 2.0f; theLight.range = initialRange; theLight.color = _currentColor; aSource = transform.parent.GetComponent<AudioSource>(); }
private void Start() { mRend = GetComponent<MeshRenderer>(); cController = GetComponent<CharacterController>(); cam = Camera.main; atSurface = false; defaultScale = transform.localScale; normalMaterial = mRend.material; normalMaterial.EnableKeyword("_EMISSION"); _initialColor = normalMaterial.color; _currentColor = normalMaterial.GetColor("_Color"); //if (GameManager.Instance.player != null && GameManager.Instance.follow != null) //Physics.IgnoreCollision(GameManager.Instance.playerCollider, GameManager.Instance.followCollider); }
public static void SetTransparent(Material material, Color? newcolor = null) { 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.DisableKeyword("_ALPHABLEND_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.SetFloat("_Metallic", 0f); material.SetFloat("_Glossiness", 0f); material.renderQueue = 3000; material.mainTexture = null; if (newcolor != null) { material.color = newcolor.Value; } }
void OnCollisionEnter(Collision coll) { switch (coll.gameObject.tag) { case "DestroyPlayerOnImpact": this.gameObject.GetComponent<PlayerPowerUpController> ().DeactivatePowerUp (null); DeathController.KillPlayer (this.gameObject, DeathController.DeathCause.Lava); break; case "Bouncy": bouncyForce = rb.mass * 275.0F; bounceVector = new Vector3 (0, bouncyForce, 0); rb.AddForce (bounceVector); currBouncePadMat = coll.gameObject.GetComponent<MeshRenderer>().material; currBouncePadMat.EnableKeyword("_EMISSION"); timePassed = 0.0f; bouncePadMatActive = true; break; case "Icey": pc.OnIce (); break; } }
public static UnityEngine.Material ToUnityMaterial(this Elements.Material material) { var uMaterial = new UnityEngine.Material(Shader.Find("Standard")); uMaterial.name = material.Name; uMaterial.color = material.Color.ToUnityColor(); uMaterial.SetInt("_Cull", (int)UnityEngine.Rendering.CullMode.Off); if (material.Color.Alpha < 1.0f) { uMaterial.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One); uMaterial.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); uMaterial.SetInt("_ZWrite", 0); uMaterial.DisableKeyword("_ALPHATEST_ON"); uMaterial.DisableKeyword("_ALPHABLEND_ON"); uMaterial.EnableKeyword("_ALPHAPREMULTIPLY_ON"); uMaterial.SetFloat("_Glossiness", material.GlossinessFactor); // uMaterial.SetFloat("_Metallic", material.SpecularFactor); uMaterial.renderQueue = 3000; } return(uMaterial); }
private void Init() { switch (algo) { case Algo.NAIVE: m_Shader = Shader.Find ("hidden/naive_gaussian_blur");break; case Algo.TWO_PASS: m_Shader = Shader.Find ("hidden/two_pass_gaussian_blur");break; case Algo.TWO_PASS_LINEAR_SAMPLING: m_Shader = Shader.Find ("hidden/two_pass_linear_sampling_gaussian_blur");break; } if (m_Shader.isSupported == false) { enabled = false; Debug.LogWarning ("Shader not supported"); return; } if (algo == Algo.NAIVE && quality == Quality.BIG_KERNEL) { quality = Quality.MEDIUM_KERNEL; Debug.LogWarning("Some graphic's driver crash with Algo.NAIVE and Quality.BIG_KERNEL !"); } m_Material = new Material (m_Shader); m_Material.EnableKeyword (quality.ToString ()); }
public static void SetTransparent(Material material, Color? newcolor = null) { if (material.shader != StandardShader) Debug.LogWarning("Trying to set transparent mode on non-standard shader. Please use the Standard Shader instead or modify this method."); 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.DisableKeyword("_ALPHABLEND_ON"); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.SetFloat("_Metallic", 0f); material.SetFloat("_Glossiness", 0f); material.renderQueue = 3000; material.mainTexture = null; if (newcolor != null) { material.color = newcolor.Value; } }
/// <summary> /// Apply all the Properties Collection to the Target Material by its Name/Id. /// This method is only used by this base class to generate the Materials for the Cache /// </summary> /// <param name="PropCollection">Our source helper Prop Collection Dictionary.</param> /// <param name="CollectionName">Set the Collection by its Name/Id.</param> /// <param name="Target">Target material.</param> private void SetProperties(Dictionary<string, PropertiesCollection> PropCollection, string CollectionName, Material Target) { //Querry the Dictionary by the CollectionId and apply all properties to the Target Material if (PropCollection.ContainsKey(CollectionName)) { //Apply all Textures foreach (var tex in PropCollection[CollectionName].Textures) { Target.SetTexture(tex.Target.GetString(), tex.Value); } //Apply all Float Values foreach (var val in PropCollection[CollectionName].Floats) { Target.SetFloat(val.Target.GetString(), val.Value); } //Apply all Color tints foreach (var tints in PropCollection[CollectionName].Tints) { Target.SetColor(tints.Target.GetString(), tints.Value); } //Apply for all Shader Features foreach (var feature in PropCollection[CollectionName].Features) { if (feature.Value) Target.EnableKeyword(feature.Target.GetString()); else Target.DisableKeyword(feature.Target.GetString()); } } else { Debug.LogError("There is no matching Id on this Collection"); } }
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); }
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); }
//material public static void EnableBlending(Material mat, bool enable) { if(!internalBlendingSupport) return; if(enable) { mat.EnableKeyword("MARMO_SKY_BLEND_ON"); mat.DisableKeyword("MARMO_SKY_BLEND_OFF"); } else { mat.DisableKeyword("MARMO_SKY_BLEND_ON"); mat.EnableKeyword("MARMO_SKY_BLEND_OFF"); } }
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; }
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); }
private static void ApplyBlendMode(UnityEngine.Material unityMaterial, BlendMode blendMode) { // disable shader passes unityMaterial.SetShaderPassEnabled("DistortionVectors", false); unityMaterial.SetShaderPassEnabled("MOTIONVECTORS", false); unityMaterial.SetShaderPassEnabled("TransparentDepthPrepass", false); unityMaterial.SetShaderPassEnabled("TransparentDepthPostpass", false); unityMaterial.SetShaderPassEnabled("TransparentBackface", false); // reset existing blend modes, will be enabled explicitly unityMaterial.DisableKeyword("_BLENDMODE_ALPHA"); unityMaterial.DisableKeyword("_BLENDMODE_ADD"); unityMaterial.DisableKeyword("_BLENDMODE_PRE_MULTIPLY"); switch (blendMode) { case Engine.VPT.BlendMode.Opaque: // required for the blend mode unityMaterial.SetInt(SrcBlend, (int)UnityEngine.Rendering.BlendMode.One); unityMaterial.SetInt(DstBlend, (int)UnityEngine.Rendering.BlendMode.Zero); unityMaterial.SetInt(ZWrite, 1); // properties unityMaterial.SetFloat(SurfaceType, 0); // 0 = Opaque; 1 = Transparent unityMaterial.SetFloat(AlphaCutoffEnable, 0); // render queue unityMaterial.renderQueue = -1; break; case Engine.VPT.BlendMode.Cutout: // set render type unityMaterial.SetOverrideTag("RenderType", "TransparentCutout"); // keywords unityMaterial.EnableKeyword("_ALPHATEST_ON"); unityMaterial.EnableKeyword("_NORMALMAP_TANGENT_SPACE"); // required for the blend mode unityMaterial.SetInt(SrcBlend, (int)UnityEngine.Rendering.BlendMode.One); unityMaterial.SetInt(DstBlend, (int)UnityEngine.Rendering.BlendMode.Zero); unityMaterial.SetInt(ZWrite, 1); // properties unityMaterial.SetFloat(SurfaceType, 0); // 0 = Opaque; 1 = Transparent unityMaterial.SetFloat(AlphaCutoffEnable, 1); unityMaterial.SetFloat(ZTestDepthEqualForOpaque, 3); unityMaterial.SetFloat(ZTestModeDistortion, 4); unityMaterial.SetFloat(ZTestGBuffer, 3); // render queue unityMaterial.renderQueue = 2450; break; case Engine.VPT.BlendMode.Translucent: // set render type unityMaterial.SetOverrideTag("RenderType", "Transparent"); // keywords //unityMaterial.EnableKeyword("_ALPHATEST_ON"); // required for _AlphaCutoffEnable unityMaterial.EnableKeyword("_BLENDMODE_PRESERVE_SPECULAR_LIGHTING"); unityMaterial.EnableKeyword("_BLENDMODE_PRE_MULTIPLY"); unityMaterial.EnableKeyword("_ENABLE_FOG_ON_TRANSPARENT"); unityMaterial.EnableKeyword("_NORMALMAP_TANGENT_SPACE"); unityMaterial.EnableKeyword("_SURFACE_TYPE_TRANSPARENT"); // required for the blend mode unityMaterial.SetInt(SrcBlend, (int)UnityEngine.Rendering.BlendMode.One); unityMaterial.SetInt(DstBlend, (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha); unityMaterial.SetInt(ZWrite, 0); // properties unityMaterial.SetFloat(SurfaceType, 1); // 0 = Opaque; 1 = Transparent //unityMaterial.SetFloat("_AlphaCutoffEnable", 1); // enable keyword _ALPHATEST_ON if this is required unityMaterial.SetFloat(BlendMode, 4); // 0 = Alpha, 1 = Additive, 4 = PreMultiply // render queue const int transparentRenderQueueBase = 3000; const int transparentSortingPriority = 0; unityMaterial.SetInt(TransparentSortPriority, transparentSortingPriority); unityMaterial.renderQueue = transparentRenderQueueBase + transparentSortingPriority; break; default: throw new ArgumentOutOfRangeException(); } }
// // Start generates a USD scene procedurally, containing a single cube with a material, shader // and texture bound. It then inspects the cube to discover the material. A Unity material is // constructed and the parameters are copied in a generic way. Similarly, the texture is // discovered and loaded as a Unity Texture2D and bound to the material. // // Also See: https://docs.unity3d.com/Manual/MaterialsAccessingViaScript.html // void Start() { // Create a scene for this test, but could also be read from disk. Scene usdScene = CreateSceneWithShading(); // Read the material and shader ID. var usdMaterial = new MaterialSample(); string shaderId; // ReadMaterial was designed for Unity and assumes there is one "surface" shader bound. if (!MaterialSample.ReadMaterial(usdScene, kCubePath, usdMaterial, out shaderId)) { throw new System.Exception("Failed to read material"); } // Map the shader ID to the corresponding Unity/USD shader pair. ShaderPair shader; if (shaderId == null || !m_shaderMap.TryGetValue(shaderId, out shader)) { throw new System.Exception("Material had no surface bound"); } // // Read and process the shader-specific parameters. // // UsdShade requires all connections target an attribute, but we actually want to deserialize // the entire prim, so we get just the prim path here. var shaderPath = new pxr.SdfPath(usdMaterial.surface.connectedPath).GetPrimPath(); usdScene.Read(shaderPath, shader.usdShader); // // Construct material & process the inputs, textures, and keywords. // var mat = new UnityEngine.Material(shader.unityShader); // Apply material keywords. foreach (string keyword in usdMaterial.requiredKeywords ?? new string[0]) { mat.EnableKeyword(keyword); } // Iterate over all input parameters and copy values and/or construct textures. foreach (var param in shader.usdShader.GetInputParameters()) { if (!SetMaterialParameter(mat, param.unityName, param.value)) { throw new System.Exception("Incompatible shader data type: " + param.ToString()); } } foreach (var param in shader.usdShader.GetInputTextures()) { if (string.IsNullOrEmpty(param.connectedPath)) { // Not connected to a texture. continue; } // Only 2D textures are supported in this example. var usdTexture = new Texture2DSample(); // Again, we want the prim path, not the attribute path. var texturePath = new pxr.SdfPath(param.connectedPath).GetPrimPath(); usdScene.Read(texturePath, usdTexture); // This example also only supports explicit sourceFiles, they cannot be connected. if (string.IsNullOrEmpty(usdTexture.sourceFile.defaultValue)) { continue; } // For details, see: https://docs.unity3d.com/Manual/MaterialsAccessingViaScript.html foreach (string keyword in param.requiredShaderKeywords) { mat.EnableKeyword(keyword); } var data = System.IO.File.ReadAllBytes(usdTexture.sourceFile.defaultValue); var unityTex = new Texture2D(2, 2); unityTex.LoadImage(data); mat.SetTexture(param.unityName, unityTex); Debug.Log("Set " + param.unityName + " to " + usdTexture.sourceFile.defaultValue); unityTex.Apply(updateMipmaps: true, makeNoLongerReadable: false); } // // Create and bind the geometry. // // Create a cube and set the material. // Note that geometry is handled minimally here and is incomplete. var cubeSample = new CubeSample(); usdScene.Read(kCubePath, cubeSample); var go = GameObject.CreatePrimitive(PrimitiveType.Cube); go.transform.SetParent(transform, worldPositionStays: false); go.transform.localScale = Vector3.one * (float)cubeSample.size; m_cube = transform; go.GetComponent <MeshRenderer>().material = mat; }
void TrySetTextureTransform( Schema.TextureInfo textureInfo, UnityEngine.Material material, int texturePropertyId, int scaleTransformPropertyId = -1, int rotationPropertyId = -1, int uvChannelPropertyId = -1, bool flipY = false ) { // Scale (x,y) and Transform (z,w) float4 textureST = new float4( 1, 1, // scale 0, 0 // transform ); var texCoord = textureInfo.texCoord; if (textureInfo.extensions != null && textureInfo.extensions.KHR_texture_transform != null) { var tt = textureInfo.extensions.KHR_texture_transform; if (tt.texCoord >= 0) { texCoord = tt.texCoord; } float cos = 1; float sin = 0; if (tt.offset != null) { textureST.z = tt.offset[0]; textureST.w = 1 - tt.offset[1]; } if (tt.scale != null) { textureST.x = tt.scale[0]; textureST.y = tt.scale[1]; } if (tt.rotation != 0) { cos = math.cos(tt.rotation); sin = math.sin(tt.rotation); var newRot = new Vector2(textureST.x * sin, textureST.y * -sin); Assert.IsTrue(rotationPropertyId >= 0, "Texture rotation property invalid!"); material.SetVector(rotationPropertyId, newRot); textureST.x *= cos; textureST.y *= cos; material.EnableKeyword(KW_UV_ROTATION); textureST.z -= newRot.y; // move offset to move rotation point (horizontally) } else { // In case _UV_ROTATION keyword is set (because another texture is rotated), // make sure the rotation is properly nulled material.SetVector(rotationPropertyId, Vector4.zero); } textureST.w -= textureST.y * cos; // move offset to move flip axis point (vertically) } if (texCoord != 0) { if (uvChannelPropertyId >= 0 && texCoord < 2f) { material.EnableKeyword(KW_UV_CHANNEL_SELECT); material.SetFloat(uvChannelPropertyId, texCoord); } else { logger?.Error(LogCode.UVMulti, texCoord.ToString()); } } if (flipY) { textureST.w = 1 - textureST.w; // flip offset in Y textureST.y = -textureST.y; // flip scale in Y } material.SetTextureOffset(texturePropertyId, textureST.zw); material.SetTextureScale(texturePropertyId, textureST.xy); Assert.IsTrue(scaleTransformPropertyId >= 0, "Texture scale/transform property invalid!"); material.SetVector(scaleTransformPropertyId, textureST); }