public void Update(GameTime gameTime)
{
UpdateCamera();
if (Map.CursorPositionVisible.X < 0)
{
Camera.CameraHeight = 600;
Camera.CameraDistance = 500;
Camera.SetTarget(new Vector3(Map.TileSize.X * Map.MapSize.X / 2, Map.CursorPosition.Z * 32, Map.TileSize.Y * Map.MapSize.Y / 2));
Camera.Update(gameTime);
return;
}
Camera.CameraHeight = 400;
Camera.CameraDistance = 300;
int X = (int)Map.CursorPositionVisible.X;
int Y = (int)Map.CursorPositionVisible.Y;
float Z = Map.LayerManager.ListLayer[(int)Map.CursorPosition.Z].ArrayTerrain[X, Y].Position.Z * 32 + (Map.CursorPosition.Z * 32) + 0.3f;
Map2D GroundLayer = Map.LayerManager.ListLayer[(int)Map.CursorPosition.Z].LayerGrid;
DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y);
Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo;
Cursor = ActiveTerrain3D.CreateTile3D(0, Point.Zero,
X * Map.TileSize.X, Y * Map.TileSize.Y, Z, Map.CursorPosition.Z * 32 + 0.3f, Map.TileSize, new List <Texture2D>()
{
sprCursor
}, Z, Z, Z, Z, 0)[0];
Camera.SetTarget(new Vector3(Map.TileSize.X * Map.CursorPositionVisible.X, Map.CursorPosition.Z * 32, Map.TileSize.Y * Map.CursorPositionVisible.Y));
Camera.Update(gameTime);
DicDrawablePointPerColor.Clear();
ListDrawableArrowPerColor.Clear();
}
private void OnDisable()
{
Terrain3D terrain3D = (Terrain3D)target;
terrain3D.Refresh();
Tools.hidden = false;
}
public void AddDrawablePath(List <MovementAlgorithmTile> ListPoint)
{
for (int P = 1; P < ListPoint.Count; P++)
{
MovementAlgorithmTile ActivePoint = ListPoint[P];
MovementAlgorithmTile Previous = ListPoint[P - 1];
MovementAlgorithmTile Next = null;
if (P + 1 < ListPoint.Count)
{
Next = ListPoint[P + 1];
}
int X = (int)ActivePoint.Position.X;
int Y = (int)ActivePoint.Position.Y;
float Z = Map.LayerManager.ListLayer[ActivePoint.LayerIndex].ArrayTerrain[X, Y].Position.Z * 32 + (ActivePoint.LayerIndex * 32) + 0.1f;
Map2D GroundLayer = Map.LayerManager.ListLayer[ActivePoint.LayerIndex].LayerGrid;
DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y);
Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo;
ListDrawableArrowPerColor.Add(ActiveTerrain3D.CreateTile3D(0, GetCursorTextureOffset(Previous, ActivePoint, Next),
X * Map.TileSize.X, Y * Map.TileSize.Y, Z, Z + 0.15f, Map.TileSize, new List <Texture2D>()
{
Map.sprCursorPath
}, Z, Z, Z, Z, 0)[0]);
}
}
private void DrawProperties()
{
Terrain3D terrain3D = (Terrain3D)target;
terrain3D.chunks = EditorGUILayout.IntField("Chunks", terrain3D.chunks);
terrain3D.chunkSize = EditorGUILayout.IntField("Chunk Size", terrain3D.chunkSize);
terrain3D.resolution = EditorGUILayout.IntField("Resolution", terrain3D.resolution);
}
protected void CreateMap(DeathmatchMap Map, MapLayer Owner, int LayerIndex)
{
Map2D GroundLayer = Owner.LayerGrid;
for (int X = Map.MapSize.X - 1; X >= 0; --X)
{
for (int Y = Map.MapSize.Y - 1; Y >= 0; --Y)
{
DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y);
Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo;
if (ActiveTerrain3D.TerrainStyle == Terrain3D.TerrainStyles.Invisible)
{
continue;
}
float Z = Owner.ArrayTerrain[X, Y].Position.Z * 32 + (LayerIndex * 32);
float ZFront = Z;
float ZBack = Z;
float ZRight = Z;
float ZLeft = Z;
if (Y + 1 < Map.MapSize.Y)
{
ZFront = Owner.ArrayTerrain[X, Y + 1].Position.Z * 32 + (LayerIndex * 32);
}
if (Y - 1 >= 0)
{
ZBack = Owner.ArrayTerrain[X, Y - 1].Position.Z * 32 + (LayerIndex * 32);
}
if (X - 1 >= 0)
{
ZLeft = Owner.ArrayTerrain[X - 1, Y].Position.Z * 32 + (LayerIndex * 32);
}
if (X + 1 < Map.MapSize.X)
{
ZRight = Owner.ArrayTerrain[X + 1, Y].Position.Z * 32 + (LayerIndex * 32);
}
List <Tile3D> ListNew3DTile = ActiveTerrain3D.CreateTile3D(ActiveTerrain.TilesetIndex, ActiveTerrain.Origin.Location,
X * Map.TileSize.X, Y * Map.TileSize.Y, Z, LayerIndex * 32, Map.TileSize, Map.ListTileSet, ZFront, ZBack, ZLeft, ZRight, 0);
foreach (Tile3D ActiveTile in ListNew3DTile)
{
if (!DicTile3DByTileset.ContainsKey(ActiveTile.TilesetIndex))
{
DicTile3DByTileset.Add(ActiveTile.TilesetIndex, new Tile3DHolder(effect, Map.ListTileSet[ActiveTile.TilesetIndex]));
}
DicTile3DByTileset[ActiveTile.TilesetIndex].AddTile(ActiveTile);
}
}
}
for (int L = 0; L < Owner.ListSubLayer.Count; L++)
{
CreateMap(Map, Owner.ListSubLayer[L], LayerIndex);
}
}
private void OnEnable()
{
Terrain3D terrain3D = (Terrain3D)target;
terrain3D.Initialize();
terrain3D.Refresh();
Tools.hidden = true;
EditorUtility.SetSelectedRenderState(terrain3D.gameObject.GetComponent <Renderer>(), EditorSelectedRenderState.Hidden);
}
public void Update(Terrain3D terrain3D)
{
if (currentVoxel == null || currentVoxel.Value >= Mathf.Abs(0.95f))
{
NextVoxel(terrain3D);
}
currentVoxel.Value += 0.1f;
terrain3D.Refresh();
}
private static void Create()
{
GameObject terrain3DGameObject = new GameObject("Terrain3D");
Terrain3D terrain3D = (Terrain3D)terrain3DGameObject.AddComponent(typeof(Terrain3D));
terrain3D.Initialize();
terrain3D.Refresh();
Terrain3DObject terrain3DObject = CreateInstance <Terrain3DObject>();
AssetDatabase.CreateAsset(terrain3DObject, "Assets/Terrain3D.asset");
AssetDatabase.SaveAssets();
}
public BrushHit[] Paint(Terrain3D terrain3D)
{
List <BrushHit> brushHits = new List <BrushHit>();
// Cast a ray through a screen point and return the hit point.
Camera cam = Camera.current;
if (!cam)
{
return(new BrushHit[0]);
}
SceneView sceneView = SceneView.currentDrawingSceneView;
if (!sceneView)
{
return(new BrushHit[0]);
}
Event e = Event.current;
Vector3 mousePosition = e.mousePosition;
mousePosition.y = sceneView.camera.pixelHeight - e.mousePosition.y;
Ray ray = cam.ScreenPointToRay(mousePosition);
RaycastHit hit;
if (Physics.Raycast(ray, out hit, Mathf.Infinity))
{
float length = (cam.transform.position - hit.point).magnitude / 30.0f;
Handles.color = Color.blue;
Handles.DrawLine(hit.point, hit.point + hit.normal * length);
Handles.CircleHandleCap(0, hit.point, Quaternion.LookRotation(hit.normal), size + 5.0f, EventType.Repaint);
Handles.CircleHandleCap(0, hit.point, Quaternion.LookRotation(hit.normal), size + falloff, EventType.Repaint);
// Transform the hit point from world space to local space
Vector3 localHit = terrain3D.transform.InverseTransformPoint(hit.point);
TerrainChunk chunk = terrain3D.terrainChunk;
int hitX = (int)(localHit.x / chunk.multiplier);
int hitY = (int)(localHit.y / chunk.multiplier);
int hitZ = (int)(localHit.z / chunk.multiplier);
int hitIndex = hitX + chunk.size * hitY + chunk.size2 * hitZ;
brushHits.Add(new BrushHit(chunk.voxels[hitIndex], strength * 0.1f * Time.deltaTime));
}
return(brushHits.ToArray());
}
public override void LoadNode()
{
_Width = IOHelp.ReadFloat();
_Depth = IOHelp.ReadFloat();
_YScale = IOHelp.ReadFloat();
_HeightMapPath = IOHelp.ReadString();
Node3D prev_t = SceneGraph3D.CurScene.FindNode("TerrainObjNode");
if (prev_t != null)
{
TerrainNode = prev_t as Terrain3D;
// SceneGraph3D.CurScene.Remove(prev_t);
}
}
public Viewer3D() : base("3D Viewer")
{
DisplayObject = new Object3D();
_oldCamera = Engine.Renderer.Camera;
Engine.Renderer.Camera = new Camera3D(new Vector3(20, 50, 200));
Engine.Renderer.Camera.LookAt = Vector3.Normalize(Vector3.Zero - Engine.Renderer.Camera.Position);
_skeletalShader ??= Engine.AssetLoader.Get <ShaderAsset>("Shaders/SkeletalAnim.xml");
if (_boneVerticesStream == null)
{
GLThread.ExecuteGLThreadAsync(() => { _boneVerticesStream = new RenderStreamBatch <VertexDataWithBones>(0, 1, false); });
}
_terrain = new Terrain3D(32, 32, 16);
_windowFlags |= ImGuiWindowFlags.MenuBar;
}
private void OnSceneGUI()
{
Terrain3D terrain3D = (Terrain3D)target;
Event e = Event.current;
switch (selectedTab)
{
case 0:
elevation.Update(terrain3D);
break;
default:
break;
}
SceneView.RepaintAll();
}
private void NextVoxel(Terrain3D terrain3D)
{
if (numColumns < 10)
{
if (indexY == -1)
{
indexY = terrain3D.terrainChunk.size / 2;
indexX = random.Next() % terrain3D.terrainChunk.size;
indexZ = random.Next() % terrain3D.terrainChunk.size;
}
else if (indexY < terrain3D.terrainChunk.size)
{
++indexY;
}
else
{
indexY = terrain3D.terrainChunk.size / 2;
indexX = random.Next() % terrain3D.terrainChunk.size;
indexZ = random.Next() % terrain3D.terrainChunk.size;
++numColumns;
if (numColumns >= 10)
{
NextVoxel(terrain3D);
return;
}
}
}
else
{
indexY = terrain3D.terrainChunk.size - 1;
indexX = random.Next() % terrain3D.terrainChunk.size;
indexZ = random.Next() % terrain3D.terrainChunk.size;
}
int index = indexX + indexY * terrain3D.terrainChunk.size + indexZ * terrain3D.terrainChunk.size2;
currentVoxel = terrain3D.terrainChunk.voxels[index];
}
public void AddDrawablePoints(List <MovementAlgorithmTile> ListPoint, Color PointColor)
{
List <Tile3D> ListDrawablePoint3D = new List <Tile3D>(ListPoint.Count);
foreach (MovementAlgorithmTile ActivePoint in ListPoint)
{
int X = (int)ActivePoint.Position.X;
int Y = (int)ActivePoint.Position.Y;
float Z = Map.LayerManager.ListLayer[ActivePoint.LayerIndex].ArrayTerrain[X, Y].Position.Z * 32 + (ActivePoint.LayerIndex * 32) + 0.1f;
Map2D GroundLayer = Map.LayerManager.ListLayer[ActivePoint.LayerIndex].LayerGrid;
DrawableTile ActiveTerrain = GroundLayer.GetTile(X, Y);
Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo;
ListDrawablePoint3D.Add(ActiveTerrain3D.CreateTile3D(0, Point.Zero,
X * Map.TileSize.X, Y * Map.TileSize.Y, Z, Z + 0.1f, Map.TileSize, new List <Texture2D>()
{
sprCursor
}, Z, Z, Z, Z, 0)[0]);
}
DicDrawablePointPerColor.Add(PointColor, ListDrawablePoint3D);
}
public override void ApplyInEditor()
{
if (TerrainNode == null)
{
TerrainNode = SceneGraph3D.CurScene.FindNode("TerrainObjNode") as Terrain3D;
}
if (TerrainNode != null)
{
SceneGraph3D.CurScene.Remove(TerrainNode);
}
if (_HeightMapPath == "")
{
TerrainNode = new Terrain3D(_Width, _Depth, 0, 32, 32);
TerrainNode.Name = "TerrainObjNode";
SceneGraph3D.CurScene.Root.Add(TerrainNode);
}
else
{
TerrainNode = new Terrain3D(_Width, _Depth, 0, _YScale, 32, 32, new Texture2D(_HeightMapPath, LoadMethod.Single, false));
TerrainNode.Name = "TerrainObjNode";
SceneGraph3D.CurScene.Root.Add(TerrainNode);
}
}
public void Update(Terrain3D terrain3D)
{
Event e = Event.current;
if ((e.type == EventType.KeyDown) && e.keyCode == (KeyCode.B))
{
isButtonIsDown = true;
GUIUtility.hotControl = 0;
}
if ((e.type == EventType.KeyUp) && e.keyCode == (KeyCode.B))
{
isButtonIsDown = false;
}
if ((e.type == EventType.MouseDown) && e.button == 0)
{
isMouseIsDown = true;
GUIUtility.hotControl = 0;
}
if (((e.type == EventType.MouseUp) && e.button == 0) || e.alt)
{
isMouseIsDown = false;
}
if (isButtonIsDown)
{
Vector3 currentMousePosition = Event.current.mousePosition;
float xMovement = oldMousePosition.x - currentMousePosition.x;
oldMousePosition = currentMousePosition;
if (xMovement != 0.0f)
{
brush.Size += xMovement / 3;
}
}
if (isMouseIsDown)
{
BrushHit[] hits = brush.Paint(terrain3D);
for (int i = 0; i < hits.Length; ++i)
{
hits[i].voxel.Value += hits[i].influence;
}
terrain3D.Refresh();
}
else
{
if (!isButtonIsDown)
{
brush.DrawBrush();
}
else
{
brush.DrawPrevious();
}
}
}
public Map3DDrawable(DeathmatchMap Map, GraphicsDevice g)
{
this.Map = Map;
sprCursor = Map.sprCursor;
Camera = new DefaultCamera(g);
effect = Map.Content.Load <Effect>("Shaders/Default Shader 3D");
PolygonEffect = new BasicEffect(g);
PolygonEffect.TextureEnabled = true;
PolygonEffect.EnableDefaultLighting();
float aspectRatio = g.Viewport.Width / (float)g.Viewport.Height;
Matrix Projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4,
aspectRatio,
1, 10000);
PolygonEffect.Projection = Projection;
PolygonEffect.World = Matrix.Identity;
PolygonEffect.View = Matrix.Identity;
// Key light.
effect.Parameters["DirLight0Direction"].SetValue(new Vector3(-0.5265408f, -0.5735765f, -0.6275069f));
effect.Parameters["DirLight0DiffuseColor"].SetValue(new Vector3(1, 0.9607844f, 0.8078432f));
effect.Parameters["DirLight0SpecularColor"].SetValue(new Vector3(1, 0.9607844f, 0.8078432f));
// Fill light.
effect.Parameters["DirLight1Direction"].SetValue(new Vector3(0.7198464f, 0.3420201f, 0.6040227f));
effect.Parameters["DirLight1DiffuseColor"].SetValue(new Vector3(0.9647059f, 0.7607844f, 0.4078432f));
effect.Parameters["DirLight1SpecularColor"].SetValue(Vector3.Zero);
// Back light.
effect.Parameters["DirLight2Direction"].SetValue(new Vector3(0.4545195f, -0.7660444f, 0.4545195f));
effect.Parameters["DirLight2DiffuseColor"].SetValue(new Vector3(0.3231373f, 0.3607844f, 0.3937255f));
effect.Parameters["DirLight2SpecularColor"].SetValue(new Vector3(0.3231373f, 0.3607844f, 0.3937255f));
Vector3 diffuseColor = Vector3.One;
Vector3 emissiveColor = Vector3.Zero;
Vector3 ambientLightColor = new Vector3(0.05333332f, 0.09882354f, 0.1819608f);
Vector4 diffuse = new Vector4();
Vector3 emissive = new Vector3();
float alpha = 1;
diffuse.X = diffuseColor.X * alpha;
diffuse.Y = diffuseColor.Y * alpha;
diffuse.Z = diffuseColor.Z * alpha;
diffuse.W = alpha;
emissive.X = (emissiveColor.X + ambientLightColor.X * diffuseColor.X) * alpha;
emissive.Y = (emissiveColor.Y + ambientLightColor.Y * diffuseColor.Y) * alpha;
emissive.Z = (emissiveColor.Z + ambientLightColor.Z * diffuseColor.Z) * alpha;
effect.Parameters["DiffuseColor"].SetValue(diffuse);
effect.Parameters["EmissiveColor"].SetValue(emissive);
effect.Parameters["SpecularColor"].SetValue(Vector3.One);
effect.Parameters["SpecularPower"].SetValue(64);
DicDrawablePointPerColor = new Dictionary <Color, List <Tile3D> >();
DicTile3DByTileset = new Dictionary <int, Tile3DHolder>();
ListDrawableArrowPerColor = new List <Tile3D>();
for (int L = 0; L < Map.LayerManager.ListLayer.Count; L++)
{
CreateMap(Map, Map.LayerManager.ListLayer[L], L);
}
foreach (KeyValuePair <int, Tile3DHolder> ActiveTileSet in DicTile3DByTileset)
{
ActiveTileSet.Value.Finish(GameScreen.GraphicsDevice);
}
float Z = Map.LayerManager.ListLayer[0].ArrayTerrain[0, 0].Position.Z * 32;
Map2D GroundLayer = Map.LayerManager.ListLayer[0].LayerGrid;
DrawableTile ActiveTerrain = GroundLayer.GetTile(0, 0);
Terrain3D ActiveTerrain3D = ActiveTerrain.Terrain3DInfo;
Cursor = ActiveTerrain3D.CreateTile3D(0, Point.Zero,
0, 0, Z, 0, Map.TileSize, new List <Texture2D>()
{
sprCursor
}, Z, Z, Z, Z, 0)[0];
}
private void Update()
{
Terrain3D terrain3D = (Terrain3D)target;
automatedTest.Update(terrain3D);
}
public override void OnInspectorGUI()
{
Terrain3D terrain3D = (Terrain3D)target;
selectedTab = GUILayout.Toolbar(selectedTab, tabs);
switch (selectedTab)
{
case 0:
elevation.DrawInspector();
break;
case 1:
paint.DrawInspector();
break;
case 2:
DrawProperties();
break;
default:
break;
}
GUILayout.BeginHorizontal();
if (isEditing)
{
if (GUILayout.Button("Disable Editing"))
{
isEditing = false;
}
}
else
{
if (GUILayout.Button("Enable Editing"))
{
isEditing = true;
}
}
if (GUILayout.Button("Force Refresh"))
{
}
GUILayout.EndHorizontal();
EditorGUILayout.LabelField("Profiling", EditorStyles.boldLabel);
if (isRunningTest)
{
if (GUILayout.Button("Stop Test"))
{
EditorApplication.update -= Update;
isRunningTest = false;
terrain3D.Initialize();
terrain3D.Refresh();
}
}
else
{
if (GUILayout.Button("Run Test"))
{
EditorApplication.update += Update;
isRunningTest = true;
terrain3D.Initialize();
terrain3D.Refresh();
automatedTest.Start();
}
}
}
private void Refresh()
{
Terrain3D terrain3D = (Terrain3D)target;
terrain3D.Refresh();
}
private void Initialize()
{
Terrain3D terrain3D = (Terrain3D)target;
terrain3D.Initialize();
}
