public override void OnInspectorGUI()
{
DrawDefaultInspector();
if (GUILayout.Button("Generate"))
{
TerrainMesh terrain = (TerrainMesh)target;
terrain.Generate();
}
}
public Chunk(GenerationSetting settings, ChunkPosition position)
{
this.settings = settings;
this.position = position;
meshObj = new TerrainMesh(75, settings.meshSize, settings.meshSize).GetMeshGameObject();
vertices = meshObj.GetComponent<MeshFilter>().mesh.vertices;
size = meshObj.GetComponent<MeshFilter>().mesh.bounds.size;
}
public Terrain(Program owner)
{
vegetation = new Vegetation(owner);
ground = new GameObject();
heightMap = new Heightmap("data/text_height.png", 1000f, 100, 100);
heightMap.MaxHeight = 100f;
TerrainMesh sceneryMesh = new TerrainMesh(1.0f, heightMap);
//sceneryMesh.Texture = new Bonsai.Objects.Textures.TextureBase("data\\grass.png");
ground.Mesh = sceneryMesh;
//ground.RotateXAngle = (float)Math.PI / 2;
splatShader = new ShaderBase("splatting", "splatting3.fx");
if (Framework.Instance.DeviceCaps.PixelShaderVersion.Major >= 3)
{
splatShader.SetTechnique("TextureSplatting_fx30");
}
else
{
splatShader.SetTechnique("TextureSplatting");
}
splatShader.SetVariable("matViewProj", ShaderBase.ShaderParameters.CameraProjection);
splatShader.SetVariable("sunPosition", new Vector3(1, 1, 1));
splatShader.SetVariable("underwater", 0.0f);
splatShader.SetVariable("matWorld", ShaderBase.ShaderParameters.World);
splatShader.SetVariable("matInvertTransposeWorld", ShaderBase.ShaderParameters.WorldInvertTranspose);
splatShader.SetVariable("cameraPos", ShaderBase.ShaderParameters.CameraPosition);
splatShader.SetVariable("nearRepeat", 64.0f);
splatShader.SetVariable("farRepeat", 20.0f);
splatShader.SetVariable("nearFactor2", 3.0f);
splatShader.SetVariable("farFactor2", 2.0f);
splatShader.SetVariable("nearFactor3", 3.0f);
splatShader.SetVariable("farFactor3", 2.0f);
splatShader.SetVariable("nearFactor4", 3.0f);
splatShader.SetVariable("farFactor4", 2.0f);
splatShader.SetVariable("blendSqDistance", 50f * 50f);
splatShader.SetVariable("blendSqWidth", 1.0f / (200f * 200f));
TextureBase normalMap = new TextureBase("data/text_norm.png");
TextureBase alphaMap = new TextureBase("data/text.dds");
TextureBase grassTexture = new TextureBase("data/grass.png");
TextureBase rockTexture = new TextureBase("data/rock.png");
TextureBase rockNormal = new TextureBase("data/splat_rock_normal.jpg");
TextureBase sandTexture = new TextureBase("data/sand.png");
TextureBase concreteTexture = new TextureBase("data/road.png");
splatShader.SetVariable("NormalMapTexture", normalMap);
splatShader.SetVariable("AlphaTexture", alphaMap);
splatShader.SetVariable("DetailTexture1", grassTexture);
splatShader.SetVariable("DetailTexture2", rockTexture);
splatShader.SetVariable("DetailTexture2NormalMap", rockNormal);
splatShader.SetVariable("DetailTexture3", sandTexture);
splatShader.SetVariable("DetailTexture4", concreteTexture);
ground.Shader = splatShader;
}
private GameObject GenerateFragment(PSPolygon polygon)
{
TerrainPiece piece = Instantiate(terrainPieceTemplate, gameObject.transform.position, gameObject.transform.rotation);
var poly = new Polygon();
poly.Add(TerrainMesh.createContour(polygon.points));
var quality = new QualityOptions();
quality.MinimumAngle = 36;
quality.MaximumAngle = 91;
var imesh = poly.Triangulate(quality);
List <Vector2> vertices = new List <Vector2>();
List <int> triangles = new List <int>();
getTriangles(imesh, ref vertices, ref triangles);
var polygonBoundsCenter = polygon.Bounds.center;
var doNotWrapUV = polygonBoundsCenter.x < 0 && polygonBoundsCenter.y < 0;
var floorEdges = getFloorEdges(polygon);
var uvs = vertices.Select(v => getUV(v, doNotWrapUV)).ToArray();
var uv2s = vertices.Select(v => getUV2(v, doNotWrapUV, floorEdges)).ToArray();
UpdateMesh(
piece.GetComponent <MeshFilter>(),
vertices.Select(v => (Vector3)v),
uvs,
uv2s,
vertices.Select(p => (Color32)terrainTintColor(p, doNotWrapUV)),
triangles);
UpdateMesh(
piece.background,
vertices.Select(v => (Vector3)v),
uvs,
uv2s,
vertices.Select(p => (Color32)backgroundTintColor(p, doNotWrapUV)),
triangles);
PolygonCollider2D collider = piece.gameObject.AddComponent <PolygonCollider2D>();
collider.SetPath(0, polygon.points);
piece.terrainMesh = this;
piece.doNotWrapUV = doNotWrapUV;
piece.floorEdges = floorEdges;
piece.gameObject.SetActive(true);
return(piece.gameObject);
}
public Forest(Game game, ICameraProvider cameraProvider, TerrainMesh terrain, SunlightParameters sky)
: base(game)
{
if (game == null || cameraProvider == null || terrain == null)
{
throw new ArgumentNullException();
}
_game = game;
_cameraProvider = cameraProvider;
_terrain = terrain;
_sky = sky;
_treePositions = new List <Vector3>();
}
private IEnumerable <TerrainMesh <TerrainVertex> > Meshes(SceneGraph sceneGraph)
{
_meshes = new TerrainMesh <TerrainVertex> [100, 100];
for (int x = 0; x < 100; x++)
{
for (int y = 0; y < 100; y++)
{
var mesh = new TerrainMesh <TerrainVertex> (sceneGraph, new Vec2i(x * _patchStep, y * _patchStep),
new Vec2i(_patchSize, _patchSize), 20f, 0.03999f, 3, 5f, 4f);
_meshes[x, y] = mesh;
yield return(mesh);
}
}
}
// Use this for initialization
void Start()
{
Camera camera = Camera.main;
cameraTransform = camera.transform;
camHeight = 2f * camera.orthographicSize;
camWidth = camHeight * camera.aspect;
currentTerrainIndex = 0;
previousTerrainIndex = 1;
TerrainMesh startTerrain = terrainSegments [currentTerrainIndex];
startTerrain.GenerateTerrain(); //Generates the mesh for the terrain
}
// Use this for initialization
void Start()
{
TerrainMesh tt = tilePrefab.GetComponent <TerrainMesh>();
if (tt != null)
{
quadsPerTile = tt.quadsPerTile;
}
if (train == null)
{
train = Camera.main.transform;
}
StartCoroutine(GenerateWorldAroundPlayer());
}
// Update is called once per frame
void Update()
{
float cameraPosition = cameraTransform.position.x - camWidth / 2 - 10;
if (cameraPosition > terrainSegments [previousTerrainIndex].endPoint.x)
{
previousTerrainIndex = currentTerrainIndex;
currentTerrainIndex++;
if (currentTerrainIndex > 1)
{
currentTerrainIndex = 0;
}
TerrainMesh terrainToRegenerate = terrainSegments [currentTerrainIndex];
terrainToRegenerate.GenerateTerrain();
}
}
private void GenerateTerrain(int randomlayers = 0, int terrainGranularity = 0, float terrainStep = 0.0f, float terrainScale = 0.0f)
{
if (terrainGranularity <= 0)
{
terrainGranularity = TerrainGranularity;
}
if (terrainStep <= 0.0f)
{
terrainStep = TerrainStep;
}
if (terrainScale <= 0.0f)
{
terrainScale = TerrainScale;
}
if (randomlayers <= 0)
{
ObservedTerrain.GenerateEmpty(terrainStep, terrainScale);
}
else
{
ObservedTerrain.GenerateRandom(terrainStep, terrainScale, randomlayers);
}
TerrainGranularity = terrainGranularity;
TerrainStep = terrainStep;
TerrainScale = terrainScale;
ObservedTerrain.Gridify(terrainGranularity);
TerrainMesh.Clear();
if (randomlayers <= 0)
{
return;
}
ObservedTerrain.Calculate();
ObservedTerrain.Triangulate();
ObservedTerrain.GetMeshData(out var vertices, out var indices, out var normals);
TerrainMesh.vertices = vertices;
TerrainMesh.normals = normals;
TerrainMesh.triangles = indices;
}
void Start()
{
GameObject meshObj = new TerrainMesh(75, 200, 200).GetMeshGameObject();
MeshFilter filter = meshObj.GetComponent<MeshFilter>();
Vector3[] vertices = filter.mesh.vertices;
for (int i = 0; i < vertices.Length; i++) {
Vector3 vert = vertices[i];
float xCoord = vert.x * scale;
float zCoord = vert.z * scale;
float value = (settings.GetModule().GetValue(xCoord, zCoord, 0) - 0.5f) * scale;
vertices[i].y = value * settings.power;
}
filter.mesh.vertices = vertices;
filter.mesh.RecalculateBounds();
filter.mesh.RecalculateNormals();
}
public override void PrepareVisibleObjects(ICamera cam, int level)
{
//if (level > 0)
//{
// if (terrain1.State == ResourceState.Loaded)
// {
// ActiveTerrain = terrain1;
// }
// else
// {
// terrain1.Touch();
// }
// if (ActiveTerrain != null)
// {
// TerrainMesh tm = ActiveTerrain.Resource;
// tm.PrepareVisibleObjects(cam, level);
// }
//}
//else
{
if (terrain0.State == ResourceState.Loaded)
{
ActiveTerrain = terrain0;
}
else
{
terrain0.Touch();
}
if (ActiveTerrain != null)
{
TerrainMesh tm = ActiveTerrain.Resource;
tm.PrepareVisibleObjects(cam, level);
}
}
}
private void FixedUpdate()
{
float terrainTransformScale = terrain.transform.localScale.x;
var p = target.position;
var perlin = p / terrainTransformScale - terrain.transform.position;
float normalizedX = perlin.x;
float normalizedZ = perlin.z;
float height = TerrainMesh.CalculateCombinedPerlin(normalizedX, normalizedZ, terrain.OuterScale, terrain.OuterHeight, terrain.InnerScale, terrain.InnerHeight);
//float height = Mathf.PerlinNoise(normalizedX * terrain.InnerScale, normalizedZ * terrain.InnerScale) * terrain.InnerHeight + Mathf.PerlinNoise(normalizedX * terrain.OuterScale, normalizedZ * terrain.OuterScale) * terrain.OuterHeight;
height *= terrainTransformScale;
if (p.y < height)
{
target.transform.position = new Vector3(p.x, height + colliderHalfHeight, p.z);
}
transform.position = new Vector3(p.x, height - colliderHalfHeight, p.z);
}
public Chunk(float x, float y, float z, int size, int height, float surfaceCrossValue, float noiseScaleFactor, Material material, GameObject parent)
{
size++;
this.size = size;
this.height = height;
data = new float[size, height, size];
this.xOrigin = x;
this.yOrigin = y;
this.zOrigin = z;
this.surfaceCrossValue = surfaceCrossValue;
this.noiseScaleFactor = noiseScaleFactor;
meshGameObject = new GameObject("Chunk" + x + "," + y + "," + z, typeof(MeshFilter), typeof(MeshRenderer), typeof(MeshCollider));
meshGameObject.transform.position = new Vector3(x, y, z);
meshGameObject.transform.SetParent(parent.transform, false);
mesh = new Mesh();
FillData();
TerrainMesh.FillMesh(ref mesh, data, size, height, surfaceCrossValue);
data = null;
meshGameObject.GetComponent <MeshFilter>().mesh = mesh;
meshGameObject.GetComponent <MeshCollider>().sharedMesh = mesh;
meshGameObject.GetComponent <MeshRenderer>().material = material;
meshGameObject.layer = 10;
}
public override void Awake()
{
base.Awake();
m_Geometry = new TerrainMesh(100, 100, 1);
m_Renderer = GetComponent <MeshRenderer>();
if (m_Renderer == null)
{
m_Renderer = AddComponent <MeshRenderer>();
}
m_Renderer.Geometry = m_Geometry;
m_Renderer.CastShadow = false;
m_Renderer.ReceiveShadow = true;
m_WeightData = new TerrainWeightData()
{
SandLayer = 9,
GroundLayer = 18,
RockLayer = 23,
SnowLayer = 27
};
}
public void BuildTerrain(int width, float minHeight, float maxHeight)
{
_width = width;
_minHeight = minHeight;
_maxHeight = maxHeight;
// When running test scenarios over and over we need to generate the exact same terrains
const int myRandomTerrainSeed = 1337;
Heightmap = new Heightmap(myRandomTerrainSeed);
Heightmap.GenerateFaultHeightmap(_width, _width, _minHeight, _maxHeight,
new HeightmapFaultSettings(16, 256, 1024, 128, 0.5f));
// TODO Adding world transformation confuses the sunlight/terrain shader.. not sure why
// const float scale = 10;
Matrix world = Matrix.Identity;
// Matrix.CreateScale(scale) * Matrix.CreateTranslation(scale * Position);
Mesh = new TerrainMesh(Game, _cameraProvider, Heightmap, world);
Mesh.Initialize();
// TerrainMeshes.Add(first);
return;
}
void ApplyDataToMesh()
{
TerrainMesh.FillMesh(ref mesh, data, size, height, surfaceCrossValue);
GetComponent <MeshFilter>().mesh = mesh;
}
private void Generate()
{
var mesh = TerrainMesh.TerrainDraft(xSize, zSize, xSegments, zSegments, noiseScale).ToMesh();
meshFilter.mesh = mesh;
}
public static void ReleaseItem(TerrainMesh mesh)
{
mesh.State = PoolItemState.Free;
mesh.VertexCount = 0;
mesh.IndexCount = 0;
}
private static TerrainMesh CreateMesh(int vertices)
{
// Create a new mesh and return it
int maxIndices = (int)(vertices * 1.5d);
var mesh = new TerrainMesh();
mesh.State = PoolItemState.Free;
mesh.VertexBuffer = new VertexBuffer(device, typeof(TerrainVertex), vertices, BufferUsage.WriteOnly);
mesh.IndexBuffer = new IndexBuffer(device, IndexElementSize.ThirtyTwoBits, maxIndices, BufferUsage.WriteOnly);
return mesh;
}
private void Update()
{
// Precache information
var mouse = Input.mousePosition;
var cam = Camera.main;
var center = cam.ScreenToWorldPoint(new Vector3(mouse.x, mouse.y, Vector3.Distance(cam.transform.position, transform.position) + BrushZCorretion));
var alpha = 0.0f;
// Clear terrain
if (Input.GetKeyDown(KeyCode.C))
{
ObservedTerrain.Clear();
ObservedTerrain.Calculate();
TerrainMesh.Clear();
}
// Terrain granularity adjustment
var incgran = Input.GetKeyDown(KeyCode.UpArrow);
var decgran = Input.GetKeyDown(KeyCode.DownArrow);
if (incgran ^ decgran)
{
if (incgran)
{
++TerrainGranularity;
}
if (decgran)
{
--TerrainGranularity;
}
if (TerrainGranularity < 1)
{
TerrainGranularity = 1;
}
ObservedTerrain.Gridify(TerrainGranularity);
ObservedTerrain.Calculate();
ObservedTerrain.Triangulate();
ObservedTerrain.GetMeshData(out var vertices, out var indices, out var normals);
TerrainMesh.Clear();
TerrainMesh.vertices = vertices;
TerrainMesh.normals = normals;
TerrainMesh.triangles = indices;
}
// If mouse is inside terrain bounds
if (TerrainCollider.bounds.Contains(center))
{
// Display brush with some alpha
alpha = 0.75f;
// Adjust brush
if (Input.GetKey(KeyCode.Q))
{
BrushRadius += 0.01f;
}
if (Input.GetKey(KeyCode.E))
{
BrushRadius -= 0.01f;
}
if (BrushRadius <= 0.1f)
{
BrushRadius = 0.1f;
}
BrushZCorretion += Input.mouseScrollDelta.y / 10.0f;
// Reset brush
if (Input.GetKeyDown(KeyCode.R))
{
BrushRadius = 1.0f;
BrushZCorretion = 0.0f;
}
// Build/Clear terrain
var build = Input.GetMouseButton(0);
var clear = Input.GetMouseButton(1);
if (build ^ clear)
{
if (build)
{
ObservedTerrain.Update(new Vector3(center.z, center.y, center.x), BrushRadius, +BrushDelta);
}
if (clear)
{
ObservedTerrain.Update(new Vector3(center.z, center.y, center.x), BrushRadius, -BrushDelta);
}
ObservedTerrain.Calculate();
ObservedTerrain.Triangulate();
ObservedTerrain.GetMeshData(out var vertices, out var indices, out var normals);
TerrainMesh.Clear();
TerrainMesh.vertices = vertices;
TerrainMesh.normals = normals;
TerrainMesh.triangles = indices;
}
}
// Apply brush adjustment
Brush.transform.position = center;
Brush.transform.localScale = new Vector3(BrushRadius, BrushRadius, BrushRadius);
BrushMaterial.SetColor("_Color", new Color(0.75f, 0.75f, 0.75f, alpha));
}
private void Initialize()
{
if (parameters.SceneryType == SceneryParameters.SceneryTypeEnum.Photofield)
{
if (parameters.HeightMapFile != null)
{
heightMap = new Heightmap(parameters.SceneryFolder + parameters.HeightMapFile,
(float)parameters.HeightMapSize, parameters.HeightMapResolution, parameters.HeightMapResolution);
heightMap.MinHeight = parameters.MinimumHeight;
heightMap.MaxHeight = parameters.MaximumHeight;
}
else
{
heightMap = new Heightmap(1000);
}
photoScenery = new PhotoScenery(parameters);
// Set lighting conditions
if (definition != null)
{
if (definition.SkyTable.Rows.Count > 0)
{
DataRow dataRow = definition.SkyTable.Rows[0];
Vector3 ambientVector = (Vector3)dataRow["AmbientLight"];
Vector3 sunVector = (Vector3)dataRow["SunLight"];
SetSky(null, (Vector3)dataRow["SunPosition"],
Color.FromArgb((int)(255 * ambientVector.X), (int)(255 * ambientVector.Y), (int)(255 * ambientVector.Z)),
Color.FromArgb((int)(255 * sunVector.X), (int)(255 * sunVector.Y), (int)(255 * sunVector.Z)),
(float)(dataRow["TerrainAmbient"]), (float)(dataRow["TerrainSun"]));
lensFlare = new LensFlare();
}
}
}
else
{
vegetation = new Vegetation(owner);
ground = new GameObject();
heightMap = new Heightmap(parameters.SceneryFolder + parameters.HeightMapFile, 1000f, 100, 100);
heightMap.MinHeight = parameters.MinimumHeight;
heightMap.MaxHeight = parameters.MaximumHeight;
TerrainMesh sceneryMesh = new TerrainMesh(1.0f, heightMap);
ground.Mesh = sceneryMesh;
// Load the detail settings
currentDetail = Bonsai.Utils.Settings.GetValue("SceneryDetail", "2");
dynamicSceneryDetail = Convert.ToInt32(Bonsai.Utils.Settings.GetValue("DynamicScenery", "1"));
if (currentDetail.Equals("1"))
{
sceneryMesh.Texture = new Bonsai.Objects.Textures.TextureBase(parameters.SplatLowFile);
}
else
{
//ground.RotateXAngle = (float)Math.PI / 2;
//splatShader = new ShaderBase("splatting", "splatting3.fx");
//if (Framework.Instance.DeviceCaps.PixelShaderVersion.Major >= 3)
// splatShader.SetTechnique("TextureSplatting_fx30");
//else
// splatShader.SetTechnique("TextureSplatting");
splatShader = new ShaderBase("splatting", "splat.fx");
splatShader.SetTechnique("TextureSplatting");
splatShader.SetVariable("matViewProj", ShaderBase.ShaderParameters.CameraProjection);
splatShader.SetVariable("sunPosition", new Vector3(1, 1, 1));
splatShader.SetVariable("underwater", 0.0f);
splatShader.SetVariable("matWorld", ShaderBase.ShaderParameters.World);
splatShader.SetVariable("matInvertTransposeWorld", ShaderBase.ShaderParameters.WorldInvertTranspose);
splatShader.SetVariable("cameraPos", ShaderBase.ShaderParameters.CameraPosition);
splatShader.SetVariable("nearRepeat", 64.0f);
splatShader.SetVariable("farRepeat", 16.0f);
splatShader.SetVariable("nearFactor2", 1.0f);
splatShader.SetVariable("farFactor2", 1.0f);
splatShader.SetVariable("nearFactor3", 1.0f);
splatShader.SetVariable("farFactor3", 1.0f);
splatShader.SetVariable("nearFactor4", 5.0f);
splatShader.SetVariable("farFactor4", 5.0f);
splatShader.SetVariable("blendSqDistance", 50f * 50f);
splatShader.SetVariable("blendSqWidth", 1.0f / (200f * 200f));
TextureBase normalMap = new TextureBase(parameters.NormalMapFile);
TextureBase alphaMap = new TextureBase(parameters.SplatHighFile);
//TextureBase grassTexture = new TextureBase("data/grass_zoomout.png");
TextureBase grassTexture = new TextureBase(parameters.Texture1File);
TextureBase rockTexture = new TextureBase(parameters.Texture2File);
//TextureBase rockNormal = new TextureBase("data/splat_rock_normal.jpg");
TextureBase sandTexture = new TextureBase(parameters.Texture3File);
TextureBase concreteTexture = new TextureBase(parameters.Texture4File);
splatShader.SetVariable("NormalMapTexture", normalMap);
splatShader.SetVariable("AlphaTexture", alphaMap);
splatShader.SetVariable("DetailTexture1", grassTexture);
splatShader.SetVariable("DetailTexture2", rockTexture);
//splatShader.SetVariable("DetailTexture2NormalMap", rockNormal);
splatShader.SetVariable("DetailTexture3", sandTexture);
splatShader.SetVariable("DetailTexture4", concreteTexture);
ground.Shader = splatShader;
}
CreateSurroundings();
// Load the trees
vegetation.LoadTrees(heightMap, definition);
// Load the simple trees
LoadSimpleTrees(definition);
// Load the simple tall trees
LoadSimpleTallTrees(definition);
// Load the simple small trees
LoadSimpleSmallTrees(definition);
// Load the scenery objects
LoadSceneryObjects(definition);
// Load the windmills
LoadWindmills(definition);
// Load the weather
LoadWeather(definition);
// Load the dynamic scenery
if (dynamicSceneryDetail > 0)
{
LoadDynamicScenery(definition);
}
// Load the sky
sky = new GameObject();
DomeMesh skyDome = new DomeMesh(4500, 16, 16);
sky.Mesh = skyDome;
DataRow dataRow = definition.SkyTable.Rows[0];
foreach (DataRow skyRow in definition.SkyTable.Rows)
{
string skyName = skyRow["Name"].ToString();
if (skyName.Equals(Bonsai.Utils.Settings.GetValue("Sky")))
{
dataRow = skyRow;
break;
}
}
// Load the water
LoadWater(definition);
//water = new Water(new Vector3(90, 0, 180), 100f, Bonsai.Objects.Terrain.Water.QualityLevelEnum.Low);
if (dataRow != null)
{
Vector3 ambientVector = (Vector3)dataRow["AmbientLight"];
Vector3 sunVector = (Vector3)dataRow["SunLight"];
SetSky(dataRow["Texture"].ToString(), (Vector3)dataRow["SunPosition"],
Color.FromArgb((int)(255 * ambientVector.X), (int)(255 * ambientVector.Y), (int)(255 * ambientVector.Z)),
Color.FromArgb((int)(255 * sunVector.X), (int)(255 * sunVector.Y), (int)(255 * sunVector.Z)),
(float)(dataRow["TerrainAmbient"]), (float)(dataRow["TerrainSun"]));
}
// Apply the ads
if (Utility.MediaExists("ads/ad1.jpg"))
{
ApplyAds("ad.jpg", "ads/ad1.jpg");
}
if (Utility.MediaExists("ads/ad2.jpg"))
{
ApplyAds("ad2.jpg", "ads/ad2.jpg");
}
lensFlare = new LensFlare();
}
#if EDITOR
// Load the racing pylons
LoadGates(definition);
#else
if (Program.Instance.Player != null)
{
Program.Instance.Player.Heightmap = heightMap;
Program.Instance.Player.DefaultStartPosition = parameters.DefaultStartPosition;
Program.Instance.Player.WaterStartPosition = parameters.WaterStartPosition;
}
SetWaterCallback(Program.Instance.OnFrameRenderWater);
// Rerender the reflection
if (Effects.Reflection.Instance != null)
{
Effects.Reflection.Instance.Invalidate();
}
#endif
}
private MeshData UpdateMeshData(MeshData oldData, IClipShape clipShape)
{
var clipPolygon = clipShape.ClipPolygon();
var oldVertices = oldData.vertices;
var oldTriangles = oldData.triangles;
var oldPaths = oldData.paths;
var newVertices = new List <Vector2>(oldVertices.Length);
var vertexIndex = new Dictionary <int, int>(oldVertices.Length);
Vector2 v;
for (int i = 0; i < oldVertices.Length; i++)
{
v = oldVertices[i];
if (clipPolygon.PointInPolygon(v))
{
vertexIndex.Add(i, -1);
}
else
{
vertexIndex.Add(i, newVertices.Count);
newVertices.Add(v);
}
}
var newTriangles = new List <int>(oldTriangles.Length);
var clippedTriangles = new List <int[]>();
List <int> oldTriangle = new List <int>(3);
for (int i = 0; i < oldTriangles.Length / 3; i++)
{
oldTriangle.Clear();
oldTriangle.Add(oldTriangles[3 * i]);
oldTriangle.Add(oldTriangles[3 * i + 1]);
oldTriangle.Add(oldTriangles[3 * i + 2]);
var newTriangle = oldTriangle.Select(oldIndex => vertexIndex[oldIndex]).ToArray();
if (newTriangle.Any(newIndex => newIndex > -1))
{
if (newTriangle.All(newIndex => newIndex > -1) && !clipShape.ShouldClipTriangle(newTriangle.Select(newIndex => newVertices[newIndex])))
{
newTriangles.AddRange(newTriangle);
}
else
{
clippedTriangles.Add(oldTriangle.ToArray());
}
}
}
var newPolygons = clippedTriangles
.Select(t => t.Select(oldIndex => (Vector2)oldVertices[oldIndex]))
.SelectMany(t => PSClipperHelper.difference(t, clipPolygon.points));
var mesher = new GenericMesher();
foreach (var points in newPolygons)
{
var poly = new Polygon();
poly.Add(TerrainMesh.createContour(points));
var imesh = mesher.Triangulate(poly);
TerrainMesh.getTriangles(imesh, ref newVertices, ref newTriangles);
}
var newPaths = oldPaths
.SelectMany(p => PSClipperHelper.difference(p, clipPolygon.points))
.Select(p => p.ToArray())
.ToArray();
var particles = oldPaths
.SelectMany(p => PSClipperHelper.intersection(p, clipPolygon.points))
.Select(p => GenerateParticles(new PSPolygon(p)))
.ToArray();
return(new MeshData(
newVertices.Select(c => new Vector3(c.x, c.y, 0)).ToArray(),
newVertices.Select(c => (Color32)terrainMesh.terrainTintColor(c, doNotWrapUV)).ToArray(),
newVertices.Select(c => terrainMesh.getUV(c, doNotWrapUV)).ToArray(),
newVertices.Select(c => terrainMesh.getUV2(c, doNotWrapUV, floorEdges)).ToArray(),
newTriangles.ToArray(),
newPaths,
particles));
}
