// Use this for initialization
public virtual void Start()
{
m_cameraToWorldMatrix = Matrix4x4d.Identity();
//using different materials for both the far and near cameras because they have different projection matrixes
//the projection matrix in the shader has to match that of the camera or the projection will be wrong and the ocean will
//appear to "shift around"
m_oceanMaterialNear = new Material(ShaderTool.GetMatFromShader2("CompiledOceanWhiteCaps.shader"));
m_oceanMaterialFar = new Material(ShaderTool.GetMatFromShader2("CompiledOceanWhiteCaps.shader"));
m_manager.GetSkyNode().InitUniforms(m_oceanMaterialNear);
m_manager.GetSkyNode().InitUniforms(m_oceanMaterialFar);
m_oldlocalToOcean = Matrix4x4d.Identity();
m_oldworldToOcean = Matrix4x4d.Identity();
m_offset = Vector3d2.Zero();
//Create the projected grid. The resolution is the size in pixels
//of each square in the grid. If the squares are small the size of
//the mesh will exceed the max verts for a mesh in Unity. In this case
//split the mesh up into smaller meshes.
m_resolution = Mathf.Max(1, m_resolution);
//The number of squares in the grid on the x and y axis
int NX = Screen.width / m_resolution;
int NY = Screen.height / m_resolution;
numGrids = 1;
// const int MAX_VERTS = 65000;
//The number of meshes need to make a grid of this resolution
if (NX * NY > MAX_VERTS)
{
numGrids += (NX * NY) / MAX_VERTS;
}
m_screenGrids = new Mesh[numGrids];
// waterGameObjectsNear = new GameObject[numGrids];
// waterMeshRenderersNear = new MeshRenderer[numGrids];
// waterMeshFiltersNear = new MeshFilter[numGrids];
//
// waterGameObjectsFar = new GameObject[numGrids];
// waterMeshRenderersFar = new MeshRenderer[numGrids];
// waterMeshFiltersFar = new MeshFilter[numGrids];
//Make the meshes. The end product will be a grid of verts that cover
//the screen on the x and y axis with the z depth at 0. This grid is then
//projected as the ocean by the shader
for (int i = 0; i < numGrids; i++)
{
NY = Screen.height / numGrids / m_resolution;
m_screenGrids [i] = MakePlane(NX, NY, (float)i / (float)numGrids, 1.0f / (float)numGrids);
m_screenGrids [i].bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
//bad idea, the meshes still render arbitrarily to the near and far camera and end up drawing over everything
//to get around this I use drawmesh further down
//seems to have better performance also
// waterGameObjectsNear[i] = new GameObject();
// waterGameObjectsNear[i].transform.parent=m_manager.parentCelestialBody.transform;
// waterMeshFiltersNear[i] = waterGameObjectsNear[i].AddComponent<MeshFilter>();
// waterMeshFiltersNear[i].mesh.Clear ();
// waterMeshFiltersNear[i].mesh = m_screenGrids[i];
// waterGameObjectsNear[i].layer = 15;
//
// waterMeshRenderersNear[i] = waterGameObjectsNear[i].AddComponent<MeshRenderer>();
//
// waterMeshRenderersNear[i].sharedMaterial = m_oceanMaterialNear;
// waterMeshRenderersNear[i].material =m_oceanMaterialNear;
//
// waterMeshRenderersNear[i].castShadows = false;
// waterMeshRenderersNear[i].receiveShadows = false;
//
// waterMeshRenderersNear[i].enabled=true;
//
//
// waterGameObjectsFar[i] = new GameObject();
// waterGameObjectsFar[i].transform.parent=m_manager.parentCelestialBody.transform;
// waterMeshFiltersFar[i] = waterGameObjectsFar[i].AddComponent<MeshFilter>();
// waterMeshFiltersFar[i].mesh.Clear ();
// waterMeshFiltersFar[i].mesh = m_screenGrids[i];
// waterGameObjectsFar[i].layer = 15;
//
// waterMeshRenderersFar[i] = waterGameObjectsFar[i].AddComponent<MeshRenderer>();
//
// waterMeshRenderersFar[i].sharedMaterial = m_oceanMaterialFar;
// waterMeshRenderersFar[i].material =m_oceanMaterialFar;
//
// waterMeshRenderersFar[i].castShadows = false;
// waterMeshRenderersFar[i].receiveShadows = false;
//
// waterMeshRenderersFar[i].enabled=true;
}
// PQS pqs = m_manager.parentCelestialBody.pqsController;
//
// if (pqs.ChildSpheres[0])
// UnityEngine.Object.Destroy (pqs.ChildSpheres [0]);
// if (ocean)
// {
// UnityEngine.Object.Destroy (ocean);
// }
// Debug.Log("PQS.childspheres count"+pqs.ChildSpheres.Length);
// PQS pqs = m_manager.parentCelestialBody.pqsController;
// if (pqs.ChildSpheres [0]) {
// ocean = pqs.ChildSpheres [0];
// // ocean.surfaceMaterial = new Material (ShaderTool.GetMatFromShader2 ("EmptyShader.shader"));
//
// ///Thanks to rbray89 for this snippet that disables the stock ocean in a clean way
// GameObject container = ocean.gameObject;
//
// FakeOceanPQS fakeOcean1 = new GameObject ().AddComponent<FakeOceanPQS> ();
//
// fakeOcean1.CloneFrom (ocean);
// Destroy (ocean);
//
// FakeOceanPQS fakeOcean = container.AddComponent<FakeOceanPQS> ();
// fakeOcean.CloneFrom (fakeOcean1);
//
// Destroy (fakeOcean1);
//
// FieldInfo field = typeof(PQS).GetFields (BindingFlags.Instance | BindingFlags.NonPublic).First (
// f => f.FieldType == typeof(PQS[]));
// field.SetValue (pqs, new PQS[] {fakeOcean });
//
// PQSMod_CelestialBodyTransform cbt = pqs.GetComponentsInChildren<PQSMod_CelestialBodyTransform> () [0];
// cbt.secondaryFades = new PQSMod_CelestialBodyTransform.AltitudeFade[] { };
// }
// fakeOceanMesh = isosphere.Create (m_manager.GetRadius());
//
//
// fakeOcean = new GameObject ();
// fakeOceanMF = fakeOcean.AddComponent<MeshFilter>();
// fakeOceanMF.mesh = fakeOceanMesh;
// fakeOcean.layer = 15;
//
//
// fakeOcean.transform.parent = m_manager.parentCelestialBody.transform;
//
// fakeOceanMR = fakeOcean.AddComponent<MeshRenderer>();
//
// newMat = new Material (ShaderTool.GetMatFromShader2 ("BlackShader.shader"));
// fakeOceanMR.sharedMaterial = newMat;
// fakeOceanMR.material =newMat;
//
// fakeOceanMR.castShadows = false;
// fakeOceanMR.receiveShadows = false;
}
// Use this for initialization
public virtual void Init()
{
if (Core.Instance.oceanPixelLights)
{
m_oceanMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/OceanWhiteCapsPixelLights")]);
}
else
{
m_oceanMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/OceanWhiteCaps")]);
}
if (Core.Instance.oceanSkyReflections)
{
m_oceanMaterial.EnableKeyword("SKY_REFLECTIONS_ON");
m_oceanMaterial.DisableKeyword("SKY_REFLECTIONS_OFF");
}
else
{
m_oceanMaterial.EnableKeyword("SKY_REFLECTIONS_OFF");
m_oceanMaterial.DisableKeyword("SKY_REFLECTIONS_ON");
}
if (Core.Instance.usePlanetShine)
{
m_oceanMaterial.EnableKeyword("PLANETSHINE_ON");
m_oceanMaterial.DisableKeyword("PLANETSHINE_OFF");
}
else
{
m_oceanMaterial.DisableKeyword("PLANETSHINE_ON");
m_oceanMaterial.EnableKeyword("PLANETSHINE_OFF");
}
if (Core.Instance.oceanRefraction)
{
m_oceanMaterial.EnableKeyword("REFRACTION_ON");
m_oceanMaterial.DisableKeyword("REFRACTION_OFF");
}
else
{
m_oceanMaterial.EnableKeyword("REFRACTION_OFF");
m_oceanMaterial.DisableKeyword("REFRACTION_ON");
}
if (Core.Instance.shadowsOnOcean && (QualitySettings.shadows != ShadowQuality.Disable))
{
if (QualitySettings.shadows == ShadowQuality.HardOnly)
{
m_oceanMaterial.EnableKeyword("OCEAN_SHADOWS_HARD");
m_oceanMaterial.DisableKeyword("OCEAN_SHADOWS_SOFT");
}
else
{
m_oceanMaterial.EnableKeyword("OCEAN_SHADOWS_SOFT");
m_oceanMaterial.DisableKeyword("OCEAN_SHADOWS_HARD");
}
m_oceanMaterial.DisableKeyword("OCEAN_SHADOWS_OFF");
}
else
{
m_oceanMaterial.EnableKeyword("OCEAN_SHADOWS_OFF");
m_oceanMaterial.DisableKeyword("OCEAN_SHADOWS_HARD");
m_oceanMaterial.DisableKeyword("OCEAN_SHADOWS_SOFT");
}
m_oceanMaterial.SetOverrideTag("IgnoreProjector", "True");
m_manager.GetSkyNode().InitUniforms(m_oceanMaterial);
m_oceanMaterial.SetTexture(ShaderProperties._customDepthTexture_PROPERTY, Core.Instance.bufferRenderingManager.depthTexture);
//if (Core.Instance.oceanRefraction)
m_oceanMaterial.SetTexture("_BackgroundTexture", Core.Instance.bufferRenderingManager.refractionTexture);
m_oceanMaterial.renderQueue = 2501;
m_oldlocalToOcean = Matrix4x4d.Identity();
m_offset = Vector3d2.Zero();
//Create the projected grid. The resolution is the size in pixels
//of each square in the grid. If the squares are small the size of
//the mesh will exceed the max verts for a mesh in Unity. In this case
//split the mesh up into smaller meshes.
m_resolution = Mathf.Max(1, m_resolution);
//The number of squares in the grid on the x and y axis
int NX = Screen.width / m_resolution;
int NY = Screen.height / m_resolution;
numGrids = 1;
// const int MAX_VERTS = 65000;
//The number of meshes need to make a grid of this resolution
if (NX * NY > MAX_VERTS)
{
numGrids += (NX * NY) / MAX_VERTS;
}
m_screenGrids = new Mesh[numGrids];
waterGameObjects = new GameObject[numGrids];
waterMeshRenderers = new MeshRenderer[numGrids];
waterMeshFilters = new MeshFilter[numGrids];
//Make the meshes. The end product will be a grid of verts that cover
//the screen on the x and y axis with the z depth at 0. This grid is then
//projected as the ocean by the shader
for (int i = 0; i < numGrids; i++)
{
NY = Screen.height / numGrids / m_resolution;
m_screenGrids [i] = MakePlane(NX, NY, (float)i / (float)numGrids, 1.0f / (float)numGrids);
m_screenGrids [i].bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
waterGameObjects[i] = new GameObject();
waterGameObjects[i].transform.parent = m_manager.parentCelestialBody.transform; //might be redundant
waterMeshFilters[i] = waterGameObjects[i].AddComponent <MeshFilter>();
waterMeshFilters[i].mesh.Clear();
waterMeshFilters[i].mesh = m_screenGrids[i];
waterGameObjects[i].layer = 15;
waterMeshRenderers[i] = waterGameObjects[i].AddComponent <MeshRenderer>();
waterMeshRenderers[i].sharedMaterial = m_oceanMaterial;
waterMeshRenderers[i].material = m_oceanMaterial;
waterMeshRenderers[i].receiveShadows = false;
waterMeshRenderers[i].shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
waterMeshRenderers[i].enabled = true;
}
oceanCameraProjectionMatModifier = waterGameObjects[0].AddComponent <OceanCameraUpdateHook>();
oceanCameraProjectionMatModifier.oceanNode = this;
underwaterMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/UnderwaterScatterProjector")]);
m_manager.GetSkyNode().InitPostprocessMaterial(underwaterMaterial);
m_manager.GetSkyNode().InitPostprocessMaterial(m_oceanMaterial);
underwaterMaterial.renderQueue = 2502; //draw over fairings which is 2450 and over ocean which is 2501
underwaterProjector = new AtmosphereProjector(underwaterMaterial, m_manager.parentLocalTransform, (float)m_manager.m_radius);
underwaterProjector.setActivated(false);
initUniforms();
//move this to separate class and make it work on every camera
//refraction command buffer
oceanRefractionCommandBuffer = new CommandBuffer();
oceanRefractionCommandBuffer.name = "ScattererOceanGrabScreen";
// copy screen
oceanRefractionCommandBuffer.Blit(BuiltinRenderTextureType.CurrentActive, Core.Instance.bufferRenderingManager.refractionTexture);
Core.Instance.farCamera.AddCommandBuffer(CameraEvent.AfterForwardOpaque, oceanRefractionCommandBuffer);
Core.Instance.nearCamera.AddCommandBuffer(CameraEvent.AfterForwardOpaque, oceanRefractionCommandBuffer);
//dimming
if (Core.Instance.underwaterLightDimming && (HighLogic.LoadedScene != GameScenes.MAINMENU))
{
underwaterDimmingHook = (UnderwaterDimmingHook)Core.Instance.scaledSpaceCamera.gameObject.AddComponent(typeof(UnderwaterDimmingHook));
underwaterDimmingHook.oceanNode = this;
}
}
// Use this for initialization
public virtual void Start()
{
// m_cameraToWorldMatrix = Matrix4x4d.Identity ();
//
//using different materials for both the far and near cameras because they have different projection matrixes
//the projection matrix in the shader has to match that of the camera or the projection will be wrong and the ocean will
//appear to "shift around"
if (Core.Instance.oceanPixelLights)
{
m_oceanMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/OceanWhiteCapsPixelLights")]);
}
else
{
m_oceanMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/OceanWhiteCaps")]);
}
if (Core.Instance.oceanSkyReflections)
{
m_oceanMaterial.EnableKeyword("SKY_REFLECTIONS_ON");
m_oceanMaterial.DisableKeyword("SKY_REFLECTIONS_OFF");
}
else
{
m_oceanMaterial.EnableKeyword("SKY_REFLECTIONS_OFF");
m_oceanMaterial.DisableKeyword("SKY_REFLECTIONS_ON");
}
if (Core.Instance.usePlanetShine)
{
m_oceanMaterial.EnableKeyword("PLANETSHINE_ON");
m_oceanMaterial.DisableKeyword("PLANETSHINE_OFF");
}
else
{
m_oceanMaterial.DisableKeyword("PLANETSHINE_ON");
m_oceanMaterial.EnableKeyword("PLANETSHINE_OFF");
}
if (Core.Instance.oceanRefraction)
{
m_oceanMaterial.EnableKeyword("REFRACTION_ON");
m_oceanMaterial.DisableKeyword("REFRACTION_OFF");
}
else
{
m_oceanMaterial.EnableKeyword("REFRACTION_OFF");
m_oceanMaterial.DisableKeyword("REFRACTION_ON");
}
// m_manager.GetSkyNode ().InitUniforms (m_oceanMaterialNear);
m_manager.GetSkyNode().InitUniforms(m_oceanMaterial);
m_oceanMaterial.SetTexture(ShaderProperties._customDepthTexture_PROPERTY, Core.Instance.customDepthBufferTexture);
m_oceanMaterial.SetTexture("_BackgroundTexture", Core.Instance.refractionTexture);
m_oceanMaterial.renderQueue = 2050;
m_oldlocalToOcean = Matrix4x4d.Identity();
// m_oldworldToOcean = Matrix4x4d.Identity ();
m_offset = Vector3d2.Zero();
//Create the projected grid. The resolution is the size in pixels
//of each square in the grid. If the squares are small the size of
//the mesh will exceed the max verts for a mesh in Unity. In this case
//split the mesh up into smaller meshes.
m_resolution = Mathf.Max(1, m_resolution);
//The number of squares in the grid on the x and y axis
int NX = Screen.width / m_resolution;
int NY = Screen.height / m_resolution;
numGrids = 1;
// const int MAX_VERTS = 65000;
//The number of meshes need to make a grid of this resolution
if (NX * NY > MAX_VERTS)
{
numGrids += (NX * NY) / MAX_VERTS;
}
m_screenGrids = new Mesh[numGrids];
waterGameObjects = new GameObject[numGrids];
waterMeshRenderers = new MeshRenderer[numGrids];
waterMeshFilters = new MeshFilter[numGrids];
//Make the meshes. The end product will be a grid of verts that cover
//the screen on the x and y axis with the z depth at 0. This grid is then
//projected as the ocean by the shader
for (int i = 0; i < numGrids; i++)
{
NY = Screen.height / numGrids / m_resolution;
m_screenGrids [i] = MakePlane(NX, NY, (float)i / (float)numGrids, 1.0f / (float)numGrids);
m_screenGrids [i].bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
waterGameObjects[i] = new GameObject();
waterGameObjects[i].transform.parent = m_manager.parentCelestialBody.transform; //might be redundant
waterMeshFilters[i] = waterGameObjects[i].AddComponent <MeshFilter>();
waterMeshFilters[i].mesh.Clear();
waterMeshFilters[i].mesh = m_screenGrids[i];
//waterGameObjects[i].layer = 15;
waterGameObjects[i].layer = 23;
waterMeshRenderers[i] = waterGameObjects[i].AddComponent <MeshRenderer>();
waterMeshRenderers[i].sharedMaterial = m_oceanMaterial;
waterMeshRenderers[i].material = m_oceanMaterial;
waterMeshRenderers[i].receiveShadows = false;
waterMeshRenderers[i].shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
// CommandBufferModifiedProjectionMatrix tmp = waterGameObjects[i].AddComponent<CommandBufferModifiedProjectionMatrix>();
// tmp.Core.Instance=Core.Instance;
waterMeshRenderers[i].enabled = true;
}
cbProjectionMat = waterGameObjects[0].AddComponent <CommandBufferModifiedProjectionMatrix>();
cbProjectionMat.oceanNode = this;
underwaterGameObject = new GameObject();
if (underwaterGameObject.GetComponent <MeshFilter> ())
{
underwaterMeshFilter = underwaterGameObject.GetComponent <MeshFilter> ();
}
else
{
underwaterMeshFilter = underwaterGameObject.AddComponent <MeshFilter>();
}
underwaterMeshFilter.mesh.Clear();
underwaterMeshFilter.mesh = MeshFactory.MakePlaneWithFrustumIndexes();
underwaterMeshFilter.mesh.bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
if (underwaterGameObject.GetComponent <MeshRenderer> ())
{
underwaterMeshrenderer = underwaterGameObject.GetComponent <MeshRenderer> ();
}
else
{
underwaterMeshrenderer = underwaterGameObject.AddComponent <MeshRenderer>();
}
underwaterPostProcessingMaterial = new Material(ShaderReplacer.Instance.LoadedShaders[("Scatterer/UnderwaterScatter")]);
underwaterPostProcessingMaterial.SetOverrideTag("IgnoreProjector", "True");
m_manager.GetSkyNode().InitPostprocessMaterial(underwaterPostProcessingMaterial);
underwaterPostProcessingMaterial.renderQueue = 2049;
if (Core.Instance.oceanRefraction && (HighLogic.LoadedScene != GameScenes.TRACKSTATION))
{
Core.Instance.refractionCam.underwaterPostProcessing = underwaterMeshrenderer;
}
underwaterMeshrenderer.sharedMaterial = underwaterPostProcessingMaterial;
underwaterMeshrenderer.material = underwaterPostProcessingMaterial;
underwaterMeshrenderer.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
underwaterMeshrenderer.receiveShadows = false;
underwaterMeshrenderer.enabled = false;
//underwaterGameObject.layer = 15;
underwaterGameObject.layer = 23;
}
// Use this for initialization
public virtual void Start()
{
// m_cameraToWorldMatrix = Matrix4x4d.Identity ();
//
//using different materials for both the far and near cameras because they have different projection matrixes
//the projection matrix in the shader has to match that of the camera or the projection will be wrong and the ocean will
//appear to "shift around"
// m_oceanMaterialNear = new Material (ShaderTool.GetMatFromShader2 ("CompiledOceanWhiteCaps.shader"));
if (m_core.oceanPixelLights)
{
m_oceanMaterialFar = new Material(ShaderTool.GetMatFromShader2("CompiledOceanWhiteCapsPixelLights.shader"));
}
else
{
m_oceanMaterialFar = new Material(ShaderTool.GetMatFromShader2("CompiledOceanWhiteCaps.shader"));
}
if (m_core.oceanSkyReflections)
{
m_oceanMaterialFar.EnableKeyword("SKY_REFLECTIONS_ON");
m_oceanMaterialFar.DisableKeyword("SKY_REFLECTIONS_OFF");
}
else
{
m_oceanMaterialFar.EnableKeyword("SKY_REFLECTIONS_OFF");
m_oceanMaterialFar.DisableKeyword("SKY_REFLECTIONS_ON");
}
// m_manager.GetSkyNode ().InitUniforms (m_oceanMaterialNear);
m_manager.GetSkyNode().InitUniforms(m_oceanMaterialFar);
m_oldlocalToOcean = Matrix4x4d.Identity();
// m_oldworldToOcean = Matrix4x4d.Identity ();
m_offset = Vector3d2.Zero();
//Create the projected grid. The resolution is the size in pixels
//of each square in the grid. If the squares are small the size of
//the mesh will exceed the max verts for a mesh in Unity. In this case
//split the mesh up into smaller meshes.
m_resolution = Mathf.Max(1, m_resolution);
//The number of squares in the grid on the x and y axis
int NX = Screen.width / m_resolution;
int NY = Screen.height / m_resolution;
numGrids = 1;
// const int MAX_VERTS = 65000;
//The number of meshes need to make a grid of this resolution
if (NX * NY > MAX_VERTS)
{
numGrids += (NX * NY) / MAX_VERTS;
}
m_screenGrids = new Mesh[numGrids];
waterGameObjects = new GameObject[numGrids];
waterMeshRenderers = new MeshRenderer[numGrids];
waterMeshFilters = new MeshFilter[numGrids];
//Make the meshes. The end product will be a grid of verts that cover
//the screen on the x and y axis with the z depth at 0. This grid is then
//projected as the ocean by the shader
for (int i = 0; i < numGrids; i++)
{
NY = Screen.height / numGrids / m_resolution;
m_screenGrids [i] = MakePlane(NX, NY, (float)i / (float)numGrids, 1.0f / (float)numGrids);
m_screenGrids [i].bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f));
waterGameObjects[i] = new GameObject();
waterGameObjects[i].transform.parent = m_manager.parentCelestialBody.transform; //might be redundant
waterMeshFilters[i] = waterGameObjects[i].AddComponent <MeshFilter>();
waterMeshFilters[i].mesh.Clear();
waterMeshFilters[i].mesh = m_screenGrids[i];
waterGameObjects[i].layer = 15;
waterMeshRenderers[i] = waterGameObjects[i].AddComponent <MeshRenderer>();
waterMeshRenderers[i].sharedMaterial = m_oceanMaterialFar;
waterMeshRenderers[i].material = m_oceanMaterialFar;
waterMeshRenderers[i].shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
waterMeshRenderers[i].receiveShadows = false;
// CommandBufferModifiedProjectionMatrix tmp = waterGameObjects[i].AddComponent<CommandBufferModifiedProjectionMatrix>();
// tmp.m_core=m_core;
waterMeshRenderers[i].enabled = true;
}
cbProjectionMat = waterGameObjects[0].AddComponent <CommandBufferModifiedProjectionMatrix>();
cbProjectionMat.m_core = m_core;
}
