public void updateStuff(Material oceanMaterial, Camera inCamera) { // m_manager.GetSkyNode ().SetOceanUniforms (m_oceanMaterial); //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; 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 //I probably did the math wrong anyway and it worked by sheer luck and incessant tries // Vector4 translation = m_manager.parentCelestialBody.transform.localToWorldMatrix.GetColumn (3); Vector3d translation = m_manager.parentCelestialBody.position; 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; Matrix4x4d localToCam = camToLocal.Inverse(); // camera in local space relative to planet's origin Vector3d2 cl = new Vector3d2(); cl = camToLocal * Vector3d2.Zero(); double radius = m_manager.GetRadius() + m_oceanLevel; 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; Matrix4x4d worldToOcean = localToOcean * worldToLocal; Vector3d2 delta = new Vector3d2(0, 0, 0); if (m_oldlocalToOcean != Matrix4x4d.Identity()) { delta = localToOcean * (m_oldlocalToOcean.Inverse() * Vector3d2.Zero()); m_offset += delta; } //reset offset when bigger than 20000 to avoid floating point issues when later casting the offset to float if (Mathf.Max(Mathf.Abs((float)m_offset.x), Mathf.Abs((float)m_offset.y)) > 20000f) { m_offset.x = 0.0; m_offset.y = 0.0; } m_oldlocalToOcean = localToOcean; // Matrix4x4d ctos = ModifiedProjectionMatrix (inCamera); //moved to command buffer // Matrix4x4d stoc = ctos.Inverse (); Vector3d2 oc = cameraToOcean * Vector3d2.Zero(); h = oc.z; // m_skyMaterialLocal.EnableKeyword ("ECLIPSES_ON"); // m_skyMaterialLocal.DisableKeyword ("ECLIPSES_OFF"); offset = new Vector3d2(-m_offset.x, -m_offset.y, h); //old horizon code //This breaks down when you tilt the camera by 90 degrees in any direction //I made some new horizon code down, scroll down // 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; // // 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.SetMatrix(ShaderProperties._Globals_CameraToWorld_PROPERTY, cameraToWorld.ToMatrix4x4()); oceanMaterial.SetVector(ShaderProperties._Ocean_SunDir_PROPERTY, oceanSunDir.ToVector3()); oceanMaterial.SetMatrix(ShaderProperties._Ocean_CameraToOcean_PROPERTY, cameraToOcean.ToMatrix4x4()); oceanMaterial.SetMatrix(ShaderProperties._Ocean_OceanToCamera_PROPERTY, cameraToOcean.Inverse().ToMatrix4x4()); // oceanMaterial.SetMatrix (ShaderProperties._Globals_CameraToScreen_PROPERTY, ctos.ToMatrix4x4 ()); // oceanMaterial.SetMatrix (ShaderProperties._Globals_ScreenToCamera_PROPERTY, stoc.ToMatrix4x4 ()); oceanMaterial.SetMatrix(ShaderProperties._Globals_WorldToOcean_PROPERTY, worldToOcean.ToMatrix4x4()); oceanMaterial.SetMatrix(ShaderProperties._Globals_OceanToWorld_PROPERTY, worldToOcean.Inverse().ToMatrix4x4()); oceanMaterial.SetVector(ShaderProperties._Ocean_CameraPos_PROPERTY, offset.ToVector3()); //oceanMaterial.SetVector (ShaderProperties._Ocean_Color_PROPERTY, new Color (m_oceanUpwellingColor.x, m_oceanUpwellingColor.y, m_oceanUpwellingColor.z)); oceanMaterial.SetVector(ShaderProperties._Ocean_Color_PROPERTY, m_oceanUpwellingColor); oceanMaterial.SetVector("_Underwater_Color", m_UnderwaterColor); oceanMaterial.SetVector(ShaderProperties._Ocean_ScreenGridSize_PROPERTY, new Vector2((float)m_resolution / (float)Screen.width, (float)m_resolution / (float)Screen.height)); oceanMaterial.SetFloat(ShaderProperties._Ocean_Radius_PROPERTY, (float)(radius + m_oceanLevel)); // oceanMaterial.SetFloat("scale_PROPERTY, 1); oceanMaterial.SetFloat(ShaderProperties.scale_PROPERTY, oceanScale); oceanMaterial.SetFloat(ShaderProperties._OceanAlpha_PROPERTY, oceanAlpha); oceanMaterial.SetFloat(ShaderProperties.alphaRadius_PROPERTY, alphaRadius); oceanMaterial.SetFloat(ShaderProperties._GlobalOceanAlpha_PROPERTY, m_manager.m_skyNode.interpolatedSettings._GlobalOceanAlpha); m_manager.GetSkyNode().SetOceanUniforms(oceanMaterial); //horizon calculations //these are used to find where the horizon line is on screen //and "clamp" vertexes that are above it back to it //as the grid is projected on the whole screen, vertexes over the horizon need to be dealt with //simply passing a flag to drop fragments or moving these vertexes offscreen will cause issues //as the horizon line can be between two vertexes and the horizon line will appear "pixelated" //as whole chunks go missing //these need to be done here //1)for double precision //2)for speed Vector3d2 sphereDir = (localToCam * Vector3d2.Zero()).Normalized(); //direction to center of planet double OHL = (localToCam * Vector3d2.Zero()).Magnitude(); //distance to center of planet double rHorizon = Math.Sqrt((OHL)*(OHL)-(radius * radius)); //distance to the horizon, i.e distance to ocean sphere tangent //basic geometry yo //Theta=angle to horizon, now all that is left to do is check the viewdir against this angle in the shader double cosTheta = rHorizon / (OHL); double sinTheta = Math.Sqrt(1 - cosTheta * cosTheta); oceanMaterial.SetVector(ShaderProperties.sphereDir_PROPERTY, sphereDir.ToVector3()); oceanMaterial.SetFloat(ShaderProperties.cosTheta_PROPERTY, (float)cosTheta); oceanMaterial.SetFloat(ShaderProperties.sinTheta_PROPERTY, (float)sinTheta); if (Core.Instance.usePlanetShine) { Matrix4x4 planetShineSourcesMatrix = m_manager.m_skyNode.planetShineSourcesMatrix; Vector3d2 oceanSunDir2; for (int i = 0; i < 4; i++) { Vector4 row = planetShineSourcesMatrix.GetRow(i); oceanSunDir2 = localToOcean.ToMatrix3x3d() * new Vector3d2(row.x, row.y, row.z); planetShineSourcesMatrix.SetRow(i, new Vector4((float)oceanSunDir2.x, (float)oceanSunDir2.y, (float)oceanSunDir2.z, row.w)); } oceanMaterial.SetMatrix("planetShineSources", planetShineSourcesMatrix); oceanMaterial.SetMatrix("planetShineRGB", m_manager.m_skyNode.planetShineRGBMatrix); } m_manager.GetSkyNode().UpdatePostProcessMaterial(underwaterPostProcessingMaterial); underwaterPostProcessingMaterial.SetVector("_Underwater_Color", m_UnderwaterColor); m_oceanMaterial.SetFloat("refractionIndex", refractionIndex); m_oceanMaterial.SetFloat("transparencyDepth", transparencyDepth); m_oceanMaterial.SetFloat("darknessDepth", darknessDepth); underwaterPostProcessingMaterial.SetFloat("transparencyDepth", transparencyDepth); underwaterPostProcessingMaterial.SetFloat("darknessDepth", darknessDepth); //underwaterPostProcessingMaterial.SetFloat ("refractionIndex", refractionIndex); }
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); }
public void OnPreRender() { sunViewPortPos = inCore.scaledSpaceCamera.WorldToViewportPoint (ScaledSpace.LocalToScaledSpace(inCore.sunCelestialBody.transform.position)); float dist = (float)(inCore.scaledSpaceCamera.transform.position - ScaledSpace.LocalToScaledSpace(inCore.sunCelestialBody.transform.position)) .magnitude; sunGlareScale = dist / 2266660f; //if dist> 0.75 sunglarefadedistance -->1 //if dist < 0.25*sunglarefadedistance -->0 //else values smoothstepped in between sunGlareFade = Mathf.SmoothStep(0, 1, (dist / sunGlareFadeDistance) - 0.25f); hitStatus = false; // if (!MapView.MapIsEnabled && !(HighLogic.LoadedScene == GameScenes.TRACKSTATION)) if (!MapView.MapIsEnabled) { hitStatus = Physics.Raycast(inCore.farCamera.transform.position, (inCore.sunCelestialBody.transform.position - inCore.farCamera.transform.position).normalized, out hit, Mathf.Infinity, (int)((1 << 15) + (1 << 0))); if (!hitStatus) { hitStatus = Physics.Raycast(inCore.scaledSpaceCamera.transform.position, (ScaledSpace.LocalToScaledSpace(inCore.sunCelestialBody.transform.position) - inCore.scaledSpaceCamera.transform.position) .normalized, out hit, Mathf.Infinity, (int)((1 << 10))); } } else { hitStatus = Physics.Raycast(inCore.scaledSpaceCamera.transform.position, (ScaledSpace.LocalToScaledSpace(inCore.sunCelestialBody.transform.position) - inCore.transform.position).normalized, out hit, Mathf.Infinity, (int)((1 << 10))); } eclipse = hitStatus; sunglareMaterial.SetVector("sunViewPortPos", sunViewPortPos); sunglareMaterial.SetFloat("aspectRatio", inCore.scaledSpaceCamera.aspect); sunglareMaterial.SetFloat("sunGlareScale", sunGlareScale); sunglareMaterial.SetFloat("sunGlareFade", sunGlareFade); //check for active PQS // if (!transmittanceSet && inCore.pqsEnabled && !(HighLogic.LoadedScene == GameScenes.TRACKSTATION)) if (!transmittanceSet && inCore.pqsEnabled) { if ((lastActivePQS != inCore.managerWactivePQS) || !(lastActivePQS)) { sunglareMaterial.SetFloat("Rg", inCore.managerWactivePQS.m_skyNode.Rg); sunglareMaterial.SetFloat("Rt", inCore.managerWactivePQS.m_skyNode.Rt); sunglareMaterial.SetTexture("_Sky_Transmittance", inCore.managerWactivePQS.m_skyNode.m_transmit); lastActivePQS = inCore.managerWactivePQS; Debug.Log("[Scatterer] Sunflare: loaded new transmittance table"); } sunglareMaterial.SetFloat("useTransmittance", 1f); transmittanceSet = true; } if (transmittanceSet) { if (!inCore.pqsEnabled) { sunglareMaterial.SetFloat("useTransmittance", 0f); transmittanceSet = false; } else { if (!MapView.MapIsEnabled) { sunglareMaterial.SetVector("_Globals_WorldCameraPos", inCore.farCamera.transform.position - lastActivePQS.parentCelestialBody.transform.position); } else { sunglareMaterial.SetVector("_Globals_WorldCameraPos", (Vector3)ScaledSpace.ScaledToLocalSpace(inCore.scaledSpaceCamera.transform.position) - lastActivePQS.parentCelestialBody.transform.position); } sunglareMaterial.SetVector("_Sun_WorldSunDir", lastActivePQS.getDirectionToSun().normalized); } } }