SimpleRenderEngine/test/primitives-test.cpp at master · Chris-Carvelli/SimpleRenderEngine · 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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
#include <iostream>
#include <vector>
#include <fstream>

#include "sre/Texture.hpp"
#include "sre/Renderer.hpp"
#include "sre/Material.hpp"
#include "sre/SDLRenderer.hpp"

#define GLM_ENABLE_EXPERIMENTAL
#include <glm/gtx/euler_angles.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>


using namespace sre;

class PrimitivesTest {
public:
    PrimitivesTest(){
        r.init();

        camera.lookAt({0,0,3},{0,0,0},{0,1,0});
        camera.setPerspectiveProjection(60,0.1,100);

        material = Shader::getStandardBlinnPhong()->createMaterial();
        material->setColor({1.0f,1.0f,1.0f,1.0f});
        material->setSpecularity(Color(1,1,1,20.0f));

        mesh = Mesh::create().withCube().build();
        worldLights.setAmbientLight({0.0,0.0,0.0});
        worldLights.addLight(Light::create().withPointLight({0, 3,0}).withColor({1,0,0}).withRange(20).build());
        worldLights.addLight(Light::create().withPointLight({3, 0,0}).withColor({0,1,0}).withRange(20).build());
        worldLights.addLight(Light::create().withPointLight({0,-3,0}).withColor({0,0,1}).withRange(20).build());
        worldLights.addLight(Light::create().withPointLight({-3,0,0}).withColor({1,1,1}).withRange(20).build());

        r.frameRender = [&](){
            render();
        };

        r.startEventLoop();
    }

    void render(){
        auto renderPass = RenderPass::create()
                .withCamera(camera)
                .withWorldLights(&worldLights)
                .withClearColor(true, {1, 0, 0, 1})
                .build();
        renderPass.draw(mesh, glm::eulerAngleY(glm::radians((float)i*0.5f)), material);
        gui();
        i++;
    }

    void gui(){
        bool changed = ImGui::Combo("Shader",&shader,"Phong\0UVs\0Normals\0Tangents\0");
        if (changed){
            switch (shader){
                case 0:
                    material = Shader::getStandardBlinnPhong()->createMaterial();
                    break;
                case 1:
                    material = Shader::create()
                            .withSourceResource("debug_uv_vert.glsl", ShaderType::Vertex)
                            .withSourceResource("debug_uv_frag.glsl", ShaderType::Fragment)
                            .build()->createMaterial();
                    break;
                case 2:
                    material = Shader::create()
                            .withSourceResource("debug_normal_vert.glsl", ShaderType::Vertex)
                            .withSourceResource("debug_normal_frag.glsl", ShaderType::Fragment)
                            .build()->createMaterial();
                    break;
                case 3:
                    material = Shader::create()
                            .withSourceResource("debug_tangent_vert.glsl", ShaderType::Vertex)
                            .withSourceResource("debug_tangent_frag.glsl", ShaderType::Fragment)
                            .build()->createMaterial();
                    break;
                default:
                    std::cout << "Err"<<std::endl;
            }

            material->setColor({1.0f,1.0f,1.0f,1.0f});
            material->setSpecularity(Color(1,1,1,20.0f));
        }
        changed |= ImGui::Checkbox("Recompute normals",&recomputeNormals);
        changed |= ImGui::Checkbox("Recompute tangents",&recomputeTangents);
        changed |= ImGui::Combo("Primitive",&primitive,"Cube\0Sphere\0Quad\0Torus\0");
        if (changed){
            switch (primitive){
                case 0:
                    mesh = Mesh::create().withCube(1).withRecomputeNormals(recomputeNormals).withRecomputeTangents(recomputeTangents).build();
                    break;
                case 1:
                    mesh = Mesh::create().withSphere().withRecomputeNormals(recomputeNormals).withRecomputeTangents(recomputeTangents).build();
                    break;
                case 2:
                    mesh = Mesh::create().withQuad(1).withRecomputeNormals(recomputeNormals).withRecomputeTangents(recomputeTangents).build();
                    break;
                case 3:
                    mesh = Mesh::create().withTorus().withRecomputeNormals(recomputeNormals).withRecomputeTangents(recomputeTangents).build();
                    break;
                default:
                    std::cout << "Err"<<std::endl;
            }
        }

    }
private:
    bool recomputeNormals = false;
    bool recomputeTangents = false;
    int shader = 0;
    int primitive = 0;
    SDLRenderer r;
    Camera camera;
    WorldLights worldLights;
    std::shared_ptr<Mesh> mesh;
    std::shared_ptr<Material> material;
    int i=0;
};

int main() {
    std::make_unique<PrimitivesTest>();
    return 0;
}