mirror of
https://github.com/overte-org/overte.git
synced 2025-04-14 07:47:30 +02:00
Merge pull request #3953 from ZappoMan/someCleanup
Remove some dead code from Voxel rendering
This commit is contained in:
Philip Rosedale
commit
8505aaceba
14 changed files with 167 additions and 2627 deletions
|
|
@ -1,21 +0,0 @@
|
|||
#version 120
|
||||
|
||||
//
|
||||
// passthrough.vert
|
||||
// vertex shader
|
||||
//
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
attribute float voxelSizeIn;
|
||||
varying float voxelSize;
|
||||
|
||||
void main(void) {
|
||||
gl_FrontColor = gl_Color;
|
||||
gl_Position = gl_Vertex; // don't call ftransform(), because we do projection in geometry shader
|
||||
voxelSize = voxelSizeIn;
|
||||
}
|
||||
|
|
@ -1,174 +0,0 @@
|
|||
#version 120
|
||||
|
||||
//
|
||||
// point_size.vert
|
||||
// vertex shader
|
||||
//
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
attribute float voxelSizeIn;
|
||||
varying float voxelSize;
|
||||
|
||||
uniform float viewportWidth;
|
||||
uniform float viewportHeight;
|
||||
uniform vec3 cameraPosition;
|
||||
|
||||
// Bit codes for faces
|
||||
const int NONE = 0;
|
||||
const int RIGHT = 1;
|
||||
const int LEFT = 2;
|
||||
const int BOTTOM = 4;
|
||||
const int BOTTOM_RIGHT = BOTTOM + RIGHT;
|
||||
const int BOTTOM_LEFT = BOTTOM + LEFT;
|
||||
const int TOP = 8;
|
||||
const int TOP_RIGHT = TOP + RIGHT;
|
||||
const int TOP_LEFT = TOP + LEFT;
|
||||
const int NEAR = 16;
|
||||
const int NEAR_RIGHT = NEAR + RIGHT;
|
||||
const int NEAR_LEFT = NEAR + LEFT;
|
||||
const int NEAR_BOTTOM = NEAR + BOTTOM;
|
||||
const int NEAR_BOTTOM_RIGHT = NEAR + BOTTOM + RIGHT;
|
||||
const int NEAR_BOTTOM_LEFT = NEAR + BOTTOM + LEFT;
|
||||
const int NEAR_TOP = NEAR + TOP;
|
||||
const int NEAR_TOP_RIGHT = NEAR + TOP + RIGHT;
|
||||
const int NEAR_TOP_LEFT = NEAR + TOP + LEFT;
|
||||
const int FAR = 32;
|
||||
const int FAR_RIGHT = FAR + RIGHT;
|
||||
const int FAR_LEFT = FAR + LEFT;
|
||||
const int FAR_BOTTOM = FAR + BOTTOM;
|
||||
const int FAR_BOTTOM_RIGHT = FAR + BOTTOM + RIGHT;
|
||||
const int FAR_BOTTOM_LEFT = FAR + BOTTOM + LEFT;
|
||||
const int FAR_TOP = FAR + TOP;
|
||||
const int FAR_TOP_RIGHT = FAR + TOP + RIGHT;
|
||||
const int FAR_TOP_LEFT = FAR + TOP + LEFT;
|
||||
|
||||
// If we know the position of the camera relative to the voxel, we can a priori know the vertices that make the visible hull
|
||||
// polygon. This also tells us which two vertices are known to make the longest possible distance between any pair of these
|
||||
// vertices for the projected polygon. This is a visibleFaces table based on this knowledge.
|
||||
|
||||
void main(void) {
|
||||
// Note: the gl_Vertex in this case are in "world coordinates" meaning they've already been scaled to TREE_SCALE
|
||||
// this is also true for voxelSizeIn.
|
||||
vec4 bottomNearRight = gl_Vertex;
|
||||
vec4 topFarLeft = (gl_Vertex + vec4(voxelSizeIn, voxelSizeIn, voxelSizeIn, 0.0));
|
||||
|
||||
int visibleFaces = NONE;
|
||||
|
||||
// In order to use our visibleFaces "table" (implemented as if statements) below, we need to encode the 6-bit code to
|
||||
// orient camera relative to the 6 defining faces of the voxel. Based on camera position relative to the bottomNearRight
|
||||
// corner and the topFarLeft corner, we can calculate which hull and therefore which two vertices are furthest apart
|
||||
// linearly once projected
|
||||
if (cameraPosition.x < bottomNearRight.x) {
|
||||
visibleFaces += RIGHT;
|
||||
}
|
||||
if (cameraPosition.x > topFarLeft.x) {
|
||||
visibleFaces += LEFT;
|
||||
}
|
||||
if (cameraPosition.y < bottomNearRight.y) {
|
||||
visibleFaces += BOTTOM;
|
||||
}
|
||||
if (cameraPosition.y > topFarLeft.y) {
|
||||
visibleFaces += TOP;
|
||||
}
|
||||
if (cameraPosition.z < bottomNearRight.z) {
|
||||
visibleFaces += NEAR;
|
||||
}
|
||||
if (cameraPosition.z > topFarLeft.z) {
|
||||
visibleFaces += FAR;
|
||||
}
|
||||
|
||||
vec4 cornerAdjustOne;
|
||||
vec4 cornerAdjustTwo;
|
||||
|
||||
if (visibleFaces == RIGHT) {
|
||||
cornerAdjustOne = vec4(0,0,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(0,1,1,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == LEFT) {
|
||||
cornerAdjustOne = vec4(1,0,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,1,1,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == BOTTOM) {
|
||||
cornerAdjustOne = vec4(0,0,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,0,1,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == TOP) {
|
||||
cornerAdjustOne = vec4(0,1,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,1,1,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == NEAR) {
|
||||
cornerAdjustOne = vec4(0,0,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,1,0,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == FAR) {
|
||||
cornerAdjustOne = vec4(0,0,1,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,1,1,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == NEAR_BOTTOM_LEFT ||
|
||||
visibleFaces == FAR_TOP ||
|
||||
visibleFaces == FAR_TOP_RIGHT) {
|
||||
cornerAdjustOne = vec4(0,1,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,0,1,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == FAR_TOP_LEFT ||
|
||||
visibleFaces == NEAR_RIGHT ||
|
||||
visibleFaces == NEAR_BOTTOM ||
|
||||
visibleFaces == NEAR_BOTTOM_RIGHT) {
|
||||
cornerAdjustOne = vec4(0,0,1,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,1,0,0) * voxelSizeIn;
|
||||
} else if (visibleFaces == NEAR_TOP_RIGHT ||
|
||||
visibleFaces == FAR_LEFT ||
|
||||
visibleFaces == FAR_BOTTOM_LEFT ||
|
||||
visibleFaces == BOTTOM_RIGHT ||
|
||||
visibleFaces == TOP_LEFT) {
|
||||
cornerAdjustOne = vec4(1,0,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(0,1,1,0) * voxelSizeIn;
|
||||
|
||||
// Everything else...
|
||||
//} else if (visibleFaces == BOTTOM_LEFT ||
|
||||
// visibleFaces == TOP_RIGHT ||
|
||||
// visibleFaces == NEAR_LEFT ||
|
||||
// visibleFaces == FAR_RIGHT ||
|
||||
// visibleFaces == NEAR_TOP ||
|
||||
// visibleFaces == NEAR_TOP_LEFT ||
|
||||
// visibleFaces == FAR_BOTTOM ||
|
||||
// visibleFaces == FAR_BOTTOM_RIGHT) {
|
||||
} else {
|
||||
cornerAdjustOne = vec4(0,0,0,0) * voxelSizeIn;
|
||||
cornerAdjustTwo = vec4(1,1,1,0) * voxelSizeIn;
|
||||
}
|
||||
|
||||
// Determine our corners
|
||||
vec4 cornerOne = gl_Vertex + cornerAdjustOne;
|
||||
vec4 cornerTwo = gl_Vertex + cornerAdjustTwo;
|
||||
|
||||
// Find their model view projections
|
||||
vec4 cornerOneMVP = gl_ModelViewProjectionMatrix * cornerOne;
|
||||
vec4 cornerTwoMVP = gl_ModelViewProjectionMatrix * cornerTwo;
|
||||
|
||||
// Map to x, y screen coordinates
|
||||
vec2 cornerOneScreen = vec2(cornerOneMVP.x / cornerOneMVP.w, cornerOneMVP.y / cornerOneMVP.w);
|
||||
if (cornerOneMVP.w < 0) {
|
||||
cornerOneScreen.x = -cornerOneScreen.x;
|
||||
cornerOneScreen.y = -cornerOneScreen.y;
|
||||
}
|
||||
|
||||
vec2 cornerTwoScreen = vec2(cornerTwoMVP.x / cornerTwoMVP.w, cornerTwoMVP.y / cornerTwoMVP.w);
|
||||
if (cornerTwoMVP.w < 0) {
|
||||
cornerTwoScreen.x = -cornerTwoScreen.x;
|
||||
cornerTwoScreen.y = -cornerTwoScreen.y;
|
||||
}
|
||||
|
||||
// Find the distance between them in pixels
|
||||
float voxelScreenWidth = abs(cornerOneScreen.x - cornerTwoScreen.x) * viewportWidth / 2.0;
|
||||
float voxelScreenHeight = abs(cornerOneScreen.y - cornerTwoScreen.y) * viewportHeight / 2.0;
|
||||
float voxelScreenLength = sqrt(voxelScreenHeight * voxelScreenHeight + voxelScreenWidth * voxelScreenWidth);
|
||||
|
||||
// Find the center of the voxel
|
||||
vec4 centerVertex = gl_Vertex;
|
||||
float halfSizeIn = voxelSizeIn / 2;
|
||||
centerVertex += vec4(halfSizeIn, halfSizeIn, halfSizeIn, 0.0);
|
||||
vec4 center = gl_ModelViewProjectionMatrix * centerVertex;
|
||||
|
||||
// Finally place the point at the center of the voxel, with a size equal to the maximum screen length
|
||||
gl_Position = center;
|
||||
gl_PointSize = voxelScreenLength;
|
||||
gl_FrontColor = gl_Color;
|
||||
}
|
||||
|
|
@ -1,87 +0,0 @@
|
|||
#version 120
|
||||
#extension GL_ARB_geometry_shader4 : enable
|
||||
|
||||
//
|
||||
// voxel.geom
|
||||
// geometry shader
|
||||
//
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
//
|
||||
// VOXEL GEOMETRY SHADER
|
||||
//
|
||||
// Input: gl_VerticesIn/gl_PositionIn
|
||||
// GL_POINTS
|
||||
// Assumes vertex shader has not transformed coordinates
|
||||
// Each gl_PositionIn is the corner of voxel
|
||||
// varying voxelSize - which is the voxel size
|
||||
//
|
||||
// Note: In vertex shader doesn't do any transform. Therefore passing the 3D world coordinates xyz to us
|
||||
//
|
||||
// Output: GL_TRIANGLE_STRIP
|
||||
//
|
||||
// Issues:
|
||||
// how do we need to handle lighting of these colors??
|
||||
// how do we handle normals?
|
||||
// check for size=0 and don't output the primitive
|
||||
//
|
||||
|
||||
varying in float voxelSize[1];
|
||||
|
||||
const int VERTICES_PER_FACE = 4;
|
||||
const int COORD_PER_VERTEX = 3;
|
||||
const int COORD_PER_FACE = COORD_PER_VERTEX * VERTICES_PER_FACE;
|
||||
|
||||
void faceOfVoxel(vec4 corner, float scale, float[COORD_PER_FACE] facePoints, vec4 color, vec4 normal) {
|
||||
for (int v = 0; v < VERTICES_PER_FACE; v++ ) {
|
||||
vec4 vertex = corner;
|
||||
for (int c = 0; c < COORD_PER_VERTEX; c++ ) {
|
||||
int cIndex = c + (v * COORD_PER_VERTEX);
|
||||
vertex[c] += (facePoints[cIndex] * scale);
|
||||
}
|
||||
|
||||
gl_FrontColor = color * (gl_LightModel.ambient + gl_LightSource[0].ambient +
|
||||
gl_LightSource[0].diffuse * max(0.0, dot(normal, gl_LightSource[0].position)));
|
||||
|
||||
gl_Position = gl_ModelViewProjectionMatrix * vertex;
|
||||
EmitVertex();
|
||||
}
|
||||
EndPrimitive();
|
||||
}
|
||||
|
||||
|
||||
void main() {
|
||||
//increment variable
|
||||
int i;
|
||||
vec4 corner;
|
||||
float scale;
|
||||
|
||||
float bottomFace[COORD_PER_FACE] = float[COORD_PER_FACE]( 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1 );
|
||||
float topFace[COORD_PER_FACE] = float[COORD_PER_FACE]( 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1 );
|
||||
float rightFace[COORD_PER_FACE] = float[COORD_PER_FACE]( 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1 );
|
||||
float leftFace[COORD_PER_FACE] = float[COORD_PER_FACE]( 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1 );
|
||||
float frontFace[COORD_PER_FACE] = float[COORD_PER_FACE]( 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0 );
|
||||
float backFace[COORD_PER_FACE] = float[COORD_PER_FACE]( 1, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1 );
|
||||
|
||||
vec4 bottomNormal = vec4(0.0, -1, 0.0, 0.0);
|
||||
vec4 topNormal = vec4(0.0, 1, 0.0, 0.0);
|
||||
vec4 rightNormal = vec4( -1, 0.0, 0.0, 0.0);
|
||||
vec4 leftNormal = vec4( 1, 0.0, 0.0, 0.0);
|
||||
vec4 frontNormal = vec4(0.0, 0.0, -1, 0.0);
|
||||
vec4 backNormal = vec4(0.0, 0.0, 1, 0.0);
|
||||
|
||||
for(i = 0; i < gl_VerticesIn; i++) {
|
||||
corner = gl_PositionIn[i];
|
||||
scale = voxelSize[i];
|
||||
faceOfVoxel(corner, scale, bottomFace, gl_FrontColorIn[i], bottomNormal);
|
||||
faceOfVoxel(corner, scale, topFace, gl_FrontColorIn[i], topNormal );
|
||||
faceOfVoxel(corner, scale, rightFace, gl_FrontColorIn[i], rightNormal );
|
||||
faceOfVoxel(corner, scale, leftFace, gl_FrontColorIn[i], leftNormal );
|
||||
faceOfVoxel(corner, scale, frontFace, gl_FrontColorIn[i], frontNormal );
|
||||
faceOfVoxel(corner, scale, backFace, gl_FrontColorIn[i], backNormal );
|
||||
}
|
||||
}
|
||||
|
|
@ -1915,8 +1915,6 @@ void Application::init() {
|
|||
_deferredLightingEffect.init();
|
||||
_glowEffect.init();
|
||||
_ambientOcclusionEffect.init();
|
||||
_voxelShader.init();
|
||||
_pointShader.init();
|
||||
|
||||
// TODO: move _myAvatar out of Application. Move relevant code to MyAvataar or AvatarManager
|
||||
_avatarManager.init();
|
||||
|
|
@ -1987,8 +1985,6 @@ void Application::init() {
|
|||
|
||||
// Set up VoxelSystem after loading preferences so we can get the desired max voxel count
|
||||
_voxels.setMaxVoxels(Menu::getInstance()->getMaxVoxels());
|
||||
_voxels.setUseVoxelShader(false);
|
||||
_voxels.setVoxelsAsPoints(false);
|
||||
_voxels.setDisableFastVoxelPipeline(false);
|
||||
_voxels.init();
|
||||
|
||||
|
|
|
|||
|
|
@ -64,9 +64,7 @@
|
|||
#include "renderer/DeferredLightingEffect.h"
|
||||
#include "renderer/GeometryCache.h"
|
||||
#include "renderer/GlowEffect.h"
|
||||
#include "renderer/PointShader.h"
|
||||
#include "renderer/TextureCache.h"
|
||||
#include "renderer/VoxelShader.h"
|
||||
#include "scripting/ControllerScriptingInterface.h"
|
||||
#include "ui/BandwidthDialog.h"
|
||||
#include "ui/BandwidthMeter.h"
|
||||
|
|
@ -295,8 +293,6 @@ public:
|
|||
|
||||
NodeBounds& getNodeBoundsDisplay() { return _nodeBoundsDisplay; }
|
||||
|
||||
VoxelShader& getVoxelShader() { return _voxelShader; }
|
||||
PointShader& getPointShader() { return _pointShader; }
|
||||
FileLogger* getLogger() { return _logger; }
|
||||
|
||||
glm::vec2 getViewportDimensions() const { return glm::vec2(_glWidget->getDeviceWidth(), _glWidget->getDeviceHeight()); }
|
||||
|
|
@ -588,8 +584,6 @@ private:
|
|||
DeferredLightingEffect _deferredLightingEffect;
|
||||
GlowEffect _glowEffect;
|
||||
AmbientOcclusionEffect _ambientOcclusionEffect;
|
||||
VoxelShader _voxelShader;
|
||||
PointShader _pointShader;
|
||||
|
||||
Audio _audio;
|
||||
|
||||
|
|
|
|||
|
|
@ -123,7 +123,6 @@ public:
|
|||
LodToolsDialog* getLodToolsDialog() const { return _lodToolsDialog; }
|
||||
HMDToolsDialog* getHMDToolsDialog() const { return _hmdToolsDialog; }
|
||||
int getMaxVoxels() const { return _maxVoxels; }
|
||||
QAction* getUseVoxelShader() const { return _useVoxelShader; }
|
||||
|
||||
bool getShadowsEnabled() const;
|
||||
|
||||
|
|
@ -304,7 +303,6 @@ private:
|
|||
float _avatarLODIncreaseFPS;
|
||||
float _avatarLODDistanceMultiplier;
|
||||
int _boundaryLevelAdjust;
|
||||
QAction* _useVoxelShader;
|
||||
int _maxVoxelPacketsPerSecond;
|
||||
QString replaceLastOccurrence(QChar search, QChar replace, QString string);
|
||||
quint64 _lastAdjust;
|
||||
|
|
|
|||
|
|
@ -1,80 +0,0 @@
|
|||
//
|
||||
// PointShader.cpp
|
||||
// interface/src/renderer
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 10/30/13.
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
// include this before QOpenGLFramebufferObject, which includes an earlier version of OpenGL
|
||||
#include "InterfaceConfig.h"
|
||||
|
||||
#include <QOpenGLFramebufferObject>
|
||||
|
||||
#include "Application.h"
|
||||
#include "PointShader.h"
|
||||
#include "ProgramObject.h"
|
||||
#include "RenderUtil.h"
|
||||
|
||||
PointShader::PointShader()
|
||||
: _initialized(false)
|
||||
{
|
||||
_program = NULL;
|
||||
}
|
||||
|
||||
PointShader::~PointShader() {
|
||||
if (_initialized) {
|
||||
delete _program;
|
||||
}
|
||||
}
|
||||
|
||||
ProgramObject* PointShader::createPointShaderProgram(const QString& name) {
|
||||
ProgramObject* program = new ProgramObject();
|
||||
program->addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/" + name + ".vert" );
|
||||
program->link();
|
||||
return program;
|
||||
}
|
||||
|
||||
void PointShader::init() {
|
||||
if (_initialized) {
|
||||
qDebug("[ERROR] PointShader is already initialized.");
|
||||
return;
|
||||
}
|
||||
_program = createPointShaderProgram("point_size");
|
||||
_initialized = true;
|
||||
}
|
||||
|
||||
void PointShader::begin() {
|
||||
_program->bind();
|
||||
}
|
||||
|
||||
void PointShader::end() {
|
||||
_program->release();
|
||||
}
|
||||
|
||||
int PointShader::attributeLocation(const char* name) const {
|
||||
if (_program) {
|
||||
return _program->attributeLocation(name);
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
int PointShader::uniformLocation(const char* name) const {
|
||||
if (_program) {
|
||||
return _program->uniformLocation(name);
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
void PointShader::setUniformValue(int uniformLocation, float value) {
|
||||
_program->setUniformValue(uniformLocation, value);
|
||||
}
|
||||
|
||||
void PointShader::setUniformValue(int uniformLocation, const glm::vec3& value) {
|
||||
_program->setUniformValue(uniformLocation, value.x, value.y, value.z);
|
||||
}
|
||||
|
|
@ -1,48 +0,0 @@
|
|||
//
|
||||
// PointShader.h
|
||||
// interface/src/renderer
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 10/30/13.
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
#ifndef hifi_PointShader_h
|
||||
#define hifi_PointShader_h
|
||||
|
||||
#include <QObject>
|
||||
|
||||
class ProgramObject;
|
||||
|
||||
/// A shader program that draws voxels as points with variable sizes
|
||||
class PointShader : public QObject {
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
PointShader();
|
||||
~PointShader();
|
||||
|
||||
void init();
|
||||
|
||||
/// Starts using the voxel point shader program.
|
||||
void begin();
|
||||
|
||||
/// Stops using the voxel point shader program.
|
||||
void end();
|
||||
|
||||
/// Gets access to attributes from the shader program
|
||||
int attributeLocation(const char* name) const;
|
||||
int uniformLocation(const char* name) const;
|
||||
void setUniformValue(int uniformLocation, float value);
|
||||
void setUniformValue(int uniformLocation, const glm::vec3& value);
|
||||
|
||||
static ProgramObject* createPointShaderProgram(const QString& name);
|
||||
|
||||
private:
|
||||
bool _initialized;
|
||||
ProgramObject* _program;
|
||||
};
|
||||
|
||||
#endif // hifi_PointShader_h
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
//
|
||||
// VoxelShader.cpp
|
||||
// interface/src/renderer
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 9/22/13.
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
// include this before QOpenGLFramebufferObject, which includes an earlier version of OpenGL
|
||||
#include "InterfaceConfig.h"
|
||||
|
||||
#include <QOpenGLFramebufferObject>
|
||||
|
||||
#include "Application.h"
|
||||
#include "VoxelShader.h"
|
||||
#include "ProgramObject.h"
|
||||
#include "RenderUtil.h"
|
||||
|
||||
VoxelShader::VoxelShader()
|
||||
: _initialized(false)
|
||||
{
|
||||
_program = NULL;
|
||||
}
|
||||
|
||||
VoxelShader::~VoxelShader() {
|
||||
if (_initialized) {
|
||||
delete _program;
|
||||
}
|
||||
}
|
||||
|
||||
ProgramObject* VoxelShader::createGeometryShaderProgram(const QString& name) {
|
||||
ProgramObject* program = new ProgramObject();
|
||||
program->addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() + "shaders/passthrough.vert" );
|
||||
program->addShaderFromSourceFile(QGLShader::Geometry, Application::resourcesPath() + "shaders/" + name + ".geom" );
|
||||
program->setGeometryInputType(GL_POINTS);
|
||||
program->setGeometryOutputType(GL_TRIANGLE_STRIP);
|
||||
const int VERTICES_PER_FACE = 4;
|
||||
const int FACES_PER_VOXEL = 6;
|
||||
const int VERTICES_PER_VOXEL = VERTICES_PER_FACE * FACES_PER_VOXEL;
|
||||
program->setGeometryOutputVertexCount(VERTICES_PER_VOXEL);
|
||||
program->link();
|
||||
return program;
|
||||
}
|
||||
|
||||
void VoxelShader::init() {
|
||||
if (_initialized) {
|
||||
qDebug("[ERROR] TestProgram is already initialized.");
|
||||
return;
|
||||
}
|
||||
|
||||
_program = createGeometryShaderProgram("voxel");
|
||||
_initialized = true;
|
||||
}
|
||||
|
||||
void VoxelShader::begin() {
|
||||
_program->bind();
|
||||
}
|
||||
|
||||
void VoxelShader::end() {
|
||||
_program->release();
|
||||
}
|
||||
|
||||
int VoxelShader::attributeLocation(const char * name) const {
|
||||
if (_program) {
|
||||
return _program->attributeLocation(name);
|
||||
} else {
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1,49 +0,0 @@
|
|||
//
|
||||
// VoxelShader.h
|
||||
// interface/src/renderer
|
||||
//
|
||||
// Created by Brad Hefta-Gaub on 9/23/13.
|
||||
// Copyright 2013 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
#ifndef hifi_VoxelShader_h
|
||||
#define hifi_VoxelShader_h
|
||||
|
||||
#include <QObject>
|
||||
|
||||
class ProgramObject;
|
||||
|
||||
/// A generic full screen glow effect.
|
||||
class VoxelShader : public QObject {
|
||||
Q_OBJECT
|
||||
|
||||
public:
|
||||
VoxelShader();
|
||||
~VoxelShader();
|
||||
|
||||
void init();
|
||||
|
||||
/// Starts using the voxel geometry shader effect.
|
||||
void begin();
|
||||
|
||||
/// Stops using the voxel geometry shader effect.
|
||||
void end();
|
||||
|
||||
/// Gets access to attributes from the shader program
|
||||
int attributeLocation(const char * name) const;
|
||||
|
||||
static ProgramObject* createGeometryShaderProgram(const QString& name);
|
||||
|
||||
public slots:
|
||||
|
||||
private:
|
||||
|
||||
bool _initialized;
|
||||
|
||||
ProgramObject* _program;
|
||||
};
|
||||
|
||||
#endif // hifi_VoxelShader_h
|
||||
|
|
@ -1,742 +0,0 @@
|
|||
//
|
||||
// PrimitiveRenderer.cpp
|
||||
// interface/src/voxels
|
||||
//
|
||||
// Copyright 2014 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
#include <QMutexLocker>
|
||||
|
||||
#include "InterfaceConfig.h"
|
||||
#include "OctreeElement.h"
|
||||
#include "PrimitiveRenderer.h"
|
||||
|
||||
Primitive::Primitive() {
|
||||
}
|
||||
|
||||
Primitive::~Primitive() {
|
||||
}
|
||||
|
||||
// Simple dispatch between API and SPI
|
||||
|
||||
const VertexElementList& Primitive::vertexElements() const {
|
||||
return vVertexElements();
|
||||
}
|
||||
|
||||
VertexElementIndexList& Primitive::vertexElementIndices() {
|
||||
return vVertexElementIndices();
|
||||
}
|
||||
|
||||
TriElementList& Primitive::triElements() {
|
||||
return vTriElements();
|
||||
}
|
||||
|
||||
void Primitive::releaseVertexElements() {
|
||||
vReleaseVertexElements();
|
||||
}
|
||||
|
||||
unsigned long Primitive::getMemoryUsage() {
|
||||
return vGetMemoryUsage();
|
||||
}
|
||||
|
||||
|
||||
Cube::Cube(
|
||||
float x,
|
||||
float y,
|
||||
float z,
|
||||
float s,
|
||||
unsigned char r,
|
||||
unsigned char g,
|
||||
unsigned char b,
|
||||
unsigned char faceExclusions
|
||||
) :
|
||||
_cpuMemoryUsage(0) {
|
||||
init(x, y, z, s, r, g, b, faceExclusions);
|
||||
}
|
||||
|
||||
Cube::~Cube() {
|
||||
terminate();
|
||||
}
|
||||
|
||||
void Cube::init(
|
||||
float x,
|
||||
float y,
|
||||
float z,
|
||||
float s,
|
||||
unsigned char r,
|
||||
unsigned char g,
|
||||
unsigned char b,
|
||||
unsigned char faceExclusions
|
||||
) {
|
||||
|
||||
initializeVertices(x, y, z, s, r, g, b, faceExclusions);
|
||||
initializeTris(faceExclusions);
|
||||
}
|
||||
|
||||
void Cube::terminate() {
|
||||
|
||||
terminateTris();
|
||||
terminateVertices();
|
||||
}
|
||||
|
||||
void Cube::initializeVertices(
|
||||
float x,
|
||||
float y,
|
||||
float z,
|
||||
float s,
|
||||
unsigned char r,
|
||||
unsigned char g,
|
||||
unsigned char b,
|
||||
unsigned char faceExclusions
|
||||
) {
|
||||
|
||||
for (int i = 0; i < _sNumVerticesPerCube; i++) {
|
||||
// Check whether the vertex is necessary for the faces indicated by faceExclusions bit mask.
|
||||
// uncomment this line to load all faces: if (~0x00 & _sFaceIndexToHalfSpaceMask[i >> 2]) {
|
||||
// uncomment this line to include shared faces: if (faceExclusions & _sFaceIndexToHalfSpaceMask[i >> 2]) {
|
||||
// uncomment this line to exclude shared faces:
|
||||
if (~faceExclusions & _sFaceIndexToHalfSpaceMask[i >> 2]) {
|
||||
|
||||
VertexElement* v = new VertexElement();
|
||||
if (v) {
|
||||
// Construct vertex position
|
||||
v->position.x = x + s * _sVertexIndexToConstructionVector[i][0];
|
||||
v->position.y = y + s * _sVertexIndexToConstructionVector[i][1];
|
||||
v->position.z = z + s * _sVertexIndexToConstructionVector[i][2];
|
||||
|
||||
// Construct vertex normal
|
||||
v->normal.x = _sVertexIndexToNormalVector[i >> 2][0];
|
||||
v->normal.y = _sVertexIndexToNormalVector[i >> 2][1];
|
||||
v->normal.z = _sVertexIndexToNormalVector[i >> 2][2];
|
||||
|
||||
// Construct vertex color
|
||||
//#define FALSE_COLOR
|
||||
#ifndef FALSE_COLOR
|
||||
v->color.r = r;
|
||||
v->color.g = g;
|
||||
v->color.b = b;
|
||||
v->color.a = 255;
|
||||
#else
|
||||
static unsigned char falseColor[6][3] = {
|
||||
192, 0, 0, // Bot
|
||||
0, 192, 0, // Top
|
||||
0, 0, 192, // Right
|
||||
192, 0, 192, // Left
|
||||
192, 192, 0, // Near
|
||||
192, 192, 192 // Far
|
||||
};
|
||||
v->color.r = falseColor[i >> 2][0];
|
||||
v->color.g = falseColor[i >> 2][1];
|
||||
v->color.b = falseColor[i >> 2][2];
|
||||
v->color.a = 255;
|
||||
#endif
|
||||
|
||||
// Add vertex element to list
|
||||
_vertices.push_back(v);
|
||||
_cpuMemoryUsage += sizeof(VertexElement);
|
||||
_cpuMemoryUsage += sizeof(VertexElement*);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Cube::terminateVertices() {
|
||||
|
||||
for (VertexElementList::iterator it = _vertices.begin(); it != _vertices.end(); ++it) {
|
||||
delete *it;
|
||||
}
|
||||
_cpuMemoryUsage -= _vertices.size() * (sizeof(VertexElement) + sizeof(VertexElement*));
|
||||
_vertices.clear();
|
||||
}
|
||||
|
||||
void Cube::initializeTris(
|
||||
unsigned char faceExclusions
|
||||
) {
|
||||
|
||||
int index = 0;
|
||||
for (int i = 0; i < _sNumFacesPerCube; i++) {
|
||||
// Check whether the vertex is necessary for the faces indicated by faceExclusions bit mask.
|
||||
// uncomment this line to load all faces: if (~0x00 & _sFaceIndexToHalfSpaceMask[i]) {
|
||||
// uncomment this line to include shared faces: if (faceExclusions & _sFaceIndexToHalfSpaceMask[i]) {
|
||||
// uncomment this line to exclude shared faces:
|
||||
if (~faceExclusions & _sFaceIndexToHalfSpaceMask[i]) {
|
||||
|
||||
int start = index;
|
||||
// Create the triangulated face, two tris, six indices referencing four vertices, both
|
||||
// with cw winding order, such that:
|
||||
|
||||
// A-B
|
||||
// |\|
|
||||
// D-C
|
||||
|
||||
// Store triangle ABC
|
||||
|
||||
TriElement* tri = new TriElement();
|
||||
if (tri) {
|
||||
tri->indices[0] = index++;
|
||||
tri->indices[1] = index++;
|
||||
tri->indices[2] = index;
|
||||
|
||||
// Add tri element to list
|
||||
_tris.push_back(tri);
|
||||
_cpuMemoryUsage += sizeof(TriElement);
|
||||
_cpuMemoryUsage += sizeof(TriElement*);
|
||||
}
|
||||
|
||||
// Now store triangle ACD
|
||||
tri = new TriElement();
|
||||
if (tri) {
|
||||
tri->indices[0] = start;
|
||||
tri->indices[1] = index++;
|
||||
tri->indices[2] = index++;
|
||||
|
||||
// Add tri element to list
|
||||
_tris.push_back(tri);
|
||||
_cpuMemoryUsage += sizeof(TriElement);
|
||||
_cpuMemoryUsage += sizeof(TriElement*);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void Cube::terminateTris() {
|
||||
|
||||
for (TriElementList::iterator it = _tris.begin(); it != _tris.end(); ++it) {
|
||||
delete *it;
|
||||
}
|
||||
_cpuMemoryUsage -= _tris.size() * (sizeof(TriElement) + sizeof(TriElement*));
|
||||
_tris.clear();
|
||||
}
|
||||
|
||||
const VertexElementList& Cube::vVertexElements() const {
|
||||
return _vertices;
|
||||
}
|
||||
|
||||
VertexElementIndexList& Cube::vVertexElementIndices() {
|
||||
return _vertexIndices;
|
||||
}
|
||||
|
||||
TriElementList& Cube::vTriElements() {
|
||||
return _tris;
|
||||
}
|
||||
|
||||
void Cube::vReleaseVertexElements() {
|
||||
terminateVertices();
|
||||
}
|
||||
|
||||
unsigned long Cube::vGetMemoryUsage() {
|
||||
return _cpuMemoryUsage;
|
||||
}
|
||||
|
||||
unsigned char Cube::_sFaceIndexToHalfSpaceMask[6] = {
|
||||
OctreeElement::HalfSpace::Bottom,
|
||||
OctreeElement::HalfSpace::Top,
|
||||
OctreeElement::HalfSpace::Right,
|
||||
OctreeElement::HalfSpace::Left,
|
||||
OctreeElement::HalfSpace::Near,
|
||||
OctreeElement::HalfSpace::Far,
|
||||
};
|
||||
|
||||
// Construction vectors ordered such that the vertices of each face are
|
||||
// clockwise in a right-handed coordinate system with B-L-N at 0,0,0.
|
||||
float Cube::_sVertexIndexToConstructionVector[24][3] = {
|
||||
// Bottom
|
||||
{ 0,0,0 },
|
||||
{ 1,0,0 },
|
||||
{ 1,0,1 },
|
||||
{ 0,0,1 },
|
||||
// Top
|
||||
{ 0,1,0 },
|
||||
{ 0,1,1 },
|
||||
{ 1,1,1 },
|
||||
{ 1,1,0 },
|
||||
// Right
|
||||
{ 1,0,0 },
|
||||
{ 1,1,0 },
|
||||
{ 1,1,1 },
|
||||
{ 1,0,1 },
|
||||
// Left
|
||||
{ 0,0,0 },
|
||||
{ 0,0,1 },
|
||||
{ 0,1,1 },
|
||||
{ 0,1,0 },
|
||||
// Near
|
||||
{ 0,0,0 },
|
||||
{ 0,1,0 },
|
||||
{ 1,1,0 },
|
||||
{ 1,0,0 },
|
||||
// Far
|
||||
{ 0,0,1 },
|
||||
{ 1,0,1 },
|
||||
{ 1,1,1 },
|
||||
{ 0,1,1 },
|
||||
};
|
||||
|
||||
// Normals for a right-handed coordinate system
|
||||
float Cube::_sVertexIndexToNormalVector[6][3] = {
|
||||
{ 0,-1, 0 }, // Bottom
|
||||
{ 0, 1, 0 }, // Top
|
||||
{ 1, 0, 0 }, // Right
|
||||
{ -1, 0, 0 }, // Left
|
||||
{ 0, 0,-1 }, // Near
|
||||
{ 0, 0, 1 }, // Far
|
||||
};
|
||||
|
||||
Renderer::Renderer() {
|
||||
}
|
||||
|
||||
Renderer::~Renderer() {
|
||||
}
|
||||
|
||||
// Simple dispatch between API and SPI
|
||||
int Renderer::add(
|
||||
Primitive* primitive
|
||||
) {
|
||||
return vAdd(primitive);
|
||||
}
|
||||
|
||||
void Renderer::remove(
|
||||
int id
|
||||
) {
|
||||
vRemove(id);
|
||||
}
|
||||
|
||||
void Renderer::release() {
|
||||
vRelease();
|
||||
}
|
||||
|
||||
void Renderer::render() {
|
||||
vRender();
|
||||
}
|
||||
|
||||
unsigned long Renderer::getMemoryUsage() {
|
||||
return vGetMemoryUsage();
|
||||
}
|
||||
|
||||
unsigned long Renderer::getMemoryUsageGPU() {
|
||||
return vGetMemoryUsageGPU();
|
||||
}
|
||||
|
||||
PrimitiveRenderer::PrimitiveRenderer(
|
||||
int maxCount
|
||||
) :
|
||||
_maxCount(maxCount),
|
||||
_triBufferId(0),
|
||||
_vertexBufferId(0),
|
||||
|
||||
_vertexElementCount(0),
|
||||
_maxVertexElementCount(0),
|
||||
|
||||
_triElementCount(0),
|
||||
_maxTriElementCount(0),
|
||||
|
||||
_primitives(),
|
||||
_primitiveCount(0),
|
||||
|
||||
_gpuMemoryUsage(0),
|
||||
_cpuMemoryUsage(0)
|
||||
|
||||
{
|
||||
init();
|
||||
}
|
||||
|
||||
PrimitiveRenderer::~PrimitiveRenderer() {
|
||||
|
||||
terminate();
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::init() {
|
||||
|
||||
initializeGL();
|
||||
initializeBookkeeping();
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::initializeGL() {
|
||||
|
||||
glGenBuffers(1, &_triBufferId);
|
||||
glGenBuffers(1, &_vertexBufferId);
|
||||
|
||||
// Set up the element array buffer containing the index ids
|
||||
_maxTriElementCount = _maxCount * 2;
|
||||
int size = _maxTriElementCount * _sIndicesPerTri * sizeof(GLint);
|
||||
_gpuMemoryUsage += size;
|
||||
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _triBufferId);
|
||||
glBufferData(GL_ELEMENT_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
||||
|
||||
// Set up the array buffer in the form of array of structures
|
||||
// I chose AOS because it maximizes the amount of data tranferred
|
||||
// by a single glBufferSubData call.
|
||||
_maxVertexElementCount = _maxCount * 8;
|
||||
size = _maxVertexElementCount * sizeof(VertexElement);
|
||||
_gpuMemoryUsage += size;
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferId);
|
||||
glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
// Initialize the first tri element in the buffer to all zeros, the
|
||||
// degenerate case
|
||||
deconstructTriElement(0);
|
||||
|
||||
// Initialize the first vertex element in the buffer to all zeros, the
|
||||
// degenerate case
|
||||
deconstructVertexElement(0);
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::initializeBookkeeping() {
|
||||
|
||||
// Start primitive count at one, because zero is reserved for the degenerate triangle
|
||||
_primitives.resize(_maxCount + 1);
|
||||
|
||||
// Set the counters
|
||||
_primitiveCount = 1;
|
||||
_vertexElementCount = 1;
|
||||
_triElementCount = 1;
|
||||
|
||||
// Guesstimate the memory consumption
|
||||
_cpuMemoryUsage = sizeof(PrimitiveRenderer);
|
||||
_cpuMemoryUsage += _availablePrimitiveIndex.capacity() * sizeof(int);
|
||||
_cpuMemoryUsage += _availableVertexElementIndex.capacity() * sizeof(int);
|
||||
_cpuMemoryUsage += _availableTriElementIndex.capacity() * sizeof(int);
|
||||
_cpuMemoryUsage += _deconstructTriElementIndex.capacity() * sizeof(int);
|
||||
_cpuMemoryUsage += _constructPrimitiveIndex.capacity() * sizeof(int);
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::terminate() {
|
||||
|
||||
terminateBookkeeping();
|
||||
terminateGL();
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::terminateGL() {
|
||||
|
||||
if (_vertexBufferId) {
|
||||
glDeleteBuffers(1, &_vertexBufferId);
|
||||
_vertexBufferId = 0;
|
||||
}
|
||||
|
||||
if (_triBufferId) {
|
||||
glDeleteBuffers(1, &_triBufferId);
|
||||
_triBufferId = 0;
|
||||
}
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::terminateBookkeeping() {
|
||||
|
||||
// Delete all of the primitives
|
||||
for (int i = _primitiveCount + 1; --i > 0; ) {
|
||||
Primitive* primitive = _primitives[i];
|
||||
if (primitive) {
|
||||
_cpuMemoryUsage -= primitive->getMemoryUsage();
|
||||
_primitives[i] = 0;
|
||||
delete primitive;
|
||||
}
|
||||
}
|
||||
|
||||
// Drain the queues
|
||||
_availablePrimitiveIndex.clear();
|
||||
_availableVertexElementIndex.clear();
|
||||
_availableTriElementIndex.clear();
|
||||
_deconstructTriElementIndex.clear();
|
||||
_constructPrimitiveIndex.clear();
|
||||
|
||||
_cpuMemoryUsage = sizeof(PrimitiveRenderer) + _primitives.size() * sizeof(Primitive *);
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::constructElements(
|
||||
Primitive* primitive
|
||||
) {
|
||||
|
||||
// Load vertex elements
|
||||
VertexElementIndexList& vertexElementIndexList = primitive->vertexElementIndices();
|
||||
const VertexElementList& vertices = primitive->vertexElements();
|
||||
{
|
||||
for (VertexElementList::const_iterator it = vertices.begin(); it != vertices.end(); ++it ) {
|
||||
int index = getAvailableVertexElementIndex();
|
||||
if (index != 0) {
|
||||
// Store the vertex element index in the primitive's
|
||||
// vertex element index list
|
||||
vertexElementIndexList.push_back(index);
|
||||
|
||||
VertexElement* vertex = *it;
|
||||
transferVertexElement(index, vertex);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Load tri elements
|
||||
if (vertexElementIndexList.size() == vertices.size()) {
|
||||
TriElementList& tris = primitive->triElements();
|
||||
|
||||
for (TriElementList::iterator it = tris.begin(); it != tris.end(); ++it) {
|
||||
TriElement* tri = *it;
|
||||
int index = getAvailableTriElementIndex();
|
||||
if (index != 0) {
|
||||
int k;
|
||||
k = tri->indices[0];
|
||||
tri->indices[0] = vertexElementIndexList[k];
|
||||
|
||||
k = tri->indices[1];
|
||||
tri->indices[1] = vertexElementIndexList[k];
|
||||
|
||||
k = tri->indices[2];
|
||||
tri->indices[2] = vertexElementIndexList[k];
|
||||
|
||||
tri->id = index;
|
||||
transferTriElement(index, tri->indices);
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// TODO: failure mode
|
||||
}
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::deconstructElements(
|
||||
Primitive* primitive
|
||||
) {
|
||||
|
||||
// Schedule the tri elements of the face for deconstruction
|
||||
{
|
||||
TriElementList& tris = primitive->triElements();
|
||||
|
||||
for (TriElementList::const_iterator it = tris.begin(); it != tris.end(); ++it) {
|
||||
const TriElement* tri = *it;
|
||||
|
||||
if (tri->id) {
|
||||
// Put the tri element index into decon queue
|
||||
_deconstructTriElementIndex.push(tri->id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return the vertex element index to the available queue, it is not necessary
|
||||
// to zero the data
|
||||
{
|
||||
VertexElementIndexList& vertexIndexList = primitive->vertexElementIndices();
|
||||
|
||||
for (VertexElementIndexList::const_iterator it = vertexIndexList.begin(); it != vertexIndexList.end(); ++it) {
|
||||
int index = *it;
|
||||
|
||||
if (index) {
|
||||
// Put the vertex element index into the available queue
|
||||
_availableVertexElementIndex.push(index);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
delete primitive;
|
||||
}
|
||||
|
||||
int PrimitiveRenderer::getAvailablePrimitiveIndex() {
|
||||
|
||||
int index;
|
||||
|
||||
// Check the available primitive index queue first for an available index.
|
||||
if (!_availablePrimitiveIndex.isEmpty()) {
|
||||
index = _availablePrimitiveIndex.pop();
|
||||
} else if (_primitiveCount < _maxCount) {
|
||||
// There are no primitive indices available from the queue,
|
||||
// make one up
|
||||
index = _primitiveCount++;
|
||||
} else {
|
||||
index = 0;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
int PrimitiveRenderer::getAvailableVertexElementIndex() {
|
||||
|
||||
int index;
|
||||
|
||||
// Check the available vertex element queue first for an available index.
|
||||
if (!_availableVertexElementIndex.isEmpty()) {
|
||||
index = _availableVertexElementIndex.pop();
|
||||
} else if (_vertexElementCount < _maxVertexElementCount) {
|
||||
// There are no vertex elements available from the queue,
|
||||
// grab one from the end of the list
|
||||
index = _vertexElementCount++;
|
||||
} else {
|
||||
index = 0;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
int PrimitiveRenderer::getAvailableTriElementIndex() {
|
||||
|
||||
int index;
|
||||
|
||||
// Check the tri elements scheduled for deconstruction queue first to
|
||||
// intercept and reuse an index without it having to be destroyed
|
||||
if (!_deconstructTriElementIndex.isEmpty()) {
|
||||
index = _deconstructTriElementIndex.pop();
|
||||
} else if (!_availableTriElementIndex.isEmpty()) {
|
||||
// Nothing available in the deconstruction queue, now
|
||||
// check the available tri element queue for an available index.
|
||||
index = _availableTriElementIndex.pop();
|
||||
} else if (_triElementCount < _maxTriElementCount) {
|
||||
// There are no reusable tri elements available from the queue,
|
||||
// grab one from the end of the list
|
||||
index = _triElementCount++;
|
||||
} else {
|
||||
index = 0;
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::deconstructTriElement(
|
||||
int idx
|
||||
) {
|
||||
|
||||
// Set the tri element to the degenerate case.
|
||||
static int degenerate[3] = { 0, 0, 0 };
|
||||
transferTriElement(idx, degenerate);
|
||||
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::deconstructVertexElement(
|
||||
int idx
|
||||
) {
|
||||
|
||||
// Set the vertex element to the degenerate case.
|
||||
VertexElement degenerate;
|
||||
memset(°enerate, 0, sizeof(degenerate));
|
||||
|
||||
transferVertexElement(idx, °enerate);
|
||||
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::transferVertexElement(
|
||||
int idx,
|
||||
VertexElement* vertex
|
||||
) {
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferId);
|
||||
glBufferSubData(GL_ARRAY_BUFFER, idx * sizeof(VertexElement), sizeof(VertexElement), vertex);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::transferTriElement(
|
||||
int idx,
|
||||
int tri[3]
|
||||
) {
|
||||
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _triBufferId);
|
||||
glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, idx * _sBytesPerTriElement, _sBytesPerTriElement, tri);
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
||||
}
|
||||
|
||||
int PrimitiveRenderer::vAdd(
|
||||
Primitive* primitive
|
||||
) {
|
||||
|
||||
QMutexLocker lock(&_guard);
|
||||
int id = getAvailablePrimitiveIndex();
|
||||
if (id != 0) {
|
||||
// Take ownership of primitive, including responsibility
|
||||
// for destruction
|
||||
_primitives[id] = primitive;
|
||||
_constructPrimitiveIndex.push(id);
|
||||
_cpuMemoryUsage += primitive->getMemoryUsage();
|
||||
}
|
||||
return id;
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::vRemove(
|
||||
int id
|
||||
) {
|
||||
|
||||
if (id != 0) {
|
||||
QMutexLocker lock(&_guard);
|
||||
|
||||
// Locate and remove the primitive by id in the vector map
|
||||
Primitive* primitive = _primitives[id];
|
||||
if (primitive) {
|
||||
_primitives[id] = 0;
|
||||
_cpuMemoryUsage -= primitive->getMemoryUsage();
|
||||
deconstructElements(primitive);
|
||||
|
||||
// Queue the index onto the available primitive stack.
|
||||
_availablePrimitiveIndex.push(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::vRelease() {
|
||||
|
||||
QMutexLocker lock(&_guard);
|
||||
|
||||
terminateBookkeeping();
|
||||
initializeBookkeeping();
|
||||
}
|
||||
|
||||
void PrimitiveRenderer::vRender() {
|
||||
|
||||
int id;
|
||||
QMutexLocker lock(&_guard);
|
||||
|
||||
// Iterate over the set of triangle element array buffer ids scheduled for
|
||||
// destruction. Set the triangle element to the degenerate case. Queue the id
|
||||
// onto the available tri element stack.
|
||||
while (!_deconstructTriElementIndex.isEmpty()) {
|
||||
id = _deconstructTriElementIndex.pop();
|
||||
deconstructTriElement(id);
|
||||
_availableTriElementIndex.push(id);
|
||||
}
|
||||
|
||||
// Iterate over the set of primitive ids scheduled for construction. Transfer
|
||||
// primitive data to the GPU.
|
||||
while (!_constructPrimitiveIndex.isEmpty()) {
|
||||
id = _constructPrimitiveIndex.pop();
|
||||
Primitive* primitive = _primitives[id];
|
||||
if (primitive) {
|
||||
constructElements(primitive);
|
||||
|
||||
// No need to keep an extra copy of the vertices
|
||||
_cpuMemoryUsage -= primitive->getMemoryUsage();
|
||||
primitive->releaseVertexElements();
|
||||
_cpuMemoryUsage += primitive->getMemoryUsage();
|
||||
}
|
||||
}
|
||||
|
||||
// The application uses clockwise winding for the definition of front face, this renderer
|
||||
// aalso uses clockwise (that is the gl default) to construct the triangulation
|
||||
// so...
|
||||
//glFrontFace(GL_CW);
|
||||
glEnable(GL_CULL_FACE);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, _vertexBufferId);
|
||||
|
||||
glEnableClientState(GL_VERTEX_ARRAY);
|
||||
glVertexPointer(3, GL_FLOAT, sizeof(VertexElement), 0);
|
||||
|
||||
glEnableClientState(GL_NORMAL_ARRAY);
|
||||
glNormalPointer(GL_FLOAT, sizeof(VertexElement), (const GLvoid*)12);
|
||||
|
||||
glEnableClientState(GL_COLOR_ARRAY);
|
||||
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(VertexElement), (const GLvoid*)24);
|
||||
|
||||
glBindBuffer(GL_ARRAY_BUFFER, 0);
|
||||
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, _triBufferId);
|
||||
glDrawElements(GL_TRIANGLES, 3 * _triElementCount, GL_UNSIGNED_INT, 0);
|
||||
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
|
||||
|
||||
glDisable(GL_CULL_FACE);
|
||||
}
|
||||
|
||||
unsigned long PrimitiveRenderer::vGetMemoryUsage() {
|
||||
return _cpuMemoryUsage;
|
||||
}
|
||||
|
||||
unsigned long PrimitiveRenderer::vGetMemoryUsageGPU() {
|
||||
return _gpuMemoryUsage;
|
||||
}
|
||||
|
|
@ -1,503 +0,0 @@
|
|||
//
|
||||
// PrimitiveRenderer.h
|
||||
// interface/src/voxels
|
||||
//
|
||||
// Created by Norman Craft.
|
||||
// Copyright 2014 High Fidelity, Inc.
|
||||
//
|
||||
// Distributed under the Apache License, Version 2.0.
|
||||
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
|
||||
//
|
||||
|
||||
#ifndef hifi_PrimitiveRenderer_h
|
||||
#define hifi_PrimitiveRenderer_h
|
||||
|
||||
#include <QStack>
|
||||
#include <QVector>
|
||||
#include <QMutex>
|
||||
|
||||
/// Vertex element structure.
|
||||
/// Using the array of structures approach to specifying
|
||||
/// vertex data to GL cuts down on the calls to glBufferSubData
|
||||
///
|
||||
typedef
|
||||
struct __VertexElement {
|
||||
struct __position {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
} position;
|
||||
struct __normal {
|
||||
float x;
|
||||
float y;
|
||||
float z;
|
||||
} normal;
|
||||
struct __color {
|
||||
unsigned char r;
|
||||
unsigned char g;
|
||||
unsigned char b;
|
||||
unsigned char a;
|
||||
} color;
|
||||
} VertexElement;
|
||||
|
||||
/// Triangle element index structure.
|
||||
/// Specify the vertex indices of the triangle and its element index.
|
||||
///
|
||||
typedef
|
||||
struct __TriElement {
|
||||
int indices[3];
|
||||
int id;
|
||||
|
||||
} TriElement;
|
||||
|
||||
/// Vertex element list container.
|
||||
///
|
||||
typedef QVector<VertexElement *> VertexElementList;
|
||||
|
||||
/// Vertex element index list container.
|
||||
///
|
||||
typedef QVector<int> VertexElementIndexList;
|
||||
|
||||
/// Triangle element list container
|
||||
///
|
||||
typedef QVector<TriElement *> TriElementList;
|
||||
|
||||
///
|
||||
/// @class Primitive
|
||||
/// Primitive Interface class.
|
||||
/// Abstract class for accessing vertex and tri elements of geometric primitives
|
||||
///
|
||||
///
|
||||
class Primitive {
|
||||
public:
|
||||
virtual ~Primitive();
|
||||
|
||||
// API methods go here
|
||||
|
||||
/// Vertex element accessor.
|
||||
/// @return A list of vertex elements of the primitive
|
||||
///
|
||||
const VertexElementList& vertexElements() const;
|
||||
|
||||
/// Vertex element index accessor.
|
||||
/// @return A list of vertex element indices of the primitive
|
||||
///
|
||||
VertexElementIndexList& vertexElementIndices();
|
||||
|
||||
/// Tri element accessor.
|
||||
/// @return A list of tri elements of the primitive
|
||||
///
|
||||
TriElementList& triElements();
|
||||
|
||||
/// Release vertex elements.
|
||||
///
|
||||
void releaseVertexElements();
|
||||
|
||||
/// Get memory usage.
|
||||
///
|
||||
unsigned long getMemoryUsage();
|
||||
|
||||
protected:
|
||||
/// Default constructor prohibited to API user, restricted to service implementer.
|
||||
///
|
||||
Primitive();
|
||||
|
||||
private:
|
||||
/// Copy constructor prohibited.
|
||||
///
|
||||
Primitive(
|
||||
const Primitive& copy
|
||||
);
|
||||
|
||||
// SPI methods are defined here
|
||||
|
||||
/// Vertex element accessor.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual const VertexElementList& vVertexElements() const = 0;
|
||||
|
||||
/// Vertex element index accessor.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual VertexElementIndexList& vVertexElementIndices() = 0;
|
||||
|
||||
/// Tri element accessor.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual TriElementList& vTriElements() = 0;
|
||||
|
||||
/// Release vertex elements.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual void vReleaseVertexElements() = 0;
|
||||
|
||||
/// Get memory usage.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual unsigned long vGetMemoryUsage() = 0;
|
||||
|
||||
};
|
||||
|
||||
|
||||
///
|
||||
/// @class Cube
|
||||
/// Class for accessing the vertex and triangle elements of a cube
|
||||
///
|
||||
class Cube: public Primitive {
|
||||
public:
|
||||
/// Configuration dependency injection constructor.
|
||||
///
|
||||
Cube(
|
||||
float x, ///< Cube location on X-axis
|
||||
float y, ///< Cube location on Y-axis
|
||||
float z, ///< Cube location on Z-axis
|
||||
float s, ///< Cube size
|
||||
unsigned char r, ///< Cube red color component
|
||||
unsigned char g, ///< Cube green color component
|
||||
unsigned char b, ///< Cube blue color component
|
||||
unsigned char faces ///< Bitmask of faces of cube excluded from construction
|
||||
);
|
||||
|
||||
~Cube();
|
||||
|
||||
private:
|
||||
/// Copy constructor prohibited.
|
||||
///
|
||||
Cube (
|
||||
const Cube& cube
|
||||
);
|
||||
|
||||
/// Cube initialization
|
||||
///
|
||||
void init(
|
||||
float x, ///< Cube location on X-axis
|
||||
float y, ///< Cube location on Y-axis
|
||||
float z, ///< Cube location on Z-axis
|
||||
float s, ///< Cube size
|
||||
unsigned char r, ///< Cube red color component
|
||||
unsigned char g, ///< Cube green color component
|
||||
unsigned char b, ///< Cube blue color component
|
||||
unsigned char faceExclusions ///< Bitmask of faces of cube excluded from construction
|
||||
);
|
||||
|
||||
/// Cube termination
|
||||
///
|
||||
void terminate();
|
||||
|
||||
/// Initialize cube's vertex list
|
||||
///
|
||||
void initializeVertices(
|
||||
float x, ///< Cube location on X-axis
|
||||
float y, ///< Cube location on Y-axis
|
||||
float z, ///< Cube location on Z-axis
|
||||
float s, ///< Cube size
|
||||
unsigned char r, ///< Cube red color component
|
||||
unsigned char g, ///< Cube green color component
|
||||
unsigned char b, ///< Cube blue color component
|
||||
unsigned char faceExclusions ///< Bitmask of faces of cube excluded from construction
|
||||
);
|
||||
|
||||
/// Terminate cube's vertex list
|
||||
///
|
||||
void terminateVertices();
|
||||
|
||||
/// Initialize cube's triangle list
|
||||
///
|
||||
void initializeTris(
|
||||
unsigned char faceExclusions
|
||||
);
|
||||
|
||||
/// Terminate cube's triangle list
|
||||
///
|
||||
void terminateTris();
|
||||
|
||||
// SPI virtual override methods go here
|
||||
|
||||
const VertexElementList& vVertexElements() const;
|
||||
VertexElementIndexList& vVertexElementIndices();
|
||||
TriElementList& vTriElements();
|
||||
void vReleaseVertexElements();
|
||||
unsigned long vGetMemoryUsage();
|
||||
|
||||
private:
|
||||
VertexElementList _vertices; ///< Vertex element list
|
||||
VertexElementIndexList _vertexIndices; ///< Vertex element index list
|
||||
TriElementList _tris; ///< Tri element list
|
||||
|
||||
unsigned long _cpuMemoryUsage; ///< Memory allocation of object
|
||||
|
||||
static const int _sNumFacesPerCube = 6; ///< Number of faces per cube
|
||||
static const int _sNumVerticesPerCube = 24; ///< Number of vertices per cube
|
||||
static unsigned char _sFaceIndexToHalfSpaceMask[6]; ///< index to bitmask map
|
||||
static float _sVertexIndexToConstructionVector[24][3]; ///< Vertex index to construction vector map
|
||||
static float _sVertexIndexToNormalVector[6][3]; ///< Vertex index to normal vector map
|
||||
|
||||
};
|
||||
|
||||
|
||||
///
|
||||
/// @class Renderer
|
||||
/// GL renderer interface class.
|
||||
/// Abstract class for rendering geometric primitives in GL
|
||||
///
|
||||
class Renderer {
|
||||
public:
|
||||
virtual ~Renderer();
|
||||
|
||||
// API methods go here
|
||||
|
||||
/// Add primitive to renderer database.
|
||||
///
|
||||
int add(
|
||||
Primitive* primitive ///< Primitive instance to be added
|
||||
);
|
||||
|
||||
/// Remove primitive from renderer database.
|
||||
///
|
||||
void remove(
|
||||
int id ///< Primitive id to be removed
|
||||
);
|
||||
|
||||
/// Clear all primitives from renderer database
|
||||
///
|
||||
void release();
|
||||
|
||||
/// Render primitive database.
|
||||
/// The render method assumes appropriate GL context and state has
|
||||
/// already been provided for
|
||||
///
|
||||
void render();
|
||||
|
||||
/// Get memory usage.
|
||||
///
|
||||
unsigned long getMemoryUsage();
|
||||
|
||||
/// Get GPU memory usage.
|
||||
///
|
||||
unsigned long getMemoryUsageGPU();
|
||||
|
||||
protected:
|
||||
/// Default constructor prohibited to API user, restricted to service implementer.
|
||||
///
|
||||
Renderer();
|
||||
|
||||
private:
|
||||
/// Copy constructor prohibited.
|
||||
///
|
||||
Renderer(
|
||||
const Renderer& copy
|
||||
);
|
||||
|
||||
// SPI methods are defined here
|
||||
|
||||
/// Add primitive to renderer database.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
/// @return Primitive id
|
||||
///
|
||||
virtual int vAdd(
|
||||
Primitive* primitive ///< Primitive instance to be added
|
||||
) = 0;
|
||||
|
||||
/// Remove primitive from renderer database.
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual void vRemove(
|
||||
int id ///< Primitive id
|
||||
) = 0;
|
||||
|
||||
/// Clear all primitives from renderer database
|
||||
/// Service implementer to provide private override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual void vRelease() = 0;
|
||||
|
||||
/// Render primitive database.
|
||||
/// Service implementer to provide private virtual override for this method
|
||||
/// in derived class
|
||||
///
|
||||
virtual void vRender() = 0;
|
||||
|
||||
/// Get memory usage.
|
||||
///
|
||||
virtual unsigned long vGetMemoryUsage() = 0;
|
||||
|
||||
/// Get GPU memory usage.
|
||||
///
|
||||
virtual unsigned long vGetMemoryUsageGPU() = 0;
|
||||
|
||||
};
|
||||
|
||||
///
|
||||
/// @class PrimitiveRenderer
|
||||
/// Renderer implementation class for the rendering of geometric primitives
|
||||
/// using GL element array and GL array buffers
|
||||
///
|
||||
class PrimitiveRenderer : public Renderer {
|
||||
public:
|
||||
/// Configuration dependency injection constructor.
|
||||
///
|
||||
PrimitiveRenderer(
|
||||
int maxCount ///< Max count
|
||||
);
|
||||
|
||||
~PrimitiveRenderer();
|
||||
|
||||
private:
|
||||
/// Default constructor prohibited.
|
||||
///
|
||||
PrimitiveRenderer();
|
||||
|
||||
/// Copy constructor prohibited.
|
||||
///
|
||||
PrimitiveRenderer(
|
||||
const PrimitiveRenderer& renderer
|
||||
);
|
||||
|
||||
void init();
|
||||
void terminate();
|
||||
|
||||
/// Allocate and initialize GL buffers.
|
||||
///
|
||||
void initializeGL();
|
||||
|
||||
/// Terminate and deallocate GL buffers.
|
||||
///
|
||||
void terminateGL();
|
||||
|
||||
void initializeBookkeeping();
|
||||
void terminateBookkeeping();
|
||||
|
||||
/// Construct the elements of the faces of the primitive.
|
||||
///
|
||||
void constructElements(
|
||||
Primitive* primitive ///< Primitive instance
|
||||
);
|
||||
|
||||
/// Deconstruct the elements of the faces of the primitive.
|
||||
///
|
||||
void deconstructElements(
|
||||
Primitive* primitive ///< Primitive instance
|
||||
);
|
||||
|
||||
/// Deconstruct the triangle element from the GL buffer.
|
||||
///
|
||||
void deconstructTriElement(
|
||||
int idx ///< Triangle element index
|
||||
);
|
||||
|
||||
/// Deconstruct the vertex element from the GL buffer.
|
||||
///
|
||||
void deconstructVertexElement(
|
||||
int idx ///< Vertex element index
|
||||
);
|
||||
|
||||
/// Transfer the vertex element to the GL buffer.
|
||||
///
|
||||
void transferVertexElement(
|
||||
int idx, ///< Vertex element index
|
||||
VertexElement *vertex ///< Vertex element instance
|
||||
);
|
||||
|
||||
/// Transfer the triangle element to the GL buffer.
|
||||
///
|
||||
void transferTriElement(
|
||||
int idx, ///< Triangle element index
|
||||
int tri[3] ///< Triangle element data
|
||||
);
|
||||
|
||||
/// Get available primitive index.
|
||||
/// Get an available primitive index from either the recycling
|
||||
/// queue or incrementing the counter
|
||||
///
|
||||
int getAvailablePrimitiveIndex();
|
||||
|
||||
/// Get available vertex element index.
|
||||
/// Get an available vertex element index from either the recycling
|
||||
/// queue or incrementing the counter
|
||||
///
|
||||
int getAvailableVertexElementIndex();
|
||||
|
||||
/// Get available triangle element index.
|
||||
/// Get an available triangle element index from either the elements
|
||||
/// scheduled for deconstruction queue, the recycling
|
||||
/// queue or incrementing the counter
|
||||
///
|
||||
int getAvailableTriElementIndex();
|
||||
|
||||
// SPI virtual override methods go here
|
||||
|
||||
/// Add primitive to renderer database.
|
||||
///
|
||||
int vAdd(
|
||||
Primitive* primitive ///< Primitive instance to be added
|
||||
);
|
||||
|
||||
/// Remove primitive from renderer database.
|
||||
///
|
||||
void vRemove(
|
||||
int id ///< Primitive id to be removed
|
||||
);
|
||||
|
||||
/// Clear all primitives from renderer database
|
||||
///
|
||||
void vRelease();
|
||||
|
||||
/// Render triangle database.
|
||||
///
|
||||
void vRender();
|
||||
|
||||
/// Get memory usage.
|
||||
///
|
||||
unsigned long vGetMemoryUsage();
|
||||
|
||||
/// Get gpu memory usage.
|
||||
///
|
||||
unsigned long vGetMemoryUsageGPU();
|
||||
|
||||
private:
|
||||
|
||||
int _maxCount; ///< Maximum count of tris
|
||||
|
||||
// GL related parameters
|
||||
|
||||
GLuint _triBufferId; ///< GL element array buffer id
|
||||
GLuint _vertexBufferId; ///< GL vertex array buffer id
|
||||
|
||||
// Book keeping parameters
|
||||
|
||||
int _vertexElementCount; ///< Count of vertices
|
||||
int _maxVertexElementCount; ///< Max count of vertices
|
||||
|
||||
int _triElementCount; ///< Count of triangles
|
||||
int _maxTriElementCount; ///< Max count of triangles
|
||||
|
||||
QVector<Primitive *> _primitives; ///< Vector of primitive
|
||||
int _primitiveCount; ///< Count of primitives
|
||||
|
||||
QStack<int> _availablePrimitiveIndex; ///< Queue of primitive indices available
|
||||
QStack<int> _availableVertexElementIndex; ///< Queue of vertex element indices available
|
||||
QStack<int> _availableTriElementIndex; ///< Queue of triangle element indices available
|
||||
QStack<int> _deconstructTriElementIndex; ///< Queue of triangle element indices requiring deletion from GL
|
||||
QStack<int> _constructPrimitiveIndex; ///< Queue of primitives requiring addition to GL
|
||||
|
||||
QMutex _guard;
|
||||
|
||||
// Statistics parameters, not necessary for proper operation
|
||||
|
||||
unsigned long _gpuMemoryUsage; ///< GPU memory used by this instance
|
||||
unsigned long _cpuMemoryUsage; ///< CPU memory used by this instance
|
||||
|
||||
|
||||
static const int _sIndicesPerTri = 3;
|
||||
static const int _sBytesPerTriElement = sizeof(GLint) * _sIndicesPerTri;
|
||||
};
|
||||
|
||||
|
||||
#endif // hifi_PrimitiveRenderer_h
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -25,22 +25,12 @@
|
|||
#include "Camera.h"
|
||||
#include "Util.h"
|
||||
#include "world.h"
|
||||
#include "renderer/VoxelShader.h"
|
||||
#include "PrimitiveRenderer.h"
|
||||
|
||||
class ProgramObject;
|
||||
|
||||
const int NUM_CHILDREN = 8;
|
||||
|
||||
|
||||
struct VoxelShaderVBOData
|
||||
{
|
||||
float x, y, z; // position
|
||||
float s; // size
|
||||
unsigned char r,g,b; // color
|
||||
};
|
||||
|
||||
|
||||
class VoxelSystem : public NodeData, public OctreeElementDeleteHook, public OctreeElementUpdateHook {
|
||||
Q_OBJECT
|
||||
|
||||
|
|
@ -80,7 +70,6 @@ public:
|
|||
void killLocalVoxels();
|
||||
|
||||
virtual void hideOutOfView(bool forceFullFrustum = false);
|
||||
void inspectForOcclusions();
|
||||
bool hasViewChanged();
|
||||
bool isViewChanging();
|
||||
|
||||
|
|
@ -97,8 +86,6 @@ public slots:
|
|||
void clearAllNodesBufferIndex();
|
||||
|
||||
void setDisableFastVoxelPipeline(bool disableFastVoxelPipeline);
|
||||
void setUseVoxelShader(bool useVoxelShader);
|
||||
void setVoxelsAsPoints(bool voxelsAsPoints);
|
||||
|
||||
protected:
|
||||
float _treeScale;
|
||||
|
|
@ -140,8 +127,6 @@ private:
|
|||
static bool killSourceVoxelsOperation(OctreeElement* element, void* extraData);
|
||||
static bool forceRedrawEntireTreeOperation(OctreeElement* element, void* extraData);
|
||||
static bool clearAllNodesBufferIndexOperation(OctreeElement* element, void* extraData);
|
||||
static bool inspectForExteriorOcclusionsOperation(OctreeElement* element, void* extraData);
|
||||
static bool inspectForInteriorOcclusionsOperation(OctreeElement* element, void* extraData);
|
||||
static bool hideOutOfViewOperation(OctreeElement* element, void* extraData);
|
||||
static bool hideAllSubTreeOperation(OctreeElement* element, void* extraData);
|
||||
static bool showAllSubTreeOperation(OctreeElement* element, void* extraData);
|
||||
|
|
@ -191,14 +176,8 @@ private:
|
|||
void initVoxelMemory();
|
||||
void cleanupVoxelMemory();
|
||||
|
||||
bool _useVoxelShader;
|
||||
bool _voxelsAsPoints;
|
||||
bool _voxelShaderModeWhenVoxelsAsPointsEnabled;
|
||||
|
||||
GLuint _vboVoxelsID; /// when using voxel shader, we'll use this VBO
|
||||
GLuint _vboVoxelsIndicesID; /// when using voxel shader, we'll use this VBO for our indexes
|
||||
VoxelShaderVBOData* _writeVoxelShaderData;
|
||||
VoxelShaderVBOData* _readVoxelShaderData;
|
||||
|
||||
GLuint _vboVerticesID;
|
||||
GLuint _vboColorsID;
|
||||
|
|
@ -258,17 +237,6 @@ private:
|
|||
float _lastKnownVoxelSizeScale;
|
||||
int _lastKnownBoundaryLevelAdjust;
|
||||
|
||||
bool _inOcclusions;
|
||||
bool _showCulledSharedFaces; ///< Flag visibility of culled faces
|
||||
bool _usePrimitiveRenderer; ///< Flag primitive renderer for use
|
||||
PrimitiveRenderer* _renderer; ///< Voxel renderer
|
||||
|
||||
static const unsigned int _sNumOctantsPerHemiVoxel = 4;
|
||||
static int _sCorrectedChildIndex[8];
|
||||
static unsigned short _sSwizzledOcclusionBits[64]; ///< Swizzle value of bit pairs of the value of index
|
||||
static unsigned char _sOctantIndexToBitMask[8]; ///< Map octant index to partition mask
|
||||
static unsigned char _sOctantIndexToSharedBitMask[8][8]; ///< Map octant indices to shared partition mask
|
||||
|
||||
// haze
|
||||
bool _drawHaze;
|
||||
float _farHazeDistance;
|
||||
|
|
|
|||
Loading…
Reference in a new issue