github-starred/ultimatepp
2
0
Fork 0
mirror of https://github.com/ultimatepp/ultimatepp.git synced 2026-05-15 14:16:07 -06:00
Code Issues 33 Projects Packages Wiki Activity Actions

CoreGl: Added support for geometry shaders and attributes. Moved fbo implementation to separate file

Browse source 
git-svn-id: svn://ultimatepp.org/upp/trunk@6321 f0d560ea-af0d-0410-9eb7-867de7ffcac7
This commit is contained in:
unodgs 2013-09-08 10:32:22 +00:00
parent 89e6e36eca
commit bc9b4f37ed
13 changed files with 418 additions and 219 deletions
Download patch file Download diff file Expand all files Collapse all files

65
rainbow/CoreGl/CoreGl.h
View file

@ -16,45 +16,12 @@
2 - Stencil clip
3 - Manual clip
*/
#ifdef flagLINUXGL
#define Time XTime
#define Font XFont
#define Display XDisplay
#define Picture XPicture
#define Screen XScreen
#define Window XWindow
#define Complex XComplex
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#endif
#include <CoreGl/glew.h>
#ifdef flagWINGL
#include <CoreGl/wglew.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#ifdef flagLINUXGL
#include <GL/glx.h>
#endif
#ifdef flagLINUXGL
#undef Picture
#undef Time
#undef Font
#undef Display
#undef Screen
#undef Window
#undef Complex
#endif
#include "Gl.h"
#include <Painter/Painter.h>
#include "Shaders.h"
#include "Fbo.h"
NAMESPACE_UPP
struct FrameInfo {
@ -74,35 +41,11 @@ float GetFps();
#define IMAGEFILE <CoreGl/CoreGl.iml>
#include <Draw/iml_header.h>
#include "Shaders.h"
#include "Resources.brc"
typedef Rect_<float> RectF;
typedef Point_<float> PointF;
struct Fbo : Moveable<Fbo>
{
GLuint texId;
GLuint fbId;
GLuint rbId;
GLenum status;
int width;
int height;
bool ready;
bool Create(int width, int height, bool resize = false);
void Resize(int width, int height);
void Bind();
void Unbind();
void Clear();
void BlitToScreen();
void BlitTo(const Fbo& fbo);
String GetError();
Fbo() : width(0), height(0), ready(false)
{}
};
#include "FontGl.h"
#include "ResGl.h"

3
rainbow/CoreGl/CoreGl.upp
View file

@ -4,6 +4,7 @@ uses
options(WIN32) "-D_WIN32 -DGLEW_STATIC";
file
Gl.h,
CoreGl.h,
FontGl.h,
ResGl.h,
@ -40,6 +41,8 @@ file
Resources readonly separator,
Resources.cpp,
Resources.brc,
Fbo.h,
Fbo.cpp,
Shaders.h,
Shaders.cpp,
AlphaMag.vert,

1
rainbow/CoreGl/Ctrl.cpp
View file

@ -10,7 +10,6 @@ int Ctrl::Xbuttons;
int Ctrl::Xbuttontime;
Point Ctrl::Xbuttonpos;
void Ctrl::GuiPlatformConstruct()
{
cliptobounds = true;

3
rainbow/CoreGl/Ctrl.h
View file

@ -46,7 +46,8 @@ public:
static Console console;
static Rect screenRect;
static bool screenReady;
static void InitGl();
static void ExitGl();
static void EndSession();

4
rainbow/CoreGl/DrawOp.cpp
View file

@ -364,8 +364,8 @@ void SystemDraw::DrawImageOp(int x, int y, int cx, int cy, const Image& img, con
#endif
}
}
glColor4ub(255, 255, 255, 255);
else
glColor4ub(255, 255, 255, 255);
float vtx[12];
SetVtx(vtx, sx, sy, dx, dy);

18
rainbow/CoreGl/DrawText.cpp
View file

@ -167,14 +167,14 @@ void SystemDraw::Text(int x, int y, int angle, const wchar *text, Font font, Col
int glowA = 1;
#endif
alphaMagProg.Set("GlyphColor", ink.GetR() * ic, ink.GetG() * ic, ink.GetB() * ic, inkA * ic * ac);
alphaMagProg.Set("OutlineColor", outlineColor.GetR() * ic, outlineColor.GetG() * ic, outlineColor.GetB() * ic, outlineA * ic * ac);
alphaMagProg.Set("GlowColor", glowColor.GetR() * ic, glowColor.GetG() * ic, glowColor.GetB() * ic, glowA * ic * ac);
alphaMagProg.Set("Outline", outlineStrength > 0); //0.1 - 0.45
alphaMagProg.Set("Glow", glowStrength > 0); //0.55 - 0.095
alphaMagProg.Set("Shadow", false);
alphaMagProg.Set("OutlineCenter", outlineCenter);
alphaMagProg.Set("GlowCenter", glowCenter);
alphaMagProg.SetUniform("GlyphColor", ink.GetR() * ic, ink.GetG() * ic, ink.GetB() * ic, inkA * ic * ac);
alphaMagProg.SetUniform("OutlineColor", outlineColor.GetR() * ic, outlineColor.GetG() * ic, outlineColor.GetB() * ic, outlineA * ic * ac);
alphaMagProg.SetUniform("GlowColor", glowColor.GetR() * ic, glowColor.GetG() * ic, glowColor.GetB() * ic, glowA * ic * ac);
alphaMagProg.SetUniform("Outline", outlineStrength > 0); //0.1 - 0.45
alphaMagProg.SetUniform("Glow", glowStrength > 0); //0.55 - 0.095
alphaMagProg.SetUniform("Shadow", false);
alphaMagProg.SetUniform("OutlineCenter", outlineCenter);
alphaMagProg.SetUniform("GlowCenter", glowCenter);
float xp = (float) x;
float yp = (float) y;
@ -201,7 +201,7 @@ void SystemDraw::Text(int x, int y, int angle, const wchar *text, Font font, Col
{
resources.Bind(fi.pages[ci.page], Resources::LINEAR_FILTERING);
glActiveTexture(GL_TEXTURE0);
alphaMagProg.Set("Texture", 0);
alphaMagProg.SetUniform("Texture", 0);
page = ci.page;
}

103
rainbow/CoreGl/Fbo.cpp Normal file
View file

@ -0,0 +1,103 @@
#include "Fbo.h"
NAMESPACE_UPP
bool Fbo::Create(int width, int height, bool resize)
{
this->width = width;
this->height = height;
if(!resize)
{
glGenFramebuffers(1, &fbId);
glGenRenderbuffers(1, &rbId);
glGenTextures(1, &texId);
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbId);
glBindTexture(GL_TEXTURE_2D, texId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0);
glBindRenderbuffer(GL_RENDERBUFFER, rbId);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbId, 0);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbId);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbId);
status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
ready = true;
return status == GL_FRAMEBUFFER_COMPLETE;
}
void Fbo::Resize(int width, int height)
{
if(ready)
Create(width, height, true);
}
void Fbo::Bind()
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbId);
}
void Fbo::Unbind()
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
void Fbo::Clear()
{
glClearColor(0.f, 0.f, 0.f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
void Fbo::BlitToScreen()
{
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbId);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
void Fbo::BlitTo(const Fbo& fbo)
{
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbId);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo.fbId);
glBlitFramebuffer(0, 0, width, height, 0, 0, fbo.width, fbo.height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
void Fbo::Remove()
{
glDeleteTextures(1, &texId);
glDeleteRenderbuffers(1, &rbId);
glDeleteFramebuffers(1, &fbId);
}
String Fbo::GetError()
{
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE:
return "Framebuffer complete";
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
return "Framebuffer incomplete attachment";
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
return "Framebuffer incomplete missing attachment";
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
return "Framebuffer incomplete draw buffer";
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
return "Framebuffer incomplete read buffer";
case GL_FRAMEBUFFER_UNSUPPORTED:
return "Framebuffer unsupported";
default:
return "Unknown error";
}
}
END_UPP_NAMESPACE

36
rainbow/CoreGl/Fbo.h Normal file
View file

@ -0,0 +1,36 @@
#ifndef _CoreGl_Fbo_h_
#define _CoreGl_Fbo_h_
#include <Core/Core.h>
#include <Draw/Draw.h>
#include "Gl.h"
NAMESPACE_UPP
struct Fbo : Moveable<Fbo>
{
GLuint texId;
GLuint fbId;
GLuint rbId;
GLenum status;
int width;
int height;
bool ready;
bool Create(int width, int height, bool resize = false);
void Resize(int width, int height);
void Bind();
void Unbind();
void Clear();
void BlitToScreen();
void BlitTo(const Fbo& fbo);
void Remove();
String GetError();
Fbo() : width(0), height(0), ready(false)
{}
};
END_UPP_NAMESPACE
#endif

40
rainbow/CoreGl/Gl.h Normal file
View file

@ -0,0 +1,40 @@
#ifndef _CoreGl_Gl_h_
#define _CoreGl_Gl_h_
#ifdef flagLINUXGL
#define Time XTime
#define Font XFont
#define Display XDisplay
#define Picture XPicture
#define Screen XScreen
#define Window XWindow
#define Complex XComplex
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#endif
#include <CoreGl/glew.h>
#ifdef flagWINGL
#include <CoreGl/wglew.h>
#endif
#include <GL/gl.h>
#include <GL/glu.h>
#ifdef flagLINUXGL
#include <GL/glx.h>
#endif
#ifdef flagLINUXGL
#undef Picture
#undef Time
#undef Font
#undef Display
#undef Screen
#undef Window
#undef Complex
#endif
#endif

91
rainbow/CoreGl/Resources.cpp
View file

@ -295,97 +295,6 @@ OpenGLFont& Resources::GetFont(const Font& font, bool preload)
tahomaNFontDef, (const byte**) tahomaNFontImg, tahomaNFontImg_length, tahomaNFontImg_count);
}
bool Fbo::Create(int width, int height, bool resize)
{
this->width = width;
this->height = height;
if(!resize)
{
glGenFramebuffers(1, &fbId);
glGenRenderbuffers(1, &rbId);
glGenTextures(1, &texId);
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbId);
glBindTexture(GL_TEXTURE_2D, texId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_FALSE);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_BGRA, GL_UNSIGNED_BYTE, 0);
glBindRenderbuffer(GL_RENDERBUFFER, rbId);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH24_STENCIL8, width, height);
glFramebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, fbId, 0);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rbId);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, rbId);
status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
ready = true;
return status == GL_FRAMEBUFFER_COMPLETE;
}
void Fbo::Resize(int width, int height)
{
if(ready)
Create(width, height, true);
}
void Fbo::Bind()
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbId);
}
void Fbo::Unbind()
{
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
void Fbo::Clear()
{
glClearColor(0.f, 0.f, 0.f, 1.f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
}
void Fbo::BlitToScreen()
{
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbId);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBlitFramebuffer(0, 0, width, height, 0, 0, width, height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
void Fbo::BlitTo(const Fbo& fbo)
{
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbId);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo.fbId);
glBlitFramebuffer(0, 0, width, height, 0, 0, fbo.width, fbo.height, GL_COLOR_BUFFER_BIT, GL_NEAREST);
}
String Fbo::GetError()
{
switch(status)
{
case GL_FRAMEBUFFER_COMPLETE:
return "Framebuffer complete";
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT:
return "Framebuffer incomplete attachment";
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:
return "Framebuffer incomplete missing attachment";
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER:
return "Framebuffer incomplete draw buffer";
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER:
return "Framebuffer incomplete read buffer";
case GL_FRAMEBUFFER_UNSUPPORTED:
return "Framebuffer unsupported";
default:
return "Unknown error";
}
}
int64 GetHighTickCount()
{
#ifdef PLATFORM_WIN32

209
rainbow/CoreGl/Shaders.cpp
View file

@ -1,7 +1,5 @@
#if defined(flagWINGL) || defined(flagLINUXGL)
#include <CtrlLib/CtrlLib.h>
#include "Shaders.h"
NAMESPACE_UPP
@ -13,7 +11,7 @@ void Shader::PrintShaderInfoLog(GLuint obj, const char* fileName)
glGetShaderiv(obj, GL_INFO_LOG_LENGTH, &infoLength);
if(infoLength > 1)
if(infoLength > 0)
{
char* info = new char[infoLength];
glGetShaderInfoLog(obj, infoLength, &charsWritten, info);
@ -34,7 +32,7 @@ void Shader::PrintProgramInfoLog(GLuint obj, const char* fileName)
glGetProgramiv(obj, GL_INFO_LOG_LENGTH, &infoLength);
if(infoLength > 1)
if(infoLength > 0)
{
char* info = new char[infoLength];
glGetShaderInfoLog(obj, infoLength, &charsWritten, info);
@ -85,49 +83,82 @@ bool Shader::IsProgramLinked(int program)
return result == GL_TRUE;
}
int Shader::CompileProgram(const char* vs, const char* fs)
int Shader::CompileProgram(const char* vs, const char* fs, const char* gs)
{
vertSrc = vs;
fragSrc = fs;
geomSrc = gs;
const GLchar* vertexShaderSrc = (const GLchar*) vertSrc;
const GLchar* fragmentShaderSrc = (const GLchar*) fragSrc;
const GLchar* geometryShaderSrc = (const GLchar*) geomSrc;
DeleteFile("shader_vertex.log");
DeleteFile("shader_fragment.log");
DeleteFile("shader_geometry.log");
DeleteFile("shader_link.log");
DeleteFile("shader_validation.log");
GLenum vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSrc, NULL);
glCompileShader(vertexShader);
GLenum vertexShader = 0;
GLenum fragmentShader = 0;
GLenum geometryShader = 0;
if(!IsProgramCompiled(vertexShader))
if(!vertSrc.IsEmpty())
{
PrintShaderInfoLog(vertexShader, "shader_vertex.log");
error = "Vertex shader compilation error:\n\n" + compileError;
glDeleteShader(vertexShader);
return -1;
vertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(vertexShader, 1, &vertexShaderSrc, NULL);
glCompileShader(vertexShader);
if(!IsProgramCompiled(vertexShader))
{
PrintShaderInfoLog(vertexShader, "shader_vertex.log");
error = "Vertex shader compilation error:\n\n" + compileError;
glDeleteShader(vertexShader);
return -1;
}
}
GLenum fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSrc, NULL);
glCompileShader(fragmentShader);
if(!IsProgramCompiled(fragmentShader))
if(!fragSrc.IsEmpty())
{
PrintShaderInfoLog(fragmentShader, "shader_fragment.log");
error = "Fragment shader compilation error:\n\n" + compileError;
glDeleteShader(fragmentShader);
return -1;
fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(fragmentShader, 1, &fragmentShaderSrc, NULL);
glCompileShader(fragmentShader);
if(!IsProgramCompiled(fragmentShader))
{
PrintShaderInfoLog(fragmentShader, "shader_fragment.log");
error = "Fragment shader compilation error:\n\n" + compileError;
glDeleteShader(fragmentShader);
return -1;
}
}
if(!geomSrc.IsEmpty())
{
geometryShader = glCreateShader(GL_GEOMETRY_SHADER);
glShaderSource(geometryShader, 1, &geometryShaderSrc, NULL);
glCompileShader(geometryShader);
if(!IsProgramCompiled(geometryShader))
{
PrintShaderInfoLog(geometryShader, "shader_geometry.log");
error = "Geometry shader compilation error:\n\n" + compileError;
glDeleteShader(geometryShader);
return -1;
}
}
program = glCreateProgram();
if(program > 0)
{
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
if(vertexShader > 0)
glAttachShader(program, vertexShader);
if(fragmentShader > 0)
glAttachShader(program, fragmentShader);
if(geometryShader > 0)
glAttachShader(program, geometryShader);
glLinkProgram(program);
if(!IsProgramLinked(program))
{
@ -143,9 +174,9 @@ int Shader::CompileProgram(const char* vs, const char* fs)
return program;
}
int Shader::CompileProgram(const byte* vs, const byte* fs)
int Shader::CompileProgram(const byte* vs, const byte* fs, const byte* gs)
{
return CompileProgram((const char*) vs, (const char*) fs);
return CompileProgram((const char*) vs, (const char*) fs, (const char*) gs);
}
int Shader::GetProgram()
@ -173,49 +204,64 @@ int Shader::GetUniformId(const char* var)
return uniforms[n];
}
void Shader::Set(const char* var, float v)
int Shader::GetAttributeId(const char* var)
{
int n = attributes.Find(var);
if(n < 0)
{
int id = glGetAttribLocation(program, var);
CheckGLError();
if(id >= 0)
attributes.Add(var, id);
return id;
}
else
return attributes[n];
}
void Shader::SetUniform(const char* var, float v)
{
int id = GetUniformId(var);
if(id >= 0)
glUniform1f(id, v);
}
void Shader::Set(const char* var, bool v)
void Shader::SetUniform(const char* var, bool v)
{
int id = GetUniformId(var);
if(id >= 0)
glUniform1i(id, int(v));
}
void Shader::Set(const char* var, int v)
void Shader::SetUniform(const char* var, int v)
{
int id = GetUniformId(var);
if(id >= 0)
glUniform1i(id, v);
}
void Shader::Set(const char* var, float v0, float v1)
void Shader::SetUniform(const char* var, float v0, float v1)
{
int id = GetUniformId(var);
if(id >= 0)
glUniform2f(id, v0, v1);
}
void Shader::Set(const char* var, float v0, float v1, float v2)
void Shader::SetUniform(const char* var, float v0, float v1, float v2)
{
int id = GetUniformId(var);
if(id >= 0)
glUniform3f(id, v0, v1, v2);
}
void Shader::Set(const char* var, float v0, float v1, float v2, float v3)
void Shader::SetUniform(const char* var, float v0, float v1, float v2, float v3)
{
int id = GetUniformId(var);
if(id >= 0)
glUniform4f(id, v0, v1, v2, v3);
}
void Shader::Set(const char* var, float* v, int size, int count)
void Shader::SetUniform(const char* var, float* v, int size, int count)
{
int id = GetUniformId(var);
if(id >= 0)
@ -225,7 +271,94 @@ void Shader::Set(const char* var, float* v, int size, int count)
else if(size == 3)
glUniform3fv(id, count, v);
else if(size == 4)
glUniform4fv(id, count, v);
glUniform4fv(id, count, v);
else if(size == 16)
glUniformMatrix4fv(id, count, GL_FALSE, v);
}
}
void Shader::SetMatrixUniform(const char* var, float* v, int size, int count)
{
int id = GetUniformId(var);
if(id >= 0)
{
if(size == 2)
glUniform2fv(id, count, v);
else if(size == 3)
glUniform3fv(id, count, v);
else if(size == 4)
glUniform4fv(id, count, v);
else if(size == 16)
glUniformMatrix4fv(id, count, GL_FALSE, v);
}
}
void Shader::EnableAttribute(const char* var, bool b)
{
int id = GetAttributeId(var);
if(id >= 0)
{
if(b)
glEnableVertexAttribArray(id);
else
glDisableVertexAttribArray(id);
}
}
void Shader::DisableAttribute(const char* var)
{
EnableAttribute(var, false);
}
void Shader::DisableAllAtrributes()
{
for(int i = 0; i < attributes.GetCount(); i++)
{
int id = attributes[i];
if(id >= 0)
glDisableVertexAttribArray(id);
}
}
void Shader::SetAttribute(const char* var, float v)
{
int id = GetAttributeId(var);
if(id >= 0)
glVertexAttrib1f(id, v);
}
void Shader::SetAttribute(const char* var, float v0, float v1)
{
int id = GetAttributeId(var);
if(id >= 0)
glVertexAttrib2f(id, v0, v1);
}
void Shader::SetAttribute(const char* var, float v0, float v1, float v2)
{
int id = GetAttributeId(var);
if(id >= 0)
glVertexAttrib3f(id, v0, v1, v2);
}
void Shader::SetAttribute(const char* var, float v0, float v1, float v2, float v3)
{
int id = GetAttributeId(var);
if(id >= 0)
glVertexAttrib4f(id, v0, v1, v2, v3);
}
void Shader::SetAttribute(const char* var, float* v, int size)
{
int id = GetAttributeId(var);
if(id >= 0)
{
if(size == 2)
glVertexAttrib2fv(id, v);
else if(size == 3)
glVertexAttrib3fv(id, v);
else if(size == 4)
glVertexAttrib4fv(id, v);
}
}
@ -240,6 +373,12 @@ void Shader::Stop()
glUseProgram(0);
}
void Shader::Release()
{
if(program >= 0)
glDeleteProgram(program);
}
Shader::Shader() : program(-1)
{}

44
rainbow/CoreGl/Shaders.h
View file

@ -1,6 +1,12 @@
#ifndef _CoreGl_Shaders_h_
#define _CoreGl_Shaders_h_
#include <Core/Core.h>
#include <Draw/Draw.h>
#include "Gl.h"
NAMESPACE_UPP
class Shader
{
private:
@ -9,7 +15,9 @@ private:
String compileError;
String fragSrc;
String vertSrc;
String geomSrc;
VectorMap<String, int> uniforms;
VectorMap<String, int> attributes;
void PrintShaderInfoLog(GLuint obj, const char* fileName);
void PrintProgramInfoLog(GLuint obj, const char* fileName);
@ -17,25 +25,41 @@ private:
bool CheckGLError();
bool IsProgramCompiled(int program);
bool IsProgramLinked(int program);
int GetUniformId(const char* var);
public:
int GetUniformId(const char* var);
int GetAttributeId(const char* var);
int CompileProgram(const char* vs, const char* fs);
int CompileProgram(const byte* vs, const byte* fs);
int CompileProgram(const char* vs, const char* fs, const char* gs = NULL);
int CompileProgram(const byte* vs, const byte* fs, const byte* gs = NULL);
int GetProgram();
void Set(const char* var, float v);
void Set(const char* var, bool v);
void Set(const char* var, int v);
void Set(const char* var, float v0, float v1);
void Set(const char* var, float v0, float v1, float v2);
void Set(const char* var, float v0, float v1, float v2, float v3);
void Set(const char* var, float* v, int size, int count);
void SetUniform(const char* var, float v);
void SetUniform(const char* var, bool v);
void SetUniform(const char* var, int v);
void SetUniform(const char* var, float v0, float v1);
void SetUniform(const char* var, float v0, float v1, float v2);
void SetUniform(const char* var, float v0, float v1, float v2, float v3);
void SetUniform(const char* var, float* v, int size, int count = 1);
void SetMatrixUniform(const char* var, float* v, int size, int count = 1);
void EnableAttribute(const char* var, bool b = true);
void DisableAttribute(const char* var);
void DisableAllAtrributes();
void SetAttribute(const char* var, float v);
void SetAttribute(const char* var, float v0, float v1);
void SetAttribute(const char* var, float v0, float v1, float v2);
void SetAttribute(const char* var, float v0, float v1, float v2, float v3);
void SetAttribute(const char* var, float* v, int size);
void Start();
void Stop();
String GetError();
void Release();
Shader();
};
END_UPP_NAMESPACE
#endif

20
rainbow/CoreGl/Wnd.cpp
View file

@ -18,6 +18,7 @@ float Ctrl::angle = 0.f;
float Ctrl::scale = 1.f;
float Ctrl::alpha = 255.f;
Rect Ctrl::screenRect;
bool Ctrl::screenReady = false;
Point Ctrl::glCursorPos = Null;
Image Ctrl::glCursorImage;
Rect Ctrl::glCaretRect;
@ -222,6 +223,7 @@ void Ctrl::DrawScreen()
if(hRC)
#endif
if(desktop && !painting) {
screenReady = true;
painting = true;
resources.BindStatic();
int64 t0 = GetHighTickCount();
@ -263,19 +265,19 @@ void Ctrl::DrawScreen()
float blurSizeHorz = 1.f / (float) screenFbo0.width;
float blurSizeVert = 1.f / (float) screenFbo0.height;
blurProg.Start();
blurProg.Set("blurSize", blurSizeHorz);
blurProg.Set("gaussian", gx, gy, gz);
blurProg.Set("blurMultiplyVec", 1, 0);
blurProg.Set("blurStrength", blur);
blurProg.Set("grayStrength", gray);
blurProg.SetUniform("blurSize", blurSizeHorz);
blurProg.SetUniform("gaussian", gx, gy, gz);
blurProg.SetUniform("blurMultiplyVec", 1, 0);
blurProg.SetUniform("blurStrength", blur);
blurProg.SetUniform("grayStrength", gray);
screenFbo1.Bind();
draw.DrawTextureOp(drawRect, screenFbo0.texId, screenFbo0.width, screenFbo0.height, drawRect);
screenFbo1.Unbind();
blurProg.Set("blurSize", blurSizeVert);
blurProg.Set("blurMultiplyVec", 0, 1);
blurProg.Set("blurStrength", blur);
blurProg.Set("grayStrength", gray);
blurProg.SetUniform("blurSize", blurSizeVert);
blurProg.SetUniform("blurMultiplyVec", 0, 1);
blurProg.SetUniform("blurStrength", blur);
blurProg.SetUniform("grayStrength", gray);
draw.ApplyTransforms();
draw.DrawTextureOp(drawRect, screenFbo1.texId, screenFbo1.width, screenFbo1.height, drawRect);
blurProg.Stop();