VulkEngineGUI/entity_components.cpp at main · mooresethmoore/VulkEngineGUI · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
#include "entity_components.hpp"


namespace lve {

    glm::mat4 TransformComponent::mat4() {
        const float c3 = glm::cos(rotation.z);
        const float s3 = glm::sin(rotation.z);
        const float c2 = glm::cos(rotation.x);
        const float s2 = glm::sin(rotation.x);
        const float c1 = glm::cos(rotation.y);
        const float s1 = glm::sin(rotation.y);
        return glm::mat4{
            {
                scale.x * (c1 * c3 + s1 * s2 * s3),
                scale.x * (c2 * s3),
                scale.x * (c1 * s2 * s3 - c3 * s1),
                0.0f,
            },
            {
                scale.y * (c3 * s1 * s2 - c1 * s3),
                scale.y * (c2 * c3),
                scale.y * (c1 * c3 * s2 + s1 * s3),
                0.0f,
            },
            {
                scale.z * (c2 * s1),
                scale.z * (-s2),
                scale.z * (c1 * c2),
                0.0f,
            },
            {translation.x, translation.y, translation.z, 1.0f} };
    }

    glm::mat3 TransformComponent::normalMatrix() {
        const float c3 = glm::cos(rotation.z);
        const float s3 = glm::sin(rotation.z);
        const float c2 = glm::cos(rotation.x);
        const float s2 = glm::sin(rotation.x);
        const float c1 = glm::cos(rotation.y);
        const float s1 = glm::sin(rotation.y);
        const glm::vec3 invScale = 1.0f / scale;

        return glm::mat3{
            {
                invScale.x * (c1 * c3 + s1 * s2 * s3),
                invScale.x * (c2 * s3),
                invScale.x * (c1 * s2 * s3 - c3 * s1),
            },
            {
                invScale.y * (c3 * s1 * s2 - c1 * s3),
                invScale.y * (c2 * c3),
                invScale.y * (c1 * c3 * s2 + s1 * s3),
            },
            {
                invScale.z * (c2 * s1),
                invScale.z * (-s2),
                invScale.z * (c1 * c2),
            },
        };
    }


    void TransformComponent::imgui_editor() {
        // to be used within the context of a ImGui::Begin(f"<Transform Component>"); -- ImGui::End();
        if (ImGui::TreeNode("Transform")) {
            //static float position[3] = {translation[0],translation[1],translation[2]};
            //ImGui::InputFloat3("Position", { translation[0],translation[1],translation[2] });

            //posPtr = glm::value_ptr(translation);
            ImGui::InputFloat3("Position", glm::value_ptr(translation));
            ImGui::InputFloat3("Rotation (Tait-Bryan YXZ)", glm::value_ptr(rotation));
            ImGui::InputFloat3("Scale", glm::value_ptr(scale));
            ImGui::TreePop();
        }
    }

    void PointLightComponent::imgui_editor() {

    }

    void ColorComponent::imgui_editor() {
        if (ImGui::TreeNode("Color")) {
            ImGui::ColorEdit3("Color", glm::value_ptr(color));


            ImGui::TreePop();
        }
    }
}