// Initialization code
void init()
{
	// Initializes the glew library
	glewInit();
	glEnable(GL_DEPTH_TEST);

	//Create shader program
	std::string vertShader = readShader("VertexShader.glsl");
	std::string fragShader = readShader("FragmentShader.glsl");

	vertex_shader = createShader(vertShader, GL_VERTEX_SHADER);
	fragment_shader = createShader(fragShader, GL_FRAGMENT_SHADER);

	program = glCreateProgram();
	glAttachShader(program, vertex_shader);
	glAttachShader(program, fragment_shader);
	glLinkProgram(program);

	//Generate the View Projection matrix
	glm::mat4 view = glm::lookAt(glm::vec3(0.0f, 0.0f, 2.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));
	glm::mat4 proj = glm::perspective(45.0f, 800.0f / 800.0f, 0.1f, 100.0f);
	VP = proj * view;

	//Get uniforms
	uniMVP = glGetUniformLocation(program, "MVP");
	uniHue = glGetUniformLocation(program, "hue");

	//Set options
	glFrontFace(GL_CCW);
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
예제 #2
0
//------------------------------------------------------------------------------
GLuint loadProgram( const std::string &name ){
    GLuint program{0};

    std::vector<GLuint> shaders;
    std::list<std::string> available = {"1.20","3.30"};

    std::string glslv;

    const GLubyte * glslVersion = glGetString( GL_SHADING_LANGUAGE_VERSION );
    std::string sv(reinterpret_cast<const char*>(glslVersion));

    for( auto i = available.begin(); i != available.end() ; ++i ){
        if( 0 == sv.find(*i) ){
            glslv = *i;
            break;
        }
    }

    if( "" == glslv ){
        printf( "Invalid shader version: %s\n", sv.c_str());
        exit(EXIT_FAILURE);
    }

    std::string strVertexShader = name+"."+glslv+".vert";
    std::string strFragmentShader = name+"."+glslv+".frag";

    shaders.push_back( createShader( GL_VERTEX_SHADER, strVertexShader ) );
    shaders.push_back( createShader( GL_FRAGMENT_SHADER, strFragmentShader ) );

    program = createProgram( shaders );

    std::for_each( shaders.begin(), shaders.end(), glDeleteShader );

    return program;
}
	bool COGLES2SLMaterialRenderer::init(s32& outMaterialTypeNr,
			const c8* vertexShaderProgram,
			const c8* pixelShaderProgram,
			bool registerMaterial )
	{
		outMaterialTypeNr = -1;

		if ( Program == 0 && !createProgram() )
			return false;

		if ( vertexShaderProgram )
			if ( !createShader( GL_VERTEX_SHADER, vertexShaderProgram, "" ) )
				return false;

		if ( pixelShaderProgram )
			if ( !createShader( GL_FRAGMENT_SHADER, pixelShaderProgram, "" ) )
				return false;

		for ( size_t i = 0; i < EVA_COUNT; ++i )
			glBindAttribLocation( Program, i, sBuiltInVertexAttributeNames[i] );

		if ( !linkProgram() )
			return false;

		// register myself as new material
		if ( registerMaterial )
			outMaterialTypeNr = Driver->addMaterialRenderer( this );
		return true;
	}
예제 #4
0
// bind shaders by vertex shader file and fragment shader fie
void CShader::createShaderProgram() {
    GLint vs = -1;
    GLint gs = -1;
    GLint ts = -1;
    GLint fs = -1;

    vs = createShader( _vs.c_str(), GL_VERTEX_SHADER );
    fs = createShader( _fs.c_str(), GL_FRAGMENT_SHADER );
    assert(  vs >= 0 );
    assert(  fs >= 0 );

    if( _gs!= "" ) {
        gs = createShader( _gs.c_str(), GL_GEOMETRY_SHADER );
        assert( gs >= 0 );
    }

    // bypass tessellation shader for now
    if( _ts != "" ) {
        // ts = createShader( _ts.c_str(), gl_tessshader)
    }

    _sp = createShaderProgram( vs, gs, ts, fs );  
    
    _inited = true;
}
static GLuint createShaderProgram(const char *vertexShaderSrc, const char *fragmentShaderSrc) {
    GLuint program = glCreateProgram();
    glAttachShader(program, createShader(vertexShaderSrc, GL_VERTEX_SHADER));
    glAttachShader(program, createShader(fragmentShaderSrc, GL_FRAGMENT_SHADER));
    glLinkProgram(program);
    return program;
}
예제 #6
0
static void gl_init(void) {
    GLuint program = glCreateProgram();
    glAttachShader(program, createShader(vertex_shader  , GL_VERTEX_SHADER));
    glAttachShader(program, createShader(fragment_shader, GL_FRAGMENT_SHADER));
    glLinkProgram(program);
    char msg[512];
    glGetProgramInfoLog(program, sizeof msg, NULL, msg);
    std::cout << "info: " <<  msg << std::endl;
    glUseProgram(program);
    std::vector<float> elements(nbNodes);
    int count = 0;
    for (float x=0; x < nbNodes; ++x ) {
        elements[count] = count;
        ++count;
    }
    /*Create one texture to store all the needed information */
    glGenTextures(1, &nodeTexture);
    /* Store the vertices in a vertex buffer object (VBO) */
    glGenBuffers(1, &indicesVBO);
    glBindBuffer(GL_ARRAY_BUFFER, indicesVBO);
    glBufferData(GL_ARRAY_BUFFER, elements.size() * sizeof(float), &elements[0], GL_STATIC_DRAW);
    /* Get the locations of the uniforms so we can access them */
    nodeSamplerLocation      = glGetUniformLocation(program, "nodeInfo");
    glBindAttribLocation(program, 0, "indices");
#ifndef __EMSCRIPTEN__ // GLES2 & WebGL do not have these, only pre 3.0 desktop GL and compatibility mode GL3.0+ GL do.
    //Enable glPoint size in shader, always enable in Open Gl ES 2.
    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
    glEnable(GL_POINT_SPRITE);
#endif
}
예제 #7
0
//------------------------------------------------------------------------------
// setupGenericShaders - This function is totally not needed on PC because there
// is fixed-function support in D3D9
//------------------------------------------------------------------------------
inline void GFXD3D9Device::setupGenericShaders( GenericShaderType type /* = GSColor */ )
{
#ifdef WANT_TO_SIMULATE_UI_ON_360
   if( mGenericShader[GSColor] == NULL )
   {
      mGenericShader[GSColor] =           createShader( "shaders/common/genericColorV.hlsl", 
         "shaders/common/genericColorP.hlsl", 
         2.f );

      mGenericShader[GSModColorTexture] = createShader( "shaders/common/genericModColorTextureV.hlsl", 
         "shaders/common/genericModColorTextureP.hlsl", 
         2.f );

      mGenericShader[GSAddColorTexture] = createShader( "shaders/common/genericAddColorTextureV.hlsl", 
         "shaders/common/genericAddColorTextureP.hlsl", 
         2.f );
   }

   mGenericShader[type]->process();

   MatrixF world, view, proj;
   mWorldMatrix[mWorldStackSize].transposeTo( world );
   mViewMatrix.transposeTo( view );
   mProjectionMatrix.transposeTo( proj );

   mTempMatrix = world * view * proj;

   setVertexShaderConstF( VC_WORLD_PROJ, (F32 *)&mTempMatrix, 4 );
#else
   disableShaders();
#endif
}
void COpenGLSLMaterialRenderer::init(s32& outMaterialTypeNr,
	const c8* vertexShaderProgram,
	const c8* pixelShaderProgram)
{
	outMaterialTypeNr = -1;

	if (!createProgram())
		return;

#if defined(GL_ARB_vertex_shader) && defined (GL_ARB_fragment_shader)
	if (vertexShaderProgram)
		if (!createShader(GL_VERTEX_SHADER_ARB, vertexShaderProgram))
			return;


	if (pixelShaderProgram)
		if (!createShader(GL_FRAGMENT_SHADER_ARB, pixelShaderProgram))
			return;
#endif

	if (!linkProgram())
		return;

	// register myself as new material
	outMaterialTypeNr = Driver->addMaterialRenderer(this);
}
	bool COGLES2SLMaterialRenderer::init(s32& outMaterialTypeNr,
			const c8* vertexShaderProgram,
			const c8* pixelShaderProgram,
			bool registerMaterial )
	{
		outMaterialTypeNr = -1;

		if ( Program == 0 && !createProgram() )
			return false;

		if ( vertexShaderProgram )
			if ( !createShader( GL_VERTEX_SHADER, vertexShaderProgram, "" ) )
				return false;

		if ( pixelShaderProgram )
			if ( !createShader( GL_FRAGMENT_SHADER, pixelShaderProgram, "" ) )
				return false;

		if ( !linkProgram() )
			return false;

		// register myself as new material
		if ( registerMaterial )
			outMaterialTypeNr = Driver->addMaterialRenderer( this );
		return true;
	}
예제 #10
0
void QEglFSCursor::createShaderPrograms()
{
    static const char *textureVertexProgram =
        "attribute highp vec2 vertexCoordEntry;\n"
        "attribute highp vec2 textureCoordEntry;\n"
        "varying highp vec2 textureCoord;\n"
        "void main() {\n"
        "   textureCoord = textureCoordEntry;\n"
        "   gl_Position = vec4(vertexCoordEntry, 1.0, 1.0);\n"
        "}\n";

    static const char *textureFragmentProgram =
        "uniform sampler2D texture;\n"
        "varying highp vec2 textureCoord;\n"
        "void main() {\n"
        "   gl_FragColor = texture2D(texture, textureCoord).bgra;\n"
        "}\n";

    GLuint vertexShader = createShader(GL_VERTEX_SHADER, textureVertexProgram);
    GLuint fragmentShader = createShader(GL_FRAGMENT_SHADER, textureFragmentProgram);
    m_program = createProgram(vertexShader, fragmentShader);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    m_vertexCoordEntry = glGetAttribLocation(m_program, "vertexCoordEntry");
    m_textureCoordEntry = glGetAttribLocation(m_program, "textureCoordEntry");
    m_textureEntry = glGetUniformLocation(m_program, "texture");
}
예제 #11
0
/**
 * Compile the shader from file 'filename', with error handling
 */
int Shader::loadShader(string fileName){
	GLint link_ok = GL_FALSE;
	GLuint vs, fs;

	string vsName = fileName+".v.glsl";
	string fsName = fileName+".f.glsl";

	if ((vs = createShader(vsName.c_str(), GL_VERTEX_SHADER))   == 0) return 0;
	if ((fs = createShader(fsName.c_str(), GL_FRAGMENT_SHADER)) == 0) return 0;
	program = glCreateProgram();
	glAttachShader(program, vs);
	glAttachShader(program, fs);
	glLinkProgram(program);

	glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
	if (!link_ok) {
		logWar("glLinkProgram:");
		printShaderLog(program);
        glDeleteShader(vs);
        glDeleteShader(fs);
		return -1;
	}
    glDeleteShader(vs);
    glDeleteShader(fs);
	loadVars();
    return 0;
}
bool Cc3dProgram::initWithFile(const string&vertShaderFilePath,const string&fragShaderFilePath){
    m_vertShaderFilePath=vertShaderFilePath;
    m_fragShaderFilePath=fragShaderFilePath;
    //create shader
    vector<string> _vertShaderFileName=splitStrInTwoByLastDot(vertShaderFilePath);
    vector<string> _fragShaderFileName=splitStrInTwoByLastDot(fragShaderFilePath);
    //创建Program
    GLuint vertShader=createShader(_vertShaderFileName[0].c_str(), _vertShaderFileName[1].c_str());
    GLuint fragShader=createShader(_fragShaderFileName[0].c_str(), _fragShaderFileName[1].c_str());
    //Calls glCreateProgram, glAttachShader, and glLinkProgram to link the vertex and fragment shaders into a complete program.
    GLuint programHandle = glCreateProgram();
    glAttachShader(programHandle, vertShader);
    glAttachShader(programHandle, fragShader);
    
    //needs to be done prior to linking
    {
        glBindAttribLocation(programHandle, ATTRIB_LOC_position_local, "position_local");
        glBindAttribLocation(programHandle, ATTRIB_LOC_texCoord, "texCoordIn");
        glBindAttribLocation(programHandle, ATTRIB_LOC_normal_local, "normal_local");
    }
    glLinkProgram(programHandle);//link过以后,通过glGet**Location得到的索引就是固定的了
    //check and see if there were any link errors
    GLint linkSuccess;
    glGetProgramiv(programHandle, GL_LINK_STATUS, &linkSuccess);
    if (linkSuccess == GL_FALSE) {
        GLchar messages[1024];
        glGetProgramInfoLog(programHandle, sizeof(messages), 0, &messages[0]);
        C3DASSERT(false,messages);
    }
    m_program=programHandle;
    return true;
}
예제 #13
0
	GLuint Shader::reload(void)
	{
		// Loesche den Shader Code aus dem Grafikspeicher und weise allen IDs den Wert 0 zu:
		deleteShader();
		m_VertexShader   = 0;
		m_FragmentShader = 0;
		m_ShaderProgram  = 0;

		// Create vertex shader
		m_VertexShader = createShader( GL_VERTEX_SHADER, m_VertexShaderFilename.c_str() );
		if(m_VertexShader == 0)
		{
			return 0;
		}
		
		// Create fragment shader
		m_FragmentShader = createShader( GL_FRAGMENT_SHADER, m_FragmentShaderFilename.c_str() );
		if(m_FragmentShader == 0)
		{
			return 0;
		}

		// Generate shader program
		m_ShaderProgram = createShaderProgram( m_VertexShader, m_FragmentShader );
		if(m_ShaderProgram == 0)
		{
			return 0;
		}

		// No errors
		return 1;
	}
예제 #14
0
	GLuint Shader::compile(void)
	{
		// Generate vertex shader
		m_VertexShader = createShader( GL_VERTEX_SHADER, m_VertexShaderFilename.c_str() );
		if(m_VertexShader == 0)
		{
			return 0;
		}
		
		// Generate fragment shader
		m_FragmentShader = createShader( GL_FRAGMENT_SHADER, m_FragmentShaderFilename.c_str() );
		if(m_FragmentShader == 0)
		{
			return 0;
		}

		// Generate shader program
		m_ShaderProgram = createShaderProgram( m_VertexShader, m_FragmentShader );
		if(m_ShaderProgram == 0)
		{
			return 0;
		}

		// No errors
		return 1;
	}
예제 #15
0
void Render::initialize(const std::string &frag, const std::string &vert, int numOfRects)
{
   initialized = true;
   GLenum err = glewInit();

      if (GLEW_OK != err)
      {
         std::cout<<boost::format("Glew error: %s\n") % glewGetErrorString(err);
         exit(1);
      }

      std::cout<<boost::format("Status: Using GLEW %s\n") % glewGetString(GLEW_VERSION);
   
      GLuint vertShader = createShader(vert, GL_VERTEX_SHADER);
   GLuint fragShader = createShader(frag, GL_FRAGMENT_SHADER);
   program = createProgram(vertShader,fragShader);

   glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
   glEnable(GL_BLEND);


   createAndBindBuffers(numOfRects);
   activateProgram(program);
   bindTexture();
}
예제 #16
0
static void gl_init(void) {
    GLuint program = glCreateProgram();
    glAttachShader(program, createShader(vertex_shader  , GL_VERTEX_SHADER));
    glAttachShader(program, createShader(fragment_shader, GL_FRAGMENT_SHADER));
    glLinkProgram(program);
    char msg[512];
    glGetProgramInfoLog(program, sizeof msg, NULL, msg);
    std::cout << "info: " <<  msg << std::endl;
    glUseProgram(program);
    std::vector<float> elements(nbNodes);
    int count = 0;
    for (float x=0; x < nbNodes; ++x ) {
        elements[count] = count;
        ++count;
    }
    /*Create one texture to store all the needed information */
    glGenTextures(1, &nodeTexture);
    /* Store the vertices in a vertex buffer object (VBO) */
    glGenBuffers(1, &indicesVBO);
    glBindBuffer(GL_ARRAY_BUFFER, indicesVBO);
    float zeroes[nbNodes];
    memset(zeroes, 0, sizeof(zeroes));
    glBufferData(GL_ARRAY_BUFFER, elements.size() * sizeof(float), zeroes, GL_STATIC_DRAW);
    for (int x = 0; x < nbNodes; x++) {
      glBufferSubData(GL_ARRAY_BUFFER, x * sizeof(float), elements.size() * sizeof(float), &elements[x]);
    }
    /* Get the locations of the uniforms so we can access them */
    nodeSamplerLocation      = glGetUniformLocation(program, "nodeInfo");
    glBindAttribLocation(program, 0, "indices");
    //Enable glPoint size in shader, always enable in Open Gl ES 2.
    glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
    glEnable(GL_POINT_SPRITE);
}
예제 #17
0
//====================================================================================================================================
bool GPUProgram::createFromFiles( const std::string& _rstrVertexShaderPath, const std::string& _rstrGeometryShaderPath , const std::string& _rstrFragmentShaderPath )
{

    // required to have the OpenGL functions working - this is because of our use of OpenGL with Qt
    initializeOpenGLFunctions();


    const bool bUseGeometryShader = "" != _rstrGeometryShaderPath;

    // Creates the requested Shaders - or assert on error !
    m_iGPUVertexShaderID        = createShader( _rstrVertexShaderPath, GL_VERTEX_SHADER );
    m_iGPUFragmentShaderID      = createShader( _rstrFragmentShaderPath, GL_FRAGMENT_SHADER );



    if( bUseGeometryShader )
    {
        m_iGPUGeometryShaderID    = createShader( _rstrGeometryShaderPath, GL_GEOMETRY_SHADER );
    }

    // Creates the GPU Program
    m_iGPUProgramID = glCreateProgram();

    // Attaches a Vertex and a Fragmen Shader
    glAttachShader( m_iGPUProgramID, m_iGPUVertexShaderID );
    glAttachShader( m_iGPUProgramID, m_iGPUFragmentShaderID );

    if( bUseGeometryShader )
    {
        glAttachShader( m_iGPUProgramID, m_iGPUGeometryShaderID );
    }

    // Links the GPU Program to finally make it effective
    // NB : this will "copy" the attached Shaders into the Program, kinda like static C library linking
    glLinkProgram( m_iGPUProgramID );

    // Now you can detach the Shaders !
    // NB : You can even delete the Shaders
    //      if you don't want to use them for other GPU Programs
    //      => they are not needed, since linking "copied" them into the Program !
    // NB2: on some mobile device, the driver may not behave properly,
    // and won't like to have the Shaders to be detached !... But this is out of scope.
    glDetachShader( m_iGPUProgramID, m_iGPUVertexShaderID );
    glDetachShader( m_iGPUProgramID, m_iGPUFragmentShaderID );

    if( bUseGeometryShader )
    {
        glDetachShader( m_iGPUProgramID, m_iGPUGeometryShaderID );
    }

    destroyShader( m_iGPUVertexShaderID );
    destroyShader( m_iGPUFragmentShaderID );

    if( bUseGeometryShader )
    {
        destroyShader( m_iGPUGeometryShaderID );
    }

}
예제 #18
0
GPUuint Shader::fromFile(const std::string &vert, const std::string &frag)
{
	Array<GPUuint> shaderList;
	shaderList.push_back(createShader(vert));
	shaderList.push_back(createShader(frag));

	return createProgram(shaderList);
}
예제 #19
0
//GLSL shader program creation
GLuint createShaderProgram(const char *fileNameVS, const char *fileNameGS, const char *fileNameFS, GLuint programID)
{
	//Create a new GLSL program
	bool reload = (programID != 0);
	if(!reload){
		programID = glCreateProgram();
	}

	GLsizei count;
	GLuint shaders[3];
	glGetAttachedShaders(programID, 3, &count, shaders);
	GLuint vertexShaderID = 0;
	GLuint geometryShaderID = 0;
	GLuint fragmentShaderID = 0;

	for(GLsizei i=0; i<count; i++){
		GLint shadertype;
		glGetShaderiv(shaders[i], GL_SHADER_TYPE, &shadertype);
		if(shadertype == GL_VERTEX_SHADER){
			vertexShaderID = shaders[i];
		}else if(shadertype == GL_GEOMETRY_SHADER){
			geometryShaderID = shaders[i];
		}else if(shadertype == GL_FRAGMENT_SHADER){
			fragmentShaderID = shaders[i];
		}
	}

	if(fileNameVS){
		// Create vertex shader
		vertexShaderID=createShader(fileNameVS, GL_VERTEX_SHADER, vertexShaderID);
		if(!reload){
			// Attach vertex shader to program object
			glAttachShader(programID, vertexShaderID);
		}
	}

	if(fileNameGS){
		// Create geometry shader
		geometryShaderID=createShader(fileNameGS, GL_GEOMETRY_SHADER, geometryShaderID);
		if(!reload){
			// Attach vertex shader to program object
			glAttachShader(programID, geometryShaderID);
		}
	}
	
	if(fileNameFS){
		// Create fragment shader
		fragmentShaderID = createShader(fileNameFS, GL_FRAGMENT_SHADER, fragmentShaderID);
		if(!reload){
			// Attach fragment shader to program object
			glAttachShader(programID, fragmentShaderID);
		}
	}

	return programID;
}
예제 #20
0
void compileAndLinkGLProgram(ShaderProgram *program, std::string vertexShaderFileName, std::string fragmentShaderFileName) {
    LOGV("Creating shader program from %s and %s", vertexShaderFileName.c_str(), fragmentShaderFileName.c_str());

    GLuint vertexHandle = createShader(vertexShaderFileName, GL_VERTEX_SHADER);
    GLuint fragmentHandle = createShader(fragmentShaderFileName, GL_FRAGMENT_SHADER);
    GLuint programHandle = createProgram(vertexHandle, fragmentHandle);
    program->setHandles(programHandle, vertexHandle, fragmentHandle);

    //TODO: glErrors?
}
예제 #21
0
void Background :: initgl() {
	// The standard gl object stuff.
	vert = createShader(GL_VERTEX_SHADER,   VS_BKGD);
	frag = createShader(GL_FRAGMENT_SHADER, FS_BKGD);

	prog = glCreateProgram();
	glAttachShader(prog, vert);
	glAttachShader(prog, frag);
	glBindFragDataLocation(prog, 0, "out_color");

	glLinkProgram(prog);
	glUseProgram(prog);
	printShaderError(vert, VS_BKGD);
	printShaderError(frag, FS_BKGD);

	//vao, vbo, 
	glGenBuffers(1, &vbo);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);

	// Uploaded to the GPU
	float rectArray [] {
		-1.0f,  1.0f, 0.0f, 0.0f, // TL
		 1.0f,  1.0f, 1.0f, 0.0f, // TR
		 1.0f, -1.0f, 1.0f, 1.0f, // BR

		-1.0f,  1.0f, 0.0f, 0.0f, // TL
		-1.0f, -1.0f, 0.0f, 1.0f, // BL
		 1.0f, -1.0f, 1.0f, 1.0f  // BR
	};

	glBufferData(GL_ARRAY_BUFFER, sizeof(rectArray), rectArray, GL_STATIC_DRAW);

	glGenVertexArrays(1, &vao);
	glBindVertexArray(vao);

	GLuint pos = glGetAttribLocation(prog, "pos");
	GLuint uv  = glGetAttribLocation(prog, "uv");

	glVertexAttribPointer(pos, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, nullptr);
	glVertexAttribPointer(uv , 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 4, (void *) (sizeof(GLfloat) * 2));

	glEnableVertexAttribArray(pos);
	glEnableVertexAttribArray(uv);

	glUniform1i(glGetUniformLocation(prog, "BkgdTex"), BSPOT_BKGD);
	// ren_dim / img_dim = num of repeat
	glUniform2f(glGetUniformLocation(prog, "rep_num"),
		RENDER_WIDTH  / (float) ih->getSheetWidth(),
		RENDER_HEIGHT / (float) ih->getSheetHeight());

	// Because the vectors must be horizontal (in arrays), the matrix must be transposed.
	glUniform2f(glGetUniformLocation(prog, "img_dim"), ih->getSheetWidth(), ih->getSheetHeight());

	unbind();
}
예제 #22
0
파일: GLSLShader.cpp 프로젝트: hoijui/CG1
void GLSLShader::load(const string& name)
{
	vs_object = createShader(GL_VERTEX_SHADER, name+string(".vert"));
	fs_object = createShader(GL_FRAGMENT_SHADER, name+string(".frag"));
	prog_object = glCreateProgram();
	
	if(vs_object)glAttachShader(prog_object, vs_object);
	if(fs_object)glAttachShader(prog_object, fs_object);
	glLinkProgram(prog_object);
	
	printProgramLog(prog_object);
}
예제 #23
0
	GLuint Shader::load()
	{
		GLuint program = glCreateProgram();

		glAttachShader(program, createShader(GL_VERTEX_SHADER));
		glAttachShader(program, createShader(GL_FRAGMENT_SHADER));

		glLinkProgram(program);
		glValidateProgram(program);

		return program;
	}
예제 #24
0
void CreateWorld()
{
	surfaceShader = createShader("Shaders/SurfaceVertexShader.glsl", "Shaders/SurfacePixelShader.glsl", NULL);
	cloudsShader = createShader("Shaders/CloudsVertexShader.glsl", "Shaders/CloudsPixelShader.glsl", NULL);
	
	createCloudsMap();
	createCloudsTexture();
	initRootMapPatch(rootMapPatch, MapMin, MapMax);
	createPatchDisplayList();
	InitializeCriticalSection(&queueCritSect);
	CreateThread(NULL, 0, LPTHREAD_START_ROUTINE(patchQueueThreadProc), NULL, 0, NULL);
}
void COpenGLSLMaterialRenderer::init(s32& outMaterialTypeNr,
		const c8* vertexShaderProgram,
		const c8* pixelShaderProgram,
		const c8* geometryShaderProgram,
		scene::E_PRIMITIVE_TYPE inType, scene::E_PRIMITIVE_TYPE outType,
		u32 verticesOut)
{
	outMaterialTypeNr = -1;

	if (!createProgram())
		return;

#if defined(GL_ARB_vertex_shader) && defined (GL_ARB_fragment_shader)
	if (vertexShaderProgram)
		if (!createShader(GL_VERTEX_SHADER_ARB, vertexShaderProgram))
			return;

	if (pixelShaderProgram)
		if (!createShader(GL_FRAGMENT_SHADER_ARB, pixelShaderProgram))
			return;
#endif

#if defined(GL_ARB_geometry_shader4) || defined(GL_EXT_geometry_shader4) || defined(GL_NV_geometry_program4) || defined(GL_NV_geometry_shader4)
	if (geometryShaderProgram && Driver->queryFeature(EVDF_GEOMETRY_SHADER))
	{
		if (!createShader(GL_GEOMETRY_SHADER_EXT, geometryShaderProgram))
			return;
#if defined(GL_ARB_geometry_shader4) || defined(GL_EXT_geometry_shader4) || defined(GL_NV_geometry_shader4)
		if (Program2) // Geometry shaders are supported only in OGL2.x+ drivers.
		{
			Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_INPUT_TYPE_EXT, Driver->primitiveTypeToGL(inType));
			Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_OUTPUT_TYPE_EXT, Driver->primitiveTypeToGL(outType));
			if (verticesOut==0)
				Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_VERTICES_OUT_EXT, Driver->MaxGeometryVerticesOut);
			else
				Driver->extGlProgramParameteri(Program2, GL_GEOMETRY_VERTICES_OUT_EXT, core::min_(verticesOut, Driver->MaxGeometryVerticesOut));
		}
#elif defined(GL_NV_geometry_program4)
		if (verticesOut==0)
			Driver->extGlProgramVertexLimit(GL_GEOMETRY_PROGRAM_NV, Driver->MaxGeometryVerticesOut);
		else
			Driver->extGlProgramVertexLimit(GL_GEOMETRY_PROGRAM_NV, core::min_(verticesOut, Driver->MaxGeometryVerticesOut));
#endif
	}
#endif

	if (!linkProgram())
		return;

	// register myself as new material
	outMaterialTypeNr = Driver->addMaterialRenderer(this);
}
예제 #26
0
//GLuint createProgram(const char* vtxSrc, const char* fragSrc) {
void createProgram(GLuint * progArray, const char * vtxShaderSrc, const char * fragShaderSrc) {
	//now it is just for testing so use simple two shaders
    const char* vtxSrc = vtxShaderSrc;
    const char* fragSrc = fragShaderSrc;

    GLuint vtxShader = 0;
    GLuint fragShader = 0;
    GLuint program = 0;
    GLint linked = GL_FALSE;

    progArray[0] = 0;

    vtxShader = createShader(GL_VERTEX_SHADER, vtxSrc);
    if (!vtxShader)
        goto exit;

    fragShader = createShader(GL_FRAGMENT_SHADER, fragSrc);
    if (!fragShader)
        goto exit;

    program = glCreateProgram();
    if (!program) {
        checkGlError("glCreateProgram");
        goto exit;
    }
    glAttachShader(program, vtxShader);
    glAttachShader(program, fragShader);

    glLinkProgram(program);
    glGetProgramiv(program, GL_LINK_STATUS, &linked);
    if (!linked) {
        ALOGE("Could not link program");
        GLint infoLogLen = 0;
        glGetProgramiv(program, GL_INFO_LOG_LENGTH, &infoLogLen);
        if (infoLogLen) {
            GLchar* infoLog = (GLchar*)malloc(infoLogLen);
            if (infoLog) {
                glGetProgramInfoLog(program, infoLogLen, NULL, infoLog);
                ALOGE("Could not link program:\n%s\n", infoLog);
                free(infoLog);
            }
        }
        glDeleteProgram(program);
        program = 0;
    }

	exit:
		glDeleteShader(vtxShader);
		glDeleteShader(fragShader);
		progArray[0] = program;
}
예제 #27
0
void createGraphicsPipeline(GR_DEVICE device, GR_PIPELINE& pipeline, GR_MEMORY_REF& pipelineMemRef) {
	// Load shaders
	GR_SHADER vertexShader = createShader(device, "shaders/vs.bin");
	GR_SHADER fragShader = createShader(device, "shaders/ps.bin");

	// Specify descriptor slots
	GR_DESCRIPTOR_SLOT_INFO vsDescriptorSlots[2];

	vsDescriptorSlots[0].slotObjectType = GR_SLOT_SHADER_RESOURCE;
	vsDescriptorSlots[0].shaderEntityIndex = 0;

	vsDescriptorSlots[1].slotObjectType = GR_SLOT_SHADER_RESOURCE;
	vsDescriptorSlots[1].shaderEntityIndex = 1;

	GR_DESCRIPTOR_SLOT_INFO psDescriptorSlots[2];

	psDescriptorSlots[0].slotObjectType = GR_SLOT_UNUSED;
	psDescriptorSlots[1].slotObjectType = GR_SLOT_UNUSED;

	// Create graphics pipeline
	GR_GRAPHICS_PIPELINE_CREATE_INFO pipelineCreateInfo = {};

	pipelineCreateInfo.vs.shader = vertexShader;
	pipelineCreateInfo.vs.dynamicMemoryViewMapping.slotObjectType = GR_SLOT_UNUSED;
	pipelineCreateInfo.vs.descriptorSetMapping[0].descriptorCount = 2;
	pipelineCreateInfo.vs.descriptorSetMapping[0].pDescriptorInfo = vsDescriptorSlots;

	pipelineCreateInfo.ps.shader = fragShader;
	pipelineCreateInfo.ps.dynamicMemoryViewMapping.slotObjectType = GR_SLOT_UNUSED;
	pipelineCreateInfo.ps.descriptorSetMapping[0].descriptorCount = 2;
	pipelineCreateInfo.ps.descriptorSetMapping[0].pDescriptorInfo = psDescriptorSlots;

	pipelineCreateInfo.iaState.topology = GR_TOPOLOGY_TRIANGLE_LIST;
	pipelineCreateInfo.iaState.disableVertexReuse = GR_FALSE;

	pipelineCreateInfo.rsState.depthClipEnable = GR_FALSE;

	pipelineCreateInfo.cbState.logicOp = GR_LOGIC_OP_COPY;
	pipelineCreateInfo.cbState.target[0].blendEnable = GR_TRUE;
	pipelineCreateInfo.cbState.target[0].channelWriteMask = 0xF; // RGBA bits
	pipelineCreateInfo.cbState.target[0].format.channelFormat = GR_CH_FMT_R8G8B8A8;
	pipelineCreateInfo.cbState.target[0].format.numericFormat = GR_NUM_FMT_UNORM;

	pipelineCreateInfo.dbState.format.channelFormat = GR_CH_FMT_R4G4B4A4;
	pipelineCreateInfo.dbState.format.numericFormat = GR_NUM_FMT_UNDEFINED;

	grCreateGraphicsPipeline(device, &pipelineCreateInfo, &pipeline);

	pipelineMemRef = allocateObjectMemory(device, pipeline);
}
예제 #28
0
static GLuint createProgram(const char *vertexShaderSrc, const char *fragmentShaderSrc)
{
	GLuint vertexShader = createShader(GL_VERTEX_SHADER, vertexShaderSrc);
	if (!vertexShader) {
		fprintf(stderr, "createShader(GL_VERTEX_SHADER) failed\n");
		return 0;
	}

	GLuint fragmentShader = createShader(GL_FRAGMENT_SHADER, fragmentShaderSrc);
	if (!fragmentShader) {
		fprintf(stderr, "createShader(GL_FRAGMENT_SHADER) failed\n");
		glDeleteShader(vertexShader);
		return 0;
	}

	GLuint programObject = glCreateProgram();
	if (!programObject) {
		fprintf(stderr, "glCreateProgram() failed: %d\n", glGetError());
		return 0;
	}

	glAttachShader(programObject, vertexShader);
	glAttachShader(programObject, fragmentShader);

	// Link the program
	glLinkProgram(programObject);

	// Check the link status
	GLint linked = 0;
	glGetProgramiv(programObject, GL_LINK_STATUS, &linked);
	if (!linked) {
		GLint infoLen = 0;
		glGetProgramiv(programObject, GL_INFO_LOG_LENGTH, &infoLen);
		if (infoLen > 1) {
			char* infoLog = (char *)malloc(infoLen);
			glGetProgramInfoLog(programObject, infoLen, NULL, infoLog);
			fprintf(stderr, "Error linking program: %s\n", infoLog);
			free(infoLog);
		}

		glDeleteProgram(programObject);
		return 0;
	}

	// Delete these here because they are attached to the program object.
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	return programObject;
}
예제 #29
0
파일: main.c 프로젝트: riskybacon/spikes
/**
 * Create a GLSL program object from vertex and fragment shader files.
 *
 * @param  vShaderFile   The vertex shader filename
 * @param  fShaderFile   The fragment shader filename
 * @return handle to the GLSL program
 */
GLuint createGLSLProgram(const char* vertexSource, const char* fragmentSource)
{
	GLuint vertexShader;
	GLuint fragmentShader;
	char* log;
   _program = glCreateProgram();
   
   // Create vertex shader
   vertexShader  = createShader(vertexSource, GL_VERTEX_SHADER);

   // Check for compile errors
   if(!shaderCompileStatus(vertexShader))
   {
      log = getShaderLog(vertexShader);
      fprintf(stderr, "Could not compile vertex shader:\n%s\n", log);
      free(log);
      terminate(EXIT_FAILURE);
   }

   // Create fragment shader
   fragmentShader = createShader(fragmentSource, GL_FRAGMENT_SHADER);
   
   // Check for compile errors
   if(!shaderCompileStatus(fragmentShader))
   {
      log = getShaderLog(fragmentShader);
      fprintf(stderr, "Could not compile fragment shader:\n%s\n", log);
      free(log);
      terminate(EXIT_FAILURE);
   }

   // Attach the shaders to the program
   glAttachShader(_program, vertexShader);
   glAttachShader(_program, fragmentShader);
   
   // Link the program
   glLinkProgram(_program);
   
   // Check for linker errors
   if(!programLinkStatus(_program))
   {
      log = getProgramLog(_program);
      fprintf(stderr, "GLSL program filed to link:\n%s\n", log);
      free(log);
      terminate(EXIT_FAILURE);
   }

   return _program;
}
예제 #30
0
파일: Main.cpp 프로젝트: jalway/tut2
// Initialization code
void init()
{
	// Initializes the glew library
	glewInit();

	// Enables the depth test, which you will want in most cases. You can disable this in the render loop if you need to.
	glEnable(GL_DEPTH_TEST);
	

	// Read in the shader code from a file.
	std::string vertShader = readShader("VertexShader.glsl");
	std::string fragShader = readShader("FragmentShader.glsl");

	// createShader consolidates all of the shader compilation code
	vertex_shader = createShader(vertShader, GL_VERTEX_SHADER);
	fragment_shader = createShader(fragShader, GL_FRAGMENT_SHADER);

	// A shader is a program that runs on your GPU instead of your CPU. In this sense, OpenGL refers to your groups of shaders as "programs".
	// Using glCreateProgram creates a shader program and returns a GLuint reference to it.
	program = glCreateProgram();
	glAttachShader(program, vertex_shader);		// This attaches our vertex shader to our program.
	glAttachShader(program, fragment_shader);	// This attaches our fragment shader to our program.

	// This links the program, using the vertex and fragment shaders to create executables to run on the GPU.
	glLinkProgram(program);
	// End of shader and program creation

	// This gets us a reference to the uniform variable in the vertex shader, which is called "MVP".
	// We're using this variable as a 4x4 transformation matrix
	// Only 2 parameters required: A reference to the shader program and the name of the uniform variable within the shader code.
	uniMVP = glGetUniformLocation(program, "MVP");

	// Creates the view matrix using glm::lookAt.
	// First parameter is camera position, second parameter is point to be centered on-screen, and the third paramter is the up axis.
	view = glm::lookAt(	glm::vec3(0.0f, 0.0f, -1.0f), glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(0.0f, 1.0f, 0.0f));

	// Creates a projection matrix using glm::perspective.
	// First parameter is the vertical FoV (Field of View), second paramter is the aspect ratio, 3rd parameter is the near clipping plane, 4th parameter is the far clipping plane.
	proj = glm::perspective(45.0f, 800.0f / 600.0f, 0.1f, 1000.0f);

	trans = glm::rotate(trans, glm::radians(-30.0f), glm::vec3(1.0f, 0.0f, 0.0f));


	// Determines the interpretation of polygons for rasterization. The first parameter, face, determines which polygons the mode applies to.
	// The face can be either GL_FRONT, GL_BACK, or GL_FRONT_AND_BACK
	// The mode determines how the polygons will be rasterized. GL_POINT will draw points at each vertex, GL_LINE will draw lines between the vertices, and 
	// GL_FILL will fill the area inside those lines.
	glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}