private int GetIndexOffset(int CharacterStartIndexInclusive, int MaxCharacterEndIndexInclusive, T DesiredPixelOffset)
{
int OffsetIndex = 0;
int EndOffsetIndex = MaxCharacterEndIndexInclusive - CharacterStartIndexInclusive;
IVector <T> offset = MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>());
IVector <T> lastOffset = MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>());
while (true)
{
m_TextWidget.GetSize(CharacterStartIndexInclusive, CharacterStartIndexInclusive + OffsetIndex, out offset);
OffsetIndex++;
if (offset[0].GreaterThanOrEqualTo(DesiredPixelOffset) || OffsetIndex >= EndOffsetIndex)
{
if (offset[1].Abs().LessThan(.01) &&
lastOffset[0].Subtract(DesiredPixelOffset).Abs().LessThan(offset[0].Subtract(DesiredPixelOffset).Abs()))
{
OffsetIndex--;
}
break;
}
lastOffset = offset;
}
int MaxLength = Math.Min(MaxCharacterEndIndexInclusive - CharacterStartIndexInclusive, OffsetIndex);
return(CharacterStartIndexInclusive + MaxLength);
}
public override void OnKeyDown(AGG.UI.KeyEventArgs keyEvent)
{
if (keyEvent.KeyCode == Keys.Space)
{
T cx = m_quad.xn(0).Add(m_quad.xn(1)).Add(m_quad.xn(2)).Add(m_quad.xn(3)).Divide(4);
T cy = m_quad.yn(0).Add(m_quad.yn(1)).Add(m_quad.yn(2)).Add(m_quad.yn(3)).Divide(4);
IAffineTransformMatrix <T> tr = MatrixFactory <T> .NewTranslation(cx.Negative(), cy.Negative());
tr.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), (Math.PI / 2.0));
tr.Translate(MatrixFactory <T> .CreateVector2D(cx, cy));
T xn0 = m_quad.xn(0); T yn0 = m_quad.yn(0);
T xn1 = m_quad.xn(1); T yn1 = m_quad.yn(1);
T xn2 = m_quad.xn(2); T yn2 = m_quad.yn(2);
T xn3 = m_quad.xn(3); T yn3 = m_quad.yn(3);
tr.Transform(ref xn0, ref yn0);
tr.Transform(ref xn1, ref yn1);
tr.Transform(ref xn2, ref yn2);
tr.Transform(ref xn3, ref yn3);
m_quad.SetXN(0, xn0); m_quad.SetYN(0, yn0);
m_quad.SetXN(1, xn1); m_quad.SetYN(1, yn1);
m_quad.SetXN(2, xn2); m_quad.SetYN(2, yn2);
m_quad.SetXN(3, xn3); m_quad.SetYN(3, yn3);
force_redraw();
}
base.OnKeyDown(keyEvent);
}
public TextEditWidget(string Text, RectDouble <T> bounds, T CapitalHeight)
{
Bounds = bounds;
m_TextWidget = new TextWidget <T>(Text, M.Zero <T>(), M.Zero <T>(), CapitalHeight);
AddChild(m_TextWidget);
m_CharIndexToInsertBefore = Text.Length;
IAffineTransformMatrix <T> transform = GetTransform();
IVector <T> v1 = transform.TransformVector(MatrixFactory <T> .CreateVector2D(bounds.x1, bounds.y1));
IVector <T> v2 = transform.TransformVector(MatrixFactory <T> .CreateVector2D(bounds.x2, bounds.y2));
SetTransform(transform);
m_BorderSize = CapitalHeight.Multiply(.2);
m_Thickness = CapitalHeight.Divide(8);
m_CapsHeight = CapitalHeight;
FixBarPosition(true);
UndoData newUndoData = new UndoData(this);
m_UndoBuffer.Add(newUndoData, "Initial", UndoBuffer.MergeType.NotMergable);
}
public void PointToClient(ref IVector <T> screenPoint)
{
T x = screenPoint[0], y = screenPoint[1];
PointToClient(ref x, ref y);
screenPoint = MatrixFactory <T> .CreateVector2D(x, y);
}
public void GetSize(int characterToMeasureStartIndexInclusive, int characterToMeasureEndIndexInclusive,
out IVector <T> offset)
{
//offset = MatrixFactory<T>.CreateVector2D ();
//offset.x = 0;
//offset.y = 0;
T x = M.Zero <T>(), y = M.Zero <T>();
if (m_Text.Length > 0)
{
characterToMeasureStartIndexInclusive = Math.Max(0, Math.Min(characterToMeasureStartIndexInclusive, m_Text.Length - 1));
characterToMeasureEndIndexInclusive = Math.Max(0, Math.Min(characterToMeasureEndIndexInclusive, m_Text.Length - 1));
for (int i = characterToMeasureStartIndexInclusive; i <= characterToMeasureEndIndexInclusive; i++)
{
char singleChar = m_Text[i];
if (singleChar == '\r' || singleChar == '\n')
{
x = M.Zero <T>();
y.SubtractEquals(m_FontSize.Add(m_SpaceBetweenLines));
}
else
{
T sigleWidth;
T sigleHeight;
GetSize(singleChar, out sigleWidth, out sigleHeight);
x.AddEquals(sigleWidth.Add(m_SpaceBetweenCharacters));
y.AddEquals(sigleHeight);
}
}
}
offset = MatrixFactory <T> .CreateVector2D(x, y);
}
public void KeyDown(KeyEventArgs keyEvent)
{
if (keyEvent.KeyCode == Keys.Z)
{
m_TurningLeft = true;
}
if (keyEvent.KeyCode == Keys.X)
{
m_TurningRight = true;
}
if (keyEvent.KeyCode == Keys.OemPeriod)
{
m_Thrusting = true;
}
if (keyEvent.KeyCode == Keys.OemQuestion)
{
if (!m_FireKeyDown)
{
double bulletVelocity = 220;
// WIP: have a weapon and tell it to fire.
// set something to fire down
IVector <T> DirectionVector = MatrixFactory <T> .CreateVector2D(m_Rotation.Cos(), m_Rotation.Sin());
m_BulletList.Add(new Bullet <T>(Position.Add(DirectionVector.Multiply(m_PlayerStyleSheetReference.Instance.DistanceToFrontOfShip.ToDouble())),
m_Velocity.Add(DirectionVector.Multiply(bulletVelocity))));
m_FireKeyDown = true;
m_PlayerStyleSheetReference.Instance.FireSoundReference.Instance.PlayAnAvailableCopy();
}
}
}
public override void OnDraw()
{
if (m_Selecting)
{
IVector <T> selectPosition = m_TextWidget.GetOffsetLeftOfCharacterIndex(m_SelectionIndexToStartBefore);
IVector <T> screenSelectStart = selectPosition;
screenSelectStart[0].AddEquals(2);
IVector <T> screenSelectEnd = MatrixFactory <T> .CreateVector2D(screenSelectStart[0], screenSelectStart[1].Add(Bounds.Height));
PointToScreen(ref screenSelectStart);
PointToScreen(ref screenSelectEnd);
GetRenderer().Line(screenSelectStart, screenSelectEnd, new RGBA_Bytes(0, 1.0, 0));
}
base.OnDraw();
RectDouble <T> boundsPlusPoint5 = Bounds;
boundsPlusPoint5.Inflate(M.New <T>(.5));
RoundedRect <T> borderRect = new RoundedRect <T>(boundsPlusPoint5, M.Zero <T>());
ConvStroke <T> borderLine = new ConvStroke <T>(borderRect);
GetRenderer().Render(borderLine, new RGBA_Bytes(0, 0, 0));
IVector <T> screenStart = m_BarPosition;
screenStart[0].AddEquals(2);
IVector <T> screenEnd = MatrixFactory <T> .CreateVector2D(screenStart[0], screenStart[1].Add(Bounds.Height));
PointToScreen(ref screenStart);
PointToScreen(ref screenEnd);
GetRenderer().Line(screenStart, screenEnd, new RGBA_Bytes(0, 0, 1.0));
}
public override void OnInitialize()
{
int FrameRateOffset = -15;
RGBA_Doubles FrameRateControlColor = new RGBA_Doubles(.2, .2, .2, 1);
m_PotentialDrawsBudgetPosition = MatrixFactory <T> .CreateVector2D(M.New <T>(10), height().Add(FrameRateOffset));
m_ShowPotentialDrawsBudgetGraph = new AGG.UI.cbox_ctrl <T>(m_PotentialDrawsBudgetPosition[0], m_PotentialDrawsBudgetPosition[1], "D:0.0");
m_ShowPotentialDrawsBudgetGraph.text_color(FrameRateControlColor);
m_ShowPotentialDrawsBudgetGraph.inactive_color(FrameRateControlColor);
AddChild(m_ShowPotentialDrawsBudgetGraph);
m_PotentialDrawsBudgetGraph = new DataViewGraph <T>(m_PotentialDrawsBudgetPosition, 100, 100);
m_PotentialUpdatesBudgetPosition = MatrixFactory <T> .CreateVector2D(M.New <T>(115), height().Add(FrameRateOffset));
m_ShowPotentialUpdatesBudgetGraph = new AGG.UI.cbox_ctrl <T>(m_PotentialUpdatesBudgetPosition[0], m_PotentialUpdatesBudgetPosition[1], "U:0.0");
m_ShowPotentialUpdatesBudgetGraph.text_color(FrameRateControlColor);
m_ShowPotentialUpdatesBudgetGraph.inactive_color(FrameRateControlColor);
AddChild(m_ShowPotentialUpdatesBudgetGraph);
m_PotentialUpdatesBudgetGraph = new DataViewGraph <T>(m_PotentialUpdatesBudgetPosition, 100, 100);
m_ActualDrawsBudgetPosition = MatrixFactory <T> .CreateVector2D(M.New <T>(220), height().Add(FrameRateOffset));
m_ShowActualDrawsBudgetGraph = new AGG.UI.cbox_ctrl <T>(m_ActualDrawsBudgetPosition[0], m_ActualDrawsBudgetPosition[1], "A:0.0");
m_ShowActualDrawsBudgetGraph.text_color(FrameRateControlColor);
m_ShowActualDrawsBudgetGraph.inactive_color(FrameRateControlColor);
AddChild(m_ShowActualDrawsBudgetGraph);
m_ActualDrawsBudgetGraph = new DataViewGraph <T>(m_ActualDrawsBudgetPosition, 100, 100);
base.OnInitialize();
}
public void StartGame()
{
m_SequenceEntityList.Add(new SequenceEntity <T>(MatrixFactory <T> .CreateVector2D(20, 20)));
m_RockList.Add(new Rock <T>(40, m_RockList));
m_Player = new Player <T>(m_BulletList);
m_Player.Position = MatrixFactory <T> .CreateVector2D(Entity <T> .GameWidth / 2, Entity <T> .GameHeight / 2);
}
private void Bezier(T x1, T y1,
T x2, T y2,
T x3, T y3)
{
m_points.Add(MatrixFactory <T> .CreateVector2D(x1, y1));
RecursiveBezier(x1, y1, x2, y2, x3, y3, 0);
m_points.Add(MatrixFactory <T> .CreateVector2D(x3, y3));
}
//----------------------------------------------------------------
public void Transform(ref T x, ref T y)
{
IVector <T> v = m_trans_dir.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
x = v[0];
y = v[1];
//m_trans_dir.Transform(ref x, ref y);
}
// this will return the position to the left of the requested character.
public IVector <T> GetOffsetLeftOfCharacterIndex(int characterIndex)
{
IVector <T> offset = MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>());
if (characterIndex > 0)
{
m_text.GetSize(0, characterIndex - 1, out offset);
}
return(offset);
}
protected override void DoDraw(RendererBase <T> destRenderer)
{
IAffineTransformMatrix <T> Final = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
Final.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), m_Rotation.ToDouble());
Final.Translate(m_Position);
ConvTransform <T> TransformedShip = new ConvTransform <T>(m_PlayerToDraw, Final);
destRenderer.Render(TransformedShip, new RGBA_Bytes(.9, .4, .2, 1));
}
public void Resynchronize(T xe, T ye, uint len)
{
// Assume x1,y1 are equal to the ones at the previous end point
int x1 = m_coord_x.Y;
int y1 = m_coord_y.Y;
int sx1 = m_scale_x.Y;
int sy1 = m_scale_y.Y;
// Calculate transformed coordinates at x2,y2
T xt = xe;
T yt = ye;
//m_trans_dir.Transform(ref xt, ref yt);
IVector <T> v1 = m_trans_dir.TransformVector(MatrixFactory <T> .CreateVector2D(xt, yt));
xt = v1[0];
yt = v1[1];
int x2 = Basics.RoundInt(xt.Multiply((double)subpixel_scale));
int y2 = Basics.RoundInt(yt.Multiply((double)subpixel_scale));
double delta = 1 / (double)subpixel_scale;
T dx;
T dy;
// Calculate scale by X at x2,y2
dx = xt.Add(delta);
dy = yt;
//m_trans_inv.Transform(ref dx, ref dy);
IVector <T> v2 = m_trans_inv.TransformVector(MatrixFactory <T> .CreateVector2D(dx, dy));
dx = v2[0];
dy = v2[1];
dx.SubtractEquals(xe);
dy.SubtractEquals(ye);
int sx2 = (int)Basics.RoundUint(M.New <T>((double)subpixel_scale).Divide(M.Length(dx, dy)).ToInt()) >> subpixel_shift;
// Calculate scale by Y at x2,y2
dx = xt;
dy = yt.Add(delta);
//m_trans_inv.Transform(ref dx, ref dy);
IVector <T> v3 = m_trans_inv.TransformVector(MatrixFactory <T> .CreateVector2D(dx, dy));
dx = v3[0];
dy = v3[1];
dx.SubtractEquals(xe);
dy.SubtractEquals(ye);
int sy2 = (int)Basics.RoundUint(M.New <T>((double)subpixel_scale).Divide(M.Length(dx, dy)).ToInt()) >> subpixel_shift;
// Initialize the interpolators
m_coord_x = new Dda2LineInterpolator(x1, x2, (int)len);
m_coord_y = new Dda2LineInterpolator(y1, y2, (int)len);
m_scale_x = new Dda2LineInterpolator(sx1, sx2, (int)len);
m_scale_y = new Dda2LineInterpolator(sy1, sy2, (int)len);
}
public Player(List <Entity <T> > bulletList)
: base(26)
{
m_BulletList = bulletList;
Position = MatrixFactory <T> .CreateVector2D(GameWidth / 2, GameHeight / 2);
m_PlayerToDraw.MoveTo(18, 0);
m_PlayerToDraw.LineTo(-8, +10);
m_PlayerToDraw.LineTo(-8, -10);
m_Velocity = MatrixFactory <T> .CreateVector2D(0, 0);
}
public uint Vertex(out T x, out T y)
{
uint cmd = m_VertexSource.Vertex(out x, out y);
if (Path.IsVertex(cmd))
{
IVector <T> v = m_Transform.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
//m_Transform.Transform(ref x, ref y);
x = v[0];
y = v[1];
}
return(cmd);
}
//-------------------------------------------------------------------
public IAffineTransformMatrix <T> ToAffine()
{
//Affine mtx = Affine.NewTranslation(-m_wx1, -m_wy1);
//mtx *= Affine.NewScaling(m_kx, m_ky);
//mtx *= Affine.NewTranslation(m_dx1, m_dy1);
//return mtx;
IAffineTransformMatrix <T> a = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
a.Translate(MatrixFactory <T> .CreateVector2D(m_wx1.Negative(), m_wy1.Negative()));
a.Scale(MatrixFactory <T> .CreateVector2D(m_kx, m_ky));
a.Scale(MatrixFactory <T> .CreateVector2D(m_dx1, m_dy1));
return(a);
}
void DrawAATest()
{
PathStorage <T> PolgonToDraw = new PathStorage <T>();
T Angle = M.Zero <T>();
bool DrawTrinagle = true;
if (DrawTrinagle)
{
PolgonToDraw.MoveTo(Angle.Cos(), Angle.Sin());
Angle.AddEquals(120.0 / 180.0 * Math.PI);
PolgonToDraw.LineTo(Angle.Cos(), Angle.Sin());
Angle.AddEquals(120.0 / 180.0 * Math.PI);
PolgonToDraw.LineTo(Angle.Cos(), Angle.Sin());
Angle.AddEquals(120.0 / 180.0 * Math.PI);
//Triangle.line_to(Math.Cos(Angle), Math.Sin(Angle));
PolgonToDraw.ClosePolygon();
}
else
{
PolgonToDraw.MoveTo(M.Zero <T>(), M.Zero <T>());
PolgonToDraw.LineTo(M.One <T>(), M.Zero <T>());
PolgonToDraw.LineTo(M.One <T>(), M.One <T>());
PolgonToDraw.LineTo(M.Zero <T>(), M.One <T>());
PolgonToDraw.ClosePolygon();
}
IAffineTransformMatrix <T> tran = MatrixFactory <T> .NewScaling(VectorDimension.Two, M.New <T>(80));
tran.RotateAlong(MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>()), Math.PI / 8);
tran.Translate(MatrixFactory <T> .CreateVector2D(M.New <T>(500), M.New <T>(100)));
ConvTransform <T> TransformedPolygon = new ConvTransform <T>(PolgonToDraw, tran);
((RendererOpenGL <T>)GetRenderer()).m_ForceTexturedEdgeAntiAliasing = true;
GetRenderer().Render(TransformedPolygon, new RGBA_Bytes(0, 0, 0));
Ellipse <T> testEllipse = new Ellipse <T>(M.New <T>(300), M.New <T>(250), M.New <T>(60), M.New <T>(60));
GetRenderer().Render(testEllipse, new RGBA_Bytes(205, 23, 12, 120));
((RendererOpenGL <T>)GetRenderer()).m_ForceTexturedEdgeAntiAliasing = false;
//conv_stroke OutLine = new conv_stroke(TransformedPolygon);
//OutLine.width(2);
//conv_transform TransformedOutLine = new conv_transform(OutLine, Affine.NewTranslation(100, 0));
//GetRenderer().Render(TransformedOutLine, new RGBA_Bytes(0, 0, 0));
//conv_transform TransformedOutLine2 = new conv_transform(OutLine, Affine.NewScaling(6) * Affine.NewTranslation(200, 0));
//conv_stroke OutLineOutLine = new conv_stroke(TransformedOutLine2);
//GetRenderer().Render(OutLineOutLine, new RGBA_Bytes(0, 0, 0));
}
public void TransformTest()
{
IAffineTransformMatrix <DoubleComponent> a = MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two);
a.Translate(MatrixFactory <DoubleComponent> .CreateVector2D(10, 20));
DoubleComponent x = 10;
DoubleComponent y = 20;
DoubleComponent newx = 0;
DoubleComponent newy = 0;
a.Transform(ref newx, ref newy);
Assert.AreEqual((double)x, (double)newx, .001);
Assert.AreEqual((double)y, (double)newy, .001);
}
override public void OnMouseMove(MouseEventArgs mouseEvent)
{
if (MouseDownOnBar)
{
IVector <T> mouseRelClient = MatrixFactory <T> .CreateVector2D(M.New <T>(mouseEvent.X), M.New <T>(mouseEvent.Y));
PointToClient(ref mouseRelClient);
IVector <T> newLocation = Parrent.Location;
newLocation[0].AddEquals(mouseRelClient[0].Subtract(m_DownPosition[0]));
newLocation[1].AddEquals(mouseRelClient[1].Subtract(m_DownPosition[1]));
Parrent.Location = newLocation;
// TODO: invalidate the parents current position and where it is going.
//Invalidate();
}
}
override public void OnMouseDown(MouseEventArgs mouseEvent)
{
if (InRect(M.New <T>(mouseEvent.X), M.New <T>(mouseEvent.Y)))
{
MouseDownOnBar = true;
mouseEvent.Handled = true;
IVector <T> mouseRelClient = MatrixFactory <T> .CreateVector2D(M.New <T>(mouseEvent.X), M.New <T>(mouseEvent.Y));
PointToClient(ref mouseRelClient);
m_DownPosition = mouseRelClient;
}
else
{
MouseDownOnBar = false;
}
}
public override void OnDraw()
{
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
IPixelFormat pixf = new FormatRGB(rbuf_window(), new BlenderBGR());
FormatClippingProxy clippingProxy = new FormatClippingProxy(pixf);
clippingProxy.Clear(new RGBA_Doubles(1, 1, 1));
IAffineTransformMatrix <T> mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
mtx.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
mtx.Scale(g_scale);
mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), g_angle.Add(Math.PI).ToDouble());
mtx.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2, height / 2));
if (m_scanline.status())
{
g_rasterizer.SetVectorClipBox(0, 0, width, height);
ConvStroke <T> stroke = new ConvStroke <T>(g_path);
stroke.Width = m_width_slider.value();
stroke.LineJoin = LineJoin.RoundJoin;
ConvTransform <T> trans = new ConvTransform <T>(stroke, mtx);
Renderer <T> .RenderSolidAllPaths(clippingProxy, g_rasterizer, g_scanline, trans, g_colors, g_path_idx, g_npaths);
}
else
{
/*
* double w = m_width_slider.Value() * mtx.scale();
*
* line_profile_aa profile = new line_profile_aa(w, new gamma_none());
* renderer_outline_aa ren = new renderer_outline_aa(rb, profile);
* rasterizer_outline_aa ras = new rasterizer_outline_aa(ren);
*
* conv_transform trans = new conv_transform(g_path, mtx);
*
* ras.render_all_paths(trans, g_colors, g_path_idx, g_npaths);
*/
}
base.OnDraw();
}
//--------------------------------------------------------------------
public void TransformAllPaths(IAffineTransformMatrix <T> trans)
{
uint idx;
uint num_ver = m_vertices.TotalVertices();
for (idx = 0; idx < num_ver; idx++)
{
T x, y;
if (Path.IsVertex(m_vertices.Vertex(idx, out x, out y)))
{
//trans.Transform(ref x, ref y);
//m_vertices.ModifyVertex(idx, x, y);
IVector <T> v = trans.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
m_vertices.ModifyVertex(idx, v[0], v[1]);
}
}
}
public override void OnDraw()
{
#if use_timers
AllTimer.Start();
#endif
int width = (int)rbuf_window().Width;
int height = (int)rbuf_window().Height;
uint i;
for (i = 0; i < m_NumPaths; i++)
{
// g_colors[i].A_Byte = (byte)(m_AlphaSlider.value() * 255);
g_colors[i] = RGBA_Bytes.ModifyComponent(g_colors[i], Component.A, (byte)(m_AlphaSlider.value().ToDouble() * 255));
}
IAffineTransformMatrix <T> transform = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
transform.Translate(MatrixFactory <T> .CreateVector2D(g_base_dx.Negative(), g_base_dy.Negative()));
transform.Scale(MatrixFactory <T> .CreateVector2D(g_scale, g_scale));
transform.RotateAlong(MatrixFactory <T> .CreateVector2D(M.Zero <T>(), M.Zero <T>()), g_angle + Math.PI);
transform.Shear(MatrixFactory <T> .CreateVector2D(g_skew_x.Divide(1000.0), g_skew_y.Divide(1000.0)));
transform.Translate(MatrixFactory <T> .CreateVector2D(M.New <T>(width).Divide(2), M.New <T>(height).Divide(2)));
// This code renders the lion:
ConvTransform <T> transformedPathStorage = new ConvTransform <T>(g_PathStorage, transform);
#if use_timers
Lion50Timer.Start();
for (uint j = 0; j < 200; j++)
#endif
{
this.GetRenderer().Render(transformedPathStorage, g_colors, g_path_idx, m_NumPaths);
}
#if use_timers
Lion50Timer.Stop();
#endif
#if use_timers
AllTimer.Stop();
CExecutionTimer.Instance.AppendResultsToFile("TimingTest.txt", AllTimer.GetTotalSeconds());
CExecutionTimer.Instance.Reset();
#endif
base.OnDraw();
}
public void KeyUp(KeyEventArgs keyEvent)
{
if (keyEvent.KeyCode == Keys.Z)
{
m_TurningLeft = false;
}
if (keyEvent.KeyCode == Keys.X)
{
m_TurningRight = false;
}
if (keyEvent.KeyCode == Keys.OemPeriod)
{
m_Thrusting = false;
m_Acceleration = MatrixFactory <T> .CreateVector2D(0, 0);
}
if (keyEvent.KeyCode == Keys.OemQuestion)
{
m_FireKeyDown = false;
}
}
public void WorldTransform(List <IVector <T> > VBuffer, IVector <T> vPos)
{
//create the world transformation matrix
//Matrix4X4 matTransform = new Matrix4X4();
IAffineTransformMatrix <T> matTransform = MatrixFactory <T> .NewIdentity(VectorDimension.Three);
//scale
matTransform.Scale(MatrixFactory <T> .CreateVector2D(m_MineScale, m_MineScale));
//translate
matTransform.Translate(MatrixFactory <T> .CreateVector2D(vPos[0], vPos[1]));
//Transform the ships vertices
for (int i = 0; i < VBuffer.Count; i++)
{
IVector <T> Temp = VBuffer[i];
Temp = matTransform.TransformVector(Temp);
VBuffer[i] = Temp;
}
}
public void Transform(IAffineTransformMatrix <T> trans, uint path_id)
{
uint num_ver = m_vertices.TotalVertices();
for (; path_id < num_ver; path_id++)
{
T x, y;
uint PathAndFlags = m_vertices.Vertex(path_id, out x, out y);
if (Path.IsStop(PathAndFlags))
{
break;
}
if (Path.IsVertex(PathAndFlags))
{
//trans.Transform(ref x, ref y);
//m_vertices.ModifyVertex(path_id, x, y);
IVector <T> v1 = trans.TransformVector(MatrixFactory <T> .CreateVector2D(x, y));
m_vertices.ModifyVertex(path_id, v1[0], v1[1]);
}
}
}
public void InvertTest()
{
//Affine a = Affine.NewIdentity();
IAffineTransformMatrix <DoubleComponent> a =
MatrixFactory <DoubleComponent> .NewIdentity(VectorDimension.Two);
a.Translate(
MatrixFactory <DoubleComponent> .CreateVector2D(
M.New <DoubleComponent>(10),
M.New <DoubleComponent>(10)));
IAffineTransformMatrix <DoubleComponent> b = MatrixFactory <DoubleComponent> .CreateAffine(a);
b = b.Inverse;
DoubleComponent x = 100;
DoubleComponent y = 100;
DoubleComponent newx = x;
DoubleComponent newy = y;
IVector <DoubleComponent> v1 =
MatrixFactory <DoubleComponent> .CreateVector2D(
M.New <DoubleComponent>(100),
M.New <DoubleComponent>(100));
IVector <DoubleComponent> v2 = a.TransformVector(v1);
IVector <DoubleComponent> v3 = b.TransformVector(v2);
//a.Transform(ref newx, ref newy);
//b.Transform(ref newx, ref newy);
Assert.AreEqual((double)v1[0], (double)v3[0], .001);
Assert.AreEqual((double)v1[1], (double)v3[1], .001);
}
void transform_image(double angle)
{
double width = rbuf_img(0).Width;
double height = rbuf_img(0).Height;
#if SourceDepth24
FormatRGB pixf = new FormatRGB(rbuf_img(0), new BlenderBGR());
FormatRGB pixf_pre = new FormatRGB(rbuf_img(0), new BlenderPreMultBGR());
#else
pixfmt_alpha_blend_rgba32 pixf = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra32());
pixfmt_alpha_blend_rgba32 pixf_pre = new pixfmt_alpha_blend_rgba32(rbuf_img(0), new blender_bgra_pre());
#endif
FormatClippingProxy rb = new FormatClippingProxy(pixf);
FormatClippingProxy rb_pre = new FormatClippingProxy(pixf_pre);
rb.Clear(new RGBA_Doubles(1.0, 1.0, 1.0));
IAffineTransformMatrix <T> src_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(-width / 2.0, -height / 2.0));
src_mtx.RotateAlong(MatrixFactory <T> .CreateVector2D(0, 0), angle * Math.PI / 180.0);
src_mtx.Translate(MatrixFactory <T> .CreateVector2D(width / 2.0, height / 2.0));
IAffineTransformMatrix <T> img_mtx = MatrixFactory <T> .CreateAffine(src_mtx);
img_mtx = img_mtx.Inverse;
double r = width;
if (height < r)
{
r = height;
}
r *= 0.5;
r -= 4.0;
VertexSource.Ellipse <T> ell = new AGG.VertexSource.Ellipse <T>(width / 2.0, height / 2.0, r, r, 200);
ConvTransform <T> tr = new ConvTransform <T>(ell, src_mtx);
m_num_pix += r * r * Math.PI;
SpanInterpolatorLinear <T> interpolator = new SpanInterpolatorLinear <T>(img_mtx);
ImageFilterLookUpTable <T> filter = new ImageFilterLookUpTable <T>();
bool norm = m_normalize.status();
#if SourceDepth24
FormatRGB pixf_img = new FormatRGB(rbuf_img(1), new BlenderBGR());
#else
pixfmt_alpha_blend_rgba32 pixf_img = new pixfmt_alpha_blend_rgba32(rbuf_img(1), new blender_bgra32());
#endif
RasterBufferAccessorClip source = new RasterBufferAccessorClip(pixf_img, RGBA_Doubles.RgbaPre(0, 0, 0, 0));
switch (m_filters.cur_item())
{
case 0:
{
#if SourceDepth24
SpanImageFilterRgbNN <T> sg = new SpanImageFilterRgbNN <T>(source, interpolator);
#else
span_image_filter_rgba_nn sg = new span_image_filter_rgba_nn(source, interpolator);
#endif
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
case 1:
{
#if SourceDepth24
//span_image_filter_rgb_bilinear_clip sg = new span_image_filter_rgb_bilinear_clip(pixf_img, rgba.rgba_pre(0, 0.4, 0, 0.5), interpolator);
SpanImageFilterRgbBilinear <T> sg = new SpanImageFilterRgbBilinear <T>(source, interpolator);
#else
//span_image_filter_rgba_bilinear_clip sg = new span_image_filter_rgba_bilinear_clip(pixf_img, rgba.rgba_pre(0, 0, 0, 0), interpolator);
span_image_filter_rgba_bilinear sg = new span_image_filter_rgba_bilinear(source, interpolator);
#endif
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
case 5:
case 6:
case 7:
{
switch (m_filters.cur_item())
{
case 5: filter.Calculate(new ImageFilterHanning <T>(), norm); break;
case 6: filter.Calculate(new ImageFilterHamming <T>(), norm); break;
case 7: filter.Calculate(new ImageFilterHermite <T>(), norm); break;
}
SpanImageFilterRgb2x2 <T> sg = new SpanImageFilterRgb2x2 <T>(source, interpolator, filter);
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
case 2:
case 3:
case 4:
case 8:
case 9:
case 10:
case 11:
case 12:
case 13:
case 14:
case 15:
case 16:
{
switch (m_filters.cur_item())
{
case 2: filter.Calculate(new ImageFilterBicubic <T>(), norm); break;
case 3: filter.Calculate(new ImageFilterSpline16 <T>(), norm); break;
case 4: filter.Calculate(new ImageFilterSpline36 <T>(), norm); break;
case 8: filter.Calculate(new ImageFilterKaiser <T>(), norm); break;
case 9: filter.Calculate(new ImageFilterQuadric <T>(), norm); break;
case 10: filter.Calculate(new ImageFilterCatrom <T>(), norm); break;
case 11: filter.Calculate(new ImageFilterGaussian <T>(), norm); break;
case 12: filter.Calculate(new ImageFilterBessel <T>(), norm); break;
case 13: filter.Calculate(new ImageFilterMitchell <T>(), norm); break;
case 14: filter.Calculate(new ImageFilterSinc <T>(m_radius.value()), norm); break;
case 15: filter.Calculate(new ImageFilterLanczos <T>(m_radius.value()), norm); break;
case 16:
filter.Calculate(new ImageFilterBlackman <T>(m_radius.value()), norm);
break;
}
#if SourceDepth24
SpanImageFilterRgb <T> sg = new SpanImageFilterRgb <T>(source, interpolator, filter);
#else
span_image_filter_rgb sg = new span_image_filter_rgba(source, interpolator, filter);
#endif
m_Rasterizer.AddPath(tr);
Renderer <T> .GenerateAndRender(m_Rasterizer, m_ScanlineUnpacked, rb_pre, m_SpanAllocator, sg);
}
break;
}
}
public blur_application(PixelFormats format, ERenderOrigin RenderOrigin)
: base(format, RenderOrigin)
{
m_rbuf2 = new RasterBuffer();
m_shape_bounds = new RectDouble <T>();
m_method = new rbox_ctrl <T>(10.0, 10.0, 130.0, 70.0);
m_radius = new SliderWidget <T>(130 + 10.0, 10.0 + 4.0, 130 + 300.0, 10.0 + 8.0 + 4.0);
m_shadow_ctrl = new polygon_ctrl <T>(4);
m_channel_r = new cbox_ctrl <T>(10.0, 80.0, "Red");
m_channel_g = new cbox_ctrl <T>(10.0, 95.0, "Green");
m_channel_b = new cbox_ctrl <T>(10.0, 110.0, "Blue");
m_FlattenCurves = new cbox_ctrl <T>(10, 315, "Convert And Flatten Curves");
m_FlattenCurves.status(true);
AddChild(m_method);
m_method.text_size(8);
m_method.add_item("Stack Blur");
m_method.add_item("Recursive Blur");
m_method.add_item("Channels");
m_method.cur_item(1);
AddChild(m_radius);
m_radius.range(0.0, 40.0);
m_radius.value(15.0);
m_radius.label("Blur Radius={0:F2}");
AddChild(m_shadow_ctrl);
AddChild(m_channel_r);
AddChild(m_channel_g);
AddChild(m_channel_b);
AddChild(m_FlattenCurves);
m_channel_g.status(true);
m_sl = new ScanlinePacked8();
m_path = new PathStorage <T>();
m_shape = new ConvCurve <T>(m_path);
m_path.RemoveAll();
m_path.MoveTo(28.47, 6.45);
m_path.Curve3(21.58, 1.12, 19.82, 0.29);
m_path.Curve3(17.19, -0.93, 14.21, -0.93);
m_path.Curve3(9.57, -0.93, 6.57, 2.25);
m_path.Curve3(3.56, 5.42, 3.56, 10.60);
m_path.Curve3(3.56, 13.87, 5.03, 16.26);
m_path.Curve3(7.03, 19.58, 11.99, 22.51);
m_path.Curve3(16.94, 25.44, 28.47, 29.64);
m_path.LineTo(28.47, 31.40);
m_path.Curve3(28.47, 38.09, 26.34, 40.58);
m_path.Curve3(24.22, 43.07, 20.17, 43.07);
m_path.Curve3(17.09, 43.07, 15.28, 41.41);
m_path.Curve3(13.43, 39.75, 13.43, 37.60);
m_path.LineTo(13.53, 34.77);
m_path.Curve3(13.53, 32.52, 12.38, 31.30);
m_path.Curve3(11.23, 30.08, 9.38, 30.08);
m_path.Curve3(7.57, 30.08, 6.42, 31.35);
m_path.Curve3(5.27, 32.62, 5.27, 34.81);
m_path.Curve3(5.27, 39.01, 9.57, 42.53);
m_path.Curve3(13.87, 46.04, 21.63, 46.04);
m_path.Curve3(27.59, 46.04, 31.40, 44.04);
m_path.Curve3(34.28, 42.53, 35.64, 39.31);
m_path.Curve3(36.52, 37.21, 36.52, 30.71);
m_path.LineTo(36.52, 15.53);
m_path.Curve3(36.52, 9.13, 36.77, 7.69);
m_path.Curve3(37.01, 6.25, 37.57, 5.76);
m_path.Curve3(38.13, 5.27, 38.87, 5.27);
m_path.Curve3(39.65, 5.27, 40.23, 5.62);
m_path.Curve3(41.26, 6.25, 44.19, 9.18);
m_path.LineTo(44.19, 6.45);
m_path.Curve3(38.72, -0.88, 33.74, -0.88);
m_path.Curve3(31.35, -0.88, 29.93, 0.78);
m_path.Curve3(28.52, 2.44, 28.47, 6.45);
m_path.ClosePolygon();
m_path.MoveTo(28.47, 9.62);
m_path.LineTo(28.47, 26.66);
m_path.Curve3(21.09, 23.73, 18.95, 22.51);
m_path.Curve3(15.09, 20.36, 13.43, 18.02);
m_path.Curve3(11.77, 15.67, 11.77, 12.89);
m_path.Curve3(11.77, 9.38, 13.87, 7.06);
m_path.Curve3(15.97, 4.74, 18.70, 4.74);
m_path.Curve3(22.41, 4.74, 28.47, 9.62);
m_path.ClosePolygon();
IAffineTransformMatrix <T> shape_mtx = MatrixFactory <T> .NewIdentity(VectorDimension.Two);
shape_mtx.Scale(M.New <T>(4.0));
shape_mtx.Translate(MatrixFactory <T> .CreateVector2D(150, 100));
m_path.Transform(shape_mtx);
BoundingRect <T> .BoundingRectSingle(m_shape, 0, ref m_shape_bounds);
m_shadow_ctrl.SetXN(0, m_shape_bounds.x1);
m_shadow_ctrl.SetYN(0, m_shape_bounds.y1);
m_shadow_ctrl.SetXN(1, m_shape_bounds.x2);
m_shadow_ctrl.SetYN(1, m_shape_bounds.y1);
m_shadow_ctrl.SetXN(2, m_shape_bounds.x2);
m_shadow_ctrl.SetYN(2, m_shape_bounds.y2);
m_shadow_ctrl.SetXN(3, m_shape_bounds.x1);
m_shadow_ctrl.SetYN(3, m_shape_bounds.y2);
m_shadow_ctrl.line_color(new RGBA_Doubles(0, 0.3, 0.5, 0.3));
}
