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); }