private void Generate()
{
var draft = ChairGenerator.Chair(legWidth, legHeight, RandomE.Range(seatLB, seatUB), backHeight,
hasStretchers, hasArmrests);
meshFilter.mesh = draft.ToMesh();
}
public void Generate()
{
character.characterName.text = nameGenerator.fullName;
character.hairRenderer.sprite = hairSprites.GetRandom();
character.bodyRenderer.sprite = bodySprites.GetRandom();
character.headRenderer.sprite = headSprites.GetRandom();
character.chestRenderer.sprite = chestSprites.GetRandom();
character.legsRenderer.sprite = legsSprites.GetRandom();
character.feetRenderer.sprite = feetSprites.GetRandom();
if (RandomE.Chance(0.3f))
{
character.weaponRenderer.enabled = true;
character.weaponRenderer.sprite = weaponSprites.GetRandom();
if (RandomE.Chance(0.3f))
{
character.shieldRenderer.enabled = true;
character.shieldRenderer.sprite = shieldSprites.GetRandom();
}
else
{
character.shieldRenderer.enabled = false;
}
}
else
{
character.weaponRenderer.enabled = false;
character.shieldRenderer.enabled = false;
}
}
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 void WithArray()
{
for (int i = 0; i < 100; i++)
{
Assert.Contains(RandomE.GetRandom(0, 1, array23), array0123);
}
}
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);
}
public void WithEmptyArray()
{
for (int i = 0; i < 100; i++)
{
Assert.Contains(RandomE.GetRandom(0, 1, emptyArray), array01);
}
}
private IEnumerator GenerateCoroutine()
{
var algorithm = generatorAlgorithm;
if (algorithm == MazeGenerator.Algorithm.None)
{
algorithm = RandomE.GetRandom(MazeGenerator.Algorithm.RandomTraversal,
MazeGenerator.Algorithm.RandomDepthFirstTraversal,
MazeGenerator.Algorithm.RandomBreadthFirstTraversal);
}
hue = Random.value;
var backgroundColor = new ColorHSV(hue, backgroundSaturation, backgroundValue).complementary.ToColor();
background.CrossFadeColor(backgroundColor, fadeDuration, true, false);
switch (algorithm)
{
case MazeGenerator.Algorithm.RandomTraversal:
yield return(StartCoroutine(mazeGenerator.RandomTraversal(DrawEdge, texture.Apply)));
break;
case MazeGenerator.Algorithm.RandomDepthFirstTraversal:
yield return(StartCoroutine(mazeGenerator.RandomDepthFirstTraversal(DrawEdge, texture.Apply)));
break;
case MazeGenerator.Algorithm.RandomBreadthFirstTraversal:
yield return(StartCoroutine(mazeGenerator.RandomBreadthFirstTraversal(DrawEdge, texture.Apply)));
break;
}
texture.Apply();
}
public void NoParams()
{
for (int i = 0; i < 100; i++)
{
Assert.Contains(RandomE.GetRandom(0, 1), array01);
}
}
public void Generate(bool randomizeConfig = true)
{
if (constantSeed)
{
Random.InitState(0);
}
if (randomizeConfig)
{
GeneratePalette();
config.palette.wallColor = GetMainColorHSV().ToColor();
config.roofConfig.type = RandomE.GetRandom(RoofType.Flat, RoofType.Hipped, RoofType.Gabled);
}
if (generator == null)
{
generator = new BuildingGenerator();
}
var buildingDraft = generator.Generate(config);
AssignDraftToMeshFilter(buildingDraft, buildingMeshFilter, ref buildingMesh);
float buildingRadius = Mathf.Sqrt(config.length / 2 * config.length / 2 + config.width / 2 * config.width / 2);
float platformRadius = buildingRadius + platformRadiusOffset;
var platformDraft = Platform(platformRadius, platformHeight);
AssignDraftToMeshFilter(platformDraft, platformMeshFilter, ref platformMesh);
}
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);
}
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 IEnumerator GenerateCoroutine()
{
var algorithm = generatorAlgorithm;
if (algorithm == MazeGenerator.Algorithm.None)
{
algorithm = RandomE.GetRandom(MazeGenerator.Algorithm.RandomTraversal,
MazeGenerator.Algorithm.RandomDepthFirstTraversal,
MazeGenerator.Algorithm.RandomBreadthFirstTraversal);
}
hue = Random.value;
switch (algorithm)
{
case MazeGenerator.Algorithm.RandomTraversal:
yield return(StartCoroutine(mazeGenerator.RandomTraversal(DrawEdge, texture.Apply)));
break;
case MazeGenerator.Algorithm.RandomDepthFirstTraversal:
yield return(StartCoroutine(mazeGenerator.RandomDepthFirstTraversal(DrawEdge, texture.Apply)));
break;
case MazeGenerator.Algorithm.RandomBreadthFirstTraversal:
yield return(StartCoroutine(mazeGenerator.RandomBreadthFirstTraversal(DrawEdge, texture.Apply)));
break;
}
texture.Apply();
}
protected void GeneratePalette()
{
List <ColorHSV> palette = RandomE.TetradicPalette(0.25f, 0.7f);
targetPalette.mainColor = palette[0].WithSV(0.8f, 0.6f);
targetPalette.secondaryColor = palette[1].WithSV(0.8f, 0.6f);
targetPalette.skyColor = palette[2];
targetPalette.horizonColor = palette[3];
targetPalette.groundColor = ColorHSV.Lerp(targetPalette.skyColor, targetPalette.horizonColor, 0.5f);
}
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);
}
private void Generate()
{
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[2], targetPalette[3], 0.5f));
controller = new BoidController();
var mesh = controller.Generate(targetPalette[0].WithSV(1, 1).ToColor(),
targetPalette[1].WithSV(0.8f, 0.8f).ToColor());
meshFilter.mesh = mesh;
}
public void Generate()
{
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[0], targetPalette[1], 0.5f));
config.gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
var draft = LowPolyTerrainGenerator.TerrainDraft(config);
draft.Move(Vector3.left * config.terrainSize.x / 2 + Vector3.back * config.terrainSize.z / 2);
meshFilter.mesh = draft.ToMesh();
}
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);
}
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 void Generate()
{
Vector3 terrainSize = new Vector3(terrainSizeX, terrainSizeY, terrainSizeZ);
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[0], targetPalette[1], 0.5f));
var gradient = ColorE.Gradient(targetPalette[2].WithS(0.8f).WithV(0.8f),
targetPalette[3].WithS(0.8f).WithV(0.8f));
var draft = LowPolyTerrainGenerator.TerrainDraft(terrainSize, cellSize, noiseScale, gradient);
draft.Move(Vector3.left * terrainSizeX / 2 + Vector3.back * terrainSizeZ / 2);
meshFilter.mesh = draft.ToMesh();
}
public Gradient BlendGradient(Gradient terrain_gradient, Gradient object_gradient)
{
List <ColorHSV> targetPalette = new List <ColorHSV>();
List <ColorHSV> currentPalette = new List <ColorHSV>();
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
Debug.Log(targetPalette.Count);
ColorHSV groundColor = new ColorHSV(terrain_gradient.Evaluate(0));
ColorHSV newColor = new ColorHSV(object_gradient.Evaluate(1));
targetPalette.Add(ColorHSV.Lerp(groundColor, newColor, 0.5f));
var gradient = ColorE.Gradient(from: targetPalette[2].WithSV(0.8f, 0.8f),
to: targetPalette[3].WithSV(0.8f, 0.8f));
return(object_gradient);
}
private MeshDraft KhrushchyovkaDraft()
{
float width = Random.Range(widthLB, widthUB);
float length = Random.Range(lengthLB, lengthUB);
int floorCount = Random.Range(floorCountLB, floorCountUB);
var hasAttic = RandomE.Chance(0.5f);
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);
var facadePlan0 = FacadeGenerator(length, floorCount, hasAttic, true, true);
draft.Add(Facade(corners[0], Vector3.right, facadePlan0));
var facadePlan1 = FacadeGenerator(width, floorCount, hasAttic);
draft.Add(Facade(corners[1], Vector3.forward, facadePlan1));
var facadePlan2 = FacadeGenerator(length, floorCount, hasAttic, false, true);
draft.Add(Facade(corners[2], Vector3.left, facadePlan2));
var 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 = MeshE.QuadDraft(corners[0], corners[1], corners[2], corners[3]);
basement.Paint(roofColor);
draft.Add(basement);
return(draft);
}
private IEnumerator GenerateCoroutine()
{
texture = new Texture2D(mazeWidth, mazeHeight, TextureFormat.ARGB32, false, true)
{
filterMode = FilterMode.Point
};
cellWidth = (mazeWidth - cellWallSize) / (cellSize + cellWallSize);
cellHeight = (mazeHeight - cellWallSize) / (cellSize + cellWallSize);
maze = new Maze(cellWidth, cellHeight);
var origin = new Cell {
x = Random.Range(0, cellWidth), y = Random.Range(0, cellHeight)
};
maze[origin] = Directions.None;
edges = new List <Edge>(maze.GetEdges(origin));
texture.Clear(Color.black);
yield return(null);
switch (mazeAlgorithm)
{
case MazeAlgorithm.None:
if (RandomE.Chance(0.5f))
{
yield return(StartCoroutine(RandomTraversal()));
}
else
{
yield return(StartCoroutine(RandomDepthFirstTraversal()));
}
break;
case MazeAlgorithm.RandomTraversal:
yield return(StartCoroutine(RandomTraversal()));
break;
case MazeAlgorithm.RandomDepthFirstTraversal:
yield return(StartCoroutine(RandomDepthFirstTraversal()));
break;
}
texture.Apply();
}
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);
}
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);
}
private ILayout PlanEntranceFacade(float facadeWidth, int floors, float entranceInterval, bool hasAttic, bool leftIsConvex,
bool rightIsConvex)
{
float remainder;
List <PanelSize> panelSizes = DivideFacade(facadeWidth, leftIsConvex, rightIsConvex, out remainder);
bool hasBalconies = RandomE.Chance(0.5f);
commonConstructors[PanelType.Entrance] = constructors[PanelType.Entrance].GetRandom();
commonConstructors[PanelType.EntranceWindow] = constructors[PanelType.EntranceWindow].GetRandom();
commonConstructors[PanelType.Wall] = constructors[PanelType.Wall].GetRandom();
var horizontal = new HorizontalLayout();
bool hasRemainder = remainder > Geometry.Epsilon;
if (hasRemainder)
{
horizontal.Add(CreateBufferWallVertical(remainder / 2, floors, hasAttic));
}
int entranceCount = Mathf.Max(Mathf.FloorToInt(facadeWidth / entranceInterval) - 1, 1);
int entranceIndexInterval = (panelSizes.Count - entranceCount) / (entranceCount + 1);
int lastEntranceIndex = -1;
for (int i = 0; i < entranceCount; i++)
{
int entranceIndex = (i + 1) * entranceIndexInterval + i;
horizontal.Add(CreateNormalFacadeVertical(panelSizes, lastEntranceIndex + 1, entranceIndex, floors, hasAttic, hasBalconies));
horizontal.Add(CreateEntranceVertical(sizeValues[panelSizes[entranceIndex]], floors, hasAttic));
if (i == entranceCount - 1)
{
horizontal.Add(CreateNormalFacadeVertical(panelSizes, entranceIndex + 1, panelSizes.Count, floors, hasAttic, hasBalconies));
}
lastEntranceIndex = entranceIndex;
}
if (hasRemainder)
{
horizontal.Add(CreateBufferWallVertical(remainder / 2, floors, hasAttic));
}
return(horizontal);
}
public CompoundMeshDraft Generate(Config config)
{
Assert.IsTrue(config.width > 0);
Assert.IsTrue(config.length > 0);
Assert.IsTrue(config.floors > 0);
Assert.IsTrue(config.entranceInterval > 0);
InitializeConstructors(config.palette);
var foundationPolygon = new List <Vector2>
{
Vector2.left *config.length / 2 + Vector2.down *config.width / 2,
Vector2.right *config.length / 2 + Vector2.down *config.width / 2,
Vector2.right *config.length / 2 + Vector2.up *config.width / 2,
Vector2.left *config.length / 2 + Vector2.up *config.width / 2
};
commonConstructors[PanelType.Entrance] = constructors[PanelType.Entrance].GetRandom();
commonConstructors[PanelType.EntranceWindow] = constructors[PanelType.EntranceWindow].GetRandom();
var facadeLayouts = new List <FacadeLayout>();
for (int i = 0; i < foundationPolygon.Count; i++)
{
Vector2 a = foundationPolygon[i];
Vector2 b = foundationPolygon.GetLooped(i + 1);
float? entranceInterval = i == 0 ? config.entranceInterval : (float?)null;
bool hasBalconies = RandomE.Chance(0.5f);
facadeLayouts.Add(GenerateFacade(a, b, config.floors, hasBalconies, config.hasAttic, entranceInterval));
}
float facadeHeight = floorHeight * config.floors + socleHeight + (config.hasAttic ? atticHeight : 0);
var compoundDraft = GenerateFacadesCompoundMeshDraft(foundationPolygon, facadeLayouts);
var roofDraft = RoofGenerator.Generate(foundationPolygon, facadeHeight, config.roofConfig)
.Paint(config.palette.roofColor);
compoundDraft.Add(roofDraft);
compoundDraft.MergeDraftsWithTheSameName();
compoundDraft.SortDraftsByName();
compoundDraft.name = "Building";
return(compoundDraft);
}
private ILayout PlanNormalFacade(float facadeWidth, int floors, bool hasAttic, bool leftIsConvex, bool rightIsConvex)
{
List <PanelSize> panelSizes = DivideFacade(facadeWidth, leftIsConvex, rightIsConvex, out float remainder);
bool hasBalconies = RandomE.Chance(0.5f);
var vertical = CreateNormalFacadeVertical(panelSizes, 0, panelSizes.Count, floors, hasAttic, hasBalconies);
if (remainder > Geometry.Epsilon)
{
return(new HorizontalLayout
{
CreateBufferWallVertical(remainder / 2, floors, hasAttic),
vertical,
CreateBufferWallVertical(remainder / 2, floors, hasAttic)
});
}
return(vertical);
}
private void GenerateLevel()
{
// Destroy existing bricks
foreach (var brick in bricks)
{
Object.Destroy(brick);
}
bricks.Clear();
var gradient = RandomE.gradientHSV;
for (int y = 0; y < wallHeight; y++)
{
// Select color for current line
var lineColor = gradient.Evaluate(y / (wallHeight - 1f));
// Generate brick sizes for current line
List <BrickSize> brickSizes = BrickSizes(wallWidth);
float x = 0f;
var previousColor = lineColor;
for (int i = 0; i < brickSizes.Count; i++)
{
// Randomize tint of current brick
var color = lineColor;
while (previousColor == color)
{
color -= Color.white * RandomE.Range(-0.2f, 0.2f, 3);
}
previousColor = color;
var brickSize = brickSizes[i];
if (i >= 0)
{
x += sizeValues[brickSize] / 2;
}
Vector3 position = Vector3.right * (x - wallWidth / 2f) + Vector3.up * (wallHeightOffset + y / 2f);
bricks.Add(GenerateBrick(position, color, brickSize));
x += sizeValues[brickSize] / 2;
}
}
}
public void Generate()
{
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[2], targetPalette[3], 0.5f));
var chairDraft = ChairGenerator.Chair(legWidth, legHeight, seatWidth, seatDepth, seatHeight, backHeight,
hasStretchers, hasArmrests, targetPalette[0].WithS(0.8f).WithV(0.8f).ToColor());
var chairMesh = chairDraft.ToMesh();
chairMesh.RecalculateBounds();
chairMeshFilter.mesh = chairMesh;
float chairRadius = Mathf.Sqrt(seatWidth / 2f * seatWidth / 2f + seatDepth / 2f * seatDepth / 2f);
float platformRadius = chairRadius + platformRadiusOffset;
var platformMesh = Platform(platformRadius, platformBaseOffset, platformSegments, platformHeight).ToMesh();
platformMesh.RecalculateBounds();
platformMeshFilter.mesh = platformMesh;
}
public void Generate()
{
targetPalette = RandomE.TetradicPalette(0.25f, 0.75f);
targetPalette.Add(ColorHSV.Lerp(targetPalette[2], targetPalette[3], 0.5f));
config.color = targetPalette[0].WithSV(0.8f, 0.8f).ToColor();
var chairDraft = ChairGenerator.Chair(config);
var chairMesh = chairDraft.ToMesh();
chairMesh.RecalculateBounds();
chairMeshFilter.mesh = chairMesh;
float chairRadius = Mathf.Sqrt(config.seatWidth * config.seatWidth / 4 + config.seatDepth * config.seatDepth / 4);
float platformRadius = chairRadius + platformRadiusOffset;
var platformMesh = Platform(platformRadius, platformBaseOffset, platformSegments, platformHeight).ToMesh();
platformMesh.RecalculateBounds();
platformMeshFilter.mesh = platformMesh;
}
