281 lines
No EOL
7 KiB
C#
281 lines
No EOL
7 KiB
C#
using System.Runtime.InteropServices;
|
|
|
|
namespace Oriels;
|
|
[StructLayout(LayoutKind.Sequential)]
|
|
struct BufferData {
|
|
public Matrix matrix;
|
|
public Vec3 dimensions;
|
|
public float time;
|
|
}
|
|
|
|
public class Space {
|
|
MaterialBuffer<BufferData> buffer;
|
|
BufferData data = new BufferData();
|
|
|
|
Material matFloor = new Material(Shader.Default);
|
|
Model shed = Model.FromFile("shed/shed.glb", Shader.FromFile("shaders/room.hlsl"));
|
|
Mesh cube = Mesh.Cube;
|
|
|
|
Solid floor;
|
|
public Space() {
|
|
buffer = new MaterialBuffer<BufferData>(3); // index
|
|
|
|
// recenter the nodes in the leek model
|
|
// so that the leek is centered at the origin
|
|
// and the scale is 1
|
|
// Vec3 center = new Vec3(0, 0, 0);
|
|
// foreach (ModelNode node in leek.Nodes) {
|
|
// if (node.Mesh != null) {
|
|
// // average the vertices to find the center
|
|
// foreach (Vertex vertex in node.Mesh.GetVerts()) {
|
|
// center += vertex.pos;
|
|
// }
|
|
// center /= node.Mesh.VertCount;
|
|
// }
|
|
// node.LocalTransform = Matrix.TS(
|
|
// Vec3.Zero,
|
|
// 1f
|
|
// );
|
|
// // node.ModelTransform = Matrix.TS(
|
|
// // new Vec3(0, 0, 0),
|
|
// // 1f
|
|
// // );
|
|
// }
|
|
// leek.RootNode.LocalTransform = Matrix.TS(
|
|
// -center,
|
|
// 1f
|
|
// );
|
|
|
|
|
|
floor = new Solid(World.BoundsPose.position, Quat.Identity, SolidType.Immovable);
|
|
scale = 64f;
|
|
floorScale = new Vec3(scale, 0.1f, scale);
|
|
floor.AddBox(floorScale);
|
|
// box on each side
|
|
floor.AddBox(new Vec3(scale, scale / 2, 0.1f), 1, new Vec3(0, scale / 4, -scale / 2));
|
|
floor.AddBox(new Vec3(scale, scale / 2, 0.1f), 1, new Vec3(0, scale / 4, scale / 2));
|
|
floor.AddBox(new Vec3(0.1f, scale / 2, scale), 1, new Vec3(-scale / 2, scale / 4, 0));
|
|
floor.AddBox(new Vec3(0.1f, scale / 2, scale), 1, new Vec3(scale / 2, scale / 4, 0));
|
|
// and ceiling
|
|
floor.AddBox(new Vec3(scale, 0.1f, scale), 1, new Vec3(0, scale / 2, 0));
|
|
matFloor.SetTexture("diffuse", Tex.FromFile("floor.png"));
|
|
matFloor.SetFloat("tex_scale", 32);
|
|
|
|
meshBeam = Mesh.GeneratePlane(new Vec2(0.1f, 1));
|
|
Vertex[] verts = meshBeam.GetVerts();
|
|
verts[0].col = new Color(1f, 0.5f, 0.5f);
|
|
meshBeam.SetVerts(verts);
|
|
}
|
|
Mesh meshBeam;
|
|
|
|
public float scale;
|
|
public Vec3 floorScale;
|
|
|
|
|
|
public void Frame() {
|
|
Mono mono = Mono.inst;
|
|
// Oriel oriel = Mono.inst.oriel;
|
|
// data.matrix = (Matrix)System.Numerics.Matrix4x4.Transpose(oriel.matrixInv);
|
|
// data.dimensions = oriel.bounds.dimensions;
|
|
|
|
data.matrix = (Matrix)System.Numerics.Matrix4x4.Transpose(Matrix.T(Vec3.Up));
|
|
data.dimensions = new Vec3(0.1f, 0.1f, 0.1f);
|
|
buffer.Set(data);
|
|
|
|
|
|
|
|
|
|
|
|
// PR.BlockOut(floor.GetPose().ToMatrix(floorScale), Color.White * 0.333f, matFloor);
|
|
// foreach (ModelNode node in shed.Visuals) {
|
|
|
|
// Console.WriteLine(i + " - " + node.Name);
|
|
|
|
// node.Material.SetVector("_center", oriel.bounds.center);
|
|
// node.Material.SetVector("_dimensions", oriel.bounds.dimensions);
|
|
// node.Material["_matrix"] = (Matrix)System.Numerics.Matrix4x4.Transpose(oriel.matrix);
|
|
|
|
// Console.WriteLine("Shader: " + node.Material.Shader.Name);
|
|
|
|
// node.Mesh.Draw(matRoom, Matrix.TRS(new Vec3(0, World.BoundsPose.position.y, -1), Quat.Identity, Vec3.One));
|
|
// Console.WriteLine(matRoom.ParamCount + " test " + node.Material.ParamCount);
|
|
// }
|
|
// room.RootNode.Material.SetVector("_center", oriel.bounds.center);
|
|
// room.RootNode.Material.SetVector("_dimensions", oriel.bounds.dimensions);
|
|
// room.RootNode.Material["_matrix"] = (Matrix)System.Numerics.Matrix4x4.Transpose(oriel.matrix);
|
|
|
|
// Shader.
|
|
// World.BoundsPose.position.y
|
|
|
|
|
|
shed.Draw(Matrix.Identity);
|
|
|
|
// leek.Draw(Matrix.TRS(new Vec3(2.5f, 0, -2.5f) * 1.2f, Quat.FromAngles(180f, 30f, 0f), 1.2f));
|
|
|
|
|
|
float radius = 9;
|
|
Vec3 pillarsOffset = new Vec3(0, 0, -10);
|
|
for (float x = -radius; x < radius; x++) {
|
|
for (float z = -radius; z < radius; z++) {
|
|
|
|
float d2 = Mono.inst.noise.D2((int)x, (int)z);
|
|
float xpos = pillarsOffset.x + x;
|
|
float zpos = pillarsOffset.z - z;
|
|
|
|
if (Vec3.Distance(new Vec3(xpos, 0, zpos), Vec3.Zero) < radius / 2) {
|
|
Mesh.Cube.Draw(
|
|
mono.mat.holo,
|
|
Matrix.TS(
|
|
new Vec3(
|
|
xpos + x,
|
|
radius / 2,
|
|
zpos + z / 2
|
|
) + Quat.FromAngles(d2 * 90, d2 * 360, 0) * Vec3.Forward * 2f,
|
|
new Vec3(2, 1, 2) * (0.5f + d2)
|
|
),
|
|
Color.White
|
|
);
|
|
continue;
|
|
}
|
|
|
|
float height = 1 + d2;
|
|
float angle = d2 * 360f;
|
|
Vec3 offset = Quat.FromAngles(0, angle, 0) * Vec3.Forward * d2 * 0.5f;
|
|
xpos += offset.x;
|
|
zpos += offset.z;
|
|
Mesh.Cube.Draw(
|
|
mono.mat.holo,
|
|
Matrix.TRS(
|
|
new Vec3(xpos, (height * 0.5f), zpos),
|
|
Quat.FromAngles(0, angle, 0),
|
|
new Vec3(0.1f, height, 0.1f)
|
|
),
|
|
new Color(1f, 1f, 1f, 1f)
|
|
);
|
|
|
|
Mesh.Cube.Draw(
|
|
mono.mat.holo,
|
|
Matrix.TRS(
|
|
new Vec3(xpos, height, zpos),
|
|
Quat.FromAngles(0, angle, 0),
|
|
new Vec3(0.95f, height, 0.95f)
|
|
),
|
|
new Color(0.3f, 0.7f + (d2 * 0.3f), 0.2f, 1f)
|
|
);
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < drops.Length; i++) {
|
|
if (drops[i] == null) drops[i] = new Drop();
|
|
|
|
drops[i].Frame(i);
|
|
}
|
|
}
|
|
Drop[] drops = new Drop[128];
|
|
class Drop {
|
|
public Vec3 pos;
|
|
float rippleT = 1f;
|
|
bool falling = false;
|
|
Mesh mesh_ripple = Model.FromFile("ripple.glb").FindNode("ripple").Mesh;
|
|
|
|
public void Frame(int id) {
|
|
Mono mono = Mono.inst;
|
|
|
|
if (!falling) {
|
|
PR.Noise noise = Mono.inst.noise;
|
|
rippleT += Time.Stepf / 0.5f;
|
|
if (rippleT >= 1.0f + (1.0f + noise.D1(id))) {
|
|
pos = new Vec3(
|
|
noise.value * 10f,
|
|
10,
|
|
-0.5f + noise.uvalue * -10f
|
|
);
|
|
falling = true;
|
|
}
|
|
|
|
float t = 1 - MathF.Min(rippleT, 1f);
|
|
t *= t;
|
|
t = 1 - t;
|
|
mesh_ripple.Draw(
|
|
mono.mat.holoclear,
|
|
Matrix.TRS(pos, Quat.Identity, new Vec3(0.333f * t, 0.0133f, 0.333f * t)),
|
|
new Color(1f, 1f, 1f, 1f) * (1f - t)
|
|
);
|
|
}
|
|
|
|
if (falling) {
|
|
// rain's terminal velocity is 9.8 m/s
|
|
pos.y -= 9.8f * Time.Stepf;
|
|
if (pos.y <= 0.0f) {
|
|
pos.y = 0.0f;
|
|
rippleT = 0f;
|
|
falling = false;
|
|
}
|
|
|
|
Mesh.Cube.Draw(
|
|
mono.mat.holoclear,
|
|
Matrix.TRS(pos, Quat.Identity, new Vec3(0.002f, 0.98f, 0.002f)),
|
|
new Color(0.8f, 0.8f, 1f) * 0.1333f
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
// Tree tree = new Tree();
|
|
// Tree[] trees = new Tree[128];
|
|
|
|
// class Tree {
|
|
// float r; // damage
|
|
// float g; // resources
|
|
// float b; // peak
|
|
// Vec3 pos;
|
|
// float angle;
|
|
// // color(r, max(g, b), b)
|
|
// // height = b
|
|
|
|
// public void Frame() {
|
|
|
|
// }
|
|
// }
|
|
}
|
|
|
|
|
|
/*
|
|
COMMENTS
|
|
|
|
sapling
|
|
e
|
|
|
|
e = lerp(e, g * lft, lft / x)
|
|
r += e
|
|
g -= e
|
|
b -= min(g, 0)
|
|
reliant on ideal conditions being there to ease off of the seed dependency
|
|
(scrappy can outlast the g)
|
|
|
|
tree
|
|
r += min(g, 0) + background radiation * lft
|
|
g += b * lft
|
|
b +=
|
|
r 0->b
|
|
g = clamp(g, 0, 1)
|
|
b = clamp(b, 0, 1)
|
|
|
|
e = (r / neighbors) * lft
|
|
g -= e
|
|
|
|
if g > 1 - r
|
|
seed(g, pos + Quat.FromAngles(0, noise.value * 360f, 0) * b)
|
|
g = 0
|
|
|
|
tilt towards best spot
|
|
* rand.dir * r * smoothstart (r * r * r * r * r) ?
|
|
|
|
if r > b
|
|
b += lft
|
|
|
|
if b > 1
|
|
poof
|
|
|
|
*/ |