示例#1
0
/*----------------------------------------------------------------------------*/
GLint Shader::link() {
	GLint linked = oogl::ShaderProgram::link();
	if (*getInfoLog() != 0) { // if info log not empty
		oogl::logEvent("Link status: %i, info log:\n%s", linked, getInfoLog());
	}
	return linked;
}
示例#2
0
/*----------------------------------------------------------------------------*/
GLint ShaderUnit::compile() {
	GLint compiled = oogl::ShaderObject::compile();
	if (*getInfoLog() != 0) { // if info log not empty
		oogl::logEvent("Compile status: %i, info log:\n\n%s", compiled, getInfoLog());
	}/* else {
		oogl::logEvent("Compile status: %i", compiled);
	}*/
	return compiled;
}
示例#3
0
bool GLSLShader::link()
{
	int		status;
	char	*info_log;

	/*** link program object ***/
	glLinkProgram( *m_program_object );

	glGetProgramiv( *m_program_object, GL_OBJECT_LINK_STATUS_ARB, &status );
	if( !status )
	{
		CGoGNerr << "ERROR - GLSLShader::create() - error occured while linking shader program." << CGoGNendl;
		info_log = getInfoLog( *m_program_object );
		CGoGNerr << "  LINK " << info_log << CGoGNendl;
		delete [] info_log;

		glDetachShader( *m_program_object, *m_vertex_shader_object );
		glDetachShader( *m_program_object, *m_fragment_shader_object );
		if (*m_geom_shader_object)
			glDetachShader( *m_program_object, *m_geom_shader_object );
		glDeleteShader( *m_program_object );
		*m_program_object = 0;

		return false;
	}
	return true;
}
示例#4
0
void GlShaderProgram::link() {
  bool allShaderCompiled = true;

  for (size_t i = 0 ; i < attachedShaders.size() ; ++i) {
    if (!attachedShaders[i]->isCompiled()) {
      allShaderCompiled = false;
    }

    if (attachedShaders[i]->getShaderType() == Geometry) {
      glProgramParameteriEXT(programObjectId, GL_GEOMETRY_INPUT_TYPE_EXT, attachedShaders[i]->getInputPrimitiveType());
      glProgramParameteriEXT(programObjectId, GL_GEOMETRY_OUTPUT_TYPE_EXT, attachedShaders[i]->getOutputPrimitiveType());

      GLint maxOutputVertices = maxGeometryShaderOutputVertices;

      if (maxOutputVertices == 0)
        glGetIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES_EXT, &maxOutputVertices);

      glProgramParameteriEXT(programObjectId, GL_GEOMETRY_VERTICES_OUT_EXT, maxOutputVertices);
    }
  }

  glLinkProgram(programObjectId);

  getInfoLog(programObjectId, PROGRAM, programLinkLog);

  GLint linked;
  glGetProgramiv(programObjectId, GL_LINK_STATUS, &linked);
  programLinked = allShaderCompiled && linked > 0;
}
	GlShaderBlinnShadowMap()
	{
		std::string infoLog;

		initVertFragShadersFromDirectory("shader_blinn_shadow_map");
		attachFragShader(SHADER_GLSL_DEFAULT_DIR"shader_blinn/fragment_shader_skeleton.glsl");

		// link programs
		if (!link())
		{
			std::string infoLog;
			getInfoLog(infoLog);
			std::cerr << "info Log: during linking: " << infoLog << std::endl;
			return;
		}

		setupUniform(texture0_enabled, "texture0_enabled");
		setupUniform(shadow_map_matrix_uniform, "shadow_map_matrix");

		use();
		setUniform1i("texture0", 0);
		setUniform1i("texture_shadow_map", 1);
		disable();

		initBlinnSkeleton(*this);
	}
示例#6
0
CrossCompiler::Spirv CrossCompiler::hlslToSpirv(std::string hlslText)
{
    auto program = glslang::TProgram();

    auto entryPoints = getEntryPoints(hlslText);
    for (auto& stageEntries : entryPoints)
    {
        auto stage = toEShLanguage(stageEntries.first);
        for (auto name : stageEntries.second)
        {
            addShader(program, hlslText, stage, name);
        }
    }

    if (!program.link(messagesType))
        throw std::exception(program.getInfoLog());

    Spirv spirv;
    if (entryPoints["vs"].size() > 0)
        spirv.vs = getBinary(program, EShLanguage::EShLangVertex);

    if (entryPoints["ps"].size() > 0)
        spirv.ps = getBinary(program, EShLanguage::EShLangFragment);
    return spirv;
}
示例#7
0
void GlShader::compileShaderObject(const char *shaderSrc) {
  glShaderSource(shaderObjectId, 1,(const char **) &shaderSrc, NULL);
  glCompileShader(shaderObjectId);
  GLint compileStatus;
  glGetShaderiv(shaderObjectId, GL_COMPILE_STATUS, &compileStatus);
  shaderCompiled = compileStatus > 0;
  getInfoLog(shaderObjectId, SHADER, compilationLog);
}
        void PlainShaderProgram::init()
        {
            Commons::Render::ShaderPtr vs(new Commons::Render::Shader(GL_VERTEX_SHADER));
            vs->setSource(VERTEX_SHADER);
            LOG_INFO("Compiling plain vertex shader...");
            bool isCompiled = vs->compile();
            std::string log;
            vs->getInfoLog(log);
            WriteShaderLog(log);
            if (!isCompiled)
                throw Commons::GLException("Can't compile vertex shader. See log for details");

            Commons::Render::ShaderPtr fs(new Commons::Render::Shader(GL_FRAGMENT_SHADER));
            fs->setSource(FRAGMENT_SHADER);
            isCompiled = fs->compile();
            fs->getInfoLog(log);
            WriteShaderLog(log);
            if (!isCompiled)
                throw Commons::GLException("Can't compile fragment shader. See log for details");

            // Link
            attach(fs);
            attach(vs);

            bool isLinked = link();
            getInfoLog(log);
            WriteShaderLog(log);
            if (!isLinked)
                throw Commons::GLException("Can't link shader program. See log for details");



            bool isValidated = validate();
            getInfoLog(log);
            WriteShaderLog(log);
            if (!isValidated)
                throw Commons::GLException("Can't validate shader program. See log for details");

            //uint32_t a = m_shader->getNumAttributes();
            //uint32_t un = m_shader->getNumUniforms();

            // TODO: helpers...
            m_uMVP = getUniformLocation("m_MVP");
            m_uTex1 = getUniformLocation("u_tex1");
            setUniformSampler2D(m_uTex1, 0);
        }
示例#9
0
/*----------------------------------------------------------------------------*/
void Shader::use() {
#ifndef NDEBUG
	if (!validate()) {
		oogl::logEvent("Failed to validate Shader#%u.\nInfo log:\n%s", getHandle(), getInfoLog());
		assert(false); // abort!
	}
#endif

	oogl::ShaderProgram::use();
}
示例#10
0
void GLSLProgram::link() {
	LOG_DEBUG << "linking program" << std::endl;
	GLint status;
	glLinkProgram(prog);
	glGetProgramiv(prog, GL_LINK_STATUS, &status);

	if (!status) {
		std::string log = "can't link program: " + getInfoLog(prog);
		LOG_ERROR << log << std::endl;
		throw std::runtime_error(log);
	} else {
		LOG_DEBUG << "linked program - no errors" << std::endl;
	}
}
示例#11
0
void gle::Program::link()
{
  GLint status;

  glLinkProgram(_id);
  GLenum error = glGetError();
  if (error == GL_INVALID_OPERATION)
    throw new gle::Exception::InvalidOperation("Cannot link the program");
  else if (error != GL_NO_ERROR)
    throw new gle::Exception::OpenGLError();
  glGetProgramiv(_id, GL_LINK_STATUS, &status);
  if (status != GL_TRUE)
    throw new gle::Exception::LinkageError(getInfoLog());
}
示例#12
0
void addShader(glslang::TProgram& program, std::string& hlslText, EShLanguage stage, std::string entryPointName)
{
    auto shader = new glslang::TShader(stage);

    const char * text = hlslText.c_str();
    shader->setStrings(&text, 1);
    shader->setEntryPoint(entryPointName.c_str());

    program.addShader(shader);

    if (!shader->parse(&DefaultResources, defaultVersion, false, messagesType))
    {
        throw std::exception(shader->getInfoLog());
    }
}
示例#13
0
	GlShaderTexturize()
	{
		if (!initVertFragShadersFromDirectory("shader_texturize"))
			return;

		if (!link())
		{
			std::string infoLog;
			getInfoLog(infoLog);
			std::cerr << "info Log: linking: " << infoLog << std::endl;
			return;
		}

		setupUniform(pvm_matrix_uniform, "pvm_matrix");
	}
示例#14
0
文件: Shader.cpp 项目: dgkae/cppgl
void Shader::compile()
{
    GLint res;

    glCompileShader( _obj );
    glGetShaderiv( _obj, GL_COMPILE_STATUS, &res );

    if (res != GL_TRUE) {
        CLOG(getInfoLog());
        _compiled = false;
    } else {
        _compiled = true;
    }

    assert(res == GL_TRUE);
}
示例#15
0
	CShaderBathymetry()
	{
		std::string infoLog;

		initVertFragShadersFromDirectory("shader_bathymetry");
		attachFragShader(SHADER_GLSL_DEFAULT_DIR"shader_blinn/fragment_shader_skeleton.glsl");

		// link programs
		link();
		if (error())
		{
			std::string infoLog;
			getInfoLog(infoLog);
			std::cerr << "info Log: during linking: " << infoLog << std::endl;
			return;
		}

		initBlinnSkeleton(*this);
	}
示例#16
0
void
Program::link()
//[]----------------------------------------------------[]
//|  Link                                                |
//[]----------------------------------------------------[]
{
  // Link program
  glLinkProgram(handle);

  GLint ok;

  // Get link status
  glGetProgramiv(handle, GL_LINK_STATUS, &ok);
  if (ok == GL_TRUE)
    state = BUILT;
  else
  {
    string log = getInfoLog(handle, glGetProgramiv, glGetProgramInfoLog);
    error(LINK_ERROR, getName(), log.c_str());
  }
}
示例#17
0
void
Shader::compile()
//[]----------------------------------------------------[]
//|  Compile                                             |
//[]----------------------------------------------------[]
{
  // Compile shader
  glCompileShader(handle);

  GLint ok;

  // Get compile status
  glGetShaderiv(handle, GL_COMPILE_STATUS, &ok);
  if (ok == GL_TRUE)
    compiled = true;
  else
  {
    string log = getInfoLog(handle, glGetShaderiv, glGetShaderInfoLog);
    error(COMPILE_ERROR, getName(), log.c_str());
  }
}
示例#18
0
	GlShaderBlinn()
	{
		std::string infoLog;

		initVertFragShadersFromDirectory("shader_blinn");
		attachFragShader(SHADER_GLSL_DEFAULT_DIR"shader_blinn/fragment_shader_skeleton.glsl");

		// link programs
		if (!link())
		{
			std::string infoLog;
			getInfoLog(infoLog);
			std::cerr << "info Log: during linking: " << infoLog << std::endl;
			return;
		}

		setupUniform(texture0_enabled, "texture0_enabled");
		setupUniform(vertex_color, "vertex_color");

		initBlinnSkeleton(*this);
	}
示例#19
0
	/**
	 * link compiled shaders
	 */
	bool link()
	{
		glLinkProgram(program);
		CGlErrorCheck();

		GLint status;
		glGetProgramiv(program, GL_LINK_STATUS, &status);

		if (status == GL_TRUE)
			return true;

		std::cerr << getInfoLog() << std::endl;
		error = true;

		for (CGlShader &s : shaders)
		{
			std::cerr << " Shader filename: " << s.filename << std::endl;
			error = true;
		}
		return false;
	}
	GLShaderHeightColorBlinn()
	{
		std::string infoLog;

		initVertFragShadersFromDirectory("shader_height_color_blinn");
		attachFragShader(SHADER_GLSL_DEFAULT_DIR"shader_blinn/fragment_shader_skeleton.glsl");

		// link programs
		if (!link())
		{
			std::string infoLog;
			getInfoLog(infoLog);
			std::cerr << "info Log: during linking: " << infoLog << std::endl;
			return;
		}

		setupUniform(height_color_scale, "height_color_scale");
		setupUniform(height_color_offset, "height_color_offset");

		initBlinnSkeleton(*this);

		setupColorScaleAndOffset();
	}
示例#21
0
文件: Program.cpp 项目: dcbishop/dglw
void Program::debugLog() const {
   std::string program_log = getInfoLog();
   if(program_log.size() > 0) {
      LOG("ShaderLog: %s", &program_log[0]);
   }
}
示例#22
0
bool GLSLShader::create(GLint inputGeometryPrimitive,GLint outputGeometryPrimitive, int nb_max_vertices)
{
	int	status;
	char* info_log;

	if (nb_max_vertices != -1)
		m_nbMaxVertices = nb_max_vertices;

	m_geom_inputPrimitives = inputGeometryPrimitive;
	m_geom_outputPrimitives = outputGeometryPrimitive;

	/*** check if shaders are loaded ***/
	if( !*m_vertex_shader_object || !*m_fragment_shader_object )
	{
		CGoGNerr << "ERROR - GLSLShader::create() - shaders are not defined." << CGoGNendl;
		return false;
	}

	/*** create program object ***/
	m_program_object = glCreateProgram();

	if( !*m_program_object )
	{
		CGoGNerr << "ERROR - GLSLShader::create() - unable to create program object." << CGoGNendl;
		return false;
	}

	/*** attach shaders to program object ***/
	glAttachShader( *m_program_object, *m_vertex_shader_object );
	glAttachShader( *m_program_object, *m_fragment_shader_object );
	if (*m_geom_shader_object)
	{
		glAttachShader( *m_program_object, *m_geom_shader_object );

		if (CURRENT_OGL_VERSION == 2)
		{
			glProgramParameteriEXT(*m_program_object, GL_GEOMETRY_INPUT_TYPE_EXT, inputGeometryPrimitive);
			glProgramParameteriEXT(*m_program_object, GL_GEOMETRY_OUTPUT_TYPE_EXT, outputGeometryPrimitive);
			glProgramParameteriEXT(*m_program_object, GL_GEOMETRY_VERTICES_OUT_EXT, m_nbMaxVertices);
		}
	}

	/*** link program object ***/
	glLinkProgram( *m_program_object );

	glGetProgramiv( *m_program_object, GL_LINK_STATUS, &status );
	if( !status )
	{
		CGoGNerr << "ERROR - GLSLShader::create() - error occured while linking shader program." << CGoGNendl;
		info_log = getInfoLog( *m_program_object );
		CGoGNerr << "  LINK " << info_log << CGoGNendl;
		delete [] info_log;

		glDetachShader( *m_program_object, *m_vertex_shader_object );
		glDetachShader( *m_program_object, *m_fragment_shader_object );
		if (*m_geom_shader_object)
			glDetachShader( *m_program_object, *m_geom_shader_object );
		glDeleteShader( *m_program_object );
		*m_program_object = 0;

		return false;
	}

	*m_uniMat_Proj		= glGetUniformLocation(*m_program_object, "ProjectionMatrix");
	*m_uniMat_Model		= glGetUniformLocation(*m_program_object, "ModelViewMatrix");
	*m_uniMat_ModelProj	= glGetUniformLocation(*m_program_object, "ModelViewProjectionMatrix");
	*m_uniMat_Normal	= glGetUniformLocation(*m_program_object, "NormalMatrix");

	return true;
}
示例#23
0
/** Retrieves compilation info log for a shader object with GLES id
 *  @param shader_id.
 *
 *  @param shader_id GLES id of a shader object to retrieve compilation
 *          info log for.
 *
 *  @return String instance containing the log.
 **/
std::string TestCaseBase::getCompilationInfoLog(glw::GLuint shader_id)
{
	return getInfoLog(LT_SHADER_OBJECT, shader_id);
}
示例#24
0
/** Retrieves linking info log for a program object with GLES id
 *  @param po_id.
 *
 *  @param po_id GLES id of a program object to retrieve linking
 *               info log for.
 *
 *  @return String instance containing the log.
 **/
std::string TestCaseBase::getLinkingInfoLog(glw::GLuint po_id)
{
	return getInfoLog(LT_PROGRAM_OBJECT, po_id);
}
示例#25
0
/** Retrieves linking info log for a pipeline object with GLES id
 *  @param ppo_id.
 *
 *  @param ppo_id GLES id of a pipeline object to retrieve validation
 *               info log for.
 *
 *  @return String instance containing the log.
 **/
std::string TestCaseBase::getPipelineInfoLog(glw::GLuint ppo_id)
{
	return getInfoLog(LT_PIPELINE_OBJECT, ppo_id);
}