private int /*GLuint*/ Compile(OpenGL.ShaderType type, string source)
{
OpenGLRendererBase.CheckGLErrors();
var shader = OpenGL.GL.CreateShader(type);
if (shader == 0)
{
throw new Exception/*RendererException*/ ($"Critical Error - Could not create shader object of type:{type}.");
}
OpenGLRendererBase.CheckGLErrors();
// Define shader source and compile
OpenGL.GL.ShaderSource(shader, source);
OpenGL.GL.CompileShader(shader);
// Check for errors
OpenGL.GL.GetShader(shader, OpenGL.ShaderParameter.CompileStatus, out var status);
if (status == 0)
{
OutputShaderLog(shader);
return(0);
}
OpenGLRendererBase.CheckGLErrors();
return(shader);
}
protected OpenGLTextureTarget(OpenGLRendererBase owner, bool addStencilBuffer)
: base(owner)
{
d_texture = 0;
d_usesStencil = addStencilBuffer;
CreateCEGUITexture();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="owner"></param>
/// <param name="renderMaterial"></param>
protected OpenGLGeometryBufferBase(OpenGLRendererBase owner, RenderMaterial renderMaterial)
: base(renderMaterial)
{
d_owner = owner;
d_clippingActive = true;
d_matrix = new Matrix();
d_matrixValid = false;
}
/// <summary>
/// Basic constructor.
/// </summary>
/// <param name="owner"></param>
/// <param name="name"></param>
internal OpenGLTexture(OpenGLRendererBase owner, string name)
{
d_size = Sizef.Zero;
d_grabBuffer = null;
d_dataSize = Sizef.Zero;
d_texelScaling = Vector2.Zero;
_owner = owner;
d_name = name;
}
/// <summary>
/// Construct a default OpenGLViewportTarget that uses the currently
/// defined OpenGL viewport as it's initial area.
/// </summary>
/// <param name="owner"></param>
internal OpenGLViewportTarget(OpenGLRendererBase owner)
: base(owner)
{
// viewport area defaults to whatever the current OpenGL viewport is set to
var vp = new int[4];
OpenGL.GL.GetInteger(OpenGL.GetPName.Viewport, vp);
var initArea = new Rectf(new Vector2(vp[0], vp[1]),
new Sizef(vp[2], vp[3]));
SetArea(initArea);
}
public virtual void Link()
{
// Attach shaders and link
OpenGL.GL.AttachShader(d_program, d_vertexShader);
if (d_geometryShader != 0)
{
OpenGL.GL.AttachShader(d_program, d_geometryShader);
}
if (d_fragmentShader != 0)
{
OpenGL.GL.AttachShader(d_program, d_fragmentShader);
}
OpenGL.GL.LinkProgram(d_program);
// Check for problems
OpenGL.GL.GetProgram(d_program, OpenGL.GetProgramParameterName.LinkStatus, out var status);
if (status == 0)
{
OutputProgramLog(d_program);
OpenGL.GL.DeleteProgram(d_program);
d_program = 0;
}
OpenGLRendererBase.CheckGLErrors();
if (d_program == 0)
{
return;
}
d_createdSuccessfully = true;
OpenGLRendererBase.CheckGLErrors();
}
/// <summary>
/// Creates and loads shader programs from the two strings supplied to it
/// </summary>
/// <param name="vertex_shader_source"></param>
/// <param name="fragment_shader_source"></param>
/// <param name="glStateChanger"></param>
public OpenGLBaseShader(string vertex_shader_source,
string fragment_shader_source,
OpenGLBaseStateChangeWrapper glStateChanger)
{
d_glStateChanger = glStateChanger;
d_createdSuccessfully = false;
d_vertexShader = 0;
d_fragmentShader = 0;
d_geometryShader = 0;
d_program = 0;
// Compile the shaders
d_vertexShader = Compile(OpenGL.ShaderType.VertexShader, vertex_shader_source);
if (d_vertexShader == 0)
{
return;
}
OpenGLRendererBase.CheckGLErrors();
if (!string.IsNullOrWhiteSpace(fragment_shader_source))
{
d_fragmentShader = Compile(OpenGL.ShaderType.FragmentShader, fragment_shader_source);
if (d_fragmentShader == 0)
{
return;
}
}
OpenGLRendererBase.CheckGLErrors();
d_program = OpenGL.GL.CreateProgram();
}
protected OpenGLRenderTarget(OpenGLRendererBase owner)
{
Owner = owner;
}
// TODO: virtual ~OGLTextureTargetFactory() {}
public virtual ITextureTarget Create(OpenGLRendererBase renderer)
{
return(null);
}
public OpenGL1Texture(OpenGLRendererBase owner, string name)
: base(owner, name)
{
}
/// <summary>
/// Construct a OpenGLViewportTarget that uses the specified Rect as it's initial area.
/// </summary>
/// <param name="owner"></param>
/// <param name="area">
/// Rect object describing the initial viewport area that should be used for the RenderTarget.
/// </param>
internal OpenGLViewportTarget(OpenGLRendererBase owner, Rectf area)
: base(owner)
{
SetArea(area);
}
