Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-08-08 18:56:55 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #5371 from Atlante45/smart_pointers

Browse source 
Smart pointers fixes
This commit is contained in:
Brad Davis 2015-07-21 08:52:29 -07:00
commit 9016f437a8
61 changed files with 316 additions and 320 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
ice-server/src/IceServer.cpp
View file

@ -116,7 +116,7 @@ SharedNetworkPeer IceServer::addOrUpdateHeartbeatingPeer(Packet& packet) {
if (!matchingPeer) { if (!matchingPeer) {
// if we don't have this sender we need to create them now // if we don't have this sender we need to create them now
matchingPeer = SharedNetworkPeer(new NetworkPeer(senderUUID, publicSocket, localSocket)); matchingPeer = QSharedPointer<NetworkPeer>::create(senderUUID, publicSocket, localSocket);
_activePeers.insert(senderUUID, matchingPeer); _activePeers.insert(senderUUID, matchingPeer);
qDebug() << "Added a new network peer" << *matchingPeer; qDebug() << "Added a new network peer" << *matchingPeer;

16
interface/src/Application.cpp
View file

@ -363,7 +363,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer &startup_time) :
_bookmarks = new Bookmarks(); // Before setting up the menu _bookmarks = new Bookmarks(); // Before setting up the menu
_runningScriptsWidget = new RunningScriptsWidget(_window); _runningScriptsWidget = new RunningScriptsWidget(_window);
_renderEngine->addTask(render::TaskPointer(new RenderDeferredTask())); _renderEngine->addTask(make_shared<RenderDeferredTask>());
_renderEngine->registerScene(_main3DScene); _renderEngine->registerScene(_main3DScene);
// start the nodeThread so its event loop is running // start the nodeThread so its event loop is running
@ -2231,8 +2231,8 @@ void Application::shrinkMirrorView() {
const float HEAD_SPHERE_RADIUS = 0.1f; const float HEAD_SPHERE_RADIUS = 0.1f;
bool Application::isLookingAtMyAvatar(Avatar* avatar) { bool Application::isLookingAtMyAvatar(AvatarSharedPointer avatar) {
glm::vec3 theirLookAt = avatar->getHead()->getLookAtPosition(); glm::vec3 theirLookAt = dynamic_pointer_cast<Avatar>(avatar)->getHead()->getLookAtPosition();
glm::vec3 myEyePosition = _myAvatar->getHead()->getEyePosition(); glm::vec3 myEyePosition = _myAvatar->getHead()->getEyePosition();
if (pointInSphere(theirLookAt, myEyePosition, HEAD_SPHERE_RADIUS * _myAvatar->getScale())) { if (pointInSphere(theirLookAt, myEyePosition, HEAD_SPHERE_RADIUS * _myAvatar->getScale())) {
return true; return true;
@ -2296,7 +2296,7 @@ void Application::updateMyAvatarLookAtPosition() {
if (lookingAt && _myAvatar != lookingAt.get()) { if (lookingAt && _myAvatar != lookingAt.get()) {
// If I am looking at someone else, look directly at one of their eyes // If I am looking at someone else, look directly at one of their eyes
isLookingAtSomeone = true; isLookingAtSomeone = true;
Head* lookingAtHead = static_cast<Avatar*>(lookingAt.get())->getHead(); auto lookingAtHead = static_pointer_cast<Avatar>(lookingAt)->getHead();
const float MAXIMUM_FACE_ANGLE = 65.0f * RADIANS_PER_DEGREE; const float MAXIMUM_FACE_ANGLE = 65.0f * RADIANS_PER_DEGREE;
glm::vec3 lookingAtFaceOrientation = lookingAtHead->getFinalOrientationInWorldFrame() * IDENTITY_FRONT; glm::vec3 lookingAtFaceOrientation = lookingAtHead->getFinalOrientationInWorldFrame() * IDENTITY_FRONT;
@ -3202,8 +3202,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
// Background rendering decision // Background rendering decision
if (BackgroundRenderData::_item == 0) { if (BackgroundRenderData::_item == 0) {
auto backgroundRenderData = BackgroundRenderData::Pointer(new BackgroundRenderData(&_environment)); auto backgroundRenderData = make_shared<BackgroundRenderData>(&_environment);
auto backgroundRenderPayload = render::PayloadPointer(new BackgroundRenderData::Payload(backgroundRenderData)); auto backgroundRenderPayload = make_shared<BackgroundRenderData::Payload>(backgroundRenderData);
BackgroundRenderData::_item = _main3DScene->allocateID(); BackgroundRenderData::_item = _main3DScene->allocateID();
pendingChanges.resetItem(WorldBoxRenderData::_item, backgroundRenderPayload); pendingChanges.resetItem(WorldBoxRenderData::_item, backgroundRenderPayload);
} else { } else {
@ -3234,8 +3234,8 @@ void Application::displaySide(RenderArgs* renderArgs, Camera& theCamera, bool se
// Make sure the WorldBox is in the scene // Make sure the WorldBox is in the scene
if (WorldBoxRenderData::_item == 0) { if (WorldBoxRenderData::_item == 0) {
auto worldBoxRenderData = WorldBoxRenderData::Pointer(new WorldBoxRenderData()); auto worldBoxRenderData = make_shared<WorldBoxRenderData>();
auto worldBoxRenderPayload = render::PayloadPointer(new WorldBoxRenderData::Payload(worldBoxRenderData)); auto worldBoxRenderPayload = make_shared<WorldBoxRenderData::Payload>(worldBoxRenderData);
WorldBoxRenderData::_item = _main3DScene->allocateID(); WorldBoxRenderData::_item = _main3DScene->allocateID();

4
interface/src/Application.h
View file

@ -285,8 +285,8 @@ public:
QStringList getRunningScripts() { return _scriptEnginesHash.keys(); } QStringList getRunningScripts() { return _scriptEnginesHash.keys(); }
ScriptEngine* getScriptEngine(QString scriptHash) { return _scriptEnginesHash.contains(scriptHash) ? _scriptEnginesHash[scriptHash] : NULL; } ScriptEngine* getScriptEngine(QString scriptHash) { return _scriptEnginesHash.contains(scriptHash) ? _scriptEnginesHash[scriptHash] : NULL; }
bool isLookingAtMyAvatar(Avatar* avatar); bool isLookingAtMyAvatar(AvatarSharedPointer avatar);
float getRenderResolutionScale() const; float getRenderResolutionScale() const;
int getRenderAmbientLight() const; int getRenderAmbientLight() const;

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

@ -62,10 +62,10 @@ namespace render {
return ItemKey::Builder::opaqueShape(); return ItemKey::Builder::opaqueShape();
} }
template <> const Item::Bound payloadGetBound(const AvatarSharedPointer& avatar) { template <> const Item::Bound payloadGetBound(const AvatarSharedPointer& avatar) {
return static_cast<Avatar*>(avatar.get())->getBounds(); return static_pointer_cast<Avatar>(avatar)->getBounds();
} }
template <> void payloadRender(const AvatarSharedPointer& avatar, RenderArgs* args) { template <> void payloadRender(const AvatarSharedPointer& avatar, RenderArgs* args) {
Avatar* avatarPtr = static_cast<Avatar*>(avatar.get()); auto avatarPtr = static_pointer_cast<Avatar>(avatar);
bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::RenderLookAtVectors); bool renderLookAtVectors = Menu::getInstance()->isOptionChecked(MenuOption::RenderLookAtVectors);
avatarPtr->setDisplayingLookatVectors(renderLookAtVectors); avatarPtr->setDisplayingLookatVectors(renderLookAtVectors);

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

@ -429,7 +429,7 @@ void MyAvatar::startRecording() {
return; return;
} }
if (!_recorder) { if (!_recorder) {
_recorder = RecorderPointer(new Recorder(this)); _recorder = QSharedPointer<Recorder>::create(this);
} }
// connect to AudioClient's signal so we get input audio // connect to AudioClient's signal so we get input audio
auto audioClient = DependencyManager::get<AudioClient>(); auto audioClient = DependencyManager::get<AudioClient>();
@ -481,7 +481,7 @@ void MyAvatar::loadLastRecording() {
return; return;
} }
if (!_player) { if (!_player) {
_player = PlayerPointer(new Player(this)); _player = QSharedPointer<Player>::create(this);
} }
_player->loadRecording(_recorder->getRecording()); _player->loadRecording(_recorder->getRecording());
@ -876,7 +876,7 @@ void MyAvatar::updateLookAtTargetAvatar() {
const float GREATEST_LOOKING_AT_DISTANCE = 10.0f; const float GREATEST_LOOKING_AT_DISTANCE = 10.0f;
foreach (const AvatarSharedPointer& avatarPointer, DependencyManager::get<AvatarManager>()->getAvatarHash()) { foreach (const AvatarSharedPointer& avatarPointer, DependencyManager::get<AvatarManager>()->getAvatarHash()) {
Avatar* avatar = static_cast<Avatar*>(avatarPointer.get()); auto avatar = static_pointer_cast<Avatar>(avatarPointer);
bool isCurrentTarget = avatar->getIsLookAtTarget(); bool isCurrentTarget = avatar->getIsLookAtTarget();
float distanceTo = glm::length(avatar->getHead()->getEyePosition() - cameraPosition); float distanceTo = glm::length(avatar->getHead()->getEyePosition() - cameraPosition);
avatar->setIsLookAtTarget(false); avatar->setIsLookAtTarget(false);
@ -911,7 +911,7 @@ void MyAvatar::updateLookAtTargetAvatar() {
} }
auto avatarPointer = _lookAtTargetAvatar.lock(); auto avatarPointer = _lookAtTargetAvatar.lock();
if (avatarPointer) { if (avatarPointer) {
static_cast<Avatar*>(avatarPointer.get())->setIsLookAtTarget(true); static_pointer_cast<Avatar>(avatarPointer)->setIsLookAtTarget(true);
} }
} }

4
interface/src/devices/Faceshift.cpp
View file

@ -208,7 +208,7 @@ void Faceshift::receive(const QByteArray& buffer) {
for (fsMsgPtr msg; (msg = _stream.get_message()); ) { for (fsMsgPtr msg; (msg = _stream.get_message()); ) {
switch (msg->id()) { switch (msg->id()) {
case fsMsg::MSG_OUT_TRACKING_STATE: { case fsMsg::MSG_OUT_TRACKING_STATE: {
const fsTrackingData& data = static_cast<fsMsgTrackingState*>(msg.get())->tracking_data(); const fsTrackingData& data = static_pointer_cast<fsMsgTrackingState>(msg)->tracking_data();
if ((_tracking = data.m_trackingSuccessful)) { if ((_tracking = data.m_trackingSuccessful)) {
glm::quat newRotation = glm::quat(data.m_headRotation.w, -data.m_headRotation.x, glm::quat newRotation = glm::quat(data.m_headRotation.w, -data.m_headRotation.x,
data.m_headRotation.y, -data.m_headRotation.z); data.m_headRotation.y, -data.m_headRotation.z);
@ -256,7 +256,7 @@ void Faceshift::receive(const QByteArray& buffer) {
break; break;
} }
case fsMsg::MSG_OUT_BLENDSHAPE_NAMES: { case fsMsg::MSG_OUT_BLENDSHAPE_NAMES: {
const vector<string>& names = static_cast<fsMsgBlendshapeNames*>(msg.get())->blendshape_names(); const vector<string>& names = static_pointer_cast<fsMsgBlendshapeNames>(msg)->blendshape_names();
for (size_t i = 0; i < names.size(); i++) { for (size_t i = 0; i < names.size(); i++) {
if (names[i] == "EyeBlink_L") { if (names[i] == "EyeBlink_L") {
_leftBlinkIndex = i; _leftBlinkIndex = i;

2
interface/src/devices/Joystick.cpp
View file

@ -103,7 +103,7 @@ void Joystick::registerToUserInputMapper(UserInputMapper& mapper) {
// Grab the current free device ID // Grab the current free device ID
_deviceID = mapper.getFreeDeviceID(); _deviceID = mapper.getFreeDeviceID();
auto proxy = UserInputMapper::DeviceProxy::Pointer(new UserInputMapper::DeviceProxy(_name)); auto proxy = std::make_shared<UserInputMapper::DeviceProxy>(_name);
proxy->getButton = [this] (const UserInputMapper::Input& input, int timestamp) -> bool { return this->getButton(input.getChannel()); }; proxy->getButton = [this] (const UserInputMapper::Input& input, int timestamp) -> bool { return this->getButton(input.getChannel()); };
proxy->getAxis = [this] (const UserInputMapper::Input& input, int timestamp) -> float { return this->getAxis(input.getChannel()); }; proxy->getAxis = [this] (const UserInputMapper::Input& input, int timestamp) -> float { return this->getAxis(input.getChannel()); };
proxy->getAvailabeInputs = [this] () -> QVector<UserInputMapper::InputPair> { proxy->getAvailabeInputs = [this] () -> QVector<UserInputMapper::InputPair> {

2
interface/src/devices/KeyboardMouseDevice.cpp
View file

@ -159,7 +159,7 @@ void KeyboardMouseDevice::registerToUserInputMapper(UserInputMapper& mapper) {
// Grab the current free device ID // Grab the current free device ID
_deviceID = mapper.getFreeDeviceID(); _deviceID = mapper.getFreeDeviceID();
auto proxy = UserInputMapper::DeviceProxy::Pointer(new UserInputMapper::DeviceProxy("Keyboard")); auto proxy = std::make_shared<UserInputMapper::DeviceProxy>("Keyboard");
proxy->getButton = [this] (const UserInputMapper::Input& input, int timestamp) -> bool { return this->getButton(input.getChannel()); }; proxy->getButton = [this] (const UserInputMapper::Input& input, int timestamp) -> bool { return this->getButton(input.getChannel()); };
proxy->getAxis = [this] (const UserInputMapper::Input& input, int timestamp) -> float { return this->getAxis(input.getChannel()); }; proxy->getAxis = [this] (const UserInputMapper::Input& input, int timestamp) -> float { return this->getAxis(input.getChannel()); };
proxy->getAvailabeInputs = [this] () -> QVector<UserInputMapper::InputPair> { proxy->getAvailabeInputs = [this] () -> QVector<UserInputMapper::InputPair> {

2
interface/src/devices/SixenseManager.cpp
View file

@ -664,7 +664,7 @@ void SixenseManager::registerToUserInputMapper(UserInputMapper& mapper) {
// Grab the current free device ID // Grab the current free device ID
_deviceID = mapper.getFreeDeviceID(); _deviceID = mapper.getFreeDeviceID();
auto proxy = UserInputMapper::DeviceProxy::Pointer(new UserInputMapper::DeviceProxy("Hydra")); auto proxy = std::make_shared<UserInputMapper::DeviceProxy>("Hydra");
proxy->getButton = [this] (const UserInputMapper::Input& input, int timestamp) -> bool { return this->getButton(input.getChannel()); }; proxy->getButton = [this] (const UserInputMapper::Input& input, int timestamp) -> bool { return this->getButton(input.getChannel()); };
proxy->getAxis = [this] (const UserInputMapper::Input& input, int timestamp) -> float { return this->getAxis(input.getChannel()); }; proxy->getAxis = [this] (const UserInputMapper::Input& input, int timestamp) -> float { return this->getAxis(input.getChannel()); };
proxy->getAvailabeInputs = [this] () -> QVector<UserInputMapper::InputPair> { proxy->getAvailabeInputs = [this] () -> QVector<UserInputMapper::InputPair> {

6
interface/src/ui/ApplicationCompositor.cpp
View file

@ -547,8 +547,8 @@ void ApplicationCompositor::buildHemiVertices(
auto geometryCache = DependencyManager::get<GeometryCache>(); auto geometryCache = DependencyManager::get<GeometryCache>();
_hemiVertices = gpu::BufferPointer(new gpu::Buffer()); _hemiVertices = std::make_shared<gpu::Buffer>();
_hemiIndices = gpu::BufferPointer(new gpu::Buffer()); _hemiIndices = std::make_shared<gpu::Buffer>();
if (fov >= PI) { if (fov >= PI) {
@ -610,7 +610,7 @@ void ApplicationCompositor::drawSphereSection(gpu::Batch& batch) {
static const int VERTEX_DATA_SLOT = 0; static const int VERTEX_DATA_SLOT = 0;
static const int TEXTURE_DATA_SLOT = 1; static const int TEXTURE_DATA_SLOT = 1;
static const int COLOR_DATA_SLOT = 2; static const int COLOR_DATA_SLOT = 2;
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone auto streamFormat = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
streamFormat->setAttribute(gpu::Stream::POSITION, VERTEX_DATA_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0); streamFormat->setAttribute(gpu::Stream::POSITION, VERTEX_DATA_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
streamFormat->setAttribute(gpu::Stream::TEXCOORD, TEXTURE_DATA_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV)); streamFormat->setAttribute(gpu::Stream::TEXCOORD, TEXTURE_DATA_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV));
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_DATA_SLOT, gpu::Element(gpu::VEC4, gpu::FLOAT, gpu::RGBA)); streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_DATA_SLOT, gpu::Element(gpu::VEC4, gpu::FLOAT, gpu::RGBA));

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

@ -220,7 +220,7 @@ bool Overlays::editOverlay(unsigned int id, const QScriptValue& properties) {
if (thisOverlay) { if (thisOverlay) {
if (thisOverlay->is3D()) { if (thisOverlay->is3D()) {
Base3DOverlay* overlay3D = static_cast<Base3DOverlay*>(thisOverlay.get()); auto overlay3D = std::static_pointer_cast<Base3DOverlay>(thisOverlay);
bool oldDrawOnHUD = overlay3D->getDrawOnHUD(); bool oldDrawOnHUD = overlay3D->getDrawOnHUD();
thisOverlay->setProperties(properties); thisOverlay->setProperties(properties);
@ -282,15 +282,15 @@ unsigned int Overlays::getOverlayAtPoint(const glm::vec2& point) {
i.previous(); i.previous();
unsigned int thisID = i.key(); unsigned int thisID = i.key();
if (i.value()->is3D()) { if (i.value()->is3D()) {
Base3DOverlay* thisOverlay = static_cast<Base3DOverlay*>(i.value().get()); auto thisOverlay = std::dynamic_pointer_cast<Base3DOverlay>(i.value());
if (!thisOverlay->getIgnoreRayIntersection()) { if (thisOverlay && !thisOverlay->getIgnoreRayIntersection()) {
if (thisOverlay->findRayIntersection(origin, direction, distance, thisFace)) { if (thisOverlay->findRayIntersection(origin, direction, distance, thisFace)) {
return thisID; return thisID;
} }
} }
} else { } else {
Overlay2D* thisOverlay = static_cast<Overlay2D*>(i.value().get()); auto thisOverlay = std::dynamic_pointer_cast<Overlay2D>(i.value());
if (thisOverlay->getVisible() && thisOverlay->isLoaded() && if (thisOverlay && thisOverlay->getVisible() && thisOverlay->isLoaded() &&
thisOverlay->getBoundingRect().contains(pointCopy.x, pointCopy.y, false)) { thisOverlay->getBoundingRect().contains(pointCopy.x, pointCopy.y, false)) {
return thisID; return thisID;
} }
@ -354,8 +354,8 @@ RayToOverlayIntersectionResult Overlays::findRayIntersection(const PickRay& ray)
while (i.hasPrevious()) { while (i.hasPrevious()) {
i.previous(); i.previous();
unsigned int thisID = i.key(); unsigned int thisID = i.key();
Base3DOverlay* thisOverlay = static_cast<Base3DOverlay*>(i.value().get()); auto thisOverlay = std::dynamic_pointer_cast<Base3DOverlay>(i.value());
if (thisOverlay->getVisible() && !thisOverlay->getIgnoreRayIntersection() && thisOverlay->isLoaded()) { if (thisOverlay && thisOverlay->getVisible() && !thisOverlay->getIgnoreRayIntersection() && thisOverlay->isLoaded()) {
float thisDistance; float thisDistance;
BoxFace thisFace; BoxFace thisFace;
QString thisExtraInfo; QString thisExtraInfo;
@ -471,13 +471,13 @@ QSizeF Overlays::textSize(unsigned int id, const QString& text) const {
Overlay::Pointer thisOverlay = _overlaysHUD[id]; Overlay::Pointer thisOverlay = _overlaysHUD[id];
if (thisOverlay) { if (thisOverlay) {
if (typeid(*thisOverlay) == typeid(TextOverlay)) { if (typeid(*thisOverlay) == typeid(TextOverlay)) {
return static_cast<TextOverlay*>(thisOverlay.get())->textSize(text); return std::dynamic_pointer_cast<TextOverlay>(thisOverlay)->textSize(text);
} }
} else { } else {
thisOverlay = _overlaysWorld[id]; thisOverlay = _overlaysWorld[id];
if (thisOverlay) { if (thisOverlay) {
if (typeid(*thisOverlay) == typeid(Text3DOverlay)) { if (typeid(*thisOverlay) == typeid(Text3DOverlay)) {
return static_cast<Text3DOverlay*>(thisOverlay.get())->textSize(text); return std::dynamic_pointer_cast<Text3DOverlay>(thisOverlay)->textSize(text);
} }
} }
} }

6
libraries/avatars/src/AvatarData.cpp
View file

@ -632,7 +632,7 @@ void AvatarData::loadRecording(QString filename) {
return; return;
} }
if (!_player) { if (!_player) {
_player = PlayerPointer(new Player(this)); _player = QSharedPointer<Player>::create(this);
} }
_player->loadFromFile(filename); _player->loadFromFile(filename);
@ -644,7 +644,7 @@ void AvatarData::startPlaying() {
return; return;
} }
if (!_player) { if (!_player) {
_player = PlayerPointer(new Player(this)); _player = QSharedPointer<Player>::create(this);
} }
_player->startPlaying(); _player->startPlaying();
} }
@ -746,7 +746,7 @@ void AvatarData::stopPlaying() {
} }
} }
void AvatarData::changeReferential(Referential *ref) { void AvatarData::changeReferential(Referential* ref) {
delete _referential; delete _referential;
_referential = ref; _referential = ref;
} }

2
libraries/avatars/src/AvatarHashMap.cpp
View file

@ -34,7 +34,7 @@ bool AvatarHashMap::isAvatarInRange(const glm::vec3& position, const float range
} }
AvatarSharedPointer AvatarHashMap::newSharedAvatar() { AvatarSharedPointer AvatarHashMap::newSharedAvatar() {
return AvatarSharedPointer(new AvatarData()); return std::make_shared<AvatarData>();
} }
AvatarSharedPointer AvatarHashMap::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) { AvatarSharedPointer AvatarHashMap::addAvatar(const QUuid& sessionUUID, const QWeakPointer<Node>& mixerWeakPointer) {

2
libraries/avatars/src/Player.cpp
View file

@ -202,7 +202,7 @@ void Player::loadFromFile(const QString& file) {
if (_recording) { if (_recording) {
_recording->clear(); _recording->clear();
} else { } else {
_recording = RecordingPointer(new Recording()); _recording = QSharedPointer<Recording>();
} }
readRecordingFromFile(_recording, file); readRecordingFromFile(_recording, file);

4
libraries/avatars/src/Recording.cpp
View file

@ -417,7 +417,7 @@ RecordingPointer readRecordingFromFile(RecordingPointer recording, const QString
// Reset the recording passed in the arguments // Reset the recording passed in the arguments
if (!recording) { if (!recording) {
recording.reset(new Recording()); recording = QSharedPointer<Recording>::create();
} }
QDataStream fileStream(byteArray); QDataStream fileStream(byteArray);
@ -652,7 +652,7 @@ RecordingPointer readRecordingFromRecFile(RecordingPointer recording, const QStr
timer.start(); timer.start();
if (!recording) { if (!recording) {
recording.reset(new Recording()); recording = QSharedPointer<Recording>::create();
} }
QDataStream fileStream(byteArray); QDataStream fileStream(byteArray);

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

@ -22,7 +22,7 @@
#include "RenderableDebugableEntityItem.h" #include "RenderableDebugableEntityItem.h"
EntityItemPointer RenderableBoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableBoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableBoxEntityItem(entityID, properties)); return std::make_shared<RenderableBoxEntityItem>(entityID, properties);
} }
void RenderableBoxEntityItem::render(RenderArgs* args) { void RenderableBoxEntityItem::render(RenderArgs* args) {

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

@ -37,8 +37,8 @@ public:
bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) { bool addToScene(EntityItemPointer self, std::shared_ptr<render::Scene> scene, render::PendingChanges& pendingChanges) {
_myItem = scene->allocateID(); _myItem = scene->allocateID();
auto renderData = RenderableEntityItemProxy::Pointer(new RenderableEntityItemProxy(self)); auto renderData = std::make_shared<RenderableEntityItemProxy>(self);
auto renderPayload = render::PayloadPointer(new RenderableEntityItemProxy::Payload(renderData)); auto renderPayload = std::make_shared<RenderableEntityItemProxy::Payload>(renderData);
pendingChanges.resetItem(_myItem, renderPayload); pendingChanges.resetItem(_myItem, renderPayload);

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

@ -20,7 +20,7 @@
#include "RenderableLightEntityItem.h" #include "RenderableLightEntityItem.h"
EntityItemPointer RenderableLightEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableLightEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableLightEntityItem(entityID, properties)); return std::make_shared<RenderableLightEntityItem>(entityID, properties);
} }
void RenderableLightEntityItem::render(RenderArgs* args) { void RenderableLightEntityItem::render(RenderArgs* args) {

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

@ -20,7 +20,7 @@
#include "RenderableLineEntityItem.h" #include "RenderableLineEntityItem.h"
EntityItemPointer RenderableLineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableLineEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableLineEntityItem(entityID, properties)); return std::make_shared<RenderableLineEntityItem>(entityID, properties);
} }
void RenderableLineEntityItem::updateGeometry() { void RenderableLineEntityItem::updateGeometry() {

6
libraries/entities-renderer/src/RenderableModelEntityItem.cpp
View file

@ -24,7 +24,7 @@
#include "RenderableModelEntityItem.h" #include "RenderableModelEntityItem.h"
EntityItemPointer RenderableModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableModelEntityItem(entityID, properties)); return std::make_shared<RenderableModelEntityItem>(entityID, properties);
} }
RenderableModelEntityItem::~RenderableModelEntityItem() { RenderableModelEntityItem::~RenderableModelEntityItem() {
@ -190,8 +190,8 @@ bool RenderableModelEntityItem::addToScene(EntityItemPointer self, std::shared_p
_myMetaItem = scene->allocateID(); _myMetaItem = scene->allocateID();
auto renderData = RenderableModelEntityItemMeta::Pointer(new RenderableModelEntityItemMeta(self)); auto renderData = std::make_shared<RenderableModelEntityItemMeta>(self);
auto renderPayload = render::PayloadPointer(new RenderableModelEntityItemMeta::Payload(renderData)); auto renderPayload = std::make_shared<RenderableModelEntityItemMeta::Payload>(renderData);
pendingChanges.resetItem(_myMetaItem, renderPayload); pendingChanges.resetItem(_myMetaItem, renderPayload);

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

@ -19,7 +19,7 @@
#include "RenderableParticleEffectEntityItem.h" #include "RenderableParticleEffectEntityItem.h"
EntityItemPointer RenderableParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableParticleEffectEntityItem(entityID, properties)); return std::make_shared<RenderableParticleEffectEntityItem>(entityID, properties);
} }
RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableParticleEffectEntityItem::RenderableParticleEffectEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

9
libraries/entities-renderer/src/RenderablePolyVoxEntityItem.cpp
View file

@ -40,7 +40,7 @@
#include "RenderablePolyVoxEntityItem.h" #include "RenderablePolyVoxEntityItem.h"
EntityItemPointer RenderablePolyVoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderablePolyVoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderablePolyVoxEntityItem(entityID, properties)); return std::make_shared<RenderablePolyVoxEntityItem>(entityID, properties);
} }
RenderablePolyVoxEntityItem::RenderablePolyVoxEntityItem(const EntityItemID& entityItemID, RenderablePolyVoxEntityItem::RenderablePolyVoxEntityItem(const EntityItemID& entityItemID,
@ -349,15 +349,16 @@ void RenderablePolyVoxEntityItem::getModel() {
auto mesh = _modelGeometry.getMesh(); auto mesh = _modelGeometry.getMesh();
const std::vector<uint32_t>& vecIndices = polyVoxMesh.getIndices(); const std::vector<uint32_t>& vecIndices = polyVoxMesh.getIndices();
auto indexBuffer = new gpu::Buffer(vecIndices.size() * sizeof(uint32_t), (gpu::Byte*)vecIndices.data()); auto indexBuffer = std::make_shared<gpu::Buffer>(vecIndices.size() * sizeof(uint32_t),
(gpu::Byte*)vecIndices.data());
auto indexBufferPtr = gpu::BufferPointer(indexBuffer); auto indexBufferPtr = gpu::BufferPointer(indexBuffer);
auto indexBufferView = new gpu::BufferView(indexBufferPtr, gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::RAW)); auto indexBufferView = new gpu::BufferView(indexBufferPtr, gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::RAW));
mesh->setIndexBuffer(*indexBufferView); mesh->setIndexBuffer(*indexBufferView);
const std::vector<PolyVox::PositionMaterialNormal>& vecVertices = polyVoxMesh.getVertices(); const std::vector<PolyVox::PositionMaterialNormal>& vecVertices = polyVoxMesh.getVertices();
auto vertexBuffer = new gpu::Buffer(vecVertices.size() * sizeof(PolyVox::PositionMaterialNormal), auto vertexBuffer = std::make_shared<gpu::Buffer>(vecVertices.size() * sizeof(PolyVox::PositionMaterialNormal),
(gpu::Byte*)vecVertices.data()); (gpu::Byte*)vecVertices.data());
auto vertexBufferPtr = gpu::BufferPointer(vertexBuffer); auto vertexBufferPtr = gpu::BufferPointer(vertexBuffer);
auto vertexBufferView = new gpu::BufferView(vertexBufferPtr, auto vertexBufferView = new gpu::BufferView(vertexBufferPtr,
0, 0,

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

@ -22,7 +22,7 @@
#include "RenderableDebugableEntityItem.h" #include "RenderableDebugableEntityItem.h"
EntityItemPointer RenderableSphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableSphereEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableSphereEntityItem(entityID, properties)); return std::make_shared<RenderableSphereEntityItem>(entityID, properties);
} }
void RenderableSphereEntityItem::render(RenderArgs* args) { void RenderableSphereEntityItem::render(RenderArgs* args) {

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

@ -22,7 +22,7 @@
#include "GLMHelpers.h" #include "GLMHelpers.h"
EntityItemPointer RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableTextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableTextEntityItem(entityID, properties)); return std::make_shared<RenderableTextEntityItem>(entityID, properties);
} }
void RenderableTextEntityItem::render(RenderArgs* args) { void RenderableTextEntityItem::render(RenderArgs* args) {

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

@ -32,7 +32,7 @@ const float DPI = 30.47f;
const float METERS_TO_INCHES = 39.3701f; const float METERS_TO_INCHES = 39.3701f;
EntityItemPointer RenderableWebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableWebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableWebEntityItem(entityID, properties)); return std::make_shared<RenderableWebEntityItem>(entityID, properties);
} }
RenderableWebEntityItem::RenderableWebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : RenderableWebEntityItem::RenderableWebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

6
libraries/entities-renderer/src/RenderableZoneEntityItem.cpp
View file

@ -20,7 +20,7 @@
#include <PerfStat.h> #include <PerfStat.h>
EntityItemPointer RenderableZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer RenderableZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new RenderableZoneEntityItem(entityID, properties)); return std::make_shared<RenderableZoneEntityItem>(entityID, properties);
} }
template<typename Lambda> template<typename Lambda>
@ -195,8 +195,8 @@ bool RenderableZoneEntityItem::addToScene(EntityItemPointer self, std::shared_pt
render::PendingChanges& pendingChanges) { render::PendingChanges& pendingChanges) {
_myMetaItem = scene->allocateID(); _myMetaItem = scene->allocateID();
auto renderData = RenderableZoneEntityItemMeta::Pointer(new RenderableZoneEntityItemMeta(self)); auto renderData = std::make_shared<RenderableZoneEntityItemMeta>(self);
auto renderPayload = render::PayloadPointer(new RenderableZoneEntityItemMeta::Payload(renderData)); auto renderPayload = std::make_shared<RenderableZoneEntityItemMeta::Payload>(renderData);
pendingChanges.resetItem(_myMetaItem, renderPayload); pendingChanges.resetItem(_myMetaItem, renderPayload);
return true; return true;

8
libraries/entities/src/EntityScriptingInterface.cpp
View file

@ -419,7 +419,7 @@ bool EntityScriptingInterface::setVoxels(QUuid entityID,
return false; return false;
} }
EntityItemPointer entity = static_cast<EntityItemPointer>(_entityTree->findEntityByEntityItemID(entityID)); EntityItemPointer entity = _entityTree->findEntityByEntityItemID(entityID);
if (!entity) { if (!entity) {
qCDebug(entities) << "EntityScriptingInterface::setVoxelSphere no entity with ID" << entityID; qCDebug(entities) << "EntityScriptingInterface::setVoxelSphere no entity with ID" << entityID;
return false; return false;
@ -432,7 +432,7 @@ bool EntityScriptingInterface::setVoxels(QUuid entityID,
auto now = usecTimestampNow(); auto now = usecTimestampNow();
PolyVoxEntityItem* polyVoxEntity = static_cast<PolyVoxEntityItem*>(entity.get()); auto polyVoxEntity = std::dynamic_pointer_cast<PolyVoxEntityItem>(entity);
_entityTree->lockForWrite(); _entityTree->lockForWrite();
actor(*polyVoxEntity); actor(*polyVoxEntity);
entity->setLastEdited(now); entity->setLastEdited(now);
@ -467,8 +467,8 @@ bool EntityScriptingInterface::setPoints(QUuid entityID, std::function<bool(Line
} }
auto now = usecTimestampNow(); auto now = usecTimestampNow();
LineEntityItem* lineEntity = static_cast<LineEntityItem*>(entity.get()); auto lineEntity = std::static_pointer_cast<LineEntityItem>(entity);
_entityTree->lockForWrite(); _entityTree->lockForWrite();
bool success = actor(*lineEntity); bool success = actor(*lineEntity);
entity->setLastEdited(now); entity->setLastEdited(now);

2
libraries/entities/src/ModelEntityItem.cpp
View file

@ -29,7 +29,7 @@ const float ModelEntityItem::DEFAULT_ANIMATION_FPS = 30.0f;
EntityItemPointer ModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer ModelEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new ModelEntityItem(entityID, properties)); return std::make_shared<ModelEntityItem>(entityID, properties);
} }
ModelEntityItem::ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : ModelEntityItem::ModelEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/ParticleEffectEntityItem.cpp
View file

@ -56,7 +56,7 @@ const QString ParticleEffectEntityItem::DEFAULT_TEXTURES = "";
EntityItemPointer ParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer ParticleEffectEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new ParticleEffectEntityItem(entityID, properties)); return std::make_shared<ParticleEffectEntityItem>(entityID, properties);
} }
// our non-pure virtual subclass for now... // our non-pure virtual subclass for now...

7
libraries/entities/src/PolyVoxEntityItem.cpp
View file

@ -28,12 +28,9 @@ const PolyVoxEntityItem::PolyVoxSurfaceStyle PolyVoxEntityItem::DEFAULT_VOXEL_SU
PolyVoxEntityItem::SURFACE_MARCHING_CUBES; PolyVoxEntityItem::SURFACE_MARCHING_CUBES;
EntityItemPointer PolyVoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer PolyVoxEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new PolyVoxEntityItem(entityID, properties)); return std::make_shared<PolyVoxEntityItem>(entityID, properties);
} }
QByteArray PolyVoxEntityItem::makeEmptyVoxelData(quint16 voxelXSize, quint16 voxelYSize, quint16 voxelZSize) { QByteArray PolyVoxEntityItem::makeEmptyVoxelData(quint16 voxelXSize, quint16 voxelYSize, quint16 voxelZSize) {
int rawSize = voxelXSize * voxelYSize * voxelZSize; int rawSize = voxelXSize * voxelYSize * voxelZSize;
@ -48,8 +45,6 @@ QByteArray PolyVoxEntityItem::makeEmptyVoxelData(quint16 voxelXSize, quint16 vox
return newVoxelData; return newVoxelData;
} }
PolyVoxEntityItem::PolyVoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : PolyVoxEntityItem::PolyVoxEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :
EntityItem(entityItemID), EntityItem(entityItemID),
_voxelVolumeSize(PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE), _voxelVolumeSize(PolyVoxEntityItem::DEFAULT_VOXEL_VOLUME_SIZE),

2
libraries/entities/src/TextEntityItem.cpp
View file

@ -30,7 +30,7 @@ const xColor TextEntityItem::DEFAULT_BACKGROUND_COLOR = { 0, 0, 0};
const bool TextEntityItem::DEFAULT_FACE_CAMERA = false; const bool TextEntityItem::DEFAULT_FACE_CAMERA = false;
EntityItemPointer TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer TextEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new TextEntityItem(entityID, properties)); return std::make_shared<TextEntityItem>(entityID, properties);
} }
TextEntityItem::TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : TextEntityItem::TextEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/WebEntityItem.cpp
View file

@ -23,7 +23,7 @@
const QString WebEntityItem::DEFAULT_SOURCE_URL("http://www.google.com"); const QString WebEntityItem::DEFAULT_SOURCE_URL("http://www.google.com");
EntityItemPointer WebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer WebEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new WebEntityItem(entityID, properties)); return std::make_shared<WebEntityItem>(entityID, properties);
} }
WebEntityItem::WebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : WebEntityItem::WebEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

2
libraries/entities/src/ZoneEntityItem.cpp
View file

@ -30,7 +30,7 @@ const ShapeType ZoneEntityItem::DEFAULT_SHAPE_TYPE = SHAPE_TYPE_BOX;
const QString ZoneEntityItem::DEFAULT_COMPOUND_SHAPE_URL = ""; const QString ZoneEntityItem::DEFAULT_COMPOUND_SHAPE_URL = "";
EntityItemPointer ZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) { EntityItemPointer ZoneEntityItem::factory(const EntityItemID& entityID, const EntityItemProperties& properties) {
return EntityItemPointer(new ZoneEntityItem(entityID, properties)); return std::make_shared<ZoneEntityItem>(entityID, properties);
} }
ZoneEntityItem::ZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) : ZoneEntityItem::ZoneEntityItem(const EntityItemID& entityItemID, const EntityItemProperties& properties) :

10
libraries/fbx/src/FBXReader.cpp
View file

@ -1323,7 +1323,7 @@ void buildModelMesh(ExtractedMesh& extracted) {
model::Mesh mesh; model::Mesh mesh;
// Grab the vertices in a buffer // Grab the vertices in a buffer
gpu::BufferPointer vb(new gpu::Buffer()); auto vb = make_shared<gpu::Buffer>();
vb->setData(extracted.mesh.vertices.size() * sizeof(glm::vec3), vb->setData(extracted.mesh.vertices.size() * sizeof(glm::vec3),
(const gpu::Byte*) extracted.mesh.vertices.data()); (const gpu::Byte*) extracted.mesh.vertices.data());
gpu::BufferView vbv(vb, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); gpu::BufferView vbv(vb, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
@ -1348,7 +1348,7 @@ void buildModelMesh(ExtractedMesh& extracted) {
int totalAttributeSize = clusterWeightsOffset + clusterWeightsSize; int totalAttributeSize = clusterWeightsOffset + clusterWeightsSize;
// Copy all attribute data in a single attribute buffer // Copy all attribute data in a single attribute buffer
gpu::BufferPointer attribBuffer(new gpu::Buffer()); auto attribBuffer = make_shared<gpu::Buffer>();
attribBuffer->resize(totalAttributeSize); attribBuffer->resize(totalAttributeSize);
attribBuffer->setSubData(normalsOffset, normalsSize, (gpu::Byte*) fbxMesh.normals.constData()); attribBuffer->setSubData(normalsOffset, normalsSize, (gpu::Byte*) fbxMesh.normals.constData());
attribBuffer->setSubData(tangentsOffset, tangentsSize, (gpu::Byte*) fbxMesh.tangents.constData()); attribBuffer->setSubData(tangentsOffset, tangentsSize, (gpu::Byte*) fbxMesh.tangents.constData());
@ -1407,7 +1407,7 @@ void buildModelMesh(ExtractedMesh& extracted) {
return; return;
} }
gpu::BufferPointer ib(new gpu::Buffer()); auto ib = make_shared<gpu::Buffer>();
ib->resize(totalIndices * sizeof(int)); ib->resize(totalIndices * sizeof(int));
int indexNum = 0; int indexNum = 0;
@ -1437,7 +1437,7 @@ void buildModelMesh(ExtractedMesh& extracted) {
mesh.setIndexBuffer(ibv); mesh.setIndexBuffer(ibv);
if (parts.size()) { if (parts.size()) {
gpu::BufferPointer pb(new gpu::Buffer()); auto pb = make_shared<gpu::Buffer>();
pb->setData(parts.size() * sizeof(model::Mesh::Part), (const gpu::Byte*) parts.data()); pb->setData(parts.size() * sizeof(model::Mesh::Part), (const gpu::Byte*) parts.data());
gpu::BufferView pbv(pb, gpu::Element(gpu::VEC4, gpu::UINT32, gpu::XYZW)); gpu::BufferView pbv(pb, gpu::Element(gpu::VEC4, gpu::UINT32, gpu::XYZW));
mesh.setPartBuffer(pbv); mesh.setPartBuffer(pbv);
@ -1926,7 +1926,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
} }
material.id = getID(object.properties); material.id = getID(object.properties);
material._material = model::MaterialPointer(new model::Material()); material._material = make_shared<model::Material>();
material._material->setEmissive(material.emissive); material._material->setEmissive(material.emissive);
if (glm::all(glm::equal(material.diffuse, glm::vec3(0.0f)))) { if (glm::all(glm::equal(material.diffuse, glm::vec3(0.0f)))) {
material._material->setDiffuse(material.diffuse); material._material->setDiffuse(material.diffuse);

2
libraries/fbx/src/OBJReader.cpp
View file

@ -131,7 +131,7 @@ void setMeshPartDefaults(FBXMeshPart& meshPart, QString materialID) {
meshPart.materialID = materialID; meshPart.materialID = materialID;
meshPart.opacity = 1.0; meshPart.opacity = 1.0;
meshPart._material = model::MaterialPointer(new model::Material()); meshPart._material = std::make_shared<model::Material>();
meshPart._material->setDiffuse(glm::vec3(1.0, 1.0, 1.0)); meshPart._material->setDiffuse(glm::vec3(1.0, 1.0, 1.0));
meshPart._material->setOpacity(1.0); meshPart._material->setOpacity(1.0);
meshPart._material->setMetallic(0.0); meshPart._material->setMetallic(0.0);

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

@ -40,97 +40,99 @@ const GLBackend::GLState::Commands makeResetStateCommands() {
// and we have a 50/50 chance that State::DEFAULT is not yet initialized. // and we have a 50/50 chance that State::DEFAULT is not yet initialized.
// Since State::DEFAULT = State::Data() it is much easier to not use the actual State::DEFAULT // Since State::DEFAULT = State::Data() it is much easier to not use the actual State::DEFAULT
// but another State::Data object with a default initialization. // but another State::Data object with a default initialization.
State::Data DEFAULT = State::Data(); const State::Data DEFAULT = State::Data();
CommandPointer depthBiasCommand = CommandPointer(new CommandDepthBias(&GLBackend::do_setStateDepthBias, Vec2(DEFAULT.depthBias, DEFAULT.depthBiasSlopeScale))); auto depthBiasCommand = std::make_shared<CommandDepthBias>(&GLBackend::do_setStateDepthBias,
CommandPointer stencilCommand = CommandPointer(new CommandStencil(&GLBackend::do_setStateStencil, DEFAULT.stencilActivation, DEFAULT.stencilTestFront, DEFAULT.stencilTestBack)); Vec2(DEFAULT.depthBias, DEFAULT.depthBiasSlopeScale));
auto stencilCommand = std::make_shared<CommandStencil>(&GLBackend::do_setStateStencil, DEFAULT.stencilActivation,
DEFAULT.stencilTestFront, DEFAULT.stencilTestBack);
// The state commands to reset to default, // The state commands to reset to default,
// WARNING depending on the order of the State::Field enum // WARNING depending on the order of the State::Field enum
return { return {
CommandPointer(new Command1I(&GLBackend::do_setStateFillMode, DEFAULT.fillMode)), std::make_shared<Command1I>(&GLBackend::do_setStateFillMode, DEFAULT.fillMode),
CommandPointer(new Command1I(&GLBackend::do_setStateCullMode, DEFAULT.cullMode)), std::make_shared<Command1I>(&GLBackend::do_setStateCullMode, DEFAULT.cullMode),
CommandPointer(new Command1B(&GLBackend::do_setStateFrontFaceClockwise, DEFAULT.frontFaceClockwise)), std::make_shared<Command1B>(&GLBackend::do_setStateFrontFaceClockwise, DEFAULT.frontFaceClockwise),
CommandPointer(new Command1B(&GLBackend::do_setStateDepthClampEnable, DEFAULT.depthClampEnable)), std::make_shared<Command1B>(&GLBackend::do_setStateDepthClampEnable, DEFAULT.depthClampEnable),
CommandPointer(new Command1B(&GLBackend::do_setStateScissorEnable, DEFAULT.scissorEnable)), std::make_shared<Command1B>(&GLBackend::do_setStateScissorEnable, DEFAULT.scissorEnable),
CommandPointer(new Command1B(&GLBackend::do_setStateMultisampleEnable, DEFAULT.multisampleEnable)), std::make_shared<Command1B>(&GLBackend::do_setStateMultisampleEnable, DEFAULT.multisampleEnable),
CommandPointer(new Command1B(&GLBackend::do_setStateAntialiasedLineEnable, DEFAULT.antialisedLineEnable)), std::make_shared<Command1B>(&GLBackend::do_setStateAntialiasedLineEnable, DEFAULT.antialisedLineEnable),
// Depth bias has 2 fields in State but really one call in GLBackend // Depth bias has 2 fields in State but really one call in GLBackend
CommandPointer(depthBiasCommand), CommandPointer(depthBiasCommand),
CommandPointer(depthBiasCommand), CommandPointer(depthBiasCommand),
CommandPointer(new CommandDepthTest(&GLBackend::do_setStateDepthTest, DEFAULT.depthTest)), std::make_shared<CommandDepthTest>(&GLBackend::do_setStateDepthTest, DEFAULT.depthTest),
// Depth bias has 3 fields in State but really one call in GLBackend // Depth bias has 3 fields in State but really one call in GLBackend
CommandPointer(stencilCommand), CommandPointer(stencilCommand),
CommandPointer(stencilCommand), CommandPointer(stencilCommand),
CommandPointer(stencilCommand), CommandPointer(stencilCommand),
CommandPointer(new Command1B(&GLBackend::do_setStateAlphaToCoverageEnable, DEFAULT.alphaToCoverageEnable)), std::make_shared<Command1B>(&GLBackend::do_setStateAlphaToCoverageEnable, DEFAULT.alphaToCoverageEnable),
CommandPointer(new Command1U(&GLBackend::do_setStateSampleMask, DEFAULT.sampleMask)), std::make_shared<Command1U>(&GLBackend::do_setStateSampleMask, DEFAULT.sampleMask),
CommandPointer(new CommandBlend(&GLBackend::do_setStateBlend, DEFAULT.blendFunction)), std::make_shared<CommandBlend>(&GLBackend::do_setStateBlend, DEFAULT.blendFunction),
CommandPointer(new Command1U(&GLBackend::do_setStateColorWriteMask, DEFAULT.colorWriteMask)) std::make_shared<Command1U>(&GLBackend::do_setStateColorWriteMask, DEFAULT.colorWriteMask)
}; };
} }
void generateFillMode(GLBackend::GLState::Commands& commands, State::FillMode fillMode) { void generateFillMode(GLBackend::GLState::Commands& commands, State::FillMode fillMode) {
commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateFillMode, int32(fillMode)))); commands.push_back(std::make_shared<Command1I>(&GLBackend::do_setStateFillMode, int32(fillMode)));
} }
void generateCullMode(GLBackend::GLState::Commands& commands, State::CullMode cullMode) { void generateCullMode(GLBackend::GLState::Commands& commands, State::CullMode cullMode) {
commands.push_back(CommandPointer(new Command1I(&GLBackend::do_setStateCullMode, int32(cullMode)))); commands.push_back(std::make_shared<Command1I>(&GLBackend::do_setStateCullMode, int32(cullMode)));
} }
void generateFrontFaceClockwise(GLBackend::GLState::Commands& commands, bool isClockwise) { void generateFrontFaceClockwise(GLBackend::GLState::Commands& commands, bool isClockwise) {
commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateFrontFaceClockwise, isClockwise))); commands.push_back(std::make_shared<Command1B>(&GLBackend::do_setStateFrontFaceClockwise, isClockwise));
} }
void generateDepthClampEnable(GLBackend::GLState::Commands& commands, bool enable) { void generateDepthClampEnable(GLBackend::GLState::Commands& commands, bool enable) {
commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateDepthClampEnable, enable))); commands.push_back(std::make_shared<Command1B>(&GLBackend::do_setStateDepthClampEnable, enable));
} }
void generateScissorEnable(GLBackend::GLState::Commands& commands, bool enable) { void generateScissorEnable(GLBackend::GLState::Commands& commands, bool enable) {
commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateScissorEnable, enable))); commands.push_back(std::make_shared<Command1B>(&GLBackend::do_setStateScissorEnable, enable));
} }
void generateMultisampleEnable(GLBackend::GLState::Commands& commands, bool enable) { void generateMultisampleEnable(GLBackend::GLState::Commands& commands, bool enable) {
commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateMultisampleEnable, enable))); commands.push_back(std::make_shared<Command1B>(&GLBackend::do_setStateMultisampleEnable, enable));
} }
void generateAntialiasedLineEnable(GLBackend::GLState::Commands& commands, bool enable) { void generateAntialiasedLineEnable(GLBackend::GLState::Commands& commands, bool enable) {
commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateAntialiasedLineEnable, enable))); commands.push_back(std::make_shared<Command1B>(&GLBackend::do_setStateAntialiasedLineEnable, enable));
} }
void generateDepthBias(GLBackend::GLState::Commands& commands, const State& state) { void generateDepthBias(GLBackend::GLState::Commands& commands, const State& state) {
commands.push_back(CommandPointer(new CommandDepthBias(&GLBackend::do_setStateDepthBias, Vec2(state.getDepthBias(), state.getDepthBiasSlopeScale())))); commands.push_back(std::make_shared<CommandDepthBias>(&GLBackend::do_setStateDepthBias, Vec2(state.getDepthBias(), state.getDepthBiasSlopeScale())));
} }
void generateDepthTest(GLBackend::GLState::Commands& commands, const State::DepthTest& test) { void generateDepthTest(GLBackend::GLState::Commands& commands, const State::DepthTest& test) {
commands.push_back(CommandPointer(new CommandDepthTest(&GLBackend::do_setStateDepthTest, int32(test.getRaw())))); commands.push_back(std::make_shared<CommandDepthTest>(&GLBackend::do_setStateDepthTest, int32(test.getRaw())));
} }
void generateStencil(GLBackend::GLState::Commands& commands, const State& state) { void generateStencil(GLBackend::GLState::Commands& commands, const State& state) {
commands.push_back(CommandPointer(new CommandStencil(&GLBackend::do_setStateStencil, state.getStencilActivation(), state.getStencilTestFront(), state.getStencilTestBack()))); commands.push_back(std::make_shared<CommandStencil>(&GLBackend::do_setStateStencil, state.getStencilActivation(), state.getStencilTestFront(), state.getStencilTestBack()));
} }
void generateAlphaToCoverageEnable(GLBackend::GLState::Commands& commands, bool enable) { void generateAlphaToCoverageEnable(GLBackend::GLState::Commands& commands, bool enable) {
commands.push_back(CommandPointer(new Command1B(&GLBackend::do_setStateAlphaToCoverageEnable, enable))); commands.push_back(std::make_shared<Command1B>(&GLBackend::do_setStateAlphaToCoverageEnable, enable));
} }
void generateSampleMask(GLBackend::GLState::Commands& commands, uint32 mask) { void generateSampleMask(GLBackend::GLState::Commands& commands, uint32 mask) {
commands.push_back(CommandPointer(new Command1U(&GLBackend::do_setStateSampleMask, mask))); commands.push_back(std::make_shared<Command1U>(&GLBackend::do_setStateSampleMask, mask));
} }
void generateBlend(GLBackend::GLState::Commands& commands, const State& state) { void generateBlend(GLBackend::GLState::Commands& commands, const State& state) {
commands.push_back(CommandPointer(new CommandBlend(&GLBackend::do_setStateBlend, state.getBlendFunction()))); commands.push_back(std::make_shared<CommandBlend>(&GLBackend::do_setStateBlend, state.getBlendFunction()));
} }
void generateColorWriteMask(GLBackend::GLState::Commands& commands, uint32 mask) { void generateColorWriteMask(GLBackend::GLState::Commands& commands, uint32 mask) {
commands.push_back(CommandPointer(new Command1U(&GLBackend::do_setStateColorWriteMask, mask))); commands.push_back(std::make_shared<Command1U>(&GLBackend::do_setStateColorWriteMask, mask));
} }
GLBackend::GLState* GLBackend::syncGPUObject(const State& state) { GLBackend::GLState* GLBackend::syncGPUObject(const State& state) {

6
libraries/gpu/src/gpu/Texture.cpp
View file

@ -80,7 +80,7 @@ bool Texture::Storage::allocateMip(uint16 level) {
auto& mip = _mips[level]; auto& mip = _mips[level];
for (auto& face : mip) { for (auto& face : mip) {
if (!face) { if (!face) {
face.reset(new Pixels()); face = std::make_shared<Pixels>();
changed = true; changed = true;
} }
} }
@ -419,7 +419,7 @@ bool Texture::generateIrradiance() {
return false; return false;
} }
if (!_irradiance) { if (!_irradiance) {
_irradiance.reset(new SphericalHarmonics()); _irradiance = std::make_shared<SphericalHarmonics>();
} }
_irradiance->evalFromTexture(*this); _irradiance->evalFromTexture(*this);
@ -563,7 +563,7 @@ glm::vec3 linearTosRGB(glm::vec3& color) {
return glm::pow(color, glm::vec3(GAMMA_CORRECTION_INV)); return glm::pow(color, glm::vec3(GAMMA_CORRECTION_INV));
} }
// Originial code for the Spherical Harmonics taken from "Sun and Black Cat- Igor Dykhta (igor dykhta email) © 2007-2014 " // Originial code for the Spherical Harmonics taken from "Sun and Black Cat- Igor Dykhta (igor dykhta email) <EFBFBD> 2007-2014 "
void sphericalHarmonicsAdd(float * result, int order, const float * inputA, const float * inputB) { void sphericalHarmonicsAdd(float * result, int order, const float * inputA, const float * inputB) {
const int numCoeff = order * order; const int numCoeff = order * order;
for(int i=0; i < numCoeff; i++) { for(int i=0; i < numCoeff; i++) {

2
libraries/model/src/model/Light.cpp
View file

@ -18,7 +18,7 @@ Light::Light() :
_transform() { _transform() {
// only if created from nothing shall we create the Buffer to store the properties // only if created from nothing shall we create the Buffer to store the properties
Schema schema; Schema schema;
_schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Byte*) &schema)); _schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Schema), (const gpu::Byte*) &schema));
} }
Light::Light(const Light& light) : Light::Light(const Light& light) :

2
libraries/model/src/model/Material.cpp
View file

@ -20,7 +20,7 @@ Material::Material() :
// only if created from nothing shall we create the Buffer to store the properties // only if created from nothing shall we create the Buffer to store the properties
Schema schema; Schema schema;
_schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Byte*) &schema)); _schemaBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Schema), (const gpu::Byte*) &schema));
} }

8
libraries/model/src/model/Skybox.cpp
View file

@ -68,19 +68,19 @@ void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Sky
SKYBOX_CONSTANTS_SLOT = skyShader->getUniforms().findLocation("skyboxBuffer"); SKYBOX_CONSTANTS_SLOT = skyShader->getUniforms().findLocation("skyboxBuffer");
} }
auto skyState = gpu::StatePointer(new gpu::State()); auto skyState = std::make_shared<gpu::State>();
thePipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState)); thePipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));
const float CLIP = 1.0f; const float CLIP = 1.0f;
const glm::vec2 vertices[4] = { {-CLIP, -CLIP}, {CLIP, -CLIP}, {-CLIP, CLIP}, {CLIP, CLIP}}; const glm::vec2 vertices[4] = { {-CLIP, -CLIP}, {CLIP, -CLIP}, {-CLIP, CLIP}, {CLIP, CLIP}};
theBuffer.reset(new gpu::Buffer(sizeof(vertices), (const gpu::Byte*) vertices)); theBuffer = std::make_shared<gpu::Buffer>(sizeof(vertices), (const gpu::Byte*) vertices);
theFormat.reset(new gpu::Stream::Format()); theFormat = std::make_shared<gpu::Stream::Format>();
theFormat->setAttribute(gpu::Stream::POSITION, gpu::Stream::POSITION, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ)); theFormat->setAttribute(gpu::Stream::POSITION, gpu::Stream::POSITION, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ));
auto color = glm::vec4(1.0f); auto color = glm::vec4(1.0f);
theConstants.reset(new gpu::Buffer(sizeof(color), (const gpu::Byte*) &color)); theConstants = std::make_shared<gpu::Buffer>(sizeof(color), (const gpu::Byte*) &color);
} }
glm::mat4 projMat; glm::mat4 projMat;

11
libraries/model/src/model/Stage.cpp
View file

@ -136,7 +136,7 @@ void EarthSunModel::setSunLongitude(float lon) {
Atmosphere::Atmosphere() { Atmosphere::Atmosphere() {
// only if created from nothing shall we create the Buffer to store the properties // only if created from nothing shall we create the Buffer to store the properties
Data data; Data data;
_dataBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Data), (const gpu::Byte*) &data)); _dataBuffer = gpu::BufferView(std::make_shared<gpu::Buffer>(sizeof(Data), (const gpu::Byte*) &data));
setScatteringWavelength(_scatteringWavelength); setScatteringWavelength(_scatteringWavelength);
setRayleighScattering(_rayleighScattering); setRayleighScattering(_rayleighScattering);
@ -188,8 +188,8 @@ const float NUM_HOURS_PER_DAY = 24.0f;
const float NUM_HOURS_PER_HALF_DAY = NUM_HOURS_PER_DAY * 0.5f; const float NUM_HOURS_PER_HALF_DAY = NUM_HOURS_PER_DAY * 0.5f;
SunSkyStage::SunSkyStage() : SunSkyStage::SunSkyStage() :
_sunLight(new Light()), _sunLight(std::make_shared<Light>()),
_skybox(new Skybox()) _skybox(std::make_shared<Skybox>())
{ {
_sunLight->setType(Light::SUN); _sunLight->setType(Light::SUN);
@ -204,9 +204,8 @@ SunSkyStage::SunSkyStage() :
// Begining of march // Begining of march
setYearTime(60.0f); setYearTime(60.0f);
_skybox.reset(new Skybox()); _skybox = std::make_shared<Skybox>();
_skybox->setColor(Color(1.0f, 0.0f, 0.0f)); _skybox->setColor(Color(1.0f, 0.0f, 0.0f));
} }
SunSkyStage::~SunSkyStage() { SunSkyStage::~SunSkyStage() {
@ -302,4 +301,4 @@ void SunSkyStage::setBackgroundMode(BackgroundMode mode) {
void SunSkyStage::setSkybox(const SkyboxPointer& skybox) { void SunSkyStage::setSkybox(const SkyboxPointer& skybox) {
_skybox = skybox; _skybox = skybox;
invalidate(); invalidate();
} }

2
libraries/networking/src/NetworkPeer.cpp
View file

@ -215,7 +215,7 @@ static QHash<QUuid, BandwidthRecorderPtr> PEER_BANDWIDTH;
BandwidthRecorder& getBandwidthRecorder(const QUuid & uuid) { BandwidthRecorder& getBandwidthRecorder(const QUuid & uuid) {
if (!PEER_BANDWIDTH.count(uuid)) { if (!PEER_BANDWIDTH.count(uuid)) {
PEER_BANDWIDTH.insert(uuid, BandwidthRecorderPtr(new BandwidthRecorder())); PEER_BANDWIDTH.insert(uuid, QSharedPointer<BandwidthRecorder>::create());
} }
return *PEER_BANDWIDTH[uuid].data(); return *PEER_BANDWIDTH[uuid].data();
} }

12
libraries/render-utils/src/DeferredLightingEffect.cpp
View file

@ -56,7 +56,7 @@ gpu::PipelinePointer DeferredLightingEffect::getPipeline(SimpleProgramKey config
return it.value(); return it.value();
} }
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
if (config.isCulled()) { if (config.isCulled()) {
state->setCullMode(gpu::State::CULL_BACK); state->setCullMode(gpu::State::CULL_BACK);
} else { } else {
@ -117,7 +117,7 @@ void DeferredLightingEffect::init(AbstractViewStateInterface* viewState) {
//auto PSBlit = gpu::StandardShaderLib::getDrawTexturePS(); //auto PSBlit = gpu::StandardShaderLib::getDrawTexturePS();
auto blitProgram = gpu::StandardShaderLib::getProgram(gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS, gpu::StandardShaderLib::getDrawTexturePS); auto blitProgram = gpu::StandardShaderLib::getProgram(gpu::StandardShaderLib::getDrawViewportQuadTransformTexcoordVS, gpu::StandardShaderLib::getDrawTexturePS);
gpu::Shader::makeProgram(*blitProgram); gpu::Shader::makeProgram(*blitProgram);
gpu::StatePointer blitState = gpu::StatePointer(new gpu::State()); auto blitState = std::make_shared<gpu::State>();
blitState->setBlendFunction(true, blitState->setBlendFunction(true,
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);
@ -127,7 +127,7 @@ void DeferredLightingEffect::init(AbstractViewStateInterface* viewState) {
// Allocate a global light representing the Global Directional light casting shadow (the sun) and the ambient light // Allocate a global light representing the Global Directional light casting shadow (the sun) and the ambient light
_globalLights.push_back(0); _globalLights.push_back(0);
_allocatedLights.push_back(model::LightPointer(new model::Light())); _allocatedLights.push_back(std::make_shared<model::Light>());
model::LightPointer lp = _allocatedLights[0]; model::LightPointer lp = _allocatedLights[0];
@ -191,7 +191,7 @@ void DeferredLightingEffect::addSpotLight(const glm::vec3& position, float radiu
unsigned int lightID = _pointLights.size() + _spotLights.size() + _globalLights.size(); unsigned int lightID = _pointLights.size() + _spotLights.size() + _globalLights.size();
if (lightID >= _allocatedLights.size()) { if (lightID >= _allocatedLights.size()) {
_allocatedLights.push_back(model::LightPointer(new model::Light())); _allocatedLights.push_back(std::make_shared<model::Light>());
} }
model::LightPointer lp = _allocatedLights[lightID]; model::LightPointer lp = _allocatedLights[lightID];
@ -614,7 +614,7 @@ void DeferredLightingEffect::loadLightProgram(const char* vertSource, const char
locations.atmosphereBufferUnit = program->getUniforms().findLocation("atmosphereBufferUnit"); locations.atmosphereBufferUnit = program->getUniforms().findLocation("atmosphereBufferUnit");
#endif #endif
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
if (lightVolume) { if (lightVolume) {
state->setCullMode(gpu::State::CULL_BACK); state->setCullMode(gpu::State::CULL_BACK);
@ -657,7 +657,7 @@ void DeferredLightingEffect::setGlobalSkybox(const model::SkyboxPointer& skybox)
model::MeshPointer DeferredLightingEffect::getSpotLightMesh() { model::MeshPointer DeferredLightingEffect::getSpotLightMesh() {
if (!_spotLightMesh) { if (!_spotLightMesh) {
_spotLightMesh.reset(new model::Mesh()); _spotLightMesh = std::make_shared<model::Mesh>();
int slices = 32; int slices = 32;
int rings = 3; int rings = 3;

2
libraries/render-utils/src/Environment.cpp
View file

@ -59,7 +59,7 @@ void Environment::setupAtmosphereProgram(const char* vertSource, const char* fra
gpu::Shader::BindingSet slotBindings; gpu::Shader::BindingSet slotBindings;
gpu::Shader::makeProgram(*program, slotBindings); gpu::Shader::makeProgram(*program, slotBindings);
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
state->setCullMode(gpu::State::CULL_NONE); state->setCullMode(gpu::State::CULL_NONE);
state->setDepthTest(false); state->setDepthTest(false);

172
libraries/render-utils/src/GeometryCache.cpp
View file

@ -79,8 +79,8 @@ void GeometryCache::renderSphere(gpu::Batch& batch, float radius, int slices, in
qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED VERTICES BUFFER"; qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED VERTICES BUFFER";
#endif #endif
} }
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
if (registered) { if (registered) {
_registeredSphereVertices[id] = verticesBuffer; _registeredSphereVertices[id] = verticesBuffer;
_lastRegisteredSphereVertices[id] = radiusKey; _lastRegisteredSphereVertices[id] = radiusKey;
@ -144,7 +144,7 @@ void GeometryCache::renderSphere(gpu::Batch& batch, float radius, int slices, in
#endif #endif
} }
gpu::BufferPointer indicesBuffer(new gpu::Buffer()); auto indicesBuffer = std::make_shared<gpu::Buffer>();
if (registered) { if (registered) {
_registeredSphereIndices[id] = indicesBuffer; _registeredSphereIndices[id] = indicesBuffer;
_lastRegisteredSphereIndices[id] = slicesStacksKey; _lastRegisteredSphereIndices[id] = slicesStacksKey;
@ -229,8 +229,8 @@ void GeometryCache::renderSphere(gpu::Batch& batch, float radius, int slices, in
qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED COLORS BUFFER"; qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED COLORS BUFFER";
#endif #endif
} }
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
if (registered) { if (registered) {
_registeredSphereColors[id] = colorBuffer; _registeredSphereColors[id] = colorBuffer;
_lastRegisteredSphereColors[id] = colorKey; _lastRegisteredSphereColors[id] = colorKey;
@ -278,7 +278,7 @@ void GeometryCache::renderSphere(gpu::Batch& batch, float radius, int slices, in
static gpu::Stream::FormatPointer streamFormat; static gpu::Stream::FormatPointer streamFormat;
static gpu::Element positionElement, normalElement, colorElement; static gpu::Element positionElement, normalElement, colorElement;
if (!streamFormat) { if (!streamFormat) {
streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone streamFormat = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0); streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA)); streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
@ -316,7 +316,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int xDivisions, int yDivisions
int vertices = (xDivisions + 1 + yDivisions + 1) * 2; int vertices = (xDivisions + 1 + yDivisions + 1) * 2;
if (!_gridBuffers.contains(key)) { if (!_gridBuffers.contains(key)) {
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
GLfloat* vertexData = new GLfloat[vertices * 2]; GLfloat* vertexData = new GLfloat[vertices * 2];
GLfloat* vertex = vertexData; GLfloat* vertex = vertexData;
@ -347,7 +347,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int xDivisions, int yDivisions
} }
if (!_gridColors.contains(colorKey)) { if (!_gridColors.contains(colorKey)) {
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
_gridColors[colorKey] = colorBuffer; _gridColors[colorKey] = colorBuffer;
int compactColor = ((int(color.x * 255.0f) & 0xFF)) | int compactColor = ((int(color.x * 255.0f) & 0xFF)) |
@ -370,7 +370,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int xDivisions, int yDivisions
const int VERTICES_SLOT = 0; const int VERTICES_SLOT = 0;
const int COLOR_SLOT = 1; const int COLOR_SLOT = 1;
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone auto streamFormat = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0); streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0);
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA)); streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
@ -417,7 +417,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int x, int y, int width, int h
#endif #endif
} }
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
if (registered) { if (registered) {
_registeredAlternateGridBuffers[id] = verticesBuffer; _registeredAlternateGridBuffers[id] = verticesBuffer;
_lastRegisteredAlternateGridBuffers[id] = key; _lastRegisteredAlternateGridBuffers[id] = key;
@ -458,7 +458,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int x, int y, int width, int h
} }
if (!_gridColors.contains(colorKey)) { if (!_gridColors.contains(colorKey)) {
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
_gridColors[colorKey] = colorBuffer; _gridColors[colorKey] = colorBuffer;
int compactColor = ((int(color.x * 255.0f) & 0xFF)) | int compactColor = ((int(color.x * 255.0f) & 0xFF)) |
@ -483,7 +483,7 @@ void GeometryCache::renderGrid(gpu::Batch& batch, int x, int y, int width, int h
const int VERTICES_SLOT = 0; const int VERTICES_SLOT = 0;
const int COLOR_SLOT = 1; const int COLOR_SLOT = 1;
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); // 1 for everyone auto streamFormat = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0); streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0);
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA)); streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
@ -511,11 +511,11 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
details.isCreated = true; details.isCreated = true;
details.vertices = points.size(); details.vertices = points.size();
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -572,11 +572,11 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
details.isCreated = true; details.isCreated = true;
details.vertices = points.size(); details.vertices = points.size();
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -635,11 +635,11 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
details.isCreated = true; details.isCreated = true;
details.vertices = points.size(); details.vertices = points.size();
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -726,7 +726,7 @@ void GeometryCache::renderSolidCube(gpu::Batch& batch, float size, const glm::ve
const int NORMALS_OFFSET = sizeof(GLfloat) * FLOATS_PER_VERTEX; const int NORMALS_OFFSET = sizeof(GLfloat) * FLOATS_PER_VERTEX;
if (!_solidCubeVertices.contains(size)) { if (!_solidCubeVertices.contains(size)) {
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
_solidCubeVertices[size] = verticesBuffer; _solidCubeVertices[size] = verticesBuffer;
GLfloat* vertexData = new GLfloat[vertexPoints * 2]; // vertices and normals GLfloat* vertexData = new GLfloat[vertexPoints * 2]; // vertices and normals
@ -777,15 +777,15 @@ void GeometryCache::renderSolidCube(gpu::Batch& batch, float size, const glm::ve
12,13,14, 14,15,12, // left 12,13,14, 14,15,12, // left
16,17,18, 18,19,16, // bottom 16,17,18, 18,19,16, // bottom
20,21,22, 22,23,20 }; // back 20,21,22, 22,23,20 }; // back
gpu::BufferPointer indexBuffer(new gpu::Buffer()); auto indexBuffer = std::make_shared<gpu::Buffer>();
_solidCubeIndexBuffer = indexBuffer; _solidCubeIndexBuffer = indexBuffer;
_solidCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices); _solidCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices);
} }
if (!_solidCubeColors.contains(colorKey)) { if (!_solidCubeColors.contains(colorKey)) {
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
_solidCubeColors[colorKey] = colorBuffer; _solidCubeColors[colorKey] = colorBuffer;
const int NUM_COLOR_SCALARS_PER_CUBE = 24; const int NUM_COLOR_SCALARS_PER_CUBE = 24;
@ -811,7 +811,7 @@ void GeometryCache::renderSolidCube(gpu::Batch& batch, float size, const glm::ve
static gpu::Stream::FormatPointer streamFormat; static gpu::Stream::FormatPointer streamFormat;
static gpu::Element positionElement, normalElement, colorElement; static gpu::Element positionElement, normalElement, colorElement;
if (!streamFormat) { if (!streamFormat) {
streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone streamFormat = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0); streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); streamFormat->setAttribute(gpu::Stream::NORMAL, NORMALS_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA)); streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
@ -850,7 +850,7 @@ void GeometryCache::renderWireCube(gpu::Batch& batch, float size, const glm::vec
const int indices = (TOP_EDGES + BOTTOM_EDGES + SIDE_EDGES) * VERTICES_PER_EDGE; const int indices = (TOP_EDGES + BOTTOM_EDGES + SIDE_EDGES) * VERTICES_PER_EDGE;
if (!_cubeVerticies.contains(size)) { if (!_cubeVerticies.contains(size)) {
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
_cubeVerticies[size] = verticesBuffer; _cubeVerticies[size] = verticesBuffer;
int vertexPoints = vertices * FLOATS_PER_VERTEX; int vertexPoints = vertices * FLOATS_PER_VERTEX;
@ -876,15 +876,15 @@ void GeometryCache::renderWireCube(gpu::Batch& batch, float size, const glm::vec
4, 5, 5, 6, 6, 7, 7, 4, // (bottom) 4, 5, 5, 6, 6, 7, 7, 4, // (bottom)
0, 4, 1, 5, 2, 6, 3, 7, // (side edges) 0, 4, 1, 5, 2, 6, 3, 7, // (side edges)
}; };
gpu::BufferPointer indexBuffer(new gpu::Buffer()); auto indexBuffer = std::make_shared<gpu::Buffer>();
_wireCubeIndexBuffer = indexBuffer; _wireCubeIndexBuffer = indexBuffer;
_wireCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices); _wireCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices);
} }
if (!_cubeColors.contains(colorKey)) { if (!_cubeColors.contains(colorKey)) {
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
_cubeColors[colorKey] = colorBuffer; _cubeColors[colorKey] = colorBuffer;
const int NUM_COLOR_SCALARS_PER_CUBE = 8; const int NUM_COLOR_SCALARS_PER_CUBE = 8;
@ -905,7 +905,7 @@ void GeometryCache::renderWireCube(gpu::Batch& batch, float size, const glm::vec
static gpu::Stream::FormatPointer streamFormat; static gpu::Stream::FormatPointer streamFormat;
static gpu::Element positionElement, colorElement; static gpu::Element positionElement, colorElement;
if (!streamFormat) { if (!streamFormat) {
streamFormat.reset(new gpu::Stream::Format()); // 1 for everyone streamFormat = std::make_shared<gpu::Stream::Format>(); // 1 for everyone
streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0); streamFormat->setAttribute(gpu::Stream::POSITION, VERTICES_SLOT, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA)); streamFormat->setAttribute(gpu::Stream::COLOR, COLOR_SLOT, gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA));
positionElement = streamFormat->getAttributes().at(gpu::Stream::POSITION)._element; positionElement = streamFormat->getAttributes().at(gpu::Stream::POSITION)._element;
@ -957,11 +957,11 @@ void GeometryCache::renderBevelCornersRect(gpu::Batch& batch, int x, int y, int
details.isCreated = true; details.isCreated = true;
details.vertices = NUM_VERTICES; details.vertices = NUM_VERTICES;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1065,11 +1065,11 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, co
details.isCreated = true; details.isCreated = true;
details.vertices = vertices; details.vertices = vertices;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1171,11 +1171,11 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec2& minCorner, co
details.isCreated = true; details.isCreated = true;
details.vertices = vertices; details.vertices = vertices;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1250,11 +1250,11 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec3& minCorner, co
details.isCreated = true; details.isCreated = true;
details.vertices = vertices; details.vertices = vertices;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1353,11 +1353,11 @@ void GeometryCache::renderQuad(gpu::Batch& batch, const glm::vec3& topLeft, cons
details.isCreated = true; details.isCreated = true;
details.vertices = vertices; details.vertices = vertices;
details.vertexSize = FLOATS_PER_VERTEX; // NOTE: this isn't used for BatchItemDetails maybe we can get rid of it details.vertexSize = FLOATS_PER_VERTEX; // NOTE: this isn't used for BatchItemDetails maybe we can get rid of it
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1440,11 +1440,11 @@ void GeometryCache::renderDashedLine(gpu::Batch& batch, const glm::vec3& start,
details.vertices = (segmentCountFloor + 1) * 2; details.vertices = (segmentCountFloor + 1) * 2;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
details.isCreated = true; details.isCreated = true;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1605,11 +1605,11 @@ void GeometryCache::renderLine(gpu::Batch& batch, const glm::vec3& p1, const glm
details.isCreated = true; details.isCreated = true;
details.vertices = vertices; details.vertices = vertices;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1695,11 +1695,11 @@ void GeometryCache::renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm
details.isCreated = true; details.isCreated = true;
details.vertices = vertices; details.vertices = vertices;
details.vertexSize = FLOATS_PER_VERTEX; details.vertexSize = FLOATS_PER_VERTEX;
gpu::BufferPointer verticesBuffer(new gpu::Buffer()); auto verticesBuffer = std::make_shared<gpu::Buffer>();
gpu::BufferPointer colorBuffer(new gpu::Buffer()); auto colorBuffer = std::make_shared<gpu::Buffer>();
gpu::Stream::FormatPointer streamFormat(new gpu::Stream::Format()); auto streamFormat = std::make_shared<gpu::Stream::Format>();
gpu::BufferStreamPointer stream(new gpu::BufferStream()); auto stream = std::make_shared<gpu::BufferStream>();
details.verticesBuffer = verticesBuffer; details.verticesBuffer = verticesBuffer;
details.colorBuffer = colorBuffer; details.colorBuffer = colorBuffer;
@ -1756,7 +1756,7 @@ void GeometryCache::useSimpleDrawPipeline(gpu::Batch& batch) {
auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps)); auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
gpu::Shader::makeProgram((*program)); gpu::Shader::makeProgram((*program));
auto state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
// enable decal blend // enable decal blend
state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA); state->setBlendFunction(true, gpu::State::SRC_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::INV_SRC_ALPHA);
@ -2129,8 +2129,8 @@ void NetworkGeometry::downloadFinished(QNetworkReply* reply) {
} }
QVariantHash lods = _mapping.value("lod").toHash(); QVariantHash lods = _mapping.value("lod").toHash();
for (QVariantHash::const_iterator it = lods.begin(); it != lods.end(); it++) { for (QVariantHash::const_iterator it = lods.begin(); it != lods.end(); it++) {
QSharedPointer<NetworkGeometry> geometry(new NetworkGeometry(url.resolved(it.key()), auto geometry = QSharedPointer<NetworkGeometry>::create(url.resolved(it.key()),
QSharedPointer<NetworkGeometry>(), true, _mapping, _textureBase)); QSharedPointer<NetworkGeometry>(), true, _mapping, _textureBase);
geometry->setSelf(geometry.staticCast<Resource>()); geometry->setSelf(geometry.staticCast<Resource>());
geometry->setLODParent(_lodParent); geometry->setLODParent(_lodParent);
_lods.insert(it.value().toFloat(), geometry); _lods.insert(it.value().toFloat(), geometry);
@ -2206,7 +2206,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
} }
{ {
networkMesh._indexBuffer = gpu::BufferPointer(new gpu::Buffer()); networkMesh._indexBuffer = std::make_shared<gpu::Buffer>();
networkMesh._indexBuffer->resize(totalIndices * sizeof(int)); networkMesh._indexBuffer->resize(totalIndices * sizeof(int));
int offset = 0; int offset = 0;
foreach(const FBXMeshPart& part, mesh.parts) { foreach(const FBXMeshPart& part, mesh.parts) {
@ -2220,7 +2220,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
} }
{ {
networkMesh._vertexBuffer = gpu::BufferPointer(new gpu::Buffer()); networkMesh._vertexBuffer = std::make_shared<gpu::Buffer>();
// if we don't need to do any blending, the positions/normals can be static // if we don't need to do any blending, the positions/normals can be static
if (mesh.blendshapes.isEmpty()) { if (mesh.blendshapes.isEmpty()) {
int normalsOffset = mesh.vertices.size() * sizeof(glm::vec3); int normalsOffset = mesh.vertices.size() * sizeof(glm::vec3);
@ -2248,7 +2248,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData()); mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData());
// otherwise, at least the cluster indices/weights can be static // otherwise, at least the cluster indices/weights can be static
networkMesh._vertexStream = gpu::BufferStreamPointer(new gpu::BufferStream()); networkMesh._vertexStream = std::make_shared<gpu::BufferStream>();
networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, 0, sizeof(glm::vec3)); networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, 0, sizeof(glm::vec3));
if (mesh.normals.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, normalsOffset, sizeof(glm::vec3)); if (mesh.normals.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, normalsOffset, sizeof(glm::vec3));
if (mesh.tangents.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, tangentsOffset, sizeof(glm::vec3)); if (mesh.tangents.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, tangentsOffset, sizeof(glm::vec3));
@ -2259,7 +2259,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
if (mesh.clusterWeights.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, clusterWeightsOffset, sizeof(glm::vec4)); if (mesh.clusterWeights.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, clusterWeightsOffset, sizeof(glm::vec4));
int channelNum = 0; int channelNum = 0;
networkMesh._vertexFormat = gpu::Stream::FormatPointer(new gpu::Stream::Format()); networkMesh._vertexFormat = std::make_shared<gpu::Stream::Format>();
networkMesh._vertexFormat->setAttribute(gpu::Stream::POSITION, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0); networkMesh._vertexFormat->setAttribute(gpu::Stream::POSITION, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ), 0);
if (mesh.normals.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::NORMAL, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); if (mesh.normals.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::NORMAL, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
if (mesh.tangents.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::TANGENT, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); if (mesh.tangents.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::TANGENT, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
@ -2290,7 +2290,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
networkMesh._vertexBuffer->setSubData(clusterWeightsOffset, networkMesh._vertexBuffer->setSubData(clusterWeightsOffset,
mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData()); mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData());
networkMesh._vertexStream = gpu::BufferStreamPointer(new gpu::BufferStream()); networkMesh._vertexStream = std::make_shared<gpu::BufferStream>();
if (mesh.tangents.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, 0, sizeof(glm::vec3)); if (mesh.tangents.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, 0, sizeof(glm::vec3));
if (mesh.colors.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, colorsOffset, sizeof(glm::vec3)); if (mesh.colors.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, colorsOffset, sizeof(glm::vec3));
if (mesh.texCoords.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, texCoordsOffset, sizeof(glm::vec2)); if (mesh.texCoords.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, texCoordsOffset, sizeof(glm::vec2));
@ -2298,7 +2298,7 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
if (mesh.clusterWeights.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, clusterWeightsOffset, sizeof(glm::vec4)); if (mesh.clusterWeights.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, clusterWeightsOffset, sizeof(glm::vec4));
int channelNum = 0; int channelNum = 0;
networkMesh._vertexFormat = gpu::Stream::FormatPointer(new gpu::Stream::Format()); networkMesh._vertexFormat = std::make_shared<gpu::Stream::Format>();
networkMesh._vertexFormat->setAttribute(gpu::Stream::POSITION, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); networkMesh._vertexFormat->setAttribute(gpu::Stream::POSITION, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
if (mesh.normals.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::NORMAL, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); if (mesh.normals.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::NORMAL, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));
if (mesh.tangents.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::TANGENT, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)); if (mesh.tangents.size()) networkMesh._vertexFormat->setAttribute(gpu::Stream::TANGENT, channelNum++, gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ));

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

@ -114,11 +114,11 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey key,
gpu::Shader::makeProgram(*program, slotBindings); gpu::Shader::makeProgram(*program, slotBindings);
auto locations = std::shared_ptr<Locations>(new Locations()); auto locations = std::make_shared<Locations>();
initLocations(program, *locations); initLocations(program, *locations);
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
// Backface on shadow // Backface on shadow
if (key.isShadow()) { if (key.isShadow()) {
@ -145,7 +145,7 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey key,
if (!key.isWireFrame()) { if (!key.isWireFrame()) {
RenderKey wireframeKey(key.getRaw() | RenderKey::IS_WIREFRAME); RenderKey wireframeKey(key.getRaw() | RenderKey::IS_WIREFRAME);
gpu::StatePointer wireframeState = gpu::StatePointer(new gpu::State(state->getValues())); auto wireframeState = std::make_shared<gpu::State>(state->getValues());
wireframeState->setFillMode(gpu::State::FILL_LINE); wireframeState->setFillMode(gpu::State::FILL_LINE);
@ -158,7 +158,7 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey key,
if (!key.isShadow()) { if (!key.isShadow()) {
RenderKey mirrorKey(key.getRaw() | RenderKey::IS_MIRROR); RenderKey mirrorKey(key.getRaw() | RenderKey::IS_MIRROR);
gpu::StatePointer mirrorState = gpu::StatePointer(new gpu::State(state->getValues())); auto mirrorState = std::make_shared<gpu::State>(state->getValues());
mirrorState->setFrontFaceClockwise(true); mirrorState->setFrontFaceClockwise(true);
@ -168,7 +168,7 @@ void Model::RenderPipelineLib::addRenderPipeline(Model::RenderKey key,
if (!key.isWireFrame()) { if (!key.isWireFrame()) {
RenderKey wireframeKey(key.getRaw() | RenderKey::IS_MIRROR | RenderKey::IS_WIREFRAME); RenderKey wireframeKey(key.getRaw() | RenderKey::IS_MIRROR | RenderKey::IS_WIREFRAME);
gpu::StatePointer wireframeState = gpu::StatePointer(new gpu::State(state->getValues()));; auto wireframeState = std::make_shared<gpu::State>(state->getValues());
wireframeState->setFillMode(gpu::State::FILL_LINE); wireframeState->setFillMode(gpu::State::FILL_LINE);
@ -476,8 +476,8 @@ bool Model::updateGeometry() {
MeshState state; MeshState state;
state.clusterMatrices.resize(mesh.clusters.size()); state.clusterMatrices.resize(mesh.clusters.size());
_meshStates.append(state); _meshStates.append(state);
gpu::BufferPointer buffer(new gpu::Buffer()); auto buffer = std::make_shared<gpu::Buffer>();
if (!mesh.blendshapes.isEmpty()) { if (!mesh.blendshapes.isEmpty()) {
buffer->resize((mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3)); buffer->resize((mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3));
buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.vertices.constData()); buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.vertices.constData());
@ -886,7 +886,7 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene, render::PendingChan
foreach (auto renderItem, _transparentRenderItems) { foreach (auto renderItem, _transparentRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderData = MeshPartPayload::Pointer(renderItem); auto renderData = MeshPartPayload::Pointer(renderItem);
auto renderPayload = render::PayloadPointer(new MeshPartPayload::Payload(renderData)); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderData);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
_renderItems.insert(item, renderPayload); _renderItems.insert(item, renderPayload);
somethingAdded = true; somethingAdded = true;
@ -895,7 +895,7 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene, render::PendingChan
foreach (auto renderItem, _opaqueRenderItems) { foreach (auto renderItem, _opaqueRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderData = MeshPartPayload::Pointer(renderItem); auto renderData = MeshPartPayload::Pointer(renderItem);
auto renderPayload = render::PayloadPointer(new MeshPartPayload::Payload(renderData)); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderData);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
_renderItems.insert(item, renderPayload); _renderItems.insert(item, renderPayload);
somethingAdded = true; somethingAdded = true;
@ -916,7 +916,7 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene, render::PendingChan
foreach (auto renderItem, _transparentRenderItems) { foreach (auto renderItem, _transparentRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderData = MeshPartPayload::Pointer(renderItem); auto renderData = MeshPartPayload::Pointer(renderItem);
auto renderPayload = render::PayloadPointer(new MeshPartPayload::Payload(renderData)); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderData);
renderPayload->addStatusGetters(statusGetters); renderPayload->addStatusGetters(statusGetters);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
_renderItems.insert(item, renderPayload); _renderItems.insert(item, renderPayload);
@ -926,7 +926,7 @@ bool Model::addToScene(std::shared_ptr<render::Scene> scene, render::PendingChan
foreach (auto renderItem, _opaqueRenderItems) { foreach (auto renderItem, _opaqueRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderData = MeshPartPayload::Pointer(renderItem); auto renderData = MeshPartPayload::Pointer(renderItem);
auto renderPayload = render::PayloadPointer(new MeshPartPayload::Payload(renderData)); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderData);
renderPayload->addStatusGetters(statusGetters); renderPayload->addStatusGetters(statusGetters);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
_renderItems.insert(item, renderPayload); _renderItems.insert(item, renderPayload);
@ -2156,9 +2156,9 @@ void Model::segregateMeshGroups() {
for (int partIndex = 0; partIndex < totalParts; partIndex++) { for (int partIndex = 0; partIndex < totalParts; partIndex++) {
// this is a good place to create our renderPayloads // this is a good place to create our renderPayloads
if (translucentMesh) { if (translucentMesh) {
_transparentRenderItems << std::shared_ptr<MeshPartPayload>(new MeshPartPayload(true, this, i, partIndex)); _transparentRenderItems << std::make_shared<MeshPartPayload>(true, this, i, partIndex);
} else { } else {
_opaqueRenderItems << std::shared_ptr<MeshPartPayload>(new MeshPartPayload(false, this, i, partIndex)); _opaqueRenderItems << std::make_shared<MeshPartPayload>(false, this, i, partIndex);
} }
} }
} }
@ -2206,7 +2206,7 @@ bool Model::initWhenReady(render::ScenePointer scene) {
foreach (auto renderItem, _transparentRenderItems) { foreach (auto renderItem, _transparentRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderData = MeshPartPayload::Pointer(renderItem); auto renderData = MeshPartPayload::Pointer(renderItem);
auto renderPayload = render::PayloadPointer(new MeshPartPayload::Payload(renderData)); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderData);
_renderItems.insert(item, renderPayload); _renderItems.insert(item, renderPayload);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
} }
@ -2214,7 +2214,7 @@ bool Model::initWhenReady(render::ScenePointer scene) {
foreach (auto renderItem, _opaqueRenderItems) { foreach (auto renderItem, _opaqueRenderItems) {
auto item = scene->allocateID(); auto item = scene->allocateID();
auto renderData = MeshPartPayload::Pointer(renderItem); auto renderData = MeshPartPayload::Pointer(renderItem);
auto renderPayload = render::PayloadPointer(new MeshPartPayload::Payload(renderData)); auto renderPayload = std::make_shared<MeshPartPayload::Payload>(renderData);
_renderItems.insert(item, renderPayload); _renderItems.insert(item, renderPayload);
pendingChanges.resetItem(item, renderPayload); pendingChanges.resetItem(item, renderPayload);
} }

2
libraries/render-utils/src/OglplusHelpers.cpp
View file

@ -57,7 +57,7 @@ ProgramPtr loadDefaultShader() {
void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& fs) { void compileProgram(ProgramPtr & result, const std::string& vs, const std::string& fs) {
using namespace oglplus; using namespace oglplus;
try { try {
result = ProgramPtr(new Program()); result = QSharedPointer<Program>::create();
// attach the shaders to the program // attach the shaders to the program
result->AttachShader( result->AttachShader(
VertexShader() VertexShader()

10
libraries/render-utils/src/RenderDeferredTask.cpp
View file

@ -79,9 +79,9 @@ RenderDeferredTask::RenderDeferredTask() : Task() {
_jobs.push_back(Job(new ResetGLState::JobModel())); _jobs.push_back(Job(new ResetGLState::JobModel()));
// Give ourselves 3 frmaes of timer queries // Give ourselves 3 frmaes of timer queries
_timerQueries.push_back(gpu::QueryPointer(new gpu::Query())); _timerQueries.push_back(std::make_shared<gpu::Query>());
_timerQueries.push_back(gpu::QueryPointer(new gpu::Query())); _timerQueries.push_back(std::make_shared<gpu::Query>());
_timerQueries.push_back(gpu::QueryPointer(new gpu::Query())); _timerQueries.push_back(std::make_shared<gpu::Query>());
_currentTimerQueryIndex = 0; _currentTimerQueryIndex = 0;
} }
@ -196,8 +196,8 @@ const gpu::PipelinePointer& DrawOverlay3D::getOpaquePipeline() {
auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(overlay3D_vert))); auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(overlay3D_vert)));
auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(overlay3D_frag))); auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(overlay3D_frag)));
auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps)); auto program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
auto state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
state->setDepthTest(true, true, gpu::LESS_EQUAL); state->setDepthTest(true, true, gpu::LESS_EQUAL);
_opaquePipeline.reset(gpu::Pipeline::create(program, state)); _opaquePipeline.reset(gpu::Pipeline::create(program, state));

2
libraries/render-utils/src/TextureCache.cpp
View file

@ -736,7 +736,7 @@ DilatableNetworkTexture::DilatableNetworkTexture(const QUrl& url, const QByteArr
QSharedPointer<Texture> DilatableNetworkTexture::getDilatedTexture(float dilation) { QSharedPointer<Texture> DilatableNetworkTexture::getDilatedTexture(float dilation) {
QSharedPointer<Texture> texture = _dilatedTextures.value(dilation); QSharedPointer<Texture> texture = _dilatedTextures.value(dilation);
if (texture.isNull()) { if (texture.isNull()) {
texture = QSharedPointer<Texture>(new Texture()); texture = QSharedPointer<Texture>::create();
if (!_image.isNull()) { if (!_image.isNull()) {
QImage dilatedImage = _image; QImage dilatedImage = _image;

6
libraries/render-utils/src/text/Font.cpp
View file

@ -223,7 +223,7 @@ void Font::setupGPU() {
_outlineLoc = program->getUniforms().findLocation("Outline"); _outlineLoc = program->getUniforms().findLocation("Outline");
_colorLoc = program->getUniforms().findLocation("Color"); _colorLoc = program->getUniforms().findLocation("Color");
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
state->setCullMode(gpu::State::CULL_BACK); state->setCullMode(gpu::State::CULL_BACK);
state->setDepthTest(true, true, gpu::LESS_EQUAL); state->setDepthTest(true, true, gpu::LESS_EQUAL);
state->setBlendFunction(true, state->setBlendFunction(true,
@ -240,14 +240,14 @@ void Font::setupGPU() {
assert(sizeof(QuadBuilder) == 4 * sizeof(TextureVertex)); assert(sizeof(QuadBuilder) == 4 * sizeof(TextureVertex));
// Setup rendering structures // Setup rendering structures
_format.reset(new gpu::Stream::Format()); _format = std::make_shared<gpu::Stream::Format>();
_format->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0); _format->setAttribute(gpu::Stream::POSITION, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ), 0);
_format->setAttribute(gpu::Stream::TEXCOORD, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV), OFFSET); _format->setAttribute(gpu::Stream::TEXCOORD, 0, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::UV), OFFSET);
} }
} }
void Font::rebuildVertices(float x, float y, const QString& str, const glm::vec2& bounds) { void Font::rebuildVertices(float x, float y, const QString& str, const glm::vec2& bounds) {
_verticesBuffer.reset(new gpu::Buffer()); _verticesBuffer = std::make_shared<gpu::Buffer>();
_numVertices = 0; _numVertices = 0;
_lastStringRendered = str; _lastStringRendered = str;
_lastBounds = bounds; _lastBounds = bounds;

96
libraries/render/src/render/DrawStatus.cpp
View file

@ -34,27 +34,27 @@ using namespace render;
const gpu::PipelinePointer& DrawStatus::getDrawItemBoundsPipeline() { const gpu::PipelinePointer& DrawStatus::getDrawItemBoundsPipeline() {
if (!_drawItemBoundsPipeline) { if (!_drawItemBoundsPipeline) {
auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(drawItemBounds_vert))); auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(drawItemBounds_vert)));
auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(drawItemBounds_frag))); auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(drawItemBounds_frag)));
gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps)); gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
gpu::Shader::BindingSet slotBindings; gpu::Shader::BindingSet slotBindings;
gpu::Shader::makeProgram(*program, slotBindings); gpu::Shader::makeProgram(*program, slotBindings);
_drawItemBoundPosLoc = program->getUniforms().findLocation("inBoundPos"); _drawItemBoundPosLoc = program->getUniforms().findLocation("inBoundPos");
_drawItemBoundDimLoc = program->getUniforms().findLocation("inBoundDim"); _drawItemBoundDimLoc = program->getUniforms().findLocation("inBoundDim");
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
state->setDepthTest(true, false, gpu::LESS_EQUAL); state->setDepthTest(true, false, gpu::LESS_EQUAL);
// Blend on transparent // Blend on transparent
state->setBlendFunction(true, state->setBlendFunction(true,
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::DEST_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ZERO); gpu::State::DEST_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ZERO);
// Good to go add the brand new pipeline // Good to go add the brand new pipeline
_drawItemBoundsPipeline.reset(gpu::Pipeline::create(program, state)); _drawItemBoundsPipeline.reset(gpu::Pipeline::create(program, state));
} }
return _drawItemBoundsPipeline; return _drawItemBoundsPipeline;
@ -62,27 +62,27 @@ const gpu::PipelinePointer& DrawStatus::getDrawItemBoundsPipeline() {
const gpu::PipelinePointer& DrawStatus::getDrawItemStatusPipeline() { const gpu::PipelinePointer& DrawStatus::getDrawItemStatusPipeline() {
if (!_drawItemStatusPipeline) { if (!_drawItemStatusPipeline) {
auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(drawItemStatus_vert))); auto vs = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(drawItemStatus_vert)));
auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(drawItemStatus_frag))); auto ps = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(drawItemStatus_frag)));
gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps)); gpu::ShaderPointer program = gpu::ShaderPointer(gpu::Shader::createProgram(vs, ps));
gpu::Shader::BindingSet slotBindings; gpu::Shader::BindingSet slotBindings;
gpu::Shader::makeProgram(*program, slotBindings); gpu::Shader::makeProgram(*program, slotBindings);
_drawItemStatusPosLoc = program->getUniforms().findLocation("inBoundPos"); _drawItemStatusPosLoc = program->getUniforms().findLocation("inBoundPos");
_drawItemStatusDimLoc = program->getUniforms().findLocation("inBoundDim"); _drawItemStatusDimLoc = program->getUniforms().findLocation("inBoundDim");
_drawItemStatusValueLoc = program->getUniforms().findLocation("inStatus"); _drawItemStatusValueLoc = program->getUniforms().findLocation("inStatus");
gpu::StatePointer state = gpu::StatePointer(new gpu::State()); auto state = std::make_shared<gpu::State>();
state->setDepthTest(false, false, gpu::LESS_EQUAL); state->setDepthTest(false, false, gpu::LESS_EQUAL);
// Blend on transparent // Blend on transparent
state->setBlendFunction(true, state->setBlendFunction(true,
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::DEST_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ZERO); gpu::State::DEST_ALPHA, gpu::State::BLEND_OP_ADD, gpu::State::ZERO);
// Good to go add the brand new pipeline // Good to go add the brand new pipeline
_drawItemStatusPipeline.reset(gpu::Pipeline::create(program, state)); _drawItemStatusPipeline.reset(gpu::Pipeline::create(program, state));
} }
return _drawItemStatusPipeline; return _drawItemStatusPipeline;
@ -98,10 +98,10 @@ void DrawStatus::run(const SceneContextPointer& sceneContext, const RenderContex
int nbItems = 0; int nbItems = 0;
{ {
if (!_itemBounds) { if (!_itemBounds) {
_itemBounds.reset(new gpu::Buffer()); _itemBounds = std::make_shared<gpu::Buffer>();
} }
if (!_itemStatus) { if (!_itemStatus) {
_itemStatus.reset(new gpu::Buffer()); _itemStatus = std::make_shared<gpu::Buffer>();;
} }
_itemBounds->resize((inItems.size() * sizeof(AABox))); _itemBounds->resize((inItems.size() * sizeof(AABox)));
@ -148,14 +148,14 @@ void DrawStatus::run(const SceneContextPointer& sceneContext, const RenderContex
AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData()); AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData()); glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
const unsigned int VEC3_ADRESS_OFFSET = 3; const unsigned int VEC3_ADRESS_OFFSET = 3;
for (int i = 0; i < nbItems; i++) { for (int i = 0; i < nbItems; i++) {
batch._glUniform3fv(_drawItemBoundPosLoc, 1, (const GLfloat*) (itemAABox + i)); batch._glUniform3fv(_drawItemBoundPosLoc, 1, (const GLfloat*) (itemAABox + i));
batch._glUniform3fv(_drawItemBoundDimLoc, 1, ((const GLfloat*) (itemAABox + i)) + VEC3_ADRESS_OFFSET); batch._glUniform3fv(_drawItemBoundDimLoc, 1, ((const GLfloat*) (itemAABox + i)) + VEC3_ADRESS_OFFSET);
batch.draw(gpu::LINES, 24, 0); batch.draw(gpu::LINES, 24, 0);
} }
batch.setPipeline(getDrawItemStatusPipeline()); batch.setPipeline(getDrawItemStatusPipeline());

6
libraries/render/src/render/DrawTask.h
View file

@ -43,11 +43,11 @@ public:
Varying() {} Varying() {}
template <class T> template <class T>
Varying(const T& data) : _concept(new Job::Varying::Model<T>(data)) {} Varying(const T& data) : _concept(std::make_shared<Job::Varying::Model<T>>(data)) {}
// Access the _data contained win the concept explicitely // Access the _data contained win the concept explicitely
template <class T> T& edit() { return (static_cast<Model<T>*> (_concept.get())->_data); } template <class T> T& edit() { return std::static_pointer_cast<Model<T>>(_concept)->_data; }
template <class T> const T& get() const { return (static_cast<const Model<T>*> (_concept.get())->_data); } template <class T> const T& get() const { return std::static_pointer_cast<const Model<T>>(_concept)->_data; }
protected: protected:
friend class Job; friend class Job;

6
libraries/render/src/render/Engine.cpp
View file

@ -15,8 +15,8 @@ using namespace render;
Engine::Engine() : Engine::Engine() :
_sceneContext(new SceneContext()), _sceneContext(std::make_shared<SceneContext>()),
_renderContext(new RenderContext()) _renderContext(std::make_shared<RenderContext>())
{ {
} }
@ -45,6 +45,6 @@ void Engine::buildStandardTaskPipeline() {
_tasks.clear(); _tasks.clear();
} }
addTask(TaskPointer(new DrawSceneTask())); addTask(std::make_shared<DrawSceneTask>());
} }

4
libraries/render/src/render/Scene.cpp
View file

@ -87,14 +87,14 @@ void Item::Status::getPackedValues(glm::ivec4& values) const {
void Item::PayloadInterface::addStatusGetter(const Status::Getter& getter) { void Item::PayloadInterface::addStatusGetter(const Status::Getter& getter) {
if (!_status) { if (!_status) {
_status.reset(new Status()); _status = std::make_shared<Status>();
} }
_status->addGetter(getter); _status->addGetter(getter);
} }
void Item::PayloadInterface::addStatusGetters(const Status::Getters& getters) { void Item::PayloadInterface::addStatusGetters(const Status::Getters& getters) {
if (!_status) { if (!_status) {
_status.reset(new Status()); _status = std::make_shared<Status>();
} }
for (auto& g : getters) { for (auto& g : getters) {
_status->addGetter(g); _status->addGetter(g);

4
libraries/render/src/render/Scene.h
View file

@ -364,7 +364,7 @@ protected:
DataPointer _data; DataPointer _data;
// Update mechanics // Update mechanics
virtual void update(const UpdateFunctorPointer& functor) { static_cast<Updater*>(functor.get())->_func((*_data)); } virtual void update(const UpdateFunctorPointer& functor) { std::static_pointer_cast<Updater>(functor)->_func((*_data)); }
friend class Item; friend class Item;
}; };
@ -448,7 +448,7 @@ public:
void removeItem(ItemID id); void removeItem(ItemID id);
template <class T> void updateItem(ItemID id, std::function<void(T&)> func) { template <class T> void updateItem(ItemID id, std::function<void(T&)> func) {
updateItem(id, UpdateFunctorPointer(new UpdateFunctor<T>(func))); updateItem(id, std::make_shared<UpdateFunctor<T>>(func));
} }
void updateItem(ItemID id, const UpdateFunctorPointer& functor); void updateItem(ItemID id, const UpdateFunctorPointer& functor);

2
libraries/script-engine/src/SceneScriptingInterface.h
View file

@ -117,7 +117,7 @@ protected:
SceneScriptingInterface() {}; SceneScriptingInterface() {};
~SceneScriptingInterface() {}; ~SceneScriptingInterface() {};
model::SunSkyStagePointer _skyStage = model::SunSkyStagePointer(new model::SunSkyStage()); model::SunSkyStagePointer _skyStage = std::make_shared<model::SunSkyStage>();
bool _shouldRenderAvatars = true; bool _shouldRenderAvatars = true;
bool _shouldRenderEntities = true; bool _shouldRenderEntities = true;

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

@ -158,8 +158,7 @@ protected:
mutable Flags _flags; mutable Flags _flags;
// Cached transform // Cached transform
// TODO: replace this auto ptr by a "unique ptr" as soon as we are compiling in C++11 mutable std::unique_ptr<Mat4> _matrix;
mutable std::auto_ptr<Mat4> _matrix;
bool isCacheInvalid() const { return _flags[FLAG_CACHE_INVALID]; } bool isCacheInvalid() const { return _flags[FLAG_CACHE_INVALID]; }
void validCache() const { _flags.set(FLAG_CACHE_INVALID, false); } void validCache() const { _flags.set(FLAG_CACHE_INVALID, false); }

2
libraries/ui/src/InfoView.cpp
View file

@ -25,7 +25,7 @@ InfoView::InfoView(QQuickItem* parent) : QQuickItem(parent) {
} }
void InfoView::registerType() { void InfoView::registerType() {
qmlRegisterType<InfoView>("Hifi", 1, 0, NAME.toLocal8Bit().constData()); qmlRegisterType<InfoView>("Hifi", 1, 0, NAME.toLocal8Bit().constData());
} }
QString fetchVersion(const QUrl& url) { QString fetchVersion(const QUrl& url) {

22
tools/scribe/src/TextTemplate.cpp
View file

@ -42,7 +42,7 @@ const TextTemplatePointer TextTemplate::Config::addInclude(const ConfigPointer&
String includeStream; String includeStream;
if (config->_includerCallback(config, include, includeStream)) { if (config->_includerCallback(config, include, includeStream)) {
// ok, then create a new Template on the include file with this as lib // ok, then create a new Template on the include file with this as lib
included = TextTemplatePointer(new TextTemplate(include, config)); included = std::make_shared<TextTemplate>(include, config);
std::stringstream src(includeStream); std::stringstream src(includeStream);
@ -398,7 +398,7 @@ const BlockPointer TextTemplate::processStepVar(const BlockPointer& block, Strin
BlockPointer parent = Block::getCurrentBlock(block); BlockPointer parent = Block::getCurrentBlock(block);
// Add a new BLock // Add a new BLock
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::VAR; newBlock->command.type = Command::VAR;
@ -460,7 +460,7 @@ const BlockPointer TextTemplate::processStepDef(const BlockPointer& block, Strin
BlockPointer parent = Block::getCurrentBlock(block); BlockPointer parent = Block::getCurrentBlock(block);
// Add a new BLock // Add a new BLock
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::DEF; newBlock->command.type = Command::DEF;
@ -482,12 +482,12 @@ const BlockPointer TextTemplate::processStepCommandIf(const BlockPointer& block,
BlockPointer parent = Block::getCurrentBlock(block); BlockPointer parent = Block::getCurrentBlock(block);
// Add a new BLock depth // Add a new BLock depth
BlockPointer newIfBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newIfBlock = std::make_shared<Block>(_root->sourceName);
newIfBlock->command.type = Command::IFBLOCK; newIfBlock->command.type = Command::IFBLOCK;
Block::addNewBlock(parent, newIfBlock); Block::addNewBlock(parent, newIfBlock);
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::IF; newBlock->command.type = Command::IF;
@ -506,7 +506,7 @@ const BlockPointer TextTemplate::processStepCommandEndIf(const BlockPointer& blo
if ((parent->command.type == Command::IF) if ((parent->command.type == Command::IF)
|| (parent->command.type == Command::ELIF) || (parent->command.type == Command::ELIF)
|| (parent->command.type == Command::ELSE)) { || (parent->command.type == Command::ELSE)) {
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::ENDIF; newBlock->command.type = Command::ENDIF;
@ -533,7 +533,7 @@ const BlockPointer TextTemplate::processStepCommandElse(const BlockPointer& bloc
parent = parent->parent; parent = parent->parent;
// Add a new BLock depth // Add a new BLock depth
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
newBlock->ostr << grabbed; newBlock->ostr << grabbed;
newBlock->command.type = Command::ELSE; newBlock->command.type = Command::ELSE;
newBlock->command.arguments.push_back(expression); newBlock->command.arguments.push_back(expression);
@ -562,7 +562,7 @@ const BlockPointer TextTemplate::processStepCommandElif(const BlockPointer& bloc
parent = parent->parent; parent = parent->parent;
// Add a new BLock depth // Add a new BLock depth
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::ELIF; newBlock->command.type = Command::ELIF;
@ -595,7 +595,7 @@ const BlockPointer TextTemplate::processStepInclude(const BlockPointer& block, S
BlockPointer parent = Block::getCurrentBlock(block); BlockPointer parent = Block::getCurrentBlock(block);
// Add a new BLock // Add a new BLock
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::INCLUDE; newBlock->command.type = Command::INCLUDE;
@ -631,7 +631,7 @@ const BlockPointer TextTemplate::processStepFunc(const BlockPointer& block, Stri
BlockPointer parent = Block::getCurrentBlock(block); BlockPointer parent = Block::getCurrentBlock(block);
// Add a new BLock // Add a new BLock
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::FUNC; newBlock->command.type = Command::FUNC;
@ -660,7 +660,7 @@ const BlockPointer TextTemplate::processStepEndFunc(const BlockPointer& block, S
// Everything is cool , so let's unplugg the FUnc block from this tree and just put the EndFunc block // Everything is cool , so let's unplugg the FUnc block from this tree and just put the EndFunc block
BlockPointer newBlock = BlockPointer(new Block(_root->sourceName)); BlockPointer newBlock = std::make_shared<Block>(_root->sourceName);
(newBlock->ostr) << grabbed; (newBlock->ostr) << grabbed;
newBlock->command.type = Command::ENDFUNC; newBlock->command.type = Command::ENDFUNC;

2
tools/scribe/src/TextTemplate.h
View file

@ -141,7 +141,7 @@ public:
static bool loadFile(const Config::Pointer& config, const char* filename, String& source); static bool loadFile(const Config::Pointer& config, const char* filename, String& source);
TextTemplate(const String& name, const Config::Pointer& config = Config::Pointer(new Config())); TextTemplate(const String& name, const Config::Pointer& config = std::make_shared<Config>());
~TextTemplate(); ~TextTemplate();
// Scibe does all the job of parsing an inout template stream and then gneerating theresulting stream using the vars // Scibe does all the job of parsing an inout template stream and then gneerating theresulting stream using the vars

4
tools/scribe/src/main.cpp
View file

@ -31,7 +31,7 @@ int main (int argc, char** argv) {
bool showParseTree = false; bool showParseTree = false;
bool makeCPlusPlus = false; bool makeCPlusPlus = false;
TextTemplate::Config::Pointer config(new TextTemplate::Config()); auto config = std::make_shared<TextTemplate::Config>();
enum Mode { enum Mode {
READY = 0, READY = 0,
@ -165,7 +165,7 @@ int main (int argc, char** argv) {
return 0; return 0;
} }
TextTemplate::Pointer scribe(new TextTemplate(srcFilename, config)); auto scribe = std::make_shared<TextTemplate>(srcFilename, config);
// ready to parse and generate // ready to parse and generate
std::ostringstream destStringStream; std::ostringstream destStringStream;