private void ClassicMaterial() { TerrainLayer ly = editData.layers[_selectProcedural]; if (ly.texture != null) { GUILayout.Label("Modify", PGUIStyle.nodeLabelBold); GUILayout.BeginHorizontal("Box"); GUILayout.Label(PResourceManager.LoadTexture("Terrain/TDiff.jpg")); ly.texture = EditorGUILayout.ObjectField(ly.texture, typeof(Texture2D), true, GUILayout.Width(75), GUILayout.Height(75)) as Texture; TerrainObject tobj = currentSelect.GetComponent <TerrainObject>(); tobj.material.SetTexture("_Splat" + _selectProcedural, ly.texture); if (tobj.material.HasProperty("_BumpSplat" + _selectProcedural)) { GUILayout.Label(PResourceManager.LoadTexture("Terrain/TBump.jpg")); ly.bumpTexture = EditorGUILayout.ObjectField(ly.bumpTexture, typeof(Texture2D), true, GUILayout.Width(75), GUILayout.Height(75)) as Texture; tobj.material.SetTexture("_BumpSplat" + _selectProcedural, ly.bumpTexture); } GUILayout.FlexibleSpace(); GUILayout.EndHorizontal(); } }
public void InstantiateCubes(List <TerrainData_Full> list) { List <TerrainData_Full> SurfaceDataFullList = list; foreach (TerrainData_Full data in SurfaceDataFullList) { Vector3 cubeLoc = new Vector3(data.gridLocX, data.gridLocZ, data.gridLocY); if (!surfacesTop.ContainsKey(cubeLoc)) { GameObject GodNode = _CubeBuilder.BuildMeAFuckingCube(data); TerrainObject newScript = GodNode.GetComponent <TerrainObject> (); GodNode.transform.eulerAngles = new Vector3(GodNode.transform.eulerAngles.x, GetAngle(newScript.cubeRot), 0); GodNode.transform.SetParent(this.transform); int sizeOfCubes = _mapSettings.sizeOfCubes; GodNode.transform.localScale = new Vector3(sizeOfCubes, sizeOfCubes, sizeOfCubes); Vector3 worldLoc = (Vector3)_GridManager.GridLocToWorldLocLookup [cubeLoc]; GodNode.transform.position = worldLoc; surfacesTop.Add(cubeLoc, newScript); } } }
void createterrain(int height = 5) { ///Create the Terrain Object ///Controls how the heigh map is loaded TerrainObject to = new TerrainObject(GraphicFactory, "..\\Content\\Textures\\hmap", new Vector3(0, -30, 0), Matrix.Identity, MaterialDescription.DefaultBepuMaterial(), 3, 3, height); ///Create the Model using the Terrain Object. Here we pass the textures used TerrainModel stm = new TerrainModel(GraphicFactory, to, "TerrainName", "..\\Content\\Textures\\Terraingrass"); stm.SetTexture("..\\Content\\Textures\\Terraingrass", TextureType.DIFFUSE); ForwardXNABasicShader shader = new ForwardXNABasicShader(); ForwardMaterial fmaterial = new ForwardMaterial(shader); ///The object itself obj = new IObject(fmaterial, stm, to); ///Add to the world this.World.AddObject(obj); ///light =p shader.BasicEffect.EnableDefaultLighting(); shader.BasicEffect.SpecularPower = 250; shader.BasicEffect.PreferPerPixelLighting = true; //Fog =P shader.BasicEffect.FogEnabled = true; shader.BasicEffect.FogColor = new Vector3(0.1f, 0.1f, 0.1f); // Dark grey shader.BasicEffect.FogStart = 30; shader.BasicEffect.FogEnd = 300; }
//creates (instantiates) a terrain chunk (but does not render it yet) public void CreateChunk(LODPos pos, bool render) { //if the chunk has aready been created, dont build it again! if (chunks.ContainsKey(pos)) { return; } totalChunks++; //build the terrainobject and add its gameobject to the chunks list(may remove this last thing later) //TerrainObject chunk = Build.buildObject<TerrainObject>(pos.toVector3(), Quaternion.identity); GameObject terrainGO = Pool.getTerrain(); terrainGO.name = "Terrain Chunk " + pos.ToString(); TerrainObject chunk = terrainGO.GetComponent <TerrainObject>(); chunk.init(pos, planet); chunks.Add(pos, chunk); //Debug.Log("chunks added key :" + pos.ToString()); visChunks.Add(pos); if (render) { chunk.calculateNoise(); chunk.Render(); //renders the chunk immediately } //RequestSystem.terrainToRender.Add(chunk); }
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager) { base.LoadContent(GraphicInfo, factory, contentManager); ///Create the Terrain Object ///Controls how the heigh map is loaded TerrainObject to = new TerrainObject(factory, "..\\Content\\Textures\\Untitled", Vector3.Zero, Matrix.Identity, MaterialDescription.DefaultBepuMaterial(), 1, 1, 10); ///Create the Model using the Terrain Object. Here we pass the textures used, in our case we are using MultiTextured Terrain so we pass lots of textures TerrainModel stm = new TerrainModel(factory, to, "TerrainName", "..\\Content\\Textures\\Terraingrass"); stm.SetTexture(factory.CreateTexture2DColor(1, 1, Color.Green), TextureType.DIFFUSE); ///Create the shader ///In this sample we passed lots of textures, each one describe a level in the terrain, the ground is the sand and grass. the hills are rocks and the "mountains" are snow ///They are interpolated in the shader, you can control how using the shader parameters exposed in the DeferredTerrainShader ForwardXNABasicShader shader = new ForwardXNABasicShader(); ///Deferred material ForwardMaterial fmaterial = new ForwardMaterial(shader); ///The object itself IObject obj = new IObject(fmaterial, stm, to); ///Add to the world this.World.AddObject(obj); shader.BasicEffect.EnableDefaultLighting(); CameraFirstPerson cam = new CameraFirstPerson(GraphicInfo.Viewport); this.World.CameraManager.AddCamera(cam); }
public static void deleteTerrain(TerrainObject obj) { obj.reset(); obj.gameObject.SetActive(false); obj.gameObject.name = "pooled terrain"; pooledTerrain.Add(obj.gameObject); //GameObject.Destroy(obj.gameObject); }
private void SetScriptFields(TerrainData_Full data, TerrainObject script) { script.cubeUniqueID = data.cubeUniqueID; script.gridLocX = data.gridLocX; script.gridLocZ = data.gridLocZ; script.gridLocY = data.gridLocY; script.cubeLandType = data.cubeLandType; script.cubeList = data.cubeList; script.cubeType = data.cubeType; script.cubeRot = data.cubeRot; script.cubeSlopeType = data.cubeSlopeType; script.objReplaceable = data.objReplaceable; script.objDestructable = data.objDestructable; script.objList = data.objList; script.objType = data.objType; script.objRot = data.objRot; script.health = data.health; script.Growth = data.Growth; script.surfaceTop = data.surfaceTop; script.surfaceBottom = data.surfaceBottom; script.cubeSetActive = data.cubeSetActive; script.inSight = data.inSight; script.neighVects = data.neighVects; script._01 = data._01; script._03 = data._03; script._04 = data._04; script._05 = data._05; script._07 = data._07; script._09 = data._09; script._10 = data._10; script._11 = data._11; script._12 = data._12; script._14 = data._14; script._15 = data._15; script._16 = data._16; script._17 = data._17; script._19 = data._19; script._21 = data._21; script._22 = data._22; script._23 = data._23; script._25 = data._25; script.sunRiseVect = _SunManager.sunRiseVect; script.sunMidVect = _SunManager.sunMidVect; script.sunSetVect = _SunManager.sunSetVect; script.terrainData = data; }
//deletes all pieces of the given chunk and reactivates it or "combines" all its pieces into it public void combineChunk(LODPos pos) { //reactivate the chunk chunks[pos].gameObject.SetActive(true); //Debug.Log(pos.ToString() + " was activated"); //now find all of its pieces and destroy them //1 level lower int newLev = pos.level - 1; //the position of the first subchunk in this chunk WorldPos newStart = new WorldPos(pos.x * 2, pos.y * 2, pos.z * 2); for (int x = 0; x <= 1; x++) { for (int y = 0; y <= 1; y++) { for (int z = 0; z <= 1; z++) { LODPos newChunk = new LODPos(newLev, newStart.x + x, newStart.y + y, newStart.z + z); TerrainObject tobj = null; if (chunks.TryGetValue(newChunk, out tobj)) { //if the chunk to be deleted is split, combine it first if (splitChunks.Contains(newChunk)) { combineChunk(newChunk); } //remove it from vischunks visChunks.Remove(newChunk); //remove from chunkstosplitrender if it is in it if (chunksToSplitRender.Contains(newChunk)) { chunksToSplitRender.Remove(newChunk); } //finally remove from the chunks dictionary and utterly DESTROY IT (but it will later be pooled chunks.Remove(newChunk); //Object.Destroy(tobj); Pool.deleteTerrain(tobj); //Debug.Log("chunk " + newChunk.ToString() + " was deleted"); } } } } chunks[pos].isSplit = false; if (chunksToSplitRender.Contains(pos)) { chunksToSplitRender.Remove(pos); } //move this from splitchunks to vischunks splitChunks.Remove(pos); visChunks.Add(pos); }
// Use this for initialization void Start() { rig2d = GetComponent <Rigidbody2D>(); //Enables the RigidBody2d component animy = GetComponent <Animator>(); //Allows the animator to work Block = FindObjectOfType <TerrainObject>(); RealMaxspeed = maxspeed; stopjump.Start(); stopwatch.Start(); }
public void Create(VertexGenerator vg, Vector3 origin) { //Track the angle we are currenlty on TerrainAngle = vg.CurrentTerrainRule.Angle; //Create the front mesh and populate our key verts for the front plane MeshPiece mp = new MeshPiece(vg, MeshPiece.Plane.Front, settings); mp.PopulateKeyVerticies(MeshPiece.Plane.Front); //Now create the mesh mp.Create(origin, TerrainAngle); //The first mesh could be null if we are below the minimum verticies we need to create a plane if (mp.MeshObject != null) { //Create a placeholder object for our mesh pieces InstantiateTerrainObject(); //if (meshCollider == null) { // meshCollider = TerrainObject.AddComponent<MeshCollider>(); // meshCollider.convex = true; //} if (terrainCollider == null) { terrainCollider = TerrainObject.AddComponent <TerrainCollider>(); terrainCollider.material = new PhysicMaterial(); } //And add the front plane mesh piece to our list of meshes in the terrain piece MeshPieces.Add(mp); if (settings.DrawDetailMeshRenderer) { MeshPiece mpDetail = new MeshPiece(vg, MeshPiece.Plane.Detail, settings); mpDetail.Create(origin + settings.DetailPlaneOffset, TerrainAngle, mp.KeyTopVerticies); MeshPieces.Add(mpDetail); } if (settings.DrawTopMeshCollider || settings.DrawTopMeshRenderer) { MeshPiece mpTop = new MeshPiece(vg, MeshPiece.Plane.Top, settings); mpTop.Create(mp.StartTopMesh, TerrainAngle, mp.KeyTopVerticies); MeshPieces.Add(mpTop); } //Just to tidy up the heirarchy ParentMeshesToTerrainObject(); } }
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager) { base.LoadContent(GraphicInfo, factory, contentManager); CameraFirstPerson CameraFirstPerson = new CameraFirstPerson(true, GraphicInfo); Texture2D tMap = factory.GetTexture2D("Textures//hmap_10243"); QuadTerrain q = new PloobsEngine.Material.QuadTerrain(factory, tMap, 33, 513, 10, 3f); DeferredTerrainMaterial mat = new DeferredTerrainMaterial(q); //Set various terrain stats. mat.diffuseScale = q.flatScale / 4; mat.detailScale = q.flatScale / 100; mat.detailMapStrength = 2; mat.textureBlend = factory.GetTexture2D("Textures//hmap_256blend"); mat.textureDetail = factory.GetTexture2D("Textures//coolgrass2DOT3"); mat.textureRed = factory.GetTexture2D("Textures//TexR"); mat.textureGreen = factory.GetTexture2D("Textures//TexG"); mat.textureBlue = factory.GetTexture2D("Textures//TexB"); mat.textureBlack = factory.GetTexture2D("Textures//TexBase"); TerrainObject to = new TerrainObject(factory, Vector3.Zero, Matrix.Identity, q.getHeightMap(), MaterialDescription.DefaultBepuMaterial()); IObject obj3 = new IObject(mat, null, to); this.World.AddObject(obj3); LightThrowBepu lt = new LightThrowBepu(this.World, factory); #region NormalLight DirectionalLightPE ld1 = new DirectionalLightPE(Vector3.Left, Color.White); DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Right, Color.White); DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Backward, Color.White); DirectionalLightPE ld4 = new DirectionalLightPE(Vector3.Forward, Color.White); DirectionalLightPE ld5 = new DirectionalLightPE(Vector3.Down, Color.White); float li = 0.5f; ld1.LightIntensity = li; ld2.LightIntensity = li; ld3.LightIntensity = li; ld4.LightIntensity = li; ld5.LightIntensity = li; this.World.AddLight(ld1); this.World.AddLight(ld2); this.World.AddLight(ld3); this.World.AddLight(ld4); this.World.AddLight(ld5); #endregion this.World.CameraManager.AddCamera(CameraFirstPerson); CameraFirstPerson.FarPlane = 20000; SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap"); CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc); }
public List <TerrainObject> CreateTerrainObject(int length, TerrainObject tObj) { List <TerrainObject> newTerrainObject = new List <TerrainObject>(); for (int i = 0; i < length; i++) { newTerrainObject.Add(tObj); } return(newTerrainObject); }
public GridTileOccupant(GameObject obj, Vector3 position, Quaternion rotation, Vector3 scale, OccupantType type) { this.obj = obj; this.position = position; this.rotation = rotation; this.scale = scale; this.terrainObject = obj.GetComponent <TerrainObject>(); this.windEffectController = obj.GetComponent <WindEffectController>(); this.type = type; }
// Constructor, it will be passed the grid location that the tile will be set to. public Tile(Point passedGridLocation, int passedObject, GroundType passedGroundType) { tObject = null; this.GridPosition = passedGridLocation; this.FloorType = passedGroundType; this.DrawPosition = new Point(this.GridPosition.X * GetTileSize().X, this.GridPosition.Y * GetTileSize().Y); this.DrawRectangle = new Rectangle(this.DrawPosition, GetTileSize()); this.tileEffects = SpriteEffects.None; if (this.FloorType == GroundType.Water) { this.IsCollider = true; } }
public TerrainModel(GraphicFactory factory, TerrainObject terrainObject, String TerrainName, String BaseTexture, String NivelBaixo = null, String NivelMedio = null, String NivelAlto = null) : base(factory, TerrainName, false) { this.terrainObject = terrainObject; LoadModelo(factory); TextureInformations[0][0].SetTexture(BaseTexture, TextureType.MULTITEX1); TextureInformations[0][0].SetTexture(NivelBaixo, TextureType.MULTITEX2); TextureInformations[0][0].SetTexture(NivelMedio, TextureType.MULTITEX3); TextureInformations[0][0].SetTexture(NivelAlto, TextureType.MULTITEX4); TextureInformations[0][0].SetTexture(terrainObject.HeightMap, TextureType.HEIGHTMAP); }
private GameObject CreateGhost(TerrainObject selectedPrefab, Vector3 pos) { UnityGraph.LogGameObject(selectedPrefab.gameObject); ResourceDispenser dispenser = selectedPrefab.GetComponent <ResourceDispenser>(); GameObject obj = GameObject.Instantiate(dispenser.AnimatedTransform.GetChild(0).gameObject); obj.layer = Globals.inst.layerTrigger; foreach (var collider in obj.GetComponentsInChildren <MeshCollider>()) { collider.enabled = false; } return(obj); }
public void DetermineAnimationParameters() { terrainObject = GetComponent <TerrainObject>(); objectMesh = GetComponent <MeshFilter>().mesh; TreeAnimationController treeAnimationController = TreeAnimationController.instance; vertices = objectMesh.vertices; terrainObject.animationNumber = treeAnimationController.meshVertices.Count; treeAnimationController.meshVertices.Add(objectMesh.vertices); List <float> randomValues = new List <float>(); for (int i = 0; i < vertices.Length; i++) { randomValues.Add((float)rand.NextDouble()); } treeAnimationController.randomValues.Add(randomValues); int sum = 0; foreach (int submesh in terrainObject.numVerticesPerObject) { sum += submesh; } totalObjects = vertices.Length / sum; List <List <int> > vertPosPerObject = new List <List <int> >(); for (int i = 0; i < totalObjects; i++) { List <int> objectVertPos = new List <int>(); for (int j = 0; j < terrainObject.numVerticesPerObject.Count; j++) { int add = 0; for (int l = 0; l < j; l++) { int a = terrainObject.numVerticesPerObject[l]; add += totalObjects * a; } for (int k = 0; k < terrainObject.numVerticesPerObject[j]; k++) { int vertPos = k + add + i * terrainObject.numVerticesPerObject[j]; objectVertPos.Add(k + add + i * terrainObject.numVerticesPerObject[j]); } } vertPosPerObject.Add(objectVertPos); } treeAnimationController.vertPosPerObject.Add(vertPosPerObject); }
/// <summary> /// Load content for the screen. /// </summary> /// <param name="GraphicInfo"></param> /// <param name="factory"></param> /// <param name="contentManager"></param> protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager) { base.LoadContent(GraphicInfo, factory, contentManager); RasterizerState = new RasterizerState(); RasterizerState.FillMode = FillMode.WireFrame; ///Forward Shader (look at this shader construction for more info) TerrainMaterial material = new TerrainMaterial(factory, "Terrain//HeightMap"); ///The object itself TerrainObject to = new TerrainObject(factory, Vector3.Zero, Matrix.Identity, material.Model.GetHeights(), MaterialDescription.DefaultBepuMaterial()); IObject obj = new IObject(material, null, to); ///Add to the world this.World.AddObject(obj); ///add a camera RotatingCamera cam = new RotatingCamera(this, new Vector3(-200, -100, -300)); this.World.CameraManager.AddCamera(cam); SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubeMap"); CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc); { Texture2D t = factory.CreateTexture2DColor(1, 1, Color.Red); SimpleModel simpleModel = new SimpleModel(factory, "Model/block"); simpleModel.SetTexture(t); ///Forward Shader (look at this shader construction for more info) ForwardXNABasicShader shader = new ForwardXNABasicShader(); ///Forward material ForwardMaterial fmaterial = new ForwardMaterial(shader); for (int i = 0; i < 10; i++) { for (int j = 0; j < 5; j++) { ///Physic info (position, rotation and scale are set here) BoxObject tmesh = new BoxObject(new Vector3(j * 10 + 200, 100, i * 10 + 200), 1, 1, 1, 10, Vector3.One * 2, Matrix.Identity, MaterialDescription.DefaultBepuMaterial()); ///The object itself obj = new IObject(fmaterial, simpleModel, tmesh); ///Add to the world this.World.AddObject(obj); objs.Add(obj); tmesh.isMotionLess = true; } } shader.BasicEffect.EnableDefaultLighting(); } }
/// <summary> /// Asynchron method for loading the sandbox. /// </summary> private IEnumerator loadSandbox() { this.menuCanvasGroup.blocksRaycasts = false; this.startSandboxButton.SetActive(false); TerrainObject terrain = GameObject.Find("Plane").GetComponent <TerrainObject>(); yield return(null); terrain.generateMeshHeights(); this.closeMainMenu(); yield return(null); }
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager) { base.LoadContent(GraphicInfo, factory, contentManager); Picking picking = new Picking(this); this.AddScreenUpdateable(picking); perlim = factory.CreateTexture2DPerlinNoise(512, 512, 0.03f, 3f, 0.5f, 1); to = new TerrainObject(factory, perlim, Vector3.Zero, Matrix.Identity, MaterialDescription.DefaultBepuMaterial(), 2, 2); //TerrainObject to = new TerrainObject(factory,"..\\Content\\Textures\\Untitled",Vector3.Zero,Matrix.Identity,MaterialDescription.DefaultBepuMaterial(),2,1); TerrainModel stm = new TerrainModel(factory, to, "TerrainName", "..\\Content\\Textures\\Terraingrass", "..\\Content\\Textures\\rock", "..\\Content\\Textures\\sand", "..\\Content\\Textures\\snow"); DeferredTerrainShader shader = new DeferredTerrainShader(TerrainType.MULTITEXTURE); DeferredMaterial mat = new DeferredMaterial(shader); IObject obj3 = new IObject(mat, stm, to); this.World.AddObject(obj3); #region NormalLight DirectionalLightPE ld1 = new DirectionalLightPE(Vector3.Left, Color.White); DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Right, Color.White); DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Backward, Color.White); DirectionalLightPE ld4 = new DirectionalLightPE(Vector3.Forward, Color.White); DirectionalLightPE ld5 = new DirectionalLightPE(Vector3.Down, Color.White); float li = 0.5f; ld1.LightIntensity = li; ld2.LightIntensity = li; ld3.LightIntensity = li; ld4.LightIntensity = li; ld5.LightIntensity = li; this.World.AddLight(ld1); this.World.AddLight(ld2); this.World.AddLight(ld3); this.World.AddLight(ld4); this.World.AddLight(ld5); #endregion this.World.CameraManager.AddCamera(new CameraFirstPerson(true, GraphicInfo)); SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//cubemap"); CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc); ///O PICKING FUNCIONA APENAS COM OBJETOS QUE TENHAM CORPO FISICO REAL !!! ///OS GHOST E OS DUMMY NUNCA SERAO SELECIONADOS ///Para ser informado a todo frame sobre as colisoes do raio, basta utilizar o outro construtor picking.OnPickedLeftButton += new OnPicked(onPick); }
protected override void LoadContent(GraphicInfo GraphicInfo, GraphicFactory factory, IContentManager contentManager) { base.LoadContent(GraphicInfo, factory, contentManager); ///Create the Terrain Object ///Controls how the heigh map is loaded TerrainObject to = new TerrainObject(factory, "..\\Content\\Textures\\Untitled", Vector3.Zero, Matrix.Identity, MaterialDescription.DefaultBepuMaterial(), 2, 1); ///Create the Model using the Terrain Object. Here we pass the textures used, in our case we are using MultiTextured Terrain so we pass lots of textures TerrainModel stm = new TerrainModel(factory, to, "TerrainName", "..\\Content\\Textures\\Terraingrass", "..\\Content\\Textures\\rock", "..\\Content\\Textures\\sand", "..\\Content\\Textures\\snow"); ///Create the shader ///In this sample we passed lots of textures, each one describe a level in the terrain, the ground is the sand and grass. the hills are rocks and the "mountains" are snow ///They are interpolated in the shader, you can control how using the shader parameters exposed in the DeferredTerrainShader DeferredTerrainShader shader = new DeferredTerrainShader(TerrainType.MULTITEXTURE); ///the classic material DeferredMaterial mat = new DeferredMaterial(shader); IObject obj3 = new IObject(mat, stm, to); this.World.AddObject(obj3); lt = new LightThrowBepu(this.World, factory); #region NormalLight DirectionalLightPE ld1 = new DirectionalLightPE(Vector3.Left, Color.White); DirectionalLightPE ld2 = new DirectionalLightPE(Vector3.Right, Color.White); DirectionalLightPE ld3 = new DirectionalLightPE(Vector3.Backward, Color.White); DirectionalLightPE ld4 = new DirectionalLightPE(Vector3.Forward, Color.White); DirectionalLightPE ld5 = new DirectionalLightPE(Vector3.Down, Color.White); float li = 0.5f; ld1.LightIntensity = li; ld2.LightIntensity = li; ld3.LightIntensity = li; ld4.LightIntensity = li; ld5.LightIntensity = li; this.World.AddLight(ld1); this.World.AddLight(ld2); this.World.AddLight(ld3); this.World.AddLight(ld4); this.World.AddLight(ld5); #endregion CameraFirstPerson cam = new CameraFirstPerson(MathHelper.ToRadians(30), MathHelper.ToRadians(-10), new Vector3(200, 150, 250), GraphicInfo); this.World.CameraManager.AddCamera(cam); SkyBoxSetTextureCube stc = new SkyBoxSetTextureCube("Textures//grassCube"); CommandProcessor.getCommandProcessor().SendCommandAssyncronous(stc); this.RenderTechnic.AddPostEffect(new AntiAliasingPostEffectStalker()); }
private void UpdateTerrainComponent() { if (editData.nbrTerrainObject == 0) { TerrainObject _child = editData.defaultChild.gameObject.GetComponent <TerrainObject>(); _child.enabledLODSystem = editData.activateLOD; _child.enabledBillboard = editData.activateBillboard; _child.enabledLayerCul = editData.activateLayerCul; _child.closeView = editData.closeView; _child.normalView = editData.normalView; _child.farView = editData.farView; _child.backgroundView = editData.backgroundView; _child.master = 1; } }
public void RemoveTerrainObject(HexCoordinates coordinates) { //TODO this could be more efficient CellStack stack = GetCellStackFromWorldCoords(coordinates); if (stack) { Vector2Int index = stack.indexWithinChunk; TerrainObject obj = terrainObjects[index.x, index.y]; if (obj != null) { terrainObjects[index.x, index.y] = null; GameObject.Destroy(obj.gameObject); } } }
public void GenerateObjects(TerrainObject objectInfo) { cleanUpObjects(); int width = heightMap.GetLength(0); int height = heightMap.GetLength(1); NoiseParameters noiseParameters = objectInfo.noise; float[,] noiseMap = Noise.GenerateNoiseMap(width, height, Random.Range(0, int.MaxValue), noiseParameters.noiseScale, noiseParameters.octaves, noiseParameters.persistance, noiseParameters.lacunarity, Vector2.zero); float startHeight = heightCurve.Evaluate(objectInfo.startHeight) * heightMultiplier; float endHeight = heightCurve.Evaluate(objectInfo.endHeight) * heightMultiplier; for (int j = 0; j < height; j++) { for (int i = 0; i < width; i++) { float y = heightCurve.Evaluate(heightMap[i, j]) * heightMultiplier; if (y >= startHeight && y <= endHeight && noiseMap[i, j] > objectInfo.noiseThreshold) { Vector3 pos = new Vector3((width - 1) / -2f + i, y, (height - 1) / 2f - j) * uniformScale; pos += new Vector3(Random.Range(-1f, 1f), 0, Random.Range(-1f, 1f)) * 0.2f; pos += transform.position; IslandObject obj = Instantiate(objectInfo.prefab, pos, Quaternion.identity); obj.transform.SetParent(objectContainer, true); obj.Generate(); // Align the rotation of the object to the normal of the terrain at that point if (objectInfo.alignToNormal) { Ray ray = new Ray(pos + Vector3.up * 10, Vector3.down); RaycastHit hitInfo; bool hit = mesh.meshCollider.Raycast(ray, out hitInfo, Mathf.Infinity); if (hit) { obj.transform.up = hitInfo.normal; } } } } } }
/* * void OnTriggerEnter2D(Collider2D other) { * * // Check if there is a terrain object that is blocking the path on this tile * TerrainObject terrainObj = other.GetComponent<TerrainObject>(); * if(terrainObj) * { * // If the terrain object is a barrier, then this tile is not patheable * isPatheable = !terrainObj.isBarrier; * } * * } */ /// <summary> /// Automatically detects if there is a barrier terrain object on this tile /// setting the isPatheable field accordingly. /// /// To use right-click isPatheable field and select "Set Patheable" /// </summary> private void SetPatheable() { bool cleanUpCollider = false; // Checks to see if we should remove temporarily created collider Collider2D tileCollider = GetComponent <Collider2D>(); if (tileCollider == null) { // Create a temporary collider to raycast from cleanUpCollider = true; tileCollider = gameObject.AddComponent <BoxCollider2D>(); } // Create raycast to see if there are any barriers on this tile RaycastHit2D[] results = Physics2D.BoxCastAll(transform.position, new Vector2(0.98f, 0.98f), 0, Vector2.zero, 0); //Debug.Log("Num col: " + results.Length); isPatheable = true; // If there were any collision, then check if colliding object is a terrain barrier if (results.Length > 0) { //check if each collider is a barrier for (int i = 0; i < results.Length; i++) { TerrainObject terrainObj = results[i].collider.GetComponent <TerrainObject>(); //Debug.Log(results[i].collider.gameObject.name); if (terrainObj) { if (terrainObj.isBarrier) { isPatheable = false; break; } } } } if (cleanUpCollider) { // Clean up temporary collider DestroyImmediate(tileCollider); } }
private TerrainObject ParseTerrainObject(JObject currentGameObject, GameObject parent = null) { var name = JSONHelper.GetValue("Name", currentGameObject); var model = JSONHelper.GetValue("Model", currentGameObject); var IsEnabled = JSONHelper.ToBool(JSONHelper.GetValue("isEnabled", currentGameObject)); var mod = ToylandSiege.GetInstance().Content.Load <Model>(model); var terrainObj = new TerrainObject(name, mod); terrainObj.IsEnabled = IsEnabled; terrainObj.IsStatic = true; terrainObj.IsCollidable = true; terrainObj.Type = JSONHelper.GetValue("Type", currentGameObject); terrainObj.Parent = parent; if (JSONHelper.ValueExist("Position", currentGameObject)) { terrainObj.Position = JSONHelper.ParseVector3(currentGameObject.GetValue("Position")); } if (JSONHelper.ValueExist("Rotation", currentGameObject)) { terrainObj.Rotation = JSONHelper.ParseVector3(currentGameObject.GetValue("Rotation")); } if (JSONHelper.ValueExist("Scale", currentGameObject)) { terrainObj.Scale = JSONHelper.ParseVector3(currentGameObject.GetValue("Scale")); } terrainObj.CreateTransformationMatrix(); if (JSONHelper.ValueExist("Child", currentGameObject)) { for (int i = 0; i < currentGameObject.GetValue("Child").Count(); i++) { terrainObj.AddChild(ParseGameObject(currentGameObject.GetValue("Child")[i].ToObject <JObject>(), terrainObj)); } } // TODO: Load from a config file? terrainObj.Collider.BType = Collider.BoundingType.Box; terrainObj.Collider.RecreateBounding(); return(terrainObj); }
internal void CheckShader() { TerrainObject curr = currentSelect.GetComponent <TerrainObject>(); foreach (var a in TerrainShader.pool) { if (a.shader == curr.material.shader) { shaderType = (TerrainShaderType)a.type; if (curr.material.HasProperty("_Tiling")) { upsideTile = curr.material.GetVector("_Tiling"); upsideF = curr.material.GetFloat("_UpSide"); blendFac = curr.material.GetFloat("_Blend"); } } } }
private void AddContainerComponents(GameObject GodNode, TerrainData_Full data) { TerrainObject newTerrainScript = GodNode.AddComponent <TerrainObject>(); SetScriptFields(data, newTerrainScript); foreach (SelectObject script in selectObjects) { script.terrainscript = newTerrainScript; } newTerrainScript.ConnectObjectLinks(); BoxCollider boxColl = GodNode.AddComponent <BoxCollider> (); boxColl.isTrigger = true; Vector3 collPos = new Vector3(0, 0.5f, 0); boxColl.center = collPos; }
// Method that removes an occupant from a grid tile public void RemoveTerrainTileOccupant(GridTile tile) { for (int i = 0; i < tile.occupants.Count; i++) { // if type is Terrain Generated if (tile.occupants[i].type == GridTileOccupant.OccupantType.TerrainGenerated) { // Get the terrainObject script from the occupant TerrainObject terrainObj = tile.occupants[i].obj.GetComponent <TerrainObject>(); // Get the submeshes that should be in this particular terrain object from the biomemeshes Mesh[] objMeshes = thisTerrainController.biomeMeshes[terrainObj.biome].mesh[terrainObj.objectNR]; // create an object of with info of the object that should be removed // for each of these meshes for (int k = 0; k < objMeshes.Length; k++) { Vector3 startVert = objMeshes[k].vertices[0]; startVert = new Vector3(startVert.x * tile.occupants[i].scale.x, startVert.y * tile.occupants[i].scale.y, startVert.z * tile.occupants[i].scale.z); // scale, rotate and move the vertex according to inputs startVert = tile.occupants[i].rotation * startVert; startVert = startVert + (tile.occupants[i].position - terrainObj.transform.position); int numVerts = objMeshes[k].vertexCount; // Add a copy of the mesh that should be removed. Move, rotate and scale it as it is in the game. terrainObj.RemoveMesh(new MoveMeshObj(startVert, numVerts)); } } } for (int i = 0; i < tile.occupants.Count; i++) { // if type is Terrain Generated if (tile.occupants[i].type == GridTileOccupant.OccupantType.TerrainGenerated) { // set the tile occupant to null tile.occupants.RemoveAt(i); } } }
//generates a chunk if it will exist but first generates all chunk levels above it and subdivides them //returns true if the chunk is successfully created public bool requestChunk(LODPos pos) { //Debug.Log(pos.ToString()); //if it is already built, we are done if (chunks.ContainsKey(pos)) { return(true); } LODPos abovePos = getAbove(pos); if (chunks.ContainsKey(getAbove(pos))) { TerrainObject above = null; chunks.TryGetValue(abovePos, out above); //if it is already split, the current terrian chunk will never exist if (above.isSplit) { return(false); } else { //split the chunk and then check if the chunk exists now splitChunk(abovePos); return(chunks.ContainsKey(pos)); } } else //the above chunk does not exist { //request the above chunk to be generated, and if it is, split it and check if the current chunk is generated if (requestChunk(abovePos)) { splitChunk(abovePos); return(chunks.ContainsKey(pos)); } return(false); } }
public void AddTerrainObject (TerrainObject newTerrainObject) { terrainObjects.Add(newTerrainObject); }
public void RemoveTerrainObject (TerrainObject objectToRemove) { terrainObjects.Remove(objectToRemove); }