本文整理汇总了C++中compile_shader函数的典型用法代码示例。如果您正苦于以下问题:C++ compile_shader函数的具体用法?C++ compile_shader怎么用?C++ compile_shader使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了compile_shader函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的C++代码示例。
示例1: create_simple_program
static GLuint create_simple_program(const GLchar * vsource, int vsource_size, const GLchar *fsource, int fsource_size ) {
GLuint program = 0;
GLuint vshader = 0;
GLuint fshader = 0;
GLint linkedparam = GL_FALSE;
program = glCreateProgram();
vshader = compile_shader( GL_VERTEX_SHADER, vsource, vsource_size );
fshader = compile_shader( GL_FRAGMENT_SHADER, fsource, fsource_size );
if(program && vshader && fshader)
linkedparam = link_program( program, vshader, fshader);
if( vshader )
glDeleteShader( vshader );
if( fshader )
glDeleteShader( fshader );
if(program && (linkedparam != GL_TRUE))
glDeleteProgram(program);
if (linkedparam != GL_TRUE)
program = 0;
return program;
}
示例2: glCreateShader
GLuint gl_context::add_shader(std::string const& vertex_file_path,
std::string const& fragment_file_path) const {
GLuint vertex_id = glCreateShader(GL_VERTEX_SHADER);
GLuint fragment_id = glCreateShader(GL_FRAGMENT_SHADER);
compile_shader(vertex_file_path, vertex_id);
compile_shader(fragment_file_path, fragment_id);
// Link the program
std::cout << "Linking program" << std::endl;
GLuint shader_id = glCreateProgram();
glAttachShader(shader_id, vertex_id);
glAttachShader(shader_id, fragment_id);
glLinkProgram(shader_id);
// Check the program
GLint result = GL_FALSE;
int info_log_length;
glGetProgramiv(shader_id, GL_LINK_STATUS, &result);
glGetProgramiv(shader_id, GL_INFO_LOG_LENGTH, &info_log_length);
if(info_log_length > 1) {
std::string err_message;
err_message.resize(info_log_length);
glGetProgramInfoLog(shader_id, info_log_length, NULL, &err_message[0]);
std::cerr << "SHADER ERROR: " << err_message << std::endl;
}
glDeleteShader(vertex_id);
glDeleteShader(fragment_id);
return shader_id;
}
示例3: build_program
GLuint build_program(const char* src_vert, const char* src_frag)
{
GLuint h_vert = compile_shader(GL_VERTEX_SHADER, src_vert);
if(!h_vert)
{
std::cerr << "Error while compiling the vertex shader" << std::endl;
return 0;
}
GLuint h_frag = compile_shader(GL_FRAGMENT_SHADER, src_frag);
if(!h_frag)
{
std::cerr << "Error wihle compiling the fragment shader" << std::endl;
return 0;
}
GLuint h_prog = glCreateProgram();
if(!h_prog)
{
std::cerr << "Program object creation failed." << std::endl;
return h_prog;
}
glAttachShader( h_prog, h_vert );
glAttachShader( h_prog, h_frag );
glLinkProgram( h_prog );
if(!check_link_status(h_prog)) return 0;
return h_prog;
}
示例4: create_rectangle_program
// Compile rectnagle program
void create_rectangle_program(rectangle_t *state)
{
// Compile vertex shader
GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
#ifdef RASPI
compile_shader(vertexShader, "SPH/shaders/rectangle_es.vert");
#else
compile_shader(vertexShader, "shaders/rectangle.vert");
#endif
// Compile frag shader
GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
#ifdef RASPI
compile_shader(fragmentShader, "SPH/shaders/rectangle_es.frag");
#else
compile_shader(fragmentShader, "shaders/rectangle.frag");
#endif
// Create shader program
state->rectangle_program = glCreateProgram();
glAttachShader(state->rectangle_program, vertexShader);
glAttachShader(state->rectangle_program, fragmentShader);
// Link and use program
glLinkProgram(state->rectangle_program);
show_program_log(state->rectangle_program);
// Get rectangle location
state->color_location = glGetUniformLocation(state->rectangle_program, "color");
state->position_location = glGetAttribLocation(state->rectangle_program, "position");
}
示例5: read_shader
void Shader::LoadShader(const char* vertex_file_path,const char* fragment_file_path){
GLuint VertexShaderID=glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID=glCreateShader(GL_FRAGMENT_SHADER);
std::string VertexShaderCode;
read_shader(VertexShaderCode,vertex_file_path);
std::string FragmentShaderCode;
read_shader(FragmentShaderCode,fragment_file_path);
GLint Result=GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
compile_shader(VertexShaderID,VertexShaderCode);
check_shader(VertexShaderID,Result,InfoLogLength);// Check Vertex Shader
// Compile Fragment Shader
compile_shader(FragmentShaderID,FragmentShaderCode);
check_shader(FragmentShaderID,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);
check_program(ProgramID,InfoLogLength);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
programID=ProgramID;
}
示例6: init_shaders
void init_shaders(void)
{
GLuint vs, fs;
char *vs_source, *fs_source;
GLint vs_length, fs_length;
vs = glCreateShader(GL_VERTEX_SHADER);
fs = glCreateShader(GL_FRAGMENT_SHADER);
vs_source = read_file(VERTEX_SOURCE, &vs_length);
fs_source = read_file(FRAG_SOURCE , &fs_length);
glShaderSource(vs, 1, (const char**)&vs_source, &vs_length);
glShaderSource(fs, 1, (const char**)&fs_source, &fs_length);
compile_shader(vs);
compile_shader(fs);
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glLinkProgram(prog);
}
示例7: init_shaders
/* Create and compile shaders */
void init_shaders(void) {
GLuint vs, fs, prog;
char *vs_source, *fs_source;
size_t vs_length, fs_length;
vs = glCreateShader(GL_VERTEX_SHADER);
fs = glCreateShader(GL_FRAGMENT_SHADER);
vs_source = read_file(VERTEX_SHADER, &vs_length);
fs_source = read_file(FRAGMENT_SHADER, &fs_length);
glShaderSource(vs, 1, (const char**)&vs_source, (GLint*)&vs_length);
glShaderSource(fs, 1, (const char**)&fs_source, (GLint*)&fs_length);
compile_shader(vs);
compile_shader(fs);
prog = glCreateProgram();
glBindAttribLocation(prog, 0, "in_coords");
glBindAttribLocation(prog, 1, "in_color");
glAttachShader(prog, vs);
glAttachShader(prog, fs);
glLinkProgram(prog);
glUseProgram(prog);
}
示例8: create_shader_from_filename
Shader* create_shader_from_filename(const std::string& filename) {
std::vector<ShaderStage*> shader_list;
{
FileData file = load_file(filename + ".vert");
shader_list.push_back(new ShaderStage(compile_shader(GL_VERTEX_SHADER, filename.c_str(), file.data())));
}
{
FileData file = load_file(filename + ".frag");
shader_list.push_back(new ShaderStage(compile_shader(GL_FRAGMENT_SHADER, filename.c_str(), file.data())));
}
for(ShaderStage* s : shader_list) {
if(s->resource == 0) {
std::for_each(shader_list.begin(), shader_list.end(), free_shaderstage);
return nullptr;
}
}
GLuint resource = link_program(filename.c_str(), shader_list);
std::for_each(shader_list.begin(), shader_list.end(), free_shaderstage);
if(resource == 0) return nullptr;
Shader* shader = new Shader();
shader->resource = resource;
init_shader(shader);
return shader;
}
示例9: load_shaders
/* Loads, compiles and activates vertex, geometry and fragment shaders */
GLuint load_shaders(const GLchar* vertex_file_path, const GLchar* fragment_file_path)
{
std::string vertex_source = read_shader_file(vertex_file_path);
std::string fragment_source = read_shader_file(fragment_file_path);
GLuint vertex = compile_shader((GLchar*) vertex_source.c_str(), GL_VERTEX_SHADER, vertex_file_path);
GLuint fragment = compile_shader((GLchar*) fragment_source.c_str(), GL_FRAGMENT_SHADER, fragment_file_path);
GLuint program = glCreateProgram();
glAttachShader(program, vertex);
glAttachShader(program, fragment);
glLinkProgram(program);
GLint success;
GLchar info_log[512];
glGetProgramiv(program, GL_LINK_STATUS, &success);
if (!success) {
glGetProgramInfoLog(program, 512, NULL, info_log);
Error::throw_error(Error::cant_load_shader, "Linking failed for "
+ std::string(vertex_file_path) + ": " + std::string(info_log));
}
glDeleteShader(vertex);
glDeleteShader(fragment);
glUseProgram(program);
return program;
}
示例10: create_backround_program
void create_backround_program(background_t *state)
{
// Compile vertex shader
GLuint vertex_shader = glCreateShader(GL_VERTEX_SHADER);
#ifdef RASPI
compile_shader(vertex_shader, "SPH/shaders/background_es.vert");
#else
compile_shader(vertex_shader, "shaders/background.vert");
#endif
// Compile fragment shader
GLuint frag_shader = glCreateShader(GL_FRAGMENT_SHADER);
#ifdef RASPI
compile_shader(frag_shader, "SPH/shaders/background_es.frag");
#else
compile_shader(frag_shader, "shaders/background.frag");
#endif
// Create shader program
state->program = glCreateProgram();
glAttachShader(state->program, vertex_shader);
glAttachShader(state->program, frag_shader);
// Link program
glLinkProgram(state->program);
show_program_log(state->program);
// Get position attribute location
state->position_location = glGetAttribLocation(state->program, "position");
// Get tex_coord location
state->tex_coord_location = glGetAttribLocation(state->program, "tex_coord");
// Get tex uniform location
state->tex_location = glGetUniformLocation(state->program, "tex");
}
示例11: load_shaders
static void load_shaders(void)
{
static int done;
GLuint s_vert;
GLuint s_frag;
GLint linked;
if ( done )
return;
prog = glCreateProgram();
compile_shader("shaders/md5_vert.glsl", GL_VERTEX_SHADER, &s_vert);
compile_shader("shaders/md5_frag.glsl", GL_FRAGMENT_SHADER, &s_frag);
glAttachShader(prog, s_vert);
glAttachShader(prog, s_frag);
glLinkProgram(prog);
glGetProgramiv(prog, GL_LINK_STATUS, &linked);
if ( !linked ) {
GLsizei len;
GLchar buf[512];
glGetProgramInfoLog(prog, sizeof(buf), &len, buf);
con_printf("shaders link error: %.*s\n", len, buf);
exit(1);
}
u_Texture = glGetUniformLocationARB(prog, "Texture");
u_normalTexture = glGetUniformLocationARB(prog, "normalTexture");
done = 1;
}
示例12: create_program_from_source
GLuint create_program_from_source(std::string vertex_source,
std::string frag_source)
{
return create_program_from_shaders(
compile_shader(vertex_source, GL_VERTEX_SHADER),
compile_shader(frag_source, GL_FRAGMENT_SHADER));
}
示例13: compile_program
static GLuint compile_program(const char *vertex, const char *fragment, unsigned i)
{
GLuint prog = glCreateProgram();
if (!prog)
return 0;
GLuint vert = 0;
GLuint frag = 0;
if (vertex)
{
RARCH_LOG("Found GLSL vertex shader.\n");
vert = glCreateShader(GL_VERTEX_SHADER);
if (!compile_shader(vert, "#define VERTEX\n", vertex))
{
RARCH_ERR("Failed to compile vertex shader #%u\n", i);
return false;
}
glAttachShader(prog, vert);
}
if (fragment)
{
RARCH_LOG("Found GLSL fragment shader.\n");
frag = glCreateShader(GL_FRAGMENT_SHADER);
if (!compile_shader(frag, "#define FRAGMENT\n", fragment))
{
RARCH_ERR("Failed to compile fragment shader #%u\n", i);
return false;
}
glAttachShader(prog, frag);
}
if (vertex || fragment)
{
RARCH_LOG("Linking GLSL program.\n");
if (!link_program(prog))
{
RARCH_ERR("Failed to link program #%u.\n", i);
return 0;
}
// Clean up dead memory. We're not going to relink the program.
// Detaching first seems to kill some mobile drivers (according to the intertubes anyways).
if (vert)
glDeleteShader(vert);
if (frag)
glDeleteShader(frag);
glUseProgram(prog);
GLint location = get_uniform(prog, "Texture");
glUniform1i(location, 0);
glUseProgram(0);
}
return prog;
}
示例14: build_shader
GLhandleARB build_shader(const char* vert,const char* frag) {
GLhandleARB shadowShaderId;
shadowShaderId = glCreateProgramObjectARB();
glAttachObjectARB(shadowShaderId,vert?compile_shader(vert,GL_VERTEX_SHADER):0);
glAttachObjectARB(shadowShaderId,frag?compile_shader(frag,GL_FRAGMENT_SHADER):0);
glLinkProgramARB(shadowShaderId);
return shadowShaderId;
}
示例15: compile_programs
static bool compile_programs(GLuint *gl_prog, struct shader_program *progs, size_t num)
{
for (unsigned i = 0; i < num; i++)
{
gl_prog[i] = pglCreateProgram();
if (gl_prog[i] == 0)
{
RARCH_ERR("Failed to create GL program #%u.\n", i);
return false;
}
if (progs[i].vertex)
{
RARCH_LOG("Found GLSL vertex shader.\n");
GLuint shader = pglCreateShader(GL_VERTEX_SHADER);
if (!compile_shader(shader, progs[i].vertex))
{
RARCH_ERR("Failed to compile vertex shader #%u\n", i);
return false;
}
pglAttachShader(gl_prog[i], shader);
free(progs[i].vertex);
}
if (progs[i].fragment)
{
RARCH_LOG("Found GLSL fragment shader.\n");
GLuint shader = pglCreateShader(GL_FRAGMENT_SHADER);
if (!compile_shader(shader, progs[i].fragment))
{
RARCH_ERR("Failed to compile fragment shader #%u\n", i);
return false;
}
pglAttachShader(gl_prog[i], shader);
free(progs[i].fragment);
}
if (progs[i].vertex || progs[i].fragment)
{
RARCH_LOG("Linking GLSL program.\n");
if (!link_program(gl_prog[i]))
{
RARCH_ERR("Failed to link program #%u\n", i);
return false;
}
GLint location = pglGetUniformLocation(gl_prog[i], "rubyTexture");
pglUniform1i(location, 0);
pglUseProgram(0);
}
}
return true;
}