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);
}
Beispiel #2
0
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);
	}
}
Beispiel #3
0
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
}
Beispiel #4
0
	/*
	====================
	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()));
			}
		}
Beispiel #5
0
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;
}
Beispiel #6
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);

}
Beispiel #8
0
 void GLState::glsBindAttribLocation(const GLuint program, const GLuint index,
   const GLchar* name) {
   glBindAttribLocation(program, index, name);
   ERROR_CHECK;
 }
Beispiel #9
0
Datei: egl.c Projekt: cmotc/lima
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;
}
Beispiel #12
0
	void Shader::BindAttributeLocation(unsigned int id, const std::string &name)
	{
		glBindAttribLocation(m_ShaderObject, id, name.c_str());
	}
Beispiel #13
0
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);

}
Beispiel #14
0
void glse_glBindAttribLocation()
{
  GLSE_SET_COMMAND_PTR(c, glBindAttribLocation);
  glBindAttribLocation (c->program, c->index, c->name);
  check_gl_err();
}
Beispiel #15
0
/*
 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);
    
}
Beispiel #16
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());
}
Beispiel #18
0
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);
}
Beispiel #21
0
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;
}
Beispiel #23
0
void GLProgram::bindAttribLocation(const std::string &attributeName, GLuint index) const
{
    glBindAttribLocation(_program, index, attributeName.c_str());
}
Beispiel #24
0
	void ShaderProgram::BindAttribLocation(const int location, const std::string& name)
	{
		glBindAttribLocation(_programHandle, location, name.c_str());
	}
Beispiel #25
0
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;
}
Beispiel #27
0
void kzsGLSL::bindAttribLocation( GLuint location, const char* varname )
{
	glBindAttribLocation( shaderProgram, location, varname );
}
Beispiel #28
0
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;
	}
}
Beispiel #29
0
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;
}
Beispiel #30
0
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));
	}
}