Mirrors/overte-thingvellir
3
0
Fork 0
mirror of https://thingvellir.net/git/overte synced 2025-03-27 23:52:03 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:highfidelity/hifi into avatar-entities-3

Browse source
This commit is contained in:
Seth Alves 2016-05-16 09:51:20 -07:00
commit 3876a8037c
19 changed files with 328 additions and 227 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

32
interface/src/Application.cpp
View file

@ -865,10 +865,7 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
if (action == controller::toInt(controller::Action::RETICLE_CLICK)) {
auto reticlePos = getApplicationCompositor().getReticlePosition();
QPoint globalPos(reticlePos.x, reticlePos.y);
// FIXME - it would be nice if this was self contained in the _compositor or Reticle class
auto localPos = isHMDMode() ? globalPos : _glWidget->mapFromGlobal(globalPos);
QPoint localPos(reticlePos.x, reticlePos.y); // both hmd and desktop already handle this in our coordinates.
if (state) {
QMouseEvent mousePress(QEvent::MouseButtonPress, localPos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
sendEvent(_glWidget, &mousePress);
@ -889,15 +886,15 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
} else if (action == controller::toInt(controller::Action::UI_NAV_SELECT)) {
if (!offscreenUi->navigationFocused()) {
auto reticlePosition = getApplicationCompositor().getReticlePosition();
offscreenUi->toggleMenu(_glWidget->mapFromGlobal(QPoint(reticlePosition.x, reticlePosition.y)));
offscreenUi->toggleMenu(QPoint(reticlePosition.x, reticlePosition.y));
}
} else if (action == controller::toInt(controller::Action::CONTEXT_MENU)) {
auto reticlePosition = getApplicationCompositor().getReticlePosition();
offscreenUi->toggleMenu(_glWidget->mapFromGlobal(QPoint(reticlePosition.x, reticlePosition.y)));
offscreenUi->toggleMenu(QPoint(reticlePosition.x, reticlePosition.y));
} else if (action == controller::toInt(controller::Action::UI_NAV_SELECT)) {
if (!offscreenUi->navigationFocused()) {
auto reticlePosition = getApplicationCompositor().getReticlePosition();
offscreenUi->toggleMenu(_glWidget->mapFromGlobal(QPoint(reticlePosition.x, reticlePosition.y)));
offscreenUi->toggleMenu(QPoint(reticlePosition.x, reticlePosition.y));
}
} else if (action == controller::toInt(controller::Action::RETICLE_X)) {
auto oldPos = getApplicationCompositor().getReticlePosition();
@ -1076,6 +1073,10 @@ Application::Application(int& argc, char** argv, QElapsedTimer& startupTimer) :
// in the queue, which can be pretty damn frequent. Hence the idle function has a bunch
// of logic to abort early if it's being called too often.
_idleTimer->start(0);
// After all of the constructor is completed, then set firstRun to false.
Setting::Handle<bool> firstRun{ Settings::firstRun, true };
firstRun.set(false);
}
@ -1093,11 +1094,6 @@ void Application::checkChangeCursor() {
_cursorNeedsChanging = false;
}
// After all of the constructor is completed, then set firstRun to false.
Setting::Handle<bool> firstRun{ Settings::firstRun, true };
firstRun.set(false);
}
void Application::showCursor(const QCursor& cursor) {
@ -2274,7 +2270,7 @@ void Application::keyReleaseEvent(QKeyEvent* event) {
if (event->key() == Qt::Key_Alt && _altPressed && hasFocus()) {
auto offscreenUi = DependencyManager::get<OffscreenUi>();
auto reticlePosition = getApplicationCompositor().getReticlePosition();
offscreenUi->toggleMenu(_glWidget->mapFromGlobal(QPoint(reticlePosition.x, reticlePosition.y)));
offscreenUi->toggleMenu(QPoint(reticlePosition.x, reticlePosition.y));
}
_keysPressed.remove(event->key());
@ -2743,15 +2739,7 @@ void Application::setLowVelocityFilter(bool lowVelocityFilter) {
}
ivec2 Application::getMouse() const {
auto reticlePosition = getApplicationCompositor().getReticlePosition();
// in the HMD, the reticlePosition is the mouse position
if (isHMDMode()) {
return reticlePosition;
}
// in desktop mode, we need to map from global to widget space
return toGlm(_glWidget->mapFromGlobal(QPoint(reticlePosition.x, reticlePosition.y)));
return getApplicationCompositor().getReticlePosition();
}
FaceTracker* Application::getActiveFaceTracker() {

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

@ -682,7 +682,11 @@ void MyAvatar::saveData() {
settings.setValue("leanScale", _leanScale);
settings.setValue("scale", _targetScale);
settings.setValue("fullAvatarURL", _fullAvatarURLFromPreferences);
settings.setValue("fullAvatarURL",
_fullAvatarURLFromPreferences == AvatarData::defaultFullAvatarModelUrl() ?
"" :
_fullAvatarURLFromPreferences.toString());
settings.setValue("fullAvatarModelName", _fullAvatarModelName);
settings.setValue("animGraphURL", _animGraphUrl);

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

@ -997,7 +997,7 @@ QByteArray AvatarData::identityByteArray() {
QByteArray identityData;
QDataStream identityStream(&identityData, QIODevice::Append);
QUrl emptyURL("");
const QUrl& urlToSend = (_skeletonModelURL == AvatarData::defaultFullAvatarModelUrl()) ? emptyURL : _skeletonModelURL;
const QUrl& urlToSend = _skeletonModelURL.scheme() == "file" ? emptyURL : _skeletonModelURL;
QUrl unusedModelURL; // legacy faceModel support

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

@ -267,7 +267,7 @@ void RenderableParticleEffectEntityItem::updateRenderItem() {
if (numBytes == 0) {
return;
}
memcpy(particleBuffer->editData(), particlePrimitives->data(), numBytes);
particleBuffer->setData(numBytes, (const gpu::Byte*)particlePrimitives->data());
// Update transform and bounds
payload.setModelTransform(transform);

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

@ -1332,7 +1332,7 @@ FBXGeometry* FBXReader::extractFBXGeometry(const QVariantHash& mapping, const QS
}
// NOTE: shapeVertices are in joint-frame
QVector<ShapeVertices> shapeVertices;
std::vector<ShapeVertices> shapeVertices;
shapeVertices.resize(geometry.joints.size());
// find our special joints
@ -1523,7 +1523,7 @@ FBXGeometry* FBXReader::extractFBXGeometry(const QVariantHash& mapping, const QS
float clusterScale = extractUniformScale(fbxCluster.inverseBindMatrix);
glm::mat4 meshToJoint = glm::inverse(joint.bindTransform) * modelTransform;
ShapeVertices& points = shapeVertices[jointIndex];
ShapeVertices& points = shapeVertices.at(jointIndex);
float totalWeight = 0.0f;
for (int j = 0; j < cluster.indices.size(); j++) {
@ -1585,7 +1585,7 @@ FBXGeometry* FBXReader::extractFBXGeometry(const QVariantHash& mapping, const QS
// transform cluster vertices to joint-frame and save for later
float clusterScale = extractUniformScale(firstFBXCluster.inverseBindMatrix);
glm::mat4 meshToJoint = glm::inverse(joint.bindTransform) * modelTransform;
ShapeVertices& points = shapeVertices[jointIndex];
ShapeVertices& points = shapeVertices.at(jointIndex);
foreach (const glm::vec3& vertex, extracted.mesh.vertices) {
const glm::mat4 vertexTransform = meshToJoint * glm::translate(vertex);
points.push_back(extractTranslation(vertexTransform) * clusterScale);
@ -1626,7 +1626,7 @@ FBXGeometry* FBXReader::extractFBXGeometry(const QVariantHash& mapping, const QS
FBXJoint& joint = geometry.joints[i];
// NOTE: points are in joint-frame
ShapeVertices& points = shapeVertices[i];
ShapeVertices& points = shapeVertices.at(i);
if (points.size() > 0) {
// compute average point
glm::vec3 avgPoint = glm::vec3(0.0f);

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

@ -624,7 +624,6 @@ FBXGeometry* OBJReader::readOBJ(QByteArray& model, const QVariantHash& mapping,
return geometryPtr;
}
void fbxDebugDump(const FBXGeometry& fbxgeo) {
qCDebug(modelformat) << "---------------- fbxGeometry ----------------";
qCDebug(modelformat) << " hasSkeletonJoints =" << fbxgeo.hasSkeletonJoints;

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

@ -65,15 +65,22 @@ public:
class GLBuffer : public GPUObject {
public:
Stamp _stamp;
GLuint _buffer;
GLuint _size;
const GLuint _buffer;
const GLuint _size;
const Stamp _stamp;
GLBuffer();
GLBuffer(const Buffer& buffer, GLBuffer* original = nullptr);
~GLBuffer();
void setSize(GLuint size);
void transfer();
private:
bool getNextTransferBlock(GLintptr& outOffset, GLsizeiptr& outSize, size_t& currentPage) const;
// The owning texture
const Buffer& _gpuBuffer;
};
static GLBuffer* syncGPUObject(const Buffer& buffer);
static GLuint getBufferID(const Buffer& buffer);

101
libraries/gpu/src/gpu/GLBackendBuffer.cpp
View file

@ -12,12 +12,40 @@
using namespace gpu;
GLBackend::GLBuffer::GLBuffer() :
_stamp(0),
_buffer(0),
_size(0)
{
GLuint allocateSingleBuffer() {
GLuint result;
glGenBuffers(1, &result);
(void)CHECK_GL_ERROR();
return result;
}
GLBackend::GLBuffer::GLBuffer(const Buffer& buffer, GLBuffer* original) :
_buffer(allocateSingleBuffer()),
_size((GLuint)buffer._sysmem.getSize()),
_stamp(buffer._sysmem.getStamp()),
_gpuBuffer(buffer) {
glBindBuffer(GL_ARRAY_BUFFER, _buffer);
if (GLEW_VERSION_4_4 || GLEW_ARB_buffer_storage) {
glBufferStorage(GL_ARRAY_BUFFER, _size, nullptr, GL_DYNAMIC_STORAGE_BIT);
(void)CHECK_GL_ERROR();
} else {
glBufferData(GL_ARRAY_BUFFER, _size, nullptr, GL_DYNAMIC_DRAW);
(void)CHECK_GL_ERROR();
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
if (original) {
glBindBuffer(GL_COPY_WRITE_BUFFER, _buffer);
glBindBuffer(GL_COPY_READ_BUFFER, original->_buffer);
glCopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 0, original->_size);
glBindBuffer(GL_COPY_WRITE_BUFFER, 0);
glBindBuffer(GL_COPY_READ_BUFFER, 0);
(void)CHECK_GL_ERROR();
}
Backend::setGPUObject(buffer, this);
Backend::incrementBufferGPUCount();
Backend::updateBufferGPUMemoryUsage(0, _size);
}
GLBackend::GLBuffer::~GLBuffer() {
@ -28,37 +56,56 @@ GLBackend::GLBuffer::~GLBuffer() {
Backend::decrementBufferGPUCount();
}
void GLBackend::GLBuffer::setSize(GLuint size) {
Backend::updateBufferGPUMemoryUsage(_size, size);
_size = size;
void GLBackend::GLBuffer::transfer() {
glBindBuffer(GL_ARRAY_BUFFER, _buffer);
(void)CHECK_GL_ERROR();
GLintptr offset;
GLsizeiptr size;
size_t currentPage { 0 };
auto data = _gpuBuffer.getSysmem().readData();
while (getNextTransferBlock(offset, size, currentPage)) {
glBufferSubData(GL_ARRAY_BUFFER, offset, size, data + offset);
(void)CHECK_GL_ERROR();
}
glBindBuffer(GL_ARRAY_BUFFER, 0);
(void)CHECK_GL_ERROR();
_gpuBuffer._flags &= ~Buffer::DIRTY;
}
bool GLBackend::GLBuffer::getNextTransferBlock(GLintptr& outOffset, GLsizeiptr& outSize, size_t& currentPage) const {
size_t pageCount = _gpuBuffer._pages.size();
// Advance to the first dirty page
while (currentPage < pageCount && (0 == (Buffer::DIRTY & _gpuBuffer._pages[currentPage]))) {
++currentPage;
}
// If we got to the end, we're done
if (currentPage >= pageCount) {
return false;
}
// Advance to the next clean page
outOffset = static_cast<GLintptr>(currentPage * _gpuBuffer._pageSize);
while (currentPage < pageCount && (0 != (Buffer::DIRTY & _gpuBuffer._pages[currentPage]))) {
_gpuBuffer._pages[currentPage] &= ~Buffer::DIRTY;
++currentPage;
}
outSize = static_cast<GLsizeiptr>((currentPage * _gpuBuffer._pageSize) - outOffset);
return true;
}
GLBackend::GLBuffer* GLBackend::syncGPUObject(const Buffer& buffer) {
GLBuffer* object = Backend::getGPUObject<GLBackend::GLBuffer>(buffer);
if (object && (object->_stamp == buffer.getSysmem().getStamp())) {
return object;
// Has the storage size changed?
if (!object || object->_stamp != buffer.getSysmem().getStamp()) {
object = new GLBuffer(buffer, object);
}
// need to have a gpu object?
if (!object) {
object = new GLBuffer();
glGenBuffers(1, &object->_buffer);
(void) CHECK_GL_ERROR();
Backend::setGPUObject(buffer, object);
if (0 != (buffer._flags & Buffer::DIRTY)) {
object->transfer();
}
// Now let's update the content of the bo with the sysmem version
// TODO: in the future, be smarter about when to actually upload the glBO version based on the data that did change
//if () {
glBindBuffer(GL_ARRAY_BUFFER, object->_buffer);
glBufferData(GL_ARRAY_BUFFER, buffer.getSysmem().getSize(), buffer.getSysmem().readData(), GL_DYNAMIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
object->_stamp = buffer.getSysmem().getStamp();
object->setSize((GLuint)buffer.getSysmem().getSize());
//}
(void) CHECK_GL_ERROR();
return object;
}

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

@ -209,6 +209,8 @@ void GLBackend::resetOutputStage() {
_output._drawFBO = 0;
glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
}
glEnable(GL_FRAMEBUFFER_SRGB);
}
void GLBackend::do_setFramebuffer(Batch& batch, size_t paramOffset) {

144
libraries/gpu/src/gpu/Resource.cpp
View file

@ -109,40 +109,18 @@ void Resource::Sysmem::deallocateMemory(Byte* dataAllocated, Size size) {
}
}
Resource::Sysmem::Sysmem() :
_stamp(0),
_size(0),
_data(NULL)
{
}
Resource::Sysmem::Sysmem() {}
Resource::Sysmem::Sysmem(Size size, const Byte* bytes) :
_stamp(0),
_size(0),
_data(NULL)
{
if (size > 0) {
_size = allocateMemory(&_data, size);
if (_size >= size) {
if (bytes) {
memcpy(_data, bytes, size);
}
}
Resource::Sysmem::Sysmem(Size size, const Byte* bytes) {
if (size > 0 && bytes) {
setData(_size, bytes);
}
}
Resource::Sysmem::Sysmem(const Sysmem& sysmem) :
_stamp(0),
_size(0),
_data(NULL)
{
Resource::Sysmem::Sysmem(const Sysmem& sysmem) {
if (sysmem.getSize() > 0) {
_size = allocateMemory(&_data, sysmem.getSize());
if (_size >= sysmem.getSize()) {
if (sysmem.readData()) {
memcpy(_data, sysmem.readData(), sysmem.getSize());
}
}
allocate(sysmem._size);
setData(_size, sysmem._data);
}
}
@ -208,7 +186,6 @@ Resource::Size Resource::Sysmem::setData( Size size, const Byte* bytes ) {
if (allocate(size) == size) {
if (size && bytes) {
memcpy( _data, bytes, _size );
_stamp++;
}
}
return _size;
@ -217,7 +194,6 @@ Resource::Size Resource::Sysmem::setData( Size size, const Byte* bytes ) {
Resource::Size Resource::Sysmem::setSubData( Size offset, Size size, const Byte* bytes) {
if (size && ((offset + size) <= getSize()) && bytes) {
memcpy( _data + offset, bytes, size );
_stamp++;
return size;
}
return 0;
@ -264,65 +240,105 @@ Buffer::Size Buffer::getBufferGPUMemoryUsage() {
return Context::getBufferGPUMemoryUsage();
}
Buffer::Buffer() :
Resource(),
_sysmem(new Sysmem()) {
Buffer::Buffer(Size pageSize) :
_pageSize(pageSize) {
_bufferCPUCount++;
}
Buffer::Buffer(Size size, const Byte* bytes) :
Resource(),
_sysmem(new Sysmem(size, bytes)) {
_bufferCPUCount++;
Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
Buffer::Buffer(Size size, const Byte* bytes, Size pageSize) : Buffer(pageSize) {
setData(size, bytes);
}
Buffer::Buffer(const Buffer& buf) :
Resource(),
_sysmem(new Sysmem(buf.getSysmem())) {
_bufferCPUCount++;
Buffer::updateBufferCPUMemoryUsage(0, _sysmem->getSize());
Buffer::Buffer(const Buffer& buf) : Buffer(buf._pageSize) {
setData(buf.getSize(), buf.getData());
}
Buffer& Buffer::operator=(const Buffer& buf) {
(*_sysmem) = buf.getSysmem();
const_cast<Size&>(_pageSize) = buf._pageSize;
setData(buf.getSize(), buf.getData());
return (*this);
}
Buffer::~Buffer() {
_bufferCPUCount--;
if (_sysmem) {
Buffer::updateBufferCPUMemoryUsage(_sysmem->getSize(), 0);
delete _sysmem;
_sysmem = NULL;
}
Buffer::updateBufferCPUMemoryUsage(_sysmem.getSize(), 0);
}
Buffer::Size Buffer::resize(Size size) {
_end = size;
auto prevSize = editSysmem().getSize();
auto newSize = editSysmem().resize(size);
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
return newSize;
if (prevSize < size) {
auto newPages = getRequiredPageCount();
auto newSize = newPages * _pageSize;
editSysmem().resize(newSize);
// All new pages start off as clean, because they haven't been populated by data
_pages.resize(newPages, 0);
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
}
return _end;
}
void Buffer::markDirty(Size offset, Size bytes) {
if (!bytes) {
return;
}
_flags |= DIRTY;
// Find the starting page
Size startPage = (offset / _pageSize);
// Non-zero byte count, so at least one page is dirty
Size pageCount = 1;
// How much of the page is after the offset?
Size remainder = _pageSize - (offset % _pageSize);
// If there are more bytes than page space remaining, we need to increase the page count
if (bytes > remainder) {
// Get rid of the amount that will fit in the current page
bytes -= remainder;
pageCount += (bytes / _pageSize);
if (bytes % _pageSize) {
++pageCount;
}
}
// Mark the pages dirty
for (Size i = 0; i < pageCount; ++i) {
_pages[i + startPage] |= DIRTY;
}
}
Buffer::Size Buffer::setData(Size size, const Byte* data) {
auto prevSize = editSysmem().getSize();
auto newSize = editSysmem().setData(size, data);
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
return newSize;
resize(size);
setSubData(0, size, data);
return _end;
}
Buffer::Size Buffer::setSubData(Size offset, Size size, const Byte* data) {
return editSysmem().setSubData( offset, size, data);
auto changedBytes = editSysmem().setSubData(offset, size, data);
if (changedBytes) {
markDirty(offset, changedBytes);
}
return changedBytes;
}
Buffer::Size Buffer::append(Size size, const Byte* data) {
auto prevSize = editSysmem().getSize();
auto newSize = editSysmem().append( size, data);
Buffer::updateBufferCPUMemoryUsage(prevSize, newSize);
return newSize;
auto offset = _end;
resize(_end + size);
setSubData(offset, size, data);
return _end;
}
Buffer::Size Buffer::getSize() const {
Q_ASSERT(getSysmem().getSize() >= _end);
return _end;
}
Buffer::Size Buffer::getRequiredPageCount() const {
Size result = _end / _pageSize;
if (_end % _pageSize) {
++result;
}
return result;
}
const Element BufferView::DEFAULT_ELEMENT = Element( gpu::SCALAR, gpu::UINT8, gpu::RAW );

81
libraries/gpu/src/gpu/Resource.h
View file

@ -88,10 +88,10 @@ protected:
// Access the byte array.
// The edit version allow to map data.
const Byte* readData() const { return _data; }
Byte* editData() { _stamp++; return _data; }
Byte* editData() { return _data; }
template< typename T > const T* read() const { return reinterpret_cast< T* > ( _data ); }
template< typename T > T* edit() { _stamp++; return reinterpret_cast< T* > ( _data ); }
template< typename T > T* edit() { return reinterpret_cast< T* > ( _data ); }
// Access the current version of the sysmem, used to compare if copies are in sync
Stamp getStamp() const { return _stamp; }
@ -102,9 +102,9 @@ protected:
bool isAvailable() const { return (_data != 0); }
private:
Stamp _stamp;
Size _size;
Byte* _data;
Stamp _stamp { 0 };
Size _size { 0 };
Byte* _data { nullptr };
};
};
@ -115,22 +115,28 @@ class Buffer : public Resource {
static void updateBufferCPUMemoryUsage(Size prevObjectSize, Size newObjectSize);
public:
enum Flag {
DIRTY = 0x01,
};
// Currently only one flag... 'dirty'
using PageFlags = std::vector<uint8_t>;
static const Size DEFAULT_PAGE_SIZE = 4096;
static uint32_t getBufferCPUCount();
static Size getBufferCPUMemoryUsage();
static uint32_t getBufferGPUCount();
static Size getBufferGPUMemoryUsage();
Buffer();
Buffer(Size size, const Byte* bytes);
Buffer(Size pageSize = DEFAULT_PAGE_SIZE);
Buffer(Size size, const Byte* bytes, Size pageSize = DEFAULT_PAGE_SIZE);
Buffer(const Buffer& buf); // deep copy of the sysmem buffer
Buffer& operator=(const Buffer& buf); // deep copy of the sysmem buffer
~Buffer();
// The size in bytes of data stored in the buffer
Size getSize() const { return getSysmem().getSize(); }
Size getSize() const;
const Byte* getData() const { return getSysmem().readData(); }
Byte* editData() { return editSysmem().editData(); }
// Resize the buffer
// Keep previous data [0 to min(pSize, mSize)]
Size resize(Size pSize);
@ -143,6 +149,23 @@ public:
// \return the number of bytes copied
Size setSubData(Size offset, Size size, const Byte* data);
template <typename T>
Size setSubData(Size index, const T& t) {
Size offset = index * sizeof(T);
Size size = sizeof(T);
return setSubData(offset, size, reinterpret_cast<const Byte*>(&t));
}
template <typename T>
Size setSubData(Size index, const std::vector<T>& t) {
if (t.empty()) {
return 0;
}
Size offset = index * sizeof(T);
Size size = t.size() * sizeof(T);
return setSubData(offset, size, reinterpret_cast<const Byte*>(&t[0]));
}
// Append new data at the end of the current buffer
// do a resize( size + getSize) and copy the new data
// \return the number of bytes copied
@ -155,18 +178,38 @@ public:
template <typename T>
Size append(const std::vector<T>& t) {
if (t.empty()) {
return _end;
}
return append(sizeof(T) * t.size(), reinterpret_cast<const Byte*>(&t[0]));
}
// Access the sysmem object.
const Sysmem& getSysmem() const { assert(_sysmem); return (*_sysmem); }
Sysmem& editSysmem() { assert(_sysmem); return (*_sysmem); }
const GPUObjectPointer gpuObject {};
protected:
void markDirty(Size offset, Size bytes);
Sysmem* _sysmem = NULL;
template <typename T>
void markDirty(Size index, Size count = 1) {
markDirty(sizeof(T) * index, sizeof(T) * count);
}
// Access the sysmem object, limited to ourselves and GPUObject derived classes
const Sysmem& getSysmem() const { return _sysmem; }
Sysmem& editSysmem() { return _sysmem; }
Byte* editData() { return editSysmem().editData(); }
Size getRequiredPageCount() const;
Size _end { 0 };
mutable uint8_t _flags;
mutable PageFlags _pages;
const Size _pageSize;
Sysmem _sysmem;
// FIXME find a more generic way to do this.
friend class GLBackend;
friend class BufferView;
};
typedef std::shared_ptr<Buffer> BufferPointer;
@ -290,8 +333,14 @@ public:
int _stride;
};
#if 0
// Direct memory access to the buffer contents is incompatible with the paging memory scheme
template <typename T> Iterator<T> begin() { return Iterator<T>(&edit<T>(0), _stride); }
template <typename T> Iterator<T> end() { return Iterator<T>(&edit<T>(getNum<T>()), _stride); }
#else
template <typename T> Iterator<const T> begin() const { return Iterator<const T>(&get<T>(), _stride); }
template <typename T> Iterator<const T> end() const { return Iterator<const T>(&get<T>(getNum<T>()), _stride); }
#endif
template <typename T> Iterator<const T> cbegin() const { return Iterator<const T>(&get<T>(), _stride); }
template <typename T> Iterator<const T> cend() const { return Iterator<const T>(&get<T>(getNum<T>()), _stride); }
@ -328,6 +377,7 @@ public:
qDebug() << "Accessing buffer outside the BufferView range, element size = " << sizeof(T) << " when bufferView size = " << _size;
}
#endif
_buffer->markDirty(_offset, sizeof(T));
T* t = (reinterpret_cast<T*> (_buffer->editData() + _offset));
return *(t);
}
@ -361,6 +411,7 @@ public:
qDebug() << "Accessing buffer outside the BufferView range, index = " << index << " number elements = " << getNum<T>();
}
#endif
_buffer->markDirty(elementOffset, sizeof(T));
return *(reinterpret_cast<T*> (_buffer->editData() + elementOffset));
}
};

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

@ -98,6 +98,7 @@ void Material::setFresnel(const Color& fresnel, bool isSRGB) {
}
void Material::setMetallic(float metallic) {
metallic = glm::clamp(metallic, 0.0f, 1.0f);
_key.setMetallic(metallic > 0.0f);
_schemaBuffer.edit<Schema>()._key = (uint32)_key._flags.to_ulong();
_schemaBuffer.edit<Schema>()._metallic = metallic;

54
libraries/render-utils/src/AnimDebugDraw.cpp
View file

@ -118,29 +118,18 @@ AnimDebugDraw::AnimDebugDraw() :
// HACK: add red, green and blue axis at (1,1,1)
_animDebugDrawData->_vertexBuffer->resize(sizeof(Vertex) * 6);
Vertex* data = (Vertex*)_animDebugDrawData->_vertexBuffer->editData();
data[0].pos = glm::vec3(1.0, 1.0f, 1.0f);
data[0].rgba = toRGBA(255, 0, 0, 255);
data[1].pos = glm::vec3(2.0, 1.0f, 1.0f);
data[1].rgba = toRGBA(255, 0, 0, 255);
data[2].pos = glm::vec3(1.0, 1.0f, 1.0f);
data[2].rgba = toRGBA(0, 255, 0, 255);
data[3].pos = glm::vec3(1.0, 2.0f, 1.0f);
data[3].rgba = toRGBA(0, 255, 0, 255);
data[4].pos = glm::vec3(1.0, 1.0f, 1.0f);
data[4].rgba = toRGBA(0, 0, 255, 255);
data[5].pos = glm::vec3(1.0, 1.0f, 2.0f);
data[5].rgba = toRGBA(0, 0, 255, 255);
_animDebugDrawData->_indexBuffer->resize(sizeof(uint16_t) * 6);
uint16_t* indices = (uint16_t*)_animDebugDrawData->_indexBuffer->editData();
for (int i = 0; i < 6; i++) {
indices[i] = i;
}
static std::vector<Vertex> vertices({
Vertex { glm::vec3(1.0, 1.0f, 1.0f), toRGBA(255, 0, 0, 255) },
Vertex { glm::vec3(2.0, 1.0f, 1.0f), toRGBA(255, 0, 0, 255) },
Vertex { glm::vec3(1.0, 1.0f, 1.0f), toRGBA(0, 255, 0, 255) },
Vertex { glm::vec3(1.0, 2.0f, 1.0f), toRGBA(0, 255, 0, 255) },
Vertex { glm::vec3(1.0, 1.0f, 1.0f), toRGBA(0, 0, 255, 255) },
Vertex { glm::vec3(1.0, 1.0f, 2.0f), toRGBA(0, 0, 255, 255) },
});
static std::vector<uint16_t> indices({ 0, 1, 2, 3, 4, 5 });
_animDebugDrawData->_vertexBuffer->setSubData<Vertex>(0, vertices);
_animDebugDrawData->_indexBuffer->setSubData<uint16_t>(0, indices);
}
AnimDebugDraw::~AnimDebugDraw() {
@ -356,9 +345,13 @@ void AnimDebugDraw::update() {
numVerts += (int)DebugDraw::getInstance().getRays().size() * VERTICES_PER_RAY;
// allocate verts!
data._vertexBuffer->resize(sizeof(Vertex) * numVerts);
Vertex* verts = (Vertex*)data._vertexBuffer->editData();
Vertex* v = verts;
std::vector<Vertex> vertices;
vertices.resize(numVerts);
//Vertex* verts = (Vertex*)data._vertexBuffer->editData();
Vertex* v = nullptr;
if (numVerts) {
v = &vertices[0];
}
// draw absolute poses
for (auto& iter : _absolutePoses) {
@ -381,6 +374,8 @@ void AnimDebugDraw::update() {
}
}
}
data._vertexBuffer->resize(sizeof(Vertex) * numVerts);
data._vertexBuffer->setSubData<Vertex>(0, vertices);
// draw markers from shared DebugDraw singleton
for (auto& iter : markerMap) {
@ -408,20 +403,19 @@ void AnimDebugDraw::update() {
}
DebugDraw::getInstance().clearRays();
assert(numVerts == (v - verts));
assert((!numVerts && !v) || (numVerts == (v - &vertices[0])));
render::Item::Bound theBound;
for (int i = 0; i < numVerts; i++) {
theBound += verts[i].pos;
theBound += vertices[i].pos;
}
data._bound = theBound;
data._isVisible = (numVerts > 0);
data._indexBuffer->resize(sizeof(uint16_t) * numVerts);
uint16_t* indices = (uint16_t*)data._indexBuffer->editData();
for (int i = 0; i < numVerts; i++) {
indices[i] = i;
data._indexBuffer->setSubData<uint16_t>(i, (uint16_t)i);;
}
});
scene->enqueuePendingChanges(pendingChanges);

8
libraries/render-utils/src/FramebufferCache.cpp
View file

@ -59,7 +59,8 @@ void FramebufferCache::createPrimaryFramebuffer() {
_deferredFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
_deferredFramebufferDepthColor = gpu::FramebufferPointer(gpu::Framebuffer::create());
auto colorFormat = gpu::Element::COLOR_RGBA_32;
// auto colorFormat = gpu::Element::COLOR_RGBA_32;
auto colorFormat = gpu::Element::COLOR_SRGBA_32;
auto width = _frameBufferSize.width();
auto height = _frameBufferSize.height();
@ -95,10 +96,7 @@ void FramebufferCache::createPrimaryFramebuffer() {
auto smoothSampler = gpu::Sampler(gpu::Sampler::FILTER_MIN_MAG_MIP_LINEAR);
// FIXME: Decide on the proper one, let s stick to R11G11B10 for now
//_lightingTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element::COLOR_RGBA_32, width, height, defaultSampler));
_lightingTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::SCALAR, gpu::FLOAT, gpu::R11G11B10), width, height, defaultSampler));
//_lightingTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC4, gpu::HALF, gpu::RGBA), width, height, defaultSampler));
_lightingFramebuffer = gpu::FramebufferPointer(gpu::Framebuffer::create());
_lightingFramebuffer->setRenderBuffer(0, _lightingTexture);
_lightingFramebuffer->setDepthStencilBuffer(_primaryDepthTexture, depthFormat);
@ -212,7 +210,7 @@ gpu::TexturePointer FramebufferCache::getLightingTexture() {
gpu::FramebufferPointer FramebufferCache::getFramebuffer() {
if (_cachedFramebuffers.isEmpty()) {
_cachedFramebuffers.push_back(gpu::FramebufferPointer(gpu::Framebuffer::create(gpu::Element::COLOR_RGBA_32, _frameBufferSize.width(), _frameBufferSize.height())));
_cachedFramebuffers.push_back(gpu::FramebufferPointer(gpu::Framebuffer::create(gpu::Element::COLOR_SRGBA_32, _frameBufferSize.width(), _frameBufferSize.height())));
}
gpu::FramebufferPointer result = _cachedFramebuffers.front();
_cachedFramebuffers.pop_front();

2
libraries/render-utils/src/simple.slf
View file

@ -18,7 +18,7 @@
// the interpolated normal
in vec3 _normal;
in vec3 _modelNormal;
in vec3 _color;
in vec4 _color;
in vec2 _texCoord0;
in vec4 _position;

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

@ -116,35 +116,25 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
// FIrst thing, we collect the bound and the status for all the items we want to render
int nbItems = 0;
{
if (!_itemBounds) {
_itemBounds = std::make_shared<gpu::Buffer>();
}
if (!_itemStatus) {
_itemStatus = std::make_shared<gpu::Buffer>();;
}
if (!_itemCells) {
_itemCells = std::make_shared<gpu::Buffer>();;
}
_itemBounds.resize(inItems.size());
_itemStatus.resize(inItems.size());
_itemCells.resize(inItems.size());
_itemBounds->resize((inItems.size() * sizeof(AABox)));
_itemStatus->resize((inItems.size() * NUM_STATUS_VEC4_PER_ITEM * sizeof(glm::vec4)));
_itemCells->resize((inItems.size() * sizeof(Octree::Location)));
AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
for (auto& item : inItems) {
// AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
// glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
// Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
for (size_t i = 0; i < inItems.size(); ++i) {
const auto& item = inItems[i];
if (!item.bound.isInvalid()) {
if (!item.bound.isNull()) {
(*itemAABox) = item.bound;
_itemBounds[i] = item.bound;
} else {
(*itemAABox).setBox(item.bound.getCorner(), 0.1f);
_itemBounds[i].setBox(item.bound.getCorner(), 0.1f);
}
auto& itemScene = scene->getItem(item.id);
(*itemCell) = scene->getSpatialTree().getCellLocation(itemScene.getCell());
_itemCells[i] = scene->getSpatialTree().getCellLocation(itemScene.getCell());
auto itemStatusPointer = itemScene.getStatus();
if (itemStatusPointer) {
@ -152,25 +142,19 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
auto&& currentStatusValues = itemStatusPointer->getCurrentValues();
int valueNum = 0;
for (int vec4Num = 0; vec4Num < NUM_STATUS_VEC4_PER_ITEM; vec4Num++) {
(*itemStatus) = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
auto& value = (vec4Num ? _itemStatus[i].first : _itemStatus[i].second);
value = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
for (int component = 0; component < VEC4_LENGTH; component++) {
valueNum = vec4Num * VEC4_LENGTH + component;
if (valueNum < (int)currentStatusValues.size()) {
(*itemStatus)[component] = currentStatusValues[valueNum].getPackedData();
value[component] = currentStatusValues[valueNum].getPackedData();
}
}
itemStatus++;
}
} else {
(*itemStatus) = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
itemStatus++;
(*itemStatus) = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
itemStatus++;
_itemStatus[i].first = _itemStatus[i].second = glm::ivec4(Item::Status::Value::INVALID.getPackedData());
}
nbItems++;
itemAABox++;
itemCell++;
}
}
}
@ -194,25 +178,20 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
// bind the one gpu::Pipeline we need
batch.setPipeline(getDrawItemBoundsPipeline());
AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
//AABox* itemAABox = reinterpret_cast<AABox*> (_itemBounds->editData());
//glm::ivec4* itemStatus = reinterpret_cast<glm::ivec4*> (_itemStatus->editData());
//Octree::Location* itemCell = reinterpret_cast<Octree::Location*> (_itemCells->editData());
const unsigned int VEC3_ADRESS_OFFSET = 3;
if (_showDisplay) {
for (int i = 0; i < nbItems; i++) {
batch._glUniform3fv(_drawItemBoundPosLoc, 1, (const float*) (itemAABox + i));
batch._glUniform3fv(_drawItemBoundDimLoc, 1, ((const float*) (itemAABox + i)) + VEC3_ADRESS_OFFSET);
glm::ivec4 cellLocation(itemCell->pos.x, itemCell->pos.y, itemCell->pos.z, itemCell->depth);
batch._glUniform3fv(_drawItemBoundPosLoc, 1, (const float*)&(_itemBounds[i]));
batch._glUniform3fv(_drawItemBoundDimLoc, 1, ((const float*)&(_itemBounds[i])) + VEC3_ADRESS_OFFSET);
glm::ivec4 cellLocation(_itemCells[i].pos, _itemCells[i].depth);
batch._glUniform4iv(_drawItemCellLocLoc, 1, ((const int*)(&cellLocation)));
batch.draw(gpu::LINES, 24, 0);
itemCell++;
}
}
@ -222,10 +201,10 @@ void DrawStatus::run(const SceneContextPointer& sceneContext,
if (_showNetwork) {
for (int i = 0; i < nbItems; i++) {
batch._glUniform3fv(_drawItemStatusPosLoc, 1, (const float*) (itemAABox + i));
batch._glUniform3fv(_drawItemStatusDimLoc, 1, ((const float*) (itemAABox + i)) + VEC3_ADRESS_OFFSET);
batch._glUniform4iv(_drawItemStatusValue0Loc, 1, (const int*)(itemStatus + NUM_STATUS_VEC4_PER_ITEM * i));
batch._glUniform4iv(_drawItemStatusValue1Loc, 1, (const int*)(itemStatus + NUM_STATUS_VEC4_PER_ITEM * i + 1));
batch._glUniform3fv(_drawItemStatusPosLoc, 1, (const float*)&(_itemBounds[i]));
batch._glUniform3fv(_drawItemStatusDimLoc, 1, ((const float*)&(_itemBounds[i])) + VEC3_ADRESS_OFFSET);
batch._glUniform4iv(_drawItemStatusValue0Loc, 1, (const int*)&(_itemStatus[i].first));
batch._glUniform4iv(_drawItemStatusValue1Loc, 1, (const int*)&(_itemStatus[i].second));
batch.draw(gpu::TRIANGLES, 24 * NUM_STATUS_VEC4_PER_ITEM, 0);
}
}

10
libraries/render/src/render/DrawStatus.h
View file

@ -68,9 +68,13 @@ namespace render {
gpu::Stream::FormatPointer _drawItemFormat;
gpu::PipelinePointer _drawItemBoundsPipeline;
gpu::PipelinePointer _drawItemStatusPipeline;
gpu::BufferPointer _itemBounds;
gpu::BufferPointer _itemCells;
gpu::BufferPointer _itemStatus;
std::vector<AABox> _itemBounds;
std::vector<std::pair<glm::ivec4, glm::ivec4>> _itemStatus;
std::vector<Octree::Location> _itemCells;
//gpu::BufferPointer _itemBounds;
//gpu::BufferPointer _itemCells;
//gpu::BufferPointer _itemStatus;
gpu::TexturePointer _statusIconMap;
};
}

10
scripts/system/away.js
View file

@ -262,6 +262,14 @@ eventMapping.from(Controller.Standard.LeftPrimaryThumb).peek().to(goActive);
eventMapping.from(Controller.Standard.RightPrimaryThumb).peek().to(goActive);
eventMapping.from(Controller.Standard.LeftSecondaryThumb).peek().to(goActive);
eventMapping.from(Controller.Standard.RightSecondaryThumb).peek().to(goActive);
eventMapping.from(Controller.Standard.LT).peek().to(goActive);
eventMapping.from(Controller.Standard.LB).peek().to(goActive);
eventMapping.from(Controller.Standard.LS).peek().to(goActive);
eventMapping.from(Controller.Standard.RT).peek().to(goActive);
eventMapping.from(Controller.Standard.RB).peek().to(goActive);
eventMapping.from(Controller.Standard.RS).peek().to(goActive);
eventMapping.from(Controller.Standard.Back).peek().to(goActive);
eventMapping.from(Controller.Standard.Start).peek().to(goActive);
Controller.enableMapping(eventMappingName);
Script.scriptEnding.connect(function () {
@ -270,4 +278,4 @@ Script.scriptEnding.connect(function () {
Controller.disableMapping(eventMappingName);
Controller.mousePressEvent.disconnect(goActive);
Controller.keyPressEvent.disconnect(maybeGoActive);
});
});

3
scripts/system/controllers/handControllerGrab.js
View file

@ -739,6 +739,9 @@ function MyController(hand) {
};
this.propsArePhysical = function(props) {
if (!props.dynamic) {
return false;
}
var isPhysical = (props.shapeType && props.shapeType != 'none');
return isPhysical;
}