public void TestDepthFromOtherFrameBuffer()
{
Runner.ExecuteAsLoop(_ =>
{
FrameBuffer testBuffer = new FrameBuffer(Engine.Renderer.DrawBuffer.Size).WithColor().WithDepth(true);
var shader = Engine.AssetLoader.Get <ShaderAsset>("Shaders/DepthTest.xml");
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderTo(testBuffer);
composer.ClearFrameBuffer();
composer.RenderSprite(new Vector3(0, 0, 10), new Vector2(100, 100), Color.Green);
composer.RenderTo(null);
composer.SetUseViewMatrix(false);
composer.SetShader(shader.Shader);
shader.Shader.SetUniformInt("depthTexture", 1);
Texture.EnsureBound(testBuffer.DepthTexture.Pointer, 1);
composer.RenderSprite(new Vector3(0, 0, 0), testBuffer.Texture.Size, Color.White, testBuffer.Texture);
composer.SetShader();
composer.SetUseViewMatrix(true);
composer.RenderSprite(new Vector3(20, 20, 15), new Vector2(100, 100), Color.Blue);
composer.RenderSprite(new Vector3(10, 10, 0), new Vector2(100, 100), Color.Red);
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.TestDepthFromOtherFrameBuffer);
testBuffer.Dispose();
}).WaitOne();
}
public void Draw(RenderComposer composer)
{
composer.RenderToAndClear(_fbo);
composer.SetUseViewMatrix(false);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(100, 100), new Color(_currentRedValue, (byte)50, (byte)50));
composer.RenderTo(null);
composer.SetUseViewMatrix(true);
composer.RenderSprite(new Vector3(10, -50, 0), new Vector2(100, 100), new Color(_currentRedValue, (byte)50, (byte)50));
if (_asyncSample)
{
if (_sampleReq == null || _sampleReq.Finished)
{
if (_sampleReq != null && _sampleReq.Finished)
{
_lastColorResult = new Color(_sampleReq.Data[0], _sampleReq.Data[1], _sampleReq.Data[2], _sampleReq.Data[3]);
}
_sampleReq = _fbo.SampleAsync(new Rectangle(0, 0, 1, 1), OpenGL.PixelFormat.Rgba);
}
}
else
{
byte[] sampleReq = _fbo.Sample(new Rectangle(0, 0, 1, 1), OpenGL.PixelFormat.Rgba);
_lastColorResult = new Color(sampleReq[0], sampleReq[1], sampleReq[2], sampleReq[3]);
}
composer.RenderSprite(new Vector3(-100, -50, 10), new Vector2(100, 100), _lastColorResult);
}
protected override bool RenderInternal(RenderComposer composer)
{
if (TextureAsset == null)
{
return(false);
}
// Corners
composer.RenderSprite(_topLeftDraw, _topLeftDrawSize, _calculatedColor, TextureAsset.Texture, _topLeftUV);
composer.RenderSprite(_topRightDraw, _topRightDrawSize, _calculatedColor, TextureAsset.Texture, _topRightUV);
composer.RenderSprite(_bottomLeftDraw, _bottomLeftDrawSize, _calculatedColor, TextureAsset.Texture, _bottomLeftUV);
composer.RenderSprite(_bottomRightDraw, _bottomRightDrawSize, _calculatedColor, TextureAsset.Texture, _bottomRightUV);
// Center
composer.RenderSprite(_centerDraw, _centerDrawSize, _calculatedColor, TextureAsset.Texture, _centerUV);
// Vertical bars
DrawTileVertical(composer, _verticalBarLeftDraw, _verticalBarLeftDrawSize, _verticalBarLeftTileArea, _verticalBarLeftUV);
DrawTileVertical(composer, _verticalBarRightDraw, _verticalBarRightDrawSize, _verticalBarRightTileArea, _verticalBarRightUV);
// Horizontal bars
DrawTileHorizontal(composer, _horizontalBarTopDraw, _horizontalBarTopDrawSize, _horizontalBarTopTileArea, _horizontalBarTopUV);
DrawTileHorizontal(composer, _horizontalBarBottomDraw, _horizontalBarBottomDrawSize, _horizontalBarBottomTileArea, _horizontalBarBottomUV);
return(true);
}
public void FramebufferResizing()
{
Runner.ExecuteAsLoop(_ =>
{
FrameBuffer testBuffer = new FrameBuffer(new Vector2(1000, 1000)).WithColor();
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderToAndClear(testBuffer);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(1000, 1000), Color.Red);
composer.RenderTo(null);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(100, 100), Color.White, testBuffer.Texture);
testBuffer.Resize(new Vector2(500, 500), true);
composer.RenderToAndClear(testBuffer);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(500, 500), Color.Green);
composer.RenderTo(null);
composer.RenderFrameBuffer(testBuffer, new Vector2(100, 100), new Vector3(100, 0, 0));
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.FramebufferResizing);
testBuffer.Dispose();
}).WaitOne();
}
protected override bool RenderInternal(RenderComposer c)
{
if (OutlineColor != null)
{
c.RenderSprite(Position - _scaledOutline.ToVec3(), Size + _scaledOutline * 2, OutlineColor.Value);
}
c.RenderSprite(Bounds, _calculatedColor);
return(true);
}
public void TestUVMapping()
{
var asset = Engine.AssetLoader.Get <TextureAsset>("Images/logoAsymmetric.png");
Runner.ExecuteAsLoop(_ =>
{
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderSprite(new Vector3(10, 10, 0), new Vector2(100, 100), Color.White, asset.Texture, null, true);
composer.RenderSprite(new Vector3(100, 10, 0), new Vector2(100, 100), Color.White, asset.Texture, null, false, true);
composer.RenderSprite(new Vector3(200, 10, 0), new Vector2(100, 100), Color.White, asset.Texture, null, true, true);
composer.FlushRenderStream();
asset.Texture.Tile = false;
composer.RenderSprite(new Vector3(10, 100, 0), new Vector2(100, 100), Color.White, asset.Texture, null, true);
composer.RenderSprite(new Vector3(100, 100, 0), new Vector2(100, 100), Color.White, asset.Texture, null, false, true);
composer.RenderSprite(new Vector3(200, 100, 0), new Vector2(100, 100), Color.White, asset.Texture, null, true, true);
composer.RenderSprite(new Vector3(10, 200, 0), new Vector2(100, 100), Color.White, asset.Texture, new Rectangle(0, 0, 50, 50), true);
composer.RenderSprite(new Vector3(100, 200, 0), new Vector2(100, 100), Color.White, asset.Texture, new Rectangle(0, 0, 50, 50), false, true);
composer.RenderSprite(new Vector3(200, 200, 0), new Vector2(100, 100), Color.White, asset.Texture, new Rectangle(0, 0, 50, 50), true, true);
composer.FlushRenderStream();
asset.Texture.Tile = true;
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.TestUVMapping);
}).WaitOne();
}
public override void Draw(RenderComposer composer)
{
Color textCol = new Color(32, 32, 32);
int size = 20;
string text = "The quick brown fox jumped over the lazy dog.";
composer.SetUseViewMatrix(false);
composer.RenderSprite(new Vector3(0, 0, 0), Engine.Renderer.CurrentTarget.Size, new Color(240, 240, 240));
composer.PushModelMatrix(Matrix4x4.CreateScale(1, 1, 1) * Matrix4x4.CreateTranslation(100, 100, 0));
FontAsset.GlyphRasterizer = GlyphRasterizer.Emotion;
composer.RenderLine(new Vector3(0, 0, 0), new Vector3(500, 0, 0), Color.Red);
composer.RenderString(new Vector3(0, 0, 0), textCol, "Emotion Renderer:\n" + text, _font.GetAtlas(size));
FontAsset.GlyphRasterizer = GlyphRasterizer.EmotionSDFVer3;
composer.RenderLine(new Vector3(0, 140, 0), new Vector3(500, 140, 0), Color.Red);
composer.RenderString(new Vector3(0, 140, 0), textCol, "EmotionSDFVer3:\n" + text, _font.GetAtlas(size));
FontAsset.GlyphRasterizer = GlyphRasterizer.EmotionSDFVer4;
composer.RenderLine(new Vector3(0, 300, 0), new Vector3(500, 300, 0), Color.Red);
composer.RenderString(new Vector3(0, 300, 0), textCol, "EmotionSDFVer4:\n" + text, _font.GetAtlas(size));
FontAsset.GlyphRasterizer = GlyphRasterizer.StbTrueType;
composer.RenderLine(new Vector3(0, 450, 0), new Vector3(500, 450, 0), Color.Red);
composer.RenderString(new Vector3(0, 450, 0), textCol, "StbTrueType:\n" + text, _font.GetAtlas(size));
composer.PopModelMatrix();
composer.SetUseViewMatrix(true);
}
public void RenderComposerSpriteLimit()
{
Runner.ExecuteAsLoop(_ =>
{
RenderComposer composer = Engine.Renderer.StartFrame();
const int count = ushort.MaxValue * 2;
const int size = 1;
var y = 0;
var x = 0;
var elements = 0;
while (elements < count)
{
var c = new Color(elements, 255 - elements, elements < ushort.MaxValue ? 255 : 0);
composer.RenderSprite(new Vector3(x * size, y * size, 0), new Vector2(size, size), c);
x++;
elements++;
if (x * size < Engine.Renderer.CurrentTarget.Size.X)
{
continue;
}
y++;
x = 0;
}
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.RenderComposerSpriteLimitTest);
}).WaitOne();
}
public void Draw(RenderComposer composer)
{
Vector2 pen = Vector2.Zero;
string[] assets = Engine.AssetLoader.AllAssets;
for (int i = 0; i < assets.Length; i++)
{
if (!assets[i].Contains(".png"))
{
continue;
}
var texture = Engine.AssetLoader.Get <TextureAsset>(assets[i]);
if (texture == null || texture.Texture == null)
{
continue;
}
composer.RenderSprite(pen.ToVec3(), texture.Texture.Size, Color.White, texture.Texture);
pen.X += texture.Texture.Size.X;
if (pen.X > 1000)
{
pen.Y += 500;
pen.X = 0;
}
}
}
public void DecodePngInterlaced()
{
string png = Path.Join("Assets", "Images", "spritesheetAnimation.png");
byte[] bytes = File.ReadAllBytes(png);
Assert.True(PngFormat.IsPng(bytes));
byte[] decodedPixelData = PngFormat.Decode(bytes, out PngFileHeader fileHeader);
Assert.True(decodedPixelData != null);
Assert.True(fileHeader.InterlaceMethod == 1);
Runner.ExecuteAsLoop(_ =>
{
var r = new Texture(
fileHeader.Size,
decodedPixelData,
fileHeader.PixelFormat);
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderSprite(Vector3.Zero, fileHeader.Size, Color.White, r);
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.PngDecodeInterlaced);
r.Dispose();
}).WaitOne();
}
public void ShaderBrokenLoad()
{
var shader = Engine.AssetLoader.Get <ShaderAsset>("Shaders/BrokenShader.xml");
;
Runner.ExecuteAsLoop(_ =>
{
RenderComposer composer = Engine.Renderer.StartFrame();
// Set shader.
composer.SetShader(shader.Shader);
// Render a blank square.
composer.RenderSprite(new Vector3(10, 10, 0), new Vector2(10, 10), Color.White);
// Reset to default shader.
composer.SetShader();
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.BrokenShader);
}).WaitOne();
// Even though the shader is broken, and it doesn't specify a fallback, it should load the compat shader.
Assert.True(shader.Shader != null);
Assert.True(shader.IsFallback);
Engine.AssetLoader.Destroy(shader.Name);
}
public void DecodeBmp256()
{
string bmp256 = Path.Join("Assets", "Images", "256colorbmp.bmp");
byte[] bytes = File.ReadAllBytes(bmp256);
Assert.True(BmpFormat.IsBmp(bytes));
byte[] decodedPixelData = BmpFormat.Decode(bytes, out BmpFileHeader fileHeader);
Assert.True(decodedPixelData != null);
Runner.ExecuteAsLoop(_ =>
{
var r = new Texture(
new Vector2(fileHeader.Width, fileHeader.Height),
decodedPixelData,
PixelFormat.Bgra
)
{
FlipY = true
};
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderSprite(Vector3.Zero, new Vector2(fileHeader.Width, fileHeader.Height), Color.White, r);
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.Bmp256ColorDecode);
r.Dispose();
}).WaitOne();
}
public void Draw(RenderComposer composer)
{
// The vertices were taken from a font, and the polygon is huge.
composer.PushModelMatrix(Matrix4x4.CreateScale(0.1f, 0.1f, 1f));
composer.SetStencilTest(true);
composer.StencilWindingStart();
composer.ToggleRenderColor(false);
// Draw all of them together. Winding will take care of the overlap.
var accum = Rectangle.Empty;
for (var i = 0; i < _testPolygon.Length; i++)
{
composer.RenderVertices(_testPolygon[i].Vertices, Color.White);
accum = accum.Union(_testPolygon[i].Bounds2D);
}
composer.StencilWindingEnd();
composer.ToggleRenderColor(true);
// You need one quad which covers the bounds of all the polygons.
// In this case I added the bounding boxes, but you could just draw a screen sized quad.
composer.RenderSprite(accum, Color.Red);
composer.SetStencilTest(false);
composer.PopModelMatrix();
}
public override void Render(RenderComposer composer)
{
if (InclineAngle != 0f)
{
composer.PushModelMatrix(
Matrix4x4.CreateRotationZ(InclineAngle, new Vector3(Center, 0))
);
}
composer.RenderSprite(
Position,
Size,
!IsAffectedByGravityPush ? Color.White : Color.Pink,
TextureAsset.Texture,
null,
IsFacingRight
);
if (InclineAngle != 0f)
{
composer.PopModelMatrix();
}
if (IsInteracting)
{
string text = Dialogues[0].DialogueLines[0];
composer.RenderString(Position + new Vector3(-30, -30, 0), Color.Black, text, Engine.AssetLoader.Get <FontAsset>("Fonts/Calibri 400.ttf").GetAtlas(16));
}
//Rectangle futurePosition = new Rectangle(CollisionBox.X, CollisionBox.Y - (GravityTimer.Progress * StartingVelocityY), CollisionBox.Width, CollisionBox.Height);
//composer.RenderOutline(futurePosition, Color.Green, 1);
//composer.RenderOutline(CollisionBox.ToRectangle(), Color.Red, 2);
}
public void ShaderFallback()
{
var shader = Engine.AssetLoader.Get <ShaderAsset>("Shaders/BrokenShaderWithFallback.xml");
;
Runner.ExecuteAsLoop(_ =>
{
RenderComposer composer = Engine.Renderer.StartFrame();
// Set shader.
composer.SetShader(shader.Shader);
// Render a blank square.
composer.RenderSprite(new Vector3(10, 10, 0), new Vector2(10, 10), Color.White);
// Reset to default shader.
composer.SetShader();
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.ShaderFallback);
}).WaitOne();
// The shader should've loaded its fallback.
Assert.True(shader.Shader != null);
Assert.True(shader.IsFallback);
Engine.AssetLoader.Destroy(shader.Name);
}
public override void Draw(RenderComposer composer)
{
composer.SetUseViewMatrix(false);
composer.RenderSprite(new Vector3(0, 0, 0), Engine.Renderer.CurrentTarget.Size, Color.CornflowerBlue);
composer.SetUseViewMatrix(true);
foreach (RopeSimConnection2D p in _connections)
{
composer.RenderLine((p.Start.Position + new Vector2(_circleRadius)).ToVec3(), (p.End.Position + new Vector2(_circleRadius)).ToVec3(), Color.White);
}
if (_dragging != null)
{
Vector2 worldMouse = Engine.Renderer.Camera.ScreenToWorld(Engine.Host.MousePosition);
composer.RenderLine((_dragging.Position + new Vector2(_circleRadius)).ToVec3(), worldMouse.ToVec3(), Color.Red);
}
if (_draggingCut != Vector2.Zero)
{
Vector2 worldMouse = Engine.Renderer.Camera.ScreenToWorld(Engine.Host.MousePosition);
composer.RenderLine(_draggingCut.ToVec3(), worldMouse.ToVec3(), Color.Red);
}
foreach (var p in _points)
{
composer.RenderCircle(p.Position.ToVec3(), _circleRadius, p.Locked ? Color.Magenta : Color.Black);
}
}
public void TestFullScaleInteger()
{
Runner.ExecuteAsLoop(_ =>
{
Engine.Renderer.Camera = new PixelArtCamera(Vector3.Zero);
Engine.Host.Size = new Vector2(640, 360);
DesktopTest.EventualConsistencyHostWait();
RenderComposer composer = Engine.Renderer.StartFrame();
composer.RenderSprite(new Vector3(_backgroundSize * -1, 0), _backgroundSize, Color.Black);
composer.RenderSprite(new Vector3(0, 0, 0), _backgroundSize, Color.CornflowerBlue);
composer.RenderSprite(new Vector3(0, 0, 0), new Vector2(10, 10), Color.Red);
composer.RenderSprite(new Vector3(_backgroundSize - new Vector2(10, 10), 0), new Vector2(10, 10), Color.Red);
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.TestFullScaleInteger);
}).WaitOne();
}
protected override bool RenderInternal(RenderComposer c)
{
c.SetUseViewMatrix(false);
c.RenderSprite(Vector3.Zero, c.CurrentTarget.Size, Color.CornflowerBlue);
base.RenderInternal(c);
_ui.Render(c);
return(true);
}
public override void Draw(RenderComposer composer)
{
DrawableFontAtlas atlas = _font.GetAtlas(30);
var l = new TextLayouter(atlas.Atlas);
string text;
if (!_myPaddle.Ready)
{
text = "Press 'Space' when ready!";
}
else if (_pad1 == _myPaddle && !_pad2.Ready || _pad2 == _myPaddle && !_pad1.Ready)
{
text = "Waiting for other player.";
}
else
{
text = $"{_pad1.Score}/{_pad2.Score}";
}
Vector2 textSize = l.MeasureString(text);
float screenHorizontalCenter = Engine.Configuration.RenderSize.X / 2;
composer.RenderString(new Vector3(screenHorizontalCenter - textSize.X / 2, 10, 0), Color.White, text, atlas);
composer.RenderSprite(_pad1.VisualPosition, _pad1.Size, _pad1.Ready ? Color.White : Color.Red);
composer.RenderSprite(_pad2.VisualPosition, _pad2.Size, _pad2.Ready ? Color.White : Color.Red);
// Uncomment to view paddle collisions.
//LineSegment[] padCol = _pad2.GetPaddleCollision();
//for (var i = 0; i < padCol.Length; i++)
//{
// composer.RenderLine(ref padCol[i], Color.Red);
//}
NetworkTransform ball = IdToObject["Ball"];
composer.RenderSprite(ball.VisualPosition, ball.Size, Color.White);
NetworkTransform upperWall = IdToObject["UpperWall"];
NetworkTransform lowerWall = IdToObject["LowerWall"];
composer.RenderSprite(upperWall.VisualPosition, upperWall.Size, Color.White);
composer.RenderSprite(lowerWall.VisualPosition, lowerWall.Size, Color.White);
}
private void RenderAnimation(RenderComposer composer)
{
var offset = new Vector2(100, 100);
if (_animation.Anchors.Length > 0)
{
offset += _animation.Anchors[_animation.CurrentFrameIndex] * Scale;
}
composer.RenderSprite(new Vector3(offset, 1), _animation.CurrentFrame.Size * Scale, Color.White, _animation.Texture, _animation.CurrentFrame, _mirrored);
}
protected override bool RenderInternal(RenderComposer c)
{
c.SetStencilTest(true);
c.ToggleRenderColor(false);
c.StencilStartDraw();
c.RenderSprite(this, Color.White);
c.ToggleRenderColor(true);
c.StencilFillIn();
return(base.RenderInternal(c));
}
public override void Render(RenderComposer composer)
{
if (TextureAsset == null)
{
return;
}
if (BlurIntensity > 0)
{
// Apply Blur effect if such is set
composer.SetShader(BlurShader.Shader);
BlurShader.Shader.SetUniformFloat("sigma", BlurIntensity);
}
Color color = Color.White;
if (ShadowReverseIntensity < 255)
{
// Apply Shadow effect if such is set
color = new Color(ShadowReverseIntensity, ShadowReverseIntensity, ShadowReverseIntensity); // 180 for a shadowy look
}
if (Rotation != 0f)
{
// Apply rotation if such is set
// Tiled rotates images around the bottom left corner
composer.PushModelMatrix(
Matrix4x4.CreateRotationZ(Rotation, new Vector3(X, Y + DisplaySize.Y, 0))
);
}
// Render
composer.RenderSprite(
Position,
DisplaySize,
color,
TextureAsset.Texture,
TextureArea,
FlipX
);
if (Rotation != 0f)
{
// Remove the rotation matrix
composer.PopModelMatrix();
}
if (BlurIntensity > 0)
{
// Remove the blur shader
composer.SetShader(null);
}
}
private void RenderAnimation(RenderComposer composer)
{
if (_overlayAnimation != null)
{
Rectangle uv = Animation.Frames[_overlayAnimation.StartingFrame];
Vector2 anchor = Animation.Anchors[_overlayAnimation.StartingFrame];
composer.RenderSprite(new Vector3(new Vector2(100, 100) + anchor * Scale, 1), uv.Size * Scale, Color.Red, Animation.Texture, uv);
}
var offset = new Vector2(100, 100);
// Animation has a controller.
if (AnimController != null)
{
AnimController.GetCurrentFrameData(out Texture texture, out Rectangle uv, out Vector2 anchor, Mirrored);
composer.RenderSprite(new Vector3(offset + anchor * Scale, 1), uv.Size * Scale, Color.White, texture, uv, Mirrored);
return;
}
// Animation is just a texture.
if (Animation.Anchors.Length > 0) offset += Animation.Anchors[Animation.CurrentFrameIndex] * Scale;
composer.RenderSprite(new Vector3(offset, 1), Animation.CurrentFrame.Size * Scale, Color.White, Animation.Texture, Animation.CurrentFrame, Mirrored);
}
protected override void AfterRenderChildren(RenderComposer c)
{
#if false
{
if (MouseFocus != null)
{
c.RenderOutline(MouseFocus.Bounds, Color.Red);
}
c.RenderSprite(new Rectangle(Engine.Host.MousePosition.X, Engine.Host.MousePosition.Y, 1, 1), Color.Pink);
}
#endif
base.AfterRenderChildren(c);
}
public void Render(RenderComposer c)
{
var colorMultiplier = (byte)(_mouseDragging ? 100 : 50);
c.RenderOutline(Rect, Color);
if (_anchor == 5)
{
c.RenderSprite(Rect, Color.Add(Color, colorMultiplier).SetAlpha(colorMultiplier));
}
c.RenderCircle(Rect.Position.ToVec3(), 2, _anchor == 1 ? Color.Add(Color, colorMultiplier) : Color, true);
c.RenderCircle(Rect.TopRight.ToVec3(), 2, _anchor == 2 ? Color.Add(Color, colorMultiplier) : Color, true);
c.RenderCircle(Rect.BottomRight.ToVec3(), 2, _anchor == 3 ? Color.Add(Color, colorMultiplier) : Color, true);
c.RenderCircle(Rect.BottomLeft.ToVec3(), 2, _anchor == 4 ? Color.Add(Color, colorMultiplier) : Color, true);
}
protected override void RenderContent(RenderComposer composer)
{
Vector2 offset = ImGui.GetWindowPos();
offset.Y += ImGui.GetWindowHeight();
_lastOffset = offset;
composer.RenderSprite(new Vector3(offset, 0), _anim.Texture.Size * _parent.Scale, Color.White, _anim.Texture);
for (var i = 0; i < _anim.Frames.Length; i++)
{
composer.RenderOutline(new Vector3(offset + _anim.Frames[i].Position * _parent.Scale, 1), _anim.Frames[i].Size * _parent.Scale, _holdingIdx == i ? Color.Green : Color.Red);
composer.RenderString(new Vector3(offset + _anim.Frames[i].Position * _parent.Scale, 1), Color.Red, i.ToString(), _font.GetAtlas(15 * _parent.Scale));
}
ImGui.Text(_holdingIdx == -1 ? "Click on a rectangle to change it's position." : $"Select new position for frame {_holdingIdx}!");
}
protected override void RenderContent(RenderComposer composer)
{
Vector2 pos = ImGui.GetWindowPos();
pos.Y += ImGui.GetWindowHeight();
for (int i = _anim.StartingFrame; i <= _anim.EndingFrame; i++)
{
composer.RenderSprite(new Vector3(pos, 0), _anim.Frames[i].Size, Color.White, _anim.Texture, _anim.Frames[i]);
composer.RenderSprite(new Vector3(pos + _anim.Anchors[i], 1), new Vector2(3, 3), Color.Red);
ImGui.InputFloat2($"Frame {i} ({_anim.Frames[i]})", ref _anim.Anchors[i]);
ImGui.SameLine();
if (_clickPlace)
{
ImGui.TextDisabled($"Click Place {i}");
}
else
{
if (ImGui.Button($"Click Place {i}"))
{
_clickPlace = true;
_clickPlaceIdx = i;
_clickPlaceOffset = pos;
}
}
pos.X += _anim.Frames[i].Size.X;
}
if (_clickPlace)
{
if (ImGui.Button("Cancel Click Place"))
{
_clickPlace = false;
}
}
}
public static void RenderToolGrid(RenderComposer c, Vector3 position, Vector2 size, Color background, int gridSize)
{
c.RenderSprite(position, size, background);
Vector2 posVec2 = position.ToVec2();
for (var x = 0; x < size.X; x += gridSize)
{
c.RenderLine(posVec2 + new Vector2(x, 0), posVec2 + new Vector2(x, size.Y), Color.White * 0.2f);
}
for (var y = 0; y < size.Y; y += gridSize)
{
c.RenderLine(posVec2 + new Vector2(0, y), posVec2 + new Vector2(size.X, y), Color.White * 0.2f);
}
}
public override void Render(RenderComposer composer)
{
// If she's in a magic flow render her as a circle
if (IsMagicFlowActive)
{
composer.RenderCircle(CollisionBox.Center.ToVec3(Z), 15, Color.Pink, true);
return;
}
// If walking on an incline apply rotation
if (InclineAngle != 0f)
{
composer.PushModelMatrix(
Matrix4x4.CreateRotationZ(InclineAngle, new Vector3(Center, 0))
);
}
// Render the sprite
composer.RenderSprite(
Position,
Size,
!IsGravityPushActive ? Color.White : Color.Pink,
Sprite.Texture,
Sprite.CurrentFrame,
IsFacingRight, false
);
// Remove the rotation matrix
if (InclineAngle != 0f)
{
composer.PopModelMatrix();
}
if (IsGravityPushActive)
{
composer.RenderOutline(
new Vector3(
CollisionBox.Center.X - GravityPushRange,
CollisionBox.Center.Y - GravityPushRange,
15
),
new Vector2(GravityPushRange * 2),
Color.Pink,
2
);
}
}
public void RenderComposerRandomInvalidation()
{
Runner.ExecuteAsLoop(_ =>
{
RenderComposer composer = Engine.Renderer.StartFrame();
const int count = ushort.MaxValue * 2;
const int size = 1;
var y = 0;
var x = 0;
var elements = 0;
// Generate the locations at which an invalidation will occur.
var invalidationIdx = new List <int>();
for (var i = 0; i < 10; i++)
{
invalidationIdx.Add(Helpers.GenerateRandomNumber(100, count - 100));
}
while (elements < count)
{
if (invalidationIdx.IndexOf(elements) != -1)
{
Engine.Log.Info($"Invalidation of batch at element - {elements}", TestRunnerLogger.TestRunnerSrc);
composer.FlushRenderStream();
}
var c = new Color(elements, 255 - elements, elements < ushort.MaxValue ? 255 : 0);
composer.RenderSprite(new Vector3(x * size, y * size, 0), new Vector2(size, size), c);
x++;
elements++;
if (x * size < Engine.Renderer.CurrentTarget.Size.X)
{
continue;
}
y++;
x = 0;
}
Engine.Renderer.EndFrame();
Runner.VerifyScreenshot(ResultDb.RenderComposerSpriteLimitTest);
}).WaitOne();
}
