/// <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; } } } }
// 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. }
// Use this for initialization void Start () { waterZones = GameObject.FindGameObjectsWithTag("InteractableWater"); currentWeather = Weather.CLEAR; day = true; skybox = RenderSettings.skybox; skybox.SetFloat("_DayToNight", 0f); skybox.SetFloat("_RainToSnow", 0f); skybox.SetFloat("_NormalToRainSnow", 0f); skybox.SetFloat("_RainSnowToSpecial", 0f); mainLight = FindObjectOfType<Light>(); foreach (Material m in materials) { m.SetFloat("_Snow", 0f); } rain = GameObject.Find("PS_Rain"); snow = GameObject.Find("PS_Snowflakes"); other = GameObject.Find("PS_weather"); rain.SetActive(false); snow.SetActive(false); other.SetActive(false); tM = FindObjectOfType<TrackManager>(); SetAurore(false); }
private void AddOverlay(TextureSet mTexture, TextureSet dTexture, float altitude, float fadeDistance, float pqsfadeDistance) { Assembly assembly = Assembly.GetExecutingAssembly(); string[] resources = assembly.GetManifestResourceNames(); StreamReader shaderStreamReader = new StreamReader(assembly.GetManifestResourceStream("CityLights.Shaders.Compiled-SphereCityLights.shader")); Log("read stream"); String shaderString = shaderStreamReader.ReadToEnd(); Material lightMaterial = new Material(shaderString); Material pqsLightMaterial = new Material(shaderString); lightMaterial.SetTexture("_MainTex", mTexture.Texture); lightMaterial.SetTexture("_DetailTex", dTexture.Texture); lightMaterial.SetFloat("_DetailScale", dTexture.Scale); lightMaterial.SetVector("_DetailOffset", dTexture.Offset); lightMaterial.SetFloat("_FadeDist", fadeDistance); lightMaterial.SetFloat("_FadeScale", 1); pqsLightMaterial.SetTexture("_MainTex", mTexture.Texture); pqsLightMaterial.SetTexture("_DetailTex", dTexture.Texture); pqsLightMaterial.SetFloat("_DetailScale", dTexture.Scale); pqsLightMaterial.SetVector("_DetailOffset", dTexture.Offset); pqsLightMaterial.SetFloat("_FadeDist", pqsfadeDistance); pqsLightMaterial.SetFloat("_FadeScale", .02f); overlayList.Add(Overlay.GeneratePlanetOverlay("Kerbin", altitude, lightMaterial, pqsLightMaterial, mTexture.StartOffset, false, true)); }
void Update() { terrain = GetComponent<Terrain>(); tData = terrain ? terrain.terrainData : null; tMaterial = terrain ? terrain.materialTemplate : null; if (!terrain || !tData || !tMaterial) return; if(disableBasemap && !Application.isPlaying && GetComponent<Terrain>().basemapDistance != 1000000) // only reset on update in edit mode GetComponent<Terrain>().basemapDistance = 1000000; if (cutoutMode) { if (tMaterial.HasProperty("_CutoutModeHideAlpha") && tMaterial.GetFloat("_CutoutModeHideAlpha") != cutoutModeHideAlpha) tMaterial.SetFloat("_CutoutModeHideAlpha", cutoutModeHideAlpha); } else if (tMaterial.HasProperty("_CutoutModeHideAlpha") && tMaterial.GetFloat("_CutoutModeHideAlpha") != -1) tMaterial.SetFloat("_CutoutModeHideAlpha", -1); if (!Application.isPlaying) ApplyTransparencyMap(); else if (!transparencyMap && autoUpdateTransparencyMap) { UpdateTransparencyMap(); ApplyTransparencyMap(); } else ApplyTransparencyMap(); }
public static void DrawProteinsAtoms(Material renderProteinsMaterial, Camera camera, RenderBuffer instanceId, RenderBuffer atomId, RenderBuffer depthBuffer, int pass) { // Protein params renderProteinsMaterial.SetInt("_EnableLod", Convert.ToInt32(GlobalProperties.Get.EnableLod)); renderProteinsMaterial.SetFloat("_Scale", GlobalProperties.Get.Scale); renderProteinsMaterial.SetFloat("_FirstLevelBeingRange", GlobalProperties.Get.FirstLevelOffset); renderProteinsMaterial.SetVector("_CameraForward", camera.transform.forward); renderProteinsMaterial.SetBuffer("_LodLevelsInfos", GPUBuffers.Get.LodInfo); renderProteinsMaterial.SetBuffer("_ProteinInstanceInfo", GPUBuffers.Get.ProteinInstancesInfo); renderProteinsMaterial.SetBuffer("_ProteinInstancePositions", GPUBuffers.Get.ProteinInstancePositions); renderProteinsMaterial.SetBuffer("_ProteinInstanceRotations", GPUBuffers.Get.ProteinInstanceRotations); renderProteinsMaterial.SetBuffer("_ProteinColors", GPUBuffers.Get.IngredientsColors); renderProteinsMaterial.SetBuffer("_ProteinAtomInfo", GPUBuffers.Get.ProteinAtomInfo); renderProteinsMaterial.SetBuffer("_ProteinAtomPositions", GPUBuffers.Get.ProteinAtoms); renderProteinsMaterial.SetBuffer("_ProteinClusterPositions", GPUBuffers.Get.ProteinAtomClusters); renderProteinsMaterial.SetBuffer("_ProteinSphereBatchInfos", GPUBuffers.Get.SphereBatches); /****/ renderProteinsMaterial.SetInt("_NumCutObjects", SceneManager.Get.NumCutObjects); renderProteinsMaterial.SetInt("_NumIngredientTypes", SceneManager.Get.NumAllIngredients); renderProteinsMaterial.SetBuffer("_CutInfos", GPUBuffers.Get.CutInfo); renderProteinsMaterial.SetBuffer("_CutScales", GPUBuffers.Get.CutScales); renderProteinsMaterial.SetBuffer("_CutPositions", GPUBuffers.Get.CutPositions); renderProteinsMaterial.SetBuffer("_CutRotations", GPUBuffers.Get.CutRotations); /****/ Graphics.SetRenderTarget(new[] { instanceId, atomId }, depthBuffer); renderProteinsMaterial.SetPass(1); Graphics.DrawProceduralIndirect(MeshTopology.Points, GPUBuffers.Get.ArgBuffer); }
public static void DrawProteinSphereBatches(Material renderProteinsMaterial, Camera camera, RenderBuffer colorBuffer, RenderBuffer depthBuffer, int pass, bool animated = false) { // Protein params renderProteinsMaterial.SetInt("_EnableLod", Convert.ToInt32(PersistantSettings.Instance.EnableLod)); renderProteinsMaterial.SetFloat("_Scale", PersistantSettings.Instance.Scale); renderProteinsMaterial.SetFloat("_FirstLevelBeingRange", PersistantSettings.Instance.FirstLevelOffset); renderProteinsMaterial.SetVector("_CameraForward", camera.transform.forward); renderProteinsMaterial.SetBuffer("_LodLevelsInfos", GPUBuffers.Instance.LodInfo); renderProteinsMaterial.SetBuffer("_ProteinInstanceInfo", GPUBuffers.Instance.ProteinInstanceInfo); if(animated) renderProteinsMaterial.SetBuffer("_ProteinInstancePositions", GPUBuffers.Instance.ProteinAnimationPositions); else renderProteinsMaterial.SetBuffer("_ProteinInstancePositions", GPUBuffers.Instance.ProteinInstancePositions); if (animated) renderProteinsMaterial.SetBuffer("_ProteinInstanceRotations", GPUBuffers.Instance.ProteinAnimationRotations); else renderProteinsMaterial.SetBuffer("_ProteinInstanceRotations", GPUBuffers.Instance.ProteinInstanceRotations); renderProteinsMaterial.SetBuffer("_ProteinAtomCount", GPUBuffers.Instance.ProteinAtomCount); renderProteinsMaterial.SetBuffer("_ProteinColors", GPUBuffers.Instance.ProteinColors); renderProteinsMaterial.SetBuffer("_ProteinAtomPositions", GPUBuffers.Instance.ProteinAtoms); renderProteinsMaterial.SetBuffer("_ProteinClusterPositions", GPUBuffers.Instance.ProteinAtomClusters); renderProteinsMaterial.SetBuffer("_ProteinSphereBatchInfos", GPUBuffers.Instance.SphereBatches); Graphics.SetRenderTarget(colorBuffer, depthBuffer); renderProteinsMaterial.SetPass(pass); Graphics.DrawProceduralIndirect(MeshTopology.Points, GPUBuffers.Instance.ArgBuffer); }
void updateSprite(SpriteRenderer spriteRenderer, AlphaMaskScript mask) { Texture2D a = mask.clipTexture; Texture2D b = spriteRenderer.sprite.texture; float w1 = (float)a.width; float h1 = (float)a.height; float w2 = (float)b.width; float h2 = (float)b.height; float xScale = h1 / h2; float yScale = w1 / w2; float adjustScale = xScale > yScale ? yScale : xScale; xScale = xScale / adjustScale / mask.scale; yScale = yScale / adjustScale / mask.scale; float xOffset = mask.xOffsetPixel / w2; float yOffset = mask.yOffsetPixel / h2; var mat = new Material(Shader.Find("Unlit/AlphaMask")); mat.name = mask.ToName(); mat.SetTexture("_ClipTex", mask.clipTexture); mat.SetFloat("_xScale", xScale); mat.SetFloat("_yScale", yScale); mat.SetFloat("_xOffset", xOffset); mat.SetFloat("_yOffset", yOffset); spriteRenderer.sharedMaterial = mat; Debug.Log(string.Format( "update alpha mask target={0}x{1} mask={2}x{3}", w1, h1, w2, h2 )); }
public void UpdateMeshHeights(Material material, float minHeight, float maxHeight) { savedMinHeight = minHeight; savedMaxHeight = maxHeight; material.SetFloat("minHeight", minHeight); material.SetFloat("maxHeight", maxHeight); }
private void createMaterials() { gameMaterial = new Material(GameShader); gameMaterial.SetFloat("_GridStepX", 1.0f/Width); gameMaterial.SetFloat("_GridStepY", 1.0f/Height); edgeDetectMaterial = new Material(EdgeDetectShader); }
public Material getMaterial(){ if (material == null) { material = new Material(Shader.Find("Custom/2D Tile Shader")); material.SetTexture("_Tex", texture); material.SetFloat("_Width", width); material.SetFloat("_Height", height); } return material; }
public void Apply(ConfigNode node) { //create scaled material and set proprties to defaults scaledMaterial = new Material (Shaders.EmissiveScaled); scaledMaterial.SetTextureScale ("_EmissiveMap", Vector2.one); scaledMaterial.SetTextureOffset ("_EmissiveMap", Vector2.zero); scaledMaterial.SetColor ("_Color", new Color (1f, 1f, 1f)); scaledMaterial.SetFloat ("_Brightness", 1.25f); scaledMaterial.SetFloat ("_Transparency", 0.75f); }
// Use this for initialization void Awake() { MeshRenderer rend = GetComponent<MeshRenderer>(); shockwaveDistortionMat = rend.material = Instantiate(rend.material); Callback.DoLerp((float l) => { shockwaveDistortionMat.SetFloat("_MaxRange", l / 2); shockwaveDistortionMat.SetFloat("_Annulus", 1 - (l * l)); }, time, this); }
void Awake() { if(!grayscaleMaterial) { grayscaleMaterial = new Material(BDAShaderLoader.GrayscaleEffectShader); grayscaleMaterial.SetTexture("_RampTex", textureRamp); grayscaleMaterial.SetFloat("_RedPower", rampOffset); grayscaleMaterial.SetFloat("_RedDelta", rampOffset); } }
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)); }
public void SetWaveMat(Material mat, GameObject gamin) { float meshWidth = gamin.GetComponent<MeshFilter>().sharedMesh.bounds.size.x; //float meshWidth = gamin.transform.lossyScale.x * gamin.transform.lossyScale.x; mat.SetFloat ("_TimeCostum", Time.time); mat.SetVector ("_ObjectScale", gamin.transform.lossyScale); mat.SetFloat ("_SineAmplitude", amplitude); mat.SetVector ("_SineFrequency", new Vector4 (sineFrequency.x, sineFrequency.y, 0, 0)); mat.SetVector ("_Speed", new Vector4 (waveSpeed.x, waveSpeed.y, 0, 0)); mat.SetVector ("_Steepness", new Vector4 (steepness.x, steepness.y, 0, 0)); mat.SetVector ("_Dir", new Vector4 (waveDirection1.x, waveDirection1.y, waveDirection1.z, 0)); mat.SetVector ("_Dir2", new Vector4 (waveDirection2.x, waveDirection2.y, waveDirection2.z, 0)); }
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); }
private void Start() { Debug.Assert(_chargeSpeed > 0f); Material mat = new Material(Shader.Find(_shaderName)); _guitarBodyRenderer.material = mat; _currHeight = _bottomHeight; mat.SetVector("_PlanePos", new Vector4(0, _bottomHeight, 0, 1)); mat.SetVector("_PlaneNormal", new Vector4(0, 1, 0, 0)); mat.SetFloat("_ThresDist", _currHeight); mat.SetTexture("_MainTex", _guitarBodyTex); mat.SetFloat("_EmissionSwitch", 0f); mat.SetFloat("_EmissionIntensity", _EmissionIntensity); }
/// <summary> /// Create a Masking Material Instance for the given ID /// </summary> /// <param name="baseMaterial"></param> /// <param name="stencilID"></param> /// <returns></returns> public static Material GetStencilMaterial(Material baseMaterial, int stencilID) { // Check if Material supports masking if (!baseMaterial.HasProperty(ShaderUtilities.ID_StencilID)) { Debug.LogWarning("Selected Shader does not support Stencil Masking. Please select the Distance Field or Mobile Distance Field Shader."); return baseMaterial; } Material stencilMaterial = null; // Check if baseMaterial already has a masking material associated with it. int index = m_materialList.FindIndex(item => item.baseMaterial == baseMaterial && item.stencilID == stencilID); if (index == -1) { //Create new Masking Material Instance for this Base Material stencilMaterial = new Material(baseMaterial); stencilMaterial.hideFlags = HideFlags.HideAndDontSave; stencilMaterial.name += " Masking ID:" + stencilID; stencilMaterial.shaderKeywords = baseMaterial.shaderKeywords; // Set Stencil Properties ShaderUtilities.GetShaderPropertyIDs(); stencilMaterial.SetFloat(ShaderUtilities.ID_StencilID, stencilID); stencilMaterial.SetFloat(ShaderUtilities.ID_StencilComp, 4); MaskingMaterial temp = new MaskingMaterial(); temp.baseMaterial = baseMaterial; temp.stencilMaterial = stencilMaterial; temp.stencilID = stencilID; temp.count = 1; m_materialList.Add(temp); //Debug.Log("Masking material for " + baseMaterial.name + " DOES NOT exists. Creating new " + maskingMaterial.name + " with ID " + maskingMaterial.GetInstanceID() + " which is used " + temp.count + " time(s)."); } else { stencilMaterial = m_materialList[index].stencilMaterial; m_materialList[index].count += 1; //Debug.Log("Masking material for " + baseMaterial.name + " already exists. Passing reference to " + maskingMaterial.name + " with ID " + maskingMaterial.GetInstanceID() + " which is used " + m_materialList[index].count + " time(s)."); } // Used for Debug ListMaterials(); return stencilMaterial; }
// Constructor public RendererCache(Renderer r, Material sharedOpaqueMaterial, float zTest, float stencilRef) { data = new List<Data>(); renderer = r; go = r.gameObject; Material[] materials = r.sharedMaterials; if (materials != null) { for (int i = 0; i < materials.Length; i++) { Material sourceMat = materials[i]; if (sourceMat == null) { continue; } Data d = new Data(); string tag = sourceMat.GetTag("RenderType", true, "Opaque"); if (tag == "Transparent" || tag == "TransparentCutout") { Material replacementMat = new Material(transparentShader); replacementMat.SetFloat(ShaderPropertyID._ZTest, zTest); replacementMat.SetFloat(ShaderPropertyID._StencilRef, stencilRef); if (sourceMat.HasProperty(ShaderPropertyID._MainTex)) { replacementMat.SetTexture(ShaderPropertyID._MainTex, sourceMat.mainTexture); replacementMat.SetTextureOffset("_MainTex", sourceMat.mainTextureOffset); replacementMat.SetTextureScale("_MainTex", sourceMat.mainTextureScale); } int cutoff = ShaderPropertyID._Cutoff; replacementMat.SetFloat(cutoff, sourceMat.HasProperty(cutoff) ? sourceMat.GetFloat(cutoff) : transparentCutoff); d.material = replacementMat; d.transparent = true; } else { d.material = sharedOpaqueMaterial; d.transparent = false; } d.submeshIndex = i; data.Add(d); } } visible = IsVisible(); }
void Awake() { for (int i = 0; i < maxRipples; ++i) { ripples.Add(new Ripple()); } material = GetComponent<Renderer>().material; previousPosition = transform.position; material.SetFloat("_MaxRadius_c", maxRadius); material.SetFloat("_RippleWidth_c", rippleWidth); material.SetFloat("_RippleSpacing_c", rippleSpacing); material.SetFloat("_NumConcentricRipples_c", numConcentricRipples); material.SetFloat("_RippleAlpha_c", rippleAlpha); material.SetVector("_RippleColor", rippleColor); }
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"); }
public static IEnumerator LinearDissolve(Material mat, float from, float to, float time) { float elapsedTime = 0f; while (elapsedTime < time) { if (mat.HasProperty(dissolveAmountID)) { mat.SetFloat(dissolveAmountID, Mathf.Lerp(from, to, elapsedTime/time)); } elapsedTime += Time.deltaTime; yield return null; } if (mat.HasProperty(dissolveAmountID)) { mat.SetFloat (dissolveAmountID, to); } }
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); } }
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 () { //Destroy(this); currentMaterial = GetComponent<Renderer>().material; cycle = 6.0f;//flowSpeed * 3.0f * .1f;//.15f; //Debug.Log("flowSpeed: " + flowSpeed + " cycle: " + cycle); halfCycle = cycle * .5f; flowMapOffset0 = 0.0f; flowMapOffset1 = halfCycle; //flowSpeed *= -1.0f; currentMaterial.SetFloat("halfCycle", halfCycle); /*if ( currentMaterial.HasProperty("_normalStrength") ) { float normalStrength = currentMaterial.GetFloat("_normalStrength") * flowSpeed; Debug.Log("normalStrength: " + normalStrength); normalStrength = Mathf.Clamp(normalStrength, 0.01f, 50.0f); currentMaterial.SetFloat("_normalStrength", normalStrength); } if ( currentMaterial.HasProperty("flowTide") ) hasTide = true; else hasTide = false;*/ }
static public int SetFloat(IntPtr l) { try { int argc = LuaDLL.lua_gettop(l); if (matchType(l, argc, 2, typeof(int), typeof(float))) { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.Int32 a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(a1, a2); pushValue(l, true); return(1); } else if (matchType(l, argc, 2, typeof(string), typeof(float))) { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.String a1; checkType(l, 2, out a1); System.Single a2; checkType(l, 3, out a2); self.SetFloat(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)); } }
static int SetFloat(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(int), typeof(float))) { UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1); int arg0 = (int)LuaDLL.lua_tonumber(L, 2); float arg1 = (float)LuaDLL.lua_tonumber(L, 3); obj.SetFloat(arg0, arg1); return(0); } else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(string), typeof(float))) { UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1); string arg0 = ToLua.ToString(L, 2); float arg1 = (float)LuaDLL.lua_tonumber(L, 3); obj.SetFloat(arg0, arg1); return(0); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Material.SetFloat")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
/// <summary> /// Sets the shader parameters of this renderer to the specified material. /// </summary> /// <param name="material"></param> public void SetShaderParams(Material material) { // Set all properties material.SetBuffer("HairVertexTangents", this._master.g_HairVertexTangents); material.SetBuffer("HairVertexPositions", this._master.g_HairVertexPositions); material.SetBuffer("TriangleIndicesBuffer", this.g_TriangleIndicesBuffer); material.SetBuffer("LineIndicesBuffer", this.g_LineIndicesBuffer); material.SetBuffer("GlobalRotations", this._master.g_GlobalRotations); material.SetBuffer("HairThicknessCoeffs", this._master.g_HairThicknessCoeffs); material.SetBuffer("TexCoords", this._master.g_TexCoords); material.SetFloat("_ThinTip", this.hairMaterial.GetFloat("_ThinTip")); material.SetFloat("_HairWidth", this.hairMaterial.GetFloat("_HairWidth")); material.SetFloat("_HairWidthMultiplier", this.hairMaterial.GetFloat("_HairWidthMultiplier")); SetSimulationTransformCorrection(material); }
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); }
public static Material createMaterial(FacadeSkin skin) { Material mat = new Material(Shader.Find("Standard (Specular setup)")); Texture2D colortex = getTexture(skin.colorTexturePath); Texture2D normaltex = getTexture(skin.normalTexturePath); Texture2D speculartex = getTexture(skin.specularTexturePath); mat.SetTexture("_MainTex", colortex); mat.SetTexture("_BumpMap", normaltex); mat.SetFloat("_BumpScale", 1.0f); mat.SetFloat("_Glossiness", 0.1f); mat.SetTexture("_SpecGlossMap", speculartex); return mat; }
public FourierGPU(int size) { if(size > 256) { Debug.Log("FourierGPU::FourierGPU - fourier grid size must not be greater than 256, changing to 256"); size = 256; } if(!Mathf.IsPowerOfTwo(size)) { Debug.Log("FourierGPU::FourierGPU - fourier grid size must be pow2 number, changing to nearest pow2 number"); size = Mathf.NextPowerOfTwo(size); } // Shader shader = Shader.Find("Math/Fourier"); Shader shader = ShaderTool.GetShader2 ("CompiledFourier.shader"); if(shader == null) Debug.Log("FourierGPU::FourierGPU - Could not find shader Math/Fourier"); m_fourier = new Material(shader); m_size = size; //must be pow2 num m_fsize = (float)m_size; m_passes = (int)(Mathf.Log(m_fsize)/Mathf.Log(2.0f)); m_butterflyLookupTable = new Texture2D[m_passes]; ComputeButterflyLookupTable(); m_fourier.SetFloat("_Size", m_fsize); }
private void Render(RenderTexture destination) { // Make sure we have a current render target InitRenderTexture(); // Set the target and dispatch the compute shader rtxShader.SetTexture(0, "Result", _target); var threadGroupsX = Mathf.CeilToInt(Screen.width / 8.0f); var threadGroupsY = Mathf.CeilToInt(Screen.height / 8.0f); rtxShader.Dispatch(0, threadGroupsX, threadGroupsY, 1); // Blit the result texture to the screen _addMaterial.SetFloat(Sample, _currentSample); Graphics.Blit(_target, destination, _addMaterial); _currentSample++; }
// 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); } }
Material GetUnlitMaterial(bool doubleSided = false) { if (unlitShader == null) { unlitShader = FinderShaderUnlit(); } if (unlitShader == null) { return(null); } var mat = new Material(unlitShader); if (doubleSided) { // Turn off back-face culling mat.SetFloat(cullModePropId, 0); #if UNITY_EDITOR mat.doubleSidedGI = true; #endif } return(mat); }
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); }
Material GetPbrMetallicRoughnessMaterial(bool doubleSided = false) { if (pbrMetallicRoughnessShader == null) { pbrMetallicRoughnessShader = FinderShaderMetallicRoughness(); } if (pbrMetallicRoughnessShader == null) { return(null); } var mat = new Material(pbrMetallicRoughnessShader); if (doubleSided) { // Turn off back-face culling mat.SetFloat(cullModePropId, 0); #if UNITY_EDITOR mat.doubleSidedGI = true; #endif } return(mat); }
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, gltf, transmissionTexturePropId, transmissionTextureScaleTransformPropId, // TODO: add support in shader transmissionTextureRotationPropId, // TODO: add support in shader transmissionTextureUVChannelPropId // TODO: add support in shader )) { } } return(renderQueue); } return(base.ApplyTransmission( ref baseColorLinear, gltf, transmission, material, renderQueue )); }
// マテリアルの登録 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); }
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 override void SetAlphaModeMask(Schema.Material gltfMaterial, Material material) { base.SetAlphaModeMask(gltfMaterial, material); material.SetFloat(k_AlphaClip, 1); }
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); }
public void SetSmoothness(Material material, float smoothness) { material.SetFloat(Smoothness, smoothness); }
private static UnityEngine.Material Convert(RenderWareStream.Material src, TextureDictionary[] txds, MaterialFlags flags) { LoadedTexture diffuse; LoadedTexture mask = null; var overrideAlpha = (flags & MaterialFlags.OverrideAlpha) == MaterialFlags.OverrideAlpha; var vehicle = (flags & MaterialFlags.Vehicle) == MaterialFlags.Vehicle; if (!overrideAlpha && src.Colour.A != 255) { flags |= MaterialFlags.Alpha; } if (src.TextureCount > 0) { var tex = src.Textures[0]; diffuse = txds.GetDiffuse(tex.TextureName); if (src.TextureCount > 1) { Debug.LogFormat("Something has {0} textures!", src.TextureCount); } if (diffuse == null) { Debug.LogWarningFormat("Unable to find texture {0}", tex.TextureName); } if (!string.IsNullOrEmpty(tex.MaskName)) { mask = txds.GetAlpha(tex.MaskName) ?? diffuse; } else if (vehicle) { mask = diffuse; } if (!overrideAlpha && mask != null && mask.HasAlpha) { flags |= MaterialFlags.Alpha; } } else { diffuse = WhiteTex; } var shader = GetShader(flags); var mat = new UnityEngine.Material(shader); var clr = Types.Convert(src.Colour); if (vehicle) { var found = false; for (var i = 1; i < _sKeyColors.Length; ++i) { var key = _sKeyColors[i]; if (key.r != clr.r || key.g != clr.g || key.b != clr.b) { continue; } mat.SetInt(CarColorIndexId, i); found = true; break; } if (found) { mat.color = Color.white; } else { mat.color = clr; } } else { mat.color = clr; } if (diffuse != null) { mat.SetTexture(MainTexId, diffuse.Texture); } if (mask != null) { mat.SetTexture(MaskTexId, mask.Texture); } mat.SetFloat(MetallicId, src.Specular); mat.SetFloat(SmoothnessId, src.Smoothness); return(mat); }
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); }
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 static void ApplyBlendMode(UnityEngine.Material unityMaterial, BlendMode blendMode) { switch (blendMode) { case BlendMode.Opaque: // keywords unityMaterial.DisableKeyword("_ALPHATEST_ON"); unityMaterial.DisableKeyword("_ALPHABLEND_ON"); unityMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON"); // 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(Mode, 0); // render queue unityMaterial.renderQueue = -1; break; case BlendMode.Cutout: // keywords unityMaterial.EnableKeyword("_ALPHATEST_ON"); unityMaterial.DisableKeyword("_ALPHABLEND_ON"); unityMaterial.DisableKeyword("_ALPHAPREMULTIPLY_ON"); // 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(Mode, 1); // render queue unityMaterial.renderQueue = 2450; break; case BlendMode.Translucent: // keywords unityMaterial.DisableKeyword("_ALPHATEST_ON"); unityMaterial.DisableKeyword("_ALPHABLEND_ON"); unityMaterial.EnableKeyword("_ALPHAPREMULTIPLY_ON"); // required for the blend mode 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); // properties unityMaterial.SetFloat(Mode, 3); // render queue unityMaterial.renderQueue = 3000; break; default: throw new ArgumentOutOfRangeException(); } }
protected override void SetDoubleSided(Schema.Material gltfMaterial, Material material) { base.SetDoubleSided(gltfMaterial, material); material.SetFloat(cullPropId, (int)CullMode.Off); }
private void CreateMaterialsForInstances(ResultSetBuilder resultSetBuilder) { for (var i = 0; i < _materialInstanceList.Count; i++) { var instanceDocument = _materialInstanceList[i]; var parentDocument = FindUnrealMaterialByInstanceDocument(instanceDocument); RaiseStepEvent(instanceDocument.FileName, MaterialCount + i); if (null == parentDocument) { continue; } var processor = new MaterialInstanceDocumentProcessor(); var result = processor.Convert(instanceDocument); var materialInstance = result.RootNode; var shaderPath = "Assets/" + MakeRelativePath(_outputDirectory, MakeOutputPathForShaderGraph(parentDocument)); var shaderAsset = AssetDatabase.LoadAssetAtPath <Shader>(shaderPath); if (null == shaderAsset) { continue; } var graphData = JsonUtility.FromJson <GraphData>(File.ReadAllText(shaderPath)); var materialAsset = new Material(shaderAsset); foreach (var parameter in materialInstance.ScalarParameters) { var parameterName = parameter.FindPropertyValue("ParameterName") ?? FindNameFromParameterInfo(parameter); var parameterValue = ValueUtil.ParseFloat(parameter.FindPropertyValue("ParameterValue") ?? "1.0"); if (graphData.properties.Any(p => p.displayName == parameterName)) { var parameterReference = graphData.properties.First(p => p.displayName == parameterName).referenceName; materialAsset.SetFloat(parameterReference, parameterValue); } } foreach (var parameter in materialInstance.VectorParameters) { var parameterName = parameter.FindPropertyValue("ParameterName") ?? FindNameFromParameterInfo(parameter); var parameterValue = ValueUtil.ParseVector4(parameter.FindPropertyValue("ParameterValue") ?? "(R=0.0,G=0.0,B=0.0,A=1.0)"); if (graphData.properties.Any(p => p.displayName == parameterName)) { var parameterReference = graphData.properties.First(p => p.displayName == parameterName).referenceName; materialAsset.SetVector(parameterReference, new Vector4(parameterValue.X, parameterValue.Y, parameterValue.Z, parameterValue.A)); } } foreach (var parameter in materialInstance.TextureParameters) { var parameterName = parameter.FindPropertyValue("ParameterName") ?? FindNameFromParameterInfo(parameter); var parameterValue = ValueUtil.ParseResourceReference(parameter.FindPropertyValue("ParameterValue")); if (graphData.properties.Any(p => p.displayName == parameterName)) { var parameterReference = graphData.properties.First(p => p.displayName == parameterName).referenceName; var textureAssetPath = "Assets" + Path.ChangeExtension(parameterValue.FileName, "TGA"); var textureAsset = AssetDatabase.LoadAssetAtPath <Texture>(textureAssetPath); materialAsset.SetTexture(parameterReference, textureAsset); } } var outputPath = MakeOutputPathForMaterial(instanceDocument, true); Directory.CreateDirectory(Path.GetDirectoryName(outputPath)); AssetDatabase.CreateAsset(materialAsset, outputPath); } }
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; }
// https://forum.unity.com/threads/specular-convolution-when-calculating-mip-maps-for-cubemap-render-texture.617680/ private Cubemap GetSpecularCubeMap(Cubemap srcCubemap) { var convolutionMaterial = new UnityEngine.Material(Shader.Find("Hidden/CubeBlur")); GL.PushMatrix(); GL.LoadOrtho(); RenderTexture dstCubemap = new RenderTexture(srcCubemap.width, srcCubemap.height, 0, RenderTextureFormat.ARGBHalf); dstCubemap.dimension = UnityEngine.Rendering.TextureDimension.Cube; dstCubemap.volumeDepth = 6; dstCubemap.wrapMode = TextureWrapMode.Clamp; dstCubemap.filterMode = FilterMode.Trilinear; dstCubemap.isPowerOfTwo = true; dstCubemap.Create(); var mip = .2f; var dstMip = 0; var mipRes = srcCubemap.width; convolutionMaterial.SetTexture("_MainTex", srcCubemap); convolutionMaterial.SetFloat("_Texel", 1f / mipRes); convolutionMaterial.SetFloat("_Level", mip); convolutionMaterial.SetPass(0); Texture2D tex2d = new Texture2D(srcCubemap.width * 6, srcCubemap.height, TextureFormat.RGBAHalf, false); // Positive X Graphics.SetRenderTarget(dstCubemap, dstMip, CubemapFace.PositiveX); GL.Begin(GL.QUADS); GL.TexCoord3(1, 1, 1); GL.Vertex3(0, 0, 1); GL.TexCoord3(1, -1, 1); GL.Vertex3(0, 1, 1); GL.TexCoord3(1, -1, -1); GL.Vertex3(1, 1, 1); GL.TexCoord3(1, 1, -1); GL.Vertex3(1, 0, 1); GL.End(); tex2d.ReadPixels(new Rect(0, 0, srcCubemap.width, srcCubemap.height), srcCubemap.width * 0, 0); // Negative X Graphics.SetRenderTarget(dstCubemap, dstMip, CubemapFace.NegativeX); GL.Begin(GL.QUADS); GL.TexCoord3(-1, 1, -1); GL.Vertex3(0, 0, 1); GL.TexCoord3(-1, -1, -1); GL.Vertex3(0, 1, 1); GL.TexCoord3(-1, -1, 1); GL.Vertex3(1, 1, 1); GL.TexCoord3(-1, 1, 1); GL.Vertex3(1, 0, 1); GL.End(); tex2d.ReadPixels(new Rect(0, 0, srcCubemap.width, srcCubemap.height), srcCubemap.width * 1, 0); // Positive Y Graphics.SetRenderTarget(dstCubemap, dstMip, CubemapFace.PositiveY); GL.Begin(GL.QUADS); GL.TexCoord3(-1, 1, -1); GL.Vertex3(0, 0, 1); GL.TexCoord3(-1, 1, 1); GL.Vertex3(0, 1, 1); GL.TexCoord3(1, 1, 1); GL.Vertex3(1, 1, 1); GL.TexCoord3(1, 1, -1); GL.Vertex3(1, 0, 1); GL.End(); tex2d.ReadPixels(new Rect(0, 0, srcCubemap.width, srcCubemap.height), srcCubemap.width * 2, 0); // Negative Y Graphics.SetRenderTarget(dstCubemap, dstMip, CubemapFace.NegativeY); GL.Begin(GL.QUADS); GL.TexCoord3(-1, -1, 1); GL.Vertex3(0, 0, 1); GL.TexCoord3(-1, -1, -1); GL.Vertex3(0, 1, 1); GL.TexCoord3(1, -1, -1); GL.Vertex3(1, 1, 1); GL.TexCoord3(1, -1, 1); GL.Vertex3(1, 0, 1); GL.End(); tex2d.ReadPixels(new Rect(0, 0, srcCubemap.width, srcCubemap.height), srcCubemap.width * 3, 0); // Positive Z Graphics.SetRenderTarget(dstCubemap, dstMip, CubemapFace.PositiveZ); GL.Begin(GL.QUADS); GL.TexCoord3(-1, 1, 1); GL.Vertex3(0, 0, 1); GL.TexCoord3(-1, -1, 1); GL.Vertex3(0, 1, 1); GL.TexCoord3(1, -1, 1); GL.Vertex3(1, 1, 1); GL.TexCoord3(1, 1, 1); GL.Vertex3(1, 0, 1); GL.End(); tex2d.ReadPixels(new Rect(0, 0, srcCubemap.width, srcCubemap.height), srcCubemap.width * 4, 0); // Negative Z Graphics.SetRenderTarget(dstCubemap, dstMip, CubemapFace.NegativeZ); GL.Begin(GL.QUADS); GL.TexCoord3(1, 1, -1); GL.Vertex3(0, 0, 1); GL.TexCoord3(1, -1, -1); GL.Vertex3(0, 1, 1); GL.TexCoord3(-1, -1, -1); GL.Vertex3(1, 1, 1); GL.TexCoord3(-1, 1, -1); GL.Vertex3(1, 0, 1); GL.End(); tex2d.ReadPixels(new Rect(0, 0, srcCubemap.width, srcCubemap.height), srcCubemap.width * 5, 0); GL.PopMatrix(); tex2d.Apply(); for (int x = 0; x < tex2d.width; x++) { for (int y1 = 0, y2 = tex2d.height - 1; y1 < y2; y1++, y2--) { var t1 = tex2d.GetPixel(x, y1); tex2d.SetPixel(x, y1, tex2d.GetPixel(x, y2)); tex2d.SetPixel(x, y2, t1); } } UnityEngine.Object.DestroyImmediate(dstCubemap); var path = "Assets/temp" + DateTime.Now.ToBinary() + ".exr"; File.WriteAllBytes(path, tex2d.EncodeToEXR()); AssetDatabase.Refresh(); TextureImporter im = AssetImporter.GetAtPath(path) as TextureImporter; im.isReadable = true; im.textureShape = TextureImporterShape.TextureCube; im.SaveAndReimport(); return(AssetDatabase.LoadAssetAtPath <Cubemap>(path)); }
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(); } }
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); }
private Entity CreatePlanetEntity(Entity prefabEntity, List <int> usedIndexes) { Entity spawnedEntity = EntityManager.Instantiate(prefabEntity); RenderMesh renderMesh = EntityManager.GetSharedComponentData <RenderMesh>(spawnedEntity); UnityEngine.Material mat = new UnityEngine.Material(renderMesh.material); mat.SetVector("_RedMinMax", new UnityEngine.Vector4(_random.NextFloat(0f, 1f), _random.NextFloat(0f, 1f))); mat.SetVector("_GreenMinMax", new UnityEngine.Vector4(_random.NextFloat(0f, 1f), _random.NextFloat(0f, 1f))); mat.SetVector("_BlueMinMax", new UnityEngine.Vector4(_random.NextFloat(0f, 1f), _random.NextFloat(0f, 1f))); mat.SetFloat("_NoiseScale", _random.NextFloat(10f, 80f)); renderMesh.material = mat; EntityManager.SetSharedComponentData(spawnedEntity, renderMesh); float rndSize = _random.NextFloat(1f, 2.5f); int rndOrbitRadiusIdx = _random.NextInt(0, SpawnRadiuses.Length); while (usedIndexes.Contains(rndOrbitRadiusIdx)) { rndOrbitRadiusIdx = _random.NextInt(0, SpawnRadiuses.Length); } float rndOrbitRadius = SpawnRadiuses[rndOrbitRadiusIdx]; int rndDir = _random.NextInt(-5, 6); rndDir = rndDir * 2 + 1; float movementSpeed = math.sign(rndDir) * 1f * rndSize / rndOrbitRadius; float rndPosRadians = _random.NextFloat(0f, math.PI); EntityManager.AddComponentData(spawnedEntity, new OrbitRadius { Value = rndOrbitRadius }); EntityManager.AddComponentData(spawnedEntity, new MovementSpeed { Value = movementSpeed }); EntityManager.AddComponentData(spawnedEntity, new OrbitAngle { Value = rndPosRadians }); EntityManager.AddComponentData(spawnedEntity, new Scale { Value = rndSize }); EntityManager.AddComponentData(spawnedEntity, new ShootCooldown { Value = 0.5f }); EntityManager.AddComponentData(spawnedEntity, new ShootTime { Value = 0f }); EntityManager.AddComponentData(spawnedEntity, new AddPlanetHUD()); EntityManager.AddComponentData(spawnedEntity, new ChangeSphereColliderRadius { Value = rndSize * 0.5f }); EntityManager.AddComponentData(spawnedEntity, new NextRocketType { Value = 0 }); BodyMass planetMass = EntityManager.GetComponentData <BodyMass>(spawnedEntity); planetMass.Value *= rndSize; EntityManager.SetComponentData(spawnedEntity, planetMass); SimpleSphereCollider collider = EntityManager.GetComponentData <SimpleSphereCollider>(spawnedEntity); collider.Radius = rndSize * 0.5f; EntityManager.SetComponentData(spawnedEntity, collider); EntityManager.SetComponentData(spawnedEntity, new Translation { Value = new float3(math.cos(_random.NextFloat(0f, 1f) * math.PI), 0f, math.sin(_random.NextFloat(0f, 1f) * math.PI)) * rndOrbitRadius }); usedIndexes.Add(rndOrbitRadiusIdx); return(spawnedEntity); }
void UpdatePreview() { if (!this) return; #if BVH if (previewBvh) { if (!entityBuffer.IsCreated) RebuildEntityBuffers(); if (!bvhNodeBuffer.IsCreated) RebuildBvh(); } else { sphereBuffer.SafeDispose(); bvhNodeBuffer.SafeDispose(); entityBuffer.SafeDispose(); ActiveEntities.Clear(); } #endif // BVH if (scene) { Transform cameraTransform = targetCamera.transform; cameraTransform.position = scene.CameraPosition; cameraTransform.rotation = Quaternion.LookRotation(scene.CameraTarget - scene.CameraPosition); targetCamera.fieldOfView = scene.CameraFieldOfView; } Action updateDelegate = OnEditorUpdate; if (EditorApplication.update.GetInvocationList().All(x => x != (Delegate) updateDelegate)) EditorApplication.update += OnEditorUpdate; if (opaquePreviewCommandBuffer == null) opaquePreviewCommandBuffer = new CommandBuffer { name = "World Preview (Opaque)" }; if (transparentPreviewCommandBuffer == null) transparentPreviewCommandBuffer = new CommandBuffer { name = "World Preview (Transparent)" }; targetCamera.RemoveAllCommandBuffers(); targetCamera.AddCommandBuffer(CameraEvent.AfterForwardOpaque, opaquePreviewCommandBuffer); targetCamera.AddCommandBuffer(CameraEvent.AfterForwardAlpha, transparentPreviewCommandBuffer); opaquePreviewCommandBuffer.Clear(); transparentPreviewCommandBuffer.Clear(); foreach (UnityEngine.Material material in previewMaterials) DestroyImmediate(material); previewMaterials.Clear(); var skybox = targetCamera.GetComponent<Skybox>(); if (AssetDatabase.IsMainAsset(skybox.material)) RenderSettings.skybox = skybox.material = new UnityEngine.Material(skybox.material); skybox.material.SetColor("_Color1", scene.SkyBottomColor); skybox.material.SetColor("_Color2", scene.SkyTopColor); EnsurePreviewObjectExists(PrimitiveType.Sphere, ref previewSphere); EnsurePreviewObjectExists(PrimitiveType.Quad, ref previewRect); EnsurePreviewObjectExists(PrimitiveType.Cube, ref previewBox); var previewMeshRenderer = previewSphere.GetComponent<MeshRenderer>(); CollectActiveEntities(); opaquePreviewCommandBuffer.EnableShaderKeyword("LIGHTPROBE_SH"); transparentPreviewCommandBuffer.EnableShaderKeyword("LIGHTPROBE_SH"); foreach (EntityData entity in ActiveEntities) { if (!entity.Material) continue; bool transparent = entity.Material.Type == MaterialType.Dielectric; bool emissive = entity.Material.Type == MaterialType.DiffuseLight; Color albedoMainColor = entity.Material.Albedo ? entity.Material.Albedo.MainColor : Color.white; Color color = transparent ? albedoMainColor.GetAlphaReplaced(0.5f) : albedoMainColor; var material = new UnityEngine.Material(previewMeshRenderer.sharedMaterial) { color = color }; previewMaterials.Add(material); material.SetFloat("_Metallic", entity.Material.Type == MaterialType.Metal ? 1 : 0); material.SetFloat("_Glossiness", entity.Material.Type == MaterialType.Metal ? 1 - entity.Material.Roughness : transparent ? 1 : 0); material.SetTexture("_MainTex", entity.Material.Albedo ? entity.Material.Albedo.Image : null); if (transparent) { material.SetInt("_SrcBlend", (int) BlendMode.One); material.SetInt("_DstBlend", (int) BlendMode.OneMinusSrcAlpha); material.SetInt("_ZWrite", 0); material.EnableKeyword("_ALPHAPREMULTIPLY_ON"); material.renderQueue = 3000; } if (emissive) { material.EnableKeyword("_EMISSION"); material.SetColor("_EmissionColor", entity.Material.Emission ? entity.Material.Emission.MainColor : Color.black); } CommandBuffer previewCommandBuffer = transparent ? transparentPreviewCommandBuffer : opaquePreviewCommandBuffer; switch (entity.Type) { case EntityType.Sphere: SphereData s = entity.SphereData; previewCommandBuffer.DrawMesh(previewSphere.sharedMesh, Matrix4x4.TRS(entity.Position, entity.Rotation, s.Radius * 2 * Vector3.one), material, 0, material.FindPass("FORWARD")); break; case EntityType.Rect: RectData r = entity.RectData; previewCommandBuffer.DrawMesh(previewRect.sharedMesh, Matrix4x4.TRS(entity.Position, Quaternion.LookRotation(Vector3.forward) * entity.Rotation,float3(r.Size, 1)), material, 0, material.FindPass("FORWARD")); break; case EntityType.Box: BoxData b = entity.BoxData; previewCommandBuffer.DrawMesh(previewBox.sharedMesh, Matrix4x4.TRS(entity.Position, entity.Rotation, b.Size), material, 0, material.FindPass("FORWARD")); break; } } }
public Material CreateMaterial(PbrMaterial vpxMaterial, ITextureProvider textureProvider, StringBuilder debug = null) { Material defaultMaterial = GetDefaultMaterial(vpxMaterial.MapBlendMode); var unityMaterial = new Material(GetShader(vpxMaterial)); unityMaterial.CopyPropertiesFromMaterial(defaultMaterial); unityMaterial.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; } 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. float metallicValue = 0f; if (vpxMaterial.IsMetal && (!vpxMaterial.IsOpacityActive || vpxMaterial.Opacity >= 1)) { metallicValue = 1f; debug?.AppendLine("Metallic set to 1."); } unityMaterial.SetFloat(Metallic, metallicValue); // roughness / glossiness SetSmoothness(unityMaterial, vpxMaterial.Roughness); // map if (vpxMaterial.HasMap) { unityMaterial.SetTexture(BaseMap, textureProvider.GetTexture(vpxMaterial.Map.Name)); } // normal map if (vpxMaterial.HasNormalMap) { unityMaterial.EnableKeyword("_NORMALMAP"); unityMaterial.EnableKeyword("_NORMALMAP_TANGENT_SPACE"); unityMaterial.SetTexture(NormalMap, textureProvider.GetTexture(vpxMaterial.NormalMap.Name)); } return(unityMaterial); }
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; } } }
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)); }
private void ApplyBlendMode(UnityEngine.Material unityMaterial, BlendMode blendMode) { switch (blendMode) { case BlendMode.Opaque: // set render type unityMaterial.SetOverrideTag("RenderType", "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(Surface, 0); // 0 = Opaque; 1 = Transparent // render queue unityMaterial.renderQueue = -1; break; case BlendMode.Cutout: // set render type unityMaterial.SetOverrideTag("RenderType", "TransparentCutout"); // keywords unityMaterial.EnableKeyword("_ALPHATEST_ON"); // required for 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(Surface, 0); // 0 = Opaque; 1 = Transparent unityMaterial.SetInt(AlphaClip, 1); // render queue unityMaterial.renderQueue = 2450; break; case BlendMode.Translucent: // disable shader passes unityMaterial.SetShaderPassEnabled("SHADOWCASTER", false); // set render type unityMaterial.SetOverrideTag("RenderType", "Transparent"); // keywords unityMaterial.EnableKeyword("_ALPHAPREMULTIPLY_ON"); // required for 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(Surface, 1); // 0 = Opaque; 1 = Transparent unityMaterial.SetFloat(Blend, 1); // 0 = Alpha, 1 = Premultiply, 2 = Additive, 3 = Multiply // render queue const int transparentRenderQueueBase = 3000; const int transparentSortingPriority = 0; unityMaterial.SetInt(QueueOffset, transparentSortingPriority); unityMaterial.renderQueue = transparentRenderQueueBase + transparentSortingPriority; break; default: throw new ArgumentOutOfRangeException(); } }
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; } unityMaterial.SetColor(Color, 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(Glossiness, vpxMaterial.Roughness); // blend mode ApplyBlendMode(unityMaterial, vpxMaterial.MapBlendMode); if (vpxMaterial.MapBlendMode == BlendMode.Translucent) { col.a = Mathf.Min(1, Mathf.Max(0, vpxMaterial.Opacity)); unityMaterial.SetColor(Color, col); } // map if (table != null && vpxMaterial.HasMap) { unityMaterial.SetTexture( MainTex, 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); }