656 lines
19 KiB
C
656 lines
19 KiB
C
#include <raylib.h>
|
|
#include <stdlib.h>
|
|
|
|
void LoadGizmo();
|
|
void UnloadGizmo();
|
|
Matrix UpdateGizmo(Camera3D camera, Vector3 position);
|
|
|
|
#ifdef RAYGIZMO_IMPLEMENTATION
|
|
|
|
#include "raymath.h"
|
|
#include <math.h>
|
|
#include <rlgl.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
// This will be multiplied by the distance from the camera to the gizmo,
|
|
// Which keeps the screen-space gizmo size constant.
|
|
#define GIZMO_SIZE 0.12f
|
|
|
|
// Line drawing thicknesses
|
|
#define GIZMO_HANDLE_DRAW_THICKNESS 5.0f
|
|
#define GIZMO_ACTIVE_AXIS_DRAW_THICKNESS 2.0f
|
|
|
|
// These sizes are relative to the gizmo radius
|
|
#define GIZMO_AXIS_HANDLE_LENGTH 1.2;
|
|
#define GIZMO_AXIS_HANDLE_TIP_LENGTH 0.3;
|
|
#define GIZMO_AXIS_HANDLE_TIP_RADIUS 0.1;
|
|
#define GIZMO_PLANE_HANDLE_OFFSET 0.4;
|
|
#define GIZMO_PLANE_HANDLE_SIZE 0.2;
|
|
|
|
#define X_AXIS \
|
|
(Vector3) { 1.0, 0.0, 0.0 }
|
|
#define Y_AXIS \
|
|
(Vector3) { 0.0, 1.0, 0.0 }
|
|
#define Z_AXIS \
|
|
(Vector3) { 0.0, 0.0, 1.0 }
|
|
|
|
#define MASK_FRAMEBUFFER_WIDTH 500.0
|
|
#define MASK_FRAMEBUFFER_HEIGHT 500.0
|
|
|
|
#define swap(x, y) \
|
|
do { \
|
|
unsigned char \
|
|
swap_temp[sizeof(x) == sizeof(y) ? (signed)sizeof(x) : -1]; \
|
|
memcpy(swap_temp, &y, sizeof(x)); \
|
|
memcpy(&y, &x, sizeof(x)); \
|
|
memcpy(&x, swap_temp, sizeof(x)); \
|
|
} while (0)
|
|
|
|
#define id_to_red_color(id) \
|
|
(Color) { id, 0, 0, 0 }
|
|
|
|
static const char* SHADER_COLOR_VERT = "\
|
|
#version 330\n\
|
|
in vec3 vertexPosition; \
|
|
in vec4 vertexColor; \
|
|
out vec4 fragColor; \
|
|
out vec3 fragPosition; \
|
|
uniform mat4 mvp; \
|
|
void main() { \
|
|
fragColor = vertexColor; \
|
|
fragPosition = vertexPosition; \
|
|
gl_Position = mvp * vec4(vertexPosition, 1.0); \
|
|
} \
|
|
";
|
|
|
|
static const char* SHADER_ROT_HANDLE_COLOR_FRAG = "\
|
|
#version 330\n\
|
|
in vec4 fragColor; \
|
|
in vec3 fragPosition; \
|
|
uniform vec3 cameraPosition; \
|
|
uniform vec3 gizmoPosition; \
|
|
out vec4 finalColor; \
|
|
void main() { \
|
|
vec3 r = normalize(fragPosition - gizmoPosition); \
|
|
vec3 c = normalize(fragPosition - cameraPosition); \
|
|
if (dot(r, c) > 0.1) discard; \
|
|
finalColor = fragColor; \
|
|
} \
|
|
";
|
|
|
|
static Shader SHADER_ROT_HANDLE_COLOR;
|
|
static int SHADER_ROT_HANDLE_CAMERA_POS_LOC;
|
|
static int SHADER_ROT_HANDLE_GIZMO_POS_LOC;
|
|
|
|
static unsigned int MASK_FRAMEBUFFER;
|
|
static unsigned int MASK_TEXTURE;
|
|
|
|
static bool IS_GIZMO_LOADED;
|
|
static Vector3 GIZMO_CURRENT_AXIS;
|
|
|
|
typedef enum HandleId {
|
|
HANDLE_X,
|
|
|
|
ROT_HANDLE_X,
|
|
AXIS_HANDLE_X,
|
|
PLANE_HANDLE_X,
|
|
|
|
HANDLE_Y,
|
|
|
|
ROT_HANDLE_Y,
|
|
AXIS_HANDLE_Y,
|
|
PLANE_HANDLE_Y,
|
|
|
|
HANDLE_Z,
|
|
|
|
ROT_HANDLE_Z,
|
|
AXIS_HANDLE_Z,
|
|
PLANE_HANDLE_Z
|
|
} HandleId;
|
|
|
|
typedef enum GizmoState {
|
|
GIZMO_COLD,
|
|
|
|
GIZMO_HOT,
|
|
|
|
GIZMO_HOT_ROT,
|
|
GIZMO_HOT_AXIS,
|
|
GIZMO_HOT_PLANE,
|
|
|
|
GIZMO_ACTIVE,
|
|
|
|
GIZMO_ACTIVE_ROT,
|
|
GIZMO_ACTIVE_AXIS,
|
|
GIZMO_ACTIVE_PLANE,
|
|
} GizmoState;
|
|
|
|
typedef struct Handle {
|
|
Vector3 position;
|
|
Vector3 axis;
|
|
Color color;
|
|
float dist_to_cam;
|
|
} Handle;
|
|
|
|
typedef struct HandleColors {
|
|
Color x;
|
|
Color y;
|
|
Color z;
|
|
} HandleColors;
|
|
|
|
typedef struct Handles {
|
|
Handle arr[3];
|
|
} Handles;
|
|
|
|
static GizmoState GIZMO_STATE;
|
|
|
|
bool check_if_mouse_moved() {
|
|
Vector2 mouse_delta = GetMouseDelta();
|
|
return (fabs(mouse_delta.x) + fabs(mouse_delta.y)) > EPSILON;
|
|
}
|
|
|
|
static float vector2_get_angle(Vector2 v1, Vector2 v2) {
|
|
Vector2 v1_norm = Vector2Normalize(v1);
|
|
Vector2 v2_norm = Vector2Normalize(v2);
|
|
float dot = Vector2DotProduct(v1_norm, v2_norm);
|
|
if (1.0 - fabs(dot) < EPSILON) return 0.0;
|
|
|
|
float angle = acos(dot);
|
|
float z = v1.x * v2.y - v1.y * v2.x;
|
|
|
|
if (fabs(z) < EPSILON) return 0.0;
|
|
else if (z > 0) return angle;
|
|
else return -angle;
|
|
}
|
|
|
|
static int isect_line_plane(
|
|
Vector3* out_p,
|
|
Vector3 line_p0,
|
|
Vector3 line_p1,
|
|
Vector3 plane_p,
|
|
Vector3 plane_normal
|
|
) {
|
|
Vector3 u = Vector3Subtract(line_p1, line_p0);
|
|
float dot = Vector3DotProduct(plane_normal, u);
|
|
if (fabs(dot) <= EPSILON) {
|
|
return 0;
|
|
}
|
|
|
|
Vector3 w = Vector3Subtract(line_p0, plane_p);
|
|
float k = -Vector3DotProduct(plane_normal, w) / dot;
|
|
u = Vector3Scale(u, k);
|
|
*out_p = Vector3Add(line_p0, u);
|
|
return 1;
|
|
}
|
|
|
|
static int get_two_vecs_nearest_point(
|
|
Vector3* vec0_out_nearest_point,
|
|
Vector3 vec0_p0,
|
|
Vector3 vec0_p1,
|
|
Vector3 vec1_p0,
|
|
Vector3 vec1_p1
|
|
) {
|
|
Vector3 vec0 = Vector3Subtract(vec0_p1, vec0_p0);
|
|
Vector3 vec1 = Vector3Subtract(vec1_p1, vec1_p0);
|
|
Vector3 plane_vec = Vector3CrossProduct(vec0, vec1);
|
|
plane_vec = Vector3Normalize(plane_vec);
|
|
Vector3 plane_normal = Vector3CrossProduct(vec0, plane_vec);
|
|
plane_normal = Vector3Normalize(plane_normal);
|
|
|
|
int is_isect = isect_line_plane(
|
|
vec0_out_nearest_point, vec1_p0, vec1_p1, vec0_p0, plane_normal
|
|
);
|
|
|
|
return is_isect;
|
|
}
|
|
|
|
static RayCollision get_ray_plane_collision(
|
|
Ray ray, Vector3 plane_point, Vector3 plane_normal
|
|
) {
|
|
RayCollision collision = {0};
|
|
|
|
// Calculate the parameter t
|
|
float denominator = ray.direction.x * plane_normal.x
|
|
+ ray.direction.y * plane_normal.y
|
|
+ ray.direction.z * plane_normal.z;
|
|
|
|
if (denominator == 0) {
|
|
// Ray is parallel to the plane, no collision
|
|
return collision;
|
|
}
|
|
|
|
float t = ((plane_point.x - ray.position.x) * plane_normal.x
|
|
+ (plane_point.y - ray.position.y) * plane_normal.y
|
|
+ (plane_point.z - ray.position.z) * plane_normal.z)
|
|
/ denominator;
|
|
|
|
if (t < 0) {
|
|
// Intersection point is behind the ray's starting point, no collision
|
|
return collision;
|
|
}
|
|
|
|
// Calculate the collision point
|
|
collision.point.x = ray.position.x + t * ray.direction.x;
|
|
collision.point.y = ray.position.y + t * ray.direction.y;
|
|
collision.point.z = ray.position.z + t * ray.direction.z;
|
|
collision.hit = true;
|
|
|
|
return collision;
|
|
}
|
|
|
|
static Handles get_sorted_handles(Handle h0, Handle h1, Handle h2) {
|
|
if (h0.dist_to_cam < h1.dist_to_cam) swap(h0, h1);
|
|
if (h1.dist_to_cam < h2.dist_to_cam) swap(h1, h2);
|
|
if (h0.dist_to_cam < h1.dist_to_cam) swap(h0, h1);
|
|
|
|
Handles handles = {.arr = {h0, h1, h2}};
|
|
return handles;
|
|
}
|
|
|
|
static HandleColors get_handle_colors(GizmoState hot_state) {
|
|
bool is_hot = GIZMO_STATE == hot_state || GIZMO_STATE == hot_state + 4;
|
|
Color x = is_hot && GIZMO_CURRENT_AXIS.x == 1.0 ? WHITE : RED;
|
|
Color y = is_hot && GIZMO_CURRENT_AXIS.y == 1.0 ? WHITE : GREEN;
|
|
Color z = is_hot && GIZMO_CURRENT_AXIS.z == 1.0 ? WHITE : BLUE;
|
|
HandleColors colors = {x, y, z};
|
|
return colors;
|
|
}
|
|
|
|
static void draw_axis_handles(
|
|
Camera3D camera,
|
|
Vector3 position,
|
|
float gizmo_radius,
|
|
Color color_x,
|
|
Color color_y,
|
|
Color color_z
|
|
) {
|
|
float length = gizmo_radius * GIZMO_AXIS_HANDLE_LENGTH;
|
|
float tip_length = gizmo_radius * GIZMO_AXIS_HANDLE_TIP_LENGTH;
|
|
float tip_radius = gizmo_radius * GIZMO_AXIS_HANDLE_TIP_RADIUS;
|
|
|
|
Vector3 px = Vector3Add(position, Vector3Scale(X_AXIS, length));
|
|
Vector3 py = Vector3Add(position, Vector3Scale(Y_AXIS, length));
|
|
Vector3 pz = Vector3Add(position, Vector3Scale(Z_AXIS, length));
|
|
|
|
Handle hx = {px, X_AXIS, color_x, Vector3DistanceSqr(px, camera.position)};
|
|
Handle hy = {py, Y_AXIS, color_y, Vector3DistanceSqr(py, camera.position)};
|
|
Handle hz = {pz, Z_AXIS, color_z, Vector3DistanceSqr(pz, camera.position)};
|
|
|
|
Handles handles = get_sorted_handles(hx, hy, hz);
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
Handle* h = &handles.arr[i];
|
|
Vector3 tip_end = Vector3Add(
|
|
h->position, Vector3Scale(h->axis, tip_length)
|
|
);
|
|
DrawLine3D(position, h->position, h->color);
|
|
DrawCylinderEx(h->position, tip_end, tip_radius, 0.0, 16, h->color);
|
|
}
|
|
}
|
|
|
|
static void draw_plane_handles(
|
|
Camera3D camera,
|
|
Vector3 position,
|
|
float gizmo_radius,
|
|
Color color_x,
|
|
Color color_y,
|
|
Color color_z
|
|
) {
|
|
float offset = gizmo_radius * GIZMO_PLANE_HANDLE_OFFSET;
|
|
float size = gizmo_radius * GIZMO_PLANE_HANDLE_SIZE;
|
|
|
|
Vector3 px = Vector3Add(position, (Vector3){0.0, offset, offset});
|
|
Vector3 py = Vector3Add(position, (Vector3){offset, 0.0, offset});
|
|
Vector3 pz = Vector3Add(position, (Vector3){offset, offset, 0.0});
|
|
|
|
Handle hx = {px, Z_AXIS, color_x, Vector3DistanceSqr(px, camera.position)};
|
|
Handle hy = {py, Y_AXIS, color_y, Vector3DistanceSqr(py, camera.position)};
|
|
Handle hz = {pz, X_AXIS, color_z, Vector3DistanceSqr(pz, camera.position)};
|
|
|
|
Handles handles = get_sorted_handles(hx, hy, hz);
|
|
|
|
rlDisableBackfaceCulling();
|
|
for (int i = 0; i < 3; ++i) {
|
|
Handle* h = &handles.arr[i];
|
|
rlPushMatrix();
|
|
{
|
|
rlTranslatef(h->position.x, h->position.y, h->position.z);
|
|
rlRotatef(90.0, h->axis.x, h->axis.y, h->axis.z);
|
|
DrawPlane(
|
|
Vector3Zero(), Vector2Scale(Vector2One(), size), h->color
|
|
);
|
|
}
|
|
rlPopMatrix();
|
|
}
|
|
}
|
|
|
|
static void draw_rot_handles(
|
|
Camera3D camera,
|
|
Vector3 position,
|
|
float gizmo_radius,
|
|
Color color_x,
|
|
Color color_y,
|
|
Color color_z
|
|
) {
|
|
BeginShaderMode(SHADER_ROT_HANDLE_COLOR);
|
|
{
|
|
SetShaderValue(
|
|
SHADER_ROT_HANDLE_COLOR,
|
|
SHADER_ROT_HANDLE_CAMERA_POS_LOC,
|
|
&camera.position,
|
|
SHADER_UNIFORM_VEC3
|
|
);
|
|
SetShaderValue(
|
|
SHADER_ROT_HANDLE_COLOR,
|
|
SHADER_ROT_HANDLE_GIZMO_POS_LOC,
|
|
&position,
|
|
SHADER_UNIFORM_VEC3
|
|
);
|
|
DrawCircle3D(position, gizmo_radius, Y_AXIS, 90.0, color_x);
|
|
DrawCircle3D(position, gizmo_radius, X_AXIS, 90.0, color_y);
|
|
DrawCircle3D(position, gizmo_radius, X_AXIS, 0.0, color_z);
|
|
}
|
|
EndShaderMode();
|
|
}
|
|
|
|
static void draw_gizmo(
|
|
Camera3D camera,
|
|
Vector3 position,
|
|
Color rot_handle_color_x,
|
|
Color rot_handle_color_y,
|
|
Color rot_handle_color_z,
|
|
Color axis_handle_color_x,
|
|
Color axis_handle_color_y,
|
|
Color axis_handle_color_z,
|
|
Color plane_handle_color_x,
|
|
Color plane_handle_color_y,
|
|
Color plane_handle_color_z
|
|
) {
|
|
float radius = GIZMO_SIZE * Vector3Distance(camera.position, position);
|
|
|
|
// Draw gizmo's handle elements
|
|
BeginMode3D(camera);
|
|
{
|
|
rlSetLineWidth(GIZMO_HANDLE_DRAW_THICKNESS);
|
|
rlDisableDepthTest();
|
|
|
|
draw_plane_handles(
|
|
camera,
|
|
position,
|
|
radius,
|
|
plane_handle_color_x,
|
|
plane_handle_color_y,
|
|
plane_handle_color_z
|
|
);
|
|
|
|
draw_rot_handles(
|
|
camera,
|
|
position,
|
|
radius,
|
|
rot_handle_color_x,
|
|
rot_handle_color_y,
|
|
rot_handle_color_z
|
|
);
|
|
|
|
draw_axis_handles(
|
|
camera,
|
|
position,
|
|
radius,
|
|
axis_handle_color_x,
|
|
axis_handle_color_y,
|
|
axis_handle_color_z
|
|
);
|
|
}
|
|
EndMode3D();
|
|
|
|
// Draw long white line which represents current active axis
|
|
if (GIZMO_STATE == GIZMO_ACTIVE_ROT || GIZMO_STATE == GIZMO_ACTIVE_AXIS) {
|
|
BeginMode3D(camera);
|
|
{
|
|
rlSetLineWidth(GIZMO_ACTIVE_AXIS_DRAW_THICKNESS);
|
|
Vector3 half_axis_line = Vector3Scale(GIZMO_CURRENT_AXIS, 1000.0);
|
|
DrawLine3D(
|
|
Vector3Subtract(position, half_axis_line),
|
|
Vector3Add(position, half_axis_line),
|
|
WHITE
|
|
);
|
|
}
|
|
EndMode3D();
|
|
}
|
|
|
|
// Draw white line from the gizmo's center to the mouse cursor when rotating
|
|
if (GIZMO_STATE == GIZMO_ACTIVE_ROT) {
|
|
rlSetLineWidth(GIZMO_ACTIVE_AXIS_DRAW_THICKNESS);
|
|
DrawLineV(
|
|
GetWorldToScreen(position, camera), GetMousePosition(), WHITE
|
|
);
|
|
}
|
|
}
|
|
|
|
static unsigned char get_gizmo_mask_pixel(Camera3D camera, Vector3 position) {
|
|
// -------------------------------------------------------------------
|
|
// Draw gizmo into a separate framebuffer for the mouse pixel-picking
|
|
rlEnableFramebuffer(MASK_FRAMEBUFFER);
|
|
rlViewport(0, 0, MASK_FRAMEBUFFER_WIDTH, MASK_FRAMEBUFFER_HEIGHT);
|
|
rlClearScreenBuffers();
|
|
rlDisableColorBlend();
|
|
|
|
draw_gizmo(
|
|
camera,
|
|
position,
|
|
id_to_red_color(ROT_HANDLE_X),
|
|
id_to_red_color(ROT_HANDLE_Y),
|
|
id_to_red_color(ROT_HANDLE_Z),
|
|
id_to_red_color(AXIS_HANDLE_X),
|
|
id_to_red_color(AXIS_HANDLE_Y),
|
|
id_to_red_color(AXIS_HANDLE_Z),
|
|
id_to_red_color(PLANE_HANDLE_X),
|
|
id_to_red_color(PLANE_HANDLE_Y),
|
|
id_to_red_color(PLANE_HANDLE_Z)
|
|
);
|
|
|
|
rlDisableFramebuffer();
|
|
rlEnableColorBlend();
|
|
rlViewport(0, 0, GetScreenWidth(), GetScreenHeight());
|
|
|
|
// -------------------------------------------------------------------
|
|
// Pick the pixel under the mouse cursor
|
|
Vector2 mouse_position = GetMousePosition();
|
|
unsigned char* pixels = (unsigned char*)rlReadTexturePixels(
|
|
MASK_TEXTURE,
|
|
MASK_FRAMEBUFFER_WIDTH,
|
|
MASK_FRAMEBUFFER_HEIGHT,
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R8G8B8A8
|
|
);
|
|
|
|
float x_ratio = Clamp(mouse_position.x / (float)GetScreenWidth(), 0.0, 1.0);
|
|
float y_ratio = Clamp(
|
|
1.0 - (mouse_position.y / (float)GetScreenHeight()), 0.0, 1.0
|
|
);
|
|
int x = (int)(MASK_FRAMEBUFFER_WIDTH * x_ratio);
|
|
int y = (int)(MASK_FRAMEBUFFER_HEIGHT * y_ratio);
|
|
int idx = 4 * (y * MASK_FRAMEBUFFER_WIDTH + x);
|
|
unsigned char mask_val = pixels[idx];
|
|
|
|
free(pixels);
|
|
return mask_val;
|
|
}
|
|
|
|
Matrix update_gizmo_rot(Camera3D camera, Vector3 position) {
|
|
if (!check_if_mouse_moved()) return MatrixIdentity();
|
|
|
|
Vector2 rot_center = GetWorldToScreen(position, camera);
|
|
Vector2 p1 = Vector2Subtract(GetMousePosition(), rot_center);
|
|
Vector2 p0 = Vector2Subtract(p1, GetMouseDelta());
|
|
float angle = vector2_get_angle(p1, p0);
|
|
|
|
// If we look at gizmo from behind, we should flip the rotation
|
|
if (Vector3DotProduct(GIZMO_CURRENT_AXIS, position)
|
|
> Vector3DotProduct(GIZMO_CURRENT_AXIS, camera.position)) {
|
|
angle *= -1;
|
|
}
|
|
|
|
// We rotate gizmo relative to it's own center, so we first translate it to
|
|
// the center of world coordinates, then rotate and then translate back
|
|
Matrix transform = MatrixMultiply(
|
|
MatrixMultiply(
|
|
MatrixTranslate(-position.x, -position.y, -position.z),
|
|
MatrixRotate(GIZMO_CURRENT_AXIS, angle)
|
|
),
|
|
MatrixTranslate(position.x, position.y, position.z)
|
|
);
|
|
|
|
return transform;
|
|
}
|
|
|
|
Matrix update_gizmo_axis(Camera3D camera, Vector3 position) {
|
|
if (!check_if_mouse_moved()) return MatrixIdentity();
|
|
|
|
Vector2 p = Vector2Add(GetWorldToScreen(position, camera), GetMouseDelta());
|
|
Ray r = GetMouseRay(p, camera);
|
|
Vector3 isect_p = Vector3Zero();
|
|
bool is_isect = get_two_vecs_nearest_point(
|
|
&isect_p,
|
|
camera.position,
|
|
Vector3Add(camera.position, r.direction),
|
|
position,
|
|
Vector3Add(position, GIZMO_CURRENT_AXIS)
|
|
);
|
|
|
|
if (!is_isect)
|
|
{
|
|
return MatrixIdentity();
|
|
}
|
|
|
|
Vector3 offset = Vector3Subtract(isect_p, position);
|
|
offset = Vector3Multiply(offset, GIZMO_CURRENT_AXIS);
|
|
Matrix transform = MatrixTranslate(offset.x, offset.y, offset.z);
|
|
|
|
return transform;
|
|
}
|
|
|
|
Matrix update_gizmo_plane(Camera3D camera, Vector3 position) {
|
|
if (!check_if_mouse_moved()) return MatrixIdentity();
|
|
Vector2 p = Vector2Add(GetWorldToScreen(position, camera), GetMouseDelta());
|
|
Ray r = GetMouseRay(p, camera);
|
|
RayCollision c = get_ray_plane_collision(r, position, GIZMO_CURRENT_AXIS);
|
|
Vector3 offset = Vector3Subtract(c.point, position);
|
|
Matrix transform = MatrixTranslate(offset.x, offset.y, offset.z);
|
|
|
|
return transform;
|
|
}
|
|
|
|
Matrix update_gizmo(Camera3D camera, Vector3 position, unsigned char mask_val) {
|
|
bool is_lmb_down = IsMouseButtonDown(0);
|
|
|
|
if (!is_lmb_down) GIZMO_STATE = GIZMO_COLD;
|
|
|
|
if (GIZMO_STATE < GIZMO_ACTIVE) {
|
|
if (mask_val < HANDLE_Y) GIZMO_CURRENT_AXIS = X_AXIS;
|
|
else if (mask_val < HANDLE_Z) GIZMO_CURRENT_AXIS = Y_AXIS;
|
|
else GIZMO_CURRENT_AXIS = Z_AXIS;
|
|
|
|
if (mask_val % 4 == 1)
|
|
GIZMO_STATE = is_lmb_down ? GIZMO_ACTIVE_ROT : GIZMO_HOT_ROT;
|
|
else if (mask_val % 4 == 2)
|
|
GIZMO_STATE = is_lmb_down ? GIZMO_ACTIVE_AXIS : GIZMO_HOT_AXIS;
|
|
else if (mask_val % 4 == 3)
|
|
GIZMO_STATE = is_lmb_down ? GIZMO_ACTIVE_PLANE : GIZMO_HOT_PLANE;
|
|
}
|
|
|
|
switch (GIZMO_STATE) {
|
|
case GIZMO_ACTIVE_ROT: return update_gizmo_rot(camera, position);
|
|
case GIZMO_ACTIVE_AXIS: return update_gizmo_axis(camera, position);
|
|
case GIZMO_ACTIVE_PLANE: return update_gizmo_plane(camera, position);
|
|
default: return MatrixIdentity();
|
|
}
|
|
}
|
|
|
|
void LoadGizmo() {
|
|
if (IS_GIZMO_LOADED) return;
|
|
|
|
SHADER_ROT_HANDLE_COLOR = LoadShaderFromMemory(
|
|
SHADER_COLOR_VERT, SHADER_ROT_HANDLE_COLOR_FRAG
|
|
);
|
|
SHADER_ROT_HANDLE_CAMERA_POS_LOC = GetShaderLocation(
|
|
SHADER_ROT_HANDLE_COLOR, "cameraPosition"
|
|
);
|
|
SHADER_ROT_HANDLE_GIZMO_POS_LOC = GetShaderLocation(
|
|
SHADER_ROT_HANDLE_COLOR, "gizmoPosition"
|
|
);
|
|
|
|
MASK_FRAMEBUFFER = rlLoadFramebuffer(
|
|
MASK_FRAMEBUFFER_WIDTH, MASK_FRAMEBUFFER_HEIGHT
|
|
);
|
|
if (!MASK_FRAMEBUFFER) {
|
|
TraceLog(LOG_ERROR, "Failed to create gizmo's mask framebuffer");
|
|
exit(1);
|
|
}
|
|
rlEnableFramebuffer(MASK_FRAMEBUFFER);
|
|
|
|
MASK_TEXTURE = rlLoadTexture(
|
|
NULL,
|
|
MASK_FRAMEBUFFER_WIDTH,
|
|
MASK_FRAMEBUFFER_HEIGHT,
|
|
RL_PIXELFORMAT_UNCOMPRESSED_R32G32B32A32,
|
|
1
|
|
);
|
|
rlActiveDrawBuffers(1);
|
|
rlFramebufferAttach(
|
|
MASK_FRAMEBUFFER,
|
|
MASK_TEXTURE,
|
|
RL_ATTACHMENT_COLOR_CHANNEL0,
|
|
RL_ATTACHMENT_TEXTURE2D,
|
|
0
|
|
);
|
|
if (!rlFramebufferComplete(MASK_FRAMEBUFFER)) {
|
|
TraceLog(LOG_ERROR, "Gizmo's framebuffer is not complete");
|
|
exit(1);
|
|
}
|
|
|
|
IS_GIZMO_LOADED = true;
|
|
}
|
|
|
|
void UnloadGizmo() {
|
|
if (!IS_GIZMO_LOADED) return;
|
|
|
|
UnloadShader(SHADER_ROT_HANDLE_COLOR);
|
|
rlUnloadFramebuffer(MASK_FRAMEBUFFER);
|
|
rlUnloadTexture(MASK_TEXTURE);
|
|
IS_GIZMO_LOADED = false;
|
|
}
|
|
|
|
Matrix UpdateGizmo(Camera3D camera, Vector3 position) {
|
|
if (!IS_GIZMO_LOADED) {
|
|
TraceLog(LOG_ERROR, "Gizmo must be loaded before the update");
|
|
exit(1);
|
|
}
|
|
|
|
unsigned char mask_val = get_gizmo_mask_pixel(camera, position);
|
|
Matrix transform = update_gizmo(camera, position, mask_val);
|
|
|
|
// -------------------------------------------------------------------
|
|
// Draw gizmo
|
|
HandleColors rot_handle_colors = get_handle_colors(GIZMO_HOT_ROT);
|
|
HandleColors axis_handle_colors = get_handle_colors(GIZMO_HOT_AXIS);
|
|
HandleColors plane_handle_colors = get_handle_colors(GIZMO_HOT_PLANE);
|
|
|
|
draw_gizmo(
|
|
camera,
|
|
position,
|
|
rot_handle_colors.x,
|
|
rot_handle_colors.y,
|
|
rot_handle_colors.z,
|
|
axis_handle_colors.x,
|
|
axis_handle_colors.y,
|
|
axis_handle_colors.z,
|
|
plane_handle_colors.x,
|
|
plane_handle_colors.y,
|
|
plane_handle_colors.z
|
|
);
|
|
|
|
return transform;
|
|
}
|
|
|
|
#endif
|
|
|