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