public SetMatrix ( int nameID, |
||
nameID | int | Property name ID, use Shader.PropertyToID to get it. |
matrix | Matrix value to set. | |
리턴 | void |
static public int SetMatrix(IntPtr l) { try{ if (matchType(l, 2, typeof(System.String), typeof(UnityEngine.Matrix4x4))) { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.String a1; checkType(l, 2, out a1); UnityEngine.Matrix4x4 a2; checkType(l, 3, out a2); self.SetMatrix(a1, a2); return(0); } else if (matchType(l, 2, typeof(System.Int32), typeof(UnityEngine.Matrix4x4))) { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.Int32 a1; checkType(l, 2, out a1); UnityEngine.Matrix4x4 a2; checkType(l, 3, out a2); self.SetMatrix(a1, a2); return(0); } LuaDLL.luaL_error(l, "No matched override function to call"); return(0); } catch (Exception e) { LuaDLL.luaL_error(l, e.ToString()); return(0); } }
static int SetMatrix(IntPtr L) { try { int count = LuaDLL.lua_gettop(L); if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(int), typeof(UnityEngine.Matrix4x4))) { UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1); int arg0 = (int)LuaDLL.lua_tonumber(L, 2); UnityEngine.Matrix4x4 arg1 = (UnityEngine.Matrix4x4)ToLua.ToObject(L, 3); obj.SetMatrix(arg0, arg1); return(0); } else if (count == 3 && TypeChecker.CheckTypes(L, 1, typeof(UnityEngine.Material), typeof(string), typeof(UnityEngine.Matrix4x4))) { UnityEngine.Material obj = (UnityEngine.Material)ToLua.ToObject(L, 1); string arg0 = ToLua.ToString(L, 2); UnityEngine.Matrix4x4 arg1 = (UnityEngine.Matrix4x4)ToLua.ToObject(L, 3); obj.SetMatrix(arg0, arg1); return(0); } else { return(LuaDLL.luaL_throw(L, "invalid arguments to method: UnityEngine.Material.SetMatrix")); } } catch (Exception e) { return(LuaDLL.toluaL_exception(L, e)); } }
static public int SetMatrix(IntPtr l) { try { int argc = LuaDLL.lua_gettop(l); if (matchType(l, argc, 2, typeof(int), typeof(UnityEngine.Matrix4x4))) { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.Int32 a1; checkType(l, 2, out a1); UnityEngine.Matrix4x4 a2; checkValueType(l, 3, out a2); self.SetMatrix(a1, a2); pushValue(l, true); return(1); } else if (matchType(l, argc, 2, typeof(string), typeof(UnityEngine.Matrix4x4))) { UnityEngine.Material self = (UnityEngine.Material)checkSelf(l); System.String a1; checkType(l, 2, out a1); UnityEngine.Matrix4x4 a2; checkValueType(l, 3, out a2); self.SetMatrix(a1, a2); pushValue(l, true); return(1); } pushValue(l, false); LuaDLL.lua_pushstring(l, "No matched override function to call"); return(2); } catch (Exception e) { return(error(l, e)); } }
public static void RenderDistortion(Material material, RenderTexture source, RenderTexture destination, float angle, Vector2 center, Vector2 radius) { bool flag = source.texelSize.y < 0f; if (flag) { center.y = 1f - center.y; angle = -angle; } Matrix4x4 matrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0f, 0f, angle), Vector3.one); material.SetMatrix("_RotationMatrix", matrix); material.SetVector("_CenterRadius", new Vector4(center.x, center.y, radius.x, radius.y)); material.SetFloat("_Angle", angle * 0.0174532924f); Graphics.Blit(source, destination, material); }
public static void RenderDistortion(Material material, RenderTexture source, RenderTexture destination, float angle, Vector2 center, Vector2 radius) { bool invertY = source.texelSize.y < 0.0f; if (invertY) { center.y = 1.0f - center.y; angle = -angle; } Matrix4x4 rotationMatrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0, 0, angle), Vector3.one); material.SetMatrix("_RotationMatrix", rotationMatrix); material.SetVector("_CenterRadius", new Vector4(center.x, center.y, radius.x, radius.y)); material.SetFloat("_Angle", angle * Mathf.Deg2Rad); Graphics.Blit(source, destination, material); }
public void UpdateMaterial(RaycastHit hit) { var hitGO = hit.transform; if (hitGO!=null) { if (!RemoveWhenDisable) Destroy(gameObject, RemoveAfterTime); fadeInOutShaderColor = GetComponents<FadeInOutShaderColor>(); fadeInOutShaderFloat = GetComponents<FadeInOutShaderFloat>(); uvTextureAnimator = GetComponent<UVTextureAnimator>(); renderParent = transform.parent.GetComponent<Renderer>(); var materials = renderParent.sharedMaterials; var length = materials.Length + 1; var newMaterials = new Material[length]; materials.CopyTo(newMaterials, 0); renderParent.material = Material; instanceMat = renderParent.material; newMaterials[length - 1] = instanceMat; renderParent.sharedMaterials = newMaterials; if (UsePointMatrixTransform) { var m = Matrix4x4.TRS(hit.transform.InverseTransformPoint(hit.point), Quaternion.Euler(180, 180, 0f), TransformScale); //m *= transform.localToWorldMatrix; instanceMat.SetMatrix("_DecalMatr", m); } if (materialQueue!=-1) instanceMat.renderQueue = materialQueue; if (fadeInOutShaderColor!=null) { foreach (var inOutShaderColor in fadeInOutShaderColor) { inOutShaderColor.UpdateMaterial(instanceMat); } } if (fadeInOutShaderFloat!=null) { foreach (var inOutShaderFloat in fadeInOutShaderFloat) { inOutShaderFloat.UpdateMaterial(instanceMat); } } if (uvTextureAnimator!=null) uvTextureAnimator.SetInstanceMaterial(instanceMat, hit.textureCoord); } }
private void convolve_internal(Texture dstTex, Texture srcCube, bool dstRGBM, bool srcRGBM, bool linear, Camera cam, Material skyMat, Matrix4x4 matrix) { bool prevHDR = cam.hdr; CameraClearFlags prevFlags = cam.clearFlags; int prevMask = cam.cullingMask; cam.clearFlags = CameraClearFlags.Skybox; cam.cullingMask = 0; cam.hdr = !dstRGBM; // might need HDR camera buffer when we're not rendering to RGBM encoded pixels skyMat.name = "Internal Convolve Skybox"; skyMat.shader = Shader.Find("Hidden/Marmoset/RGBM Convolve"); //toggleKeywordPair("MARMO_LINEAR", "MARMO_GAMMA", linear); toggleKeywordPair("MARMO_RGBM_INPUT_ON", "MARMO_RGBM_INPUT_OFF", srcRGBM); toggleKeywordPair("MARMO_RGBM_OUTPUT_ON", "MARMO_RGBM_OUTPUT_OFF", dstRGBM); skyMat.SetMatrix("_SkyMatrix", matrix); skyMat.SetTexture("_CubeHDR", srcCube); bindRandomValueTable(skyMat,"_PhongRands", srcCube.width); Material prevSkyMat = UnityEngine.RenderSettings.skybox; UnityEngine.RenderSettings.skybox = skyMat; Cubemap dstCube = dstTex as Cubemap; RenderTexture dstRT = dstTex as RenderTexture; if( dstCube ) { if( generateMipChain ) { int mipCount = mset.QPow.Log2i(dstCube.width) - 1; int mip = highestMipIsMirror ? 1 : 0; for( ; mip<mipCount; ++mip ) { int mipSize = 1 << (mipCount-mip); float mipExp = mset.QPow.clampedDownShift(this.maxExponent, highestMipIsMirror ? (mip-1) : mip, 1); skyMat.SetFloat("_SpecularExp", mipExp); skyMat.SetFloat ("_SpecularScale", this.convolutionScale); Cubemap mipCube = new Cubemap(mipSize, dstCube.format, false); cam.RenderToCubemap(mipCube); for(int f=0; f<6; ++f) { CubemapFace face = (CubemapFace)f; dstCube.SetPixels(mipCube.GetPixels(face), face, mip); } Cubemap.DestroyImmediate(mipCube); } dstCube.Apply(false); } else { skyMat.SetFloat("_SpecularExp", this.maxExponent); skyMat.SetFloat ("_SpecularScale", this.convolutionScale); cam.RenderToCubemap(dstCube); } } else if(dstRT) { skyMat.SetFloat("_SpecularExp", this.maxExponent); skyMat.SetFloat ("_SpecularScale", this.convolutionScale); cam.RenderToCubemap(dstRT); } cam.clearFlags = prevFlags; cam.cullingMask = prevMask; cam.hdr = prevHDR; UnityEngine.RenderSettings.skybox = prevSkyMat; }
public void Apply(CloudsMaterial material, float radius, Transform parent) { Remove(); particleMaterial.MaxScale = size.y; particleMaterial.MaxTrans = maxTranslation; particleMaterial.NoiseScale = new Vector3(noiseScale.x, noiseScale.y, noiseScale.z / radius); ParticleMaterial = new Material(ParticleCloudShader); particleMaterial.ApplyMaterialProperties(ParticleMaterial); material.ApplyMaterialProperties(ParticleMaterial); ParticleMaterial.EnableKeyword("SOFT_DEPTH_ON"); volumeHolder = new GameObject(); //Add the renderer here so othe rentities (shadows) //can easily access it. Renderer r = volumeHolder.AddComponent<MeshRenderer>(); r.material = ParticleMaterial; ParticleMaterial.SetMatrix(ShaderProperties._ShadowBodies_PROPERTY, Matrix4x4.zero); ParticleMaterial.renderQueue = (int)Tools.Queue.Transparent + 2; r.enabled = false; volumeHolder.transform.parent = parent; volumeHolder.transform.localPosition = Vector3.zero; volumeHolder.transform.localScale = Vector3.one; volumeHolder.transform.localRotation = Quaternion.identity; volumeHolder.layer = (int)Tools.Layer.Local; volumeManager = new VolumeManager(radius, size, ParticleMaterial, volumeHolder.transform, area.x, (int)area.y); }
void SetFrustumRays(Material material) { Matrix4x4 frustumRays; Vector3 cameraPosLocal; GetFrustumRays(out frustumRays, out cameraPosLocal); material.SetVector("_CameraPosLocal", cameraPosLocal); material.SetMatrix("_FrustumRays", frustumRays); material.SetFloat("_FrustumApex", GetFrustumApex()); }
public void SetUniforms(Material mat) { //Sets uniforms that this or other gameobjects may need if (mat == null) return; mat.SetFloat("_Extinction_Cutoff", ExtinctionCutoff); if (!MapView.MapIsEnabled) { mat.SetFloat("_Alpha_Global", alphaGlobal); mat.SetFloat("_Extinction_Tint", extinctionTint); mat.SetFloat("extinctionMultiplier", extinctionMultiplier); } else { mat.SetFloat("_Alpha_Global", mapAlphaGlobal); mat.SetFloat("_Extinction_Tint", mapExtinctionTint); mat.SetFloat("extinctionMultiplier", mapExtinctionMultiplier); } mat.SetFloat("scale", atmosphereGlobalScale); mat.SetFloat("Rg", Rg * atmosphereGlobalScale); mat.SetFloat("Rt", Rt * atmosphereGlobalScale); mat.SetFloat("RL", RL * atmosphereGlobalScale); // if (debugSettings [5]) if (!MapView.MapIsEnabled) { mat.SetFloat("_Globals_ApparentDistance", 1f); } else { mat.SetFloat("_Globals_ApparentDistance", (float)((parentCelestialBody.Radius / 100.2f) / MapViewScale)); // mat.SetFloat ("_Globals_ApparentDistance", MapViewScale); } // if (debugSettings[1]) if (!MapView.MapIsEnabled) { mat.SetMatrix("_Globals_WorldToCamera", farCamera.worldToCameraMatrix); mat.SetMatrix("_Globals_CameraToWorld", farCamera.worldToCameraMatrix.inverse); } else { mat.SetMatrix("_Globals_WorldToCamera", scaledSpaceCamera.worldToCameraMatrix); mat.SetMatrix("_Globals_CameraToWorld", scaledSpaceCamera.worldToCameraMatrix.inverse); } mat.SetVector("betaR", m_betaR / 1000.0f); mat.SetFloat("mieG", Mathf.Clamp(m_mieG, 0.0f, 0.99f)); mat.SetTexture("_Sky_Transmittance", m_transmit); mat.SetTexture("_Sky_Inscatter", m_inscatter); mat.SetTexture("_Sky_Irradiance", m_irradiance); mat.SetFloat("_Sun_Intensity", 100f); mat.SetVector("_Sun_WorldSunDir", m_manager.getDirectionToSun().normalized); // mat.SetVector("_Sun_WorldSunDir", m_manager.getDirectionToSun()); // //copied from m_manager's set uniforms //Matrix4x4 p; // if (debugSettings [2]) if (!MapView.MapIsEnabled) { p = farCamera.projectionMatrix; } else { p = scaledSpaceCamera.projectionMatrix; } m_cameraToScreenMatrix = new Matrix4x4d(p); mat.SetMatrix("_Globals_CameraToScreen", m_cameraToScreenMatrix.ToMatrix4x4()); mat.SetMatrix("_Globals_ScreenToCamera", m_cameraToScreenMatrix.Inverse().ToMatrix4x4()); // if (debugSettings [3]) if (!MapView.MapIsEnabled) { mat.SetVector("_Globals_WorldCameraPos", farCamera.transform.position); } else { mat.SetVector("_Globals_WorldCameraPos", scaledSpaceCamera.transform.position); } // else // { // Vector3 newpos= ScaledSpace.ScaledToLocalSpace(scaledSpaceCamera.transform.position); // // m_skyMaterial.SetVector ("_Globals_WorldCameraPos", scaledSpaceCamera.transform.position); // mat.SetVector ("_Globals_WorldCameraPos", newpos); // } // // if (debugSettings [4]) if (!MapView.MapIsEnabled) { mat.SetVector("_Globals_Origin", parentCelestialBody.transform.position); } else { // celestialTransform = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == parentCelestialBody.name); celestialTransform = ParentPlanetTransform; // idek =celestialTransform.position; idek = celestialTransform.position - scaledSpaceCamera.transform.position; mat.SetVector("_Globals_Origin", idek); } if (!MapView.MapIsEnabled) { mat.SetFloat("_Exposure", m_HDRExposure); } else { mat.SetFloat("_Exposure", mapExposure); } // int childCnt = 0; // Transform scaledSunTransform=ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == "Sun"); // foreach (Transform child in scaledSunTransform) // { // print(childCnt); // print(child.gameObject.name); // childCnt++; // MeshRenderer temp; // temp = child.gameObject.GetComponent<MeshRenderer>(); //// temp.enabled=false; // print(temp.enabled); // } }
/** * Sets the shader uniforms that are necessary to project on screen the * TerrainQuad of the given TerrainNode. This method can set the uniforms * that are common to all the quads of the given terrain. */ public virtual void SetUniforms(TerrainNode node, Material mat) { if(mat == null || node == null) return; float d1 = node.GetSplitDist() + 1.0f; float d2 = 2.0f * node.GetSplitDist(); mat.SetVector(m_uniforms.blending, new Vector2(d1, d2 - d1)); m_localToCamera = node.GetView().GetWorldToCamera() * node.GetLocalToWorld(); m_localToScreen = node.GetView().GetCameraToScreen() * m_localToCamera; Vector3d2 localCameraPos = node.GetLocalCameraPos(); Vector3d2 worldCamera = node.GetView().GetWorldCameraPos(); Matrix4x4d A = LocalToDeformedDifferential(localCameraPos); Matrix4x4d B = DeformedToTangentFrame(worldCamera); Matrix4x4d ltot = B * node.GetLocalToWorld() * A; m_localToTangent = new Matrix3x3d( ltot.m[0,0], ltot.m[0,1], ltot.m[0,3], ltot.m[1,0], ltot.m[1,1], ltot.m[1,3], ltot.m[3,0], ltot.m[3,1], ltot.m[3,3]); mat.SetMatrix(m_uniforms.localToScreen, m_localToScreen.ToMatrix4x4()); mat.SetMatrix(m_uniforms.localToWorld, node.GetLocalToWorld().ToMatrix4x4()); }
public static void RenderDistortion(Material material, RenderTexture source, RenderTexture destination, float angle, Vector2 center, Vector2 radius) { Matrix4x4 rotationMatrix = Matrix4x4.TRS(Vector3.zero, Quaternion.Euler(0, 0, angle), Vector3.one); material.SetMatrix("_RotationMatrix", rotationMatrix); material.SetVector("_CenterRadius", new Vector4(center.x,center.y,radius.x,radius.y) ); material.SetFloat("_Angle", angle * Mathf.Deg2Rad); ImageEffects.BlitWithMaterial( material, source, destination ); }
private void ApplyCache(Material material, float scale = 1.0f) { foreach (KeyValuePair<object,object> field in cache) { object obj = field.Value; float scaleValue = 1f; if (obj != null && obj.GetType() == typeof(ScaledValue)) { obj = ((ScaledValue)obj).obj; scaleValue = scale; } else if (obj != null && obj.GetType() == typeof(InverseScaledValue)) { obj = ((InverseScaledValue)obj).obj; scaleValue = 1 / scale; } if (obj.GetType() == typeof(TextureWrapper)) { TextureWrapper value = (TextureWrapper)obj; value.ApplyTexture(material, (String)field.Key); } //float else if (obj.GetType() == typeof(float)) { float value = (float)obj; material.SetFloat((int)field.Key, value * scaleValue); } //Color else if (obj.GetType() == typeof(Color)) { Color value = (Color)obj; material.SetColor((int)field.Key, value/256f); } //Color32 else if (obj.GetType() == typeof(Color32)) { Color32 value = (Color32)obj; material.SetColor((int)field.Key, value); }//Vector2 else if (obj.GetType() == typeof(Vector2)) { Vector2 value = (Vector2)obj; material.SetVector((int)field.Key, value * scaleValue); } //Vector3 else if (obj.GetType() == typeof(Vector3)) { Vector3 value = (Vector3)obj; material.SetVector((int)field.Key, value * scaleValue); } //Vector4 else if (obj.GetType() == typeof(Vector4)) { Vector4 value = (Vector4)obj; material.SetVector((int)field.Key, value * scaleValue); } //Matrix else if (obj.GetType() == typeof(Matrix4x4)) { Matrix4x4 value = (Matrix4x4)obj; material.SetMatrix((int)field.Key, value); } //bool else if (obj.GetType() == typeof(bool)) { bool value = (bool)obj; if (value) { material.EnableKeyword((String)field.Key); } else { material.DisableKeyword((String)field.Key); } } //enum else if (obj.GetType().IsEnum) { String value = Enum.GetName(obj.GetType(), obj); material.EnableKeyword(value); } } }
public static void ComputeColorComposition(Camera camera, Material colorCompositeMaterial, RenderTexture dst, RenderTexture instanceIdBuffer, RenderTexture atomIdBuffer, RenderTexture depthBuffer) { var temp1 = new DisplayInfo[CPUBuffers.Get.IngredientsDisplayInfo.Count]; var temp2 = new DisplayInfo[CPUBuffers.Get.IngredientGroupsDisplayInfo.Count]; GPUBuffers.Get.IngredientsColorInfo.GetData(temp1); GPUBuffers.Get.IngredientGroupsColorInfo.GetData(temp2); CPUBuffers.Get.IngredientsDisplayInfo = temp1.ToList(); CPUBuffers.Get.IngredientGroupsDisplayInfo = temp2.ToList(); //Debug.Log(temp2[5].ToString()); /**************/ //colorCompositeMaterial.SetFloat("_depth", ColorManager.Get.depthSlider); colorCompositeMaterial.SetFloat("_UseHCL", Convert.ToInt32(ColorManager.Get.UseHCL)); colorCompositeMaterial.SetFloat("_ShowAtoms", Convert.ToInt32(ColorManager.Get.ShowAtoms)); colorCompositeMaterial.SetFloat("_ShowChains", Convert.ToInt32(ColorManager.Get.ShowChains)); colorCompositeMaterial.SetFloat("_ShowResidues", Convert.ToInt32(ColorManager.Get.ShowResidues)); colorCompositeMaterial.SetFloat("_ShowSecondaryStructures", Convert.ToInt32(ColorManager.Get.ShowSecondaryStructures)); colorCompositeMaterial.SetFloat("_AtomDistance", ColorManager.Get.AtomDistance); colorCompositeMaterial.SetFloat("_ChainDistance", ColorManager.Get.ChainDistance); colorCompositeMaterial.SetFloat("_ResidueDistance", ColorManager.Get.ResidueDistance); colorCompositeMaterial.SetFloat("_SecondaryStructureDistance", ColorManager.Get.SecondaryStructureDistance); // LOD infos var rangeValues = Matrix4x4.zero; int distAcc = 0; for (int i = 0; i < ColorManager.Get.LevelRanges.Length; i++) { distAcc += (int)(ColorManager.Get.LevelRanges[i] * ColorManager.Get.DistanceMax); rangeValues[i] = distAcc; } rangeValues[ColorManager.Get.LevelRanges.Length] = ColorManager.Get.DistanceMax; var selectionSphere = (Vector4)SelectionManager.Instance.SelectionGameObject.transform.position; selectionSphere.w = SelectionManager.Instance.SelectionGameObject.GetComponent<SphereCollider>().radius; colorCompositeMaterial.SetVector("_FocusSphere", selectionSphere); colorCompositeMaterial.SetMatrix("_ProjectionMatrix", camera.projectionMatrix); colorCompositeMaterial.SetMatrix("_InverseViewMatrix", camera.cameraToWorldMatrix); colorCompositeMaterial.SetInt("_UseDistanceLevels", Convert.ToInt32(ColorManager.Get.UseDistanceLevels)); colorCompositeMaterial.SetInt("_NumLevelMax", ColorManager.Get.NumLevelMax); colorCompositeMaterial.SetInt("_DistanceMax", ColorManager.Get.DistanceMax); colorCompositeMaterial.SetMatrix("_LevelRanges", rangeValues); //*****// colorCompositeMaterial.SetFloat("_LevelLerpFactor", ColorManager.Get.LevelLerpFactor); colorCompositeMaterial.SetInt("_NumPixels", instanceIdBuffer.width * instanceIdBuffer.height); //*****// colorCompositeMaterial.SetTexture("_DepthBuffer", depthBuffer); colorCompositeMaterial.SetTexture("_AtomIdBuffer", atomIdBuffer); colorCompositeMaterial.SetTexture("_InstanceIdBuffer", instanceIdBuffer); // Properties colorCompositeMaterial.SetBuffer("_ProteinAtomInfos", GPUBuffers.Get.ProteinAtomInfo); colorCompositeMaterial.SetBuffer("_ProteinAtomInfos2", GPUBuffers.Get.ProteinAtomInfo2); colorCompositeMaterial.SetBuffer("_ProteinInstanceInfo", GPUBuffers.Get.ProteinInstancesInfo); colorCompositeMaterial.SetBuffer("_LipidAtomInfos", GPUBuffers.Get.LipidAtomPositions); colorCompositeMaterial.SetBuffer("_LipidInstancesInfo", GPUBuffers.Get.LipidInstancesInfo); colorCompositeMaterial.SetBuffer("_IngredientsInfo", GPUBuffers.Get.IngredientsInfo); colorCompositeMaterial.SetBuffer("_IngredientGroupsColorInfo", GPUBuffers.Get.IngredientGroupsColorInfo); colorCompositeMaterial.SetBuffer("_ProteinIngredientsColorInfo", GPUBuffers.Get.IngredientsColorInfo); // Predifined colors colorCompositeMaterial.SetBuffer("_AtomColors", GPUBuffers.Get.AtomColors); colorCompositeMaterial.SetBuffer("_AminoAcidColors", GPUBuffers.Get.AminoAcidColors); colorCompositeMaterial.SetBuffer("_IngredientsColors", GPUBuffers.Get.IngredientsColors); colorCompositeMaterial.SetBuffer("_IngredientsChainColors", GPUBuffers.Get.IngredientsChainColors); colorCompositeMaterial.SetBuffer("_IngredientGroupsColor", GPUBuffers.Get.IngredientGroupsColor); // Values for color generation on the fly colorCompositeMaterial.SetBuffer("_IngredientGroupsLerpFactors", GPUBuffers.Get.IngredientGroupsLerpFactors); colorCompositeMaterial.SetBuffer("_IngredientGroupsColorValues", GPUBuffers.Get.IngredientGroupsColorValues); colorCompositeMaterial.SetBuffer("_IngredientGroupsColorRanges", GPUBuffers.Get.IngredientGroupsColorRanges); colorCompositeMaterial.SetBuffer("_ProteinIngredientsRandomValues", GPUBuffers.Get.ProteinIngredientsRandomValues); Graphics.Blit(null, dst, colorCompositeMaterial, 0); }
private void ApplyToMaterial(Material mat, ShaderIDs bids) { mat.SetVector(bids.exposureIBL, this.exposures); mat.SetVector(bids.exposureLM, this.exposuresLM); mat.SetMatrix(bids.skyMatrix, this.skyMatrix); mat.SetMatrix(bids.invSkyMatrix, this.invMatrix); mat.SetVector(bids.skyMin, skyMin); mat.SetVector(bids.skyMax, skyMax); if(specularCube) mat.SetTexture(bids.specCubeIBL, this.specularCube); else mat.SetTexture(bids.specCubeIBL, this.blackCube); if(skyboxCube) mat.SetTexture(bids.skyCubeIBL, this.skyboxCube); for(int i=0; i<9; ++i) { mat.SetVector(bids.SH[i], this.SH.cBuffer[i]); } }
void UpdatePostProcessMaterial(Material mat) { //mat.SetFloat ("atmosphereGlobalScale", atmosphereGlobalScale); // mat.SetFloat ("Rg", Rg*atmosphereGlobalScale*postProcessingScale); // mat.SetFloat("Rt", Rt*atmosphereGlobalScale*postProcessingScale); // mat.SetFloat("Rl", RL*atmosphereGlobalScale*postProcessingScale); float totalscale = 1; float totalscale2 = 1; for (int j=0; j<5; j++) { totalscale=totalscale*additionalScales[j]; } for (int j=6; j<10; j++) { totalscale2=totalscale2*additionalScales[j]; } mat.SetFloat ("Rg", Rg*atmosphereGlobalScale*totalscale); mat.SetFloat("Rt", Rt*atmosphereGlobalScale*totalscale); mat.SetFloat("Rl", RL*atmosphereGlobalScale*totalscale); //mat.SetFloat("_inscatteringCoeff", inscatteringCoeff); mat.SetFloat("_extinctionCoeff", extinctionCoeff); mat.SetFloat("_global_alpha", postProcessingAlpha); mat.SetFloat("_Exposure", postProcessExposure); mat.SetFloat("_global_depth", postProcessDepth); mat.SetFloat("_global_depth2", totalscale2); mat.SetFloat("_Scale", postProcessingScale); // mat.SetFloat("_Scale", 1); // mat.SetMatrix ("_Globals_CameraToWorld", cams [0].worldToCameraMatrix.inverse); if (debugSettings [1]) { mat.SetMatrix ("_Globals_CameraToWorld", farCamera.worldToCameraMatrix.inverse); } else { mat.SetMatrix ("_Globals_CameraToWorld", scaledSpaceCamera.worldToCameraMatrix.inverse); } if (debugSettings [2]) { mat.SetVector ("_CameraForwardDirection", farCamera.transform.forward); } else { mat.SetVector ("_CameraForwardDirection", scaledSpaceCamera.transform.forward); } if (debugSettings [3]) { mat.SetVector ("_Globals_Origin", /*Vector3.zero-*/parentCelestialBody.transform.position); } else { Transform celestialTransform = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == parentCelestialBody.name); Vector3 idek =celestialTransform.position; mat.SetVector ("_Globals_Origin", /*Vector3.zero-*/ idek); } //mat.SetVector("betaR", m_betaR / (Rg / m_radius)); // mat.SetVector("betaR", m_betaR / (postProcessDepth)); mat.SetVector("betaR", new Vector4(2.9e-3f, 0.675e-2f, 1.655e-2f, 0.0f)); mat.SetFloat("mieG", 0.4f); mat.SetVector("SUN_DIR", /*Vector3.zero-*/m_manager.GetSunNodeDirection()); mat.SetFloat("SUN_INTENSITY", sun_intensity); }
/// <summary> /// Sets the simulation upscaling correction paramters to the given material. /// </summary> /// <param name="mat"></param> protected void SetSimulationTransformCorrection(Material mat) { mat.SetMatrix("_TFX_World2Object", Matrix4x4.TRS(this.transform.position, this.transform.rotation, Vector3.one).inverse); // this.transform.worldToLocalMatrix); mat.SetMatrix("_TFX_ScaleMatrix", Matrix4x4.Scale(this.transform.localScale)); mat.SetMatrix("_TFX_Object2World", Matrix4x4.TRS(this.transform.position, this.transform.rotation, Vector3.one)); // this.transform.localToWorldMatrix); Vector3 scale = new Vector3 ( 1 / this.transform.lossyScale.x, 1 / this.transform.lossyScale.y, 1 / this.transform.lossyScale.z ); mat.SetVector("_TFX_PositionOffset", Vector3.Scale(this.transform.position, scale) - this.transform.position); }
public void SetUniforms(Material mat) { //Sets uniforms that this or other gameobjects may need if(mat == null) return; //mat.SetFloat ("atmosphereGlobalScale", atmosphereGlobalScale); mat.SetFloat ("_Alpha_Cutoff", alphaCutoff); mat.SetFloat ("_Alpha_Global", alphaGlobal); mat.SetFloat("scale",atmosphereGlobalScale); mat.SetFloat("Rg", Rg*atmosphereGlobalScale); mat.SetFloat("Rt", Rt*atmosphereGlobalScale); mat.SetFloat("RL", RL*atmosphereGlobalScale); // if (debugSettings [5]) if(!MapView.MapIsEnabled) { mat.SetFloat ("_Globals_ApparentDistance", apparentDistance); } else { mat.SetFloat("_Globals_ApparentDistance", (float)(parentCelestialBody.Radius/100.2f)); } // if (debugSettings[1]) if(!MapView.MapIsEnabled) { mat.SetMatrix ("_Globals_WorldToCamera", farCamera.worldToCameraMatrix); mat.SetMatrix ("_Globals_CameraToWorld", farCamera.worldToCameraMatrix.inverse); } else { mat.SetMatrix ("_Globals_WorldToCamera", scaledSpaceCamera.worldToCameraMatrix); mat.SetMatrix ("_Globals_CameraToWorld", scaledSpaceCamera.worldToCameraMatrix.inverse); } mat.SetVector("betaR", m_betaR / 1000.0f); mat.SetFloat("mieG", Mathf.Clamp(m_mieG, 0.0f, 0.99f)); mat.SetTexture("_Sky_Transmittance", m_transmit); mat.SetTexture("_Sky_Inscatter", m_inscatter); mat.SetTexture("_Sky_Irradiance", m_irradiance); // mat.SetTexture("_Sky_Map", m_skyMap); mat.SetFloat("_Sun_Intensity", sun_intensity); mat.SetVector("_Sun_WorldSunDir", m_manager.getDirectionToSun().normalized); // mat.SetVector("_Sun_WorldSunDir", m_manager.getDirectionToSun()); // //copied from m_manager's set uniforms Matrix4x4 p; // if (debugSettings [2]) if(!MapView.MapIsEnabled) { p = farCamera.projectionMatrix; } else { p = scaledSpaceCamera.projectionMatrix; } m_cameraToScreenMatrix = new Matrix4x4d (p); mat.SetMatrix ("_Globals_CameraToScreen", m_cameraToScreenMatrix.ToMatrix4x4 ()); mat.SetMatrix ("_Globals_ScreenToCamera", m_cameraToScreenMatrix.Inverse ().ToMatrix4x4 ()); // if (debugSettings [3]) { mat.SetVector ("_Globals_WorldCameraPos", farCamera.transform.position); } // else // { // Vector3 newpos= ScaledSpace.ScaledToLocalSpace(scaledSpaceCamera.transform.position); // // m_skyMaterial.SetVector ("_Globals_WorldCameraPos", scaledSpaceCamera.transform.position); // mat.SetVector ("_Globals_WorldCameraPos", newpos); // } // if (debugSettings [4]) if(!MapView.MapIsEnabled) { mat.SetVector ("_Globals_Origin", parentCelestialBody.transform.position); } else { Transform celestialTransform = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == parentCelestialBody.name); Vector3 idek =celestialTransform.position; mat.SetVector ("_Globals_Origin", idek); } mat.SetFloat ("_Exposure", m_HDRExposure); }
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; } } }
public void SetValues(Material m, IEnumerable<StoredValue> values) { foreach(var v in values) { switch(v.Property.type) { case MaterialProperty.PropertyType.color: m.SetColor(v.Property.name, (Color)v.Value); break; case MaterialProperty.PropertyType.real: m.SetFloat(v.Property.name, (float)v.Value); break; case MaterialProperty.PropertyType.texture: m.SetTexture(v.Property.name, (Texture)v.Value); break; case MaterialProperty.PropertyType.vector: m.SetVector(v.Property.name, (Vector4)v.Value); break; case MaterialProperty.PropertyType.textureOffset: m.SetTextureOffset(v.Property.name, (Vector2)v.Value); break; case MaterialProperty.PropertyType.textureScale: m.SetTextureScale(v.Property.name, (Vector2)v.Value); break; case MaterialProperty.PropertyType.matrix: m.SetMatrix(v.Property.name, (Matrix4x4)v.Value); break; } } }
private void DrawField(Material material) { material.SetPass(0); material.SetMatrix("object_to_world", transform.localToWorldMatrix); Graphics.DrawProcedural(MeshTopology.Points, PointCount); }
public void updateStuff (Material oceanMaterial, Camera inCamera) { //Calculates the required data for the projected grid // compute ltoo = localToOcean transform, where ocean frame = tangent space at // camera projection on sphere radius in local space Matrix4x4 ctol1 = inCamera.cameraToWorldMatrix; //position relative to kerbin // Vector3d tmp = (inCamera.transform.position) - m_manager.parentCelestialBody.transform.position; Matrix4x4d cameraToWorld = new Matrix4x4d (ctol1.m00, ctol1.m01, ctol1.m02, ctol1.m03, ctol1.m10, ctol1.m11, ctol1.m12, ctol1.m13, ctol1.m20, ctol1.m21, ctol1.m22, ctol1.m23, ctol1.m30, ctol1.m31, ctol1.m32, ctol1.m33); //Looking back, I have no idea how I figured this crap out Vector4 translation = m_manager.parentCelestialBody.transform.worldToLocalMatrix.inverse.GetColumn (3); Matrix4x4d worldToLocal = new Matrix4x4d (1, 0, 0, -translation.x, 0, 1, 0, -translation.y, 0, 0, 1, -translation.z, 0, 0, 0, 1); Matrix4x4d camToLocal = worldToLocal * cameraToWorld; // camera in local space relative to planet's origin Vector3d2 cl = new Vector3d2 (); cl = camToLocal * Vector3d2.Zero (); // double radius = m_manager.GetRadius (); double radius = m_manager.GetRadius ()+m_oceanLevel; // Vector3d2 ux, uy, uz, oo; uz = cl.Normalized (); // unit z vector of ocean frame, in local space if (m_oldlocalToOcean != Matrix4x4d.Identity ()) { ux = (new Vector3d2 (m_oldlocalToOcean.m [1, 0], m_oldlocalToOcean.m [1, 1], m_oldlocalToOcean.m [1, 2])).Cross (uz).Normalized (); } else { ux = Vector3d2.UnitZ ().Cross (uz).Normalized (); } uy = uz.Cross (ux); // unit y vector oo = uz * (radius); // origin of ocean frame, in local space //local to ocean transform //computed from oo and ux, uy, uz should be correct Matrix4x4d localToOcean = new Matrix4x4d ( ux.x, ux.y, ux.z, -ux.Dot (oo), uy.x, uy.y, uy.z, -uy.Dot (oo), uz.x, uz.y, uz.z, -uz.Dot (oo), 0.0, 0.0, 0.0, 1.0); Matrix4x4d cameraToOcean = localToOcean * camToLocal; //Couldn't figure out how to change the wind's direction in all that math so I tried to do the easy thing //And Rotated the ocean and the sun //This didn't work //deleted rotation code here Vector3d2 delta = new Vector3d2 (0, 0, 0); if (m_oldlocalToOcean != Matrix4x4d.Identity ()) { delta = localToOcean * (m_oldlocalToOcean.Inverse () * Vector3d2.Zero ()); m_offset += delta; } m_oldlocalToOcean = localToOcean; Matrix4x4d ctos = ModifiedProjectionMatrix (inCamera); Matrix4x4d stoc = ctos.Inverse (); Vector3d2 oc = cameraToOcean * Vector3d2.Zero (); h = oc.z; Vector4d stoc_w = (stoc * Vector4d.UnitW ()).XYZ0 (); Vector4d stoc_x = (stoc * Vector4d.UnitX ()).XYZ0 (); Vector4d stoc_y = (stoc * Vector4d.UnitY ()).XYZ0 (); Vector3d2 A0 = (cameraToOcean * stoc_w).XYZ (); Vector3d2 dA = (cameraToOcean * stoc_x).XYZ (); Vector3d2 B = (cameraToOcean * stoc_y).XYZ (); Vector3d2 horizon1, horizon2; // Vector3d2 offset = new Vector3d2 (-m_offset.x, -m_offset.y, h); offset = new Vector3d2 (-m_offset.x, -m_offset.y, h); // Vector3d2 offset = new Vector3d2 (0f, 0f, h); double h1 = h * (h + 2.0 * radius); double h2 = (h + radius) * (h + radius); double alpha = B.Dot (B) * h1 - B.z * B.z * h2; double beta0 = (A0.Dot (B) * h1 - B.z * A0.z * h2) / alpha; double beta1 = (dA.Dot (B) * h1 - B.z * dA.z * h2) / alpha; double gamma0 = (A0.Dot (A0) * h1 - A0.z * A0.z * h2) / alpha; double gamma1 = (A0.Dot (dA) * h1 - A0.z * dA.z * h2) / alpha; double gamma2 = (dA.Dot (dA) * h1 - dA.z * dA.z * h2) / alpha; horizon1 = new Vector3d2 (-beta0, -beta1, 0.0); horizon2 = new Vector3d2 (beta0 * beta0 - gamma0, 2.0 * (beta0 * beta1 - gamma1), beta1 * beta1 - gamma2); Vector3d2 sunDir = new Vector3d2 (m_manager.getDirectionToSun ().normalized); Vector3d2 oceanSunDir = localToOcean.ToMatrix3x3d () * sunDir; oceanMaterial.SetVector ("_Ocean_SunDir", oceanSunDir.ToVector3 ()); oceanMaterial.SetVector ("_Ocean_Horizon1", horizon1.ToVector3 ()); oceanMaterial.SetVector ("_Ocean_Horizon2", horizon2.ToVector3 ()); oceanMaterial.SetMatrix ("_Ocean_CameraToOcean", cameraToOcean.ToMatrix4x4 ()); oceanMaterial.SetMatrix ("_Ocean_OceanToCamera", cameraToOcean.Inverse ().ToMatrix4x4 ()); oceanMaterial.SetMatrix ("_Globals_CameraToScreen", ctos.ToMatrix4x4 ()); oceanMaterial.SetMatrix ("_Globals_ScreenToCamera", stoc.ToMatrix4x4 ()); oceanMaterial.SetVector ("_Ocean_CameraPos", offset.ToVector3 ()); oceanMaterial.SetVector ("_Ocean_Color", new Color(m_oceanUpwellingColor.x,m_oceanUpwellingColor.y,m_oceanUpwellingColor.z) /* *0.1f */); oceanMaterial.SetVector ("_Ocean_ScreenGridSize", new Vector2 ((float)m_resolution / (float)Screen.width, (float)m_resolution / (float)Screen.height)); oceanMaterial.SetFloat ("_Ocean_Radius", (float)radius); // oceanMaterial.SetFloat("scale", 1); oceanMaterial.SetFloat ("scale", oceanScale); oceanMaterial.SetFloat ("_OceanAlpha", oceanAlpha); oceanMaterial.SetFloat ("alphaRadius", alphaRadius); oceanMaterial.SetFloat ("sunReflectionMultiplier", sunReflectionMultiplier); oceanMaterial.SetFloat ("skyReflectionMultiplier", skyReflectionMultiplier); oceanMaterial.SetFloat ("seaRefractionMultiplier", seaRefractionMultiplier); m_manager.GetSkyNode ().SetOceanUniforms (oceanMaterial); }
/// <summary> /// Sets the self shadowmapping parameters of this light to the specified evaluation material. /// </summary> /// <param name="evalMaterial"></param> public void SetSelfShadowParameters(Material evalMaterial) { if (this.shadowMappingCamera == null) { Debug.LogError("SetSelfShadowParameters was called on a light which does not cast self shadows!"); return; } // Far-/near clipping plane evalMaterial.SetVector("_SelfShadowFarNear", new Vector2(this.shadowMappingCamera.farClipPlane, this.shadowMappingCamera.nearClipPlane)); // Calculate shadow matrix // Set shadow matrix evalMaterial.SetMatrix("_SelfShadowMatrix", GetShadowMatrix()); // Set other parameters evalMaterial.SetTexture("_SelfShadowMap", this.selfShadowMap); evalMaterial.SetFloat("_SelfShadowFiberSpacing", fiberSpacing); // TODO }
public static void RenderDistortion(Material material, RenderTexture source, RenderTexture destination, float angle, Vector3 center, float radius, int subdivisions) { RenderTexture.active = destination; angle *= Mathf.Deg2Rad; Matrix4x4 rotationMatrix = Matrix4x4.TRS(Vector3.zero, Quaternion.EulerAngles (0, 0, angle), Vector3.one); Vector4 pixelCenter = new Vector4 (source.width * center.x, source.height * center.y, 1, 1); radius *= source.height; material.SetMatrix("_RotationMatrix", rotationMatrix); material.SetVector("_Center", pixelCenter); material.SetFloat("_Radius", radius); material.SetFloat("_Angle", angle); material.SetTexture("_MainTex", source); GL.PushMatrix (); GL.LoadOrtho (); for (int i = 0; i < material.passCount; i++) { material.SetPass (i); ImageEffects.DrawGrid(subdivisions, subdivisions); } GL.PopMatrix (); }
private void InitMaterial(Material mat) { mat.SetVector("_SunDir", this.SunDir); mat.SetMatrix("_Moon_wtl", this.getMoonMatrix); mat.SetVector("_betaR", this.betaR_RayleighOffset); mat.SetVector("_betaM", this.BetaM); mat.SetVector("_SkyMultiplier", this.skyMultiplier); mat.SetFloat("_SunSize", 32f / this.SunSize); mat.SetVector("_mieConst", this.mieConst); mat.SetVector("_miePhase_g", this.miePhase_g); mat.SetVector("_GroundColor", this.bottomTint); mat.SetVector("_NightHorizonColor", this.getNightHorizonColor); mat.SetVector("_NightZenithColor", this.getNightZenithColor); mat.SetVector("_MoonInnerCorona", this.getMoonInnerCorona); mat.SetVector("_MoonOuterCorona", this.getMoonOuterCorona); mat.SetFloat("_MoonSize", this.MoonSize); mat.SetVector("_colorCorrection", this.ColorCorrection); if (this.Tonemapping) { } mat.SetFloat("_OuterSpaceIntensity", this.OuterSpaceIntensity); if (this.starMaterial != null) { this.starMaterial.SetFloat("StarIntensity", this.starBrightness); } }
void InitMaterial(Material mat) { mat.SetVector ("_SunDir", SunDir); mat.SetMatrix ("_Moon_wtl", getMoonMatrix); mat.SetVector ("_betaR", BetaR); mat.SetVector ("_betaM", BetaM); // x = Sunset, y = Day, z = Rayleigh, w = Night mat.SetVector ("_SkyMultiplier", skyMultiplier); mat.SetFloat ("_SunSize", 24.0f / SunSize); mat.SetVector ("_mieConst", mieConst); mat.SetVector ("_miePhase_g", miePhase_g); mat.SetVector ("_SkyTint", skyTint); mat.SetVector ("_GroundColor", bottomTint); mat.SetVector ("_NightHorizonColor", NightHorizonColor * nt); mat.SetVector ("_NightZenithColor", getNightZenithColor); mat.SetVector ("_MoonInnerCorona", getMoonInnerCorona); mat.SetVector ("_MoonOuterCorona", getMoonOuterCorona); mat.SetFloat ("_MoonSize", MoonSize); mat.SetVector ("_colorCorrection", ColorCorrection); mat.shaderKeywords = hdrMode.ToArray (); if (EnableNightSky) mat.DisableKeyword("NIGHTSKY_OFF"); else mat.EnableKeyword("NIGHTSKY_OFF"); mat.SetFloat ("_OuterSpaceIntensity", OuterSpaceIntensity); starMaterial.SetFloat ("StarIntensity", starBrightness); }
private void copy_internal(Texture dstCube, Texture srcCube, bool dstRGBM, bool srcRGBM, bool linear, Camera cam, Material skyMat, Matrix4x4 matrix) { bool prevHDR = cam.hdr; CameraClearFlags prevFlags = cam.clearFlags; int prevMask = cam.cullingMask; cam.clearFlags = CameraClearFlags.Skybox; cam.cullingMask = 0; cam.hdr = !dstRGBM; // might need HDR camera buffer when we're not rendering to RGBM encoded pixels skyMat.name = "Internal HDR to RGBM Skybox"; skyMat.shader = Shader.Find("Hidden/Marmoset/RGBM Cube"); //toggleKeywordPair("MARMO_LINEAR", "MARMO_GAMMA", linear); toggleKeywordPair("MARMO_RGBM_INPUT_ON", "MARMO_RGBM_INPUT_OFF", srcRGBM); toggleKeywordPair("MARMO_RGBM_OUTPUT_ON", "MARMO_RGBM_OUTPUT_OFF", dstRGBM); skyMat.SetMatrix("_SkyMatrix", matrix); skyMat.SetTexture("_CubeHDR", srcCube); Material prevSkyMat = UnityEngine.RenderSettings.skybox; UnityEngine.RenderSettings.skybox = skyMat; RenderTexture RT = dstCube as RenderTexture; Cubemap cube = dstCube as Cubemap; if(RT) cam.RenderToCubemap(RT); else if(cube) cam.RenderToCubemap(cube); cam.hdr = prevHDR; cam.clearFlags = prevFlags; cam.cullingMask = prevMask; UnityEngine.RenderSettings.skybox = prevSkyMat; }
void UpdatePostProcessMaterial(Material mat) { //mat.SetFloat ("atmosphereGlobalScale", atmosphereGlobalScale); // mat.SetFloat ("Rg", Rg*atmosphereGlobalScale*postProcessingScale); // mat.SetFloat("Rt", Rt*atmosphereGlobalScale*postProcessingScale); // mat.SetFloat("Rl", RL*atmosphereGlobalScale*postProcessingScale); totalscale = 1; totalscale2 = 1; for (int j = 0; j < 5; j++) { totalscale = totalscale * additionalScales[j]; } for (int j = 6; j < 10; j++) { totalscale2 = totalscale2 * additionalScales[j]; } mat.SetFloat("Rg", Rg * atmosphereGlobalScale * totalscale); mat.SetFloat("Rt", Rt * atmosphereGlobalScale * totalscale); mat.SetFloat("Rl", RL * atmosphereGlobalScale * totalscale); //mat.SetFloat("_inscatteringCoeff", inscatteringCoeff); mat.SetFloat("_extinctionCoeff", extinctionCoeff); mat.SetFloat("_global_alpha", postProcessingAlpha); mat.SetFloat("_Exposure", postProcessExposure); mat.SetFloat("_global_depth", postProcessDepth); mat.SetFloat("_global_depth2", totalscale2); mat.SetFloat("terrain_reflectance", terrainReflectance); mat.SetFloat("_irradianceFactor", irradianceFactor); mat.SetFloat("_Scale", postProcessingScale); // mat.SetFloat("_Scale", 1); mat.SetFloat("_Ocean_Sigma", oceanSigma); mat.SetFloat("_Ocean_Threshold", _Ocean_Threshold); // mat.SetMatrix ("_Globals_CameraToWorld", cams [0].worldToCameraMatrix.inverse); if (debugSettings[1]) { mat.SetMatrix("_Globals_CameraToWorld", farCamera.worldToCameraMatrix.inverse); } else { mat.SetMatrix("_Globals_CameraToWorld", scaledSpaceCamera.worldToCameraMatrix.inverse); } if (debugSettings[2]) { mat.SetVector("_CameraForwardDirection", farCamera.transform.forward); } else { mat.SetVector("_CameraForwardDirection", scaledSpaceCamera.transform.forward); } if (debugSettings[3]) { mat.SetVector("_Globals_Origin", /*Vector3.zero-*/ parentCelestialBody.transform.position); } else { // celestialTransform = ScaledSpace.Instance.scaledSpaceTransforms.Single(t => t.name == parentCelestialBody.name); celestialTransform = ParentPlanetTransform; idek = celestialTransform.position; mat.SetVector("_Globals_Origin", /*Vector3.zero-*/ idek); } //mat.SetVector("betaR", m_betaR / (Rg / m_radius)); // mat.SetVector("betaR", m_betaR / (postProcessDepth)); mat.SetVector("betaR", new Vector4(2.9e-3f, 0.675e-2f, 1.655e-2f, 0.0f)); mat.SetFloat("mieG", 0.4f); mat.SetVector("SUN_DIR", m_manager.GetSunNodeDirection()); mat.SetFloat("SUN_INTENSITY", sunIntensity); Matrix4x4 ctol1 = farCamera.cameraToWorldMatrix; Vector3d tmp = (farCamera.transform.position) - m_manager.parentCelestialBody.transform.position; Matrix4x4d viewMat = new Matrix4x4d(ctol1.m00, ctol1.m01, ctol1.m02, tmp.x, ctol1.m10, ctol1.m11, ctol1.m12, tmp.y, ctol1.m20, ctol1.m21, ctol1.m22, tmp.z, ctol1.m30, ctol1.m31, ctol1.m32, ctol1.m33); // print ("viewmat"); // print (viewMat.ToMatrix4x4()); // Matrix4x4 viewMat = farCamera.worldToCameraMatrix; viewMat = viewMat.Inverse(); Matrix4x4 projMat = GL.GetGPUProjectionMatrix(farCamera.projectionMatrix, false); // projMat.m23 = projMat.m23 * 0.5f; // print ("projmat"); // print (projMat); Matrix4x4 viewProjMat = (projMat * viewMat.ToMatrix4x4()); mat.SetMatrix("_ViewProjInv", viewProjMat.inverse); // mat.SetMatrix("_ViewToWorld", viewMat.ToMatrix4x4()); // // var lpoints = RecalculateFrustrumPoints(farCamera); // mat.SetVector("_FrustrumPoints", new Vector4( // lpoints[4].x,lpoints[5].x,lpoints[5].y,lpoints[6].y)); // // mat.SetFloat("_CameraFar", farCamera.farClipPlane); }