Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-09 22:51:28 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Trying to clen up the REnderMode usage in connection with the needed gpu::State for all the different variations

Browse source
This commit is contained in:
Sam Gateau 2015-03-31 17:35:34 -07:00
parent d4dac0477b
commit 9b63739a72
20 changed files with 190 additions and 129 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
interface/src/Application.cpp
View file

@ -2705,7 +2705,7 @@ void Application::updateShadowMap() {
{ {
PerformanceTimer perfTimer("avatarManager"); PerformanceTimer perfTimer("avatarManager");
DependencyManager::get<AvatarManager>()->renderAvatars(Avatar::SHADOW_RENDER_MODE); DependencyManager::get<AvatarManager>()->renderAvatars(RenderArgs::SHADOW_RENDER_MODE);
} }
{ {
@ -2975,7 +2975,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
bool mirrorMode = (theCamera.getMode() == CAMERA_MODE_MIRROR); bool mirrorMode = (theCamera.getMode() == CAMERA_MODE_MIRROR);
{ {
PerformanceTimer perfTimer("avatars"); PerformanceTimer perfTimer("avatars");
DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? Avatar::MIRROR_RENDER_MODE : Avatar::NORMAL_RENDER_MODE, DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE,
false, selfAvatarOnly); false, selfAvatarOnly);
} }
@ -2993,7 +2993,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
{ {
PerformanceTimer perfTimer("avatarsPostLighting"); PerformanceTimer perfTimer("avatarsPostLighting");
DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? Avatar::MIRROR_RENDER_MODE : Avatar::NORMAL_RENDER_MODE, DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE,
true, selfAvatarOnly); true, selfAvatarOnly);
} }

29
interface/src/avatar/Avatar.cpp
View file

@ -267,7 +267,7 @@ static TextRenderer* textRenderer(TextRendererType type) {
return displayNameRenderer; return displayNameRenderer;
} }
void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool postLighting) { void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode, bool postLighting) {
if (_referential) { if (_referential) {
_referential->update(); _referential->update();
} }
@ -337,7 +337,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool
// simple frustum check // simple frustum check
float boundingRadius = getBillboardSize(); float boundingRadius = getBillboardSize();
ViewFrustum* frustum = (renderMode == Avatar::SHADOW_RENDER_MODE) ? ViewFrustum* frustum = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
Application::getInstance()->getShadowViewFrustum() : Application::getInstance()->getDisplayViewFrustum(); Application::getInstance()->getShadowViewFrustum() : Application::getInstance()->getDisplayViewFrustum();
if (frustum->sphereInFrustum(getPosition(), boundingRadius) == ViewFrustum::OUTSIDE) { if (frustum->sphereInFrustum(getPosition(), boundingRadius) == ViewFrustum::OUTSIDE) {
return; return;
@ -359,7 +359,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool
GLOW_FROM_AVERAGE_LOUDNESS = 0.0f; GLOW_FROM_AVERAGE_LOUDNESS = 0.0f;
} }
float glowLevel = _moving && distanceToTarget > GLOW_DISTANCE && renderMode == NORMAL_RENDER_MODE float glowLevel = _moving && distanceToTarget > GLOW_DISTANCE && renderMode == RenderArgs::NORMAL_RENDER_MODE
? 1.0f ? 1.0f
: GLOW_FROM_AVERAGE_LOUDNESS; : GLOW_FROM_AVERAGE_LOUDNESS;
@ -368,7 +368,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool
renderBody(frustum, renderMode, postLighting, glowLevel); renderBody(frustum, renderMode, postLighting, glowLevel);
} }
if (!postLighting && renderMode != SHADOW_RENDER_MODE) { if (!postLighting && renderMode != RenderArgs::SHADOW_RENDER_MODE) {
// add local lights // add local lights
const float BASE_LIGHT_DISTANCE = 2.0f; const float BASE_LIGHT_DISTANCE = 2.0f;
const float LIGHT_EXPONENT = 1.0f; const float LIGHT_EXPONENT = 1.0f;
@ -432,7 +432,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool
float angle = abs(angleBetween(toTarget + delta, toTarget - delta)); float angle = abs(angleBetween(toTarget + delta, toTarget - delta));
float sphereRadius = getHead()->getAverageLoudness() * SPHERE_LOUDNESS_SCALING; float sphereRadius = getHead()->getAverageLoudness() * SPHERE_LOUDNESS_SCALING;
if (renderMode == NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) && if (renderMode == RenderArgs::NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) &&
(angle < MAX_SPHERE_ANGLE) && (angle > MIN_SPHERE_ANGLE)) { (angle < MAX_SPHERE_ANGLE) && (angle > MIN_SPHERE_ANGLE)) {
glPushMatrix(); glPushMatrix();
glTranslatef(_position.x, _position.y, _position.z); glTranslatef(_position.x, _position.y, _position.z);
@ -451,8 +451,8 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool
} }
const float DISPLAYNAME_DISTANCE = 20.0f; const float DISPLAYNAME_DISTANCE = 20.0f;
setShowDisplayName(renderMode == NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE); setShowDisplayName(renderMode == RenderArgs::NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);
if (!postLighting || renderMode != NORMAL_RENDER_MODE || (isMyAvatar() && if (!postLighting || renderMode != RenderArgs::NORMAL_RENDER_MODE || (isMyAvatar() &&
Application::getInstance()->getCamera()->getMode() == CAMERA_MODE_FIRST_PERSON)) { Application::getInstance()->getCamera()->getMode() == CAMERA_MODE_FIRST_PERSON)) {
return; return;
} }
@ -475,14 +475,13 @@ glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
return glm::angleAxis(angle * proportion, axis); return glm::angleAxis(angle * proportion, axis);
} }
void Avatar::renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, bool postLighting, float glowLevel) { void Avatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel) {
Model::RenderMode modelRenderMode = (renderMode == SHADOW_RENDER_MODE) ? Model::RenderMode modelRenderMode = renderMode;
Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE;
{ {
Glower glower(glowLevel); Glower glower(glowLevel);
if (_shouldRenderBillboard || !(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) { if (_shouldRenderBillboard || !(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
if (postLighting || renderMode == SHADOW_RENDER_MODE) { if (postLighting || renderMode == RenderArgs::SHADOW_RENDER_MODE) {
// render the billboard until both models are loaded // render the billboard until both models are loaded
renderBillboard(); renderBillboard();
} }
@ -501,7 +500,7 @@ void Avatar::renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, bool
getHead()->render(1.0f, renderFrustum, modelRenderMode, postLighting); getHead()->render(1.0f, renderFrustum, modelRenderMode, postLighting);
} }
bool Avatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderMode renderMode) const { bool Avatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const {
return true; return true;
} }
@ -525,9 +524,9 @@ void Avatar::simulateAttachments(float deltaTime) {
} }
} }
void Avatar::renderAttachments(RenderMode renderMode, RenderArgs* args) { void Avatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args) {
Model::RenderMode modelRenderMode = (renderMode == SHADOW_RENDER_MODE) ? RenderArgs::RenderMode modelRenderMode = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE; RenderArgs::SHADOW_RENDER_MODE : RenderArgs::DEFAULT_RENDER_MODE;
foreach (Model* model, _attachmentModels) { foreach (Model* model, _attachmentModels) {
model->render(1.0f, modelRenderMode, args); model->render(1.0f, modelRenderMode, args);
} }

12
interface/src/avatar/Avatar.h
View file

@ -67,10 +67,8 @@ public:
void init(); void init();
void simulate(float deltaTime); void simulate(float deltaTime);
enum RenderMode { NORMAL_RENDER_MODE, SHADOW_RENDER_MODE, MIRROR_RENDER_MODE }; virtual void render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode = RenderArgs::NORMAL_RENDER_MODE,
virtual void render(const glm::vec3& cameraPosition, RenderMode renderMode = NORMAL_RENDER_MODE,
bool postLighting = false); bool postLighting = false);
//setters //setters
@ -208,11 +206,11 @@ protected:
float calculateDisplayNameScaleFactor(const glm::vec3& textPosition, bool inHMD); float calculateDisplayNameScaleFactor(const glm::vec3& textPosition, bool inHMD);
void renderDisplayName(); void renderDisplayName();
virtual void renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, bool postLighting, float glowLevel = 0.0f); virtual void renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel = 0.0f);
virtual bool shouldRenderHead(const glm::vec3& cameraPosition, RenderMode renderMode) const; virtual bool shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const;
void simulateAttachments(float deltaTime); void simulateAttachments(float deltaTime);
virtual void renderAttachments(RenderMode renderMode, RenderArgs* args); virtual void renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args);
virtual void updateJointMappings(); virtual void updateJointMappings();

6
interface/src/avatar/AvatarManager.cpp
View file

@ -114,7 +114,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
simulateAvatarFades(deltaTime); simulateAvatarFades(deltaTime);
} }
void AvatarManager::renderAvatars(Avatar::RenderMode renderMode, bool postLighting, bool selfAvatarOnly) { void AvatarManager::renderAvatars(RenderArgs::RenderMode renderMode, bool postLighting, bool selfAvatarOnly) {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
"Application::renderAvatars()"); "Application::renderAvatars()");
bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::RenderLookAtVectors); bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::RenderLookAtVectors);
@ -156,9 +156,9 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
} }
} }
void AvatarManager::renderAvatarFades(const glm::vec3& cameraPosition, Avatar::RenderMode renderMode) { void AvatarManager::renderAvatarFades(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) {
// render avatar fades // render avatar fades
Glower glower(renderMode == Avatar::NORMAL_RENDER_MODE ? 1.0f : 0.0f); Glower glower(renderMode == RenderArgs::NORMAL_RENDER_MODE ? 1.0f : 0.0f);
foreach(const AvatarSharedPointer& fadingAvatar, _avatarFades) { foreach(const AvatarSharedPointer& fadingAvatar, _avatarFades) {
Avatar* avatar = static_cast<Avatar*>(fadingAvatar.data()); Avatar* avatar = static_cast<Avatar*>(fadingAvatar.data());

4
interface/src/avatar/AvatarManager.h
View file

@ -37,7 +37,7 @@ public:
void updateMyAvatar(float deltaTime); void updateMyAvatar(float deltaTime);
void updateOtherAvatars(float deltaTime); void updateOtherAvatars(float deltaTime);
void renderAvatars(Avatar::RenderMode renderMode, bool postLighting = false, bool selfAvatarOnly = false); void renderAvatars(RenderArgs::RenderMode renderMode, bool postLighting = false, bool selfAvatarOnly = false);
void clearOtherAvatars(); void clearOtherAvatars();
@ -55,7 +55,7 @@ private:
AvatarManager(const AvatarManager& other); AvatarManager(const AvatarManager& other);
void simulateAvatarFades(float deltaTime); void simulateAvatarFades(float deltaTime);
void renderAvatarFades(const glm::vec3& cameraPosition, Avatar::RenderMode renderMode); void renderAvatarFades(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode);
AvatarSharedPointer newSharedAvatar(); AvatarSharedPointer newSharedAvatar();

4
interface/src/avatar/Hand.cpp
View file

@ -103,7 +103,7 @@ void Hand::resolvePenetrations() {
} }
void Hand::render(bool isMine, Model::RenderMode renderMode) { void Hand::render(bool isMine, Model::RenderMode renderMode) {
if (renderMode != Model::SHADOW_RENDER_MODE && if (renderMode != RenderArgs::SHADOW_RENDER_MODE &&
Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionShapes)) { Menu::getInstance()->isOptionChecked(MenuOption::RenderSkeletonCollisionShapes)) {
// draw a green sphere at hand joint location, which is actually near the wrist) // draw a green sphere at hand joint location, which is actually near the wrist)
for (size_t i = 0; i < getNumPalms(); i++) { for (size_t i = 0; i < getNumPalms(); i++) {
@ -119,7 +119,7 @@ void Hand::render(bool isMine, Model::RenderMode renderMode) {
} }
} }
if (renderMode != Model::SHADOW_RENDER_MODE && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHands)) { if (renderMode != RenderArgs::SHADOW_RENDER_MODE && Menu::getInstance()->isOptionChecked(MenuOption::DisplayHands)) {
renderHandTargets(isMine); renderHandTargets(isMine);
} }

2
interface/src/avatar/Hand.h
View file

@ -52,7 +52,7 @@ public:
}; };
void simulate(float deltaTime, bool isMine); void simulate(float deltaTime, bool isMine);
void render(bool isMine, Model::RenderMode renderMode = Model::DEFAULT_RENDER_MODE); void render(bool isMine, Model::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE);
void collideAgainstAvatar(Avatar* avatar, bool isMyHand); void collideAgainstAvatar(Avatar* avatar, bool isMyHand);

19
interface/src/avatar/MyAvatar.cpp
View file

@ -326,7 +326,7 @@ void MyAvatar::renderDebugBodyPoints() {
} }
// virtual // virtual
void MyAvatar::render(const glm::vec3& cameraPosition, RenderMode renderMode, bool postLighting) { void MyAvatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode, bool postLighting) {
// don't render if we've been asked to disable local rendering // don't render if we've been asked to disable local rendering
if (!_shouldRender) { if (!_shouldRender) {
return; // exit early return; // exit early
@ -997,7 +997,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName, const g
Avatar::attach(modelURL, jointName, translation, rotation, scale, allowDuplicates, useSaved); Avatar::attach(modelURL, jointName, translation, rotation, scale, allowDuplicates, useSaved);
} }
void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, bool postLighting, float glowLevel) { void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel) {
if (!(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) { if (!(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
return; // wait until both models are loaded return; // wait until both models are loaded
} }
@ -1024,8 +1024,7 @@ void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, boo
} }
// Render the body's voxels and head // Render the body's voxels and head
Model::RenderMode modelRenderMode = (renderMode == SHADOW_RENDER_MODE) ? RenderArgs::RenderMode modelRenderMode = renderMode;
Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE;
if (!postLighting) { if (!postLighting) {
RenderArgs args; RenderArgs args;
args._viewFrustum = renderFrustum; args._viewFrustum = renderFrustum;
@ -1044,9 +1043,9 @@ void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, boo
const float RENDER_HEAD_CUTOFF_DISTANCE = 0.50f; const float RENDER_HEAD_CUTOFF_DISTANCE = 0.50f;
bool MyAvatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderMode renderMode) const { bool MyAvatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const {
const Head* head = getHead(); const Head* head = getHead();
return (renderMode != NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) || return (renderMode != RenderArgs::NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) ||
(glm::length(cameraPosition - head->getEyePosition()) > RENDER_HEAD_CUTOFF_DISTANCE * _scale); (glm::length(cameraPosition - head->getEyePosition()) > RENDER_HEAD_CUTOFF_DISTANCE * _scale);
} }
@ -1392,15 +1391,15 @@ void MyAvatar::updateMotionBehavior() {
_feetTouchFloor = menu->isOptionChecked(MenuOption::ShiftHipsForIdleAnimations); _feetTouchFloor = menu->isOptionChecked(MenuOption::ShiftHipsForIdleAnimations);
} }
void MyAvatar::renderAttachments(RenderMode renderMode, RenderArgs* args) { void MyAvatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args) {
if (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON || renderMode == MIRROR_RENDER_MODE) { if (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON || renderMode == RenderArgs::MIRROR_RENDER_MODE) {
Avatar::renderAttachments(renderMode, args); Avatar::renderAttachments(renderMode, args);
return; return;
} }
const FBXGeometry& geometry = _skeletonModel.getGeometry()->getFBXGeometry(); const FBXGeometry& geometry = _skeletonModel.getGeometry()->getFBXGeometry();
QString headJointName = (geometry.headJointIndex == -1) ? QString() : geometry.joints.at(geometry.headJointIndex).name; QString headJointName = (geometry.headJointIndex == -1) ? QString() : geometry.joints.at(geometry.headJointIndex).name;
Model::RenderMode modelRenderMode = (renderMode == SHADOW_RENDER_MODE) ? RenderArgs::RenderMode modelRenderMode = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE; RenderArgs::SHADOW_RENDER_MODE : RenderArgs::DEFAULT_RENDER_MODE;
for (int i = 0; i < _attachmentData.size(); i++) { for (int i = 0; i < _attachmentData.size(); i++) {
const QString& jointName = _attachmentData.at(i).jointName; const QString& jointName = _attachmentData.at(i).jointName;
if (jointName != headJointName && jointName != "Head") { if (jointName != headJointName && jointName != "Head") {

8
interface/src/avatar/MyAvatar.h
View file

@ -37,9 +37,9 @@ public:
void simulate(float deltaTime); void simulate(float deltaTime);
void updateFromTrackers(float deltaTime); void updateFromTrackers(float deltaTime);
void render(const glm::vec3& cameraPosition, RenderMode renderMode = NORMAL_RENDER_MODE, bool postLighting = false); void render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode = RenderArgs::NORMAL_RENDER_MODE, bool postLighting = false);
void renderBody(ViewFrustum* renderFrustum, RenderMode renderMode, bool postLighting, float glowLevel = 0.0f); void renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel = 0.0f);
bool shouldRenderHead(const glm::vec3& cameraPosition, RenderMode renderMode) const; bool shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const;
void renderDebugBodyPoints(); void renderDebugBodyPoints();
// setters // setters
@ -181,7 +181,7 @@ signals:
void transformChanged(); void transformChanged();
protected: protected:
virtual void renderAttachments(RenderMode renderMode, RenderArgs* args); virtual void renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args);
private: private:
float _turningKeyPressTime; float _turningKeyPressTime;

2
interface/src/ui/overlays/ModelOverlay.cpp
View file

@ -68,7 +68,7 @@ void ModelOverlay::render(RenderArgs* args) {
if (glowLevel > 0.0f) { if (glowLevel > 0.0f) {
glower = new Glower(glowLevel); glower = new Glower(glowLevel);
} }
_model.render(getAlpha(), Model::DEFAULT_RENDER_MODE, args); _model.render(getAlpha(), RenderArgs::DEFAULT_RENDER_MODE, args);
if (glower) { if (glower) {
delete glower; delete glower;
} }

2
libraries/entities-renderer/src/EntityTreeRenderer.cpp
View file

@ -364,7 +364,7 @@ void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode, RenderArgs::R
_tree->recurseTreeWithOperation(renderOperation, &args); _tree->recurseTreeWithOperation(renderOperation, &args);
Model::RenderMode modelRenderMode = renderMode == RenderArgs::SHADOW_RENDER_MODE Model::RenderMode modelRenderMode = renderMode == RenderArgs::SHADOW_RENDER_MODE
? Model::SHADOW_RENDER_MODE : Model::DEFAULT_RENDER_MODE; ? RenderArgs::SHADOW_RENDER_MODE : RenderArgs::DEFAULT_RENDER_MODE;
// we must call endScene while we still have the tree locked so that no one deletes a model // we must call endScene while we still have the tree locked so that no one deletes a model
// on us while rendering the scene // on us while rendering the scene

4
libraries/gpu/src/gpu/GLBackend.h
View file

@ -263,7 +263,7 @@ protected:
// Synchronize the state cache of this Backend with the actual real state of the GL Context // Synchronize the state cache of this Backend with the actual real state of the GL Context
void syncPipelineStateCache(); void syncPipelineStateCache();
// Grab the actual gl state into it's gpu::State equivalent. THis is used by the above call syncPipleineStateCache() // Grab the actual gl state into it's gpu::State equivalent. THis is used by the above call syncPipleineStateCache()
void getCurrentGLState(State::Cache& state); void getCurrentGLState(State::Data& state);
struct PipelineStageState { struct PipelineStageState {
@ -272,7 +272,7 @@ protected:
GLuint _program; GLuint _program;
bool _invalidProgram; bool _invalidProgram;
State::Cache _stateCache; State::Data _stateCache;
State::Signature _stateSignatureCache; State::Signature _stateSignatureCache;
GLState* _state; GLState* _state;

2
libraries/gpu/src/gpu/GLBackendPipeline.cpp
View file

@ -112,7 +112,7 @@ void GLBackend::do_setPipeline(Batch& batch, uint32 paramOffset) {
void GLBackend::updatePipeline() { void GLBackend::updatePipeline() {
#ifdef DEBUG_GLSTATE #ifdef DEBUG_GLSTATE
if (_pipeline._needStateSync) { if (_pipeline._needStateSync) {
State::Cache state; State::Data state;
getCurrentGLState(state); getCurrentGLState(state);
State::Signature signature = State::evalSignature(state); State::Signature signature = State::evalSignature(state);
} }

4
libraries/gpu/src/gpu/GLBackendState.cpp
View file

@ -401,7 +401,7 @@ State::BlendArg blendArgFromGL(GLenum blendArg) {
return State::ONE; return State::ONE;
} }
void GLBackend::getCurrentGLState(State::Cache& state) { void GLBackend::getCurrentGLState(State::Data& state) {
{ {
GLint modes[2]; GLint modes[2];
glGetIntegerv(GL_POLYGON_MODE, modes); glGetIntegerv(GL_POLYGON_MODE, modes);
@ -532,7 +532,7 @@ void GLBackend::getCurrentGLState(State::Cache& state) {
} }
void GLBackend::syncPipelineStateCache() { void GLBackend::syncPipelineStateCache() {
State::Cache state; State::Data state;
getCurrentGLState(state); getCurrentGLState(state);
State::Signature signature = State::evalSignature(state); State::Signature signature = State::evalSignature(state);

9
libraries/gpu/src/gpu/State.cpp
View file

@ -20,9 +20,9 @@ State::State() {
State::~State() { State::~State() {
} }
const State::Cache State::DEFAULT = State::Cache(); const State::Data State::DEFAULT = State::Data();
State::Signature State::evalSignature(const Cache& state) { State::Signature State::evalSignature(const Data& state) {
Signature signature(0); Signature signature(0);
if (state.fillMode != State::DEFAULT.fillMode) { if (state.fillMode != State::DEFAULT.fillMode) {
@ -79,3 +79,8 @@ State::Signature State::evalSignature(const Cache& state) {
return signature; return signature;
} }
State::State(const Data& values) :
_values(values) {
_signature = evalSignature(_values);
}

21
libraries/gpu/src/gpu/State.h
View file

@ -18,6 +18,9 @@
#include <unordered_map> #include <unordered_map>
#include <bitset> #include <bitset>
// Why a macro and not a fancy template you will ask me ?
// Because some of the fields are bool packed tightly in the State::Cache class
// and it s just not good anymore for template T& variable manipulation...
#define SET_FIELD(field, defaultValue, value, dest) {\ #define SET_FIELD(field, defaultValue, value, dest) {\
dest = value;\ dest = value;\
if (value == defaultValue) {\ if (value == defaultValue) {\
@ -39,7 +42,7 @@ public:
virtual ~State(); virtual ~State();
const Stamp getStamp() const { return _stamp; } const Stamp getStamp() const { return _stamp; }
enum ComparisonFunction { enum ComparisonFunction {
NEVER = 0, NEVER = 0,
LESS, LESS,
@ -233,9 +236,9 @@ public:
bool operator!= (const BlendFunction& right) const { return getRaw() != right.getRaw(); } bool operator!= (const BlendFunction& right) const { return getRaw() != right.getRaw(); }
}; };
// The Cache class is the full explicit description of the State class fields value. // The Data class is the full explicit description of the State class fields value.
// Useful for having one const static called Default for reference or for the gpu::Backend to keep track of the current value // Useful for having one const static called Default for reference or for the gpu::Backend to keep track of the current value
class Cache { class Data {
public: public:
float depthBias = 0.0f; float depthBias = 0.0f;
float depthBiasSlopeScale = 0.0f; float depthBiasSlopeScale = 0.0f;
@ -262,7 +265,7 @@ public:
bool antialisedLineEnable : 1; bool antialisedLineEnable : 1;
bool alphaToCoverageEnable : 1; bool alphaToCoverageEnable : 1;
Cache() : Data() :
frontFaceClockwise(false), frontFaceClockwise(false),
depthClipEnable(false), depthClipEnable(false),
scissorEnable(false), scissorEnable(false),
@ -273,7 +276,7 @@ public:
}; };
// The unique default values for all the fields // The unique default values for all the fields
static const Cache DEFAULT; static const Data DEFAULT;
void setFillMode(FillMode fill) { SET_FIELD(FILL_MODE, DEFAULT.fillMode, fill, _values.fillMode); } void setFillMode(FillMode fill) { SET_FIELD(FILL_MODE, DEFAULT.fillMode, fill, _values.fillMode); }
FillMode getFillMode() const { return FillMode(_values.fillMode); } FillMode getFillMode() const { return FillMode(_values.fillMode); }
@ -385,13 +388,17 @@ public:
Signature getSignature() const { return _signature; } Signature getSignature() const { return _signature; }
static Signature evalSignature(const Cache& state); static Signature evalSignature(const Data& state);
// For convenience, create a State from the values directly
State(const Data& values);
const Data& getValues() const { return _values; }
protected: protected:
State(const State& state); State(const State& state);
State& operator=(const State& state); State& operator=(const State& state);
Cache _values; Data _values;
Signature _signature{0}; Signature _signature{0};
Stamp _stamp{0}; Stamp _stamp{0};

11
libraries/render-utils/src/DeferredBufferWrite.slh
View file

@ -22,12 +22,19 @@ float evalOpaqueFinalAlpha(float alpha, float mapAlpha) {
} }
void packDeferredFragment(vec3 normal, float alpha, vec3 diffuse, vec3 specular, float shininess) { void packDeferredFragment(vec3 normal, float alpha, vec3 diffuse, vec3 specular, float shininess) {
if (alpha != glowIntensity) {
discard;
}
gl_FragData[0] = vec4(diffuse.rgb, alpha); gl_FragData[0] = vec4(diffuse.rgb, alpha);
gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0); gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0);
gl_FragData[2] = vec4(specular, shininess / 128.0); gl_FragData[2] = vec4(specular, shininess / 128.0);
} }
void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 diffuse, vec3 specular, float shininess, vec3 emissive) { void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 diffuse, vec3 specular, float shininess, vec3 emissive) {
if (alpha != glowIntensity) {
discard;
}
gl_FragData[0] = vec4(diffuse.rgb, alpha); gl_FragData[0] = vec4(diffuse.rgb, alpha);
//gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0); //gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0);
gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5); gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5);
@ -35,6 +42,10 @@ void packDeferredFragmentLightmap(vec3 normal, float alpha, vec3 diffuse, vec3 s
} }
void packDeferredFragmentTranslucent(vec3 normal, float alpha, vec3 diffuse, vec3 specular, float shininess) { void packDeferredFragmentTranslucent(vec3 normal, float alpha, vec3 diffuse, vec3 specular, float shininess) {
if (alpha <= alphaThreshold) {
discard;
}
gl_FragData[0] = vec4(diffuse.rgb, alpha); gl_FragData[0] = vec4(diffuse.rgb, alpha);
// gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0); // gl_FragData[1] = vec4(normal, 0.0) * 0.5 + vec4(0.5, 0.5, 0.5, 1.0);
// gl_FragData[2] = vec4(specular, shininess / 128.0); // gl_FragData[2] = vec4(specular, shininess / 128.0);

129
libraries/render-utils/src/Model.cpp
View file

@ -115,8 +115,9 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey key,
Locations* locations = new Locations(); Locations* locations = new Locations();
initLocations(program, *locations); initLocations(program, *locations);
gpu::StatePointer state = gpu::StatePointer(new gpu::State());
gpu::StatePointer state = gpu::StatePointer(new gpu::State());
// Backface on shadow // Backface on shadow
if (key.isShadow()) { if (key.isShadow()) {
state->setCullMode(gpu::State::CULL_FRONT); state->setCullMode(gpu::State::CULL_FRONT);
@ -133,9 +134,23 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey key,
state->setBlendFunction(key.isTranslucent(), state->setBlendFunction(key.isTranslucent(),
gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA,
gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE); gpu::State::FACTOR_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ONE);
// Good to go add the brand new pipeline
auto pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state)); auto pipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, state));
auto it = insert(value_type(key.getRaw(), RenderPipeline(pipeline, std::shared_ptr<Locations>(locations)))); auto it = insert(value_type(key.getRaw(), RenderPipeline(pipeline, std::shared_ptr<Locations>(locations))));
// If not a shadow pass, create the mirror version from the same state, just change the FrontFace
if (!key.isShadow()) {
RenderKey mirrorKey(key.getRaw() | RenderKey::IS_MIRROR);
gpu::StatePointer mirrorState = gpu::StatePointer(new gpu::State(state->getValues()));
// mirrorState->setFrontFaceClockwise(true);
// create a new RenderPipeline with the same shader side and the mirrorState
auto mirrorPipeline = gpu::PipelinePointer(gpu::Pipeline::create(program, mirrorState));
auto it = insert(value_type(mirrorKey.getRaw(), RenderPipeline(mirrorPipeline, std::shared_ptr<Locations>(locations))));
}
} }
@ -257,6 +272,7 @@ void Model::init() {
auto modelLightmapNormalSpecularMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_lightmap_normal_specular_map_frag))); auto modelLightmapNormalSpecularMapPixel = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(model_lightmap_normal_specular_map_frag)));
// Fill the renderPipelineLib // Fill the renderPipelineLib
_renderPipelineLib.addRenderPipeline( _renderPipelineLib.addRenderPipeline(
RenderKey(0), RenderKey(0),
modelVertex, modelPixel); modelVertex, modelPixel);
@ -265,7 +281,7 @@ void Model::init() {
RenderKey(RenderKey::HAS_TANGENTS), RenderKey(RenderKey::HAS_TANGENTS),
modelNormalMapVertex, modelNormalMapPixel); modelNormalMapVertex, modelNormalMapPixel);
_renderPipelineLib.addRenderPipeline( _renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::HAS_SPECULAR), RenderKey(RenderKey::HAS_SPECULAR),
modelVertex, modelSpecularMapPixel); modelVertex, modelSpecularMapPixel);
@ -276,15 +292,11 @@ void Model::init() {
_renderPipelineLib.addRenderPipeline( _renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::IS_TRANSLUCENT), RenderKey(RenderKey::IS_TRANSLUCENT),
modelVertex, modelTranslucentPixel); modelVertex, modelTranslucentPixel);
_renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::IS_DEPTH_ONLY | RenderKey::IS_SHADOW),
modelShadowVertex, modelShadowPixel);
_renderPipelineLib.addRenderPipeline( _renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::HAS_LIGHTMAP), RenderKey(RenderKey::HAS_LIGHTMAP),
modelLightmapVertex, modelLightmapPixel); modelLightmapVertex, modelLightmapPixel);
_renderPipelineLib.addRenderPipeline( _renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::HAS_LIGHTMAP | RenderKey::HAS_TANGENTS), RenderKey(RenderKey::HAS_LIGHTMAP | RenderKey::HAS_TANGENTS),
modelLightmapNormalMapVertex, modelLightmapNormalMapPixel); modelLightmapNormalMapVertex, modelLightmapNormalMapPixel);
@ -312,13 +324,18 @@ void Model::init() {
RenderKey(RenderKey::IS_SKINNED | RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR), RenderKey(RenderKey::IS_SKINNED | RenderKey::HAS_TANGENTS | RenderKey::HAS_SPECULAR),
skinModelNormalMapVertex, modelNormalSpecularMapPixel); skinModelNormalMapVertex, modelNormalSpecularMapPixel);
_renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::IS_SKINNED | RenderKey::IS_DEPTH_ONLY | RenderKey::IS_SHADOW),
skinModelShadowVertex, modelShadowPixel);
_renderPipelineLib.addRenderPipeline( _renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::IS_SKINNED | RenderKey::IS_TRANSLUCENT), RenderKey(RenderKey::IS_SKINNED | RenderKey::IS_TRANSLUCENT),
skinModelVertex, modelTranslucentPixel); skinModelVertex, modelTranslucentPixel);
_renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::IS_DEPTH_ONLY | RenderKey::IS_SHADOW),
modelShadowVertex, modelShadowPixel);
_renderPipelineLib.addRenderPipeline(
RenderKey(RenderKey::IS_SKINNED | RenderKey::IS_DEPTH_ONLY | RenderKey::IS_SHADOW),
skinModelShadowVertex, modelShadowPixel);
} }
} }
@ -654,6 +671,8 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
return false; return false;
} }
// auto glowEffectIntensity = DependencyManager::get<GlowEffect>()->getIntensity();
// Let's introduce a gpu::Batch to capture all the calls to the graphics api // Let's introduce a gpu::Batch to capture all the calls to the graphics api
_renderBatch.clear(); _renderBatch.clear();
gpu::Batch& batch = _renderBatch; gpu::Batch& batch = _renderBatch;
@ -675,14 +694,14 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
batch.setViewTransform(_transforms[0]); batch.setViewTransform(_transforms[0]);
GLBATCH(glDisable)(GL_COLOR_MATERIAL); // GLBATCH(glDisable)(GL_COLOR_MATERIAL);
// taking care of by the state? // taking care of by the state?
/* if (mode == DIFFUSE_RENDER_MODE || mode == NORMAL_RENDER_MODE) { /* if (mode == RenderArgs::DIFFUSE_RENDER_MODE || mode == RenderArgs::NORMAL_RENDER_MODE) {
GLBATCH(glDisable)(GL_CULL_FACE); GLBATCH(glDisable)(GL_CULL_FACE);
} else { } else {
GLBATCH(glEnable)(GL_CULL_FACE); GLBATCH(glEnable)(GL_CULL_FACE);
if (mode == SHADOW_RENDER_MODE) { if (mode == RenderArgs::SHADOW_RENDER_MODE) {
GLBATCH(glCullFace)(GL_FRONT); GLBATCH(glCullFace)(GL_FRONT);
} }
} }
@ -691,28 +710,31 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
// render opaque meshes with alpha testing // render opaque meshes with alpha testing
// GLBATCH(glDisable)(GL_BLEND); // GLBATCH(glDisable)(GL_BLEND);
GLBATCH(glEnable)(GL_ALPHA_TEST); // GLBATCH(glEnable)(GL_ALPHA_TEST);
if (mode == SHADOW_RENDER_MODE) { /* if (mode == RenderArgs::SHADOW_RENDER_MODE) {
GLBATCH(glAlphaFunc)(GL_EQUAL, 0.0f); GLBATCH(glAlphaFunc)(GL_EQUAL, 0.0f);
} }
*/
/*DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers( /*DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers(
mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE, mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::DIFFUSE_RENDER_MODE,
mode == DEFAULT_RENDER_MODE || mode == NORMAL_RENDER_MODE, mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::NORMAL_RENDER_MODE,
mode == DEFAULT_RENDER_MODE); mode == RenderArgs::DEFAULT_RENDER_MODE);
*/ */
{ {
GLenum buffers[3]; GLenum buffers[3];
int bufferCount = 0; int bufferCount = 0;
if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::DIFFUSE_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
buffers[bufferCount++] = GL_COLOR_ATTACHMENT0; buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
} }
if (mode == DEFAULT_RENDER_MODE || mode == NORMAL_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::NORMAL_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
buffers[bufferCount++] = GL_COLOR_ATTACHMENT1; buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
} }
if (mode == DEFAULT_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
buffers[bufferCount++] = GL_COLOR_ATTACHMENT2; buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
} }
GLBATCH(glDrawBuffers)(bufferCount, buffers); GLBATCH(glDrawBuffers)(bufferCount, buffers);
@ -758,7 +780,7 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args, true); translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args, true);
translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, args, true); translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, args, true);
GLBATCH(glDisable)(GL_ALPHA_TEST); // GLBATCH(glDisable)(GL_ALPHA_TEST);
/* GLBATCH(glEnable)(GL_BLEND); /* GLBATCH(glEnable)(GL_BLEND);
GLBATCH(glDepthMask)(false); GLBATCH(glDepthMask)(false);
GLBATCH(glDepthFunc)(GL_LEQUAL); GLBATCH(glDepthFunc)(GL_LEQUAL);
@ -771,7 +793,8 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
GLBATCH(glDrawBuffers)(bufferCount, buffers); GLBATCH(glDrawBuffers)(bufferCount, buffers);
} }
if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::DIFFUSE_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f; const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f;
translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, false, args, true); translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, false, args, true);
translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, true, args, true); translucentMeshPartsRendered += renderMeshes(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, true, args, true);
@ -790,7 +813,7 @@ bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
GLBATCH(glDepthFunc)(GL_LESS); GLBATCH(glDepthFunc)(GL_LESS);
GLBATCH(glDisable)(GL_CULL_FACE); GLBATCH(glDisable)(GL_CULL_FACE);
if (mode == SHADOW_RENDER_MODE) { if (mode == RenderArgs::SHADOW_RENDER_MODE) {
GLBATCH(glCullFace)(GL_BACK); GLBATCH(glCullFace)(GL_BACK);
} }
@ -1713,6 +1736,9 @@ void Model::setupBatchTransform(gpu::Batch& batch) {
void Model::endScene(RenderMode mode, RenderArgs* args) { void Model::endScene(RenderMode mode, RenderArgs* args) {
PROFILE_RANGE(__FUNCTION__); PROFILE_RANGE(__FUNCTION__);
// auto glowEffectIntensity = DependencyManager::get<GlowEffect>()->getIntensity();
#if defined(ANDROID) #if defined(ANDROID)
#else #else
glPushMatrix(); glPushMatrix();
@ -1739,13 +1765,13 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
_sceneRenderBatch.clear(); _sceneRenderBatch.clear();
gpu::Batch& batch = _sceneRenderBatch; gpu::Batch& batch = _sceneRenderBatch;
GLBATCH(glDisable)(GL_COLOR_MATERIAL); // GLBATCH(glDisable)(GL_COLOR_MATERIAL);
/* if (mode == DIFFUSE_RENDER_MODE || mode == NORMAL_RENDER_MODE) { /* if (mode == RenderArgs::DIFFUSE_RENDER_MODE || mode == RenderArgs::NORMAL_RENDER_MODE) {
GLBATCH(glDisable)(GL_CULL_FACE); GLBATCH(glDisable)(GL_CULL_FACE);
} else { } else {
GLBATCH(glEnable)(GL_CULL_FACE); GLBATCH(glEnable)(GL_CULL_FACE);
if (mode == SHADOW_RENDER_MODE) { if (mode == RenderArgs::SHADOW_RENDER_MODE) {
GLBATCH(glCullFace)(GL_FRONT); GLBATCH(glCullFace)(GL_FRONT);
} }
}*/ }*/
@ -1753,28 +1779,31 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
// render opaque meshes with alpha testing // render opaque meshes with alpha testing
// GLBATCH(glDisable)(GL_BLEND); // GLBATCH(glDisable)(GL_BLEND);
GLBATCH(glEnable)(GL_ALPHA_TEST); // GLBATCH(glEnable)(GL_ALPHA_TEST);
if (mode == SHADOW_RENDER_MODE) { /* if (mode == RenderArgs::SHADOW_RENDER_MODE) {
GLBATCH(glAlphaFunc)(GL_EQUAL, 0.0f); GLBATCH(glAlphaFunc)(GL_EQUAL, 0.0f);
} }
*/
/*DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers( /*DependencyManager::get<TextureCache>()->setPrimaryDrawBuffers(
mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE, mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::DIFFUSE_RENDER_MODE,
mode == DEFAULT_RENDER_MODE || mode == NORMAL_RENDER_MODE, mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::NORMAL_RENDER_MODE,
mode == DEFAULT_RENDER_MODE); mode == RenderArgs::DEFAULT_RENDER_MODE);
*/ */
{ {
GLenum buffers[3]; GLenum buffers[3];
int bufferCount = 0; int bufferCount = 0;
if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::DIFFUSE_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
buffers[bufferCount++] = GL_COLOR_ATTACHMENT0; buffers[bufferCount++] = GL_COLOR_ATTACHMENT0;
} }
if (mode == DEFAULT_RENDER_MODE || mode == NORMAL_RENDER_MODE) { //if (mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::NORMAL_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
buffers[bufferCount++] = GL_COLOR_ATTACHMENT1; buffers[bufferCount++] = GL_COLOR_ATTACHMENT1;
} }
if (mode == DEFAULT_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
buffers[bufferCount++] = GL_COLOR_ATTACHMENT2; buffers[bufferCount++] = GL_COLOR_ATTACHMENT2;
} }
GLBATCH(glDrawBuffers)(bufferCount, buffers); GLBATCH(glDrawBuffers)(bufferCount, buffers);
@ -1820,7 +1849,7 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args); translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, false, args);
translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, args); translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_OPAQUE_THRESHOLD, false, true, true, true, args);
GLBATCH(glDisable)(GL_ALPHA_TEST); // GLBATCH(glDisable)(GL_ALPHA_TEST);
/* GLBATCH(glEnable)(GL_BLEND); /* GLBATCH(glEnable)(GL_BLEND);
GLBATCH(glDepthMask)(false); GLBATCH(glDepthMask)(false);
GLBATCH(glDepthFunc)(GL_LEQUAL); GLBATCH(glDepthFunc)(GL_LEQUAL);
@ -1833,7 +1862,8 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
GLBATCH(glDrawBuffers)(bufferCount, buffers); GLBATCH(glDrawBuffers)(bufferCount, buffers);
} }
if (mode == DEFAULT_RENDER_MODE || mode == DIFFUSE_RENDER_MODE) { // if (mode == RenderArgs::DEFAULT_RENDER_MODE || mode == RenderArgs::DIFFUSE_RENDER_MODE) {
if (mode != RenderArgs::SHADOW_RENDER_MODE) {
const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f; const float MOSTLY_TRANSPARENT_THRESHOLD = 0.0f;
translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, false, args); translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, false, args);
translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, true, args); translucentParts += renderMeshesForModelsInScene(batch, mode, true, MOSTLY_TRANSPARENT_THRESHOLD, false, false, false, true, args);
@ -1849,7 +1879,7 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
GLBATCH(glDepthFunc)(GL_LESS); GLBATCH(glDepthFunc)(GL_LESS);
GLBATCH(glDisable)(GL_CULL_FACE); GLBATCH(glDisable)(GL_CULL_FACE);
if (mode == SHADOW_RENDER_MODE) { if (mode == RenderArgs::SHADOW_RENDER_MODE) {
GLBATCH(glCullFace)(GL_BACK); GLBATCH(glCullFace)(GL_BACK);
} }
@ -2273,9 +2303,16 @@ void Model::pickPrograms(gpu::Batch& batch, RenderMode mode, bool translucent, f
// dare! // dare!
batch.setPipeline((*pipeline).second._pipeline); batch.setPipeline((*pipeline).second._pipeline);
if ((locations->alphaThreshold > -1) && (mode != SHADOW_RENDER_MODE)) { if ((locations->alphaThreshold > -1) && (mode != RenderArgs::SHADOW_RENDER_MODE)) {
GLBATCH(glUniform1f)(locations->alphaThreshold, alphaThreshold); GLBATCH(glUniform1f)(locations->alphaThreshold, alphaThreshold);
} }
if ((locations->glowIntensity > -1) && (mode != RenderArgs::SHADOW_RENDER_MODE)) {
GLBATCH(glUniform1f)(locations->glowIntensity, DependencyManager::get<GlowEffect>()->getIntensity());
}
// if (!(translucent && alphaThreshold == 0.0f) && (mode != RenderArgs::SHADOW_RENDER_MODE)) {
// GLBATCH(glAlphaFunc)(GL_EQUAL, DependencyManager::get<GlowEffect>()->getIntensity());
// }
} }
int Model::renderMeshesForModelsInScene(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, int Model::renderMeshesForModelsInScene(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold,
@ -2344,7 +2381,7 @@ int Model::renderMeshesFromList(QVector<int>& list, gpu::Batch& batch, RenderMod
PROFILE_RANGE(__FUNCTION__); PROFILE_RANGE(__FUNCTION__);
auto textureCache = DependencyManager::get<TextureCache>(); auto textureCache = DependencyManager::get<TextureCache>();
auto glowEffect = DependencyManager::get<GlowEffect>(); // auto glowEffect = DependencyManager::get<GlowEffect>();
QString lastMaterialID; QString lastMaterialID;
int meshPartsRendered = 0; int meshPartsRendered = 0;
updateVisibleJointStates(); updateVisibleJointStates();
@ -2443,7 +2480,7 @@ int Model::renderMeshesFromList(QVector<int>& list, gpu::Batch& batch, RenderMod
} }
// apply material properties // apply material properties
if (mode == SHADOW_RENDER_MODE) { if (mode == RenderArgs::SHADOW_RENDER_MODE) {
/// GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0); /// GLBATCH(glBindTexture)(GL_TEXTURE_2D, 0);
} else { } else {
@ -2455,13 +2492,13 @@ int Model::renderMeshesFromList(QVector<int>& list, gpu::Batch& batch, RenderMod
qDebug() << "NEW part.materialID:" << part.materialID; qDebug() << "NEW part.materialID:" << part.materialID;
} }
if (locations->glowIntensity >= 0) { /* if (locations->glowIntensity >= 0) {
GLBATCH(glUniform1f)(locations->glowIntensity, glowEffect->getIntensity()); GLBATCH(glUniform1f)(locations->glowIntensity, glowEffect->getIntensity());
} }
if (!(translucent && alphaThreshold == 0.0f)) { if (!(translucent && alphaThreshold == 0.0f)) {
GLBATCH(glAlphaFunc)(GL_EQUAL, glowEffect->getIntensity()); GLBATCH(glAlphaFunc)(GL_EQUAL, glowEffect->getIntensity());
} }
*/
if (locations->materialBufferUnit >= 0) { if (locations->materialBufferUnit >= 0) {
batch.setUniformBuffer(locations->materialBufferUnit, material->getSchemaBuffer()); batch.setUniformBuffer(locations->materialBufferUnit, material->getSchemaBuffer());
} }

43
libraries/render-utils/src/Model.h
View file

@ -51,6 +51,8 @@ class Model : public QObject, public PhysicsEntity {
public: public:
typedef RenderArgs::RenderMode RenderMode;
static void setAbstractViewStateInterface(AbstractViewStateInterface* viewState) { _viewState = viewState; } static void setAbstractViewStateInterface(AbstractViewStateInterface* viewState) { _viewState = viewState; }
Model(QObject* parent = NULL); Model(QObject* parent = NULL);
@ -94,15 +96,13 @@ public:
void init(); void init();
void reset(); void reset();
virtual void simulate(float deltaTime, bool fullUpdate = true); virtual void simulate(float deltaTime, bool fullUpdate = true);
enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE }; bool render(float alpha = 1.0f, RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
bool render(float alpha = 1.0f, RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
// Scene rendering support // Scene rendering support
static void startScene(RenderArgs::RenderSide renderSide); static void startScene(RenderArgs::RenderSide renderSide);
bool renderInScene(float alpha = 1.0f, RenderArgs* args = NULL); bool renderInScene(float alpha = 1.0f, RenderArgs* args = NULL);
static void endScene(RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL); static void endScene(RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
/// Sets the URL of the model to render. /// Sets the URL of the model to render.
/// \param fallback the URL of a fallback model to render if the requested model fails to load /// \param fallback the URL of a fallback model to render if the requested model fails to load
@ -410,28 +410,28 @@ private:
static QVector<Model*> _modelsInScene; static QVector<Model*> _modelsInScene;
static gpu::Batch _sceneRenderBatch; static gpu::Batch _sceneRenderBatch;
static void endSceneSimple(RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL); static void endSceneSimple(RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
static void endSceneSplitPass(RenderMode mode = DEFAULT_RENDER_MODE, RenderArgs* args = NULL); static void endSceneSplitPass(RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
// helper functions used by render() or renderInScene() // helper functions used by render() or renderInScene()
void renderSetup(RenderArgs* args); void renderSetup(RenderArgs* args);
bool renderCore(float alpha, RenderMode mode, RenderArgs* args); bool renderCore(float alpha, RenderArgs::RenderMode mode, RenderArgs* args);
int renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, int renderMeshes(gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args = NULL, bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args = NULL,
bool forceRenderSomeMeshes = false); bool forceRenderSomeMeshes = false);
void setupBatchTransform(gpu::Batch& batch); void setupBatchTransform(gpu::Batch& batch);
QVector<int>* pickMeshList(bool translucent, float alphaThreshold, bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned); QVector<int>* pickMeshList(bool translucent, float alphaThreshold, bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned);
int renderMeshesFromList(QVector<int>& list, gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, int renderMeshesFromList(QVector<int>& list, gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
RenderArgs* args, Locations* locations, RenderArgs* args, Locations* locations,
bool forceRenderSomeMeshes = false); bool forceRenderSomeMeshes = false);
static void pickPrograms(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, static void pickPrograms(gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args, bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args,
Locations*& locations); Locations*& locations);
static int renderMeshesForModelsInScene(gpu::Batch& batch, RenderMode mode, bool translucent, float alphaThreshold, static int renderMeshesForModelsInScene(gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args); bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, RenderArgs* args);
@ -449,6 +449,7 @@ private:
IS_STEREO_FLAG, IS_STEREO_FLAG,
IS_DEPTH_ONLY_FLAG, IS_DEPTH_ONLY_FLAG,
IS_SHADOW_FLAG, IS_SHADOW_FLAG,
IS_MIRROR_FLAG, //THis means that the mesh is rendered mirrored, not the same as "Rear view mirror"
NUM_FLAGS, NUM_FLAGS,
}; };
@ -463,6 +464,7 @@ private:
IS_STEREO = (1 << IS_STEREO_FLAG), IS_STEREO = (1 << IS_STEREO_FLAG),
IS_DEPTH_ONLY = (1 << IS_DEPTH_ONLY_FLAG), IS_DEPTH_ONLY = (1 << IS_DEPTH_ONLY_FLAG),
IS_SHADOW = (1 << IS_SHADOW_FLAG), IS_SHADOW = (1 << IS_SHADOW_FLAG),
IS_MIRROR = (1 << IS_MIRROR_FLAG),
}; };
typedef unsigned short Flags; typedef unsigned short Flags;
@ -480,22 +482,25 @@ private:
bool isStereo() const { return isFlag(IS_STEREO); } bool isStereo() const { return isFlag(IS_STEREO); }
bool isDepthOnly() const { return isFlag(IS_DEPTH_ONLY); } bool isDepthOnly() const { return isFlag(IS_DEPTH_ONLY); }
bool isShadow() const { return isFlag(IS_SHADOW); } // = depth only but with back facing bool isShadow() const { return isFlag(IS_SHADOW); } // = depth only but with back facing
bool isMirror() const { return isFlag(IS_MIRROR); }
Flags _flags = 0; Flags _flags = 0;
short _spare = 0; short _spare = 0;
int getRaw() { return *reinterpret_cast<int*>(this); } int getRaw() { return *reinterpret_cast<int*>(this); }
RenderKey(RenderMode mode, RenderKey(RenderArgs::RenderMode mode,
bool translucent, float alphaThreshold, bool hasLightmap, bool translucent, float alphaThreshold, bool hasLightmap,
bool hasTangents, bool hasSpecular, bool isSkinned) : bool hasTangents, bool hasSpecular, bool isSkinned) :
RenderKey( ((translucent && (alphaThreshold == 0.0f) && (mode != SHADOW_RENDER_MODE)) ? IS_TRANSLUCENT : 0) RenderKey( ((translucent && (alphaThreshold == 0.0f) && (mode != RenderArgs::SHADOW_RENDER_MODE)) ? IS_TRANSLUCENT : 0)
| (hasLightmap && (mode != SHADOW_RENDER_MODE) ? HAS_LIGHTMAP : 0) // Lightmap, tangents and specular don't matter for depthOnly | (hasLightmap && (mode != RenderArgs::SHADOW_RENDER_MODE) ? HAS_LIGHTMAP : 0) // Lightmap, tangents and specular don't matter for depthOnly
| (hasTangents && (mode != SHADOW_RENDER_MODE) ? HAS_TANGENTS : 0) | (hasTangents && (mode != RenderArgs::SHADOW_RENDER_MODE) ? HAS_TANGENTS : 0)
| (hasSpecular && (mode != SHADOW_RENDER_MODE) ? HAS_SPECULAR : 0) | (hasSpecular && (mode != RenderArgs::SHADOW_RENDER_MODE) ? HAS_SPECULAR : 0)
| (isSkinned ? IS_SKINNED : 0) | (isSkinned ? IS_SKINNED : 0)
| ((mode == SHADOW_RENDER_MODE) ? IS_DEPTH_ONLY : 0) | ((mode == RenderArgs::SHADOW_RENDER_MODE) ? IS_DEPTH_ONLY : 0)
| ((mode == SHADOW_RENDER_MODE) ? IS_SHADOW : 0)) {} | ((mode == RenderArgs::SHADOW_RENDER_MODE) ? IS_SHADOW : 0)
| ((mode == RenderArgs::MIRROR_RENDER_MODE) ? IS_MIRROR :0)
) {}
RenderKey(int bitmask) : _flags(bitmask) {} RenderKey(int bitmask) : _flags(bitmask) {}
}; };

2
libraries/shared/src/RenderArgs.h
View file

@ -17,7 +17,7 @@ class OctreeRenderer;
class RenderArgs { class RenderArgs {
public: public:
enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE }; enum RenderMode { DEFAULT_RENDER_MODE, SHADOW_RENDER_MODE, DIFFUSE_RENDER_MODE, NORMAL_RENDER_MODE, MIRROR_RENDER_MODE };
enum RenderSide { MONO, STEREO_LEFT, STEREO_RIGHT }; enum RenderSide { MONO, STEREO_LEFT, STEREO_RIGHT };
OctreeRenderer* _renderer; OctreeRenderer* _renderer;