/// <summary>
/// Dispatches untyped items. Replaces DispatchNotTyped(). To get the same behavior as
/// the old DispatchNotTyped(), set the TypeFilter property to null prior to calling.</summary>
/// <param name="traverseList">The traverse list</param>
/// <param name="camera">The camera</param>
protected void DispatchTraverseList(ICollection<TraverseNode> traverseList, Camera camera)
{
// Prepare for geometric picking -- create the ray in world space and reset geometric hit-list.
// First create the ray in viewing coordinates and transform to world coordinates.
float nx = (m_x / (float)m_width) - 0.5f;//normalized x
float ny = 0.5f - (m_y / (float)m_height);//normalized y
Ray3F rayWorld = camera.CreateRay(nx, ny);
Matrix4F worldToView = camera.ViewMatrix;
Matrix4F viewToWorld = new Matrix4F();
viewToWorld.Invert(worldToView);
rayWorld.Transform(viewToWorld);
ClearHitList();
// for geometric picking. will be cleared for each HitRecord.
List<uint> userData = new List<uint>(1);
// Dispatch traverse list
int index = 0;
foreach (TraverseNode node in traverseList)
{
// First test for filtering.
IRenderObject renderObject = node.RenderObject;
if (FilterByType(renderObject))
{
IIntersectable intersectable = renderObject.GetIntersectable();
IGeometricPick geometricPick = intersectable as IGeometricPick;
if (geometricPick != null)
{
// Picking by geometry.
Matrix4F objToWorld = new Matrix4F(node.Transform);
Matrix4F worldToObj = new Matrix4F();
worldToObj.Invert(objToWorld);
Matrix4F viewToObj = Matrix4F.Multiply(viewToWorld, worldToObj);
if (m_frustumPick)
{
//The pick frustum is in view space. Transform to world space then object space.
Frustum frustumObj = new Frustum(m_viewFrust0);
frustumObj.Transform(viewToObj);
//Multi-pick. Get everything in the pick frustum (m_viewFrust0).
Vec3F eyeObj;
worldToObj.Transform(camera.Eye, out eyeObj);
userData.Clear();
if (geometricPick.IntersectFrustum(frustumObj, eyeObj, node.RenderState, userData))
{
// Prepare a multi-pick HitRecord, as if OpenGL had calculated this.
HitRecord hit = new HitRecord(
node.GraphPath,
renderObject,
objToWorld,
userData.ToArray());
m_geoHitList.Add(hit);
}
}
else
{ //Single pick. We care about distance from camera eye.
//Make a copy of the ray in world-space and tranform it to object space.
Ray3F rayObj = rayWorld; //remember, Ray3F is a value type, not a reference type.
rayObj.Transform(worldToObj);
// Do the intersection test in object space.
userData.Clear();
Vec3F intersectionPt, surfaceNormal;
Vec3F nearestVert;
bool intersected;
intersected = geometricPick.IntersectRay(
rayObj, camera, node.RenderState, objToWorld, this,
out intersectionPt, out nearestVert, out surfaceNormal, userData);
if (intersected)
{
// Transform to world space and then to screen space.
objToWorld.Transform(intersectionPt, out intersectionPt);
objToWorld.Transform(nearestVert, out nearestVert);
// Prepare a single-pick HitRecord, as if OpenGL had calculated this.
HitRecord hit = new HitRecord(
node.GraphPath,
renderObject,
objToWorld,
userData.ToArray());
// This is the one difference from OpenGL pick. We have the world pt already.
hit.WorldIntersection = intersectionPt;
hit.NearestVert = nearestVert;
// Another difference is that it's possible to get the surface normal.
if (surfaceNormal != Vec3F.ZeroVector)
{
objToWorld.TransformNormal(surfaceNormal, out surfaceNormal);
surfaceNormal.Normalize();
hit.Normal = surfaceNormal;
}
m_geoHitList.Add(hit);
}
}
}
else
{
// Picking by "rendering", using OpenGL pick.
PushMatrix(node.Transform, false);
Gl.glPushName(index);
IRenderPick pickInterface = renderObject as IRenderPick;
if (pickInterface != null)
{
pickInterface.PickDispatch(node.GraphPath, node.RenderState, this, camera);
}
else
{
renderObject.Dispatch(node.GraphPath, node.RenderState, this, camera);
}
Gl.glPopName();
PopMatrix();
}
}
index++;
}
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_cancelDrag || m_hitRegion == HitRegion.None || NodeList.Count == 0)
return;
bool hitAxis = m_hitRegion == HitRegion.XAxis
|| m_hitRegion == HitRegion.YAxis
|| m_hitRegion == HitRegion.ZAxis;
Matrix4F view = vc.Camera.ViewMatrix;
Matrix4F proj = vc.Camera.ProjectionMatrix;
Matrix4F vp = view * proj;
// create ray in world space.
Ray3F rayW = vc.GetRay(scrPt, vp);
// create ray in view space.
Ray3F rayV = vc.GetRay(scrPt, proj);
Vec3F translate = m_translatorControl.OnDragging(rayV);
ISnapSettings snapSettings = (ISnapSettings)DesignView;
bool snapToGeom = Control.ModifierKeys == m_snapGeometryKey;
if (snapToGeom)
{
Vec3F manipPos = HitMatrix.Translation;
Vec3F manipMove;
if (hitAxis)
{
//Make rayw to point toward moving axis and starting
// from manipulator’s world position.
rayW.Direction = Vec3F.Normalize(translate);
rayW.Origin = manipPos;
manipMove = Vec3F.ZeroVector;
m_cancelDrag = true; //stop further snap-to's
}
else
{
manipMove = rayW.ProjectPoint(manipPos) - manipPos;
}
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
Vec3F snapOffset = TransformUtils.CalcSnapFromOffset(node, snapSettings.SnapFrom);
Path<DomNode> path = new Path<DomNode>(Adapters.Cast<DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Vec3F orgPosW;
parentLocalToWorld.Transform(m_originalValues[i], out orgPosW);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
rayW.MoveToIncludePoint(orgPosW + snapOffset + manipMove);
HitRecord[] hits = GameEngine.RayPick(view, proj, rayW, true);
bool cansnap = false;
HitRecord target = new HitRecord();
if (hits.Length > 0)
{
// find hit record.
foreach (var hit in hits)
{
if (m_snapFilter.CanSnapTo(node, GameEngine.GetAdapterFromId(hit.instanceId)))
{
target = hit;
cansnap = true;
break;
}
}
}
if (cansnap)
{
Vec3F pos;
if (target.hasNearestVert && snapSettings.SnapVertex)
{
pos = target.nearestVertex;
}
else
{
pos = target.hitPt;
}
pos -= snapOffset;
parentWorldToLocal.Transform(ref pos);
Vec3F diff = pos - node.Transform.Translation;
node.Translation += diff;
bool rotateOnSnap = snapSettings.RotateOnSnap
&& target.hasNormal
&& (node.TransformationType & TransformationTypes.Rotation) != 0;
if (rotateOnSnap)
{
Vec3F localSurfaceNormal;
parentWorldToLocal.TransformNormal(target.normal, out localSurfaceNormal);
node.Rotation = TransformUtils.RotateToVector(
m_originalRotations[i],
localSurfaceNormal,
AxisSystemType.YIsUp);
}
}
}
}
else
{
IGrid grid = DesignView.Context.Cast<IGame>().Grid;
bool snapToGrid = Control.ModifierKeys == m_snapGridKey
&& grid.Visible
&& vc.Camera.ViewType == ViewTypes.Perspective;
float gridHeight = grid.Height;
// translate.
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
Path<DomNode> path = new Path<DomNode>(Adapters.Cast<DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
Vec3F localTranslation;
parentWorldToLocal.TransformVector(translate, out localTranslation);
Vec3F trans = m_originalValues[i] + localTranslation;
if(snapToGrid)
{
if(grid.Snap)
trans = grid.SnapPoint(trans);
else
trans.Y = gridHeight;
}
node.Translation = trans;
}
}
}
public override void OnDragging(ViewControl vc, Point scrPt)
{
if (m_cancelDrag || m_hitRegion == HitRegion.None || NodeList.Count == 0)
{
return;
}
bool hitAxis = m_hitRegion == HitRegion.XAxis ||
m_hitRegion == HitRegion.YAxis ||
m_hitRegion == HitRegion.ZAxis;
Matrix4F view = vc.Camera.ViewMatrix;
Matrix4F proj = vc.Camera.ProjectionMatrix;
Matrix4F vp = view * proj;
// create ray in world space.
Ray3F rayW = vc.GetRay(scrPt, vp);
// create ray in view space.
Ray3F rayV = vc.GetRay(scrPt, proj);
Vec3F translate = m_translatorControl.OnDragging(rayV);
ISnapSettings snapSettings = (ISnapSettings)DesignView;
bool snapToGeom = Control.ModifierKeys == m_snapGeometryKey;
if (snapToGeom)
{
Vec3F manipPos = HitMatrix.Translation;
Vec3F manipMove;
if (hitAxis)
{
//Make rayw to point toward moving axis and starting
// from manipulator’s world position.
rayW.Direction = Vec3F.Normalize(translate);
rayW.Origin = manipPos;
manipMove = Vec3F.ZeroVector;
m_cancelDrag = true; //stop further snap-to's
}
else
{
manipMove = rayW.ProjectPoint(manipPos) - manipPos;
}
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
Vec3F snapOffset = TransformUtils.CalcSnapFromOffset(node, snapSettings.SnapFrom);
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Vec3F orgPosW;
parentLocalToWorld.Transform(m_originalValues[i], out orgPosW);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
rayW.MoveToIncludePoint(orgPosW + snapOffset + manipMove);
HitRecord[] hits = GameEngine.RayPick(view, proj, rayW, true);
bool cansnap = false;
HitRecord target = new HitRecord();
if (hits.Length > 0)
{
// find hit record.
foreach (var hit in hits)
{
if (m_snapFilter.CanSnapTo(node, GameEngine.GetAdapterFromId(hit.instanceId)))
{
target = hit;
cansnap = true;
break;
}
}
}
if (cansnap)
{
Vec3F pos;
if (target.hasNearestVert && snapSettings.SnapVertex)
{
pos = target.nearestVertex;
}
else
{
pos = target.hitPt;
}
pos -= snapOffset;
parentWorldToLocal.Transform(ref pos);
Vec3F diff = pos - node.Transform.Translation;
node.Translation += diff;
bool rotateOnSnap = snapSettings.RotateOnSnap &&
target.hasNormal &&
(node.TransformationType & TransformationTypes.Rotation) != 0;
if (rotateOnSnap)
{
Vec3F localSurfaceNormal;
parentWorldToLocal.TransformNormal(target.normal, out localSurfaceNormal);
node.Rotation = TransformUtils.RotateToVector(
m_originalRotations[i],
localSurfaceNormal,
AxisSystemType.YIsUp);
}
}
}
}
else
{
IGrid grid = DesignView.Context.Cast <IGame>().Grid;
bool snapToGrid = Control.ModifierKeys == m_snapGridKey &&
grid.Visible &&
vc.Camera.ViewType == ViewTypes.Perspective;
float gridHeight = grid.Height;
// translate.
for (int i = 0; i < NodeList.Count; i++)
{
ITransformable node = NodeList[i];
Path <DomNode> path = new Path <DomNode>(Adapters.Cast <DomNode>(node).GetPath());
Matrix4F parentLocalToWorld = TransformUtils.CalcPathTransform(path, path.Count - 2);
Matrix4F parentWorldToLocal = new Matrix4F();
parentWorldToLocal.Invert(parentLocalToWorld);
Vec3F localTranslation;
parentWorldToLocal.TransformVector(translate, out localTranslation);
Vec3F trans = m_originalValues[i] + localTranslation;
if (snapToGrid)
{
if (grid.Snap)
{
trans = grid.SnapPoint(trans);
}
else
{
trans.Y = gridHeight;
}
}
node.Translation = trans;
}
}
}
/// <summary>
/// Dispatches untyped items. Replaces DispatchNotTyped(). To get the same behavior as
/// the old DispatchNotTyped(), set the TypeFilter property to null prior to calling.</summary>
/// <param name="traverseList">The traverse list</param>
/// <param name="camera">The camera</param>
protected void DispatchTraverseList(ICollection <TraverseNode> traverseList, Camera camera)
{
// Prepare for geometric picking -- create the ray in world space and reset geometric hit-list.
// First create the ray in viewing coordinates and transform to world coordinates.
float nx = (m_x / (float)m_width) - 0.5f; //normalized x
float ny = 0.5f - (m_y / (float)m_height); //normalized y
Ray3F rayWorld = camera.CreateRay(nx, ny);
Matrix4F worldToView = camera.ViewMatrix;
Matrix4F viewToWorld = new Matrix4F();
viewToWorld.Invert(worldToView);
rayWorld.Transform(viewToWorld);
ClearHitList();
// for geometric picking. will be cleared for each HitRecord.
List <uint> userData = new List <uint>(1);
// Dispatch traverse list
int index = 0;
foreach (TraverseNode node in traverseList)
{
// First test for filtering.
IRenderObject renderObject = node.RenderObject;
if (FilterByType(renderObject))
{
IIntersectable intersectable = renderObject.GetIntersectable();
IGeometricPick geometricPick = intersectable as IGeometricPick;
if (geometricPick != null)
{
// Picking by geometry.
Matrix4F objToWorld = new Matrix4F(node.Transform);
Matrix4F worldToObj = new Matrix4F();
worldToObj.Invert(objToWorld);
Matrix4F viewToObj = Matrix4F.Multiply(viewToWorld, worldToObj);
if (m_frustumPick)
{
//The pick frustum is in view space. Transform to world space then object space.
Frustum frustumObj = new Frustum(m_viewFrust0);
frustumObj.Transform(viewToObj);
//Multi-pick. Get everything in the pick frustum (m_viewFrust0).
Vec3F eyeObj;
worldToObj.Transform(camera.Eye, out eyeObj);
userData.Clear();
if (geometricPick.IntersectFrustum(frustumObj, eyeObj, node.RenderState, userData))
{
// Prepare a multi-pick HitRecord, as if OpenGL had calculated this.
HitRecord hit = new HitRecord(
node.GraphPath,
renderObject,
objToWorld,
userData.ToArray());
m_geoHitList.Add(hit);
}
}
else
{ //Single pick. We care about distance from camera eye.
//Make a copy of the ray in world-space and tranform it to object space.
Ray3F rayObj = rayWorld; //remember, Ray3F is a value type, not a reference type.
rayObj.Transform(worldToObj);
// Do the intersection test in object space.
userData.Clear();
Vec3F intersectionPt, surfaceNormal;
Vec3F nearestVert;
bool intersected;
intersected = geometricPick.IntersectRay(
rayObj, camera, node.RenderState, objToWorld, this,
out intersectionPt, out nearestVert, out surfaceNormal, userData);
if (intersected)
{
// Transform to world space and then to screen space.
objToWorld.Transform(intersectionPt, out intersectionPt);
objToWorld.Transform(nearestVert, out nearestVert);
// Prepare a single-pick HitRecord, as if OpenGL had calculated this.
HitRecord hit = new HitRecord(
node.GraphPath,
renderObject,
objToWorld,
userData.ToArray());
// This is the one difference from OpenGL pick. We have the world pt already.
hit.WorldIntersection = intersectionPt;
hit.NearestVert = nearestVert;
// Another difference is that it's possible to get the surface normal.
if (surfaceNormal != Vec3F.ZeroVector)
{
objToWorld.TransformNormal(surfaceNormal, out surfaceNormal);
surfaceNormal.Normalize();
hit.Normal = surfaceNormal;
}
m_geoHitList.Add(hit);
}
}
}
else
{
// Picking by "rendering", using OpenGL pick.
PushMatrix(node.Transform, false);
Gl.glPushName(index);
IRenderPick pickInterface = renderObject as IRenderPick;
if (pickInterface != null)
{
pickInterface.PickDispatch(node.GraphPath, node.RenderState, this, camera);
}
else
{
renderObject.Dispatch(node.GraphPath, node.RenderState, this, camera);
}
Gl.glPopName();
PopMatrix();
}
}
index++;
}
}