void kl_particle_render_geom_shdr_assign_effect(kl_particle_render_geom_shdr_t renderer, const char* effect) { char effect_key[512]; kl_shader_t vert_shader, geom_shader, pix_shader; GLuint program; CGLSetCurrentContext(renderer->context->resourceCGLContext); CGLLockContext(renderer->context->resourceCGLContext); sprintf(effect_key, "%s.Vertex.%s", effect, "GL2"); if(kl_shader_manager_get_vertex_shader(renderer->context, effect_key, &vert_shader) == KL_SUCCESS) { sprintf(effect_key, "%s.Geometry.%s", effect, "GL2"); if(kl_shader_manager_get_geometry_shader(renderer->context, effect_key, &geom_shader) == KL_SUCCESS) { sprintf(effect_key, "%s.Fragment.%s", effect, "GL2"); if(kl_shader_manager_get_pixel_shader(renderer->context, effect_key, &pix_shader) == KL_SUCCESS) { program = glCreateProgram(); glAttachShader(program, vert_shader->shader); glAttachShader(program, geom_shader->shader); glAttachShader(program, pix_shader->shader); glBindAttribLocation(program, 0, "in_X"); glBindAttribLocation(program, 1, "in_Y"); glBindAttribLocation(program, 2, "in_Z"); glLinkProgram(program); /* TODO: Check link status */ if(1) { GLuint old_program = renderer->program; kl_shader_t old_shader; renderer->program = program; program = old_program; old_shader = renderer->vert_shader; renderer->vert_shader = vert_shader; vert_shader = old_shader; old_shader = renderer->geom_shader; renderer->geom_shader = geom_shader; geom_shader = old_shader; old_shader = renderer->pix_shader; renderer->pix_shader = pix_shader; pix_shader = old_shader; } if(vert_shader != NULL) glDetachShader(program, vert_shader->shader); if(geom_shader != NULL) glDetachShader(program, geom_shader->shader); if(pix_shader != NULL) glDetachShader(program, pix_shader->shader); glDeleteProgram(program); kl_shader_manager_destroy_shader(renderer->context, &vert_shader); kl_shader_manager_destroy_shader(renderer->context, &pix_shader); kl_shader_manager_destroy_shader(renderer->context, &geom_shader); } else { kl_shader_manager_destroy_shader(renderer->context, &vert_shader); kl_shader_manager_destroy_shader(renderer->context, &geom_shader); } } else { kl_shader_manager_destroy_shader(renderer->context, &vert_shader); } } CGLUnlockContext(renderer->context->resourceCGLContext); }
void init() { // Create the main window App = new sf::Window(sf::VideoMode(RESOLUTION_X, RESOLUTION_Y, 32), "Modeling Program"); // Create a clock for measuring time elapsed Clock = sf::Clock(); __glewInit(); currentRes[0] = RESOLUTION_X; currentRes[1] = RESOLUTION_Y; transM = TRANS_TRANSLATION; axisM = X_AXIS; selected = 0; idCounter = 1; //Initial light position lightPos[0] = 2.0f; lightPos[1] = 2.0f; lightPos[2] = 2.0f; //Initial camera position cameraPos[0] = 0.0f; cameraPos[1] = 0.0f; cameraPos[2] = 0.0f; //Perspective setup glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(45.0,currentRes[0]/currentRes[1], 0.5, 50.0); glMatrixMode(GL_MODELVIEW); //Camera setup camera = Camera(); camera.translate(0.0,0.0,20.0); camera.rotate(60.0, 1.0, 0.0, 0.0); camera.rotate(30.0, 0.0, 0.0, 1.0); camera.apply_transformations(); //setup render target texture //this will eventually hald the rendered scene and be //rendered to a quad for post process effects /*int numTex = 1; glGenTextures(numTex, &textureTarget); setupTargetTexture();*/ //setup the shader programs //the first set is the vertex and fragment shaders for the 3D render //the second set is the shaders for the texture post process effects ShaderManager shaders; shaders.GL20Support = GL20Support; char const * drawVert = "Shaders/Render3dModel.vert"; char const * drawFrag = "Shaders/Render3dModel.frag"; shaderProg = shaders.buildShaderProgram(&drawVert, &drawFrag, 1, 1); /*char const * texVert = "Shaders/RenderTexture.vert"; char const * texFrag = "Shaders/RenderTexture.frag"; texProg = shaders.buildShaderProgram(&texVert, &texFrag, 1, 1);*/ char const * noLightVert = "Shaders/NoLighting.vert"; char const * noLightFrag = "Shaders/NoLighting.frag"; noLightProg = shaders.buildShaderProgram(&noLightVert, &noLightFrag, 1, 1); //this object helps draw textures that fill the viewport /*texRender = ShowTexture(texProg); texRender.GL20Support = GL20Support;*/ // Bind custom attributes glBindAttribLocation(shaderProg, 1, "ambient"); // Start render loop while (App->IsOpened()) { Clock.Reset(); // Process events handleEvents(); // Set the active window before using OpenGL commands // It's useless here because active window is always the same, // but don't forget it if you use multiple windows or controls App->SetActive(); //render 3D scene, then put 2D output in texture, render texture renderScene(); // Finally, display rendered frame on screen App->Display(); float diff = 1.0/FPS-Clock.GetElapsedTime(); if(diff > 0) sf::Sleep(diff); } }
JNIEXPORT void JNICALL JNIFUNCTION_NATIVE(nativeDrawFrame(JNIEnv* env, jobject obj)) { float width, height; float viewProjection[16]; if (!videoInited) { #ifdef DEBUG LOGI("nativeDrawFrame !VIDEO\n"); #endif return; // No point in trying to draw until video is inited. } #ifdef DEBUG LOGI("nativeDrawFrame\n"); #endif if (!gARViewInited) { if (!initARView()) return; } if (gARViewLayoutRequired) layoutARView(); // Upload new video frame if required. if (videoFrameNeedsPixelBufferDataUpload) { arglPixelBufferDataUploadBiPlanar(gArglSettings, gVideoFrame, gVideoFrame + videoWidth*videoHeight); videoFrameNeedsPixelBufferDataUpload = false; } glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear the buffers for new frame. // Display the current frame arglDispImage(gArglSettings); if (!program) { GLuint vertShader = 0, fragShader = 0; // A simple shader pair which accepts just a vertex position and colour, no lighting. const char vertShaderString[] = "attribute vec4 position;\n" "attribute vec4 colour;\n" "uniform mat4 modelViewProjectionMatrix;\n" "varying vec4 colourVarying;\n" "void main()\n" "{\n" "gl_Position = modelViewProjectionMatrix * position;\n" "colourVarying = colour;\n" "}\n"; const char fragShaderString[] = "#ifdef GL_ES\n" "precision mediump float;\n" "#endif\n" "varying vec4 colourVarying;\n" "void main()\n" "{\n" "gl_FragColor = colourVarying;\n" "}\n"; if (program) arglGLDestroyShaders(0, 0, program); program = glCreateProgram(); if (!program) { ARLOGe("drawCube: Error creating shader program.\n"); arglGLDestroyShaders(vertShader, fragShader, program); return; } if (!arglGLCompileShaderFromString(&vertShader, GL_VERTEX_SHADER, vertShaderString)) { ARLOGe("drawCube: Error compiling vertex shader.\n"); arglGLDestroyShaders(vertShader, fragShader, program); return; } if (!arglGLCompileShaderFromString(&fragShader, GL_FRAGMENT_SHADER, fragShaderString)) { ARLOGe("drawCube: Error compiling fragment shader.\n"); arglGLDestroyShaders(vertShader, fragShader, program); return; } glAttachShader(program, vertShader); glAttachShader(program, fragShader); glBindAttribLocation(program, ATTRIBUTE_VERTEX, "position"); glBindAttribLocation(program, ATTRIBUTE_COLOUR, "colour"); if (!arglGLLinkProgram(program)) { ARLOGe("drawCube: Error linking shader program.\n"); arglGLDestroyShaders(vertShader, fragShader, program); return; } arglGLDestroyShaders(vertShader, fragShader, 0); // After linking, shader objects can be deleted. // Retrieve linked uniform locations. uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX] = glGetUniformLocation(program, "modelViewProjectionMatrix"); } glUseProgram(program); // Set up 3D mode. mtxLoadIdentityf(viewProjection); mtxMultMatrixf(viewProjection, cameraLens); glStateCacheEnableDepthTest(); // Set any initial per-frame GL state you require here. // ---> // Lighting and geometry that moves with the camera should be added here. // (I.e. should be specified before camera pose transform.) // ---> // Draw an object on all valid markers. for (int i = 0; i < markersSquareCount; i++) { if (markersSquare[i].valid) { float viewProjection2[16]; mtxLoadMatrixf(viewProjection2, viewProjection); mtxMultMatrixf(viewProjection2, markersSquare[i].pose.T); drawCube(viewProjection2, 40.0f, 0.0f, 0.0f, 20.0f); } } if (cameraPoseValid) { mtxMultMatrixf(viewProjection, cameraPose); // All lighting and geometry to be drawn in world coordinates goes here. // ---> } // If you added external OpenGL code above, and that code doesn't use the glStateCache routines, // then uncomment the line below. //glStateCacheFlush(); // Set up 2D mode. mtxLoadIdentityf(viewProjection); width = (float)viewPort[viewPortIndexWidth]; height = (float)viewPort[viewPortIndexHeight]; mtxOrthof(viewProjection, 0.0f, width, 0.0f, height, -1.0f, 1.0f); glStateCacheDisableDepthTest(); // Add your own 2D overlays here. // ---> // If you added external OpenGL code above, and that code doesn't use the glStateCache routines, // then uncomment the line below. //glStateCacheFlush(); #ifdef DEBUG // Example of 2D drawing. It just draws a white border line. Change the 0 to 1 to enable. const GLfloat square_vertices [4][3] = { {0.5f, 0.5f, 0.0f}, {0.5f, height - 0.5f, 0.0f}, {width - 0.5f, height - 0.5f, 0.0f}, {width - 0.5f, 0.5f, 0.0f} }; const GLubyte square_vertex_colors_white [4][4] = { {255, 255, 255, 255}, {255, 255, 255, 255}, {255, 255, 255, 255}, {255, 255, 255, 255}}; glUniformMatrix4fv(uniforms[UNIFORM_MODELVIEW_PROJECTION_MATRIX], 1, GL_FALSE, viewProjection); glVertexAttribPointer(ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_FALSE, 0, square_vertices); glEnableVertexAttribArray(ATTRIBUTE_VERTEX); glVertexAttribPointer(ATTRIBUTE_COLOUR, 4, GL_UNSIGNED_BYTE, GL_TRUE, 0, square_vertex_colors_white); glEnableVertexAttribArray(ATTRIBUTE_COLOUR); if (!arglGLValidateProgram(program)) { ARLOGe("Error: shader program %d validation failed.\n", program); return; } glDrawArrays(GL_LINE_LOOP, 0, 4); #endif #ifdef DEBUG CHECK_GL_ERROR(); #endif }
/* ==================== Update ==================== */ VOID Shader::Update(const GData* data) { GUARD(Shader::Update); // get the shader config GConfigPtr shader_config_ptr = GConfig::Load((CHAR*)data->Ptr()); CHECK(shader_config_ptr); // check it if it is a shader? CHECK(Str(shader_config_ptr->GetValue()) == "shader"); std::map<Str, SAMPLER>samplers; // prase the shader`s children const GConfig *shader_child_config_ptr = NULL; for(U32 i = 0; shader_child_config_ptr = shader_config_ptr->GetChild(i); i++) { // prase the sampler if(Str(shader_child_config_ptr->GetValue()) == "sampler") { const GConfig *sampler_config_ptr = (const GConfig *)shader_child_config_ptr; // get the sampler name Str name = sampler_config_ptr->GetAttribute("name"); CHECK(name!=""); if(samplers.find(name)!=samplers.end())GAssert(VA("The sampler is already exists : %s.",name.c_str())); // the new sampler SAMPLER sampler; sampler.wrap_s = GL_REPEAT; sampler.wrap_t = GL_REPEAT; sampler.wrap_r = GL_REPEAT; sampler.min_filter = GL_REPEAT; sampler.mag_filter = GL_REPEAT; // get the sampler state const GConfig *sampler_child_config_ptr = NULL; for(U32 j = 0; sampler_child_config_ptr = sampler_config_ptr->GetChild(j); j++) { if(Str(sampler_child_config_ptr->GetValue()) == "wrap_s") { // get the wrap: s Str s = sampler_child_config_ptr->GetText(); CHECK(s!=""); if(s == "CLAMP_TO_EDGE") sampler.wrap_s = GL_CLAMP_TO_EDGE; else if(s == "REPEAT") sampler.wrap_s = GL_REPEAT; else if(s == "MIRRORED_REPEAT") sampler.wrap_s = GL_MIRRORED_REPEAT; else GAssert(VA("The texture`s wrap(s) value(%s) is unknown.\n", s.c_str())); } else if(Str(sampler_child_config_ptr->GetValue()) == "wrap_t") { // get the wrap: t Str t = sampler_child_config_ptr->GetText(); CHECK(t!=""); if(t == "CLAMP_TO_EDGE") sampler.wrap_t = GL_CLAMP_TO_EDGE; else if(t == "REPEAT") sampler.wrap_t = GL_REPEAT; else if(t == "MIRRORED_REPEAT") sampler.wrap_t = GL_MIRRORED_REPEAT; else GAssert(VA("The texture`s wrap(t) value(%s) is unknown.\n", t.c_str())); } else if(Str(sampler_child_config_ptr->GetValue()) == "wrap_r") { // get the wrap: r Str r = sampler_child_config_ptr->GetText(); CHECK(r!=""); if(r == "CLAMP_TO_EDGE") sampler.wrap_r = GL_CLAMP_TO_EDGE; else if(r == "REPEAT") sampler.wrap_r = GL_REPEAT; else if(r == "MIRRORED_REPEAT") sampler.wrap_r = GL_MIRRORED_REPEAT; else GAssert(VA("The texture`s wrap(r) value(%s) is unknown.\n", r.c_str())); } else if(Str(sampler_child_config_ptr->GetValue()) == "min_filter") { // get the min filter Str min = sampler_child_config_ptr->GetText(); CHECK(min!=""); if(min == "NEAREST") sampler.min_filter = GL_NEAREST; else if(min == "LINEAR") sampler.min_filter = GL_LINEAR; else if(min == "NEAREST_MIPMAP_NEAREST") sampler.min_filter = GL_NEAREST_MIPMAP_NEAREST; else if(min == "NEAREST_MIPMAP_LINEAR") sampler.min_filter = GL_NEAREST_MIPMAP_LINEAR; else if(min == "LINEAR_MIPMAP_NEAREST") sampler.min_filter = GL_LINEAR_MIPMAP_NEAREST; else if(min == "LINEAR_MIPMAP_LINEAR") sampler.min_filter = GL_LINEAR_MIPMAP_LINEAR; else GAssert(VA("The texture`s min filter value(%s) is unknown.\n", min.c_str())); } else if(Str(sampler_child_config_ptr->GetValue()) == "mag_filter") { // get the mag filter Str mag = sampler_child_config_ptr->GetText(); CHECK(mag!=""); if(mag == "NEAREST") sampler.mag_filter = GL_NEAREST; else if(mag == "LINEAR") sampler.mag_filter = GL_LINEAR; else GAssert(VA("The texture`s mag filter value(%s) is unknown.\n", mag.c_str())); } else { GAssert(VA("The shader`s sampler(%s)`s keyword(%s) is unknown!", name.c_str(), sampler_child_config_ptr->GetValue())); } } // add it to the table samplers.insert(std::make_pair(name, sampler)); } // prase the program else if(Str(shader_child_config_ptr->GetValue()) == "program") { const GConfig*program_config_ptr = (const GConfig*)shader_child_config_ptr; // the new program PROGRAM program; // get the program name Str program_name = program_config_ptr->GetAttribute("name"); CHECK(program_name!=""); for(std::list<PROGRAM>::iterator it = mPrograms.begin(); it != mPrograms.end(); ++it) { if(program_name == it->name) GAssert(VA("The program is already exists : %s.",program_name.c_str())); } program.name = program_name; // get the program attribs Str attribs = program_config_ptr->GetAttribute("attribs"); CHECK(attribs!= ""); // prase the program`s children const CHAR *vs, *fs; const GConfig *program_child_config_ptr = NULL; for(U32 j = 0; program_child_config_ptr = program_config_ptr->GetChild(j); j++) { if(Str(program_child_config_ptr->GetValue()) == "vs") { // get the vs source vs = program_child_config_ptr->GetText(); } else if(Str(program_child_config_ptr->GetValue()) == "fs") { // get the fs source fs = program_child_config_ptr->GetText(); } else { GAssert(VA("The shader`s program(%s)`s keyword(%s) is unknown!", program_name.c_str(), program_child_config_ptr->GetValue())); } } GLint result = 0; // compile the program program.object = glCreateProgram(); CHECK(program.object); // compile the vertex shader if(vs && vs != "") { GLuint handle = glCreateShader(GL_VERTEX_SHADER); CHECK(handle); // load the vertex shader source glShaderSource(handle, 1, (const GLchar**)&vs, NULL); // compile the shader glCompileShader(handle); glGetShaderiv(handle, GL_COMPILE_STATUS, &result); if(result == 0) { GLsizei size; glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &size); if(size > 1) { Str log(size+1,0); GLsizei length; glGetShaderInfoLog(handle, size, &length, &log[0]); if(length > 0) GAssert(log.c_str()); } GAssert("Fail to compile the vertex shader.\n"); } // attach the shader to the gpu program glAttachShader(program.object, handle); glDeleteShader(handle); } // compile the fragment shader if(fs && fs != "") { GLuint handle = glCreateShader(GL_FRAGMENT_SHADER); CHECK(handle); // load the fragment shader source glShaderSource(handle, 1, (const GLchar**)&fs, NULL); // compile the shader glCompileShader(handle); glGetShaderiv(handle, GL_COMPILE_STATUS, &result); if(result == 0) { GLsizei size; glGetShaderiv(handle, GL_INFO_LOG_LENGTH, &size); if(size > 1) { Str log(size+1,0); GLsizei length; glGetShaderInfoLog(handle, size, &length, &log[0]); if(length > 0) GAssert(log.c_str()); } GAssert("Fail to compile the fragment shader.\n"); } // attach the shader to the GPU Program glAttachShader(program.object, handle); glDeleteShader(handle); } // bind the attributes if(attribs.size()) { std::vector<Str>attributes = GTokenize(attribs); for(U32 k = 0; k < attributes.size(); k++) glBindAttribLocation(program.object, k, attributes[k].c_str()); } // link the shader to the gpu program glLinkProgram(program.object); glGetProgramiv(program.object, GL_LINK_STATUS, &result); if(result == 0) { GLsizei size; glGetProgramiv(program.object, GL_INFO_LOG_LENGTH, &size); if(size > 1) { Str log(size+1,0); GLsizei length; glGetProgramInfoLog(program.object, size, &length, &log[0]); if(length > 0) GAssert(log.c_str()); } GAssert("Fail to link the shader to the gpu program.\n"); } // build the uniform map GLint uniform_count, max_length; glGetProgramiv(program.object, GL_ACTIVE_UNIFORMS, &uniform_count); glGetProgramiv(program.object, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_length); CHAR* uniform_name = GNEW(CHAR[max_length+1]); CHECK(uniform_name); for( I32 k = 0; k < uniform_count; k++ ) { // get the uniform info of the program GLenum type; GLint size; memset(uniform_name,0,(max_length+1)*sizeof(CHAR)); glGetActiveUniform(program.object, k, max_length, 0, &size, &type, &uniform_name[0]); GLint location = glGetUniformLocation(program.object, &uniform_name[0]); if(location < 0) continue; // add the uniform to the table std::map<Str, UNIFORM>::iterator it = mUniforms.find(uniform_name); if(it == mUniforms.end()) { UNIFORM uniform; uniform.type = type; uniform.count = 0; it = mUniforms.insert(mUniforms.begin(), std::make_pair(uniform_name,uniform)); } CHECK(it!=mUniforms.end() && it->second.type==type); program.uniforms.push_back(std::make_pair(location,&it->second)); } GDELETE([]uniform_name); // validate the program glValidateProgram(program.object); glGetProgramiv(program.object, GL_VALIDATE_STATUS, &result); if(result == 0) { GLsizei size; glGetProgramiv(program.object, GL_INFO_LOG_LENGTH, &size); if(size > 1) { Str log(size+1,0); GLsizei length; glGetProgramInfoLog(program.object, size, &length, &log[0]); if(length > 0) GAssert(log.c_str()); } } // add the program to the map mPrograms.push_back(program); } // prase the pass else if(Str(shader_child_config_ptr->GetValue()) == "pass") { const GConfig*pass_config_ptr = (const GConfig*)shader_child_config_ptr; // get the pass name Str pass_name = pass_config_ptr->GetAttribute("name"); CHECK(pass_name!=""); // the new pass PASS pass; pass.program = NULL; pass.blend_src = GL_ONE; pass.blend_dst = GL_ZERO; pass.depth_func = GL_LEQUAL; pass.depth_mask = TRUE; pass.cull_mode = GL_NONE; // prase the pass`s children const GConfig *pass_child_config_ptr = NULL; for(U32 j = 0; pass_child_config_ptr = pass_config_ptr->GetChild(j); j++) { if(Str(pass_child_config_ptr->GetValue()) == "program") { // get the program name Str program_name = pass_child_config_ptr->GetAttribute("name"); CHECK(program_name!=""); // get the program of the pass for(std::list<PROGRAM>::iterator it = mPrograms.begin(); it != mPrograms.end(); ++it) { if(program_name == it->name) pass.program = &(*it); } CHECK(pass.program); } else if(Str(pass_child_config_ptr->GetValue()) == "blend") { // get the blend src Str src = pass_child_config_ptr->GetAttribute("src"); CHECK(src!=""); if(src == "BF_ZERO") pass.blend_src = GL_ZERO; else if(src == "BF_ONE") pass.blend_src = GL_ONE; else if(src == "BF_DST_COLOR") pass.blend_src = GL_DST_COLOR; else if(src == "BF_ONE_MINUS_DST_COLOR") pass.blend_src = GL_ONE_MINUS_DST_COLOR; else if(src == "BF_SRC_ALPHA_SATURATE") pass.blend_src = GL_SRC_ALPHA_SATURATE; else if(src == "BF_SRC_ALPHA") pass.blend_src = GL_SRC_ALPHA; else if(src == "BF_ONE_MINUS_SRC_ALPHA") pass.blend_src = GL_ONE_MINUS_SRC_ALPHA; else if(src == "BF_DST_ALPHA") pass.blend_src = GL_DST_ALPHA; else if(src == "BF_ONE_MINUS_DST_ALPHA") pass.blend_src = GL_ONE_MINUS_DST_ALPHA; // get the blend dst Str dst = pass_child_config_ptr->GetAttribute("dst"); CHECK(dst!=""); if(dst == "BF_ZERO") pass.blend_dst = GL_ZERO; else if(dst == "BF_ONE") pass.blend_dst = GL_ONE; else if(dst == "BF_SRC_COLOR") pass.blend_dst = GL_SRC_COLOR; else if(dst == "BF_ONE_MINUS_SRC_COLOR") pass.blend_dst = GL_ONE_MINUS_SRC_COLOR; else if(dst == "BF_SRC_ALPHA") pass.blend_dst = GL_SRC_ALPHA; else if(dst == "BF_ONE_MINUS_SRC_ALPHA") pass.blend_dst = GL_ONE_MINUS_SRC_ALPHA; else if(dst == "BF_DST_ALPHA") pass.blend_dst = GL_DST_ALPHA; else if(dst == "BF_ONE_MINUS_DST_ALPHA") pass.blend_dst = GL_ONE_MINUS_DST_ALPHA; } else if(Str(pass_child_config_ptr->GetValue()) == "depth") { // get the depth func Str func = pass_child_config_ptr->GetAttribute("func"); CHECK(func!=""); if(func == "CF_NEVER") pass.depth_func = GL_NEVER; else if(func == "CF_LESS") pass.depth_func = GL_LESS; else if(func == "CF_EQUAL") pass.depth_func = GL_EQUAL; else if(func == "CF_LEQUAL") pass.depth_func = GL_LEQUAL; else if(func == "CF_GREATER") pass.depth_func = GL_GREATER; else if(func == "CF_NOTEQUAL") pass.depth_func = GL_NOTEQUAL; else if(func == "CF_GEQUAL") pass.depth_func = GL_GEQUAL; else if(func == "CF_ALWAYS") pass.depth_func = GL_ALWAYS; // get the depth mask Str mask = pass_child_config_ptr->GetAttribute("mask"); CHECK(mask!=""); pass.depth_mask = (mask == "TRUE") ? TRUE : FALSE; } else if(Str(pass_child_config_ptr->GetValue()) == "cull") { // get the cull mode Str mode = pass_child_config_ptr->GetAttribute("mode"); CHECK(mode!=""); if(mode == "CULL_NONE") pass.cull_mode = GL_NONE; else if (mode == "CULL_FRONT") pass.cull_mode = GL_FRONT; else if (mode == "CULL_BACK") pass.cull_mode = GL_BACK; } else { GAssert(VA("The effect`s pass keyword(%s) is unknown!", pass_child_config_ptr->GetValue())); } } // add the pass to the table mPasses.insert(std::make_pair(pass_name,pass)); } else { GAssert(VA("The shader`s keyword(%s) is unknown!", shader_child_config_ptr->GetValue())); } }
int main () { GLFWwindow* window = NULL; const GLubyte* renderer; const GLubyte* version; GLuint cube_sp, knot_sp; GLuint vao; // // Start OpenGL using helper libraries // -------------------------------------------------------------------------- if (!glfwInit ()) { fprintf (stderr, "ERROR: could not start GLFW3\n"); return 1; } /* change to 3.2 if on Apple OS X glfwWindowHint (GLFW_CONTEXT_VERSION_MAJOR, 4); glfwWindowHint (GLFW_CONTEXT_VERSION_MINOR, 0); glfwWindowHint (GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); glfwWindowHint (GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); */ glfwWindowHint (GLFW_SAMPLES, msaa); window = glfwCreateWindow (gl_width, gl_height, "{quadratic bezier}", NULL, NULL); if (!window) { fprintf (stderr, "ERROR: opening OS window\n"); return 1; } glfwMakeContextCurrent (window); glewExperimental = GL_TRUE; glewInit (); /* get version info */ renderer = glGetString (GL_RENDERER); /* get renderer string */ version = glGetString (GL_VERSION); /* version as a string */ printf ("Renderer: %s\n", renderer); printf ("OpenGL version supported %s\n", version); int point_count = 0; // // Set up vertex buffers and vertex array object // -------------------------------------------------------------------------- { GLfloat* vp = NULL; // array of vertex points GLfloat* vn = NULL; // array of vertex normals (we haven't used these yet) GLfloat* vt = NULL; // array of texture coordinates (or these) assert (load_obj_file ("smcube.obj", vp, vt, vn, point_count)); GLuint points_vbo, texcoord_vbo, normal_vbo; glGenBuffers (1, &points_vbo); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 3 * point_count, vp, GL_STATIC_DRAW); glGenBuffers (1, &texcoord_vbo); glBindBuffer (GL_ARRAY_BUFFER, texcoord_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 2 * point_count, vt, GL_STATIC_DRAW); glGenBuffers (1, &normal_vbo); glBindBuffer (GL_ARRAY_BUFFER, normal_vbo); glBufferData (GL_ARRAY_BUFFER, sizeof (float) * 3 * point_count, vn, GL_STATIC_DRAW); glGenVertexArrays (1, &vao); glBindVertexArray (vao); glEnableVertexAttribArray (0); glBindBuffer (GL_ARRAY_BUFFER, points_vbo); glVertexAttribPointer (0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray (1); glBindBuffer (GL_ARRAY_BUFFER, texcoord_vbo); glVertexAttribPointer (1, 2, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray (2); glBindBuffer (GL_ARRAY_BUFFER, normal_vbo); glVertexAttribPointer (2, 3, GL_FLOAT, GL_FALSE, 0, NULL); free (vp); free (vn); free (vt); } // // Load shaders from files // -------------------------------------------------------------------------- { char* vertex_shader_str; char* fragment_shader_str; // allocate some memory to store shader strings vertex_shader_str = (char*)malloc (81920); fragment_shader_str = (char*)malloc (81920); // load shader strings from text files assert (parse_file_into_str ("cube.vert", vertex_shader_str, 81920)); assert (parse_file_into_str ("cube.frag", fragment_shader_str, 81920)); GLuint vs, fs; vs = glCreateShader (GL_VERTEX_SHADER); fs = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource (vs, 1, (const char**)&vertex_shader_str, NULL); glShaderSource (fs, 1, (const char**)&fragment_shader_str, NULL); // free memory free (vertex_shader_str); free (fragment_shader_str); glCompileShader (vs); glCompileShader (fs); cube_sp = glCreateProgram (); glAttachShader (cube_sp, fs); glAttachShader (cube_sp, vs); glBindAttribLocation (cube_sp, 0, "vp"); glBindAttribLocation (cube_sp, 1, "vt"); glBindAttribLocation (cube_sp, 2, "vn"); glLinkProgram (cube_sp); } { char* vertex_shader_str; char* fragment_shader_str; // allocate some memory to store shader strings vertex_shader_str = (char*)malloc (81920); fragment_shader_str = (char*)malloc (81920); // load shader strings from text files assert (parse_file_into_str ("knot.vert", vertex_shader_str, 81920)); assert (parse_file_into_str ("knot.frag", fragment_shader_str, 81920)); GLuint vs, fs; vs = glCreateShader (GL_VERTEX_SHADER); fs = glCreateShader (GL_FRAGMENT_SHADER); glShaderSource (vs, 1, (const char**)&vertex_shader_str, NULL); glShaderSource (fs, 1, (const char**)&fragment_shader_str, NULL); // free memory free (vertex_shader_str); free (fragment_shader_str); glCompileShader (vs); glCompileShader (fs); knot_sp = glCreateProgram (); glAttachShader (knot_sp, fs); glAttachShader (knot_sp, vs); glLinkProgram (knot_sp); } // // Create some matrices // -------------------------------------------------------------------------- mat4 M, V, P; M = identity_mat4 ();//scale (identity_mat4 (), vec3 (0.05, 0.05, 0.05)); vec3 cam_pos (0.0, 0.0, 15.0); vec3 targ_pos (0.0, 0.0, 0.0); vec3 up = normalise (vec3 (0.0, 1.0, 0.0)); V = look_at (cam_pos, targ_pos, up); P = perspective (67.0f, (float)gl_width / (float)gl_height, 0.1, 1000.0); int M_loc = glGetUniformLocation (cube_sp, "M"); int V_loc = glGetUniformLocation (cube_sp, "V"); int P_loc = glGetUniformLocation (cube_sp, "P"); int A_loc = glGetUniformLocation (cube_sp, "A"); int B_loc = glGetUniformLocation (cube_sp, "B"); int C_loc = glGetUniformLocation (cube_sp, "C"); int t_loc = glGetUniformLocation (cube_sp, "t"); // send matrix values to shader immediately glUseProgram (cube_sp); glUniformMatrix4fv (M_loc, 1, GL_FALSE, M.m); glUniformMatrix4fv (V_loc, 1, GL_FALSE, V.m); glUniformMatrix4fv (P_loc, 1, GL_FALSE, P.m); // // specific knots for bezier here A, C are start, end, B is control point // vec3 A = vec3 (-7.0f, -5.0f, 0.0f); vec3 B = vec3 (0.0f, 8.0f, 0.0f); vec3 C = vec3 (7.0f, -5.0f, 0.0f); glUniform3fv (A_loc, 1, A.v); glUniform3fv (B_loc, 1, B.v); glUniform3fv (C_loc, 1, C.v); int knot_loc = glGetUniformLocation (knot_sp, "pos"); int knotP_loc = glGetUniformLocation (knot_sp, "P"); int knotV_loc = glGetUniformLocation (knot_sp, "V"); glUseProgram (knot_sp); glUniformMatrix4fv (knotV_loc, 1, GL_FALSE, V.m); glUniformMatrix4fv (knotP_loc, 1, GL_FALSE, P.m); // // Start rendering // -------------------------------------------------------------------------- // tell GL to only draw onto a pixel if the fragment is closer to the viewer glEnable (GL_DEPTH_TEST); // enable depth-testing glDepthFunc (GL_LESS); // depth-testing interprets a smaller value as "closer" glDepthFunc (GL_LESS); // depth-testing is to use a "less than" function glEnable (GL_CULL_FACE); // enable culling of faces glCullFace (GL_BACK); glFrontFace (GL_CCW); glClearColor (0.04, 0.04, 0.75, 1.0); /* Render Points, allow resize in vertex shader */ glEnable (GL_PROGRAM_POINT_SIZE); glPointParameteri (GL_POINT_SPRITE_COORD_ORIGIN, GL_LOWER_LEFT); float t = 0.0f; float speed = 0.5f; double prev = glfwGetTime (); while (!glfwWindowShouldClose (window)) { glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // just the default viewport, covering the whole render area glViewport (0, 0, gl_width, gl_height); double curr = glfwGetTime (); double elapsed = curr - prev; prev = curr; // // move along spline if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_LEFT)) { t -= elapsed * speed; if (t < 0.0f) { t = 0.0f; } } if (GLFW_PRESS == glfwGetKey (window, GLFW_KEY_RIGHT)) { t += elapsed * speed; if (t > 1.0f) { t = 1.0f; } } // // render 3 knots glEnable (GL_PROGRAM_POINT_SIZE); glUseProgram (knot_sp); glUniform3fv (knot_loc, 1, A.v); glDrawArrays (GL_POINTS, 0, 1); glUseProgram (knot_sp); glUniform3fv (knot_loc, 1, B.v); glDrawArrays (GL_POINTS, 0, 1); glUseProgram (knot_sp); glUniform3fv (knot_loc, 1, C.v); glDrawArrays (GL_POINTS, 0, 1); glDisable (GL_PROGRAM_POINT_SIZE); glUseProgram (cube_sp); glBindVertexArray (vao); M = identity_mat4 ();//rotate_y_deg (identity_mat4 (), a); glUniformMatrix4fv (M_loc, 1, GL_FALSE, M.m); glUniform1f (t_loc, t); glDrawArrays (GL_TRIANGLES, 0, point_count); /* this just updates window events and keyboard input events (not used yet) */ glfwPollEvents (); glfwSwapBuffers (window); } return 0; }
void VSShaderLib::setVertexAttribName(VSShaderLib::AttribType at, std::string name) { glBindAttribLocation(pProgram,at,name.c_str()); }
/** * Set OpenGL initial state */ void tree_renderer::init() { /* Set clear color */ glClearColor(0.0, 0.0, 0.0, 1.0); /* Set 2D orthogonal projection */ //gluOrtho2D(0.0,800,600, 0.0); std::ifstream ifs; std::string line = "", text = ""; /* Initialize the vertex shader (generate, load, compile and check errors) */ ifs.open("tree_vertex.glsl", std::ios::in); while (ifs.good()) { getline(ifs, line); text += line + "\n"; } vertexSource = text.c_str(); vertexShader = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vertexShader, 1, &vertexSource, NULL); glCompileShader(vertexShader); GLint status = 0; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &status); if (status != GL_TRUE) { char buffer[512]; glGetShaderInfoLog(vertexShader, 512, NULL, buffer); std::cout << "Error while compiling the vertex shader: " << std::endl << buffer << std::endl; } /* Initialize the fragment shader (generate, load, compile and check errors) */ ifs.open("tree_fragment.glsl", std::ios::in); line = "", text = ""; while (ifs.good()) { getline(ifs, line); text += line + "\n"; } fragmentSource = text.c_str(); fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fragmentShader, 1, &fragmentSource, NULL); glCompileShader(fragmentShader); status = 0; glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &status); if (status != GL_TRUE) { char buffer[512]; glGetShaderInfoLog(fragmentShader, 512, NULL, buffer); std::cout << "Error while compiling the fragment shader: " << std::endl << buffer << std::endl; } /* Load the information of the cylinder */ load_obj_file("cylinder.obj", cylinderVertices, cylinderCoords, cylinderNormals, cylinderVertexCount); /* Load the information of the 3D cone */ load_obj_file("cone.obj", coneVertices, coneCoords, coneNormals, coneVertexCount); /* Initialize the Vertex Buffer Object for the vertices */ glGenBuffers(1, &cylinderVerticesVbo); glBindBuffer(GL_ARRAY_BUFFER, cylinderVerticesVbo); glBufferData(GL_ARRAY_BUFFER, 3 * cylinderVertexCount * sizeof(GLfloat), cylinderVertices, GL_STATIC_DRAW); glGenBuffers(1, &coneVerticesVbo); glBindBuffer(GL_ARRAY_BUFFER, coneVerticesVbo); glBufferData(GL_ARRAY_BUFFER, 3 * coneVertexCount * sizeof(GLfloat), coneVertices, GL_STATIC_DRAW); glGenBuffers(1, &lineVerticesVbo); glBindBuffer(GL_ARRAY_BUFFER, lineVerticesVbo); glBufferData(GL_ARRAY_BUFFER, 3 * lineVerticesCount * sizeof(GLfloat), lineVertices, GL_STATIC_DRAW); glGenBuffers(1, &colorVbo); glBindBuffer(GL_ARRAY_BUFFER, colorVbo); glBufferData(GL_ARRAY_BUFFER, 3 * lineVerticesCount * sizeof(GLfloat), colors, GL_STATIC_DRAW); /* Define the Vertex Array Object of the 3D model */ /* glGenVertexArrays(1, &lineVao); glBindVertexArray(lineVao); glBindBuffer(GL_ARRAY_BUFFER, lineVerticesVbo); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); glBindBuffer(GL_ARRAY_BUFFER, colorVbo); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); */ glGenVertexArrays(1, &cylinderVao); glBindVertexArray(cylinderVao); glBindBuffer(GL_ARRAY_BUFFER, cylinderVerticesVbo); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL); //glBindBuffer(GL_ARRAY_BUFFER, colorVbo); //glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, NULL); glEnableVertexAttribArray(0); //glEnableVertexAttribArray(1); /* Initialize the shader program */ shaderProgram = glCreateProgram(); glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glBindAttribLocation(shaderProgram, 0, "inPoint"); glBindAttribLocation(shaderProgram, 1, "inColor"); glLinkProgram(shaderProgram); /* Get the location of the uniform variables */ modelMatrixLocation = glGetUniformLocation(shaderProgram, "modelMatrix"); viewMatrixLocation = glGetUniformLocation(shaderProgram, "viewMatrix"); projMatrixLocation = glGetUniformLocation(shaderProgram, "projMatrix"); colorLocation = glGetUniformLocation(shaderProgram, "inColor"); /* Set the shader program in the pipeline */ glUseProgram(shaderProgram); }
void GLState::glsBindAttribLocation(const GLuint program, const GLuint index, const GLchar* name) { glBindAttribLocation(program, index, name); ERROR_CHECK; }
int main(int argc, char *argv[]) { EGLDisplay display; EGLSurface surface; GLuint vertex_shader; GLuint fragment_shader; GLuint program; GLint ret; GLint width, height; const char *vertex_shader_source = "attribute vec4 aPosition; \n" " \n" "void main() \n" "{ \n" " gl_Position = aPosition; \n" "} \n"; const char *fragment_shader_source = "precision mediump float; \n" " \n" "uniform vec4 uColor; \n" " \n" "void main() \n" "{ \n" " gl_FragColor = uColor; \n" "} \n"; GLfloat vVertices[] = {-0.45, -0.75, 0.0, 0.45, -0.75, 0.0, -0.45, 0.75, 0.0, 0.45, 0.75, 0.0}; GLfloat uColor[] = {1.0, 0.0, 0.0, 1.0}; buffer_size(&width, &height); printf("Buffer dimensions %dx%d\n", width, height); display = egl_display_init(); surface = egl_surface_init(display, 2, width, height); glViewport(0, 0, width, height); glClearColor(0.5, 0.5, 0.5, 1.0); glClear(GL_COLOR_BUFFER_BIT); vertex_shader = vertex_shader_compile(vertex_shader_source); fragment_shader = fragment_shader_compile(fragment_shader_source); program = glCreateProgram(); if (!program) { printf("Error: failed to create program!\n"); return -1; } glAttachShader(program, vertex_shader); glAttachShader(program, fragment_shader); glBindAttribLocation(program, 0, "aPosition"); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &ret); if (!ret) { char *log; printf("Error: program linking failed!:\n"); glGetProgramiv(program, GL_INFO_LOG_LENGTH, &ret); if (ret > 1) { log = malloc(ret); glGetProgramInfoLog(program, ret, NULL, log); printf("%s", log); } return -1; } glUseProgram(program); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, vVertices); glEnableVertexAttribArray(0); int location = glGetUniformLocation(program, "uColor"); glUniform4fv(location, 1, uColor); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); eglSwapBuffers(display, surface); usleep(1000000); fflush(stdout); return 0; }
void ShaderProgram::init(const char *vsFile, const char *fsFile){ // Create the shaders std::cout << "using vertex shader: " << vsFile << std::endl; std::cout << "using fragment shader: " << fsFile << std::endl; shaderVP = glCreateShader(GL_VERTEX_SHADER); shaderFP = glCreateShader(GL_FRAGMENT_SHADER); const char *vp = readSource(vsFile); const char *fp = readSource(fsFile); if (vp == NULL || fp == NULL) { std::cerr << "ShaderProgram::Init ERROR: ONE OR BOTH FILES NOT FOUND!" << std::endl; exit(EXIT_FAILURE); } // Set the source codes glShaderSource(shaderVP, 1, &vp, 0); glShaderSource(shaderFP, 1, &fp, 0); delete [] vp; delete [] fp; // Compile the shader source glCompileShader(shaderVP); // Check for errors GLint isCompiled = 0; glGetShaderiv(shaderVP, GL_COMPILE_STATUS, &isCompiled); if(isCompiled == GL_FALSE) { GLint maxLength = 0; glGetShaderiv(shaderVP, GL_INFO_LOG_LENGTH, &maxLength); // The maxLength includes the NULL character std::vector<GLchar> errorLog(maxLength); glGetShaderInfoLog(shaderVP, maxLength, &maxLength, &errorLog[0]); // Provide the infolog in whatever manor you deem best. std::cout << "Vertex Shader Compilation Error:" << std::endl; for (std::vector<GLchar>::iterator it = errorLog.begin(); it != errorLog.end(); it++) { std::cout << *it; } std::cout << std::endl; // Exit with failure. glDeleteShader(shaderVP); // Don't leak the shader. exit(EXIT_FAILURE); } glCompileShader(shaderFP); isCompiled = 0; glGetShaderiv(shaderFP, GL_COMPILE_STATUS, &isCompiled); if(isCompiled == GL_FALSE) { GLint maxLength = 0; glGetShaderiv(shaderFP, GL_INFO_LOG_LENGTH, &maxLength); // The maxLength includes the NULL character std::vector<GLchar> errorLog(maxLength); glGetShaderInfoLog(shaderFP, maxLength, &maxLength, &errorLog[0]); // Provide the infolog in whatever manor you deem best. std::cout << "Fragment Shader Compilation Error:" << std::endl; for (std::vector<GLchar>::iterator it = errorLog.begin(); it != errorLog.end(); it++) { std::cout << *it; } std::cout << std::endl; // Exit with failure. glDeleteShader(shaderVP); glDeleteShader(shaderFP); // Don't leak the shader. exit(EXIT_FAILURE); } // Create the shader program shaderID = glCreateProgram(); // Attach the shaders to the program glAttachShader(shaderID, shaderVP); glAttachShader(shaderID, shaderFP); glLinkProgram(shaderID); GLint isLinked; glGetProgramiv(shaderID, GL_LINK_STATUS, &isLinked); if (isLinked == GL_FALSE) { GLint maxLength; glGetProgramiv(shaderID, GL_INFO_LOG_LENGTH, &maxLength); //The maxLength includes the NULL character std::vector<GLchar> infoLog(maxLength); glGetProgramInfoLog(shaderID, maxLength, &maxLength, &infoLog[0]); //The program is useless now. So delete it. glDeleteProgram(shaderID); //Provide the infolog in whatever manner you deem best. for (std::vector<GLchar>::iterator it = infoLog.begin(); it != infoLog.end(); it++) { std::cout << *it; } std::cout << std::endl; //Exit with failure. glDeleteShader(shaderVP); glDeleteShader(shaderFP); exit(EXIT_FAILURE); } glDetachShader(shaderID, shaderVP); glDetachShader(shaderID, shaderFP); glDeleteShader(shaderVP); glDeleteShader(shaderFP); glCheckErrors("After Linking"); glBindAttribLocation(shaderID, 0, "vert_position"); glCheckErrors("Bind Attrib"); std::cout << "Shader Program " << shaderID << ": " << vsFile << " + " << fsFile << std::endl; }
int main(int argc, char *argv[]) #endif { #ifdef USE_SDL if (SDL_Init(SDL_INIT_VIDEO) < 0) { report("Can't initialize SDL\n"); return 1; } // TODO fullscreen + get screen size #ifndef __ANDROID__ width=height=700; #else width=320; height=480; // const SDL_VideoInfo* vinfo=SDL_GetVideoInfo(); // width = vinfo->current_w; // height = vinfo->current_h; // report("Detected %dx%d resolution.\n",width,height); #endif window = SDL_CreateWindow("Bezier Fragment Shader Demo", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_RESIZABLE | SDL_WINDOW_SHOWN | SDL_WINDOW_OPENGL); if(window == NULL) { report("Can't create window: %s\n", SDL_GetError()); return -1; } glcontext = SDL_GL_CreateContext(window); if(glcontext == NULL) { report("Can't create context: %s\n", SDL_GetError()); return -1; } SDL_GL_MakeCurrent(window, glcontext); SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1); #else glutInit(&argc,argv); glutInitWindowSize(700,700); glutInitDisplayMode(GLUT_RGB|GLUT_DOUBLE|GLUT_DEPTH); glutCreateWindow("Bezier Fragment Shader Demo"); #endif glViewport(0, 0, width, height); glClearColor(0.0, 0.0, 0.0, 0.0); glEnable(GL_DEPTH_TEST); fshader = loadShader("bezier.glsl",GL_FRAGMENT_SHADER); vshader = loadShader("bezier-vertex.glsl",GL_VERTEX_SHADER); if (!(fshader&&vshader)) { report("One of shaders failed, aborting.\n"); return -1; } program = glCreateProgram(); glAttachShader(program, fshader); glAttachShader(program, vshader); glBindAttribLocation(program, 0, "vertexPos"); glBindAttribLocation(program, 1, "bezCoordsAttr"); glLinkProgram(program); glGetProgramiv(program, GL_LINK_STATUS, &linked); if (!linked) { report("Can't link the shader\n"); return -1; } glUseProgram(program); glUniform1i(glGetUniformLocation(program, "drawFill"), 1); glUniform1i(glGetUniformLocation(program, "useBezier"), 1); glUniform1i(glGetUniformLocation(program, "drawStroke"), 1); #ifndef __ANDROID__ // glEnableClientState(GL_VERTEX_ARRAY); // Why don't they work like glEnable(A|B) did before? or am I dumb? // glEnableClientState(GL_TEXTURE_COORD_ARRAY); #endif glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); createShapes(); #ifdef USE_SDL int running = 1; timemark=SDL_GetTicks(); while(running) { if ( SDL_PollEvent(&event) > 0 ) { // SDL_WaitEvent(&event); switch(event.type) { case SDL_KEYDOWN: switch(event.key.keysym.sym) { #ifdef __ANDROID__ case SDLK_AC_SEARCH: #endif case SDLK_F1: performanceReport(); break; #ifndef __ANDROID__ case SDLK_ESCAPE: running = 0; break; #else case SDLK_AC_BACK: running = 0; break; #endif case SDLK_LEFT: Camera.beta += M_PI / 36; camera(); break; case SDLK_RIGHT: Camera.beta -= M_PI / 36; camera(); break; case SDLK_UP: Camera.alpha += M_PI / 36; camera(); break; case SDLK_DOWN: Camera.alpha -= M_PI / 36; camera(); break; default: keyb(event.key.keysym.scancode); break; } break; case SDL_MOUSEWHEEL: Camera.dist*= (event.wheel.y < 0)? 1.1 : 0.9; camera(); break; case SDL_MOUSEMOTION: if(event.motion.state == 1) motion(event.motion.xrel, event.motion.yrel); break; // Note, the first frame flickers, TODO workaround // TODO: track the real sequence of WINDOWEVENT_ENTER and WINDOWEVENT_SIZE_CHANGED events case SDL_WINDOWEVENT: if (event.window.event==SDL_WINDOWEVENT_SIZE_CHANGED) size(event.window.data1, event.window.data2); camera(); break; // handle touch events here case SDL_QUIT: running = 0; break; } } draw(); } performanceReport(); SDL_GL_MakeCurrent(NULL, NULL); SDL_GL_DeleteContext(glcontext); SDL_DestroyWindow(window); SDL_Quit(); #else glutReshapeFunc(size); glutDisplayFunc(draw); glutIdleFunc(draw); glutMouseFunc(mouse); glutMotionFunc(motion); glutSpecialFunc(keybs); glutKeyboardFunc(keyb); glutTimerFunc(TIMER_RESOLUTION,timer,0); glutMainLoop(); #endif return 0; }
void Shader::BindAttributeLocation(unsigned int id, const std::string &name) { glBindAttribLocation(m_ShaderObject, id, name.c_str()); }
void Render::gameLoopShading(){ glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE); GLint uniform_location; glUseProgram(*shader->GetShaderProgram()); uniform_location = glGetUniformLocationARB(*shader->GetShaderProgram(), "tex"); glUniform1iARB(uniform_location, 0); glBindAttribLocation(*shader->GetShaderProgram(), VBO_VERTEX, "vertex"); glBindAttribLocation(*shader->GetShaderProgram(), VBO_COLOR, "color"); glBindAttribLocation(*shader->GetShaderProgram(), VBO_TEXCORD, "texCoord"); glUniform1i(numLigth, particleVBO->getCenterSize()); glUniform1i(platformNumLitLigth, platformVBO->getCenterLitSize()); glUniform1i(platformNumUnlitLigth, platformVBO->getCenterUnlitSize()); glUniform2f(glGetUniformLocation(*shader->GetShaderProgram(), "MainCharLightpos"), mainCharParticleVBO->getMainCenter().x, mainCharParticleVBO->getMainCenter().y); //glUniform2f(glGetUniformLocation(*shader->GetShaderProgram(), "mousePointerLigthpos"), mousePointer.x, mousePointer.y); glUniform2fv(glGetUniformLocation(*shader->GetShaderProgram(), "lightpos"), particleVBO->getCenterSize(), particleVBO->getCenter()); glUniform2fv(glGetUniformLocation(*shader->GetShaderProgram(), "litPlatformLightpos"), platformVBO->getCenterLitSize(), platformVBO->getCenterLit()); glUniform2fv(glGetUniformLocation(*shader->GetShaderProgram(), "unlitPlatformLightpos"), platformVBO->getCenterUnlitSize(), platformVBO->getCenterUnlit()); //glUniform2f(glGetUniformLocation(*shader->GetShaderProgram(), "lightpos"), mainCharParticleVBO->getCenter().x, mainCharParticleVBO->getCenter().y); glUniform3f(litLightColor, 55, 208, 81); glUniform3f(unlitLightColor, 255, 0, 0); glUniform1f(mUniformscreenHeight, screenHeight); glUniform3f(lightAttenuation, 1, 1, 1); glUniform1f(radius, 5); glUniform3f(glGetUniformLocation(*shader->GetShaderProgram(), "particleLightColor"), 255-ledR, 255-ledG, 255-ledB); //if (i == 0) backgroundVBO->draw(true); //else glUseProgram(0); glDisable(GL_BLEND); glEnable(GL_BLEND); glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glUseProgram(*platformShader->GetShaderProgram()); uniform_location = glGetUniformLocationARB(*platformShader->GetShaderProgram(), "plattex"); glUniform1iARB(uniform_location, 0); glBindAttribLocation(*platformShader->GetShaderProgram(), VBO_VERTEX, "vertex"); glBindAttribLocation(*platformShader->GetShaderProgram(), VBO_COLOR, "color"); glBindAttribLocation(*platformShader->GetShaderProgram(), VBO_TEXCORD, "texCoord"); glUniform1i(glGetUniformLocation(*platformShader->GetShaderProgram(), "particleNumLigth"), particleVBO->getCenterSize()); glUniform1i(glGetUniformLocation(*platformShader->GetShaderProgram(), "platformNumLitLigth"), platformVBO->getCenterLitSize()); glUniform1i(glGetUniformLocation(*platformShader->GetShaderProgram(), "platformNumUnlitLigth"), platformVBO->getCenterUnlitSize()); glUniform2f(glGetUniformLocation(*platformShader->GetShaderProgram(), "MainCharLightpos"), mainCharParticleVBO->getMainCenter().x, mainCharParticleVBO->getMainCenter().y); //glUniform2f(glGetUniformLocation(*shader->GetShaderProgram(), "mousePointerLigthpos"), mousePointer.x, mousePointer.y); glUniform2fv(glGetUniformLocation(*platformShader->GetShaderProgram(), "lightpos"), particleVBO->getCenterSize(), particleVBO->getCenter()); glUniform2fv(glGetUniformLocation(*platformShader->GetShaderProgram(), "litPlatformLightpos"), platformVBO->getCenterLitSize(), platformVBO->getCenterLit()); glUniform2fv(glGetUniformLocation(*platformShader->GetShaderProgram(), "unlitPlatformLightpos"), platformVBO->getCenterUnlitSize(), platformVBO->getCenterUnlit()); //glUniform2f(glGetUniformLocation(*shader->GetShaderProgram(), "lightpos"), mainCharParticleVBO->getCenter().x, mainCharParticleVBO->getCenter().y); glUniform3f(glGetUniformLocation(*platformShader->GetShaderProgram(), "litLightColor"), 55, 208, 81); glUniform3f(glGetUniformLocation(*platformShader->GetShaderProgram(), "unlitLightColor"), 255, 0, 0); glUniform1f(glGetUniformLocation(*platformShader->GetShaderProgram(), "screenHeight"), screenHeight); glUniform3f(glGetUniformLocation(*platformShader->GetShaderProgram(), "lightAttenuation"), 1, 1, 1); glUniform1f(glGetUniformLocation(*platformShader->GetShaderProgram(), "radius"), 50); platformVBO->drawTexture(); glUseProgram(0); glDisable(GL_BLEND); }
void glse_glBindAttribLocation() { GLSE_SET_COMMAND_PTR(c, glBindAttribLocation); glBindAttribLocation (c->program, c->index, c->name); check_gl_err(); }
/* Inits the shader program for this object */ void GLSphere::initShader(void) { // Vertex shader source code. This draws the vertices in our window. We have 3 vertices since we're drawing an triangle. // Each vertex is represented by a vector of size 4 (x, y, z, w) coordinates. // static const string vertex_code = vs_string_CoordSystem; static const char * vs_source = vs_string_GLSphere_410.c_str(); // Fragment shader source code. This determines the colors in the fragment generated in the shader pipeline. In this case, it colors the inside of our triangle specified by our vertex shader. // static const string fragment_code = fs_string_CoordSystem; static const char * fs_source = fs_string_GLSphere_410.c_str(); // This next section we'll generate the OpenGL program and attach the shaders to it so that we can render our triangle. _program = glCreateProgram(); // We create a shader with our fragment shader source code and compile it. GLuint fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs, 1, &fs_source, NULL); glCompileShader(fs); CheckShader(fs, GL_FRAGMENT_SHADER); // We create a shader with our vertex shader source code and compile it. GLuint vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs, 1, &vs_source, NULL); glCompileShader(vs); CheckShader(vs, GL_VERTEX_SHADER); // We'll attach our two compiled shaders to the OpenGL program. glAttachShader(_program, vs); glAttachShader(_program, fs); glLinkProgram(_program); glUseProgram(_program); _modelMatrix = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f)); // Create our model matrix which will halve the size of our model int projectionMatrixLocation = glGetUniformLocation(_program, "projectionMatrixBox"); // Get the location of our projection matrix in the shader _viewMatrixLocation = glGetUniformLocation(_program, "viewMatrixBox"); // Get the location of our view matrix in the shader _modelMatrixLocation = glGetUniformLocation(_program, "modelMatrixBox"); // Get the location of our model matrix in the shader _inverseViewMatrixLocation = glGetUniformLocation(_program, "inverseViewMatrix"); _light_source0._lightPosIdx = glGetUniformLocation(_program, "light_position"); glUniformMatrix4fv(projectionMatrixLocation, 1, GL_FALSE, &projectionMatrix()[0][0] ); // Send our projection matrix to the shader glUniformMatrix4fv(_viewMatrixLocation, 1, GL_FALSE, &viewMatrix()[0][0]); // Send our view matrix to the shader glUniformMatrix4fv(_modelMatrixLocation, 1, GL_FALSE, &_modelMatrix[0][0]); // Send our model matrix to the shader glUniformMatrix4fv(_inverseViewMatrixLocation, 1, GL_FALSE, &invRotatedViewMatrix()[0][0]); /////////////////////////////////////////////////////////////////////////////////////////////// // Material _material._diffuse_material = glm::vec3(1.0, 0.5, 0.0); _material._ambient_material = glm::vec3(1.0, 0.5, 0.0); _material._specular_material = glm::vec3(1.0, 1.0, 1.0); _material._shininess = 12.0; _material._ambientColorPos = glGetUniformLocation(_program, "ambient_color"); _material._diffuseColorPos = glGetUniformLocation(_program, "diffuse_color"); _material._specularColorPos = glGetUniformLocation(_program, "specular_color"); _material._shininessIdx = glGetUniformLocation(_program, "shininess"); // Send the material to your shader program glUniform3fv(_material._ambientColorPos, 1, &_material._ambient_material[0] ); glUniform3fv(_material._diffuseColorPos, 1, &_material._diffuse_material[0]); glUniform3fv(_material._specularColorPos, 1, &_material._specular_material[0]); glUniform1f(_material._shininessIdx, _material._shininess); /////////////////////////////////////////////////////////////////////////////////////////////// // Light // define the position of the light and send the light position to your shader program _light_source0._lightPos = glm::vec4(50.0,50.0,0.0,1.0); _light_source0._ambient_intensity = 0.5; _light_source0._specular_intensity = 1.0; _light_source0._diffuse_intensity = 1.0; _light_source0._ambientIdx = glGetUniformLocation(_program, "ambient_intensity"); _light_source0._diffuseIdx = glGetUniformLocation(_program, "diffuse_intensity"); _light_source0._specularIdx = glGetUniformLocation(_program, "specular_intensity"); // Send the light information to your shader program glUniform1f(_light_source0._ambientIdx, _light_source0._ambient_intensity ); glUniform1f(_light_source0._diffuseIdx, _light_source0._diffuse_intensity); glUniform1f(_light_source0._specularIdx, _light_source0._specular_intensity); glUniform4fv(_light_source0._lightPosIdx, 1, &_light_source0._lightPos[0]); /////////////////////////////////////////////////////////////////////////////////////////////// // Vertex information / names // bind the to the shader program glBindAttribLocation(_program, 0, "in_Position"); glBindAttribLocation(_program, 1, "in_Normal"); glBindAttribLocation(_program, 2, "in_Color"); glUseProgram(0); }
void CMyOGLApp::Init() { // törlési szín legyen kékes glClearColor(0.125f, 0.25f, 0.5f, 1.0f); glEnable(GL_CULL_FACE); // kapcsoljuk be a hatrafele nezo lapok eldobasat glEnable(GL_DEPTH_TEST); // mélységi teszt bekapcsolása (takarás) glCullFace(GL_BACK); // GL_BACK: a kamerától "elfelé" nézõ lapok, GL_FRONT: a kamera felé nézõ lapok // // geometria letrehozasa // Vertex vert[] = { // x, y, z R, G, B {glm::vec3(-1, -1, 0), glm::vec3(1, 0, 0)}, {glm::vec3( 1, -1, 0), glm::vec3(0, 1, 0)}, {glm::vec3(-1, 1, 0), glm::vec3(0, 0, 1)}, {glm::vec3( 1, 1, 0), glm::vec3(1, 1, 1)}, }; // indexpuffer adatai GLushort indices[]= { // 1. háromszög 0,1,2, // 2. háromszög 2,1,3, }; // 1 db VAO foglalasa glGenVertexArrays(1, &m_vaoID); // a frissen generált VAO beallitasa aktívnak glBindVertexArray(m_vaoID); // hozzunk létre egy új VBO erõforrás nevet glGenBuffers(1, &m_vboID); glBindBuffer(GL_ARRAY_BUFFER, m_vboID); // tegyük "aktívvá" a létrehozott VBO-t // töltsük fel adatokkal az aktív VBO-t glBufferData( GL_ARRAY_BUFFER, // az aktív VBO-ba töltsünk adatokat sizeof(vert), // ennyi bájt nagyságban vert, // errõl a rendszermemóriabeli címrõl olvasva GL_STATIC_DRAW); // úgy, hogy a VBO-nkba nem tervezünk ezután írni és minden kirajzoláskor felhasnzáljuk a benne lévõ adatokat // VAO-ban jegyezzük fel, hogy a VBO-ban az elsõ 3 float sizeof(Vertex)-enként lesz az elsõ attribútum (pozíció) glEnableVertexAttribArray(0); // ez lesz majd a pozíció glVertexAttribPointer( 0, // a VB-ben található adatok közül a 0. "indexû" attribútumait állítjuk be 3, // komponens szam GL_FLOAT, // adatok tipusa GL_FALSE, // normalizalt legyen-e sizeof(Vertex), // stride (0=egymas utan) 0 // a 0. indexû attribútum hol kezdõdik a sizeof(Vertex)-nyi területen belül ); // a második attribútumhoz pedig a VBO-ban sizeof(Vertex) ugrás után sizeof(glm::vec3)-nyit menve újabb 3 float adatot találunk (szín) glEnableVertexAttribArray(1); // ez lesz majd a szín glVertexAttribPointer( 1, 3, GL_FLOAT, GL_FALSE, sizeof(Vertex), (void*)(sizeof(glm::vec3)) ); // index puffer létrehozása glGenBuffers(1, &m_ibID); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_ibID); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); glBindVertexArray(0); // feltöltüttük a VAO-t, kapcsoljuk le glBindBuffer(GL_ARRAY_BUFFER, 0); // feltöltöttük a VBO-t is, ezt is vegyük le glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); // feltöltöttük a VBO-t is, ezt is vegyük le // // shaderek betöltése // GLuint vs_ID = loadShader(GL_VERTEX_SHADER, "myVert.vert"); GLuint fs_ID = loadShader(GL_FRAGMENT_SHADER, "myFrag.frag"); // a shadereket tároló program létrehozása m_programID = glCreateProgram(); // adjuk hozzá a programhoz a shadereket glAttachShader(m_programID, vs_ID); glAttachShader(m_programID, fs_ID); // VAO-beli attribútumok hozzárendelése a shader változókhoz // FONTOS: linkelés elõtt kell ezt megtenni! glBindAttribLocation( m_programID, // shader azonosítója, amibõl egy változóhoz szeretnénk hozzárendelést csinálni 0, // a VAO-beli azonosító index "vs_in_pos"); // a shader-beli változónév glBindAttribLocation( m_programID, 1, "vs_in_col"); // illesszük össze a shadereket (kimenõ-bemenõ változók összerendelése stb.) glLinkProgram(m_programID); // linkeles ellenorzese GLint infoLogLength = 0, result = 0; glGetProgramiv(m_programID, GL_LINK_STATUS, &result); glGetProgramiv(m_programID, GL_INFO_LOG_LENGTH, &infoLogLength); if ( GL_FALSE == result ) { std::vector<char> ProgramErrorMessage( infoLogLength ); glGetProgramInfoLog(m_programID, infoLogLength, NULL, &ProgramErrorMessage[0]); fprintf(stdout, "%s\n", &ProgramErrorMessage[0]); char* aSzoveg = new char[ProgramErrorMessage.size()]; memcpy( aSzoveg, &ProgramErrorMessage[0], ProgramErrorMessage.size()); MessageBoxA(0, aSzoveg, "Sáder Huba panasza", 0); delete aSzoveg; } // mar nincs ezekre szukseg glDeleteShader( vs_ID ); glDeleteShader( fs_ID ); // // egyéb inicializálás // // vetítési mátrix létrehozása m_matProj = glm::perspective( 45.0f, m_client_width/(float)m_client_height, 1.0f, 1000.0f ); // shader-beli transzformációs mátrixok címének lekérdezése m_loc_world = glGetUniformLocation( m_programID, "world"); m_loc_view = glGetUniformLocation( m_programID, "view" ); m_loc_proj = glGetUniformLocation( m_programID, "proj" ); }
void GraphicsContext3D::bindAttribLocation(Platform3DObject program, GC3Duint index, const String& name) { ASSERT(program); makeContextCurrent(); glBindAttribLocation(program, index, name.utf8().data()); }
Renderer::Renderer () { //Everybody does this glClearColor(0, 0, 0, 1); glEnable(GL_DEPTH_TEST); glClearDepth(1.0); glDepthFunc(GL_LEQUAL); //here is stuff for setting up our shaders const char* fragFile = "diffuseFrag.frag"; const char* vertFile = "diffuseVert.vert"; vertexShader = glCreateShader(GL_VERTEX_SHADER); fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); shaderProgram = glCreateProgram(); //load up the source, compile and link the shader program const char* vertSource = textFileRead(vertFile); const char* fragSource = textFileRead(fragFile); glShaderSource(vertexShader, 1, &vertSource, 0); glShaderSource(fragmentShader, 1, &fragSource, 0); glCompileShader(vertexShader); glCompileShader(fragmentShader); //For your convenience, i decided to throw in some compiler/linker output helper functions //from CIS 565 GLint compiled; glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compiled); if (!compiled) { printShaderInfoLog(vertexShader); } glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compiled); if (!compiled) { printShaderInfoLog(fragmentShader); } //set the attribute locations for our shaders glBindAttribLocation(shaderProgram, positionLocation, "vs_position"); glBindAttribLocation(shaderProgram, normalLocation, "vs_normal"); glBindAttribLocation(shaderProgram, colorLocation, "vs_color"); //finish shader setup glAttachShader(shaderProgram, vertexShader); glAttachShader(shaderProgram, fragmentShader); glLinkProgram(shaderProgram); //check for linking success GLint linked; glGetProgramiv(shaderProgram,GL_LINK_STATUS, &linked); if (!linked) { printLinkInfoLog(shaderProgram); } //Get the uniform locations for our shaders, unfortunately they can not be set by us, we have //to ask OpenGL for them u_modelMatrixLocation = glGetUniformLocation(shaderProgram, "u_modelMatrix"); u_projMatrixLocation = glGetUniformLocation(shaderProgram, "u_projMatrix"); //Always remember that it doesn't do much good if you don't have OpenGL actually use the shaders glUseProgram(shaderProgram); }
void program_bind_attrib_location(void *ptr) { PROGRAM *program = (PROGRAM *) ptr; glBindAttribLocation(program->pid, 0, "POSITION"); glBindAttribLocation(program->pid, 2, "TEXCOORD0"); }
COGL_FragmentProgramCombiner::COGL_FragmentProgramCombiner(CRender *pRender) : COGLColorCombiner4(pRender) { delete m_pDecodedMux; m_pDecodedMux = new DecodedMuxForPixelShader; m_bFragmentProgramIsSupported = true; m_AlphaRef = 0.0f; //Create shaders for fill and copy GLint success; GLuint vs,fs; copyProgram = glCreateProgram(); vs = glCreateShader(GL_VERTEX_SHADER); glShaderSource(vs,1,&vertexShader,NULL); glCompileShader(vs); glGetShaderiv(vs,GL_COMPILE_STATUS,&success); if(!success) { char log[1024]; glGetShaderInfoLog(vs,1024,NULL,log); printf("%s\n",log); } fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs,1,&fragmentCopy,NULL); glCompileShader(fs); glGetShaderiv(fs,GL_COMPILE_STATUS,&success); if(!success) { char log[1024]; glGetShaderInfoLog(fs,1024,NULL,log); printf("%s\n",log); } glAttachShader(copyProgram,vs); glAttachShader(copyProgram,fs); glBindAttribLocation(copyProgram,VS_TEXCOORD0,"aTexCoord0"); OPENGL_CHECK_ERRORS; glBindAttribLocation(copyProgram,VS_POSITION,"aPosition"); OPENGL_CHECK_ERRORS; glLinkProgram(copyProgram); copyAlphaLocation = glGetUniformLocation(copyProgram,"AlphaRef"); glGetProgramiv(copyProgram,GL_LINK_STATUS,&success); if(!success) { char log[1024]; glGetProgramInfoLog(copyProgram,1024,NULL,log); printf("%s\n",log); } glDeleteShader(fs); //Fill shader fs = glCreateShader(GL_FRAGMENT_SHADER); glShaderSource(fs,1,&fragmentFill,NULL); glCompileShader(fs); glGetShaderiv(fs,GL_COMPILE_STATUS,&success); if(!success) { char log[1024]; glGetShaderInfoLog(fs,1024,NULL,log); printf("%s\n",log); } fillProgram = glCreateProgram(); glAttachShader(fillProgram,vs); glAttachShader(fillProgram,fs); glBindAttribLocation(fillProgram,VS_POSITION,"aPosition"); OPENGL_CHECK_ERRORS; glLinkProgram(fillProgram); fillColorLocation = glGetUniformLocation(fillProgram,"uColor"); glDeleteShader(fs); glDeleteShader(vs); }
static GLboolean render_and_check_textures(GLenum internal_format) { GLuint rgba_fb; GLuint other_fb; float rgba_image[4 * 64 * 64]; float other_image[4 * 64 * 64]; GLboolean has_green; GLuint vs; GLuint fs; GLint scale_loc; GLint bias_loc; float scale; float bias; piglit_require_extension("GL_EXT_framebuffer_object"); piglit_require_extension("GL_ARB_texture_rg"); has_green = GL_FALSE; scale = 1.0; bias = 0.0; switch (internal_format) { case GL_RG: case GL_RG8: case GL_RG16: has_green = GL_TRUE; /* FALLTHROUGH */ case GL_RED: case GL_R8: case GL_R16: break; case GL_RG16F: has_green = GL_TRUE; /* FALLTHROUGH */ case GL_R16F: piglit_require_extension("GL_ARB_half_float_pixel"); /* FALLTHROUGH */ case GL_RG32F: has_green = GL_TRUE; /* FALLTHROUGH */ case GL_R32F: scale = 511.0; piglit_require_extension("GL_ARB_texture_float"); break; case GL_RG_INTEGER: case GL_RG8I: case GL_RG16I: case GL_RG32I: has_green = GL_TRUE; /* FALLTHROUGH */ case GL_R8I: case GL_R16I: case GL_R32I: bias = -100.0; scale = 511.0; piglit_require_extension("GL_EXT_texture_integer"); break; case GL_RG8UI: case GL_RG16UI: case GL_RG32UI: has_green = GL_TRUE; /* FALLTHROUGH */ case GL_R16UI: case GL_R32UI: scale = 511.0; piglit_require_extension("GL_EXT_texture_integer"); break; case GL_RG_SNORM: case GL_RG8_SNORM: case GL_RG16_SNORM: has_green = GL_TRUE; /* FALLTHROUGH */ case GL_RED_SNORM: case GL_R8_SNORM: case GL_R16_SNORM: scale = 0.5; bias = -0.5; piglit_require_extension("GL_EXT_texture_snorm"); break; default: fprintf(stderr, "invalid format 0x%04x\n", internal_format); piglit_report_result(PIGLIT_FAIL); break; } glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), positions); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, 4 * sizeof(GLfloat), colors); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); vs = piglit_compile_shader_text(GL_VERTEX_SHADER, vert_code); fs = piglit_compile_shader_text(GL_FRAGMENT_SHADER, frag_code); fbo_program = piglit_link_simple_program(vs, fs); glBindAttribLocation(fbo_program, 0, "position"); glBindAttribLocation(fbo_program, 1, "color"); glLinkProgram(fbo_program); if (!piglit_link_check_status(fbo_program)) piglit_report_result(PIGLIT_FAIL); scale_loc = glGetUniformLocation(fbo_program, "scale"); if (scale_loc < 0) { fprintf(stderr, "couldn't get uniform location for \"scale\"\n"); piglit_report_result(PIGLIT_FAIL); } bias_loc = glGetUniformLocation(fbo_program, "bias"); if (bias_loc < 0) { fprintf(stderr, "couldn't get uniform location for \"bias\"\n"); piglit_report_result(PIGLIT_FAIL); } glUseProgram(fbo_program); glUniform1f(scale_loc, scale); glUniform1f(bias_loc, bias); /* Draw the reference image to the RGBA texture. */ rgba_fb = create_fbo(64, 64, GL_RGBA); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, rgba_fb); glViewport(0, 0, 64, 64); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, (GLint *) &rgba_tex); glBindTexture(GL_TEXTURE_2D, rgba_tex); glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, rgba_image); /* Draw the comparison image to the other texture. */ other_fb = create_fbo(64, 64, internal_format); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, other_fb); glViewport(0, 0, 64, 64); glDrawArrays(GL_TRIANGLE_FAN, 0, 4); glGetFramebufferAttachmentParameterivEXT(GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_FRAMEBUFFER_ATTACHMENT_OBJECT_NAME_EXT, (GLint *) &other_tex); glBindTexture(GL_TEXTURE_2D, other_tex); glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_FLOAT, other_image); glUseProgram(0); glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo); glViewport(0, 0, piglit_width, piglit_height); return compare_texture(rgba_image, other_image, internal_format, GL_RGBA, 64 * 64, has_green); }
int COGL_FragmentProgramCombiner::ParseDecodedMux() { if( !m_bFragmentProgramIsSupported ) return COGLColorCombiner4::ParseDecodedMux(); OGLShaderCombinerSaveType res; GLint success; if(vertexProgram == 9999) { vertexProgram = res.vertexShaderID = glCreateShader(GL_VERTEX_SHADER); glShaderSource(res.vertexShaderID, 1, &vertexShader,NULL); OPENGL_CHECK_ERRORS; glCompileShader(res.vertexShaderID); OPENGL_CHECK_ERRORS; } else { res.vertexShaderID = vertexProgram; } //Create 2 shaders, with and without alphatest GenerateProgramStr(); for(int alphaTest = 0;alphaTest < 2;alphaTest++) { res.fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER); char* tmpShader = (char*)malloc(sizeof(char) * 4096); strcpy(tmpShader,"#version " GLSL_VERSION "\n"); if(alphaTest == 1) { strcat(tmpShader,"#define ALPHA_TEST\n"); } res.alphaTest = alphaTest == 1; strcat(tmpShader,oglNewFP); glShaderSource(res.fragmentShaderID, 1,(const char**) &tmpShader,NULL); free(tmpShader); OPENGL_CHECK_ERRORS; glCompileShader(res.fragmentShaderID); glGetShaderiv(res.fragmentShaderID, GL_COMPILE_STATUS, &success); if (!success) { char Log[1024]; GLint nLength; glGetShaderInfoLog(res.fragmentShaderID, 1024, &nLength, Log); printf("Error compiling shader!\n %s",oglNewFP); printf(Log); } res.programID = glCreateProgram(); glAttachShader(res.programID,res.vertexShaderID); glAttachShader(res.programID,res.fragmentShaderID); //Bind Attributes glBindAttribLocation(res.programID,VS_COLOR,"aColor"); OPENGL_CHECK_ERRORS; glBindAttribLocation(res.programID,VS_TEXCOORD0,"aTexCoord0"); OPENGL_CHECK_ERRORS; glBindAttribLocation(res.programID,VS_TEXCOORD1,"aTexCoord1"); OPENGL_CHECK_ERRORS; glBindAttribLocation(res.programID,VS_POSITION,"aPosition"); OPENGL_CHECK_ERRORS; glLinkProgram(res.programID); OPENGL_CHECK_ERRORS; glGetProgramiv(res.programID, GL_LINK_STATUS, &success); if (!success) { char Log[1024]; GLint nLength; glGetShaderInfoLog(res.fragmentShaderID, 1024, &nLength, Log); printf("Error linking program!\n"); printf("%s\n",Log); } glUseProgram(res.programID); OPENGL_CHECK_ERRORS; //Bind texture samplers GLint tex0 = glGetUniformLocation(res.programID,"uTex0"); GLint tex1 = glGetUniformLocation(res.programID,"uTex1"); if(tex0 != -1) glUniform1i(tex0,0); if(tex1 != -1) glUniform1i(tex1,1); //Bind Uniforms res.PrimColorLocation = glGetUniformLocation(res.programID,"PrimColor"); OPENGL_CHECK_ERRORS; res.EnvColorLocation = glGetUniformLocation(res.programID,"EnvColor"); OPENGL_CHECK_ERRORS; res.PrimFracLocation = glGetUniformLocation(res.programID,"PrimFrac"); OPENGL_CHECK_ERRORS; res.EnvFracLocation = glGetUniformLocation(res.programID,"EnvFrac"); OPENGL_CHECK_ERRORS; res.AlphaRefLocation = glGetUniformLocation(res.programID,"AlphaRef"); OPENGL_CHECK_ERRORS; res.FogColorLocation = glGetUniformLocation(res.programID,"FogColor"); OPENGL_CHECK_ERRORS; res.FogMinMaxLocation = glGetUniformLocation(res.programID,"FogMinMax"); OPENGL_CHECK_ERRORS; res.dwMux0 = m_pDecodedMux->m_dwMux0; res.dwMux1 = m_pDecodedMux->m_dwMux1; res.fogIsUsed = gRDP.bFogEnableInBlender && gRSP.bFogEnabled; m_vCompiledShaders.push_back(res); } m_lastIndex = m_vCompiledShaders.size()-2; return m_lastIndex; }
void GLProgram::bindAttribLocation(const std::string &attributeName, GLuint index) const { glBindAttribLocation(_program, index, attributeName.c_str()); }
void ShaderProgram::BindAttribLocation(const int location, const std::string& name) { glBindAttribLocation(_programHandle, location, name.c_str()); }
void MD5::prepModel(void) { // Prepare Buffer Objects int offset = 0; size_t vboSize = sizeof(glm::vec2) + sizeof(glm::vec4) + sizeof(glm::mat4); glGenBuffers(1, &vbo); glBindBuffer(GL_ARRAY_BUFFER, vbo); glBufferData(GL_ARRAY_BUFFER, vboSize*numVerts, NULL, GL_STATIC_DRAW); // Generate Vertex Buffer Object for(int i = 0; i < numMeshes; ++i) { for(int j = 0; j < meshList[i].getNumVert(); ++j) { Mesh::Vertex v = meshList[i].getVerts(j); // Add UV coords glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::vec2), glm::value_ptr(v.uv)); offset += sizeof(glm::vec2); // Add vertex weights glm::vec4 bias(0.0f); glm::mat4 pos(0.0f); int index = v.weightIndex; for(int k = 0; k < v.weightElem; ++k) { Mesh::Weight w = meshList[i].getWeight(index+k); bias[k] = w.value; glm::vec4 posi(0, 0, 0, -1); posi.x = w.position.x; posi.y = w.position.y; posi.z = w.position.z; posi.w = w.jointIndex; pos[k] = posi; } glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::vec4), glm::value_ptr(bias)); offset += sizeof(glm::vec4); glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::mat4), glm::value_ptr(pos)); offset += sizeof(glm::mat4) + (sizeof(float)*2); } } offset = 0; // Generate Index Buffer Object glGenBuffers(1, &ibo); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLushort)*3*numTris, NULL, GL_STATIC_DRAW); for(int i = 0; i < numMeshes; ++i) { for(int j = 0; j < meshList[i].getNumTri(); ++j) { Mesh::Triangle t = meshList[i].getTris(j); t.v1 += offset; t.v2 += offset; t.v3 += offset; glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, offset, sizeof(GLushort)*3, (GLvoid*)&t); } offset += meshList[i].getNumTri(); } GLuint uvLoc = 0; GLuint wBias = 1; GLuint wPos = 2; if(GLEW_ARB_uniform_buffer_object) { glBindAttribLocation(shaderProgram, 0, "uv"); glBindAttribLocation(shaderProgram, 1, "wBias"); glBindAttribLocation(shaderProgram, 2, "wPos"); } else { uvLoc = glGetAttribLocation(shaderProgram, "uv"); wBias = glGetAttribLocation(shaderProgram, "wBias"); wPos = glGetAttribLocation(shaderProgram, "wPos"); } // Generate and bind Vertex Array Object glGenVertexArrays(1, &vao); glBindVertexArray(vao); //Enable and link attributes glEnableVertexAttribArray(uvLoc); glEnableVertexAttribArray(wBias); glEnableVertexAttribArray(wPos); glEnableVertexAttribArray(wPos+1); glEnableVertexAttribArray(wPos+2); glEnableVertexAttribArray(wPos+3); glBindBuffer(GL_ARRAY_BUFFER, vbo); glVertexAttribPointer(uvLoc, 2, GL_FLOAT, GL_FALSE, vboSize, 0); glVertexAttribPointer(wBias, 4, GL_FLOAT, GL_FALSE, vboSize, (GLvoid*)(sizeof(glm::vec2))); for(int i = 0; i < 4; ++i) { glVertexAttribPointer(wPos+i, 4, GL_FLOAT, GL_FALSE, vboSize, (GLvoid*)(sizeof(glm::vec2)+sizeof(glm::vec4)+(sizeof(glm::vec4)*i))); } glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo); glBindVertexArray(0); }
Buttons::Buttons(const string& title, int w) :is_mouse_down(false) ,first_run(true) ,x(0) ,y(0) ,w(w) ,h(0) ,win_w(0) ,win_h(0) ,header_h(20) // header height (draggable area) ,border(1) ,state(BSTATE_NONE) ,is_changed(false) ,is_mouse_inside_header(false) ,is_mouse_inside_panel(false) ,triggered_drag(false) ,mdx(0) ,mdy(0) ,pmx(0) ,pmy(0) ,title(title) ,title_dx(0) ,num_panel_vertices(0) ,is_locked(false) ,static_text(NULL) ,dynamic_text(NULL) ,allocated_bytes(0) ,is_open(true) ,is_visible(true) ,name(title) ,col_hue(0.0f) ,col_sat(0.0f) ,col_bright(0.0f) ,col_alpha(0.0f) ,vao(0) { if(!shaders_initialized) { bmf = new BitmapFont(); gui_shader.create(BUTTONS_VS, BUTTONS_FS); glBindAttribLocation(gui_shader.prog_id, 0, "pos"); glBindAttribLocation(gui_shader.prog_id, 1, "col"); gui_shader.link(); gui_shader.enable(); gui_shader.addUniform("projection_matrix"); gui_shader.addAttribute("pos"); gui_shader.addAttribute("col"); shaders_initialized = true; } static_text = new Text(*bmf); dynamic_text = new Text(*bmf); glBindVertexArray(vao); glGenBuffers(1, &vbo); eglGetError(); glGenVertexArrays(1, &vao); glBindVertexArray(vao); glBindBuffer(GL_ARRAY_BUFFER, vbo); eglGetError(); glEnableVertexAttribArray(0); eglGetError(); glEnableVertexAttribArray(1); eglGetError(); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(ButtonVertex), (GLvoid*)0); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(ButtonVertex), (GLvoid*)8); glBindVertexArray(0); createOrtho(768, 1024); // top draggable handle BSET_COLOR(header_color_top, 0.07,0.07,0.07,1.0); BSET_COLOR(header_color_bottom, 0.1,0.1,0.1,0.8); BSET_COLOR(shadow_color, 0.1, 0.1, 0.1, 0.1); title_dx = static_text->add(x+5, y+2, title); name = createCleanName(title); ++num_created; id = num_created; }
void kzsGLSL::bindAttribLocation( GLuint location, const char* varname ) { glBindAttribLocation( shaderProgram, location, varname ); }
void processFn(struct fnargs* args) { switch (args->fn) { case glfnUNDEFINED: abort(); // bad glfn break; case glfnActiveTexture: glActiveTexture((GLenum)args->a0); break; case glfnAttachShader: glAttachShader((GLint)args->a0, (GLint)args->a1); break; case glfnBindAttribLocation: glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2); free((void*)args->a2); break; case glfnBindBuffer: glBindBuffer((GLenum)args->a0, (GLuint)args->a1); break; case glfnBindFramebuffer: glBindFramebuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindRenderbuffer: glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1); break; case glfnBindTexture: glBindTexture((GLenum)args->a0, (GLint)args->a1); break; case glfnBlendColor: glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnBlendEquation: glBlendEquation((GLenum)args->a0); break; case glfnBlendEquationSeparate: glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFunc: glBlendFunc((GLenum)args->a0, (GLenum)args->a1); break; case glfnBlendFuncSeparate: glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnBufferData: glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2, (GLenum)args->a3); break; case glfnBufferSubData: glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)args->a3); break; case glfnCheckFramebufferStatus: ret = glCheckFramebufferStatus((GLenum)args->a0); break; case glfnClear: glClear((GLenum)args->a0); break; case glfnClearColor: glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnClearDepthf: glClearDepthf(*(GLfloat*)&args->a0); break; case glfnClearStencil: glClearStencil((GLint)args->a0); break; case glfnColorMask: glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3); break; case glfnCompileShader: glCompileShader((GLint)args->a0); break; case glfnCompressedTexImage2D: glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)args->a7); break; case glfnCompressedTexSubImage2D: glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)args->a8); break; case glfnCopyTexImage2D: glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCopyTexSubImage2D: glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7); break; case glfnCreateProgram: ret = glCreateProgram(); break; case glfnCreateShader: ret = glCreateShader((GLenum)args->a0); break; case glfnCullFace: glCullFace((GLenum)args->a0); break; case glfnDeleteBuffer: glDeleteBuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteFramebuffer: glDeleteFramebuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteProgram: glDeleteProgram((GLint)args->a0); break; case glfnDeleteRenderbuffer: glDeleteRenderbuffers(1, (const GLuint*)(&args->a0)); break; case glfnDeleteShader: glDeleteShader((GLint)args->a0); break; case glfnDeleteTexture: glDeleteTextures(1, (const GLuint*)(&args->a0)); break; case glfnDepthFunc: glDepthFunc((GLenum)args->a0); break; case glfnDepthMask: glDepthMask((GLboolean)args->a0); break; case glfnDepthRangef: glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnDetachShader: glDetachShader((GLint)args->a0, (GLint)args->a1); break; case glfnDisable: glDisable((GLenum)args->a0); break; case glfnDisableVertexAttribArray: glDisableVertexAttribArray((GLint)args->a0); break; case glfnDrawArrays: glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnDrawElements: glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3); break; case glfnEnable: glEnable((GLenum)args->a0); break; case glfnEnableVertexAttribArray: glEnableVertexAttribArray((GLint)args->a0); break; case glfnFinish: glFinish(); break; case glfnFlush: glFlush(); break; case glfnFramebufferRenderbuffer: glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3); break; case glfnFramebufferTexture2D: glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnFrontFace: glFrontFace((GLenum)args->a0); break; case glfnGenBuffer: glGenBuffers(1, (GLuint*)&ret); break; case glfnGenFramebuffer: glGenFramebuffers(1, (GLuint*)&ret); break; case glfnGenRenderbuffer: glGenRenderbuffers(1, (GLuint*)&ret); break; case glfnGenTexture: glGenTextures(1, (GLuint*)&ret); break; case glfnGenerateMipmap: glGenerateMipmap((GLenum)args->a0); break; case glfnGetActiveAttrib: glGetActiveAttrib( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)args->a4, (GLenum*)args->a5, (GLchar*)args->a6); break; case glfnGetActiveUniform: glGetActiveUniform( (GLuint)args->a0, (GLuint)args->a1, (GLsizei)args->a2, NULL, (GLint*)args->a4, (GLenum*)args->a5, (GLchar*)args->a6); break; case glfnGetAttachedShaders: glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLuint*)args->a3); break; case glfnGetAttribLocation: ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1); free((void*)args->a1); break; case glfnGetBooleanv: glGetBooleanv((GLenum)args->a0, (GLboolean*)args->a1); break; case glfnGetBufferParameteri: glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetFloatv: glGetFloatv((GLenum)args->a0, (GLfloat*)args->a1); break; case glfnGetIntegerv: glGetIntegerv((GLenum)args->a0, (GLint*)args->a1); break; case glfnGetError: ret = glGetError(); break; case glfnGetFramebufferAttachmentParameteriv: glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret); break; case glfnGetProgramiv: glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetProgramInfoLog: glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetRenderbufferParameteriv: glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderiv: glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret); break; case glfnGetShaderInfoLog: glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetShaderPrecisionFormat: glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2, (GLint*)args->a3); break; case glfnGetShaderSource: glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)args->a2, (GLchar*)args->a3); break; case glfnGetString: ret = (uintptr_t)glGetString((GLenum)args->a0); break; case glfnGetTexParameterfv: glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnGetTexParameteriv: glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnGetUniformfv: glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)args->a2); break; case glfnGetUniformiv: glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)args->a2); break; case glfnGetUniformLocation: ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1); free((void*)args->a1); break; case glfnGetVertexAttribfv: glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnGetVertexAttribiv: glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnHint: glHint((GLenum)args->a0, (GLenum)args->a1); break; case glfnIsBuffer: ret = glIsBuffer((GLint)args->a0); break; case glfnIsEnabled: ret = glIsEnabled((GLenum)args->a0); break; case glfnIsFramebuffer: ret = glIsFramebuffer((GLint)args->a0); break; case glfnIsProgram: ret = glIsProgram((GLint)args->a0); break; case glfnIsRenderbuffer: ret = glIsRenderbuffer((GLint)args->a0); break; case glfnIsShader: ret = glIsShader((GLint)args->a0); break; case glfnIsTexture: ret = glIsTexture((GLint)args->a0); break; case glfnLineWidth: glLineWidth(*(GLfloat*)&args->a0); break; case glfnLinkProgram: glLinkProgram((GLint)args->a0); break; case glfnPixelStorei: glPixelStorei((GLenum)args->a0, (GLint)args->a1); break; case glfnPolygonOffset: glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1); break; case glfnReadPixels: glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)args->a6); break; case glfnReleaseShaderCompiler: glReleaseShaderCompiler(); break; case glfnRenderbufferStorage: glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnSampleCoverage: glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1); break; case glfnScissor: glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnShaderSource: #if defined(os_ios) || defined(os_osx) glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL); #else glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL); #endif free(*(void**)args->a2); free((void*)args->a2); break; case glfnStencilFunc: glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2); break; case glfnStencilFuncSeparate: glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3); break; case glfnStencilMask: glStencilMask((GLuint)args->a0); break; case glfnStencilMaskSeparate: glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1); break; case glfnStencilOp: glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2); break; case glfnStencilOpSeparate: glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3); break; case glfnTexImage2D: glTexImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLsizei)args->a3, (GLsizei)args->a4, 0, // border (GLenum)args->a5, (GLenum)args->a6, (const GLvoid*)args->a7); break; case glfnTexSubImage2D: glTexSubImage2D( (GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLsizei)args->a4, (GLsizei)args->a5, (GLenum)args->a6, (GLenum)args->a7, (const GLvoid*)args->a8); break; case glfnTexParameterf: glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2); break; case glfnTexParameterfv: glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)args->a2); break; case glfnTexParameteri: glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2); break; case glfnTexParameteriv: glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)args->a2); break; case glfnUniform1f: glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnUniform1fv: glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform1i: glUniform1i((GLint)args->a0, (GLint)args->a1); break; case glfnUniform1iv: glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform2f: glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnUniform2fv: glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform2i: glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2); break; case glfnUniform2iv: glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform3f: glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnUniform3fv: glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform3i: glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; case glfnUniform3iv: glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform4f: glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnUniform4fv: glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniform4i: glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4); break; case glfnUniform4iv: glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)args->a2); break; case glfnUniformMatrix2fv: glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUniformMatrix3fv: glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUniformMatrix4fv: glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)args->a2); break; case glfnUseProgram: glUseProgram((GLint)args->a0); break; case glfnValidateProgram: glValidateProgram((GLint)args->a0); break; case glfnVertexAttrib1f: glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1); break; case glfnVertexAttrib1fv: glVertexAttrib1fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib2f: glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2); break; case glfnVertexAttrib2fv: glVertexAttrib2fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib3f: glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3); break; case glfnVertexAttrib3fv: glVertexAttrib3fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttrib4f: glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4); break; case glfnVertexAttrib4fv: glVertexAttrib4fv((GLint)args->a0, (GLfloat*)args->a1); break; case glfnVertexAttribPointer: glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5); break; case glfnViewport: glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3); break; } }
GLuint DepalShaderCache::GetDepalettizeShader(GEBufferFormat pixelFormat) { u32 id = GenerateShaderID(pixelFormat); bool useGL3 = gl_extensions.GLES3 || gl_extensions.VersionGEThan(3, 3); auto shader = cache_.find(id); if (shader != cache_.end()) { return shader->second->program; } char *buffer = new char[2048]; if (useGL3) { GenerateDepalShader300(buffer, pixelFormat); } else { GenerateDepalShader100(buffer, pixelFormat); } GLuint fragShader = glCreateShader(GL_FRAGMENT_SHADER); const char *buf = buffer; glShaderSource(fragShader, 1, &buf, 0); glCompileShader(fragShader); CheckShaderCompileSuccess(fragShader, buffer); GLuint program = glCreateProgram(); glAttachShader(program, vertexShader_); glAttachShader(program, fragShader); glBindAttribLocation(program, 0, "a_position"); glBindAttribLocation(program, 1, "a_texcoord0"); if (useGL3) { // This call is not really necessary, I think. #ifndef MOBILE_DEVICE glBindFragDataLocation(program, 0, "fragColor0"); #endif } glLinkProgram(program); glUseProgram(program); GLint u_tex = glGetUniformLocation(program, "tex"); GLint u_pal = glGetUniformLocation(program, "pal"); glUniform1i(u_tex, 0); glUniform1i(u_pal, 1); GLint linkStatus = GL_FALSE; glGetProgramiv(program, GL_LINK_STATUS, &linkStatus); if (linkStatus != GL_TRUE) { GLint bufLength = 0; glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength); if (bufLength) { char* errorbuf = new char[bufLength]; glGetProgramInfoLog(program, bufLength, NULL, errorbuf); #ifdef SHADERLOG OutputDebugStringUTF8(buffer); OutputDebugStringUTF8(errorbuf); #endif ERROR_LOG(G3D, "Could not link program:\n %s \n\n %s", errorbuf, buf); delete[] errorbuf; // we're dead! } delete[] buffer; return 0; } DepalShader *depal = new DepalShader(); depal->program = program; depal->fragShader = fragShader; cache_[id] = depal; delete[] buffer; return depal->program; }
KRShader::KRShader(KRContext &context, char *szKey, std::string options, std::string vertShaderSource, const std::string fragShaderSource) : KRContextObject(context) { strcpy(m_szKey, szKey); m_iProgram = 0; GLuint vertexShader = 0, fragShader = 0; try { const GLchar *vertSource[2] = {options.c_str(), vertShaderSource.c_str()}; const GLchar *fragSource[2] = {options.c_str(), fragShaderSource.c_str()}; // Create shader program. GLDEBUG(m_iProgram = glCreateProgram()); // Create and compile vertex shader. GLDEBUG(vertexShader = glCreateShader(GL_VERTEX_SHADER)); GLDEBUG(glShaderSource(vertexShader, 2, vertSource, NULL)); GLDEBUG(glCompileShader(vertexShader)); // Report any compile issues to stderr GLint logLength; GLDEBUG(glGetShaderiv(vertexShader, GL_INFO_LOG_LENGTH, &logLength)); if (logLength > 0) { GLchar *log = (GLchar *)malloc(logLength + 1); assert(log != NULL); GLDEBUG(glGetShaderInfoLog(vertexShader, logLength, &logLength, log)); log[logLength] = '\0'; KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to compile vertex shader: %s\nShader compile log:\n%s", szKey, log); free(log); } // Create and compile vertex shader. GLDEBUG(fragShader = glCreateShader(GL_FRAGMENT_SHADER)); GLDEBUG(glShaderSource(fragShader, 2, fragSource, NULL)); GLDEBUG(glCompileShader(fragShader)); // Report any compile issues to stderr GLDEBUG(glGetShaderiv(fragShader, GL_INFO_LOG_LENGTH, &logLength)); if (logLength > 0) { GLchar *log = (GLchar *)malloc(logLength + 1); assert(log != NULL); GLDEBUG(glGetShaderInfoLog(fragShader, logLength, &logLength, log)); log[logLength] = '\0'; KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to compile fragment shader: %s\nShader compile log:\n%s", szKey, log); free(log); } // Attach vertex shader to program. GLDEBUG(glAttachShader(m_iProgram, vertexShader)); // Attach fragment shader to program. GLDEBUG(glAttachShader(m_iProgram, fragShader)); // Bind attribute locations. // This needs to be done prior to linking. GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_VERTEX, "vertex_position")); GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_NORMAL, "vertex_normal")); GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TANGENT, "vertex_tangent")); GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TEXUVA, "vertex_uv")); GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_TEXUVB, "vertex_lightmap_uv")); GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_BONEINDEXES, "bone_indexes")); GLDEBUG(glBindAttribLocation(m_iProgram, KRMesh::KRENGINE_ATTRIB_BONEWEIGHTS, "bone_weights")); // Link program. GLDEBUG(glLinkProgram(m_iProgram)); GLint link_success = GL_FALSE; GLDEBUG(glGetProgramiv(m_iProgram, GL_LINK_STATUS, &link_success)); if(link_success != GL_TRUE) { // Report any linking issues to stderr KRContext::Log(KRContext::LOG_LEVEL_ERROR, "KREngine - Failed to link shader program: %s", szKey); GLDEBUG(glGetProgramiv(m_iProgram, GL_INFO_LOG_LENGTH, &logLength)); if (logLength > 0) { GLchar *log = (GLchar *)malloc(logLength + 1); assert(log != NULL); GLDEBUG(glGetProgramInfoLog(m_iProgram, logLength, &logLength, log)); log[logLength] = '\0'; KRContext::Log(KRContext::LOG_LEVEL_ERROR, "Program link log:\n%s", log); free(log); } GLDEBUG(glDeleteProgram(m_iProgram)); m_iProgram = 0; } else { // Get uniform locations for(int i=0; i < KRENGINE_NUM_UNIFORMS; i++ ){ GLDEBUG(m_uniforms[i] = glGetUniformLocation(m_iProgram, KRENGINE_UNIFORM_NAMES[i])); m_uniform_value_index[i] = -1; } } } catch(...) { if(vertexShader) { GLDEBUG(glDeleteShader(vertexShader)); vertexShader = 0; } if(fragShader) { GLDEBUG(glDeleteShader(fragShader)); fragShader = 0; } if(m_iProgram) { GLDEBUG(glDeleteProgram(m_iProgram)); m_iProgram = 0; } } // Release vertex and fragment shaders. if (vertexShader) { GLDEBUG(glDeleteShader(vertexShader)); } if (fragShader) { GLDEBUG(glDeleteShader(fragShader)); } }