unsigned int create_program(const char *vsdr, const char *psdr)
{
unsigned int vs, ps, prog;
int status;
if(!(vs = create_shader(GL_VERTEX_SHADER, vsdr))) {
return 0;
}
if(!(ps = create_shader(GL_FRAGMENT_SHADER, psdr))) {
glDeleteShader(vs);
return 0;
}
prog = glCreateProgram();
glAttachShader(prog, vs);
glAttachShader(prog, ps);
glLinkProgram(prog);
glGetProgramiv(prog, GL_LINK_STATUS, &status);
if(!status) {
fprintf(stderr, "failed to link shader program\n");
glDeleteProgram(prog);
prog = 0;
}
return prog;
}
void setup() {
GLuint vertex_shader = create_shader("vertex.shd", GL_VERTEX_SHADER);
GLuint fragment_shader = create_shader("fragment.shd", GL_FRAGMENT_SHADER);
program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
glGenVertexArrays(1, &vertex_array_object);
glBindVertexArray(vertex_array_object);
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexStorage2D(GL_TEXTURE_2D,
1, // Mipmap level
GL_RGBA32F,
256, 256);
std::unique_ptr<float[]> texture = createTexture();
glTexSubImage2D(GL_TEXTURE_2D,
0, // level 0
0, 0, // offset,
256, 256, // size
GL_RGBA,
GL_FLOAT,
texture.get());
texture.reset();
}
GLuint create_programme_from_files ( const char* vert_file_name, const char* frag_file_name) {
GLuint vert, frag, programme;
assert (create_shader (vert_file_name, &vert, GL_VERTEX_SHADER));
assert (create_shader (frag_file_name, &frag, GL_FRAGMENT_SHADER));
assert (create_programme (vert, frag, &programme));
return programme;
}
int init_shaders(void)
{
GLuint vertex_shader = create_shader("geometry_square.vs", GL_VERTEX_SHADER);
if (vertex_shader == 0)
return 0;
GLuint fragment_shader = create_shader("geometry_square.fs", GL_FRAGMENT_SHADER);
if (fragment_shader == 0)
return 0;
// Link vertex shader and fragment shader
program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
GLint link_ok = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok)
{
fprintf(stderr, "glLinkProgram: ");
print_log(program);
}
// Bind shader variables
const char* attribute_name = "coord3d";
attribute_coord3d = glGetAttribLocation(program, attribute_name);
if (attribute_coord3d == -1)
{
fprintf(stderr, "Cound not bind attribute %s\n", attribute_name);
return 0;
}
return 1;
}
static GLuint create_program(const char *vsh, const char *fsh)
{
// Build shaders
GLuint vertex_shader = create_shader(vsh, GL_VERTEX_SHADER);
GLuint fragment_shader = create_shader(fsh, GL_FRAGMENT_SHADER);
// Create program
GLuint program = glCreateProgram();
// Attach shaders
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
// Link program
glLinkProgram(program);
// Check for errors
GLint status;
glGetProgramiv(program, GL_LINK_STATUS, &status);
if (status == GL_FALSE) {
GLchar messages[1024];
glGetProgramInfoLog(program, sizeof(messages), 0, &messages[0]);
fprintf(stderr, "GLSL Program Error: %s", messages);
}
// Delete shaders
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
return program;
}
GLuint create_gs_program(const char *vertexfile, const char *geometryfile, const char *fragmentfile, GLint input, GLint output, GLint vertices) {
GLuint program = glCreateProgram();
GLuint shader;
if (vertexfile) {
shader = create_shader(vertexfile, GL_VERTEX_SHADER);
if (!shader)
return 0;
glAttachShader(program, shader);
}
if (geometryfile) {
shader = create_shader(geometryfile, GL_GEOMETRY_SHADER);
if (!shader)
return 0;
glAttachShader(program, shader);
glProgramParameteriEXT(program, GL_GEOMETRY_INPUT_TYPE_EXT, input);
glProgramParameteriEXT(program, GL_GEOMETRY_OUTPUT_TYPE_EXT, output);
glProgramParameteriEXT(program, GL_GEOMETRY_VERTICES_OUT_EXT, vertices);
}
if (fragmentfile) {
shader = create_shader(fragmentfile, GL_FRAGMENT_SHADER);
if (!shader)
return 0;
glAttachShader(program, shader);
}
glLinkProgram(program);
GLint link_ok = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
fprintf(stderr, "glLinkProgram:");
print_log(program);
glDeleteProgram(program);
return 0;
}
return program;
}
/*
Constructor for the shader. Reads two files and creates vertex shader and fragment shader as
well as links them
*/
Shader::Shader(char* vertexFile, char* fragmentFile)
{
if((VertexShader = create_shader(vertexFile, GL_VERTEX_SHADER)) == 0)
{
fprintf(stderr, "Could not create vertex shader.");
return;
}
if((FragmentShader = create_shader(fragmentFile, GL_FRAGMENT_SHADER)) == 0)
{
fprintf(stderr, "Could not create fragment shader.");
return;
}
Program = glCreateProgram();
glAttachShader(Program, VertexShader);
glAttachShader(Program, FragmentShader);
glLinkProgram(Program);
GLint linkOk = GL_FALSE;
glGetProgramiv(Program, GL_LINK_STATUS, &linkOk);
if(!linkOk)
{
fprintf(stderr, "glLinkProgram: ");
print_log(Program);
return;
}
}
static void
create_program(struct nested_client *client,
const char *vert, const char *frag)
{
GLint status;
client->vert = create_shader(vert, GL_VERTEX_SHADER);
client->frag = create_shader(frag, GL_FRAGMENT_SHADER);
client->program = glCreateProgram();
glAttachShader(client->program, client->frag);
glAttachShader(client->program, client->vert);
glBindAttribLocation(client->program, POS, "pos");
glBindAttribLocation(client->program, COL, "color");
glLinkProgram(client->program);
glGetProgramiv(client->program, GL_LINK_STATUS, &status);
if (!status) {
char log[1000];
GLsizei len;
glGetProgramInfoLog(client->program, 1000, &len, log);
fprintf(stderr, "Error: linking:\n%*s\n", len, log);
exit(1);
}
client->rotation =
glGetUniformLocation(client->program, "rotation");
}
GLuint create_program(const char *vertexfile, const char *fragmentfile) {
GLuint program = glCreateProgram();
GLuint shader;
if(vertexfile) {
shader = create_shader(vertexfile, GL_VERTEX_SHADER);
if(!shader)
return 0;
glAttachShader(program, shader);
}
if(fragmentfile) {
shader = create_shader(fragmentfile, GL_FRAGMENT_SHADER);
if(!shader)
return 0;
glAttachShader(program, shader);
}
glLinkProgram(program);
GLint link_ok = GL_FALSE;
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
fprintf(stderr, "glLinkProgram:");
print_log(program);
glDeleteProgram(program);
return 0;
}
return program;
}
fractal_t::fractal_t()
: pos_(0.5, 0), scale_factor_(1)
{
#ifdef USE_CORE_OPENGL
TwInit(TW_OPENGL_CORE, NULL);
#else
TwInit(TW_OPENGL, NULL);
#endif
// Определение "контролов" GUI
TwBar *bar = TwNewBar("Parameters");
TwDefine(" Parameters size='300 50' color='70 100 120' valueswidth=220 iconpos=topleft");
TwAddButton(bar, "Fullscreen toggle", toggle_fullscreen_callback, NULL,
" label='Toggle fullscreen mode' key=f");
// Создание шейдеров
vs_ = create_shader(GL_VERTEX_SHADER , "shaders//fractal.glslvs");
fs_ = create_shader(GL_FRAGMENT_SHADER, "shaders//fractal.glslfs");
// Создание программы путём линковки шейдерова
program_ = create_program(vs_, fs_);
// Создание буфера с вершинными данными
init_buffer();
// Создание VAO
init_vertex_array();
}
static void initializeGl()
{
GLuint frag, vert;
GLuint program;
GLint status;
frag = create_shader(frag_shader_text, GL_FRAGMENT_SHADER);
vert = create_shader(vert_shader_text, GL_VERTEX_SHADER);
program = glCreateProgram();
glAttachShader(program, frag);
glAttachShader(program, vert);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &status);
if (!status) {
char log[1000];
GLsizei len;
glGetProgramInfoLog(program, 1000, &len, log);
fprintf(stderr, "Error: linking:\n%*s\n", len, log);
exit(1);
}
glUseProgram(program);
glPos = 0;
glCol = 1;
glBindAttribLocation(program, glPos, "pos");
glBindAttribLocation(program, glCol, "color");
glLinkProgram(program);
glRotationUniform = glGetUniformLocation(program, "rotation");
}
void initPointClouds(const char* vertS, const char* fragS, float pntSize) {
GLint link_ok = GL_FALSE;
GLuint vs, fs;
vs = create_shader(vertS, GL_VERTEX_SHADER);
fs = create_shader(fragS, GL_FRAGMENT_SHADER);
//printf("vs=%i fs=%i\n",vs,fs);
__pg.Partprogram = glCreateProgram();
glAttachShader(__pg.Partprogram, vs);
glAttachShader(__pg.Partprogram, fs);
glLinkProgram(__pg.Partprogram);
glGetProgramiv(__pg.Partprogram, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
printf("particle glLinkProgram error \n");
print_log(__pg.Partprogram);
// return 0;
}
__pg.part_vert_attrib =
getShaderLocation(shaderAttrib, __pg.Partprogram, "vertex_attrib");
__pg.part_mvp_uniform =
getShaderLocation(shaderUniform, __pg.Partprogram, "mvp_uniform");
__pg.part_tex_uniform =
getShaderLocation(shaderUniform, __pg.Partprogram, "u_texture");
__pg.part_size_uniform =
getShaderLocation(shaderUniform, __pg.Partprogram, "u_point_size");
glUseProgram(__pg.Partprogram);
glUniform1f(__pg.part_size_uniform, pntSize);
}
Program::Program(map<string, GLint> params, string shader_name) : params(params) {
if ((vs = create_shader((shader_name+".v.glsl").c_str(), GL_VERTEX_SHADER)) == 0) exit(-1);
if ((fs = create_shader((shader_name+".f.glsl").c_str(), GL_FRAGMENT_SHADER)) == 0) exit(-1);
GLint compile_ok = GL_FALSE, link_ok = GL_FALSE;
id = glCreateProgram();
glAttachShader(id, vs);
glAttachShader(id, fs);
glLinkProgram(id);
glGetProgramiv(id, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
fprintf(stderr, "glLinkProgram:");
print_log(id);
exit(-1);
}
for(auto& kv : this->params){
if(kv.first.substr(0, 7) == "uniform"){
bindUniform(kv.first.substr(8).c_str(), kv.second, id); /*uniform*/
}
else{
bindAttribute(kv.first.substr(10).c_str(), kv.second, id); /*attribute*/
}
}
}
int init_resources()
{
//added in the stuff for working with the color buffers here:
GLfloat triangle_colors[] = {
1.0, 1.0, 0.0,
0.0, 0.0, 1.0,
1.0, 0.0, 0.0,
};
glGenBuffers(1, &vbo_triangle_colors);//these are just like below, so shouldn't be anything
glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle_colors);//new to you. gen buffer, pass stuff
glBufferData(GL_ARRAY_BUFFER, sizeof(triangles_colors), triangle_colors, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);//and then lastly unbind.
GLfloat triangle_vertices[] = {
0.0, 0.8,
-0.8, -0.8,
0.8, -0.8,
};
glGenBuffers(1, &vbo_triangle);
glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle);
glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_vertices), triangle_vertices, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GLint link_ok = GL_FALSE;
GLuint vs, fs;
if ((vs = create_shader("triangle.v.glsl", GL_VERTEX_SHADER)) == 0) return 0;
if ((fs = create_shader("triangle.f.glsl", GL_FRAGMENT_SHADER)) == 0) return 0;
program = glCreateProgram();
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok)
{
fprintf(stderr, "glLinkProgram:");
return 0;
}
const char* attribute_name = "coord2d";
attribute_coord2d = glGetAttribLocation(program, attribute_name);
if (attribute_coord2d == -1)
{
fprintf(stderr, "Could not bind attribute %s\n", attribute_name);
return 0;
}
//this again should look familiar.
attribute_name = "v_color";
attribute_v_color = glGetAttribLocation(program, attribute_name);
if (attribute_v_color == -1)
{
fprintf(stderr, "Could not bind attribute %s\n", attribute_name);
return 0;
}
return 1;
}
void Shader::LoadShader(const char* vertex,const char* fragment) {
std::vector<GLuint>shaders;
shaders.push_back(create_shader(vertex,GL_VERTEX_SHADER));
shaders.push_back(create_shader(fragment,GL_FRAGMENT_SHADER));
GLuint ProgramID=create_program(shaders);
programID=ProgramID;
}
int createObj(struct obj_t *obj, int numVerts, float *verts, float *txVert,
float *norms, char *vertShader, char *fragShader)
{
obj->num_verts = numVerts;
glGenBuffers(1, &obj->vbo_vert);
glBindBuffer(GL_ARRAY_BUFFER, obj->vbo_vert);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * numVerts, verts,
GL_STATIC_DRAW);
glGenBuffers(1, &obj->vbo_tex);
glBindBuffer(GL_ARRAY_BUFFER, obj->vbo_tex);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 2 * numVerts, txVert,
GL_STATIC_DRAW);
glGenBuffers(1, &obj->vbo_norm);
glBindBuffer(GL_ARRAY_BUFFER, obj->vbo_norm);
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * 3 * numVerts, norms,
GL_STATIC_DRAW);
GLint link_ok = GL_FALSE;
GLuint vs, fs;
if ((vs = create_shader(vertShader, GL_VERTEX_SHADER)) == 0)
return 0;
if ((fs = create_shader(fragShader, GL_FRAGMENT_SHADER)) == 0)
return 0;
obj->program = glCreateProgram();
glAttachShader(obj->program, vs);
glAttachShader(obj->program, fs);
glLinkProgram(obj->program);
glGetProgramiv(obj->program, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
printf("glLinkProgram:");
print_log(obj->program);
return 0;
}
obj->vert_attrib =
getShaderLocation(shaderAttrib, obj->program, "vertex_attrib");
obj->tex_attrib =
getShaderLocation(shaderAttrib, obj->program, "uv_attrib");
obj->norm_attrib =
getShaderLocation(shaderAttrib, obj->program, "norm_attrib");
obj->mvp_uniform =
getShaderLocation(shaderUniform, obj->program, "mvp_uniform");
obj->mv_uniform =
getShaderLocation(shaderUniform, obj->program, "mv_uniform");
obj->tex_uniform =
getShaderLocation(shaderUniform, obj->program, "u_texture");
obj->lightDir_uniform =
getShaderLocation(shaderUniform, obj->program, "u_lightDir");
obj->viewDir_uniform =
getShaderLocation(shaderUniform, obj->program, "u_viewDir");
}
static void
init_gl(struct window *window)
{
GLuint frag, vert;
GLuint program;
GLint status;
frag = create_shader(window, frag_shader_text, GL_FRAGMENT_SHADER);
vert = create_shader(window, vert_shader_text, GL_VERTEX_SHADER);
program = glCreateProgram();
if (g_UseBinary) {
load_program_binary("simple-egl-shader.fx", 0x9130, program);
glUseProgram(program);
window->gl.pos = 0;
window->gl.col = 1;
glBindAttribLocation(program, window->gl.pos, "pos");
glBindAttribLocation(program, window->gl.col, "color");
}
else
{
glAttachShader(program, frag);
glAttachShader(program, vert);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &status);
if (!status) {
char log[1000];
GLsizei len;
glGetProgramInfoLog(program, 1000, &len, log);
fprintf(stderr, "Error: linking:\n%*s\n", len, log);
exit(1);
}
if (g_CompileBinary) {
compile_program_binary(program, "simple-egl-shader.fx");
exit(EXIT_SUCCESS);
}
glUseProgram(program);
window->gl.pos = 0;
window->gl.col = 1;
glBindAttribLocation(program, window->gl.pos, "pos");
glBindAttribLocation(program, window->gl.col, "color");
glLinkProgram(program);
}
window->gl.rotation_uniform =
glGetUniformLocation(program, "rotation");
}
int init_resources()
{
GLfloat triangle_attributes[] ={
0.0, 0.8, 1.0, 1.0, 0.0,
-0.8, -0.8, 0.0, 0.0, 1.0,
0.8, -0.8, 1.0, 0.0, 0.0,
};
glGenBuffers(1, &vbo_triangle);
glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle);
glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_attributes), triangle_attributes, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
GLint link_ok = GL_FALSE;
GLuint vs, fs;
if ((vs = create_shader("triangle6.v.glsl", GL_VERTEX_SHADER)) == 0) return 0;
if ((fs = create_shader("triangle8.f.glsl", GL_FRAGMENT_SHADER)) == 0) return 0;
program = glCreateProgram();
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok)
{
fprintf(stderr, "glLinkProgram:");
return 0;
}
const char* attribute_name = "coord2d";
attribute_coord2d = glGetAttribLocation(program, attribute_name);
if (attribute_coord2d == -1)
{
fprintf(stderr, "Could not bind attribute %s\n", attribute_name);
return 0;
}
attribute_name = "v_color";
attribute_v_color = glGetAttribLocation(program, attribute_name);
if (attribute_v_color == -1)
{
fprintf(stderr, "Could not bind attribute %s\n", attribute_name);
return 0;
}
const char* uniform_name;
uniform_name = "fade";
uniform_fade = glGetUniformLocation(program, uniform_name);
if (uniform_fade == -1)
{
fprintf(stderr, "could not bind uniform %s\n",uniform_name);
return 0;
}
return 1;
}
void setup_program(GLuint* program_id)
{
GLuint shaders[2];
fprintf (stderr, "This routine was called\n");
shaders[1] = create_shader("FragmentShader.glsl",GL_FRAGMENT_SHADER);
shaders[0] = create_shader("VertexShader.glsl",GL_VERTEX_SHADER);
program_id[0] = create_gl_program(shaders, 2, GL_TRUE);
}
/// \brief Create program.
///
/// \param vertex Vertex shader.
/// \param fragment Fragment shader.
/// \return Program ID
GLuint create_program(const char *vertex, const char *fragment)
{
GLuint ret = dnload_glCreateProgram();
dnload_glAttachShader(ret, create_shader(vertex, GL_VERTEX_SHADER));
dnload_glAttachShader(ret, create_shader(fragment, GL_FRAGMENT_SHADER));
dnload_glLinkProgram(ret);
return ret;
}
int init_resources()
{
struct attributes triangle_attributes[] = {
{{ 0.0, 0.8, 0.0}, {1.0, 1.0, 0.0}},
{{-0.8, -0.8, 0.0}, {0.0, 0.0, 1.0}},
{{ 0.8, -0.8, 0.0}, {1.0, 0.0, 0.0}}
};
glGenBuffers(1, &vbo_triangle);
glBindBuffer(GL_ARRAY_BUFFER, vbo_triangle);
glBufferData(GL_ARRAY_BUFFER, sizeof(triangle_attributes), triangle_attributes, GL_STATIC_DRAW);
GLint link_ok = GL_FALSE;
GLuint vs, fs;
if ((vs = create_shader("/home/letigre/Desktop/Current/Tutorials/Basics/04Triangle/triangle.v.glsl", GL_VERTEX_SHADER)) == 0) return 0;
if ((fs = create_shader("/home/letigre/Desktop/Current/Tutorials/Basics/04Triangle/triangle.f.glsl", GL_FRAGMENT_SHADER)) == 0) return 0;
program = glCreateProgram();
glAttachShader(program, vs);
glAttachShader(program, fs);
glLinkProgram(program);
glGetProgramiv(program, GL_LINK_STATUS, &link_ok);
if (!link_ok) {
fprintf(stderr, "glLinkProgram:");
print_log(program);
return 0;
}
const char* attribute_name;
attribute_name = "coord3d";
attribute_coord3d = glGetAttribLocation(program, attribute_name);
if (attribute_coord3d == -1) {
fprintf(stderr, "Could not bind attribute %s\n", attribute_name);
return 0;
}
attribute_name = "v_color";
attribute_v_color = glGetAttribLocation(program, attribute_name);
if (attribute_v_color == -1) {
fprintf(stderr, "Could not bind attribute %s\n", attribute_name);
return 0;
}
const char* uniform_name;
uniform_name = "m_transform";
uniform_m_transform = glGetUniformLocation(program, uniform_name);
if (uniform_m_transform == -1) {
fprintf(stderr, "Could not bind uniform_fade %s\n", uniform_name);
return 0;
}
return 1;
}
bool GLSLProgram::create_shaders(const char* vert, const char* frag,
const char* geom,
const char* tcs, const char* tes)
{
if (vert == nullptr)
{
cout << "ERROR: Vertex shader required!\n";
return false;
}
// Vertex Shader
if (!create_shader(vert, shaders[0], GL_VERTEX_SHADER))
{
return false;
}
// Fragment Shader
if (frag != nullptr)
{
if (!create_shader(frag, shaders[1], GL_FRAGMENT_SHADER))
{
return false;
}
}
// Geometry Shader
if (geom != nullptr)
{
if (!create_shader(geom, shaders[2], GL_GEOMETRY_SHADER))
{
return false;
}
}
// Tessallation Control Shader
if (tcs != nullptr)
{
if (!create_shader(tcs, shaders[3], GL_TESS_CONTROL_SHADER))
{
return false;
}
}
// Tessallation Evaluation Shader
if (tes != nullptr)
{
if (!create_shader(tes, shaders[4], GL_TESS_EVALUATION_SHADER))
{
return false;
}
}
//create_program();
return true;
}
void setup() {
GLuint vertex_shader = create_shader("vertex.shd", GL_VERTEX_SHADER);
GLuint fragment_shader = create_shader("fragment.shd", GL_FRAGMENT_SHADER);
program = glCreateProgram();
glAttachShader(program, vertex_shader);
glAttachShader(program, fragment_shader);
glLinkProgram(program);
glDeleteShader(vertex_shader);
glDeleteShader(fragment_shader);
glGenVertexArrays(1, &vertex_array_object);
glBindVertexArray(vertex_array_object);
}
static void
make_program (GdkGLContextProgram *program,
const char *vertex_shader_code,
const char *fragment_shader_code)
{
guint vertex_shader, fragment_shader;
int status;
vertex_shader = create_shader (GL_VERTEX_SHADER, vertex_shader_code);
if (vertex_shader == 0)
return;
fragment_shader = create_shader (GL_FRAGMENT_SHADER, fragment_shader_code);
if (fragment_shader == 0)
{
glDeleteShader (vertex_shader);
return;
}
program->program = glCreateProgram ();
glAttachShader (program->program, vertex_shader);
glAttachShader (program->program, fragment_shader);
glLinkProgram (program->program);
glDeleteShader (vertex_shader);
glDeleteShader (fragment_shader);
glGetProgramiv (program->program, GL_LINK_STATUS, &status);
if (status == GL_FALSE)
{
int log_len;
char *buffer;
glGetProgramiv (program->program, GL_INFO_LOG_LENGTH, &log_len);
buffer = g_malloc (log_len + 1);
glGetProgramInfoLog (program->program, log_len, NULL, buffer);
g_warning ("Linker failure: %s\n", buffer);
g_free (buffer);
glDeleteProgram (program->program);
}
program->position_location = glGetAttribLocation (program->program, "position");
program->uv_location = glGetAttribLocation (program->program, "uv");
program->map_location = glGetUniformLocation (program->program, "map");
}
/* Creates shader:
* EXEC ADDR(0x2) CNT(0x1)
* (S)FETCH: SAMPLE R0.xyzw = R0.xyx CONST(0) LOCATION(CENTER)
* ALLOC PARAM/PIXEL SIZE(0x0)
* EXEC_END ADDR(0x3) CNT(0x1)
* ALU: MAXv export0 = R0, R0 ; gl_FragColor
* NOP
*/
static struct fd2_shader_stateobj *
create_blit_fp(void)
{
struct fd2_shader_stateobj *so = create_shader(SHADER_FRAGMENT);
struct ir2_cf *cf;
struct ir2_instruction *instr;
if (!so)
return NULL;
so->ir = ir2_shader_create();
cf = ir2_cf_create(so->ir, EXEC);
instr = ir2_instr_create_tex_fetch(cf, 0);
ir2_reg_create(instr, 0, "xyzw", 0);
ir2_reg_create(instr, 0, "xyx", 0);
instr->sync = true;
cf = ir2_cf_create_alloc(so->ir, SQ_PARAMETER_PIXEL, 0);
cf = ir2_cf_create(so->ir, EXEC_END);
instr = ir2_instr_create_alu(cf, MAXv, ~0);
ir2_reg_create(instr, 0, NULL, IR2_REG_EXPORT);
ir2_reg_create(instr, 0, NULL, 0);
ir2_reg_create(instr, 0, NULL, 0);
return assemble(so);
}
cubemap_info *
create_cubemap (u32 size, u32 fmt, u32 spsize, u32 spfmt)
{
cubemap_info *cubemap = malloc (sizeof (cubemap_info));
int i;
for (i = 0; i < 6; i++)
{
cubemap->texels[i] = memalign (32, GX_GetTexBufferSize (size, size, fmt,
GX_FALSE, 0));
GX_InitTexObj (&cubemap->tex[i], cubemap->texels[i], size, size, fmt,
GX_CLAMP, GX_CLAMP, GX_FALSE);
cubemap->face_shader[i] = create_shader (&cubemap_shader_setup,
(void *) &faceno[i]);
shader_append_texmap (cubemap->face_shader[i], &cubemap->tex[i],
faceno[i]);
shader_append_texcoordgen (cubemap->face_shader[i], GX_TEXCOORD0,
GX_TG_MTX2x4, GX_TG_TEX0, GX_IDENTITY);
}
cubemap->size = size;
cubemap->fmt = fmt;
cubemap->sphtexels = memalign (32, GX_GetTexBufferSize (spsize, spsize, spfmt,
GX_FALSE, 0));
GX_InitTexObj (&cubemap->spheretex, cubemap->sphtexels, spsize, spsize, spfmt,
GX_CLAMP, GX_CLAMP, GX_FALSE);
cubemap->sphsize = spsize;
cubemap->sphfmt = spfmt;
return cubemap;
}
// render the globe
void miniglobe::render()
{
if (DONE==0)
{
switch (SHAPE)
{
case SHAPE_SUN: create_sun(); break;
case SHAPE_MERCURY: create_orb(minicoord::MINICOORD_ORB_MERCURY); break;
case SHAPE_VENUS: create_orb(minicoord::MINICOORD_ORB_VENUS); break;
case SHAPE_EARTH: create_earth(); break;
case SHAPE_MARS: create_orb(minicoord::MINICOORD_ORB_MARS); break;
case SHAPE_JUPITER: create_orb(minicoord::MINICOORD_ORB_JUPITER); break;
case SHAPE_SATURN: create_orb(minicoord::MINICOORD_ORB_SATURN); break;
case SHAPE_URANUS: create_orb(minicoord::MINICOORD_ORB_URANUS); break;
case SHAPE_NEPTUNE: create_orb(minicoord::MINICOORD_ORB_NEPTUNE); break;
case SHAPE_CERES: create_orb(minicoord::MINICOORD_ORB_CERES); break;
case SHAPE_PLUTO: create_orb(minicoord::MINICOORD_ORB_PLUTO); break;
case SHAPE_ERIS: create_orb(minicoord::MINICOORD_ORB_ERIS); break;
case SHAPE_MOON: create_moon(); break;
default: ERRORMSG();
}
create_shader(CONFIGURE_FRONTNAME,CONFIGURE_BACKNAME,
CONFIGURE_FRONTBUF,CONFIGURE_BACKBUF);
DONE=1;
}
initstate();
STRIP->render();
exitstate();
}
/* Creates shader:
* EXEC ADDR(0x3) CNT(0x1)
* (S)FETCH: VERTEX R1.xyz1 = R0.x FMT_32_32_32_FLOAT
* UNSIGNED STRIDE(12) CONST(26, 0)
* ALLOC POSITION SIZE(0x0)
* EXEC ADDR(0x4) CNT(0x1)
* ALU: MAXv export62 = R1, R1 ; gl_Position
* ALLOC PARAM/PIXEL SIZE(0x0)
* EXEC_END ADDR(0x5) CNT(0x0)
*/
static struct fd2_shader_stateobj *
create_solid_vp(void)
{
struct fd2_shader_stateobj *so = create_shader(SHADER_VERTEX);
struct ir2_cf *cf;
struct ir2_instruction *instr;
if (!so)
return NULL;
so->ir = ir2_shader_create();
cf = ir2_cf_create(so->ir, EXEC);
instr = ir2_instr_create_vtx_fetch(cf, 26, 0, FMT_32_32_32_FLOAT, false, 12);
ir2_reg_create(instr, 1, "xyz1", 0);
ir2_reg_create(instr, 0, "x", 0);
cf = ir2_cf_create_alloc(so->ir, SQ_POSITION, 0);
cf = ir2_cf_create(so->ir, EXEC);
instr = ir2_instr_create_alu(cf, MAXv, ~0);
ir2_reg_create(instr, 62, NULL, IR2_REG_EXPORT);
ir2_reg_create(instr, 1, NULL, 0);
ir2_reg_create(instr, 1, NULL, 0);
cf = ir2_cf_create_alloc(so->ir, SQ_PARAMETER_PIXEL, 0);
cf = ir2_cf_create(so->ir, EXEC_END);
return assemble(so);
}
NE_API void load_shader_asset(shader_asset* shader) {
Assert(shader->program_id == 0);
shader->program_id = glCreateProgram();
CHECK_GL_ERROR();
shader->vertex_shader_id = create_shader(GL_VERTEX_SHADER);
shader->fragment_shader_id = create_shader(GL_FRAGMENT_SHADER);
load_shader_from_file(shader->vertex_shader_id, shader->path + "/vertex.glsl");
load_shader_from_file(shader->fragment_shader_id, shader->path + "/fragment.glsl");
attach_vertex_shader(shader->program_id, shader->vertex_shader_id);
attach_fragment_shader(shader->program_id, shader->fragment_shader_id);
link_shader_program(shader->program_id);
shader->color_uniform = shader_uniform_location(shader->program_id, "uni_Color");
shader->model_uniform = shader_uniform_location(shader->program_id, "uni_Model");
shader->view_uniform = shader_uniform_location(shader->program_id, "uni_View");
shader->projection_uniform = shader_uniform_location(shader->program_id, "uni_Projection");
}
SmartPtr<VKShader>
VKDevice::create_shader (const char *file_name)
{
FileHandle file (file_name, "rb");
XCAM_FAIL_RETURN (
ERROR, file.is_valid (), NULL,
"VKDevice load shader failed when opend shader file:%s.",
XCAM_STR (file_name));
size_t file_size;
XCAM_FAIL_RETURN (
ERROR, xcam_ret_is_ok (file.get_file_size (file_size)) || file_size == 0, NULL,
"VKDevice load shader failed when read shader file:%s.",
XCAM_STR (file_name));
std::vector<uint32_t> content (XCAM_ALIGN_UP (file_size, 4) / 4, 0);
XCAM_FAIL_RETURN (
ERROR, xcam_ret_is_ok (file.read_file ((void *)content.data (), file_size)), NULL,
"VKDevice load shader failed when read shader file:%s.",
XCAM_STR (file_name));
file.close ();
SmartPtr<VKShader> shader = create_shader (content);
if (shader.ptr ())
shader->set_name (file_name);
return shader;
}
