// 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;
}
