src/model.cpp

   1 #include "model.hpp"
   2
   3 #include <iostream>
   4
   5
   6 namespace blank {
   7
   8 Model::Model()
   9 : vertices()
  10 , colors()
  11 , normals()
  12 , handle{}
  13 , dirty(false) {
  14         glGenBuffers(ATTRIB_COUNT, handle);
  15 }
  16
  17 Model::~Model() {
  18         glDeleteBuffers(ATTRIB_COUNT, handle);
  19 }
  20
  21
  22 void Model::Clear() {
  23         vertices.clear();
  24         colors.clear();
  25         normals.clear();
  26         Invalidate();
  27 }
  28
  29 void Model::Reserve(int s) {
  30         vertices.reserve(s);
  31         colors.reserve(s);
  32         normals.reserve(s);
  33 }
  34
  35
  36 void Model::Update() {
  37         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_VERTEX]);
  38         glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW);
  39
  40 #ifndef NDEBUG
  41         if (colors.size() < vertices.size()) {
  42                 std::cerr << "Model: not enough colors!" << std::endl;
  43                 colors.resize(vertices.size(), { 1, 0, 1 });
  44         }
  45 #endif
  46         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_COLOR]);
  47         glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), colors.data(), GL_STATIC_DRAW);
  48
  49 #ifndef NDEBUG
  50         if (normals.size() < vertices.size()) {
  51                 std::cerr << "Model: not enough normals!" << std::endl;
  52                 normals.resize(vertices.size(), { 0, 1, 0 });
  53         }
  54 #endif
  55         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_NORMAL]);
  56         glBufferData(GL_ARRAY_BUFFER, normals.size() * sizeof(glm::vec3), normals.data(), GL_STATIC_DRAW);
  57
  58         dirty = false;
  59 }
  60
  61
  62 void Model::Draw() {
  63         if (dirty) {
  64                 Update();
  65         }
  66
  67         glEnableVertexAttribArray(ATTRIB_VERTEX);
  68         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_VERTEX]);
  69         glVertexAttribPointer(
  70                 ATTRIB_VERTEX, // location (for shader)
  71                 3,             // size
  72                 GL_FLOAT,      // type
  73                 GL_FALSE,      // normalized
  74                 0,             // stride
  75                 nullptr        // offset
  76         );
  77
  78         glEnableVertexAttribArray(ATTRIB_COLOR);
  79         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_COLOR]);
  80         glVertexAttribPointer(
  81                 ATTRIB_COLOR,  // location (for shader)
  82                 3,             // size
  83                 GL_FLOAT,      // type
  84                 GL_FALSE,      // normalized
  85                 0,             // stride
  86                 nullptr        // offset
  87         );
  88
  89         glEnableVertexAttribArray(ATTRIB_NORMAL);
  90         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_NORMAL]);
  91         glVertexAttribPointer(
  92                 ATTRIB_NORMAL, // location (for shader)
  93                 3,             // size
  94                 GL_FLOAT,      // type
  95                 GL_FALSE,      // normalized
  96                 0,             // stride
  97                 nullptr        // offset
  98         );
  99
 100         glDrawArrays(
 101                 GL_TRIANGLES,   // how
 102                 0,              // start
 103                 vertices.size() // len
 104         );
 105
 106         glDisableVertexAttribArray(ATTRIB_NORMAL);
 107         glDisableVertexAttribArray(ATTRIB_COLOR);
 108         glDisableVertexAttribArray(ATTRIB_VERTEX);
 109 }
 110
 111
 112 OutlineModel::OutlineModel()
 113 : vertices()
 114 , colors()
 115 , handle{}
 116 , dirty(false) {
 117         glGenBuffers(ATTRIB_COUNT, handle);
 118 }
 119
 120 OutlineModel::~OutlineModel() {
 121         glDeleteBuffers(ATTRIB_COUNT, handle);
 122 }
 123
 124
 125 void OutlineModel::Clear() {
 126         vertices.clear();
 127         colors.clear();
 128         Invalidate();
 129 }
 130
 131 void OutlineModel::Reserve(int s) {
 132         vertices.reserve(s);
 133         colors.reserve(s);
 134 }
 135
 136
 137 void OutlineModel::Update() {
 138         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_VERTEX]);
 139         glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(glm::vec3), vertices.data(), GL_STATIC_DRAW);
 140
 141 #ifndef NDEBUG
 142         if (colors.size() < vertices.size()) {
 143                 std::cerr << "OutlineModel: not enough colors!" << std::endl;
 144                 colors.resize(vertices.size(), { 1, 0, 1 });
 145         }
 146 #endif
 147         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_COLOR]);
 148         glBufferData(GL_ARRAY_BUFFER, colors.size() * sizeof(glm::vec3), colors.data(), GL_STATIC_DRAW);
 149
 150         dirty = false;
 151 }
 152
 153
 154 void OutlineModel::Draw() {
 155         if (dirty) {
 156                 Update();
 157         }
 158
 159         glEnableVertexAttribArray(ATTRIB_VERTEX);
 160         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_VERTEX]);
 161         glVertexAttribPointer(
 162                 ATTRIB_VERTEX, // location (for shader)
 163                 3,             // size
 164                 GL_FLOAT,      // type
 165                 GL_FALSE,      // normalized
 166                 0,             // stride
 167                 nullptr        // offset
 168         );
 169
 170         glEnableVertexAttribArray(ATTRIB_COLOR);
 171         glBindBuffer(GL_ARRAY_BUFFER, handle[ATTRIB_COLOR]);
 172         glVertexAttribPointer(
 173                 ATTRIB_COLOR,  // location (for shader)
 174                 3,             // size
 175                 GL_FLOAT,      // type
 176                 GL_FALSE,      // normalized
 177                 0,             // stride
 178                 nullptr        // offset
 179         );
 180
 181         glLineWidth(2.0f);
 182
 183         glDrawArrays(
 184                 GL_LINES,       // how
 185                 0,              // start
 186                 vertices.size() // len
 187         );
 188
 189         glDisableVertexAttribArray(ATTRIB_COLOR);
 190         glDisableVertexAttribArray(ATTRIB_VERTEX);
 191 }
 192
 193 }