static int make_flag_programs(struct flag_shaders *out_shaders)
{
out_shaders->vertex_shader = make_shader(GL_VERTEX_SHADER, "flag.v.glsl");
if (out_shaders->vertex_shader == 0)
return 0;
out_shaders->flag_fragment_shader = make_shader(GL_FRAGMENT_SHADER, "flag.f.glsl");
if (out_shaders->flag_fragment_shader == 0)
return 0;
out_shaders->shadowmap_fragment_shader
= make_shader(GL_FRAGMENT_SHADER, "flag-shadow-map.f.glsl");
if (out_shaders->shadowmap_fragment_shader == 0)
return 0;
out_shaders->flag_program
= make_program(out_shaders->vertex_shader, out_shaders->flag_fragment_shader);
if (out_shaders->flag_program == 0)
return 0;
out_shaders->shadowmap_program
= make_program(out_shaders->vertex_shader, out_shaders->shadowmap_fragment_shader);
if (out_shaders->shadowmap_program == 0)
return 0;
return 1;
}
void generate_debug_geometry(vector_buffer *vertices, vector_buffer *normals, geometry* out)
{
float temp[3];
vector_buffer debug;
vector_init(&debug);
for(int i = 0; i < out->vertex_count; ++i)
{
vec3_scale(vector_get(normals, i), 0.05f, temp);
vec3_add(vector_get(vertices, i), temp, temp);
vector_append(&debug, vector_get(vertices, i));
vector_append(&debug, temp);
}
out->debug_geometry.attributes.position = 3;
make_buffer(out->debug_geometry.attributes.position, &out->debug_geometry.vertex_buffer, debug.data , (GLsizei) (out->vertex_count * 3 * 2 * sizeof(float)));
out->debug_geometry.vertex_shader = make_shader(GL_VERTEX_SHADER, "shaders/debug_shader.v.glsl");
out->debug_geometry.fragment_shader = make_shader(GL_FRAGMENT_SHADER, "shaders/debug_shader.f.glsl");
out->debug_geometry.program = make_program(out->debug_geometry.vertex_shader, out->debug_geometry.fragment_shader);
glBindAttribLocation(out->debug_geometry.program, out->debug_geometry.attributes.position, "position");
glLinkProgram(out->debug_geometry.program);
out->debug_geometry.uniform.mvp_matrix = glGetUniformLocation(out->program, "mvp_matrix");
}
void
ShaderAPITest::test_uniform_size_type1(const char *glslType, GLenum glType, const char *el)
{
char buffer[1024];
GLuint program;
GLint active, i;
//printf(" Running subtest %s\n", glslType);
//fflush(stdout);
sprintf(buffer, "#version 120\nuniform %s m[60];\nvoid main() { gl_Position[0] = m[59]%s; }\n",
glslType, el);
program = make_program(buffer, NULL);
glGetProgramiv(program, GL_ACTIVE_UNIFORMS, &active);
assert_no_error();
for (i = 0; i < active; i++) {
GLint size = -1;
GLenum type = 0;
glGetActiveUniform(program, i, sizeof(buffer), NULL,
&size, &type, buffer);
assert_no_error();
assert(type == glType);
assert(size == 60);
if (strncmp(buffer, "m", 1) == 0)
break;
}
}
void
ShaderAPITest::test_uniform_query_matrix(void)
{
GLuint program;
GLfloat data[18];
GLint i, r, c;
GLint location;
program = make_program("#version 110\nuniform mat3 m[2];\nvoid main() { gl_Position.xyz = m[1][2]; }\n", NULL);
location = glGetUniformLocation(program, "m");
for (i = 0; i < 9; i++)
data[i] = i;
for (i = 9; i < 18; i++)
data[i] = 321.0;
glUniformMatrix3fv(location, 1, GL_TRUE, data);
for (i = 0; i < 18; i++)
data[i] = 123.0;
glGetUniformfv(program, location, data);
for (c = 0; c < 3; c++)
for (r = 0; r < 3; r++)
assert(data[c * 3 + r] == r * 3 + c);
for (i = 9; i < 18; i++)
assert(data[i] == 123.0);
}
// Global instance
void soso::setup(std::string path) {
printf("soso setup\n");
GLuint vertex_shader, fragment_shader;
vertex_shader = make_shader(GL_VERTEX_SHADER, (path + "/soso.vert").c_str());
fragment_shader = make_shader(GL_FRAGMENT_SHADER, (path + "/soso.frag").c_str());
program = make_program(vertex_shader, fragment_shader);
// Bind attributes
baseTexture = glGetUniformLocation(program, "baseTexture");
multipurposeMap = glGetUniformLocation(program, "multipurposeMap");
detailMap = glGetUniformLocation(program, "detailMap");
cubeMap = glGetUniformLocation(program, "cubeTextureMap");
maps = glGetUniformLocation(program, "maps");
scale = glGetUniformLocation(program, "scale");
reflectionScale = glGetUniformLocation(program, "reflectionScale");
fog = glGetUniformLocation(program, "fog");
fogSettings = glGetUniformLocation(program, "fogSettings");
ProjectionMatrix = glGetUniformLocation(program, "ProjectionMatrix");
ModelViewMatrix = glGetUniformLocation(program, "ModelViewMatrix");
Position = glGetUniformLocation(program, "Position");
//glBindAttribLocation(program, 1, "texCoord_buffer");
//glBindAttribLocation(program, 2, "normal_buffer");
printf("done %d %d %d %d\n", baseTexture, multipurposeMap, detailMap, cubeMap);
}
enum piglit_result
piglit_display(void)
{
GLboolean pass = GL_TRUE;
GLuint program, tex;
GLint tex_location;
tex = make_tex();
program = make_program();
glUseProgram(program);
tex_location = glGetUniformLocation(program, "tex");
glUniform1i(tex_location, 0);
piglit_draw_rect(-1.0f, -1.0f, 2.0f, 2.0f);
glUseProgram(0);
glDeleteTextures(1, &tex);
glDeleteProgram(program);
pass = piglit_probe_rect_rgb(0, 0,
piglit_width, piglit_height,
green) && pass;
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
void
ShaderAPITest::test_attrib_size_type1(const char *glslType, GLenum glType, const char *el)
{
char buffer[1024];
GLuint program;
GLint active, i;
//printf(" Running subtest %s\n", glslType);
//fflush(stdout);
sprintf(buffer, "#version 120\nattribute %s m;\nvoid main() { gl_Position[0] = m%s; }\n",
glslType, el);
program = make_program(buffer, NULL);
glGetProgramiv(program, GL_ACTIVE_ATTRIBUTES, &active);
assert_no_error();
for (i = 0; i < active; i++) {
GLint size = -1;
GLenum type = 0;
glGetActiveAttrib(program, i, sizeof(buffer), NULL,
&size, &type, buffer);
assert_no_error();
assert(type == glType);
assert(size == 1);
if (strncmp(buffer, "m", 1) == 0)
break;
}
assert(i < active); /* Otherwise the compiler optimised it out */
}
// Global instance
void null::setup(std::string path) {
printf("null setup\n");
GLuint vertex_shader, fragment_shader;
vertex_shader = make_shader(GL_VERTEX_SHADER, (path + "/null.vert").c_str());
fragment_shader = make_shader(GL_FRAGMENT_SHADER, (path + "/null.frag").c_str());
program = make_program(vertex_shader, fragment_shader);
printf("done\n");
}
virtual bool initialize() override
{
m_program = make_program();
glGenVertexArrays(1, &m_vao);
glBindVertexArray(m_vao);
return true;
};
void sph_simulation::simulate(int frame_count) {
if (frame_count == 0) {
frame_count = (int)ceil(parameters.simulation_time * parameters.target_fps);
}
cl_int cl_error;
std::vector<cl::Device> device_array;
check_cl_error(init_cl_single_device(&context_, device_array, "", "", true));
queue_ = cl::CommandQueue(context_, device_array[0], 0, &cl_error);
check_cl_error(cl_error);
running_device = &device_array[0];
std::string source = readKernelFile(BUFFER_KERNEL_FILE_NAME);
cl::Program program;
check_cl_error(make_program(&program, context_, device_array, source, true,
"-I ./kernels/ -I ./common/"));
kernel_density_pressure_ = make_kernel(program, "density_pressure");
kernel_advection_collision_ = make_kernel(program, "advection_collision");
kernel_forces_ = make_kernel(program, "forces");
kernel_locate_in_grid_ = make_kernel(program, "locate_in_grid");
kernel_sort_count_ = make_kernel(program, "sort_count");
kernel_sort_ = make_kernel(program, "sort");
front_buffer_ =
cl::Buffer(context_, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
sizeof(particle) * parameters.particles_count);
back_buffer_ = cl::Buffer(context_, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
sizeof(particle) * parameters.particles_count);
sort_count_buffer_ =
cl::Buffer(context_, CL_MEM_READ_WRITE | CL_MEM_ALLOC_HOST_PTR,
sizeof(unsigned int) * kSortThreadCount * kBucketCount);
particle* particles = new particle[parameters.particles_count];
init_particles(particles, parameters);
for (int i = 0; i < frame_count; ++i) {
if (pre_frame) {
pre_frame(particles, parameters, true);
}
for (int j = 0; (float)j < (1.f / parameters.simulation_scale); ++j) {
if (pre_frame) pre_frame(particles, parameters, false);
simulate_single_frame(particles, particles);
if (post_frame) post_frame(particles, parameters, false);
}
if (post_frame) {
post_frame(particles, parameters, true);
}
}
delete[] particles;
}
BoidRenderer::BoidRenderer(const BoidSystem& bs_,
std::string vshader_fname,
std::string fshader_fname,
int width,
int height)
: bs(bs_),
fov_angle_deg(60.0f),
near_plane(0.0625f),
far_plane(1024.0f),
vertex_shader_fname(vshader_fname),
fragment_shader_fname(fshader_fname)
{
update_projection_matrix((float)width/height);
// vertex buffer
GLuint vb;
glGenBuffers(1, &vb);
vertex_buffer = vb;
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer);
glBufferData(GL_ARRAY_BUFFER,
bs.size()*3*sizeof(GL_FLOAT),
NULL, GL_DYNAMIC_DRAW);
if (!vertex_buffer)
throw std::runtime_error("failed to create vertex_buffer");
vertex_shader = make_shader(
GL_VERTEX_SHADER, vertex_shader_fname.c_str());
if (!vertex_shader)
throw std::runtime_error("failed to create vertex_shader");
fragment_shader = make_shader(
GL_FRAGMENT_SHADER,
fragment_shader_fname.c_str());
if (!fragment_shader)
throw std::runtime_error("failed to create fragment_shader");
program = make_program(
vertex_shader, fragment_shader);
if (!program)
throw std::runtime_error("failed to compile shader program");
attributes.position = glGetAttribLocation(
program, "position");
if (attributes.position == -1)
throw std::runtime_error("failed to find 'position' attribute in shader program");
uniforms.pmatrix = glGetUniformLocation(
program, "pmatrix");
if (uniforms.pmatrix == -1)
throw std::runtime_error("failed to find 'pmatrix' uniform in shader program");
uniforms.mvmatrix = glGetUniformLocation(
program, "mvmatrix");
if (uniforms.mvmatrix == -1)
throw std::runtime_error("failed to find 'mvmatrix' uniform in shader program");
}
static void
use_texture_2d_program (GdkGLContextPaintData *paint_data)
{
static const char *vertex_shader_code_150 =
"#version 150\n"
"uniform sampler2D map;"
"in vec2 position;\n"
"in vec2 uv;\n"
"out vec2 vUv;\n"
"void main() {\n"
" gl_Position = vec4(position, 0, 1);\n"
" vUv = uv;\n"
"}\n";
static const char *fragment_shader_code_150 =
"#version 150\n"
"in vec2 vUv;\n"
"out vec4 vertexColor;\n"
"uniform sampler2D map;\n"
"void main() {\n"
" vertexColor = texture2D (map, vUv);\n"
"}\n";
static const char *vertex_shader_code_130 =
"#version 130\n"
"uniform sampler2D map;"
"attribute vec2 position;\n"
"attribute vec2 uv;\n"
"varying vec2 vUv;\n"
"void main() {\n"
" gl_Position = vec4(position, 0, 1);\n"
" vUv = uv;\n"
"}\n";
static const char *fragment_shader_code_130 =
"#version 130\n"
"varying vec2 vUv;\n"
"uniform sampler2D map;\n"
"void main() {\n"
" gl_FragColor = texture2D (map, vUv);\n"
"}\n";
const char *vertex_shader_code = paint_data->is_legacy
? vertex_shader_code_130
: vertex_shader_code_150;
const char *fragment_shader_code = paint_data->is_legacy
? fragment_shader_code_130
: fragment_shader_code_150;
if (paint_data->texture_2d_quad_program.program == 0)
make_program (&paint_data->texture_2d_quad_program, vertex_shader_code, fragment_shader_code);
if (paint_data->current_program != &paint_data->texture_2d_quad_program)
{
paint_data->current_program = &paint_data->texture_2d_quad_program;
glUseProgram (paint_data->current_program->program);
}
}
void marching_cubes(float threshold, scan_data *data, int debug, geometry* out) {
float temp[3];
vector_buffer vertices;
vector_buffer normals;
vector_init(&vertices);
vector_init(&normals);
for (size_t x = 0; x < data->length; x++)
for (size_t y = 0; y < data->width; y++)
for (size_t z = 0; z < data->height; z++) {
march_cube(x, y, z, step_size, threshold, data, &vertices, &normals);
}
out->vertex_count = (GLuint) vertices.size;
out->attributes.position = 0;
out->attributes.normal = 1;
make_buffer(out->attributes.position, &out->vertex_buffer, vertices.data , (GLsizei) (out->vertex_count * 3 * sizeof(float)));
make_buffer(out->attributes.normal, &out->vertex_buffer, normals.data , (GLsizei) (out->vertex_count * 3 * sizeof(float)));
out->vertex_shader = make_shader(GL_VERTEX_SHADER, "shaders/diffuse_shader.v.glsl");
out->fragment_shader = make_shader(GL_FRAGMENT_SHADER, "shaders/diffuse_shader.f.glsl");
out->program = make_program(out->vertex_shader, out->fragment_shader);
glBindAttribLocation(out->program, out->attributes.position, "position");
glBindAttribLocation(out->program, out->attributes.normal, "normal");
glLinkProgram(out->program);
out->uniform.mvp_matrix = glGetUniformLocation(out->program, "mvp_matrix");
out->uniform.normal_matrix = glGetUniformLocation(out->program, "normal_matrix");
out->center[0] = 0.0f;
out->center[1] = 0.0f;
out->center[2] = 0.0f;
for(size_t i = 0; i < out->vertex_count; ++i)
{
vec3_scale(vertices.data[i], -1.0f / out->vertex_count, temp);
vec3_add(out->center, temp, out->center);
}
if(debug)
{
generate_debug_geometry(&vertices, &normals, out);
}
vector_free(&vertices);
vector_free(&normals);
}
void
ShaderAPITest::test_uniform_scalar_count(void)
{
GLuint program;
GLint location;
GLfloat data[128];
program = make_program("#version 110\nuniform vec2 x;\nvoid main() { gl_Position.xy = x; }\n", NULL);
location = glGetUniformLocation(program, "x");
assert_no_error();
glUniform2fv(location, 64, data);
assert_error(GL_INVALID_OPERATION);
}
void
ShaderAPITest::test_uniform_array_overflow(void)
{
GLuint program;
GLint location;
GLfloat data[128];
program = make_program("#version 120\nuniform vec2 x[10];\nvoid main() { gl_Position.xy = x[9]; }\n", NULL);
location = glGetUniformLocation(program, "x");
assert_no_error();
glUniform2fv(location, 64, data);
assert_no_error();
}
int Renderer::init(const std::string &v_shader, const std::string &f_shader) {
GLuint vert_shader = make_shader(GL_VERTEX_SHADER, v_shader);
GLuint frag_shader = make_shader(GL_FRAGMENT_SHADER, f_shader);
if (!vert_shader || !frag_shader) {
return -1;
}
shader_prog = make_program({ vert_shader, frag_shader });
if (!shader_prog) {
return -1;
}
return 0;
}
/*
* Load and create all of our resources:
*/
static int make_resources(void)
{
g_resources.vertex_buffer = make_buffer(
GL_ARRAY_BUFFER,
g_vertex_buffer_data,
sizeof(g_vertex_buffer_data)
);
g_resources.element_buffer = make_buffer(
GL_ELEMENT_ARRAY_BUFFER,
g_element_buffer_data,
sizeof(g_element_buffer_data)
);
g_resources.textures[0] = make_texture("data/hello1.tga");
g_resources.textures[1] = make_texture("data/hello2.tga");
if (g_resources.textures[0] == 0 || g_resources.textures[1] == 0)
return 0;
g_resources.vertex_shader = make_shader(
GL_VERTEX_SHADER,
"hello-gl.v.glsl"
);
if (g_resources.vertex_shader == 0)
return 0;
g_resources.fragment_shader = make_shader(
GL_FRAGMENT_SHADER,
"hello-gl.f.glsl"
);
if (g_resources.fragment_shader == 0)
return 0;
g_resources.program = make_program(g_resources.vertex_shader, g_resources.fragment_shader);
if (g_resources.program == 0)
return 0;
g_resources.uniforms.fade_factor
= glGetUniformLocation(g_resources.program, "fade_factor");
g_resources.uniforms.textures[0]
= glGetUniformLocation(g_resources.program, "textures[0]");
g_resources.uniforms.textures[1]
= glGetUniformLocation(g_resources.program, "textures[1]");
g_resources.attributes.position
= glGetAttribLocation(g_resources.program, "position");
return 1;
}
void
ShaderAPITest::test_uniform_multiple_samplers(void)
{
GLuint program;
GLint location;
GLint values[2] = {0, 1};
assert_no_error();
program = make_program(NULL, "uniform sampler2D s[2];\nvoid main() { gl_FragColor = texture2D(s[1], vec2(0.0, 0.0)); }\n");
location = glGetUniformLocation_func(program, "s[0]");
assert(location != -1);
assert_no_error();
glUniform1iv_func(location, 2, values);
assert_no_error();
}
GLuint make_program(const std::string& vertexname, const std::string& fragmentname)
{
GLuint vertex_shader = make_shader(GL_VERTEX_SHADER, vertexname);
if (vertex_shader == 0)
return 0;
GLuint fragment_shader = make_shader(GL_FRAGMENT_SHADER, fragmentname);
if (fragment_shader == 0)
return 0;
GLuint program = make_program(vertex_shader, fragment_shader);
if (program == 0)
return 0;
return program;
}
void
ShaderAPITest::test_uniform_neg_location(void)
{
GLuint program;
GLfloat data[4];
program = make_program("#version 110\nvoid main() { gl_Position = vec4(1.0, 1.0, 1.0, 1.0); }\n", NULL);
assert_no_error();
glUniform1i_func(-1, 1);
assert_no_error();
glUniform1i_func(-200, 1);
assert_error(GL_INVALID_OPERATION);
glUniformMatrix2fv_func(-1, 1, GL_FALSE, data);
assert_no_error();
glUniformMatrix2fv_func(-200, 1, GL_FALSE, data);
assert_error(GL_INVALID_OPERATION);
}
void
ShaderAPITest::test_uniform_bool_conversion(void)
{
GLuint program;
GLint location;
GLint value[16]; /* in case glGetUniformiv goes nuts on the stack */
assert_no_error();
program = make_program("uniform bool b;\nvoid main() { gl_Position.x = b ? 1.5 : 0.5; }\n", NULL);
location = glGetUniformLocation(program, "b");
assert(location != -1);
assert_no_error();
glUniform1i(location, 5);
assert_no_error();
glGetUniformiv(program, location, &value[0]);
assert_no_error();
assert(value[0] == 1);
}
// not this function take the vertex shader file as input
static int make_resources(const char *vertex_shader_file)
{
g_resources.vertex_buffer = make_buffer(GL_ARRAY_BUFFER,
g_vertex_buffer_data,
sizeof(g_vertex_buffer_data));
g_resources.element_buffer = make_buffer(GL_ELEMENT_ARRAY_BUFFER,
g_element_buffer_data,
sizeof(g_element_buffer_data));
/* make textures*/
g_resources.textures[0] = make_texture("hello1.tga");
g_resources.textures[1] = make_texture("hello2.tga");
if(g_resources.textures[0] == 0 || g_resources.textures[1] == 0)
{
return 0;
}
/*make shaders */
g_resources.vertex_shader = make_shader(GL_VERTEX_SHADER, vertex_shader_file);
if(g_resources.vertex_shader == 0)
{
return 0;
}
g_resources.fragment_shader = make_shader(GL_FRAGMENT_SHADER, "hello-gl.f.glsl");
if(g_resources.fragment_shader == 0)
{
return 0;
}
g_resources.program = make_program(g_resources.vertex_shader, g_resources.fragment_shader);
if(g_resources.program == 0)
{
return 0;
}
g_resources.uniforms.timer = glGetUniformLocation(g_resources.program, "timer");
g_resources.uniforms.textures[0] = glGetUniformLocation(g_resources.program, "textures[0]");
g_resources.uniforms.textures[1] = glGetUniformLocation(g_resources.program, "textures[1]");
g_resources.attributes.position = glGetAttribLocation(g_resources.program, "position");
return 1;
}
static int make_resources(void) {
g_resources.vertex_buffer = make_buffer(
GL_ARRAY_BUFFER,
g_vertex_buffer_data,
sizeof(g_vertex_buffer_data));
g_resources.element_buffer = make_buffer(
GL_ELEMENT_ARRAY_BUFFER,
g_element_buffer_data,
sizeof(g_element_buffer_data));
g_resources.vertex_shader = make_shader(
GL_VERTEX_SHADER,
"gl.v.glsl");
if (g_resources.vertex_shader == 0)
return 0;
g_resources.fragment_shader = make_shader(
GL_FRAGMENT_SHADER,
"gl.f.glsl");
if (g_resources.fragment_shader == 0)
return 0;
g_resources.program = make_program(
g_resources.vertex_shader,
g_resources.fragment_shader);
if (g_resources.program == 0)
return 0;
g_resources.attributes.position
= glGetAttribLocation(g_resources.program, "position");
return 1;
}
int Assembler::assemble(int debug)
{
// makes machine-code from read Assemblercode
// returns 0 if successful, otherwise error-code:
/*
1 : error while decoding command
2 : error while parsing parameter
3 : label or name not found
*/
if (debug > 1)
{
printf("[FUNCTION: assemble]\n");
printf("VAR: filename_input = %s\n", filename_input);
}
this->debug = debug;
int err;
err = make_preprogram();
if (debug > 1)
printf("FINISHED make_preprogram\n\tERR = %i\n\n",err);
if (err == 0)
{
err = make_program();
if (debug > 1)
printf("FINISHED make_program\n\tERR = %i\n\n",err);
if (err != 0)
return err + 1;
} else
return err;
return 0;
}
/*
* Load and create all of our resources:
*/
int GameAsset::make_resources(void)
{
vertex_buffer = make_buffer(
GL_ARRAY_BUFFER,
g_vertex_buffer_data,
3 * sizeof(GLfloat) * this->num_vertices
);
element_buffer = make_buffer(
GL_ELEMENT_ARRAY_BUFFER,
g_element_buffer_data,
3 * sizeof(GLushort) * this->num_triangles
);
vertex_shader = make_shader(
GL_VERTEX_SHADER,
this->v_shader.c_str()
);
if (vertex_shader == 0)
return 0;
fragment_shader = make_shader(
GL_FRAGMENT_SHADER,
this->f_shader.c_str()
);
if (fragment_shader == 0)
return 0;
program = make_program(vertex_shader, fragment_shader);
if (program == 0)
return 0;
position_attrib = glGetAttribLocation(program, "position");
tx_uniform = glGetUniformLocation(program, "tx");
return 1;
}
void make_makefile(int platform)
{
char tmp[100],*s,de[5];
FILE *fp;
if (platform==DOS)
strcpy(de,".exe");
else de[0]=0;
if (!get_var("MAKEFILE_NAME",tmp))
{
if (platform==DOS)
strcpy(tmp,"makefile.wat");
else
strcpy(tmp,"Makefile");
}
fp=fopen(tmp,"w");
if (!fp)
{
printf("Unable to open %s for writing\n",tmp);
exit(0);
}
fprintf(fp,"CC=%s\n",compiler(platform));
write_flags(fp,platform,0);
write_flags(fp,platform,1);
list_o_files("IMLIB_OBJS",fp,imlib_objs,imlib_dir,object_extension(platform),platform,0);
list_o_files("IMLIB_OBJS",fp,imlib_objs,imlib_dir,object_extension(platform),platform,1);
list_o_files("PROG_OBJS",fp,ofiles,NULL,object_extension(platform),platform,0);
list_o_files("PROG_OBJS",fp,ofiles,NULL,object_extension(platform),platform,1);
if (platform==LINUX) /* for linux make two versions of program, X11 & SVGA */
{
sprintf(tmp,"%sx",basename);
fprintf(fp,"all : %s %s\n\n",basename,tmp);
make_program(fp,basename,"LINUX_SVGA",platform,0);
make_program(fp,tmp,"LINUX_X",platform,0);
fprintf(fp,"opt : %so %so\n\n",basename,tmp);
make_program(fp,basename,"LINUX_SVGA",platform,1);
make_program(fp,tmp,"LINUX_X",platform,1);
}
else
{
fprintf(fp,"all : %s%s\n\n",basename,de);
make_program(fp,basename,plat_name[platform],platform,0);
fprintf(fp,"opt : %so%s\n\n",basename,de);
make_program(fp,basename,plat_name[platform],platform,1);
}
sprintf(tmp,"%s_FILES",plat_name[platform]);
list_o_depends(fp,tmp,imlib_dir,platform,0);
list_o_depends(fp,tmp,imlib_dir,platform,1);
list_o_depends(fp,"IMLIB_OBJS",imlib_dir,platform,0);
list_o_depends(fp,"IMLIB_OBJS",imlib_dir,platform,1);
list_o_depends(fp,"O_FILES",NULL,platform,0);
list_o_depends(fp,"O_FILES",NULL,platform,1);
if (platform!=DOS)
{
fprintf(fp,"clean :\n\t"
"rm -f $(%s_FILES) $(IMLIB_OBJS) $(O_FILES)\n",
plat_name[platform]);
fprintf(fp,"cleano :\n\t"
"rm -f $(%s_FILES_O) $(IMLIB_OBJS_O) $(O_FILES_O)\n",
plat_name[platform]);
}
if (plat_stuff)
fprintf(fp,"%s",plat_stuff); /* add any platform specific additions */
fclose(fp);
}
GLuint load_program(const char *path1, const char *path2) {
GLuint shader1 = load_shader(GL_VERTEX_SHADER, path1);
GLuint shader2 = load_shader(GL_FRAGMENT_SHADER, path2);
GLuint program = make_program(shader1, shader2);
return program;
}
void test_nodeui_base(){
RtAudio dac;
RtAudio::StreamParameters parm;
parm.deviceId = 0;//dac.getDefaultOutputDevice();
parm.nChannels = 2;
parm.firstChannel = 0;
RtAudio::StreamOptions so;
unsigned int bufferFrames = BUFFERSIZE;
AudioScheduler a_sched;
ControlScheduler c_sched;
dac.openStream(&parm,NULL,RTAUDIO_SINT16, 44100, &bufferFrames, & saw, (void *) &a_sched);
dac.startStream();
init_ogl(1024,1024);
GLProgram shader = make_program("shaders/naive.vert","shaders/naive.frag");
UiBox ub1(Vec2f(-400.0,-300.0),Vec2f(800.0,600.0),{0.0,0.0,0.0,1.0},0.0,{0.0,0.0,0.0,0.0});
square_vbo = make_buffer<float>( {0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0}, 2,ARRAY_BUFFER, STATIC_DRAW);
line_vbo = make_buffer<float>({0.0,0.0,1.0,1.0}, 2,ARRAY_BUFFER, STATIC_DRAW);
float it = 0.0;
scale =0.5;
camera_x = 200.0;
camera_y = -50.0;
bool running = true;
bool pause_proc = false;
bool pause_ready = false;
NodeGridInputHandler ngrid(&pause_proc, &pause_ready);;
ngrid.backend.register_scheduler(&a_sched);
ngrid.backend.register_scheduler(&c_sched);
ngrid.shader = shader;
ngrid.node_creators["osc"] = [](){return new Osc(440);};
ngrid.node_creators["add-audio"] = [](){return new AddAudio();};
ngrid.node_creators["audio-out"] = [](){return new AudioOut3();};
ngrid.node_creators["line-play"] = [](){return new line_play(1.0,std::vector<float>({0.0})) ;};
ngrid.node_creators["phasor"] = [](){return new Phasor(440) ;};
ngrid.node_creators["multiply"] = []() {return new MultNode();};
ngrid.node_creators["sub-audio"] = [](){return new SubAudio();};
ngrid.node_creators["divide"] = []() {return new DivNode();};
ngrid.node_creators["clip"] = []() {return new ClipNode();};
ngrid.node_creators["quit-program"] = [&running](){return new QuitProgramNode(&running);};
ngrid.node_creators["save-patch"] = [&ngrid](){return new SavePatchNode(&ngrid);};
ngrid.node_creators["load-patch"] = [&ngrid](){return new LoadPatchNode(&ngrid);};
Node * n1 = ngrid.create_and_insert_node("osc", Vec2f(0.0,0.0));
Node *n2 = ngrid.create_and_insert_node("audio-out", Vec2f(0.0,50.0));
Node *n3 = ngrid.create_and_insert_node("line-play 0.01 10 12 10 8",Vec2f(0.0,-100));
ngrid.connect(n1,0,n2,0);
ngrid.connect(n3,0,n1,0);
mouse_move_spawner.register_listener(&ngrid);
mouse_click_handler.register_listener(&ngrid);
char_event_spawner.register_listener(&ngrid);
key_event_handler.register_listener(&ngrid);
mouse_wheel_event_spawner.register_listener(&ngrid);
std::thread ngrid_thread([&](){
while(running){
if(pause_proc){
pause_ready = true;
}else{
pause_ready = false;
ngrid.backend.update();
}
}
});
while(running){
float t = get_time();
if(ngrid.change){
shader.uniformf("camera_scale",1.0,1.0);
shader.uniformf("camera_translate",0.0,0.0);
bind_buffer_object(square_vbo,0);
shader.uniformf("size",2.0,2.0);
shader.uniformf("pos",-1.0,-1.0);
shader.uniformf("color",0.0,0.0,0.5,1.0);
draw_buffers_triangle_fan(4);
shader.uniformf("camera_scale",2.0/1024.0*scale,2.0/1024.0*scale);
shader.uniformf("camera_translate",camera_x,camera_y);
ngrid.draw();
ngrid.draw2(shader);
ngrid.change = false;
}else{
std::cout << "Graphics sleeping.. \n";
}
swapbuffers();
std::cout << "DT: " << get_time() - t << "\n";
float t_left = 1.0/30.0 - (get_time() - t);
std::cout << t_left << "\n";
if(t_left > 0){
sleep_sec(t_left);
}
}
ngrid_thread.join();
}
enum piglit_result
piglit_display(void)
{
GLuint tex;
static const float red[] = { 1, 0, 0, 1 };
static const float green[] = { 0, 1, 0, 1 };
static const float blue[] = { 0, 0, 1, 1 };
static const float cyan[] = { 0, 1, 1, 1 };
pass = GL_TRUE;
extension_supported =
piglit_is_extension_supported("GL_EXT_unpack_subimage");
if (!piglit_automatic) {
if (extension_supported)
printf("GL_EXT_unpack_subimage is supported\n");
else
printf("GL_EXT_unpack_subimage is not supported\n");
}
piglit_reset_gl_error();
if (!piglit_automatic)
printf("Trying GL_UNPACK_ROW_LENGTH\n");
glPixelStorei(GL_UNPACK_ROW_LENGTH, 2);
check_error();
piglit_reset_gl_error();
if (!piglit_automatic)
printf("Trying GL_UNPACK_SKIP_PIXELS\n");
glPixelStorei(GL_UNPACK_SKIP_PIXELS, 1);
check_error();
piglit_reset_gl_error();
if (!piglit_automatic)
printf("Trying GL_UNPACK_SKIP_ROWS\n");
glPixelStorei(GL_UNPACK_SKIP_ROWS, 4);
check_error();
glClear(GL_COLOR_BUFFER_BIT);
/* Try creating a texture with the unpacking parameters we've set */
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D,
0, /* level */
GL_RGBA, /* internalFormat */
1, /* width */
2, /* height */
0, /* border */
GL_RGBA, /* format */
GL_UNSIGNED_BYTE, /* type */
tex_data);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
make_program(vertex_shader, fragment_shader);
piglit_draw_rect_tex(-1, -1, 2, 2,
0, 0, 1, 1);
if (extension_supported) {
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height / 4,
blue);
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height * 3 / 4,
cyan);
} else {
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height / 4,
red);
pass &= piglit_probe_pixel_rgba(piglit_width / 2,
piglit_height * 3 / 4,
green);
}
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
int main(int argc, char **argv){
/* vertices for a triangle */
/* Why does triangle[] = { vec4_new(...) } result in a segfault when returning
* from _mm_load_ps?
*/
/* Just want a sort of 3D object, but not a closed object otherwise it's hard
* to tell what's going on w/ flat shading */
vec4_t object[18];
//+Z face
object[0] = vec4_new(-1, -1, 1, 1);
object[1] = vec4_new(1, -1, 1, 1);
object[2] = vec4_new(1, 1, 1, 1);
object[3] = vec4_new(1, 1, 1, 1);
object[4] = vec4_new(-1, 1, 1, 1);
object[5] = vec4_new(-1, -1, 1, 1);
//+X face
object[6] = vec4_new(1, -1, 1, 1);
object[7] = vec4_new(1, -1, -1, 1);
object[8] = vec4_new(1, 1, -1, 1);
object[9] = vec4_new(1, 1, -1, 1);
object[10] = vec4_new(1, 1, 1, 1);
object[11] = vec4_new(1, -1, 1, 1);
//-X face
object[12] = vec4_new(-1, -1, 1, 1);
object[13] = vec4_new(-1, -1, -1, 1);
object[14] = vec4_new(-1, 1, -1, 1);
object[15] = vec4_new(-1, 1, -1, 1);
object[16] = vec4_new(-1, 1, 1, 1);
object[17] = vec4_new(-1, -1, 1, 1);
if (SDL_Init(SDL_INIT_EVERYTHING) != 0){
fprintf(stderr, "SDL Init error: %s\n", SDL_GetError());
return 1;
}
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
#ifdef DEBUG
SDL_GL_SetAttribute(SDL_GL_CONTEXT_FLAGS, SDL_GL_CONTEXT_DEBUG_FLAG);
#endif
SDL_Window *win = SDL_CreateWindow("SSE GL Test", SDL_WINDOWPOS_CENTERED,
SDL_WINDOWPOS_CENTERED, WIN_WIDTH, WIN_HEIGHT, SDL_WINDOW_OPENGL);
SDL_GLContext context = SDL_GL_CreateContext(win);
if (check_GL_error("Opened win + context")){
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
return 1;
}
glewExperimental = GL_TRUE;
GLenum err = glewInit();
if (err != GLEW_OK){
fprintf(stderr, "GLEW init error %d\n", err);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
return 1;
}
check_GL_error("Post GLEW init");
#ifdef DEBUG
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS_ARB);
glDebugMessageCallbackARB(gl_debug_callback, NULL);
glDebugMessageControlARB(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE,
0, NULL, GL_TRUE);
#endif
glClearColor(0, 0, 0, 1);
glClearDepth(1);
glEnable(GL_DEPTH_TEST);
//Model's vao and vbo
GLuint model[2];
glGenVertexArrays(1, model);
glBindVertexArray(model[0]);
glGenBuffers(1, model + 1);
glBindBuffer(GL_ARRAY_BUFFER, model[1]);
glBufferData(GL_ARRAY_BUFFER, 4 * 6 * 3 * sizeof(GLfloat), object, GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);
if (check_GL_error("Setup buffers")){
return 1;
}
GLint vshader = make_shader(vert_shader_src, GL_VERTEX_SHADER);
GLint fshader = make_shader(frag_shader_src, GL_FRAGMENT_SHADER);
if (vshader == -1 || fshader == -1){
return 1;
}
GLint program = make_program(vshader, fshader);
if (program == -1){
return 1;
}
glDeleteShader(vshader);
glDeleteShader(fshader);
mat4_t model_mat = mat4_mult(mat4_rotate(45, vec4_new(1, 1, 0, 0)), mat4_scale(2, 2, 2));
model_mat = mat4_mult(mat4_translate(vec4_new(0, 2, -5, 1)), model_mat);
mat4_t view_mat = mat4_look_at(vec4_new(0, 0, 5, 0), vec4_new(0, 0, 0, 0), vec4_new(0, 1, 0, 0));
mat4_t proj_mat = mat4_perspective(75, ((float)WIN_WIDTH) / WIN_HEIGHT, 1, 100);
glUseProgram(program);
GLuint model_unif = glGetUniformLocation(program, "model");
GLuint view_unif = glGetUniformLocation(program, "view");
GLuint proj_unif = glGetUniformLocation(program, "proj");
glUniformMatrix4fv(model_unif, 1, GL_FALSE, (GLfloat*)&model_mat);
glUniformMatrix4fv(view_unif, 1, GL_FALSE, (GLfloat*)&view_mat);
glUniformMatrix4fv(proj_unif, 1, GL_FALSE, (GLfloat*)&proj_mat);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glDrawArrays(GL_TRIANGLES, 0, 18);
SDL_GL_SwapWindow(win);
check_GL_error("Post Draw");
SDL_Event e;
int quit = 0;
while (!quit){
while (SDL_PollEvent(&e)){
if (e.type == SDL_QUIT || e.type == SDL_KEYDOWN){
quit = 1;
}
}
}
glDeleteProgram(program);
glDeleteVertexArrays(1, model);
glDeleteBuffers(1, model + 1);
SDL_GL_DeleteContext(context);
SDL_DestroyWindow(win);
return 0;
}
