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