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