public void InitMaterials() { if (StarfieldMaterial == null) { StarfieldMaterial = MaterialHelper.CreateTemp(StarfieldShader, "Starfield"); } }
protected override void InitNode() { Body = GetComponentInParent <CelestialBody>(); Body.TerrainNodes.Add(this); TerrainMaterial = MaterialHelper.CreateTemp(Body.ColorShader, "TerrainNode"); //Manager.GetSkyNode().InitUniforms(TerrainMaterial); var faces = new Vector3d[] { new Vector3d(0, 0, 0), new Vector3d(90, 0, 0), new Vector3d(90, 90, 0), new Vector3d(90, 180, 0), new Vector3d(90, 270, 0), new Vector3d(0, 180, 180) }; FaceToLocal = Matrix4x4d.Identity(); // If this terrain is deformed into a sphere the face matrix is the rotation of the // terrain needed to make up the spherical planet. In this case there should be 6 terrains, each with a unique face number if (Face - 1 >= 0 && Face - 1 < 6) { FaceToLocal = Matrix4x4d.Rotate(faces[Face - 1]); } //LocalToWorld = Matrix4x4d.ToMatrix4x4d(transform.localToWorldMatrix) * FaceToLocal; LocalToWorld = FaceToLocal; Deformation = new DeformationSpherical(Body.Radius); TerrainQuadRoot = new TerrainQuad(this, null, 0, 0, -Body.Radius, -Body.Radius, 2.0 * Body.Radius, ZMin, ZMax); }
public void InitMaterials() { if (SkyMaterial == null) { SkyMaterial = MaterialHelper.CreateTemp(SkyShader, "Sky"); } }
public void Start() { if (Sun == null) { if (GetComponent <AtmosphereSun>() != null) { Sun = GetComponent <AtmosphereSun>(); } } SunGlareMaterial = MaterialHelper.CreateTemp(SunGlareShader, "Sunglare", (int)RenderQueue); mesh = MeshFactory.MakePlane(8, 8, MeshFactory.PLANE.XY, false, false, false); mesh.bounds = new Bounds(Vector4.zero, new Vector3(9e37f, 9e37f, 9e37f)); for (int i = 0; i < Ghost1SettingsList.Count; i++) { Ghost1Settings.SetRow(i, Ghost1SettingsList[i]); } for (int i = 0; i < Ghost2SettingsList.Count; i++) { Ghost2Settings.SetRow(i, Ghost2SettingsList[i]); } for (int i = 0; i < Ghost3SettingsList.Count; i++) { Ghost3Settings.SetRow(i, Ghost3SettingsList[i]); } InitUniforms(SunGlareMaterial); }
protected override void InitNode() { if (Settings == null) { return; } SunGlareMaterial = MaterialHelper.CreateTemp(SunGlareShader, "Sunglare", (int)RenderQueue); SunGlareMesh = MeshFactory.MakePlane(8, MeshFactory.PLANE.XY, false, false, false); SunGlareMesh.bounds = new Bounds(Vector4.zero, new Vector3(9e37f, 9e37f, 9e37f)); for (var i = 0; i < Settings.Ghost1SettingsList.Count; i++) { Ghost1Settings.SetRow(i, Settings.Ghost1SettingsList[i]); } for (var i = 0; i < Settings.Ghost2SettingsList.Count; i++) { Ghost2Settings.SetRow(i, Settings.Ghost2SettingsList[i]); } for (var i = 0; i < Settings.Ghost3SettingsList.Count; i++) { Ghost3Settings.SetRow(i, Settings.Ghost3SettingsList[i]); } InitUniforms(SunGlareMaterial); }
protected virtual void CreateLineMaterial() { if (lineShader == null) { throw new System.NullReferenceException("Line Shader is null!"); } if (!lineMaterial) { lineMaterial = MaterialHelper.CreateTemp(lineShader, "Line"); } }
private void Start() { if (FBProcessShader == null) { FBProcessShader = Shader.Find("Hidden/FrameBufferProcess"); } FBProcessMaterial = MaterialHelper.CreateTemp(FBProcessShader, "FrameBufferProcess"); CMDBufferCreate(); FBORecreate(); LastScreenSize = ScreenSize; }
private void Start() { var startTime = Time.realtimeSinceStartup; ApplicationDataPath = Application.dataPath; ViewMaterial = MaterialHelper.CreateTemp(ViewShader, "TreeView"); CalculateMesh(); //CalculateAO(); CalculateViews(); Debug.Log(string.Format("PreProcessTree.Start: Computation time: {0} s", (Time.realtimeSinceStartup - startTime))); }
public override void InitNode() { ParentBody = GetComponentInParent <Body>(); TerrainMaterial = MaterialHelper.CreateTemp(ParentBody.ColorShader, "TerrainNode"); FaceToLocal = Matrix4x4d.identity; // NOTE : Body shape dependent... var celestialBody = ParentBody as CelestialBody; var faces = new Vector3d[] { new Vector3d(0, 0, 0), new Vector3d(90, 0, 0), new Vector3d(90, 90, 0), new Vector3d(90, 180, 0), new Vector3d(90, 270, 0), new Vector3d(0, 180, 180) }; // If this terrain is deformed into a sphere the face matrix is the rotation of the // terrain needed to make up the spherical planet. In this case there should be 6 terrains, each with a unique face number if (Face - 1 >= 0 && Face - 1 < 6) { FaceToLocal = Matrix4x4d.Rotate(faces[Face - 1]); } if (celestialBody == null) { throw new Exception("Wow! Celestial body isn't Celestial?!"); } LocalToWorld = Matrix4x4d.ToMatrix4x4d(celestialBody.transform.localToWorldMatrix) * FaceToLocal; Deformation = new DeformationSpherical(celestialBody.Size); TangentFrameToWorld = new Matrix3x3d(LocalToWorld.m[0, 0], LocalToWorld.m[0, 1], LocalToWorld.m[0, 2], LocalToWorld.m[1, 0], LocalToWorld.m[1, 1], LocalToWorld.m[1, 2], LocalToWorld.m[2, 0], LocalToWorld.m[2, 1], LocalToWorld.m[2, 2]); InitUniforms(TerrainMaterial); CreateTerrainQuadRoot(ParentBody.Size); CollectSamplers(); CollectSamplersSuitable(); SamplersOrder = new TileSamplerOrder(Samplers); var producers = GetComponentsInChildren <TileProducer>(); var lastProducer = producers[producers.Length - 1]; if (lastProducer.IsLastInSequence == false) { lastProducer.IsLastInSequence = true; Debug.Log(string.Format("TerrainNode: {0} probably last in generation sequence, but maybe accidentally not marked as. Fixed!", lastProducer.name)); } }
public void SetupMainQuad(QuadPosition quadPosition) { GameObject go = new GameObject(string.Format("Quad_{0}", quadPosition)); go.transform.parent = QuadsRoot.transform; go.transform.position = Vector3.zero; go.transform.rotation = Quaternion.identity; go.transform.localPosition = Vector3.zero; go.transform.localRotation = Quaternion.identity; Mesh mesh = GetMesh(quadPosition); mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2)); Material material = MaterialHelper.CreateTemp(ColorShader, "Quad"); Quad quadComponent = go.AddComponent <Quad>(); quadComponent.Planetoid = this; quadComponent.QuadMesh = mesh; quadComponent.QuadMaterial = material; if (Atmosphere != null) { Atmosphere.InitUniforms(null, quadComponent.QuadMaterial, false); } QuadGenerationConstants gc = QuadGenerationConstants.Init(TerrainMaxHeight); gc.planetRadius = PlanetRadius; gc.cubeFaceEastDirection = quadComponent.GetCubeFaceEastDirection(quadPosition); gc.cubeFaceNorthDirection = quadComponent.GetCubeFaceNorthDirection(quadPosition); gc.patchCubeCenter = quadComponent.GetPatchCubeCenter(quadPosition); quadComponent.Position = quadPosition; quadComponent.ID = QuadID.One; quadComponent.generationConstants = gc; quadComponent.SetupCorners(quadPosition); quadComponent.ShouldDraw = true; quadComponent.ReadyForDispatch = true; Quads.Add(quadComponent); MainQuads.Add(quadComponent); }
public Quad SetupSubQuad(QuadPosition quadPosition) { GameObject go = new GameObject(string.Format("Quad_{0}", quadPosition)); Mesh mesh = GetMesh(quadPosition); mesh.bounds = new Bounds(Vector3.zero, new Vector3(PlanetRadius * 2, PlanetRadius * 2, PlanetRadius * 2)); Material material = MaterialHelper.CreateTemp(ColorShader, "Quad"); Quad quadComponent = go.AddComponent <Quad>(); quadComponent.Planetoid = this; quadComponent.QuadMesh = mesh; quadComponent.QuadMaterial = material; quadComponent.SetupCorners(quadPosition); if (Atmosphere != null) { Atmosphere.InitUniforms(null, quadComponent.QuadMaterial, false); } QuadGenerationConstants gc = QuadGenerationConstants.Init(TerrainMaxHeight); gc.planetRadius = PlanetRadius; quadComponent.Position = quadPosition; quadComponent.generationConstants = gc; quadComponent.ShouldDraw = false; if (qdtccc == null) { qdtccc = new QuadDistanceToClosestCornerComparer(); } Quads.Add(quadComponent); Quads.Sort(qdtccc); return(quadComponent); }
protected override void InitNode() { InitOceanNode(); OceanMaterial = MaterialHelper.CreateTemp(OceanShader, "Ocean"); ParentBody.Atmosphere.InitUniforms(OceanMaterial); OldLocalToOcean = Matrix4x4d.identity; Offset = Vector4.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. Resolution = Mathf.Max(1, Resolution); // The number of squares in the grid on the x and y axis var NX = Screen.width / Resolution; var NY = Screen.height / Resolution; var 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; } ScreenMeshGrids = new Mesh[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 (byte i = 0; i < numGrids; i++) { NY = Screen.height / numGrids / Resolution; ScreenMeshGrids[i] = MeshFactory.MakeOceanPlane(NX, NY, (float)i / (float)numGrids, 1.0f / (float)numGrids); ScreenMeshGrids[i].bounds = new Bounds(Vector3.zero, new Vector3(1e8f, 1e8f, 1e8f)); } }
public override void InitNode() { base.InitNode(); if (InitJacobiansMaterial == null) { Debug.Log("OceanWhiteCaps: Init jacobians material is null! Trying to find it out..."); InitJacobiansMaterial = MaterialHelper.CreateTemp(Shader.Find("SpaceEngine/Ocean/InitJacobians"), "InitJacobians"); } if (WhiteCapsPrecomputeMaterial == null) { Debug.Log("OceanWhiteCaps: White caps precompute material is null! Trying to find it out..."); WhiteCapsPrecomputeMaterial = MaterialHelper.CreateTemp(Shader.Find("SpaceEngine/Ocean/WhiteCapsPrecompute"), "WhiteCapsPrecompute"); } InitJacobiansMaterial.SetTexture("_Spectrum01", Spectrum01); InitJacobiansMaterial.SetTexture("_Spectrum23", Spectrum23); InitJacobiansMaterial.SetTexture("_WTable", WTable); InitJacobiansMaterial.SetVector("_Offset", Offset); InitJacobiansMaterial.SetVector("_InverseGridSizes", InverseGridSizes); }
public override void InitNode() { base.InitNode(); if (InitSpectrumMaterial == null) { Debug.Log("OceanFFT: Init spectrum material is null! Trying to find it out..."); InitSpectrumMaterial = MaterialHelper.CreateTemp(Shader.Find("SpaceEngine/Ocean/InitSpectrum"), "InitSpectrum"); } if (InitDisplacementMaterial == null) { Debug.Log("OceanFFT: Init displacement material is null! Trying to find it out.."); InitDisplacementMaterial = MaterialHelper.CreateTemp(Shader.Find("SpaceEngine/Ocean/InitDisplacement"), "InitDisplacement"); } MapSize = (float)FourierGridSize; Offset = new Vector4(1.0f + 0.5f / MapSize, 1.0f + 0.5f / MapSize, 0, 0); float factor = 2.0f * Mathf.PI * MapSize; InverseGridSizes = new Vector4(factor / GridSizes.x, factor / GridSizes.y, factor / GridSizes.z, factor / GridSizes.w); Fourier = new FourierGPU(FourierGridSize, FourierShader); //Create the data needed to make the waves each frame CreateRenderTextures(); GenerateWavesSpectrum(); CreateWTable(); InitSpectrumMaterial.SetTexture("_Spectrum01", Spectrum01); InitSpectrumMaterial.SetTexture("_Spectrum23", Spectrum23); InitSpectrumMaterial.SetTexture("_WTable", WTable); InitSpectrumMaterial.SetVector("_Offset", Offset); InitSpectrumMaterial.SetVector("_InverseGridSizes", InverseGridSizes); InitDisplacementMaterial.SetVector("_InverseGridSizes", InverseGridSizes); }
private void InitMaterial() { QuadMaterial = MaterialHelper.CreateTemp(Planetoid.ColorShader, "Quad", (int)Planetoid.RenderQueue); }
private void InitMaterial() { RingMaterial = MaterialHelper.CreateTemp(RingShader, "Ring", (int)RenderQueue); }
private void GenerateTerrain() { GameObject = new GameObject { name = "Patch_LOD_ " + SplitLevel + " : [" + Up + "]", layer = Sphere.gameObject.layer }; Mesh = new Mesh(); Data = new PatchData(PatchSettings.Vertices); var origin = Volume.Vertices[0]; var spacing = Size / (PatchSettings.VerticesPerSide - 1); for (ushort y = 0; y < PatchSettings.VerticesPerSide; y++) { var offset = origin; for (ushort x = 0; x < PatchSettings.VerticesPerSide; x++) { var vertex = offset; Data.Vertices.Add(vertex.NormalizeToRadius(Sphere.Radius)); Data.Normals.Add(vertex.normalized); Data.Volume.Add(offset); Data.UV1.Add(VectorHelper.CartesianToPolarUV(vertex)); Data.UV2.Add(new Vector2(0, 0)); offset += Right * spacing; } origin -= Front * spacing; } //update projected center MiddleProjected = MiddleProjected.NormalizeToRadius(Sphere.Radius); //save original parent transformations var parentPosition = Sphere.gameObject.transform.position; var parentRotation = Sphere.gameObject.transform.rotation; //reset parent transformations before assigning data (so our vertices will be centered on the parent transform) Sphere.gameObject.transform.position = Vector3.zero; Sphere.gameObject.transform.rotation = Quaternion.identity; //put this node as a child of parent GameObject.transform.parent = Sphere.gameObject.transform; var indices = Sphere.PatchManager.Patches[Edges]; //assign data to this node's mesh Mesh.SetVertices(Data.Vertices); Mesh.SetNormals(Data.Normals); Mesh.SetTriangles(indices, 0); Mesh.SetUVs(0, Data.UV1); Mesh.SetUVs(1, Data.UV2); Mesh.hideFlags = HideFlags.HideAndDontSave; Mesh.SolveTangents(ref indices, ref Data.Vertices, ref Data.Normals, ref Data.UV1); Mesh.RecalculateBounds(); //restore parent transformations Sphere.gameObject.transform.position = parentPosition; Sphere.gameObject.transform.rotation = parentRotation; NeedsTerrain = false; //discard parent's resources if (Parent != null) { Parent.DestroyNode(); } var patch = GameObject.AddComponent <Patch>(); var meshFilter = GameObject.AddComponent <MeshFilter>(); GameObject.AddComponent <MeshRenderer>(); GameObject.GetComponent <MeshRenderer>().sharedMaterial = MaterialHelper.CreateTemp(Sphere.Shader, "Patch"); meshFilter.mesh = Mesh; patch.PatchTree = this; }
public override void InitNode() { OceanMaterial = MaterialHelper.CreateTemp(OceanShader, "Ocean"); ParentBody.InitUniforms(OceanMaterial); }
private void InitMaterial() { RingMaterial = MaterialHelper.CreateTemp(RingShader, "Ring"); }
public void InitMaterials() { CloudMaterial = MaterialHelper.CreateTemp(CloudShader, "Cloudsphere", (int)RenderQueue); }
private void GenerateTerrain() { GameObject = new GameObject { name = "Patch_LOD_ " + SplitLevel + " : [" + Up + "]", layer = Sphere.gameObject.layer }; Mesh = new Mesh(); Data = new PatchData(PatchSettings.Vertices); var origin = Volume.Vertices[0]; var vertStep = Size / (PatchSettings.VerticesPerSide - 1); //vertex spacing var startHMap = 1.0f; var endHMap = 1.0f - startHMap; var uCoord = startHMap; var vCoord = startHMap; //uv coordinates for the heightmap var uvStep = (endHMap - startHMap) / (PatchSettings.VerticesPerSide - 1); //hmap uv step size inside the loop var uVolCoord = Volume.UVs[0].x; var vVolCoord = Volume.UVs[0].y; //flat uv coordinates for the cube face var volCoordStep = (Volume.UVs[1].x - Volume.UVs[0].x) / (PatchSettings.VerticesPerSide - 1); //step size of flat uv inside the loop var idx = 0; for (ushort y = 0; y < PatchSettings.VerticesPerSide; y++) { var offset = origin; uCoord = startHMap; uVolCoord = Volume.UVs[0].x; for (ushort x = 0; x < PatchSettings.VerticesPerSide; x++) { //heightmap texture coordinates Data.UV1[idx] = new Vector2(uCoord, vCoord); uCoord += uvStep; //volume texture coordinates //x,y = flat volume uv coordinates //z = vertex slope Data.UV2[idx] = new Vector2(uVolCoord, vVolCoord); uVolCoord += volCoordStep; //calculate vertex position var vtx = offset; //use normalized vertex position as vertex normal vtx.Normalize(); Data.Normals[idx] = vtx; //scale to sphere vtx = vtx * Sphere.Radius; //store Data.Vertices[idx] = vtx; Data.Volume[idx] = offset; idx++; offset += Right * vertStep; } origin -= Front * vertStep; vCoord += uvStep; vVolCoord += volCoordStep; } //update projected center MiddleProjected = MiddleProjected.NormalizeToRadius(Sphere.Radius); //save original parent transformations var parentPosition = Sphere.gameObject.transform.position; var parentRotation = Sphere.gameObject.transform.rotation; //reset parent transformations before assigning data (so our vertices will be centered on the parent transform) Sphere.gameObject.transform.position = Vector3.zero; Sphere.gameObject.transform.rotation = Quaternion.identity; //put this node as a child of parent GameObject.transform.parent = Sphere.gameObject.transform; //assign data to this node's mesh Mesh.SetVertices(Data.Vertices.ToList()); Mesh.SetUVs(0, Data.UV1.ToList()); Mesh.SetUVs(1, Data.UV2.ToList()); Mesh.SetNormals(Data.Normals.ToList()); Mesh.SetTriangles(Sphere.PatchManager.Patches[Edges], 0); Mesh.hideFlags = HideFlags.DontSave; MeshFactory.SolveTangents(Mesh); Mesh.RecalculateBounds(); //restore parent transformations Sphere.gameObject.transform.position = parentPosition; Sphere.gameObject.transform.rotation = parentRotation; NeedsTerrain = false; //discard parent's resources if (Parent != null) { Parent.DestroyNode(); } var patch = GameObject.AddComponent <Patch>(); var meshFilter = GameObject.AddComponent <MeshFilter>(); GameObject.AddComponent <MeshRenderer>(); GameObject.GetComponent <MeshRenderer>().sharedMaterial = MaterialHelper.CreateTemp(Sphere.Shader, "Patch"); meshFilter.mesh = Mesh; patch.PatchTree = this; }