/// <summary>
/// Renders the flattened path to the device using the specified color.
/// </summary>
/// <param name="device">The device to use for rendering the path.</param>
/// <param name="color">The color to use for the vertices.</param>
/// <param name="flattenedPath">The path to render.</param>
protected virtual void Render(Device device, int color, GraphicsPath flattenedPath)
{
PointF[] points = flattenedPath.PathPoints;
device.VertexFormat = CustomVertex.PositionColored.Format;
bool isClosed;
GraphicsPathIterator pi = new GraphicsPathIterator(flattenedPath);
while (pi.NextSubpath(flattenedPath, out isClosed) != 0)
{
byte type;
int start, end;
while (pi.NextPathType(out type, out start, out end) != 0)
{
int numDistinctPoints = end - start + 1;
int totNumPoints = numDistinctPoints;
if (isClosed)
{
totNumPoints++;
}
CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[totNumPoints];
P3Util.CreateColoredVertexList(colVerts, points, start, 0, numDistinctPoints, color);
if (isClosed)
{
colVerts[numDistinctPoints] = colVerts[0];
}
device.DrawUserPrimitives(PrimitiveType.LineStrip, totNumPoints - 1, colVerts);
}
}
}
/// <summary>
/// Renders the list of primitives to the device.
/// </summary>
/// <param name="device">The device to use for rendering the primitives.</param>
/// <param name="renderList">The list of primitives to render.</param>
protected virtual void Render(Device device, ArrayList renderList)
{
PointF[] points = (PointF[])renderList.ToArray(typeof(PointF));
device.VertexFormat = CustomVertex.PositionColored.Format;
for (int i = 0; i < renderListTypes.Count; i++)
{
PrimitiveTypeInfo pti = (PrimitiveTypeInfo)renderListTypes[i];
int numVerts = (pti.End - pti.Start + 1);
CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[numVerts];
P3Util.CreateColoredVertexList(colVerts, points, pti.Start, 0, numVerts, pti.Color);
switch (pti.Type)
{
case PrimitiveType.TriangleFan:
device.DrawUserPrimitives(PrimitiveType.TriangleFan, colVerts.Length - 2, colVerts);
break;
case PrimitiveType.TriangleList:
device.DrawUserPrimitives(PrimitiveType.TriangleList, colVerts.Length / 3, colVerts);
break;
case PrimitiveType.TriangleStrip:
device.DrawUserPrimitives(PrimitiveType.TriangleStrip, colVerts.Length - 2, colVerts);
break;
}
}
}
/// <summary>
/// Overridden. See <see cref="PCamera.PaintDebugFullBounds">PaintDebugFullBounds</see>.
/// </summary>
protected override void PaintDebugFullBounds(PPaintContext paintContext, Brush fullBoundsBrush, RectangleF nodeBounds)
{
Device device = (paintContext as P3PaintContext).Device;
CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[VERTEX_COUNT];
P3Util.CreateColoredRectangle(colVerts, 0, nodeBounds, (fullBoundsBrush as SolidBrush).Color.ToArgb());
device.VertexFormat = CustomVertex.PositionColored.Format;
device.DrawUserPrimitives(PrimitiveType.TriangleList, 2, colVerts);
}
/// <summary>
/// Overridden. See <see cref="PCamera.PaintDebugBounds">PCamera.PaintDebugBounds</see>.
/// </summary>
protected override void PaintDebugBounds(PPaintContext paintContext, Pen boundsPen, RectangleF nodeBounds)
{
Device device = (paintContext as P3PaintContext).Device;
CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[VERTEX_COUNT];
P3Util.CreateColoredRectangleOutline(colVerts, 0, nodeBounds, boundsPen.Color.ToArgb());
device.VertexFormat = CustomVertex.PositionColored.Format;
device.DrawUserPrimitives(PrimitiveType.LineStrip, 4, colVerts);
}
/// <summary>
/// Overridden. See <see cref="P3Node.FillVertexBuffer">P3Node.FillVertexBuffer</see>.
/// </summary>
protected override void FillVertexBuffer(VertexBuffer vb)
{
GraphicsStream stm = vb.Lock(0, 0, 0);
CustomVertex.PositionNormalTextured[] texVerts = new CustomVertex.PositionNormalTextured[VERTEX_COUNT];
P3Util.CreateTexturedRectangle(texVerts, 0, Bounds);
stm.Write(texVerts);
vb.Unlock();
}
/// <summary>
/// Override this method to fill the vertex buffer with the appropriate data. Most nodes
/// that extend P3Node will need to override this method since their number and type of
/// vertices will vary.
/// </summary>
/// <remarks>
/// It is not safe to call GetValidVertexBuffer() here, since that method may call
/// FillVertexBuffer().
/// </remarks>
/// <param name="vb">The vertex buffer to fill.</param>
protected virtual void FillVertexBuffer(VertexBuffer vb)
{
if (Brush != null)
{
GraphicsStream stm = vb.Lock(0, 0, 0);
CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[VERTEX_COUNT];
P3Util.CreateColoredRectangle(colVerts, 0, Bounds, (Brush as SolidBrush).Color.ToArgb());
stm.Write(colVerts);
vb.Unlock();
}
}
/// <summary>
/// Overridden. See <see cref="P3Node.FillVertexBuffer">P3Node.FillVertexBuffer</see>.
/// </summary>
protected override void FillVertexBuffer(VertexBuffer vb)
{
GraphicsStream stm = vb.Lock(0, 0, 0);
CustomVertex.PositionColored[] colVerts = new CustomVertex.PositionColored[renderList.Count];
PointF[] points = (PointF[])renderList.ToArray(typeof(PointF));
foreach (PrimitiveTypeInfo pti in renderListTypes)
{
P3Util.CreateColoredVertexList(colVerts, points, pti.Start, pti.Start, pti.End - pti.Start + 1, pti.Color);
}
stm.Write(colVerts);
vb.Unlock();
}
/// <summary>
/// Override this method to change the way bounds are computed. For example
/// this is where you can control how lines are wrapped.
/// </summary>
public virtual void RecomputeBounds()
{
if (text != null && (ConstrainWidthToTextWidth || ConstrainHeightToTextHeight))
{
currLeftPadding = currRightPadding = currTopPadding = currBottomPadding = 0;
// Calculate the padding values in display units
float scaleFactor = displayFontSize / DEFAULT_FONT_SIZE;
currLeftPadding = (int)(scaleFactor * LEFT_PADDING);
currRightPadding = (int)(scaleFactor * RIGHT_PADDING);
currTopPadding = (int)(scaleFactor * TOP_PADDING);
currBottomPadding = (int)(scaleFactor * BOTTOM_PADDING);
// Set the scale factor relative to the current font size
scaleFactor = displayFontSize / Font.Size;
float textWidth;
float textHeight;
if (ConstrainWidthToTextWidth)
{
Rectangle rect = measureFont.MeasureString(null, Text, DrawTextFormat.None, (textBrush as SolidBrush).Color);
textWidth = rect.Width * scaleFactor + currLeftPadding + currRightPadding;
textHeight = rect.Height * scaleFactor + currTopPadding + currBottomPadding;
}
else
{
textWidth = Width;
int scaledWidth = (int)((textWidth - (currLeftPadding + currRightPadding)) * (1 / scaleFactor));
float scaledHeight = P3Util.MeasureString(measureFont, null, Text, scaledWidth, (textBrush as SolidBrush).Color).Height;
textHeight = scaledHeight * scaleFactor + currTopPadding + currBottomPadding;;
}
float newWidth = Width;
float newHeight = Height;
if (ConstrainWidthToTextWidth)
{
newWidth = textWidth;
}
if (ConstrainHeightToTextHeight)
{
newHeight = textHeight;
}
base.SetBounds(X, Y, newWidth, newHeight);
}
}
//****************************************************************
// Painting - Methods for painting a PText.
//****************************************************************
/// <summary>
/// Overridden. See <see cref="PNode.Paint">PNode.Paint</see>.
/// </summary>
protected override void Paint(UMD.HCIL.Piccolo.Util.PPaintContext paintContext)
{
base.Paint(paintContext);
Device device = (paintContext as P3PaintContext).Device;
PMatrix currMatrix = (paintContext as P3PaintContext).Transform;
// Scale the matrix down to display font units
float scale = displayFontSize / font.Size;
currMatrix.ScaleBy(scale, X, Y);
float[] piccoloMatrixElements = currMatrix.Elements;
if (!currMatrix.IsIdentity)
{
Matrix m = new Matrix();
m.M11 = piccoloMatrixElements[0];
m.M12 = piccoloMatrixElements[1];
m.M21 = piccoloMatrixElements[2];
m.M22 = piccoloMatrixElements[3];
m.M41 = piccoloMatrixElements[4];
m.M42 = piccoloMatrixElements[5];
m.M33 = 1;
m.M44 = 1;
textSprite.Transform = m;
}
textSprite.Begin(SpriteFlags.None);
DrawTextFormat D3DAlignment = P3Util.GetD3DAlignment(stringFormat.Alignment);
// Calculate the rectangle with no padding, in actual font units
scale = 1 / scale;
int totHzPadding = currLeftPadding + currRightPadding;
int totVtPadding = currTopPadding + currBottomPadding;
Rectangle dstRect = new Rectangle((int)(Bounds.X + currLeftPadding * scale), (int)(Bounds.Y + currTopPadding * scale),
(int)((Bounds.Width - totHzPadding) * scale), (int)((Bounds.Height - totVtPadding) * scale));
// Wrap the string ourselves, instead of letting the draw method do it, since we want to make
// sure it's consistent with our own MeasureString method.
String str = P3Util.WrapString(textSprite, D3Dfont, Text, dstRect.Width, (TextBrush as SolidBrush).Color);
D3Dfont.DrawText(textSprite, str, dstRect, D3DAlignment, (TextBrush as SolidBrush).Color);
textSprite.End();
}
/// <summary>
/// Implements <see cref="UMD.HCIL.PiccoloDirect3D.Util.TesselationVisitor.TessBegin">
/// TesselationVisitor.TessBegin</see>.
/// </summary>
public virtual void TessBegin(P3Util.GlPrimitiveType which)
{
PrimitiveType type = P3Util.GetD3DPrimitiveType(which);
this.renderListTypes.Add(new PrimitiveTypeInfo(renderList.Count, renderList.Count - 1, currentTesselationColor, type));
}
/// <summary>
/// Overridden. Creates a PiccoloDirect3D scene graph.
/// </summary>
/// <returns>The main camera node in the new scene graph.</returns>
protected override PCamera CreateBasicScenegraph()
{
return(P3Util.CreateBasicScenegraph());
}
