void GenerateMap()
{
map = new bool[width, height];
RandomFillMap ();
for (int i = 0; i < smoothingInterationCount; i++)
SmoothMap ();
ProcessMap ();
MeshGenerator meshGen = new MeshGenerator ();
meshGen.GenerateMesh (map, tileSize, wallHeight);
Mesh mesh = new Mesh ();
mesh.name = "Cave (main)";
mesh.vertices = meshGen.vertices.ToArray ();
mesh.triangles = meshGen.indices.ToArray ();
int numVertices = meshGen.vertices.Count;
Vector3[] normals = new Vector3[numVertices];
Vector4[] tangents = new Vector4[numVertices];
for (int i = 0; i < numVertices; i++)
{
normals[i] = Vector3.up;
tangents[i] = new Vector4(1f, 0f, 0f, 1f);
}
mesh.normals = normals;
mesh.tangents = tangents;
//mesh.RecalculateNormals ();
mesh.uv = meshGen.texCoords.ToArray ();
mainMeshFilter.mesh = mesh;
mesh.Optimize ();
mesh = new Mesh ();
mesh.name = "Cave (walls)";
mesh.vertices = meshGen.wallVertices.ToArray ();
mesh.triangles = meshGen.wallIndices.ToArray ();
mesh.RecalculateNormals ();
wallsMeshFilter.mesh = mesh;
mesh.Optimize ();
MeshCollider meshCollider = wallsMeshFilter.gameObject.GetComponent<MeshCollider> ();
meshCollider.sharedMesh = mesh;
}
// Use this for initialization
void Start()
{
m_generator = GetComponent<MeshGenerator>();
x = 0;
y = 1; //we set this to 1 to place the Lerper on top of the level
z = 0;
m_worldGrid =
@"
00003
00011
00010
31110
00000";
m_generator.WorldInit();
Debug.Log("World initialized");
PopulateWorld();
Debug.Log("World populated");
m_generator.UpdateWorld();
Debug.Log("World updated");
}
public static MeshGenerator Union(MeshGenerator A, MeshGenerator B)
{
MeshGenerator mesh = new MeshGenerator();
return(mesh);
}
public void generateMap(bool fill = true)
{
// have to force it to low value
mapChunkSize = (fill ? 101 : 241);
float[,] map = perlinMap.generateMap(mapChunkSize, mapChunkSize, seed, scale, octaves, persistence,
lacunarity, offset);
// store whether that area is livable
int [,] livable = new int [mapChunkSize, mapChunkSize];
Color[] colormap = new Color[mapChunkSize * mapChunkSize];
for (int h = 0; h < mapChunkSize; ++h)
{
for (int w = 0; w < mapChunkSize; ++w)
{
// begin searching for livable areas
if (map[w, h] <= cityHigh && map[w, h] >= cityLow)
{
livable[w, h] = 1;
}
else
{
livable[w, h] = 0;
}
float currentHeight = map[w, h];
for (int i = 0; i < regions.Length; ++i)
{
if (currentHeight <= regions[i].height)
{
colormap[h * mapChunkSize + w] = regions[i].color;
break;
}
}
}
}
display_map display = FindObjectOfType <display_map>();
if (draw_mode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(map));
}
else if (draw_mode == DrawMode.ColorMap)
{
display.DrawTexture(TextureGenerator.TextureFromColorMap(colormap, mapChunkSize, mapChunkSize));
}
else if (draw_mode == DrawMode.Mesh)
{
display.DrawMesh(MeshGenerator.generate_terrain_mesh(map, meshHeightMultiplier,
levelOfDetails, meshHeightCurve),
TextureGenerator.TextureFromColorMap(colormap, mapChunkSize, mapChunkSize));
if (fill)
{
// instantiate a smaug model on the highest mountain!
// plant some vegetations!
// find the max value in map
int max_w = -1, max_h = -1;
float max = -1f;
for (int w = 0; w < mapChunkSize; ++w)
{
for (int h = 0; h < mapChunkSize; ++h)
{
if (map[w, h] > max)
{
max = map[w, h];
max_w = w;
max_h = h;
}
// generate some stuff on the ground
if (map[w, h] >= 0.5f && map[w, h] <= 0.7f)
{
float dice = Random.Range(0.0f, 1.0f);
if (dice < 0.05f)
{
Vector3 grassPos = new Vector3(w,
meshHeightCurve.Evaluate(map[w, h]) * meshHeightMultiplier,
mapChunkSize - h);
Instantiate(grass, grassPos, Quaternion.Euler(0.0f, Random.Range(0.0f, 360.0f), 0.0f));
}
else if (dice < 0.08f)
{
Vector3 treePos = new Vector3(w,
meshHeightCurve.Evaluate(map[w, h]) * meshHeightMultiplier,
mapChunkSize - h);
Instantiate(tree, treePos, Quaternion.Euler(0.0f, Random.Range(0.0f, 360.0f), 0.0f));
}
else if (dice < 0.12f)
{
Vector3 mushroomPos = new Vector3(w,
meshHeightCurve.Evaluate(map[w, h]) * meshHeightMultiplier,
mapChunkSize - h);
Instantiate(mushroom, mushroomPos, Quaternion.Euler(0.0f, Random.Range(0.0f, 360.0f), 0.0f));
}
else if (dice < 0.15f)
{
Vector3 sheepPos = new Vector3(w,
meshHeightCurve.Evaluate(map[w, h]) * meshHeightMultiplier,
mapChunkSize - h);
Instantiate(sheep, sheepPos, Quaternion.Euler(0.0f, Random.Range(0.0f, 360.0f), 0.0f));
}
}
else if (map[w, h] <= 0.35f)
{
float dice = Random.Range(0.0f, 1.0f);
if (dice < 0.005f)
{
Vector3 boatPos = new Vector3(w,
meshHeightCurve.Evaluate(map[w, h]) * meshHeightMultiplier,
mapChunkSize - h);
Instantiate(boat, boatPos, Quaternion.Euler(0.0f, Random.Range(0.0f, 360.0f), 0.0f));
}
}
}
}
// create position vector for smaug
Vector3 smaugPos = new Vector3(max_w,
meshHeightCurve.Evaluate(map[max_w, max_h]) * meshHeightMultiplier - 2.0f,
mapChunkSize - max_h - 2.0f);
Instantiate(smaug, smaugPos, smaug.transform.rotation);
// procedurally generate city
List <int[]> coords = squares(livable, villageSizeCutoff);
foreach (int[] i in coords)
{
int cityWidth = Mathf.Abs(i[3] - i[1]);
int cityHeight = Mathf.Abs(i[0] - i[2]);
int buildingFootprint = 2;
int[,] citygrid = new int[cityWidth, cityHeight];
for (int h = 0; h < cityHeight; ++h)
{
for (int w = 0; w < cityWidth; ++w)
{
citygrid[w, h] = (int)(Mathf.PerlinNoise(w / 10.0f, h / 10.0f) * 10.0f);
}
}
// build city
float mapY = meshHeightCurve.Evaluate(map[i[0], i[1]]) * meshHeightMultiplier;
for (int h = 0; h < cityHeight; h++)
{
for (int w = 0; w < cityWidth; w++)
{
int result = citygrid[w, h];
Debug.Log(result);
Vector3 position = new Vector3(w * buildingFootprint + i[0], mapY, mapChunkSize - (h * buildingFootprint + i[1]));
if (w * buildingFootprint < cityWidth && h * buildingFootprint < cityHeight)
{
if (result < 2)
{
Instantiate(buildings[0], position, Quaternion.Euler(-90.0f, 0.0f, 0.0f));
}
else if (result < 4)
{
Instantiate(buildings[1], position, Quaternion.Euler(-90.0f, 0.0f, 0.0f));
}
else if (result < 6)
{
Instantiate(buildings[2], position, Quaternion.Euler(-90.0f, 0.0f, 0.0f));
}
else if (result < 8)
{
Instantiate(buildings[3], position, Quaternion.Euler(-90.0f, 0.0f, 0.0f));
}
else if (result < 10)
{
Instantiate(buildings[4], position, Quaternion.Euler(-90.0f, 0.0f, 180.0f));
}
}
}
}
}
}
}
}
private IEnumerator Initialize()
{
yield return(null);
var retries = 0;
retry:
//
// STEP 1: Decide on all the arrows, filled stars and LED states
//
_arrows = new Arrow[ArrowMeshes.Length];
for (int i = 0; i < ArrowMeshes.Length; i++)
{
_arrows[i] = (Arrow)((Rnd.Range(0, 4) << 0) | (Rnd.Range(0, 5) << 2));
ArrowMeshes[i].material.mainTexture = Arrows[(int)_arrows[i]];
ArrowCB[i].text = "RGBYP".Substring((int)(_arrows[i] & Arrow.ColorMask) >> 2, 1);
}
_filledStars = new bool[StarMeshes.Length];
for (int i = 0; i < StarMeshes.Length; i++)
{
_filledStars[i] = Rnd.Range(0, 2) != 0;
StarMeshes[i].material.mainTexture = Stars[_filledStars[i] ? 1 : 0];
}
_ledsOn = new bool[LedMeshes.Length];
for (int i = 0; i < LedMeshes.Length; i++)
{
_ledsOn[i] = Rnd.Range(0, 2) != 0;
LedMeshes[i].material = LedMaterials[_ledsOn[i] ? 1 : 0];
}
//
// STEP 2: Assign the wires to their connectors and decide their colors
//
var shuffledBottom = Enumerable.Range(0, 6).ToList().Shuffle();
for (int i = 0; i < 6; i++)
{
_wires[i] = new WireInfo
{
TopConnector = i < 4 ? i : Rnd.Range(0, 4),
BottomConnector = shuffledBottom[i],
Color = (WireColor)Rnd.Range(0, 8),
Level = 1,
HasBeenCut = false
};
WireCB[_wires[i].BottomConnector].text = "RYBWGOPK".Substring((int)_wires[i].Color, 1);
for (int j = 0; j < i; j++)
{
if ((_wires[j].TopConnector > _wires[i].TopConnector && _wires[j].BottomConnector < _wires[i].BottomConnector) ||
(_wires[j].TopConnector <_wires[i].TopConnector && _wires[j].BottomConnector> _wires[i].BottomConnector))
{
_wires[i].Level = Math.Max(_wires[i].Level, _wires[j].Level + 1);
}
}
}
//
// STEP 3: Determine the solution. Make sure that at least one wire needs to be cut.
//
const string rules = "LWIPMVIFIUCCFRHHTVUDLRJBQWBPJTQD";
var colorsForRedRule = new[] { WireColor.Red, WireColor.Yellow, WireColor.Blue, WireColor.White };
for (int i = 0; i < 6; i++)
{
var applicable = new List <string>();
var rule = 0;
var arrowColor = _arrows[_wires[i].BottomConnector] & Arrow.ColorMask;
// Red: The wire is red, yellow, blue, or white.
if (colorsForRedRule.Contains(_wires[i].Color))
{
rule += 8;
applicable.Add("Red");
}
// Orange: The wire shares the same color as its arrow.
if ((_wires[i].Color == WireColor.Red && arrowColor == Arrow.Red) ||
(_wires[i].Color == WireColor.Green && arrowColor == Arrow.Green) ||
(_wires[i].Color == WireColor.Blue && arrowColor == Arrow.Blue) ||
(_wires[i].Color == WireColor.Yellow && arrowColor == Arrow.Yellow) ||
(_wires[i].Color == WireColor.Purple && arrowColor == Arrow.Purple))
{
rule += 16;
applicable.Add("Orange");
}
// Yellow: The wire’s star is black.
if (_filledStars[_wires[i].TopConnector])
{
rule += 2;
applicable.Add("Yellow");
}
// Green: The wire’s position on the bottom is even.
if (_wires[i].BottomConnector % 2 != 0)
{
rule += 4;
applicable.Add("Green");
}
// Blue: The wire crosses over another wire.
if (_wires.Any(w => (w.BottomConnector > _wires[i].BottomConnector && w.TopConnector < _wires[i].TopConnector) || (w.BottomConnector <_wires[i].BottomConnector && w.TopConnector> _wires[i].TopConnector)))
{
rule += 1;
applicable.Add("Blue");
}
_wires[i].VennColors = applicable.ToArray();
_wires[i].Reason = rules[rule];
var dir = (_arrows[_wires[i].BottomConnector] & Arrow.DirectionMask);
switch (rules[rule])
{
// C: Cut the wire.
case 'C': _wires[i].CutRule = CutRule.Cut; break;
// F: Always cut the wire, but only cut it first.
case 'F': _wires[i].CutRule = CutRule.CutFirst; break;
// L: Always cut the wire, but only cut it last.
case 'L': _wires[i].CutRule = CutRule.CutLast; break;
// W: Cut the wire if more of the LEDs are on than off.
case 'W': _wires[i].CutRule = _ledsOn.Count(l => l) > 1 ? CutRule.Cut : CutRule.DontCut; break;
// T: Cut the wire if the first LED is on.
case 'T': _wires[i].CutRule = _ledsOn[0] ? CutRule.Cut : CutRule.DontCut; break;
// U: Cut the wire if its arrow points up or down.
case 'U': _wires[i].CutRule = dir == Arrow.Up || dir == Arrow.Down ? CutRule.Cut : CutRule.DontCut; break;
// M: Cut the wire if the arrow points down or right.
case 'M': _wires[i].CutRule = dir == Arrow.Right || dir == Arrow.Down ? CutRule.Cut : CutRule.DontCut; break;
// H: Cut the wire if the wire shares a star with another wire.
case 'H': _wires[i].CutRule = _wires.Where((w, ix) => ix != i).Any(w => w.TopConnector == _wires[i].TopConnector) ? CutRule.Cut : CutRule.DontCut; break;
// P: Cut the wire if its position at the bottom is equal to the number of ports.
case 'P': _wires[i].CutRule = _wires[i].BottomConnector + 1 == Bomb.GetPortCount() ? CutRule.Cut : CutRule.DontCut; break;
// B: Cut the wire if its position at the bottom is equal to the number of batteries.
case 'B': _wires[i].CutRule = _wires[i].BottomConnector + 1 == Bomb.GetBatteryCount() ? CutRule.Cut : CutRule.DontCut; break;
// I: Cut the wire if its position at the bottom is equal to the number of indicators.
case 'I': _wires[i].CutRule = _wires[i].BottomConnector + 1 == Bomb.GetIndicators().Count() ? CutRule.Cut : CutRule.DontCut; break;
// Q: Cut the wire if the color of the wire is unique.
case 'Q': _wires[i].CutRule = _wires.Where((w, ix) => ix != i).Any(w => w.Color == _wires[i].Color) ? CutRule.DontCut : CutRule.Cut; break;
// J: Cut the wire if, at the bottom, it is adjacent to an orange or purple wire.
case 'J': _wires[i].CutRule = _wires.Any(w => (w.BottomConnector == _wires[i].BottomConnector - 1 || w.BottomConnector == _wires[i].BottomConnector + 1) && (w.Color == WireColor.Orange || w.Color == WireColor.Purple)) ? CutRule.Cut : CutRule.DontCut; break;
// V: Cut the wire if the serial number has a vowel, or if the bomb has a USB port.
case 'V': _wires[i].CutRule = Bomb.GetSerialNumberLetters().Any(ch => "AEIOU".Contains(ch)) || Bomb.GetPortCount("USB") > 0 ? CutRule.Cut : CutRule.DontCut; break;
// R: Cut the wire if its arrow direction is unique.
case 'R': _wires[i].CutRule = _arrows.Where((a, ix) => ix != _wires[i].BottomConnector).Any(a => (a & Arrow.DirectionMask) == dir) ? CutRule.DontCut : CutRule.Cut; break;
// D: Do not cut the wire.
case 'D': _wires[i].CutRule = CutRule.DontCut; break;
}
}
if (_wires.All(w => w.CutRule == CutRule.DontCut))
{
retries++;
goto retry;
}
Array.Sort(_wires, (w1, w2) => w1.BottomConnector.CompareTo(w2.BottomConnector));
for (int i = 0; i < StarMeshes.Length; i++)
{
Debug.LogFormat("[Perplexing Wires #{0}] (h) Star #{1} is {2}.", _moduleId, i + 1, _filledStars[i] ? "filled" : "empty");
}
for (int i = 0; i < ArrowMeshes.Length; i++)
{
Debug.LogFormat("[Perplexing Wires #{0}] (h) Arrow #{1} is {2} and pointing {3}.", _moduleId, i + 1, arrowColorStr(_arrows[i]), arrowDirStr(_arrows[i]));
}
for (int i = 0; i < LedMeshes.Length; i++)
{
Debug.LogFormat("[Perplexing Wires #{0}] (h) LED #{1} is {2}.", _moduleId, i + 1, _ledsOn[i] ? "on" : "off");
}
//
// STEP 4: Generate the actual wire meshes. (This also logs the wire states and rules.)
//
var wiresParent = Module.transform.Find("Wires");
for (int wIx = 0; wIx < _wires.Length; wIx++)
{
var wireObj = wiresParent.Find("Wire" + (wIx + 1)).gameObject;
// Determine the “original” control points and raise height.
var topConnector = Module.transform.Find("Strip2").Find("Connector" + (_wires[wIx].TopConnector + 1));
var topControl = topConnector.Find("Control");
topControl.localPosition = new Vector3(0, .2f, 0);
var bottomConnector = Module.transform.Find("Strip1").Find("Connector" + (_wires[wIx].BottomConnector + 1));
var bottomControl = bottomConnector.Find("Control");
var raiseBy = 1.5 * (_wires[wIx].Level - 1) * (Pt)(transform.InverseTransformPoint(bottomControl.position) - transform.InverseTransformPoint(bottomConnector.position) + transform.InverseTransformPoint(topControl.position) - transform.InverseTransformPoint(topConnector.position));
// Slightly move the control point at the top connector to mitigate the incidence of wire collisions.
var topControlX = 0f;
if (_wires.Any(w => w.TopConnector == _wires[wIx].TopConnector && w.BottomConnector < _wires[wIx].BottomConnector) && !_wires.Any(w => w.TopConnector == _wires[wIx].TopConnector && w.BottomConnector > _wires[wIx].BottomConnector))
{
topControlX = -.07f;
}
else if (_wires.Any(w => w.TopConnector == _wires[wIx].TopConnector && w.BottomConnector > _wires[wIx].BottomConnector) && !_wires.Any(w => w.TopConnector == _wires[wIx].TopConnector && w.BottomConnector < _wires[wIx].BottomConnector))
{
topControlX = .07f;
}
var topControlZ = 0f;
if (_wires.Any(w => Math.Sign(w.TopConnector - _wires[wIx].TopConnector) != Math.Sign(w.BottomConnector - _wires[wIx].BottomConnector) && w.Level < _wires[wIx].Level))
{
topControlZ = .05f;
}
else if (_wires.Any(w => Math.Sign(w.TopConnector - _wires[wIx].TopConnector) != Math.Sign(w.BottomConnector - _wires[wIx].BottomConnector) && w.Level > _wires[wIx].Level))
{
topControlZ = -.05f;
}
topControl.localPosition = new Vector3(topControlX, .2f, topControlZ);
// Generate the meshes for this wire.
var seed = Rnd.Range(0, int.MaxValue);
var mesh = MeshGenerator.GenerateWire(
transform.InverseTransformPoint(topConnector.position),
transform.InverseTransformPoint(topControl.position),
transform.InverseTransformPoint(bottomControl.position),
transform.InverseTransformPoint(bottomConnector.position),
5,
MeshGenerator.WirePiece.Uncut,
MeshGenerator.Mode.Wire,
seed,
raiseBy);
_wires[wIx].MeshFilter = wireObj.GetComponent <MeshFilter>();
_wires[wIx].MeshFilter.mesh = mesh;
wireObj.GetComponent <MeshRenderer>().material = WireMaterials[(int)_wires[wIx].Color];
_wires[wIx].CutMesh = MeshGenerator.GenerateWire(
transform.InverseTransformPoint(topConnector.position),
transform.InverseTransformPoint(topControl.position),
transform.InverseTransformPoint(bottomControl.position),
transform.InverseTransformPoint(bottomConnector.position),
5,
MeshGenerator.WirePiece.Cut,
MeshGenerator.Mode.Wire,
seed,
raiseBy);
_wires[wIx].CutHighlightMesh = MeshGenerator.GenerateWire(
transform.InverseTransformPoint(topConnector.position),
transform.InverseTransformPoint(topControl.position),
transform.InverseTransformPoint(bottomControl.position),
transform.InverseTransformPoint(bottomConnector.position),
5,
MeshGenerator.WirePiece.Cut,
MeshGenerator.Mode.Highlight,
seed,
raiseBy);
_wires[wIx].CopperMesh = MeshGenerator.GenerateWire(
transform.InverseTransformPoint(topConnector.position),
transform.InverseTransformPoint(topControl.position),
transform.InverseTransformPoint(bottomControl.position),
transform.InverseTransformPoint(bottomConnector.position),
5,
MeshGenerator.WirePiece.Copper,
MeshGenerator.Mode.Wire,
seed,
raiseBy);
var highlightMesh = MeshGenerator.GenerateWire(
transform.InverseTransformPoint(topConnector.position),
transform.InverseTransformPoint(topControl.position),
transform.InverseTransformPoint(bottomControl.position),
transform.InverseTransformPoint(bottomConnector.position),
5,
MeshGenerator.WirePiece.Uncut,
MeshGenerator.Mode.Highlight,
seed,
raiseBy);
var highlight = wireObj.transform.Find("Highlight");
_wires[wIx].HighlightMeshFilter = highlight.GetComponent <MeshFilter>();
_wires[wIx].HighlightMeshFilter.mesh = highlightMesh;
var highlight2 = highlight.Find("Highlight(Clone)");
if (highlight2 != null)
{
_wires[wIx].HighlightMeshFilter = highlight2.GetComponent <MeshFilter>();
_wires[wIx].HighlightMeshFilter.mesh = highlightMesh;
}
wireObj.GetComponent <MeshCollider>().sharedMesh = MeshGenerator.GenerateWire(
transform.InverseTransformPoint(topConnector.position),
transform.InverseTransformPoint(topControl.position),
transform.InverseTransformPoint(bottomControl.position),
transform.InverseTransformPoint(bottomConnector.position),
5,
MeshGenerator.WirePiece.Uncut,
MeshGenerator.Mode.Collider,
seed,
raiseBy);
// Fix for a possible bug in Unity
wireObj.GetComponent <MeshCollider>().enabled = true;
wireObj.GetComponent <MeshCollider>().enabled = false;
Debug.LogFormat("[Perplexing Wires #{6}] (h) Wire {0} to {1} is {2}: {3} (Venn: {4} = {5})",
_wires[wIx].TopConnector + 1,
_wires[wIx].BottomConnector + 1,
_wires[wIx].Color,
cutRuleStr(_wires[wIx].CutRule),
_wires[wIx].VennColors.Length == 0 ? "none" : _wires[wIx].VennColors.JoinString("+"),
_wires[wIx].Reason,
_moduleId);
_wires[wIx].Selectable = wireObj.GetComponent <KMSelectable>();
_wires[wIx].Selectable.OnInteract = getWireHandler(wIx);
}
// Output the generated SVG to the logfile.
var svg = new StringBuilder();
var starsCoordsX = new[] { 123.3 - 5, 161 - 5, 198.5 - 5, 236 - 5 };
var starsCoordsY = new[] { 36.2, 50, 63.6, 77.2 };
var starsConnectorCoordsX = new[] { 115.6 - 5, 153.2 - 5, 190.8 - 5, 228.4 - 5 };
var starsConnectorCoordsY = new[] { 69.8, 83.5, 97.2, 111 };
// Wires
for (var i = 0; i < 6; i++)
{
svg.AppendFormat(
"<path d='M{0} 250 {0} 200 {1} {2} {3} {4}' stroke='#543' stroke-linecap='round' stroke-linejoin='round' stroke-width='16'/>" +
"<path d='M{0} 250 {0} 200 {1} {2} {3} {4}' stroke='{5}' stroke-linecap='round' stroke-linejoin='round' stroke-width='13'/>" +
"<text x='{0}' y='370' text-anchor='middle'>{6}</text>" +
"<text x='{0}' y='390' text-anchor='middle' stroke='none' fill='{7}'>{8}</text>",
/* {0} */ 40 + 40 * i,
/* {1} */ starsConnectorCoordsX[_wires[i].TopConnector],
/* {2} */ starsConnectorCoordsY[_wires[i].TopConnector],
/* {3} */ starsCoordsX[_wires[i].TopConnector],
/* {4} */ starsCoordsY[_wires[i].TopConnector],
/* {5} */ colorSvg(_wires[i].Color),
/* {6} */ _wires[i].Reason,
/* {7} */ _wires[i].CutRule == CutRule.DontCut ? "#a00" : "#080",
/* {8} */ cutRuleSvg(_wires[i].CutRule)
);
}
// Lettering at the bottom
var vennColors = new[] { "#eb1414", "#ffb100", "#ee0", "#00be00", "#09f" };
var vennColorNames = new[] { "Red", "Orange", "Yellow", "Green", "Blue" };
for (var i = 0; i < 6; i++)
{
for (var cIx = 0; cIx < _wires[i].VennColors.Length; cIx++)
{
var c = Array.IndexOf(vennColorNames, _wires[i].VennColors[cIx]);
svg.AppendFormat("<rect x='{0}' y='{1}' width='20' height='10' stroke='none' fill='{2}'/>", 30 + 40 * i, 275 + 15 * c, vennColors[c]);
}
}
// Frames
svg.Append(
"<path d='M10 10h50v110H10z'/>" + // LEDs frame
"<path d='M95.5 10l169.2 61.7-10.2 28.2L85.3 38.2z' fill='#fff'/>" + // stars
"<path d='M10 230h260v40H10z' fill='#fff'/>"); // arrows
// LEDs
svg.AppendFormat("<path d='M35 22 l8.7 4 2.2 9.6-6 7.6H30l-6-7.6 2-9.5z' fill='{0}'/>", _ledsOn[0] ? "lime" : "#234");
svg.AppendFormat("<path d='M35 54.5l8.7 4 2.2 9.5-6 7.7H30L24 68l2-9.4z' fill='{0}'/>", _ledsOn[1] ? "lime" : "#234");
svg.AppendFormat("<path d='M35 86.8l8.7 4.3 2.2 9.5-6 7.5H30l-6-7.5 2-9.7z' fill='{0}'/>", _ledsOn[2] ? "lime" : "#234");
// Stars
for (var i = 0; i < 4; i++)
{
svg.AppendFormat("<path transform='translate({0}, {1}) rotate(20)' d='M0-10l2.2 7h7.3l-6 4.2 2.4 7-6-4.4-6 4.3 2.4-6.8-6-4.3H-2z' fill='{2}'/>", starsCoordsX[i], starsCoordsY[i], _filledStars[i] ? "black" : "white");
}
// Arrows
for (var i = 0; i < 6; i++)
{
svg.AppendFormat("<path transform='translate({0}, 250) rotate({1})' d='M0-15L11 0H5.7v15H-5.7v-15H-11z' fill='{2}'/>", 40 + 40 * i, arrowDirSvg(_arrows[i]), colorSvg(_arrows[i]));
}
Debug.LogFormat("[Perplexing Wires #{0}]=svg[Module:]<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 462 400' fill='none' stroke='#000' stroke-width='2' font-family='Trebuchet MS'>{1}</svg>", _moduleId, svg.ToString());
// Finally, get rid of the extra Wire objects that only exist to hold the colored materials.
var dwIx = _wires.Length;
while (true)
{
var wireObj = wiresParent.Find("Wire" + (dwIx + 1));
if (wireObj == null)
{
break;
}
Destroy(wireObj.gameObject);
dwIx++;
}
// Object that will be cloned to create the wire copper when a wire is cut.
_wireCopper = wiresParent.Find("WireCopper").gameObject;
_wireCopper.SetActive(false);
MainSelectable.Children = _wires.Select(w => w.Selectable).ToArray();
MainSelectable.UpdateChildren();
if (ColorblindMode.ColorblindModeActive)
{
ActivateColorblindMode();
}
}
// Use this for initialization
void Start()
{
meshGenerator = FindObjectOfType <MeshGenerator>();
Destroy(gameObject, maxLiveTime);
}
override protected void PrepareMeshGenerator(MeshGenerator meshGenerator, Map map)
{
meshGenerator.GenerateIsometric(map, floorHeightMap, mainHeightMap);
}
private void ResetMeshForTrackSegment(MeshGenerator meshGenerator, TrackSegment4 segment)
{
FieldInfo generatedMesh = typeof(TrackSegment4).GetField ("generatedMeshes", BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic);
List<Mesh> meshes = (List<Mesh>)generatedMesh.GetValue (segment);
foreach (Mesh m in meshes) {
UnityEngine.Object.DestroyImmediate (m);
}
meshes.Clear ();
foreach(Transform child in segment.gameObject.transform) {
var mesh_filter = child.gameObject.GetComponent<MeshFilter> ();
if (mesh_filter != null) {
UnityEngine.Object.DestroyImmediate (mesh_filter.mesh);
UnityEngine.Object.DestroyImmediate (mesh_filter.sharedMesh);
}
UnityEngine.Object.DestroyImmediate (child.gameObject);
}
UnityEngine.Object.DestroyImmediate( segment.gameObject.GetComponent<MouseCollider> ());
UnityEngine.Object.DestroyImmediate( segment.gameObject.GetComponent<MeshCollider> ());
UnityEngine.Object.DestroyImmediate( segment.gameObject.GetComponent<BoundingMesh> ());
}
/// <summary> /// Generate all the data in the MeshGenerator in preparation for the creation of meshes. This method may /// get executed outside of the main thread, so don't touch the Unity API when implementing. /// </summary> abstract protected void PrepareMeshGenerator(MeshGenerator meshGenerator, Map map);
protected override void PrepareMeshGenerator(MeshGenerator meshGenerator, Map map)
{
meshGenerator.GenerateEnclosed(map, floorHeightMap, mainHeightMap);
}
void Start()
{
target.mesh = MeshGenerator.GeneratePlane(1, 1, Repeat, Repeat);
targetMtrl.material = new Material(Shader.Find("Image/ImageMozaik"));
}
void Start()
{
meshGen = (MeshGenerator)gameObject.GetComponent("MeshGenerator");
fromVec = new Vector4(4,0,0,0);
up = new Vector4(0,1,0,0);
over = new Vector4(0,0,1,0);
}
/// <summary>
/// Modifies the map according to the number players connected.
/// </summary>
public bool playerConnected()
{
players = GameObject.FindGameObjectsWithTag("Player");
powCount = 0;
while (Mathf.Pow(2, powCount) <= players.Length)
powCount++; // THOUGHT: Maybe have a look at Mathf.Log()
powCount--;//need to go one step back, as the loop above will stop when one step further in the calculation of the pow count
//if any of the map rings have sunked previously and we need to spawn new ones.
//if (powCount > map.transform.childCount - 1 && powCount > ringsSpawned - ringsSunk)
if (powCount > map.transform.childCount - 1)
{
startSinking();
// if the number of players requires more map rings than already present, generate them.
if (!sinkingARing)
{
//thickness represents how many extra ring components will the new map ring contain, based on the number of players
thickness = 8f / Mathf.Pow(2, powCount - 1);
//increase the number of rings Spawned, substracting the ones that have sunk, to keep track of how many rings are on the map atm.
ringsSpawned = ringsSpawned - ringsSunk + 1;
GameObject ringNo = new GameObject(); //create a new Ring parent for the the map parts to be spawned
ringNo.transform.parent = map.transform; //add the new Ring as a child to the map GameObject
ringNo.transform.name = ringsSpawned.ToString(); //give it the name of it's ring number
ringNo.transform.tag = "Ring";
mapPartBehavior mapPart = ringNo.AddComponent<mapPartBehavior>() as mapPartBehavior;
mapData = ringNo.AddComponent<MeshGenerator>() as MeshGenerator;
mapData.AlocateMeshData((int)(thickness + radius) * 2, (int)(thickness + radius) * 2);
ringDrawing((int)thickness, ringNo); // need to deal with a float thickness to account for smaller rings.
//Set the Layer to Ground.
ringNo.transform.gameObject.layer = LayerMask.NameToLayer("Ground");
print("RngNo Layer = " + ringNo.transform.gameObject.layer);
//Remove redundant vertices.
HashSet<Vector3> noDuplicateVertices = new HashSet<Vector3>();
Vector3[] vertices = ringNo.GetComponent<MeshFilter>().mesh.vertices;
for (int i = 0; i < vertices.Length; i++)
{
noDuplicateVertices.Add(vertices[i]);
}
Vector3[] newVertices = new Vector3[noDuplicateVertices.Count];
noDuplicateVertices.CopyTo(newVertices);
//Add the new ring to the List of the map.
//map.GetComponent<EnvironmentPlacement>().AddSection(ringNo, newVertices);
}
else
{
sinkingARing = false;
int mapRingsNo = map.transform.childCount;
Transform temp = map.transform.GetChild(mapRingsNo - 1);
mapPartBehavior partsToSink = temp.GetComponent<mapPartBehavior>();
if (partsToSink != null)
partsToSink.stopSinking();
}
return true;
}
return false;
}
private void recalculate(MeshGenerator meshGenerator, TrackSegment4 segment)
{
foreach(Transform child in segment.gameObject.transform) {
if (child.name != "BetweenTracksMouseCollider" && !child.name.Contains("StationPlatformTrackTile") && child.name != "MouseSelectionCollider") {
var mesh_filter = child.gameObject.GetComponent<MeshFilter> ();
if (mesh_filter != null) {
UnityEngine.Object.Destroy (mesh_filter.mesh);
UnityEngine.Object.Destroy (mesh_filter.sharedMesh);
}
UnityEngine.Object.Destroy (child.gameObject);
}
}
if (segment.getLength() <= 0f)
{
Debug.LogWarning("Can't extrude this segment! Has a length of 0.");
}
meshGenerator.prepare(segment, segment.gameObject);
float num = 0f;
float num2 = 0f;
meshGenerator.sampleAt(segment, 0f);
int num3 = 0;
int num4 = 0;
Vector3 b = segment.getStartpoint();
do
{
float num5 = 1f - num2;
if (Vector3.Angle(segment.getDirection(), segment.getPoint(num2 + num5) - segment.getPoint(num2)) > 5f)
{
num5 /= 2f;
}
int num6 = 0;
Vector3 point = segment.getPoint(num2 + num5);
float num7 = Vector3.Angle(segment.getTangentPoint(num2), segment.getTangentPoint(num2 + num5));
num7 = Mathf.Max(num7, Vector3.Angle(segment.getNormal(num2), segment.getNormal(num2 + num5)));
while (num5 > 0.01f && (num7 > 10f || (num7 > 2f && (point - b).magnitude > 0.225f)))
{
num4++;
num5 /= 2f;
point = segment.getPoint(num2 + num5);
num7 = Vector3.Angle(segment.getTangentPoint(num2), segment.getTangentPoint(num2 + num5));
num7 = Mathf.Max(num7, Vector3.Angle(segment.getNormal(num2), segment.getNormal(num2 + num5)));
num6++;
if (num6 > 50)
{
break;
}
}
num += (point - b).magnitude;
num2 += num5;
b = point;
if (num2 > 1f)
{
break;
}
meshGenerator.sampleAt(segment, num2);
num3++;
}
while (num2 < 1f && num3 < 300);
if (!Mathf.Approximately(num2, 1f))
{
meshGenerator.sampleAt(segment, 1f);
}
meshGenerator.afterExtrusion(segment, segment.gameObject);
MeshFilter component = segment.gameObject.GetComponent<MeshFilter>();
Mesh mesh = meshGenerator.getMesh(segment.gameObject);
UnityEngine.Object.Destroy (component.sharedMesh);
UnityEngine.Object.Destroy (component.mesh);
component.sharedMesh = mesh;
meshGenerator.afterMeshGeneration(segment, segment.gameObject);
Extruder buildVolumeMeshExtruder = meshGenerator.getBuildVolumeMeshExtruder();
buildVolumeMeshExtruder.transform(segment.gameObject.transform.worldToLocalMatrix);
BoundingMesh boundingMesh = segment.gameObject.GetComponent<BoundingMesh>();
boundingMesh.layers = BoundingVolume.Layers.Buildvolume;
boundingMesh.setMesh(buildVolumeMeshExtruder.vertices.ToArray(), buildVolumeMeshExtruder.indizes.ToArray());
GameObject track_mouse_collider = segment.transform.Find ("BetweenTracksMouseCollider").gameObject;// new GameObject("BetweenTracksMouseCollider");
track_mouse_collider.transform.parent = segment.gameObject.transform;
track_mouse_collider.transform.localPosition = Vector3.zero;
track_mouse_collider.transform.localRotation = Quaternion.identity;
track_mouse_collider.layer = LayerMasks.ID_MOUSECOLLIDERS;
MeshCollider meshCollider = track_mouse_collider.GetComponent<MeshCollider>();
Mesh collisionMesh = meshGenerator.getCollisionMesh(segment.gameObject);
UnityEngine.Object.Destroy (meshCollider.sharedMesh);
meshCollider.sharedMesh = collisionMesh;
MouseCollider mouseCollider = segment.gameObject.GetComponent<MouseCollider>();
mouseCollider.colliderObject = track_mouse_collider;
}
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g)
{
int?color = GetColor(BlockTerrain.GetData(value));
if (color.HasValue)
{
g.Terrain.Mesh(x, y, z, paintedBlockMeshes[GetVariant(BlockTerrain.GetData(value))], BlocksData.DEFAULT_COLORS[color.Value]);
}
else
{
g.Terrain.Mesh(x, y, z, blockMeshes[GetVariant(BlockTerrain.GetData(value))], Color.white);
}
}
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings)
{
hasRequestedMesh = true;
//mapGenerator.RequestMeshData(mapData, levelOfDetail, OnMeshDataReceived);
ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, levelOfDetail), OnMeshDataReceived);
}
public void GenerateTerrain(int x, int y, int z, int value, BlockTerrain.Chunk chunk, MeshGenerator g)
{
Vector3 v000 = new Vector3(x, y, z);
Vector3 v001 = new Vector3(x, y, z + 1.0f);
Vector3 v010 = new Vector3(x, y + 0.125f, z);
Vector3 v011 = new Vector3(x, y + 0.125f, z + 1.0f);
Vector3 v100 = new Vector3(x + 1.0f, y, z);
Vector3 v101 = new Vector3(x + 1.0f, y, z + 1.0f);
Vector3 v110 = new Vector3(x + 1.0f, y + 0.125f, z);
Vector3 v111 = new Vector3(x + 1.0f, y + 0.125f, z + 1.0f);
GreedyTerrainMesh terrainMesh = g.AlphaTest;
int content = chunk.GetCellContent(x - 1, y, z);
if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
{
terrainMesh.NormalQuad(v001, v011, v010, v000, TextureSlot, Color.white);
}
content = chunk.GetCellContent(x, y, z - 1);
if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
{
terrainMesh.NormalQuad(v000, v010, v110, v100, TextureSlot, Color.white);
}
content = chunk.GetCellContent(x + 1, y, z);
if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
{
terrainMesh.NormalQuad(v100, v110, v111, v101, TextureSlot, Color.white);
}
content = chunk.GetCellContent(x, y + 1, z);
if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
{
terrainMesh.NormalQuad(v111, v110, v010, v011, TextureSlot, Color.white);
}
content = chunk.GetCellContent(x, y, z + 1);
if (content != BlockTerrain.NULL_BLOCK_CONTENT && content != Index && BlocksData.IsTransparent[content])
{
terrainMesh.NormalQuad(v101, v111, v011, v001, TextureSlot, Color.white);
}
}
void Start()
{
meshGen = (MeshGenerator)gameObject.GetComponent("MeshGenerator");
leftCylinders = new GameObject[(hypercube) ? 32 : 10];
rightCylinders = new GameObject[(hypercube) ? 32 : 10];
// Projection values pulled from http://steve.hollasch.net/thesis/chapter4.html
toVec = new Vector4(1,0,0,0);
fromVec = new Vector4(0,0,0,-.03f);
up = new Vector4(0,1,0,0);
over = new Vector4(0,0,1,0);
if (hypercube) {
drawHypercubeWithRotation(Matrix4x4.identity, true, leftCylinders);
} else {
drawHypertetrahedronWithRotation(Matrix4x4.identity, true, leftCylinders);
}
if (usingOculus) {
fromVec = new Vector4(0,0,0,.03f);
if (hypercube) {
drawHypercubeWithRotation(Matrix4x4.identity, false, rightCylinders);
} else {
drawHypertetrahedronWithRotation(Matrix4x4.identity, false, rightCylinders);
}
}
}
// while this does properly generate maps, the x and y vars are reversed
// since 2d arrays are [y, x] aka [rows, columns]
// therefore width is used as height and vice versa
public void GenerateMap(string seed)
{
generated = false;
map = new int[ServerManager.instance.mapWidth, ServerManager.instance.mapHeight];
RandomFillMap(seed);
for (int i = 0; i < 5; i++)
{
SmoothMap();
}
ProcessMap();
int borderSize = 1;
int[,] borderedMap = new int[ServerManager.instance.mapWidth + borderSize * 2, ServerManager.instance.mapHeight + borderSize * 2];
for (int x = 0; x < borderedMap.GetLength(0); x++)
{
for (int y = 0; y < borderedMap.GetLength(1); y++)
{
if (x >= borderSize && x < ServerManager.instance.mapWidth + borderSize && y >= borderSize && y < ServerManager.instance.mapHeight + borderSize)
{
borderedMap[x, y] = map[x - borderSize, y - borderSize];
}
else
{
borderedMap[x, y] = 1;
}
}
}
MeshGenerator meshGen = GetComponent <MeshGenerator>();
meshGen.GenerateMesh(borderedMap, 1);
List <List <Coord> > roomRegions = GetRegions(0);
foreach (List <Coord> roomRegion in roomRegions)
{
foreach (Coord tile in roomRegion)
{
spawnableCoords.Add(tile);
}
}
// generating is done
generated = true;
// lazy
GameObject waterBG = GameObject.Find("WaterBackground");
GameObject darkBG = GameObject.Find("DarkBackground");
// set size to cover map
// note: REVERSED because the function uses width as height and vice versa
waterBG.transform.localScale = new Vector3(ServerManager.instance.mapHeight * 3f / 10f, 1,
ServerManager.instance.mapWidth * 3f / 10f);
darkBG.transform.localScale = new Vector3(ServerManager.instance.mapHeight * 3f / 10f + 15, 1,
ServerManager.instance.mapWidth * 3f / 10f + 15);
ServerManager.instance.mapGenPrefab.transform.GetChild(0).GetComponent <Renderer>().sharedMaterial.mainTextureScale = new Vector2(ServerManager.instance.mapWidth / 1.5f, ServerManager.instance.mapHeight / 1.5f); // Change Tiling settings of the map
}
void Start()
{
m_grassSpr = Resources.Load<Sprite>("Grass");
m_dirtSpr = Resources.Load<Sprite>("Dirt");
m_sandSpr = Resources.Load<Sprite>("Sand");
m_stoneSpr = Resources.Load<Sprite>("Stone");
m_voxelGenerator = GetComponent<MeshGenerator>();
//we now set the parent
m_voxelGenerator.m_parent = this;
m_voxelGenerator.WorldInit();
if (networkView != null)
{
if (!networkView.isMine)
{
networkView.RPC("RequestTerrain", networkView.owner, Network.player);
}
else
{
GenerateChunk();
}
}
else
{
GenerateChunk();
}
}
private void Bake(MeshGenerator gen)
{
MeshFilter filter = gen.GetComponent <MeshFilter>();
if (filter == null)
{
EditorUtility.DisplayDialog("Save error", "No mesh present in " + gen.name, "OK");
return;
}
if (copy)
{
UnityEditor.MeshUtility.Optimize(filter.sharedMesh);
Unwrapping.GenerateSecondaryUVSet(filter.sharedMesh);
}
else
{
gen.Bake(isStatic, true);
}
if (format == BakeMeshWindow.SaveFormat.OBJ)
{
MeshRenderer renderer = gen.GetComponent <MeshRenderer>();
dirInfo = new DirectoryInfo(savePath);
FileInfo[] files = dirInfo.GetFiles(filter.sharedMesh.name + "*.obj");
string meshName = filter.sharedMesh.name;
if (files.Length > 0)
{
meshName += "_" + files.Length;
}
string path = savePath + "/" + meshName + ".obj";
string objString = Dreamteck.MeshUtility.ToOBJString(filter.sharedMesh, renderer.sharedMaterials);
File.WriteAllText(path, objString);
if (copy)
{
string relativepath = "Assets" + path.Substring(Application.dataPath.Length);
AssetDatabase.ImportAsset(relativepath, ImportAssetOptions.ForceSynchronousImport);
filter.sharedMesh = AssetDatabase.LoadAssetAtPath <Mesh>(relativepath);
}
}
if (format == BakeMeshWindow.SaveFormat.MeshAsset)
{
dirInfo = new DirectoryInfo(savePath);
FileInfo[] files = dirInfo.GetFiles(filter.sharedMesh.name + "*.asset");
string meshName = filter.sharedMesh.name;
if (files.Length > 0)
{
meshName += "_" + files.Length;
}
string path = savePath + "/" + meshName + ".asset";
string relativepath = "Assets" + path.Substring(Application.dataPath.Length);
if (copy)
{
Mesh assetMesh = Dreamteck.MeshUtility.Copy(filter.sharedMesh);
AssetDatabase.CreateAsset(assetMesh, relativepath);
}
else
{
AssetDatabase.CreateAsset(filter.sharedMesh, relativepath);
}
}
if (permanent && !copy)
{
SplineComputer meshGenComputer = gen.spline;
if (permanent)
{
meshGenComputer.Unsubscribe(gen);
Object.DestroyImmediate(gen);
}
if (removeComputer)
{
if (meshGenComputer.GetComponents <Component>().Length == 2)
{
Object.DestroyImmediate(meshGenComputer.gameObject);
}
else
{
Object.DestroyImmediate(meshGenComputer);
}
}
}
}
private void RegenerateChunk(int x)
{
if (_chunks[x].mesh == null)
{
_chunks[x].mesh = new Mesh();
_chunks[x].transform = UnityEngine.Matrix4x4.TRS(-transform.position, Quaternion.identity, Vector3.one);
}
var generator = new MeshGenerator(VoxelSize);
var vertices = new List <Vector3>();
var triangles = new List <int>();
var uv = new List <Vector2>();
var squareCount = 0;
for (var chunkX = x * ChunkWidth; chunkX < Mathf.Min(_shipSize.x, x * ChunkWidth + ChunkWidth); chunkX++)
{
for (var y = 0; y < _shipSize.y; y++)
{
/////////////////////////////////////////////////////////////
// Top face
/////////////////////////////////////////////////////////////
for (var z = 0; z < _shipSize.z; z++)
{
var blocksCount = 0;
for (var existingBlockIndex = z; existingBlockIndex < _shipSize.z; existingBlockIndex++)
{
if (_shipMap[chunkX, y, existingBlockIndex] &&
(y == _shipSize.y - 1 || !_shipMap[chunkX, y + 1, existingBlockIndex]))
{
blocksCount++;
}
else
{
break;
}
}
if (blocksCount > 0)
{
var realCoords = GetRealBlockPositionByArray(new Vector3Int(chunkX, y, z));
var centerOffset = realCoords - new Vector3(VoxelSize, VoxelSize, VoxelSize) / 2;
generator.GenerateTopFace(blocksCount, centerOffset, vertices, triangles, uv, squareCount);
squareCount++;
z += blocksCount - 1;
}
}
/////////////////////////////////////////////////////////////
// Bottom face
/////////////////////////////////////////////////////////////
for (var z = 0; z < _shipSize.z; z++)
{
var blocksCount = 0;
for (var existingBlockIndex = z; existingBlockIndex < _shipSize.z; existingBlockIndex++)
{
if (_shipMap[chunkX, y, existingBlockIndex] && (y == 0 || !_shipMap[chunkX, y - 1, existingBlockIndex]))
{
blocksCount++;
}
else
{
break;
}
}
if (blocksCount > 0)
{
var realCoords = GetRealBlockPositionByArray(new Vector3Int(chunkX, y, z));
var centerOffset = realCoords - new Vector3(VoxelSize, VoxelSize, VoxelSize) / 2;
generator.GenerateBottomFace(blocksCount, centerOffset, vertices, triangles, uv, squareCount);
squareCount++;
z += blocksCount - 1;
}
}
/////////////////////////////////////////////////////////////
// Right face
/////////////////////////////////////////////////////////////
for (var z = 0; z < _shipSize.z; z++)
{
var blocksCount = 0;
for (var existingBlockIndex = z; existingBlockIndex < _shipSize.z; existingBlockIndex++)
{
if (_shipMap[chunkX, y, existingBlockIndex] &&
(chunkX == _shipSize.x - 1 || !_shipMap[chunkX + 1, y, existingBlockIndex]))
{
blocksCount++;
}
else
{
break;
}
}
if (blocksCount > 0)
{
var realCoords = GetRealBlockPositionByArray(new Vector3Int(chunkX, y, z));
var centerOffset = realCoords - new Vector3(VoxelSize, VoxelSize, VoxelSize) / 2;
generator.GenerateRightFace(blocksCount, centerOffset, vertices, triangles, uv, squareCount);
squareCount++;
z += blocksCount - 1;
}
}
/////////////////////////////////////////////////////////////
// Left face
/////////////////////////////////////////////////////////////
for (var z = 0; z < _shipSize.z; z++)
{
var blocksCount = 0;
for (var existingBlockIndex = z; existingBlockIndex < _shipSize.z; existingBlockIndex++)
{
if (_shipMap[chunkX, y, existingBlockIndex] && (chunkX == 0 || !_shipMap[chunkX - 1, y, existingBlockIndex]))
{
blocksCount++;
}
else
{
break;
}
}
if (blocksCount > 0)
{
var realCoords = GetRealBlockPositionByArray(new Vector3Int(chunkX, y, z));
var centerOffset = realCoords - new Vector3(VoxelSize, VoxelSize, VoxelSize) / 2;
generator.GenerateLeftFace(blocksCount, centerOffset, vertices, triangles, uv, squareCount);
squareCount++;
z += blocksCount - 1;
}
}
for (var z = 0; z < _shipSize.z; z++)
{
if (!_shipMap[chunkX, y, z])
{
continue;
}
var realCoords = GetRealBlockPositionByArray(new Vector3Int(chunkX, y, z));
var centerOffset = realCoords - new Vector3(VoxelSize, VoxelSize, VoxelSize) / 2;
if (z == _shipSize.z - 1 || !_shipMap[chunkX, y, z + 1])
{
generator.GenerateFrontFace(centerOffset, vertices, triangles, uv, squareCount);
squareCount++;
}
if (z == 0 || !_shipMap[chunkX, y, z - 1])
{
generator.GenerateBackFace(centerOffset, vertices, triangles, uv, squareCount);
squareCount++;
}
}
}
}
_chunks[x].mesh.Clear();
_chunks[x].mesh.vertices = vertices.ToArray();
_chunks[x].mesh.triangles = triangles.ToArray();
_chunks[x].mesh.uv = uv.ToArray();
_chunks[x].mesh.RecalculateNormals();
}
/// <summary>
/// Generating a mesh interpreting the 3D data as noise and generating cubes in a 3D grid if the noise is over the threshold
/// Smoothens the mesh by reusing vertices
/// </summary>
/// <param name="data3D">The 3D data representation of the image (or of anything else if you want).</param>
/// <param name="threshold">Value between 0 and 1. A good value here is normally 0.5 Different values can be appropriate for different (non image) data.</param>
/// <param name="alwaysDrawBottomCube">With this parameter set the lowest place of cubes is always drawn. Making sure there are no "holes"</param>
/// <returns></returns>
public static Mesh Generate3DNoiseSmooth(Data3D data3D, float threshold, bool alwaysDrawBottomCube = true)
{
Vector3 StartPos = new Vector3(-0.5f * data3D.X + 0.5f, 0.5f, -0.5f * data3D.Y + 0.5f);
if (alwaysDrawBottomCube)
{
StartPos = new Vector3(-0.5f * data3D.X + 0.5f, -0.5f, -0.5f * data3D.Y + 0.5f);
}
Vector3 spawnPosition;
// move this much
Vector2 minUV = new Vector2(0.5f * data3D.X, 0.5f * data3D.Y);
//divide by this much
Vector2 maxUV = new Vector2(data3D.X + 1, data3D.Y + 1);
List <Vector3> positions = new List <Vector3>();
List <bool[]> ignoreFace = new List <bool[]>();
List <Vector2> uv = new List <Vector2>();
float scaleX = 1.0f / data3D.X;
float scaleY = 1.0f / data3D.Y;
float scaleZ = 1.0f / data3D.Z;
for (int i = 0; i < data3D.X; i++)
{
for (int j = 0; j < data3D.Y; j++)
{
for (int k = 0; k < data3D.Z; k++)
{
if (data3D[i, j, k].Value > threshold)
{
spawnPosition = StartPos + new Vector3(i, k, j);
positions.Add(spawnPosition);
bool[] ignore = new bool[6] {
j > 0 && data3D[i, j - 1, k].Value > threshold,
j <data3D.Y - 1 && data3D[i, j + 1, k].Value> threshold,
k <data3D.Z - 1 && data3D[i, j, k + 1].Value> threshold,
i <data3D.X - 1 && data3D[i + 1, j, k].Value> threshold,
(k == 0) || data3D[i, j, k - 1].Value > threshold,
i > 0 && data3D[i - 1, j, k].Value > threshold,
};
ignoreFace.Add(ignore);
/*
* int siteCount = 0;
* for (int count2 = 0; count2 < 6; count2++) {
* if (!ignore[count2]) {
* siteCount++;
* }
* }
* int endcount = siteCount * 4;
* //Todo make option for flowing colors
* for (int count = 0; count < endcount; count++) {
* Vector2 position = new Vector2(scaleX * i, scaleY * j);
* uv.Add(position);
* }
*/
}
}
}
}
Mesh returnvalue = MeshGenerator.GetCubesSmooth(positions, ignoreFace, Vector3.one, minUV, maxUV);
//returnvalue.uv = uv.ToArray();
return(returnvalue);
}
public void RequestMesh(HeightMap heightMap, MeshSettings meshSettings)
{
hasRequestedMesh = true;
ThreadedDataRequester.RequestData(() => MeshGenerator.GenerateTerrainMesh(heightMap.values, meshSettings, lod), OnMeshDataReceived);
}
/// <summary>
/// Generates a Terrain (deformed plane) according to the 2D data
/// </summary>
/// <param name="data2D">The height data representation of the image</param>
/// <param name="maxHeight">The maximum height the terrain should have </param>
/// <returns>Returns a mesh representing the generated terrain.</returns>
public static Mesh GenerateTerrain(DataGrid data2D, float maxHeight)
{
return(MeshGenerator.ConstructGrid(data2D, maxHeight));
}
public static void WriteGeneratedMesh(MeshGenerator gen, string sFilename)
{
DMesh3 mesh = gen.MakeDMesh();
TestUtil.WriteTestOutputMesh(mesh, sFilename);
}
void Update()
{
if (dgen != null)
{
if (dgen.Update())
{
// Alternative to the OnFinished callback
map = dgen.newDungeon;
int borderSize = 2;
borderedMap = new int[DungeonGen.width + borderSize * 2,DungeonGen.height + borderSize * 2];
for (int x = 0; x < borderedMap.GetLength(0); x ++) {
for (int y = 0; y < borderedMap.GetLength(1); y ++) {
if (x >= borderSize && x < DungeonGen.width + borderSize && y >= borderSize && y < DungeonGen.height + borderSize) {
borderedMap[x,y] = map[x-borderSize,y-borderSize];
}
else {
borderedMap[x,y] =1;
}
}
}
meshGen = GetComponent<MeshGenerator>();
Vector3 start = new Vector3(0,-10,0);
Vector3 end = new Vector3(0,-10,1);
List<Vector3> spaces = new List<Vector3>();
List<Vector3> walls = new List<Vector3>();
for (int x = 0; x < borderedMap.GetLength(0); x++){
for (int y = 0; y < borderedMap.GetLength(1); y++){
if ( borderedMap[x,y] == DungeonGen.space){
spaces.Add(new Vector3((x-borderedMap.GetLength(0)/2)*meshGen.squareWidth-meshGen.squareWidth,-10,(y-borderedMap.GetLength(1)/2)*meshGen.squareWidth-meshGen.squareWidth));
} else if (borderedMap[x,y] == DungeonGen.wall){
walls.Add(new Vector3((x-borderedMap.GetLength(0)/2)*meshGen.squareWidth-meshGen.squareWidth,-10,(y-borderedMap.GetLength(1)/2)*meshGen.squareWidth-meshGen.squareWidth));
Instantiate(WallPrefab, new Vector3((x-borderedMap.GetLength(0)/2)*meshGen.squareWidth-meshGen.squareWidth,-8,(y-borderedMap.GetLength(1)/2)*meshGen.squareWidth-meshGen.squareWidth), transform.rotation);
}
}
}
// UnityEngine.Random.seed = 2;
start = spaces[UnityEngine.Random.Range(0,spaces.Count)];
end = start;
while (Vector3.Distance(start, end) < 6){ //Place end at least 6 away from start;
end = spaces[UnityEngine.Random.Range(0,spaces.Count)];
}
for (int i = 0; i < spaces.Count/8; i++){
placeObjectOnRandomWall(spaces, walls, wallChainPrefab, Vector3.zero);//For Minotaur
Vector3 floorChain = spaces[UnityEngine.Random.Range(0,spaces.Count)];
Instantiate(floorChainPrefab, floorChain+Vector3.down, floorChainPrefab.transform.rotation);
}
Vector3 minotaurStart = start;
while (Vector3.Distance(minotaurStart, start) < 12){ //Place minotaur at least 12 away from start;
minotaurStart = spaces[UnityEngine.Random.Range(0,spaces.Count)];
}
Instantiate(MinotaurPrefab, minotaurStart, MinotaurPrefab.transform.rotation);
for (int i = 0; i < spaces.Count/16; i++){
placeObjectOnRandomWall(spaces, walls, SecurityCameraPrefab, new Vector3(0,2,0)); //For robot
}
Vector3 robotStart = start;
while (Vector3.Distance(robotStart, start) < 12){ //Place minotaur at least 12 away from start;
robotStart = spaces[UnityEngine.Random.Range(0,spaces.Count)];
}
Instantiate(RobotPrefab, robotStart, RobotPrefab.transform.rotation);
// chain.transform.position += (closestWall-wallCh)/2;
Vector3 ghostStart = start;
while (Vector3.Distance(ghostStart, start) < 4 || Vector3.Distance(ghostStart, start) >12){ //Place minotaur at least 12 away from start;
ghostStart = spaces[UnityEngine.Random.Range(0,spaces.Count)];
}
Instantiate(GhostPrefab, ghostStart, GhostPrefab.transform.rotation);
// meshGen.GenerateMesh(borderedMap);
Destroy(Camera.main.gameObject);
Instantiate(playerController, start, transform.rotation);
Instantiate(StairsPrefab, end+Vector3.down, StairsPrefab.transform.rotation);
dgen = null;
}
}
}
public IEnumerator GetBoundaryVertices()
{
MeshGenerator startingBaseMesh = GetCorrespondingPathPart();
offset = startingBaseMesh.offset;
initialCavePos = startingBaseMesh.transform.position;
if (startingBaseMesh == null)
{
Debug.LogWarning("Abort!");
return(null);
}
leftVerticesColumn = new List <Vector3>();
rightVerticesColumn = new List <Vector3>();
int borderVerticesCount = caveLength;
while (borderVerticesCount > 0)
{
// Debug.Log("Getting border vertices for part "+startingBaseMesh.gameObject);
for (int i = 0; i < startingBaseMesh.rows * startingBaseMesh.columns; i += startingBaseMesh.columns)
{
leftVerticesColumn.Add(startingBaseMesh.Vertices[i].position);
}
for (int i = startingBaseMesh.columns - 1; i < startingBaseMesh.rows * startingBaseMesh.columns; i += startingBaseMesh.columns)
{
rightVerticesColumn.Add(startingBaseMesh.Vertices[i].position);
borderVerticesCount--;
}
string nextPartName = (int.Parse(startingBaseMesh.name) + 1).ToString();
GameObject nextPart = GameObject.Find(nextPartName);
if (nextPart)
{
startingBaseMesh = nextPart.GetComponent <MeshGenerator>();
}
else
{
startingBaseMesh = null;
}
if (!startingBaseMesh)
{
caveLength = caveLength - borderVerticesCount;
borderVerticesCount = 0;
}
}
Debug.Log("Final cave length: " + caveLength);
StartCoroutine(GenerateVertices());
return(null);
}
/*private void Start()
* {
* GenerateWater();
* }*/
public void GenerateWater()
{
terrainDisplay.DrawMeshOnly(MeshGenerator.GenerateFlatMesh(mapChunkSize, levelOfDetail));
terrainDisplay.meshFilter.GetComponent <Water>().Setup(mapChunkSize);
}
public void GenerateMap()
{
float[,] noiseMap = Noise.GenerateNoiseMap(mapChunkSize, mapChunkSize, seed, noiseScale, octaves, persistance, lacunarity, offset);
float[,] rainMap = Noise.GenerateNoiseMap(mapChunkSize, mapChunkSize, rainSeed, rainNoiseScale, rainOctaves, rainPersistance, rainLacunarity, rainOffset);
float[,] heatMap = Noise.GenerateNoiseMap(mapChunkSize, mapChunkSize, heatSeed, heatNoiseScale, heatOctaves, heatPersistance, heatLacunarity, heatOffset);
Color[] colorMap = new Color[mapChunkSize * mapChunkSize];
Color[] waterColorMap = new Color[mapChunkSize * mapChunkSize];
for (int y = 0; y < mapChunkSize; y++)
{
for (int x = 0; x < mapChunkSize; x++)
{
if (useFalloff)
{
noiseMap[x, y] = Mathf.Clamp01(noiseMap[x, y] - falloffMap[x, y]);
}
float currentHeight = noiseMap[x, y];
float currentRain = rainMap[x, y];
float currentHeat = heatMap[x, y];
for (int i = 0; i < regions.Length; i++)
{
if (currentHeight <= regions[i].height)
{
colorMap[y * mapChunkSize + x] = regions[i].color;
if (UseBiomes)
{
if (HeightColorOverride)
{
for (int j = biomes.Length - 1; j >= 0; j--)
{
if (currentHeat <= biomes[j].temperatureHeight)
{
if (currentRain <= biomes[j].rainfallHeight)
{
colorMap[y * mapChunkSize + x] = biomes[j].color;
break;
}
}
}
}
else if (!HeightColorOverride && regions[i].height > 0.5f && regions[i].height <= 0.67f)
{
for (int j = biomes.Length - 1; j >= 0; j--)
{
if (currentHeat <= biomes[j].temperatureHeight)
{
if (currentRain <= biomes[j].rainfallHeight)
{
colorMap[y * mapChunkSize + x] = biomes[j].color * (1 - noiseMap[x, y] + biomeHeightTone);
break;
}
}
}
}
}
break;
}
}
for (int k = 0; k < waterRegions.Length; k++)
{
if (currentHeight <= waterRegions[k].height)
{
waterColorMap[y * mapChunkSize + x] = waterRegions[k].color;
break;
}
}
}
}
MapDisplay display = FindObjectOfType <MapDisplay>();
if (drawMode == DrawMode.NoiseMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(noiseMap));
}
else if (drawMode == DrawMode.ColorMap)
{
display.DrawTexture(TextureGenerator.TextureFromColorMap(colorMap, mapChunkSize, mapChunkSize));
}
else if (drawMode == DrawMode.Mesh)
{
MeshData meshdata = MeshGenerator.GenerateTerrainMesh(noiseMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail);
display.DrawMesh(meshdata, TextureGenerator.TextureFromColorMap(colorMap, mapChunkSize, mapChunkSize));
//display.DrawWaterTexture(TextureGenerator.TextureFromColorMap(waterColorMap, mapChunkSize, mapChunkSize));
display.waterDrawMesh(MeshGenerator.GenerateWaterMesh(noiseMap, levelOfDetail), TextureGenerator.TextureFromColorMap(waterColorMap, mapChunkSize, mapChunkSize));
if (generateTrees && (!Application.isEditor || Application.isPlaying))
{
TreeBushGenerator treeBushGenerator = this.GetComponent <TreeBushGenerator>();
treeBushGenerator.generarPlantaciones(meshdata);
treeBushGenerator.generarArbolesYArbustos();
}
}
else if (drawMode == DrawMode.FalloffMap)
{
display.DrawTexture(TextureGenerator.TextureFromHeightMap(FalloffGenerator.GenerateFalloffMap(mapChunkSize)));
}
}
void OnEnable()
{
meshGenerator = (MeshGenerator)target;
}
public void FatEditor(MeshGenerator meshGen, float fat)
{
for (int i = 0; i < meshGen.Vertices.Count; i++)
{
}
}
/*void Spawn(int[,] map) {
*
* }*/
/*void Spawn(int[,] map) {
*
* int nodeX = map.GetLength(0);
* int nodeY = map.GetLength(1);
* int mapX;
* int mapY;
*
* for (int i = 0; i < 5; i++) {
* Destroy(spheres[i]);
* Destroy(capsules[i]);
* spheres[i] = GameObject.CreatePrimitive(PrimitiveType.Sphere);
* do {
* mapX = UnityEngine.Random.Range(2, nodeX - 2);
* mapY = UnityEngine.Random.Range(2, nodeY - 2);
* }
* while (map[mapX, mapY] == 1);
* spheres[i].transform.position = new Vector3(mapX - nodeX / 2, mapY - nodeY / 2, 0);
* capsules[i] = GameObject.CreatePrimitive(PrimitiveType.Capsule);
* do {
* mapX = UnityEngine.Random.Range(2, nodeX - 2);
* mapY = UnityEngine.Random.Range(2, nodeY - 2);
* }
* while (map[mapX, mapY] == 1 || (map[mapX - 1, mapY] == 0 && map[mapX + 1, mapY] == 0 && map[mapX, mapY - 1] == 0 && map[mapX, mapY + 1] == 0));
* capsules[i].transform.position = new Vector3(mapX - nodeX / 2 + 0.5f, mapY - nodeY / 2 + 0.5f, 0);
* if (map[mapX + 1, mapY] == 1 || map[mapX - 1, mapY] == 1)
* capsules[i].transform.Rotate(0.0f, 0.0f, 90.0f, Space.Self);
* }
* }*/
void GenerateMap()
{
if (!useExistingMesh)
{
map = new int[width, height];
RandomFillMap();
for (int i = 0; i < 5; i++)
{
SmoothMap();
}
ProcessMap();
}
int borderSize = 1;
int[,] borderedMap = new int[width + borderSize * 2, height + borderSize * 2];
if (!useExistingMesh)
{
for (int x = 0; x < borderedMap.GetLength(0); x++)
{
for (int y = 0; y < borderedMap.GetLength(1); y++)
{
if (x >= borderSize && x < width + borderSize && y >= borderSize && y < height + borderSize)
{
borderedMap[x, y] = map[x - borderSize, y - borderSize];
}
else
{
borderedMap[x, y] = 1;
}
}
}
}
else
{
for (int x = 0; x < width + borderSize * 2; x++)
{
for (int y = 0; y < height + borderSize * 2; y++)
{
borderedMap[x, y] = mapTo2D[x * (width + borderSize * 2) + y] - '0';
}
}
}
/*string arrayString ="";
* for (int x = 0; x < borderedMap.GetLength(0); x ++) {
* for (int y = 0; y < borderedMap.GetLength(1); y ++) {
* arrayString += string.Format("{0}", borderedMap[x,y]);
* }
* //arrayString += System.Environment.NewLine + System.Environment.NewLine;
* }
* Debug.Log(arrayString);
*/
MeshGenerator meshGen = GetComponent <MeshGenerator>();
meshGen.GenerateMesh(borderedMap, 1, useExistingMesh);
SpawnPlayer(borderedMap);
Debug.Log(borderedMap.GetLength(0));
Debug.Log(borderedMap.GetLength(1));
SpawnSpawner(borderedMap);
}
void MeshDataThread(MapData mapData, Action<MeshData> callback) {
MeshData meshData = MeshGenerator.GenerateTerrainMesh (mapData.heightMap, meshHeightMultiplier, meshHeightCurve, levelOfDetail);
lock (meshDataThreadInfoQueue) {
meshDataThreadInfoQueue.Enqueue (new MapThreadInfo<MeshData> (callback, meshData));
}
}
public static IEnumerator CheckForFinish(Street _street)
{
List <Cell> cellsToDelete = new List <Cell>();
while (listTask.Count > 0)
{
for (int i = listTask.Count - 1; i >= 0; i--)
{
if (listTask[i].IsCompleted)
{
if (listTask[i].Result.IsValid)
{
output.Add(listTask[i].Result);
}
else
{
cellsToDelete.Add(listTask[i].Result);
}
listTask.RemoveAt(i);
}
}
yield return(null);
}
//Create Normal Grid
GameObject obj = new GameObject("Grid");
MeshFilter mf = obj.AddComponent <MeshFilter>();
MeshRenderer mr = obj.AddComponent <MeshRenderer>();
obj.transform.position = new Vector3(0, 0.1f, 0);
obj.transform.parent = _street.transform;
mr.shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
mr.receiveShadows = false;
mr.lightProbeUsage = UnityEngine.Rendering.LightProbeUsage.Off;
mr.reflectionProbeUsage = UnityEngine.Rendering.ReflectionProbeUsage.Off;
mr.material = Instance.CellDefault;
foreach (Cell c in output)
{
_street.m_StreetCells.Add(c.Pos, c);
if (c.Pos.x == 1 || c.Pos.x == -1)
{
m_FirstGenCells.Add(c);
}
}
foreach (Cell c in cellsToDelete)
{
c.Delete();
}
//Remove Cells if Generation before is missing
for (int i = 0; i < output.Count; i++)
{
Cell c = output[i];
if (_street.m_StreetCells.ContainsKey(c.Pos))
{
if (c.m_isLeft && c.Pos.x - 1 > 0 && !_street.m_StreetCells.ContainsKey(new Vector2Int(c.Pos.x - 1, c.Pos.y)))
{
Vector2Int nextPose = c.Pos;
while (_street.m_StreetCells.ContainsKey(nextPose))
{
output.Remove(c);
c.Delete();
nextPose.x++;
}
}
if (!c.m_isLeft && c.Pos.x + 1 < 0 && !_street.m_StreetCells.ContainsKey(new Vector2Int(c.Pos.x + 1, c.Pos.y)))
{
Vector2Int nextPose = c.Pos;
while (_street.m_StreetCells.ContainsKey(nextPose))
{
c.Delete();
output.Remove(c);
nextPose.x--;
}
}
}
}
_street.m_RowAmount = _street.m_StreetCells.Keys.Max(v => v.y) + 1;
MeshGenerator.CreateGridMesh(_street, mf, mr);
m_AllCells.AddRange(output);
_street.m_GridObj = obj;
_street.m_GridRenderer = mr;
}
/// <summary> /// After meshes have been prepared, this asynchronous method is called to generate MapMeshes objects. /// When overriding, add the created MapMesh object to the instance-level MeshGenerators list. /// </summary> abstract protected IEnumerator CreateMapMeshes(MeshGenerator meshGenerator);
private void SetMeshGenerator() //TODO temp, move
{
_meshGenerator = new SurfaceNetsMeshGenerator(Chunk.ChunkManager.MeshSettings, this);
}
public void Start()
{
_meshGenerator = GetComponent<MeshGenerator>();
}
// takes as parameters map data, an LOD, and an action
void MeshDataThread(MapData mapData, int lod, Action <MeshData> callback)
{
MeshData meshData = MeshGenerator.GenerateTerrainMesh(mapData.heightMap, meshHeightMultiplier, lod);
lock (meshDataQueue) { meshDataQueue.Enqueue(new ThreadInfo <MeshData> (callback, meshData)); }
}
/// <summary>
/// build mesh generator from target
/// </summary>
/// <param name="target"></param>
/// <param name="loader"></param>
/// <typeparam name="TMeshGenerator"></typeparam>
/// <returns></returns>
public TrackMeshGeneratorBuilder <TMeshGenerator, TResult, TrackRideBuilder <TResult> > Generator <TMeshGenerator>(MeshGenerator target, AssetManagerLoader loader)
where TMeshGenerator : MeshGenerator
{
var builder = new TrackMeshGeneratorBuilder <TMeshGenerator, TResult, TrackRideBuilder <TResult> >(this);
AddStep("MESH_GENERATOR",
handler =>
{
handler.Target.meshGenerator = ScriptableObject.CreateInstance <TMeshGenerator>();
handler.Target.meshGenerator.stationPlatformGO = UnityEngine.Object.Instantiate(target.stationPlatformGO);
handler.Target.meshGenerator.stationHandRailGO = UnityEngine.Object.Instantiate(target.stationHandRailGO);
handler.Target.meshGenerator.material = target.material;
handler.Target.meshGenerator.liftMaterial = target.liftMaterial;
handler.Target.meshGenerator.frictionWheelsGO = UnityEngine.Object.Instantiate(target.frictionWheelsGO);
handler.Target.meshGenerator.supportInstantiator = target.supportInstantiator;
handler.Target.meshGenerator.crossBeamGO = UnityEngine.Object.Instantiate(target.crossBeamGO);
handler.Target.meshGenerator.customColors = target.customColors;
handler.Target.meshGenerator.tunnelMeshGenerator = target.tunnelMeshGenerator;
handler.Target.meshGenerator.lsmFinGO = target.lsmFinGO;
loader.HideGo(handler.Target.meshGenerator.frictionWheelsGO);
loader.HideGo(handler.Target.meshGenerator.crossBeamGO);
loader.HideGo(handler.Target.meshGenerator.stationHandRailGO);
});
return(builder);
}
public void UpdateChunk()
{
m_voxelGenerator = GetComponent<MeshGenerator>();
//we now set the parent
m_voxelGenerator.m_parent = this;
//m_terrainArray = new int[m_chunkSize, m_chunkHeight, m_chunkSize];
m_voxelGenerator.ClearPreviousData();
//do terrain modifications here
//CreatePath();
DisplayTerrain();
//finish up the model
m_voxelGenerator.UpdateWorld();
}
