Mirrors/overte
3
0
Fork 0
mirror of https://github.com/overte-org/overte.git synced 2025-06-25 23:09:48 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Merge branch 'master' of github.com:highfidelity/hifi into dice-on-table-1

Browse source
This commit is contained in:
Seth Alves 2015-05-06 14:41:54 -07:00
commit a057d7dfa3
36 changed files with 1050 additions and 606 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
interface/src/Application.cpp
View file

@ -3174,6 +3174,10 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
glTexGenfv(GL_R, GL_EYE_PLANE, (const GLfloat*)&_shadowMatrices[i][2]);
}
// Background rendering decision
auto skyStage = DependencyManager::get<SceneScriptingInterface>()->getSkyStage();
if (skyStage->getBackgroundMode() == model::SunSkyStage::NO_BACKGROUND) {
} else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_DOME) {
if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Stars)) {
PerformanceTimer perfTimer("stars");
PerformanceWarning warn(Menu::getInstance()->isOptionChecked(MenuOption::PipelineWarnings),
@ -3208,11 +3212,6 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
if (hasStars) {
_stars.render(theCamera.getFieldOfView(), theCamera.getAspectRatio(), theCamera.getNearClip(), alpha);
}
}
if (Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
// draw the sky dome
if (!selfAvatarOnly && Menu::getInstance()->isOptionChecked(MenuOption::Atmosphere)) {
@ -3221,6 +3220,23 @@ void Application::displaySide(Camera& theCamera, bool selfAvatarOnly, RenderArgs
"Application::displaySide() ... atmosphere...");
_environment.renderAtmospheres(theCamera);
}
}
} else if (skyStage->getBackgroundMode() == model::SunSkyStage::SKY_BOX) {
auto skybox = skyStage->getSkybox();
if (skybox) {
gpu::Batch batch;
model::Skybox::render(batch, _viewFrustum, *skybox);
gpu::GLBackend::renderBatch(batch);
glUseProgram(0);
}
}
if (Menu::getInstance()->isOptionChecked(MenuOption::Wireframe)) {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
glEnable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);

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

@ -123,7 +123,11 @@ void KeyboardMouseDevice::touchUpdateEvent(const QTouchEvent* event) {
}
UserInputMapper::Input KeyboardMouseDevice::makeInput(Qt::Key code) {
return UserInputMapper::Input(_deviceID, code & KEYBOARD_MASK, UserInputMapper::ChannelType::BUTTON);
auto shortCode = (UserInputMapper::uint16)(code & KEYBOARD_MASK);
if (shortCode != code) {
shortCode |= 0x0800; // add this bit instead of the way Qt::Key add a bit on the 3rd byte for some keys
}
return UserInputMapper::Input(_deviceID, shortCode, UserInputMapper::ChannelType::BUTTON);
}
UserInputMapper::Input KeyboardMouseDevice::makeInput(Qt::MouseButton code) {

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

@ -1688,7 +1688,7 @@ FBXGeometry extractFBXGeometry(const FBXNode& node, const QVariantHash& mapping,
}
} else if (object.name == "Material") {
Material material = { glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(1.0f, 1.0f, 1.0f), glm::vec3(), 96.0f, 1.0f,
QString(""), QSharedPointer<model::Material>(NULL)};
QString(""), model::MaterialPointer(NULL)};
foreach (const FBXNode& subobject, object.children) {
bool properties = false;
QByteArray propertyName;

12
libraries/gpu/src/gpu/Batch.cpp
View file

@ -91,6 +91,18 @@ void Batch::drawIndexedInstanced(uint32 nbInstances, Primitive primitiveType, ui
_params.push_back(nbInstances);
}
void Batch::clearFramebuffer(Framebuffer::Masks targets, const Vec4& color, float depth, int stencil) {
ADD_COMMAND(clearFramebuffer);
_params.push_back(stencil);
_params.push_back(depth);
_params.push_back(color.w);
_params.push_back(color.z);
_params.push_back(color.y);
_params.push_back(color.x);
_params.push_back(targets);
}
void Batch::setInputFormat(const Stream::FormatPointer& format) {
ADD_COMMAND(setInputFormat);

5
libraries/gpu/src/gpu/Batch.h
View file

@ -81,6 +81,9 @@ public:
void drawInstanced(uint32 nbInstances, Primitive primitiveType, uint32 nbVertices, uint32 startVertex = 0, uint32 startInstance = 0);
void drawIndexedInstanced(uint32 nbInstances, Primitive primitiveType, uint32 nbIndices, uint32 startIndex = 0, uint32 startInstance = 0);
// Clear framebuffer layers
void clearFramebuffer(Framebuffer::Masks targets, const Vec4& color, float depth, int stencil);
// Input Stage
// InputFormat
// InputBuffers
@ -160,6 +163,8 @@ public:
COMMAND_drawInstanced,
COMMAND_drawIndexedInstanced,
COMMAND_clearFramebuffer,
COMMAND_setInputFormat,
COMMAND_setInputBuffer,
COMMAND_setIndexBuffer,

1
libraries/gpu/src/gpu/Context.h
View file

@ -43,6 +43,7 @@ public:
Mat4 _viewInverse;
Mat4 _projectionViewUntranslated;
Mat4 _projection;
Mat4 _projectionInverse;
Vec4 _viewport;
};

2
libraries/gpu/src/gpu/Format.h
View file

@ -27,6 +27,8 @@ typedef short int16;
typedef unsigned char uint8;
typedef char int8;
typedef unsigned char Byte;
typedef uint32 Offset;
typedef glm::mat4 Mat4;

5
libraries/gpu/src/gpu/Framebuffer.h
View file

@ -81,6 +81,7 @@ public:
BUFFER_STENCIL = 0x80000000,
BUFFER_DEPTHSTENCIL = 0xC0000000,
};
typedef uint32 Masks;
~Framebuffer();
@ -111,7 +112,7 @@ public:
// Properties
uint32 getBufferMask() const { return _bufferMask; }
Masks getBufferMask() const { return _bufferMask; }
bool isEmpty() const { return (_bufferMask == 0); }
bool hasColor() const { return (getBufferMask() & BUFFER_COLORS); }
bool hasDepthStencil() const { return (getBufferMask() & BUFFER_DEPTHSTENCIL); }
@ -137,7 +138,7 @@ protected:
TextureViews _renderBuffers;
TextureView _depthStencilBuffer;
uint32 _bufferMask = 0;
Masks _bufferMask = 0;
uint32 _frameCount = 0;

34
libraries/gpu/src/gpu/GLBackend.cpp
View file

@ -17,6 +17,7 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
(&::gpu::GLBackend::do_drawIndexed),
(&::gpu::GLBackend::do_drawInstanced),
(&::gpu::GLBackend::do_drawIndexedInstanced),
(&::gpu::GLBackend::do_clearFramebuffer),
(&::gpu::GLBackend::do_setInputFormat),
(&::gpu::GLBackend::do_setInputBuffer),
@ -170,6 +171,39 @@ void GLBackend::do_drawIndexedInstanced(Batch& batch, uint32 paramOffset) {
(void) CHECK_GL_ERROR();
}
void GLBackend::do_clearFramebuffer(Batch& batch, uint32 paramOffset) {
uint32 masks = batch._params[paramOffset + 6]._uint;
Vec4 color;
color.x = batch._params[paramOffset + 5]._float;
color.y = batch._params[paramOffset + 4]._float;
color.z = batch._params[paramOffset + 3]._float;
color.w = batch._params[paramOffset + 2]._float;
float depth = batch._params[paramOffset + 1]._float;
int stencil = batch._params[paramOffset + 0]._float;
GLuint glmask = 0;
if (masks & Framebuffer::BUFFER_DEPTH) {
glClearStencil(stencil);
glmask |= GL_STENCIL_BUFFER_BIT;
}
if (masks & Framebuffer::BUFFER_DEPTH) {
glClearDepth(depth);
glmask |= GL_DEPTH_BUFFER_BIT;
}
if (masks & Framebuffer::BUFFER_COLORS) {
glClearColor(color.x, color.y, color.z, color.w);
glmask |= GL_COLOR_BUFFER_BIT;
}
glClear(glmask);
(void) CHECK_GL_ERROR();
}
// TODO: As long as we have gl calls explicitely issued from interface
// code, we need to be able to record and batch these calls. THe long
// term strategy is to get rid of any GL calls in favor of the HIFI GPU API

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

@ -191,6 +191,8 @@ protected:
void do_drawInstanced(Batch& batch, uint32 paramOffset);
void do_drawIndexedInstanced(Batch& batch, uint32 paramOffset);
void do_clearFramebuffer(Batch& batch, uint32 paramOffset);
// Input Stage
void do_setInputFormat(Batch& batch, uint32 paramOffset);
void do_setInputBuffer(Batch& batch, uint32 paramOffset);

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

@ -171,10 +171,21 @@ void GLBackend::do_setUniformTexture(Batch& batch, uint32 paramOffset) {
GLuint slot = batch._params[paramOffset + 1]._uint;
TexturePointer uniformTexture = batch._textures.get(batch._params[paramOffset + 0]._uint);
GLuint to = getTextureID(uniformTexture);
glActiveTexture(GL_TEXTURE0 + slot);
glBindTexture(GL_TEXTURE_2D, to);
(void) CHECK_GL_ERROR();
if (!uniformTexture) {
return;
}
GLTexture* object = GLBackend::syncGPUObject(*uniformTexture);
if (object) {
GLuint to = object->_texture;
GLuint target = object->_target;
glActiveTexture(GL_TEXTURE0 + slot);
glBindTexture(target, to);
(void) CHECK_GL_ERROR();
} else {
return;
}
}

92
libraries/gpu/src/gpu/GLBackendTexture.cpp
View file

@ -297,7 +297,7 @@ GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
if (needUpdate) {
if (texture.isStoredMipAvailable(0)) {
Texture::PixelsPointer mip = texture.accessStoredMip(0);
const GLvoid* bytes = mip->_sysmem.read<Resource::Byte>();
const GLvoid* bytes = mip->_sysmem.read<Byte>();
Element srcFormat = mip->_format;
GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), srcFormat);
@ -328,7 +328,7 @@ GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
if (texture.isStoredMipAvailable(0)) {
Texture::PixelsPointer mip = texture.accessStoredMip(0);
bytes = mip->_sysmem.read<Resource::Byte>();
bytes = mip->_sysmem.read<Byte>();
srcFormat = mip->_format;
object->_contentStamp = texture.getDataStamp();
@ -363,6 +363,93 @@ GLBackend::GLTexture* GLBackend::syncGPUObject(const Texture& texture) {
}
break;
}
case Texture::TEX_CUBE: {
if (texture.getNumSlices() == 1) {
GLint boundTex = -1;
glGetIntegerv(GL_TEXTURE_BINDING_CUBE_MAP, &boundTex);
glBindTexture(GL_TEXTURE_CUBE_MAP, object->_texture);
const int NUM_FACES = 6;
const GLenum FACE_LAYOUT[] = {
GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };
if (needUpdate) {
if (texture.isStoredMipAvailable(0)) {
Texture::PixelsPointer mip = texture.accessStoredMip(0);
Element srcFormat = mip->_format;
GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), srcFormat);
uint16 width = texture.getWidth();
int faceSize = mip->_sysmem.getSize() / NUM_FACES;
glBindTexture(GL_TEXTURE_CUBE_MAP, object->_texture);
for (int f = 0; f < NUM_FACES; f++) {
glTexSubImage2D(FACE_LAYOUT[f], 0, texelFormat.internalFormat, width, width, 0,
texelFormat.format, texelFormat.type, (GLvoid*) (mip->_sysmem.read<Byte>() + f * faceSize));
}
if (texture.isAutogenerateMips()) {
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
}
object->_target = GL_TEXTURE_CUBE_MAP;
syncSampler(texture.getSampler(), texture.getType(), object);
// At this point the mip piels have been loaded, we can notify
texture.notifyGPULoaded(0);
object->_contentStamp = texture.getDataStamp();
}
} else {
const gpu::Byte* bytes = 0;
Element srcFormat = texture.getTexelFormat();
uint16 width = texture.getWidth();
int faceSize = 0;
if (texture.isStoredMipAvailable(0)) {
Texture::PixelsPointer mip = texture.accessStoredMip(0);
bytes = mip->_sysmem.read<Byte>();
srcFormat = mip->_format;
faceSize = mip->_sysmem.getSize() / NUM_FACES;
object->_contentStamp = texture.getDataStamp();
}
GLTexelFormat texelFormat = GLTexelFormat::evalGLTexelFormat(texture.getTexelFormat(), srcFormat);
glBindTexture(GL_TEXTURE_CUBE_MAP, object->_texture);
for (int f = 0; f < NUM_FACES; f++) {
glTexImage2D(FACE_LAYOUT[f], 0, texelFormat.internalFormat, width, width, 0,
texelFormat.format, texelFormat.type, (GLvoid*) (bytes + f * faceSize));
}
if (bytes && texture.isAutogenerateMips()) {
glGenerateMipmap(GL_TEXTURE_CUBE_MAP);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
} else {
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
}
object->_target = GL_TEXTURE_CUBE_MAP;
syncSampler(texture.getSampler(), texture.getType(), object);
// At this point the mip piels have been loaded, we can notify
texture.notifyGPULoaded(0);
object->_storageStamp = texture.getStamp();
object->_size = texture.getSize();
}
glBindTexture(GL_TEXTURE_CUBE_MAP, boundTex);
}
break;
}
default:
qCDebug(gpulogging) << "GLBackend::syncGPUObject(const Texture&) case for Texture Type " << texture.getType() << " not supported";
}
@ -449,6 +536,5 @@ void GLBackend::syncSampler(const Sampler& sampler, Texture::Type type, GLTextur
glTexParameterf(object->_target, GL_TEXTURE_MIN_LOD, (float) sampler.getMinMip());
glTexParameterf(object->_target, GL_TEXTURE_MAX_LOD, (sampler.getMaxMip() == Sampler::MAX_MIP_LEVEL ? 1000.f : sampler.getMaxMip()));
glTexParameterf(object->_target, GL_TEXTURE_MAX_ANISOTROPY_EXT, sampler.getMaxAnisotropy());
(void) CHECK_GL_ERROR();
}

1
libraries/gpu/src/gpu/GLBackendTransform.cpp
View file

@ -59,6 +59,7 @@ void GLBackend::updateTransform() {
// Check all the dirty flags and update the state accordingly
if (_transform._invalidProj) {
_transform._transformCamera._projection = _transform._projection;
_transform._transformCamera._projectionInverse = glm::inverse(_transform._projection);
}
if (_transform._invalidView) {

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

@ -17,7 +17,7 @@
#include <vector>
#include <QSharedPointer>
#include <memory>
#ifdef _DEBUG
#include <QDebug>
#endif
@ -26,7 +26,6 @@ namespace gpu {
class Resource {
public:
typedef unsigned char Byte;
typedef unsigned int Size;
static const Size NOT_ALLOCATED = -1;
@ -156,7 +155,7 @@ protected:
friend class Backend;
};
typedef QSharedPointer<Buffer> BufferPointer;
typedef std::shared_ptr<Buffer> BufferPointer;
typedef std::vector< BufferPointer > Buffers;
@ -317,7 +316,7 @@ public:
template <typename T> const T& get() const {
#if _DEBUG
if (_buffer.isNull()) {
if (!_buffer) {
qDebug() << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - _offset)) {
@ -333,7 +332,7 @@ public:
template <typename T> T& edit() {
#if _DEBUG
if (_buffer.isNull()) {
if (!_buffer) {
qDebug() << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - _offset)) {
@ -350,7 +349,7 @@ public:
template <typename T> const T& get(const Index index) const {
Resource::Size elementOffset = index * sizeof(T) + _offset;
#if _DEBUG
if (_buffer.isNull()) {
if (!_buffer) {
qDebug() << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - elementOffset)) {
@ -366,7 +365,7 @@ public:
template <typename T> T& edit(const Index index) const {
Resource::Size elementOffset = index * sizeof(T) + _offset;
#if _DEBUG
if (_buffer.isNull()) {
if (!_buffer) {
qDebug() << "Accessing null gpu::buffer!";
}
if (sizeof(T) > (_buffer->getSize() - elementOffset)) {

3
libraries/gpu/src/gpu/Shader.h
View file

@ -12,6 +12,7 @@
#define hifi_gpu_Shader_h
#include "Resource.h"
#include <string>
#include <memory>
#include <set>
@ -20,7 +21,7 @@ namespace gpu {
class Shader {
public:
typedef QSharedPointer< Shader > Pointer;
typedef std::shared_ptr< Shader > Pointer;
typedef std::vector< Pointer > Shaders;
class Source {

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

@ -11,6 +11,8 @@
#include "Stream.h"
#include <algorithm> //min max and more
using namespace gpu;
void Stream::Format::evaluateCache() {

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

@ -117,7 +117,7 @@ public:
void evaluateCache();
};
typedef QSharedPointer<Format> FormatPointer;
typedef std::shared_ptr<Format> FormatPointer;
};
typedef std::vector< Offset > Offsets;
@ -143,7 +143,7 @@ protected:
Offsets _offsets;
Strides _strides;
};
typedef QSharedPointer<BufferStream> BufferStreamPointer;
typedef std::shared_ptr<BufferStream> BufferStreamPointer;
};

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

@ -15,6 +15,8 @@
using namespace gpu;
uint8 Texture::NUM_FACES_PER_TYPE[NUM_TYPES] = {1, 1, 1, 6};
Texture::Pixels::Pixels(const Element& format, Size size, const Byte* bytes) :
_sysmem(size, bytes),
_format(format),
@ -131,19 +133,7 @@ Texture* Texture::createFromStorage(Storage* storage) {
}
Texture::Texture():
Resource(),
_storage(),
_stamp(0),
_size(0),
_width(1),
_height(1),
_depth(1),
_numSamples(1),
_numSlices(1),
_maxMip(0),
_type(TEX_1D),
_autoGenerateMips(false),
_defined(false)
Resource()
{
}
@ -188,8 +178,7 @@ Texture::Size Texture::resize(Type type, const Element& texelFormat, uint16 widt
}
// Evaluate the new size with the new format
const int DIM_SIZE[] = {1, 1, 1, 6};
uint32_t size = DIM_SIZE[_type] *_width * _height * _depth * _numSamples * texelFormat.getSize();
uint32_t size = NUM_FACES_PER_TYPE[_type] *_width * _height * _depth * _numSamples * texelFormat.getSize();
// If size change then we need to reset
if (changed || (size != getSize())) {

46
libraries/gpu/src/gpu/Texture.h
View file

@ -12,7 +12,8 @@
#define hifi_gpu_Texture_h
#include "Resource.h"
#include <memory>
#include <algorithm> //min max and more
namespace gpu {
@ -109,7 +110,7 @@ public:
Element _format;
bool _isGPULoaded;
};
typedef QSharedPointer< Pixels > PixelsPointer;
typedef std::shared_ptr< Pixels > PixelsPointer;
class Storage {
public:
@ -138,6 +139,8 @@ public:
TEX_2D,
TEX_3D,
TEX_CUBE,
NUM_TYPES,
};
static Texture* create1D(const Element& texelFormat, uint16 width, const Sampler& sampler = Sampler());
@ -180,11 +183,19 @@ public:
uint16 getDepth() const { return _depth; }
uint32 getRowPitch() const { return getWidth() * getTexelFormat().getSize(); }
uint32 getNumTexels() const { return _width * _height * _depth; }
// The number of faces is mostly used for cube map, and maybe for stereo ? otherwise it's 1
// For cube maps, this means the pixels of the different faces are supposed to be packed back to back in a mip
// as if the height was NUM_FACES time bigger.
static uint8 NUM_FACES_PER_TYPE[NUM_TYPES];
uint8 getNumFaces() const { return NUM_FACES_PER_TYPE[getType()]; }
uint32 getNumTexels() const { return _width * _height * _depth * getNumFaces(); }
uint16 getNumSlices() const { return _numSlices; }
uint16 getNumSamples() const { return _numSamples; }
// NumSamples can only have certain values based on the hw
static uint16 evalNumSamplesUsed(uint16 numSamplesTried);
@ -203,7 +214,7 @@ public:
uint16 evalMipWidth(uint16 level) const { return std::max(_width >> level, 1); }
uint16 evalMipHeight(uint16 level) const { return std::max(_height >> level, 1); }
uint16 evalMipDepth(uint16 level) const { return std::max(_depth >> level, 1); }
uint32 evalMipNumTexels(uint16 level) const { return evalMipWidth(level) * evalMipHeight(level) * evalMipDepth(level); }
uint32 evalMipNumTexels(uint16 level) const { return evalMipWidth(level) * evalMipHeight(level) * evalMipDepth(level) * getNumFaces(); }
uint32 evalMipSize(uint16 level) const { return evalMipNumTexels(level) * getTexelFormat().getSize(); }
uint32 evalStoredMipSize(uint16 level, const Element& format) const { return evalMipNumTexels(level) * format.getSize(); }
@ -269,27 +280,26 @@ public:
protected:
std::unique_ptr< Storage > _storage;
Stamp _stamp;
Stamp _stamp = 0;
Sampler _sampler;
Stamp _samplerStamp;
uint32 _size;
uint32 _size = 0;
Element _texelFormat;
uint16 _width;
uint16 _height;
uint16 _depth;
uint16 _width = 1;
uint16 _height = 1;
uint16 _depth = 1;
uint16 _numSamples;
uint16 _numSlices;
uint16 _numSamples = 1;
uint16 _numSlices = 1;
uint16 _maxMip;
uint16 _maxMip = 0;
Type _type;
bool _autoGenerateMips;
bool _defined;
Type _type = TEX_1D;
bool _autoGenerateMips = false;
bool _defined = false;
static Texture* create(Type type, const Element& texelFormat, uint16 width, uint16 height, uint16 depth, uint16 numSamples, uint16 numSlices, const Sampler& sampler);
Texture();
@ -303,7 +313,7 @@ protected:
friend class Backend;
};
typedef QSharedPointer<Texture> TexturePointer;
typedef std::shared_ptr<Texture> TexturePointer;
typedef std::vector< TexturePointer > Textures;
@ -344,7 +354,7 @@ public:
TextureView(const TextureView& view) = default;
TextureView& operator=(const TextureView& view) = default;
explicit operator bool() const { return (_texture); }
explicit operator bool() const { return bool(_texture); }
bool operator !() const { return (!_texture); }
};
typedef std::vector<TextureView> TextureViews;

21
libraries/gpu/src/gpu/Transform.slh
View file

@ -21,6 +21,7 @@ struct TransformCamera {
mat4 _viewInverse;
mat4 _projectionViewUntranslated;
mat4 _projection;
mat4 _projectionInverse;
vec4 _viewport;
};
@ -120,4 +121,24 @@ TransformCamera getTransformCamera() {
<@endif@>
<@endfunc@>
<@func transformEyeToWorldDir(cameraTransform, eyeDir, worldDir)@>
<@if GPU_TRANSFORM_PROFILE == GPU_CORE@>
{ // transformEyeToWorldDir
<$worldDir$> = vec3(<$cameraTransform$>._viewInverse * vec4(<$eyeDir$>.xyz, 0.0));
}
<@else@>
<$worldDir$> = vec3(gl_ModelViewMatrixInverse * vec4(<$eyeDir$>.xyz, 0.0));
<@endif@>
<@endfunc@>
<@func transformClipToEyeDir(cameraTransform, clipPos, eyeDir)@>
<@if GPU_TRANSFORM_PROFILE == GPU_CORE@>
{ // transformClipToEyeDir
<$eyeDir$> = vec3(<$cameraTransform$>._projectionInverse * vec4(<$clipPos$>.xyz, 1.0));
}
<@else@>
<$eyeDir$> = vec3(gl_ProjectionMatrixInverse * vec4(<$clipPos$>.xyz, 1.0));
<@endif@>
<@endfunc@>
<@endif@>

4
libraries/model/src/model/Geometry.h
View file

@ -47,7 +47,7 @@ public:
void setVertexBuffer(const BufferView& buffer);
const BufferView& getVertexBuffer() const { return _vertexBuffer; }
uint getNumVertices() const { return _vertexBuffer.getNumElements(); }
bool hasVertexData() const { return !_vertexBuffer._buffer.isNull(); }
bool hasVertexData() const { return !_vertexBuffer._buffer; }
// Attribute Buffers
int getNumAttributes() const { return _attributeBuffers.size(); }
@ -126,7 +126,7 @@ protected:
void evalVertexFormat();
};
typedef QSharedPointer< Mesh > MeshPointer;
typedef std::shared_ptr< Mesh > MeshPointer;
class Geometry {

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

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

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

@ -282,7 +282,7 @@ protected:
const Schema& getSchema() const { return _schemaBuffer.get<Schema>(); }
Schema& editSchema() { return _schemaBuffer.edit<Schema>(); }
};
typedef QSharedPointer< Light > LightPointer;
typedef std::shared_ptr< Light > LightPointer;
};

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

@ -11,6 +11,7 @@
#include "Material.h"
using namespace model;
using namespace gpu;
Material::Material() :
_flags(0),
@ -19,7 +20,7 @@ Material::Material() :
// only if created from nothing shall we create the Buffer to store the properties
Schema schema;
_schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Buffer::Byte*) &schema));
_schemaBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Schema), (const gpu::Byte*) &schema));
}
@ -86,7 +87,20 @@ void Material::setOpacity(float opacity) {
_schemaBuffer.edit<Schema>()._opacity = opacity;
}
void Material::setTextureView(MapChannel channel, const TextureView& view) {
void Material::setTextureView(MapChannel channel, const gpu::TextureView& view) {
_flags.set(DIFFUSE_MAP_BIT + channel);
_textureMap[channel] = view;
}
// TextureStorage
TextureStorage::TextureStorage(const QUrl& url) : gpu::Texture::Storage(), _url(url) {
init();
}
TextureStorage::~TextureStorage() {
}
void TextureStorage::init() {
_gpuTexture = TexturePointer(Texture::createFromStorage(this));
}

29
libraries/model/src/model/Material.h
View file

@ -19,12 +19,35 @@
#include "gpu/Resource.h"
#include "gpu/Texture.h"
#include <qurl.h>
namespace model {
typedef gpu::BufferView UniformBufferView;
typedef gpu::TextureView TextureView;
typedef glm::vec3 Color;
// TextureStorage is a specialized version of the gpu::Texture::Storage
// It adds the URL and the notion that it owns the gpu::Texture
class TextureStorage : public gpu::Texture::Storage {
public:
TextureStorage(const QUrl& url);
~TextureStorage();
const QUrl& getUrl() const { return _url; }
const gpu::TexturePointer& getGPUTexture() const { return _gpuTexture; }
protected:
gpu::TexturePointer _gpuTexture;
QUrl _url;
void init();
};
typedef std::shared_ptr< TextureStorage > TextureStoragePointer;
class Material {
public:
typedef gpu::BufferView UniformBufferView;
typedef gpu::TextureView TextureView;
typedef glm::vec3 Color;
@ -102,7 +125,7 @@ protected:
TextureMap _textureMap;
};
typedef QSharedPointer< Material > MaterialPointer;
typedef std::shared_ptr< Material > MaterialPointer;
};

94
libraries/model/src/model/Skybox.cpp Executable file
View file

@ -0,0 +1,94 @@
//
// Skybox.cpp
// libraries/model/src/model
//
// Created by Sam Gateau on 5/4/2015.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#include "Skybox.h"
#include "gpu/Batch.h"
#include "gpu/Context.h"
#include "ViewFrustum.h"
#include "Skybox_vert.h"
#include "Skybox_frag.h"
using namespace model;
Skybox::Skybox() {
_cubemap.reset( gpu::Texture::createCube(gpu::Element::COLOR_RGBA_32, 1));
unsigned char texels[] = {
255, 0, 0, 255,
0, 255, 255, 255,
0, 0, 255, 255,
255, 255, 0, 255,
0, 255, 0, 255,
255, 0, 255, 255,
};
_cubemap->assignStoredMip(0, gpu::Element::COLOR_RGBA_32, sizeof(texels), texels);
}
void Skybox::setColor(const Color& color) {
_color = color;
}
void Skybox::setCubemap(const gpu::TexturePointer& cubemap) {
_cubemap = cubemap;
}
void Skybox::render(gpu::Batch& batch, const ViewFrustum& viewFrustum, const Skybox& skybox) {
if (skybox.getCubemap()) {
static gpu::PipelinePointer thePipeline;
static gpu::BufferPointer theBuffer;
static gpu::Stream::FormatPointer theFormat;
if (!thePipeline) {
auto skyVS = gpu::ShaderPointer(gpu::Shader::createVertex(std::string(Skybox_vert)));
auto skyFS = gpu::ShaderPointer(gpu::Shader::createPixel(std::string(Skybox_frag)));
auto skyShader = gpu::ShaderPointer(gpu::Shader::createProgram(skyVS, skyFS));
gpu::Shader::BindingSet bindings;
bindings.insert(gpu::Shader::Binding(std::string("cubeMap"), 0));
if (!gpu::Shader::makeProgram(*skyShader, bindings)) {
}
auto skyState = gpu::StatePointer(new gpu::State());
thePipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));
const float CLIP = 1.0;
const glm::vec2 vertices[4] = { {-CLIP, -CLIP}, {CLIP, -CLIP}, {-CLIP, CLIP}, {CLIP, CLIP}};
theBuffer.reset(new gpu::Buffer(sizeof(vertices), (const gpu::Byte*) vertices));
theFormat.reset(new gpu::Stream::Format());
theFormat->setAttribute(gpu::Stream::POSITION, gpu::Stream::POSITION, gpu::Element(gpu::VEC2, gpu::FLOAT, gpu::XYZ));
}
glm::mat4 projMat;
viewFrustum.evalProjectionMatrix(projMat);
Transform viewTransform;
viewFrustum.evalViewTransform(viewTransform);
batch.setProjectionTransform(projMat);
batch.setViewTransform(viewTransform);
batch.setModelTransform(Transform()); // only for Mac
batch.setPipeline(thePipeline);
batch.setInputBuffer(gpu::Stream::POSITION, theBuffer, 0, 8);
batch.setInputFormat(theFormat);
batch.setUniformTexture(0, skybox.getCubemap());
batch.draw(gpu::TRIANGLE_STRIP, 4);
} else {
// skybox has no cubemap, just clear the color buffer
auto color = skybox.getColor();
batch.clearFramebuffer(gpu::Framebuffer::BUFFER_COLOR0, glm::vec4(skybox.getColor(),1.0f), 0.f, 0);
}
}

46
libraries/model/src/model/Skybox.h Executable file
View file

@ -0,0 +1,46 @@
//
// Skybox.h
// libraries/model/src/model
//
// Created by Sam Gateau on 5/4/2015.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
#ifndef hifi_model_Skybox_h
#define hifi_model_Skybox_h
#include "gpu/Texture.h"
class ViewFrustum;
//class Transform;
namespace gpu { class Batch; }
namespace model {
typedef glm::vec3 Color;
class Skybox {
public:
Skybox();
Skybox& operator= (const Skybox& skybox);
virtual ~Skybox() {};
void setColor(const Color& color);
const Color& getColor() const { return _color; }
void setCubemap(const gpu::TexturePointer& cubemap);
const gpu::TexturePointer& getCubemap() const { return _cubemap; }
static void render(gpu::Batch& batch, const ViewFrustum& frustum, const Skybox& skybox);
protected:
gpu::TexturePointer _cubemap;
Color _color{1.0f, 1.0f, 1.0f};
};
typedef std::shared_ptr< Skybox > SkyboxPointer;
};
#endif //hifi_model_Skybox_h

24
libraries/model/src/model/Skybox.slf Executable file
View file

@ -0,0 +1,24 @@
<@include gpu/Config.slh@>
<$VERSION_HEADER$>
// Generated on <$_SCRIBE_DATE$>
// skybox.frag
//
// Created by Sam Gateau on 5/5/2015.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
uniform samplerCube cubeMap;
varying vec3 normal;
varying vec2 texcoord;
varying vec3 color;
void main(void) {
vec4 texel = textureCube(cubeMap, normalize(normal));
gl_FragData[0] = texel;
// gl_FragData[0] = vec4(normal, 1.0);
}

40
libraries/model/src/model/Skybox.slv Executable file
View file

@ -0,0 +1,40 @@
<@include gpu/Config.slh@>
<$VERSION_HEADER$>
// Generated on <$_SCRIBE_DATE$>
// skybox.vert
// vertex shader
//
// Created by Sam Gateau on 5/5/2015.
// Copyright 2015 High Fidelity, Inc.
//
// Distributed under the Apache License, Version 2.0.
// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
//
<@include gpu/Transform.slh@>
<$declareStandardTransform()$>
varying vec3 normal;
varying vec2 texcoord;
varying vec3 color;
void main(void) {
texcoord = gl_Vertex.xy;
// pass along the diffuse color
color = vec3(texcoord, 0.0);
// standard transform
TransformCamera cam = getTransformCamera();
vec3 clipDir = vec3(texcoord.xy, 0.0);
vec3 eyeDir;
<$transformClipToEyeDir(cam, clipDir, eyeDir)$>;
normal = normalize(eyeDir);
<$transformEyeToWorldDir(cam, eyeDir, normal)$>;
normal = normalize(normal);
// Position is supposed to cmoe in clip space
gl_Position = vec4(texcoord.xy, 0.0, 1.0);
}

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

@ -138,7 +138,7 @@ void EarthSunModel::setSunLongitude(float lon) {
Atmosphere::Atmosphere() {
// only if created from nothing shall we create the Buffer to store the properties
Data data;
_dataBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Data), (const gpu::Buffer::Byte*) &data));
_dataBuffer = gpu::BufferView(new gpu::Buffer(sizeof(Data), (const gpu::Byte*) &data));
setScatteringWavelength(_scatteringWavelength);
setRayleighScattering(_rayleighScattering);
@ -184,14 +184,6 @@ void Atmosphere::setInnerOuterRadiuses(float inner, float outer) {
data._scales.z = data._scales.x / data._scales.y;
}
Skybox::Skybox() {
}
void Skybox::setCubemap(const gpu::TexturePointer& cubemap) {
_cubemap = cubemap;
}
const int NUM_DAYS_PER_YEAR = 365;
const float NUM_HOURS_PER_DAY = 24.0f;
@ -223,6 +215,10 @@ SunSkyStage::SunSkyStage() :
_skyPipeline = gpu::PipelinePointer(gpu::Pipeline::create(skyShader, skyState));
_skybox.reset(new Skybox());
_skybox->setColor(Color(1.0f, 0.0f, 0.0f));
}
SunSkyStage::~SunSkyStage() {
@ -301,6 +297,11 @@ void SunSkyStage::updateGraphicsObject() const {
}
}
void SunSkyStage::setBackgroundMode(BackgroundMode mode) {
_backgroundMode = mode;
invalidate();
}
void SunSkyStage::setSkybox(const SkyboxPointer& skybox) {
_skybox = skybox;
invalidate();

32
libraries/model/src/model/Stage.h
View file

@ -14,6 +14,7 @@
#include "gpu/Pipeline.h"
#include "Light.h"
#include "Skybox.h"
namespace model {
@ -158,22 +159,7 @@ protected:
void updateScattering();
};
typedef QSharedPointer< Atmosphere > AtmospherePointer;
class Skybox {
public:
Skybox();
Skybox& operator= (const Atmosphere& Skybox);
virtual ~Skybox() {};
void setCubemap(const gpu::TexturePointer& cubemap);
const gpu::TexturePointer& getCubemap() const { return _cubemap; }
protected:
gpu::TexturePointer _cubemap;
};
typedef QSharedPointer< Skybox > SkyboxPointer;
typedef std::shared_ptr< Atmosphere > AtmospherePointer;
// Sun sky stage generates the rendering primitives to display a scene realistically
// at the specified location and time around earth
@ -222,11 +208,23 @@ public:
LightPointer getSunLight() const { valid(); return _sunLight; }
AtmospherePointer getAtmosphere() const { valid(); return _atmosphere; }
enum BackgroundMode {
NO_BACKGROUND = 0,
SKY_DOME,
SKY_BOX,
NUM_BACKGROUND_MODES,
};
void setBackgroundMode(BackgroundMode mode);
BackgroundMode getBackgroundMode() const { return _backgroundMode; }
// Skybox
void setSkybox(const SkyboxPointer& skybox);
const SkyboxPointer& getSkybox() const { valid(); return _skybox; }
protected:
BackgroundMode _backgroundMode = SKY_DOME;
LightPointer _sunLight;
AtmospherePointer _atmosphere;
SkyboxPointer _skybox;
@ -244,7 +242,7 @@ protected:
void updateGraphicsObject() const;
};
typedef QSharedPointer< SunSkyStage > SunSkyStagePointer;
typedef std::shared_ptr< SunSkyStage > SunSkyStagePointer;
};

4
libraries/octree/src/ViewFrustum.cpp
View file

@ -862,3 +862,7 @@ void ViewFrustum::evalProjectionMatrix(glm::mat4& proj) const {
}
}
void ViewFrustum::evalViewTransform(Transform& view) const {
view.setTranslation(getPosition());
view.setRotation(getOrientation());
}

3
libraries/octree/src/ViewFrustum.h
View file

@ -20,6 +20,7 @@
#include <GLMHelpers.h>
#include <RegisteredMetaTypes.h>
#include "Transform.h"
#include "AABox.h"
#include "AACube.h"
#include "Plane.h"
@ -121,6 +122,8 @@ public:
float distanceToCamera(const glm::vec3& point) const;
void evalProjectionMatrix(glm::mat4& proj) const;
void evalViewTransform(Transform& view) const;
private:
// Used for keyhole calculations
ViewFrustum::location pointInKeyhole(const glm::vec3& point) const;

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

@ -69,7 +69,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
|| (!registered && !_sphereVertices.contains(radiusKey))) {
if (registered && _registeredSphereVertices.contains(id)) {
_registeredSphereVertices[id].clear();
_registeredSphereVertices[id].reset();
#ifdef WANT_DEBUG
qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED VERTICES BUFFER";
#endif
@ -111,7 +111,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
*(vertex++) = 0.0f;
*(vertex++) = 1.0f * radius;
verticesBuffer->append(sizeof(GLfloat) * vertices * NUM_COORDS_PER_VERTEX, (gpu::Buffer::Byte*) vertexData);
verticesBuffer->append(sizeof(GLfloat) * vertices * NUM_COORDS_PER_VERTEX, (gpu::Byte*) vertexData);
delete[] vertexData;
#ifdef WANT_DEBUG
@ -133,7 +133,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
|| (!registered && !_sphereIndices.contains(slicesStacksKey))) {
if (registered && _registeredSphereIndices.contains(id)) {
_registeredSphereIndices[id].clear();
_registeredSphereIndices[id].reset();
#ifdef WANT_DEBUG
qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED INDICES BUFFER";
#endif
@ -196,7 +196,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
indexCount += 3;
}
indicesBuffer->append(sizeof(GLushort) * indices, (gpu::Buffer::Byte*) indexData);
indicesBuffer->append(sizeof(GLushort) * indices, (gpu::Byte*) indexData);
delete[] indexData;
#ifdef WANT_DEBUG
@ -219,7 +219,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
|| (!registered && !_sphereColors.contains(colorKey))) {
if (registered && _registeredSphereColors.contains(id)) {
_registeredSphereColors[id].clear();
_registeredSphereColors[id].reset();
#ifdef WANT_DEBUG
qCDebug(renderutils) << "renderSphere()... RELEASING REGISTERED COLORS BUFFER";
#endif
@ -245,7 +245,7 @@ void GeometryCache::renderSphere(float radius, int slices, int stacks, const glm
*(colorDataAt++) = compactColor;
}
colorBuffer->append(sizeof(int) * vertices, (gpu::Buffer::Byte*) colorData);
colorBuffer->append(sizeof(int) * vertices, (gpu::Byte*) colorData);
delete[] colorData;
#ifdef WANT_DEBUG
@ -432,7 +432,7 @@ void GeometryCache::renderGrid(int xDivisions, int yDivisions, const glm::vec4&
*(vertex++) = y;
}
verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Buffer::Byte*) vertexData);
verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Byte*) vertexData);
delete[] vertexData;
_gridBuffers[key] = verticesBuffer;
@ -454,7 +454,7 @@ void GeometryCache::renderGrid(int xDivisions, int yDivisions, const glm::vec4&
*(colorDataAt++) = compactColor;
}
colorBuffer->append(sizeof(int) * vertices, (gpu::Buffer::Byte*) colorData);
colorBuffer->append(sizeof(int) * vertices, (gpu::Byte*) colorData);
delete[] colorData;
}
gpu::BufferPointer verticesBuffer = _gridBuffers[key];
@ -537,7 +537,7 @@ void GeometryCache::renderGrid(int x, int y, int width, int height, int rows, in
tx += dx;
}
verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Buffer::Byte*) vertexData);
verticesBuffer->append(sizeof(GLfloat) * vertices * 2, (gpu::Byte*) vertexData);
delete[] vertexData;
if (registered) {
@ -564,7 +564,7 @@ void GeometryCache::renderGrid(int x, int y, int width, int height, int rows, in
*(colorDataAt++) = compactColor;
}
colorBuffer->append(sizeof(int) * vertices, (gpu::Buffer::Byte*) colorData);
colorBuffer->append(sizeof(int) * vertices, (gpu::Byte*) colorData);
delete[] colorData;
}
gpu::BufferPointer verticesBuffer = registered ? _registeredAlternateGridBuffers[id] : _alternateGridBuffers[key];
@ -648,8 +648,8 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec2>& points, con
*(colorDataAt++) = compactColor;
}
details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Buffer::Byte*) vertexData);
details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Buffer::Byte*) colorData);
details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
delete[] vertexData;
delete[] colorData;
@ -711,8 +711,8 @@ void GeometryCache::updateVertices(int id, const QVector<glm::vec3>& points, con
*(colorDataAt++) = compactColor;
}
details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Buffer::Byte*) vertexData);
details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Buffer::Byte*) colorData);
details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
delete[] vertexData;
delete[] colorData;
@ -793,7 +793,7 @@ void GeometryCache::renderSolidCube(float size, const glm::vec4& color) {
*(vertex++) = *cannonicalNormal++;
}
verticesBuffer->append(sizeof(GLfloat) * vertexPoints * 2, (gpu::Buffer::Byte*) vertexData);
verticesBuffer->append(sizeof(GLfloat) * vertexPoints * 2, (gpu::Byte*) vertexData);
}
if (!_solidCubeIndexBuffer) {
@ -808,7 +808,7 @@ void GeometryCache::renderSolidCube(float size, const glm::vec4& color) {
gpu::BufferPointer indexBuffer(new gpu::Buffer());
_solidCubeIndexBuffer = indexBuffer;
_solidCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Buffer::Byte*) cannonicalIndices);
_solidCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices);
}
if (!_solidCubeColors.contains(colorKey)) {
@ -827,7 +827,7 @@ void GeometryCache::renderSolidCube(float size, const glm::vec4& color) {
compactColor, compactColor, compactColor, compactColor,
compactColor, compactColor, compactColor, compactColor };
colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
}
gpu::BufferPointer verticesBuffer = _solidCubeVerticies[size];
gpu::BufferPointer colorBuffer = _solidCubeColors[colorKey];
@ -891,7 +891,7 @@ void GeometryCache::renderWireCube(float size, const glm::vec4& color) {
vertex[i] = cannonicalVertices[i] * halfSize;
}
verticesBuffer->append(sizeof(GLfloat) * vertexPoints, (gpu::Buffer::Byte*) vertexData); // I'm skeptical that this is right
verticesBuffer->append(sizeof(GLfloat) * vertexPoints, (gpu::Byte*) vertexData); // I'm skeptical that this is right
}
if (!_wireCubeIndexBuffer) {
@ -904,7 +904,7 @@ void GeometryCache::renderWireCube(float size, const glm::vec4& color) {
gpu::BufferPointer indexBuffer(new gpu::Buffer());
_wireCubeIndexBuffer = indexBuffer;
_wireCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Buffer::Byte*) cannonicalIndices);
_wireCubeIndexBuffer->append(sizeof(cannonicalIndices), (gpu::Byte*) cannonicalIndices);
}
if (!_cubeColors.contains(colorKey)) {
@ -919,7 +919,7 @@ void GeometryCache::renderWireCube(float size, const glm::vec4& color) {
int colors[NUM_COLOR_SCALARS_PER_CUBE] = { compactColor, compactColor, compactColor, compactColor,
compactColor, compactColor, compactColor, compactColor };
colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
}
gpu::BufferPointer verticesBuffer = _cubeVerticies[size];
gpu::BufferPointer colorBuffer = _cubeColors[colorKey];
@ -1037,8 +1037,8 @@ void GeometryCache::renderBevelCornersRect(int x, int y, int width, int height,
compactColor, compactColor, compactColor, compactColor };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
delete[] vertexBuffer;
}
@ -1119,8 +1119,8 @@ void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxC
int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
}
gpu::Batch batch;
@ -1208,8 +1208,8 @@ void GeometryCache::renderQuad(const glm::vec2& minCorner, const glm::vec2& maxC
int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
}
gpu::Batch batch;
@ -1294,8 +1294,8 @@ void GeometryCache::renderQuad(const glm::vec3& minCorner, const glm::vec3& maxC
int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
}
gpu::Batch batch;
@ -1396,8 +1396,8 @@ void GeometryCache::renderQuad(const glm::vec3& topLeft, const glm::vec3& bottom
((int(color.w * 255.0f) & 0xFF) << 24);
int colors[NUM_COLOR_SCALARS_PER_QUAD] = { compactColor, compactColor, compactColor, compactColor };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
}
gpu::Batch batch;
@ -1510,8 +1510,8 @@ void GeometryCache::renderDashedLine(const glm::vec3& start, const glm::vec3& en
*(vertex++) = end.z;
*(colorDataAt++) = compactColor;
details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Buffer::Byte*) vertexData);
details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Buffer::Byte*) colorData);
details.verticesBuffer->append(sizeof(GLfloat) * FLOATS_PER_VERTEX * details.vertices, (gpu::Byte*) vertexData);
details.colorBuffer->append(sizeof(int) * details.vertices, (gpu::Byte*) colorData);
delete[] vertexData;
delete[] colorData;
@ -1581,10 +1581,10 @@ GeometryCache::BatchItemDetails::~BatchItemDetails() {
void GeometryCache::BatchItemDetails::clear() {
isCreated = false;
verticesBuffer.clear();
colorBuffer.clear();
streamFormat.clear();
stream.clear();
verticesBuffer.reset();
colorBuffer.reset();
streamFormat.reset();
stream.reset();
}
void GeometryCache::renderLine(const glm::vec3& p1, const glm::vec3& p2,
@ -1653,8 +1653,8 @@ void GeometryCache::renderLine(const glm::vec3& p1, const glm::vec3& p2,
const int NUM_COLOR_SCALARS = 2;
int colors[NUM_COLOR_SCALARS] = { compactColor1, compactColor2 };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
#ifdef WANT_DEBUG
if (id == UNKNOWN_ID) {
@ -1745,8 +1745,8 @@ void GeometryCache::renderLine(const glm::vec2& p1, const glm::vec2& p2,
const int NUM_COLOR_SCALARS = 2;
int colors[NUM_COLOR_SCALARS] = { compactColor1, compactColor2 };
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Buffer::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Buffer::Byte*) colors);
details.verticesBuffer->append(sizeof(vertexBuffer), (gpu::Byte*) vertexBuffer);
details.colorBuffer->append(sizeof(colors), (gpu::Byte*) colors);
#ifdef WANT_DEBUG
if (id == UNKNOWN_ID) {
@ -2234,10 +2234,10 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
int offset = 0;
foreach(const FBXMeshPart& part, mesh.parts) {
networkMesh._indexBuffer->setSubData(offset, part.quadIndices.size() * sizeof(int),
(gpu::Resource::Byte*) part.quadIndices.constData());
(gpu::Byte*) part.quadIndices.constData());
offset += part.quadIndices.size() * sizeof(int);
networkMesh._indexBuffer->setSubData(offset, part.triangleIndices.size() * sizeof(int),
(gpu::Resource::Byte*) part.triangleIndices.constData());
(gpu::Byte*) part.triangleIndices.constData());
offset += part.triangleIndices.size() * sizeof(int);
}
}
@ -2256,19 +2256,19 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
networkMesh._vertexBuffer->resize(clusterWeightsOffset + mesh.clusterWeights.size() * sizeof(glm::vec4));
networkMesh._vertexBuffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.vertices.constData());
networkMesh._vertexBuffer->setSubData(normalsOffset, mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.normals.constData());
networkMesh._vertexBuffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.vertices.constData());
networkMesh._vertexBuffer->setSubData(normalsOffset, mesh.normals.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.normals.constData());
networkMesh._vertexBuffer->setSubData(tangentsOffset,
mesh.tangents.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.tangents.constData());
networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.colors.constData());
mesh.tangents.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.tangents.constData());
networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.colors.constData());
networkMesh._vertexBuffer->setSubData(texCoordsOffset,
mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Resource::Byte*) mesh.texCoords.constData());
mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Byte*) mesh.texCoords.constData());
networkMesh._vertexBuffer->setSubData(texCoords1Offset,
mesh.texCoords1.size() * sizeof(glm::vec2), (gpu::Resource::Byte*) mesh.texCoords1.constData());
mesh.texCoords1.size() * sizeof(glm::vec2), (gpu::Byte*) mesh.texCoords1.constData());
networkMesh._vertexBuffer->setSubData(clusterIndicesOffset,
mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterIndices.constData());
mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterIndices.constData());
networkMesh._vertexBuffer->setSubData(clusterWeightsOffset,
mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Resource::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
networkMesh._vertexStream = gpu::BufferStreamPointer(new gpu::BufferStream());
@ -2304,14 +2304,14 @@ void NetworkGeometry::setGeometry(const FBXGeometry& geometry) {
int clusterWeightsOffset = clusterIndicesOffset + mesh.clusterIndices.size() * sizeof(glm::vec4);
networkMesh._vertexBuffer->resize(clusterWeightsOffset + mesh.clusterWeights.size() * sizeof(glm::vec4));
networkMesh._vertexBuffer->setSubData(0, mesh.tangents.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.tangents.constData());
networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.colors.constData());
networkMesh._vertexBuffer->setSubData(0, mesh.tangents.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.tangents.constData());
networkMesh._vertexBuffer->setSubData(colorsOffset, mesh.colors.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.colors.constData());
networkMesh._vertexBuffer->setSubData(texCoordsOffset,
mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Resource::Byte*) mesh.texCoords.constData());
mesh.texCoords.size() * sizeof(glm::vec2), (gpu::Byte*) mesh.texCoords.constData());
networkMesh._vertexBuffer->setSubData(clusterIndicesOffset,
mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterIndices.constData());
mesh.clusterIndices.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterIndices.constData());
networkMesh._vertexBuffer->setSubData(clusterWeightsOffset,
mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Resource::Byte*) mesh.clusterWeights.constData());
mesh.clusterWeights.size() * sizeof(glm::vec4), (gpu::Byte*) mesh.clusterWeights.constData());
networkMesh._vertexStream = gpu::BufferStreamPointer(new gpu::BufferStream());
if (mesh.tangents.size()) networkMesh._vertexStream->addBuffer(networkMesh._vertexBuffer, 0, sizeof(glm::vec3));

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

@ -451,9 +451,9 @@ bool Model::updateGeometry() {
gpu::BufferPointer buffer(new gpu::Buffer());
if (!mesh.blendshapes.isEmpty()) {
buffer->resize((mesh.vertices.size() + mesh.normals.size()) * sizeof(glm::vec3));
buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.vertices.constData());
buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.vertices.constData());
buffer->setSubData(mesh.vertices.size() * sizeof(glm::vec3),
mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) mesh.normals.constData());
mesh.normals.size() * sizeof(glm::vec3), (gpu::Byte*) mesh.normals.constData());
}
_blendedVertexBuffers.push_back(buffer);
}
@ -1732,9 +1732,9 @@ void Model::setBlendedVertices(int blendNumber, const QWeakPointer<NetworkGeomet
}
gpu::BufferPointer& buffer = _blendedVertexBuffers[i];
buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) vertices.constData() + index*sizeof(glm::vec3));
buffer->setSubData(0, mesh.vertices.size() * sizeof(glm::vec3), (gpu::Byte*) vertices.constData() + index*sizeof(glm::vec3));
buffer->setSubData(mesh.vertices.size() * sizeof(glm::vec3),
mesh.normals.size() * sizeof(glm::vec3), (gpu::Resource::Byte*) normals.constData() + index*sizeof(glm::vec3));
mesh.normals.size() * sizeof(glm::vec3), (gpu::Byte*) normals.constData() + index*sizeof(glm::vec3));
index += mesh.vertices.size();
}

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

@ -89,7 +89,7 @@ const int permutation[256] =
#define USE_CHRIS_NOISE 1
const gpu::TexturePointer& TextureCache::getPermutationNormalTexture() {
if (_permutationNormalTexture.isNull()) {
if (!_permutationNormalTexture) {
// the first line consists of random permutation offsets
unsigned char data[256 * 2 * 3];
@ -133,7 +133,7 @@ static void loadSingleColorTexture(const unsigned char* color) {
*/
const gpu::TexturePointer& TextureCache::getWhiteTexture() {
if (_whiteTexture.isNull()) {
if (!_whiteTexture) {
_whiteTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA), 1, 1));
_whiteTexture->assignStoredMip(0, _whiteTexture->getTexelFormat(), sizeof(OPAQUE_WHITE), OPAQUE_WHITE);
}
@ -141,7 +141,7 @@ const gpu::TexturePointer& TextureCache::getWhiteTexture() {
}
const gpu::TexturePointer& TextureCache::getBlueTexture() {
if (_blueTexture.isNull()) {
if (!_blueTexture) {
_blueTexture = gpu::TexturePointer(gpu::Texture::create2D(gpu::Element(gpu::VEC4, gpu::UINT8, gpu::RGBA), 1, 1));
_blueTexture->assignStoredMip(0, _blueTexture->getTexelFormat(), sizeof(OPAQUE_BLUE), OPAQUE_BLUE);
}