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;
}
