private void createPlaneBrep()
{
Plane plane = new Plane();
if (type == XYZPlanes.YZ)
{
plane = new Plane(origin, new Rhino.Geometry.Vector3d(1, 0, 0));
}
else if (type == XYZPlanes.XZ)
{
plane = new Plane(origin, new Rhino.Geometry.Vector3d(0, 1, 0));
}
else if (type == XYZPlanes.XY)
{
plane = new Plane(origin, new Rhino.Geometry.Vector3d(0, 0, 1));
}
PlaneSurface plane_surface = new PlaneSurface(plane, new Interval(-size, size), new Interval(-size, size));
Brep planeBrep = Brep.CreateFromSurface(plane_surface);
if (planeBrep != null)
{
Guid guid = UtilOld.addRhinoObjectSceneNode(ref mScene, ref planeBrep, ref mesh_m, "plane" + type.ToString(), out planeSN, true);
planeObjRef = new Rhino.DocObjects.ObjRef(guid);
}
}
private void calibrationVRtoRobot()
{
Vector3 vrPoint = Util.Math.GetTranslationVector3(UtilOld.getControllerTipPosition(ref mScene, true));
vrCallibrationPoints.Add(vrPoint);
Rhino.RhinoApp.WriteLine("add vrCallibrationPoints: " + vrPoint.ToString());
UtilOld.MarkPoint(ref mScene.staticGeometry, vrPoint, 1, 1, 0);
if (vrCallibrationPoints.Count == 8)
{
Util.Math.solveForAffineTransformOpenCV(vrCallibrationPoints, robotCallibrationPoints, ref mScene.vrToRobot);
foreach (Vector3 v in robotCallibrationPoints)
{
Vector4 v4 = new Vector4(v.X, v.Y, v.Z, 1);
v4 = mScene.vrToRobot.Inverted() * v4;
UtilOld.MarkPoint(ref mScene.staticGeometry, new Vector3(v4.X, v4.Y, v4.Z), 0, 1, 0);
}
Rhino.RhinoApp.WriteLine(mScene.vrToRobot.ToString());
Rhino.RhinoApp.WriteLine(mScene.vrToRobot.M11 + "f, " + mScene.vrToRobot.M12 + "f, " + mScene.vrToRobot.M13 + "f, " + mScene.vrToRobot.M14 + "f,");
Rhino.RhinoApp.WriteLine(mScene.vrToRobot.M21 + "f, " + mScene.vrToRobot.M22 + "f, " + mScene.vrToRobot.M23 + "f, " + mScene.vrToRobot.M24 + "f,");
Rhino.RhinoApp.WriteLine(mScene.vrToRobot.M31 + "f, " + mScene.vrToRobot.M32 + "f, " + mScene.vrToRobot.M33 + "f, " + mScene.vrToRobot.M34 + "f,");
Rhino.RhinoApp.WriteLine(mScene.vrToRobot.M41 + "f, " + mScene.vrToRobot.M42 + "f, " + mScene.vrToRobot.M43 + "f, " + mScene.vrToRobot.M44 + "f");
robotCallibrationPoints.Clear();
vrCallibrationPoints.Clear();
}
}
private void clearDrawingPop()
{
if (drawnType == DrawnType.Plane)
{
//resetPlane
mScene.xyPlane.resetOrgin();
mScene.yzPlane.resetOrgin();
mScene.xzPlane.resetOrgin();
UtilOld.setPlaneAlpha(ref mScene, 0.0f);
}
//clear the curve and points
UtilOld.removeSceneNode(ref mScene, ref strokeSN);
UtilOld.removeSceneNode(ref mScene, ref drawPoint);
if (snapPointSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref snapPointSN);
}
//remove railPlane
if (drawnType == DrawnType.Reference && railPlaneSN != null)
{
//TODO-if we remove here, press undo will casue an error
UtilOld.removeRhinoObjectSceneNode(ref mScene, ref railPlaneSN);
railPlaneSN = null;
}
if (renderObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref renderObjSN);
renderObjSN = null;
}
}
public void addEdge(OpenTK.Vector3 p1, Vector3 p2)
{
mPoints.Add(p1);
mPoints.Add(p2);
//when visualizing, stroke is in tableGeometry so we need to apply tableGeomeotry.transfrom inverted first
p1 = UtilOld.transformPoint(mScene.tableGeometry.transform.Inverted(), p1);
p2 = UtilOld.transformPoint(mScene.tableGeometry.transform.Inverted(), p2);
vertices_array.Add(p1.X);
vertices_array.Add(p1.Y);
vertices_array.Add(p1.Z);
mNumPoints++;
vertices_array.Add(p2.X);
vertices_array.Add(p2.Y);
vertices_array.Add(p2.Z);
mNumPoints++;
mGeometry = vertices_array.ToArray();
//mNumPrimitives = mNumPoints -1 ;
mNumPrimitives = mNumPoints / 2;
if (mPoints.Count % 2 == 0)
{
indices_array.Add(mNumPoints - 2);
indices_array.Add(mNumPoints - 1);
mGeometryIndices = indices_array.ToArray();
}
}
protected void registerPositon(uint deviceIndex)
{
// Find and record position of controller
Matrix4 M = UtilOld.getLeftControllerTipPosition(ref mScene, mScene.leftControllerIdx == deviceIndex);
Vector3 origin = UtilOld.transformPoint(M, new Vector3(0, 0, 0));
if (mPoints != null)
{
mPoints.Add(origin);
}
if (mPoses != null)
{
mPoses.Add(M);
}
Rhino.RhinoApp.WriteLine("RegisterPoint: " + origin.ToString());
// Add a Point Rep object to the mScene
Geometry.Geometry point = new Geometry.PointMarker(new Vector3());
Material.Material material = new Material.SingleColorMaterial(0f, .5f, 1f, 1f);
SceneNode sceneNode = new SceneNode("point", ref point, ref material);
sceneNode.transform = M;
mScene.tableGeometry.add(ref sceneNode);
}
public MarkingMenu(ref Scene scene, MenuLayout2 layout = MenuLayout2.MainMenu) : base(ref scene)
{
mScene = scene;
mLayout = layout;
mNumSectors = getNumSectors(layout);
mFirstSectorOffsetAngle = getAngularMenuOffset(mNumSectors);
mCurrentSelection = -1;
if (scene.isOculus)
{
mMinSelectionRadius = 0.2f;
mOuterSelectionRadius = 0.8f;
}
else
{
mMinSelectionRadius = 0.4f;
mOuterSelectionRadius = 0.6f;
}
Geometry.Geometry g = new Geometry.Geometry("C:\\workspace\\SparrowHawk\\src\\resources\\circle.obj");
switch (mLayout)
{
}
radialMenuMat = new Material.RadialMenuMaterial(mScene.rhinoDoc, getTexturePath(mLayout));
mSceneNode = new SceneNode("MarkingMenu", ref g, ref radialMenuMat);
mSceneNode.transform = new OpenTK.Matrix4(2, 0, 0, 0,
0, 0, -2, 0,
0, 2, 0, 0,
0, 0, 0, 1);
UtilOld.showLaser(ref mScene, false);
}
public void modelCompleted(IAsyncResult R)
{
if (dynamicBrep != null)
{
if (modelName == "tprint")
{
UtilOld.updateSceneNode(ref mScene, dynamicBrep, ref mesh_m, modelName, ref renderObjSN);
}
//fix the issue, update mSceneNode
/*
* if (currentState == State.READY)
* {
* mScene.iCurveList.Clear();
* mScene.iCurveList = localListCurve;
* afterCurveCount = mScene.iCurveList.Count;
* mScene.pushInteractionFromChain();
* }
*/
}
dynamicBrep = null;
backgroundStart = false;
displacement = 0;
if (currentState == State.END)
{
mScene.pushInteractionFromChain();
}
}
protected void notifyRobotIfSafe()
{
//Vector3 tableOrigin = Util.transformPoint(mScene.vrToRobot.Inverted(), new Vector3(0, 0, 0));
Vector3 tableOrigin = UtilOld.platformToVRPoint(ref mScene, new Vector3(0, 0, 0));
Vector3 headOrigin = UtilOld.transformPoint(mScene.mHMDPose.Inverted(), new Vector3(0, 0, 0));
Vector3 displacement = tableOrigin - headOrigin;
displacement.Y = 0;
if (displacement.Length > 1.0f && isUserIn == true)
{
Rhino.DocObjects.RhinoObject rhobj = mScene.rhinoDoc.Objects.Find(uGuid);
rhobj.Attributes.Name = "user:out";
rhobj.CommitChanges();
isUserIn = false;
Rhino.RhinoApp.WriteLine("User out. " + displacement.Length);
}
else if (displacement.Length < 1.0f && isUserIn == false)
{
Rhino.DocObjects.RhinoObject rhobj = mScene.rhinoDoc.Objects.Find(uGuid);
rhobj.Attributes.Name = "user:in";
rhobj.CommitChanges();
isUserIn = true;
Rhino.RhinoApp.WriteLine("User in. " + displacement.Length);
}
}
public void resetOrgin()
{
Point3d newOrigin = planeObjRef.Object().Geometry.GetBoundingBox(true).Center;
Matrix4 transMInvert = Matrix4.CreateTranslation(new Vector3(0f - (float)newOrigin.X, 0f - (float)newOrigin.Y, 0f - (float)newOrigin.Z));
transMInvert.Transpose();
UtilOld.updateRhinoObjectSceneNode(ref mScene, ref planeObjRef, UtilOld.OpenTKToRhinoTransform(transMInvert));
}
private void clearDrawingLeaveTop()
{
if (previewObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref previewObjSN);
previewObjSN = null;
}
}
Matrix4 GetHMDMatrixPoseEye(ref Valve.VR.CVRSystem HMD, Valve.VR.EVREye eye)
{
if (HMD == null)
{
return(new Matrix4());
}
Valve.VR.HmdMatrix34_t M = HMD.GetEyeToHeadTransform(eye);
return(UtilOld.steamVRMatrixToMatrix4(M).Inverted());
}
public void simplifyCurve(ref List <Vector3> curvePoints)
{
//clear list first
simplifiedCurvePoints.Clear();
reducePoints.Clear();
float pointReductionTubeWidth = 0.002f; //0.002
reducePoints = DouglasPeucker(ref curvePoints, 0, curvePoints.Count - 1, pointReductionTubeWidth);
//Rhino.RhinoApp.WriteLine("reduce points from" + curvePoints.Count + " to " + reducePoints.Count);
//TODO- the curve isn't correct while drawing
for (int i = 0; i < reducePoints.Count; i++)
{
simplifiedCurvePoints.Add(UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, reducePoints[i])));
}
if (simplifiedCurvePoints.Count >= 2) //TODO: might need 8 for closecurve check
{
int order = 3;
if (isClosed)
{
while (order >= 1)
{
simplifiedCurve = Rhino.Geometry.NurbsCurve.Create(true, order, simplifiedCurvePoints.ToArray());
if (simplifiedCurve != null)
{
break;
}
order--;
}
}
else
{
//null check
while (order >= 1)
{
simplifiedCurve = Rhino.Geometry.NurbsCurve.Create(false, order, simplifiedCurvePoints.ToArray());
if (simplifiedCurve != null)
{
break;
}
order--;
}
}
//reduced control points
if (simplifiedCurve.Points.Count > 5)
{
simplifiedCurve = simplifiedCurve.Rebuild(5, simplifiedCurve.Degree, false);
}
else
{
simplifiedCurve = simplifiedCurve.Rebuild(simplifiedCurve.Points.Count, simplifiedCurve.Degree, false);
}
}
}
Matrix4 GetHMDMatrixProjectionEye(ref Valve.VR.CVRSystem HMD, Valve.VR.EVREye eye)
{
if (HMD == null)
{
return(new Matrix4());
}
Valve.VR.HmdMatrix44_t M = HMD.GetProjectionMatrix(eye, mNearClip, mFarClip);
return(UtilOld.steamVRMatrixToMatrix4(M));
}
protected override void onClickOculusTrigger(ref VREvent_t vrEvent)
{
OpenTK.Vector4 controller_p = UtilOld.getLeftControllerTipPosition(ref mScene, true) * new OpenTK.Vector4(0, 0, 0, 1);
Point3d controller_pRhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)));
Rhino.DocObjects.RhinoObject rhobj = mScene.rhinoDoc.Objects.Find(cutPGuid);
rhobj.Attributes.Name = "cut:" + controller_pRhino.X + ":" + controller_pRhino.Y + ":" + controller_pRhino.Z;
rhobj.CommitChanges();
Rhino.RhinoApp.WriteLine(rhobj.Attributes.Name);
}
private void initMeshGeometry(ref Mesh triMesh)
{
//get faces from mesh
List <MeshFace> faces = new List <MeshFace>();
List <int> indices_array = new List <int>();
foreach (MeshFace face in triMesh.Faces)
{
faces.Add(face);
//TODO-loop throgn the original mesh to optimize
if (face.IsQuad)
{
Rhino.RhinoApp.WriteLine("Triangulate error.");
}
else
{
indices_array.Add(face.A);
indices_array.Add(face.B);
indices_array.Add(face.C);
}
}
mGeometryIndices = indices_array.ToArray();
//get vertices from mesh
// rhino coordinate system is different from OpenGL
List <Point3d> vertices = new List <Point3d>();
List <float> vertices_array = new List <float>();
OpenTK.Matrix4 transToOrigin = new OpenTK.Matrix4();
foreach (Point3d vertex in triMesh.Vertices)
{
vertices.Add(vertex);
OpenTK.Vector3 rp = new OpenTK.Vector3((float)vertex.X, (float)vertex.Y, (float)vertex.Z);
/*
* if(transM != OpenTK.Matrix4.Identity)
* {
* rp = Util.transformPoint(transM, rp);
*
* }*/
//seperate the data and visualization
OpenTK.Vector3 p = UtilOld.platformToVRPoint(ref mScene, rp);
vertices_array.Add(p.X);
vertices_array.Add(p.Y);
vertices_array.Add(p.Z);
}
mGeometry = vertices_array.ToArray();
mNumPrimitives = mGeometryIndices.Length / 3;
primitiveType = OpenTK.Graphics.OpenGL4.BeginMode.Triangles;
}
public override void init()
{
resetVariables();
//support undo function
if (mScene != null && (afterCurveCount - beforeCurveCount) > 0)
{
if (mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.CurveOnObj.ToString()) != "")
{
Guid curveOnObjId = new Guid(mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.CurveOnObj.ToString()));
ObjRef curveOnObjRef = new ObjRef(curveOnObjId);
if (curveOnObjRef.Object().Attributes.Name.Contains("MoveP"))
{
UtilOld.removeRhinoObject(ref mScene, curveOnObjRef.ObjectId);
}
}
mScene.iCurveList.RemoveAt(mScene.iCurveList.Count - 1);
pointOnObjRef = null;
}
if (drawnType != DrawnType.In3D && drawnType != DrawnType.None)
{
UtilOld.showLaser(ref mScene, true);
if (drawnType == DrawnType.Plane)
{
UtilOld.setPlaneAlpha(ref mScene, 0.4f);
}
//init rayCastingObjs
Rhino.DocObjects.ObjectEnumeratorSettings settings = new Rhino.DocObjects.ObjectEnumeratorSettings();
settings.ObjectTypeFilter = Rhino.DocObjects.ObjectType.Brep;
foreach (Rhino.DocObjects.RhinoObject rhObj in mScene.rhinoDoc.Objects.GetObjectList(settings))
{
bool b1 = (drawnType == DrawnType.Plane) && rhObj.Attributes.Name.Contains("plane");
bool b2 = (drawnType == DrawnType.Surface) && (rhObj.Attributes.Name.Contains("brepMesh") || rhObj.Attributes.Name.Contains("aprint") || rhObj.Attributes.Name.Contains("patchSurface"));
bool b3 = (drawnType == DrawnType.Reference) && rhObj.Attributes.Name.Contains("railPlane");
if (b1 || b2 || b3)
{
rayCastingObjs.Add(new ObjRef(rhObj.Id));
}
}
Geometry.Geometry geo = new Geometry.DrawPointMarker(new OpenTK.Vector3(0, 0, 0));
Material.Material m = new Material.SingleColorMaterial(1, 1, 1, 0);
drawPoint = new SceneNode("drawPoint", ref geo, ref m);
UtilOld.addSceneNode(ref mScene, ref drawPoint);
}
else
{
UtilOld.showLaser(ref mScene, false);
}
}
private void initScene()
{
//OpenCV Cube init
objectList = new List <MCvPoint3D32f>();
for (int i = 0; i < _height; i++)
{
for (int j = 0; j < _width; j++)
{
objectList.Add(new MCvPoint3D32f(j * _squareSize, i * _squareSize, 0.0F));
}
}
axisPoints = new List <MCvPoint3D32f>();
axisPoints.Add(new MCvPoint3D32f(0.0f, 0.0f, 0.0f));
axisPoints.Add(new MCvPoint3D32f(3.0f, 0.0f, 0.0f));
axisPoints.Add(new MCvPoint3D32f(0.0f, 3.0f, 0.0f));
axisPoints.Add(new MCvPoint3D32f(0.0f, 0.0f, -3.0f));
cubePoints = new List <MCvPoint3D32f>();
cubePoints.Add(new MCvPoint3D32f(0.0f, 0.0f, 0.0f));
cubePoints.Add(new MCvPoint3D32f(0.0f, 3.0f, 0.0f));
cubePoints.Add(new MCvPoint3D32f(3.0f, 3.0f, 0.0f));
cubePoints.Add(new MCvPoint3D32f(3.0f, 0.0f, 0.0f));
cubePoints.Add(new MCvPoint3D32f(0.0f, 0.0f, -3.0f));
cubePoints.Add(new MCvPoint3D32f(0.0f, 3.0f, -3.0f));
cubePoints.Add(new MCvPoint3D32f(3.0f, 3.0f, -3.0f));
cubePoints.Add(new MCvPoint3D32f(3.0f, 0.0f, -3.0f));
//OpenGL objects init
marker_cube_g = new Geometry.CubeGeometry(3.0f, 3.0f, -3.0f);
marker_cube_m = new Material.TextureMaterial(mScene.rhinoDoc, "texture.jpg", false);
controller_cube_g = new Geometry.CubeGeometry(0.05f, 0.05f, -0.05f);
controller_cube_m = new Material.TextureMaterial(mScene.rhinoDoc, "texture.jpg", false);
//TODO- how to deal with controllerPose ?
//SceneNode controller_cube = new SceneNode("controller_cube", ref controller_cube_g, ref controller_cube_m); ;
//mScene.staticGeometry.add(ref controller_cube);
//we need eyepose before calibration
if (mHMD == null)
{
mEyePosLeft = new Matrix4();
}
Valve.VR.HmdMatrix34_t M_L = mHMD.GetEyeToHeadTransform(Valve.VR.EVREye.Eye_Left);
mEyePosLeft = UtilOld.steamVRMatrixToMatrix4(M_L).Inverted();
Valve.VR.HmdMatrix34_t M_R = mHMD.GetEyeToHeadTransform(Valve.VR.EVREye.Eye_Right);
mEyePosRight = UtilOld.steamVRMatrixToMatrix4(M_R).Inverted();
}
private void clearDrawingPop()
{
if (previewObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref previewObjSN);
previewObjSN = null;
}
if (renderObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref renderObjSN);
renderObjSN = null;
}
}
public void getMatrixHeadtoCamera(uint primaryDeviceIndex)
{
Vector3 center = new Vector3(0, 0, 0);
if (vr_points.Count < 8)
{
//only use left controller for the calibration
center = Math.GetTranslationVector3(UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx));
Rhino.RhinoApp.WriteLine(center.ToString());
vr_points.Add(new MCvPoint3D32f(center.X, center.Y, center.Z));
calib_status = 0;
}
else
{
marker_points.Add(new MCvPoint3D32f(0, 0, 0));
marker_points.Add(new MCvPoint3D32f(3, 0, 0));
marker_points.Add(new MCvPoint3D32f(3, 3, 0));
marker_points.Add(new MCvPoint3D32f(0, 3, 0));
marker_points.Add(new MCvPoint3D32f(0, 0, -4.0f));
marker_points.Add(new MCvPoint3D32f(3.0f, 0, -4.0f));
marker_points.Add(new MCvPoint3D32f(3.0f, 3.0f, -4.0f));
marker_points.Add(new MCvPoint3D32f(0, 3.0f, -4.0f));
CvInvoke.EstimateAffine3D(vr_points.ToArray(), marker_points.ToArray(), out mVRtoMarker, out inliers, 3, 0.99);
glmVRtoMarker = new Matrix4(
(float)mVRtoMarker[0, 0], (float)mVRtoMarker[0, 1], (float)mVRtoMarker[0, 2], (float)mVRtoMarker[0, 3],
(float)mVRtoMarker[1, 0], (float)mVRtoMarker[1, 1], (float)mVRtoMarker[1, 2], (float)mVRtoMarker[1, 3],
(float)mVRtoMarker[2, 0], (float)mVRtoMarker[2, 1], (float)mVRtoMarker[2, 2], (float)mVRtoMarker[2, 3],
0, 0, 0, 1
);
calib_status = 1;
Rhino.RhinoApp.WriteLine("VRtoMarker matrix");
Rhino.RhinoApp.WriteLine(glmVRtoMarker.ToString());
vr_points.Clear();
marker_points.Clear();
//Thread start to calculate the view matrix
ThreadEnd = false;
UpdateThread = new Thread(new ThreadStart(Camera_UpdateThread));
UpdateThread.Start();
}
}
public CreatePatch(ref Scene s) : base(ref s)
{
mScene = s;
stroke_g = new Geometry.GeometryStroke(ref mScene);
stroke_m = new Material.SingleColorMaterial(1, 0, 0, 1);
mesh_m = new Material.RGBNormalMaterial(.5f);
currentState = State.READY;
//TODO-support both controllers
if (mScene.mIsLefty)
{
primaryDeviceIndex = (uint)mScene.leftControllerIdx;
}
else
{
primaryDeviceIndex = (uint)mScene.rightControllerIdx;
}
UtilOld.showLaser(ref mScene, false);
}
public override void draw(ref Geometry.Geometry g, ref Matrix4 model, ref Matrix4 vp)
{
UtilOld.depthSort(model * vp, g);
GL.Disable(EnableCap.DepthTest);
GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
GL.Enable(EnableCap.Blend);
Matrix4 modelIT = model.Inverted();
modelIT.Transpose();
int dim;
if (g.primitiveType == BeginMode.Lines)
{
dim = 2;
}
else
{
dim = 3;
}
mShader.bind();
mShader.uploadAttrib <int>("indices", g.mGeometryIndices.Length, dim, 4, VertexAttribPointerType.UnsignedInt, false, ref g.mGeometryIndices, 0);
mShader.uploadAttrib <float>("position", g.mGeometry.Count(), 3, 4, VertexAttribPointerType.Float, false, ref g.mGeometry, 0);
if (g.mNormals == null)
{
Math.addNormalsToMesh(g);
}
if (g.mNormals != null)
{
mShader.uploadAttrib <float>("normal", g.mNormals.Count(), 3, 4, VertexAttribPointerType.Float, false, ref g.mNormals, 0);
}
GL.Uniform4(mShader.uniform("color"), mColor);
GL.UniformMatrix4(mShader.uniform("modelTransform"), true, ref model);
GL.UniformMatrix4(mShader.uniform("viewProjTransform"), false, ref vp); // TODO: Fix this
GL.ProgramUniformMatrix4(mShader.mProgramShader, mShader.uniform("modelInvTrans"), true, ref modelIT);
GL.Uniform3(mShader.uniform("lightInt"), 3 * MAX_LIGHT_COUNT, ref lightIntensities[0].X);
GL.Uniform3(mShader.uniform("lightPos"), 3 * MAX_LIGHT_COUNT, ref lightPositions[0].X);
mShader.drawIndexed(g.primitiveType, 0, g.mNumPrimitives);
GL.Disable(EnableCap.Blend);
GL.Enable(EnableCap.DepthTest);
}
public void renderCurve()
{
//reduce the points in the curve first
simplifyCurve(ref ((Geometry.GeometryStroke)(stroke_g)).mPoints);
foreach (OpenTK.Vector3 point in reducePoints)
{
// -y_rhino = z_gl, z_rhino = y_gl and unit conversion
// OpenTK.Vector3 p = Util.transformPoint(Util.mGLToRhino, point*1000);
//curvePoints.Add(new Point3d(p.X, p.Y, p.Z));
curvePoints.Add(UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, point)));
allPoints.Add(new Point(UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, point))));
}
//Rhino CreateInterpolatedCurve and CreatePlanarBreps
if (curvePoints.Count >= 2)
{
curve = Rhino.Geometry.NurbsCurve.Create(true, 3, curvePoints.ToArray());
curvelist.Add(curve);
}
}
public void renderPatch()
{
//Brep patchSurface = Brep.CreatePatch(curvelist, 4, 4, mScene.rhinoDoc.ModelAbsoluteTolerance);
Brep patchSurface = Brep.CreatePatch(allPoints, 10, 10, mScene.rhinoDoc.ModelAbsoluteTolerance);
Guid planGuid = UtilOld.addRhinoObjectSceneNode(ref mScene, ref patchSurface, ref mesh_m, "patchSurface", out planeSN);
//clear profile curves
foreach (Guid id in curveGuids)
{
foreach (SceneNode sn in mScene.tableGeometry.children)
{
if (sn.guid == id)
{
mScene.tableGeometry.children.Remove(sn);
break;
}
}
}
allPoints.Clear();
curvelist.Clear();
}
public override void init()
{
resetVariables();
//support undo function
if (mScene != null && (afterCurveCount - beforeCurveCount) > 0)
{
//don't have curveOnObject don't need to do anything
if (mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.CurveOnObj.ToString()) != "")
{
Guid curveOnObjId = new Guid(mScene.iCurveList[mScene.iCurveList.Count - 1].GetUserString(CurveData.CurveOnObj.ToString()));
ObjRef curveOnObjRef = new ObjRef(curveOnObjId);
if (curveOnObjRef.Object().Attributes.Name.Contains("MoveP"))
{
UtilOld.removeRhinoObject(ref mScene, curveOnObjRef.ObjectId);
}
}
mScene.iCurveList.RemoveAt(mScene.iCurveList.Count - 1);
if (renderObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref renderObjSN);
renderObjSN = null;
}
}
// Set initial timeout that cannot be skipped to prevent double selections.
mInitialSelectOKTime = mScene.gameTime + defaultInitialDelay;
if (drawnType == DrawnType.Reference)
{
isProjection = true;
}
else
{
isProjection = false;
}
UtilOld.showLaser(ref mScene, false);
}
public static List <OpenTK.Vector3> DouglasPeucker(ref List <OpenTK.Vector3> points, int startIndex, int lastIndex, float epsilon)
{
float dmax = 0f;
int index = startIndex;
for (int i = index + 1; i < lastIndex; ++i)
{
float d = UtilOld.PointLineDistance(points[i], points[startIndex], points[lastIndex]);
if (d > dmax)
{
index = i;
dmax = d;
}
}
if (dmax > epsilon)
{
List <OpenTK.Vector3> res1 = DouglasPeucker(ref points, startIndex, index, epsilon);
List <OpenTK.Vector3> res2 = DouglasPeucker(ref points, index, lastIndex, epsilon);
//watch out the coordinate system
List <OpenTK.Vector3> finalRes = new List <OpenTK.Vector3>();
for (int i = 0; i < res1.Count - 1; ++i)
{
finalRes.Add(res1[i]);
}
for (int i = 0; i < res2.Count; ++i)
{
finalRes.Add(res2[i]);
}
return(finalRes);
}
else
{
return(new List <OpenTK.Vector3>(new OpenTK.Vector3[] { points[startIndex], points[lastIndex] }));
}
}
private void clearDrawingPop()
{
if (drawnType == DrawnType.Plane)
{
//resetPlane
mScene.xyPlane.resetOrgin();
mScene.yzPlane.resetOrgin();
mScene.xzPlane.resetOrgin();
UtilOld.setPlaneAlpha(ref mScene, 0.0f);
}
for (int i = 0; i < pointMarkers.Count; i++)
{
SceneNode sn = pointMarkers[i];
UtilOld.removeSceneNode(ref mScene, ref sn);
}
pointMarkers.Clear();
pointsList.Clear();
//clear drawPoint
UtilOld.removeSceneNode(ref mScene, ref drawPoint);
}
private void clearDrawingLeaveTop()
{
if (drawnType == DrawnType.Plane)
{
//resetPlane
mScene.xyPlane.resetOrgin();
mScene.yzPlane.resetOrgin();
mScene.xzPlane.resetOrgin();
UtilOld.setPlaneAlpha(ref mScene, 0.0f);
}
UtilOld.removeSceneNode(ref mScene, ref drawPoint);
if (snapPointSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref snapPointSN);
}
//clear the curve and points (since editCurve will render it again)
UtilOld.removeSceneNode(ref mScene, ref strokeSN);
if (renderObjSN != null)
{
UtilOld.removeSceneNode(ref mScene, ref renderObjSN);
renderObjSN = null;
}
//remove railPlane
/*
* if (drawnType == DrawnType.Reference && railPlaneSN != null)
* {
* //TODO-if we remove here, press undo will casue an error
* Util.removeRhinoObjectSceneNode(ref mScene, ref railPlaneSN);
* railPlaneSN = null;
* }
*/
}
protected override void onClickOculusGrip(ref VREvent_t vrEvent)
{
if (targetPRhObjID == Guid.Empty || currentState != State.READY)
{
return;
}
currentState = State.MOVEPLANE;
movePlaneRef = new ObjRef(targetPRhObjID);
lastTranslate = 0.0f;
//get the plane info
RhinoObject movePlaneObj = movePlaneRef.Object();
planeNormal = new Rhino.Geometry.Vector3d();
//PointOnObject still null at this point
if (movePlaneObj.Attributes.Name.Contains("planeXY"))
{
planeNormal = new Rhino.Geometry.Vector3d(0, 0, 1);
}
else if (movePlaneObj.Attributes.Name.Contains("planeYZ"))
{
planeNormal = new Rhino.Geometry.Vector3d(1, 0, 0);
}
else if (movePlaneObj.Attributes.Name.Contains("planeXZ"))
{
planeNormal = new Rhino.Geometry.Vector3d(0, 1, 0);
}
OpenTK.Vector4 controller_p = UtilOld.getControllerTipPosition(ref mScene, primaryControllerIdx == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, 0, 1);
OpenTK.Vector3 controllerVector = UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z));
float translate = OpenTK.Vector3.Dot(controllerVector, UtilOld.RhinoToOpenTKVector(planeNormal)) / (float)planeNormal.Length;
//move from the porjection point not origin
moveControlerOrigin = new Point3d(0 + translate * planeNormal.X, 0 + translate * planeNormal.Y, 0 + translate * planeNormal.Z);
}
/**
* Updates the poses of all tracked devices in the Matrix4 format.
* Also handles new tracked devices, setting them up in the scene
* and loading their render models.
*/
void updateMatrixPose()
{
if (mHMD == null)
{
return;
}
OpenVR.Compositor.WaitGetPoses(mScene.mTrackedDevices, gamePoseArray);
for (uint i = 0; i < mScene.mTrackedDevices.Length; i++)
{
var device = gamePoseArray[i];
if (device.bPoseIsValid)
{
mScene.mDevicePose[i] = UtilOld.steamVRMatrixToMatrix4(mScene.mTrackedDevices[i].mDeviceToAbsoluteTracking);
mHMD.GetTrackedDeviceClass(i);
if (mScene.mDeviceClassChar[i] == 0)
{
switch (mHMD.GetTrackedDeviceClass(i))
{
case ETrackedDeviceClass.Controller:
mScene.mDeviceClassChar[i] = 'C';
string name = UtilOld.GetTrackedDeviceString(ref mHMD, i, ETrackedDeviceProperty.Prop_RenderModelName_String);
if (name.ToLower().Contains("left"))
{
mScene.leftControllerIdx = (int)i;
// Uncomment to show controller model.
//Geometry.Geometry g = new Geometry.Geometry(@"C:/workspace/SparrowHawk/src/resources/external_controller01_left.obj");
//Material.Material m = new Material.RGBNormalMaterial(.5f);
//SceneNode s = new SceneNode("LeftControllerModel", ref g, ref m);
//s.transform = Util.createTranslationMatrix(-mScene.mLeftControllerOffset.M14, -mScene.mLeftControllerOffset.M24, -mScene.mLeftControllerOffset.M34);
//mScene.leftControllerNode.add(ref s);
}
else if (name.ToLower().Contains("right"))
{
mScene.rightControllerIdx = (int)i;
}
else if (mScene.leftControllerIdx < 0)
{
mScene.leftControllerIdx = (int)i;
}
else if (mScene.rightControllerIdx < 0)
{
mScene.rightControllerIdx = (int)i;
}
break;
case ETrackedDeviceClass.HMD: mScene.mDeviceClassChar[i] = 'H'; break;
case ETrackedDeviceClass.Invalid: mScene.mDeviceClassChar[i] = 'I'; break;
case ETrackedDeviceClass.GenericTracker: mScene.mDeviceClassChar[i] = 'G'; break;
case ETrackedDeviceClass.TrackingReference: mScene.mDeviceClassChar[i] = 'T'; break;
default: mScene.mDeviceClassChar[i] = '?'; break;
}
}
}
}
if (gamePoseArray[OpenVR.k_unTrackedDeviceIndex_Hmd].bPoseIsValid)
{
mScene.mHMDPose = UtilOld.steamVRMatrixToMatrix4(gamePoseArray[OpenVR.k_unTrackedDeviceIndex_Hmd].mDeviceToAbsoluteTracking).Inverted();
}
if (mScene.leftControllerIdx > 0)
{
mScene.leftControllerNode.transform = mScene.mDevicePose[mScene.leftControllerIdx] * mScene.mLeftControllerOffset;
}
if (mScene.rightControllerIdx > 0)
{
mScene.rightControllerNode.transform = mScene.mDevicePose[mScene.rightControllerIdx] * mScene.mRightControllerOffset;
}
}
protected override void OnKeyPress(OpenTK.KeyPressEventArgs e)
{
if (e.KeyChar == 'C' || e.KeyChar == 'c')
{
((VrRenderer)mRenderer).ovrvision_controller.getMatrixHeadtoCamera(0);
mScene.popInteraction();
mScene.pushInteraction(new Interaction.CalibrationAR(ref mScene, ref mRenderer.ovrvision_controller));
}
if (e.KeyChar == 'D' || e.KeyChar == 'd')
{
mRenderer.ovrvision_controller.setDefaultMatrixHC();
}
if (e.KeyChar == 'J' || e.KeyChar == 'j')
{
//mScene.popInteraction();
//mScene.pushInteraction(new Interaction.EditPlane(ref mScene, ref xyPlane, ref xzPlane, ref yzPlane));
//mScene.pushInteraction(new Interaction.RotatePlane(ref mScene, ref xyPlane2, ref xzPlane2, ref yzPlane2));
//clear the stroke
foreach (SceneNode sn in mScene.tableGeometry.children)
{
if (sn.name == "PrintStroke")
{
mScene.tableGeometry.children.Remove(sn);
break;
}
}
}
if (e.KeyChar == 'M' || e.KeyChar == 'm')
{
mScene.popInteraction();
mScene.pushInteraction(new Interaction.Stroke(ref mScene));
}
if (e.KeyChar == 'V' || e.KeyChar == 'v')
{
calibrationVRtoRobot();
}
if (e.KeyChar == 'P' || e.KeyChar == 'p')
{
/*
* mScene.popInteraction();
* controllerP = new List<Vector3>();
* mScene.pushInteraction(new Interaction.PickPoint(ref mScene, ref controllerP));
*/
Rhino.DocObjects.ObjectEnumeratorSettings settings = new Rhino.DocObjects.ObjectEnumeratorSettings();
settings.ObjectTypeFilter = Rhino.DocObjects.ObjectType.Brep;
Brep teapotBody = new Brep();
Brep teapotSprout = new Brep();
Brep teapotHandle = new Brep();
foreach (Rhino.DocObjects.RhinoObject rhObj in mScene.rhinoDoc.Objects.GetObjectList(settings))
{
if (rhObj.Attributes.Name == "aprinteGZx3Sz91Ag")
{
teapotBody = ((Brep)rhObj.Geometry).DuplicateBrep();
mScene.rhinoDoc.Objects.Delete(rhObj.Id, true);
}
else if (rhObj.Attributes.Name == "aprintS8FyJC391Ag")
{
teapotSprout = ((Brep)rhObj.Geometry).DuplicateBrep();
mScene.rhinoDoc.Objects.Delete(rhObj.Id, true);
}
else if (rhObj.Attributes.Name == "aprintVBE2eS391Ag")
{
teapotHandle = ((Brep)rhObj.Geometry).DuplicateBrep();
mScene.rhinoDoc.Objects.Delete(rhObj.Id, true);
}
}
Material.Material mesh_m = new Material.LambertianMaterial(.7f, .7f, .7f, .3f);
string modelName = "aprint";
SceneNode teapotBodySN;
UtilOld.addRhinoObjectSceneNode(ref mScene, ref teapotBody, ref mesh_m, modelName, out teapotBodySN);
SceneNode teapotSproutSN;
UtilOld.addRhinoObjectSceneNode(ref mScene, ref teapotSprout, ref mesh_m, modelName, out teapotSproutSN);
SceneNode teapotHandleSN;
UtilOld.addRhinoObjectSceneNode(ref mScene, ref teapotHandle, ref mesh_m, modelName, out teapotHandleSN);
}
if (e.KeyChar == 'A' || e.KeyChar == 'a')
{
//mScene.popInteraction();
//mScene.pushInteraction(new Interaction.Align(ref mScene));
//for rhino object
OpenTK.Matrix4 currentRotation = mScene.platformRotation;
float theta = (float)(90.0f / 360f * 2 * Math.PI);
Rhino.RhinoApp.WriteLine("Theta = " + theta);
Matrix4.CreateRotationZ(theta, out mScene.platformRotation);
mScene.platformRotation.Transpose();
//rotate Rhino objects
OpenTK.Matrix4 rotMRhino = mScene.platformRotation * currentRotation.Inverted();
Rhino.DocObjects.ObjectEnumeratorSettings settings = new Rhino.DocObjects.ObjectEnumeratorSettings();
mScene.transM = new Transform();
for (int row = 0; row < 4; row++)
{
for (int col = 0; col < 4; col++)
{
mScene.transM[row, col] = rotMRhino[row, col];
}
}
settings.ObjectTypeFilter = Rhino.DocObjects.ObjectType.Brep;
foreach (Rhino.DocObjects.RhinoObject rhObj in mScene.rhinoDoc.Objects.GetObjectList(settings))
{
SceneNode sn;
if (mScene.BiDictionaryRhinoVR.TryGetByFirst(rhObj.Id, out sn) && !rhObj.Attributes.Name.Contains("planeXY") && !rhObj.Attributes.Name.Contains("planeXZ") &&
!rhObj.Attributes.Name.Contains("planeYZ"))
{
//SceneNode sn = mScene.brepToSceneNodeDic[rhObj.Id];
//mScene.brepToSceneNodeDic.Remove(rhObj.Id);
Guid newGuid = mScene.rhinoDoc.Objects.Transform(rhObj.Id, mScene.transM, true);
Rhino.RhinoApp.WriteLine("transM " + mScene.transM.ToString());
mScene.rhinoDoc.Views.Redraw();
//mScene.brepToSceneNodeDic.Add(newGuid, sn);
//mScene.SceneNodeToBrepDic[sn.guid] = mScene.rhinoDoc.Objects.Find(newGuid);
}
}
}
if (e.KeyChar == 'O' || e.KeyChar == 'o')
{
mScene.popInteraction();
UtilOld.clearAllModel(ref mScene);
}
if (e.KeyChar == 'Q' || e.KeyChar == 'q')
{
//print out debug info
foreach (var item in mScene.selectionDic)
{
Rhino.RhinoApp.WriteLine(item.Key.ToString() + ": " + item.Value.ToString());
}
}
if (e.KeyChar == 'Z' || e.KeyChar == 'z')
{
while (!mScene.interactionStackEmpty())
{
mScene.popInteraction();
}
}
if (e.KeyChar == 'X' || e.KeyChar == 'x')
{
mScene.popInteraction();
mScene.pushInteraction(new Interaction.CreatePatch(ref mScene));
}
if (e.KeyChar == '[' || e.KeyChar == '{')
{
mScene.popInteraction();
mScene.pushInteraction(new Interaction.PickPoint(ref mScene, ref mLeftControllerPoses));
current_i = null;
}
if (e.KeyChar == ']' || e.KeyChar == '}')
{
mScene.popInteraction();
mScene.pushInteraction(new Interaction.PickPoint(ref mScene, ref mRightControllerPoses));
current_i = null;
}
}
