OpenSubdiv/examples/farViewer/gl_mesh.cpp

987 lines
31 KiB
C++
Raw Normal View History

//
// Copyright 2013 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
// names, trademarks, service marks, or product names of the Licensor
// and its affiliates, except as required to comply with Section 4(c) of
// the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#include "gl_mesh.h"
#include "gl_fontutils.h"
#include "../common/patchColors.h"
#include <cassert>
#include <cstdlib>
#include <cstring>
//------------------------------------------------------------------------------
// color palettes
static float g_solidColor[4] = {1.0f, 1.0f, 1.0f, 1.0f},
g_ambientColor[4] = {0.1f, 0.1f, 0.1f, 1.0f};
static float g_levelColors[10][4] = {{1.0f, 1.0f, 1.0f},
{1.0f, 1.0f, 0.0f},
{1.0f, 0.5f, 0.0f},
{0.8f, 0.0f, 0.0f},
{0.0f, 1.0f, 0.5f},
{0.0f, 1.0f, 1.0f},
{0.0f, 0.5f, 1.0f},
{0.0f, 0.5f, 0.5f},
{0.5f, 0.0f, 1.0f},
{1.0f, 0.5f, 1.0f}};
static float g_parentTypeColors[4][4] = {{0.9f, 0.9f, 0.9f},
{0.4f, 0.8f, 0.4f},
{0.8f, 0.8f, 0.4f},
{0.8f, 0.4f, 0.4f}};
//------------------------------------------------------------------------------
void
GLMesh::setSolidColor(float * color) {
color[0] = _diffuseColor[0];
color[1] = _diffuseColor[1];
color[2] = _diffuseColor[2];
}
void
GLMesh::setColorByLevel(int level, float * color) {
color[0] = g_levelColors[level][0];
color[1] = g_levelColors[level][1];
color[2] = g_levelColors[level][2];
}
void
GLMesh::setColorBySharpness(float sharpness, float * color) {
// 0.0 2.0 4.0
// green --- yellow --- red
color[0] = std::min(1.0f, sharpness * 0.5f);
color[1] = std::min(1.0f, 2.0f - sharpness * 0.5f);
color[2] = 0;
}
//------------------------------------------------------------------------------
static GLuint g_faceTexture=0;
static GLuint
getFaceTexture() {
#include "face_texture.h"
if (not g_faceTexture) {
glGenTextures(1, &g_faceTexture);
glBindTexture(GL_TEXTURE_2D, g_faceTexture);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, FACE_TEXTURE_WIDTH,
FACE_TEXTURE_HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, face_texture);
}
return g_faceTexture;
}
//------------------------------------------------------------------------------
GLMesh::GLMesh() : _TBOfaceColors(0) {
for (int i=0; i<COMP_NUM_COMPONENTS; ++i) {
_VAO[i]=0;
_VBO[i]=0;
_EAO[i]=0;
_numComps[i] = 0;
}
memcpy(_ambientColor, g_ambientColor, sizeof(float)*4);
memcpy(_diffuseColor, g_solidColor, sizeof(float)*4);
}
GLMesh::~GLMesh() {
for (int i=0; i<COMP_NUM_COMPONENTS; ++i) {
if (_VAO[i]) {
glDeleteVertexArrays(1, &_VAO[i]);
}
if (_VBO[i]) {
glDeleteBuffers(1, &_VBO[i]);
}
if (_EAO[i]) {
glDeleteBuffers(1, &_EAO[i]);
}
}
}
//------------------------------------------------------------------------------
void
GLMesh::initializeVertexComponentBuffer(float const * vertData, int nverts) {
std::vector<float> & vbo = _vbo[COMP_VERT];
vbo.resize(nverts * 6);
std::vector<int> & eao = _eao[COMP_VERT];
eao.resize(nverts);
for (int vert=0; vert<nverts; ++vert) {
// copy positions
memcpy(&vbo[vert*6], &vertData[vert*3], 3*sizeof(float));
// populate EAO
eao[vert] = vert;
}
}
//------------------------------------------------------------------------------
void
GLMesh::Initialize(Options /* options */,
int nverts, int nfaces, int * vertsperface, int * faceverts,
float const * vertexData) {
{ // vertex color component ----------------------------
initializeVertexComponentBuffer(vertexData, nverts);
std::vector<float> & vbo = _vbo[COMP_VERT];
for (int vert=0, ofs=3; vert<nverts; ++vert, ofs+=6) {
setSolidColor(&vbo[ofs]);
}
}
{ // edge color component ------------------------------
int nedges = nfaces;
std::vector<float> & vbo = _vbo[COMP_EDGE];
vbo.resize(nedges * 2 * 6);
std::vector<int> & eao = _eao[COMP_EDGE];
eao.resize(nedges*2);
for (int edge=0; edge<nedges; ++edge) {
// edge mode expects faces with 2 verts (aka edges) as input
assert(vertsperface[edge]==2);
eao[edge*2 ] = edge*2;
eao[edge*2+1] = edge*2+1;
int const * verts = &faceverts[edge*2];
float * v0 = &vbo[edge*2*6],
* v1 = v0+6;
// copy position
memcpy(v0, vertexData + verts[0]*3, sizeof(float)*3);
memcpy(v1, vertexData + verts[1]*3, sizeof(float)*3);
// default to solid color
setSolidColor(v0+3);
setSolidColor(v1+3);
}
}
{ // face component ------------------------------------
std::vector<float> & vbo = _vbo[COMP_FACE];
vbo.resize(nverts * 3);
memcpy(&vbo[0], vertexData, nverts*sizeof(float)*3);
int nfaceverts = 0;
for (int i=0; i<nfaces; ++i) {
nfaceverts += vertsperface[i];
}
std::vector<int> & eao = _eao[COMP_FACE];
eao.resize(nfaceverts);
_faceColors.resize(nfaces*4);
int const * fverts = faceverts;
for (int face=0, ofs=0; face<nfaces; ++face) {
int nverts = vertsperface[face];
for (int vert=0; vert<nverts; ++vert) {
eao[ofs++] = fverts[vert];
}
setSolidColor(&_faceColors[face*4]);
fverts += nverts;
}
}
_numComps[COMP_FACE] = (int)_eao[COMP_FACE].size();
_numComps[COMP_EDGE] = (int)_eao[COMP_EDGE].size();
_numComps[COMP_VERT] = (int)_eao[COMP_VERT].size();
InitializeDeviceBuffers();
}
//------------------------------------------------------------------------------
void
GLMesh::Initialize(Options options, TopologyRefiner const & refiner,
PatchTable const * patchTable, float const * vertexData) {
if (patchTable) {
initializeBuffers(options, refiner, *patchTable, vertexData);
} else {
initializeBuffers(options, refiner, vertexData);
}
_numComps[COMP_FACE] = (int)_eao[COMP_FACE].size();
_numComps[COMP_EDGE] = (int)_eao[COMP_EDGE].size();
_numComps[COMP_VERT] = (int)_eao[COMP_VERT].size();
//InitializeDeviceBuffers();
}
//------------------------------------------------------------------------------
void
GLMesh::initializeBuffers(Options options,
TopologyRefiner const & refiner, float const * vertexData) {
typedef OpenSubdiv::Far::ConstIndexArray IndexArray;
int maxlevel = refiner.GetMaxLevel();
OpenSubdiv::Far::TopologyLevel const & refLastLevel = refiner.GetLevel(maxlevel);
2015-05-22 03:42:29 +00:00
int nverts = refLastLevel.GetNumVertices(),
nedges = refLastLevel.GetNumEdges(),
nfaces = refLastLevel.GetNumFaces(),
firstvert = 0;
for (int i=0; i<maxlevel; ++i) {
firstvert += refiner.GetLevel(i).GetNumVertices();
}
float const * vertData = &vertexData[firstvert*3];
{ // vertex color component ----------------------------
initializeVertexComponentBuffer(vertData, nverts);
std::vector<float> & vbo = _vbo[COMP_VERT];
// set colors
if (options.vertColorMode==VERTCOLOR_BY_LEVEL) {
for (int level=0, ofs=3; level<=maxlevel; ++level) {
for (int vert=0; vert<refiner.GetLevel(level).GetNumVertices(); ++vert, ofs+=6) {
setColorByLevel(level, &vbo[ofs]);
}
}
} else if (options.vertColorMode==VERTCOLOR_BY_SHARPNESS) {
for (int vert=0, ofs=3; vert<refLastLevel.GetNumVertices(); ++vert, ofs+=6) {
setColorBySharpness(refLastLevel.GetVertexSharpness(vert), &vbo[ofs]);
}
} else if (options.vertColorMode==VERTCOLOR_BY_PARENT_TYPE) {
int ofs=3;
if (maxlevel>0) {
OpenSubdiv::Far::TopologyLevel const & refPrevLevel = refiner.GetLevel(maxlevel-1);
for (int vert=0; vert<refPrevLevel.GetNumFaces(); ++vert, ofs+=6) {
memcpy(&vbo[ofs], g_parentTypeColors[1], sizeof(float)*3);
}
for (int vert=0; vert<refPrevLevel.GetNumEdges(); ++vert, ofs+=6) {
memcpy(&vbo[ofs], g_parentTypeColors[2], sizeof(float)*3);
}
for (int vert=0; vert<refPrevLevel.GetNumVertices(); ++vert, ofs+=6) {
memcpy(&vbo[ofs], g_parentTypeColors[3], sizeof(float)*3);
}
} else {
for (int vert=0; vert<refLastLevel.GetNumVertices(); ++vert, ofs+=6) {
memcpy(&vbo[ofs], g_parentTypeColors[0], sizeof(float)*3);
}
}
} else {
for (int vert=0, ofs=3; vert<nverts; ++vert) {
setSolidColor(&vbo[ofs+=6]);
}
}
}
{ // edge color component ------------------------------
std::vector<float> & vbo = _vbo[COMP_EDGE];
vbo.resize(nedges * 2 * 6);
std::vector<int> & eao = _eao[COMP_EDGE];
eao.resize(nedges*2);
for (int edge=0; edge<nedges; ++edge) {
eao[edge*2 ] = edge*2;
eao[edge*2+1] = edge*2+1;
IndexArray const verts = refLastLevel.GetEdgeVertices(edge);
float * v0 = &vbo[edge*2*6],
* v1 = v0+6;
// copy position
memcpy(v0, vertData + verts[0]*3, sizeof(float)*3);
memcpy(v1, vertData + verts[1]*3, sizeof(float)*3);
// set colors
if (options.edgeColorMode==EDGECOLOR_BY_LEVEL) {
setColorByLevel(maxlevel, v0+3);
setColorByLevel(maxlevel, v1+3);
} else if (options.edgeColorMode==EDGECOLOR_BY_SHARPNESS) {
float sharpness = refLastLevel.GetEdgeSharpness(edge);
setColorBySharpness(sharpness, v0+3);
setColorBySharpness(sharpness, v1+3);
} else {
// default to solid color
setSolidColor(v0+3);
setSolidColor(v1+3);
}
}
}
{ // face component ------------------------------------
std::vector<float> & vbo = _vbo[COMP_FACE];
vbo.resize(nverts * 3);
memcpy(&vbo[0], vertData, nverts*sizeof(float)*3);
int nfaceverts = refLastLevel.GetNumFaceVertices();
std::vector<int> & eao = _eao[COMP_FACE];
eao.resize(nfaceverts);
_faceColors.resize(nfaces*4);
for (int face=0, ofs=0; face<nfaces; ++face) {
IndexArray fverts = refLastLevel.GetFaceVertices(face);
for (int vert=0; vert<fverts.size(); ++vert) {
eao[ofs++] = fverts[vert];
}
setSolidColor(&_faceColors[face*4]);
}
}
}
//------------------------------------------------------------------------------
inline void
setEdge(std::vector<float> & vbo, int edge, float const * vertData, int v0, int v1, float const * color) {
float * dst0 = &vbo[edge*2*6],
* dst1 = dst0+6;
memcpy(dst0, vertData + (v0*3), sizeof(float)*3);
memcpy(dst1, vertData + (v1*3), sizeof(float)*3);
memcpy(dst0+3, color, sizeof(float)*3);
memcpy(dst1+3, color, sizeof(float)*3);
}
//------------------------------------------------------------------------------
void
GLMesh::InitializeFVar(Options options, TopologyRefiner const & refiner,
PatchTable const * patchTable, int channel, int tessFactor, float const * fvarData) {
int nverts = refiner.GetNumFVarValuesTotal(channel);
{ // vertex color component ----------------------------
initializeVertexComponentBuffer(fvarData, nverts);
std::vector<float> & vbo = _vbo[COMP_VERT];
if (options.vertColorMode==VERTCOLOR_BY_LEVEL) {
for (int level=0, ofs=3; level<=refiner.GetMaxLevel(); ++level) {
for (int vert=0; vert<refiner.GetLevel(level).GetNumFVarValues(channel); ++vert, ofs+=6) {
assert(ofs<(int)vbo.size());
setColorByLevel(level, &vbo[ofs]);
}
}
} else {
for (int vert=0, ofs=3; vert<nverts; ++vert) {
setSolidColor(&vbo[ofs+=6]);
}
}
}
if (tessFactor>0) {
// edge color component ------------------------------
int npatches = patchTable->GetNumPatchesTotal(),
nvertsperpatch = (tessFactor) * (tessFactor),
nedgesperpatch = (tessFactor-1) * (tessFactor*2+tessFactor-1),
//nverts = npatches * nvertsperpatch,
nedges = npatches * nedgesperpatch;
std::vector<float> & vbo = _vbo[COMP_EDGE];
vbo.resize(nedges * 2 * 6);
std::vector<int> & eao = _eao[COMP_EDGE];
eao.reserve(nedges*2);
// default to solid color
float const * color=0;
// wireframe indices
int * basisedges = (int *)alloca(2*nedgesperpatch*sizeof(int)),
* ptr = basisedges;
for (int i=0; i<(tessFactor-1); ++i) { // tess pattern :
for (int j=0; j<(tessFactor-1); ++j) { //
*ptr++ = i*tessFactor + j; // o---o---o--
*ptr++ = i*tessFactor + j+1; // |\ |\ |
// | \ | \ |
*ptr++ = i * tessFactor + j; // | \| \|
*ptr++ = (i+1) * tessFactor + j; // o---o---o--
// |\ |\ |
*ptr++ = i * tessFactor + j; // | \ | \ |
*ptr++ = (i+1) * tessFactor + j+1; // | \| \|
} // o---o---o--
*ptr++ = (i+1) * tessFactor - 1; // | | |
*ptr++ = (i+2) * tessFactor - 1;
*ptr++ = tessFactor * (tessFactor-1) + i;
*ptr++ = tessFactor * (tessFactor-1) + i+1;
}
OpenSubdiv::Far::PatchTable::PatchHandle handle;
for (int patch=0, offset=0; patch<npatches; ++patch) {
if (options.edgeColorMode==EDGECOLOR_BY_PATCHTYPE) {
handle.patchIndex = patch;
OpenSubdiv::Far::PatchDescriptor::Type type =
patchTable->GetFVarPatchType(channel, handle);
if (OpenSubdiv::Far::PatchDescriptor::IsAdaptive(type)) {
color = getAdaptivePatchColor(
OpenSubdiv::Far::PatchDescriptor(type));
} else {
static float quadColor[3] = { 1.0f, 1.0f, 0.0f };
color = quadColor;
}
}
assert(color);
for (int edge=0; edge<nedgesperpatch; ++edge) {
eao.push_back((int)eao.size());
eao.push_back((int)eao.size());
int v0 = offset + basisedges[edge*2],
v1 = offset + basisedges[edge*2+1];
setEdge(vbo, patch*nedgesperpatch+edge, fvarData, v0, v1, color);
}
offset += nvertsperpatch;
}
}
_numComps[COMP_FACE] = (int)_eao[COMP_FACE].size();
_numComps[COMP_EDGE] = (int)_eao[COMP_EDGE].size();
_numComps[COMP_VERT] = (int)_eao[COMP_VERT].size();
InitializeDeviceBuffers();
}
//------------------------------------------------------------------------------
// returns the number of edges in a patch with 'numCVs'
inline int
getNumEdges(int numCVs) {
switch (numCVs) {
case 4: return 4;
// case 9: return 12;
case 9: return 4;
// case 12: return 17;
case 12: return 4;
// case 16: return 24;
case 16: return 4;
case 20: return 4;
default:
assert(0);
}
return -1;
}
//------------------------------------------------------------------------------
int const *
getEdgeList(int numCVs) {
/*
static int edgeList4[] = { 0, 1, 1, 2, 2, 3, 3, 0 };
static int edgeList9[] = { 0, 1, 1, 4,
3, 2, 2, 5,
8, 7, 7, 6,
0, 3, 3, 8,
1, 2, 2, 7,
4, 5, 5, 6 };
static int edgeList12[] = { 4, 0, 0, 3, 3, 5,
11, 1, 1, 2, 2, 6,
10, 9, 9, 8, 8, 7,
4, 11, 11, 10, 0, 1,
1, 9, 3, 2, 2, 8,
5, 6, 6, 7 };
static int edgeList16[] = { 4, 15, 15, 14, 14, 13,
5, 0, 0, 3, 3, 12,
6, 1, 1, 2, 2, 11,
7, 8, 8, 9, 9, 10,
4, 5, 5, 6, 6, 7,
15, 0, 0, 1, 1, 8,
14, 3, 3, 2, 2, 9,
13, 12, 12, 11, 11, 10 };
*/
static int edgeList4of16[] = { 5, 6, 6, 10, 10, 9, 9, 5 };
static int edgeList4of20[] = { 0, 5, 5, 10, 10, 15, 15, 0 };
switch (numCVs) {
case 4: return edgeList4of20; break;
case 16: return edgeList4of16; break;
case 20: return edgeList4of20; break;
default:
assert(0);
}
return 0;
}
inline int
getRingSize(OpenSubdiv::Far::PatchDescriptor desc) {
if (desc.GetType()==OpenSubdiv::Far::PatchDescriptor::GREGORY_BASIS) {
return 4;
} else {
return desc.GetNumControlVertices();
}
}
//------------------------------------------------------------------------------
void
GLMesh::initializeBuffers(Options options, TopologyRefiner const & refiner,
PatchTable const & patchTable, float const * vertexData) {
int nverts = refiner.GetNumVerticesTotal();
{ // vertex color component ----------------------------
initializeVertexComponentBuffer(vertexData, nverts);
std::vector<float> & vbo = _vbo[COMP_VERT];
if (options.vertColorMode==VERTCOLOR_BY_LEVEL) {
for (int level=0, ofs=3; level<=refiner.GetMaxLevel(); ++level) {
for (int vert=0; vert<refiner.GetLevel(level).GetNumVertices(); ++vert, ofs+=6) {
assert(ofs<(int)vbo.size());
setColorByLevel(level, &vbo[ofs]);
}
}
} else {
for (int vert=0, ofs=3; vert<nverts; ++vert) {
setSolidColor(&vbo[ofs+=6]);
}
}
}
typedef OpenSubdiv::Far::PatchDescriptor Descriptor;
{ // edge color component ------------------------------
int nedges = 0;
for (int array=0; array<(int)patchTable.GetNumPatchArrays(); ++array) {
int ncvs = getRingSize(patchTable.GetPatchArrayDescriptor(array));
nedges += patchTable.GetNumPatches(array) * getNumEdges(ncvs);
}
std::vector<float> & vbo = _vbo[COMP_EDGE];
vbo.resize(nedges * 2 * 6);
std::vector<int> & eao = _eao[COMP_EDGE];
eao.resize(nedges*2);
// default to solid color
float solidColor[3];
setSolidColor(solidColor);
float const * color=solidColor;
for (int array=0, edge=0; array<(int)patchTable.GetNumPatchArrays(); ++array) {
OpenSubdiv::Far::PatchDescriptor desc =
patchTable.GetPatchArrayDescriptor(array);
if (options.edgeColorMode==EDGECOLOR_BY_PATCHTYPE) {
color = getAdaptivePatchColor(desc);
}
int ncvs = getRingSize(desc);
for (int patch=0; patch<patchTable.GetNumPatches(array); ++patch) {
OpenSubdiv::Far::ConstIndexArray const cvs =
patchTable.GetPatchVertices(array, patch);
int const * edgeList=getEdgeList(ncvs);
for (int k=0; k<getNumEdges(cvs.size()); ++k, ++edge) {
eao[edge*2 ] = edge*2;
eao[edge*2+1] = edge*2+1;
int v0 = cvs[edgeList[k*2]],
v1 = cvs[edgeList[k*2+1]];
setEdge(vbo, edge, vertexData, v0, v1, color);
}
}
}
}
{ // face color component ------------------------------
int nfaces = patchTable.GetNumPatchesTotal();
std::vector<float> & vbo = _vbo[COMP_FACE];
vbo.resize(nverts*3);
memcpy(&vbo[0], vertexData, nverts*sizeof(float)*3);
std::vector<int> & eao = _eao[COMP_FACE];
eao.resize(nfaces*4);
_faceColors.resize(nfaces*4, 1.0f);
// default to solid color
for (int array=0, face=0; array<(int)patchTable.GetNumPatchArrays(); ++array) {
OpenSubdiv::Far::PatchDescriptor desc =
patchTable.GetPatchArrayDescriptor(array);
//int ncvs = getRingSize(desc);
for (int patch=0; patch<patchTable.GetNumPatches(array); ++patch, ++face) {
OpenSubdiv::Far::ConstIndexArray const cvs =
patchTable.GetPatchVertices(array, patch);
if (desc.GetType()==Descriptor::REGULAR) {
eao[face*4 ] = cvs[ 5];
eao[face*4+1] = cvs[ 6];
eao[face*4+2] = cvs[10];
eao[face*4+3] = cvs[ 9];
} else {
memcpy(&eao[face*4], cvs.begin(), 4*sizeof(OpenSubdiv::Far::Index));
}
if (options.faceColorMode==FACECOLOR_BY_PATCHTYPE) {
float const * color = getAdaptivePatchColor(desc);
memcpy(&_faceColors[face*4], color, 4*sizeof(float));
} else {
setSolidColor(&_faceColors[face*4]);
}
}
}
}
}
//------------------------------------------------------------------------------
template <typename T> static GLuint
createTextureBuffer(T const &data, GLint format, int offset=0) {
GLuint buffer = 0, texture = 0;
glGenTextures(1, &texture);
glGenBuffers(1, &buffer);
glBindBuffer(GL_ARRAY_BUFFER, buffer);
glBufferData(GL_ARRAY_BUFFER,
(data.size()-offset)*sizeof(typename T::value_type),
&data[offset], GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindTexture(GL_TEXTURE_BUFFER, texture);
glTexBuffer(GL_TEXTURE_BUFFER, format, buffer);
glBindTexture(GL_TEXTURE_BUFFER, 0);
glDeleteBuffers(1, &buffer);
GLUtils::CheckGLErrors("createTextureBuffer");
return texture;
}
//------------------------------------------------------------------------------
void
GLMesh::InitializeDeviceBuffers() {
// copy buffers to device
for (int i=0; i<COMP_NUM_COMPONENTS; ++i) {
if (not _VAO[i]) {
glGenVertexArrays(1, &_VAO[i]);
}
glBindVertexArray(_VAO[i]);
if (not _vbo[i].empty()) {
if (not _VBO[i]) {
glGenBuffers(1, &_VBO[i]);
}
glBindBuffer(GL_ARRAY_BUFFER, _VBO[i]);
glBufferData(GL_ARRAY_BUFFER, _vbo[i].size()*sizeof(GLfloat), &_vbo[i][0], GL_STATIC_DRAW);
glEnableVertexAttribArray(0);
int numelements = (i==COMP_FACE) ? 3 : 6;
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, numelements*sizeof(GLfloat), 0);
if (i==COMP_FACE) {
// face vbo has no color component
glDisableVertexAttribArray(1);
} else {
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6*sizeof(GLfloat), (void*)12);
}
}
if (not _eao[i].empty()) {
if (not _EAO[i]) {
glGenBuffers(1, &_EAO[i]);
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _EAO[i]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, _eao[i].size()*sizeof(int), &_eao[i][0], GL_STATIC_DRAW);
}
GLUtils::CheckGLErrors("init");
}
if (not _faceColors.empty()) {
_TBOfaceColors = createTextureBuffer(_faceColors, GL_RGBA32F);
}
glBindVertexArray(0);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
clearBuffers();
}
//------------------------------------------------------------------------------
void
GLMesh::clearBuffers() {
for (int i=0; i<COMP_NUM_COMPONENTS; ++i) {
_vbo[i].clear();
_eao[i].clear();
}
}
//------------------------------------------------------------------------------
static const char * g_simpleShaderSrc =
#include "simpleShader.gen.h"
;
static const char * g_faceShaderSrc =
#include "faceShader.gen.h"
;
GLuint g_simpleProgram=0,
g_faceProgram=0;
// Update and bind transform state
static void
bindProgram( char const * shaderSource,
GLuint * program,
GLuint transformUB,
GLuint lightingUB,
bool geometry) {
assert(program);
GLuint uboIndex=GL_INVALID_INDEX,
transformBinding=0,
lightingBinding=1;
// Update and bind transform state
if (not *program) {
*program = glCreateProgram();
static char const versionStr[] = "#version 330\n",
vtxDefineStr[] = "#define VERTEX_SHADER\n",
geoDefineStr[] = "#define GEOMETRY_SHADER\n",
fragDefineStr[] = "#define FRAGMENT_SHADER\n";
std::string vsSrc = std::string(versionStr) + vtxDefineStr + shaderSource,
gsSrc = std::string(versionStr) + geoDefineStr + shaderSource,
fsSrc = std::string(versionStr) + fragDefineStr + shaderSource;
GLuint vertexShader =
GLUtils::CompileShader(GL_VERTEX_SHADER, vsSrc.c_str()),
geometryShader = geometry ?
GLUtils::CompileShader(GL_GEOMETRY_SHADER, gsSrc.c_str()) : 0,
fragmentShader =
GLUtils::CompileShader(GL_FRAGMENT_SHADER, fsSrc.c_str());
glAttachShader(*program, vertexShader);
if (geometry) {
glAttachShader(*program, geometryShader);
}
glAttachShader(*program, fragmentShader);
glLinkProgram(*program);
GLint status;
glGetProgramiv(*program, GL_LINK_STATUS, &status);
if (status == GL_FALSE) {
GLint infoLogLength;
glGetProgramiv(*program, GL_INFO_LOG_LENGTH, &infoLogLength);
char *infoLog = new char[infoLogLength];
glGetProgramInfoLog(*program, infoLogLength, NULL, infoLog);
printf("%s\n", infoLog);
delete[] infoLog;
exit(1);
}
uboIndex = glGetUniformBlockIndex(*program, "Transform");
if (uboIndex != GL_INVALID_INDEX) {
glUniformBlockBinding(*program, uboIndex, transformBinding);
}
uboIndex = glGetUniformBlockIndex(*program, "Lighting");
if (uboIndex != GL_INVALID_INDEX) {
glUniformBlockBinding(*program, uboIndex, lightingBinding);
}
}
glUseProgram(*program);
if (transformUB) {
glBindBufferBase(GL_UNIFORM_BUFFER, transformBinding, transformUB);
}
if (lightingUB) {
glBindBufferBase(GL_UNIFORM_BUFFER, lightingBinding, lightingUB);
}
}
//------------------------------------------------------------------------------
void
GLMesh::Draw(Component comp, GLuint transformUB, GLuint lightingUB) {
if (comp==COMP_VERT) {
bindProgram(g_simpleShaderSrc, &g_simpleProgram, transformUB, lightingUB, false);
glBindVertexArray(_VAO[COMP_VERT]);
glPointSize(4.0f);
glDrawElements(GL_POINTS, _numComps[COMP_VERT], GL_UNSIGNED_INT, (void *)0);
glPointSize(1.0f);
} else if (comp==COMP_EDGE) {
bindProgram(g_simpleShaderSrc, &g_simpleProgram, transformUB, lightingUB, false);
glBindVertexArray(_VAO[COMP_EDGE]);
glDrawElements(GL_LINES, _numComps[COMP_EDGE], GL_UNSIGNED_INT, (void *)0);
} else if (comp==COMP_FACE) {
glEnable(GL_CULL_FACE);
bindProgram(g_faceShaderSrc, &g_faceProgram, transformUB, lightingUB, true);
{ // set shader parameters
GLuint diffuseColor = glGetUniformLocation(g_faceProgram, "diffuseColor");
glProgramUniform4f(g_faceProgram, diffuseColor, _diffuseColor[0],
_diffuseColor[1], _diffuseColor[2], _diffuseColor[3]);
GLuint faceColors = glGetUniformLocation(g_faceProgram, "faceColors");
glUniform1i(faceColors, 0); // GL_TEXTURE0
GLuint faceTexture = glGetUniformLocation(g_faceProgram, "faceTexture");
glUniform1i(faceTexture, 1); // GL_TEXTURE1
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_BUFFER, _TBOfaceColors);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, getFaceTexture());
}
glBindVertexArray(_VAO[COMP_FACE]);
glDrawElements(GL_LINES_ADJACENCY, _numComps[COMP_FACE], GL_UNSIGNED_INT, (void *)0);
glDisable(GL_CULL_FACE);
}
}
//------------------------------------------------------------------------------
void
GLMesh::SetDiffuseColor(float r, float g, float b, float a) {
_diffuseColor[0] = r;
_diffuseColor[1] = g;
_diffuseColor[2] = b;
_diffuseColor[3] = a;
}
//------------------------------------------------------------------------------
void
GLMesh::SetFaceColor(int face, float r, float g, float b, float a) {
assert( (face*4) < (int)_faceColors.size() );
float * color = &_faceColors[face*4];
color[0] = r;
color[1] = g;
color[2] = b;
color[3] = a;
}
//------------------------------------------------------------------------------