public TetrahedronTypeB BuildTensegrityTypeB(Tetra tetra, SpatialSlur.Mesh.Impl.NodeList <SpatialSlur.Mesh.HeMesh3d.Vertex> verts)
{
var p0 = (Vector3)verts[tetra.Vertex0].Position;
var p1 = (Vector3)verts[tetra.Vertex1].Position;
var p2 = (Vector3)verts[tetra.Vertex2].Position;
var p3 = (Vector3)verts[tetra.Vertex3].Position;
p0 = transform.TransformPoint(p0);
p1 = transform.TransformPoint(p1);
p2 = transform.TransformPoint(p2);
p3 = transform.TransformPoint(p3);
var cen = (p0 + p1 + p2 + p3) / 4f;
var tetratype = Instantiate(_typeB, transform);
tetratype.transform.position = cen;
p0 = tetratype.transform.InverseTransformPoint(p0);
p1 = tetratype.transform.InverseTransformPoint(p1);
p2 = tetratype.transform.InverseTransformPoint(p2);
p3 = tetratype.transform.InverseTransformPoint(p3);
tetratype.SetupTetraPoints(new Vector3[] { p0, p1, p2, p3 });
tetratype.SetupStructure();
return(tetratype);
}
protected Tetra UnpackTetra()
{
Tetra o = new Tetra();
byte stateByte = ReadByte();
o.DriveThrough = (stateByte & (1 << 0)) != 0;
o.ShootThrough = (stateByte & (1 << 1)) != 0;
o.Ricochet = (stateByte & (1 << 2)) != 0;
o.Transform = UnpackMeshTransform();
for (int i = 0; i < 4; i++)
{
o.Verts.Add(ReadVector3F());
}
byte normalFlags = ReadByte();
for (int i = 0; i < 4; i++)
{
Tetra.Face face = new Tetra.Face();
o.Faces.Add(face);
face.UseNormals = (normalFlags & (1 << i)) != 0;
if (face.UseNormals)
{
for (int j = 0; j < 3; j++)
{
face.Norms.Add(ReadVector3F());
}
}
}
byte uvFlags = ReadByte();
for (int i = 0; i < 4; i++)
{
Tetra.Face face = o.Faces[i];
face.UseUVs = (uvFlags & (1 << i)) != 0;
if (face.UseNormals)
{
for (int j = 0; j < 3; j++)
{
face.UVs.Add(ReadVector2F());
}
}
}
for (int i = 0; i < 4; i++)
{
Tetra.Face face = o.Faces[i];
face.MaterialID = ReadInt32();
}
return(o);
}
public void CheckNeighbor(Tetra T)
{
foreach (var e in T.Edge)
{
if (e.GetName().Contains(this.transform.name))
{
var f = T.Edgeface[e];
Evaulate(f, T);
}
}
print(T.name);
}
public void Evaulate(List <Face> f, Tetra T)
{
foreach (var fp in f)
{
if (fp.GetTag() == "Free")
{
_fp.Add(fp.GetTransform());
}
else
{
tp2[0] = T.FacePoint[fp];
var c = tp2[0].gameObject.AddComponent <SphereCollider>();
c.isTrigger = true;
c.radius = 0.3f;
}
}
print(_fp.Count);
}
public override ExecutionResult ExecuteInstruction(MmixComputer mmixComputer, Tetra tetra)
{
// register to store into
var reg = mmixComputer.Registers[tetra.X];
// multiply by 4 as ops are 4 bytes wide
long relativeAddress = 4 * (tetra.Y + tetra.Z);
// sign check as there isn't a ulong + long overload that handles negatives (I think)
ulong address;
if (relativeAddress > 0)
{
address = mmixComputer.PC + (ulong)relativeAddress;
}
else
{
address = mmixComputer.PC - (ulong)(-relativeAddress);
}
reg.Store(address);
return(ExecutionResult.CONTINUE);
}
/// <summary>
/// Constructs an empty grid. All public member variables must be
/// initialized before this object can be used in BoSSS.
/// </summary>
public UnstructuredTetraGrid()
: base()
{
m_GridSimplex = new Tetra();
}
protected override void OnHandleInput()
{
base.OnHandleInput();
if (Input.MousePressed == MouseButtons.Right)
{
results.Fraction = 1;
if (pickConstraint == null)
{
Vector3 rayFrom = Freelook.Eye;
Vector3 rayTo = GetRayTo(Input.MousePoint, Freelook.Eye, Freelook.Target, FieldOfView);
Vector3 rayDir = (rayTo - rayFrom);
rayDir.Normalize();
AlignedSoftBodyArray sbs = ((SoftRigidDynamicsWorld)PhysicsContext.World).SoftBodyArray;
for (int ib = 0; ib < sbs.Count; ++ib)
{
SoftBody psb = sbs[ib];
SRayCast res = new SRayCast();
if (psb.RayTest(rayFrom, rayTo, res))
{
results = res;
}
}
if (results.Fraction < 1)
{
impact = rayFrom + (rayTo - rayFrom) * results.Fraction;
drag = !(PhysicsContext as Physics).cutting;
lastMousePos = Input.MousePoint;
node = null;
switch (results.Feature)
{
case EFeature.Tetra:
{
Tetra tet = results.Body.Tetras[results.Index];
node = tet.Nodes[0];
for (int i = 1; i < 4; ++i)
{
if ((node.X - impact).LengthSquared() >
(tet.Nodes[i].X - impact).LengthSquared())
{
node = tet.Nodes[i];
}
}
break;
}
case EFeature.Face:
{
Face f = results.Body.Faces[results.Index];
node = f.N[0];
for (int i = 1; i < 3; ++i)
{
if ((node.X - impact).LengthSquared() >
(f.N[i].X - impact).LengthSquared())
{
node = f.N[i];
}
}
}
break;
}
if (node != null)
{
goal = node.X;
}
//return;
}
}
}
else if (Input.MouseReleased == MouseButtons.Right)
{
if ((!drag) && (PhysicsContext as Physics).cutting && (results.Fraction < 1))
{
ImplicitSphere isphere = new ImplicitSphere(impact, 1);
results.Body.Refine(isphere, 0.0001f, true);
}
results.Fraction = 1;
drag = false;
}
// Mouse movement
if (Input.MouseDown == MouseButtons.Right)
{
if (node != null && (results.Fraction < 1))
{
if (!drag)
{
int x = Input.MousePoint.X - lastMousePos.X;
int y = Input.MousePoint.Y - lastMousePos.Y;
if ((x * x) + (y * y) > 6)
{
drag = true;
}
}
if (drag)
{
lastMousePos = Input.MousePoint;
}
}
}
(PhysicsContext as Physics).HandleInput(Input, FrameDelta);
}
/// <summary>
/// テトラメッシュを構築して返す
/// </summary>
/// <param name="posList"></param>
/// <param name="tetraCount">作成されたテトラ数</param>
/// <param name="tetraIndexList">テトラ数ｘ４のインデックスリスト</param>
/// <param name="tetraSizeList">テトラの重心からの最大距離リスト</param>
public static void CalcTetraMesh(List <Vector3> posList, out int tetraCount, out List <int> tetraIndexList, out List <float> tetraSizeList)
{
tetraCount = 0;
tetraIndexList = new List <int>();
tetraSizeList = new List <float>();
// 作業用バッファ
List <TetraVertex> vertexList = new List <TetraVertex>();
for (int i = 0; i < posList.Count; i++)
{
vertexList.Add(new TetraVertex(posList[i], i));
}
// 入力頂点のバウンディングボックス
Bounds b = new Bounds(posList[0], Vector3.one * 0.01f);
foreach (var pos in posList)
{
b.Encapsulate(pos);
}
// ポイントをすべて内包するテトラポイントを追加する
float areaRadius = Mathf.Max(Mathf.Max(b.extents.x, b.extents.y), b.extents.z);
float dist = areaRadius * 100.0f;
var tempSV0 = new TetraVertex();
var tempSV1 = new TetraVertex();
var tempSV2 = new TetraVertex();
var tempSV3 = new TetraVertex();
tempSV0.pos = b.center + new Vector3(0.0f, -dist, 0.0f);
tempSV1.pos = b.center + new Vector3(-dist, dist, dist);
tempSV2.pos = b.center + new Vector3(dist, dist, dist);
tempSV3.pos = b.center + new Vector3(0.0f, dist, -dist);
int svcnt = vertexList.Count;
tempSV0.index = svcnt++;
tempSV1.index = svcnt++;
tempSV2.index = svcnt++;
tempSV3.index = svcnt++;
vertexList.Add(tempSV0);
vertexList.Add(tempSV1);
vertexList.Add(tempSV2);
vertexList.Add(tempSV3);
// 最初のテトラを分割テトラとして登録
List <Tetra> divideTetras = new List <Tetra>();
var tetra0 = new Tetra(tempSV0, tempSV1, tempSV2, tempSV3);
tetra0.CalcCircumcircle();
divideTetras.Add(tetra0);
// 重複チェック用
Dictionary <ulong, Tetra> useTetraHash = new Dictionary <ulong, Tetra>();
useTetraHash.Add(tetra0.GetTetraHash(), tetra0);
// テトラ構築
for (int k = 0; k < (vertexList.Count - 4); k++)
{
var point = vertexList[k];
List <Tetra> tempDivTetras = new List <Tetra>();
for (int i = 0; i < divideTetras.Count;)
{
var tetra = divideTetras[i];
if (tetra.ContainsPoint(point) == false)
{
if (tetra.IntersectCircumcircle(point.pos))
{
// 再分割
var tetra1 = new Tetra(tetra.vertexList[0], tetra.vertexList[1], tetra.vertexList[2], point);
var tetra2 = new Tetra(tetra.vertexList[0], tetra.vertexList[2], tetra.vertexList[3], point);
var tetra3 = new Tetra(tetra.vertexList[0], tetra.vertexList[3], tetra.vertexList[1], point);
var tetra4 = new Tetra(tetra.vertexList[1], tetra.vertexList[2], tetra.vertexList[3], point);
tempDivTetras.Add(tetra1);
tempDivTetras.Add(tetra2);
tempDivTetras.Add(tetra3);
tempDivTetras.Add(tetra4);
useTetraHash.Remove(tetra.GetTetraHash());
divideTetras.RemoveAt(i);
continue;
}
}
i++;
}
// 次の候補として追加
foreach (var tetra in tempDivTetras)
{
ulong thash = tetra.GetTetraHash();
if (useTetraHash.ContainsKey(thash) == false)
{
tetra.CalcCircumcircle();
useTetraHash.Add(thash, tetra);
divideTetras.Add(tetra);
}
else
{
// 衝突
// 衝突もとも削除する
var deltetra = useTetraHash[thash];
useTetraHash.Remove(thash);
divideTetras.Remove(deltetra);
}
}
}
// 最初に追加したテトラを削除
for (int i = 0; i < divideTetras.Count;)
{
var tetra = divideTetras[i];
if (tetra.ContainsPoint(tempSV0, tempSV1, tempSV2, tempSV3))
{
// このテトラは削除する
useTetraHash.Remove(tetra.GetTetraHash());
divideTetras.RemoveAt(i);
continue;
}
i++;
}
vertexList.Remove(tempSV0);
vertexList.Remove(tempSV1);
vertexList.Remove(tempSV2);
vertexList.Remove(tempSV3);
// テトラの検証
for (int i = 0; i < divideTetras.Count;)
{
var tetra = divideTetras[i];
if (tetra.Verification() == false)
{
divideTetras.RemoveAt(i);
continue;
}
i++;
}
// 最終結果を格納
tetraCount = divideTetras.Count;
foreach (var tetra in divideTetras)
{
for (int i = 0; i < 4; i++)
{
tetraIndexList.Add(tetra.vertexList[i].index);
}
tetraSizeList.Add(tetra.tetraSize);
}
}
public bool CheckSame(Tetra tri)
{
return(circumCenter == tri.circumCenter && circumRadius == tri.circumRadius);
}
public override ExecutionResult ExecuteInstruction(MmixComputer mmixComputer, Tetra tetra)
{
var reg = mmixComputer.Registers[tetra.X];
ulong a = mmixComputer.Registers[tetra.Y].ToULong() + mmixComputer.Registers[tetra.Z].ToULong();
var bytes = mmixComputer.ReadOcta(a);
reg.Store(bytes);
return(ExecutionResult.CONTINUE);
}
void depthSort(Tetra.InstancedData[] datas)
{
Vector3 vEye = vEyeTarget + vLook * eyeDist;
Array.Sort(datas,
delegate(Tetra.InstancedData x, Tetra.InstancedData y) {
return (new Vector2(y.modelMats.Row3.X, y.modelMats.Row3.Y) - vEye.Xy).LengthFast.
CompareTo ((new Vector2(x.modelMats.Row3.X, x.modelMats.Row3.Y) - vEye.Xy).LengthFast); });
}
public override ExecutionResult ExecuteInstruction(MmixComputer mmixComputer, Tetra tetra)
{
mmixComputer.rBB = mmixComputer.Registers[255];
// TODO there is a lot more to be understood here - http://mmix.cs.hm.edu/doc/instructions-en.html#TRAP
// for now, XYZ == 0 terminates the program.
if (tetra.Y == Constants.Fputs && tetra.Z == 1)
{
// get pointer from $255
var address = mmixComputer.Registers[255].ToLong();
byte letter;
var letters = new List <byte>();
do
{
letter = mmixComputer.Memory[address];
letters.Add(letter);
address++;
} while (letter != 0x00);
Console.Write(Encoding.ASCII.GetString(letters.ToArray()));
}
if (tetra.ToInt() == 0)
{
return(ExecutionResult.HALTED);
}
return(ExecutionResult.CONTINUE);
}
public abstract ExecutionResult ExecuteInstruction(MmixComputer mmixComputer, Tetra tetra);
public ExecutionResult Execute(MmixComputer mmixComputer, Tetra tetra)
{
//Console.WriteLine(Symbol);
return(ExecuteInstruction(mmixComputer, tetra));
}
