ES2GFXDriver::ES2GFXDriver(SDL_GLContext ctx, int winSizeX, int winSizeY)
: ctx(ctx),viewSizeX(winSizeX),viewSizeY(winSizeY)
{
GLuint blitTexVertShader = CompileShader(GL_VERTEX_SHADER, blitTexVertShaderSource);
GLuint blitTexFragShader = CompileShader(GL_FRAGMENT_SHADER, blitTexFragShaderSource);
this->blitTexProgramInfo.program = LinkProgram(blitTexVertShader, blitTexFragShader);
this->blitTexProgramInfo.texSamplerUniform = glGetUniformLocation(this->blitTexProgramInfo.program, "u_texSampler");
this->blitTexProgramInfo.paletteSamplerUniform = glGetUniformLocation(this->blitTexProgramInfo.program, "u_paletteSampler");
this->blitTexProgramInfo.scaleUniform = glGetUniformLocation(this->blitTexProgramInfo.program, "u_scale");
this->blitTexProgramInfo.texcoordAttrib = glGetAttribLocation(this->blitTexProgramInfo.program, "a_texcoord");
this->blitTexProgramInfo.positionAttrib = glGetAttribLocation(this->blitTexProgramInfo.program, "a_position");
GLuint blitColorVertShader = CompileShader(GL_VERTEX_SHADER, blitColorVertShaderSource);
GLuint blitColorFragShader = CompileShader(GL_FRAGMENT_SHADER, blitColorFragShaderSource);
this->blitColorProgramInfo.program = LinkProgram(blitColorVertShader, blitColorFragShader);
this->blitColorProgramInfo.colorUniform = glGetUniformLocation(this->blitColorProgramInfo.program, "u_color");
this->blitColorProgramInfo.positionAttrib = glGetAttribLocation(this->blitColorProgramInfo.program, "a_position");
}
void
OpenGL::InitShaders()
{
DeinitShaders();
solid_shader = CompileProgram(solid_vertex_shader, solid_fragment_shader);
solid_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
solid_shader->BindAttribLocation(Attribute::POSITION, "position");
solid_shader->BindAttribLocation(Attribute::COLOR, "color");
LinkProgram(*solid_shader);
solid_projection = solid_shader->GetUniformLocation("projection");
solid_modelview = solid_shader->GetUniformLocation("modelview");
solid_shader->Use();
glUniformMatrix4fv(solid_modelview, 1, GL_FALSE,
glm::value_ptr(glm::mat4()));
texture_shader = CompileProgram(texture_vertex_shader, texture_fragment_shader);
texture_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
texture_shader->BindAttribLocation(Attribute::POSITION, "position");
texture_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord");
LinkProgram(*texture_shader);
texture_projection = texture_shader->GetUniformLocation("projection");
texture_texture = texture_shader->GetUniformLocation("texture");
texture_shader->Use();
glUniform1i(texture_texture, 0);
invert_shader = CompileProgram(invert_vertex_shader, invert_fragment_shader);
invert_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
invert_shader->BindAttribLocation(Attribute::POSITION, "position");
invert_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord");
LinkProgram(*invert_shader);
invert_projection = invert_shader->GetUniformLocation("projection");
invert_texture = invert_shader->GetUniformLocation("texture");
invert_shader->Use();
glUniform1i(invert_texture, 0);
alpha_shader = CompileProgram(alpha_vertex_shader, alpha_fragment_shader);
alpha_shader->BindAttribLocation(Attribute::TRANSLATE, "translate");
alpha_shader->BindAttribLocation(Attribute::POSITION, "position");
alpha_shader->BindAttribLocation(Attribute::TEXCOORD, "texcoord");
alpha_shader->BindAttribLocation(Attribute::COLOR, "color");
LinkProgram(*alpha_shader);
alpha_projection = alpha_shader->GetUniformLocation("projection");
alpha_texture = alpha_shader->GetUniformLocation("texture");
alpha_shader->Use();
glUniform1i(alpha_texture, 0);
glVertexAttrib4f(Attribute::TRANSLATE, 0, 0, 0, 0);
}
// Cria programa de shader //
static void CreateShaderProgram()
{
// vertex shader //
GLuint v_id = glCreateShader(GL_VERTEX_SHADER);
if (v_id == 0)
Error("Could not create vertex shader object");
glShaderSource(v_id, 1, &vsource, 0);
CompileShader(v_id);
// fragment shader */
GLuint f_id = glCreateShader(GL_FRAGMENT_SHADER);
if (f_id == 0)
Error("Could not create fragment shader object");
glShaderSource(f_id, 1, &fsource, 0);
CompileShader(f_id);
// program */
p_id = glCreateProgram();
if (p_id == 0)
Error("Could not create program object");
glBindAttribLocation(p_id, 0, "myVertex");
glBindAttribLocation(p_id, 1, "color");
glAttachShader(p_id, v_id);
glAttachShader(p_id, f_id);
LinkProgram(p_id);
}
ShaderProgram::ShaderProgram(const char* vertexshader, const char* fragmentshader) :
_blend_sfactor(GL_ONE),
_blend_dfactor(GL_ZERO)
{
_program = glCreateProgram();
CHECK_ERROR_GL();
GLuint vertex_shader = CompileShader(GL_VERTEX_SHADER, vertexshader);
GLuint fragment_shader = CompileShader(GL_FRAGMENT_SHADER, fragmentshader);
glAttachShader(_program, vertex_shader);
CHECK_ERROR_GL();
glAttachShader(_program, fragment_shader);
CHECK_ERROR_GL();
if (!LinkProgram(_program)) {
if (_program) {
glDeleteProgram(_program);
CHECK_ERROR_GL();
_program = 0;
}
return;
}
ValidateProgram(_program);
glDetachShader(_program, vertex_shader);
CHECK_ERROR_GL();
glDetachShader(_program, fragment_shader);
CHECK_ERROR_GL();
glDeleteShader(vertex_shader);
CHECK_ERROR_GL();
glDeleteShader(fragment_shader);
CHECK_ERROR_GL();
}
bool GrGLShaderBuilder::finish() {
SkASSERT(0 == fOutput.fProgramID);
GL_CALL_RET(fOutput.fProgramID, CreateProgram());
if (!fOutput.fProgramID) {
return false;
}
SkTDArray<GrGLuint> shadersToDelete;
if (!this->compileAndAttachShaders(fOutput.fProgramID, &shadersToDelete)) {
GL_CALL(DeleteProgram(fOutput.fProgramID));
return false;
}
this->bindProgramLocations(fOutput.fProgramID);
if (fUniformManager->isUsingBindUniform()) {
fUniformManager->getUniformLocations(fOutput.fProgramID, fUniforms);
}
GL_CALL(LinkProgram(fOutput.fProgramID));
// Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
bool checkLinked = !fGpu->ctxInfo().isChromium();
#ifdef SK_DEBUG
checkLinked = true;
#endif
if (checkLinked) {
GrGLint linked = GR_GL_INIT_ZERO;
GL_CALL(GetProgramiv(fOutput.fProgramID, GR_GL_LINK_STATUS, &linked));
if (!linked) {
GrGLint infoLen = GR_GL_INIT_ZERO;
GL_CALL(GetProgramiv(fOutput.fProgramID, GR_GL_INFO_LOG_LENGTH, &infoLen));
SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
if (infoLen > 0) {
// retrieve length even though we don't need it to workaround
// bug in chrome cmd buffer param validation.
GrGLsizei length = GR_GL_INIT_ZERO;
GL_CALL(GetProgramInfoLog(fOutput.fProgramID,
infoLen+1,
&length,
(char*)log.get()));
GrPrintf((char*)log.get());
}
SkDEBUGFAIL("Error linking program");
GL_CALL(DeleteProgram(fOutput.fProgramID));
fOutput.fProgramID = 0;
return false;
}
}
if (!fUniformManager->isUsingBindUniform()) {
fUniformManager->getUniformLocations(fOutput.fProgramID, fUniforms);
}
for (int i = 0; i < shadersToDelete.count(); ++i) {
GL_CALL(DeleteShader(shadersToDelete[i]));
}
return true;
}
GLuint LinkShaders3(GLuint vertShader, GLuint geomShader, GLuint fragShader) {
GLuint program = CreateProgram();
assert(vertShader || fragShader);
if (vertShader) AttachShader(program, vertShader);
if (geomShader) AttachShader(program, geomShader);
if (fragShader) AttachShader(program, fragShader);
LinkProgram(program);
/* check link */
{
GLint stat;
GetProgramiv(program, GL_LINK_STATUS, &stat);
if (!stat) {
GLchar log[1000];
GLsizei len;
GetProgramInfoLog(program, 1000, &len, log);
wxLogError(wxT("BR24radar_pi: problem linking program: %s"), log);
return 0;
}
}
return program;
}
void LoadShaders()
{
const char* VertexShaderText =
"#version 140\n"
"in vec3 aPosition;\n"
"in vec2 aTexCoord;\n"
"out vec2 vTexCoord;\n"
"void main(void) {\n"
" gl_Position = vec4(aPosition.xyz, 1.0f);\n"
" vTexCoord = aTexCoord;\n"
"}";
mVS = CompileShader(GL_VERTEX_SHADER, VertexShaderText);
const char* FragmentShaderText =
"#version 140\n"
"uniform sampler2D uColorMap;\n"
"in vec2 vTexCoord;\n"
"out vec4 oColor;\n"
"void main(void) {\n"
" oColor = texture2D( uColorMap, vTexCoord.xy );\n"
"}";
mFS = CompileShader(GL_FRAGMENT_SHADER, FragmentShaderText);
mProg = LinkProgram(mVS, mFS, "oColor");
mPosLoc = glGetAttribLocation(mProg, "aPosition");
mTexCoordLoc = glGetAttribLocation(mProg, "aTexCoord");
mSamplerLoc = glGetUniformLocation(mProg, "uColorMap");
}
GLuint GlUtil::CreateProgram(const char* vertex_source, const char* fragment_source)
{
LOGI("%s\n", vertex_source);
GLuint vertexShader = 0;
GLuint fragment_shader = 0;
if (vertex_source)
{
vertexShader = LoadShader(GL_VERTEX_SHADER, vertex_source);
if (!vertexShader) {
return 0;
}
}
if (fragment_source)
{
fragment_shader = LoadShader(GL_FRAGMENT_SHADER, fragment_source);
if (!fragment_shader) {
return 0;
}
}
GLuint program = glCreateProgram();
if (program) {
glAttachShader(program, vertexShader);
CheckGlError("glAttachShader");
if (fragment_shader)
{
glAttachShader(program, fragment_shader);
CheckGlError("glAttachShader");
}
LinkProgram(program);
}
return program;
}
Graphics::ShaderProgram* ShaderManager::GetNewShaderProgram(const istring &filename)
{
auto strings = Utility::File::ParseToStrings(filename);
auto shader = new Graphics::ShaderProgram();
shader->CreateProgram();
for (auto str : strings)
{
auto type = str[0];
auto sfile = str.substr(2);
switch (type)
{
case 'F':
shader->CompileShader(sfile.c_str(), GL_FRAGMENT_SHADER, false);
break;
case 'V':
shader->CompileShader(sfile.c_str(), GL_VERTEX_SHADER, false);
break;
default:
std::cout << "Invalid shader Type=[" << type << "] specified in FileName=[" << filename << "]";
return nullptr;
}
}
shader->LinkProgram();
shader->SetShaderName(filename);
return shader;
}
Shader::Shader( const std::string &vertFilename, const std::string &fragFilename )
{
AddVertexShader( vertFilename );
AddFragmentShader( fragFilename );
LinkProgram();
}
//----------------------------------------------------------
// Constructor
//----------------------------------------------------------
Program::Program(const std::string& p_strVS, const std::string& p_strPS) : m_uiProgram(0)
{
GLuint uiVS, uiPS;
// 1. Create and compile vertex shader.
if( !CompileShader(&uiVS, GL_VERTEX_SHADER, p_strVS))
{
printf("Failed to compile vertex shader\n");
return;
}
// 2. Create and compile fragment shader.
if( !CompileShader(&uiPS, GL_FRAGMENT_SHADER, p_strPS))
{
printf("Failed to compile pixel shader\n");
glDeleteShader(uiVS);
return;
}
// 3. Create shader program that we'll (hopefully) eventually return
m_uiProgram = glCreateProgram();
// 4. Attach vertex shader and pixel shader to program.
glAttachShader(m_uiProgram, uiVS);
glAttachShader(m_uiProgram, uiPS);
// 5. Bind attribute locations. This needs to be done prior to linking.
for( int i = 0; i < wolf::AT_NUM_ATTRIBS; i++ )
{
glBindAttribLocation(m_uiProgram, i, gs_aAttributeMap[i]);
}
// 6. Link program.
if( !LinkProgram() )
{
printf("Failed to link program: %d\n", m_uiProgram);
if( uiVS )
{
glDeleteShader(uiVS);
}
if( uiPS )
{
glDeleteShader(uiPS);
}
if( m_uiProgram )
{
glDeleteProgram(m_uiProgram);
m_uiProgram = 0;
}
return;
}
// Release vertex and fragment shaders.
if( uiVS )
glDeleteShader(uiVS);
if( uiPS )
glDeleteShader(uiPS);
}
void GSShaderOGL::BindProgram(GLuint vs, GLuint gs, GLuint ps)
{
GLuint p = LinkProgram(vs, gs, ps);
if (GLState::program != p) {
GLState::program = p;
glUseProgram(p);
}
}
int GLSL::LinkProgramViaCode(const char *vertexShaderCode,
const char *fragmentShaderCode,
const char *geometryShaderCode)
{
int vshader = CompileShaderViaCode(vertexShaderCode, GL_VERTEX_SHADER);
int fshader = CompileShaderViaCode(fragmentShaderCode, GL_FRAGMENT_SHADER);
int gshader = -1;
if (geometryShaderCode)
gshader = CompileShaderViaCode(geometryShaderCode, GL_GEOMETRY_SHADER);
return LinkProgram(vshader, fshader, gshader);
}
void kzsGLSL::initShaderProgram( const char* vertFile )
{
vertShader = glCreateShader( GL_VERTEX_SHADER );
if ( readShaderSource( vertShader, vertFile ) ) exit( 1 );
CompileShader( vertShader, "Compile error in vertex shader.\n\n" );
CreateProgramObject( FRAG_NONE );
LinkProgram();
}
GLvoid CGLES3Context::ApiProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
{
CProgramObj *p = FindProgram(program);
if (p->m_pVertex && p->m_pFragment)
{
LinkProgram(p);
}
CTX_ANALYZER_FUNC4(ProgramBinary, GLOutput, GL_OUT_BUF_SIZE, program, binaryFormat, binary, length);
}
void glsl_program :: render(GemState *state)
{
if(m_wantLink){
m_wantLink=0;
LinkProgram();
}
if(GLEW_VERSION_2_0)
renderGL2();
else
renderARB();
}
GLuint GLCanvas::LoadCompileLinkShaders() {
std::cout << "load, compile, & link shaders" << std::endl;
std::string v_string = ReadFile("shadows.vs");
char *v = (char*) v_string.c_str();
std::string f_string = ReadFile("shadows.fs");
char *f = (char*) f_string.c_str();
CompileProgram(v, &vertex_shader);
CompileProgram(f, &fragment_shader);
LinkProgram(program);
HandleGLError("Failed to compile or link shaders");
return glGetUniformLocationARB(program,"ShadowMap");
}
GrGLProgram* GrGLProgramBuilder::finalize() {
// verify we can get a program id
GrGLuint programID;
GL_CALL_RET(programID, CreateProgram());
if (0 == programID) {
this->cleanupFragmentProcessors();
return nullptr;
}
// compile shaders and bind attributes / uniforms
SkTDArray<GrGLuint> shadersToDelete;
fVS.finalize(GrGLSLUniformHandler::kVertex_Visibility);
if (!this->compileAndAttachShaders(fVS, programID, GR_GL_VERTEX_SHADER, &shadersToDelete)) {
this->cleanupProgram(programID, shadersToDelete);
return nullptr;
}
// NVPR actually requires a vertex shader to compile
bool useNvpr = primitiveProcessor().isPathRendering();
if (!useNvpr) {
const GrPrimitiveProcessor& primProc = this->primitiveProcessor();
int vaCount = primProc.numAttribs();
for (int i = 0; i < vaCount; i++) {
GL_CALL(BindAttribLocation(programID, i, primProc.getAttrib(i).fName));
}
}
fFS.finalize(GrGLSLUniformHandler::kFragment_Visibility);
if (!this->compileAndAttachShaders(fFS, programID, GR_GL_FRAGMENT_SHADER, &shadersToDelete)) {
this->cleanupProgram(programID, shadersToDelete);
return nullptr;
}
this->bindProgramResourceLocations(programID);
GL_CALL(LinkProgram(programID));
// Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
bool checkLinked = kChromium_GrGLDriver != fGpu->ctxInfo().driver();
#ifdef SK_DEBUG
checkLinked = true;
#endif
if (checkLinked) {
checkLinkStatus(programID);
}
this->resolveProgramResourceLocations(programID);
this->cleanupShaders(shadersToDelete);
return this->createProgram(programID);
}
GrGLProgram* GrGLProgramBuilder::finalize() {
// verify we can get a program id
GrGLuint programID;
GL_CALL_RET(programID, CreateProgram());
if (0 == programID) {
return NULL;
}
// compile shaders and bind attributes / uniforms
SkTDArray<GrGLuint> shadersToDelete;
if (!fVS.compileAndAttachShaders(programID, &shadersToDelete)) {
this->cleanupProgram(programID, shadersToDelete);
return NULL;
}
// NVPR actually requires a vertex shader to compile
bool useNvpr = primitiveProcessor().isPathRendering();
if (!useNvpr) {
fVS.bindVertexAttributes(programID);
}
if (!fFS.compileAndAttachShaders(programID, &shadersToDelete)) {
this->cleanupProgram(programID, shadersToDelete);
return NULL;
}
bool usingBindUniform = fGpu->glInterface()->fFunctions.fBindUniformLocation != NULL;
if (usingBindUniform) {
this->bindUniformLocations(programID);
}
fFS.bindFragmentShaderLocations(programID);
GL_CALL(LinkProgram(programID));
// Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
bool checkLinked = !fGpu->ctxInfo().isChromium();
#ifdef SK_DEBUG
checkLinked = true;
#endif
if (checkLinked) {
checkLinkStatus(programID);
}
if (!usingBindUniform) {
this->resolveUniformLocations(programID);
}
this->cleanupShaders(shadersToDelete);
return this->createProgram(programID);
}
bool GrGLShaderBuilder::finish(GrGLuint* outProgramId) {
SK_TRACE_EVENT0("GrGLShaderBuilder::finish");
GrGLuint programId = 0;
GL_CALL_RET(programId, CreateProgram());
if (!programId) {
return false;
}
if (!this->compileAndAttachShaders(programId)) {
GL_CALL(DeleteProgram(programId));
return false;
}
this->bindProgramLocations(programId);
GL_CALL(LinkProgram(programId));
// Calling GetProgramiv is expensive in Chromium. Assume success in release builds.
bool checkLinked = !fGpu->ctxInfo().isChromium();
#ifdef SK_DEBUG
checkLinked = true;
#endif
if (checkLinked) {
GrGLint linked = GR_GL_INIT_ZERO;
GL_CALL(GetProgramiv(programId, GR_GL_LINK_STATUS, &linked));
if (!linked) {
GrGLint infoLen = GR_GL_INIT_ZERO;
GL_CALL(GetProgramiv(programId, GR_GL_INFO_LOG_LENGTH, &infoLen));
SkAutoMalloc log(sizeof(char)*(infoLen+1)); // outside if for debugger
if (infoLen > 0) {
// retrieve length even though we don't need it to workaround
// bug in chrome cmd buffer param validation.
GrGLsizei length = GR_GL_INIT_ZERO;
GL_CALL(GetProgramInfoLog(programId,
infoLen+1,
&length,
(char*)log.get()));
GrPrintf((char*)log.get());
}
SkDEBUGFAIL("Error linking program");
GL_CALL(DeleteProgram(programId));
return false;
}
}
fUniformManager.getUniformLocations(programId, fUniforms);
*outProgramId = programId;
return true;
}
bool InnterShader::Init() {
if(!ShaderBasic::Init()) {
return false;
}
if(!AddShader(GL_VERTEX_SHADER, NULL, vertexShaderSource)) {
return false;
}
if(!AddShader(GL_FRAGMENT_SHADER, NULL, fragmentShaderSource)) {
return false;
}
if(!LinkProgram()) {
return false;
}
return true;
}
ShaderObject::ShaderObject( std::string VertexShaderFileName, std::string PixelShaderFileName )
{
Handle = glCreateProgramObjectARB();
Compiled = false;
ShaderCode VertexShader;
ShaderCode PixelShader;
VertexShader.CreateFromFile( VertexShaderFileName, GL_VERTEX_SHADER_ARB );
PixelShader.CreateFromFile( PixelShaderFileName, GL_FRAGMENT_SHADER_ARB );
AttachShader( VertexShader );
AttachShader( PixelShader );
LinkProgram();
}
void Program::Init(const VertexShader &vs, const FragmentShader &fs, const char *name)
{
Destroy();
mID = glCreateProgram();
Attach(vs);
Attach(fs);
LinkProgram(name);
Detach(vs);
Detach(fs);
CacheUniforms();
}
tPointShadowBlurShader::tPointShadowBlurShader(void)
{
InitShader(resources_get("point_shadow_blur_shader.vert"), resources_get("point_shadow_blur_shader.frag"), "Point Shadow Blur Shader");
glBindAttribLocation(program, vertex_attribute, "vertex_attr");
LinkProgram();
tex_uniform = GetUniformLocation("tex_uni");
blur_dir_uniform = GetUniformLocation("blur_dir_uni");
Bind();
glUniform1i(tex_uniform, 0);
}
void kzsGLSL::initShaderProgram( const char* vertFile, const char* fragFile )
{
vertShader = glCreateShader( GL_VERTEX_SHADER );
fragShader = glCreateShader( GL_FRAGMENT_SHADER );
if ( readShaderSource( vertShader, vertFile ) ) exit( 1 );
if ( readShaderSource( fragShader, fragFile ) ) exit( 1 );
CompileShader( vertShader, "Compile error in vertex shader.\n\n" );
CompileShader( fragShader, "Compile error in fragment shader.\n\n" );
CreateProgramObject( FRAG_EXIST );
LinkProgram();
}
tPointShadowShader::tPointShadowShader(void)
{
InitShader(resources_get("point_shadow_shader.vert"), resources_get("point_shadow_shader.frag"), "Point Shadow Shader");
glBindAttribLocation(program, tFaceShader::vertex_attribute, "vertex_attr");
glBindAttribLocation(program, tFaceShader::uvcoord_attribute, "uv_attr");
LinkProgram();
modelview_projection_matrix_uniform = GetUniformLocation("modelview_projection_matrix_uni");
light_pos_uniform = GetUniformLocation("light_pos_uni");
light_dist_uniform = GetUniformLocation("light_dist_uni");
transformation_uniform = GetUniformLocation("transformation_uni");
diffuse_tex_enabled_uniform = GetUniformLocation("diffuse_tex_enabled_uni");
diffuse_tex_uniform = GetUniformLocation("diffuse_tex_uni");
Bind();
glUniform1i(diffuse_tex_uniform, 0);
}
/*
=============
OpenGLProgram::InitializeProgram
OpenGLProgram Initialization.
=============
*/
bool OpenGLProgram::InitializeProgram( const char* name, const std::vector<Shader*>& shaderList, const char* outVariable, ProgramFeatures::Value features ) {
m_programID = glCreateProgram();
SetProgramName( name );
for( std::vector<Shader*>::const_iterator iter = shaderList.begin(); iter != shaderList.end(); ++iter ) {
if( AttachShader( ( *iter ) ) == 0 ) {
char buff[256];
sprintf_s( buff, "Failed to compile %s program", name );
Log::GetInstance()->WriteToLog( "OpenGLProgram", buff );
return false;
}
}
SetOutVariable( outVariable );
LinkProgram();
SetFeatures( features );
return m_programID > 0;
}
/*
================
Shader Private
================
*/
bool Shader::LoadShader(string fragfile, string vertfile)
{
_frag = glCreateShader(GL_FRAGMENT_SHADER);
_vert = glCreateShader(GL_VERTEX_SHADER);
if (!_frag || !_vert)
return false;
if (!CompileShader(_frag, fragfile) || !CompileShader(_vert, vertfile))
return false;
_prog = glCreateProgram();
if (!_prog)
return false;
glAttachShader(_prog, _vert);
glAttachShader(_prog, _frag);
if (!LinkProgram())
return false;
return true;
}
int main( int argc , char* args[] )
{
/* The window */
SDL_Window* window = NULL;
/* The window surface */
SDL_Surface* screen = NULL;
/* The event structure */
SDL_Event event;
/* The game loop flag */
_Bool running = true;
if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
{
printf( "SDL2 could not initialize! SDL2_Error: %s\n", SDL_GetError() );
SDL_Quit();
return 1;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
window = SDL_CreateWindow(
WINDOW_TITLE,
SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED,
WINDOW_WIDTH,
WINDOW_HEIGHT,
SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL);
if (window == NULL) {
printf("unable to create window: %s\n", SDL_GetError());
SDL_Quit();
return 1;
}
SDL_GLContext maincontext; /* Our opengl context handle */
maincontext = SDL_GL_CreateContext(window);
SDL_GL_SetSwapInterval(1);
GLint level5Pixels[] = { 0xFF00FFFF, 0xFF00FF00, 0xFFFF0000, 0xFF000000 };
GLint level6Pixels[] = { 0xFFFFFFFF };
GLuint texture = 0;
glGenTextures(1, &texture);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_BASE_LEVEL, 5);
glTexImage2D(GL_TEXTURE_2D,
5,
GL_RGBA,
2, 2,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
level5Pixels);
glTexImage2D(GL_TEXTURE_2D,
6,
GL_RGBA,
1, 1,
0,
GL_RGBA,
GL_UNSIGNED_BYTE,
level6Pixels);
const GLchar* vshadercode = "#version 330 core\n"\
"layout(location = 0) in vec4 a_position\n;"\
"layout(location = 1) in vec2 a_texcoord\n;"\
"out vec2 v_texcoord\n;"\
"void main(void)\n"\
"{\n"\
" gl_Position = a_position;\n"\
" v_texcoord = a_texcoord;\n"\
"}";
const GLchar* fshadercode = "#version 330 core\n"\
"in vec2 v_texcoord;\n"\
"uniform sampler2D sTexture;\n"\
"out vec4 o_color;\n"\
"void main(){\n"\
" vec2 tc = v_texcoord.xy*0.5 + 0.5;\n"\
" o_color = texture( sTexture, tc );\n"\
"}";
GLuint vshader = glCreateShader(GL_VERTEX_SHADER);
GLuint fshader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(vshader, 1, &vshadercode, NULL);
glShaderSource(fshader, 1, &fshadercode, NULL);
CompileShader(vshader, "Vertex");
CompileShader(fshader, "Fragment");
GLuint program = glCreateProgram();
glAttachShader(program, vshader);
glAttachShader(program, fshader);
LinkProgram(program, "");
glUseProgram(program);
GLuint texLoc = glGetUniformLocation(program, "sTexture");
GLuint matViewProjLoc = glGetUniformLocation(program, "u_matViewProjection");
GLuint posLoc = 0;
GLuint texcoordLoc = 1;
glViewport(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
GLuint vao = 0;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
GLuint quadVB = 0;
glGenBuffers(1, &quadVB);
glBindBuffer(GL_ARRAY_BUFFER, quadVB);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 16, 0);
glEnableVertexAttribArray(1);
glBindVertexArray(vao);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_ALWAYS);
GLuint renderbuffers[2];
glGenRenderbuffers(2, renderbuffers);
int num_samples = 1;
if (argc > 1)
num_samples = atoi(args[1]);
printf("Using %u multisample(s)\n", num_samples);
if (num_samples > 1)
{
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[0]);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_RGBA, WINDOW_WIDTH, WINDOW_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[1]);
glRenderbufferStorageMultisample(GL_RENDERBUFFER, num_samples, GL_DEPTH_STENCIL, WINDOW_WIDTH, WINDOW_HEIGHT);
}
else
{
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[0]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_RGBA, WINDOW_WIDTH, WINDOW_HEIGHT);
glBindRenderbuffer(GL_RENDERBUFFER, renderbuffers[1]);
glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_STENCIL, WINDOW_WIDTH, WINDOW_HEIGHT);
}
GLuint fbo;
glGenFramebuffers(1, &fbo);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, renderbuffers[0]);
glFramebufferRenderbuffer(GL_DRAW_FRAMEBUFFER, GL_DEPTH_STENCIL_ATTACHMENT, GL_RENDERBUFFER, renderbuffers[1]);
GLenum bufs[1];
glDrawBuffers(1, bufs);
GLenum status = glCheckFramebufferStatus(GL_DRAW_FRAMEBUFFER);
if (status != GL_FRAMEBUFFER_COMPLETE)
{
fprintf(stderr, "Failed creating FBO!\n");
exit(EXIT_FAILURE);
}
float f = 0.0f;
uint s = 0;
while( running )
{
while( SDL_PollEvent( &event ) != 0 )
{
if( event.type == SDL_QUIT )
{
running = false;
}
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
glBindFramebuffer(GL_READ_FRAMEBUFFER, 0);
glReadBuffer(GL_BACK);
glClearColor( 1.0, 0.0, 0.0, 1.0 );
glClearDepth(f);
glClearStencil(s & 0xFF);
f += .125f;
if (f > 1.0f)
f = 0;
s += 1;
glClear ( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT );
glEnable(GL_STENCIL_TEST);
glStencilOp(GL_REPLACE, GL_REPLACE, GL_REPLACE);
uint i;
for (i = 0; i < 512; i++)
{
glStencilFunc(GL_ALWAYS, i & 0xFF, 0xFF);
float nx = ((float)(i) / WINDOW_WIDTH) * 2.0f - 1.0f;
float px = ((float)(i + 1) / WINDOW_WIDTH) * 2.0f - 1.0f;
const GLfloat quadVerts[] = {
nx, 0.8f, 0.33f, 1.0f,
px, 0.8f, 0.33f, 1.0f,
nx, -0.8f, 0.33f, 1.0f,
px, -0.8f, 0.33f, 1.0f,
};
glBufferData(GL_ARRAY_BUFFER, sizeof(quadVerts), quadVerts, GL_STATIC_DRAW);
glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, fbo);
glReadBuffer(GL_COLOR_ATTACHMENT0);
glBlitFramebuffer(0,
0,
WINDOW_WIDTH,
WINDOW_HEIGHT,
0,
0,
WINDOW_WIDTH,
WINDOW_HEIGHT,
GL_COLOR_BUFFER_BIT,
GL_LINEAR);
SDL_GL_SwapWindow(window);
}
glDeleteRenderbuffers(2, renderbuffers);
glDeleteProgram(program);
glDeleteShader(vshader);
glDeleteShader(fshader);
glDeleteTextures(1, &texture);
glDeleteBuffers(1, &quadVB);
glDeleteVertexArrays(1, &vao);
SDL_GL_DeleteContext(maincontext);
SDL_DestroyWindow( window );
SDL_Quit();
return 0;
}
bool GLShader::setup(const char *vp, const char *fp, const char *fp2)
{
int err;
if ( ! HasGLSL())
{
Logger::log (LOG_ERROR,"%s doesn't support GLSL\n", glGetString(GL_RENDERER));
return false;
}
// printf("compiling vertex shader..\n");
err = CompileProgram(GL_VERTEX_SHADER_ARB, (GLcharARB*) vp, &vertShader);
if (0 != err)
{
Logger::log (LOG_ERROR,"----Vertex Shader could not compile\n");
Logger::log(LOG_DEBUG," VERTEX:\n\n%s\n\n ",vp);
Logger::log(LOG_DEBUG,"FRAGMENT: \n\n%s\n\n",fp);
return false;
}
// printf("compiling fragment shader..\n");
err = CompileProgram(GL_FRAGMENT_SHADER_ARB, (GLcharARB*)fp, &fragShader);
if (0 != err)
{
Logger::log (LOG_ERROR,"----Fragment Shader could not compile\n");
Logger::log(LOG_DEBUG,"VERTEX: \n\n%s\n\n ",vp);
Logger::log(LOG_DEBUG,"FRAGMENT: \n\n%s\n\n",fp);
return false;
}
if (fp2) if (strlen(fp2))
{
// printf("compiling fragment shader 2..\n");
err = CompileProgram(GL_FRAGMENT_SHADER_ARB, (GLcharARB*)fp2, &fragShader2);
if (0 != err)
{
Logger::log (LOG_ERROR,"Fragment Shader 2 could not compile\n");
return false;
}
}
program = glCreateProgramObjectARB();
glAttachObjectARB(program,fragShader);
glAttachObjectARB(program,vertShader);
if (fp2) if (strlen(fp2)) glAttachObjectARB(program,fragShader2);
//printf("Linking..\n");
err = LinkProgram(program);
if (GL_NO_ERROR != err)
{
return false;
}
//printf("ok\n\n");
loaded = true;
return true;
}
