/// <summary>
/// build stl files from ring data
/// </summary>
/// <param name="correctedRingList"></param>
/// <param name="flatFileName"></param>
/// <param name="rolledFileName"></param>
static void SaveRolledSTLFile(Barrel barrel, DataOutputOptions options, CylGridData correctedRingList, double unrollRadius, string fileName, IProgress <int> progress)
{
try
{
var v3rolledPtList = correctedRingList.AsCartGridData();
var _flatStlFile = new StlFile();
var trimesh = new TriMesh();
trimesh.BuildFromGrid(v3rolledPtList);
StlFile.SaveBinary(trimesh, fileName);
}
catch (Exception)
{
throw;
}
}
private TriMesh openBinary(string fileName)
{
UInt32 triCountBin = 0;
var triangles = new TriMesh();
try
{
if (fileName != null && fileName != "" & System.IO.File.Exists(fileName))
{
using (System.IO.BinaryReader br = new System.IO.BinaryReader(System.IO.File.Open(fileName, System.IO.FileMode.Open)))
{
br.BaseStream.Seek(0, System.IO.SeekOrigin.Begin);
char[] header = new char[80];
UInt32 triIndex = 0;
header = br.ReadChars(80);
triCountBin = br.ReadUInt32();
while (triIndex < triCountBin && br.BaseStream.Position < br.BaseStream.Length)
{
double n1 = br.ReadSingle();
double n2 = br.ReadSingle();
double n3 = br.ReadSingle();
double v1x = br.ReadSingle();
double v1y = br.ReadSingle();
double v1z = br.ReadSingle();
double v2x = br.ReadSingle();
double v2y = br.ReadSingle();
double v2z = br.ReadSingle();
double v3x = br.ReadSingle();
double v3y = br.ReadSingle();
double v3z = br.ReadSingle();
UInt16 attr = br.ReadUInt16();
Vector3 norm = new Vector3(n1, n2, n3);
Vector3 p1 = new Vector3(v1x, v1y, v1z);
Vector3 p2 = new Vector3(v2x, v2y, v2z);
Vector3 p3 = new Vector3(v3x, v3y, v3z);
triangles.Add(new Triangle(p1, p2, p3, triIndex));
triIndex++;
}
}
}
return(triangles);
}
catch (Exception)
{
throw;
}
}
/*
* Make the shape for the Kinect depth camera output
*/
protected Shape MakeCameraOutputShape(Camera cam, bool iscolor)
{
Shape shape = new Shape();
Appearance app = new Appearance();
PhongMaterial mtl = new PhongMaterial(new Col4(1.0f, 1.0f, 1.0f, 0.7f));
Sampler sampler = new Sampler();
TriMesh mesh = new TriMesh("position float 3, normal float 3, texcoord float 2");
Vec2 videosize = new Vec2(640, 480);
Vec2 texsize = new Vec2(1024, 512);
Box3 vvol = cam.ViewVol;
Vec3 campos = cam.Translation;
float camdist = campos.Length; // distance of camera from body
float backdist = camdist + vvol.max.z / 6.0f;
float h = backdist * vvol.Height / vvol.min.z;
float w = h;
backdist -= camdist;
if (Kinect != null)
{
Texture tex = new Texture();
sampler.Texture = tex;
if (iscolor)
{
tex.Name = "magicmirror.kinect.colorimage";
Kinect.ColorTexture = tex;
}
else
{
tex.Name = "magicmirror.kinect.depthimage";
Kinect.DepthTexture = tex;
}
}
sampler.Name = "diffuse";
sampler.Set(Sampler.TEXTUREOP, Sampler.DIFFUSE);
sampler.Set(Sampler.TEXCOORD, 0);
app.Set(Appearance.CULLING, 1);
app.Set(Appearance.LIGHTING, 1);
app.Set(Appearance.TRANSPARENCY, 1);
app.SetSampler(0, sampler);
app.Material = mtl;
app.Name = "cameraoutput";
shape.Appearance = app;
GeoUtil.Rect(mesh, h * videosize.x / videosize.y, h, videosize.x / texsize.x, videosize.y / texsize.y);
shape.Geometry = mesh;
shape.Name = "magicmirror.kinect.camerashape";
shape.Translate(0, h / 2, -backdist);
return(shape);
}
public static void Main(string[] args)
{
using (Context c = Context.Create(DebugLevel.Debug))
{
using (Environment e = c.CreateEnvironment())
{
float[] vertices = new float[] { 1, 0, 0, 0, 1, 0, 0, 0, 1 };
float[] indices = new float[] { 0, 1, 2 };
using (TriMesh trimesh = new TriMesh(vertices, indices))
{
using (Body body = e.CreateBody(""))
{
body.InitFromTriMesh(trimesh, true);
body.Name = "mytriangle";
e.Add(body);
e.SetViewer("qtcoin");
float[] pose = new float[] { 1, 0, 0, 0, 0, 0, 0 };
ulong startsimtime = e.SimulationTime;
for (int i = 0; i < 10000; ++i)
{
e.Lock();
ulong newsimtime = e.SimulationTime;
double deltatime = (double)((newsimtime - startsimtime) * 1e-6);
//double fanim = System.Math.IEEERemainder(deltatime,1.0);
pose[0] = (float)System.Math.Sin(deltatime);
pose[3] = (float)System.Math.Cos(deltatime);
body.TransformF = pose;
e.Unlock();
// wait until sim time changes
while (newsimtime == e.SimulationTime)
{
System.Threading.Thread.Sleep(1);
}
}
}
}
}
}
}
static void SaveFlatSTLFile(Barrel barrel, DataOutputOptions options, CylGridData correctedRingList, double unrollRadius, string fileName, IProgress <int> progress)
{
try
{
Debug.WriteLine("writing STL file " + fileName);
var _flatStlFile = new StlFile();
var v3flatptList = DataUtil.UnrollCylinder(correctedRingList, options.SurfaceFileScaleFactor, unrollRadius);
var trimesh = new TriMesh();
trimesh.BuildFromGrid(v3flatptList);
StlFile.SaveBinary(trimesh, fileName);
}
catch (Exception)
{
throw;
}
}
public MeshRenderer(Device device, ShaderCache shaderCache, Matrix transform, TriMesh mesh)
{
this.meshBuffers = new MeshBuffers(device, mesh);
this.modelToWorldTransform = new CoordinateNormalMatrixPairConstantBufferManager(device);
var vertexShaderAndBytecode = shaderCache.GetVertexShader <MeshRenderer>("game/MeshVertex");
this.vertexShader = vertexShaderAndBytecode;
this.inputLayout = new InputLayout(device, vertexShaderAndBytecode.Bytecode, MeshBuffers.InputElements);
using (var texture = MonochromaticTextures.Make(device, Color.LightGray)) {
var textureView = new ShaderResourceView(device, texture);
this.material = new BasicSpecularMaterial(device, shaderCache, textureView);
}
this.transform = transform;
}
public static void Run()
{
// Initialize scene object
Scene scene = new Scene();
// Initialize Node class object
Node cubeNode = new Node("sphere");
Mesh sphere = (new Sphere()).ToMesh();
//convert any mesh into typed TriMesh
var myMesh = TriMesh <MyVertex> .FromMesh(sphere);
//Get the vertex data in customized vertex structure.
MyVertex[] vertex = myMesh.VerticesToTypedArray();
//get the 32bit and 16bit indices
int[] indices32bit;
ushort[] indices16bit;
myMesh.IndicesToArray(out indices32bit);
myMesh.IndicesToArray(out indices16bit);
using (MemoryStream ms = new MemoryStream())
{
//or we can write the vertex directly into stream like:
myMesh.WriteVerticesTo(ms);
//the indice data can be directly write to stream, we support 32-bit and 16-bit indice.
myMesh.Write16bIndicesTo(ms);
myMesh.Write32bIndicesTo(ms);
}
// Point node to the Mesh geometry
cubeNode.Entity = sphere;
// Add Node to a scene
scene.RootNode.ChildNodes.Add(cubeNode);
// The path to the documents directory.
string MyDir = RunExamples.GetDataDir() + RunExamples.GetOutputFilePath("SphereToTriangleMeshCustomMemoryLayoutScene.fbx");
// Save 3D scene in the supported file formats
scene.Save(MyDir, FileFormat.FBX7400ASCII);
Console.WriteLine("Indices = {0}, Actual vertices = {1}, vertices before merging = {2}", myMesh.IndicesCount, myMesh.VerticesCount, myMesh.UnmergedVerticesCount);
Console.WriteLine("Total bytes of vertices in memory {0}bytes", myMesh.VerticesSizeInBytes);
Console.WriteLine("\n Converted a Sphere mesh to triangle mesh with custom memory layout of the vertex successfully.\nFile saved at " + MyDir);
}
public void BuildSingle_CreatesValidTriMesh()
{
var data = new TriMeshData();
var vertices = new float[]
{
-1, -1, 0,
1, -1, 0,
1, 1, 0,
-1, 1, 0
};
var indices = new int[] { 0, 1, 2, 0, 2, 3 };
data.BuildSingle(vertices, indices);
using (var triMesh = new TriMesh(data))
{
Assert.AreEqual(indices.Length / 3, triMesh.TriangleCount);
}
}
void TriangulateEdgeStrip(TriMesh mesh, EdgeVertices e1, Color c1, EdgeVertices e2, Color c2, bool isRiverInDir)
{
mesh.AddQuad(e1.v1, e1.v2, e2.v1, e2.v2);
mesh.AddQuadColor(c1, c2);
if (isRiverInDir)
{
Vector3 t = new Vector3(0, TriMetrics.waterElevationOffset, 0);
rivers.AddQuad(e1.v2 + t, e1.v4 + t, e2.v2 + t, e2.v4 + t);
rivers.AddQuadColor(Color.blue, Color.blue);
}
else
{
mesh.AddQuad(e1.v2, e1.v4, e2.v2, e2.v4);
mesh.AddQuadColor(c1, c2);
}
mesh.AddQuad(e1.v4, e1.v5, e2.v4, e2.v5);
mesh.AddQuadColor(c1, c2);
}
/// <summary>
/// open binary or ascii file
/// </summary>
/// <param name="fileName"></param>
/// <returns>list of triangles</returns>
public TriMesh Open(string fileName)
{
var trimesh = new TriMesh();
string solid = "SOLID";
bool isAscii = false;
int count = 80;
int start = 0;
char[] buffer = new char[80];
string bufferStr = "";
System.IO.StreamReader sr = new System.IO.StreamReader(fileName);
try
{
sr.Read(buffer, start, count);
sr.Close();
foreach (char c in buffer)
{
if (char.IsLetter(c))
{
bufferStr += c.ToString();
}
bufferStr = bufferStr.ToUpper();
}
isAscii = bufferStr.Contains(solid);
if (isAscii)
{
trimesh = openAscii(fileName);
}
else
{
trimesh = openBinary(fileName);
}
return(trimesh);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// save list of Trangles to STL ASCII file
/// </summary>
/// <param name="triangles"></param>
/// <param name="fileName"></param>
static public void SaveBinary(TriMesh trimesh, string fileName)
{
try
{
string headerstr = "binary stl file";
using (System.IO.BinaryWriter bw = new System.IO.BinaryWriter(System.IO.File.Open(fileName, System.IO.FileMode.Create)))
{
char[] header = new char[80];
char[] headerArr = headerstr.ToCharArray();
for (int i = 0; i < headerArr.Length; i++)
{
header[i] = headerArr[i];
}
bw.Write(header, 0, 80);
UInt32 tricB = (UInt32)trimesh.Count;
bw.Write(tricB);
foreach (Triangle tri in trimesh)
{
bw.Write((float)tri.Normal.X);
bw.Write((float)tri.Normal.Y);
bw.Write((float)tri.Normal.Z);
bw.Write((float)tri.Vertices[0].X);
bw.Write((float)tri.Vertices[0].Y);
bw.Write((float)tri.Vertices[0].Z);
bw.Write((float)tri.Vertices[1].X);
bw.Write((float)tri.Vertices[1].Y);
bw.Write((float)tri.Vertices[1].Z);
bw.Write((float)tri.Vertices[2].X);
bw.Write((float)tri.Vertices[2].Y);
bw.Write((float)tri.Vertices[2].Z);
bw.Write((UInt16)0);
}
}
}
catch (Exception)
{
throw;
}
}
private TriMesh openAscii(string fileName)
{
var file = openTextFile(fileName);
var triMesh = new TriMesh();
try
{
UInt32 triIndex = 0;
for (int i = 0; i < file.Count; i++)
{
if (file[i].Contains("normal"))
{
triMesh.Add(new Triangle(parseVertex(file[i + 2]), parseVertex(file[i + 3]), parseVertex(file[i + 4]), parseVector(file[i]), triIndex));
triIndex++;
}
}
int triCount = triMesh.Count;
return(triMesh);
}
catch (Exception)
{
throw;
}
}
public TriMeshDual(TriMesh mesh)
{
this.mesh = mesh;
}
// Uber hax, fix with maths later
void LayFacesFlat(SLOObject sloObject)
{
// reference to faces from the object
List <SLO_Face> faces = sloObject.Faces;
GameObject parent = new GameObject("_Flat faces parent");
parent.transform.position = Vector3.right * 5;
TriMesh[] flatFaces = new TriMesh[faces.Count];
float xPos = 7;
float yPos = 0;
float prevTriDist = 0;
float largestTri = 0;
// For all faces
for (int i = 0; i < faces.Count; i++)
{
// Create a new trimesh
TriMesh newTriMesh = new GameObject(parent.name + " - Flat face " + i).AddComponent <TriMesh>();
newTriMesh.gameObject.layer = 8;
Vector3 midPoint = (faces[i].Join0.transform.position + faces[i].Join1.transform.position + faces[i].Join2.transform.position) / 3f;
newTriMesh.CreateTri(
newTriMesh.transform.TransformPoint(faces[i].Join0.transform.position - midPoint),
newTriMesh.transform.TransformPoint(faces[i].Join1.transform.position - midPoint),
newTriMesh.transform.TransformPoint(faces[i].Join2.transform.position - midPoint),
TriMesh.Extrusion.None);
// Apply material
newTriMesh.GetComponent <MeshRenderer>().material = SLOResourceManager.Instance.m_MatFace;
#region Spacing and placement
// Get max vertex distance on x to make sure next tri is spaced accordingly
float maxVertDistance = 0;
for (int j = 0; j < 3; j++)
{
float dist = Vector3.Distance(newTriMesh.transform.position, newTriMesh.transform.TransformPoint(newTriMesh.BaseVerts[j]));
if (dist > maxVertDistance)
{
maxVertDistance = dist;
}
}
xPos += maxVertDistance + prevTriDist;
prevTriDist = maxVertDistance;
newTriMesh.transform.rotation = Quaternion.FromToRotation(faces[i].Normal, -Vector3.forward);
if (maxVertDistance > largestTri)
{
largestTri = maxVertDistance;
}
if (i == faces.Count / 3)
{
xPos = 7;
yPos = largestTri * 2f;
}
else if (i == (int)(faces.Count / 3) * 2)
{
xPos = 7;
yPos = largestTri * 4f;
}
Vector3 offset = new Vector3(xPos, yPos, -1);
newTriMesh.transform.position = offset;
newTriMesh.transform.parent = parent.transform;
#endregion
TextMesh edgeLength0 = new GameObject("Textmesh").AddComponent <TextMesh>();
edgeLength0.name = "Edge text v0-v1";
edgeLength0.gameObject.layer = 8;
edgeLength0.transform.SetParent(newTriMesh.transform);
edgeLength0.transform.position = newTriMesh.Edge01MidPoint;
edgeLength0.transform.localScale = Vector3.one * .02f;
edgeLength0.text = faces[i].Edge2Length.ToString("##");
TextMesh edgeLength1 = new GameObject("Textmesh").AddComponent <TextMesh>();
edgeLength1.name = "Edge text v1-v2";
edgeLength1.gameObject.layer = 8;
edgeLength1.transform.SetParent(newTriMesh.transform);
edgeLength1.transform.position = newTriMesh.Edge12MidPoint;
edgeLength1.transform.localScale = Vector3.one * .02f;
edgeLength1.text = faces[i].Edge1Length.ToString("##");
TextMesh edgeLength2 = new GameObject("Textmesh").AddComponent <TextMesh>();
edgeLength2.name = "Edge text v2-v0";
edgeLength2.gameObject.layer = 8;
edgeLength2.transform.SetParent(newTriMesh.transform);
edgeLength2.transform.position = newTriMesh.Edge20MidPoint;
edgeLength2.transform.localScale = Vector3.one * .02f;
edgeLength2.text = faces[i].Edge0Length.ToString("##");
flatFaces[i] = newTriMesh;
}
}
// Use this for initialization
public void Init(SLOObject sloObj, SLO_Join j0, SLO_Join j1, SLO_Join j2, Material mat, bool makeInner, bool makeOuter)
{
#region Initialization of references
// Sets reference to SLO object
m_Object = sloObj;
// Set name
gameObject.name = "Tab";
// Setup the connect joins
m_BaseJoin = j0;
m_ConnctedJoin0 = j1;
m_ConnctedJoin1 = j2;
// Find arms
for (int i = 0; i < m_BaseJoin.m_Arms.Count; i++)
{
if (m_BaseJoin.m_Arms[i].LookAtJoin == m_ConnctedJoin0)
{
m_Arm12 = m_BaseJoin.m_Arms[i];
}
if (m_BaseJoin.m_Arms[i].LookAtJoin == m_ConnctedJoin1)
{
m_Arm13 = m_BaseJoin.m_Arms[i];
}
}
#endregion
#region Calculations
m_InnerVerts = TriMeshTest1.FindInnerVerts(m_BaseJoin.transform.position, m_ConnctedJoin0.transform.position, m_ConnctedJoin1.transform.position, (m_BaseJoin.Diameter / 2f) * .001f, m_BaseJoin.Length * .001f);
Vector3 v0 = m_InnerVerts[0];
Vector3 v1 = m_InnerVerts[1];
Vector3 v2 = m_InnerVerts[2];
// Get the normal of the triangle
m_Normal = Vector3.Cross(v1 - v0, v2 - v0).normalized;
// calculate the offset based on spacing
//Vector3 normalOffset = m_Normal * ((SpacingRadius / 2f)) * .001f;
#endregion
if (makeInner)
{
// FIND INNER VERTS HERE
m_TabInner = new GameObject().AddComponent <TriMesh>() as TriMesh;
m_TabInner.name = "Tab Inner";
m_TabInner.transform.SetParent(transform);
m_TabInner.transform.position = Vector3.zero;
m_TabInner.transform.rotation = Quaternion.identity;
m_TabInner.m_Mat = mat;
m_TabInner.m_Thickness = .001f;
m_TabInner.CreateTri(v0, v1, v2, TriMesh.Extrusion.Center);
}
if (makeOuter)
{
m_TabOuter = new GameObject().AddComponent <TriMesh>() as TriMesh;
m_TabOuter.name = "Tab Outer";
m_TabOuter.transform.SetParent(transform);
m_TabOuter.m_Mat = mat;
m_TabOuter.m_Thickness = .001f;
m_TabOuter.CreateTri(v0, v1, v2, TriMesh.Extrusion.Center);
}
//transform.SetParent (m_BaseJoin.transform );
}
public CornerCuttingSimplication(TriMesh mesh)
: base(mesh)
{
}
