// FIXME: we have to set the gui dimensions before creating the optlayout because there's not a good place to put the continue/cancel init aside from here. this is part of a general problem of not really being able to resize anything
void optlayout_create (EntComponent comp, EntSpeech speech)
{
struct optlayout
* layout = xph_alloc (sizeof (struct optlayout));
layout->options = dynarr_create (2, sizeof (Entity));
component_setData (comp, layout);
Entity
this = component_entityAttached (comp);
int
x, y,
w, h,
hm, vm,
fontHeight;
gui_xy (this, &x, &y);
gui_wh (this, &w, &h);
gui_vhMargin (this, &hm, &vm);
fontHeight = fontLineHeight ();
layout->confirm = entity_create ();
component_instantiate ("gui", layout->confirm);
component_instantiate ("clickable", layout->confirm);
component_instantiate ("input", layout->confirm);
component_instantiate ("textlabel", layout->confirm);
entity_refresh (layout->confirm);
gui_place (layout->confirm, x, y + h - (vm * 2 + fontHeight), w / 2, fontHeight + vm);
gui_setFrame (layout->confirm, this);
clickable_setClickCallback (layout->confirm, NULL);
textlabel_set (layout->confirm, "Continue", ALIGN_CENTRE, x, y + h - (vm * 2 + fontHeight), w / 2);
layout->cancel = entity_create ();
component_instantiate ("gui", layout->cancel);
component_instantiate ("clickable", layout->cancel);
component_instantiate ("input", layout->cancel);
component_instantiate ("textlabel", layout->cancel);
entity_refresh (layout->cancel);
gui_place (layout->cancel, x + w / 2, y + h - (vm * 2 + fontHeight), w / 2, fontHeight + vm);
gui_setFrame (layout->cancel, this);
clickable_setClickCallback (layout->cancel, optlayout_cancelCallback);
textlabel_set (layout->cancel, "Cancel", ALIGN_CENTRE, x + w / 2, y + h - (vm * 2 + fontHeight), w / 2);
}
entity_t *sword_create() {
entity_t *sword = entity_create();
if (!sword) {
return NULL;
}
sword_t *sword_data = malloc(sizeof(sword_t));
if (!sword_data) {
entity_release(sword);
return NULL;
}
sword->entity_data = sword_data;
strcpy(sword->class_name, "sword");
sword->bounding_box = graphics_rect_make(0, 0, 34, 12);
sword->touch = _sword_touch;
sword->dealloc = _sword_dealloc;
return sword;
}
entity_t *drop_create(drop_type_t drop_type, entity_t *source) {
drop_t *drop_data;
entity_t *drop = entity_create();
if (!drop) {
return NULL;
}
drop->dealloc = _drop_dealloc;
drop->thinkRate = drop_think_interval(drop_type, ZELDA_DROP_STATE_DROPPED);
drop->think = _drop_think;
drop->update = _drop_update;
drop->render = _drop_render;
/** TODO: Revisit this to better position drop. */
drop->position = source->position;
drop_data = malloc(sizeof(drop_t));
if (!drop_data) {
entity_release(drop);
return NULL;
}
drop_data->state = ZELDA_DROP_STATE_DROPPED;
drop_data->type = drop_type;
drop->entity_data = drop_data;
if (!_load_drop_config_from_yaml_file(drop_config_file_for_type(drop_type), drop)) {
entity_release(drop);
return NULL;
}
return drop;
}
int main(int argc, char *argv[])
{
char input = 0;
char save_name[50];
//Prepare engine
Engine *engine = prepare_game(save_name);
GoF_Screen *screen = screen_create(0, 0, 30, 30, 20);
Graphics g;
graphics_init(&g, 800, 900, "The Game of Life!");
input = 0;
while(input != 'k')
{
screen_draw(screen, &g, engine);
input = graphics_event(&g);
if(input == 1)
engine_add_entity(engine, entity_create(g.last_x/screen->entity_length, g.last_y/screen->entity_length));
else if(input == 3)
engine_remove_entity(engine, g.last_x/screen->entity_length, g.last_y/screen->entity_length);
}
//Input
input = 0;
int sens = 5;
//Main game loop
while(input != 'q')
{
//Draw on screen
screen_draw(screen, &g, engine);
//Update Engine
engine_update(engine);
//Process input
while(graphics_check_event(&g))
{
input = graphics_event(&g);
switch(input)
{
case 'p':
engine->ups++;
break;
case 'm':
if(engine->ups > 1)
engine->ups--;
break;
case '.':
sens++;
break;
case ',':
if(sens > 1)
sens--;
break;
case UP_ARROW:
screen->y -= sens;
break;
case DOWN_ARROW:
screen->y += sens;
break;
case LEFT_ARROW:
screen->x -= sens;
break;
case RIGHT_ARROW:
screen->x += sens;
break;
}
}
//Sleep
usleep((1000/engine->ups) * 1000);
}
//Close graphics
graphics_close(&g);
//Save game
printf("Saving game...\n");
engine_save(engine, save_name);
//Free mem
engine_free(engine);
screen_free(screen);
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;
}
