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; }
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; }
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; }
// 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"); }
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; }
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); }
/* 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); }
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; }
/* 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; }
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"); }
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; }
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)); }
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; }
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; }
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; }
Shader::Shader(const std::string &vertexPath, const std::string &fragmentPath) { GLuint vshader = compile_shader(GL_VERTEX_SHADER, read_text_file(vertexPath)); GLuint fshader = compile_shader(GL_FRAGMENT_SHADER, read_text_file(fragmentPath)); GLuint shader = link_shader(vshader, fshader); glDeleteShader(vshader); glDeleteShader(fshader); this->program = shader; }
GLuint build_program( const GLchar * vertex_shader_source, const GLint vertex_shader_source_length, const GLchar * fragment_shader_source, const GLint fragment_shader_source_length) { GLuint vertex_shader = compile_shader( GL_VERTEX_SHADER, vertex_shader_source, vertex_shader_source_length); GLuint fragment_shader = compile_shader( GL_FRAGMENT_SHADER, fragment_shader_source, fragment_shader_source_length); return link_program(vertex_shader, fragment_shader); }
GLuint load_shaders_text(const char *vertText, const char *fragText, const char **attributes) { GLuint vert_id = compile_shader(vertText, "vert text", GL_VERTEX_SHADER); GLuint frag_id = compile_shader(fragText, "frag text", GL_FRAGMENT_SHADER); GLuint program = link_program(vert_id, frag_id, attributes); glDeleteShader(vert_id); glDeleteShader(frag_id); return program; }
/* Create program, compile shader, link program, bind attributes */ GLint create_program(const GLchar *vertSource, const GLchar *fragSource, GLsizei attribNameCnt, const GLchar **attribNames, const GLint *attribLocations, GLuint *program) { GLuint vertShader = 0, fragShader = 0, prog = 0, i; GLint status; /* Create shader program */ prog = glCreateProgram(); *program = prog; /* Create and compile vertex shader */ status = compile_shader(GL_VERTEX_SHADER, 1, &vertSource, &vertShader); if (status == 0) { LOG("Unable to compile vertex shader"); return status; } /* Create and compile fragment shader */ status = compile_shader(GL_FRAGMENT_SHADER, 1, &fragSource, &fragShader); if (status == 0) { LOG("Unable to compile fragment shader"); return status; } /* Attach vertex shader to program */ glAttachShader(prog, vertShader); /* Attach fragment shader to program */ glAttachShader(prog, fragShader); /* Bind attribute locations prior to linking */ for (i = 0; i < attribNameCnt; i++) { glBindAttribLocation(prog, attribLocations[i], attribNames[i]); } /* Link program */ glLinkProgram(prog); glGetProgramiv(prog, GL_LINK_STATUS, &status); if (status == 0) { LOG("Unable to link program"); return status; } /* Release vertex and fragment shaders */ if (vertShader) glDeleteShader(vertShader); if (fragShader) glDeleteShader(fragShader); return status; }
void load_distort_shader(App *app) { char *vs_src = read_file(SHADER_PATH("distort.vs")); char *fs_src = read_file(SHADER_PATH("distort.fs")); GLuint shaders[2]; shaders[0] = compile_shader(vs_src, GL_VERTEX_SHADER); shaders[1] = compile_shader(fs_src, GL_FRAGMENT_SHADER); app->program_distort = link_program(shaders, 2); free(vs_src); free(fs_src); }
/* * シェーダプログラムのロード */ int load_shader(char *vtxShdName, char *frgShdName, GLuint *lpProg) { GLuint vtxShader; GLuint frgShader; GLuint prog; GLint linked; /* シェーダオブジェクトの作成 */ vtxShader = glCreateShader(GL_VERTEX_SHADER); frgShader = glCreateShader(GL_FRAGMENT_SHADER); /* バーテックスシェーダのロードとコンパイル */ if (compile_shader(vtxShader, vtxShdName) < 0) { return -1; } /* フラグメントシェーダのロードとコンパイル */ if (compile_shader(frgShader, frgShdName) < 0) { return -1; } /* プログラムオブジェクトの作成 */ prog = glCreateProgram(); /* シェーダオブジェクトのシェーダプログラムへの登録 */ glAttachShader(prog, vtxShader); glAttachShader(prog, frgShader); /* シェーダオブジェクトの削除 */ glDeleteShader(vtxShader); glDeleteShader(frgShader); /* シェーダプログラムのリンク */ glLinkProgram(prog); glGetProgramiv(prog, GL_LINK_STATUS, &linked); print_program_log(prog); if (linked == GL_FALSE) { std::cout << "Link error of " << vtxShdName << " & " << frgShdName << " !!" << std::endl; return -1; } else { std::cout << "Link successful: " << vtxShdName << " & " << frgShdName << std::endl; } *lpProg = prog; return 0; }
bool shader_t::compile() { m_program_handle = 0; GLuint vertex( compile_shader( GL_VERTEX_SHADER, m_vertex_shader_src ) ); if( vertex == 0 ) { return false; } GLuint fragment( compile_shader( GL_FRAGMENT_SHADER, m_fragment_shader_src ) ); if( fragment == 0 ) { glDeleteShader( vertex ); return false; } GLuint program( glCreateProgram() ); if( program == 0 ) { glDeleteShader( vertex ); glDeleteShader( fragment ); return false; } glBindAttribLocation( program, Common::POSITION, "VertexPosition" ); glBindAttribLocation( program, Common::COLOR, "VertexColor" ); glAttachShader( program, vertex ); glAttachShader( program, fragment ); glLinkProgram( program ); glDeleteShader( vertex ); glDeleteShader( fragment ); GLint result; glGetShaderiv( program, GL_LINK_STATUS, &result ); if( GL_FALSE == result ) { log_opengl_error( program ); return false; } m_program_handle = program; return true; }
static GLuint compile_program(const char *vertex, const char *fragment, unsigned i) { GLuint prog = glCreateProgram(); if (!prog) return 0; if (vertex) { RARCH_LOG("Found GLSL vertex shader.\n"); GLuint shader = glCreateShader(GL_VERTEX_SHADER); if (!compile_shader(shader, "#define VERTEX\n", vertex)) { RARCH_ERR("Failed to compile vertex shader #%u\n", i); return false; } glAttachShader(prog, shader); } if (fragment) { RARCH_LOG("Found GLSL fragment shader.\n"); GLuint shader = glCreateShader(GL_FRAGMENT_SHADER); if (!compile_shader(shader, "#define FRAGMENT\n", fragment)) { RARCH_ERR("Failed to compile fragment shader #%u\n", i); return false; } glAttachShader(prog, shader); } if (vertex || fragment) { RARCH_LOG("Linking GLSL program.\n"); if (!link_program(prog)) { RARCH_ERR("Failed to link program #%u.\n", i); return 0; } glUseProgram(prog); GLint location = get_uniform(prog, "Texture"); glUniform1i(location, 0); glUseProgram(0); } return prog; }
HRESULT WINAPI D3DCompile2(const void *data, SIZE_T data_size, const char *filename, const D3D_SHADER_MACRO *defines, ID3DInclude *include, const char *entrypoint, const char *target, UINT sflags, UINT eflags, UINT secondary_flags, const void *secondary_data, SIZE_T secondary_data_size, ID3DBlob **shader, ID3DBlob **error_messages) { HRESULT hr; TRACE("data %p, data_size %lu, filename %s, defines %p, include %p, entrypoint %s, " "target %s, sflags %#x, eflags %#x, secondary_flags %#x, secondary_data %p, " "secondary_data_size %lu, shader %p, error_messages %p.\n", data, data_size, debugstr_a(filename), defines, include, debugstr_a(entrypoint), debugstr_a(target), sflags, eflags, secondary_flags, secondary_data, secondary_data_size, shader, error_messages); if (secondary_data) FIXME("secondary data not implemented yet\n"); if (shader) *shader = NULL; if (error_messages) *error_messages = NULL; EnterCriticalSection(&wpp_mutex); hr = preprocess_shader(data, data_size, filename, defines, include, error_messages); if (SUCCEEDED(hr)) hr = compile_shader(wpp_output, target, entrypoint, shader, error_messages); HeapFree(GetProcessHeap(), 0, wpp_output); LeaveCriticalSection(&wpp_mutex); return hr; }
Shader::Shader(const GLchar * vertex_path, const GLchar * fragment_path) { std::string vertex_code; std::string fragment_code; std::ifstream vertex_file; std::ifstream fragment_file; vertex_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); fragment_file.exceptions(std::ifstream::failbit | std::ifstream::badbit); //Try opening and streaming in the shader files try { vertex_file.open(vertex_path); fragment_file.open(fragment_path); std::stringstream vss, fss; vss << vertex_file.rdbuf(); fss << fragment_file.rdbuf(); vertex_file.close(); fragment_file.close(); vertex_code = vss.str(); fragment_code = fss.str(); } catch (std::ifstream::failure e) { std::cerr << "Application failed to read shader file. " << std::endl; } //Send the read shader code to compilation step compile_shader(vertex_path, fragment_path, vertex_code.c_str(), fragment_code.c_str()); }
void render_skinned_mesh(struct mesh *mesh, mat4 clip_from_view, mat4 view_from_model, mat4 *model_from_bind_pose) { static int prog = 0; static int uni_clip_from_view; static int uni_view_from_model; static int uni_model_from_bind_pose; int i; if (!mesh) return; if (!prog) { prog = compile_shader(skinned_mesh_vert_src, mesh_frag_src); uni_clip_from_view = glGetUniformLocation(prog, "clip_from_view"); uni_view_from_model = glGetUniformLocation(prog, "view_from_model"); uni_model_from_bind_pose = glGetUniformLocation(prog, "model_from_bind_pose"); } glUseProgram(prog); glUniformMatrix4fv(uni_clip_from_view, 1, 0, clip_from_view); glUniformMatrix4fv(uni_view_from_model, 1, 0, view_from_model); glUniformMatrix4fv(uni_model_from_bind_pose, mesh->skel->count, 0, model_from_bind_pose[0]); glBindVertexArray(mesh->vao); for (i = 0; i < mesh->count; i++) { glActiveTexture(MAP_COLOR); glBindTexture(GL_TEXTURE_2D, mesh->part[i].material); glDrawElements(GL_TRIANGLES, mesh->part[i].count, GL_UNSIGNED_SHORT, PTR(mesh->part[i].first * 2)); } }
FX_ENTRY void FX_CALL grDrawVertexArrayContiguous(FxU32 mode, FxU32 Count, void *pointers, FxU32 stride) { WriteTrace(TraceGlitch, TraceDebug, "grDrawVertexArrayContiguous(%d,%d,%d)\r\n", mode, Count, stride); if (nvidia_viewport_hack && !render_to_texture) { glViewport(0, viewport_offset, viewport_width, viewport_height); nvidia_viewport_hack = 0; } if (stride != 156) { //LOGINFO("Incompatible stride\n"); } reloadTexture(); if (need_to_compile) compile_shader(); vbo_enable(); switch (mode) { case GR_TRIANGLE_STRIP: vbo_buffer(GL_TRIANGLE_STRIP, 0, Count, pointers); break; case GR_TRIANGLE_FAN: vbo_buffer(GL_TRIANGLE_FAN, 0, Count, pointers); break; default: WriteTrace(TraceGlitch, TraceWarning, "grDrawVertexArrayContiguous : unknown mode : %x", mode); } }
FX_ENTRY void FX_CALL grDrawTriangle(const void *a, const void *b, const void *c) { WriteTrace(TraceGlitch, TraceDebug, "start"); if (nvidia_viewport_hack && !render_to_texture) { glViewport(0, viewport_offset, viewport_width, viewport_height); nvidia_viewport_hack = 0; } reloadTexture(); if (need_to_compile) compile_shader(); if (vertex_buffer_count + 3 > VERTEX_BUFFER_SIZE) { vbo_draw(); } vertex_draw_mode = GL_TRIANGLES; memcpy(&vertex_buffer[vertex_buffer_count], a, VERTEX_SIZE); memcpy(&vertex_buffer[vertex_buffer_count + 1], b, VERTEX_SIZE); memcpy(&vertex_buffer[vertex_buffer_count + 2], c, VERTEX_SIZE); vertex_buffer_count += 3; WriteTrace(TraceGlitch, TraceDebug, "Done"); }
static int compile_effect(const char *file_paths[], GLchar *shader_texts[], GLenum shader_types[], int num, GLuint program_handle) { GLint success = true; GLuint shader_handles[num]; for (int i = 0; i < num; i++) { shader_handles[i] = compile_shader(shader_types[i], (const GLchar *)shader_texts[i], file_paths[i], program_handle); glAttachShader(program_handle, shader_handles[i]); success = success && (shader_handles[i] != -1); } if (success) { //If we've successfully compiled all shaders (it's possible to fail compile but succeed linking, which is ugly.) glLinkProgram(program_handle); glGetProgramiv(program_handle, GL_LINK_STATUS, &success); if (success != true) { printf("Unable to link program %d!\n", program_handle); printLog(program_handle, true); } } for (int i = 0; i < num; i++) glDeleteShader(shader_handles[i]); return !success; //Success is 0. }
unsigned int ShaderManager::compile(Shader::Params* shaders, const Shader::AttributeParams* attributes) { for (auto shader = shaders; shader->type != Shader::kTypeInvalid; ++shader) { if (!shader->source) { shader->id = shaders_[shader->id]; continue; } if (shader->id > 0) continue; const unsigned int id = compile_shader(*shader); if (id == kInvalidProgram) return id; shaders_.push_back(id); shader->id = id; } if (!attributes) attributes = kAttributeDefaultParams; const unsigned int program = link_program(shaders, attributes); if (program == kInvalidProgram) return program; programs_.emplace_back(program, glGetUniformLocation(program, "mvp_matrix")); return static_cast<unsigned int>(programs_.size()); }