public void AbleToSetTheBackgroundColorOfASurface()
{
_renderer.DrawColor = Color.FromArgb(255, 100, 50, 250);
_renderer.Clear();
var color = _surface.GetPixel(0, 0);
color.Should().Be(Color.FromArgb(255, 100, 50, 250));
}
private void RenderEvent()
{
_renderer.Clear(Color.Black);
_renderer.DrawRectangle(new OpenGLBrush
{
Color = new Color(Color.Gray, 1f)
}, new Rectangle(20, 20, 200, 500), 50);
_renderer.DrawRectangle(new OpenGLBrush
{
Color = new Color(Color.White, 1f)
}, new Rectangle(30, 30, 50, 50), 18);
_renderer.DrawRectangle(new OpenGLBrush
{
Color = new Color(Color.White, .75f)
}, new Rectangle(30, 130, 50, 50), 18);
_renderer.DrawRectangle(new OpenGLBrush
{
Color = new Color(Color.White, .55f)
}, new Rectangle(30, 230, 50, 50), 18);
_renderer.DrawRectangle(new OpenGLBrush
{
Color = new Color(Color.White, .25f)
}, new Rectangle(30, 330, 50, 50), 18);
if (stringLayout == null)
{
stringLayout = _renderer.CreateStringLayout("LOL THIS WORKS WOOHOO", "arial", 35);
}
_renderer.DrawString(new Rectangle(300, 300, 0, 0), stringLayout, new OpenGLBrush()
{
Color = Color.RoyalBlue
});
if (imageResource == null)
{
imageResource = _renderer.CreateImage(@"C:\source\CarMp\trunk\Images\Skins\BMW\pause.png");
}
_renderer.DrawImage(new Rectangle(100, 30, 50, 51), imageResource, 1);
// DrawDirect2D();
_fpsCalcFramesCurrent++;
if (DateTime.Now > _fpsCalcDate)
{
_controlForm.FPS = _fpsCalcFramesCurrent;
_fpsCalcFramesCurrent = 0;
_fpsCalcDate = DateTime.Now.AddSeconds(1);
}
}
public void Redraw()
{
renderer.Clear();
renderer.DrawHeader();
renderer.DrawGrid(block, currentTile, finishTile);
renderer.DrawCurrentPos(currentTile);
}
/// <summary>
/// Parse method, implements the Strategy pattern.
/// </summary>
/// <remarks>
/// The object recieves concrete strategy implementation of the renderer
/// </remarks>
/// <param name="renderer">
/// Must be an instance of IRenderer
/// </param>
/// <param name="score">
/// Must be an instance of IScoreBoard
/// </param>
public void Parse(IRenderer renderer, IScoreBoard score)
{
switch (this.Player.Command)
{
case PlayerCommand.InvalidMove:
renderer.Render(INVALID_MOVE_MESSAGE);
break;
case PlayerCommand.InvalidCommand:
renderer.Render(INVALID_COMMAND_MESSAGE);
break;
case PlayerCommand.PrintTopScores:
score.Render(renderer);
break;
case PlayerCommand.Restart:
this.IsRestartCommandEntered = true;
renderer.Clear();
return;
case PlayerCommand.Exit:
renderer.Render(GOODBYE_MESSAGE);
this.IsExitCommandEntered = true;
return;
}
}
public void Run()
{
while (_window.IsOpen)
{
_renderer.SetClearColor(25, 25, 25);
_renderer.Clear();
_renderer.SetScene(_camera.Camera);
OperatePlayer();
OperateObstacles();
if (_player.State == PlayerState.IsDead)
{
_gameOver.Position = new Vector2(
_window.Width / 2 + _gameOver.Size.X + _camera.X,
_window.Height / 2);
_renderer.Draw(_gameOver);
}
else
{
_camera.X += _player.RunSpeed;
}
_renderer.Draw(
new Vector2(_window.Width / 2 + _camera.X - _player.RunSpeed, Ground),
new Vector2(_window.Width * 2, 1),
Color.White
);
_window.Display();
}
}
public void Redraw()
{
_renderer.Clear();
_renderer.DrawHeader();
_renderer.DrawGrid(_tiles, _currentTile, _finishTile);
_renderer.DrawCurrentPos(_currentTile);
}
public static void Render(IRenderer rend, Polygon[] polys, float width, bool fade)
{
rend.Clear(new Color(0, 0, 0));
foreach (Polygon poly in polys)
{
for (int historyIndex = 0; historyIndex < poly.Corners[0].Points.Count(); historyIndex++)
{
var historyFrac = (double)historyIndex / (poly.Corners[0].Points.Count() - 1);
byte alpha = (fade) ? (byte)(255 * historyFrac) : poly.Color.A;
Color color = new Color(poly.Color.R, poly.Color.G, poly.Color.B, alpha);
for (int cornerIndex = 0; cornerIndex < poly.Corners.Count(); cornerIndex++)
{
var cornerA = poly.Corners[cornerIndex];
var pointA = new Point(cornerA.Points[historyIndex].X, cornerA.Points[historyIndex].Y);
var cornerB = poly.Corners[(cornerIndex == poly.Corners.Count() - 1) ? 0 : cornerIndex + 1];
var pointB = new Point(cornerB.Points[historyIndex].X, cornerB.Points[historyIndex].Y);
rend.DrawLine(pointA, pointB, width, color);
}
}
}
}
public void StartGame()
{
this.renderer.Clear();
//AttachListenersToKeyboard();
this.AttachListenersToKeyboard();
hangmanGameLogic.ShouldPassControl = false;
while (true)
{
this.gameEvents.ProcessInput();
//render all
renderer.DrawObjects(field, hangmanGameLogic.GameObjects);
Thread.Sleep(700);
renderer.Clear();
if (this.hangmanGameLogic.ShouldPassControl)
{
DetachListenersFromKeyboard();
break;
}
}
}
private Bitmap renderMazeAsImage(bool systemDPI = false)
{
if (maze == null)
{
return(null);
}
int gap = 32;
Rectangle renderBounds = new Rectangle(gap, gap, maze.TotalSizeInPixels.Width, maze.TotalSizeInPixels.Height);
IRenderer r = IRendererFactory.GetPreferredRenderer(renderBounds.Width + (gap * 2), renderBounds.Height + (gap * 2));
r.Clear(maze.FillColor);
maze.Render(r, renderBounds);
if (currentPath != null)
{
maze.renderPath(r, renderBounds, currentPath);
}
if (currentMazeMask != null)
{
maze.renderMask(r, renderBounds, currentMazeMask);
}
Bitmap b = r.RenderTargetAsGDIBitmap();
if (!systemDPI)
{
b.SetResolution((float)maze.DPI, (float)maze.DPI);
}
return(b);
}
private void draw(object state)
{
//is the window minimized?
if (p_Window.WindowState == FormWindowState.Minimized)
{
return;
}
Game game = state as Game;
IRenderContext context = game.p_Window.Context;
IRenderer renderer = game.p_Window.Renderer;
renderer.BeginFrame(game.p_Window.Context);
renderer.SetColor(Color.Black);
renderer.Clear();
p_MapRenderer.Draw(context, renderer);
drawUI(context, renderer);
p_Cursor.Draw(context, renderer);
try {
renderer.SetFont(new Font("Arial", 12, FontStyle.Bold));
renderer.DrawString(
p_Hotloader["print"].ToString(),
10, 100);
}
catch { }
renderer.EndFrame();
}
private void GameLoop(object sender, EventArgs e)
{
HighScore += ScoreForTick;
if (Enemies.Any(enemy => CollisionDetector.AreCollided(Batwing, enemy)))
{
timer.Stop();
renderer.ShowEndGameScreen(HighScore);
return;
}
renderer.Clear();
renderer.Draw(Batwing);
if (rand.Next(100) < SpawnEnemyChange)
{
var enemy = enemiesFactory.Get(renderer.ScreenWidth, rand.Next(renderer.ScreenHeight));
Enemies.Add(enemy);
GameObjects.Add(enemy);
}
KillEnemiesIfColliding();
HighScore += Enemies.Count(enemy => !enemy.IsAlive) * ScoreForKill;
RemoveNotAliveGameObjects();
UpdateObjectsPositions();
DrawGameObjects();
}
void Update()
{
System.Diagnostics.Debug.WriteLine("Draw..");
renderer.Begin();
renderer.Clear();
// render normal triangle
renderer.UseShader(shaderProgram);
renderer.UseVertexBuffer(vb1);
renderer.DrawVertexBuffer(PrimitiveType.Triangles, 0, 3);
// render textured triangle
renderer.UseShader(shaderProgramTextured);
renderer.UseVertexBuffer(vb2.VertexBuffer);
//renderer.UseTexture(brickTexture); // Either use only one texture
renderer.UseTextures(new ITexture2D[] { brickTexture, mossTexture }); // or multiple textures
shaderProgramTextured.SetUniform(sampler1, 0); // the order of the textures is determined by setting the uniform to the right index of the texture
shaderProgramTextured.SetUniform(sampler2, 1);
renderer.DrawVertexBufferIndexed(PrimitiveType.Triangles, 6);
// animate color
uniformValue = uniformValue + 0.01f;
uniformValue = uniformValue > 1.0f ? 1.0f : uniformValue;
shaderProgramColored.SetUniform(multiplicator, uniformValue);
// render colored triangle
renderer.UseShader(shaderProgramColored);
renderer.UseVertexBuffer(vb3.VertexBuffer);
renderer.DrawVertexBufferIndexed(PrimitiveType.Triangles, 3);
renderer.SwapBuffers();
// end probably useless.. don't know if possible failures are due to wpf
//renderer.End();
}
private void StartGameLoop()
{
var builer = new ConsoleBuilder();
renderer.Render(builer.StartGameDraw(field, initialGameLogic.Character));
AttachListenersToKeyboard();
while (true)
{
gameEvents.ProcessInput();
if (initialGameLogic.PassControlToSomeoneElse)
{
DetachistenersFromKeyboard();
//Go to subgame loop;
initialGameLogic.SubGame.Invoke();
AttachListenersToKeyboard();
initialGameLogic.PassControlToSomeoneElse = false;
}
//render all
IList <IRenderable> objs = new List <IRenderable>();
objs.Add(initialGameLogic.Character);
renderer.DrawObjects(field, objs);
Thread.Sleep(20);
renderer.Clear();
}
}
public RendererTests()
{
_sdl = new SdlEngine();
_surface = _sdl.CreateSurface(10, 10);
_renderer = _surface.CreateSoftwareRenderer();
_renderer.DrawColor = Color.Black;
_renderer.Clear();
}
public void Render(IRenderer renderer, Dimensions dims, bool lowQuality)
{
if (Visible == false)
{
return;
}
renderer.Clear(Color);
}
private void OnRender(object sender, FrameEventArgs args)
{
var anchor = Player.Position.ToChunkPosition();
renderer.Clear(Color.Aqua);
var entities = World.GetChunksInRadius(anchor, Preferences.ChunkRenderRadius);
renderer.Render(Player, textures, entities);
SwapBuffers();
}
public override void Render(IRenderer renderer)
{
renderer.ShowCursor(false);
if (isFirstRender)
{
renderer.Clear();
isFirstRender = false;
}
WriteCentral(SPLASH_MESSAGE, renderer);
}
private void SaveLife()
{
FileReadWrite rw = FileReadWrite.GetReadWriteService;
UniverseState[] st = new UniverseState[_gameSetup.universes.Length];
for (int i = 0; i < _gameSetup.universes.Length; i++)
{
st[i] = _gameSetup.universes[i].UState;
}
rw.Serialize(st);
Globals.Save = false; //Class should controll self state
Globals.Pause = true;
_renderer.Clear();
_renderer.Color(ConsoleColor.White);
Console.WriteLine("Game Was Saved Press Enter to continue");
Console.ReadLine();
Globals.Pause = false;
_renderer.Clear();
}
public void Render()
{
try
{
mRenderer.Clear(UColor.Black);
mPluginManager.Render(this.Renderer);
}
catch (Exception ex)
{
throw ex;
}
}
public void ChangeFigureColor(Point mPosition, Color color, bool filled) // If filled is true the figure should be/stay filled
{
foreach (BaseFigure figure in _figures)
{
if (figure.IsClicked(mPosition))
{
if (filled)
{
figure.Fill();
figure.ColorChange(color);
}
else
{
figure.ClearFill();
renderer.Clear(color);
}
}
}
foreach (BaseFigure figure in _figures)
{
figure.Draw(renderer);
}
}
public void Render(IRenderer renderer, Dimensions dims, bool lowQuality)
{
if (Visible == false)
{
return;
}
Point clipPoint = new Point(dims.DataOffsetX, dims.DataOffsetY);
Size clipSize = new Size(dims.DataWidth, dims.DataHeight);
renderer.Clip(clipPoint, clipSize);
renderer.Clear(Color);
renderer.ClipReset();
}
public void Render(IRenderer renderer)
{
// clear background
var backColor = new Color("#003366");
renderer.Clear(backColor);
// draw stars
foreach (var star in Stars)
{
renderer.FillCircle(star.Point, star.Radius, star.Color);
}
// draw lines connecting close stars
double connectDistance = 100;
foreach (var star1 in Stars)
{
foreach (var star2 in Stars)
{
// prevent duplicate lines
if (star1.Y >= star2.Y)
{
continue;
}
// determine star distance
double dX = Math.Abs(star1.X - star2.X);
double dY = Math.Abs(star1.Y - star2.Y);
if (dX > connectDistance || dY > connectDistance)
{
continue;
}
double distance = Math.Sqrt(dX * dX + dY * dY);
// set line alpha based on distance
int alpha = (int)(255 - distance / connectDistance * 255) * 2;
alpha = Math.Min(alpha, 255);
alpha = Math.Max(alpha, 0);
var lineColor = new Color(255, 255, 255, (byte)alpha);
if (distance < connectDistance)
{
renderer.DrawLine(star1.Point, star2.Point, 1, lineColor);
}
}
}
}
public void Start()
{
while (true)
{
foreach (var gameObject in drawableObjects)
{
gameObject.Draw();
}
foreach (var movableObject in movableObjects)
{
movableObject.Move();
}
Thread.Sleep(100);
renderer.Clear();
}
}
public override void Render(IRenderer renderer)
{
renderer.ShowCursor(false);
if (isFirstRender)
{
renderer.Clear();
isFirstRender = false;
}
WriteCentral($"{player.Name} - place your pieces", renderer);
int x = 0, y = 5;
DrawGrid(player.Grid, x, y);
DrawInstruction(x + 30, y);
}
private void ToggleBloom()
{
if (_isBloomEnabled)
{
_ndcTexture = _worldRenderer.Texture;
}
else
{
_ndcTexture = _postprocessTexture;
}
_ndcRenderer.Clear();
var fullScreenQuad = new FullScreenQuad(new[] { _ndcTexture }, _fullscreenShader);
_ndcRenderer.AddToScene(fullScreenQuad);
_isBloomEnabled = !_isBloomEnabled;
}
public void Run()
{
// handle events and render the frame
while (Window.Open)
{
_fps.Tick();
Window.HandleEvents();
RelativeMouse.HandleEvents();
if (!IsElapsedFrame())
{
continue;
}
_fps.Frame();
UpdateScene();
_renderer.Clear();
_blockTexture.Use();
foreach (var axis in _axis)
{
var renderable = (OpenGLRenderable)axis.Renderable;
var shader = renderable.Geometry.Program;
shader.Use();
shader["Color"].SetValue(axis.Color);
_renderer.Render(_mainCamera, renderable);
}
_renderer.Render(_mainCamera, _chunkMeshes);
//_renderer.Render(_mainCamera, _cube);
//UserInterface.Draw();
SwapBuffers();
}
}
public void StartSokoban()
{
this.renderer.Clear();
AttachListenersToKeyboard();
this.sokobanGameLogic.ShouldPassControl = false;
while (true)
{
this.gameEvents.ProcessInput();
renderer.DrawObjects((IRenderable)level1, sokobanGameLogic.GameObjects.Cast <IRenderable>().ToList());
if (this.sokobanGameLogic.ShouldPassControl)
{
DetachListenersFromKeyboard();
break;
}
Thread.Sleep(70);
renderer.Clear();
}
}
public override void Render(IRenderer renderer)
{
renderer.ShowCursor(false);
if (isFirstRender)
{
renderer.Clear();
isFirstRender = false;
}
int y = 1;
WriteCentral("Player Setup", renderer, y);
y = 3;
WriteCentral("Enter your name", renderer, y);
y = 5;
renderer.SetPosition((renderer.Width / 2) + playerNameBuilder.Length, y);
renderer.ShowCursor(true);
}
public void Clear(IRenderer renderer, Color background)
{
renderer.Clear(background);
}
protected override void OnRenderPre(IRenderer renderer)
{
base.OnRenderPre(renderer);
ICamera oldCam = renderer.CurrentCamera;
lightCam.Viewport = new Viewport(0, 0, shadowMap.Width, shadowMap.Height);// oldCam.Viewport;
lightCam.SetFrame(sl.Position, Matrix.LookAt(sl.Position, Vector3.Zero, Vector3.Up));
lightCam.SetProjection(ProjectionMode.Orthographic, 400, 400, 1.0f, 1000.0f);
// lightCam.SetProjection(45f, 1f, 500f);
lightCam.Update();
Viewport viewport = lightCam.Viewport;
float invWidth = (viewport.Width > 0) ? (1f / ((float)viewport.Width)) : 0f;
float invHeight = (viewport.Height > 0) ? (-1f / ((float)viewport.Height)) : 0f;
Matrix matrix = new Matrix();
matrix.M11 = invWidth * 2f;
matrix.M22 = invHeight * 2f;
matrix.M33 = 1f;
matrix.M44 = 1f;
matrix.M41 = -1f;
matrix.M42 = 1f;
matrix.M41 = matrix.M41 - invWidth;
matrix.M42 = matrix.M42 - invHeight;
Matrix projection = Matrix.CreateOrthoMatrix(0, viewport.Width, viewport.Height, 0, 0, 1);
blurEffect.Parameters["SpriteTransform"].SetValue(projection);
Matrix ortho = Matrix.CreateOrthoMatrix(30, 30, 1.0f, 200f);
Matrix view = Matrix.CreateViewMatrix(sl.Position, Vector3.Zero, Vector3.Up);//Matrix.LookAt(sl.Position, Vector3.Zero, Vector3.Up);
Matrix viewproj = view * ortho;
Matrix viewprojcam = lightCam.ViewProjectionMatrix;
renderer.CurrentCamera = lightCam;
renderer.SetRenderTarget(shadowMap);
renderer.Clear(Color.White);
renderer.EnforcedMaterial = shadowMat;
renderer.EnforcedDepthStencilState = dss;
if (cullFront)
{
renderer.EnforcedRasterizerState = rs;
}
mesh.Render(renderer);
renderer.ClearEnforcedStates();
renderer.EnforcedMaterial = null;
/*
* //Pass 2 - Draw from shadow to blur rt blur horizontally
* renderer.EnforcedRasterizerState = RasterizerState.CullNone;
* renderer.SetRenderTarget(blurRT);
* SetBlurEffectParameters(1.0f / (float) blurRT.Width, 0);
* DrawFullScreenQuad(shadowMap, BlendState.Opaque, blurRT.Width, blurRT.Height, blurEffect);
*
* //Pass 3 - Draw from blurRT to shadowmap, blur vertically
* renderer.SetRenderTarget(shadowMap);
* SetBlurEffectParameters(0, 1.0f / (float) shadowMap.Height);
* DrawFullScreenQuad(blurRT, BlendState.Opaque, shadowMap.Width, shadowMap.Height, blurEffect);
*/
renderer.CurrentCamera = oldCam;
renderer.SetRenderTarget(null);
receiverMat.SetParameter("LightVP", lightCam.ViewProjectionMatrix);
receiverMat.SetParameter("LightDirection", sl.Direction);
receiverMat.SetParameter("ShadowMap", shadowMap);
}
