397 lines
12 KiB
C#
397 lines
12 KiB
C#
#region Copyright & License Information
|
|
/*
|
|
* Copyright 2007,2009,2010 Chris Forbes, Robert Pepperell, Matthew Bowra-Dean, Paul Chote, Alli Witheford.
|
|
* This file is part of OpenRA.
|
|
*
|
|
* OpenRA is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* OpenRA is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with OpenRA. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
#endregion
|
|
|
|
using System;
|
|
using System.Drawing;
|
|
using System.Drawing.Imaging;
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Windows.Forms;
|
|
using Tao.Cg;
|
|
using Tao.OpenGl;
|
|
using Tao.Platform.Windows;
|
|
using OpenRa.FileFormats.Graphics;
|
|
using Tao.Glfw;
|
|
|
|
[assembly: Renderer( typeof( OpenRa.GlRenderer.GraphicsDevice ))]
|
|
|
|
namespace OpenRa.GlRenderer
|
|
{
|
|
public class GraphicsDevice : IGraphicsDevice
|
|
{
|
|
Size windowSize;
|
|
internal IntPtr cgContext;
|
|
internal int vertexProfile, fragmentProfile;
|
|
|
|
readonly Glfw.GLFWmousebuttonfun mouseButtonCallback;
|
|
readonly Glfw.GLFWmouseposfun mousePositionCallback;
|
|
readonly Glfw.GLFWwindowclosefun windowCloseCallback;
|
|
int mouseX, mouseY;
|
|
|
|
public Size WindowSize { get { return windowSize; } }
|
|
|
|
internal static void CheckGlError()
|
|
{
|
|
var n = Gl.glGetError();
|
|
if (n != Gl.GL_NO_ERROR)
|
|
throw new InvalidOperationException("GL Error");
|
|
}
|
|
|
|
public GraphicsDevice( int width, int height, bool fullscreen, bool vsync )
|
|
{
|
|
Glfw.glfwInit();
|
|
Glfw.glfwOpenWindow(width, height, 0, 0, 0, 0, 0, 0, /*fullscreen ? Glfw.GLFW_FULLSCREEN : */Glfw.GLFW_WINDOW);
|
|
bool initDone = false;
|
|
|
|
var lastButtonBits = (MouseButtons)0;
|
|
|
|
Glfw.glfwSetMouseButtonCallback( mouseButtonCallback = ( button, action ) =>
|
|
{
|
|
var b = button == Glfw.GLFW_MOUSE_BUTTON_1 ? MouseButtons.Left
|
|
: button == Glfw.GLFW_MOUSE_BUTTON_2 ? MouseButtons.Right
|
|
: button == Glfw.GLFW_MOUSE_BUTTON_3 ? MouseButtons.Middle
|
|
: 0;
|
|
Game.DispatchMouseInput( action == Glfw.GLFW_PRESS ? MouseInputEvent.Down : MouseInputEvent.Up,
|
|
new MouseEventArgs( b, action == Glfw.GLFW_PRESS ? 1 : 0, mouseX, mouseY, 0 ), 0 );
|
|
|
|
if (action == Glfw.GLFW_PRESS) lastButtonBits |= b;
|
|
else lastButtonBits &= ~b;
|
|
|
|
if (action != Glfw.GLFW_PRESS && action != Glfw.GLFW_RELEASE)
|
|
throw new InvalidOperationException();
|
|
} );
|
|
Glfw.glfwSetMousePosCallback(mousePositionCallback = (x, y) =>
|
|
{
|
|
mouseX = x;
|
|
mouseY = y;
|
|
if (initDone)
|
|
Game.DispatchMouseInput(MouseInputEvent.Move, new MouseEventArgs(lastButtonBits, 0, x, y, 0), 0);
|
|
});
|
|
Glfw.glfwSetWindowCloseCallback( windowCloseCallback = () =>
|
|
{
|
|
Game.Exit();
|
|
Glfw.glfwIconifyWindow();
|
|
return Gl.GL_TRUE;
|
|
} );
|
|
CheckGlError();
|
|
|
|
Glfw.glfwGetWindowSize(out width, out height);
|
|
windowSize = new Size( width, height );
|
|
|
|
cgContext = Cg.cgCreateContext();
|
|
Cg.cgSetErrorCallback( CgErrorCallback );
|
|
|
|
CgGl.cgGLRegisterStates( cgContext );
|
|
CgGl.cgGLSetManageTextureParameters( cgContext, true );
|
|
vertexProfile = CgGl.cgGLGetLatestProfile( CgGl.CG_GL_VERTEX );
|
|
fragmentProfile = CgGl.cgGLGetLatestProfile( CgGl.CG_GL_FRAGMENT );
|
|
|
|
Gl.glEnableClientState( Gl.GL_VERTEX_ARRAY );
|
|
CheckGlError();
|
|
Gl.glEnableClientState( Gl.GL_TEXTURE_COORD_ARRAY );
|
|
CheckGlError();
|
|
|
|
initDone = true;
|
|
}
|
|
|
|
static Cg.CGerrorCallbackFuncDelegate CgErrorCallback = () =>
|
|
{
|
|
var err = Cg.cgGetError();
|
|
var str = Cg.cgGetErrorString( err );
|
|
throw new InvalidOperationException(
|
|
string.Format( "CG Error: {0}: {1}", err, str ) );
|
|
};
|
|
|
|
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 );
|
|
CheckGlError();
|
|
Gl.glEnable(Gl.GL_SCISSOR_TEST);
|
|
CheckGlError();
|
|
}
|
|
|
|
public void DisableScissor()
|
|
{
|
|
Gl.glDisable(Gl.GL_SCISSOR_TEST);
|
|
CheckGlError();
|
|
}
|
|
|
|
public void Begin() { }
|
|
public void End() { }
|
|
|
|
public void Clear(Color c)
|
|
{
|
|
Gl.glClearColor(0, 0, 0, 0);
|
|
CheckGlError();
|
|
Gl.glClear(Gl.GL_COLOR_BUFFER_BIT);
|
|
CheckGlError();
|
|
}
|
|
|
|
public void Present()
|
|
{
|
|
Glfw.glfwSwapBuffers();
|
|
Glfw.glfwPollEvents();
|
|
CheckGlError();
|
|
}
|
|
|
|
public void DrawIndexedPrimitives( PrimitiveType pt, Range<int> vertices, Range<int> indices )
|
|
{
|
|
Gl.glDrawElements( ModeFromPrimitiveType( pt ), indices.End - indices.Start, Gl.GL_UNSIGNED_SHORT, new IntPtr( indices.Start * 2 ) );
|
|
CheckGlError();
|
|
}
|
|
|
|
public void DrawIndexedPrimitives( PrimitiveType pt, int numVerts, int numPrimitives )
|
|
{
|
|
Gl.glDrawElements( ModeFromPrimitiveType( pt ), numPrimitives * IndicesPerPrimitive( pt ), Gl.GL_UNSIGNED_SHORT, IntPtr.Zero );
|
|
CheckGlError();
|
|
}
|
|
|
|
static int ModeFromPrimitiveType( PrimitiveType pt )
|
|
{
|
|
switch( pt )
|
|
{
|
|
case PrimitiveType.PointList: return Gl.GL_POINTS;
|
|
case PrimitiveType.LineList: return Gl.GL_LINES;
|
|
case PrimitiveType.TriangleList: return Gl.GL_TRIANGLES;
|
|
}
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
static int IndicesPerPrimitive( PrimitiveType pt )
|
|
{
|
|
switch( pt )
|
|
{
|
|
case PrimitiveType.PointList: return 1;
|
|
case PrimitiveType.LineList: return 2;
|
|
case PrimitiveType.TriangleList: return 3;
|
|
}
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
#region IGraphicsDevice Members
|
|
|
|
public IVertexBuffer<T> CreateVertexBuffer<T>( int size )
|
|
where T : struct
|
|
{
|
|
return new VertexBuffer<T>( this, size );
|
|
}
|
|
|
|
public IIndexBuffer CreateIndexBuffer( int size )
|
|
{
|
|
return new IndexBuffer( this, size );
|
|
}
|
|
|
|
public ITexture CreateTexture( Bitmap bitmap )
|
|
{
|
|
return new Texture( this, bitmap );
|
|
}
|
|
|
|
public IShader CreateShader( Stream stream )
|
|
{
|
|
return new Shader( this, stream );
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
|
|
public class VertexBuffer<T> : IVertexBuffer<T>, IDisposable
|
|
where T : struct
|
|
{
|
|
int buffer;
|
|
|
|
public VertexBuffer(GraphicsDevice dev, int size)
|
|
{
|
|
Gl.glGenBuffers(1, out buffer);
|
|
GraphicsDevice.CheckGlError();
|
|
}
|
|
|
|
public void SetData(T[] data)
|
|
{
|
|
Bind();
|
|
Gl.glBufferData(Gl.GL_ARRAY_BUFFER,
|
|
new IntPtr(Marshal.SizeOf(typeof(T))*data.Length), data, Gl.GL_DYNAMIC_DRAW);
|
|
GraphicsDevice.CheckGlError();
|
|
}
|
|
|
|
public void Bind()
|
|
{
|
|
Gl.glBindBuffer(Gl.GL_ARRAY_BUFFER, buffer);
|
|
GraphicsDevice.CheckGlError();
|
|
Gl.glVertexPointer(3, Gl.GL_FLOAT, Marshal.SizeOf(typeof(T)), IntPtr.Zero);
|
|
GraphicsDevice.CheckGlError();
|
|
Gl.glTexCoordPointer(4, Gl.GL_FLOAT, Marshal.SizeOf(typeof(T)), new IntPtr(12));
|
|
GraphicsDevice.CheckGlError();
|
|
}
|
|
|
|
bool disposed;
|
|
public void Dispose()
|
|
{
|
|
if (disposed) return;
|
|
GC.SuppressFinalize(this);
|
|
Gl.glDeleteBuffers(1, ref buffer);
|
|
GraphicsDevice.CheckGlError();
|
|
disposed = true;
|
|
}
|
|
|
|
//~VertexBuffer() { Dispose(); }
|
|
}
|
|
|
|
public class IndexBuffer : IIndexBuffer, IDisposable
|
|
{
|
|
int buffer;
|
|
|
|
public IndexBuffer(GraphicsDevice dev, int size)
|
|
{
|
|
Gl.glGenBuffers(1, out buffer);
|
|
GraphicsDevice.CheckGlError();
|
|
}
|
|
|
|
public void SetData(ushort[] data)
|
|
{
|
|
Bind();
|
|
Gl.glBufferData(Gl.GL_ELEMENT_ARRAY_BUFFER,
|
|
new IntPtr(2 * data.Length), data, Gl.GL_DYNAMIC_DRAW);
|
|
GraphicsDevice.CheckGlError();
|
|
}
|
|
|
|
public void Bind()
|
|
{
|
|
Gl.glBindBuffer(Gl.GL_ELEMENT_ARRAY_BUFFER, buffer);
|
|
GraphicsDevice.CheckGlError();
|
|
}
|
|
|
|
bool disposed;
|
|
public void Dispose()
|
|
{
|
|
if (disposed) return;
|
|
GC.SuppressFinalize(this);
|
|
Gl.glDeleteBuffers(1, ref buffer);
|
|
GraphicsDevice.CheckGlError();
|
|
disposed = true;
|
|
}
|
|
|
|
//~IndexBuffer() { Dispose(); }
|
|
}
|
|
|
|
public class Shader : IShader
|
|
{
|
|
IntPtr effect;
|
|
IntPtr technique;
|
|
GraphicsDevice dev;
|
|
|
|
public Shader(GraphicsDevice dev, Stream s)
|
|
{
|
|
this.dev = dev;
|
|
string code;
|
|
using (var file = new StreamReader(s))
|
|
code = file.ReadToEnd();
|
|
effect = Cg.cgCreateEffect(dev.cgContext, code, null);
|
|
|
|
if (effect == IntPtr.Zero)
|
|
{
|
|
var err = Cg.cgGetErrorString(Cg.cgGetError());
|
|
var results = Cg.cgGetLastListing(dev.cgContext);
|
|
throw new InvalidOperationException(
|
|
string.Format("Cg compile failed ({0}):\n{1}", err, results));
|
|
}
|
|
|
|
technique = Cg.cgGetFirstTechnique( effect );
|
|
if( technique == IntPtr.Zero )
|
|
throw new InvalidOperationException("No techniques");
|
|
while( Cg.cgValidateTechnique( technique ) == 0 )
|
|
{
|
|
technique = Cg.cgGetNextTechnique( technique );
|
|
if( technique == IntPtr.Zero )
|
|
throw new InvalidOperationException("No valid techniques");
|
|
}
|
|
}
|
|
|
|
public void Render(Action a)
|
|
{
|
|
CgGl.cgGLEnableProfile(dev.vertexProfile);
|
|
CgGl.cgGLEnableProfile(dev.fragmentProfile);
|
|
|
|
var pass = Cg.cgGetFirstPass(technique);
|
|
while (pass != IntPtr.Zero)
|
|
{
|
|
Cg.cgSetPassState(pass);
|
|
a();
|
|
Cg.cgResetPassState(pass);
|
|
pass = Cg.cgGetNextPass(pass);
|
|
}
|
|
|
|
CgGl.cgGLDisableProfile(dev.fragmentProfile);
|
|
CgGl.cgGLDisableProfile(dev.vertexProfile);
|
|
}
|
|
|
|
public void SetValue(string name, ITexture t)
|
|
{
|
|
var texture = (Texture)t;
|
|
var param = Cg.cgGetNamedEffectParameter( effect, name );
|
|
if( param != IntPtr.Zero && texture != null )
|
|
CgGl.cgGLSetupSampler( param, texture.texture );
|
|
}
|
|
|
|
public void SetValue(string name, float x, float y)
|
|
{
|
|
var param = Cg.cgGetNamedEffectParameter(effect, name);
|
|
if( param != IntPtr.Zero )
|
|
CgGl.cgGLSetParameter2f(param, x, y);
|
|
}
|
|
|
|
public void Commit() { }
|
|
}
|
|
|
|
public class Texture : ITexture
|
|
{
|
|
internal int texture;
|
|
|
|
public Texture(GraphicsDevice dev, Bitmap bitmap)
|
|
{
|
|
Gl.glGenTextures(1, out texture);
|
|
GraphicsDevice.CheckGlError();
|
|
SetData(bitmap);
|
|
}
|
|
|
|
public void SetData(Bitmap bitmap)
|
|
{
|
|
Gl.glBindTexture( Gl.GL_TEXTURE_2D, texture );
|
|
GraphicsDevice.CheckGlError();
|
|
|
|
var bits = bitmap.LockBits(
|
|
new Rectangle(0, 0, bitmap.Width, bitmap.Height),
|
|
ImageLockMode.ReadOnly,
|
|
PixelFormat.Format32bppArgb);
|
|
|
|
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_BASE_LEVEL, 0);
|
|
GraphicsDevice.CheckGlError();
|
|
Gl.glTexParameteri(Gl.GL_TEXTURE_2D, Gl.GL_TEXTURE_MAX_LEVEL, 0);
|
|
GraphicsDevice.CheckGlError();
|
|
Gl.glTexImage2D(Gl.GL_TEXTURE_2D, 0, Gl.GL_RGBA8, bits.Width, bits.Height,
|
|
0, Gl.GL_BGRA, Gl.GL_UNSIGNED_BYTE, bits.Scan0); // todo: weird strides
|
|
GraphicsDevice.CheckGlError();
|
|
|
|
bitmap.UnlockBits(bits);
|
|
}
|
|
}
|
|
}
|