public void UpdateMatrices() { var worldToLocal = new Matrix4x4d(1.0, 0.0, 0.0, -Origin.x, 0.0, 1.0, 0.0, -Origin.y, 0.0, 0.0, 1.0, -Origin.z, 0.0, 0.0, 0.0, 1.0); var cameraToLocal = worldToLocal * CameraToWorld; var localToCamera = cameraToLocal.Inverse(); var oceanFrame = cameraToLocal * Vector3d.zero; var radius = ParentBody.Size; uz = oceanFrame.Normalized(); ux = OldLocalToOcean != Matrix4x4d.identity ? new Vector3d(OldLocalToOcean.m[1, 0], OldLocalToOcean.m[1, 1], OldLocalToOcean.m[1, 2]).Cross(uz).Normalized() : Vector3d.forward.Cross(uz).Normalized(); uy = uz.Cross(ux); oo = (uz * radius); var 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); var cameraToOcean = localToOcean * cameraToLocal; //var worldToOcean = localToOcean * worldToLocal; if (OldLocalToOcean != Matrix4x4d.identity) { var delta = localToOcean * (OldLocalToOcean.Inverse() * Vector3d.zero); Offset += VectorHelper.MakeFrom(delta, 0.0f); } if (Mathf.Max(Mathf.Abs(Offset.x), Mathf.Abs(Offset.y)) > 20000.0f) { Offset.x = 0.0f; Offset.y = 0.0f; } OldLocalToOcean = localToOcean; var oc = cameraToOcean * Vector3d.zero; H = oc.z; if (double.IsNaN(H)) { H = 1.0; } var offset = new Vector3d(-Offset.x, -Offset.y, H); // TODO : Up to four light sources support... var sun = ParentBody.Suns.FirstOrDefault(); var sunDirection = sun != null?ParentBody.GetSunDirection(sun) : Vector3.zero; var oceanSunDirection = localToOcean.ToMatrix3x3d() * sunDirection; var sphereDirection = (localToCamera * Vector3d.zero).Normalized(); // Direction to center of planet var OHL = (localToCamera * Vector3d.zero).Magnitude(); // Distance to center of planet var rHorizon = Math.Sqrt(OHL * OHL - radius * radius); // Distance to the horizon, i.e distance to ocean sphere tangent // Theta equals angle to horizon, now all that is left to do is check the view direction against this angle var cosTheta = rHorizon / OHL; var sinTheta = Math.Sqrt(1.0 - cosTheta * cosTheta); var oceanGridResolution = GodManager.Instance.OceanGridResolution; OceanMaterial.SetVector("_SphereDirection", sphereDirection.ToVector3()); OceanMaterial.SetFloat("_CosTheta", (float)cosTheta); OceanMaterial.SetFloat("_SinTheta", (float)sinTheta); OceanMaterial.SetVector("_Ocean_SunDir", oceanSunDirection.ToVector3()); OceanMaterial.SetMatrix("_Ocean_CameraToOcean", cameraToOcean.ToMatrix4x4()); OceanMaterial.SetMatrix("_Ocean_OceanToCamera", cameraToOcean.Inverse().ToMatrix4x4()); OceanMaterial.SetMatrix("_Ocean_WorldToLocal", worldToLocal.ToMatrix4x4()); OceanMaterial.SetMatrix("_Ocean_LocalToOcean", localToOcean.ToMatrix4x4()); OceanMaterial.SetVector("_Ocean_CameraPos", offset.ToVector3()); OceanMaterial.SetVector("_Ocean_Color", UpwellingColor * 0.1f); OceanMaterial.SetVector("_Ocean_ScreenGridSize", new Vector2((float)oceanGridResolution / (float)Screen.width, (float)oceanGridResolution / (float)Screen.height)); OceanMaterial.SetFloat("_Ocean_Radius", radius); OceanMaterial.SetFloat("_Ocean_Wave_Level", OceanWaveLevel); // TODO : Complete ocean matrices calculation for a cyllindrical worlds... }
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 updateCameraSpecificUniforms(Material oceanMaterial, Camera inCamera) { cameraToScreen = GL.GetGPUProjectionMatrix(inCamera.projectionMatrix, false); screenToCamera = cameraToScreen.inverse; m_oceanMaterial.SetMatrix("_Globals_CameraToScreen", cameraToScreen); m_oceanMaterial.SetMatrix("_Globals_ScreenToCamera", screenToCamera); //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 //move these to dedicated projected grid class? 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); Vector3d translation = m_manager.parentLocalTransform.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(); 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; 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()); //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(); //vector to center of planet double OHL = sphereDir.Magnitude(); //distance to center of planet sphereDir = sphereDir.Normalized(); //direction 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); //planetshine properties if (Scatterer.Instance.mainSettings.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); //this can become shared code to not recompute oceanMaterial.SetMatrix("planetShineRGB", m_manager.m_skyNode.planetShineRGBMatrix); } if (!ReferenceEquals(causticsShadowMaskModulator, null)) { causticsShadowMaskModulator.CausticsShadowMaskModulateMaterial.SetMatrix("CameraToWorld", inCamera.cameraToWorldMatrix); causticsShadowMaskModulator.CausticsShadowMaskModulateMaterial.SetMatrix("WorldToLight", Scatterer.Instance.sunLight.transform.worldToLocalMatrix); causticsShadowMaskModulator.CausticsShadowMaskModulateMaterial.SetVector("PlanetOrigin", m_manager.parentLocalTransform.position); float warpTime = (TimeWarp.CurrentRate > 1) ? (float)Planetarium.GetUniversalTime() : 0f; causticsShadowMaskModulator.CausticsShadowMaskModulateMaterial.SetFloat("warpTime", warpTime); } }
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); }
protected override void UpdateNode() { OceanMaterial.renderQueue = (int)RenderQueue + RenderQueueOffset; // Calculates the required data for the projected grid var c2w = (Matrix4x4d)GodManager.Instance.CameraToWorld; var cl = c2w * -Origin; // Camera in local space // TODO : Ocean origin var radius = planetoid.PlanetRadius; //Manager.IsDeformed() ? Manager.GetRadius() : 0.0f; if ((OceanType == OceanSurfaceType.Flat && cl.z > ZMin) || (radius > 0.0 && cl.Magnitude() > radius + ZMin) || (radius < 0.0 && (new Vector2d(cl.y, cl.z)).Magnitude() < -radius - ZMin)) { OldLocalToOcean = Matrix4x4d.Identity(); Offset = Vector4.zero; DrawOcean = false; return; } DrawOcean = true; Vector3d ux, uy, uz, oo; if (OceanType == OceanSurfaceType.Flat) { // Terrain ocean ux = Vector3d.UnitX(); uy = Vector3d.UnitY(); uz = Vector3d.UnitZ(); oo = new Vector3d(cl.x, cl.y, 0.0); } else { // Planet ocean uz = cl.Normalized(); // Unit z vector of ocean frame, in local space if (OldLocalToOcean != Matrix4x4d.Identity()) { ux = (new Vector3d(OldLocalToOcean.m[1, 0], OldLocalToOcean.m[1, 1], OldLocalToOcean.m[1, 2])).Cross(uz).Normalized(); } else { ux = Vector3d.UnitZ().Cross(uz).Normalized(); } uy = uz.Cross(ux); // Unit y vector oo = uz * radius; // Origin of ocean frame, in local space } // Compute l2o = LocalToOcean transform, where ocean frame = tangent space at camera projection on sphere radius in local space var l2o = 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); // Compute c2o = CameraToOcean transform var c2o = l2o * c2w; if (OldLocalToOcean != Matrix4x4d.Identity()) { var delta = l2o * (OldLocalToOcean.Inverse() * -Origin); // TODO : Ocean origin Offset += new Vector4((float)delta.x, (float)delta.y, (float)delta.z, 0.0f); } OldLocalToOcean = l2o; var stoc = (Matrix4x4d)GodManager.Instance.ScreenToCamera; var oc = c2o * Vector3d.zero; // TODO : Ocean origin var h = oc.z; var stoc_w = (stoc * Vector4d.UnitW()).XYZ0(); var stoc_x = (stoc * Vector4d.UnitX()).XYZ0(); var stoc_y = (stoc * Vector4d.UnitY()).XYZ0(); var A0 = (c2o * stoc_w).XYZ(); var dA = (c2o * stoc_x).XYZ(); var B = (c2o * stoc_y).XYZ(); var horizon1 = Vector3d.zero; var horizon2 = Vector3d.zero; var offset = new Vector3d(-Offset.x, -Offset.y, oc.z); if (OceanType == OceanSurfaceType.Flat) { // Terrain ocean horizon1 = new Vector3d(-(h * 1e-6 + A0.z) / B.z, -dA.z / B.z, 0.0); horizon2 = Vector3d.zero; } else { // Planet ocean var h1 = h * (h + 2.0 * radius); var h2 = (h + radius) * (h + radius); var alpha = B.Dot(B) * h1 - B.z * B.z * h2; var beta0 = (A0.Dot(B) * h1 - B.z * A0.z * h2) / alpha; var beta1 = (dA.Dot(B) * h1 - B.z * dA.z * h2) / alpha; var gamma0 = (A0.Dot(A0) * h1 - A0.z * A0.z * h2) / alpha; var gamma1 = (A0.Dot(dA) * h1 - A0.z * dA.z * h2) / alpha; var gamma2 = (dA.Dot(dA) * h1 - dA.z * dA.z * h2) / alpha; horizon1 = new Vector3d(-beta0, -beta1, 0.0); horizon2 = new Vector3d(beta0 * beta0 - gamma0, 2.0 * (beta0 * beta1 - gamma1), beta1 * beta1 - gamma2); } var sunDirection = planetoid.Atmosphere.GetSunDirection(planetoid.Atmosphere.Suns[0]); var oceanSunDirection = l2o.ToMatrix3x3d() * sunDirection; OceanMaterial.SetVector("_Ocean_SunDir", oceanSunDirection.ToVector3()); OceanMaterial.SetVector("_Ocean_Horizon1", horizon1.ToVector3()); OceanMaterial.SetVector("_Ocean_Horizon2", horizon2.ToVector3()); OceanMaterial.SetMatrix("_Ocean_CameraToOcean", c2o.ToMatrix4x4()); OceanMaterial.SetMatrix("_Ocean_OceanToCamera", c2o.Inverse().ToMatrix4x4()); OceanMaterial.SetVector("_Ocean_CameraPos", offset.ToVector3()); OceanMaterial.SetVector("_Ocean_Color", UpwellingColor * 0.1f); OceanMaterial.SetVector("_Ocean_ScreenGridSize", new Vector2((float)Resolution / (float)Screen.width, (float)Resolution / (float)Screen.height)); OceanMaterial.SetFloat("_Ocean_Radius", radius); // TODO : OCEAN //Manager.GetSkyNode().SetUniforms(OceanMaterial); //Manager.GetSunNode().SetUniforms(OceanMaterial); //Manager.SetUniforms(OceanMaterial); }
public virtual void UpdateNode() { //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 Matrix4x4d ctol = View.CameraToWorld; Vector3d cl = ctol * Vector3d.Zero; // camera in local space float radius = World.IsDeformed ? World.Radius : 0.0f; if ((radius == 0.0 && cl.z > m_zmin) || (radius > 0.0 && cl.Magnitude > radius + m_zmin) || (radius < 0.0 && (new Vector2d(cl.y, cl.z)).Magnitude < -radius - m_zmin)) { m_oldLtoo = Matrix4x4d.Identity; m_offset = Vector3d.Zero; DrawOcean = false; return; } DrawOcean = true; Vector3d ux, uy, uz, oo; if (radius == 0.0f) { //terrain ocean ux = Vector3d.UnitX; uy = Vector3d.UnitY; uz = Vector3d.UnitZ; oo = new Vector3d(cl.x, cl.y, 0.0); } else { // planet ocean uz = cl.Normalized; // unit z vector of ocean frame, in local space if (m_oldLtoo != Matrix4x4d.Identity) { ux = (new Vector3d(m_oldLtoo[1, 0], m_oldLtoo[1, 1], m_oldLtoo[1, 2])).Cross(uz).Normalized; } else { ux = Vector3d.UnitZ.Cross(uz).Normalized; } uy = uz.Cross(ux); // unit y vector oo = uz * radius; // origin of ocean frame, in local space } Matrix4x4d ltoo = new Matrix4x4d( ux.x, ux.y, ux.z, -Vector3d.Dot(ux, oo), uy.x, uy.y, uy.z, -Vector3d.Dot(uy, oo), uz.x, uz.y, uz.z, -Vector3d.Dot(uz, oo), 0.0, 0.0, 0.0, 1.0); // compute ctoo = cameraToOcean transform Matrix4x4d ctoo = ltoo * ctol; if (m_oldLtoo != Matrix4x4d.Identity) { Vector3d delta = ltoo * (m_oldLtoo.Inverse * Vector3d.Zero); m_offset += delta; } m_oldLtoo = ltoo; Matrix4x4d stoc = View.ScreenToCamera; Vector3d oc = ctoo * Vector3d.Zero; double h = oc.z; Vector4d stoc_w = (stoc * Vector4d.UnitW).xyz0; Vector4d stoc_x = (stoc * Vector4d.UnitX).xyz0; Vector4d stoc_y = (stoc * Vector4d.UnitY).xyz0; Vector3d A0 = (ctoo * stoc_w).xyz; Vector3d dA = (ctoo * stoc_x).xyz; Vector3d B = (ctoo * stoc_y).xyz; Vector3d horizon1, horizon2; Vector3d offset = new Vector3d(-m_offset.x, -m_offset.y, oc.z); if (radius == 0.0) { //Terrain ocean horizon1 = new Vector3d(-(h * 1e-6 + A0.z) / B.z, -dA.z / B.z, 0.0); horizon2 = Vector3d.Zero; } else { //Planet ocean double h1 = h * (h + 2.0 * radius); double h2 = (h + radius) * (h + radius); double alpha = Vector3d.Dot(B, B) * h1 - B.z * B.z * h2; double beta0 = (Vector3d.Dot(A0, B) * h1 - B.z * A0.z * h2) / alpha; double beta1 = (Vector3d.Dot(dA, B) * h1 - B.z * dA.z * h2) / alpha; double gamma0 = (Vector3d.Dot(A0, A0) * h1 - A0.z * A0.z * h2) / alpha; double gamma1 = (Vector3d.Dot(A0, dA) * h1 - A0.z * dA.z * h2) / alpha; double gamma2 = (Vector3d.Dot(dA, dA) * h1 - dA.z * dA.z * h2) / alpha; horizon1 = new Vector3d(-beta0, -beta1, 0.0); horizon2 = new Vector3d(beta0 * beta0 - gamma0, 2.0 * (beta0 * beta1 - gamma1), beta1 * beta1 - gamma2); } Vector3 dir = World.SunNode.Direction; Vector3d sunDir = new Vector3d(dir.x, dir.y, dir.z); Vector3d oceanSunDir = ltoo.ToMatrix3x3d() * sunDir; m_oceanMaterial.SetVector("_Ocean_SunDir", MathConverter.ToVector3(oceanSunDir)); m_oceanMaterial.SetVector("_Ocean_Horizon1", MathConverter.ToVector3(horizon1)); m_oceanMaterial.SetVector("_Ocean_Horizon2", MathConverter.ToVector3(horizon2)); m_oceanMaterial.SetMatrix("_Ocean_CameraToOcean", MathConverter.ToMatrix4x4(ctoo)); m_oceanMaterial.SetMatrix("_Ocean_OceanToCamera", MathConverter.ToMatrix4x4(ctoo.Inverse)); m_oceanMaterial.SetVector("_Ocean_CameraPos", MathConverter.ToVector3(offset)); m_oceanMaterial.SetVector("_Ocean_Color", m_oceanUpwellingColor * 0.1f); m_oceanMaterial.SetVector("_Ocean_ScreenGridSize", new Vector2((float)m_resolution / (float)Screen.width, (float)m_resolution / (float)Screen.height)); m_oceanMaterial.SetFloat("_Ocean_Radius", radius); World.SkyNode.SetUniforms(m_oceanMaterial); World.SunNode.SetUniforms(m_oceanMaterial); World.SetUniforms(m_oceanMaterial); //Draw each mesh that makes up the projected grid foreach (Mesh mesh in m_screenGrids) { Graphics.DrawMesh(mesh, Matrix4x4.identity, m_oceanMaterial, 0, Camera.main); } }
public void updateStuff() { //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 // m_core.chosenCamera.ResetProjectionMatrix(); // m_core.chosenCamera.ResetWorldToCameraMatrix(); // Matrix4x4 ctol1 = m_core.chosenCamera.cameraToWorldMatrix; Matrix4x4 ctol1 = m_manager.m_skyNode.farCamera.cameraToWorldMatrix; //position relative to kerbin // Vector3d tmp = (m_core.chosenCamera.transform.position) - m_manager.parentCelestialBody.transform.position; Vector3d tmp = (m_manager.m_skyNode.farCamera.transform.position) - m_manager.parentCelestialBody.transform.position; // print ("TMP"); // print (tmp); // print (tmp.magnitude); Vector3d2 cl = new Vector3d2 (); // cl.x = tmp.x; // cl.y = tmp.y; // cl.z = tmp.z; // Matrix4x4d cameraToWorld = 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); 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); // Matrix4x4d cameraToWorld = new Matrix4x4d (0,0.906534175092856, 0.422132431102747, 6365631.33384793, // -0.997188818006091 , 0.0316302600890084, -0.0679263416526804, -906.151431945729, // 0.0749297086849734,0.420945740013386,-0.903985742542972,-12059.3565785169, // 0,0,0,1); //Vector3d planetPos = m_manager.parentCelestialBody.transform.position; Matrix4x4d worldToLocal = new Matrix4x4d (m_manager.parentCelestialBody.transform.worldToLocalMatrix); Vector4 translation = m_manager.parentCelestialBody.transform.worldToLocalMatrix.inverse.GetColumn (3); Matrix4x4d worldToLocal2 = new Matrix4x4d (1, 0, 0, -translation.x, 0, 1, 0, -translation.y, 0, 0, 1, -translation.z, 0, 0, 0, 1); // print ("translation"); // print (translation); //Matrix4x4d camToLocal = cameraToWorld.Inverse ();// * worldToLocal.Inverse(); Matrix4x4d camToLocal = worldToLocal2 * cameraToWorld; // Matrix4x4d camToLocal = ModifiedWorldToCameraMatrix (); // Matrix4x4d camToLocal = cameraToWorld ; // print ("WORLD TO LOCAL"); // print (worldToLocal); // print ("CAM T O LOCAL"); // print (camToLocal); //cl = camToLocal * Vector3d2.Zero (); /*Vector3d2*/ cl = camToLocal * Vector3d2.Zero (); // print ("CL"); // print (cl); // print (cl.Magnitude ()); // camera in local space relative to planet's origin double radius = m_manager.GetRadius (); m_drawOcean = true; 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 // h = cl.Magnitude() - radius; // print ("h="); // print (h); // h = cl.Magnitude(); // Vector3d tmp2=m_core.chosenCamera.transform.position-m_manager.parentCelestialBody.transform.position; oo = uz * (radius); // origin of ocean frame, in local space // oo = uz; // oo.x = oo.x; // oo.y = oo.y; // oo.z = oo.z; //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; // cameraToOcean = cameraToOcean.Inverse (); // Matrix4x4d cameraToOcean = OceanToWorld.Inverse() * cameraToWorld; Vector3d2 delta=new Vector3d2(0,0,0); if (m_oldlocalToOcean != Matrix4x4d.Identity()) { /*Vector3d2 */delta = localToOcean * (m_oldlocalToOcean.Inverse() * Vector3d2.Zero()); m_offset += delta; } m_oldlocalToOcean = localToOcean; Matrix4x4d ctos = ModifiedProjectionMatrix (m_manager.m_skyNode.farCamera); Matrix4x4d stoc = ctos.Inverse(); // Matrix4x4d stoc = new Matrix4x4d (1.23614492203479, 0, 0, 0, // 0, 0.577350279552042, 0, 0, // 0, 0, 0, -1, // 0, 0, -0.000249974703487648, 0.000249974763086261); // print ("STOC"); // print (stoc); // Matrix4x4d stoc = Matrix4x4d.Identity(); // Matrix4x4 p = camera.projectionMatrix; // // m_cameraToScreenMatrix = new Matrix4x4d(p); // m_screenToCameraMatrix = m_cameraToScreenMatrix.Inverse(); // Matrix4x4d stoc = new Matrix4x4d(3.57253843540205,0,0,0, // 0,3.577350279552042,0,0, // 0,0,0,-2, // 0,0,-0.00178426976276966,0.00178426997547119); Vector3d2 oc = cameraToOcean * Vector3d2.Zero(); // h = tmp2.magnitude - radius; h = oc.z; // print ("oc.z"); // print (h); // print ("h="); // print (h); // print ("tmp2.magnitude - radius"); // print (tmp2.magnitude - radius); 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); // print ("offset"); // print (offset); 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; m_oceanMaterial.SetVector("_Ocean_SunDir", oceanSunDir.ToVector3()); m_oceanMaterial.SetVector("_Ocean_Horizon1", horizon1.ToVector3()); m_oceanMaterial.SetVector("_Ocean_Horizon2", horizon2.ToVector3()); m_oceanMaterial.SetMatrix("_Ocean_CameraToOcean", cameraToOcean.ToMatrix4x4()); m_oceanMaterial.SetMatrix("_Ocean_OceanToCamera", cameraToOcean.Inverse().ToMatrix4x4()); m_oceanMaterial.SetMatrix ("_Globals_CameraToScreen", ctos.ToMatrix4x4 ()); m_oceanMaterial.SetMatrix ("_Globals_ScreenToCamera", stoc.ToMatrix4x4 ()); m_oceanMaterial.SetVector("_Ocean_CameraPos", offset.ToVector3()); m_oceanMaterial.SetVector("_Ocean_Color", m_oceanUpwellingColor * 0.1f); m_oceanMaterial.SetVector("_Ocean_ScreenGridSize", new Vector2((float)m_resolution / (float)Screen.width, (float)m_resolution / (float)Screen.height)); m_oceanMaterial.SetFloat("_Ocean_Radius", (float)radius); m_oceanMaterial.SetFloat("scale", 1); m_manager.GetSkyNode().SetOceanUniforms(m_oceanMaterial); }