private static void InputVertices(Vector3[] vertices)
{
for (int i = 0, n = vertices.Length - 1; i <= n; i++)
{
var point = vertices[i];
var x = (float)Math.Round(point.x, 2);
var y = (float)Math.Round(point.y, 2);
var z = (float)Math.Round(point.z, 2);
if (!pointVertDict.ContainsKey(x))
{
pointVertDict.Add(x, new Dictionary <float, Vert>());
}
Vert vert;
if (pointVertDict[x].ContainsKey(z))
{
vert = pointVertDict[x][z];
}
else
{
vert = new Vert();
vert.x = x;
vert.y = y;
vert.z = z;
pointVertDict[x][z] = vert;
}
indexVertDict.Add(i, vert);
}
}
public override string ToString()
{
return(string.Format("Vert {0}; PolyEdge {1}; Poly {2};",
Vert?.Join(","),
PolyEdge?.Join(","),
Poly?.Join(",")));
}
void Start()
{
buffer = new ComputeBuffer(count, sizeof(float) * 6, ComputeBufferType.Default);
Vert[] points = new Vert[count];
Random.seed = 0;
for (int i = 0; i < count; i++)
{
points[i] = new Vert();
points[i].position = new Vector3();
points[i].position.x = Random.Range(-size, size);
points[i].position.y = Random.Range(-size, size);
points[i].position.z = Random.Range(-size / 5f, size / 5f);;
/*points[i].color = new Vector3();
* points[i].color.x = Random.value > 0.5f ? 0.0f : 1.0f;
* points[i].color.y = Random.value > 0.5f ? 0.0f : 1.0f;
* points[i].color.z = Random.value > 0.5f ? 0.0f : 1.0f;
*/
points[i].color = new Color();
points[i].color.r = Random.value > 0.5f ? 0.0f : 1.0f;
points[i].color.g = Random.value > 0.5f ? 0.0f : 1.0f;
points[i].color.b = Random.value > 0.5f ? 0.0f : 1.0f;
}
buffer.SetData(points);
}
// 마우스 포인터 위치 검사하기
void CheckMousePoint()
{
Vert v = Vert.Max;
Hor h = Hor.Max;
// 4분면중에서 어느 면에 포인터가 위치하고 있는가?
switch (name)
{
case "1":
v = Vert.UP;
h = Hor.LEFT;
break;
case "2":
v = Vert.UP;
h = Hor.RIGHT;
break;
case "3":
v = Vert.DOWN;
h = Hor.LEFT;
break;
case "4":
v = Vert.DOWN;
h = Hor.RIGHT;
break;
}
EventHandler.instance.GetItemSizeOnGrid(v, h, parentSlot);
}
public static void AssignVertStruct(float[] inValues, int id, out int index, Vert i)
{
index = id;
//pos
// need to be slightly different to not get infinte forces
inValues[index++] = i.pos.x * .99f;
inValues[index++] = i.pos.y * .99f;
inValues[index++] = i.pos.z * .99f;
//vel
inValues[index++] = i.vel.x; //Random.Range(-.00f , .00f );
inValues[index++] = i.vel.y; //Random.Range(-.00f , .00f );
inValues[index++] = i.vel.z; //Random.Range(-.00f , .00f );
//nor
inValues[index++] = i.nor.x;
inValues[index++] = i.nor.y;
inValues[index++] = i.nor.z;
//uv
inValues[index++] = i.uv.x;
inValues[index++] = i.uv.y;
//ribbon id
inValues[index++] = i.ribbonID;
//life
inValues[index++] = i.life;
//debug
inValues[index++] = i.debug.x;
inValues[index++] = i.debug.y;
inValues[index++] = i.debug.z;
}
public Mesh GenerateMesh(int w)
{
width = w;
halfPix = 0.5f / width;
Mesh m = new Mesh();
int pixls = width * width;
verts = new Vert[pixls * 4];
tris.Clear();
Vector3[] fverts = new Vector3[verts.Length];
List <Vector4> uvs = new List <Vector4>();//[verts.Length];
for (int i = 0; i < verts.Length; i++)
{
uvs.Add(new Vector4());
}
for (int x = 0; x < width; x++)
{
for (int y = 0; y < width; y++)
{
for (int p = 0; p < 4; p++)
{
int ind = GetIndOf(x, y, (PicV)p);
verts[ind] = new Vert(x, y, (PicV)p, thickness);
fverts[ind] = verts[ind].pos;
uvs[ind] = verts[ind].uv;
}
FillPixel(x, y);
if (thickness > 0)
{
thickness = Mathf.Min(thickness, 0.9f);
if (x < width - 1)
{
JoinRight(x, y);
}
if (y < width - 1)
{
JoinDown(x, y);
}
if ((x < width - 1) && (y < width - 1))
{
JoinDiagonal(x, y);
}
}
}
}
m.vertices = fverts;
m.SetUVs(0, uvs);
m.triangles = tris.ToArray();
return(m);
}
private Tri TriFromEdgeToPoint(Edge newEdgeSource, Vert point, Vector3 normal)
{
Vert vert0 = newEdgeSource.Vert0;
Vert vert1 = newEdgeSource.Vert1;
return(new Tri(vert0, vert1, point, normal));
}
// Start is called before the first frame update
void Start()
{
buffer = new ComputeBuffer(count, sizeof(float) * 6, ComputeBufferType.Default);
buffer2 = new ComputeBuffer(count, sizeof(float) * 6, ComputeBufferType.Default);
Vert[] points = new Vert[count];
// Random.seed = 0;
Random.InitState(0);
for (int i = 0; i < count; i++)
{
points[i] = new Vert();
points[i].position = new Vector3();
points[i].position.x = Random.Range(-size, size);
points[i].position.y = Random.Range(-size, size);
points[i].position.z = 0.0f;
points[i].color = new Vector3();
points[i].color.x = Random.value;
points[i].color.y = Random.value;
points[i].color.z = Random.value;
}
buffer.SetData(points);
handle = computeShader.FindKernel("CSMain5");
computeShader.SetBuffer(handle, "buffer", buffer);
computeShader.SetBuffer(handle, "buffer2", buffer2);
}
private static Tri GetInitialTri(Vert vert0, Vert vert1, Vert vert2, Vector3 centerPoint)
{
Vector3 polyCenter = (vert0.Pos + vert1.Pos + vert2.Pos) / 3;
Vector3 normalGuide = centerPoint - polyCenter;
return(new Tri(vert0, vert1, vert2, normalGuide));
}
private Voxel AddClick(WorldMaster master, Maker maker, PacketAddVoxel packet)
{
int dstHeight = packet.DestinationHeight;
var voxelType = packet.VoxelType;
var vert = new Vert()
{
angle = packet.VertAngle,
hexPos = packet.HexPos
};
if (!vert.full)
{
vert = master.grid.GetVertOrIterate(packet.HexPos, null);
}
if (!vert.full || !master.graph.IsCoordinateAllowed(vert.hexPos))
{
return(null);
}
maker.BeginNewAction();
if (dstHeight == 0)
{
voxelType = VoxelType.Ground;
}
var result = master.graph.AddVoxel(vert.hexPos, (byte)dstHeight, voxelType, true);
maker.AddAction(vert.hexPos, (byte)dstHeight, VoxelType.Empty, voxelType);
maker.EndAction();
return(result);
}
public Tri(Vert v0, Vert v1, Vert v2)
{
this.verts = new List <Vert>()
{
v0, v1, v2
};
this.normal = ComputeNormal();
}
// Given a root (aa) and two adjacent vertices (bb, cc), computer the normal for aa
private static OMV.Vector3 MakeNormal(Vert aa, Vert bb, Vert cc)
{
OMV.Vector3 mm = aa.Position - bb.Position;
OMV.Vector3 nn = aa.Position - cc.Position;
OMV.Vector3 theNormal = OMV.Vector3.Cross(mm, nn);
theNormal.Normalize();
return(theNormal);
}
public Vert AddVertice(Vector3 pos)
{
Vert v = new Vert();
v.position = pos;
v.selfNode = this.vertices.AddLast(v);
return(v);
}
private IEnumerable <Tri> DrawNewPolys(IEnumerable <EdgeDistStatus> edges, Vert vert, HashSet <Tri> triList)
{
foreach (EdgeDistStatus status in edges)
{
Tri newTri = TriFromEdgeToPoint(status.Edge, vert, -status.Tri.Normal);
triList.Add(newTri);
yield return(newTri);
}
}
void deleteVertexFromList(int DataToDelete)
{
foreach (Vertex Vert in VertexList)
{
if (Vert.getData() == DataToDelete)
{
VertexList.Remove(Vert);
}
}
}
Vertex getVertexFromLList(int DataToFind)
{
foreach (Vertex Vert in VertexList)
{
if (Vert.getData() == DataToFind)
{
return(Vert);
}
}
return(new Vertex(-100));
}
public static void Draw_QUAD(Vert _a, Vert _b, Vert _c, Vert _d)
{
GL.Begin(GL.QUADS);
Add_VERT(_a);
Add_VERT(_b);
Add_VERT(_c);
Add_VERT(_d);
GL.End();
}
public static void Draw_POLY_LINE(params Vert[] _verts)
{
GL.Begin(GL.LINE_STRIP);
for (int vertIndex = 0; vertIndex < _verts.Length; vertIndex++)
{
Vert _V = _verts[vertIndex];
Add_VERT(_V);;
}
GL.End();
}
public YAMLNode ExportYAML(IExportContainer container)
{
YAMLMappingNode node = new YAMLMappingNode();
node.AddSerializedVersion(GetSerializedVersion(container.ExportVersion));
node.Add(IndexName, Index);
node.Add(UVName, UV.ExportYAML(container));
node.Add(VertName, Vert.ExportYAML(container));
node.Add(AdvanceName, Advance);
node.Add(FlippedName, Flipped);
return(node);
}
private static List <Vert> GetInitialBoxVerts()
{
Vert[] ret = new Vert[8];
ret[0] = new Vert(new Vector3(1, 1, 1));
ret[1] = new Vert(new Vector3(1, 0, 1));
ret[2] = new Vert(new Vector3(1, 1, 0));
ret[3] = new Vert(new Vector3(1, 0, 0));
ret[4] = new Vert(new Vector3(0, 1, 1));
ret[5] = new Vert(new Vector3(0, 0, 1));
ret[6] = new Vert(new Vector3(0, 1, 0));
ret[7] = new Vert(new Vector3(0, 0, 0));
return(ret.ToList());
}
public void CreateUniqueVerts()
{
var verts = MeshConstructor.Instance.verts;
for (var i = 0; i < vertices.Count; i++)
{
var newVert = new Vert(vertices[i].targetPosition, false);
verts.Add(newVert);
vertices[i].UnshareVert(this, newVert);
vertices[i] = newVert;
hasUniqueVerts = true;
}
}
public Vert OtherVert(Vert v)
{
if (this.conA.vert == v)
{
return(this.conB.vert);
}
if (this.conB.vert == v)
{
return(this.conA.vert);
}
return(null);
}
public static void Draw_POLY_LINE_CLOSE(params Vert[] _verts)
{
GL.Begin(GL.LINE_STRIP);
Vert _start = _verts[0];
Add_VERT(_start);
for (int vertIndex = 1; vertIndex < _verts.Length; vertIndex++)
{
Vert _V = _verts[vertIndex];
Add_VERT(_V);
}
Add_VERT(_start);
GL.End();
}
public Tri(Vert v0, Vert v1, Vert v2)
{
m_V0 = v0;
m_V0.m_Tris.Add(this);
m_V1 = v1;
m_V1.m_Tris.Add(this);
m_V2 = v2;
m_V2.m_Tris.Add(this);
m_Normal = Vector3.Cross(v0.m_Pos - v1.m_Pos, v0.m_Pos - v2.m_Pos).normalized * .3f;
m_Center = (v0.m_Pos + v1.m_Pos + v2.m_Pos) / 3f;
}
public override String ToString()
{
if (Vert == null && Horz == null)
{
return(null);
}
if (Vert == Horz)
{
return(Vert.ToString());
}
else
{
return($"{Vert.ToString()} {Horz.ToString()}");
}
}
public bool SetFaceFromVert(Vert v, Face f)
{
if (this.conA.vert == v)
{
this.conA.face = f;
return(true);
}
if (this.conB.vert == v)
{
this.conB.face = f;
return(true);
}
return(false);
}
public WEdge EdgeWithFaceAndNotVert(Face f, Vert v)
{
foreach (WEdge e in this.edges)
{
if (e.conA.face == f && e.conA.vert != v)
{
return(e);
}
if (e.conB.face == f && e.conB.vert != v)
{
return(e);
}
}
return(null);
}
private void ParseChunk_VRTX(BinaryReader data, ref Geoset geoset)
{
uint vertCount = data.ReadUInt32();
Vert[] verts = new Vert[vertCount];
for (int i = 0; i < vertCount; i++)
{
verts[i] = new Vert {
x = data.ReadSingle(), y = data.ReadSingle(), z = data.ReadSingle()
}
}
;
geoset.verts = verts;
}
public void Execute(int idx)
{
int dim = m_dimension;
float pitch = m_pitch;
float ptSize = m_pointSize;
float radius = pitch * 0.5f * Util.CornerConstant;
int x = idx % dim;
int y = (idx / dim) % dim;
int z = (idx / (dim * dim)) % dim;
float3 P = m_origin + float3(x, y, z) * pitch;
float distance = Distance(P);
if (abs(distance) >= radius)
{
return;
}
m_ran[idx] = 1;
float3 N = Normal(P);
P = P - N * distance;
float3 T = Util.Tangent(N);
float3 B = Util.Bitangent(N, T);
T *= ptSize;
B *= ptSize;
m_positions[idx] = new Vert
{
a = P - T - B,
b = P - T + B,
c = P + T + B,
d = P + T - B,
};
m_normals[idx] = new Vert
{
a = Normal(m_positions[idx].a),
b = Normal(m_positions[idx].b),
c = Normal(m_positions[idx].c),
d = Normal(m_positions[idx].d),
};
}
public static Mesh RasterizeMesh(Mesh oMesh, int resolution)
{
List <Vert> verts = GetVerts(oMesh);
List <Tri> tris = GetTris(oMesh, verts);
RemoveDuplicateVerts(tris, verts);
Vector3 bounds = new Vector3(oMesh.bounds.size.x, oMesh.bounds.size.y, oMesh.bounds.size.z);
Vector3 steps = new Vector3(bounds.x / resolution, bounds.y / resolution, bounds.z / resolution);
List <Vector3> raster = new List <Vector3>();
for (int x = 0; x <= resolution; x++)
{
for (int y = 0; y <= resolution; y++)
{
for (int z = 0; z <= resolution; z++)
{
raster.Add(new Vector3(-(bounds.x / 2f) + x * steps.x, -(bounds.y / 2f) + y * steps.y, -(bounds.z / 2f) + z * steps.z));
}
}
}
for (int i = 0; i < verts.Count; i++)
{
Vert v = verts[i];
float minDist = Mathf.Infinity;
int minIndex = -1;
for (int j = 0; j < raster.Count; j++)
{
float dist = Vector3.Distance(v.pos, raster[j]);
if (dist < minDist)
{
minDist = dist;
minIndex = j;
}
}
v.pos = raster[minIndex];
}
RemoveDuplicateVerts(tris, verts);
return(GenerateMesh(verts, tris));
}
// Use this for initialization
void Start()
{
buffer = new ComputeBuffer(count, sizeof(float) * 6, ComputeBufferType.Default);
Vert[] points = new Vert[count];
Random.seed = 0;
for (int i = 0; i < count; i++)
{
points[i] = new Vert();
points[i].position = new Vector3();
points[i].position.x = Random.Range(-size, size);
points[i].position.y = Random.Range(-size, size);
points[i].position.z = 0;
points[i].color = new Vector3();
points[i].color.x = Random.value > 0.5f ? 0.0f : 1.0f;
points[i].color.y = Random.value > 0.5f ? 0.0f : 1.0f;
points[i].color.z = Random.value > 0.5f ? 0.0f : 1.0f;
}
buffer.SetData(points);
index = cs.FindKernel("CSMain");
/* tex = new RenderTexture(64, 64, 24);
tex.enableRandomWrite = true;
tex.Create();*/
cs.SetBuffer(index, "data", buffer);
cs.SetInt("count", count);
// cs.SetTexture(index, "Result", tex);
cs.Dispatch(index, 1, 1,1);
/* if (cam != null)
cam.targetTexture = tex;*/
}
void Start()
{
buffer = new ComputeBuffer (count, sizeof(float) * 6, ComputeBufferType.Default);
Vert[] points = new Vert[count];
Random.seed = 0;
for (int i = 0; i < count; i++)
{
points[i] = new Vert();
points[i].position = new Vector3();
points[i].position.x = Random.Range (0, size);
points[i].position.y = Random.Range (0, size);
points[i].position.z = Random.Range (0, size);;
points[i].color = new Vector3();
points[i].color.x = points[i].position.x/size;
points[i].color.y = points[i].position.y/size;
points[i].color.z = points[i].position.z/size;
}
buffer.SetData (points);
}
