/// <summary>
/// Renders the specified graph path</summary>
/// <param name="graphPath">The graph path</param>
/// <param name="renderState">The render state</param>
/// <param name="action">The render action</param>
/// <param name="camera">The camera</param>
protected override void Render(SceneNode[] graphPath, RenderState renderState, IRenderAction action, Camera camera)
{
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(action.TopMatrix);
if (m_displayListId == 0)
{
RenderStats globalStats = Util3D.RenderStats;
RenderStats ourStats = new RenderStats();
Util3D.RenderStats = ourStats;
m_displayListId = Gl.glGenLists(1);
#if MEMORY_DEBUG
lock (s_lock) NumDisplayListIds++;
#endif
Gl.glNewList(m_displayListId, Gl.GL_COMPILE);
Render(action);
Gl.glEndList();
m_numPrimitives = ourStats.PrimCount;
m_numVertices = ourStats.VertexCount;
Util3D.RenderStats = globalStats;
}
Gl.glCallList(m_displayListId);
Gl.glPopMatrix();
Util3D.RenderStats.PrimCount += m_numPrimitives;
Util3D.RenderStats.VertexCount += m_numVertices;
}
/// <summary>
/// Sets up projection, given a Camera</summary>
/// <param name="camera">Camera that determines projection</param>
protected virtual void SetupProjection(Camera camera)
{
Gl.glViewport(0, 0, m_width, m_height);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Util3D.glMultMatrixf(camera.ProjectionMatrix);
}
private void RenderZArrow(float s)
{
Gl.glColor3f(0.0f, 0, 1.0f);
Gl.glPushMatrix();
Gl.glTranslatef(0, 0, s);
Util3D.DrawConeDisplayList(s / 20, s / 8, Util3D.RenderStyle.Solid);
Gl.glPopMatrix();
}
/// <summary>
/// Custom pick rendering</summary>
/// <param name="graphPath">The graph path</param>
/// <param name="renderState">The render state</param>
/// <param name="action">The render action</param>
/// <param name="camera">The camera</param>
public void PickDispatch(SceneNode[] graphPath, RenderState renderState, IRenderAction action, Camera camera)
{
action.RenderStateGuardian.Commit(renderState);
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(action.TopMatrix);
RenderVertices(action);
Gl.glPopMatrix();
}
private void RenderXArrow(float s)
{
Gl.glColor3f(1, 0, 0);
Gl.glPushMatrix();
Gl.glTranslatef(s, 0, 0);
Gl.glRotatef(90, 0, 1, 0);
Util3D.DrawConeDisplayList(s / 20, s / 8, Util3D.RenderStyle.Solid);
Gl.glPopMatrix();
}
/// <summary>
/// Sets up the view matrix, given a Camera</summary>
/// <param name="camera">Camera that determines view matrix</param>
protected virtual void SetupView(Camera camera)
{
Gl.glMatrixMode(Gl.GL_TEXTURE);
Gl.glLoadIdentity();
Gl.glMultMatrixf(TextureMatrix);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glLoadIdentity();
Util3D.glMultMatrixf(camera.ViewMatrix);
}
private void RenderAxisSystem(IRenderAction action)
{
// Calc width and height
float width, height;
float nearP = Camera.Frustum.Near * 1.1f;
if (Camera.Frustum.IsOrtho)
{
width = (Camera.Frustum.Right - Camera.Frustum.Left) / 2 * 0.95f;
height = (Camera.Frustum.Top - Camera.Frustum.Bottom) / 2 * 0.90f;
}
else
{
// Set the projection to orthogonal for perspective views
float h = (float)Height / (float)Width;
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Gl.glOrtho(-1, 1, -h, h, 1, 1000);
nearP = 1.1f;
width = 0.92f;
height = h * 0.90f;
}
// Push the view matrix
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Matrix4F V = new Matrix4F(Camera.ViewMatrix);
V.Translation = Vec3F.ZeroVector;
// Disable lighting
Gl.glDisable(Gl.GL_LIGHTING);
Gl.glDisable(Gl.GL_TEXTURE_2D);
Gl.glPushMatrix();
Gl.glLoadIdentity();
Gl.glTranslatef(-width, -height, -nearP);
Util3D.glMultMatrixf(V);
// Render the system
RenderAxis(width / 15);
Gl.glPopMatrix();
}
/// <summary>
/// マスの位置からメッシュを作成します。
/// </summary>
public object Convert(object value, Type targetType,
object parameter, CultureInfo culture)
{
var positions = value as IEnumerable <Square>;
if (positions == null)
{
var position = value as Square;
if (position == null)
{
return(null);
}
positions = new[] { position };
}
return(Util3D.CreateCellMesh(positions, Widen));
}
/// <summary>
/// Renders the control</summary>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="state">Render state</param>
/// <param name="transform">Transform</param>
public void Render(IRenderAction action, Camera camera, RenderState state, Matrix4F transform)
{
float s1, s2, s3;
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(transform);
CalcAxisLengths(camera, transform, out s1, out s2, out s3);
bool drawX, drawY, drawZ;
DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);
if (drawX)
{
RenderXArrow(s1);
RenderXAxis(s1);
}
if (drawY)
{
RenderYArrow(s2);
RenderYAxis(s2);
}
if (drawZ)
{
RenderZArrow(s3);
RenderZAxis(s3);
}
RenderXYSquare(s1 * SquareLength, s2 * SquareLength, true);
RenderYZSquare(s2 * SquareLength, s3 * SquareLength, true);
RenderXZSquare(s1 * SquareLength, s3 * SquareLength, true);
Gl.glPopMatrix();
}
/// <summary>
/// Renders control for picking</summary>
/// <param name="action">Render action</param>
/// <param name="camera">Camera</param>
/// <param name="renderState">Render state</param>
/// <param name="transform">Transform, local to world</param>
public void RenderPick(IRenderAction action, Camera camera, RenderState renderState, Matrix4F transform)
{
action.RenderStateGuardian.Commit(renderState);
// apply xform
Gl.glPushMatrix();
Util3D.glMultMatrixf(transform);
float s1, s2, s3;
CalcAxisLengths(camera, transform, out s1, out s2, out s3);
float squareSideX = s1 * SquareLength;
float squareSideY = s2 * SquareLength;
float squareSideZ = s3 * SquareLength;
bool drawX, drawY, drawZ;
DecideArrowDrawing(transform, camera, out drawX, out drawY, out drawZ);
// Mark each axis with a different name.
// Since the OpenGl selection buffer does a bad job in detecting lines we'll use
// triangles instead.
Gl.glPushName(m_nameBase);
if (drawX)
{
Gl.glPushName((int)HitElement.X_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(squareSideX, 0, 0);
Gl.glVertex3f(s1, 0, 0);
Gl.glVertex3f(squareSideX, 0, 0);
Gl.glEnd();
RenderXArrow(s1);
Gl.glPopName();
}
if (drawY)
{
Gl.glPushName((int)HitElement.Y_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(0, squareSideY, 0);
Gl.glVertex3f(0, s2, 0);
Gl.glVertex3f(0, squareSideY, 0);
Gl.glEnd();
RenderYArrow(s2);
Gl.glPopName();
}
if (drawZ)
{
Gl.glPushName((int)HitElement.Z_ARROW);
Gl.glBegin(Gl.GL_TRIANGLES);
Gl.glVertex3f(0, 0, squareSideZ);
Gl.glVertex3f(0, 0, s3);
Gl.glVertex3f(0, 0, squareSideZ);
Gl.glEnd();
RenderZArrow(s3);
Gl.glPopName();
}
if (drawX && drawY)
{
Gl.glPushName((int)HitElement.XY_SQUARE);
RenderXYSquare(squareSideX, squareSideY, true);
Gl.glPopName();
}
if (drawY && drawZ)
{
Gl.glPushName((int)HitElement.YZ_SQUARE);
RenderYZSquare(squareSideY, squareSideZ, true);
Gl.glPopName();
}
if (drawX && drawZ)
{
Gl.glPushName((int)HitElement.XZ_SQUARE);
RenderXZSquare(squareSideX, squareSideZ, true);
Gl.glPopName();
}
Gl.glPopMatrix();
Gl.glPopName();
}
private HitRecord[] PopulateOpenGlSelection(ICollection <TraverseNode> traverseList)
{
// Ensure that OpenGL is in correct state.
double[] viewMat = null;
double[] projectionMat = null;
int[] viewport = null;
if (m_frustumPick == false)
{
Gl.glViewport(0, 0, m_width, m_height);
Gl.glMatrixMode(Gl.GL_PROJECTION);
Gl.glLoadIdentity();
Util3D.glMultMatrixf(m_projectionMatrix);
Gl.glMatrixMode(Gl.GL_MODELVIEW);
Gl.glLoadIdentity();
Util3D.glMultMatrixf(m_viewMatrix);
viewMat = new double[16];
Gl.glGetDoublev(Gl.GL_MODELVIEW_MATRIX, viewMat);
projectionMat = new double[16];
Gl.glGetDoublev(Gl.GL_PROJECTION_MATRIX, projectionMat);
viewport = new int[4];
viewport[0] = viewport[1] = 0;
viewport[2] = m_width;
viewport[3] = m_height;
}
// Construct traverse array
HitRecord[] selection = null;
List <HitRecord> selectionList = new List <HitRecord>();
TraverseNode[] travArray = new TraverseNode[traverseList.Count];
traverseList.CopyTo(travArray, 0);
uint start = 0;
for (int i = 0; i < m_openGlHits; ++i)
{
uint nameCount = (uint)m_selectionBuffer[start];
if (nameCount > 0)
{
uint travNodeIndex = (uint)m_selectionBuffer[start + 3];
TraverseNode travNode = travArray[travNodeIndex];
HitRecord hitRecord;
if (m_frustumPick)
{
hitRecord = new HitRecord(
travNode.GraphPath,
travNode.RenderObject,
new Matrix4F(travNode.Transform),
new uint[nameCount - 1]);
}
else
{
hitRecord = new HitRecord(
travNode.GraphPath,
travNode.RenderObject,
new Matrix4F(travNode.Transform),
new uint[nameCount - 1]);
// Transform screen to world and record world-space intersection point.
float zMin = ((float)((uint)m_selectionBuffer[start + 1])) / 0xFFFFFFFF;
Vec3F intersectionPt = GetWorldIntersectionFromScreen(
m_x, m_y, zMin,
viewMat, projectionMat, viewport);
hitRecord.WorldIntersection = intersectionPt;
}
// Populate object data
for (uint j = 0; j < nameCount - 1; j++)
{
hitRecord.RenderObjectData[j] = (uint)m_selectionBuffer[start + 4 + j];
}
selectionList.Add(hitRecord);
start += 3 + nameCount;
}
}
selection = new HitRecord[selectionList.Count];
selectionList.CopyTo(selection, 0);
return(selection);
}
