epic/OpenRA
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #2731 from pchote/renderer-cleanup2

Browse Source 
Renderer refactoring - Duplication
This commit is contained in:
Chris Forbes
2013-03-09 21:08:34 -08:00
parent 70e823f526 8a53819f50
commit da566f3648
11 changed files with 131 additions and 200 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
OpenRA.FileFormats/Graphics/IGraphicsDevice.cs
View File

@@ -40,7 +40,6 @@ namespace OpenRA.FileFormats.Graphics
IShader CreateShader( string name ); IShader CreateShader( string name );
Size WindowSize { get; } Size WindowSize { get; }
int GpuMemoryUsed { get; }
void Clear(); void Clear();
void Present(); void Present();
@@ -61,9 +60,9 @@ namespace OpenRA.FileFormats.Graphics
public interface IShader public interface IShader
{ {
void SetValue( string name, float x, float y ); void SetVec(string name, float x, float y);
void SetValue( string param, ITexture texture ); void SetTexture(string param, ITexture texture);
void Render( Action a ); void Render(Action a);
} }
public interface ITexture public interface ITexture

7
OpenRA.Game/Graphics/LineRenderer.cs
View File

@@ -77,5 +77,12 @@ namespace OpenRA.Graphics
for (float y = r.Top; y < r.Bottom; y++) for (float y = r.Top; y < r.Bottom; y++)
DrawLine(new float2(r.Left, y), new float2(r.Right, y), color, color); DrawLine(new float2(r.Left, y), new float2(r.Right, y), color, color);
} }
public void SetShaderParams(ITexture palette, Size screen, float zoom, float2 scroll)
{
shader.SetVec("Scroll", (int)scroll.X, (int)scroll.Y);
shader.SetVec("r1", zoom*2f/screen.Width, -zoom*2f/screen.Height);
shader.SetVec("r2", -1, 1);
}
} }
} }

43
OpenRA.Game/Graphics/Renderer.cs
View File

@@ -26,11 +26,6 @@ namespace OpenRA.Graphics
internal static int SheetSize; internal static int SheetSize;
internal static int TempBufferSize; internal static int TempBufferSize;
internal static int TempBufferCount; internal static int TempBufferCount;
internal IShader WorldSpriteShader { get; private set; }
internal IShader WorldLineShader { get; private set; }
internal IShader LineShader { get; private set; }
internal IShader RgbaSpriteShader { get; private set; }
internal IShader SpriteShader { get; private set; }
public SpriteRenderer WorldSpriteRenderer { get; private set; } public SpriteRenderer WorldSpriteRenderer { get; private set; }
public LineRenderer WorldLineRenderer { get; private set; } public LineRenderer WorldLineRenderer { get; private set; }
@@ -50,17 +45,11 @@ namespace OpenRA.Graphics
TempBufferCount = Game.Settings.Graphics.NumTempBuffers; TempBufferCount = Game.Settings.Graphics.NumTempBuffers;
SheetSize = Game.Settings.Graphics.SheetSize; SheetSize = Game.Settings.Graphics.SheetSize;
WorldSpriteShader = device.CreateShader("shp"); WorldSpriteRenderer = new SpriteRenderer(this, device.CreateShader("shp"));
WorldLineShader = device.CreateShader("line"); WorldLineRenderer = new LineRenderer(this, device.CreateShader("line"));
LineShader = device.CreateShader("line"); LineRenderer = new LineRenderer(this, device.CreateShader("line"));
RgbaSpriteShader = device.CreateShader("rgba"); RgbaSpriteRenderer = new SpriteRenderer(this, device.CreateShader("rgba"));
SpriteShader = device.CreateShader("shp"); SpriteRenderer = new SpriteRenderer(this, device.CreateShader("shp"));
WorldSpriteRenderer = new SpriteRenderer(this, WorldSpriteShader);
WorldLineRenderer = new LineRenderer(this, WorldLineShader);
LineRenderer = new LineRenderer(this, LineShader);
RgbaSpriteRenderer = new SpriteRenderer(this, RgbaSpriteShader);
SpriteRenderer = new SpriteRenderer(this, SpriteShader);
for (int i = 0; i < TempBufferCount; i++) for (int i = 0; i < TempBufferCount; i++)
tempBuffers.Enqueue(device.CreateVertexBuffer(TempBufferSize)); tempBuffers.Enqueue(device.CreateVertexBuffer(TempBufferSize));
@@ -76,23 +65,11 @@ namespace OpenRA.Graphics
public void BeginFrame(float2 scroll, float zoom) public void BeginFrame(float2 scroll, float zoom)
{ {
device.Clear(); device.Clear();
float2 r1 = new float2(2f/Resolution.Width, -2f/Resolution.Height); WorldSpriteRenderer.SetShaderParams(PaletteTexture, Resolution, zoom, scroll);
float2 r2 = new float2(-1, 1); WorldLineRenderer.SetShaderParams(PaletteTexture, Resolution, zoom, scroll);
var zr1 = zoom*r1; SpriteRenderer.SetShaderParams(PaletteTexture, Resolution, 1f, float2.Zero);
LineRenderer.SetShaderParams(PaletteTexture, Resolution, 1f, float2.Zero);
SetShaderParams(WorldSpriteShader, zr1, r2, scroll); RgbaSpriteRenderer.SetShaderParams(PaletteTexture, Resolution, 1f, float2.Zero);
SetShaderParams(WorldLineShader, zr1, r2, scroll);
SetShaderParams(LineShader, r1, r2, float2.Zero);
SetShaderParams(RgbaSpriteShader, r1, r2, float2.Zero);
SetShaderParams(SpriteShader, r1, r2, float2.Zero);
}
void SetShaderParams(IShader s, float2 r1, float2 r2, float2 scroll)
{
s.SetValue("Palette", PaletteTexture);
s.SetValue("Scroll", (int)scroll.X, (int)scroll.Y);
s.SetValue("r1", r1.X, r1.Y);
s.SetValue("r2", r2.X, r2.Y);
} }
public void EndFrame(IInputHandler inputHandler) public void EndFrame(IInputHandler inputHandler)

21
OpenRA.Game/Graphics/SpriteRenderer.cs
View File

@@ -8,6 +8,7 @@
*/ */
#endregion #endregion
using System.Drawing;
using OpenRA.FileFormats.Graphics; using OpenRA.FileFormats.Graphics;
namespace OpenRA.Graphics namespace OpenRA.Graphics
@@ -27,14 +28,11 @@ namespace OpenRA.Graphics
this.shader = shader; this.shader = shader;
} }
public SpriteRenderer(Renderer renderer)
: this(renderer, renderer.SpriteShader) { }
public void Flush() public void Flush()
{ {
if (nv > 0) if (nv > 0)
{ {
shader.SetValue( "DiffuseTexture", currentSheet.Texture ); shader.SetTexture("DiffuseTexture", currentSheet.Texture);
shader.Render(() => shader.Render(() =>
{ {
var vb = renderer.GetTempVertexBuffer(); var vb = renderer.GetTempVertexBuffer();
@@ -72,7 +70,6 @@ namespace OpenRA.Graphics
nv += 4; nv += 4;
} }
// For RGBASpriteRenderer, which doesn't use palettes // For RGBASpriteRenderer, which doesn't use palettes
public void DrawSprite(Sprite s, float2 location) public void DrawSprite(Sprite s, float2 location)
{ {
@@ -83,5 +80,19 @@ namespace OpenRA.Graphics
{ {
DrawSprite(s, location, 0, size); DrawSprite(s, location, 0, size);
} }
public void DrawVertexBuffer(IVertexBuffer<Vertex> buffer, int start, int length, PrimitiveType type, Sheet sheet)
{
shader.SetTexture("DiffuseTexture", sheet.Texture);
shader.Render(() => renderer.DrawBatch(buffer, start, length, type));
}
public void SetShaderParams(ITexture palette, Size screen, float zoom, float2 scroll)
{
shader.SetTexture("Palette", palette);
shader.SetVec("Scroll", (int)scroll.X, (int)scroll.Y);
shader.SetVec("r1", zoom*2f/screen.Width, -zoom*2f/screen.Height);
shader.SetVec("r2", -1, 1);
}
} }
} }

8
OpenRA.Game/Graphics/TerrainRenderer.cs
View File

@@ -84,11 +84,9 @@ namespace OpenRA.Graphics
if( lastRow < firstRow ) lastRow = firstRow; if( lastRow < firstRow ) lastRow = firstRow;
Game.Renderer.WorldSpriteShader.SetValue( "DiffuseTexture", terrainSheet.Texture ); Game.Renderer.WorldSpriteRenderer.DrawVertexBuffer(
Game.Renderer.WorldSpriteShader.Render(() => vertexBuffer, verticesPerRow * firstRow, verticesPerRow * (lastRow - firstRow),
Game.Renderer.DrawBatch(vertexBuffer, PrimitiveType.QuadList, terrainSheet);
verticesPerRow * firstRow, verticesPerRow * (lastRow - firstRow),
PrimitiveType.QuadList));
foreach (var r in world.WorldActor.TraitsImplementing<IRenderOverlay>()) foreach (var r in world.WorldActor.TraitsImplementing<IRenderOverlay>())
r.Render( wr ); r.Render( wr );

77
OpenRA.Renderer.Cg/GraphicsDevice.cs
View File

@@ -24,21 +24,23 @@ namespace OpenRA.Renderer.Cg
{ {
public IGraphicsDevice Create(Size size, WindowMode windowMode) public IGraphicsDevice Create(Size size, WindowMode windowMode)
{ {
Console.WriteLine("Using Cg renderer");
return new GraphicsDevice(size, windowMode); return new GraphicsDevice(size, windowMode);
} }
} }
public class GraphicsDevice : IGraphicsDevice public class GraphicsDevice : SdlGraphics
{ {
Size windowSize; static string[] RequiredExtensions =
{
"GL_ARB_vertex_program",
"GL_ARB_fragment_program",
"GL_ARB_vertex_buffer_object"
};
internal IntPtr cgContext; internal IntPtr cgContext;
internal int vertexProfile, fragmentProfile; internal int vertexProfile, fragmentProfile;
IntPtr surf;
SdlInput input;
public Size WindowSize { get { return windowSize; } }
static Tao.Cg.Cg.CGerrorCallbackFuncDelegate CgErrorCallback = () => static Tao.Cg.Cg.CGerrorCallbackFuncDelegate CgErrorCallback = () =>
{ {
var err = Tao.Cg.Cg.cgGetError(); var err = Tao.Cg.Cg.cgGetError();
@@ -48,19 +50,8 @@ namespace OpenRA.Renderer.Cg
}; };
public GraphicsDevice(Size size, WindowMode window) public GraphicsDevice(Size size, WindowMode window)
: base(size, window, RequiredExtensions)
{ {
Console.WriteLine("Using Cg renderer");
windowSize = size;
var extensions = new []
{
"GL_ARB_vertex_program",
"GL_ARB_fragment_program",
"GL_ARB_vertex_buffer_object",
};
surf = SdlGraphics.InitializeSdlGl(ref windowSize, window, extensions);
cgContext = Tao.Cg.Cg.cgCreateContext(); cgContext = Tao.Cg.Cg.cgCreateContext();
Tao.Cg.Cg.cgSetErrorCallback(CgErrorCallback); Tao.Cg.Cg.cgSetErrorCallback(CgErrorCallback);
@@ -69,54 +60,8 @@ namespace OpenRA.Renderer.Cg
Tao.Cg.CgGl.cgGLSetManageTextureParameters(cgContext, true); Tao.Cg.CgGl.cgGLSetManageTextureParameters(cgContext, true);
vertexProfile = CgGl.cgGLGetLatestProfile(CgGl.CG_GL_VERTEX); vertexProfile = CgGl.cgGLGetLatestProfile(CgGl.CG_GL_VERTEX);
fragmentProfile = CgGl.cgGLGetLatestProfile(CgGl.CG_GL_FRAGMENT); fragmentProfile = CgGl.cgGLGetLatestProfile(CgGl.CG_GL_FRAGMENT);
Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY);
ErrorHandler.CheckGlError();
Gl.glEnableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
ErrorHandler.CheckGlError();
Sdl.SDL_SetModState(0); // i have had enough.
input = new SdlInput(surf);
} }
public void EnableScissor(int left, int top, int width, int height) public override IShader CreateShader(string name) { return new Shader(this, name); }
{
if (width < 0) width = 0;
if (height < 0) height = 0;
Gl.glScissor(left, windowSize.Height - ( top + height ), width, height);
ErrorHandler.CheckGlError();
Gl.glEnable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void DisableScissor()
{
Gl.glDisable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void Clear() { SdlGraphics.Clear(); }
public void Present() { Sdl.SDL_GL_SwapBuffers(); }
public void PumpInput(IInputHandler inputHandler) { input.PumpInput(inputHandler); }
public void DrawPrimitives(PrimitiveType pt, int firstVertex, int numVertices)
{
SdlGraphics.DrawPrimitives(pt, firstVertex, numVertices);
}
public void SetLineWidth(float width)
{
Gl.glLineWidth(width);
ErrorHandler.CheckGlError();
}
public IVertexBuffer<Vertex> CreateVertexBuffer(int size) { return new VertexBuffer<Vertex>(size); }
public ITexture CreateTexture() { return new Texture(); }
public ITexture CreateTexture(Bitmap bitmap) { return new Texture(bitmap); }
public IShader CreateShader(string name) { return new Shader(this, name); }
public int GpuMemoryUsed { get { return 0; } }
} }
} }

4
OpenRA.Renderer.Cg/Shader.cs
View File

@@ -67,7 +67,7 @@ namespace OpenRA.Renderer.Cg
Tao.Cg.CgGl.cgGLDisableProfile(dev.vertexProfile); Tao.Cg.CgGl.cgGLDisableProfile(dev.vertexProfile);
} }
public void SetValue(string name, ITexture t) public void SetTexture(string name, ITexture t)
{ {
var texture = (Texture)t; var texture = (Texture)t;
var param = Tao.Cg.Cg.cgGetNamedEffectParameter(effect, name); var param = Tao.Cg.Cg.cgGetNamedEffectParameter(effect, name);
@@ -75,7 +75,7 @@ namespace OpenRA.Renderer.Cg
Tao.Cg.CgGl.cgGLSetupSampler(param, texture.texture); Tao.Cg.CgGl.cgGLSetupSampler(param, texture.texture);
} }
public void SetValue(string name, float x, float y) public void SetVec(string name, float x, float y)
{ {
var param = Tao.Cg.Cg.cgGetNamedEffectParameter(effect, name); var param = Tao.Cg.Cg.cgGetNamedEffectParameter(effect, name);
if (param != IntPtr.Zero) if (param != IntPtr.Zero)

76
OpenRA.Renderer.Gl/GraphicsDevice.cs
View File

@@ -23,79 +23,23 @@ namespace OpenRA.Renderer.Glsl
{ {
public IGraphicsDevice Create(Size size, WindowMode windowMode) public IGraphicsDevice Create(Size size, WindowMode windowMode)
{ {
Console.WriteLine("Using Gl renderer");
return new GraphicsDevice(size, windowMode); return new GraphicsDevice(size, windowMode);
} }
} }
public class GraphicsDevice : IGraphicsDevice public class GraphicsDevice : SdlGraphics
{ {
Size windowSize; static string[] RequiredExtensions =
IntPtr surf; {
SdlInput input; "GL_ARB_vertex_shader",
"GL_ARB_fragment_shader",
public Size WindowSize { get { return windowSize; } } "GL_ARB_vertex_buffer_object"
};
public GraphicsDevice(Size size, WindowMode window) public GraphicsDevice(Size size, WindowMode window)
{ : base(size, window, RequiredExtensions) {}
Console.WriteLine("Using Gl renderer");
windowSize = size;
var extensions = new [] public override IShader CreateShader(string name) { return new Shader( this, name ); }
{
"GL_ARB_vertex_shader",
"GL_ARB_fragment_shader",
"GL_ARB_vertex_buffer_object",
};
surf = SdlGraphics.InitializeSdlGl(ref windowSize, window, extensions);
Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY);
ErrorHandler.CheckGlError();
Gl.glEnableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
ErrorHandler.CheckGlError();
Sdl.SDL_SetModState(0);
input = new SdlInput(surf);
}
public void EnableScissor(int left, int top, int width, int height)
{
if (width < 0) width = 0;
if (height < 0) height = 0;
Gl.glScissor(left, windowSize.Height - ( top + height ), width, height);
ErrorHandler.CheckGlError();
Gl.glEnable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void DisableScissor()
{
Gl.glDisable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void Clear() { SdlGraphics.Clear(); }
public void Present() { Sdl.SDL_GL_SwapBuffers(); }
public void PumpInput(IInputHandler inputHandler) { input.PumpInput(inputHandler); }
public void DrawPrimitives(PrimitiveType pt, int firstVertex, int numVertices)
{
SdlGraphics.DrawPrimitives(pt, firstVertex, numVertices);
}
public void SetLineWidth( float width )
{
Gl.glLineWidth(width);
ErrorHandler.CheckGlError();
}
public IVertexBuffer<Vertex> CreateVertexBuffer( int size ) { return new VertexBuffer<Vertex>( size ); }
public ITexture CreateTexture() { return new Texture(); }
public ITexture CreateTexture( Bitmap bitmap ) { return new Texture( bitmap ); }
public IShader CreateShader( string name ) { return new Shader( this, name ); }
public int GpuMemoryUsed { get; internal set; }
} }
} }

9
OpenRA.Renderer.Gl/Shader.cs
View File

@@ -132,15 +132,16 @@ namespace OpenRA.Renderer.Glsl
ErrorHandler.CheckGlError(); ErrorHandler.CheckGlError();
} }
public void SetValue(string name, ITexture t) public void SetTexture(string name, ITexture t)
{ {
if( t == null ) return; if (t == null)
return;
int texUnit; int texUnit;
if( samplers.TryGetValue( name, out texUnit ) ) if (samplers.TryGetValue(name, out texUnit))
textures[texUnit] = t; textures[texUnit] = t;
} }
public void SetValue(string name, float x, float y) public void SetVec(string name, float x, float y)
{ {
Gl.glUseProgramObjectARB(program); Gl.glUseProgramObjectARB(program);
ErrorHandler.CheckGlError(); ErrorHandler.CheckGlError();

6
OpenRA.Renderer.Null/NullGraphicsDevice.cs
View File

@@ -54,14 +54,12 @@ namespace OpenRA.Renderer.Null
public ITexture CreateTexture() { return new NullTexture(); } public ITexture CreateTexture() { return new NullTexture(); }
public ITexture CreateTexture(Bitmap bitmap) { return new NullTexture(); } public ITexture CreateTexture(Bitmap bitmap) { return new NullTexture(); }
public IShader CreateShader(string name) { return new NullShader(); } public IShader CreateShader(string name) { return new NullShader(); }
public int GpuMemoryUsed { get { return 0; } }
} }
public class NullShader : IShader public class NullShader : IShader
{ {
public void SetValue(string name, float x, float y) { } public void SetVec(string name, float x, float y) { }
public void SetValue(string param, ITexture texture) { } public void SetTexture(string param, ITexture texture) { }
public void Commit() { } public void Commit() { }
public void Render(Action a) { } public void Render(Action a) { }
} }

73
OpenRA.Renderer.SdlCommon/SdlGraphics.cs
View File

@@ -18,9 +18,30 @@ using Tao.Sdl;
namespace OpenRA.Renderer.SdlCommon namespace OpenRA.Renderer.SdlCommon
{ {
public static class SdlGraphics public abstract class SdlGraphics : IGraphicsDevice
{ {
public static IntPtr InitializeSdlGl( ref Size size, WindowMode window, string[] requiredExtensions ) Size windowSize;
IntPtr surf;
SdlInput input;
public Size WindowSize { get { return windowSize; } }
public SdlGraphics(Size size, WindowMode window, string[] extensions)
{
windowSize = size;
surf = InitializeSdlGl(ref windowSize, window, extensions);
Gl.glEnableClientState(Gl.GL_VERTEX_ARRAY);
ErrorHandler.CheckGlError();
Gl.glEnableClientState(Gl.GL_TEXTURE_COORD_ARRAY);
ErrorHandler.CheckGlError();
Sdl.SDL_SetModState(0);
input = new SdlInput(surf);
}
IntPtr InitializeSdlGl(ref Size size, WindowMode window, string[] requiredExtensions)
{ {
Sdl.SDL_Init( Sdl.SDL_INIT_NOPARACHUTE | Sdl.SDL_INIT_VIDEO ); Sdl.SDL_Init( Sdl.SDL_INIT_NOPARACHUTE | Sdl.SDL_INIT_VIDEO );
Sdl.SDL_GL_SetAttribute( Sdl.SDL_GL_DOUBLEBUFFER, 1 ); Sdl.SDL_GL_SetAttribute( Sdl.SDL_GL_DOUBLEBUFFER, 1 );
@@ -30,7 +51,7 @@ namespace OpenRA.Renderer.SdlCommon
Sdl.SDL_GL_SetAttribute( Sdl.SDL_GL_ALPHA_SIZE, 0 ); Sdl.SDL_GL_SetAttribute( Sdl.SDL_GL_ALPHA_SIZE, 0 );
int windowFlags = 0; int windowFlags = 0;
switch( window ) switch (window)
{ {
case WindowMode.Fullscreen: case WindowMode.Fullscreen:
windowFlags |= Sdl.SDL_FULLSCREEN; windowFlags |= Sdl.SDL_FULLSCREEN;
@@ -59,14 +80,14 @@ namespace OpenRA.Renderer.SdlCommon
Console.WriteLine("Using resolution: {0}x{1}", size.Width, size.Height); Console.WriteLine("Using resolution: {0}x{1}", size.Width, size.Height);
var surf = Sdl.SDL_SetVideoMode( size.Width, size.Height, 0, Sdl.SDL_OPENGL | windowFlags ); var surf = Sdl.SDL_SetVideoMode(size.Width, size.Height, 0, Sdl.SDL_OPENGL | windowFlags);
if (surf == IntPtr.Zero) if (surf == IntPtr.Zero)
Console.WriteLine("Failed to set video mode."); Console.WriteLine("Failed to set video mode.");
Sdl.SDL_WM_SetCaption( "OpenRA", "OpenRA" ); Sdl.SDL_WM_SetCaption("OpenRA", "OpenRA");
Sdl.SDL_ShowCursor( 0 ); Sdl.SDL_ShowCursor(0);
Sdl.SDL_EnableUNICODE( 1 ); Sdl.SDL_EnableUNICODE(1);
Sdl.SDL_EnableKeyRepeat( Sdl.SDL_DEFAULT_REPEAT_DELAY, Sdl.SDL_DEFAULT_REPEAT_INTERVAL ); Sdl.SDL_EnableKeyRepeat(Sdl.SDL_DEFAULT_REPEAT_DELAY, Sdl.SDL_DEFAULT_REPEAT_INTERVAL);
ErrorHandler.CheckGlError(); ErrorHandler.CheckGlError();
@@ -86,7 +107,7 @@ namespace OpenRA.Renderer.SdlCommon
return surf; return surf;
} }
static int ModeFromPrimitiveType(PrimitiveType pt) int ModeFromPrimitiveType(PrimitiveType pt)
{ {
switch(pt) switch(pt)
{ {
@@ -98,19 +119,49 @@ namespace OpenRA.Renderer.SdlCommon
throw new NotImplementedException(); throw new NotImplementedException();
} }
public static void DrawPrimitives(PrimitiveType pt, int firstVertex, int numVertices) public void DrawPrimitives(PrimitiveType pt, int firstVertex, int numVertices)
{ {
Gl.glDrawArrays(ModeFromPrimitiveType(pt), firstVertex, numVertices); Gl.glDrawArrays(ModeFromPrimitiveType(pt), firstVertex, numVertices);
ErrorHandler.CheckGlError(); ErrorHandler.CheckGlError();
} }
public static void Clear() public void Clear()
{ {
Gl.glClearColor(0, 0, 0, 0); Gl.glClearColor(0, 0, 0, 0);
ErrorHandler.CheckGlError(); ErrorHandler.CheckGlError();
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT); Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
ErrorHandler.CheckGlError(); ErrorHandler.CheckGlError();
} }
public void EnableScissor(int left, int top, int width, int height)
{
if (width < 0) width = 0;
if (height < 0) height = 0;
Gl.glScissor(left, windowSize.Height - (top + height), width, height);
ErrorHandler.CheckGlError();
Gl.glEnable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void DisableScissor()
{
Gl.glDisable(Gl.GL_SCISSOR_TEST);
ErrorHandler.CheckGlError();
}
public void SetLineWidth(float width)
{
Gl.glLineWidth(width);
ErrorHandler.CheckGlError();
}
public void Present() { Sdl.SDL_GL_SwapBuffers(); }
public void PumpInput(IInputHandler inputHandler) { input.PumpInput(inputHandler); }
public IVertexBuffer<Vertex> CreateVertexBuffer(int size) { return new VertexBuffer<Vertex>(size); }
public ITexture CreateTexture() { return new Texture(); }
public ITexture CreateTexture(Bitmap bitmap) { return new Texture(bitmap); }
public abstract IShader CreateShader(string name);
} }
} }