void SPECTRUM_INDICATOR__TYPE_CIRCLE::setup(int _N)
{
/********************
********************/
setup_gui();
init_vbo();
/********************
********************/
const int TargetNum = 50;
N = _N;
if(TargetNum < N){
NUM_DISP_SPECTRUMS = TargetNum;
}else{
NUM_DISP_SPECTRUMS = N;
}
IndicatorAngleStep = float(360) / NUM_DISP_SPECTRUMS;
for(int GroupNum = SIZE_S; GroupNum < NUM_INDICATORS; GroupNum++){
BaseAngle[GroupNum] = 0;
}
/********************
********************/
update_DynamicParam();
}
void viewer::init()
{
map.load();
init_program();
init_vbo();
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);
}
void SPECTRUM_INDICATOR__TYPE_POINT::setup(int _N)
{
/********************
********************/
setup_gui();
init_vbo();
/********************
********************/
N = _N;
/********************
********************/
update_DynamicParam();
}
cube *cube_create(void)
{
cube *C;
if ((C = (cube *) malloc(sizeof (cube))))
{
glGenBuffers (1, C->vbo);
glGenBuffers (1, C->ebo);
glGenTextures(6, C->tex);
init_vbo(C);
init_tex(C);
}
return C;
}
bool Image32::load_texture_from_pixels_32()
{
if (_texture_id == 0 && _pixels_32 != NULL) {
// generate and bind texture
glGenTextures(1, &_texture_id);
glBindTexture(GL_TEXTURE_2D, _texture_id);
// set texture
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _texture_width, _texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, _pixels_32);
// set texture params
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
// unbind texture
glBindTexture(GL_TEXTURE_2D, NULL);
// check for errors
//GLenum error = glGetError();
GLenum error = GL_NO_ERROR;
if (error != GL_NO_ERROR) {
std::cout << "error loading texture: " << gluErrorString(error) << std::endl;
return false;
} else {
delete [] _pixels_32;
_pixels_32 = NULL;
init_vbo();
}
} else {
std::cout << "cannot load texture from current pixels!" << std::endl;
if (_texture_id != 0) {
std::cout << "a texture has already been loaded" << std::endl;
}
if (_pixels_32 != NULL) {
std::cout << "pixels are not null" << std::endl;
}
return false;
}
_pixel_format = GL_RGBA;
return true;
}
// ----------------------------------------
// Ashton::ParticleEmitter#initialize
VALUE Ashton_ParticleEmitter_init(VALUE self, VALUE x, VALUE y, VALUE z, VALUE max_particles)
{
EMITTER();
emitter->x = NUM2DBL(x);
emitter->y = NUM2DBL(y);
emitter->z = NUM2DBL(z);
// Create space for all the particles we'll ever need!
emitter->max_particles = NUM2UINT(max_particles);
init_vbo(emitter);
emitter->particles = ALLOC_N(Particle, emitter->max_particles);
memset(emitter->particles, 0, emitter->max_particles * sizeof(Particle));
return self;
}
void SPECTRUM_INDICATOR__TYPE_STRAIGHT::setup(int _N)
{
/********************
********************/
setup_gui();
init_vbo();
/********************
********************/
N = _N;
// NUM_DISP_SPECTRUMS = int(N * 0.3);
NUM_DISP_SPECTRUMS = int(N * 0.15);
set_x_ofs();
/********************
********************/
update_DynamicParam();
}
void init_quadvbo(void) {
Vertex verts[] = {
{{-0.5,-0.5,0},{0,0,1},0,0},
{{-0.5,0.5,0},{0,0,1},0,1},
{{0.5,0.5,0},{0,0,1},1,1},
{{0.5,-0.5,0},{0,0,1},1,0},
// Alternative quad for FBO
{{-0.5,-0.5,0},{0,0,1},0,1},
{{-0.5,0.5,0},{0,0,1},0,0},
{{0.5,0.5,0},{0,0,1},1,0},
{{0.5,-0.5,0},{0,0,1},1,1}
};
init_vbo(&_vbo, VBO_SIZE);
glBindBuffer(GL_ARRAY_BUFFER, _vbo.vbo);
vbo_add_verts(&_vbo, verts, 8);
}
static struct page *init_cache(int n, int m)
{
struct page *buf;
if ((buf = (struct page *) malloc(m * sizeof (struct page))))
{
int i;
for (i = 0; i < m; ++i)
{
buf[i].x = 0.0f;
buf[i].y = 0.0f;
buf[i].a = 0.0f;
buf[i].vbo = init_vbo(n, NULL);
buf[i].next = (i == m - 1) ? -1 : i + 1;
buf[i].prev = (i == 0 ) ? -1 : i - 1;
}
}
return buf;
}
bool Image32::load_texture_from_pixels_32(GLuint* pixels, GLuint img_width, GLuint img_height, GLuint tex_width, GLuint tex_height)
{
free_texture(); // free textue if it exists
_image_width = img_width;
_image_height = img_height;
_texture_width = tex_width;
_texture_height = tex_height;
// generate texture
glGenTextures(1, &_texture_id);
// bind the gexture
glBindTexture(GL_TEXTURE_2D, _texture_id);
// set texture from pixels
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, _texture_width, _texture_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
// set texture params
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
// Unbind
glBindTexture(GL_TEXTURE_2D, NULL);
GLenum error = glGetError();
if (error != GL_NO_ERROR) {
std::cout << "unable to set pixels: " << gluErrorString(error) << std::endl;
return false;
}
_pixel_format = GL_RGBA;
init_vbo();
return true;
}
int32_t main(int32_t argc, char *argv[]) {
if( init_sdl2() ) {
return 1;
}
SDL_Window* window;
sdl2_window("test-grid", 100, 60, 1280, 720, &window);
SDL_GLContext* context;
sdl2_glcontext(3, 2, window, &context);
if( init_vbo() ) {
return 1;
}
printf("vbo\n");
struct Vbo vbo = {0};
vbo_create(&vbo);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_NORMAL, 3, GL_FLOAT, GL_STATIC_DRAW);
struct Ibo ibo = {0};
ibo_create(GL_TRIANGLES, GL_UNSIGNED_INT, GL_STATIC_DRAW, &ibo);
struct Grid grid = {0};
grid_create(4,4,1,&grid);
struct GridPages pages = {0};
grid_pages(&grid,2,2,1,&pages);
grid_dump(grid,pages);
struct GridIndex index = {0};
for( uint64_t z = 0; z < grid.size.z; z++ ) {
for( uint64_t y = 0; y < grid.size.y; y++ ) {
for( uint64_t x = 0; x < grid.size.x; x++ ) {
grid_index_xyz(&grid, &pages, NULL, x, y, z, &index);
printf("x:%lu y:%lu z:%lu page:%lu cell:%lu\n", x, y, z, index.page, index.cell);
}
}
}
printf("-----------\n");
struct GridBox box = {0};
box.position.x = 1;
box.position.y = 1;
box.position.z = 0;
box.size.x = 2;
box.size.y = 2;
box.size.z = 1;
box.level = 0;
for( uint64_t z = 0; z < box.size.z; z++ ) {
for( uint64_t y = 0; y < box.size.y; y++ ) {
for( uint64_t x = 0; x < box.size.x; x++ ) {
grid_index_xyz(&grid, &pages, &box, x, y, z, &index);
printf("x:%lu y:%lu z:%lu page:%lu cell:%lu\n", x, y, z, index.page, index.cell);
}
}
}
struct GridSize size = {0};
uint64_t array_size = grid_levelsize(&grid, &pages, 0, &size)->array;
for( int32_t i = 0; i < array_size; i++ ) {
grid_index(&grid, &pages, NULL, i, &index);
}
uint64_t x = UINT64_MAX;
printf("0x%lx\n", x);
grid_alloc(&pages, 0, 0);
grid_alloc(&pages, 1, 0);
grid_alloc(&pages, 2, 0);
grid_alloc(&pages, 3, 0);
grid_set1(&grid, &pages, NULL, 23);
grid_set1(&grid, &pages, &box, 42);
printf("lala\n");
grid_pagebox(&grid, &pages, 3, 0, &box);
printf("%lu %lu %lu %lu %lu %lu %d\n", box.position.x, box.position.y, box.position.z, box.size.x, box.size.y, box.size.z, box.level);
/* grid_pageout(&grid, &pages, 0, NULL); */
/* printf("\n"); */
/* grid_pageout(&grid, &pages, 1, NULL); */
/* printf("\n"); */
/* grid_pageout(&grid, &pages, 2, NULL); */
/* printf("\n"); */
/* grid_pageout(&grid, &pages, 3, NULL); */
/* printf("\n"); */
return 0;
}
int32_t main(int32_t argc, char *argv[]) {
if( init_sdl2() ) {
return 1;
}
SDL_Window* window;
sdl2_window("test-shading", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1280, 720, &window);
SDL_GLContext* context;
sdl2_glcontext(3, 2, window, (Color){0, 0, 0, 255}, &context);
if( init_shader() ) {
return 1;
}
if( init_vbo() ) {
return 1;
}
if( init_canvas(1280,720) ) {
return 1;
}
canvas_create("global_dynamic_canvas", 1280, 720, &global_dynamic_canvas);
canvas_create("global_static_canvas", 1280, 720, &global_static_canvas);
struct Vbo test_vbo = {0};
vbo_create(&test_vbo);
vbo_add_buffer(&test_vbo, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_STATIC_DRAW);
struct Ibo test_ibo = {0};
ibo_create(GL_TRIANGLES, GL_UNSIGNED_INT, GL_STATIC_DRAW, &test_ibo);
struct VboMesh test_mesh1 = {0};
vbo_mesh_create(&test_vbo, &test_ibo, &test_mesh1);
float triangle1[3*3] = {1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0};
vbo_mesh_append_attributes(&test_mesh1, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, 3, &triangle1);
vbo_mesh_print(&test_mesh1);
struct VboMesh test_mesh2 = {0};
vbo_mesh_create(&test_vbo, &test_ibo, &test_mesh2);
float triangle2[3*3] = {4.0, 4.0, 4.0, 5.0, 5.0, 5.0, 6.0, 6.0, 6.0};
vbo_mesh_append_attributes(&test_mesh2, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, 3, &triangle2);
vbo_mesh_print(&test_mesh2);
struct Vbo vbo = {0};
vbo_create(&vbo);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_NORMAL, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_COLOR, 4, GL_UNSIGNED_BYTE, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_SMOOTH_NORMAL, NORMAL_SIZE, GL_FLOAT, GL_STATIC_DRAW);
struct Ibo ibo = {0};
ibo_create(GL_TRIANGLES, GL_UNSIGNED_INT, GL_STATIC_DRAW, &ibo);
struct SolidTetrahedron tetrahedron = {0};
solid_tetrahedron_create(1.0, (Color){255, 0, 0, 255}, &tetrahedron);
solid_optimize((struct Solid*)&tetrahedron);
struct SolidTetrahedron tetrahedron2 = {0};
solid_tetrahedron_create(1.0, (Color){255, 0, 255, 255}, &tetrahedron2);
solid_optimize((struct Solid*)&tetrahedron2);
struct SolidBox cube = {0};
solid_cube_create(1.0, (Color){0, 255, 0, 255}, &cube);
solid_optimize((struct Solid*)&cube);
struct SolidBox cube2 = {0};
solid_cube_create(1.0, (Color){0, 255, 255, 255}, &cube2);
solid_optimize((struct Solid*)&cube2);
struct VboMesh tetrahedron_mesh;
vbo_mesh_create_from_solid((struct Solid*)&tetrahedron, &vbo, &ibo, &tetrahedron_mesh);
struct VboMesh cube_mesh = {0};
vbo_mesh_create_from_solid((struct Solid*)&cube, &vbo, &ibo, &cube_mesh);
struct VboMesh tetrahedron_mesh2;
vbo_mesh_create_from_solid((struct Solid*)&tetrahedron2, &vbo, &ibo, &tetrahedron_mesh2);
struct VboMesh cube_mesh2 = {0};
vbo_mesh_create_from_solid((struct Solid*)&cube2, &vbo, &ibo, &cube_mesh2);
vbo_mesh_print(&tetrahedron_mesh);
vbo_mesh_print(&tetrahedron_mesh2);
vbo_mesh_print(&cube_mesh);
vbo_mesh_print(&cube_mesh2);
struct Shader flat_shader = {0};
shader_create(&flat_shader);
shader_attach(&flat_shader, GL_VERTEX_SHADER, "prefix.vert", 1, "flat_shading.vert");
shader_attach(&flat_shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "flat_shading.frag");
shader_make_program(&flat_shader, "flat_shader");
Vec4f light_direction = { 0.2, -0.5, -1.0 };
shader_set_uniform_3f(&flat_shader, flat_shader.program, SHADER_UNIFORM_LIGHT_DIRECTION, 3, GL_FLOAT, light_direction);
Color ambiance = {50, 25, 150, 255
};
shader_set_uniform_4f(&flat_shader, flat_shader.program, SHADER_UNIFORM_AMBIENT_LIGHT, 4, GL_UNSIGNED_BYTE, ambiance);
struct Arcball arcball = {0};
arcball_create(window, (Vec4f){0.0,8.0,8.0,1.0}, (Vec4f){0.0,0.0,0.0,1.0}, 0.1, 100.0, &arcball);
Mat identity;
mat_identity(identity);
Quat grid_rotation = {0};
quat_from_vec_pair((Vec4f){0.0, 0.0, 1.0, 1.0}, (Vec4f){0.0, 1.0, 0.0, 1.0}, grid_rotation);
Mat grid_transform = {0};
quat_to_mat(grid_rotation, grid_transform);
draw_grid(&global_static_canvas, 0, grid_transform, (Color){127, 127, 127, 255}, 0.03f, 12.0f, 12.0f, 12);
while (true) {
SDL_Event event;
while( SDL_PollEvent(&event) ) {
switch (event.type) {
case SDL_QUIT:
goto done;
case SDL_KEYDOWN: {
SDL_KeyboardEvent* key_event = (SDL_KeyboardEvent*)&event;
if(key_event->keysym.scancode == SDL_SCANCODE_ESCAPE) {
goto done;
}
break;
}
}
arcball_event(&arcball, event);
}
sdl2_gl_set_swap_interval(1);
ogl_debug( glClearDepth(1.0f);
glClearColor(.0f, .0f, .0f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); );
Mat transform = {0};
mat_translate(identity, (float[4]){ -1.0, 1.0, -1.0, 1.0 }, transform);
int32_t main(int32_t argc, char *argv[]) {
if( init_sdl2() ) {
return 1;
}
uint32_t width = 1280;
uint32_t height = 720;
SDL_Window* window = NULL;
sdl2_window("cute3d: " __FILE__, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, &window);
SDL_GLContext* context = NULL;
sdl2_glcontext(3, 2, window, &context);
if( init_shader() ) {
return 1;
}
if( init_vbo() ) {
return 1;
}
if( init_canvas(width, height) ) {
return 1;
}
struct Arcball arcball = {};
arcball_create(width, height, (Vec4f){1.0,2.0,6.0,1.0}, (Vec4f){0.0,0.0,0.0,1.0}, 0.001f, 100.0, &arcball);
struct GameTime time = {};
gametime_create(1.0f / 60.0f, &time);
while(true) {
SDL_Event event = {};
while( sdl2_poll_event(&event) ) {
if( sdl2_handle_quit(event) ) {
goto done;
}
sdl2_handle_resize(event);
arcball_handle_resize(&arcball, event);
arcball_handle_mouse(&arcball, event);
}
sdl2_gl_set_swap_interval(1);
sdl2_clear((Color){0, 0, 0, 255}, 1.0f, GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
gametime_advance(&time, sdl2_time_delta());
gametime_integrate(&time);
Mat identity = {};
mat_identity(identity);
draw_grid(&global_dynamic_canvas, 0, identity, (Color){120, 120, 120, 255}, 0.01f, 12.0f, 12.0f, 12);
Vec4f screen_cursor = {0,0,0,1};
text_show_fps(&global_dynamic_canvas, 0, screen_cursor, 0, 0, (Color){255, 255, 255, 255}, 20.0f, "default_font", time.frame);
canvas_render_layers(&global_static_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_render_layers(&global_dynamic_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_clear(&global_dynamic_canvas);
sdl2_gl_swap_window(window);
}
done:
return 0;
}
int32_t main(int32_t argc, char *argv[]) {
printf("<<watchlist//>>\n");
if( init_sdl2() ) {
return 1;
}
int32_t width = 1280;
int32_t height = 720;
SDL_Window* window;
sdl2_window("cute3d: " __FILE__, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, &window);
SDL_GLContext* context;
sdl2_glcontext(3, 2, window, &context);
if( init_shader() ) {
return 1;
}
if( init_vbo() ) {
return 1;
}
if( init_canvas(1280,720) ) {
return 1;
}
canvas_create("global_dynamic_canvas", &global_dynamic_canvas);
canvas_create("global_static_canvas", &global_static_canvas);
struct Vbo vbo = {0};
vbo_create(&vbo);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_NORMAL, 3, GL_FLOAT, GL_STATIC_DRAW);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_COLOR, 4, GL_UNSIGNED_BYTE, GL_STATIC_DRAW);
struct Ibo ibo = {0};
ibo_create(GL_TRIANGLES, GL_UNSIGNED_INT, GL_STATIC_DRAW, &ibo);
struct CollisionEntity entity_a = {0};
entity_create("red", (Color){ 255, 0, 0, 255 }, &vbo, &ibo, &entity_a);
/* quat_mul_axis_angle(entity_a.pivot.orientation, (Vec4f)UP_AXIS, PI/4, entity_a.pivot.orientation); */
/* quat_mul_axis_angle(entity_a.pivot.orientation, (Vec4f)RIGHT_AXIS, PI/2 + 0.2, entity_a.pivot.orientation); */
vec_add(entity_a.pivot.position, (Vec4f){0.2, 0.15, 0.8, 1.0}, entity_a.pivot.position);
struct CollisionEntity entity_b = {0};
entity_create("green", (Color){ 0, 255, 0, 255 }, &vbo, &ibo, &entity_b);
quat_mul_axis_angle(entity_b.pivot.orientation, (Vec4f)RIGHT_AXIS, PI/4 - 0.2, entity_b.pivot.orientation);
quat_mul_axis_angle(entity_b.pivot.orientation, (Vec4f)UP_AXIS, PI/2 + 0.0, entity_b.pivot.orientation);
struct Shader flat_shader = {0};
shader_create(&flat_shader);
shader_attach(&flat_shader, GL_VERTEX_SHADER, "prefix.vert", 1, "flat_shading.vert");
shader_attach(&flat_shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "flat_shading.frag");
shader_make_program(&flat_shader, SHADER_DEFAULT_NAMES, "flat_shader");
Vec4f light_direction = { 0.2, -0.5, -1.0 };
shader_set_uniform_3f(&flat_shader, flat_shader.program, SHADER_UNIFORM_LIGHT_DIRECTION, 3, GL_FLOAT, light_direction);
Color ambiance = { 65, 25, 50, 255 };
shader_set_uniform_4f(&flat_shader, flat_shader.program, SHADER_UNIFORM_AMBIENT_LIGHT, 4, GL_UNSIGNED_BYTE, ambiance);
struct Arcball arcball = {0};
arcball_create(width, height, (Vec4f){5.0, 3.0, 5.0, 1.0}, (Vec4f){0.0, 0.0, 0.0, 1.0}, 1.0, 1000.0, &arcball);
size_t num_entities = 2;
struct PickingSphere* picking_spheres[2];
picking_spheres[0] = &entity_a.picking_sphere;
picking_spheres[1] = &entity_b.picking_sphere;
struct CollisionEntity* picking_entities[2];
picking_entities[0] = &entity_a;
picking_entities[1] = &entity_b;
struct GameTime time = {0};
gametime_create(1.0f / 60.0f, &time);
draw_grid(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){127, 127, 127, 127}, 0.01f, 12.0f, 12.0f, 12);
while (true) {
SDL_Event event;
while( sdl2_poll_event(&event) ) {
if( sdl2_handle_quit(event) ) {
goto done;
}
sdl2_handle_resize(event);
if( picking_sphere_drag_event(&arcball.camera, num_entities, picking_spheres, event) ) {
struct CollisionEntity* selected_entity = NULL;
float nearest = -FLT_MIN;
for( size_t i = 0; i < num_entities; i++ ) {
if( picking_spheres[i]->picked && ( picking_spheres[i]->front < nearest || nearest < 0.0f ) ) {
nearest = picking_spheres[i]->front;
selected_entity = picking_entities[i];
}
}
static int32_t last_x = -1;
static int32_t last_y = -1;
if( selected_entity != NULL ) {
if( last_x > -1 && last_y > -1 ) {
float distance = selected_entity->picking_sphere.front;
Vec4f a = {0};
camera_ray(&arcball.camera, CAMERA_PERSPECTIVE, last_x, last_y, a);
vec_mul1f(a, distance, a);
Vec4f b = {0};
camera_ray(&arcball.camera, CAMERA_PERSPECTIVE, event.motion.x, event.motion.y, b);
vec_mul1f(b, distance, b);
Vec4f move = {0};
vec_sub(b, a, move);
float length = vec_length(move);
move[1] = 0.0f;
vec_normalize(move, move);
vec_mul1f(move, length, move);
vec_add(selected_entity->pivot.position, move, selected_entity->pivot.position);
}
last_x = event.motion.x;
last_y = event.motion.y;
}
if( event.type == SDL_MOUSEBUTTONUP ) {
last_x = -1;
last_y = -1;
}
} else {
arcball_handle_resize(&arcball, event);
arcball_handle_mouse(&arcball, event);
}
}
sdl2_gl_set_swap_interval(0);
gametime_advance(&time, sdl2_time_delta());
ogl_debug( glClearDepth(1.0f);
glClearColor(.0f, .0f, .0f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); );
Mat projection_mat = {0};
Mat view_mat = {0};
camera_matrices(&arcball.camera, CAMERA_PERSPECTIVE, projection_mat, view_mat);
Mat identity = {0};
mat_identity(identity);
Mat transform_a = {0};
pivot_world_transform(&entity_a.pivot, transform_a);
//vbo_mesh_render(&entity_a.vbo_mesh, &flat_shader, &arcball.camera, transform_a);
draw_halfedgemesh_wire(&global_dynamic_canvas, 0, transform_a, (Color){255, 0, 0, 255}, 0.02f, &entity_a.hemesh);
Mat transform_b = {0};
pivot_world_transform(&entity_b.pivot, transform_b);
//vbo_mesh_render(&entity_b.vbo_mesh, &flat_shader, &arcball.camera, transform_b);
draw_halfedgemesh_wire(&global_dynamic_canvas, 0, transform_b, (Color){0, 255, 0, 255}, 0.02f, &entity_b.hemesh);
Mat between_transform = {0};
pivot_between_transform(&entity_a.pivot, &entity_b.pivot, between_transform);
Vec3f foo = {0};
mat_mul_vec(between_transform, entity_a.hemesh.vertices.array[0].position, foo);
struct CollisionConvexConvex collision = {0};
struct CollisionParameter collision_parameter = {
.face_tolerance = 0.9,
.edge_tolerance = 0.95,
.absolute_tolerance = 0.025
};
collision_create_convex_convex(&entity_a.hemesh, &entity_a.pivot,
&entity_b.hemesh, &entity_b.pivot,
collision_parameter,
&collision);
if( collision_test_convex_convex(&collision) ) {
collision_contact_convex_convex(&collision);
//printf("//collision: %d\n", collision_counter);
const struct Contacts* contacts = &collision.contacts;
VecP* m = contacts->points[contacts->num_contacts-1];
for( int32_t i = 0; i < contacts->num_contacts; i++ ) {
VecP* n = contacts->points[i];
draw_line(&global_dynamic_canvas, 0, transform_b, (Color){255, 255, 255, 255}, 0.08f, m, n);
m = n;
}
}
gametime_integrate(&time);
Vec4f screen_cursor = {0,0,0,1};
text_show_fps(&global_dynamic_canvas, 0, screen_cursor, 0, 0, (Color){255, 255, 255, 255}, 20.0, "default_font", time.frame);
canvas_render_layers(&global_static_canvas, 0, 0, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_render_layers(&global_dynamic_canvas, 0, 0, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_clear(&global_dynamic_canvas);
sdl2_gl_swap_window(window);
}
done:
SDL_Quit();
printf("done\n");
return 0;
}
//--------------------------------------------------------------
void ofApp::setup(){
/********************
********************/
ofSetVerticalSync(false);
ofEnableSmoothing();
// ofEnableDepthTest(); // 注意!!!! 2d imageで、αが効かなくなる.
ofEnableAlphaBlending();
ofEnableBlendMode(OF_BLENDMODE_ADD);
// ofEnableBlendMode(OF_BLENDMODE_ALPHA);
// image.loadImage( "light_gray.png" );
image.loadImage( "light_Square.png" );
setup_gui();
/********************
********************/
init_vbo();
/********************
setGeometryInputType(), setGeometryOutputType()に指定可能なtypeは決まっている。
http://openframeworks.cc/documentation/gl/ofShader/#show_setGeometryOutputType
入力は、単に１入力プリミティブあたりに何個の頂点を送るか、だけと考えて良い。
http://miffysora.wikidot.com/geometry-shader
並べた順にshaderに渡される。
outputは、「typeと順番」で描画内容が変わってくるので注意してoutputする。
inputの時に、混乱なきよう、順序を考慮しておくのが良い。
http://openframeworks.cc/documentation/gl/ofVbo/
shader.setGeometryOutputCount()で設定できるCountは、それほど大きくない(1024とか、そんな所)。
今回のケースでは、Lineを渡すと、始点から終点まで、textureを繰り返し描画(4点 x texture枚数)。
n本のLineを描画するのに、Vboへ全ての点を設定して一気に描画したくなるが、すぐCountがmaxを超えてしまう。
つまり、n本のLineは、都度 描画コマンドを発行すること。
********************/
//Enable detailed logging of openFrameworks messages in console
ofSetLogLevel( OF_LOG_VERBOSE );
//We must to specify geometry shader parameters before loading shader
shader.setGeometryInputType( GL_LINES );
shader.setGeometryOutputType( GL_TRIANGLE_STRIP );
// Maximal possible number of output vertices
// " * 1/2 - 1" しないと動作しなかった.(実験結果:don't know why...)
printf("%d\n", shader.getGeometryMaxOutputCount());
// shader.setGeometryOutputCount( 128 );
shader.setGeometryOutputCount( shader.getGeometryMaxOutputCount() / 2 - 1 );
//Load shader
shader.load( "shaderVert.c", "shaderFrag.c", "shaderGeom.c" );
/********************
********************/
sound.load( "surface.wav" );
sound.setLoop( true );
sound.play();
// sound.setVolume(0.0);
//Set spectrum values to 0
for (int i=0; i<N; i++) {
spectrum[i] = 0.0f;
}
}
RenderTarget::RenderTarget(const glm::ivec2& size, GLenum format, int flags, GLenum filter) throw()
: TextureBase()
, id(0)
, front(0)
, back(0)
, max(1) {
checkForGLErrors("RenderTarget() pre");
this->size = size;
/* init_vbo is a no-op if it already is initialized */
init_vbo();
/* generate projection matrix for this target */
projection = glm::ortho(0.0f, (float)size.x, 0.0f, (float)size.y, -1.0f, 1.0f);
projection = glm::scale(projection, glm::vec3(1.0f, -1.0f, 1.0f));
projection = glm::translate(projection, glm::vec3(0.0f, -(float)size.y, 0.0f));
glGenFramebuffers(1, &id);
glGenTextures(2, color);
glGenTextures(1, &depth);
glBindFramebuffer(GL_FRAMEBUFFER, id);
Engine::setup_opengl();
/* bind color buffers */
for ( int i = 0; i < 2; i++ ){
glBindTexture(GL_TEXTURE_2D, color[i]);
glTexImage2D(GL_TEXTURE_2D, 0, format, size.x, size.y, 0, format == GL_RGB8 ? GL_RGB : GL_RGBA, GL_UNSIGNED_INT, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, filter);
}
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, color[front], 0);
checkForGLErrors("glFramebufferTexture2D::color");
/* bind depth buffer */
if ( flags & DEPTH_BUFFER ){
glBindTexture(GL_TEXTURE_2D, depth);
glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, size.x, size.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_COMPARE_R_TO_TEXTURE );
//glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_COMPARE_FUNC, GL_LEQUAL);
glFramebufferTexture2DEXT(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth, 0);
checkForGLErrors("glFramebufferTexture2D::depth");
}
/* enable doublebuffering */
if ( flags & DOUBLE_BUFFER ){
max = 2;
}
GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
if(status != GL_FRAMEBUFFER_COMPLETE){
switch( status ) {
case GL_FRAMEBUFFER_UNSUPPORTED_EXT:
fprintf(stderr, "Framebuffer object format is unsupported by the video hardware. (GL_FRAMEBUFFER_UNSUPPORTED_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT:
fprintf(stderr, "Framebuffer incomplete attachment. (GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT:
fprintf(stderr, "Framebuffer incomplete missing attachment. (GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT:
fprintf(stderr, "Framebuffer incomplete dimensions. (GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT:
fprintf(stderr, "Framebuffer incomplete formats. (GL_FRAMEBUFFER_INCOMPLETE_FORMATS_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT:
fprintf(stderr, "Framebuffer incomplete draw buffer. (GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT:
fprintf(stderr, "Framebuffer incomplete read buffer. (GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER_EXT)\n");
break;
case GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT:
fprintf(stderr, "Framebuffer incomplete multisample buffer. (GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE_EXT)\n");
break;
default:
fprintf(stderr, "Framebuffer incomplete: %s\n", gluErrorString(status));
}
util_abort();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
checkForGLErrors("RenderTarget() fin");
with([this](){
RenderTarget::clear(Color::black);
} );
}
