shariq
/
Symmetry
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Implemented drawing entity projection mesh which shows the effect of the curernt transformation on the entity

Browse Source
dev
Shariq Shah 6 years ago
parent 53f4d51790
commit 1cd9b71ba7
9 changed files with 243 additions and 116 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 12
      src/common/linmath.c
  2. 182
      src/game/editor.c
  3. 78
      src/game/editor.h
  4. 2
      src/game/game.c
  5. 32
      src/game/im_render.c
  6. 32
      src/game/renderer.c
  7. 14
      src/game/transform.c
  8. 1
      src/game/transform.h
  9. 6
      todo.txt

12
src/common/linmath.c
Unescape View File

@ -801,20 +801,24 @@ void quat_get_right(vec3* res, const quat* q)
float quat_get_pitch(const quat* q) float quat_get_pitch(const quat* q)
{ {
float result = (float)atan2(2 * (q->y * q->z + q->w * q->x), q->w * q->w - q->x * q->x - q->y * q->y + q->z * q->z); float check = 2.0f * (-q->y * q->z + q->w * q->x);
return result; if(check < -0.995f || check > 0.995f)
return 0.f;
else
return TO_DEGREES(atan2f(2.f * (q->x * q->z + q->w * q->y), 1.f - 2.f * (q->x * q->x + q->y * q->y)));
//return TO_DEGREES(atan2f(2.f * (q->y * q->z + q->w * q->x), q->w * q->w - q->x * q->x - q->y * q->y + q->z * q->z));
} }
float quat_get_yaw(const quat* q) float quat_get_yaw(const quat* q)
{ {
float result = (float)asin(-2 * (q->x * q->z - q->w * q->y)); float result = (float)asin(-2 * (q->x * q->z - q->w * q->y));
return result; return TO_DEGREES(result);
} }
float quat_get_roll(const quat* q) float quat_get_roll(const quat* q)
{ {
float result = atan2(2 * (q->x * q->y + q->w * q->z), q->w * q->w + q->x * q->x - q->y * q->y - q->z * q->z); float result = atan2(2 * (q->x * q->y + q->w * q->z), q->w * q->w + q->x * q->x - q->y * q->y - q->z * q->z);
return result; return TO_DEGREES(result);
} }
void quat_mul_mat4(quat* res, quat* val, mat4* mat) void quat_mul_mat4(quat* res, quat* val, mat4* mat)

182
src/game/editor.c
Unescape View File

@ -127,16 +127,19 @@ void editor_init(struct Editor* editor)
editor->tool_rotate_amount = 0.f; editor->tool_rotate_amount = 0.f;
editor->tool_rotate_increment = 5.f; editor->tool_rotate_increment = 5.f;
editor->tool_rotate_arc_radius = 5.f; editor->tool_rotate_arc_radius = 5.f;
editor->tool_rotate_arc_segments = 50.f; editor->tool_rotate_arc_segments = 20.f;
editor->tool_rotate_starting_rotation = 0.f;
editor->tool_rotate_rotation_started = false; editor->tool_rotate_rotation_started = false;
editor->tool_rotate_allowed = false; editor->tool_rotate_allowed = false;
editor->axis_line_length = 500.f; editor->axis_line_length = 500.f;
editor->picking_enabled = true; editor->picking_enabled = true;
editor->draw_entity_wireframe = false;
vec4_fill(&editor->projected_entity_color, 0.f, 1.f, 1.f, 1.f);
vec3_fill(&editor->tool_scale_amount, 0.f, 0.f, 0.f); vec3_fill(&editor->tool_scale_amount, 0.f, 0.f, 0.f);
vec3_fill(&editor->tool_mesh_position, 0.f, 0.f, 0.f); vec3_fill(&editor->tool_mesh_position, 0.f, 0.f, 0.f);
vec4_fill(&editor->tool_mesh_color, 0.f, 1.f, 1.f, 1.f); vec4_fill(&editor->tool_mesh_color, 0.f, 1.f, 1.f, 1.f);
vec4_fill(&editor->selected_entity_colour, 0.96, 0.61, 0.17, 1.f); vec4_fill(&editor->selected_entity_color, 0.96, 0.61, 0.17, 0.5f);
vec4_fill(&editor->grid_color, 0.3f, 0.3f, 0.3f, 0.7f); vec4_fill(&editor->grid_color, 0.3f, 0.3f, 0.3f, 0.7f);
vec4_fill(&editor->axis_color_x, 0.87, 0.32, 0.40, 1.f); vec4_fill(&editor->axis_color_x, 0.87, 0.32, 0.40, 1.f);
vec4_fill(&editor->axis_color_y, 0.53, 0.67, 0.28, 1.f); vec4_fill(&editor->axis_color_y, 0.53, 0.67, 0.28, 1.f);
@ -150,6 +153,8 @@ void editor_init(struct Editor* editor)
event_manager_subscribe(event_manager, EVT_MOUSEMOTION, &editor_on_mousemotion); event_manager_subscribe(event_manager, EVT_MOUSEMOTION, &editor_on_mousemotion);
event_manager_subscribe(event_manager, EVT_KEY_PRESSED, &editor_on_key_press); event_manager_subscribe(event_manager, EVT_KEY_PRESSED, &editor_on_key_press);
event_manager_subscribe(event_manager, EVT_KEY_RELEASED, &editor_on_key_release); event_manager_subscribe(event_manager, EVT_KEY_RELEASED, &editor_on_key_release);
editor->selected_entity_wireframe = scene_static_mesh_create(game_state_get()->scene, "EDITOR_SELECTED_ENTITY_WIREFRAME", NULL, "Sphere.pamesh", MAT_UNSHADED);
} }
void editor_init_camera(struct Editor* editor, struct Hashmap* cvars) void editor_init_camera(struct Editor* editor, struct Hashmap* cvars)
@ -172,6 +177,8 @@ void editor_init_camera(struct Editor* editor, struct Hashmap* cvars)
void editor_render(struct Editor* editor, struct Camera * active_camera) void editor_render(struct Editor* editor, struct Camera * active_camera)
{ {
struct Game_State* game_state = game_state_get();
struct Renderer* renderer = game_state->renderer;
//Disabling this for now until better handling of bounding box and scale of the entity is implemented //Disabling this for now until better handling of bounding box and scale of the entity is implemented
//Get the selected entity if any, see if it has a mesh and render it in the selected entity colour //Get the selected entity if any, see if it has a mesh and render it in the selected entity colour
// if(editor->selected_entity) // if(editor->selected_entity)
@ -191,6 +198,67 @@ void editor_render(struct Editor* editor, struct Camera * active_camera)
// } // }
// } // }
if(game_state->editor->selected_entity)
{
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_BLEND);
/* Draw selected entity */
if(editor->selected_entity->type == ET_STATIC_MESH)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
shader_bind(renderer->debug_shader);
{
static mat4 mvp;
shader_set_uniform_vec4(renderer->debug_shader, "debug_color", &editor->selected_entity_color);
struct Static_Mesh* mesh = (struct Static_Mesh*)editor->selected_entity;
struct Model* model = &mesh->model;
struct Transform* transform = &mesh->base.transform;
int geometry = model->geometry_index;
mat4_identity(&mvp);
mat4_mul(&mvp, &active_camera->view_proj_mat, &transform->trans_mat);
shader_set_uniform_mat4(renderer->debug_shader, "mvp", &mvp);
geom_render(geometry, GDM_TRIANGLES);
}
shader_unbind();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
//For now just draw a placeholder sphere just to visually denote that the entity is selected
vec3 abs_pos;
quat abs_rot;
transform_get_absolute_position(editor->selected_entity, &abs_pos);
transform_get_absolute_rot(editor->selected_entity, &abs_rot);
im_sphere(1.f, abs_pos, abs_rot, editor->selected_entity_color, GDM_TRIANGLES, 1);
}
/* Draw selected entity with projected transformation applied */
if(editor->draw_entity_wireframe)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
shader_bind(renderer->debug_shader);
{
static mat4 mvp;
shader_set_uniform_vec4(renderer->debug_shader, "debug_color", &editor->projected_entity_color);
struct Static_Mesh* mesh = editor->selected_entity_wireframe;
struct Model* model = editor->selected_entity->type == ET_STATIC_MESH ? &((struct Static_Mesh*)editor->selected_entity)->model : &mesh->model;
struct Transform* transform = &mesh->base.transform;
int geometry = model->geometry_index;
mat4_identity(&mvp);
mat4_mul(&mvp, &active_camera->view_proj_mat, &transform->trans_mat);
shader_set_uniform_mat4(renderer->debug_shader, "mvp", &mvp);
geom_render(geometry, GDM_TRIANGLES);
}
shader_unbind();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
glDisable(GL_DEPTH_TEST);
glDisable(GL_BLEND);
}
vec3 position = { 0.f, 0.f, 0.f }; vec3 position = { 0.f, 0.f, 0.f };
quat rotation = { 0.f, 0.f, 0.f, 1.f }; quat rotation = { 0.f, 0.f, 0.f, 1.f };
vec3 scale = { 1.f, 1.f, 1.f }; vec3 scale = { 1.f, 1.f, 1.f };
@ -413,7 +481,7 @@ void editor_update(struct Editor* editor, float dt)
nk_labelf(context, NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE, "Position at: %.1f %.1f %.1f", editor->tool_mesh_position.x, editor->tool_mesh_position.y, editor->tool_mesh_position.z); nk_labelf(context, NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE, "Position at: %.1f %.1f %.1f", editor->tool_mesh_position.x, editor->tool_mesh_position.y, editor->tool_mesh_position.z);
break; break;
case EDITOR_MODE_ROTATE: case EDITOR_MODE_ROTATE:
nk_labelf(context, NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE, "Rotation by: %.1f", editor->tool_rotate_amount); nk_labelf(context, NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE, "Rotation by: %.1f", editor->tool_rotate_total_rotation);
break; break;
case EDITOR_MODE_SCALE: case EDITOR_MODE_SCALE:
nk_labelf(context, NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE, "Scale to: %.1f %.1f %.1f", editor->tool_scale_amount.x, editor->tool_scale_amount.y, editor->tool_scale_amount.z); nk_labelf(context, NK_TEXT_ALIGN_LEFT | NK_TEXT_ALIGN_MIDDLE, "Scale to: %.1f %.1f %.1f", editor->tool_scale_amount.x, editor->tool_scale_amount.y, editor->tool_scale_amount.z);
@ -531,15 +599,6 @@ void editor_update(struct Editor* editor, float dt)
break; break;
} }
//im_circle(editor->tool_rotate_arc_radius, editor->tool_rotate_arc_segments, false, editor->tool_mesh_position, rotation, editor->axis_color_z, 3);
//
//quat_axis_angle(&rotation, &UNIT_X, -90.f);
//im_circle(editor->tool_rotate_arc_radius, editor->tool_rotate_arc_segments, false, editor->tool_mesh_position, rotation, editor->axis_color_y, 3);
//quat_identity(&rotation);
//quat_axis_angle(&rotation, &UNIT_Y, -90.f);
//im_circle(editor->tool_rotate_arc_radius, editor->tool_rotate_arc_segments, false, editor->tool_mesh_position, rotation, editor->axis_color_x, 3);
if(editor->current_axis != EDITOR_AXIS_NONE) if(editor->current_axis != EDITOR_AXIS_NONE)
{ {
quat_identity(&rotation); quat_identity(&rotation);
@ -547,8 +606,8 @@ void editor_update(struct Editor* editor, float dt)
switch(editor->current_axis) switch(editor->current_axis)
{ {
case EDITOR_AXIS_X: quat_axis_angle(&rotation, &UNIT_Y, -90.f); vec4_assign(&arc_color, &editor->axis_color_x); break; case EDITOR_AXIS_X: quat_axis_angle(&rotation, &UNIT_Y, -90.f); vec4_assign(&arc_color, &editor->axis_color_x); break;
case EDITOR_AXIS_Y: quat_axis_angle(&rotation, &UNIT_X, -90.f); vec4_assign(&arc_color, &editor->axis_color_y) ;break; case EDITOR_AXIS_Y: quat_axis_angle(&rotation, &UNIT_X, 90.f); vec4_assign(&arc_color, &editor->axis_color_y); break;
case EDITOR_AXIS_Z: vec4_assign(&arc_color, &editor->axis_color_z); break; case EDITOR_AXIS_Z: quat_axis_angle(&rotation, &UNIT_Y, 180.f); vec4_assign(&arc_color, &editor->axis_color_z); break;
} }
if(editor->tool_rotate_allowed) if(editor->tool_rotate_allowed)
@ -557,10 +616,11 @@ void editor_update(struct Editor* editor, float dt)
im_circle(editor->tool_rotate_arc_radius, editor->tool_rotate_arc_segments, true, editor->tool_mesh_position, rotation, arc_color, 2); im_circle(editor->tool_rotate_arc_radius, editor->tool_rotate_arc_segments, true, editor->tool_mesh_position, rotation, arc_color, 2);
} }
if(editor->tool_rotate_amount != 0.f) if(editor->tool_rotate_total_rotation != 0.f)
{ {
arc_color.w = 0.5f; arc_color.w = 0.5f;
im_arc(editor->tool_rotate_arc_radius / 2.f, 0.f, editor->tool_rotate_amount, editor->tool_rotate_arc_segments, true, editor->tool_mesh_position, rotation, arc_color, 4); log_message("Starting: %f", editor->tool_rotate_starting_rotation);
im_arc(editor->tool_rotate_arc_radius / 2.f, editor->tool_rotate_starting_rotation, editor->tool_rotate_total_rotation, editor->tool_rotate_arc_segments, true, editor->tool_mesh_position, rotation, arc_color, 4);
} }
} }
} }
@ -599,7 +659,14 @@ void editor_on_mousebutton_release(const struct Event* event)
{ {
//For now, just select the first entity that is intersected //For now, just select the first entity that is intersected
struct Entity* intersected_entity = ray_result.entities_intersected[0]; struct Entity* intersected_entity = ray_result.entities_intersected[0];
editor_entity_select(editor, intersected_entity); if(intersected_entity == editor->selected_entity_wireframe)
{
if(ray_result.num_entities_intersected > 1)
intersected_entity = ray_result.entities_intersected[1];
else
intersected_entity = NULL;
}
if(intersected_entity) editor_entity_select(editor, intersected_entity);
} }
else else
{ {
@ -628,21 +695,25 @@ void editor_on_mousebutton_release(const struct Event* event)
{ {
editor->picking_enabled = true; editor->picking_enabled = true;
editor->tool_rotate_rotation_started = false; editor->tool_rotate_rotation_started = false;
transform_copy(editor->selected_entity, editor->selected_entity_wireframe, false);
editor->tool_rotate_total_rotation = 0.f;
editor->tool_rotate_starting_rotation = 0.f;
editor->draw_entity_wireframe = false;
if(editor->tool_rotate_amount != 0.f) if(editor->tool_rotate_amount != 0.f)
{ {
vec3 axis = { 0.f, 0.f, 0.f }; //vec3 axis = { 0.f, 0.f, 0.f };
bool should_rotate = true; //bool should_rotate = true;
switch(editor->current_axis) //switch(editor->current_axis)
{ //{
case EDITOR_AXIS_X: vec3_assign(&axis, &UNIT_X); break; //case EDITOR_AXIS_X: vec3_assign(&axis, &UNIT_X); break;
case EDITOR_AXIS_Y: vec3_assign(&axis, &UNIT_Y); break; //case EDITOR_AXIS_Y: vec3_assign(&axis, &UNIT_Y); break;
case EDITOR_AXIS_Z: vec3_assign(&axis, &UNIT_Z); break; //case EDITOR_AXIS_Z: vec3_assign(&axis, &UNIT_Z); break;
default: should_rotate = false; //default: should_rotate = false;
} //}
if(should_rotate) //if(should_rotate)
transform_rotate(editor->selected_entity, &axis, editor->tool_rotate_amount, TS_WORLD); // transform_rotate(editor->selected_entity, &axis, editor->tool_rotate_amount, TS_WORLD);
editor->tool_rotate_amount = 0.f; //editor->tool_rotate_amount = 0.f;
} }
} }
} }
@ -663,6 +734,14 @@ void editor_on_mousebutton_press(const struct Event* event)
{ {
editor->picking_enabled = false; editor->picking_enabled = false;
editor->tool_rotate_rotation_started = true; editor->tool_rotate_rotation_started = true;
editor->tool_rotate_total_rotation = 0.f;
editor->draw_entity_wireframe = true;
switch(editor->current_axis)
{
case EDITOR_AXIS_X: editor->tool_rotate_starting_rotation = roundf(quat_get_pitch(&editor->selected_entity->transform.rotation)); break;
case EDITOR_AXIS_Y: editor->tool_rotate_starting_rotation = roundf(quat_get_yaw(&editor->selected_entity->transform.rotation)); break;
case EDITOR_AXIS_Z: editor->tool_rotate_starting_rotation = roundf(quat_get_roll(&editor->selected_entity->transform.rotation)); break;
}
} }
} }
@ -724,6 +803,7 @@ void editor_on_mousemotion(const struct Event* event)
editor->tool_mesh_position.x = roundf(editor->tool_mesh_position.x / editor->grid_scale) * editor->grid_scale; editor->tool_mesh_position.x = roundf(editor->tool_mesh_position.x / editor->grid_scale) * editor->grid_scale;
editor->tool_mesh_position.y = roundf(editor->tool_mesh_position.y / editor->grid_scale) * editor->grid_scale; editor->tool_mesh_position.y = roundf(editor->tool_mesh_position.y / editor->grid_scale) * editor->grid_scale;
editor->tool_mesh_position.z = roundf(editor->tool_mesh_position.z / editor->grid_scale) * editor->grid_scale; editor->tool_mesh_position.z = roundf(editor->tool_mesh_position.z / editor->grid_scale) * editor->grid_scale;
transform_set_position(editor->selected_entity_wireframe, &editor->tool_mesh_position);
} }
} }
} }
@ -791,6 +871,28 @@ void editor_on_mousemotion(const struct Event* event)
editor->tool_rotate_amount = editor->tool_rotate_amount - 360.f; editor->tool_rotate_amount = editor->tool_rotate_amount - 360.f;
else if(editor->tool_rotate_amount < -360.f) else if(editor->tool_rotate_amount < -360.f)
editor->tool_rotate_amount = editor->tool_rotate_amount + 360.f; editor->tool_rotate_amount = editor->tool_rotate_amount + 360.f;
if(editor->tool_rotate_amount != 0.f)
{
vec3 axis = { 0.f, 0.f, 0.f };
bool should_rotate = true;
switch(editor->current_axis)
{
case EDITOR_AXIS_X: vec3_assign(&axis, &UNIT_X); break;
case EDITOR_AXIS_Y: vec3_assign(&axis, &UNIT_Y); break;
case EDITOR_AXIS_Z: vec3_assign(&axis, &UNIT_Z); break;
default: should_rotate = false;
}
if(should_rotate)
transform_rotate(editor->selected_entity_wireframe, &axis, editor->tool_rotate_amount, TS_WORLD);
editor->tool_rotate_total_rotation += editor->tool_rotate_amount;
if(editor->tool_rotate_total_rotation > 360.f)
editor->tool_rotate_total_rotation = (int)editor->tool_rotate_total_rotation % 360;
else if(editor->tool_rotate_total_rotation < -360.f)
editor->tool_rotate_total_rotation = (int)editor->tool_rotate_total_rotation % -360;
editor->tool_rotate_amount = 0.f;
}
} }
} }
@ -860,7 +962,11 @@ void editor_mode_set(struct Editor* editor, int mode)
{ {
editor->current_mode = mode; editor->current_mode = mode;
} }
if(editor->selected_entity && editor->current_mode == EDITOR_MODE_TRANSLATE)
editor->draw_entity_wireframe = true;
else
editor->draw_entity_wireframe = false;
editor_tool_reset(editor); editor_tool_reset(editor);
} }
@ -880,20 +986,28 @@ void editor_entity_select(struct Editor* editor, struct Entity* entity)
editor->selected_entity = NULL; editor->selected_entity = NULL;
} }
if(editor->current_mode == EDITOR_MODE_TRANSLATE) editor->draw_entity_wireframe = true;
entity->editor_selected = true; entity->editor_selected = true;
editor->selected_entity = entity; editor->selected_entity = entity;
transform_get_absolute_position(editor->selected_entity, &editor->tool_mesh_position); transform_get_absolute_position(editor->selected_entity, &editor->tool_mesh_position);
transform_copy(editor->selected_entity_wireframe, editor->selected_entity, false);
} }
} }
void editor_tool_reset(struct Editor* editor) void editor_tool_reset(struct Editor* editor)
{ {
if(editor->selected_entity) if(editor->selected_entity)
{
transform_get_absolute_position(editor->selected_entity, &editor->tool_mesh_position); transform_get_absolute_position(editor->selected_entity, &editor->tool_mesh_position);
transform_copy(editor->selected_entity_wireframe, editor->selected_entity, false);
}
else else
{
vec3_fill(&editor->tool_mesh_position, 0.f, 0.f, 0.f); vec3_fill(&editor->tool_mesh_position, 0.f, 0.f, 0.f);
}
editor->tool_rotate_amount = 0.f; editor->tool_rotate_amount = 0.f;
editor->tool_rotate_total_rotation = 0.f;
editor->tool_rotate_allowed = false; editor->tool_rotate_allowed = false;
editor->tool_rotate_rotation_started = false; editor->tool_rotate_rotation_started = false;
editor->picking_enabled = true; editor->picking_enabled = true;
@ -1235,9 +1349,9 @@ void editor_window_property_inspector(struct nk_context* context, struct Editor*
quat abs_rot = { 0.f, 0.f, 0.f, 1.f }; quat abs_rot = { 0.f, 0.f, 0.f, 1.f };
transform_get_absolute_rot(entity, &abs_rot); transform_get_absolute_rot(entity, &abs_rot);
vec3 rot_angles = { 0.f, 0.f, 0.f }; vec3 rot_angles = { 0.f, 0.f, 0.f };
rot_angles.x = TO_DEGREES(quat_get_pitch(&abs_rot)); rot_angles.x = quat_get_pitch(&abs_rot);
rot_angles.y = TO_DEGREES(quat_get_yaw(&abs_rot)); rot_angles.y = quat_get_yaw(&abs_rot);
rot_angles.z = TO_DEGREES(quat_get_roll(&abs_rot)); rot_angles.z = quat_get_roll(&abs_rot);
vec3 curr_rot = { rot_angles.x, rot_angles.y, rot_angles.z }; vec3 curr_rot = { rot_angles.x, rot_angles.y, rot_angles.z };
nk_layout_row_dynamic(context, row_height, 1); nk_property_float(context, "#X", -FLT_MAX, &curr_rot.x, FLT_MAX, 5.f, 1.f); nk_layout_row_dynamic(context, row_height, 1); nk_property_float(context, "#X", -FLT_MAX, &curr_rot.x, FLT_MAX, 5.f, 1.f);

78
src/game/editor.h
Unescape View File

@ -7,45 +7,51 @@
struct Camera; struct Camera;
struct Entity; struct Entity;
struct Hashmap; struct Hashmap;
struct Static_Mesh;
struct Editor struct Editor
{ {
int window_settings_renderer; int window_settings_renderer;
int window_settings_editor; int window_settings_editor;
int window_scene_heirarchy; int window_scene_heirarchy;
int window_property_inspector; int window_property_inspector;
int window_debug_variables; int window_debug_variables;
int camera_looking_around; int camera_looking_around;
struct Entity* selected_entity; struct Entity* selected_entity;
int top_panel_height; struct Static_Mesh* selected_entity_wireframe;
float camera_turn_speed; vec4 projected_entity_color;
float camera_move_speed; bool draw_entity_wireframe;
float camera_sprint_multiplier; int top_panel_height;
vec4 selected_entity_colour; float camera_turn_speed;
int current_mode; float camera_move_speed;
int current_axis; float camera_sprint_multiplier;
int previous_axis; vec4 selected_entity_color;
int grid_enabled; int current_mode;
int grid_relative; int current_axis;
vec4 grid_color; int previous_axis;
int grid_num_lines; int grid_enabled;
float grid_scale; int grid_relative;
int tool_snap_enabled; vec4 grid_color;
vec3 tool_mesh_position; int grid_num_lines;
vec4 tool_mesh_color; float grid_scale;
int tool_mesh_draw_enabled; int tool_snap_enabled;
float tool_rotate_arc_radius; vec3 tool_mesh_position;
int tool_rotate_arc_segments; vec4 tool_mesh_color;
float tool_rotate_amount; int tool_mesh_draw_enabled;
bool tool_rotate_allowed; float tool_rotate_arc_radius;
bool tool_rotate_rotation_started; int tool_rotate_arc_segments;
float tool_rotate_increment; float tool_rotate_amount;
vec3 tool_scale_amount; bool tool_rotate_allowed;
float axis_line_length; bool tool_rotate_rotation_started;
vec4 axis_color_x; float tool_rotate_increment;
vec4 axis_color_y; float tool_rotate_total_rotation;
vec4 axis_color_z; float tool_rotate_starting_rotation;
bool picking_enabled; vec3 tool_scale_amount;
float axis_line_length;
vec4 axis_color_x;
vec4 axis_color_y;
vec4 axis_color_z;
bool picking_enabled;
}; };
void editor_init(struct Editor* editor_state); void editor_init(struct Editor* editor_state);

2
src/game/game.c
Unescape View File

@ -106,9 +106,9 @@ bool game_init(struct Window* window, struct Hashmap* cvars)
physics_body_set_moved_callback(entity_rigidbody_on_move); physics_body_set_moved_callback(entity_rigidbody_on_move);
physics_body_set_collision_callback(entity_rigidbody_on_collision); physics_body_set_collision_callback(entity_rigidbody_on_collision);
scene_init(game_state->scene);
editor_init(game_state->editor); editor_init(game_state->editor);
renderer_init(game_state->renderer); renderer_init(game_state->renderer);
scene_init(game_state->scene);
} }
/* Debug scene setup */ /* Debug scene setup */

32
src/game/im_render.c
Unescape View File

@ -168,26 +168,44 @@ void im_circle(float radius, int num_divisions, bool filled, vec3 position, quat
void im_arc(float radius, float angle_start, float angle_end, int num_divisions, bool filled, vec3 position, quat rotation, vec4 color, int draw_order) void im_arc(float radius, float angle_start, float angle_end, int num_divisions, bool filled, vec3 position, quat rotation, vec4 color, int draw_order)
{ {
im_begin(position, rotation, (vec3) { 1.f, 1.f, 1.f }, color, filled ? GDM_TRIANGLE_FAN : GDM_LINE_LOOP, draw_order);
float arc_degrees = angle_end - angle_start; float arc_degrees = angle_end - angle_start;
if(fabsf(arc_degrees) < 0.01f)
return;
im_begin(position, rotation, (vec3) { 1.f, 1.f, 1.f }, color, filled ? GDM_TRIANGLE_FAN : GDM_LINE_LOOP, draw_order);
if(arc_degrees != 360) if(arc_degrees != 360)
im_pos(0.f, 0.f, 0.f); im_pos(0.f, 0.f, 0.f);
if(arc_degrees > 360.f) if(arc_degrees > 360.f)
{
arc_degrees = (int)arc_degrees % 360; arc_degrees = (int)arc_degrees % 360;
if(arc_degrees < -360.f) angle_end = arc_degrees;
}
else if(arc_degrees < -360.f)
{
arc_degrees = (int)arc_degrees % -360; arc_degrees = (int)arc_degrees % -360;
angle_end = arc_degrees;
}
if(fabsf(arc_degrees) < 0.01f)
arc_degrees = arc_degrees < 0.f ? -0.01f : 0.01f;
float increment = arc_degrees / num_divisions; float increment = arc_degrees / num_divisions;
if(fabsf(increment) < 0.01f)
increment = increment < 0.f ? -0.01f : 0.01f;
if(angle_start < angle_end) if(angle_start < angle_end)
{ {
for(float i = angle_start; i <= arc_degrees; i += increment) int count = 0;
im_pos(sinf(i * M_PI / 180.f) * radius, cosf(i * M_PI / 180.f) * radius, 0.f); for(float i = angle_start; i <= angle_end; i += increment)
{
count++;
im_pos(sinf(i * M_PI / 180.f) * radius, cosf(i * M_PI / 180.f) * radius, 0.f);
}
} }
else else
{ {
for(float i = angle_start; i >= arc_degrees; i += increment) for(float i = angle_start; i >= angle_end; i += increment)
im_pos(sinf(i * M_PI / 180.f) * radius, cosf(i * M_PI / 180.f) * radius, 0.f); im_pos(sinf(i * M_PI / 180.f) * radius, cosf(i * M_PI / 180.f) * radius, 0.f);
} }
@ -264,6 +282,8 @@ void im_render(struct Camera* active_viewer)
} }
shader_unbind(); shader_unbind();
glDisable(GL_BLEND);
glDisable(GL_DEPTH_TEST);
IM_State.curr_geom = -1; IM_State.curr_geom = -1;
IM_State.curr_vertex = 0; IM_State.curr_vertex = 0;

32
src/game/renderer.c
Unescape View File

@ -407,38 +407,6 @@ void renderer_render(struct Renderer* renderer, struct Scene* scene)
if(game_state->game_mode == GAME_MODE_EDITOR) if(game_state->game_mode == GAME_MODE_EDITOR)
{ {
editor_render(game_state->editor, active_camera); editor_render(game_state->editor, active_camera);
if(game_state->editor->selected_entity)
{
if(game_state->editor->selected_entity->type == ET_STATIC_MESH)
{
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
shader_bind(renderer->debug_shader);
{
static mat4 mvp;
shader_set_uniform_vec4(renderer->debug_shader, "debug_color", &game_state->editor->selected_entity_colour);
struct Static_Mesh* mesh = (struct Static_Mesh*)game_state->editor->selected_entity;
struct Model* model = &mesh->model;
struct Transform* transform = &mesh->base.transform;
int geometry = model->geometry_index;
mat4_identity(&mvp);
mat4_mul(&mvp, &active_camera->view_proj_mat, &transform->trans_mat);
shader_set_uniform_mat4(renderer->debug_shader, "mvp", &mvp);
geom_render(geometry, GDM_TRIANGLES);
}
shader_unbind();
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
//For now just draw a placeholder sphere just to visually denote that the entity is selected
vec3 abs_pos;
quat abs_rot;
transform_get_absolute_position(game_state->editor->selected_entity, &abs_pos);
transform_get_absolute_rot(game_state->editor->selected_entity, &abs_rot);
im_sphere(1.f, abs_pos, abs_rot, game_state->editor->selected_entity_colour, GDM_TRIANGLES, 1);
}
}
} }
//Immediate mode geometry render //Immediate mode geometry render

14
src/game/transform.c
Unescape View File

@ -3,7 +3,9 @@
#include "../common/array.h" #include "../common/array.h"
#include "entity.h" #include "entity.h"
#include "../common/utils.h" #include "../common/utils.h"
#include <assert.h> #include <assert.h>
#include <string.h>
void transform_init(struct Entity* entity, struct Entity* parent) void transform_init(struct Entity* entity, struct Entity* parent)
{ {
@ -66,6 +68,18 @@ void transform_parent_set(struct Entity* child, struct Entity* parent, bool upda
if(update_transmat) transform_update_transmat(child); if(update_transmat) transform_update_transmat(child);
} }
void transform_copy(struct Entity* copy_to, struct Entity* copy_from, bool copy_parent)
{
struct Entity* current_parent = copy_to->transform.parent;
struct Entity** current_children = copy_to->transform.children;
memcpy(&copy_to->transform, &copy_from->transform, sizeof(struct Transform));
if(copy_parent)
transform_parent_set(copy_to, current_parent, true);
copy_to->transform.children = current_children;
}
void transform_translate(struct Entity* entity, vec3* amount, enum Transform_Space space) void transform_translate(struct Entity* entity, vec3* amount, enum Transform_Space space)
{ {
struct Transform* transform = &entity->transform; struct Transform* transform = &entity->transform;

1
src/game/transform.h
Unescape View File

@ -32,5 +32,6 @@ void transform_get_absolute_forward(struct Entity* entity, vec3* res);
void transform_child_add(struct Entity* entity, struct Entity* child, bool update_transmat); void transform_child_add(struct Entity* entity, struct Entity* child, bool update_transmat);
bool transform_child_remove(struct Entity* entity, struct Entity* child); bool transform_child_remove(struct Entity* entity, struct Entity* child);
void transform_parent_set(struct Entity* entity, struct Entity* parent, bool update_transmat); void transform_parent_set(struct Entity* entity, struct Entity* parent, bool update_transmat);
void transform_copy(struct Entity* copy_to, struct Entity* copy_from, bool copy_parent);
#endif #endif

6
todo.txt
Unescape View File

@ -1,7 +1,4 @@
Todo: Todo:
- Rotate mesh along mouse movement or show what the rotation is going to look like by using a wireframe version of mesh when rotating
- Match amount to be rotate with actual axes and the gizmo arc being drawn
- Handle all other axes combinations
- Better, more accurate picking - Better, more accurate picking
- Editor related messages/notifications in the bottom status bar - Editor related messages/notifications in the bottom status bar
- Highlight if we are about to select an entity or perform the tool action like translate when mouse is hovered and an entity can be selected at that location - Highlight if we are about to select an entity or perform the tool action like translate when mouse is hovered and an entity can be selected at that location
@ -267,4 +264,7 @@ Done:
* Remove fixed editor windows locations and bring back floating windows * Remove fixed editor windows locations and bring back floating windows
* Only show rotation gizmo for one axis at a time * Only show rotation gizmo for one axis at a time
* Cancel tool action when right click is pressed in between * Cancel tool action when right click is pressed in between
* Rotate mesh along mouse movement or show what the rotation is going to look like by using a wireframe version of mesh when rotating
* Match amount to be rotate with actual axes and the gizmo arc being drawn
* Handle all other axes combinations

Write Preview
Loading…
Cancel
Save