transform.c

#include "transform.h"

#include <stdlib.h>
#include <math.h>
#include <stdio.h>

transform *create_tranform(vec3 translate, vec3 rotate, vec3 scale)
{
    transform *my_transform = (transform*)malloc(sizeof(transform));

    my_transform->position = translate;
    my_transform->rotation = rotate;
    my_transform->scale = scale;

    my_transform->right.x = 1.0f; my_transform->right.y = 0.0f; my_transform->right.z = 0.0f;
    my_transform->up.x = 0.0f; my_transform->up.y = 1.0f; my_transform->up.z = 0.0f;
    my_transform->forward.x = 0.0f; my_transform->forward.y = 0.0f; my_transform->forward.z = -1.0f;

    my_transform->is_trans = 1;
    my_transform->is_rot = 1;
    my_transform->is_scale = 1;

    return my_transform;
}

void move_obj(transform *my_transform, vec3 trans_val)
{
    my_transform->position.x += trans_val.x;
    my_transform->position.y += trans_val.y;
    my_transform->position.z += trans_val.z;
    my_transform->is_trans = 1;
}

void calc_transmat(transform *my_transform)
{
    vec4 p = {.x = 1.0f, .y = 0.0f, .z = 0.0f, .w = my_transform->position.x};
    vec4 q = {.x = 0.0f, .y = 1.0f, .z = 0.0f, .w = my_transform->position.y};
    vec4 r = {.x = 0.0f, .y = 0.0f, .z = 1.0f, .w = my_transform->position.z};
    vec4 s = {.x = 0.0f, .y = 0.0f, .z = 0.0f, .w = 1.0f};

    mat4 temp_mat = {.p = p, .q = q, .r = r, .s = s};

    my_transform->trans_mat = temp_mat;
    my_transform->is_trans = 0;
}

void rot_obj(transform *my_transform, vec3 rot_val)
{
    my_transform->rotation.x += rot_val.x;
    my_transform->rotation.y += rot_val.y;
    my_transform->rotation.z += rot_val.z;
    my_transform->is_rot = 1;
}

void calc_rotmat(transform *my_transform)
{
    float p = my_transform->rotation.x * M_PI / 180.0;
    float y = my_transform->rotation.y * M_PI / 180.0;
    float r = my_transform->rotation.z * M_PI / 180.0;

    printf("Rot in rad\n");
    printf("%f %f %f\n", p, y, r);

    // Since all quat calculations and on half of angles
    p *= 0.5f;
    y *= 0.5f;
    r *= 0.5f;

    float sinp = sin(p);
    float siny = sin(y);
    float sinr = sin(r);
    float cosp = cos(p);
    float cosy = cos(y);
    float cosr = cos(r);

    // Rotation in x axis
    quat x_quat = {.x = my_transform->right.x * sinp, .y = my_transform->right.y * sinp, .z = my_transform->right.z * sinp, .w = cosp};
    // Rotation in y axis
    quat y_quat = {.x = my_transform->up.x * siny, .y = my_transform->up.y * siny, .z = my_transform->up.z * siny, .w = cosy};

    // Rotation in z axis
    quat z_quat = {.x = my_transform->forward.x * sinr, .y = my_transform->forward.y * sinr, .z = my_transform->forward.z * sinr, .w = cosr};

    printf("Rotation quaternion in x axis.\n");
    printf("%f %f %f %f\n", x_quat.x, x_quat.y, x_quat.z, x_quat.w);

    printf("Rotation quaternion in y axis.\n");
    printf("%f %f %f %f\n", y_quat.x, y_quat.y, y_quat.z, y_quat.w);

    printf("Rotation quaternion in z axis.\n");
    printf("%f %f %f %f\n", z_quat.x, z_quat.y, z_quat.z, z_quat.w);

    // multiplying three quaternions: trying out orders for now first y - z - x
    quat zx = quat_mul(z_quat, x_quat);
    quat yzx = quat_mul(y_quat, zx);

    printf("Final rotation quaternion. Muultiplication of above in order y * z * x\n");
    printf("%f %f %f %f\n", yzx.x, yzx.y, yzx.z, yzx.w);

    // Vector to be rotated
    quat forward_quat = {.x = my_transform->forward.x, .y = my_transform->forward.y, .z = my_transform->forward.z, .w = 0.0f};

    printf("Vector to be rotated, forward vector of object.\n");
    printf("%f %f %f %f\n", forward_quat.x, forward_quat.y, forward_quat.z, forward_quat.w);

    printf("Conjuagte.\n");
    printf("%f %f %f %f\n", quat_neg(yzx).x, quat_neg(yzx).y, quat_neg(yzx).z, quat_neg(yzx).w);

    printf("Quaternion into forward vector.\n");
    quat final_zquat = quat_mul(yzx, forward_quat);
    printf("%f %f %f %f\n", final_zquat.x, final_zquat.y, final_zquat.z, final_zquat.w);

    final_zquat = quat_mul(final_zquat, quat_neg(yzx));
    printf("final quat after multiplying with conjugate.\n");
    printf("%f %f %f %f\n", final_zquat.x, final_zquat.y, final_zquat.z, final_zquat.w);

    my_transform->rot_mat = quat_tomat4(final_zquat);

    printf("Rot mat\n");
    printf("%f %f %f %f\n", my_transform->rot_mat.p.x, my_transform->rot_mat.p.y, my_transform->rot_mat.p.z, my_transform->rot_mat.p.w);
    printf("%f %f %f %f\n", my_transform->rot_mat.q.x, my_transform->rot_mat.q.y, my_transform->rot_mat.q.z, my_transform->rot_mat.q.w);
    printf("%f %f %f %f\n", my_transform->rot_mat.r.x, my_transform->rot_mat.r.y, my_transform->rot_mat.r.z, my_transform->rot_mat.r.w);
    printf("%f %f %f %f\n", my_transform->rot_mat.s.x, my_transform->rot_mat.s.y, my_transform->rot_mat.s.z, my_transform->rot_mat.s.w);

    printf("Old orientations.\n");
    printf("Forward: %f %f %f\n", my_transform->forward.x, my_transform->forward.y, my_transform->forward.z);
    printf("Right: %f %f %f\n", my_transform->right.x, my_transform->right.y, my_transform->right.z);
    printf("Up: %f %f %f\n", my_transform->up.x, my_transform->up.y, my_transform->up.z);

    // update all three vectors
    vec4 fd = {.x = 0.0f, .y = 0.0f, .z = -1.0f, .w = 0.0f};
    vec4 rt = {.x = 1.0f, .y = 0.0f, .z = 0.0f, .w = 0.0f};
    vec4 up = {.x= 0.0f, .y = 1.0f, .z = 0.0f, .w = 0.0f};

    fd = vec4_mat4mul(fd, my_transform->rot_mat);
    rt = vec4_mat4mul(rt, my_transform->rot_mat);
    up = vec4_mat4mul(up, my_transform->rot_mat);

    my_transform->forward.x = fd.x; my_transform->forward.y = fd.y; my_transform->forward.z = fd.z;

    my_transform->right.x = rt.x; my_transform->right.y = rt.y; my_transform->right.z = rt.z;

    my_transform->up.x = up.x; my_transform->up.y = up.y; my_transform->up.z = up.z;

    printf("New orientations.\n");
    printf("Forward: %f %f %f\n", my_transform->forward.x, my_transform->forward.y, my_transform->forward.z);
    printf("Right: %f %f %f\n", my_transform->right.x, my_transform->right.y, my_transform->right.z);
    printf("Up: %f %f %f\n", my_transform->up.x, my_transform->up.y, my_transform->up.z);

    my_transform->is_rot = 0;
}

void scale_obj(transform *my_transform, vec3 scale_val)
{
    my_transform->scale = scale_val;
    my_transform->is_scale = 1;
}

void calc_scalemat(transform *my_transform)
{
    vec4 p = {.x = my_transform->scale.x, .y = 0.0f, .z = 0.0f, .w = 0.0f};
    vec4 q = {.x = 0.0f, .y = my_transform->scale.y, .z = 0.0f, .w = 0.0f};
    vec4 r = {.x = 0.0f, .y = 0.0f, .z = my_transform->scale.z, .w = 0.0f};
    vec4 s = {.x = 0.0f, .y = 0.0f, .z = 0.0f, .w = 1.0f};

    mat4 temp_mat = {.p = p, .q = q, .r = r, .s = s};

    my_transform->scale_mat = temp_mat;
    my_transform->is_scale = 0;
}

void calc_modmat(transform *my_transform)
{
    if(my_transform->is_trans) calc_transmat(my_transform);
    if(my_transform->is_rot) calc_rotmat(my_transform);
    if(my_transform->is_scale) calc_scalemat(my_transform);

    my_transform->model_mat = mat4_mul(mat4_mul(my_transform->scale_mat, my_transform->rot_mat) , my_transform->trans_mat);
}

void destroy_transform(transform *my_transform)
{
    free(my_transform);
}