/// <summary> /// Initializes a new instance of the <see cref="Texture"/> class. /// </summary> /// <param name="renderer">Renderer to use.</param> public Texture(RendererBase renderer) { m_Renderer = renderer; Width = 4; Height = 4; Failed = false; }
protected virtual void DrawTileLayers(RendererBase <ToyWorld> renderer, ToyWorld world) { var gridView = GridView; int tileCount = gridView.Size.Size(); // Draw tile layers int i = 0; foreach (var tileLayer in GetTileLayersToRender()) { // Set up transformation to screen space for tiles // Model transform -- scale from (-1,1) to viewSize/2, center on origin Matrix transform = Matrix.CreateScale(new Vector3(gridView.Size, tileLayer.Thickness) * 0.5f); // World transform -- move center to view center if (Settings.Use3D) { transform *= Matrix.CreateTranslation(new Vector3(gridView.Center, tileLayer.SpanIntervalFrom)); } else { transform *= Matrix.CreateTranslation(new Vector3(gridView.Center, tileLayer.SpanIntervalFrom + tileLayer.Thickness / 2)); } // View and projection transforms transform *= Owner.ViewProjectionMatrix; Effect.ModelViewProjectionUniform(ref transform); Effect.TileTypesIdxOffsetUniform(i++ *tileCount); // Using the tileTypes texture should block until the data is fully copied from the pbos (onPreDraw) Grid.Draw(); } }
public override void Render(Canvas2D canvas, RendererBase renderer) { if (BonusAnimation != null) { renderer.Render(canvas, this); } }
public void Draw(RendererBase render, Rectangle r, Color col) { if (m_Texture == null) { return; } render.DrawColor = col; if (r.Width < m_Width && r.Height < m_Height) { render.DrawTexturedRect(m_Texture, r, m_Rects[0].uv[0], m_Rects[0].uv[1], m_Rects[8].uv[2], m_Rects[8].uv[3]); return; } DrawRect(render, 0, r.X, r.Y, m_Margin.Left, m_Margin.Top); DrawRect(render, 1, r.X + m_Margin.Left, r.Y, r.Width - m_Margin.Left - m_Margin.Right, m_Margin.Top); DrawRect(render, 2, (r.X + r.Width) - m_Margin.Right, r.Y, m_Margin.Right, m_Margin.Top); DrawRect(render, 3, r.X, r.Y + m_Margin.Top, m_Margin.Left, r.Height - m_Margin.Top - m_Margin.Bottom); DrawRect(render, 4, r.X + m_Margin.Left, r.Y + m_Margin.Top, r.Width - m_Margin.Left - m_Margin.Right, r.Height - m_Margin.Top - m_Margin.Bottom); DrawRect(render, 5, (r.X + r.Width) - m_Margin.Right, r.Y + m_Margin.Top, m_Margin.Right, r.Height - m_Margin.Top - m_Margin.Bottom); DrawRect(render, 6, r.X, (r.Y + r.Height) - m_Margin.Bottom, m_Margin.Left, m_Margin.Bottom); DrawRect(render, 7, r.X + m_Margin.Left, (r.Y + r.Height) - m_Margin.Bottom, r.Width - m_Margin.Left - m_Margin.Right, m_Margin.Bottom); DrawRect(render, 8, (r.X + r.Width) - m_Margin.Right, (r.Y + r.Height) - m_Margin.Bottom, m_Margin.Right, m_Margin.Bottom); }
public override void Init(RendererBase <ToyWorld> renderer, ToyWorld world, ImageSettings settings) { Settings = settings; int bufferSize = Owner.Resolution.Width * Owner.Resolution.Height; switch (Settings.CopyMode) { case RenderRequestImageCopyingMode.OpenglPbo: // Set up pixel buffer object for data transfer to RR issuer Pbo = new Pbo <uint>(); Pbo.Init(bufferSize, null, BufferUsageHint.StreamDraw); if (Settings.CopyDepth) { DepthPbo = new Pbo <float>(); DepthPbo.Init(bufferSize, null, BufferUsageHint.StreamDraw); } break; case RenderRequestImageCopyingMode.Cpu: if (RenderedScene == null || RenderedScene.Length < bufferSize) { RenderedScene = new uint[bufferSize]; if (Settings.CopyDepth) { RenderedSceneDepth = new float[bufferSize]; } } break; } }
/// <summary> /// Renders the currently visible tooltip. /// </summary> /// <param name="skin"></param> public static void RenderToolTip(SkinBase skin) { if (null == g_ToolTip) { return; } RendererBase render = skin.Renderer; Point oldRenderOffset = render.RenderOffset; Point mousePos = Input.InputHandler.MousePosition; Rectangle bounds = g_ToolTip.ToolTip.Bounds; Rectangle offset = Util.FloatRect(mousePos.X - bounds.Width * 0.5f, mousePos.Y - bounds.Height - 10, bounds.Width, bounds.Height); offset = Util.ClampRectToRect(offset, g_ToolTip.GetCanvas().Bounds); //Calculate offset on screen bounds render.AddRenderOffset(offset); render.EndClip(); skin.DrawToolTip(g_ToolTip.ToolTip); g_ToolTip.ToolTip.DoRender(skin); render.RenderOffset = oldRenderOffset; }
public override void Draw(RendererBase <ToyWorld> renderer, ToyWorld world) { if (Settings.EnabledPostprocessing == RenderRequestPostprocessing.None) { return; } GL.Disable(EnableCap.Blend); // Always draw post-processing from the front to the back buffer Owner.BackFbo.Bind(); if (Settings.EnabledPostprocessing.HasFlag(RenderRequestPostprocessing.Noise)) { renderer.EffectManager.Use(m_noiseEffect); renderer.TextureManager.Bind( Owner.FrontFbo[FramebufferAttachment.ColorAttachment0], // Use data from front Fbo Owner.GetTextureUnit(RenderRequestBase.TextureBindPosition.PostEffectTextureBindPosition)); // Advance noise time by a visually pleasing step; wrap around if we run for waaaaay too long. double step = 0.005d; double seed = renderer.SimTime * step % 3e6d; m_noiseEffect.TimeStepUniform(new Vector2((float)seed, (float)step)); m_noiseEffect.VarianceUniform(Settings.NoiseIntensityCoefficient); Owner.Quad.Draw(); Owner.SwapBuffers(); } // more stuffs // The final scene should be left in the front buffer }
protected override void DoDraw(RendererBase destRenderer) { ImageBuffer imageToDraw = ImageSequenceReference.Instance.GetImageByTime(m_TotalSeconds); //Image imageToDraw = m_PlayerShipSequence.GetImageByIndex(m_ImageIndex); //IBlender blender = new BlenderBGRA(); IBlender blender = new BlenderPreMultBGR(); /* unsafe { IImage destBuffer = destRenderer.DestImage; byte* pPixels = destBuffer.GetPixelPointerY(200); byte[] sourceBuffer = imageToDraw.ByteBuffer; for (int y = 0; y < imageToDraw.Height(); y++) { int SourceYOffset = y * imageToDraw.StrideInBytes(); int destYOffset = (int)destBuffer.StrideInBytesAbs() * y; for (int x = 0; x < imageToDraw.Width(); x++) { int sourceOffset = SourceYOffset + x * 4; RGBA_Bytes sourceColor = new RGBA_Bytes(sourceBuffer[sourceOffset + 2], sourceBuffer[sourceOffset + 1], sourceBuffer[sourceOffset + 0], sourceBuffer[sourceOffset + 3]); blender.BlendPixel(&pPixels[destYOffset + x * 4], sourceColor); } } } */ }
public override void OnDraw(RendererBase rendererToDrawWith) { ImageSequence menuBackground = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "CreditsScreen"); rendererToDrawWith.Render(menuBackground.GetImageByIndex(0), 0, 0); base.OnDraw(rendererToDrawWith); }
public void SetRendererPreDraw(ImageBuffer background, RendererBase rendererToDrawWith, Player playerToCenterOn) { rendererToDrawWith.PushTransform(); Vector2D windowCenter = new Vector2D(screenWindow.Left + (screenWindow.Right - screenWindow.Left) / 2, screenWindow.Bottom + (screenWindow.Top - screenWindow.Bottom) / 2); Vector2D playerPos = playerToCenterOn.Position; Vector2D playfieldOffset = windowCenter - playerPos; if (playfieldOffset.x > screenWindow.Left) { playfieldOffset.x = screenWindow.Left; } if (playfieldOffset.x < -background.Width() + screenWindow.Right) { playfieldOffset.x = -background.Width() + screenWindow.Right; } if (playfieldOffset.y > screenWindow.Bottom) { playfieldOffset.y = screenWindow.Bottom; } if (playfieldOffset.y < -background.Height() + screenWindow.Top) { playfieldOffset.y = -background.Height() + screenWindow.Top; } Affine translation = Affine.NewTranslation(playfieldOffset); rendererToDrawWith.SetTransform(rendererToDrawWith.GetTransform() * translation); rendererToDrawWith.SetClippingRect(screenWindow); }
/// <summary> /// Gets a <see cref="SceneObject"/> that contains this renderer. /// </summary> /// <param name="renderer"></param> /// <param name="name"></param> /// <param name="scripts"></param> /// <returns></returns> public static SceneObject WrapToSceneObject( this RendererBase renderer, string name, params Script[] scripts) { return(WrapToSceneObject(renderer, name, false, scripts)); }
protected override void DoInitialize() { var boxObj = new SceneObject(); boxObj.Name = "Box's Object"; { RendererBase renderer = this.BindingObject.Renderer; if (!renderer.IsInitialized) { renderer.Initialize(); } var modelSize = renderer as IModelSize; vec3 lengths = new vec3(modelSize.XLength, modelSize.YLength, modelSize.ZLength); var boxRenderer = BoundingBoxRenderer.Create(lengths); { var transform = this.BindingObject.Renderer as IModelTransform; vec3 position = transform.ModelMatrix.GetTranslate(); //boxRenderer.ModelMatrix = glm.translate(mat4.identity(), position); boxRenderer.ModelMatrix = transform.ModelMatrix; } //boxRenderer.Initialize(); boxObj.Renderer = boxRenderer; this.boxRenderer = boxRenderer; } { this.BindingObject.Children.Add(boxObj); } }
/// <summary> /// Renders the canvas. Call in your rendering loop. /// </summary> public void RenderCanvas() { DoThink(); RendererBase render = Skin.Renderer; render.Begin(); RecurseLayout(Skin); render.ClipRegion = Bounds; render.RenderOffset = Point.Empty; render.Scale = Scale; if (ShouldDrawBackground) { render.DrawColor = m_BackgroundColor; render.DrawFilledRect(RenderBounds); } DoRender(Skin); DragAndDrop.RenderOverlay(this, Skin); Gwen.ToolTip.RenderToolTip(Skin); render.EndClip(); render.End(); }
protected override void DoDraw(RendererBase destRenderer) { ImageBuffer imageToDraw = ImageSequenceReference.Instance.GetImageByTime(m_TotalSeconds); //Image imageToDraw = m_PlayerShipSequence.GetImageByIndex(m_ImageIndex); //IBlender blender = new BlenderBGRA(); IBlender blender = new BlenderPreMultBGR(); /* * unsafe * { * IImage destBuffer = destRenderer.DestImage; * byte* pPixels = destBuffer.GetPixelPointerY(200); * byte[] sourceBuffer = imageToDraw.ByteBuffer; * for (int y = 0; y < imageToDraw.Height(); y++) * { * int SourceYOffset = y * imageToDraw.StrideInBytes(); * int destYOffset = (int)destBuffer.StrideInBytesAbs() * y; * for (int x = 0; x < imageToDraw.Width(); x++) * { * int sourceOffset = SourceYOffset + x * 4; * RGBA_Bytes sourceColor = new RGBA_Bytes(sourceBuffer[sourceOffset + 2], sourceBuffer[sourceOffset + 1], sourceBuffer[sourceOffset + 0], sourceBuffer[sourceOffset + 3]); * blender.BlendPixel(&pPixels[destYOffset + x * 4], sourceColor); * } * } * } */ }
public override void Render(Canvas2D canvas, RendererBase renderer) { if (Sprite != null) { renderer.Render(canvas, this); } }
protected override void Dispose(bool disposing) { if (disposing) { goto label_3; } label_2: base.Dispose(disposing); return; label_3: while (this.xa2c39ea75c543fc7 != null) { this.xa2c39ea75c543fc7.Dispose(); this.xa2c39ea75c543fc7 = (RendererBase)null; if (true) { break; } } this.Manager = (SandDockManager)null; this.xac1c850120b1f254.x9b21ee8e7ceaada3 -= new xf8f9565783602018.x58986a4a0b75e5b5(this.xa3a7472ac4e61f76); this.xac1c850120b1f254.Dispose(); goto label_2; }
protected override void DoDraw(RendererBase destRenderer) { int playerSequenceIndex = GetPlayerIndex(); ImageBuffer playerImage = ((ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "Players")).GetImageByIndex(playerSequenceIndex); destRenderer.Render(playerImage, m_Position.x, m_Position.y); }
protected override void DoDraw(RendererBase <T> destRenderer) { Image <T> imageToDraw = ImageSequenceReference.Instance.GetImageByTime(m_TotalSeconds); //Image imageToDraw = m_PlayerShipSequence.GetImageByIndex(m_ImageIndex); //IBlender blender = new BlenderBGRA(); IBlender blender = new BlenderAddativeBGR(); unsafe { RasterBuffer destBuffer = destRenderer.PixelFormat.GetRenderingBuffer(); byte * pPixels = destBuffer.GetPixelPointer(200); byte[] sourceBuffer = imageToDraw.ImageBuffer; for (int y = 0; y < imageToDraw.Height; y++) { int SourceYOffset = y * imageToDraw.ScanWidthInBytes; int destYOffset = (int)destBuffer.StrideInBytesAbs * y; for (int x = 0; x < imageToDraw.Width; x++) { int sourceOffset = SourceYOffset + x * 4; blender.BlendPix(&pPixels[destYOffset + x * 4], sourceBuffer[sourceOffset + 2], sourceBuffer[sourceOffset + 1], sourceBuffer[sourceOffset + 0], sourceBuffer[sourceOffset + 3]); } } } }
public void ChangeRenderer(int aRendererIndex) { theGameEngine.Pause(); theRendererManager.SetRenderer(aRendererIndex, theGameStatus, TheUserInputPlayer); theRenderer = theRendererManager.TheRenderer; theGameEngine.Resume(); theRendererManager.Start(); }
public void Write(RendererBase renderer, MarkdownObject astNode) { var extensionHtmlRenderer = renderer as ExtensionHtmlRenderer; var extensionBlock = astNode as IExtensionBlock; var model = (TModel)extensionHtmlRenderer.GetBlockModel(extensionBlock); Render(extensionHtmlRenderer, model, extensionHtmlRenderer.FormatState); }
/// <summary> /// Gets a <see cref="SceneObject"/> that contains this renderer. /// </summary> /// <param name="renderer"></param> /// <param name="scripts"></param> /// <returns></returns> public static SceneObject WrapToSceneObject( this RendererBase renderer, params Script[] scripts) { string name = string.Format("{0}", renderer); return(WrapToSceneObject(renderer, name, false, scripts)); }
protected internal virtual void Layout( RendererBase renderer, Graphics graphics, Rectangle bounds, bool floating) { this.xda73fcb97c77d998 = bounds; }
public void MirrorAsNeeded(RendererBase <T> destRenderer) { IVector <T> oldPosition = Position; MirrorOnX(destRenderer); MirrorOnY(destRenderer); MirrorOnX(destRenderer); Position = oldPosition; }
protected void DrawAvatarTool(RendererBase <ToyWorld> renderer, IAvatar avatar, Vector2 size, Vector2 position, ToolBackgroundType type = ToolBackgroundType.BrownBorder) { GameObjectPainter goPainter = Owner.GameObjectPainter; GL.Enable(EnableCap.Blend); Owner.SetDefaultBlending(); // Bind stuff to GL (used in overrides) renderer.TextureManager.Bind(goPainter.TilesetTexture); renderer.EffectManager.Use(goPainter.Effect); goPainter.Effect.TextureUniform(0); if (Owner.FlipYAxis) { size.Y = -size.Y; position.Y = -position.Y; } Matrix transform = Matrix.CreateScale(size); transform *= Matrix.CreateTranslation(position.X, position.Y, 0.01f); // Draw the inventory background renderer.TextureManager.Bind(m_overlayTexture, Owner.GetTextureUnit(RenderRequestBase.TextureBindPosition.Ui)); renderer.EffectManager.Use(m_overlayEffect); m_overlayEffect.TextureUniform((int)RenderRequestBase.TextureBindPosition.Ui); m_overlayEffect.TileTypesTextureUniform((int)RenderRequestBase.TextureBindPosition.TileTypes); m_overlayEffect.TileTypesIdxOffsetUniform(0); m_overlayEffect.ModelViewProjectionUniform(ref transform); goPainter.LocalTileTypesBuffer[0] = (ushort)type; if (avatar.Tool != null) { goPainter.LocalTileTypesBuffer[1] = (ushort)avatar.Tool.TilesetId; } GL.BindBuffer(BufferTarget.PixelUnpackBuffer, 0); goPainter.TileTypesTexure.Update1D(2, dataType: PixelType.UnsignedShort, data: goPainter.LocalTileTypesBuffer); QuadOffset.Draw(); // Draw the inventory Tool if (avatar.Tool != null) { renderer.TextureManager.Bind(goPainter.TilesetTexture); renderer.EffectManager.Use(goPainter.Effect); goPainter.Effect.DiffuseUniform(new Vector4(1, 1, 1, 1)); goPainter.Effect.TileTypesIdxOffsetUniform(1); Matrix toolTransform = Matrix.CreateScale(0.7f) * transform; goPainter.Effect.ModelViewProjectionUniform(ref toolTransform); QuadOffset.Draw(); } }
/// <summary> /// Gets a <see cref="SceneObject"/> that contains this renderer. /// </summary> /// <param name="renderer"></param> /// <param name="generateBoundingBox"></param> /// <param name="scripts"></param> /// <returns></returns> public static SceneObject WrapToSceneObject( this RendererBase renderer, bool generateBoundingBox, params Script[] scripts) { string name = string.Format("{0}", renderer); return(WrapToSceneObject(renderer, name, generateBoundingBox, scripts)); }
private void Form_Load(object sender, EventArgs e) { { var camera = new Camera( new vec3(0, 0, 5), new vec3(0, 0, 0), new vec3(0, 1, 0), CameraType.Perspecitive, this.glCanvas1.Width, this.glCanvas1.Height); var rotator = new SatelliteManipulater(); rotator.Bind(camera, this.glCanvas1); this.scene = new Scene(camera, this.glCanvas1); this.scene.RootViewPort.ClearColor = Color.SkyBlue; this.glCanvas1.Resize += this.scene.Resize; } { const int gridsPer2Unit = 20; const int scale = 2; var ground = GroundRenderer.Create(new GroundModel(gridsPer2Unit * scale)); ground.Scale = new vec3(scale, scale, scale); var obj = new SceneObject(); obj.Renderer = ground; this.scene.RootObject.Children.Add(obj); } { SimpleRenderer movableRenderer = SimpleRenderer.Create(new Teapot()); movableRenderer.RotationAxis = new vec3(0, 1, 0); movableRenderer.Scale = new vec3(0.1f, 0.1f, 0.1f); this.movableRenderer = movableRenderer; SceneObject obj = movableRenderer.WrapToSceneObject(); this.scene.RootObject.Children.Add(obj); } { BillboardRenderer billboardRenderer = BillboardRenderer.Create(new BillboardModel()); SceneObject obj = billboardRenderer.WrapToSceneObject(new UpdateBillboardPosition(movableRenderer)); this.scene.RootObject.Children.Add(obj); } { LabelRenderer labelRenderer = LabelRenderer.Create(); labelRenderer.Text = "Teapot - CSharpGL"; SceneObject obj = labelRenderer.WrapToSceneObject(new UpdateLabelPosition(movableRenderer)); this.scene.RootObject.Children.Add(obj); } { var uiAxis = new UIAxis(AnchorStyles.Left | AnchorStyles.Bottom, new Padding(3, 3, 3, 3), new Size(128, 128)); this.scene.RootUI.Children.Add(uiAxis); } { var frmPropertyGrid = new FormProperyGrid(this.scene); frmPropertyGrid.Show(); } { var frmPropertyGrid = new FormProperyGrid(this.glCanvas1); frmPropertyGrid.Show(); } { this.scene.Start(); } }
/// <summary> /// Initializes a new instance of the <see cref="Font"/> class. /// </summary> /// <param name="renderer">Renderer to use.</param> /// <param name="faceName">Face name.</param> /// <param name="size">Font size.</param> public Font(RendererBase renderer, String faceName, int size = 10) { m_Renderer = renderer; FaceName = faceName; Size = size; Smooth = false; //Bold = false; //DropShadow = false; }
public void DrawCenter(RendererBase render, Rectangle r, Color col) { r.X += (int)((r.Width - m_Width) * 0.5); r.Y += (int)((r.Height - m_Height) * 0.5); r.Width = m_Width; r.Height = m_Height; Draw(render, r, col); }
public void DrawCenter(RendererBase render, Rectangle r) { if (m_Texture == null) { return; } DrawCenter(render, r, Color.White); }
public TexturedSkin(RendererBase renderer, Stream textureData) : base(renderer) { m_Texture = new Texture(Renderer); m_Texture.LoadStream(textureData); InitializeColors(); InitializeTextures(); }
/// <summary> /// Initializes a new instance of the <see cref="TexturedBase"/> class. /// </summary> /// <param name="renderer">Renderer to use.</param> /// <param name="textureName">Name of the skin texture map.</param> public TexturedSkin(RendererBase renderer, String textureName) : base(renderer) { m_Texture = new Texture(Renderer); m_Texture.Load(textureName); InitializeColors(); InitializeTextures(); }
public override void OnDraw() { RendererBase <T> rendererForSurfaceThisIsOn = Parrent.GetRenderer(); for (uint i = 0; i < num_paths(); i++) { rendererForSurfaceThisIsOn.Render(this, i, color(i).GetAsRGBA_Bytes()); } base.OnDraw(); }
public void Draw(RendererBase render, Rectangle r, Color col) { if (m_Texture == null) { return; } render.DrawColor = col; render.DrawTexturedRect(m_Texture, r, m_uv[0], m_uv[1], m_uv[2], m_uv[3]); }
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 PixMap(PixelFormat format, uint width, uint height) : this() { Guard.GreaterThan(width, 0u); Guard.GreaterThan(height, 0u); _pixelFormat = _injector.Resolve<IPixelFormatFactory>().CreatePixelFormat(format, width, height, out imageBytes); _buffer = _pixelFormat.GetRenderingBuffer(); _renderer = this._injector.Resolve<RendererBase>(); _scanlineCache = this._injector.Resolve<IScanlineCache>(); _rasterizer = this._injector.Resolve<IRasterizer>(); }
public override void Draw(RendererBase<ToyWorld> renderer, ToyWorld world) { if (Settings.EnabledOverlays == RenderRequestOverlay.None) return; base.Draw(renderer, world); if (Settings.EnabledOverlays.HasFlag(RenderRequestOverlay.InventoryTool)) DrawAvatarTool( renderer, world.GetAvatar(Owner.AvatarID), (Vector2)Settings.ToolSize, (Vector2)Settings.ToolPosition, Settings.ToolBackground); }
protected abstract void DoDraw(RendererBase destRenderer);
private void MirrorOnY(RendererBase destRenderer) { if(Position.y < Radius) { Vector2D oldPosition = Position; oldPosition.y += GameHeight; Position = oldPosition; this.DoDraw(destRenderer); } else if (Position.y > GameHeight - Radius) { Vector2D oldPosition = Position; oldPosition.y -= GameHeight; Position = oldPosition; this.DoDraw(destRenderer); } }
private void MirrorOnX(RendererBase destRenderer) { if(Position.x < Radius) { Vector2D oldPosition = Position; oldPosition.x += GameWidth; Position = oldPosition; DoDraw(destRenderer); } else if (Position.x > GameWidth - Radius) { Vector2D oldPosition = Position; oldPosition.x -= GameWidth; Position = oldPosition; DoDraw(destRenderer); } }
public LightScript(ICanvas canvas, ICamera camera, RendererBase renderer) { this.canvas = canvas; this.camera = camera; this.manipulater = new TranslateManipulater(renderer); }
public void MirrorAsNeeded(RendererBase destRenderer) { Vector2D oldPosition = Position; MirrorOnX(destRenderer); MirrorOnY(destRenderer); MirrorOnX(destRenderer); Position = oldPosition; }
public override void OnDraw(RendererBase rendererToDrawWith) { ImageBuffer levelMap = playfield.LevelMap; int offset; byte[] buffer = levelMap.GetBuffer(out offset); if (!haveDrawnWalls) { RendererBase backgroundRenderer = BackgroundImage.NewRenderer(); rect_i boundsI = BackgroundImage.GetBoundingRect(); rect_d bounds = new rect_d(boundsI.Left, boundsI.Bottom, boundsI.Right, boundsI.Top); backgroundRenderer.SetClippingRect(bounds); ImageSequence wallTileSequence = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "WallTile"); for (int y = 0; y < levelMap.Height(); y++) { for (int x = 0; x < levelMap.Width(); x++) { if (buffer[levelMap.GetBufferOffsetXY(x, y)] == 0) { int index = 0; // what type of wall if (x < levelMap.Width() -1 && buffer[levelMap.GetBufferOffsetXY(x + 1, y + 0)] == 0) { index |= 8; } if (y < levelMap.Height() -1 && buffer[levelMap.GetBufferOffsetXY(x + 0, y + 1)] == 0) { index |= 4; } if (x > 0 && buffer[levelMap.GetBufferOffsetXY(x - 1, y + 0)] == 0) { index |= 2; } if (y > 0 && buffer[levelMap.GetBufferOffsetXY(x + 0, y - 1)] == 0) { index |= 1; } backgroundRenderer.Render(wallTileSequence.GetImageByIndex(index), x * 16, y * 16); } } } haveDrawnWalls = true; } //for (int i = 0; i < 1; i++) for (int i = 0; i < numPlayers; i++) { playerViews[i].SetRendererPreDraw(BackgroundImage, rendererToDrawWith, playfield.PlayerList[i]); rendererToDrawWith.Render(BackgroundImage, 0, 0); foreach (SequenceEntity aSequenceEntity in playfield.SequenceEntityList) { aSequenceEntity.Draw(rendererToDrawWith); } foreach (Player aPlayer in playfield.PlayerList) { aPlayer.Draw(rendererToDrawWith); } playfield.sword.Draw(rendererToDrawWith); playfield.key.Draw(rendererToDrawWith); playfield.shield.Draw(rendererToDrawWith); playerViews[i].SetRendererPostDraw(rendererToDrawWith); } ImageSequence hud = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), (playfield.PlayerList.Count).ToString() + "PlayerHUD"); rendererToDrawWith.Render(hud.GetImageByIndex(0), 400, 300); foreach (Player aPlayer in playfield.PlayerList) { aPlayer.DrawScore(rendererToDrawWith); } rendererToDrawWith.Line(0.5, 300.5, 800.5, 300.5, new RGBA_Bytes(255, 20, 20)); rendererToDrawWith.Line(400.5, 0.5, 400.5, 600.5, new RGBA_Bytes(255, 20, 20)); base.OnDraw(rendererToDrawWith); }
void Line(Tesselate_Tests.Vertex Vertex1, Tesselate_Tests.Vertex Vertex2, double lineWidth, RendererBase renderer, bool ArrowTip) { PathStorage line = new PathStorage(); line.move_to(Vertex1.m_X * m_Scale + m_XOffset, Vertex1.m_Y * m_Scale + m_YOffset); line.line_to(Vertex2.m_X * m_Scale + m_XOffset, Vertex2.m_Y * m_Scale + m_YOffset); // Drawing as an outline conv_stroke wideLine = new conv_stroke(line); wideLine.width(lineWidth); renderer.Render(wideLine, m_LineColor.GetAsRGBA_Bytes()); if(ArrowTip) { Ellipse Dot = new Ellipse( (Vertex2.m_X * m_Scale * 9 + Vertex1.m_X * m_Scale) / 10 + m_XOffset, (Vertex2.m_Y * m_Scale * 9 + Vertex1.m_Y * m_Scale) / 10 + m_YOffset, 3, 3); GetRenderer().Render(Dot, m_LineColor.GetAsRGBA_Bytes()); } }
public void DrawScore(RendererBase destRenderer) { int playerSequenceIndex = GetPlayerIndex(); ImageSequence scoreSequence = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "ScoreNumbers"); string score = m_Score.ToString(); int x = 43; int y = 577; switch (playerSequenceIndex) { case 0: break; case 1: x = 700; break; case 2: x = 45; y = 5; break; case 3: x = 700; y = 5; break; default: break; } for (int i = 0; i < score.Length; i++) { int digit = (int)(score[i] - '0'); ImageBuffer numberImage = scoreSequence.GetImageByIndex(digit); destRenderer.Render(numberImage, x, y); x += numberImage.Width(); } }
void Triangle(Tesselate_Tests.Vertex Vertex1, Tesselate_Tests.Vertex Vertex2, Tesselate_Tests.Vertex Vertex3, RendererBase renderer) { PathStorage triangle = new PathStorage(); triangle.move_to(Vertex1.m_X * m_Scale + m_XOffset, Vertex1.m_Y * m_Scale + m_YOffset); triangle.line_to(Vertex2.m_X * m_Scale + m_XOffset, Vertex2.m_Y * m_Scale + m_YOffset); triangle.line_to(Vertex3.m_X * m_Scale + m_XOffset, Vertex3.m_Y * m_Scale + m_YOffset); renderer.Render(triangle, m_TriangleColor.GetAsRGBA_Bytes()); }
public override void OnDraw(RendererBase rendererToDrawWith) { this.ShowFrameRate = false; base.OnDraw(rendererToDrawWith); }
public virtual void Draw(RendererBase destRenderer) { DoDraw(destRenderer); MirrorAsNeeded(destRenderer); }
public DDPaintCursor(RendererBase renderer) { Renderer = renderer; }
public void Draw(RendererBase currentRenderer) { }
public override void OnDraw(RendererBase renderer) { GammaLookUpTable gamma = new GammaLookUpTable(m_gamma.value()); IBlender NormalBlender = new BlenderBGRA(); IBlender GammaBlender = new BlenderGammaBGRA(gamma); ImageBuffer rasterNormal = new ImageBuffer(NewRenderer().DestImage, NormalBlender); ImageBuffer rasterGamma = new ImageBuffer(NewRenderer().DestImage, GammaBlender); ImageClippingProxy clippingProxyNormal = new ImageClippingProxy(rasterNormal); ImageClippingProxy clippingProxyGamma = new ImageClippingProxy(rasterGamma); clippingProxyNormal.clear(new RGBA_Doubles(0,0,0)); rasterizer_scanline_aa ras = new rasterizer_scanline_aa(); scanline_packed_8 sl = new scanline_packed_8(); VertexSource.Ellipse e = new VertexSource.Ellipse(); // TODO: If you drag the control circles below the bottom of the window we get an exception. This does not happen in AGG. // It needs to be debugged. Turning on clipping fixes it. But standard agg works without clipping. Could be a bigger problem than this. //ras.clip_box(0, 0, width(), height()); // Render two "control" circles e.init(m_x[0], m_y[0], 3, 3, 16); ras.add_path(e); Renderer.RenderSolid(clippingProxyNormal, ras, sl, new RGBA_Bytes(127, 127, 127)); e.init(m_x[1], m_y[1], 3, 3, 16); ras.add_path(e); Renderer.RenderSolid(clippingProxyNormal, ras, sl, new RGBA_Bytes(127, 127, 127)); // Creating a rounded rectangle VertexSource.RoundedRect r = new VertexSource.RoundedRect(m_x[0], m_y[0], m_x[1], m_y[1], 10); r.normalize_radius(); // Drawing as an outline conv_stroke p = new conv_stroke(r); p.width(1.0); ras.add_path(p); //Renderer.RenderSolid(clippingProxyGamma, ras, sl, new RGBA_Bytes(0, 0, 0)); Renderer.RenderSolid(clippingProxyGamma, ras, sl, new RGBA_Bytes(255, 1, 1)); /* int i; // radial line test //------------------------- dashed_line<rasterizer_type, renderer_scanline_type, scanline_type> dash(ras, ren_sl, sl); double cx = width() / 2.0; double cy = height() / 2.0; ren_sl.color(agg::rgba(1.0, 1.0, 1.0, 0.2)); for(i = 180; i > 0; i--) { double n = 2.0 * agg::pi * i / 180.0; dash.draw(cx + min(cx, cy) * sin(n), cy + min(cx, cy) * cos(n), cx, cy, 1.0, (i < 90) ? i : 0.0); } typedef agg::gradient_x gradient_func_type; typedef agg::span_interpolator_linear<> interpolator_type; typedef agg::span_allocator<color_type> span_allocator_type; typedef agg::pod_auto_array<color_type, 256> color_array_type; typedef agg::span_gradient<color_type, interpolator_type, gradient_func_type, color_array_type> span_gradient_type; typedef agg::renderer_scanline_aa<renderer_base_type, span_allocator_type, span_gradient_type> renderer_gradient_type; gradient_func_type gradient_func; // The gradient function agg::trans_affine gradient_mtx; // Affine transformer interpolator_type span_interpolator(gradient_mtx); // Span interpolator span_allocator_type span_allocator; // Span Allocator color_array_type gradient_colors; // The gradient colors span_gradient_type span_gradient(span_interpolator, gradient_func, gradient_colors, 0, 100); renderer_gradient_type ren_gradient(ren_base, span_allocator, span_gradient); dashed_line<rasterizer_type, renderer_gradient_type, scanline_type> dash_gradient(ras, ren_gradient, sl); double x1, y1, x2, y2; for(i = 1; i <= 20; i++) { ren_sl.color(agg::rgba(1,1,1)); // integral point sizes 1..20 //---------------- agg::ellipse ell; ell.init(20 + i * (i + 1) + 0.5, 20.5, i / 2.0, i / 2.0, 8 + i); ras.reset(); ras.add_path(ell); agg::render_scanlines(ras, sl, ren_sl); // fractional point sizes 0..2 //---------------- ell.init(18 + i * 4 + 0.5, 33 + 0.5, i/20.0, i/20.0, 8); ras.reset(); ras.add_path(ell); agg::render_scanlines(ras, sl, ren_sl); // fractional point positioning //--------------- ell.init(18 + i * 4 + (i-1) / 10.0 + 0.5, 27 + (i - 1) / 10.0 + 0.5, 0.5, 0.5, 8); ras.reset(); ras.add_path(ell); agg::render_scanlines(ras, sl, ren_sl); // integral line widths 1..20 //---------------- fill_color_array(gradient_colors, agg::rgba(1,1,1), agg::rgba(i % 2, (i % 3) * 0.5, (i % 5) * 0.25)); x1 = 20 + i* (i + 1); y1 = 40.5; x2 = 20 + i * (i + 1) + (i - 1) * 4; y2 = 100.5; calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx); dash_gradient.draw(x1, y1, x2, y2, i, 0); fill_color_array(gradient_colors, agg::rgba(1,0,0), agg::rgba(0,0,1)); // fractional line lengths H (red/blue) //---------------- x1 = 17.5 + i * 4; y1 = 107; x2 = 17.5 + i * 4 + i/6.66666667; y2 = 107; calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx); dash_gradient.draw(x1, y1, x2, y2, 1.0, 0); // fractional line lengths V (red/blue) //--------------- x1 = 18 + i * 4; y1 = 112.5; x2 = 18 + i * 4; y2 = 112.5 + i / 6.66666667; calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx); dash_gradient.draw(x1, y1, x2, y2, 1.0, 0); // fractional line positioning (red) //--------------- fill_color_array(gradient_colors, agg::rgba(1,0,0), agg::rgba(1,1,1)); x1 = 21.5; y1 = 120 + (i - 1) * 3.1; x2 = 52.5; y2 = 120 + (i - 1) * 3.1; calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx); dash_gradient.draw(x1, y1, x2, y2, 1.0, 0); // fractional line width 2..0 (green) fill_color_array(gradient_colors, agg::rgba(0,1,0), agg::rgba(1,1,1)); x1 = 52.5; y1 = 118 + i * 3; x2 = 83.5; y2 = 118 + i * 3; calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx); dash_gradient.draw(x1, y1, x2, y2, 2.0 - (i - 1) / 10.0, 0); // stippled fractional width 2..0 (blue) fill_color_array(gradient_colors, agg::rgba(0,0,1), agg::rgba(1,1,1)); x1 = 83.5; y1 = 119 + i * 3; x2 = 114.5; y2 = 119 + i * 3; calc_linear_gradient_transform(x1, y1, x2, y2, gradient_mtx); dash_gradient.draw(x1, y1, x2, y2, 2.0 - (i - 1) / 10.0, 3.0); ren_sl.color(agg::rgba(1,1,1)); if(i <= 10) { // integral line width, horz aligned (mipmap test) //------------------- dash.draw(125.5, 119.5 + (i + 2) * (i / 2.0), 135.5, 119.5 + (i + 2) * (i / 2.0), i, 0.0); } // fractional line width 0..2, 1 px H //----------------- dash.draw(17.5 + i * 4, 192, 18.5 + i * 4, 192, i / 10.0, 0); // fractional line positioning, 1 px H //----------------- dash.draw(17.5 + i * 4 + (i - 1) / 10.0, 186, 18.5 + i * 4 + (i - 1) / 10.0, 186, 1.0, 0); } // Triangles //--------------- for (int i = 1; i <= 13; i++) { fill_color_array(gradient_colors, agg::rgba(1,1,1), agg::rgba(i % 2, (i % 3) * 0.5, (i % 5) * 0.25)); calc_linear_gradient_transform(width() - 150, height() - 20 - i * (i + 1.5), width() - 20, height() - 20 - i * (i + 1), gradient_mtx); ras.reset(); ras.move_to_d(width() - 150, height() - 20 - i * (i + 1.5)); ras.line_to_d(width() - 20, height() - 20 - i * (i + 1)); ras.line_to_d(width() - 20, height() - 20 - i * (i + 2)); agg::render_scanlines(ras, sl, ren_gradient); } */ base.OnDraw(renderer); }
public override void OnDraw(RendererBase rendererToDrawWith) { ImageSequence menuBackground = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "MainMenuBackground"); rendererToDrawWith.Render(menuBackground.GetImageByIndex(0), 0, 0); ImageSequence planetOnMenu = (ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "PlanetOnMenu"); rendererToDrawWith.Render(planetOnMenu.GetImageByRatio(planetRatio.Read()), 620, 360); base.OnDraw(rendererToDrawWith); }
public void SetRendererPostDraw(RendererBase rendererToDrawWith) { rendererToDrawWith.SetClippingRect(new rect_d(0, 0, 800, 600)); rendererToDrawWith.PopTransform(); }
protected override void DoDraw(RendererBase destRenderer) { ImageBuffer shieldImage = ((ImageSequence)DataAssetCache.Instance.GetAsset(typeof(ImageSequence), "Shield")).GetImageByIndex(0); destRenderer.Render(shieldImage, m_Position.x, m_Position.y); }
public override void Render(Canvas2D canvas, RendererBase renderer) { renderer.Render(canvas, this); }
public NeoTabWindow() { this.SetStyle(ControlStyles.AllPaintingInWmPaint | ControlStyles.OptimizedDoubleBuffer | ControlStyles.UserPaint | ControlStyles.SupportsTransparentBackColor | ControlStyles.ResizeRedraw, true); renderer = new DefaultRenderer(); tooltipRenderer = new TooltipRenderer(); }
public virtual void Render(Canvas2D canvas, RendererBase renderer) { }
public override void Init(RendererBase<ToyWorld> renderer, ToyWorld world, OverlaySettings settings) { base.Init(renderer, world, settings); }