SensorFusionSimulation/OpenGLPrimitive.hpp at master · robwasab/SensorFusionSimulation · 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
//
//  OpenGLDrawable.hpp
//  OpenGLTutorial
//
//  Created by Robby Tong on 1/1/19.
//  Copyright © 2019 Robby Tong. All rights reserved.
//

#ifndef OpenGLPrimitive_hpp
#define OpenGLPrimitive_hpp

#include <stdio.h>
#include <glm/glm.hpp>
#include "OpenGLShader.hpp"
#include "OpenGLDrawable.hpp"
#include <vector>

#define TEXTURE_WOODEN_CONTAINER "/Users/robbytong/Documents/OpenGL/Tutorials/LearnOpenGL/XCode/wooden_container.jpg"

#define TEXTURE_EARTH "/Users/robbytong/Documents/OpenGL/Tutorials/LearnOpenGL/XCode/earth_low_resolution.jpg"

#define TEXTURE_IPHONE_FACE "/Users/robbytong/Documents/OpenGL/Tutorials/LearnOpenGL/XCode/iphone_face.jpg"

#define TEXTURE_IPHONE_BACK "/Users/robbytong/Documents/OpenGL/Tutorials/LearnOpenGL/XCode/iphone_back.jpg"

#define TEXTURE_IPHONE_METAL "/Users/robbytong/Documents/OpenGL/Tutorials/LearnOpenGL/XCode/aluminum.jpg"


struct OpenGLVertexAttributes
{
    float position[3];
    float colors[3];
    float textureLocation[2];
    float normal[3];
};

typedef struct OpenGLVertexAttributes OpenGLVertexAttributes;


class OpenGLPrimitive: public OpenGLDrawable
{

private:
    float mColorTextureRatio;

    GLuint mVAO;
    GLuint mVBO;
    GLuint mTextureId;
    bool mTextureEnabled;

    GLuint mDrawingMode;
    GLuint mPolygonMode;

    OpenGLVertexAttributes * mVerticies;
    size_t mNumVerticies;

    bool mFinishedInitializing;
    float mRGB[3];

    OpenGLDrawable * mNormalArrow;
public:

    enum VERTEX_INTERPRET_MODE
    {
        VERTEX_INTERPRET_MODE_TRIANGLES         = GL_TRIANGLES,
        VERTEX_INTERPRET_MODE_TRIANGLE_STRIP    = GL_TRIANGLE_STRIP,
        VERTEX_INTERPRET_MODE_TRIANGLE_FAN      = GL_TRIANGLE_FAN,
        VERTEX_INTERPRET_MODE_LINES             = GL_LINES,
        VERTEX_INTERPRET_MODE_LINE_STRIP        = GL_LINE_STRIP,
    };

    enum POLYGON_FILL_MODE
    {
        POLYGON_FILL_MODE_OUTLINE = GL_LINE,
        POLYGON_FILL_MODE_FILL    = GL_FILL,
    };

    static OpenGLShader * mShader;
    static float COLOR_BLUE[];
    static float COLOR_RED[];
    static float COLOR_GREEN[];
    static float COLOR_YELLOW[];
    static float COLOR_ORANGE[];
    static float COLOR_PURPLE[];
    static float COLOR_DARK_GREEN[];
    static float COLOR_PINK[];
    static float COLOR_GREY[];
    static float COLOR_BLACK[];
    static float COLOR_WHITE[];

    OpenGLPrimitive(float rgb[]=NULL, const char texture_filename[]=NULL);
    virtual ~OpenGLPrimitive();

    virtual void initializeVerticies(std::vector<OpenGLVertexAttributes> * verticies,
                                     const float rgb[],
                                     GLuint * drawing_mode,
                                     GLuint * polygon_mode,
                                     float * mColorTextureRatio) = 0;

    void finishInitializing(void);

    void setColorToTextureRatio(float ratio);

    virtual void drawWithShaderAndTransform(glm::mat4 transform) final;

    void drawNormalsWithTransform(glm::mat4 transform);

    virtual std::vector<OpenGLVertexAttributes> * getPrismEdge(void)
    {
        return NULL;
    }
};
#endif /* OpenGLPrimitive */