void undo_command(){
int n;
n =0;
while (strcmp(history[n],"undo\n") != 0){
n++;
}
free(history[n]);
int com,m;
const char *canvas_file = "canvas.txt";
FILE *fp;
if ((fp = fopen(canvas_file, "w")) == NULL) {
fprintf(stderr, "error: cannot open %s.\n", canvas_file);
}
init_canvas();
print_canvas(fp);
for(m = 0; m < n-1; m ++){
com = interpret_command(history[m]);
if(strcmp(history[m],"undo\n") == 0)
break;
}
}
static gboolean expose_event(GtkWidget *widget, GdkEventExpose *event,
gpointer data)
{
static int first = 1;
DPRINTF("--- expose ---");
if (first) {
init_canvas();
first = 0;
}
tool_dehover();
redraw();
return TRUE;
}
int main()
{
int com, n, i;
const char *canvas_file = "canvas.txt";
FILE *fp;
char buf[BUFSIZE];
if ((fp = fopen(canvas_file, "w")) == NULL) {
fprintf(stderr, "error: cannot open %s.\n", canvas_file);
return 1;
}
init_canvas();
print_canvas(fp);
n = 0;
while (1) {
printf("%d > ", n);
fgets(buf, BUFSIZE, stdin);
history[n] = (char*)malloc(sizeof(char) * strlen(buf));
strcpy(history[n], buf);
if (++n >= HISTORY_SIZE) break;
com = interpret_command(buf);
if (com == COM_QUIT) break;
print_canvas(fp);
}
fclose(fp);
if ((fp = fopen("history.txt", "w")) != NULL) {
for (i = 0; i < n; i++)
fprintf(fp, "%s", history[i]);
fclose(fp);
}
}
void *dragon_draw_worker(void *data)
{
struct draw_data *draw = (struct draw_data*)data;
/* 1. Initialiser la surface */
uint64_t area = draw->dragon_width * draw->dragon_height,
area_block_size = area / draw->nb_thread,
area_remainder = area - (area_block_size * draw->nb_thread);
uint64_t area_start = draw->id * area_block_size,
area_end = (draw->id != draw->nb_thread-1) ?
(draw->id + 1) * area_block_size:
(draw->id + 1) * area_block_size + area_remainder;
//printf_safe((char*)"Draw_worker canvas initialization data: Start=%" PRIu64 ", \tEnd=%" PRIu64 ", \tID=%d\n", area_start, area_end, draw->id);
init_canvas(
area_start,
area_end,
draw->dragon,
-1);
if (pthread_barrier_wait(draw->barrier) == PTHREAD_BARRIER_SERIAL_THREAD)
{
//printf_safe((char*)"Canvas initialization completed, all draw_workers are synchronized and ready to draw.\n");
}
/* 2. Dessiner le dragon */
uint64_t block_size = draw->size / draw->nb_thread,
remainder = draw->size - (block_size * draw->nb_thread);
uint64_t start = draw->id * block_size,
end = (draw->id != draw->nb_thread-1) ?
(draw->id + 1) * block_size:
(draw->id + 1) * block_size + remainder;
//printf_safe((char*)"Draw_worker data: Start=%" PRIu64 ", \tEnd=%" PRIu64 ", \tID=%d\n", start, end, draw->id);
dragon_draw_raw(
start,
end,
draw->dragon,
draw->dragon_width,
draw->dragon_height,
draw->limits,
draw->id);
if (pthread_barrier_wait(draw->barrier) == PTHREAD_BARRIER_SERIAL_THREAD)
{
//printf_safe((char*)"Drawing completed, all draw_workers are synchronized and ready to scale.\n");
}
/* 3. Effectuer le rendu final */
uint64_t scale_height = draw->image_height,
scale_block_size = scale_height / draw->nb_thread,
scale_remainder = scale_height - (scale_block_size * draw->nb_thread);
uint64_t scale_start = draw->id * scale_block_size,
scale_end = (draw->id != draw->nb_thread-1) ?
(draw->id + 1) * scale_block_size:
(draw->id + 1) * scale_block_size + scale_remainder;
//printf_safe((char*)"Draw_worker scale data: Start=%" PRIu64 ", \tEnd=%" PRIu64 ", \tID=%d\n", scale_start, scale_end, draw->id);
scale_dragon(
scale_start,
scale_end,
draw->image,
draw->image_width,
draw->image_height,
draw->dragon,
draw->dragon_width,
draw->dragon_height,
draw->palette);
pthread_exit(NULL);
}
int32_t main(int32_t argc, char *argv[]) {
if( init_sdl2() ) {
return 1;
}
int width = 1280;
int 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_canvas(width, height) ) {
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);
vbo_add_buffer(&vbo, SHADER_ATTRIBUTE_VERTEX_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 hard_tetrahedron = {0};
struct SolidBox hard_cube = {0};
struct SolidSphere16 hard_sphere16 = {0};
struct SolidSphere32 hard_sphere32 = {0};
solid_tetrahedron_create(1.0, (Color){255, 0, 0, 255}, &hard_tetrahedron);
solid_cube_create(0.5, (Color){0, 255, 0, 255}, &hard_cube);
solid_sphere16_create(16, 8, 0.75, (Color){0, 255, 255, 255}, &hard_sphere16);
solid_sphere32_create(32, 16, 0.75, (Color){255, 255, 0, 255}, &hard_sphere32);
solid_optimize((struct Solid*)&hard_tetrahedron);
solid_optimize((struct Solid*)&hard_cube);
solid_optimize((struct Solid*)&hard_sphere16);
solid_optimize((struct Solid*)&hard_sphere32);
struct VboMesh hard_tetrahedron_mesh, hard_box_mesh, hard_cube_mesh, hard_sphere16_mesh, hard_sphere32_mesh;
vbo_mesh_create_from_solid((struct Solid*)&hard_tetrahedron, &vbo, &ibo, &hard_tetrahedron_mesh);
vbo_mesh_create_from_solid((struct Solid*)&hard_cube, &vbo, &ibo, &hard_cube_mesh);
vbo_mesh_create_from_solid((struct Solid*)&hard_sphere16, &vbo, &ibo, &hard_sphere16_mesh);
vbo_mesh_create_from_solid((struct Solid*)&hard_sphere32, &vbo, &ibo, &hard_sphere32_mesh);
struct SolidTetrahedron smooth_tetrahedron = {0};
struct SolidBox smooth_cube = {0};
struct SolidSphere16 smooth_sphere16 = {0};
struct SolidSphere32 smooth_sphere32 = {0};
solid_tetrahedron_create(1.0, (Color){255, 0, 0, 255}, &smooth_tetrahedron);
solid_cube_create(0.5, (Color){0, 255, 0, 255}, &smooth_cube);
solid_sphere16_create(16, 8, 0.75, (Color){0, 255, 255, 255}, &smooth_sphere16);
solid_sphere32_create(32, 16, 0.75, (Color){255, 255, 0, 255}, &smooth_sphere32);
solid_optimize((struct Solid*)&smooth_tetrahedron);
solid_optimize((struct Solid*)&smooth_cube);
solid_optimize((struct Solid*)&smooth_sphere16);
solid_optimize((struct Solid*)&smooth_sphere32);
solid_smooth_normals((struct Solid*)&smooth_tetrahedron, smooth_tetrahedron.normals, smooth_tetrahedron.normals);
solid_smooth_normals((struct Solid*)&smooth_cube, smooth_cube.normals, smooth_cube.normals);
solid_smooth_normals((struct Solid*)&smooth_sphere16, smooth_sphere16.normals, smooth_sphere16.normals);
solid_smooth_normals((struct Solid*)&smooth_sphere32, smooth_sphere32.normals, smooth_sphere32.normals);
struct VboMesh smooth_tetrahedron_mesh, smooth_box_mesh, smooth_cube_mesh, smooth_sphere16_mesh, smooth_sphere32_mesh;
vbo_mesh_create_from_solid((struct Solid*)&smooth_tetrahedron, &vbo, &ibo, &smooth_tetrahedron_mesh);
vbo_mesh_create_from_solid((struct Solid*)&smooth_cube, &vbo, &ibo, &smooth_cube_mesh);
vbo_mesh_create_from_solid((struct Solid*)&smooth_sphere16, &vbo, &ibo, &smooth_sphere16_mesh);
vbo_mesh_create_from_solid((struct Solid*)&smooth_sphere32, &vbo, &ibo, &smooth_sphere32_mesh);
struct Arcball arcball = {0};
arcball_create(width, height, (Vec4f){2.5,17.0,17.0,1.0}, (Vec4f){2.5,0.0,0.0,1.0}, 0.1, 100.0, &arcball);
float circular_motion_angle = 0.0f;
float circular_motion_speed = (2.0f*PI)/30;
float circular_motion_radius = 12.0f;
Vec3f light_position = { circular_motion_radius, 10.0, circular_motion_radius };
Vec3f light_direction = {0};
vec_sub((Vec3f){0.0f, 0.0f, 0.0f}, light_position, light_direction);
vec_normalize(light_direction, light_direction);
Vec3f eye_position = {0};
vec_copy3f(arcball.camera.pivot.position, eye_position);
Color ambiance = {50, 25, 150, 255};
Color specular = {255, 255, 255, 255};
float material_shininess = 1.0;
Vec4f material_coefficients = { 0.8, 0.2, 0.0, 0.0 };
// flat
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");
shader_set_uniform_3f(&flat_shader, flat_shader.program, SHADER_UNIFORM_LIGHT_DIRECTION, 3, GL_FLOAT, light_direction);
shader_set_uniform_4f(&flat_shader, flat_shader.program, SHADER_UNIFORM_AMBIENT_LIGHT, 4, GL_UNSIGNED_BYTE, ambiance);
// gouraud
struct Shader gouraud_shader = {0};
shader_create(&gouraud_shader);
shader_attach(&gouraud_shader, GL_VERTEX_SHADER, "prefix.vert", 1, "gouraud_shading.vert");
shader_attach(&gouraud_shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "gouraud_shading.frag");
shader_make_program(&gouraud_shader, SHADER_DEFAULT_NAMES, "gouraud_shader");
shader_set_uniform_3f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_LIGHT_POSITION, 3, GL_FLOAT, light_position);
shader_set_uniform_3f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_EYE_POSITION, 3, GL_FLOAT, eye_position);
shader_set_uniform_4f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_AMBIENT_LIGHT, 4, GL_UNSIGNED_BYTE, ambiance);
shader_set_uniform_4f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_SPECULAR_LIGHT, 4, GL_UNSIGNED_BYTE, specular);
shader_set_uniform_1f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_MATERIAL_SHININESS, 1, GL_FLOAT, &material_shininess);
shader_set_uniform_4f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_MATERIAL_COEFFICIENTS, 4, GL_FLOAT, material_coefficients);
shader_set_uniform_3f(&gouraud_shader, gouraud_shader.program, SHADER_UNIFORM_EYE_POSITION, 3, GL_FLOAT, &arcball.camera.pivot.position);
Mat identity = IDENTITY_MAT;
draw_grid(&global_static_canvas, 0, identity, (Color){127, 127, 127, 255}, 0.03f, 12.0f, 12.0f, 12);
Mat shading_label_transform = IDENTITY_MAT;
Quat text_rotation = IDENTITY_QUAT;
quat_from_axis_angle((Vec3f)X_AXIS, -PI/2.0f, text_rotation);
mat_rotate(shading_label_transform, text_rotation, shading_label_transform);
mat_translate(shading_label_transform, (float[4]){ 6.5, 0.0, -2.5, 1.0 }, shading_label_transform);
void lua_player::run_global_scope()
{
QObject::disconnect(this, SIGNAL (started ()));
luaL_openlibs(L);
luabind::open(L);
luabind::module(L, "ghtv")
[
luabind::class_<lua_player>("lua_player")
];
init_sandbox();
init_canvas();
init_event();
start_time = boost::posix_time::microsec_clock::universal_time();
QObject::connect(this, SIGNAL(resume_current_frame_signal (int)), this
, SLOT(resume_current_frame (int)), Qt::QueuedConnection);
QObject::connect(this, SIGNAL(run_require_signal (std::string)), this
, SLOT(run_require_slot (std::string)), Qt::QueuedConnection);
try
{
main_file_url = player::create_url(path, root_path);
lua_path = main_file_url.path ().toStdString ();
{
std::string::reverse_iterator
iterator = std::find(lua_path.rbegin(), lua_path.rend(), '/')
, iterator_backslash = std::find(lua_path.rbegin(), lua_path.rend(), '\\');
iterator = (std::min)(iterator, iterator_backslash);
if(iterator != lua_path.rend())
lua_path.erase(boost::prior(iterator.base()), lua_path.end());
else
{
std::string error_msg = "Couldn't create a absolute path from the path for the NCL file: ";
error_msg += lua_path;
ncl_window->error_occurred(error_msg);
return;
}
}
activate_frame(path, main_file_url.toString ().toStdString ());
QObject::connect(current_activation_frame (), SIGNAL(execution_finished ())
, this, SLOT(global_scope_finished ()));
QObject::connect(this, SIGNAL(signal_all_execution_finished ())
, this, SLOT(try_unqueue_events ()), Qt::QueuedConnection);
QObject::connect(this, SIGNAL(signal_try_unqueue_event ())
, this, SLOT(try_unqueue_event ()), Qt::QueuedConnection);
assert(pending_download_file == 0);
pending_download_file = new player::url_file(main_file_url, this);
if(!pending_download_file->local())
{
QObject::connect(this, SIGNAL(download_lua_signal ()), this
, SLOT(download_global ()), Qt::QueuedConnection);
QObject::connect(pending_download_file, SIGNAL(download_finished_signal()), this
, SLOT(download_lua()));
QObject::connect(pending_download_file, SIGNAL(error_signal(std::string)), this
, SLOT(download_error(std::string)));
}
else
{
QObject::connect(this, SIGNAL(download_lua_signal ()), this
, SLOT(download_global ()), Qt::QueuedConnection);
Q_EMIT download_lua_signal();
}
}
catch(std::exception const& e)
{
std::string error = "Error loading file ";
error += root_path;
error += '/';
error += path;
error += " with error: ";
error += e.what();
ncl_window->error_occurred(error);
}
}
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[]) {
printf("<<watchlist//>>\n");
if( init_sdl2() ) {
return 1;
}
uint32_t width = 1280;
uint32_t height = 720;
SDL_Window* window;
sdl2_window("test-canvas", 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_canvas() ) {
return 1;
}
printf("sizeof(struct Canvas): %zu\n", sizeof(struct Canvas));
printf("MAX_OGL_PRIMITIVES: %d\n", MAX_OGL_PRIMITIVES);
struct Arcball arcball = {0};
arcball_create(width, height, (Vec4f){1.0,2.0,8.0,1.0}, (Vec4f){0.0,0.0,0.0,1.0}, 0.01, 1000.0, &arcball);
struct Character symbols[256] = {0};
default_font_create(symbols);
struct Shader shader = {0};
shader_create(&shader);
shader_attach(&shader, GL_VERTEX_SHADER, "prefix.vert", 1, "volumetric_lines.vert");
shader_attach(&shader, GL_FRAGMENT_SHADER, "prefix.frag", 1, "volumetric_lines.frag");
shader_make_program(&shader, SHADER_DEFAULT_NAMES, "lines_shader");
struct Font font = {0};
font_create_from_characters(L"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789.,:;", 256, symbols, 9, 3, global_default_font_palette, &font);
struct Canvas text_canvas = {0};
canvas_create("text_canvas", &text_canvas);
canvas_add_attribute(&text_canvas, SHADER_ATTRIBUTE_VERTEX, 3, GL_FLOAT);
canvas_add_attribute(&text_canvas, SHADER_ATTRIBUTE_VERTEX_COLOR, 4, GL_UNSIGNED_BYTE);
canvas_add_attribute(&text_canvas, SHADER_ATTRIBUTE_VERTEX_TEXCOORD, 2, GL_FLOAT);
log_assert( canvas_add_shader(&text_canvas, shader.name, &shader) < MAX_CANVAS_SHADER );
log_assert( canvas_add_font(&text_canvas, "other_font", &font) < MAX_CANVAS_FONTS );
struct GameTime time = {0};
gametime_create(1.0f / 60.0f, &time);
SDL_SetEventFilter(event_filter, NULL);
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);
}
gametime_advance(&time, sdl2_time_delta());
sdl2_debug( SDL_GL_SetSwapInterval(1) );
ogl_debug( glClearDepth(1.0f);
glClearColor(.0f, .0f, .0f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); );
draw_grid(&text_canvas, 0, (Mat)IDENTITY_MAT, (Color){20, 180, 240, 255}, 0.02f, 12.0f, 12.0f, 12);
draw_basis(&text_canvas, 1, (Mat)IDENTITY_MAT, 0.02f, 1.0f);
Mat text_matrix = {0};
Quat text_rotation = {0};
quat_from_axis_angle((Vec4f){1.0, 0.0, 0.0, 1.0}, PI/2, text_rotation);
mat_rotate(NULL, text_rotation, text_matrix);
mat_translate(text_matrix, (Vec4f){-3.5, -1.0, 6.25, 1.0}, text_matrix);
Vec4f world_cursor = {0,0,0,1};
text_put_world(&text_canvas, 0, world_cursor, text_matrix, (Color){0, 255, 255, 255}, 0.5f, "other_font", L"Dies ist ein Test\n");
text_put_world(&text_canvas, 0, world_cursor, text_matrix, (Color){255, 255, 0, 255}, 0.5f, "other_font", L"fuer einen Text");
gametime_integrate(&time);
Vec4f screen_cursor = {0,0,0,1};
double fps = text_show_fps(&global_dynamic_canvas, 0, screen_cursor, 0, 0, (Color){255, 255, 255, 255}, 20.0f, "default_font", time.frame);
/* text_show_time(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){255, 255, 255, 255}, 0, 0, time.t); */
/* text_put_screen(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){255, 210, 255, 255}, 0, 0, L"LALA singt das Meerschweinchen\n"); */
/* text_put_screen(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){0, 210, 255, 255}, 0, 0, L"FICKEN immer und ueberall\n"); */
/* text_put_screen(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){20, 210, 110, 255}, 0, 0, L"FUMMELN den ganzen Tag lang\n"); */
/* text_printf(&text_canvas, screen_cursor, 0, "default_font", 20.0, (Color){255, 40, 60, 255}, 0, 0, L"PRINTF %d Luftballons\n", 99); */
canvas_render_layers(&text_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_clear(&text_canvas);
canvas_render_layers(&global_dynamic_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
canvas_clear(&global_dynamic_canvas);
sdl2_debug( SDL_GL_SwapWindow(window) );
}
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_canvas(width, height) ) {
return 1;
}
canvas_create("global_dynamic_canvas", &global_dynamic_canvas);
struct Arcball arcball = {0};
arcball_create(width, height, (Vec4f){0.0,6.0,10.0,1.0}, (Vec4f){0.0,0.0,0.0,1.0}, 0.001f, 100.0, &arcball);
struct GameTime time = {0};
gametime_create(1.0f / 60.0f, &time);
Vec4f a = {0.0f, 0.0f, 1.0f};
Vec4f b = {1.0f, 0.0f, 1.0f};
draw_vec(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){25, 255, 25, 255}, 0.01f, a, (Vec3f){0.0f, 0.0f, 0.0f}, 1.0f, 1.0f);
draw_vec(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){255, 25, 25, 255}, 0.01f, b, (Vec3f){0.0f, 0.0f, 0.0f}, 1.0f, 1.0f);
Quat axis_angle_rot = {0};
quat_from_axis_angle((Vec4f)Y_AXIS, PI/4, axis_angle_rot);
draw_quaternion(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){255, 255, 255, 255}, (Color){255, 0, 255, 255}, 0.01f, axis_angle_rot, 2.0f);
vec_print("axis_angle_rot: ", axis_angle_rot);
Vec4f axis_angle_result = {0};
vec_rotate(a, axis_angle_rot, axis_angle_result);
draw_vec(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){255, 255, 25, 255}, 0.01f, axis_angle_result, (Vec3f){0.0f, 0.0f, 0.0f}, 1.0f, 2.0f);
Vec4f axis = {0};
float angle = 0.0f;
quat_to_axis_angle(axis_angle_rot, axis, &angle);
Quat axis_angle_rot2 = {0};
quat_from_axis_angle(axis, angle, axis_angle_rot2);
vec_print("axis_angle_rot2: ", axis_angle_rot2);
Quat euler_angles_rot = {0};
quat_from_euler_angles(0.0f, PI/4, 0.0f, euler_angles_rot);
vec_print("euler_angles_rot: ", euler_angles_rot);
Vec4f euler_angles_result = {0};
vec_rotate(a, euler_angles_rot, euler_angles_result);
draw_vec(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){25, 255, 255, 255}, 0.01f, euler_angles_result, (Vec3f){0.0f, 0.0f, 0.0f}, 1.0f, 3.0f);
Quat vec_pair_rot = {0};
quat_from_vec_pair(a, b, vec_pair_rot);
vec_print("vec_pair_rot: ", vec_pair_rot);
Vec4f vec_pair_result = {0};
vec_rotate(a, vec_pair_rot, vec_pair_result);
draw_vec(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){255, 25, 255, 255}, 0.01f, vec_pair_result, (Vec3f){0.0f, 0.0f, 0.0f}, 1.0f, 4.0f);
Mat xaxis_control = {0};
xaxis_control[0] = 1; xaxis_control[4] = 0; xaxis_control[8] = 0; xaxis_control[12] = 0;
xaxis_control[1] = 0; xaxis_control[5] = cosf(PI/4); xaxis_control[9] = -sinf(PI/4); xaxis_control[13] = 0;
xaxis_control[2] = 0; xaxis_control[6] = sinf(PI/4); xaxis_control[10] = cosf(PI/4); xaxis_control[14] = 0;
xaxis_control[3] = 0; xaxis_control[7] = 0; xaxis_control[11] = 0; xaxis_control[15] = 1;
mat_print("xaxis_control: ", xaxis_control);
Quat xaxis_rot = {0};
quat_from_axis_angle((Vec4f)X_AXIS, PI/4, xaxis_rot);
Mat xaxis_mat = {0};
quat_to_mat(xaxis_rot, xaxis_mat);
mat_print("xaxis_mat: ", xaxis_mat);
Mat yaxis_control = {0};
yaxis_control[0] = cosf(PI/4); yaxis_control[4] = 0; yaxis_control[8] = sinf(PI/4); yaxis_control[12] = 0;
yaxis_control[1] = 0; yaxis_control[5] = 1; yaxis_control[9] = 0; yaxis_control[13] = 0;
yaxis_control[2] = -sinf(PI/4); yaxis_control[6] = 0; yaxis_control[10] = cosf(PI/4); yaxis_control[14] = 0;
yaxis_control[3] = 0; yaxis_control[7] = 0; yaxis_control[11] = 0; yaxis_control[15] = 1;
mat_print("yaxis_control: ", yaxis_control);
Quat yaxis_rot = {0};
quat_from_axis_angle((Vec4f)Y_AXIS, PI/4, yaxis_rot);
Mat yaxis_mat = {0};
quat_to_mat(yaxis_rot, yaxis_mat);
mat_print("yaxis_mat: ", yaxis_mat);
Mat zaxis_control = {0};
zaxis_control[0] = cosf(PI/4); zaxis_control[4] = -sinf(PI/4); zaxis_control[8] = 0; zaxis_control[12] = 0;
zaxis_control[1] = sinf(PI/4); zaxis_control[5] = cosf(PI/4); zaxis_control[9] = 0; zaxis_control[13] = 0;
zaxis_control[2] = 0; zaxis_control[6] = 0; zaxis_control[10] = 1; zaxis_control[14] = 0;
zaxis_control[3] = 0; zaxis_control[7] = 0; zaxis_control[11] = 0; zaxis_control[15] = 1;
mat_print("zaxis_control: ", zaxis_control);
Quat zaxis_rot = {0};
quat_from_axis_angle((Vec4f)Z_AXIS, PI/4, zaxis_rot);
Mat zaxis_mat = {0};
quat_to_mat(zaxis_rot, zaxis_mat);
mat_print("zaxis_mat: ", zaxis_mat);
draw_grid(&global_static_canvas, 0, (Mat)IDENTITY_MAT, (Color){120, 120, 120, 255}, 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);
arcball_handle_resize(&arcball, event);
arcball_handle_mouse(&arcball, event);
}
sdl2_gl_set_swap_interval(0);
ogl_debug( glClearDepth(1.0f);
glClearColor(.0f, .0f, .0f, 1.0f);
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); );
gametime_advance(&time, sdl2_time_delta());
gametime_integrate(&time);
canvas_render_layers(&global_static_canvas, 0, MAX_CANVAS_LAYERS, &arcball.camera, (Mat)IDENTITY_MAT);
sdl2_gl_swap_window(window);
}
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;
}
