public static MeshDraft Back1(Vector3 center, float width, float length, float height) { var draft = new MeshDraft(); int plankCount = Random.Range(1, 5); float plankStep = height/plankCount; float plankHeight = plankStep*Random.Range(0.3f, 0.8f); float plankWidth = width - length*2; float offeset = 0; if (plankCount > 1) { offeset = RandomE.Range(0, (plankStep - plankHeight)/2, 3); } Vector3 startPosition = Vector3.up*(-height/2 + plankStep - plankHeight/2 - offeset); for (int i = 0; i < plankCount; i++) { var plank = MeshDraft.Hexahedron(plankWidth, length, plankHeight); plank.Move(startPosition + Vector3.up*i*plankStep); draft.Add(plank); } var rod = MeshDraft.Hexahedron(length, length, height); rod.Move(Vector3.left*(width/2 - length/2)); draft.Add(rod); rod.Move(Vector3.right*(width - length)); draft.Add(rod); draft.Move(center + Vector3.up*height/2); return draft; }
private MeshDraft Facade(Vector3 origin, Vector3 direction, List<FloorPlan> facadePlan) { var draft = new MeshDraft(); Vector3 height = Vector3.zero; foreach (FloorPlan floor in facadePlan) { List<Panel> panels = floor.panels; Vector3 panelOrigin = origin + height; foreach (var panel in panels) { Vector3 offset = Vector3.up*panel.heightOffset; Vector3 panelWidth = direction.normalized*sizeValues[panel.size]; Vector3 panelHeight = Vector3.up*panel.height; PanelConstructor panelConstructor; if (commonPanelConstructors.ContainsKey(panel.type)) { panelConstructor = commonPanelConstructors[panel.type]; } else { panelConstructor = panelConstructors[panel.type].GetRandom(); } draft.Add(panelConstructor(panelOrigin + offset, panelWidth, panelHeight)); panelOrigin += panelWidth; } height += Vector3.up*floor.height; } return draft; }
public static MeshDraft RodBack(Vector3 center, float width, float length, float height) { var draft = new MeshDraft(); int rodCount = Random.Range(1, 5); float maxWidth = (width - length*2)/rodCount; float rodWidth = RandomE.Range(maxWidth/4, maxWidth*3/4, 3); float interval = (width - length*2 - rodWidth*rodCount)/(rodCount + 1); float upperRodHeight = Mathf.Min(height*3/4, length*Random.Range(1, 4)); float rodHeight = height - upperRodHeight; var leftRod = MeshDraft.Hexahedron(length, length, rodHeight); leftRod.Move(Vector3.left*(width - length)/2 + Vector3.down*upperRodHeight/2); draft.Add(leftRod); leftRod.Move(Vector3.right*(width - length)); draft.Add(leftRod); Vector3 startPosition = Vector3.left*(width/2 - length - interval - rodWidth/2) + Vector3.down*upperRodHeight/2; for (int i = 0; i < rodCount; i++) { var rod = MeshDraft.Hexahedron(rodWidth, length, rodHeight); rod.Move(startPosition + Vector3.right*i*(rodWidth + interval)); draft.Add(rod); } var upperRod = MeshDraft.Hexahedron(width, length, upperRodHeight); upperRod.Move(Vector3.up*rodHeight/2); draft.Add(upperRod); draft.Move(center + Vector3.up*height/2); return draft; }
private MeshDraft Armrests1(Vector3 seatDimensions, Vector3 backCenter, float backHeight, float legWidth) { var draft = new MeshDraft(); float armrestHeight = RandomE.Range(backHeight/4, backHeight*3/4, 3); float armrestLength = RandomE.Range(seatDimensions.z*3/4, seatDimensions.z, 2); legWidth = RandomE.Range(legWidth*3/4, legWidth, 2); var corner = backCenter + Vector3.left*(seatDimensions.x/2 + legWidth/2) + Vector3.forward*legWidth/2; float offset = 0; if (RandomE.Chance(0.5f)) { offset = RandomE.Range(armrestLength/4, armrestLength/2, 2) - legWidth/2; } var v0 = corner + Vector3.back*(armrestLength - legWidth/2 - offset) + Vector3.down*legWidth; var v1 = v0 + Vector3.up*(armrestHeight + legWidth/2); var v2 = corner + Vector3.up*armrestHeight; var v3 = v2 + Vector3.back*armrestLength; var armrest = BeamDraft(v0, v1, legWidth); armrest.Add(BeamDraft(v2, v3, legWidth)); draft.Add(armrest); armrest.Move(Vector3.right*(seatDimensions.x + legWidth)); draft.Add(armrest); return draft; }
private static MeshDraft Platform(float radius, float baseOffset, int segments, float heignt) { float segmentAngle = 360f/segments; float currentAngle = 0; var lowerRing = new List<Vector3>(segments); var upperRing = new List<Vector3>(segments); for (var i = 0; i < segments; i++) { var lowerPoint = PTUtils.PointOnCircle3XZ(radius + baseOffset, currentAngle); lowerRing.Add(lowerPoint + Vector3.down*heignt); var upperPoint = PTUtils.PointOnCircle3XZ(radius, currentAngle); upperRing.Add(upperPoint); currentAngle -= segmentAngle; } var platform = new MeshDraft {name = "Platform"}; var bottom = MeshDraft.TriangleFan(lowerRing); bottom.Add(MeshDraft.Band(lowerRing, upperRing)); bottom.Paint(new Color(0.5f, 0.5f, 0.5f, 1)); platform.Add(bottom); upperRing.Reverse(); var top = MeshDraft.TriangleFan(upperRing); top.Paint(new Color(0.8f, 0.8f, 0.8f, 1)); platform.Add(top); return platform; }
public static MeshDraft KhrushchyovkaDraft(float width, float length, int floorCount, bool hasAttic) { float height = FloorHeight*floorCount + SocleHeight + (hasAttic ? AtticHeight : 0); var draft = new MeshDraft {name = "Khrushchyovka"}; var corners = new Vector3[] { Vector3.left*length/2 + Vector3.back*width/2, Vector3.right*length/2 + Vector3.back*width/2, Vector3.right*length/2 + Vector3.forward*width/2, Vector3.left*length/2 + Vector3.forward*width/2 }; commonPanelConstructors[PanelType.Entrance] = panelConstructors[PanelType.Entrance].GetRandom(); commonPanelConstructors[PanelType.EntranceWall] = panelConstructors[PanelType.EntranceWall].GetRandom(); wallColor = RandomE.colorHSV.WithA(0); List<FloorPlan> facadePlan0 = FacadeGenerator(length, floorCount, hasAttic, true, true); draft.Add(Facade(corners[0], Vector3.right, facadePlan0)); List<FloorPlan> facadePlan1 = FacadeGenerator(width, floorCount, hasAttic); draft.Add(Facade(corners[1], Vector3.forward, facadePlan1)); List<FloorPlan> facadePlan2 = FacadeGenerator(length, floorCount, hasAttic, false, true); draft.Add(Facade(corners[2], Vector3.left, facadePlan2)); List<FloorPlan> facadePlan3 = FacadeGenerator(width, floorCount, hasAttic); draft.Add(Facade(corners[3], Vector3.back, facadePlan3)); draft.Add(Roof(corners[0], corners[1], corners[2], corners[3], Vector3.up*height)); var basement = MeshDraft.Quad(corners[0], corners[1], corners[2], corners[3]); basement.Paint(roofColor); draft.Add(basement); return draft; }
public BoidController(MeshFilter meshFilter) { template = MeshDraft.Tetrahedron(0.3f); // Avoid vertex count overflow swarmCount = Mathf.Min(65000/template.vertices.Count, swarmCount); // Optimization trick: in each frame we simulate only small percent of all boids simulationUpdate = Mathf.RoundToInt(swarmCount*simulationPercent); int vertexCount = swarmCount*template.vertices.Count; draft = new MeshDraft { name = "Boids", vertices = new List<Vector3>(vertexCount), triangles = new List<int>(vertexCount), normals = new List<Vector3>(vertexCount), uv = new List<Vector2>(vertexCount), colors = new List<Color>(vertexCount) }; for (var i = 0; i < swarmCount; i++) { boids.Add(new Boid()); draft.Add(template); } mesh = draft.ToMesh(); mesh.MarkDynamic(); meshFilter.mesh = mesh; }
private void Awake() { template = MeshE.TetrahedronDraft(0.3f); swarmCount = Mathf.Min(65000/template.vertices.Count, swarmCount); simulationUpdate = Mathf.RoundToInt(swarmCount*simulationPercent); var vertexCount = swarmCount*template.vertices.Count; draft = new MeshDraft { name = "Boids", vertices = new List<Vector3>(vertexCount), triangles = new List<int>(vertexCount), normals = new List<Vector3>(vertexCount), uv = new List<Vector2>(vertexCount), colors = new List<Color>(vertexCount) }; for (var i = 0; i < swarmCount; i++) { boids.Add(new Boid()); draft.Add(template); } mesh = draft.ToMesh(); mesh.MarkDynamic(); GetComponent<MeshFilter>().mesh = mesh; Generate(); StartCoroutine(Simulate()); }
public static MeshDraft Armrests0(float seatWidth, float seatDepth, Vector3 backCenter, float backHeight, float legWidth) { var draft = new MeshDraft(); float armrestHeight = RandomE.Range(backHeight/4, backHeight*3/4, 3); float armrestLength = seatDepth - legWidth; Vector3 corner = backCenter + Vector3.left*(seatWidth/2 - legWidth/2) + Vector3.back*legWidth/2; float offset = 0; if (RandomE.Chance(0.5f)) { offset = RandomE.Range(legWidth/2, legWidth, 2); } Vector3 v0 = corner + Vector3.back*(armrestLength - legWidth/2); Vector3 v1 = v0 + Vector3.up*(armrestHeight - legWidth/2); Vector3 v2 = corner + Vector3.up*armrestHeight; Vector3 v3 = v2 + Vector3.back*(armrestLength + offset); var armrest = ChairGenerator.BeamDraft(v0, v1, legWidth); armrest.Add(ChairGenerator.BeamDraft(v2, v3, legWidth)); draft.Add(armrest); armrest.Move(Vector3.right*(seatWidth - legWidth)); draft.Add(armrest); return draft; }
public static MeshDraft XStretchers(Vector3[] legCenters, float legWidth, float legHeight) { var draft = new MeshDraft(); legWidth = RandomE.Range(legWidth/2, legWidth*3/4, 2); draft.Add(ChairGenerator.BeamDraft(legCenters[0], legCenters[2], legWidth)); draft.Add(ChairGenerator.BeamDraft(legCenters[1], legCenters[3], legWidth)); draft.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight/2, 2)); return draft; }
public static MeshDraft Chair( float legWidth, float legHeight, float seatWidth, float seatDepth, float seatHeight, float backHeight, bool hasStretchers, bool hasArmrests, Color color) { Vector3 right = Vector3.right*(seatWidth - legWidth)/2; Vector3 forward = Vector3.forward*(seatDepth - legWidth)/2; var chair = new MeshDraft {name = "Chair"}; // Generate legs var legCenters = new Vector3[] { -right - forward, right - forward, right + forward, -right + forward }; chair.Add(Leg0(legCenters[0], legWidth, legHeight)); chair.Add(Leg0(legCenters[1], legWidth, legHeight)); chair.Add(Leg0(legCenters[2], legWidth, legHeight)); chair.Add(Leg0(legCenters[3], legWidth, legHeight)); // Generate stretchers if (hasStretchers) { var stretchersConstructor = stretchersConstructors.GetRandom(); chair.Add(stretchersConstructor(legCenters, legWidth, legHeight)); } // Generate seat chair.Add(Seat0(Vector3.up*legHeight, seatWidth, seatDepth, seatHeight)); // Generate chair back Vector3 backCenter = Vector3.up*(legHeight + seatHeight) + Vector3.forward*(seatDepth - legWidth)/2; var backConstructor = backConstructors.GetRandom(); chair.Add(backConstructor(backCenter, seatWidth, legWidth, backHeight)); // Generate armrests if (hasArmrests) { var armrestsConstructor = armrestsConstructors.GetRandom(); chair.Add(armrestsConstructor(seatWidth, seatDepth, backCenter, backHeight, legWidth)); } chair.Paint(color); return chair; }
public static MeshDraft HStretchers(Vector3[] legCenters, float legWidth, float legHeight) { var draft = new MeshDraft(); legWidth = RandomE.Range(legWidth/2, legWidth, 3); draft.Add(ChairGenerator.BeamDraft(legCenters[0], legCenters[3], legWidth)); draft.Add(ChairGenerator.BeamDraft(legCenters[1], legCenters[2], legWidth)); Vector3 leftCenter = (legCenters[3] + legCenters[0])/2; Vector3 rightCenter = (legCenters[2] + legCenters[1])/2; draft.Add(ChairGenerator.BeamDraft(leftCenter, rightCenter, legWidth)); draft.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight*3/4, 3)); return draft; }
public static MeshDraft BoxStretchers(Vector3[] legCenters, float legWidth, float legHeight) { var draft = new MeshDraft(); legWidth = RandomE.Range(legWidth/2, legWidth, 3); MeshDraft stretcher0 = ChairGenerator.BeamDraft(legCenters[0], legCenters[1], legWidth); stretcher0.Add(ChairGenerator.BeamDraft(legCenters[2], legCenters[3], legWidth)); stretcher0.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight*3/4, 3)); MeshDraft stretcher1 = ChairGenerator.BeamDraft(legCenters[0], legCenters[3], legWidth); stretcher1.Add(ChairGenerator.BeamDraft(legCenters[1], legCenters[2], legWidth)); stretcher1.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight*3/4, 3)); draft.Add(stretcher0); draft.Add(stretcher1); return draft; }
/// <inheritdoc /> public GameObject CreatePrimitive(PrimitiveDefinition definition, GameObject parent, bool addCollider) { var spawnedPrimitive = new GameObject(definition.Shape.ToString()); spawnedPrimitive.transform.SetParent(parent.transform, false); MWVector3 dims = definition.Dimensions; MeshDraft meshDraft; switch (definition.Shape) { case PrimitiveShape.Sphere: meshDraft = MeshDraft.Sphere( definition.Radius.GetValueOrDefault(0.5f), definition.USegments.GetValueOrDefault(36), definition.VSegments.GetValueOrDefault(36), true); break; case PrimitiveShape.Box: dims = dims ?? new MWVector3(1, 1, 1); meshDraft = MeshDraft.Hexahedron(dims.X, dims.Z, dims.Y, true); break; case PrimitiveShape.Capsule: dims = dims ?? new MWVector3(0, 1, 0); meshDraft = MeshDraft.Capsule( dims.LargestComponentValue(), definition.Radius.GetValueOrDefault(0.5f), definition.USegments.GetValueOrDefault(36), definition.VSegments.GetValueOrDefault(36)); // default capsule is Y-aligned; rotate if necessary if (dims.LargestComponentIndex() == 0) { meshDraft.Rotate(Quaternion.Euler(0, 0, 90)); } else if (dims.LargestComponentIndex() == 2) { meshDraft.Rotate(Quaternion.Euler(90, 0, 0)); } break; case PrimitiveShape.Cylinder: dims = dims ?? new MWVector3(0, 1, 0); meshDraft = MeshDraft.Cylinder( definition.Radius.GetValueOrDefault(0.5f), definition.USegments.GetValueOrDefault(36), dims.LargestComponentValue(), true); // default cylinder is Y-aligned; rotate if necessary if (dims.LargestComponentIndex() == 0) { meshDraft.Rotate(Quaternion.Euler(0, 0, 90)); } else if (dims.LargestComponentIndex() == 2) { meshDraft.Rotate(Quaternion.Euler(90, 0, 0)); } break; case PrimitiveShape.Plane: dims = dims ?? new MWVector3(1, 0, 1); meshDraft = MeshDraft.Plane( dims.X, dims.Z, definition.USegments.GetValueOrDefault(1), definition.VSegments.GetValueOrDefault(1), true); meshDraft.Move(new Vector3(-dims.X / 2, 0, -dims.Z / 2)); break; case PrimitiveShape.InnerSphere: meshDraft = MeshDraft.Sphere( definition.Radius.GetValueOrDefault(0.5f), definition.USegments.GetValueOrDefault(36), definition.VSegments.GetValueOrDefault(36), true); meshDraft.FlipFaces(); break; default: throw new Exception($"{definition.Shape.ToString()} is not a known primitive type."); } spawnedPrimitive.AddComponent <MeshFilter>().mesh = meshDraft.ToMesh(); var renderer = spawnedPrimitive.AddComponent <MeshRenderer>(); renderer.sharedMaterial = MREAPI.AppsAPI.DefaultMaterial; if (addCollider) { spawnedPrimitive.AddColliderToPrimitive(definition); } return(spawnedPrimitive); }
public static void Octahedron() { PrimitiveTemplate(octahedron, () => MeshDraft.Octahedron(1).ToMesh()); }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Tetrahedron(radius).ToMesh(); }
public static MeshDraft Balcony(Vector3 origin, Vector3 width, Vector3 height) { Vector3 right = width.normalized; Vector3 normal = Vector3.Cross(height, width).normalized; Vector3 balconyWidth = width; Vector3 balconyHeight = Vector3.up * BalconyHeight; Vector3 balconyDepth = normal * BalconyDepth; var draft = new MeshDraft(); var balconyOuter = MeshDraft.PartialBox(balconyWidth, balconyDepth, balconyHeight, Directions.All & ~Directions.Up & ~Directions.Back); balconyOuter.FlipFaces(); Vector3 balconyCenter = origin + width / 2 + balconyDepth / 2 + balconyHeight / 2; balconyOuter.Move(balconyCenter); balconyOuter.Paint(BuildingGenerator.wallColor); Vector3 innerWidthOffset = right * BalconyThickness; Vector3 innerWidth = balconyWidth - innerWidthOffset * 2; Vector3 innerHeightOffset = Vector3.up * BalconyThickness; Vector3 innerHeight = balconyHeight - innerHeightOffset; Vector3 innerDepthOffset = normal * BalconyThickness; Vector3 innerDepth = balconyDepth - innerDepthOffset; var balconyInner = MeshDraft.PartialBox(innerWidth, innerDepth, innerHeight, Directions.All & ~Directions.Up & ~Directions.Back); balconyInner.Move(balconyCenter - innerDepthOffset / 2 + innerHeightOffset / 2); Vector3 borderOrigin = origin + balconyWidth + balconyHeight; Vector3 borderInnerOrigin = borderOrigin - innerWidthOffset; var balconyBorder = Bracket(borderOrigin, -balconyWidth, balconyDepth, borderInnerOrigin, -innerWidth, innerDepth); draft.Add(balconyOuter); draft.Add(balconyInner); draft.Add(balconyBorder); Vector3 windowWidthOffset = right * WindowWidthOffset; Vector3 windowHeightOffset = Vector3.up * WindowHeightOffset; Vector3 windowWidth = right * (width.magnitude - WindowWidthOffset * 2); Vector3 windowHeight = Vector3.up * WindowHeight; Vector3 windowDepth = normal * WindowDepth; int rodCount = Mathf.FloorToInt(windowWidth.magnitude / WindowSegmentMinWidth); Vector3 doorWidth = right * windowWidth.magnitude / (rodCount + 1); Vector3 doorHeight = windowHeightOffset + windowHeight; List <Vector3> outerFrame = new List <Vector3> { origin + windowWidthOffset + innerHeightOffset, origin + windowWidthOffset + doorHeight, origin + windowWidthOffset + windowWidth + doorHeight, origin + windowWidthOffset + windowWidth + windowHeightOffset, origin + windowWidthOffset + doorWidth + windowHeightOffset, origin + windowWidthOffset + doorWidth + innerHeightOffset }; var panel = MeshDraft.TriangleStrip(new List <Vector3> { outerFrame[0], origin, outerFrame[1], origin + height, outerFrame[2], origin + width + height, outerFrame[3], origin + width, outerFrame[4], origin + width, outerFrame[5] }); draft.Add(panel); List <Vector3> innerFrame = new List <Vector3>(); foreach (Vector3 vertex in outerFrame) { innerFrame.Add(vertex - windowDepth); } var frame = MeshDraft.FlatBand(innerFrame, outerFrame); draft.Add(frame); draft.Paint(BuildingGenerator.wallColor); draft.Add(Windowpane(outerFrame[0] - windowDepth, doorWidth, doorHeight - innerHeightOffset)); draft.Add(Windowpane(outerFrame[4] - windowDepth, windowWidth - doorWidth, windowHeight)); return(draft); }
private void Start() { draft = MeshE.PlaneDraft(xSize, zSize, xSegments, zSegments); draft.Move(Vector3.left*xSize/2 + Vector3.back*zSize/2); Generate(); }
public void UpdateDraft(GameObject terrain, MeshDraft memberMesh) { terrain.GetComponent<ChunkCollider>().terrain_draft = memberMesh; }
public static void Sphere() { PrimitiveTemplate(sphere, () => MeshDraft.Sphere(1, 16, 16).ToMesh()); }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Icosahedron(Random.Range(1, 6)).ToMesh(); }
public static void Cylinder() { PrimitiveTemplate(cylinder, () => MeshDraft.Cylinder(1, 16, 1).ToMesh()); }
public static void Prism() { PrimitiveTemplate(prism, () => MeshDraft.Prism(1, 16, 1).ToMesh()); }
public static void Pyramid() { PrimitiveTemplate(pyramid, () => MeshDraft.Pyramid(1, 6, 1).ToMesh()); }
public static MeshDraft BalconyGlazed(Vector3 origin, Vector3 width, Vector3 height) { Vector3 balconyWidth = width; Vector3 balconyHeight = height.normalized*BalconyHeight; Vector3 balconyDepth = Vector3.Cross(height, width).normalized*BalconyDepth; var draft = new MeshDraft(); var balcony = MeshDraft.Hexahedron(balconyWidth, balconyDepth, balconyHeight, Directions.All & ~Directions.Up & ~Directions.Back); balcony.FlipFaces(); balcony.Move(origin + width/2 + balconyDepth/2 + balconyHeight/2); balcony.Paint(BuildingGenerator.wallColor); draft.Add(balcony); Vector3 roof0 = origin + height; Vector3 roof1 = roof0 + balconyWidth; Vector3 roof2 = roof1 + balconyDepth; Vector3 roof3 = roof0 + balconyDepth; var roof = MeshDraft.Quad(roof0, roof1, roof2, roof3); roof.Paint(BuildingGenerator.roofColor); draft.Add(roof); Vector3 glassHeight = height - balconyHeight; Vector3 glass0 = origin + balconyHeight; Vector3 glass1 = glass0 + balconyDepth; Vector3 glass2 = glass1 + balconyWidth; var glass = Windowpane(glass0, balconyDepth, glassHeight); glass.Add(Windowpane(glass1, balconyWidth, glassHeight)); glass.Add(Windowpane(glass2, -balconyDepth, glassHeight)); draft.Add(glass); return draft; }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Capsule(height, radius, segments, rings).ToMesh(); }
public void MorphFitDown(MeshDraft fromMesh, MeshDraft toMesh) { int length = toMesh.normals.Count; int row = (vert_x * 6); for (int i = 0; i < length; i += row) { fromMesh.vertices[i] = (new Vector3(fromMesh.vertices[i].x, toMesh.vertices[i + row - 1].y, fromMesh.vertices[i].z)); fromMesh.vertices[i + 1] = (new Vector3(fromMesh.vertices[i + 1].x, toMesh.vertices[i + row - 2].y, fromMesh.vertices[i + 1].z)); fromMesh.vertices[i + 3] = (new Vector3(fromMesh.vertices[i + 3].x, toMesh.vertices[i + row - 1].y, fromMesh.vertices[i + 3].z)); } }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Plane(xSize, zSize, xSegments, zSegments).ToMesh(); }
public static void Plane() { PrimitiveTemplate(plane, () => MeshDraft.Plane(10, 10, 10, 10).ToMesh()); }
private MeshDraft Chair() { var legWidth = Random.Range(legWidthLB, legWidthUB); var legHeight = Random.Range(legHeightLB, legHeightUB); var seatDimensions = RandomE.Range(seatLB, seatUB); var backHeight = Random.Range(backHeightLB, backHeightUB); var chair = new MeshDraft { name = "Chair" }; var right = Vector3.right * (seatDimensions.x - legWidth) / 2; var forward = Vector3.forward * (seatDimensions.z - legWidth) / 2; var legCenters = new Vector3[] { -right - forward, right - forward, right + forward, -right + forward }; chair.Add(Leg0(legCenters[0], legWidth, legHeight)); chair.Add(Leg0(legCenters[1], legWidth, legHeight)); chair.Add(Leg0(legCenters[2], legWidth, legHeight)); chair.Add(Leg0(legCenters[3], legWidth, legHeight)); if (RandomE.Chance(0.3f)) { var stretcherFunc = new Func <Vector3[], float, float, MeshDraft>[] { XStretchers, HStretchers, BoxStretchers }.Choice(); chair.Add(stretcherFunc(legCenters, legWidth, legHeight)); } chair.Add(Seat0(Vector3.up * legHeight, seatDimensions.x, seatDimensions.z, seatDimensions.y)); var backFunc = new Func <Vector3, float, float, float, MeshDraft>[] { Back0, Back1, RodBack }.Choice(); var backCenter = Vector3.up * (legHeight + seatDimensions.y) + Vector3.forward * (seatDimensions.z - legWidth) / 2; chair.Add(backFunc(backCenter, seatDimensions.x, legWidth, backHeight)); if (RandomE.Chance(0.3f)) { var armrestsFunc = new Func <Vector3, Vector3, float, float, MeshDraft>[] { Armrests0, Armrests1 }.Choice(); chair.Add(armrestsFunc(seatDimensions, backCenter, backHeight, legWidth)); } chair.Paint(RandomE.colorHSV); return(chair); }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Pyramid(radius, segments, height).ToMesh(); }
public void GetMesh(SocketIOEvent e) { GameObject[] receivedMeshes = GameObject.FindGameObjectsWithTag("ReceivedMesh"); List <JSONObject> meshDatas = e.data.GetField("meshes").list; for (int n = 0; n < meshDatas.Count; n++) //foreach (JSONObject meshData in e.data.GetField("meshes").list) { JSONObject meshData = meshDatas[n]; byte[] data = Convert.FromBase64String(meshData.str); var customMesh = ZeroFormatterSerializer.Deserialize <CustomMesh>(data); //print("verts: " + customMesh.vertices.Count); List <Vector3> vertices = new List <Vector3>(); if (vertices != null) { for (int i = 0; i < customMesh.vertices.Count; i++) { vertices.Add(new Vector3(customMesh.vertices[i][0], customMesh.vertices[i][1], customMesh.vertices[i][2])); } } List <int> triangles = new List <int>(); if (customMesh.faces != null) { for (int i = 0; i < customMesh.faces.Count; i++) { if (customMesh.faces[i][0] == 0) { triangles.Add(customMesh.faces[i][1]); triangles.Add(customMesh.faces[i][2]); triangles.Add(customMesh.faces[i][3]); } else if (customMesh.faces[i][0] == 1) { triangles.Add(customMesh.faces[i][1]); triangles.Add(customMesh.faces[i][2]); triangles.Add(customMesh.faces[i][3]); triangles.Add(customMesh.faces[i][1]); triangles.Add(customMesh.faces[i][3]); triangles.Add(customMesh.faces[i][4]); } } } List <Vector2> uvs = new List <Vector2>(); if (customMesh.uvs != null) { for (int i = 0; i < customMesh.uvs.Count; i++) { uvs.Add(new Vector2(customMesh.uvs[i][0], customMesh.uvs[i][1])); } } List <Vector3> normals = new List <Vector3>(); if (customMesh.normals != null) { for (int i = 0; i < customMesh.normals.Count; i++) { normals.Add(new Vector3(customMesh.normals[i][0], customMesh.normals[i][1], customMesh.normals[i][2])); } } MeshDraft meshDraft = new MeshDraft(); meshDraft.vertices = vertices; meshDraft.triangles = triangles; meshDraft.uv = uvs; meshDraft.normals = normals; if (n + 1 >= receivedMeshes.Length) { GameObject receivedMeshInstance = (GameObject)Instantiate(receivedMeshPrefab); receivedMeshInstance.GetComponent <MeshFilter>().mesh = meshDraft.ToMesh(); } else { receivedMeshes[n].GetComponent <MeshFilter>().mesh = meshDraft.ToMesh(); } } if (receivedMeshes.Length > meshDatas.Count) { for (int i = meshDatas.Count; i < receivedMeshes.Length; i++) { Destroy(receivedMeshes[i]); } Resources.UnloadUnusedAssets(); } }
public static void Dodecahedron() { PrimitiveTemplate(dodecahedron, () => MeshDraft.Dodecahedron(1).ToMesh()); }
public static MeshDraft[] TerrainDraft(Config config) { Assert.IsTrue(config.terrainSize.x > 0); Assert.IsTrue(config.terrainSize.z > 0); Assert.IsTrue(config.cellSize > 0); var noiseOffset = new Vector2(Random.Range(0f, 100f), Random.Range(0f, 100f)); var segOffset = new Vector2(0, 0); int xSegmentsTotal = Mathf.FloorToInt(config.terrainSize.x / config.cellSize); int zSegmentsTotal = Mathf.FloorToInt(config.terrainSize.z / config.cellSize); // need to make sure xSegTotal and zSegTotal are even because of division by 2 // if odd, there is space between terrain parts xSegmentsTotal -= xSegmentsTotal % 2; zSegmentsTotal -= zSegmentsTotal % 2; int xSegments = Mathf.FloorToInt(xSegmentsTotal / 2); int zSegments = Mathf.FloorToInt(zSegmentsTotal / 2); float xStep = config.terrainSize.x / xSegmentsTotal; float zStep = config.terrainSize.z / zSegmentsTotal; int vertexCount = 6 * xSegments * zSegments; List <Vector2> pathPoints = convertPathCoordinatesToSegments(config.path, new Vector3(xStep, zStep), config.offsets); MeshDraft[] drafts = new MeshDraft[4]; for (int d = 0; d < 4; d++) { var draft = new MeshDraft { name = "Terrain", vertices = new List <Vector3>(vertexCount), triangles = new List <int>(vertexCount), normals = new List <Vector3>(vertexCount), colors = new List <Color>(vertexCount) }; for (int i = 0; i < vertexCount; i++) { draft.vertices.Add(Vector3.zero); draft.triangles.Add(0); draft.normals.Add(Vector3.zero); draft.colors.Add(Color.black); } for (int x = 0; x < xSegments; x++) { for (int z = 0; z < zSegments; z++) { int index0 = 6 * (x + z * xSegments); int index1 = index0 + 1; int index2 = index0 + 2; int index3 = index0 + 3; int index4 = index0 + 4; int index5 = index0 + 5; float height00 = GetHeight(x + 0, z + 0, xSegments, zSegments, noiseOffset, config, segOffset); float height01 = GetHeight(x + 0, z + 1, xSegments, zSegments, noiseOffset, config, segOffset); float height10 = GetHeight(x + 1, z + 0, xSegments, zSegments, noiseOffset, config, segOffset); float height11 = GetHeight(x + 1, z + 1, xSegments, zSegments, noiseOffset, config, segOffset); var vertex00 = new Vector3((x + 0) * xStep, height00 * config.terrainSize.y, (z + 0) * zStep); var vertex01 = new Vector3((x + 0) * xStep, height01 * config.terrainSize.y, (z + 1) * zStep); var vertex10 = new Vector3((x + 1) * xStep, height10 * config.terrainSize.y, (z + 0) * zStep); var vertex11 = new Vector3((x + 1) * xStep, height11 * config.terrainSize.y, (z + 1) * zStep); draft.vertices[index0] = vertex00; draft.vertices[index1] = vertex01; draft.vertices[index2] = vertex11; draft.vertices[index3] = vertex00; draft.vertices[index4] = vertex11; draft.vertices[index5] = vertex10; draft.colors[index0] = config.gradient.Evaluate(height00); draft.colors[index1] = config.gradient.Evaluate(height01); draft.colors[index2] = config.gradient.Evaluate(height11); draft.colors[index3] = config.gradient.Evaluate(height00); draft.colors[index4] = config.gradient.Evaluate(height11); draft.colors[index5] = config.gradient.Evaluate(height10); Vector3 normal000111 = Vector3.Cross(vertex01 - vertex00, vertex11 - vertex00).normalized; Vector3 normal001011 = Vector3.Cross(vertex11 - vertex00, vertex10 - vertex00).normalized; draft.normals[index0] = normal000111; draft.normals[index1] = normal000111; draft.normals[index2] = normal000111; draft.normals[index3] = normal001011; draft.normals[index4] = normal001011; draft.normals[index5] = normal001011; draft.triangles[index0] = index0; draft.triangles[index1] = index1; draft.triangles[index2] = index2; draft.triangles[index3] = index3; draft.triangles[index4] = index4; draft.triangles[index5] = index5; } } drafts[d] = draft; // adjust noise offset for the 4 parts of the terrain to ensure continuity if (d % 2 == 0) { noiseOffset.x += config.noiseScale; segOffset.x = xSegments; } else if (d == 1) { noiseOffset.y += config.noiseScale; noiseOffset.x -= config.noiseScale; segOffset.x = 0; segOffset.y = xSegments; } } return(drafts); }
public static MeshDraft Chair(float legWidth, float legHeight, Vector3 seatDimensions, float backHeight, bool hasStretchers, bool hasArmrests) { Vector3 right = Vector3.right*(seatDimensions.x - legWidth)/2; Vector3 forward = Vector3.forward*(seatDimensions.z - legWidth)/2; var chair = new MeshDraft {name = "Chair"}; // Generate legs var legCenters = new Vector3[] { -right - forward, right - forward, right + forward, -right + forward }; chair.Add(Leg0(legCenters[0], legWidth, legHeight)); chair.Add(Leg0(legCenters[1], legWidth, legHeight)); chair.Add(Leg0(legCenters[2], legWidth, legHeight)); chair.Add(Leg0(legCenters[3], legWidth, legHeight)); // Generate stretchers if (hasStretchers) { var stretcherFunc = new Func<Vector3[], float, float, MeshDraft>[] { Stretchers.XStretchers, Stretchers.HStretchers, Stretchers.BoxStretchers }.GetRandom(); chair.Add(stretcherFunc(legCenters, legWidth, legHeight)); } chair.Add(Seat0(Vector3.up*legHeight, seatDimensions.x, seatDimensions.z, seatDimensions.y)); // Generate chair back var backFunc = new Func<Vector3, float, float, float, MeshDraft>[] { Backs.Back0, Backs.Back1, Backs.RodBack }.GetRandom(); Vector3 backCenter = Vector3.up*(legHeight + seatDimensions.y) + Vector3.forward*(seatDimensions.z - legWidth)/2; chair.Add(backFunc(backCenter, seatDimensions.x, legWidth, backHeight)); // Generate armrests if (hasArmrests) { var armrestsFunc = new Func<Vector3, Vector3, float, float, MeshDraft>[] { Armrests.Armrests0, Armrests.Armrests1 }.GetRandom(); chair.Add(armrestsFunc(seatDimensions, backCenter, backHeight, legWidth)); } chair.Paint(RandomE.colorHSV); return chair; }
public void Rebuild(int sleepMs = 0) { if (!needRebuild) { return; } var parentMap = gameObject.GetComponentInParent <TestMap>(); if (start.x < 0 || start.y < 0 || end.x < 0 || end.y < 0) { return; // will cause fatal error } mapData = DDA.GetTilesBetween(start, end); if (mapData == null) { return; } float tileSize = parentMap.tileSize; if (thread != null && thread.IsAlive) { return; } thread = new Thread(() => { Thread.Sleep(sleepMs); MeshDraft chunkMesh = new MeshDraft(); int gameObjectCount = 0; foreach (var tile in mapData.tiles) { //if (!tile.seen) continue; MeshDraft tileMesh = parentMap.GetCachedTerMesh(tile.ter); // probably will not work in non main thread if (tileMesh != null) { if (chunkMesh.vertexCount + tileMesh.vertexCount < 65000) { MeshDraft tileMeshCopy = tileMesh.Clone(); tileMeshCopy.Move(new Vector3((tile.loc.x - start.x) * tileSize, tile.loc.y * tileSize, (tile.loc.z - start.y) * tileSize)); chunkMesh.Add(tileMeshCopy); } else { AssignMesh(chunkMesh, "subchunk" + gameObjectCount.ToString("D2")); gameObjectCount++; chunkMesh = new MeshDraft(); } } } if (chunkMesh.vertexCount > 0 && gameObjectCount == 0) { AssignMesh(chunkMesh); } else if (chunkMesh.vertexCount > 0) { AssignMesh(chunkMesh, "subchunk" + gameObjectCount.ToString("D2")); } }); thread.Start(); }
public static void Cube() { PrimitiveTemplate(cube, () => MeshDraft.Cube(1).ToMesh()); }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Hexahedron(width, length, height).ToMesh(); }
public static void Tetrahedron() { PrimitiveTemplate(tetrahedron, () => MeshDraft.Tetrahedron(1).ToMesh()); }
private MeshDraft BoxStretchers(Vector3[] legCenters, float legWidth, float legHeight) { var draft = new MeshDraft(); legWidth = RandomE.Range(legWidth/2, legWidth, 3); var stretcher0 = BeamDraft(legCenters[0], legCenters[1], legWidth); stretcher0.Add(BeamDraft(legCenters[2], legCenters[3], legWidth)); stretcher0.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight*3/4, 3)); var stretcher1 = BeamDraft(legCenters[0], legCenters[3], legWidth); stretcher1.Add(BeamDraft(legCenters[1], legCenters[2], legWidth)); stretcher1.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight*3/4, 3)); draft.Add(stretcher0); draft.Add(stretcher1); return draft; }
public static MeshDraft Balcony(Vector3 origin, Vector3 width, Vector3 height) { Vector3 right = width.normalized; Vector3 normal = Vector3.Cross(height, width).normalized; Vector3 balconyWidth = width; Vector3 balconyHeight = Vector3.up*BalconyHeight; Vector3 balconyDepth = normal*BalconyDepth; var draft = new MeshDraft(); var balconyOuter = MeshDraft.Hexahedron(balconyWidth, balconyDepth, balconyHeight, Directions.All & ~Directions.Up & ~Directions.Back); balconyOuter.FlipFaces(); Vector3 balconyCenter = origin + width/2 + balconyDepth/2 + balconyHeight/2; balconyOuter.Move(balconyCenter); balconyOuter.Paint(BuildingGenerator.wallColor); Vector3 innerWidthOffset = right*BalconyThickness; Vector3 innerWidth = balconyWidth - innerWidthOffset*2; Vector3 innerHeightOffset = Vector3.up*BalconyThickness; Vector3 innerHeight = balconyHeight - innerHeightOffset; Vector3 innerDepthOffset = normal*BalconyThickness; Vector3 innerDepth = balconyDepth - innerDepthOffset; var balconyInner = MeshDraft.Hexahedron(innerWidth, innerDepth, innerHeight, Directions.All & ~Directions.Up & ~Directions.Back); balconyInner.Move(balconyCenter - innerDepthOffset/2 + innerHeightOffset/2); Vector3 borderOrigin = origin + balconyWidth + balconyHeight; Vector3 borderInnerOrigin = borderOrigin - innerWidthOffset; var balconyBorder = Bracket(borderOrigin, -balconyWidth, balconyDepth, borderInnerOrigin, -innerWidth, innerDepth); draft.Add(balconyOuter); draft.Add(balconyInner); draft.Add(balconyBorder); Vector3 windowWidthOffset = right*WindowWidthOffset; Vector3 windowHeightOffset = Vector3.up*WindowHeightOffset; Vector3 windowWidth = right*(width.magnitude - WindowWidthOffset*2); Vector3 windowHeight = Vector3.up*WindowHeight; Vector3 windowDepth = normal*WindowDepth; int rodCount = Mathf.FloorToInt(windowWidth.magnitude/WindowSegmentMinWidth); Vector3 doorWidth = right*windowWidth.magnitude/(rodCount + 1); Vector3 doorHeight = windowHeightOffset + windowHeight; List<Vector3> outerFrame = new List<Vector3> { origin + windowWidthOffset + innerHeightOffset, origin + windowWidthOffset + doorHeight, origin + windowWidthOffset + windowWidth + doorHeight, origin + windowWidthOffset + windowWidth + windowHeightOffset, origin + windowWidthOffset + doorWidth + windowHeightOffset, origin + windowWidthOffset + doorWidth + innerHeightOffset }; var panel = MeshDraft.TriangleStrip(new List<Vector3> { outerFrame[0], origin, outerFrame[1], origin + height, outerFrame[2], origin + width + height, outerFrame[3], origin + width, outerFrame[4], origin + width, outerFrame[5] }); draft.Add(panel); List<Vector3> innerFrame = new List<Vector3>(); foreach (Vector3 vertex in outerFrame) { innerFrame.Add(vertex - windowDepth); } var frame = MeshDraft.FlatBand(innerFrame, outerFrame); draft.Add(frame); draft.Paint(BuildingGenerator.wallColor); draft.Add(Windowpane(outerFrame[0] - windowDepth, doorWidth, doorHeight - innerHeightOffset)); draft.Add(Windowpane(outerFrame[4] - windowDepth, windowWidth - doorWidth, windowHeight)); return draft; }
private MeshDraft HStretchers(Vector3[] legCenters, float legWidth, float legHeight) { var draft = new MeshDraft(); legWidth = RandomE.Range(legWidth/2, legWidth, 3); draft.Add(BeamDraft(legCenters[0], legCenters[3], legWidth)); draft.Add(BeamDraft(legCenters[1], legCenters[2], legWidth)); var leftCenter = (legCenters[3] + legCenters[0])/2; var rightCenter = (legCenters[2] + legCenters[1])/2; draft.Add(BeamDraft(leftCenter, rightCenter, legWidth)); draft.Move(Vector3.up*RandomE.Range(legHeight/4, legHeight*3/4, 3)); return draft; }
private static MeshDraft Windowpane(Vector3 origin, Vector3 width, Vector3 heigth) { Vector3 right = width.normalized; Vector3 normal = Vector3.Cross(width, heigth).normalized; var draft = new MeshDraft(); int rodCount = Mathf.FloorToInt(width.magnitude/WindowSegmentMinWidth); float interval = width.magnitude/(rodCount + 1); Vector3 frameWidth = right*WindowFrameWidth/2; Vector3 frameHeight = Vector3.up*WindowFrameWidth/2; Vector3 frameLength = normal*WindowFrameWidth/2; Vector3 startPosition = origin + heigth/2 + frameLength/2; for (int i = 0; i < rodCount; i++) { var frame = MeshDraft.Hexahedron(frameWidth*2, frameLength, heigth - frameHeight*2, Directions.Left | Directions.Back | Directions.Right); frame.Move(startPosition + right*(i + 1)*interval); draft.Add(frame); } Vector3 windowCorner = origin + frameWidth + frameHeight; Vector3 windowWidth = width - frameWidth*2; Vector3 windowHeigth = heigth - frameHeight*2; var window = PerforatedQuad(origin, width, heigth, windowCorner, windowWidth, windowHeigth); draft.Add(window); var hole = MeshDraft.Hexahedron(windowWidth, frameLength, windowHeigth, Directions.All & ~Directions.ZAxis); hole.Move(startPosition + width/2); hole.FlipFaces(); draft.Add(hole); draft.Paint(BuildingGenerator.frameColor); var glass = MeshDraft.Quad(windowCorner + frameLength, windowWidth, windowHeigth); glass.Paint(BuildingGenerator.glassColor); draft.Add(glass); return draft; }
public static void Build(RockThreadReturnData returnData) { RockData data = returnData.RockData; MeshDraft MD; switch (data.RockBasePrimitiveShape) { case RockData.BasePrimitiveShapes.Dodecahedron: MD = MeshDraft.Dodecahedron(0.5f); break; case RockData.BasePrimitiveShapes.Icosahedron: MD = MeshDraft.Icosahedron(0.5f, false); break; case RockData.BasePrimitiveShapes.Prism: MD = MeshDraft.Prism(0.5f, data.Segments, 1f, false); break; case RockData.BasePrimitiveShapes.Pyramid: MD = MeshDraft.Pyramid(0.5f, data.Segments, 1f, false); break; default: MD = MeshDraft.Sphere(0.5f, data.Segments, data.Segments, false); break; } ; MeshObjectData rock = new MeshObjectData(); rock.vertices = MD.vertices.ToArray(); rock.triangles = MD.triangles.ToArray(); rock.tangents = MD.tangents.ToArray(); rock.AutoWeldMesh(0.0001f, 0.4f); Vector3[] verts = rock.vertices; INoise noise = new SimplexNoise(data.RockSeed, 0.3f, 0.2f); Rand r = new Rand(data.RockSeed); for (int i = 0; i < verts.Length; i++) { float currentNoise = NoiseGen(noise, 3, verts[i].x / 0.5f, verts[i].y / 0.5f, verts[i].z / 0.5f); //currentNoise*=2; Vector3 norm = verts[i].normalized; verts[i].x += currentNoise * norm.x; verts[i].y += currentNoise * norm.y; verts[i].z += currentNoise * norm.z; verts[i].x *= 3; verts[i].y *= 1.2f; verts[i].z *= 1.5f; } rock.vertices = verts; rock.flatShade(); Color[] vertexColor = new Color[rock.vertices.Length]; for (int i = 0; i < rock.vertices.Length; i++) { vertexColor[i] = data.RockGradientColor.Color.Evaluate(1 - rock.vertices[i].y); } rock.colors = vertexColor; returnData.RockBuildData = rock; returnData.ManagerCallBack(returnData); }
public void MorphFitRight(MeshDraft fromMesh, MeshDraft toMesh) { int length = toMesh.normals.Count; int limit = vert_x * 6; for (int i = 0; i < limit; i += 6) { int offset = (length - vert_x * 6); fromMesh.vertices[i] = (new Vector3(fromMesh.vertices[i].x, toMesh.vertices[offset + i + 1].y, fromMesh.vertices[i].z)); fromMesh.vertices[i + 3] = (new Vector3(fromMesh.vertices[i + 3].x, toMesh.vertices[offset + i + 1].y, fromMesh.vertices[i + 3].z)); fromMesh.vertices[i + 5] = (new Vector3(fromMesh.vertices[i + 5].x, toMesh.vertices[offset + i + 2].y, fromMesh.vertices[i + 5].z)); } }
public static MeshDraft TerrainDraft(Config config) { Assert.IsTrue(config.terrainSize.x > 0); Assert.IsTrue(config.terrainSize.z > 0); Assert.IsTrue(config.cellSize > 0); var noiseOffset = new Vector2(Random.Range(0f, 100f), Random.Range(0f, 100f)); int xSegments = Mathf.FloorToInt(config.terrainSize.x / config.cellSize); int zSegments = Mathf.FloorToInt(config.terrainSize.z / config.cellSize); float xStep = config.terrainSize.x / xSegments; float zStep = config.terrainSize.z / zSegments; int vertexCount = 6 * xSegments * zSegments; var draft = new MeshDraft { name = "Terrain", vertices = new List <Vector3>(vertexCount), triangles = new List <int>(vertexCount), normals = new List <Vector3>(vertexCount), colors = new List <Color>(vertexCount) }; for (int i = 0; i < vertexCount; i++) { draft.vertices.Add(Vector3.zero); draft.triangles.Add(0); draft.normals.Add(Vector3.zero); draft.colors.Add(Color.black); } for (int x = 0; x < xSegments; x++) { for (int z = 0; z < zSegments; z++) { int index0 = 6 * (x + z * xSegments); int index1 = index0 + 1; int index2 = index0 + 2; int index3 = index0 + 3; int index4 = index0 + 4; int index5 = index0 + 5; float height00 = GetHeight(x + 0, z + 0, xSegments, zSegments, noiseOffset, config.noiseScale); float height01 = GetHeight(x + 0, z + 1, xSegments, zSegments, noiseOffset, config.noiseScale); float height10 = GetHeight(x + 1, z + 0, xSegments, zSegments, noiseOffset, config.noiseScale); float height11 = GetHeight(x + 1, z + 1, xSegments, zSegments, noiseOffset, config.noiseScale); var vertex00 = new Vector3((x + 0) * xStep, height00 * config.terrainSize.y, (z + 0) * zStep); var vertex01 = new Vector3((x + 0) * xStep, height01 * config.terrainSize.y, (z + 1) * zStep); var vertex10 = new Vector3((x + 1) * xStep, height10 * config.terrainSize.y, (z + 0) * zStep); var vertex11 = new Vector3((x + 1) * xStep, height11 * config.terrainSize.y, (z + 1) * zStep); draft.vertices[index0] = vertex00; draft.vertices[index1] = vertex01; draft.vertices[index2] = vertex11; draft.vertices[index3] = vertex00; draft.vertices[index4] = vertex11; draft.vertices[index5] = vertex10; draft.colors[index0] = config.gradient.Evaluate(height00); draft.colors[index1] = config.gradient.Evaluate(height01); draft.colors[index2] = config.gradient.Evaluate(height11); draft.colors[index3] = config.gradient.Evaluate(height00); draft.colors[index4] = config.gradient.Evaluate(height11); draft.colors[index5] = config.gradient.Evaluate(height10); Vector3 normal000111 = Vector3.Cross(vertex01 - vertex00, vertex11 - vertex00).normalized; Vector3 normal001011 = Vector3.Cross(vertex11 - vertex00, vertex10 - vertex00).normalized; draft.normals[index0] = normal000111; draft.normals[index1] = normal000111; draft.normals[index2] = normal000111; draft.normals[index3] = normal001011; draft.normals[index4] = normal001011; draft.normals[index5] = normal001011; draft.triangles[index0] = index0; draft.triangles[index1] = index1; draft.triangles[index2] = index2; draft.triangles[index3] = index3; draft.triangles[index4] = index4; draft.triangles[index5] = index5; } } return(draft); }
private void Start() { GetComponent <MeshFilter>().mesh = MeshDraft.Spheroid(radius, height, horizontalSegments, verticalSegments).ToMesh(); }
public static void Icosahedron() { PrimitiveTemplate(icosahedron, () => MeshDraft.Icosahedron(1).ToMesh()); }
private MeshDraft Chair() { var legWidth = Random.Range(legWidthLB, legWidthUB); var legHeight = Random.Range(legHeightLB, legHeightUB); var seatDimensions = RandomE.Range(seatLB, seatUB); var backHeight = Random.Range(backHeightLB, backHeightUB); var chair = new MeshDraft {name = "Chair"}; var right = Vector3.right*(seatDimensions.x - legWidth)/2; var forward = Vector3.forward*(seatDimensions.z - legWidth)/2; var legCenters = new Vector3[] { -right - forward, right - forward, right + forward, -right + forward }; chair.Add(Leg0(legCenters[0], legWidth, legHeight)); chair.Add(Leg0(legCenters[1], legWidth, legHeight)); chair.Add(Leg0(legCenters[2], legWidth, legHeight)); chair.Add(Leg0(legCenters[3], legWidth, legHeight)); if (RandomE.Chance(0.3f)) { var stretcherFunc = new Func<Vector3[], float, float, MeshDraft>[] { XStretchers, HStretchers, BoxStretchers }.GetRandom(); chair.Add(stretcherFunc(legCenters, legWidth, legHeight)); } chair.Add(Seat0(Vector3.up*legHeight, seatDimensions.x, seatDimensions.z, seatDimensions.y)); var backFunc = new Func<Vector3, float, float, float, MeshDraft>[] { Back0, Back1, RodBack }.GetRandom(); var backCenter = Vector3.up*(legHeight + seatDimensions.y) + Vector3.forward*(seatDimensions.z - legWidth)/2; chair.Add(backFunc(backCenter, seatDimensions.x, legWidth, backHeight)); if (RandomE.Chance(0.3f)) { var armrestsFunc = new Func<Vector3, Vector3, float, float, MeshDraft>[] { Armrests0, Armrests1 }.GetRandom(); chair.Add(armrestsFunc(seatDimensions, backCenter, backHeight, legWidth)); } chair.Paint(RandomE.colorHSV); return chair; }
/// <summary> /// Generate new colors and positions for boids /// </summary> public Mesh Generate() { template = MeshDraft.Tetrahedron(0.3f); // Avoid vertex count overflow swarmCount = Mathf.Min(65000/template.vertices.Count, swarmCount); // Optimization trick: in each frame we simulate only small percent of all boids maxSimulationSteps = Mathf.RoundToInt(swarmCount*simulationPercent); int vertexCount = swarmCount*template.vertices.Count; // Paint template in random color template.colors.Clear(); var color = RandomE.colorHSV; // Assuming that we are dealing with tetrahedron, first vertex should be boid's "nose" template.colors.Add(color.Inverted()); for (int i = 1; i < template.vertices.Count; i++) { template.colors.Add(color); } draft = new MeshDraft { name = "Boids", vertices = new List<Vector3>(vertexCount), triangles = new List<int>(vertexCount), normals = new List<Vector3>(vertexCount), uv = new List<Vector2>(vertexCount), colors = new List<Color>(vertexCount) }; for (var i = 0; i < swarmCount; i++) { // Assign random starting values for each boid var boid = new Boid { position = Random.insideUnitSphere*spawnSphere, rotation = Random.rotation, velocity = Random.onUnitSphere*maxSpeed }; boids.Add(boid); draft.Add(template); } mesh = draft.ToMesh(); mesh.MarkDynamic(); return mesh; }
private void Start() { draft = MeshE.PlaneDraft(xSize, zSize, xSegments, zSegments); draft.Move(Vector3.left * xSize / 2 + Vector3.back * zSize / 2); Generate(); }
private static MeshDraft SplitToRects(VOX.Model model, bool[,] matrix, ColorPlanePos pos, ColorPlane plane, int count, float halfTexelShift) { MeshDraft mesh = new MeshDraft(); int matIdX = plane.matID % 16; int matIdY = plane.matID / 16; Vector2 uvStart = new Vector2(matIdX / 16.0f, matIdY / 16.0f); int[,] h, w; h = new int[plane.sizeX, plane.sizeY]; w = new int[plane.sizeX, plane.sizeY]; while (count > 0) { int minw = 0, area = 0; int maxArea = 0; int[] maxFace = new int[4] { 0, 0, 0, 0 }; for (int j = 0; j < plane.sizeX; j++) { for (int i = 0; i < plane.sizeY; i++) { if (!matrix[j, i]) { continue; } if (j == 0) { h[j, i] = 1; } else { h[j, i] = h[j - 1, i] + 1; } if (i == 0) { w[j, i] = 1; } else { w[j, i] = w[j, i - 1] + 1; } minw = w[j, i]; for (int dh = 0; dh < h[j, i]; dh++) { if (w[j - dh, i] < minw) { minw = w[j - dh, i]; } area = (dh + 1) * minw; if (area > maxArea) { maxArea = area; maxFace[0] = i - minw + 1; maxFace[1] = j - dh; maxFace[2] = i; maxFace[3] = j; } } } } int vi = mesh.vertices.Count; bool order = true; float x1 = maxFace[1]; float y1 = maxFace[0]; float x2 = maxFace[3] + 1; float y2 = maxFace[2] + 1; if (pos.normal.y == -1) { mesh.vertices.Add(new Vector3(maxFace[1], pos.pos + 1, maxFace[0])); mesh.vertices.Add(new Vector3(maxFace[3] + 1, pos.pos + 1, maxFace[0])); mesh.vertices.Add(new Vector3(maxFace[3] + 1, pos.pos + 1, maxFace[2] + 1)); mesh.vertices.Add(new Vector3(maxFace[1], pos.pos + 1, maxFace[2] + 1)); x1 *= 1.0f / model.sizeX / 16.0f; y1 *= 1.0f / model.sizeZ / 16.0f; x2 *= 1.0f / model.sizeX / 16.0f; y2 *= 1.0f / model.sizeZ / 16.0f; } else if (pos.normal.y == 1) { mesh.vertices.Add(new Vector3(maxFace[1], pos.pos, maxFace[0])); mesh.vertices.Add(new Vector3(maxFace[3] + 1, pos.pos, maxFace[0])); mesh.vertices.Add(new Vector3(maxFace[3] + 1, pos.pos, maxFace[2] + 1)); mesh.vertices.Add(new Vector3(maxFace[1], pos.pos, maxFace[2] + 1)); order = false; x1 *= 1.0f / model.sizeX / 16.0f; y1 *= 1.0f / model.sizeZ / 16.0f; x2 *= 1.0f / model.sizeX / 16.0f; y2 *= 1.0f / model.sizeZ / 16.0f; } else if (pos.normal.z == -1) { mesh.vertices.Add(new Vector3(maxFace[1], maxFace[0], pos.pos)); mesh.vertices.Add(new Vector3(maxFace[3] + 1, maxFace[0], pos.pos)); mesh.vertices.Add(new Vector3(maxFace[3] + 1, maxFace[2] + 1, pos.pos)); mesh.vertices.Add(new Vector3(maxFace[1], maxFace[2] + 1, pos.pos)); x1 *= 1.0f / model.sizeX / 16.0f; y1 *= 1.0f / model.sizeY / 16.0f; x2 *= 1.0f / model.sizeX / 16.0f; y2 *= 1.0f / model.sizeY / 16.0f; } else if (pos.normal.z == 1) { mesh.vertices.Add(new Vector3(maxFace[1], maxFace[0], pos.pos + 1)); mesh.vertices.Add(new Vector3(maxFace[3] + 1, maxFace[0], pos.pos + 1)); mesh.vertices.Add(new Vector3(maxFace[3] + 1, maxFace[2] + 1, pos.pos + 1)); mesh.vertices.Add(new Vector3(maxFace[1], maxFace[2] + 1, pos.pos + 1)); order = false; x1 *= 1.0f / model.sizeX / 16.0f; y1 *= 1.0f / model.sizeY / 16.0f; x2 *= 1.0f / model.sizeX / 16.0f; y2 *= 1.0f / model.sizeY / 16.0f; } else if (pos.normal.x == -1) { mesh.vertices.Add(new Vector3(pos.pos, maxFace[0], maxFace[1])); mesh.vertices.Add(new Vector3(pos.pos, maxFace[0], maxFace[3] + 1)); mesh.vertices.Add(new Vector3(pos.pos, maxFace[2] + 1, maxFace[3] + 1)); mesh.vertices.Add(new Vector3(pos.pos, maxFace[2] + 1, maxFace[1])); order = false; x1 *= 1.0f / model.sizeY / 16.0f; y1 *= 1.0f / model.sizeY / 16.0f; x2 *= 1.0f / model.sizeY / 16.0f; y2 *= 1.0f / model.sizeY / 16.0f; } else if (pos.normal.x == 1) { mesh.vertices.Add(new Vector3(pos.pos + 1, maxFace[0], maxFace[1])); mesh.vertices.Add(new Vector3(pos.pos + 1, maxFace[0], maxFace[3] + 1)); mesh.vertices.Add(new Vector3(pos.pos + 1, maxFace[2] + 1, maxFace[3] + 1)); mesh.vertices.Add(new Vector3(pos.pos + 1, maxFace[2] + 1, maxFace[1])); x1 *= 1.0f / model.sizeY / 16.0f; y1 *= 1.0f / model.sizeY / 16.0f; x2 *= 1.0f / model.sizeY / 16.0f; y2 *= 1.0f / model.sizeY / 16.0f; } x1 += uvStart.x + halfTexelShift; y1 += uvStart.y + halfTexelShift; x2 += uvStart.x - halfTexelShift; y2 += uvStart.y - halfTexelShift; mesh.uv.Add(new Vector2(x1, y1)); mesh.uv.Add(new Vector2(x2, y1)); mesh.uv.Add(new Vector2(x2, y2)); mesh.uv.Add(new Vector2(x1, y2)); if (order) { mesh.triangles.Add(vi); mesh.triangles.Add(vi + 2); mesh.triangles.Add(vi + 1); mesh.triangles.Add(vi + 2); mesh.triangles.Add(vi); mesh.triangles.Add(vi + 3); } else { mesh.triangles.Add(vi); mesh.triangles.Add(vi + 1); mesh.triangles.Add(vi + 2); mesh.triangles.Add(vi + 2); mesh.triangles.Add(vi + 3); mesh.triangles.Add(vi); } for (int j = maxFace[1]; j <= maxFace[3]; j++) { for (int i = maxFace[0]; i <= maxFace[2]; i++) { matrix[j, i] = false; count--; } } for (int j = 0; j < plane.sizeX; j++) { for (int i = 0; i < plane.sizeY; i++) { w[j, i] = 0; h[j, i] = 0; } } } return(mesh); }
protected static MeshDraft Balcony( Vector3 origin, float width, float height, Color wallColor, Color frameColor, Color glassColor) { Vector3 widthVector = Vector3.right * width; Vector3 heightVector = Vector3.up * height; var draft = Balcony(origin, width, wallColor); Vector3 innerHeightOffset = Vector3.up * BalconyThickness; Vector3 windowHeightOffset = Vector3.up * WindowBottomOffset; Vector3 windowWidth = Vector3.right * (width - WindowWidthOffset * 2); Vector3 windowHeight = Vector3.up * (height - WindowBottomOffset - WindowTopOffset); Vector3 windowDepth = Vector3.forward * WindowDepth; int rodCount = Mathf.FloorToInt(windowWidth.magnitude / WindowSegmentMinWidth); Vector3 doorWidth = Vector3.right * windowWidth.magnitude / (rodCount + 1); Vector3 doorHeight = windowHeightOffset + windowHeight; Vector3 outerFrameOrigin = origin + Vector3.right * WindowWidthOffset; List <Vector3> outerFrame = new List <Vector3> { outerFrameOrigin + innerHeightOffset, outerFrameOrigin + doorHeight, outerFrameOrigin + windowWidth + doorHeight, outerFrameOrigin + windowWidth + windowHeightOffset, outerFrameOrigin + doorWidth + windowHeightOffset, outerFrameOrigin + doorWidth + innerHeightOffset }; var panel = new MeshDraft().AddTriangleStrip(new List <Vector3> { outerFrame[0], origin, outerFrame[1], origin + heightVector, outerFrame[2], origin + widthVector + heightVector, outerFrame[3], origin + widthVector, outerFrame[4], origin + widthVector, outerFrame[5] }).Paint(wallColor); draft.Add(panel); List <Vector3> innerFrame = new List <Vector3>(); foreach (Vector3 vertex in outerFrame) { innerFrame.Add(vertex - windowDepth); } var frame = MeshDraft.FlatBand(innerFrame, outerFrame); frame.Paint(wallColor); draft.Add(frame); Vector3 windowpaneMin1 = outerFrame[0] - windowDepth; Vector3 windowpaneMin2 = outerFrame[4] - windowDepth; draft.Add(Windowpane(windowpaneMin1, windowpaneMin1 + doorWidth + doorHeight - innerHeightOffset, frameColor, glassColor)); draft.Add(Windowpane(windowpaneMin2, windowpaneMin2 + windowWidth - doorWidth + windowHeight, frameColor, glassColor)); return(draft); }
public static void Dome() { PrimitiveTemplate(dome, () => MeshDraft.Dome(0.5f, 16, 16, true, 240).ToMesh()); }
// private IEnumerator BeepBoop() // { // // wait 1 seconds and continue // yield return new WaitForSeconds(1); // socket.Emit("beep"); // // wait 3 seconds and continue // yield return new WaitForSeconds(3); // socket.Emit("beep"); // // wait 2 seconds and continue // yield return new WaitForSeconds(2); // socket.Emit("beep"); // // wait ONE FRAME and continue // yield return null; // socket.Emit("beep"); // socket.Emit("beep"); // } // public void TestOpen(SocketIOEvent e) // { // Debug.Log("[SocketIO] Open received: " + e.name + " " + e.data); // } // public void TestBoop(SocketIOEvent e) // { // Debug.Log("[SocketIO] Boop received: " + e.name + " " + e.data); // if (e.data == null) { return; } // Debug.Log( // "#####################################################" + // "THIS: " + e.data.GetField("this").str + // "#####################################################" // ); // } // public void TestError(SocketIOEvent e) // { // Debug.Log("[SocketIO] Error received: " + e.name + " " + e.data); // } // public void TestClose(SocketIOEvent e) // { // Debug.Log("[SocketIO] Close received: " + e.name + " " + e.data); // } public void GetMesh(SocketIOEvent e) { print("data received"); //print(e.data.GetField("mesh")); byte[] data = Convert.FromBase64String(e.data.GetField("mesh").str); //print(data.Length); var customMesh = ZeroFormatterSerializer.Deserialize <CustomMesh>(data); // print(customMesh.GetType()); print("verts: " + customMesh.vertices.Count); List <Vector3> vertices = new List <Vector3> (); if (vertices != null) { for (int i = 0; i < customMesh.vertices.Count; i++) { //CustomVector3d cv = customMesh.vertices [i]; vertices.Add(new Vector3(customMesh.vertices[i][0], customMesh.vertices[i][1], customMesh.vertices[i][2])); } } List <int> triangles = new List <int> (); if (customMesh.faces != null) { for (int i = 0; i < customMesh.faces.Count; i++) { if (customMesh.faces[i][0] == 0) { triangles.Add(customMesh.faces[i][1]); triangles.Add(customMesh.faces[i][2]); triangles.Add(customMesh.faces[i][3]); } else if (customMesh.faces[i][0] == 1) { triangles.Add(customMesh.faces[i][1]); triangles.Add(customMesh.faces[i][2]); triangles.Add(customMesh.faces[i][3]); triangles.Add(customMesh.faces[i][1]); triangles.Add(customMesh.faces[i][3]); triangles.Add(customMesh.faces[i][4]); } } } List <Vector2> uvs = new List <Vector2>(); if (customMesh.uvs != null) { for (int i = 0; i < customMesh.uvs.Count; i++) { uvs.Add(new Vector2(customMesh.uvs[i][0], customMesh.uvs[i][1])); } } List <Vector3> normals = new List <Vector3>(); if (customMesh.normals != null) { for (int i = 0; i < customMesh.normals.Count; i++) { normals.Add(new Vector3(customMesh.normals[i][0], customMesh.normals[i][1], customMesh.normals[i][2])); } } MeshDraft meshDraft = new MeshDraft(); meshDraft.vertices = vertices; meshDraft.triangles = triangles; meshDraft.uv = uvs; meshDraft.normals = normals; GetComponent <MeshFilter>().mesh = meshDraft.ToMesh(); //CustomMesh customMesh = new CustomMesh(); // print(customMesh.ToString()); //var d = ZeroFormatterSerializer.Serialize(customMesh); //var dd = ZeroFormatterSerializer.Deserialize<CustomMesh>(d); }
public static MeshDraft TerrainDraft(Vector3 terrainSize, float cellSize, float noiseScale, Gradient gradient) { var noiseOffset = new Vector2(Random.Range(0f, 100f), Random.Range(0f, 100f)); int xSegments = Mathf.FloorToInt(terrainSize.x/cellSize); int zSegments = Mathf.FloorToInt(terrainSize.z/cellSize); float xStep = terrainSize.x/xSegments; float zStep = terrainSize.z/zSegments; int vertexCount = 6*xSegments*zSegments; var draft = new MeshDraft { name = "Terrain", vertices = new List<Vector3>(vertexCount), triangles = new List<int>(vertexCount), normals = new List<Vector3>(vertexCount), colors = new List<Color>(vertexCount) }; for (int i = 0; i < vertexCount; i++) { draft.vertices.Add(Vector3.zero); draft.triangles.Add(0); draft.normals.Add(Vector3.zero); draft.colors.Add(Color.black); } for (int x = 0; x < xSegments; x++) { for (int z = 0; z < zSegments; z++) { int index0 = 6*(x + z*xSegments); int index1 = index0 + 1; int index2 = index0 + 2; int index3 = index0 + 3; int index4 = index0 + 4; int index5 = index0 + 5; float height00 = GetHeight(x + 0, z + 0, xSegments, zSegments, noiseOffset, noiseScale); float height01 = GetHeight(x + 0, z + 1, xSegments, zSegments, noiseOffset, noiseScale); float height10 = GetHeight(x + 1, z + 0, xSegments, zSegments, noiseOffset, noiseScale); float height11 = GetHeight(x + 1, z + 1, xSegments, zSegments, noiseOffset, noiseScale); var vertex00 = new Vector3((x + 0)*xStep, height00*terrainSize.y, (z + 0)*zStep); var vertex01 = new Vector3((x + 0)*xStep, height01*terrainSize.y, (z + 1)*zStep); var vertex10 = new Vector3((x + 1)*xStep, height10*terrainSize.y, (z + 0)*zStep); var vertex11 = new Vector3((x + 1)*xStep, height11*terrainSize.y, (z + 1)*zStep); draft.vertices[index0] = vertex00; draft.vertices[index1] = vertex01; draft.vertices[index2] = vertex11; draft.vertices[index3] = vertex00; draft.vertices[index4] = vertex11; draft.vertices[index5] = vertex10; draft.colors[index0] = gradient.Evaluate(height00); draft.colors[index1] = gradient.Evaluate(height01); draft.colors[index2] = gradient.Evaluate(height11); draft.colors[index3] = gradient.Evaluate(height00); draft.colors[index4] = gradient.Evaluate(height11); draft.colors[index5] = gradient.Evaluate(height10); Vector3 normal000111 = Vector3.Cross(vertex01 - vertex00, vertex11 - vertex00).normalized; Vector3 normal001011 = Vector3.Cross(vertex11 - vertex00, vertex10 - vertex00).normalized; draft.normals[index0] = normal000111; draft.normals[index1] = normal000111; draft.normals[index2] = normal000111; draft.normals[index3] = normal001011; draft.normals[index4] = normal001011; draft.normals[index5] = normal001011; draft.triangles[index0] = index0; draft.triangles[index1] = index1; draft.triangles[index2] = index2; draft.triangles[index3] = index3; draft.triangles[index4] = index4; draft.triangles[index5] = index5; } } return draft; }