本文整理汇总了C++中compileShader函数的典型用法代码示例。如果您正苦于以下问题:C++ compileShader函数的具体用法?C++ compileShader怎么用?C++ compileShader使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了compileShader函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: glCreateShader
GLuint Shaders::loadShaderFromString(const std::string& vertexSourceCode, const std::string& fragmentSourceCode)
{
// Create the shaders
GLuint vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
GLint result = GL_FALSE;
int infoLogLength;
compileShader(vertexShaderID, vertexSourceCode, &result, &infoLogLength);
compileShader(fragmentShaderID, fragmentSourceCode, &result, &infoLogLength);
// Link the program
GLuint programID = glCreateProgram();
glAttachShader(programID, vertexShaderID);
glAttachShader(programID, fragmentShaderID);
glLinkProgram(programID);
// Check the program
glGetProgramiv(programID, GL_LINK_STATUS, &result);
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
if ( infoLogLength > 0 ){
std::vector<char> programErrorMessage(infoLogLength+1);
glGetProgramInfoLog(programID, infoLogLength, NULL, &programErrorMessage[0]);
printf("%s\n", &programErrorMessage[0]);
}
glDeleteShader(vertexShaderID);
glDeleteShader(fragmentShaderID);
return programID;
}
示例2: memset
bool Shader::LoadAndCompile(const std::string& sVert, const std::string& sFrag)
{
GLhandleARB so[2];
memset(so, 0, sizeof(GLhandleARB)*2);
///Loading the shader
so[0] = loadShader(sVert.c_str());
if(so[0]==0){
std::cerr << "loading shader "+sVert+" failed" << std::endl;
return false;
}
///Compiling the shader, done by the graphic card
if(!compileShader(so[0])){
std::cerr << "compiling shader "+sVert+" failed" << std::endl;
return false;
}
so[1] = loadShader(sFrag.c_str());
if(so[1]==0){
std::cerr << "loading shader "+sFrag+" failed " << std::endl;
return false;
}
if(!compileShader(so[1])){
std::cerr << "compiling shader "+sFrag+" failed " << std::endl;
return false;
}
m_oProgram = linkShaders(so,2);
m_bIsReady = true;
return true;
}
示例3: compileShaders
static GLboolean compileShaders(const GLchar* vertexShaderSource, const GLchar* fragmentShaderSource, GLuint* shaderVertexObjectId, GLuint* shaderFragmentObjectId, GLuint* programObjectId) {
if(!compileShader(&vertexShaderSource[0], NULL, GL_VERTEX_SHADER, shaderVertexObjectId)) {
// Undo compilation
}
if(!compileShader(&fragmentShaderSource[0], NULL, GL_FRAGMENT_SHADER, shaderFragmentObjectId)){
// Undo compilation
return GL_FALSE;
}
*programObjectId = glCreateProgram();
glAttachShader(*programObjectId, *shaderVertexObjectId);
glAttachShader(*programObjectId, *shaderFragmentObjectId);
glLinkProgram(*programObjectId);
GLint linkSuccess = GL_FALSE;
glGetProgramiv(*programObjectId, GL_LINK_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256] = {0};
glGetProgramInfoLog(*programObjectId, sizeof(messages), 0, &messages[0]);
printf("Prgram compilation failed: %s", messages);
// Undo compilation
return GL_FALSE;
}
return GL_TRUE;
}
示例4: glCreateProgram
bool GLSLProgram::compileShaders(const std::string& vertexShaderFilePath, const std::string& fragmentShaderFilePath)
{
//Create the program to bind shader in
_programID = glCreateProgram();
//Create shader programs:
_vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
if (_vertexShaderID == 0)
{
fatalError("Vertex shader failed to be created");
return false;
}
_fragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
if (_fragmentShaderID == 0)
{
fatalError("Fragment shader failed to be created");
return false;
}
//open, read and compile each program
//compile vertex shader
if (!compileShader(vertexShaderFilePath, _vertexShaderID))
{
return false;
}
//compile fragment shader
if (!compileShader(fragmentShaderFilePath, _fragmentShaderID))
{
return false;
}
return true;
}
示例5: linkProgram
//------------------------------------------------------------------------------
GLuint linkProgram(const char *define) {
GLuint vertexShader = compileShader(GL_VERTEX_SHADER,
"VERTEX_SHADER", define);
GLuint geometryShader = compileShader(GL_GEOMETRY_SHADER,
"GEOMETRY_SHADER", define);
GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER,
"FRAGMENT_SHADER", define);
GLuint program = glCreateProgram();
glAttachShader(program, vertexShader);
glAttachShader(program, geometryShader);
glAttachShader(program, fragmentShader);
glBindAttribLocation(program, 0, "position");
glBindAttribLocation(program, 1, "normal");
glLinkProgram(program);
glDeleteShader(vertexShader);
glDeleteShader(geometryShader);
glDeleteShader(fragmentShader);
GLint status;
glGetProgramiv(program, GL_LINK_STATUS, &status );
if( status == GL_FALSE ) {
GLchar emsg[1024];
glGetProgramInfoLog(program, sizeof(emsg), 0, emsg);
fprintf(stderr, "Error linking GLSL program : %s\n", emsg );
exit(0);
}
return program;
}
示例6: glCreateProgram
void GLSLProgram::compileShaders(const std::string& vertexShaderFilePath, const std::string& fragmentShaderFilePath)
{
//Vertex and fragment shaders are successfully compiled.
//Now time to link them together into a program.
//Get a program object.
programID = glCreateProgram();
vertexShaderID = glCreateShader(GL_VERTEX_SHADER);
if (vertexShaderID == 0)
{
std::printf("ERROR : could not create Vertex shader");
}
fragShaderID = glCreateShader(GL_FRAGMENT_SHADER);
if (fragShaderID == 0)
{
std::printf("ERROR : could not create Fragment shader");
}
compileShader(vertexShaderFilePath, vertexShaderID);
compileShader(fragmentShaderFilePath, fragShaderID);
}
示例7: compileShader
void GpuProgram::create(const char* vs, const char* fs) {
GLuint vertexID = compileShader(vs, GL_VERTEX_SHADER);
GLuint fragmentID = compileShader(fs, GL_FRAGMENT_SHADER);
name_ = glCreateProgram();
OGLERROR;
glAttachShader(name_, vertexID);
OGLERROR;
glAttachShader(name_, fragmentID);
OGLERROR;
glLinkProgram(name_);
OGLERROR;
#ifdef _DEBUG
glGetProgramiv(name_, GL_LINK_STATUS, &success_);
OGLERROR;
if (!success_) {
glGetProgramInfoLog(name_, 512, nullptr, logProgram_);
OGLERROR;
printf("%s", logProgram_);
}
#endif
glDeleteShader(vertexID);
OGLERROR;
glDeleteShader(fragmentID);
OGLERROR;
}
示例8: buildProgram
GLProgram buildProgram(VSrc&& vsrc, GSrc&& gsrc, FSrc&& fsrc) {
GLShader vs = compileShader(GL_VERTEX_SHADER, std::forward<VSrc>(vsrc));
GLShader gs = compileShader(GL_GEOMETRY_SHADER, std::forward<GSrc>(gsrc));
GLShader fs = compileShader(GL_FRAGMENT_SHADER, std::forward<FSrc>(fsrc));
return buildProgram({ std::move(vs), std::move(gs), std::move(fs) });
}
示例9: loadShaders
void loadShaders(GLuint *_positionSlot, GLuint *_colorSlot) {
GLuint vertex = compileShader(GL_VERTEX_SHADER, VERTEX_SHADER_CODE);
GLuint fragment = compileShader(GL_FRAGMENT_SHADER, FRAGMENT_SHADER_CODE);
GLuint program = glCreateProgram();
glAttachShader(program, vertex);
glAttachShader(program, fragment);
glLinkProgram(program);
GLint linkSuccess;
glGetShaderiv(program, GL_COMPILE_STATUS, &linkSuccess);
if (linkSuccess == GL_FALSE) {
GLchar messages[256];
glGetProgramInfoLog(program, sizeof(messages), NULL, &messages[0]);
printf("Program linking error: %s\n", messages);
exit(1);
}
glUseProgram(program);
*_positionSlot = glGetAttribLocation(program, "Position");
*_colorSlot = glGetAttribLocation(program, "SourceColor");
glEnableVertexAttribArray(*_positionSlot);
glEnableVertexAttribArray(*_colorSlot);
return;
}
示例10: init
void init(Data*data){
data->cameraTransform = std::make_shared<OrbitCamera>();
data->cameraProjection = std::make_shared<PerspectiveCamera>(
glm::half_pi<float>(),
(float)data->window.width/data->window.height);
data->program = createProgram(
compileShader(GL_VERTEX_SHADER ,loadFile("shaders/orbitManipulator.vp")),
compileShader(GL_FRAGMENT_SHADER,loadFile("shaders/orbitManipulator.fp")));
data->mvpUniform = glGetUniformLocation(data->program,"mvp");
glGenBuffers(1,&data->vbo);
glBindBuffer(GL_ARRAY_BUFFER,data->vbo);
float vertices[]={0,0,0,1, 1,0,0,1, 0,1,0,1};
glBufferData(GL_ARRAY_BUFFER,sizeof(vertices),vertices,GL_STATIC_DRAW);
glGenVertexArrays(1,&data->vao);
glBindVertexArray(data->vao);
glBindBuffer(GL_ARRAY_BUFFER,data->vbo);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0,4,GL_FLOAT,GL_FALSE,sizeof(float)*4,0);
glBindVertexArray(0);
glClearColor(0,0,0,1);
glDisable(GL_CULL_FACE);
}
示例11: showShaderInfoLog
GLuint ShaderManager::buildProgram(const Shader& vshaderInstance, const Shader& fhaderInstance, const Shader& ghaderInstance)
{
if (!compileShader(vshaderInstance))
{
showShaderInfoLog(vshaderInstance);
}
if (!compileShader(fhaderInstance))
{
showShaderInfoLog(fhaderInstance);
}
if (!compileShader(ghaderInstance))
{
showShaderInfoLog(ghaderInstance);
}
GLuint program = glCreateProgram();
glAttachShader(program, vshaderInstance.getID());
glAttachShader(program, fhaderInstance.getID());
glLinkProgram(program);
GLint linked;
glGetProgramiv(program, GL_LINK_STATUS, &linked);
if (!linked)
{
showProgramInfoLog(program);
}
glDeleteShader(vshaderInstance.getID());
glDeleteShader(fhaderInstance.getID());
return program;
}
示例12: LoadShaders
GLuint LoadShaders(const char *vertFile,const char * fragFile)
{
GLuint vShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint fShaderID = glCreateShader(GL_FRAGMENT_SHADER);
char * vShaderSource = readFile(vertFile);
char * fShaderSource = readFile(fragFile);
compileShader(vShaderID, vShaderSource);
compileShader(fShaderID, fShaderSource);
GLuint programID = glCreateProgram();
glAttachShader(programID, vShaderID);
glAttachShader(programID, fShaderID);
glLinkProgram(programID);
GLint result;
int infoLogLength;
glGetProgramiv(programID, GL_LINK_STATUS, &result);
if (result != GL_TRUE)
{
glGetProgramiv(programID, GL_INFO_LOG_LENGTH, &infoLogLength);
char *buf = (char *)malloc(infoLogLength+1);
glGetProgramInfoLog(programID, infoLogLength, NULL, buf);
fprintf(stderr,"%s\n", buf);
free(buf);
}
glDeleteShader(vShaderID);
glDeleteShader(fShaderID);
return programID;
}
示例13: glCreateProgram
void Shader::load() {
Renderer *renderer = Naquadah::getRenderer();
if (renderer != nullptr) {
std::string vertexCode = FileIO::mergeLines(FileIO::readTextFile(vertexFilename));
std::string fragmentCode = FileIO::mergeLines(FileIO::readTextFile(fragmentFilename));
std::string geometryCode = FileIO::mergeLines(FileIO::readTextFile(geometryFilename));
std::string tessCtrlCode = FileIO::mergeLines(FileIO::readTextFile(tessCtrlFilename));
std::string tessEvalCode = FileIO::mergeLines(FileIO::readTextFile(tessEvalFilename));
this->program = glCreateProgram();
vertexId = compileShader(program, GL_VERTEX_SHADER, vertexCode.c_str());
fragmentId = compileShader(program, GL_FRAGMENT_SHADER, fragmentCode.c_str());
if (geometryCode.size() > 0)
geometryId = compileShader(program, GL_GEOMETRY_SHADER, geometryCode.c_str());
if (tessCtrlCode.size() > 0 && tessEvalCode.size() > 0) {
tessCtrlId = compileShader(program, GL_TESS_CONTROL_SHADER, tessCtrlCode.c_str());
tessEvalId = compileShader(program, GL_TESS_EVALUATION_SHADER, tessEvalCode.c_str());
}
setDefaultAttributes();
if (linkProgram(program))
valid = true;
} else
valid = false;
loaded = true;
}
示例14: compileShader
GLuint shaderhelper::createProgram(const std::string & vertexFilename, const std::string & fragmentFilename)
{
GLuint vertexShaderId = compileShader(vertexFilename, GL_VERTEX_SHADER);
GLuint fragmentShaderId = compileShader(fragmentFilename, GL_FRAGMENT_SHADER);
GLuint programId = glCreateProgram();
glAttachShader(programId, vertexShaderId);
glAttachShader(programId, fragmentShaderId);
glLinkProgram(programId);
GLint compilationSuccess = GL_FALSE;
int infoLogLength;
glGetProgramiv(programId, GL_LINK_STATUS, &compilationSuccess);
glGetProgramiv(programId, GL_INFO_LOG_LENGTH, &infoLogLength);
if (infoLogLength > 0) {
std::vector<char> programErrorMessage((unsigned long) (infoLogLength + 1));
glGetProgramInfoLog(programId, infoLogLength, nullptr, &programErrorMessage[0]);
throw std::runtime_error(&programErrorMessage[0]);
}
glDeleteShader(vertexShaderId);
glDeleteShader(fragmentShaderId);
return programId;
}
示例15: glCreateShader
GLuint ShaderProgram::loadShaders(const char * vertex_file_path, const char * fragment_file_path ) {
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Compile both shaders. Exit if compile errors.
if ( !compileShader(vertex_file_path, VertexShaderID)
|| !compileShader(fragment_file_path, FragmentShaderID) ) {
return 0;
}
// Link the program
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);
// Check the program
GLint Result = GL_FALSE;
int InfoLogLength;
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if ( InfoLogLength > 0 ) {
std::vector<char> ProgramErrorMessage(InfoLogLength+1);
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
std::cerr << &ProgramErrorMessage[0] << std::endl;
}
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return ProgramID;
}