public void TestTranspose()
{
float x = TK.MathHelper.Pi;
float y = TK.MathHelper.PiOver4;
TK.Matrix4 tkM = TK.Matrix4.CreateRotationX(x) * TK.Matrix4.CreateRotationY(y);
Matrix3x3 m = Matrix3x3.FromRotationX(x) * Matrix3x3.FromRotationY(y);
tkM.Transpose();
m.Transpose();
TestHelper.AssertEquals(tkM, m, "Testing transpose");
}
public override void draw(bool isTop)
{
//visualize the point on the plane
if (onPlane && isTop)
{
//ray casting to the pre-defind planes
OpenTK.Vector4 controller_p = UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, 0, 1);
OpenTK.Vector4 controller_pZ = UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, -1, 1);
Point3d controller_pRhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)));
Point3d controller_pZRhin = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_pZ.X, controller_pZ.Y, controller_pZ.Z)));
Rhino.Geometry.Vector3d direction = new Rhino.Geometry.Vector3d(controller_pZRhin.X - controller_pRhino.X, controller_pZRhin.Y - controller_pRhino.Y, controller_pZRhin.Z - controller_pRhino.Z);
Ray3d ray = new Ray3d(controller_pRhino, direction);
Rhino.DocObjects.ObjectEnumeratorSettings settings = new Rhino.DocObjects.ObjectEnumeratorSettings();
settings.ObjectTypeFilter = Rhino.DocObjects.ObjectType.Brep;
//settings.NameFilter = "plane";
float mimD = 1000000f;
hitPlane = false;
if (!lockPlane)
{
foreach (Rhino.DocObjects.RhinoObject rhObj in mScene.rhinoDoc.Objects.GetObjectList(settings))
{
//only drawing on planes for now rhObj.Attributes.Name.Contains("brepMesh") || rhObj.Attributes.Name.Contains("aprint") || rhObj.Attributes.Name.Contains("plane")
if (rhObj.Attributes.Name.Contains("plane"))
{
List <GeometryBase> geometries = new List <GeometryBase>();
geometries.Add(rhObj.Geometry);
//must be a brep or surface, not mesh
Point3d[] rayIntersections = Rhino.Geometry.Intersect.Intersection.RayShoot(ray, geometries, 1);
if (rayIntersections != null)
{
//get the nearest one
OpenTK.Vector3 tmpP = UtilOld.platformToVRPoint(ref mScene, new OpenTK.Vector3((float)rayIntersections[0].X, (float)rayIntersections[0].Y, (float)rayIntersections[0].Z));
float distance = (float)Math.Sqrt(Math.Pow(tmpP.X - controller_p.X, 2) + Math.Pow(tmpP.Y - controller_p.Y, 2) + Math.Pow(tmpP.Z - controller_p.Z, 2));
if (distance < mimD)
{
hitPlane = true;
targetPRhObj = rhObj;
mimD = distance;
projectP = UtilOld.platformToVRPoint(ref mScene, new OpenTK.Vector3((float)rayIntersections[0].X, (float)rayIntersections[0].Y, (float)rayIntersections[0].Z));
}
}
}
}
}
else
{
if (targetPRhObj != null)
{
List <GeometryBase> geometries = new List <GeometryBase>();
geometries.Add(targetPRhObj.Geometry);
//must be a brep or surface, not mesh
Point3d[] rayIntersections = Rhino.Geometry.Intersect.Intersection.RayShoot(ray, geometries, 1);
if (rayIntersections != null)
{
//get the nearest one
OpenTK.Vector3 tmpP = UtilOld.platformToVRPoint(ref mScene, new OpenTK.Vector3((float)rayIntersections[0].X, (float)rayIntersections[0].Y, (float)rayIntersections[0].Z));
float distance = (float)Math.Sqrt(Math.Pow(tmpP.X - controller_p.X, 2) + Math.Pow(tmpP.Y - controller_p.Y, 2) + Math.Pow(tmpP.Z - controller_p.Z, 2));
if (distance < mimD)
{
hitPlane = true;
mimD = distance;
projectP = UtilOld.platformToVRPoint(ref mScene, new OpenTK.Vector3((float)rayIntersections[0].X, (float)rayIntersections[0].Y, (float)rayIntersections[0].Z));
}
}
}
}
if (!hitPlane)
{
targetPRhObj = null;
projectP = new OpenTK.Vector3(100, 100, 100); //make it invisable
}
//visualize the projection points
// inverted rotation first
OpenTK.Matrix4 t = OpenTK.Matrix4.CreateTranslation(UtilOld.transformPoint(mScene.tableGeometry.transform.Inverted(), projectP));
t.Transpose();
drawPoint.transform = t;
}
if (currentState != State.PAINT || !isTop)
{
return;
}
// drawing curve
Vector3 pos = new Vector3();
if (onPlane)
{
pos = projectP;
if (hitPlane)
{
//GeometryStroke handle rotation
((Geometry.GeometryStroke)stroke_g).addPoint(pos);
rhihoPointList.Add(UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, pos)));
}
}
else
{
pos = Util.Math.GetTranslationVector3(UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx));
//GeometryStroke handle rotation already
((Geometry.GeometryStroke)stroke_g).addPoint(pos);
rhihoPointList.Add(UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, pos)));
}
if (((Geometry.GeometryStroke)stroke_g).mNumPrimitives == 1)
{
SceneNode stroke = new SceneNode("Stroke", ref stroke_g, ref stroke_m);
mScene.tableGeometry.add(ref stroke);
//mScene.staticGeometry.add(ref stroke);
strokeId = stroke.guid;
}
//testing the performance of rhino curve
if (rhihoPointList.Count == 2)
{
rcurve = Curve.CreateInterpolatedCurve(rhihoPointList.ToArray(), 3);
}
else if (rhihoPointList.Count > 2)
{
rcurve.Extend(Rhino.Geometry.CurveEnd.End, Rhino.Geometry.CurveExtensionStyle.Line, rhihoPointList[rhihoPointList.Count - 1]);
}
}
public override void draw(bool isTop)
{
if (!isTop)
{
return;
}
OpenTK.Vector4 controller_p = UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, 0, 1);
OpenTK.Vector4 controller_pZ = UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, -1, 1);
Point3d controller_pRhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)));
Point3d controller_pZRhin = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_pZ.X, controller_pZ.Y, controller_pZ.Z)));
Rhino.Geometry.Vector3d direction = new Rhino.Geometry.Vector3d(controller_pZRhin.X - controller_pRhino.X, controller_pZRhin.Y - controller_pRhino.Y, controller_pZRhin.Z - controller_pRhino.Z);
if (drawnType != DrawnType.In3D)
{
UtilOld.rayCasting(controller_pRhino, direction, ref rayCastingObjs, ref projectP, out targetPRhObjID);
}
else
{
projectP = controller_pRhino;
}
//TODO-only snap for the first drawing point
if (pointMarkers.Count == 0 && targetPRhObjID != Guid.Empty)
{
computeContourCurve();
UtilOld.snapToPoints(ref projectP, ref snapPointsList);
}
Vector3 projectPVR = UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(projectP));
if (drawnType != DrawnType.In3D)
{
OpenTK.Matrix4 t = OpenTK.Matrix4.CreateTranslation(projectPVR);
t.Transpose();
drawPoint.transform = t;
if (targetPRhObjID != Guid.Empty)
{
drawPoint.material = new Material.SingleColorMaterial(1, 1, 1, 1);
}
else
{
drawPoint.material = new Material.SingleColorMaterial(1, 1, 1, 0);
}
}
//moving XYZ planes
if (currentState == State.MOVEPLANE)
{
OpenTK.Vector3 controllerVector = UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)) - UtilOld.RhinoToOpenTKPoint(moveControlerOrigin);
float translate = OpenTK.Vector3.Dot(controllerVector, UtilOld.RhinoToOpenTKVector(planeNormal)) / (float)planeNormal.Length;
float relTranslate = translate - lastTranslate;
lastTranslate = translate;
Matrix4 transM = Matrix4.CreateTranslation(new Vector3(relTranslate * (float)planeNormal.X, relTranslate * (float)planeNormal.Y, relTranslate * (float)planeNormal.Z));
transM.Transpose();
UtilOld.updateRhinoObjectSceneNode(ref mScene, ref movePlaneRef, UtilOld.OpenTKToRhinoTransform(transM));
}
}
public override void draw(bool isTop)
{
if (!isTop)
{
return;
}
// Clean this monstrosity
OpenTK.Vector4 controller_p = UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, 0, 1);
OpenTK.Vector4 controller_pZ = UtilOld.getControllerTipPosition(ref mScene, primaryDeviceIndex == mScene.leftControllerIdx) * new OpenTK.Vector4(0, 0, -1, 1);
Point3d controller_pRhino = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)));
Point3d controller_pZRhin = UtilOld.openTkToRhinoPoint(UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_pZ.X, controller_pZ.Y, controller_pZ.Z)));
Rhino.Geometry.Vector3d direction = new Rhino.Geometry.Vector3d(controller_pZRhin.X - controller_pRhino.X, controller_pZRhin.Y - controller_pRhino.Y, controller_pZRhin.Z - controller_pRhino.Z);
if (drawnType != DrawnType.In3D)
{
UtilOld.rayCasting(controller_pRhino, direction, ref rayCastingObjs, ref projectP, out targetPRhObjID);
}
else
{
projectP = controller_pRhino;
}
//only snap for the first drawing point
if (currentState != State.DRAW && snapPointsList.Count > 0)
{
if (UtilOld.snapToPoints(ref projectP, ref snapPointsList) != -1)
{
isSnap = true;
snapPointSN.material = new Material.SingleColorMaterial(1, 1, 1, 1);
}
else
{
isSnap = false;
snapPointSN.material = new Material.SingleColorMaterial(0, 1, 0, 1);
}
}
//
Vector3 projectPVR = UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(projectP));
if (drawnType != DrawnType.In3D)
{
OpenTK.Matrix4 t = OpenTK.Matrix4.CreateTranslation(projectPVR);
t.Transpose();
drawPoint.transform = t;
if (targetPRhObjID != Guid.Empty)
{
drawPoint.material = new Material.SingleColorMaterial(1, 1, 1, 1);
}
else
{
drawPoint.material = new Material.SingleColorMaterial(1, 1, 1, 0);
}
}
//moving XYZ planes
if (currentState == State.MOVEPLANE)
{
OpenTK.Vector3 controllerVector = UtilOld.vrToPlatformPoint(ref mScene, new OpenTK.Vector3(controller_p.X, controller_p.Y, controller_p.Z)) - UtilOld.RhinoToOpenTKPoint(moveControlerOrigin);
float translate = OpenTK.Vector3.Dot(controllerVector, UtilOld.RhinoToOpenTKVector(planeNormal)) / (float)planeNormal.Length;
float relTranslate = translate - lastTranslate;
lastTranslate = translate;
Matrix4 transM = Matrix4.CreateTranslation(new Vector3(relTranslate * (float)planeNormal.X, relTranslate * (float)planeNormal.Y, relTranslate * (float)planeNormal.Z));
transM.Transpose();
UtilOld.updateRhinoObjectSceneNode(ref mScene, ref movePlaneRef, UtilOld.OpenTKToRhinoTransform(transM));
}
if (currentState != State.DRAW)
{
return;
}
else
{
//checking the projectPoint is valid
if (drawnType != DrawnType.In3D && targetPRhObjID == Guid.Empty)
{
return;
}
}
//drawing curve section belows
if (shouldSnap && ((Geometry.GeometryStroke)stroke_g).mNumPoints == 0)
{
((Geometry.GeometryStroke)stroke_g).addPoint(UtilOld.platformToVRPoint(ref mScene, UtilOld.RhinoToOpenTKPoint(snapPointsList[0])));
}
((Geometry.GeometryStroke)stroke_g).addPoint(projectPVR);
rhinoCurvePoints.Add(projectP);
if (((Geometry.GeometryStroke)stroke_g).mNumPrimitives == 1)
{
strokeSN = new SceneNode("Stroke", ref stroke_g, ref stroke_m);
UtilOld.addSceneNode(ref mScene, ref strokeSN);
}
//create rhino curve for comoputing length of the curve
if (rhinoCurvePoints.Count == 2)
{
if (shouldSnap)
{
//make sure the first point is the snap point if necessary
if (UtilOld.computePointDistance(UtilOld.RhinoToOpenTKPoint(rhinoCurvePoints[0]), UtilOld.RhinoToOpenTKPoint(snapPointsList[0])) != 0)
{
rhinoCurvePoints.Insert(0, snapPointsList[0]);
}
}
rhinoCurve = Rhino.Geometry.Curve.CreateInterpolatedCurve(rhinoCurvePoints.ToArray(), 3);
}
else if (rhinoCurvePoints.Count > 2)
{
double length1 = rhinoCurve.GetLength();
rhinoCurve = Rhino.Geometry.Curve.CreateInterpolatedCurve(rhinoCurvePoints.ToArray(), 3);
double length2 = rhinoCurve.GetLength();
displacement = displacement + (float)Math.Abs(length2 - length1);
//TODO-Debug why it failed
//rhinoCurve = rhinoCurve.Extend(Rhino.Geometry.CurveEnd.End, Rhino.Geometry.CurveExtensionStyle.Line, rhinoCurvePoints[rhinoCurvePoints.Count - 1]);
//dynamic render model
//TODO: finding the right curve
if (dynamicRender != "none" && backgroundStart == false && displacement > 10)
{
backgroundStart = true;
R = d.BeginInvoke(new AsyncCallback(modelCompleted), null);
}
}
}
void Mainloop(float delta)
{
this.window.SwapBuffers();
GL.ClearColor(1f, 0f, 1f, 1.0f);
GL.Clear(ClearBufferMask.ColorBufferBit);
GL.Clear(ClearBufferMask.DepthBufferBit);
this.window.Title = delta.ToString();
return;
if (b_W)
{
camera.moveFront(delta * camaraSpeed);
}
if (b_S)
{
camera.moveFront(delta * -camaraSpeed);
}
if (b_A)
{
camera.moveSideways(delta * -camaraSpeed);
}
if (b_D)
{
camera.moveSideways(delta * camaraSpeed);
}
if (b_Q)
{
camera.moveUp(delta * camaraSpeed);
}
if (b_E)
{
camera.moveUp(-delta * camaraSpeed);
}
if (b_F)
{
spotColor = new Vector3(2);
}
else
{
spotColor = new Vector3(0);
}
GL.Uniform3(GL.GetUniformLocation(shader.GetShaderID(), "u_spot_light.diffuse"), ref spotColor);
GL.Uniform3(GL.GetUniformLocation(shader.GetShaderID(), "u_spot_light.specular"), ref spotColor);
spotColor *= 0.1F;
GL.Uniform3(GL.GetUniformLocation(shader.GetShaderID(), "u_spot_light.ambient"), ref spotColor);
camera.update();
modelViewProj = camera.GetViewProj() * camModelRender;
Matrix4 modelView = camera.GetView() * camModelRender;
var matrix4 = new OpenTK.Matrix4();
matrix4.Transpose();
Matrix4 invModelView = new Matrix4(); //TODO: glm.transpose( inverse( modelView ) );
Vector3 transformedSunDirection = new Vector3(); //TODO: transpose( inverse( camera.GetView() ) ) * vec4( sunDirection, 1.0F );
GL.Uniform3(directionLocation, ref transformedSunDirection);
Matrix4 pointLightMatrix = glm.rotate(new mat4(1f), -delta, new vec3(0, 1, 0)).M();
pointLightPosition = pointLightMatrix * pointLightPosition;
Vector3 transformedPointLightPosition = new Vector3(); //TODO:(Vector3) ( camera.GetView() * ( pointLightPosition ) );
GL.Uniform3(pointLightLocation, ref transformedPointLightPosition);
GL.UniformMatrix4(modelViewProjMatrixLocation, false, ref modelViewProj);
GL.UniformMatrix4(modelViewLocation, false, ref modelView);
GL.UniformMatrix4(invModelViewLocation, false, ref invModelView);
///
for (int i = 0; i < this.mats.Count; ++i)
{
//mats[i] =Matrix4.ro rotate(mats[i],time * , Vector3 (0, time,0));
modelViewProj = camera.GetViewProj() * mats[i];
modelView = camera.GetView() * mats[i];
invModelView = (modelView.Inverted());
GL.UniformMatrix4(modelViewProjMatrixLocation, false, ref modelViewProj);
GL.UniformMatrix4(modelViewLocation, false, ref modelView);
GL.UniformMatrix4(invModelViewLocation, false, ref invModelView);
//TODO:models[i] -> Render();
}
}