static void load_test_file (const char *filename)
{
FILE *f;
GLint size;
char *code;
GLint i;
f = fopen (filename, "r");
if (f == NULL)
return;
fseek (f, 0, SEEK_END);
size = ftell (f);
fseek (f, 0, SEEK_SET);
code = (char *) (malloc (size));
if (code == NULL) {
fclose (f);
return;
}
size = fread (code, 1, size, f);
fclose (f);
glShaderSourceARB (vert, 1, (const GLcharARB **) (&code), &size);
glCompileShaderARB (vert);
if (!CheckObjectStatus (vert))
exit (0);
for (i = 0; i < sizeof (attribs) / sizeof (*attribs); i++)
if (attribs[i].dispatch == A && attribs[i].bind != -1)
glBindAttribLocationARB (prog, attribs[i].bind, attribs[i].name);
}
void BL_Shader::BindAttribute(const char *attr, int loc)
{
if (GLEW_ARB_fragment_shader &&
GLEW_ARB_vertex_shader &&
GLEW_ARB_shader_objects )
{
glBindAttribLocationARB(mShader, loc, attr);
}
}
void Shader::bindAttribute(int location, const std::string& name) {
if (m_shaderProgram) {
ensureGlContext();
GLint n;
glGetIntegerv(GL_MAX_VERTEX_ATTRIBS, &n);
if (location < n) {
glCheck(glBindAttribLocationARB(m_shaderProgram,location,name.c_str()));
m_currentAttrib = getVertexAttribLocation(name);
} else {
err() << "Invalid attribute location " << location << " in vertex." << std::endl;
}
}
}
bool ShaderProgramGl::link(string &messages){
assertGl();
VertexShaderGl *vertexShaderGl= static_cast<VertexShaderGl*>(vertexShader);
FragmentShaderGl *fragmentShaderGl= static_cast<FragmentShaderGl*>(fragmentShader);
const ShaderSource *vss= vertexShaderGl->getSource();
const ShaderSource *fss= fragmentShaderGl->getSource();
messages= "Linking program: " + vss->getPathInfo() + ", " + fss->getPathInfo() + "\n";
//attach
glAttachObjectARB(handle, vertexShaderGl->getHandle());
glAttachObjectARB(handle, fragmentShaderGl->getHandle());
assertGl();
//bind attributes
for(int i=0; i<attributes.size(); ++i){
//int a= attributes[i].second;
//string s= attributes[i].first;
glBindAttribLocationARB(handle, attributes[i].second, attributes[i].first.c_str());
}
assertGl();
//link
glLinkProgramARB(handle);
glValidateProgramARB(handle);
assertGl();
//log
GLint logLength= 0;
glGetObjectParameterivARB(handle, GL_OBJECT_INFO_LOG_LENGTH_ARB, &logLength);
char *buffer= new char[logLength+1];
glGetInfoLogARB(handle, logLength+1, NULL, buffer);
messages+= buffer;
delete [] buffer;
assertGl();
//status
GLint status= false;
glGetObjectParameterivARB(handle, GL_OBJECT_LINK_STATUS_ARB, &status);
assertGl();
return status!=0;
}
struct glpal_ctx *pal_init_glsl(GLboolean float_packed_pixels)
{CHECK_GL_ERR;
printf("Compiling pallet shader:\n");
GLint prog = 0;
if(!float_packed_pixels)
prog = compile_program(vtx_shader, pal_frag_shader);
else
prog = compile_program(vtx_shader, pal_frag_mix);
if(!prog) return NULL;
glUseProgramObjectARB(prog);
glUniform1iARB(glGetUniformLocationARB(prog, "src"), 0);
glUniform1iARB(glGetUniformLocationARB(prog, "pal"), 1);
glBindAttribLocationARB(prog, 0, "vertex");
glUseProgramObjectARB(0);
printf("Pallet shader compiled\n");
struct priv_ctx *priv = malloc(sizeof(*priv));
priv->pubctx.render = render;
priv->pubctx.step = pal_step;
priv->pubctx.start_switch = start_switch;
priv->pubctx.changing = changing;
priv->pal = pal_ctx_new(0);
priv->prog = prog;
priv->cnt = 0;
glGenTextures(2, &priv->tex);
glBindTexture(GL_TEXTURE_1D, priv->tex[0]);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_BGRA, GL_UNSIGNED_BYTE, pal_ctx_get_active(priv->pal));
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_1D, 0);
glBindTexture(GL_TEXTURE_1D, priv->tex[1]);
glTexImage1D(GL_TEXTURE_1D, 0, GL_RGBA, 256, 0, GL_BGRA, GL_UNSIGNED_BYTE, pal_ctx_get_active(priv->pal));
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_1D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glBindTexture(GL_TEXTURE_1D, 0);
CHECK_GL_ERR;
return (struct glpal_ctx *)priv;
}
GLuint
ParticleRenderer::_compileProgram(const char *vsource, const char *fsource)
{
// create empty shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
// link shader source code
glShaderSource(vertexShader, 1, &vsource, 0);
glShaderSource(fragmentShader, 1, &fsource, 0);
// compile the source code
glCompileShader(vertexShader);
glCompileShader(fragmentShader);
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, fragmentShader);
glBindAttribLocationARB(program, 1, "pointRadius");
glLinkProgram(program);
// check if program linked
GLint success = 0;
glGetProgramiv(program, GL_LINK_STATUS, &success); // get linked status of program and store it in success
if (!success)
{
char temp[256];
glGetProgramInfoLog(program, 256, 0, temp);
printf("Failed to link program:\n%s\n", temp);
glDeleteProgram(program);
program = 0;
}
return program;
}
/*----------------------------------------------------------------------------*/
void link_shaders()
{
program = glCreateProgram();
glBindAttribLocationARB(program, 6, "tangent");//after prog is created
if(vert_shader > 0)
{
assert(vert_shader > 0);
glAttachShader(program, vert_shader);
}
if(frag_shader > 0)
{
assert(frag_shader > 0);
glAttachShader(program, frag_shader);
}
glLinkProgram(program);
glUseProgram(program);
//this must come after gl_use_prog
//check for return value !=-1
//this must run on each reload
//true for all uniforms
GLint spotlight = glGetUniformLocation(program, "spotSamp");
glUniform1i(spotlight, 4);
GLint shine = glGetUniformLocation(program, "shiny");
glUniform1i(shine, 3);
GLint spec = glGetUniformLocation(program, "specular");
glUniform1i(spec, 2);
GLint norm = glGetUniformLocation(program, "normal");
glUniform1i(norm, 1);
GLint diff = glGetUniformLocation(program, "diffSamp");
glUniform1i(diff, 0);
}
void InitScene (void)
{
GLint params[1];
const char *tab[2];
/*
* GL should silently ignore calls that delete object 0.
*/
begintest (TT_GETERROR_NOERROR, "glDeleteObject(0)");
glDeleteObjectARB (0);
endtest ();
/*
* GL generates an error on invalid object handle.
*/
begintest (TT_GETERROR_INVALIDVALUE, "Pass invalid non-zero object handle");
glDeleteObjectARB (find_invalid_handle ());
endtest ();
glUseProgramObjectARB (find_invalid_handle ());
endtest ();
/*
* Create object. GL should return unique non-zero values.
*/
begintest (TT_PARAM1_NONZERO, "Create object");
vert = glCreateShaderObjectARB (GL_VERTEX_SHADER_ARB);
endtest1 (vert);
frag = glCreateShaderObjectARB (GL_FRAGMENT_SHADER_ARB);
endtest1 (frag);
prog = glCreateProgramObjectARB ();
endtest1 (prog);
endtest1 (vert != frag && frag != prog && prog != vert);
/*
* Link empty program.
*/
begintest (TT_PARAM1_NONZERO, "Link empty program");
glLinkProgramARB (prog);
endtest1 (CheckObjectStatus (prog));
/*
* Use empty program object. Empty program objects are valid.
*/
begintest (TT_GETERROR_NOERROR, "Use empty program object");
glUseProgramObjectARB (prog);
endtest ();
/*
* Attach invalid object handles. Program object 0 should not be accepted.
*/
begintest (TT_GETERROR_INVALIDVALUE, "Attach invalid object handle");
glAttachObjectARB (0, find_invalid_handle ());
endtest ();
glAttachObjectARB (0, frag);
endtest ();
glAttachObjectARB (find_invalid_handle (), find_invalid_handle ());
endtest ();
glAttachObjectARB (find_invalid_handle (), frag);
endtest ();
glAttachObjectARB (prog, find_invalid_handle ());
endtest ();
/*
* Attach valid object handles with wrong semantics.
*/
begintest (TT_GETERROR_INVALIDOPERATION, "Attach object badly");
glAttachObjectARB (vert, frag);
endtest ();
glAttachObjectARB (vert, prog);
endtest ();
glAttachObjectARB (prog, prog);
endtest ();
/*
* Detach non-attached object.
*/
begintest (TT_GETERROR_INVALIDOPERATION, "Detach non-attached object");
glDetachObjectARB (prog, vert);
endtest ();
glDetachObjectARB (prog, frag);
endtest ();
/*
* Attach shader.
*/
begintest (TT_GETERROR_NOERROR, "Attach shader to program object");
glAttachObjectARB (prog, vert);
endtest ();
glAttachObjectARB (prog, frag);
endtest ();
/*
* Attach object twice.
*/
begintest (TT_GETERROR_INVALIDOPERATION, "Attach object twice");
glAttachObjectARB (prog, vert);
endtest ();
glAttachObjectARB (prog, frag);
endtest ();
/*
* Detach attached object.
*/
begintest (TT_GETERROR_NOERROR, "Detach attached object");
glDetachObjectARB (prog, vert);
endtest ();
glDetachObjectARB (prog, frag);
endtest ();
/*
* Attach shader again.
*/
begintest (TT_GETERROR_NOERROR, "Attach shader again");
glAttachObjectARB (prog, vert);
endtest ();
glAttachObjectARB (prog, frag);
endtest ();
/*
* Delete attached object.
*/
begintest (TT_GETERROR_NOERROR, "Delete attached object");
glDeleteObjectARB (vert);
endtest ();
glDeleteObjectARB (frag);
endtest ();
/*
* Query delete status. It should return TRUE. Object handles are still valid
* as they are referenced by program object container.
*/
begintest (TT_PARAM1_NONZERO, "Query delete status");
glGetObjectParameterivARB (vert, GL_OBJECT_DELETE_STATUS_ARB, params);
endtest1 (params[0]);
glGetObjectParameterivARB (frag, GL_OBJECT_DELETE_STATUS_ARB, params);
endtest1 (params[0]);
/*
* Delete already deleted attached object. The behaviour is undefined, but we
* check for no errors. The object still exists, so the handle value is okay.
* In other words, these calls should be silently ignored by GL.
*/
begintest (TT_GETERROR_NOERROR, "Delete already deleted attached object");
glDeleteObjectARB (vert);
endtest ();
glDeleteObjectARB (frag);
endtest ();
/*
* Compile shader source with syntax error.
*/
begintest (TT_PARAM1_ZERO, "Compile shader source with syntax error");
glShaderSourceARB (vert, 1, &invsynvertsrc, NULL);
glCompileShaderARB (vert);
endtest1 (CheckObjectStatus (vert));
glShaderSourceARB (frag, 1, &invsynfragsrc, NULL);
glCompileShaderARB (frag);
endtest1 (CheckObjectStatus (frag));
/*
* Compile shader source with semantic error.
*/
begintest (TT_PARAM1_ZERO, "Compile shader source with semantic error");
glShaderSourceARB (vert, 1, &invsemvertsrc, NULL);
glCompileShaderARB (vert);
endtest1 (CheckObjectStatus (vert));
glShaderSourceARB (frag, 1, &invsemfragsrc, NULL);
glCompileShaderARB (frag);
endtest1 (CheckObjectStatus (frag));
/*
* Link ill-formed vertex-fragment program.
*/
begintest (TT_PARAM1_ZERO, "Link ill-formed vertex-fragment program");
glLinkProgramARB (prog);
endtest1 (CheckObjectStatus (prog));
/*
* Use badly linked program object.
*/
begintest (TT_GETERROR_INVALIDOPERATION, "Use badly linked program object");
glUseProgramObjectARB (prog);
endtest ();
/*
* Compile well-formed shader source. Check if multi-string sources can be handled.
*/
begintest (TT_PARAM1_NONZERO, "Compile well-formed shader source");
tab[0] = uniforms;
tab[1] = validvertsrc;
glShaderSourceARB (vert, 2, tab, NULL);
glCompileShaderARB (vert);
endtest1 (CheckObjectStatus (vert));
tab[0] = uniforms;
tab[1] = validfragsrc;
glShaderSourceARB (frag, 2, tab, NULL);
glCompileShaderARB (frag);
endtest1 (CheckObjectStatus (frag));
/*
* Link vertex-fragment program.
*/
begintest (TT_PARAM1_NONZERO, "Link vertex-fragment program");
glLinkProgramARB (prog);
endtest1 (CheckObjectStatus (prog));
/*
* Use valid linked program object.
*/
begintest (TT_GETERROR_NOERROR, "Use linked program object");
glUseProgramObjectARB (prog);
endtest ();
/*
* Get current program.
*/
begintest (TT_PARAM1_NONZERO, "Get current program");
endtest1 (glGetHandleARB (GL_PROGRAM_OBJECT_ARB) == prog);
/*
* Use 0 program object.
*/
begintest (TT_GETERROR_NOERROR, "Use 0 program object");
glUseProgramObjectARB (0);
endtest ();
/*
* Query uniform location. Uniforms with gl_ prefix cannot be queried.
*/
begintest (TT_PARAM1_NONZERO, "Query uniform location");
endtest1 (glGetUniformLocationARB (prog, "gl_ModelViewMatrix") == -1);
endtest1 (glGetUniformLocationARB (prog, "UniformThatDoesNotExist") == -1);
endtest1 (glGetUniformLocationARB (prog, "") == -1);
endtest1 (glGetUniformLocationARB (prog, "CommonUniform") != -1);
endtest1 (glGetUniformLocationARB (prog, "VertexUniform") != -1);
endtest1 (glGetUniformLocationARB (prog, "FragmentUniform") != -1);
/*
* Query attrib location. Attribs with gl_ prefix cannot be queried.
* When gl_Vertex is used, none of the generic attribs can have index 0.
*/
begintest (TT_PARAM1_NONZERO, "Query attrib location");
endtest1 (glGetAttribLocationARB (prog, "gl_Vertex") == -1);
endtest1 (glGetAttribLocationARB (prog, "AttribThatDoesNotExist") == -1);
endtest1 (glGetAttribLocationARB (prog, "") == -1);
endtest1 (glGetAttribLocationARB (prog, "FirstAttrib") > 0);
endtest1 (glGetAttribLocationARB (prog, "SecondAttrib") > 0);
/*
* Bind attrib locations, link and check if locations are correct.
*/
begintest (TT_PARAM1_NONZERO, "Bind attrib location #1");
glBindAttribLocationARB (prog, 1, "FirstAttrib");
glBindAttribLocationARB (prog, 2, "SecondAttrib");
glLinkProgramARB (prog);
endtest1 (CheckObjectStatus (prog));
endtest1 (glGetAttribLocationARB (prog, "FirstAttrib") == 1);
endtest1 (glGetAttribLocationARB (prog, "SecondAttrib") == 2);
/*
* Bind attrib locations in different order. Link and check if locations are correct.
*/
begintest (TT_PARAM1_NONZERO, "Bind attrib location #2");
glBindAttribLocationARB (prog, 1, "SecondAttrib");
glBindAttribLocationARB (prog, 2, "FirstAttrib");
glLinkProgramARB (prog);
endtest1 (CheckObjectStatus (prog));
endtest1 (glGetAttribLocationARB (prog, "SecondAttrib") == 1);
endtest1 (glGetAttribLocationARB (prog, "FirstAttrib") == 2);
/*
* Detach deleted object.
*/
begintest (TT_GETERROR_NOERROR, "Detach deleted object");
glDetachObjectARB (prog, vert);
endtest ();
glDetachObjectARB (prog, frag);
endtest ();
/*
* Delete deleted detached object.
*/
begintest (TT_GETERROR_INVALIDVALUE, "Delete deleted detached object");
glDeleteObjectARB (vert);
endtest ();
glDeleteObjectARB (frag);
endtest ();
exit (0);
}
bool GlslProgram :: bindAttributeTo ( int loc, const char * name )
{
glBindAttribLocationARB ( program, loc, name );
return true;
}
//-----------------------------------------------------------------------
void GLSLLinkProgram::activate(void)
{
if (!mLinked)
{
if (mVertexProgram)
{
// Some drivers (e.g. OS X on nvidia) incorrectly determine the attribute binding automatically
// and end up aliasing existing built-ins. So avoid!
// Bind all used attribs - not all possible ones otherwise we'll get
// lots of warnings in the log, and also may end up aliasing names used
// as varyings by accident
// Because we can't ask GL whether an attribute is used in the shader
// until it is linked (chicken and egg!) we have to parse the source
size_t numAttribs = sizeof(msCustomAttributes)/sizeof(CustomAttribute);
const String& vpSource = mVertexProgram->getGLSLProgram()->getSource();
for (size_t i = 0; i < numAttribs; ++i)
{
const CustomAttribute& a = msCustomAttributes[i];
// we're looking for either:
// attribute vec<n> <semantic_name>
// in vec<n> <semantic_name>
// The latter is recommended in GLSL 1.3 onwards
// be slightly flexible about formatting
String::size_type pos = vpSource.find(a.name);
if (pos != String::npos)
{
String::size_type startpos = vpSource.find("attribute", pos < 20 ? 0 : pos-20);
if (startpos == String::npos)
startpos = vpSource.find("in", pos-20);
if (startpos != String::npos && startpos < pos)
{
// final check
String expr = vpSource.substr(startpos, pos + a.name.length() - startpos);
StringVector vec = StringUtil::split(expr);
if ((vec[0] == "in" || vec[0] == "attribute") && vec[2] == a.name)
glBindAttribLocationARB(mGLHandle, a.attrib, a.name.c_str());
}
}
}
}
if (mGeometryProgram)
{
RenderOperation::OperationType inputOperationType = mGeometryProgram->getGLSLProgram()->getInputOperationType();
glProgramParameteriEXT(mGLHandle,GL_GEOMETRY_INPUT_TYPE_EXT,
getGLGeometryInputPrimitiveType(inputOperationType, mGeometryProgram->isAdjacencyInfoRequired()));
RenderOperation::OperationType outputOperationType = mGeometryProgram->getGLSLProgram()->getOutputOperationType();
switch (outputOperationType)
{
case RenderOperation::OT_POINT_LIST:
case RenderOperation::OT_LINE_STRIP:
case RenderOperation::OT_TRIANGLE_STRIP:
case RenderOperation::OT_LINE_LIST:
case RenderOperation::OT_TRIANGLE_LIST:
case RenderOperation::OT_TRIANGLE_FAN:
break;
}
glProgramParameteriEXT(mGLHandle,GL_GEOMETRY_OUTPUT_TYPE_EXT,
getGLGeometryOutputPrimitiveType(outputOperationType));
glProgramParameteriEXT(mGLHandle,GL_GEOMETRY_VERTICES_OUT_EXT,
mGeometryProgram->getGLSLProgram()->getMaxOutputVertices());
}
glLinkProgramARB( mGLHandle );
glGetObjectParameterivARB( mGLHandle, GL_OBJECT_LINK_STATUS_ARB, &mLinked );
// force logging and raise exception if not linked
checkForGLSLError( "GLSLLinkProgram::Activate",
"Error linking GLSL Program Object : ", mGLHandle, !mLinked, !mLinked );
if(mLinked)
{
logObjectInfo( String("GLSL link result : "), mGLHandle );
buildGLUniformReferences();
extractAttributes();
}
}
if (mLinked)
{
checkForGLSLError( "GLSLLinkProgram::Activate",
"Error prior to using GLSL Program Object : ", mGLHandle, false, false);
glUseProgramObjectARB( mGLHandle );
checkForGLSLError( "GLSLLinkProgram::Activate",
"Error using GLSL Program Object : ", mGLHandle, false, false);
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_ARBVertexShader_nglBindAttribLocationARB(JNIEnv *env, jclass clazz, jint programObj, jint index, jobject name, jint name_position, jlong function_pointer) {
const GLcharARB *name_address = ((const GLcharARB *)(*env)->GetDirectBufferAddress(env, name)) + name_position;
glBindAttribLocationARBPROC glBindAttribLocationARB = (glBindAttribLocationARBPROC)((intptr_t)function_pointer);
glBindAttribLocationARB(programObj, index, name_address);
}
bool CGLMShaderPair::SetProgramPair ( CGLMProgram *vp, CGLMProgram *fp )
{
m_valid = false; // assume failure
// true result means successful link and query
bool vpgood = (vp!=NULL) && (vp->m_descs[ kGLMGLSL ].m_valid);
bool fpgood = (fp!=NULL) && (fp->m_descs[ kGLMGLSL ].m_valid);
if (!fpgood)
{
// fragment side allowed to be "null".
fp = m_ctx->m_nullFragmentProgram;
}
if (vpgood && fpgood)
{
// attempt link. but first, detach any previously attached programs
if (m_vertexProg)
{
glDetachObjectARB(m_program, m_vertexProg->m_descs[kGLMGLSL].m_object.glsl);
GLMCheckError();
m_vertexProg = NULL;
}
if (m_fragmentProg)
{
glDetachObjectARB(m_program, m_fragmentProg->m_descs[kGLMGLSL].m_object.glsl);
GLMCheckError();
m_fragmentProg = NULL;
}
// now attach
glAttachObjectARB(m_program, vp->m_descs[kGLMGLSL].m_object.glsl);
m_vertexProg = vp;
GLMCheckError();
glAttachObjectARB(m_program, fp->m_descs[kGLMGLSL].m_object.glsl);
m_fragmentProg = fp;
GLMCheckError();
// force the locations for input attributes v0-vN to be at locations 0-N
// use the vertex attrib map to know which slots are live or not... oy! we don't have that map yet... but it's OK.
// fallback - just force v0-v15 to land in locations 0-15 as a standard.
if (vp->m_descs[kGLMGLSL].m_valid)
{
for( int i=0; i < 16; i++)
{
char tmp[16];
sprintf(tmp, "v%d", i); // v0 v1 v2 ... et al
glBindAttribLocationARB( m_program, i, tmp );
GLMCheckError();
}
}
// now link
glLinkProgramARB( m_program );
GLMCheckError();
// check for success
GLint result = 0;
glGetObjectParameterivARB(m_program,GL_OBJECT_LINK_STATUS_ARB,&result); // want GL_TRUE
if (result == GL_TRUE)
{
// success
m_valid = true;
m_revision++;
}
else
{
GLint length = 0;
GLint laux = 0;
// do some digging
glGetObjectParameterivARB(m_program,GL_OBJECT_INFO_LOG_LENGTH_ARB,&length);
GLcharARB *logString = (GLcharARB *)malloc(length * sizeof(GLcharARB));
glGetInfoLogARB(m_program, length, &laux, logString);
char *vtemp = strdup(vp->m_text);
vtemp[ vp->m_descs[kGLMGLSL].m_textOffset + vp->m_descs[kGLMGLSL].m_textLength ] = 0;
char *ftemp = strdup(fp->m_text);
ftemp[ fp->m_descs[kGLMGLSL].m_textOffset + fp->m_descs[kGLMGLSL].m_textLength ] = 0;
GLMPRINTF(("-D- ----- GLSL link failed: \n %s ",logString ));
GLMPRINTF(("-D- ----- GLSL vertex program selected: %08x (handle %08x)", vp, vp->m_descs[kGLMGLSL].m_object.glsl ));
GLMPRINTTEXT(( vtemp + vp->m_descs[kGLMGLSL].m_textOffset, eDebugDump, GLMPRINTTEXT_NUMBEREDLINES ));
GLMPRINTF(("-D- ----- GLSL fragment program selected: %08x (handle %08x)", fp, vp->m_descs[kGLMGLSL].m_object.glsl ));
GLMPRINTTEXT(( ftemp + fp->m_descs[kGLMGLSL].m_textOffset, eDebugDump, GLMPRINTTEXT_NUMBEREDLINES ));
GLMPRINTF(("-D- -----end-----" ));
free( ftemp );
free( vtemp );
free( logString );
}
}
else
{
// fail
Assert(!"Can't link these programs");
}
if (m_valid)
{
m_locVertexParams = glGetUniformLocationARB( m_program, "vc");
GLMCheckError();
m_locVertexInteger0 = glGetUniformLocationARB( m_program, "i0");
GLMCheckError();
m_locVertexBool0 = glGetUniformLocationARB( m_program, "b0");
GLMCheckError();
m_locVertexBool1 = glGetUniformLocationARB( m_program, "b1");
GLMCheckError();
m_locVertexBool2 = glGetUniformLocationARB( m_program, "b2");
GLMCheckError();
m_locVertexBool3 = glGetUniformLocationARB( m_program, "b3");
GLMCheckError();
m_locFragmentParams = glGetUniformLocationARB( m_program, "pc");
GLMCheckError();
m_locFragmentFakeSRGBEnable = glGetUniformLocationARB( m_program, "flSRGBWrite");
GLMCheckError();
m_fakeSRGBEnableValue = -1.0f;
for( int sampler=0; sampler<16; sampler++)
{
char tmp[16];
sprintf(tmp, "sampler%d", sampler); // sampler0 .. sampler1.. etc
m_locSamplers[sampler] = glGetUniformLocationARB( m_program, tmp );
GLMCheckError();
}
}
else
{
m_locVertexParams = -1;
m_locVertexInteger0 = -1;
m_locVertexBool0 = -1;
m_locVertexBool1 = -1;
m_locVertexBool2 = -1;
m_locVertexBool3 = -1;
m_locFragmentParams = -1;
m_locFragmentFakeSRGBEnable = -1;
m_fakeSRGBEnableValue = -999;
memset( m_locSamplers, 0xFF, sizeof( m_locSamplers ) );
m_revision = 0;
}
return m_valid;
}
void ShaderProgram::BindVertexAttribute(int index, const char* name)
{
if (_id) glBindAttribLocationARB(_id, index, name);
}
void Shader::bindAttribLocation(char *varname, GLuint index)
{
glBindAttribLocationARB(m_Handle, index, varname);
Link();
}
//--------------------------------------------------------------
void ofxVBO::draw() {
//fbo.begin();
// Rotate around and center
glPushMatrix();
glTranslatef(0, 0, 0);
//glTranslatef(-25,-50,0);
shader.setShaderActive(true); // Turn on the Shader
// Turn on depths
if(bDepthTest) glEnable(GL_DEPTH_TEST);
else glDisable(GL_DEPTH_TEST);
// Get the attribute and bind it
GLint pixel_loc = glGetAttribLocationARB(shader.shader, "particleSize");
glVertexAttribPointerARB(pixel_loc, 1, GL_FLOAT, false, 0, pointSizes);
glBindAttribLocationARB(shader.shader, pixel_loc, "particleSize");
// printf("Size Location: %i\n", pixel_loc);
// Enable Sprites and texture replace
glEnable(GL_POINT_SPRITE);
glTexEnvi(GL_POINT_SPRITE, GL_COORD_REPLACE, GL_TRUE);
glEnable(GL_VERTEX_PROGRAM_POINT_SIZE); // Enable Vertex Points
glEnableClientState(GL_VERTEX_ARRAY); // Enable Vertex
glEnableClientState(GL_COLOR_ARRAY); // Enable Color
// Color
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[0]); // Bind the color VBO
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, NUM_PARTICLES * 4 * sizeof(float), color);
glColorPointer(4, GL_FLOAT, 0, 0);
// Pnts
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo[1]); // Bind the pnts VBO
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, 0, NUM_PARTICLES * 3 * sizeof(float), pnts);
glVertexPointer(3, GL_FLOAT, 0, 0);
// Enable the PixelSize Attribute
glEnableVertexAttribArrayARB(pixel_loc);
ofEnableAlphaBlending();
// Additive Blending
//glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE);
// shader.setUniformVariable3f("theColor", 1.0, 1.0, 0.0); // Set Shader to Yellow
texture.bind();
glDrawArrays(GL_POINTS, 0, NUM_PARTICLES); // Draw Just Points
texture.unbind();
//shader.setUniformVariable3f("theColor", 1.0, 1.0, 1.0); // Set Shader to White
ofSetColor(255, 255, 255);
//glDrawArrays(GL_LINES, 0, NUM_PARTICLES); // Draw Lines
ofDisableAlphaBlending();
// Clean up
glDisable(GL_POINT_SPRITE);
glDisableClientState(GL_COLOR_ARRAY);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableVertexAttribArrayARB(pixel_loc);
// bind other buffer
glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
shader.setShaderActive(false);
glPopMatrix();
if(bDepthTest) glDisable(GL_DEPTH_TEST);
else glEnable(GL_DEPTH_TEST);
//fbo.end();
//fbo.draw(0,0,ofGetWidth(),ofGetHeight());
}
