自学教程：C++ CreateProgram函数代码示例

const char* PezInitialize(int width, int height){    BuddhaMesh = CreateMesh("buddha.ctm");    QuadVbo = CreateQuad(-1, -1, 1, 1);    #ifdef LIGHTING    DepthProgram = CreateProgram("Glass.Vertex", "Glass.Fragment.Lighting" SUFFIX);    AbsorptionProgram = CreateProgram("Glass.Vertex.Quad", "Glass.Fragment.Blit" SUFFIX);#else    DepthProgram = CreateProgram("Glass.Vertex", "Glass.Fragment.Depth" SUFFIX);    AbsorptionProgram = CreateProgram("Glass.Vertex.Quad", "Glass.Fragment.Absorption" SUFFIX);#endif    // Create a floating-point render target:    GLuint textureHandle;    glGenTextures(1, &textureHandle);    glBindTexture(GL_TEXTURE_2D, textureHandle);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);    #ifdef LIGHTING    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 768, 1024, 0, GL_RGB, GL_UNSIGNED_BYTE, 0);#elif defined(__IPAD__)    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 768, 1024, 0, GL_LUMINANCE, GL_HALF_FLOAT_OES, 0);#else    glTexImage2D(GL_TEXTURE_2D, 0, GL_RG16F, 768, 1024, 0, GL_RG, GL_FLOAT, 0);#endif        PezCheckCondition(GL_NO_ERROR == glGetError(), "This passes on Mac OS X and iOS.");    OffscreenTexture = textureHandle;        GLuint fboHandle;    glGenFramebuffers(1, &fboHandle);    glBindFramebuffer(GL_FRAMEBUFFER, fboHandle);    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textureHandle, 0);#ifdef LIGHTING    GLuint depthRenderbuffer;    glGenRenderbuffers(1, &depthRenderbuffer);    glBindRenderbuffer(GL_RENDERBUFFER, depthRenderbuffer);    glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, width, height);    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, depthRenderbuffer);#endif    PezCheckCondition(GL_FRAMEBUFFER_COMPLETE == glCheckFramebufferStatus(GL_FRAMEBUFFER), "This asserts on iOS and passes on Mac OS X.");    OffscreenFbo = fboHandle;    glBindFramebuffer(GL_FRAMEBUFFER, 0);    glBindRenderbuffer(GL_RENDERBUFFER, 0);        // Set up the projection matrix:    const float HalfWidth = 0.5;    const float HalfHeight = HalfWidth * PEZ_VIEWPORT_HEIGHT / PEZ_VIEWPORT_WIDTH;    ProjectionMatrix = M4MakeFrustum(-HalfWidth, +HalfWidth, -HalfHeight, +HalfHeight, 5, 20);    return "Glass Demo";}

boolShaderProgramOGL::Initialize(){  NS_ASSERTION(mProgramState == STATE_NEW, "Shader program has already been initialised");  if (!CreateProgram(mProfile.mVertexShaderString,                     mProfile.mFragmentShaderString)) {    mProgramState = STATE_ERROR;    return false;  }  mProgramState = STATE_OK;  for (uint32_t i = 0; i < KnownUniform::KnownUniformCount; ++i) {    mProfile.mUniforms[i].mLocation =      mGL->fGetUniformLocation(mProgram, mProfile.mUniforms[i].mNameString);  }  for (uint32_t i = 0; i < mProfile.mAttributes.Length(); ++i) {    mProfile.mAttributes[i].mLocation =      mGL->fGetAttribLocation(mProgram, mProfile.mAttributes[i].mName);    NS_ASSERTION(mProfile.mAttributes[i].mLocation >= 0, "Bad attribute location.");  }  mProfile.mHasMatrixProj = mProfile.mUniforms[KnownUniform::MatrixProj].mLocation != -1;  return true;}

Graphics::ShaderProgram* ShaderManager::GetNewShaderProgram(const istring &filename){    auto strings = Utility::File::ParseToStrings(filename);    auto shader = new Graphics::ShaderProgram();    shader->CreateProgram();    for (auto str : strings)    {        auto type = str[0];        auto sfile = str.substr(2);        switch (type)        {        case 'F':            shader->CompileShader(sfile.c_str(), GL_FRAGMENT_SHADER, false);            break;        case 'V':            shader->CompileShader(sfile.c_str(), GL_VERTEX_SHADER, false);            break;        default:            std::cout << "Invalid shader Type=[" << type << "] specified in FileName=[" << filename << "]";            return nullptr;        }    }    shader->LinkProgram();    shader->SetShaderName(filename);    return shader;}

cl_int buildCachedProgram(ocl_constructs * occs, char * filebase, const char * options){  cl_int error = 0;  if(occs->program != NULL)    return error;  char binaryName[256];  binaryName[0] = '/0';  strcat(binaryName, filebase);  strcat(binaryName, ".bin");  occs->program = CreateProgramFromBinary(occs->context, occs->deviceId, binaryName, options);  if(occs->program == NULL){    occs->program = CreateProgram(occs->context, occs->deviceId, filebase, options);    if(occs->program == NULL){      //Cleanup(context, commandQueue, program, kernel, memObjects);      fprintf(stderr, "cachedProgram.c::buildCachedProgram failed to build program/n");      return 1;    }    if(SaveProgramBinary(occs->program, occs->deviceId, binaryName)){      fprintf(stderr, "cachedProgram.c::buildCachedProgram failed to save program binary/n");      //CLeanup      return 2;    }  }  return error;}

bool GrGLShaderBuilder::finish() {    SkASSERT(0 == fOutput.fProgramID);    GL_CALL_RET(fOutput.fProgramID, CreateProgram());    if (!fOutput.fProgramID) {        return false;    }    SkTDArray<GrGLuint> shadersToDelete;    if (!this->compileAndAttachShaders(fOutput.fProgramID, &shadersToDelete)) {        GL_CALL(DeleteProgram(fOutput.fProgramID));        return false;    }    this->bindProgramLocations(fOutput.fProgramID);    if (fUniformManager->isUsingBindUniform()) {        fUniformManager->getUniformLocations(fOutput.fProgramID, fUniforms);    }    GL_CALL(LinkProgram(fOutput.fProgramID));    // Calling GetProgramiv is expensive in Chromium. Assume success in release builds.    bool checkLinked = !fGpu->ctxInfo().isChromium();#ifdef SK_DEBUG    checkLinked = true;#endif    if (checkLinked) {        GrGLint linked = GR_GL_INIT_ZERO;        GL_CALL(GetProgramiv(fOutput.fProgramID, GR_GL_LINK_STATUS, &linked));        if (!linked) {            GrGLint infoLen = GR_GL_INIT_ZERO;            GL_CALL(GetProgramiv(fOutput.fProgramID, GR_GL_INFO_LOG_LENGTH, &infoLen));            SkAutoMalloc log(sizeof(char)*(infoLen+1));  // outside if for debugger            if (infoLen > 0) {                // retrieve length even though we don't need it to workaround                // bug in chrome cmd buffer param validation.                GrGLsizei length = GR_GL_INIT_ZERO;                GL_CALL(GetProgramInfoLog(fOutput.fProgramID,                                          infoLen+1,                                          &length,                                          (char*)log.get()));                GrPrintf((char*)log.get());            }            SkDEBUGFAIL("Error linking program");            GL_CALL(DeleteProgram(fOutput.fProgramID));            fOutput.fProgramID = 0;            return false;        }    }    if (!fUniformManager->isUsingBindUniform()) {        fUniformManager->getUniformLocations(fOutput.fProgramID, fUniforms);    }    for (int i = 0; i < shadersToDelete.count(); ++i) {      GL_CALL(DeleteShader(shadersToDelete[i]));    }    return true;}

mjSkyboxShaders::mjSkyboxShaders(){	// Set up shader	CreateProgram(skyboxVertexShaderCode, skyboxFragmentShaderCode);	name = new char[7];	strncpy(name, "skybox", strnlen("skybox", 10)+1);    LOGI("%s %d: new %s", __FILE__, __LINE__, "char[] for skybox shader name");    checkGlError("create glProgram");    // Get the texture handle location    maTextureHandle = glGetUniformLocation(glProgramHandle, "uTexture");    maMVPMatrixHandle = glGetUniformLocation(glProgramHandle, "maMVPMatrix");    maMMatrixHandle = glGetUniformLocation(glProgramHandle, "maMMatrix");    checkGlError("getting parameters");    LOGI("textureHandle %d, mvpMAtrixHandle %d", maTextureHandle, maMVPMatrixHandle);    enableDepthMask = false;    enableDepthTest = false;}

WebGLProgram::WebGLProgram(WebGLContext* webgl)    : WebGLContextBoundObject(webgl)    , mGLName(CreateProgram(webgl->GL()))    , mTransformFeedbackBufferMode(LOCAL_GL_NONE){    mContext->mPrograms.insertBack(this);}

void CreateBoundaries(Surface dest, int width, int height){	glBindFramebuffer(GL_FRAMEBUFFER, dest.FboHandle);	glViewport(0, 0, width, height);    glClearColor(0, 0, 0, 0);    glClear(GL_COLOR_BUFFER_BIT);	GLuint vao;    glGenVertexArrays(1, &vao);    glBindVertexArray(vao);	GLuint program = CreateProgram("Vertex.ver", "Fill.frag");	glUseProgram(program);	#define T 0.9999f    float positions[] = { -T, -T, T, -T, T,  T, -T,  T, -T, -T };    #undef T    GLuint vbo;    GLsizeiptr size = sizeof(positions);    glGenBuffers(1, &vbo);    glBindBuffer(GL_ARRAY_BUFFER, vbo);    glBufferData(GL_ARRAY_BUFFER, size, positions, GL_STATIC_DRAW);    GLsizeiptr stride = 2 * sizeof(positions[0]);    glEnableVertexAttribArray(PositionSlot);    glVertexAttribPointer(PositionSlot, 2, GL_FLOAT, GL_FALSE, stride, 0);    glDrawArrays(GL_LINE_STRIP, 0, 5);    glDeleteBuffers(1, &vbo);	glDeleteProgram(program);    glDeleteVertexArrays(1, &vao);}

void InitializeProgram(){    std::vector<GLuint> shaderList;        shaderList.push_back(LoadShader(GL_VERTEX_SHADER, "PosColorLocalTransform.vert"));    shaderList.push_back(LoadShader(GL_FRAGMENT_SHADER, "ColorPassthrough.frag"));    theProgram = CreateProgram(shaderList);    positionAttrib = glGetAttribLocation(theProgram, "position");    colorAttrib = glGetAttribLocation(theProgram, "color");    modelToCameraMatrixUnif = glGetUniformLocation(theProgram, "modelToCameraMatrix");    cameraToClipMatrixUnif = glGetUniformLocation(theProgram, "cameraToClipMatrix");    float zNear = 1.0f;    float zFar = 100.0f;    cameraToClipMatrix[0].x = frustumScale;    cameraToClipMatrix[1].y = frustumScale;    cameraToClipMatrix[2].z = (zFar + zNear) / (zNear - zFar);    cameraToClipMatrix[2].w = -1.0f;    cameraToClipMatrix[3].z = (2 * zFar * zNear) / (zNear - zFar);    glUseProgram(theProgram);    glUniformMatrix4fv(cameraToClipMatrixUnif, 1, GL_FALSE, glm::value_ptr(cameraToClipMatrix));    glUseProgram(0);    std::for_each(shaderList.begin(), shaderList.end(), glDeleteShader);}

void InitializeProgram(){    std::vector<GLuint> shaderList;    shaderList.push_back(LoadShader(GL_VERTEX_SHADER, "Standard.vert"));    shaderList.push_back(LoadShader(GL_FRAGMENT_SHADER, "Standard.frag"));    theProgram = CreateProgram(shaderList);    offsetUniform = glGetUniformLocation(theProgram, "offset");    perspectiveMatrixUnif = glGetUniformLocation(theProgram, "perspectiveMatrix");    float zNear = 1.0f;    float zFar = 3.0f;    memset(perspectiveMatrix, 0, sizeof(float) * 16);    perspectiveMatrix[0] = frustumScale;    perspectiveMatrix[5] = frustumScale;    perspectiveMatrix[10] = (zFar + zNear) / (zNear - zFar);    perspectiveMatrix[14] = (2 *zFar * zNear) / (zNear - zFar);    perspectiveMatrix[11] = -1.0f;    glUseProgram(theProgram);    glUniformMatrix4fv(perspectiveMatrixUnif, 1, GL_FALSE, perspectiveMatrix);    glUseProgram(0);    std::for_each(shaderList.begin(), shaderList.end(), glDeleteShader);}

// load shaders.bool COGModelShader::Load (OGShaderID _Id, const std::string& _VertShader, const std::string& _FragmentShader){    if(ShaderLoadFromFile(_FragmentShader.c_str(), GL_FRAGMENT_SHADER, &m_uiFragShader) == 0)        return false;    if(ShaderLoadFromFile(_VertShader.c_str(), GL_VERTEX_SHADER, &m_uiVertShader) == 0)        return false;    const char* pszAttribs[] = { "inVertex", "inNormal", "inTexCoord" };    if (CreateProgram(&m_uiId, m_uiVertShader, m_uiFragShader, pszAttribs, 3) == 0)        return false;    m_uiMVPMatrixLoc = glGetUniformLocation(m_uiId, "MVPMatrix");    m_uiMVMatrixLoc = glGetUniformLocation(m_uiId, "MVMatrix");    m_uiLightDirLoc = glGetUniformLocation(m_uiId, "LightDirection");    m_uiTextureLoc = glGetUniformLocation(m_uiId, "sTexture");    m_uiFogEndLoc = glGetUniformLocation(m_uiId, "FogEnd");    m_uiFogRcpDiffLoc = glGetUniformLocation(m_uiId, "FogRcpEndStartDiff");    m_uiFogColorLoc = glGetUniformLocation(m_uiId, "FogColor");    m_uiFogEnabled = glGetUniformLocation(m_uiId, "FogEnabled");    m_uiMaterialAmbient = glGetUniformLocation(m_uiId, "MaterialAmbient");    m_uiMaterialDiffuse = glGetUniformLocation(m_uiId, "MaterialDiffuse");    m_Id = _Id;    return true;}

Program::Program(Shader &Vertex,Shader &Fragment){	GLuint Shaders[2];	Shaders[0] = Vertex.ReturnShader();	Shaders[1] = Fragment.ReturnShader();	pr = CreateProgram(Shaders,2);}

void gles2_init_shaders () {	memset(&shader, 0, sizeof(ShaderInfo));	// Load custom shaders   	float input_size[2], output_size[2], texture_size[2];		shader.program = CreateProgram(vertex_shader_custom, fragment_shader_custom_scanlines_16bit);	if(shader.program)	{		shader.u_vp_matrix   = glGetUniformLocation(shader.program, "MVPMatrix");  	 	shader.a_texcoord    = glGetAttribLocation(shader.program, "TexCoord");		shader.a_position    = glGetAttribLocation(shader.program, "VertexCoord");				shader.input_size    = glGetUniformLocation(shader.program, "InputSize");		shader.output_size   = glGetUniformLocation(shader.program, "OutputSize");		shader.texture_size  = glGetUniformLocation(shader.program, "TextureSize");	}	input_size [0]  = _dispvars->texture_width;   	input_size [1]  = _dispvars->texture_height;	output_size[0]  = _dispvars->output_width;	output_size[1]  = _dispvars->output_height;	texture_size[0] = _dispvars->texture_width;	texture_size[1] = _dispvars->texture_height;	if(!shader.program) 		exit(0);		glUseProgram(shader.program); SHOW_ERROR	glUniform2fv(shader.input_size, 1, input_size);	glUniform2fv(shader.output_size, 1, output_size);	glUniform2fv(shader.texture_size, 1, texture_size);}

GLuint LinkShaders3(GLuint vertShader, GLuint geomShader, GLuint fragShader) {  GLuint program = CreateProgram();  assert(vertShader || fragShader);  if (vertShader) AttachShader(program, vertShader);  if (geomShader) AttachShader(program, geomShader);  if (fragShader) AttachShader(program, fragShader);  LinkProgram(program);  /* check link */  {    GLint stat;    GetProgramiv(program, GL_LINK_STATUS, &stat);    if (!stat) {      GLchar log[1000];      GLsizei len;      GetProgramInfoLog(program, 1000, &len, log);      wxLogError(wxT("BR24radar_pi: problem linking program: %s"), log);      return 0;    }  }  return program;}

boolShaderProgramOGL::Initialize(){  NS_ASSERTION(mProgramState == STATE_NEW, "Shader program has already been initialised");  if (!CreateProgram(mProfile.mVertexShaderString,                     mProfile.mFragmentShaderString)) {    mProgramState = STATE_ERROR;    return false;  }  mProgramState = STATE_OK;  for (uint32_t i = 0; i < mProfile.mUniforms.Length(); ++i) {    mProfile.mUniforms[i].mLocation =      mGL->fGetUniformLocation(mProgram, mProfile.mUniforms[i].mName);    NS_ASSERTION(mProfile.mUniforms[i].mLocation >= 0, "Bad uniform location.");  }  for (uint32_t i = 0; i < mProfile.mAttributes.Length(); ++i) {    mProfile.mAttributes[i].mLocation =      mGL->fGetAttribLocation(mProgram, mProfile.mAttributes[i].mName);    NS_ASSERTION(mProfile.mAttributes[i].mLocation >= 0, "Bad attribute location.");  }  // this is a one-off that's present in the 2DRect versions of some shaders.  mTexCoordMultiplierUniformLocation =    mGL->fGetUniformLocation(mProgram, "uTexCoordMultiplier");  return true;}

GLuint Shader::Initialize(std::string vert_file_name, std::string frag_file_name) {	GLuint vert_id, frag_id;	assert(CreateShader(vert_file_name, &vert_id, GL_VERTEX_SHADER));	assert(CreateShader(frag_file_name, &frag_id, GL_FRAGMENT_SHADER));	assert(CreateProgram(vert_id, frag_id, &ShaderId));	return ShaderId;}

static u32 createprogram() {  programnum++;#if defined(__WEBGL__)  return glCreateProgram();#else  return CreateProgram();#endif // __WEBGL__}

bool GLSLShader::CompileAndLink(){    m_programId = CreateProgram(m_pVertexShaderSource->c_str(), m_pFragmentShaderSource->c_str());    LOGD("GLSL program handle create: %d", m_programId);    return m_programId == 0 ? false : true;}

WebGLProgram::WebGLProgram(WebGLContext* webgl)    : WebGLRefCountedObject(webgl)    , mGLName(CreateProgram(webgl->GL()))    , mNumActiveTFOs(0)    , mNextLink_TransformFeedbackBufferMode(LOCAL_GL_SEPARATE_ATTRIBS){    mContext->mPrograms.insertBack(this);}

 //------------------------------------------------------------------------------ GLShader::GLShader(const std::string& vertexShader, const std::string& fragmentShader) noexcept {     m_vertexShaderId = CompileShader(vertexShader, GL_VERTEX_SHADER);     m_fragmentShaderId = CompileShader(fragmentShader, GL_FRAGMENT_SHADER);     m_programId = CreateProgram(m_vertexShaderId, m_fragmentShaderId);          BuildAttributeHandleMap(); }

Shader::Shader(const std::string& fileName){	CreateShader(GL_VERTEX_SHADER, fileName + ".vs");	CreateShader(GL_GEOMETRY_SHADER, fileName + ".gs");	CreateShader(GL_FRAGMENT_SHADER, fileName + ".fs");	CreateProgram();}

void InitializeProgram(void) {    std::cout << "OpenGL initialization function/n" << std::endl;    std::vector<GLuint> shaders;    shaders.push_back(LoadShader(GL_VERTEX_SHADER, "pass_along.vert"));    shaders.push_back(LoadShader(GL_FRAGMENT_SHADER, "uniform_color.frag"));    shader_program = CreateProgram(shaders);    std::for_each(shaders.begin(), shaders.end(), glDeleteShader);}

ShaderProgram::ShaderProgram(FragmentShader *pFragmentShader, VertexShader *pVertexShader){    Init();    SetFragmentShader(pFragmentShader);    SetVertexShader(pVertexShader);    CreateProgram();}

void GlHelper::InitializeProgram() {    std::vector<GLuint> shaderList;    shaderList.push_back(CreateShader(GL_VERTEX_SHADER, "./vertex.shader"));    shaderList.push_back(CreateShader(GL_FRAGMENT_SHADER, "./fragment.shader"));    theProgram = CreateProgram(shaderList);    std::for_each(shaderList.begin(), shaderList.end(), glDeleteShader);}

void InitializeProgram(){	GLuint shaderList[2];		shaderList[0] = CreateShader(GL_FRAGMENT_SHADER, "dat/gengine.frag");	shaderList[1] = CreateShader(GL_VERTEX_SHADER, "dat/gengine.vert");		CreateProgram(shaderList);}

void SimpleGLWindow::Initialize(u32 flags) {	RECT rect;	GetWindowRect(hWnd_, &rect);	SetFlags(flags);	SetupGL();	ResizeGL(rect.right-rect.left,rect.bottom-rect.top);	CreateProgram();	GenerateChecker();}

void InitializeProgram() {  std::vector<GLuint> shaderList;  shaderList.push_back( CreateShader( GL_VERTEX_SHADER, strVertexShader ) );  shaderList.push_back( CreateShader( GL_FRAGMENT_SHADER, strFragmentShader ) );  theProgram = CreateProgram( shaderList );  std::for_each( std::begin( shaderList ), std::end( shaderList ), glDeleteShader );}

	void initializeProgram() {		std::vector<GLuint> shaderList;		shaderList.push_back(CreateShader(GL_VERTEX_SHADER, VSbasic));		shaderList.push_back(CreateShader(GL_FRAGMENT_SHADER, FSbasic));		theProgram = CreateProgram(shaderList);		std::for_each(shaderList.begin(), shaderList.end(), glDeleteShader);	}

void InitializeProgram(){    std::vector<GLuint> shaderList;    shaderList.push_back(LoadShader(GL_VERTEX_SHADER, "FragPosition.vert"));    shaderList.push_back(LoadShader(GL_FRAGMENT_SHADER, "FragPosition.frag"));    theProgram = CreateProgram(shaderList);    std::for_each(shaderList.begin(), shaderList.end(), glDeleteShader);}

// --------------------------------------------------------------------------------------------------------------------GLuint CreateProgram(const std::string& _vsFilename, const std::string& _psFilename, const std::string& _shaderPrefix, const char** _uniformNames, GLuint* _outUniformLocations){    GLuint retProg = CreateProgram(_vsFilename, _psFilename, _shaderPrefix);    if (retProg != 0) {        for (int i = 0; _uniformNames[i] != nullptr; ++i) {            _outUniformLocations[i] = glGetUniformLocation(retProg, _uniformNames[i]);        }    }    return retProg;}