Mirrors/overte-HifiExperiments
3
0
Fork 0
mirror of https://github.com/HifiExperiments/overte.git synced 2025-08-04 13:17:59 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

merge with upstream team-teaching

Browse source
This commit is contained in:
Sam Gateau 2015-05-24 19:45:37 -07:00
commit f0ab6d96f5
52 changed files with 334 additions and 445 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
assignment-client/src/octree/OctreeQueryNode.cpp
View file

@ -325,8 +325,7 @@ void OctreeQueryNode::updateLastKnownViewFrustum() {
}
// save that we know the view has been sent.
quint64 now = usecTimestampNow();
setLastTimeBagEmpty(now); // is this what we want? poor names
setLastTimeBagEmpty();
}

6
assignment-client/src/octree/OctreeQueryNode.h
View file

@ -77,7 +77,7 @@ public:
bool moveShouldDump() const;
quint64 getLastTimeBagEmpty() const { return _lastTimeBagEmpty; }
void setLastTimeBagEmpty(quint64 lastTimeBagEmpty) { _lastTimeBagEmpty = lastTimeBagEmpty; }
void setLastTimeBagEmpty() { _lastTimeBagEmpty = _sceneSendStartTime; }
bool getCurrentPacketIsColor() const { return _currentPacketIsColor; }
bool getCurrentPacketIsCompressed() const { return _currentPacketIsCompressed; }
@ -98,6 +98,8 @@ public:
void setLastRootTimestamp(quint64 timestamp) { _lastRootTimestamp = timestamp; }
unsigned int getlastOctreePacketLength() const { return _lastOctreePacketLength; }
int getDuplicatePacketCount() const { return _duplicatePacketCount; }
void sceneStart(quint64 sceneSendStartTime) { _sceneSendStartTime = sceneSendStartTime; }
void nodeKilled();
void forceNodeShutdown();
@ -158,6 +160,8 @@ private:
SentPacketHistory _sentPacketHistory;
QQueue<OCTREE_PACKET_SEQUENCE> _nackedSequenceNumbers;
quint64 _sceneSendStartTime = 0;
};
#endif // hifi_OctreeQueryNode_h

16
assignment-client/src/octree/OctreeSendThread.cpp
View file

@ -343,8 +343,7 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
if (!viewFrustumChanged && !nodeData->getWantDelta()) {
// only set our last sent time if we weren't resetting due to frustum change
quint64 now = usecTimestampNow();
nodeData->setLastTimeBagEmpty(now);
nodeData->setLastTimeBagEmpty();
}
// track completed scenes and send out the stats packet accordingly
@ -368,9 +367,11 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
// TODO: add these to stats page
//::startSceneSleepTime = _usleepTime;
nodeData->sceneStart(usecTimestampNow() - CHANGE_FUDGE);
// start tracking our stats
nodeData->stats.sceneStarted(isFullScene, viewFrustumChanged, _myServer->getOctree()->getRoot(), _myServer->getJurisdiction());
nodeData->stats.sceneStarted(isFullScene, viewFrustumChanged,
_myServer->getOctree()->getRoot(), _myServer->getJurisdiction());
// This is the start of "resending" the scene.
bool dontRestartSceneOnMove = false; // this is experimental
@ -561,6 +562,13 @@ int OctreeSendThread::packetDistributor(OctreeQueryNode* nodeData, bool viewFrus
}
if (somethingToSend) {
qDebug() << "Hit PPS Limit, packetsSentThisInterval =" << packetsSentThisInterval
<< " maxPacketsPerInterval = " << maxPacketsPerInterval
<< " clientMaxPacketsPerInterval = " << clientMaxPacketsPerInterval;
}
// Here's where we can/should allow the server to send other data...
// send the environment packet
// TODO: should we turn this into a while loop to better handle sending multiple special packets

1
examples/defaultScripts.js
View file

@ -15,7 +15,6 @@ Script.load("controllers/hydra/hydraMove.js");
Script.load("inspect.js");
Script.load("lobby.js");
Script.load("notifications.js");
Script.load("look.js");
Script.load("users.js");
Script.load("grab.js");
Script.load("pointer.js");

183
examples/look.js
View file

@ -1,183 +0,0 @@
//
// look.js
// examples
//
// Copyright 2015 High Fidelity, Inc.
//
// This is an example script that demonstrates use of the Controller class
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
var wantDebugging = false;
// Configuration
var TOUCH_YAW_SCALE = -0.25;
var TOUCH_PITCH_SCALE = -12.5;
var FIXED_TOUCH_TIMESTEP = 0.016;
var MOUSE_YAW_SCALE = -0.25;
var MOUSE_PITCH_SCALE = -12.5;
var FIXED_MOUSE_TIMESTEP = 0.016;
// Mouse Data
var alwaysLook = false; // if you want the mouse look to happen only when you click, change this to false
var isMouseDown = false;
var lastTouchX = 0;
var lastTouchY = 0;
var yawFromTouch = 0;
var pitchFromTouch = 0;
// Touch Data
var TIME_BEFORE_GENERATED_END_TOUCH_EVENT = 50; // ms
var startedTouching = false;
var lastTouchEvent = 0;
var lastMouseX = 0;
var lastMouseY = 0;
var yawFromMouse = 0;
var pitchFromMouse = 0;
// Mouse Events
function mousePressEvent(event) {
if (wantDebugging) {
print("mousePressEvent event.x,y=" + event.x + ", " + event.y);
}
if (event.isRightButton) {
isMouseDown = true;
lastMouseX = event.x;
lastMouseY = event.y;
}
}
function mouseReleaseEvent(event) {
if (wantDebugging) {
print("mouseReleaseEvent event.x,y=" + event.x + ", " + event.y);
}
isMouseDown = false;
}
function mouseMoveEvent(event) {
if (wantDebugging) {
print("mouseMoveEvent event.x,y=" + event.x + ", " + event.y);
}
if (alwaysLook || isMouseDown) {
yawFromMouse += ((event.x - lastMouseX) * MOUSE_YAW_SCALE * FIXED_MOUSE_TIMESTEP);
pitchFromMouse += ((event.y - lastMouseY) * MOUSE_PITCH_SCALE * FIXED_MOUSE_TIMESTEP);
lastMouseX = event.x;
lastMouseY = event.y;
}
}
// Touch Events
function touchBeginEvent(event) {
if (wantDebugging) {
print("touchBeginEvent event.x,y=" + event.x + ", " + event.y);
}
lastTouchX = event.x;
lastTouchY = event.y;
yawFromTouch = 0;
pitchFromTouch = 0;
startedTouching = true;
var d = new Date();
lastTouchEvent = d.getTime();
}
function touchEndEvent(event) {
if (wantDebugging) {
if (event) {
print("touchEndEvent event.x,y=" + event.x + ", " + event.y);
} else {
print("touchEndEvent generated");
}
}
startedTouching = false;
}
function touchUpdateEvent(event) {
// print("TOUCH UPDATE");
if (wantDebugging) {
print("touchUpdateEvent event.x,y=" + event.x + ", " + event.y);
}
if (!startedTouching) {
// handle Qt 5.4.x bug where we get touch update without a touch begin event
touchBeginEvent(event);
return;
}
yawFromTouch += ((event.x - lastTouchX) * TOUCH_YAW_SCALE * FIXED_TOUCH_TIMESTEP);
pitchFromTouch += ((event.y - lastTouchY) * TOUCH_PITCH_SCALE * FIXED_TOUCH_TIMESTEP);
lastTouchX = event.x;
lastTouchY = event.y;
var d = new Date();
lastTouchEvent = d.getTime();
}
function update(deltaTime) {
if (wantDebugging) {
print("update()...");
}
if (startedTouching) {
var d = new Date();
var sinceLastTouch = d.getTime() - lastTouchEvent;
if (sinceLastTouch > TIME_BEFORE_GENERATED_END_TOUCH_EVENT) {
touchEndEvent();
}
}
if (yawFromTouch != 0 || yawFromMouse != 0) {
var newOrientation = Quat.multiply(MyAvatar.orientation, Quat.fromPitchYawRollRadians(0, yawFromTouch + yawFromMouse, 0));
if (wantDebugging) {
print("changing orientation"
+ " [old]MyAvatar.orientation="+MyAvatar.orientation.x + "," + MyAvatar.orientation.y + ","
+ MyAvatar.orientation.z + "," + MyAvatar.orientation.w
+ " newOrientation="+newOrientation.x + "," + newOrientation.y + "," + newOrientation.z + "," + newOrientation.w);
}
MyAvatar.orientation = newOrientation;
yawFromTouch = 0;
yawFromMouse = 0;
}
if (pitchFromTouch != 0 || pitchFromMouse != 0) {
var newPitch = MyAvatar.headPitch + pitchFromTouch + pitchFromMouse;
if (wantDebugging) {
print("changing pitch [old]MyAvatar.headPitch="+MyAvatar.headPitch+ " newPitch="+newPitch);
}
MyAvatar.headPitch = newPitch;
pitchFromTouch = 0;
pitchFromMouse = 0;
}
}
// Map the mouse events to our functions
Controller.mousePressEvent.connect(mousePressEvent);
Controller.mouseMoveEvent.connect(mouseMoveEvent);
Controller.mouseReleaseEvent.connect(mouseReleaseEvent);
// Map the mouse events to our functions
Controller.touchBeginEvent.connect(touchBeginEvent);
Controller.touchUpdateEvent.connect(touchUpdateEvent);
Controller.touchEndEvent.connect(touchEndEvent);
// disable the standard application for mouse events
Controller.captureTouchEvents();
function scriptEnding() {
// re-enabled the standard application for mouse events
Controller.releaseTouchEvents();
}
// would be nice to change to update
Script.update.connect(update);
Script.scriptEnding.connect(scriptEnding);

0
examples/ajt-test.js → examples/particles.js
View file

84
interface/src/Application.cpp
View file

@ -116,6 +116,7 @@
#include "devices/TV3DManager.h"
#include "gpu/Batch.h"
#include "gpu/Context.h"
#include "gpu/GLBackend.h"
#include "scripting/AccountScriptingInterface.h"
@ -835,6 +836,13 @@ void Application::initializeUi() {
void Application::paintGL() {
PROFILE_RANGE(__FUNCTION__);
_glWidget->makeCurrent();
auto lodManager = DependencyManager::get<LODManager>();
gpu::Context context;
RenderArgs renderArgs(&context, nullptr, getViewFrustum(), lodManager->getOctreeSizeScale(),
lodManager->getBoundaryLevelAdjust(), RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
PerformanceTimer perfTimer("paintGL");
//Need accurate frame timing for the oculus rift
if (OculusManager::isConnected()) {
@ -848,7 +856,7 @@ void Application::paintGL() {
{
PerformanceTimer perfTimer("renderOverlay");
_applicationOverlay.renderOverlay();
_applicationOverlay.renderOverlay(&renderArgs);
}
glEnable(GL_LINE_SMOOTH);
@ -897,22 +905,25 @@ void Application::paintGL() {
loadViewFrustum(_myCamera, _viewFrustum);
if (getShadowsEnabled()) {
updateShadowMap();
renderArgs._renderMode = RenderArgs::SHADOW_RENDER_MODE;
updateShadowMap(&renderArgs);
}
renderArgs._renderMode = RenderArgs::DEFAULT_RENDER_MODE;
if (OculusManager::isConnected()) {
//When in mirror mode, use camera rotation. Otherwise, use body rotation
if (_myCamera.getMode() == CAMERA_MODE_MIRROR) {
OculusManager::display(_glWidget, _myCamera.getRotation(), _myCamera.getPosition(), _myCamera);
OculusManager::display(_glWidget, &renderArgs, _myCamera.getRotation(), _myCamera.getPosition(), _myCamera);
} else {
OculusManager::display(_glWidget, _myAvatar->getWorldAlignedOrientation(), _myAvatar->getDefaultEyePosition(), _myCamera);
OculusManager::display(_glWidget, &renderArgs, _myAvatar->getWorldAlignedOrientation(), _myAvatar->getDefaultEyePosition(), _myCamera);
}
} else if (TV3DManager::isConnected()) {
TV3DManager::display(_myCamera);
TV3DManager::display(&renderArgs, _myCamera);
} else {
DependencyManager::get<GlowEffect>()->prepare();
DependencyManager::get<GlowEffect>()->prepare(&renderArgs);
// Viewport is assigned to the size of the framebuffer
QSize size = DependencyManager::get<TextureCache>()->getFrameBufferSize();
@ -921,16 +932,16 @@ void Application::paintGL() {
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
displaySide(_myCamera);
displaySide(&renderArgs, _myCamera);
glPopMatrix();
if (Menu::getInstance()->isOptionChecked(MenuOption::FullscreenMirror)) {
_rearMirrorTools->render(true, _glWidget->mapFromGlobal(QCursor::pos()));
_rearMirrorTools->render(&renderArgs, true, _glWidget->mapFromGlobal(QCursor::pos()));
} else if (Menu::getInstance()->isOptionChecked(MenuOption::Mirror)) {
renderRearViewMirror(_mirrorViewRect);
renderRearViewMirror(&renderArgs, _mirrorViewRect);
}
auto finalFbo = DependencyManager::get<GlowEffect>()->render();
auto finalFbo = DependencyManager::get<GlowEffect>()->render(&renderArgs);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
glBindFramebuffer(GL_READ_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(finalFbo));
@ -2884,7 +2895,7 @@ glm::vec3 Application::getSunDirection() {
// FIXME, preprocessor guard this check to occur only in DEBUG builds
static QThread * activeRenderingThread = nullptr;
void Application::updateShadowMap() {
void Application::updateShadowMap(RenderArgs* renderArgs) {
activeRenderingThread = QThread::currentThread();
PerformanceTimer perfTimer("shadowMap");
@ -3005,23 +3016,23 @@ void Application::updateShadowMap() {
{
PerformanceTimer perfTimer("avatarManager");
DependencyManager::get<AvatarManager>()->renderAvatars(RenderArgs::SHADOW_RENDER_MODE);
DependencyManager::get<AvatarManager>()->renderAvatars(renderArgs);
}
{
PerformanceTimer perfTimer("entities");
_entities.render(RenderArgs::SHADOW_RENDER_MODE);
_entities.render(renderArgs);
}
// render JS/scriptable overlays
{
PerformanceTimer perfTimer("3dOverlays");
_overlays.renderWorld(false, RenderArgs::SHADOW_RENDER_MODE);
_overlays.renderWorld(renderArgs, false);
}
{
PerformanceTimer perfTimer("3dOverlaysFront");
_overlays.renderWorld(true, RenderArgs::SHADOW_RENDER_MODE);
_overlays.renderWorld(renderArgs, true);
}
glDisable(GL_POLYGON_OFFSET_FILL);
@ -3089,15 +3100,16 @@ PickRay Application::computePickRay(float x, float y) const {
return result;
}
QImage Application::renderAvatarBillboard() {
QImage Application::renderAvatarBillboard(RenderArgs* renderArgs) {
auto primaryFramebuffer = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
glBindFramebuffer(GL_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(primaryFramebuffer));
// the "glow" here causes an alpha of one
Glower glower;
Glower glower(renderArgs);
const int BILLBOARD_SIZE = 64;
renderRearViewMirror(QRect(0, _glWidget->getDeviceHeight() - BILLBOARD_SIZE,
// TODO: Pass a RenderArgs to renderAvatarBillboard
renderRearViewMirror(renderArgs, QRect(0, _glWidget->getDeviceHeight() - BILLBOARD_SIZE,
BILLBOARD_SIZE, BILLBOARD_SIZE),
true);
@ -3152,6 +3164,7 @@ const ViewFrustum* Application::getDisplayViewFrustum() const {
class MyFirstStuff {
public:
typedef render::Payload<MyFirstStuff> Payload;
typedef std::shared_ptr<Payload> PayloadPointer;
typedef std::shared_ptr<MyFirstStuff> Pointer;
};
@ -3164,8 +3177,7 @@ template <> void render::payloadRender(const MyFirstStuff::Pointer& stuff, Rende
}
}
void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs::RenderSide renderSide) {
void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool selfAvatarOnly) {
activeRenderingThread = QThread::currentThread();
PROFILE_RANGE(__FUNCTION__);
PerformanceTimer perfTimer("display");
@ -3204,7 +3216,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
viewTransform.setScale(Transform::Vec3(-1.0f, 1.0f, 1.0f));
}
if (renderSide != RenderArgs::MONO) {
if (renderArgs->_renderSide != RenderArgs::MONO) {
glm::mat4 invView = glm::inverse(_untranslatedViewMatrix);
viewTransform.evalFromRawMatrix(invView);
@ -3335,7 +3347,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
// render JS/scriptable overlays
{
PerformanceTimer perfTimer("3dOverlays");
_overlays.renderWorld(false);
_overlays.renderWorld(renderArgs, false);
}
// render models...
@ -3357,7 +3369,9 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
if (theCamera.getMode() == CAMERA_MODE_MIRROR) {
renderMode = RenderArgs::MIRROR_RENDER_MODE;
}
_entities.render(renderMode, renderSide, renderDebugFlags);
renderArgs->_renderMode = renderMode;
renderArgs->_debugFlags = renderDebugFlags;
_entities.render(renderArgs);
if (!Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) {
// Restaure polygon mode
@ -3378,14 +3392,15 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
{
PerformanceTimer perfTimer("avatars");
DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE,
false, selfAvatarOnly);
renderArgs->_renderMode = mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE;
DependencyManager::get<AvatarManager>()->renderAvatars(renderArgs, false, selfAvatarOnly);
renderArgs->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
}
static render::ItemID myFirstRenderItem = 0;
if (myFirstRenderItem == 0) {
std::shared_ptr<MyFirstStuff::Payload> myFirstPayload(new MyFirstStuff::Payload(std::shared_ptr<MyFirstStuff>(new MyFirstStuff())));
auto myFirstPayload = MyFirstStuff::PayloadPointer(new MyFirstStuff::Payload(std::shared_ptr<MyFirstStuff>(new MyFirstStuff())));
myFirstRenderItem = _main3DScene->allocateID();
render::Scene::PendingChanges pendingChanges;
@ -3413,8 +3428,9 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
{
PerformanceTimer perfTimer("avatarsPostLighting");
DependencyManager::get<AvatarManager>()->renderAvatars(mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE,
true, selfAvatarOnly);
renderArgs->_renderMode = mirrorMode ? RenderArgs::MIRROR_RENDER_MODE : RenderArgs::NORMAL_RENDER_MODE;
DependencyManager::get<AvatarManager>()->renderAvatars(renderArgs, true, selfAvatarOnly);
renderArgs->_renderMode = RenderArgs::NORMAL_RENDER_MODE;
}
//Render the sixense lasers
@ -3438,7 +3454,7 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
"Application::displaySide() ... octree fades...");
_octreeFadesLock.lockForWrite();
for(std::vector<OctreeFade>::iterator fade = _octreeFades.begin(); fade != _octreeFades.end();) {
fade->render();
fade->render(renderArgs);
if(fade->isDone()) {
fade = _octreeFades.erase(fade);
} else {
@ -3463,8 +3479,8 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
{
PerformanceTimer perfTimer("3dOverlaysFront");
glClear(GL_DEPTH_BUFFER_BIT);
Glower glower; // Sets alpha to 1.0
_overlays.renderWorld(true);
Glower glower(renderArgs); // Sets alpha to 1.0
_overlays.renderWorld(renderArgs, true);
}
activeRenderingThread = nullptr;
}
@ -3542,7 +3558,7 @@ glm::vec2 Application::getScaledScreenPoint(glm::vec2 projectedPoint) {
return screenPoint;
}
void Application::renderRearViewMirror(const QRect& region, bool billboard) {
void Application::renderRearViewMirror(RenderArgs* renderArgs, const QRect& region, bool billboard) {
// Grab current viewport to reset it at the end
int viewport[4];
glGetIntegerv(GL_VIEWPORT, viewport);
@ -3602,11 +3618,11 @@ void Application::renderRearViewMirror(const QRect& region, bool billboard) {
// render rear mirror view
glPushMatrix();
displaySide(_mirrorCamera, true);
displaySide(renderArgs, _mirrorCamera, true);
glPopMatrix();
if (!billboard) {
_rearMirrorTools->render(false, _glWidget->mapFromGlobal(QCursor::pos()));
_rearMirrorTools->render(renderArgs, false, _glWidget->mapFromGlobal(QCursor::pos()));
}
// reset Viewport and projection matrix

8
interface/src/Application.h
View file

@ -269,9 +269,9 @@ public:
virtual void setupWorldLight();
virtual bool shouldRenderMesh(float largestDimension, float distanceToCamera);
QImage renderAvatarBillboard();
QImage renderAvatarBillboard(RenderArgs* renderArgs);
void displaySide(Camera& whichCamera, bool selfAvatarOnly = false, RenderArgs::RenderSide renderSide = RenderArgs::MONO);
void displaySide(RenderArgs* renderArgs, Camera& whichCamera, bool selfAvatarOnly = false);
/// Stores the current modelview matrix as the untranslated view matrix to use for transforms and the supplied vector as
/// the view matrix translation.
@ -500,8 +500,8 @@ private:
glm::vec3 getSunDirection();
void updateShadowMap();
void renderRearViewMirror(const QRect& region, bool billboard = false);
void updateShadowMap(RenderArgs* renderArgs);
void renderRearViewMirror(RenderArgs* renderArgs, const QRect& region, bool billboard = false);
void setMenuShortcutsEnabled(bool enabled);
static void attachNewHeadToNode(Node *newNode);

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

@ -268,7 +268,7 @@ static TextRenderer* textRenderer(TextRendererType type) {
return displayNameRenderer;
}
void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode, bool postLighting) {
void Avatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {
if (_referential) {
_referential->update();
}
@ -339,7 +339,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
// simple frustum check
float boundingRadius = getBillboardSize();
ViewFrustum* frustum = nullptr;
if (renderMode == RenderArgs::SHADOW_RENDER_MODE) {
if (renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) {
frustum = Application::getInstance()->getShadowViewFrustum();
} else {
frustum = Application::getInstance()->getDisplayViewFrustum();
@ -365,14 +365,14 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
GLOW_FROM_AVERAGE_LOUDNESS = 0.0f;
}
float glowLevel = _moving && distanceToTarget > GLOW_DISTANCE && renderMode == RenderArgs::NORMAL_RENDER_MODE
float glowLevel = _moving && distanceToTarget > GLOW_DISTANCE && renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE
? 1.0f
: GLOW_FROM_AVERAGE_LOUDNESS;
// render body
renderBody(frustum, renderMode, postLighting, glowLevel);
renderBody(renderArgs, frustum, postLighting, glowLevel);
if (!postLighting && renderMode != RenderArgs::SHADOW_RENDER_MODE) {
if (!postLighting && renderArgs->_renderMode != RenderArgs::SHADOW_RENDER_MODE) {
// add local lights
const float BASE_LIGHT_DISTANCE = 2.0f;
const float LIGHT_EXPONENT = 1.0f;
@ -396,10 +396,10 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
_skeletonModel.renderJointCollisionShapes(0.7f);
}
if (renderHead && shouldRenderHead(cameraPosition, renderMode)) {
if (renderHead && shouldRenderHead(renderArgs, cameraPosition)) {
getHead()->getFaceModel().renderJointCollisionShapes(0.7f);
}
if (renderBounding && shouldRenderHead(cameraPosition, renderMode)) {
if (renderBounding && shouldRenderHead(renderArgs, cameraPosition)) {
_skeletonModel.renderBoundingCollisionShapes(0.7f);
}
@ -436,7 +436,7 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
float angle = abs(angleBetween(toTarget + delta, toTarget - delta));
float sphereRadius = getHead()->getAverageLoudness() * SPHERE_LOUDNESS_SCALING;
if (renderMode == RenderArgs::NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) &&
if (renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE && (sphereRadius > MIN_SPHERE_SIZE) &&
(angle < MAX_SPHERE_ANGLE) && (angle > MIN_SPHERE_ANGLE)) {
glPushMatrix();
glTranslatef(_position.x, _position.y, _position.z);
@ -455,8 +455,8 @@ void Avatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode rend
}
const float DISPLAYNAME_DISTANCE = 20.0f;
setShowDisplayName(renderMode == RenderArgs::NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);
if (!postLighting || renderMode != RenderArgs::NORMAL_RENDER_MODE || (isMyAvatar() &&
setShowDisplayName(renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE && distanceToTarget < DISPLAYNAME_DISTANCE);
if (!postLighting || renderArgs->_renderMode != RenderArgs::NORMAL_RENDER_MODE || (isMyAvatar() &&
Application::getInstance()->getCamera()->getMode() == CAMERA_MODE_FIRST_PERSON)) {
return;
}
@ -479,13 +479,12 @@ glm::quat Avatar::computeRotationFromBodyToWorldUp(float proportion) const {
return glm::angleAxis(angle * proportion, axis);
}
void Avatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel) {
Model::RenderMode modelRenderMode = renderMode;
void Avatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel) {
{
Glower glower(glowLevel);
Glower glower(renderArgs, glowLevel);
if (_shouldRenderBillboard || !(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
if (postLighting || renderMode == RenderArgs::SHADOW_RENDER_MODE) {
if (postLighting || renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) {
// render the billboard until both models are loaded
renderBillboard();
}
@ -493,18 +492,16 @@ void Avatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode rende
}
if (postLighting) {
getHand()->render(false, modelRenderMode);
getHand()->render(renderArgs, false);
} else {
RenderArgs args;
args._viewFrustum = renderFrustum;
_skeletonModel.render(1.0f, modelRenderMode, &args);
renderAttachments(renderMode, &args);
_skeletonModel.render(renderArgs, 1.0f);
renderAttachments(renderArgs);
}
}
getHead()->render(1.0f, renderFrustum, modelRenderMode, postLighting);
getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
}
bool Avatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const {
bool Avatar::shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const {
return true;
}
@ -528,11 +525,11 @@ void Avatar::simulateAttachments(float deltaTime) {
}
}
void Avatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args) {
void Avatar::renderAttachments(RenderArgs* args) {
// RenderArgs::RenderMode modelRenderMode = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
// RenderArgs::SHADOW_RENDER_MODE : RenderArgs::DEFAULT_RENDER_MODE;
foreach (Model* model, _attachmentModels) {
model->render(1.0f, renderMode, args);
model->render(args, 1.0f);
}
}

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

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

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

@ -115,7 +115,7 @@ void AvatarManager::updateOtherAvatars(float deltaTime) {
simulateAvatarFades(deltaTime);
}
void AvatarManager::renderAvatars(RenderArgs::RenderMode renderMode, bool postLighting, bool selfAvatarOnly) {
void AvatarManager::renderAvatars(RenderArgs* renderArgs, bool postLighting, bool selfAvatarOnly) {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
"Application::renderAvatars()");
bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::RenderLookAtVectors);
@ -129,14 +129,14 @@ void AvatarManager::renderAvatars(RenderArgs::RenderMode renderMode, bool postLi
if (!avatar->isInitialized()) {
continue;
}
avatar->render(cameraPosition, renderMode, postLighting);
avatar->render(renderArgs, cameraPosition, postLighting);
avatar->setDisplayingLookatVectors(renderLookAtVectors);
}
renderAvatarFades(cameraPosition, renderMode);
renderAvatarFades(renderArgs, cameraPosition);
}
} else {
// just render myAvatar
_myAvatar->render(cameraPosition, renderMode, postLighting);
_myAvatar->render(renderArgs, cameraPosition, postLighting);
_myAvatar->setDisplayingLookatVectors(renderLookAtVectors);
}
}
@ -159,14 +159,14 @@ void AvatarManager::simulateAvatarFades(float deltaTime) {
}
}
void AvatarManager::renderAvatarFades(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) {
void AvatarManager::renderAvatarFades(RenderArgs* renderArgs, const glm::vec3& cameraPosition) {
// render avatar fades
Glower glower(renderMode == RenderArgs::NORMAL_RENDER_MODE ? 1.0f : 0.0f);
Glower glower(renderArgs, renderArgs->_renderMode == RenderArgs::NORMAL_RENDER_MODE ? 1.0f : 0.0f);
foreach(const AvatarSharedPointer& fadingAvatar, _avatarFades) {
Avatar* avatar = static_cast<Avatar*>(fadingAvatar.data());
if (avatar != static_cast<Avatar*>(_myAvatar.data()) && avatar->isInitialized()) {
avatar->render(cameraPosition, renderMode);
avatar->render(renderArgs, cameraPosition);
}
}
}

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

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

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

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

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

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

14
interface/src/avatar/Head.cpp
View file

@ -262,15 +262,13 @@ void Head::relaxLean(float deltaTime) {
_deltaLeanForward *= relaxationFactor;
}
void Head::render(float alpha, ViewFrustum* renderFrustum, Model::RenderMode mode, bool postLighting) {
void Head::render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum, bool postLighting) {
if (postLighting) {
if (_renderLookatVectors) {
renderLookatVectors(_leftEyePosition, _rightEyePosition, getCorrectedLookAtPosition());
renderLookatVectors(renderArgs, _leftEyePosition, _rightEyePosition, getCorrectedLookAtPosition());
}
} else {
RenderArgs args;
args._viewFrustum = renderFrustum;
_faceModel.render(alpha, mode, &args);
_faceModel.render(renderArgs, alpha);
}
}
@ -353,9 +351,9 @@ void Head::addLeanDeltas(float sideways, float forward) {
_deltaLeanForward += forward;
}
void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition) {
void Head::renderLookatVectors(RenderArgs* renderArgs, glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition) {
auto geometryCache = DependencyManager::get<GeometryCache>();
DependencyManager::get<GlowEffect>()->begin();
DependencyManager::get<GlowEffect>()->begin(renderArgs);
glLineWidth(2.0);
@ -364,7 +362,7 @@ void Head::renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosi
geometryCache->renderLine(leftEyePosition, lookatPosition, startColor, endColor, _leftEyeLookAtID);
geometryCache->renderLine(rightEyePosition, lookatPosition, startColor, endColor, _rightEyeLookAtID);
DependencyManager::get<GlowEffect>()->end();
DependencyManager::get<GlowEffect>()->end(renderArgs);
}

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

@ -40,7 +40,7 @@ public:
void init();
void reset();
void simulate(float deltaTime, bool isMine, bool billboard = false);
void render(float alpha, ViewFrustum* renderFrustum, Model::RenderMode mode, bool postLighting);
void render(RenderArgs* renderArgs, float alpha, ViewFrustum* renderFrustum, bool postLighting);
void setScale(float scale);
void setPosition(glm::vec3 position) { _position = position; }
void setAverageLoudness(float averageLoudness) { _averageLoudness = averageLoudness; }
@ -153,7 +153,7 @@ private:
int _rightEyeLookAtID;
// private methods
void renderLookatVectors(glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition);
void renderLookatVectors(RenderArgs* renderArgs, glm::vec3 leftEyePosition, glm::vec3 rightEyePosition, glm::vec3 lookatPosition);
void calculateMouthShapes();
friend class FaceModel;

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

@ -328,13 +328,13 @@ void MyAvatar::renderDebugBodyPoints() {
}
// virtual
void MyAvatar::render(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode, bool postLighting) {
void MyAvatar::render(RenderArgs* renderArgs, const glm::vec3& cameraPosition, bool postLighting) {
// don't render if we've been asked to disable local rendering
if (!_shouldRender) {
return; // exit early
}
Avatar::render(cameraPosition, renderMode, postLighting);
Avatar::render(renderArgs, cameraPosition, postLighting);
// don't display IK constraints in shadow mode
if (Menu::getInstance()->isOptionChecked(MenuOption::ShowIKConstraints) && postLighting) {
@ -1166,7 +1166,7 @@ void MyAvatar::attach(const QString& modelURL, const QString& jointName, const g
Avatar::attach(modelURL, jointName, translation, rotation, scale, allowDuplicates, useSaved);
}
void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode renderMode, bool postLighting, float glowLevel) {
void MyAvatar::renderBody(RenderArgs* renderArgs, ViewFrustum* renderFrustum, bool postLighting, float glowLevel) {
if (!(_skeletonModel.isRenderable() && getHead()->getFaceModel().isRenderable())) {
return; // wait until both models are loaded
}
@ -1190,28 +1190,25 @@ void MyAvatar::renderBody(ViewFrustum* renderFrustum, RenderArgs::RenderMode ren
}*/
// Render the body's voxels and head
RenderArgs::RenderMode modelRenderMode = renderMode;
if (!postLighting) {
RenderArgs args;
args._viewFrustum = renderFrustum;
_skeletonModel.render(1.0f, modelRenderMode, &args);
renderAttachments(renderMode, &args);
_skeletonModel.render(renderArgs, 1.0f);
renderAttachments(renderArgs);
}
// Render head so long as the camera isn't inside it
if (shouldRenderHead(cameraPos, renderMode)) {
getHead()->render(1.0f, renderFrustum, modelRenderMode, postLighting);
if (shouldRenderHead(renderArgs, cameraPos)) {
getHead()->render(renderArgs, 1.0f, renderFrustum, postLighting);
}
if (postLighting) {
getHand()->render(true, modelRenderMode);
getHand()->render(renderArgs, true);
}
}
const float RENDER_HEAD_CUTOFF_DISTANCE = 0.50f;
bool MyAvatar::shouldRenderHead(const glm::vec3& cameraPosition, RenderArgs::RenderMode renderMode) const {
bool MyAvatar::shouldRenderHead(const RenderArgs* renderArgs, const glm::vec3& cameraPosition) const {
const Head* head = getHead();
return (renderMode != RenderArgs::NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) ||
return (renderArgs->_renderMode != RenderArgs::NORMAL_RENDER_MODE) || (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON) ||
(glm::length(cameraPosition - head->getEyePosition()) > RENDER_HEAD_CUTOFF_DISTANCE * _scale);
}
@ -1474,7 +1471,8 @@ void MyAvatar::maybeUpdateBillboard() {
return;
}
}
QImage image = Application::getInstance()->renderAvatarBillboard();
RenderArgs renderArgs;
QImage image = Application::getInstance()->renderAvatarBillboard(&renderArgs);
_billboard.clear();
QBuffer buffer(&_billboard);
buffer.open(QIODevice::WriteOnly);
@ -1551,9 +1549,9 @@ void MyAvatar::updateMotionBehavior() {
_feetTouchFloor = menu->isOptionChecked(MenuOption::ShiftHipsForIdleAnimations);
}
void MyAvatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs* args) {
if (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON || renderMode == RenderArgs::MIRROR_RENDER_MODE) {
Avatar::renderAttachments(renderMode, args);
void MyAvatar::renderAttachments(RenderArgs* args) {
if (Application::getInstance()->getCamera()->getMode() != CAMERA_MODE_FIRST_PERSON || args->_renderMode == RenderArgs::MIRROR_RENDER_MODE) {
Avatar::renderAttachments(args);
return;
}
const FBXGeometry& geometry = _skeletonModel.getGeometry()->getFBXGeometry();
@ -1563,7 +1561,7 @@ void MyAvatar::renderAttachments(RenderArgs::RenderMode renderMode, RenderArgs*
for (int i = 0; i < _attachmentData.size(); i++) {
const QString& jointName = _attachmentData.at(i).jointName;
if (jointName != headJointName && jointName != "Head") {
_attachmentModels.at(i)->render(1.0f, renderMode, args);
_attachmentModels.at(i)->render(args, 1.0f);
}
}
}

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

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

9
interface/src/devices/OculusManager.cpp
View file

@ -465,7 +465,7 @@ void OculusManager::configureCamera(Camera& camera) {
}
//Displays everything for the oculus, frame timing must be active
void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera) {
void OculusManager::display(QGLWidget * glCanvas, RenderArgs* renderArgs, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera) {
#ifdef DEBUG
// Ensure the frame counter always increments by exactly 1
@ -532,7 +532,7 @@ void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientati
//Bind our framebuffer object. If we are rendering the glow effect, we let the glow effect shader take care of it
if (Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect)) {
DependencyManager::get<GlowEffect>()->prepare();
DependencyManager::get<GlowEffect>()->prepare(renderArgs);
} else {
auto primaryFBO = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
glBindFramebuffer(GL_FRAMEBUFFER, gpu::GLBackend::getFramebufferID(primaryFBO));
@ -613,7 +613,8 @@ void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientati
glViewport(vp.Pos.x, vp.Pos.y, vp.Size.w, vp.Size.h);
qApp->displaySide(*_camera, false, RenderArgs::MONO);
renderArgs->_renderSide = RenderArgs::MONO;
qApp->displaySide(renderArgs, *_camera, false);
qApp->getApplicationOverlay().displayOverlayTextureHmd(*_camera);
});
_activeEye = ovrEye_Count;
@ -625,7 +626,7 @@ void OculusManager::display(QGLWidget * glCanvas, const glm::quat &bodyOrientati
if (Menu::getInstance()->isOptionChecked(MenuOption::EnableGlowEffect)) {
//Full texture viewport for glow effect
glViewport(0, 0, _renderTargetSize.w, _renderTargetSize.h);
finalFbo = DependencyManager::get<GlowEffect>()->render();
finalFbo = DependencyManager::get<GlowEffect>()->render(renderArgs);
} else {
finalFbo = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
glBindFramebuffer(GL_FRAMEBUFFER, 0);

4
interface/src/devices/OculusManager.h
View file

@ -20,6 +20,8 @@
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include "RenderArgs.h"
class Camera;
class PalmData;
class Text3DOverlay;
@ -61,7 +63,7 @@ public:
static void endFrameTiming();
static bool allowSwap();
static void configureCamera(Camera& camera);
static void display(QGLWidget * glCanvas, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera);
static void display(QGLWidget * glCanvas, RenderArgs* renderArgs, const glm::quat &bodyOrientation, const glm::vec3 &position, Camera& whichCamera);
static void reset();
/// param \yaw[out] yaw in radians

9
interface/src/devices/TV3DManager.cpp
View file

@ -80,7 +80,7 @@ void TV3DManager::configureCamera(Camera& whichCamera, int screenWidth, int scre
glLoadIdentity();
}
void TV3DManager::display(Camera& whichCamera) {
void TV3DManager::display(RenderArgs* renderArgs, Camera& whichCamera) {
double nearZ = DEFAULT_NEAR_CLIP; // near clipping plane
double farZ = DEFAULT_FAR_CLIP; // far clipping plane
@ -93,7 +93,7 @@ void TV3DManager::display(Camera& whichCamera) {
int portalH = deviceSize.height();
DependencyManager::get<GlowEffect>()->prepare();
DependencyManager::get<GlowEffect>()->prepare(renderArgs);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
Camera eyeCamera;
@ -118,7 +118,8 @@ void TV3DManager::display(Camera& whichCamera) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
qApp->displaySide(eyeCamera, false, RenderArgs::MONO);
renderArgs->_renderSide = RenderArgs::MONO;
qApp->displaySide(renderArgs, eyeCamera, false);
qApp->getApplicationOverlay().displayOverlayTextureStereo(whichCamera, _aspect, fov);
_activeEye = NULL;
}, [&]{
@ -128,7 +129,7 @@ void TV3DManager::display(Camera& whichCamera) {
glPopMatrix();
glDisable(GL_SCISSOR_TEST);
auto finalFbo = DependencyManager::get<GlowEffect>()->render();
auto finalFbo = DependencyManager::get<GlowEffect>()->render(renderArgs);
auto fboSize = finalFbo->getSize();
// Get the ACTUAL device size for the BLIT
deviceSize = qApp->getDeviceSize();

2
interface/src/devices/TV3DManager.h
View file

@ -33,7 +33,7 @@ public:
static void connect();
static bool isConnected();
static void configureCamera(Camera& camera, int screenWidth, int screenHeight);
static void display(Camera& whichCamera);
static void display(RenderArgs* renderArgs, Camera& whichCamera);
static void overrideOffAxisFrustum(float& left, float& right, float& bottom, float& top, float& nearVal,
float& farVal, glm::vec4& nearClipPlane, glm::vec4& farClipPlane);
private:

6
interface/src/octree/OctreeFade.cpp
View file

@ -37,8 +37,8 @@ OctreeFade::OctreeFade(FadeDirection direction, float red, float green, float bl
opacity = (direction == FADE_OUT) ? FADE_OUT_START : FADE_IN_START;
}
void OctreeFade::render() {
DependencyManager::get<GlowEffect>()->begin();
void OctreeFade::render(RenderArgs* renderArgs) {
DependencyManager::get<GlowEffect>()->begin(renderArgs);
glDisable(GL_LIGHTING);
glPushMatrix();
@ -53,7 +53,7 @@ void OctreeFade::render() {
glEnable(GL_LIGHTING);
DependencyManager::get<GlowEffect>()->end();
DependencyManager::get<GlowEffect>()->end(renderArgs);
opacity *= (direction == FADE_OUT) ? FADE_OUT_STEP : FADE_IN_STEP;
}

2
interface/src/octree/OctreeFade.h
View file

@ -39,7 +39,7 @@ public:
OctreeFade(FadeDirection direction = FADE_OUT, float red = DEFAULT_RED,
float green = DEFAULT_GREEN, float blue = DEFAULT_BLUE);
void render();
void render(RenderArgs* renderArgs);
bool isDone() const;
};

12
interface/src/ui/ApplicationOverlay.cpp
View file

@ -185,7 +185,7 @@ ApplicationOverlay::~ApplicationOverlay() {
}
// Renders the overlays either to a texture or to the screen
void ApplicationOverlay::renderOverlay() {
void ApplicationOverlay::renderOverlay(RenderArgs* renderArgs) {
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings), "ApplicationOverlay::displayOverlay()");
Overlays& overlays = qApp->getOverlays();
@ -222,7 +222,7 @@ void ApplicationOverlay::renderOverlay() {
// give external parties a change to hook in
emit qApp->renderingOverlay();
overlays.renderHUD();
overlays.renderHUD(renderArgs);
renderPointers();
@ -979,6 +979,14 @@ void ApplicationOverlay::renderStatsAndLogs() {
glLineWidth(1.0f);
glPointSize(1.0f);
// Determine whether to compute timing details
bool shouldDisplayTimingDetail = Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails) &&
Menu::getInstance()->isOptionChecked(MenuOption::Stats) &&
Stats::getInstance()->isExpanded();
if (shouldDisplayTimingDetail != PerformanceTimer::isActive()) {
PerformanceTimer::setActive(shouldDisplayTimingDetail);
}
if (Menu::getInstance()->isOptionChecked(MenuOption::Stats)) {
// let's set horizontal offset to give stats some margin to mirror
int horizontalOffset = MIRROR_VIEW_WIDTH + MIRROR_VIEW_LEFT_PADDING * 2;

2
interface/src/ui/ApplicationOverlay.h
View file

@ -32,7 +32,7 @@ public:
ApplicationOverlay();
~ApplicationOverlay();
void renderOverlay();
void renderOverlay(RenderArgs* renderArgs);
void displayOverlayTexture();
void displayOverlayTextureStereo(Camera& whichCamera, float aspectRatio, float fov);
void displayOverlayTextureHmd(Camera& whichCamera);

5
interface/src/ui/JSConsole.cpp
View file

@ -59,6 +59,7 @@ JSConsole::JSConsole(QWidget* parent, ScriptEngine* scriptEngine) :
connect(_scriptEngine, SIGNAL(evaluationFinished(QScriptValue, bool)),
this, SLOT(handleEvalutationFinished(QScriptValue, bool)));
connect(_scriptEngine, SIGNAL(printedMessage(const QString&)), this, SLOT(handlePrint(const QString&)));
connect(_scriptEngine, SIGNAL(errorMessage(const QString&)), this, SLOT(handleError(const QString&)));
resizeTextInput();
}
@ -96,6 +97,10 @@ void JSConsole::handleEvalutationFinished(QScriptValue result, bool isException)
appendMessage(gutter, resultStr);
}
void JSConsole::handleError(const QString& message) {
appendMessage(GUTTER_ERROR, "<span style='" + RESULT_ERROR_STYLE + "'>" + message.toHtmlEscaped() + "</span>");
}
void JSConsole::handlePrint(const QString& message) {
appendMessage("", message);
}

1
interface/src/ui/JSConsole.h
View file

@ -49,6 +49,7 @@ protected slots:
void resizeTextInput();
void handleEvalutationFinished(QScriptValue result, bool isException);
void handlePrint(const QString& message);
void handleError(const QString& message);
private:
void appendMessage(const QString& gutter, const QString& message);

2
interface/src/ui/RearMirrorTools.cpp
View file

@ -47,7 +47,7 @@ RearMirrorTools::RearMirrorTools(QRect& bounds) :
_headZoomIconRect = QRect(_bounds.left() + ICON_PADDING, _bounds.bottom() - ICON_PADDING - ICON_SIZE, ICON_SIZE, ICON_SIZE);
}
void RearMirrorTools::render(bool fullScreen, const QPoint & mousePosition) {
void RearMirrorTools::render(RenderArgs* renderArgs, bool fullScreen, const QPoint & mousePosition) {
if (fullScreen) {
_fullScreen = true;
displayIcon(QRect(QPoint(), qApp->getDeviceSize()), _shrinkIconRect, _closeTexture);

2
interface/src/ui/RearMirrorTools.h
View file

@ -24,7 +24,7 @@ class RearMirrorTools : public QObject {
Q_OBJECT
public:
RearMirrorTools(QRect& bounds);
void render(bool fullScreen, const QPoint & mousePos);
void render(RenderArgs* renderArgs, bool fullScreen, const QPoint & mousePos);
bool mousePressEvent(int x, int y);
static Setting::Handle<int> rearViewZoomLevel;

9
interface/src/ui/Stats.cpp
View file

@ -224,9 +224,10 @@ void Stats::display(
lines = 5;
int columnOneWidth = _generalStatsWidth;
PerformanceTimer::tallyAllTimerRecords(); // do this even if we're not displaying them, so they don't stack up
if (_expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails)) {
bool performanceTimerIsActive = PerformanceTimer::isActive();
bool displayPerf = _expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails);
if (displayPerf && performanceTimerIsActive) {
PerformanceTimer::tallyAllTimerRecords(); // do this even if we're not displaying them, so they don't stack up
columnOneWidth = _generalStatsWidth + _pingStatsWidth + _geoStatsWidth; // 3 columns wide...
// we will also include room for 1 line per timing record and a header of 4 lines
@ -276,7 +277,7 @@ void Stats::display(
// TODO: the display of these timing details should all be moved to JavaScript
if (_expanded && Menu::getInstance()->isOptionChecked(MenuOption::DisplayDebugTimingDetails)) {
if (displayPerf && performanceTimerIsActive) {
bool onlyDisplayTopTen = Menu::getInstance()->isOptionChecked(MenuOption::OnlyDisplayTopTen);
// Timing details...
verticalOffset += STATS_PELS_PER_LINE * 4; // skip 3 lines to be under the other columns

2
interface/src/ui/Stats.h
View file

@ -27,6 +27,8 @@ public:
static void drawBackground(unsigned int rgba, int x, int y, int width, int height);
void toggleExpanded();
bool isExpanded() { return _expanded; }
void checkClick(int mouseX, int mouseY, int mouseDragStartedX, int mouseDragStartedY, int horizontalOffset);
void resetWidth(int width, int horizontalOffset);
void display(const float* color, int horizontalOffset, float fps, int inPacketsPerSecond, int outPacketsPerSecond,

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

@ -47,7 +47,7 @@ void LocalModelsOverlay::render(RenderArgs* args) {
Application* app = Application::getInstance();
glm::vec3 oldTranslation = app->getViewMatrixTranslation();
app->setViewMatrixTranslation(oldTranslation + _position);
_entityTreeRenderer->render();
_entityTreeRenderer->render(args);
Application::getInstance()->setViewMatrixTranslation(oldTranslation);
} glPopMatrix();

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

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

22
interface/src/ui/overlays/Overlays.cpp
View file

@ -82,34 +82,27 @@ void Overlays::update(float deltatime) {
}
void Overlays::renderHUD() {
void Overlays::renderHUD(RenderArgs* renderArgs) {
QReadLocker lock(&_lock);
auto lodManager = DependencyManager::get<LODManager>();
RenderArgs args(NULL, Application::getInstance()->getViewFrustum(),
lodManager->getOctreeSizeScale(),
lodManager->getBoundaryLevelAdjust(),
RenderArgs::DEFAULT_RENDER_MODE, RenderArgs::MONO, RenderArgs::RENDER_DEBUG_NONE);
foreach(Overlay* thisOverlay, _overlaysHUD) {
if (thisOverlay->is3D()) {
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
thisOverlay->render(&args);
thisOverlay->render(renderArgs);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
} else{
thisOverlay->render(&args);
thisOverlay->render(renderArgs);
}
}
}
void Overlays::renderWorld(bool drawFront,
RenderArgs::RenderMode renderMode,
RenderArgs::RenderSide renderSide,
RenderArgs::DebugFlags renderDebugFlags) {
void Overlays::renderWorld(RenderArgs* renderArgs, bool drawFront) {
QReadLocker lock(&_lock);
if (_overlaysWorld.size() == 0) {
return;
@ -123,11 +116,6 @@ void Overlays::renderWorld(bool drawFront,
float myAvatarScale = 1.0f;
auto lodManager = DependencyManager::get<LODManager>();
RenderArgs args(NULL, Application::getInstance()->getDisplayViewFrustum(),
lodManager->getOctreeSizeScale(),
lodManager->getBoundaryLevelAdjust(),
renderMode, renderSide, renderDebugFlags);
foreach(Overlay* thisOverlay, _overlaysWorld) {
Base3DOverlay* overlay3D = static_cast<Base3DOverlay*>(thisOverlay);
@ -154,7 +142,7 @@ void Overlays::renderWorld(bool drawFront,
default:
break;
}
thisOverlay->render(&args);
thisOverlay->render(renderArgs);
glPopMatrix();
}
}

6
interface/src/ui/overlays/Overlays.h
View file

@ -53,10 +53,8 @@ public:
~Overlays();
void init();
void update(float deltatime);
void renderWorld(bool drawFront, RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO,
RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
void renderHUD();
void renderWorld(RenderArgs* renderArgs, bool drawFront);
void renderHUD(RenderArgs* renderArgs);
public slots:
/// adds an overlay with the specific properties

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

@ -474,13 +474,11 @@ void EntityTreeRenderer::applyZonePropertiesToScene(const ZoneEntityItem* zone)
}
}
void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode,
RenderArgs::RenderSide renderSide,
RenderArgs::DebugFlags renderDebugFlags) {
void EntityTreeRenderer::render(RenderArgs* renderArgs) {
if (_tree && !_shuttingDown) {
Model::startScene(renderSide);
Model::startScene(renderArgs->_renderSide);
ViewFrustum* frustum = (renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
ViewFrustum* frustum = (renderArgs->_renderMode == RenderArgs::SHADOW_RENDER_MODE) ?
_viewState->getShadowViewFrustum() : _viewState->getCurrentViewFrustum();
// Setup batch transform matrices
@ -492,44 +490,44 @@ void EntityTreeRenderer::render(RenderArgs::RenderMode renderMode,
batch.setProjectionTransform(projMat);
batch.setViewTransform(viewMat);
RenderArgs args(this, frustum, getSizeScale(), getBoundaryLevelAdjust(),
renderMode, renderSide, renderDebugFlags, &batch);
renderArgs->_renderer = this;
renderArgs->_batch = &batch;
_tree->lockForRead();
// Whenever you're in an intersection between zones, we will always choose the smallest zone.
_bestZone = NULL;
_bestZoneVolume = std::numeric_limits<float>::max();
_tree->recurseTreeWithOperation(renderOperation, &args);
_tree->recurseTreeWithOperation(renderOperation, renderArgs);
applyZonePropertiesToScene(_bestZone);
// we must call endScene while we still have the tree locked so that no one deletes a model
// on us while rendering the scene
Model::endScene(renderMode, &args);
Model::endScene(renderArgs);
_tree->unlock();
glPushMatrix();
gpu::GLBackend::renderBatch(batch, true);
renderArgs->_context->enqueueBatch(batch);
glPopMatrix();
// stats...
_meshesConsidered = args._meshesConsidered;
_meshesRendered = args._meshesRendered;
_meshesOutOfView = args._meshesOutOfView;
_meshesTooSmall = args._meshesTooSmall;
_meshesConsidered = renderArgs->_meshesConsidered;
_meshesRendered = renderArgs->_meshesRendered;
_meshesOutOfView = renderArgs->_meshesOutOfView;
_meshesTooSmall = renderArgs->_meshesTooSmall;
_elementsTouched = args._elementsTouched;
_itemsRendered = args._itemsRendered;
_itemsOutOfView = args._itemsOutOfView;
_itemsTooSmall = args._itemsTooSmall;
_elementsTouched = renderArgs->_elementsTouched;
_itemsRendered = renderArgs->_itemsRendered;
_itemsOutOfView = renderArgs->_itemsOutOfView;
_itemsTooSmall = renderArgs->_itemsTooSmall;
_materialSwitches = args._materialSwitches;
_trianglesRendered = args._trianglesRendered;
_quadsRendered = args._quadsRendered;
_materialSwitches = renderArgs->_materialSwitches;
_trianglesRendered = renderArgs->_trianglesRendered;
_quadsRendered = renderArgs->_quadsRendered;
_translucentMeshPartsRendered = args._translucentMeshPartsRendered;
_opaqueMeshPartsRendered = args._opaqueMeshPartsRendered;
_translucentMeshPartsRendered = renderArgs->_translucentMeshPartsRendered;
_opaqueMeshPartsRendered = renderArgs->_opaqueMeshPartsRendered;
}
deleteReleasedModels(); // seems like as good as any other place to do some memory cleanup
}
@ -713,7 +711,7 @@ void EntityTreeRenderer::renderElement(OctreeElement* element, RenderArgs* args)
Glower* glower = NULL;
if (entityItem->getGlowLevel() > 0.0f) {
glower = new Glower(entityItem->getGlowLevel());
glower = new Glower(args, entityItem->getGlowLevel());
}
entityItem->render(args);
args->_itemsRendered++;
@ -1159,7 +1157,7 @@ void EntityTreeRenderer::entityCollisionWithEntity(const EntityItemID& idA, cons
return;
}
// Don't respond to small continuous contacts.
const float COLLISION_MINUMUM_PENETRATION = 0.005;
const float COLLISION_MINUMUM_PENETRATION = 0.005f;
if ((collision.type != CONTACT_EVENT_TYPE_START) && (glm::length(collision.penetration) < COLLISION_MINUMUM_PENETRATION)) {
return;
}

4
libraries/entities-renderer/src/EntityTreeRenderer.h
View file

@ -58,9 +58,7 @@ public:
void processEraseMessage(const QByteArray& dataByteArray, const SharedNodePointer& sourceNode);
virtual void init();
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO,
RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
virtual void render(RenderArgs* renderArgs) override;
virtual const FBXGeometry* getGeometryForEntity(const EntityItem* entityItem);
virtual const Model* getModelForEntityItem(const EntityItem* entityItem);

4
libraries/entities-renderer/src/RenderableWebEntityItem.cpp
View file

@ -25,8 +25,8 @@
#include "EntityTreeRenderer.h"
const float DPI = 30.47;
const float METERS_TO_INCHES = 39.3701;
const float DPI = 30.47f;
const float METERS_TO_INCHES = 39.3701f;
EntityItem* RenderableWebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return new RenderableWebEntityItem(entityID, properties);

15
libraries/gpu/src/gpu/Context.cpp
View file

@ -15,9 +15,22 @@
using namespace gpu;
Context::Context() {
}
Context::Context(const Context& context) {
}
Context::~Context() {
}
bool Context::makeProgram(Shader& shader, const Shader::BindingSet& bindings) {
if (shader.isProgram()) {
return GLBackend::makeProgram(shader, bindings);
}
return false;
}
}
void Context::enqueueBatch(Batch& batch) {
GLBackend::renderBatch(batch, true);
}

4
libraries/octree/src/OctreeHeadlessViewer.h
View file

@ -33,9 +33,7 @@ public:
virtual void renderElement(OctreeElement* element, RenderArgs* args) { /* swallow these */ }
virtual void init();
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO,
RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE) { /* swallow these */ }
virtual void render(RenderArgs* renderArgs) override { /* swallow these */ }
void setJurisdictionListener(JurisdictionListener* jurisdictionListener) { _jurisdictionListener = jurisdictionListener; }

35
libraries/octree/src/OctreeRenderer.cpp
View file

@ -164,32 +164,29 @@ bool OctreeRenderer::renderOperation(OctreeElement* element, void* extraData) {
return false;
}
void OctreeRenderer::render(RenderArgs::RenderMode renderMode,
RenderArgs::RenderSide renderSide,
RenderArgs::DebugFlags renderDebugFlags) {
RenderArgs args(this, _viewFrustum, getSizeScale(), getBoundaryLevelAdjust(),
renderMode, renderSide, renderDebugFlags);
void OctreeRenderer::render(RenderArgs* renderArgs) {
if (_tree) {
renderArgs->_renderer = this;
_tree->lockForRead();
_tree->recurseTreeWithOperation(renderOperation, &args);
_tree->recurseTreeWithOperation(renderOperation, renderArgs);
_tree->unlock();
}
_meshesConsidered = args._meshesConsidered;
_meshesRendered = args._meshesRendered;
_meshesOutOfView = args._meshesOutOfView;
_meshesTooSmall = args._meshesTooSmall;
_meshesConsidered = renderArgs->_meshesConsidered;
_meshesRendered = renderArgs->_meshesRendered;
_meshesOutOfView = renderArgs->_meshesOutOfView;
_meshesTooSmall = renderArgs->_meshesTooSmall;
_elementsTouched = args._elementsTouched;
_itemsRendered = args._itemsRendered;
_itemsOutOfView = args._itemsOutOfView;
_itemsTooSmall = args._itemsTooSmall;
_elementsTouched = renderArgs->_elementsTouched;
_itemsRendered = renderArgs->_itemsRendered;
_itemsOutOfView = renderArgs->_itemsOutOfView;
_itemsTooSmall = renderArgs->_itemsTooSmall;
_materialSwitches = args._materialSwitches;
_trianglesRendered = args._trianglesRendered;
_quadsRendered = args._quadsRendered;
_materialSwitches = renderArgs->_materialSwitches;
_trianglesRendered = renderArgs->_trianglesRendered;
_quadsRendered = renderArgs->_quadsRendered;
_translucentMeshPartsRendered = args._translucentMeshPartsRendered;
_opaqueMeshPartsRendered = args._opaqueMeshPartsRendered;
_translucentMeshPartsRendered = renderArgs->_translucentMeshPartsRendered;
_opaqueMeshPartsRendered = renderArgs->_opaqueMeshPartsRendered;
}

4
libraries/octree/src/OctreeRenderer.h
View file

@ -51,9 +51,7 @@ public:
virtual void init();
/// render the content of the octree
virtual void render(RenderArgs::RenderMode renderMode = RenderArgs::DEFAULT_RENDER_MODE,
RenderArgs::RenderSide renderSide = RenderArgs::MONO,
RenderArgs::DebugFlags renderDebugFlags = RenderArgs::RENDER_DEBUG_NONE);
virtual void render(RenderArgs* renderArgs);
ViewFrustum* getViewFrustum() const { return _viewFrustum; }
void setViewFrustum(ViewFrustum* viewFrustum) { _viewFrustum = viewFrustum; }

16
libraries/render-utils/src/GlowEffect.cpp
View file

@ -94,7 +94,7 @@ void GlowEffect::init(bool enabled) {
_enabled = enabled;
}
void GlowEffect::prepare() {
void GlowEffect::prepare(RenderArgs* renderArgs) {
auto primaryFBO = DependencyManager::get<TextureCache>()->getPrimaryFramebuffer();
GLuint fbo = gpu::GLBackend::getFramebufferID(primaryFBO);
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo);
@ -105,19 +105,19 @@ void GlowEffect::prepare() {
_isOddFrame = !_isOddFrame;
}
void GlowEffect::begin(float intensity) {
void GlowEffect::begin(RenderArgs* renderArgs, float intensity) {
// store the current intensity and add the new amount
_intensityStack.push(_intensity);
glBlendColor(0.0f, 0.0f, 0.0f, _intensity += intensity);
_isEmpty &= (_intensity == 0.0f);
}
void GlowEffect::end() {
void GlowEffect::end(RenderArgs* renderArgs) {
// restore the saved intensity
glBlendColor(0.0f, 0.0f, 0.0f, _intensity = _intensityStack.pop());
}
gpu::FramebufferPointer GlowEffect::render() {
gpu::FramebufferPointer GlowEffect::render(RenderArgs* renderArgs) {
PerformanceTimer perfTimer("glowEffect");
auto textureCache = DependencyManager::get<TextureCache>();
@ -212,10 +212,14 @@ void GlowEffect::toggleGlowEffect(bool enabled) {
}
Glower::Glower(float amount) {
DependencyManager::get<GlowEffect>()->begin(amount);
RenderArgs renderArgs;
DependencyManager::get<GlowEffect>()->begin(&renderArgs, amount);
}
Glower::Glower(RenderArgs* renderArgs, float amount) : _renderArgs(renderArgs) {
DependencyManager::get<GlowEffect>()->begin(_renderArgs, amount);
}
Glower::~Glower() {
DependencyManager::get<GlowEffect>()->end();
DependencyManager::get<GlowEffect>()->end(_renderArgs);
}

14
libraries/render-utils/src/GlowEffect.h
View file

@ -15,6 +15,8 @@
#include <gpu/GPUConfig.h>
#include <gpu/Framebuffer.h>
#include "RenderArgs.h"
#include <QObject>
#include <QGLWidget>
#include <QStack>
@ -37,14 +39,14 @@ public:
void init(bool enabled);
/// Prepares the glow effect for rendering the current frame. To be called before rendering the scene.
void prepare();
void prepare(RenderArgs* renderArgs);
/// Starts using the glow effect.
/// \param intensity the desired glow intensity, from zero to one
void begin(float intensity = 1.0f);
void begin(RenderArgs* renderArgs, float intensity = 1.0f);
/// Stops using the glow effect.
void end();
void end(RenderArgs* renderArgs);
/// Returns the current glow intensity.
float getIntensity() const { return _intensity; }
@ -52,7 +54,7 @@ public:
/// Renders the glow effect. To be called after rendering the scene.
/// \param toTexture whether to render to a texture, rather than to the frame buffer
/// \return the framebuffer object to which we rendered, or NULL if to the frame buffer
gpu::FramebufferPointer render();
gpu::FramebufferPointer render(RenderArgs* renderArgs);
public slots:
void toggleGlowEffect(bool enabled);
@ -85,7 +87,11 @@ class Glower {
public:
Glower(float amount = 1.0f);
Glower(RenderArgs* renderArgs, float amount = 1.0f);
~Glower();
private:
RenderArgs* _renderArgs;
};
#endif // hifi_GlowEffect_h

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

@ -765,27 +765,29 @@ void Model::renderSetup(RenderArgs* args) {
}
}
bool Model::render(float alpha, RenderMode mode, RenderArgs* args) {
bool Model::render(RenderArgs* renderArgs, float alpha) {
PROFILE_RANGE(__FUNCTION__);
// render the attachments
foreach (Model* attachment, _attachments) {
attachment->render(alpha, mode, args);
attachment->render(renderArgs, alpha);
}
if (_meshStates.isEmpty()) {
return false;
}
renderSetup(args);
return renderCore(alpha, mode, args);
renderSetup(renderArgs);
return renderCore(renderArgs, alpha);
}
bool Model::renderCore(float alpha, RenderMode mode, RenderArgs* args) {
bool Model::renderCore(RenderArgs* args, float alpha) {
PROFILE_RANGE(__FUNCTION__);
if (!_viewState) {
return false;
}
auto mode = args->_renderMode;
// Let's introduce a gpu::Batch to capture all the calls to the graphics api
_renderBatch.clear();
gpu::Batch& batch = _renderBatch;
@ -1844,7 +1846,7 @@ void Model::setupBatchTransform(gpu::Batch& batch, RenderArgs* args) {
batch.setViewTransform(_transforms[0]);
}
void Model::endScene(RenderMode mode, RenderArgs* args) {
void Model::endScene(RenderArgs* args) {
PROFILE_RANGE(__FUNCTION__);
@ -1853,6 +1855,8 @@ void Model::endScene(RenderMode mode, RenderArgs* args) {
glPushMatrix();
#endif
auto mode = args->_renderMode;
RenderArgs::RenderSide renderSide = RenderArgs::MONO;
if (args) {
renderSide = args->_renderSide;

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

@ -98,12 +98,12 @@ public:
void reset();
virtual void simulate(float deltaTime, bool fullUpdate = true);
bool render(float alpha = 1.0f, RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
bool render(RenderArgs* renderArgs, float alpha = 1.0f);
// Scene rendering support
static void startScene(RenderArgs::RenderSide renderSide);
bool renderInScene(float alpha = 1.0f, RenderArgs* args = NULL);
static void endScene(RenderArgs::RenderMode mode = RenderArgs::DEFAULT_RENDER_MODE, RenderArgs* args = NULL);
static void endScene(RenderArgs* args);
/// 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
@ -371,7 +371,7 @@ private:
// helper functions used by render() or renderInScene()
void renderSetup(RenderArgs* args);
bool renderCore(float alpha, RenderArgs::RenderMode mode, RenderArgs* args);
bool renderCore(RenderArgs* args, float alpha);
int renderMeshes(gpu::Batch& batch, RenderArgs::RenderMode mode, bool translucent, float alphaThreshold,
bool hasLightmap, bool hasTangents, bool hasSpecular, bool isSkinned, bool isWireframe, RenderArgs* args = NULL,
bool forceRenderMeshes = false);

49
libraries/shared/src/PerfStat.cpp
View file

@ -79,29 +79,50 @@ void PerformanceTimerRecord::tallyResult(const quint64& now) {
// PerformanceTimer
// ----------------------------------------------------------------------------
std::atomic<bool> PerformanceTimer::_isActive(false);
QHash<QThread*, QString> PerformanceTimer::_fullNames;
QMap<QString, PerformanceTimerRecord> PerformanceTimer::_records;
PerformanceTimer::PerformanceTimer(const QString& name) :
_start(0),
_name(name)
{
QString& fullName = _fullNames[QThread::currentThread()];
fullName.append("/");
fullName.append(_name);
_start = usecTimestampNow();
PerformanceTimer::PerformanceTimer(const QString& name) {
if (_isActive) {
_name = name;
QString& fullName = _fullNames[QThread::currentThread()];
fullName.append("/");
fullName.append(_name);
_start = usecTimestampNow();
}
}
PerformanceTimer::~PerformanceTimer() {
quint64 elapsedusec = (usecTimestampNow() - _start);
QString& fullName = _fullNames[QThread::currentThread()];
PerformanceTimerRecord& namedRecord = _records[fullName];
namedRecord.accumulateResult(elapsedusec);
fullName.resize(fullName.size() - (_name.size() + 1));
if (_isActive && _start != 0) {
quint64 elapsedusec = (usecTimestampNow() - _start);
QString& fullName = _fullNames[QThread::currentThread()];
PerformanceTimerRecord& namedRecord = _records[fullName];
namedRecord.accumulateResult(elapsedusec);
fullName.resize(fullName.size() - (_name.size() + 1));
}
}
// static
// static
bool PerformanceTimer::isActive() {
return _isActive;
}
// static
void PerformanceTimer::setActive(bool active) {
if (active != _isActive) {
_isActive.store(active);
if (!active) {
_fullNames.clear();
_records.clear();
}
qDebug() << "PerformanceTimer has been turned" << ((active) ? "on" : "off");
}
}
// static
void PerformanceTimer::tallyAllTimerRecords() {
QMap<QString, PerformanceTimerRecord>::iterator recordsItr = _records.begin();
QMap<QString, PerformanceTimerRecord>::const_iterator recordsEnd = _records.end();

7
libraries/shared/src/PerfStat.h
View file

@ -19,6 +19,7 @@
#include "SharedUtil.h"
#include "SimpleMovingAverage.h"
#include <atomic>
#include <cstring>
#include <string>
#include <map>
@ -76,14 +77,18 @@ public:
PerformanceTimer(const QString& name);
~PerformanceTimer();
static bool isActive();
static void setActive(bool active);
static const PerformanceTimerRecord& getTimerRecord(const QString& name) { return _records[name]; };
static const QMap<QString, PerformanceTimerRecord>& getAllTimerRecords() { return _records; };
static void tallyAllTimerRecords();
static void dumpAllTimerRecords();
private:
quint64 _start;
quint64 _start = 0;
QString _name;
static std::atomic<bool> _isActive;
static QHash<QThread*, QString> _fullNames;
static QMap<QString, PerformanceTimerRecord> _records;
};

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

@ -16,6 +16,7 @@ class ViewFrustum;
class OctreeRenderer;
namespace gpu {
class Batch;
class Context;
}
class RenderArgs {
@ -30,7 +31,8 @@ public:
RENDER_DEBUG_SIMULATION_OWNERSHIP = 2,
};
RenderArgs(OctreeRenderer* renderer = nullptr,
RenderArgs(gpu::Context* context = nullptr,
OctreeRenderer* renderer = nullptr,
ViewFrustum* viewFrustum = nullptr,
float sizeScale = 1.0f,
int boundaryLevelAdjust = 0,
@ -55,6 +57,7 @@ public:
int translucentMeshPartsRendered = 0,
int opaqueMeshPartsRendered = 0) :
_context(context),
_renderer(renderer),
_viewFrustum(viewFrustum),
_sizeScale(sizeScale),
@ -82,6 +85,7 @@ public:
_opaqueMeshPartsRendered(opaqueMeshPartsRendered) {
}
gpu::Context* _context;
OctreeRenderer* _renderer;
ViewFrustum* _viewFrustum;
float _sizeScale;

4
libraries/shared/src/Transform.h
View file

@ -24,13 +24,13 @@
inline bool isValidScale(glm::vec3 scale) {
bool result = scale.x != 0.0f && scale.y != 0.0f && scale.z != 0.0f;
assert(result);
// assert(result);
return result;
}
inline bool isValidScale(float scale) {
bool result = scale != 0.0f;
assert(result);
// assert(result);
return result;
}

10
tools/vhacd-util/src/VHACDUtilApp.cpp
View file

@ -255,27 +255,27 @@ VHACDUtilApp::VHACDUtilApp(int argc, char* argv[]) :
vHacdDepth = parser.value(vHacdDepthOption).toInt();
}
float vHacdAlpha = 0.05;
float vHacdAlpha = 0.05f;
if (parser.isSet(vHacdAlphaOption)) {
vHacdAlpha = parser.value(vHacdAlphaOption).toFloat();
}
float vHacdBeta = 0.05;
float vHacdBeta = 0.05f;
if (parser.isSet(vHacdBetaOption)) {
vHacdBeta = parser.value(vHacdBetaOption).toFloat();
}
float vHacdGamma = 0.00125;
float vHacdGamma = 0.00125f;
if (parser.isSet(vHacdGammaOption)) {
vHacdGamma = parser.value(vHacdGammaOption).toFloat();
}
float vHacdDelta = 0.05;
float vHacdDelta = 0.05f;
if (parser.isSet(vHacdDeltaOption)) {
vHacdDelta = parser.value(vHacdDeltaOption).toFloat();
}
float vHacdConcavity = 0.0025;
float vHacdConcavity = 0.0025f;
if (parser.isSet(vHacdConcavityOption)) {
vHacdConcavity = parser.value(vHacdConcavityOption).toFloat();
}