[Bf-blender-cvs] [1109e900ce2] soc-2021-simulation-display: Physics: Added visualisation for slider and hinge constraints.
soumya pochiraju
noreply at git.blender.org
Sun Aug 1 16:05:12 CEST 2021
Commit: 1109e900ce2e28aa1bb2cfc1a61bbd0c5a46630c
Author: soumya pochiraju
Date: Sun Aug 1 13:28:46 2021 +0530
Branches: soc-2021-simulation-display
https://developer.blender.org/rB1109e900ce2e28aa1bb2cfc1a61bbd0c5a46630c
Physics: Added visualisation for slider and hinge constraints.
===================================================================
M source/blender/draw/CMakeLists.txt
M source/blender/draw/engines/overlay/overlay_extra.c
M source/blender/draw/engines/overlay/overlay_private.h
M source/blender/draw/engines/overlay/overlay_shader.c
A source/blender/draw/engines/overlay/shaders/constraint_angular_limits_vert.glsl
===================================================================
diff --git a/source/blender/draw/CMakeLists.txt b/source/blender/draw/CMakeLists.txt
index 5f943006eb0..e7e07efa273 100644
--- a/source/blender/draw/CMakeLists.txt
+++ b/source/blender/draw/CMakeLists.txt
@@ -385,6 +385,7 @@ data_to_c_simple(engines/overlay/shaders/background_frag.glsl SRC)
data_to_c_simple(engines/overlay/shaders/clipbound_vert.glsl SRC)
data_to_c_simple(engines/overlay/shaders/collision_display_box_vert.glsl SRC)
data_to_c_simple(engines/overlay/shaders/collision_display_cylinder_vert.glsl SRC)
+data_to_c_simple(engines/overlay/shaders/constraint_angular_limits_vert.glsl SRC)
data_to_c_simple(engines/overlay/shaders/depth_only_vert.glsl SRC)
data_to_c_simple(engines/overlay/shaders/edit_curve_handle_geom.glsl SRC)
data_to_c_simple(engines/overlay/shaders/edit_curve_handle_vert.glsl SRC)
diff --git a/source/blender/draw/engines/overlay/overlay_extra.c b/source/blender/draw/engines/overlay/overlay_extra.c
index 0ee0726899a..aca267574c4 100644
--- a/source/blender/draw/engines/overlay/overlay_extra.c
+++ b/source/blender/draw/engines/overlay/overlay_extra.c
@@ -64,7 +64,7 @@
#include "draw_manager_text.h"
#include "BLI_math_rotation.h"
-#include "math.h"
+#include <math.h>
#ifdef WITH_BULLET
# include "RBI_api.h"
@@ -2103,15 +2103,13 @@ static void OVERLAY_linear_limits_walls(RigidBodyCon *rbc,
sub_v3_v3v3(initial_offset, ob1->loc, ob2->loc);
sub_v3_v3v3(current_offset, ob1->rigidbody_object->pos, ob2->rigidbody_object->pos);
- printf("woop");
-
- /* rotate wall to correct initial orientation */
+ /* Rotate wall to correct initial orientation */
float rot1[3][3] = {{0}};
- /* Constraint object rotation. */
+ /* Constraint object transform. */
float rot2[3][3] = {{0}};
- /* Constrained object(ob2) rotation. */
+ /* Constrained object(ob2) transform. */
float rot3[3][3] = {{0}};
- /* Constrained object(ob2) initial rotation inverse. */
+ /* Constrained object(ob2) initial transform inverse. */
float rot4[3][3] = {{0}};
/* Get rotation from object matrices. */
@@ -2125,7 +2123,7 @@ static void OVERLAY_linear_limits_walls(RigidBodyCon *rbc,
BKE_object_rot_to_mat3(ob2, rot4, false);
invert_m3(rot4);
/* Remove initial rotation of ob2. */
- mul_m3_m3m3(rot3, rot4, rot3);
+ mul_m3_m3m3(rot3, rot3, rot4);
float ax[3] = {0.0f};
@@ -2219,6 +2217,8 @@ static void OVERLAY_linear_limits_rod(RigidBodyCon *rbc,
float initial_distance_vec[3];
float line_start[3] = {0.0f};
float line_end[3] = {0.0f};
+ float ob1_projection[3] = {0.0f};
+ float ob2_projection[3] = {0.0f};
sub_v3_v3v3(initial_distance_vec, ob1->loc, ob2->loc);
sub_v3_v3v3(distance_vec, ob1->rigidbody_object->pos, ob2->rigidbody_object->pos);
float constrained_axis[3] = {0.0f};
@@ -2233,45 +2233,227 @@ static void OVERLAY_linear_limits_rod(RigidBodyCon *rbc,
mat4_to_rot(rot2, ob1->obmat);
BKE_object_rot_to_mat3(ob1, rot3, false);
invert_m3(rot3);
- mul_m3_m3m3(rot2, rot3, rot2);
- mul_m3_v3(rot1, constrained_axis);
+ mul_m3_m3m3(rot2, rot2, rot3);
+ /*mul_m3_v3(rot1, constrained_axis);
mul_m3_v3(rot2, constrained_axis);
mul_m3_v3(rot2, initial_distance_vec);
sub_v3_v3(distance_vec, initial_distance_vec);
+ //dot_v3v3(distance_vec, constrained_axis); */
float cross_product[3];
cross_v3_v3v3(cross_product, distance_vec, constrained_axis);
+ mul_m3_v3(rot1, constrained_axis);
+ normalize_v3(constrained_axis);
- bool draw_rod = fabsf(len_v3(cross_product)) < 0.01f;
- printf("gah:%f ax: %f %f %f\n", fabsf(len_v3(cross_product)), constrained_axis[0], constrained_axis[1], constrained_axis[2]);
- printf("dist: %f %f %f\n", distance_vec[0], distance_vec[1], distance_vec[2]);
-
+ bool draw_rod = true;
if(draw_rod) {
-
- line_start[0] += rbc->limit_lin_x_upper;
- line_end[0] -= rbc->limit_lin_x_upper;
+ line_start[0] += (rbc->limit_lin_x_upper*0.5f);
+ line_end[0] -= (rbc->limit_lin_x_upper*0.5f);
+ float initial_component_along_axis = dot_v3v3(initial_distance_vec, constrained_axis);
+ line_start[0] -= (initial_component_along_axis*0.5f);
+ line_end[0] += (initial_component_along_axis*0.5f);
mul_m3_v3(rot1, line_start);
mul_m3_v3(rot1, line_end);
mul_m3_v3(rot2, line_start);
mul_m3_v3(rot2, line_end);
- sub_v3_v3(line_start, initial_distance_vec);
- add_v3_v3(line_end, initial_distance_vec);
- add_v3_v3(line_start, ob1->rigidbody_object->pos);
- add_v3_v3(line_end, ob2->rigidbody_object->pos);
+ mul_v3_fl(initial_distance_vec, 0.5f);
+ // sub_v3_v3(line_start, initial_distance_vec);
+ // add_v3_v3(line_end, initial_distance_vec);
+ float mid_point[3];
+ add_v3_v3v3(mid_point, ob1->rigidbody_object->pos, ob2->rigidbody_object->pos);
+ mul_v3_fl(mid_point, 0.5f);
+ add_v3_v3(line_start, mid_point);
+ add_v3_v3(line_end, mid_point);
+
+ closest_to_line_segment_v3(ob1_projection, ob1->rigidbody_object->pos, line_start, line_end);
+ closest_to_line_segment_v3(ob2_projection, ob2->rigidbody_object->pos, line_start, line_end);
OVERLAY_extra_line_dashed(cb, line_start, line_end, color);
+ OVERLAY_extra_line_dashed(cb, ob1->rigidbody_object->pos, ob1_projection, color);
+ OVERLAY_extra_line_dashed(cb, ob2->rigidbody_object->pos, ob2_projection, color);
+
+ }
+
+}
+
+static void OVERLAY_angular_limits_rods( OVERLAY_ExtraCallBuffers *cb,
+ Object *ob1,
+ Object *ob2,
+ const float axis_in_w[3],
+ const float color[4]) {
+ float start[3];
+ float end[3];
+
+ float point1[3];
+ float point2[3];
+ float point3[3];
+ float point4[3];
+
+ float ob_dist_vec[3];
+ sub_v3_v3v3(ob_dist_vec, ob1->rigidbody_object->pos, ob2->rigidbody_object->pos);
+ float ob_dist_normalized[3];
+ normalize_v3_v3(ob_dist_normalized, ob_dist_vec);
+
+ copy_v3_v3(start, ob1->rigidbody_object->pos);
+ copy_v3_v3(end, ob2->rigidbody_object->pos);
+
+ copy_v3_v3(point1, ob1->rigidbody_object->pos);
+ copy_v3_v3(point2, ob1->rigidbody_object->pos);
+ copy_v3_v3(point3, ob2->rigidbody_object->pos);
+ copy_v3_v3(point4, ob2->rigidbody_object->pos);
+
+ float offset = dot_v3v3(ob_dist_vec, axis_in_w);
+ float offset_vec[3];
+ copy_v3_v3(offset_vec, axis_in_w);
+
+ float sign = offset > 0.0f ? 1.0f :1 -1.0f;
+ mul_v3_fl(offset_vec, offset*sign*0.5);
+
+ sub_v3_v3(point2, offset_vec);
+ add_v3_v3(point3, offset_vec);
+
+ float angle_rod_vec[3];
+ sub_v3_v3v3(angle_rod_vec, point2, point3);
+ normalize_v3(angle_rod_vec);
+
+ add_v3_v3(start, angle_rod_vec);
+ sub_v3_v3(end, angle_rod_vec);
+
+ OVERLAY_extra_line_dashed(cb, start, point1, color);
+ OVERLAY_extra_line_dashed(cb, point1, point2, color);
+ OVERLAY_extra_line_dashed(cb, point2, point3, color);
+ OVERLAY_extra_line_dashed(cb, point3, point4, color);
+ OVERLAY_extra_line_dashed(cb, point4, end, color);
+
+}
+
+static void OVERLAY_angular_limits_arc(OVERLAY_Data *data,
+ Object *ob1,
+ Object *ob2,
+ const float transform_mat[3][3],
+ const float angle,
+ float angular_offset,
+ const float axis_in_w[3],
+ const float color[4]) {
+ /* Rotate the arc about constrained axis by required amount.
+ * Initialy, arc should lie along the 2 objects' distance vector. */
+ float ob_dist_vec[3];
+ sub_v3_v3v3(ob_dist_vec, ob1->rigidbody_object->pos, ob2->rigidbody_object->pos);
+
+ float constrained_axis_rot;
+ float arc_start[3] = {cosf((angle/2) + angular_offset), sinf((angle/2) + angular_offset), 0.0f};
+ mul_m3_v3(transform_mat, arc_start);
+ constrained_axis_rot = angle_signed_on_axis_v3v3_v3(arc_start, ob_dist_vec, axis_in_w);
+ angular_offset -= ( constrained_axis_rot);
+
+ float final_mat[4][4] = {{0.0f}};
+
+ float ob1_initial_rot[3][3];
+ float ob1_transform_inv[4][4] = {{0.0f}};
+ float ob2_initial_rot_inv[3][3];
+ float ob2_transform[4][4];
+
+ copy_m4_m4(ob1_transform_inv, ob1->obmat);
+ invert_m4(ob1_transform_inv);
+ BKE_object_rot_to_mat3(ob1, ob1_initial_rot, false);
+
+ BKE_object_rot_to_mat3(ob2, ob2_initial_rot_inv, false);
+ invert_m3(ob2_initial_rot_inv);
+ copy_m4_m4(ob2_transform, ob2->obmat);
+
+ mul_m4_m3m4(final_mat, ob1_initial_rot, ob1_transform_inv);
+ mul_m4_m3m4(final_mat, ob2_initial_rot_inv, final_mat);
+ mul_m4_m4m4(final_mat, ob2_transform, final_mat);
+ mul_m4_m4m3(final_mat, final_mat, transform_mat);
+
+ copy_v3_v3(final_mat[3], ob1->rigidbody_object->pos);
+ final_mat[3][3] = 1.0f;
+
+ normalize_m4(final_mat);
+
+ float segment_width = M_PI*10/180;
+ int n_segments = (int)(angle/segment_width) + 2;
+
+ GPUShader *sh = OVERLAY_shader_constraint_angular_limits();
+ DRWShadingGroup *grp = DRW_shgroup_create(sh, data->psl->extra_ps[1]);
+ DRW_shgroup_uniform_vec4_array_copy(grp, "mat_vecs", final_mat, 4);
+ //DRW_shgroup_uniform_vec4_array_copy(grp, "mat_vecs1", ob1_transform, 4);
+ DRW_shgroup_uniform_float_copy(grp, "offset", angular_offset);
+ DRW_shgroup_uniform_float_copy(grp, "angle", angle);
+ DRW_shgroup_uniform_vec3_copy(grp, "color", color);
+ DRW_shgroup_call_procedural_lines(grp, NULL, n_segments);
+}
+
+static void OVERLAY_angular_limits(OVERLAY_Data *data,
+ OVERLAY_ExtraCallBuffers *cb,
+ RigidBodyCon *rbc,
+ Object *ob1,
+ Object *ob2,
+ Object *constraint_ob,
+ int axis) {
+ float color[4] = {0.0f,
@@ Diff output truncated at 10240 characters. @@
More information about the Bf-blender-cvs
mailing list