C++ (Cpp) glGetObjectParameteriv Examples

Example #1

File: DefaultShader.cpp Project: DimondTheCat/xray

//
// defaultShader constructor
//
//  This constructor actually compiles and links the GLSL shader,
// so it must be called with a current context active.
////////////////////////////////////////////////////////////////////////////////
defaultShader::defaultShader() : m_program(0), m_fShader(0), m_vShader(0) {

  if (glShadingLanguageSupport) {
  m_program = glCreateProgramObject();
  m_vShader = glCreateShaderObject( GL_VERTEX_SHADER);
  m_fShader = glCreateShaderObject( GL_FRAGMENT_SHADER);
  glAttachObject( m_program, m_vShader);
  glAttachObject( m_program, m_fShader);

  const char *temp = vShader;
  glShaderSource( m_vShader, 1, &temp, NULL);
  temp = fShader;
  glShaderSource( m_fShader, 1, &temp, NULL);

  GLint success;
  glCompileShader( m_vShader);
  glGetObjectParameteriv( m_vShader, GL_COMPILE_STATUS, &success);
  if (! success) {
    //figure out why we didn't compile
    char log[256];
    //printf("Failed to compile vertex shader\n");
    glGetInfoLog( m_vShader, 256, NULL, log);
    //printf(" Infolog: %s\n", log);
  }

  glCompileShader( m_fShader);
  glGetObjectParameteriv( m_fShader, GL_COMPILE_STATUS, &success);
  if (! success) {
    //figure out why we didn't compile
    char log[256];
    //printf("Failed to compile fragment shader\n");
    glGetInfoLog( m_fShader, 256, NULL, log);
    //printf(" Infolog: %s\n", log);
  }

  glLinkProgram( m_program);
  glGetObjectParameteriv( m_program, GL_LINK_STATUS, &success);
  if (! success) {
    //figure out why we didn't link
    char log[256];
    //printf("Failed to link\n");
    glGetInfoLog( m_program, 256, NULL, log);
    //printf(" Infolog: %s\n", log);
  }  
}
}

Example #2

File: gl_shader.cpp Project: SHMAUS-Carter/OpenGames

bool FShader::Load(const char * name, const char * vert_prog_lump, const char * frag_prog_lump, const char * proc_prog_lump, const char * defines)
{
	static char buffer[10000];
	FString error;

	if (gl.shadermodel > 0)
	{
		int vp_lump = Wads.CheckNumForFullName(vert_prog_lump);
		if (vp_lump == -1) I_Error("Unable to load '%s'", vert_prog_lump);
		FMemLump vp_data = Wads.ReadLump(vp_lump);

		int fp_lump = Wads.CheckNumForFullName(frag_prog_lump);
		if (fp_lump == -1) I_Error("Unable to load '%s'", frag_prog_lump);
		FMemLump fp_data = Wads.ReadLump(fp_lump);


		FString vp_comb;
		FString fp_comb;
		vp_comb = defines;
		if (gl.shadermodel < 4) 
		{
			vp_comb << "#define NO_SM4\n";
		}

		fp_comb = vp_comb;
		// This uses GetChars on the strings to get rid of terminating 0 characters.
		vp_comb << vp_data.GetString().GetChars() << "\n";
		fp_comb << fp_data.GetString().GetChars() << "\n";

		if (proc_prog_lump != NULL)
		{
			if (*proc_prog_lump != '#')
			{
				int pp_lump = Wads.CheckNumForFullName(proc_prog_lump);
				if (pp_lump == -1) I_Error("Unable to load '%s'", proc_prog_lump);
				FMemLump pp_data = Wads.ReadLump(pp_lump);

				fp_comb << pp_data.GetString().GetChars();
			}
			else 
			{
				// Proc_prog_lump is not a lump name but the source itself (from generated shaders)
				fp_comb << proc_prog_lump+1;
			}
		}

		hVertProg = glCreateShader(GL_VERTEX_SHADER);
		hFragProg = glCreateShader(GL_FRAGMENT_SHADER);	


		int vp_size = (int)vp_comb.Len();
		int fp_size = (int)fp_comb.Len();

		const char *vp_ptr = vp_comb.GetChars();
		const char *fp_ptr = fp_comb.GetChars();

		glShaderSource(hVertProg, 1, &vp_ptr, &vp_size);
		glShaderSource(hFragProg, 1, &fp_ptr, &fp_size);

		glCompileShader(hVertProg);
		glCompileShader(hFragProg);

		hShader = glCreateProgram();

		glAttachShader(hShader, hVertProg);
		glAttachShader(hShader, hFragProg);

		glBindAttribLocation(hShader, VATTR_GLOWDISTANCE, "glowdistance");
		glBindAttribLocation(hShader, VATTR_FOGPARAMS, "fogparams");
		glBindAttribLocation(hShader, VATTR_LIGHTLEVEL, "lightlevel_in"); // Korshun.

		glLinkProgram(hShader);

		glGetShaderInfoLog(hVertProg, 10000, NULL, buffer);
		if (*buffer) 
		{
			error << "Vertex shader:\n" << buffer << "\n";
		}
		glGetShaderInfoLog(hFragProg, 10000, NULL, buffer);
		if (*buffer) 
		{
			error << "Fragment shader:\n" << buffer << "\n";
		}

		glGetProgramInfoLog(hShader, 10000, NULL, buffer);
		if (*buffer) 
		{
			error << "Linking:\n" << buffer << "\n";
		}
		int linked;
		glGetObjectParameteriv(hShader, GL_LINK_STATUS, &linked);
		if (linked == 0)
		{
			// only print message if there's an error.
			Printf("Init Shader '%s':\n%s\n", name, error.GetChars());
		}
		timer_index = glGetUniformLocation(hShader, "timer");
		desaturation_index = glGetUniformLocation(hShader, "desaturation_factor");
		fogenabled_index = glGetUniformLocation(hShader, "fogenabled");
		texturemode_index = glGetUniformLocation(hShader, "texturemode");
		camerapos_index = glGetUniformLocation(hShader, "camerapos");
		lightparms_index = glGetUniformLocation(hShader, "lightparms");
		colormapstart_index = glGetUniformLocation(hShader, "colormapstart");
		colormaprange_index = glGetUniformLocation(hShader, "colormaprange");
		lightrange_index = glGetUniformLocation(hShader, "lightrange");
		fogcolor_index = glGetUniformLocation(hShader, "fogcolor");
		lights_index = glGetUniformLocation(hShader, "lights");
		dlightcolor_index = glGetUniformLocation(hShader, "dlightcolor");

		glowbottomcolor_index = glGetUniformLocation(hShader, "bottomglowcolor");
		glowtopcolor_index = glGetUniformLocation(hShader, "topglowcolor");
		
		glUseProgram(hShader);

		int texture_index = glGetUniformLocation(hShader, "texture2");
		if (texture_index > 0) glUniform1i(texture_index, 1);

		glUseProgram(0);
		return !!linked;
	}
	return false;
}