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());
}
