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)); }