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

first take at the Transform encapsulating a transform matrix

Browse source
This commit is contained in:
Sam Gateau 2014-11-06 09:55:34 -08:00
parent 2b27af51f1
commit 67535a386c
5 changed files with 183 additions and 23 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

19
interface/src/gpu/Batch.cpp
View file

@ -156,3 +156,22 @@ void Batch::setIndexBuffer(Type type, const BufferPointer& buffer, Offset offset
_params.push_back(_buffers.cache(buffer));
_params.push_back(type);
}
void Batch::setModelTransform(const TransformPointer& model) {
ADD_COMMAND(setModelTransform);
_params.push_back(_transforms.cache(model));
}
void Batch::setViewTransform(const TransformPointer& view) {
ADD_COMMAND(setViewTransform);
_params.push_back(_transforms.cache(view));
}
void Batch::setProjectionTransform(const TransformPointer& proj) {
ADD_COMMAND(setProjectionTransform);
_params.push_back(_transforms.cache(proj));
}

22
interface/src/gpu/Batch.h
View file

@ -16,9 +16,8 @@
#include <vector>
#include "gpu/Format.h"
#include "gpu/Resource.h"
#include "gpu/Stream.h"
#include "gpu/Transform.h"
#if defined(NSIGHT_FOUND)
#include "nvToolsExt.h"
@ -60,11 +59,16 @@ public:
void clear();
// Drawcalls
void draw(Primitive primitiveType, uint32 numVertices, uint32 startVertex = 0);
void drawIndexed(Primitive primitiveType, uint32 nbIndices, uint32 startIndex = 0);
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);
// Input Stage
// InputFormat
// InputBuffers
// IndexBuffer
void setInputFormat(const Stream::FormatPointer& format);
void setInputStream(Slot startChannel, const BufferStream& stream); // not a command, just unroll into a loop of setInputBuffer
@ -72,6 +76,11 @@ public:
void setIndexBuffer(Type type, const BufferPointer& buffer, Offset offset);
// Transform Stage
void setModelTransform(const TransformPointer& model);
void setViewTransform(const TransformPointer& view);
void setProjectionTransform(const TransformPointer& proj);
// 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
@ -138,11 +147,13 @@ public:
COMMAND_drawIndexedInstanced,
COMMAND_setInputFormat,
COMMAND_setInputBuffer,
COMMAND_setIndexBuffer,
COMMAND_setModelTransform,
COMMAND_setViewTransform,
COMMAND_setProjectionTransform,
// 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
@ -265,6 +276,7 @@ public:
typedef Cache<Buffer>::Vector BufferCaches;
typedef Cache<Stream::Format>::Vector StreamFormatCaches;
typedef Cache<Transform>::Vector TransformCaches;
typedef unsigned char Byte;
typedef std::vector<Byte> Bytes;
@ -299,6 +311,8 @@ public:
BufferCaches _buffers;
StreamFormatCaches _streamFormats;
TransformCaches _transforms;
Bytes _data;
protected:
};

76
interface/src/gpu/GLBackend.cpp
View file

@ -24,11 +24,13 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
(&::gpu::GLBackend::do_drawIndexedInstanced),
(&::gpu::GLBackend::do_setInputFormat),
(&::gpu::GLBackend::do_setInputBuffer),
(&::gpu::GLBackend::do_setIndexBuffer),
(&::gpu::GLBackend::do_setModelTransform),
(&::gpu::GLBackend::do_setViewTransform),
(&::gpu::GLBackend::do_setProjectionTransform),
(&::gpu::GLBackend::do_glEnable),
(&::gpu::GLBackend::do_glDisable),
@ -111,7 +113,6 @@ static const GLenum _elementTypeToGLType[NUM_TYPES]= {
GLBackend::GLBackend() :
_inputFormat(0),
_inputAttributeActivation(0),
_needInputFormatUpdate(true),
@ -122,7 +123,10 @@ GLBackend::GLBackend() :
_inputBufferStrides(_inputBuffersState.size(), 0),
_indexBuffer(0),
_indexBufferOffset(0)
_indexBufferOffset(0),
_transform()
{
}
@ -183,6 +187,7 @@ void GLBackend::checkGLError() {
void GLBackend::do_draw(Batch& batch, uint32 paramOffset) {
updateInput();
updateTransform();
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
GLenum mode = _primitiveToGLmode[primitiveType];
@ -195,6 +200,7 @@ void GLBackend::do_draw(Batch& batch, uint32 paramOffset) {
void GLBackend::do_drawIndexed(Batch& batch, uint32 paramOffset) {
updateInput();
updateTransform();
Primitive primitiveType = (Primitive)batch._params[paramOffset + 2]._uint;
GLenum mode = _primitiveToGLmode[primitiveType];
@ -424,6 +430,68 @@ void GLBackend::do_setIndexBuffer(Batch& batch, uint32 paramOffset) {
CHECK_GL_ERROR();
}
// Transform Stage
void GLBackend::do_setModelTransform(Batch& batch, uint32 paramOffset) {
TransformPointer modelTransform = batch._transforms.get(batch._params[paramOffset]._uint);
if (modelTransform != _transform._model) {
_transform._invalidModel = true;
}
}
void GLBackend::do_setViewTransform(Batch& batch, uint32 paramOffset) {
TransformPointer viewTransform = batch._transforms.get(batch._params[paramOffset]._uint);
if (viewTransform != _transform._view) {
_transform._invalidView = true;
}
}
void GLBackend::do_setProjectionTransform(Batch& batch, uint32 paramOffset) {
TransformPointer projectionTransform = batch._transforms.get(batch._params[paramOffset]._uint);
if (projectionTransform != _transform._projection) {
_transform._invalidProj = true;
}
}
void GLBackend::updateTransform() {
if (_transform._invalidProj) {
if (_transform._lastMode != GL_PROJECTION) {
glMatrixMode(GL_PROJECTION);
_transform._lastMode = GL_PROJECTION;
}
CHECK_GL_ERROR();
}
if (_transform._invalidModel || _transform._invalidView) {
if (_transform._lastMode != GL_MODELVIEW) {
glMatrixMode(GL_MODELVIEW);
_transform._lastMode = GL_MODELVIEW;
}
if (!_transform._model.isNull()) {
if (!_transform._view.isNull()) {
Transform::Mat4 mv = _transform._view->getMatrix() * _transform._model->getMatrix();
glLoadMatrixf((const GLfloat*) &mv[0]);
} else {
glLoadMatrixf((const GLfloat*) &_transform._model->getMatrix());
}
} else {
if (!_transform._view.isNull()) {
glLoadMatrixf((const GLfloat*) & _transform._view->getMatrix());
} else {
// glLoadIdentity();
}
}
CHECK_GL_ERROR();
_transform._invalidModel = false;
_transform._invalidView = false;
}
}
// 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

46
interface/src/gpu/GLBackend.h
View file

@ -52,11 +52,22 @@ public:
protected:
// Draw Stage
void do_draw(Batch& batch, uint32 paramOffset);
void do_drawIndexed(Batch& batch, uint32 paramOffset);
void do_drawInstanced(Batch& batch, uint32 paramOffset);
void do_drawIndexedInstanced(Batch& batch, uint32 paramOffset);
// Input Stage
void do_setInputFormat(Batch& batch, uint32 paramOffset);
void do_setInputBuffer(Batch& batch, uint32 paramOffset);
void do_setIndexBuffer(Batch& batch, uint32 paramOffset);
void updateInput();
bool _needInputFormatUpdate;
Stream::FormatPointer _inputFormat;
typedef std::bitset<MAX_NUM_INPUT_BUFFERS> InputBuffersState;
InputBuffersState _inputBuffersState;
Buffers _inputBuffers;
Offsets _inputBufferOffsets;
Offsets _inputBufferStrides;
@ -68,18 +79,31 @@ protected:
typedef std::bitset<MAX_NUM_ATTRIBUTES> InputActivationCache;
InputActivationCache _inputAttributeActivation;
void do_draw(Batch& batch, uint32 paramOffset);
void do_drawIndexed(Batch& batch, uint32 paramOffset);
void do_drawInstanced(Batch& batch, uint32 paramOffset);
void do_drawIndexedInstanced(Batch& batch, uint32 paramOffset);
// Transform Stage
void do_setModelTransform(Batch& batch, uint32 paramOffset);
void do_setViewTransform(Batch& batch, uint32 paramOffset);
void do_setProjectionTransform(Batch& batch, uint32 paramOffset);
void updateInput();
void do_setInputFormat(Batch& batch, uint32 paramOffset);
void do_setInputBuffer(Batch& batch, uint32 paramOffset);
void updateTransform();
struct TransformStageState {
TransformPointer _model;
TransformPointer _view;
TransformPointer _projection;
bool _invalidModel;
bool _invalidView;
bool _invalidProj;
void do_setVertexBuffer(Batch& batch, uint32 paramOffset);
void do_setIndexBuffer(Batch& batch, uint32 paramOffset);
GLenum _lastMode;
TransformStageState() :
_model(0),
_view(0),
_projection(0),
_invalidModel(true),
_invalidView(true),
_invalidProj(true),
_lastMode(GL_TEXTURE) {}
} _transform;
// 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

43
interface/src/renderer/Model.cpp
View file

@ -556,6 +556,16 @@ bool Model::render(float alpha, RenderMode mode, RenderArgs* args) {
// Let's introduce a gpu::Batch to capture all the calls to the graphics api
gpu::Batch batch;
// Capture the view matrix once for the rendering of this model
gpu::TransformPointer viewTransform(new gpu::Transform());
glm::mat4 v = Application::getInstance()->getUntranslatedViewMatrix();
viewTransform->evalFromRawMatrix(v);
glm::mat4 v2 = viewTransform->getMatrix();
viewTransform->localTranslate(Application::getInstance()->getViewMatrixTranslation());
// batch.setViewTransform(viewTransform);
GLBATCH(glDisable)(GL_COLOR_MATERIAL);
@ -1853,17 +1863,42 @@ int Model::renderMeshes(gpu::Batch& batch, RenderMode mode, bool translucent, fl
GLBATCH(glPushMatrix)();
//Application::getInstance()->loadTranslatedViewMatrix(_translation);
GLBATCH(glLoadMatrixf)((const GLfloat*)&Application::getInstance()->getUntranslatedViewMatrix());
// GLBATCH(glLoadMatrixf)((const GLfloat*)&Application::getInstance()->getUntranslatedViewMatrix());
// Capture the view matrix once for the rendering of this model
glm::mat4 v = Application::getInstance()->getUntranslatedViewMatrix();
gpu::TransformPointer viewTransform(new gpu::Transform());
viewTransform->evalFromRawMatrix(v);
glm::vec3 viewMatTranslation = Application::getInstance()->getViewMatrixTranslation();
GLBATCH(glTranslatef)(_translation.x + viewMatTranslation.x, _translation.y + viewMatTranslation.y,
_translation.z + viewMatTranslation.z);
viewTransform->localTranslate(viewMatTranslation + _translation);
glm::mat4 v2 = viewTransform->getMatrix();
// batch.setViewTransform(viewTransform);
// GLBATCH(glTranslatef)(_translation.x + viewMatTranslation.x, _translation.y + viewMatTranslation.y,
// _translation.z + viewMatTranslation.z);
const MeshState& state = _meshStates.at(i);
if (state.clusterMatrices.size() > 1) {
GLBATCH(glUniformMatrix4fv)(skinLocations->clusterMatrices, state.clusterMatrices.size(), false,
(const float*)state.clusterMatrices.constData());
// gpu::TransformPointer modelTransform(new gpu::Transform());
// modelTransform->setTranslation(_translation);
// batch.setModelTransform(viewTransform);
// gpu::TransformPointer mv(new gpu::Transform());
// gpu::Transform::mult(*mv, *viewTransform, *modelTransform);
batch.setModelTransform(viewTransform);
} else {
GLBATCH(glMultMatrixf)((const GLfloat*)&state.clusterMatrices[0]);
// GLBATCH(glMultMatrixf)((const GLfloat*)&state.clusterMatrices[0]);
gpu::TransformPointer modelTransform(new gpu::Transform(state.clusterMatrices[0]));
gpu::TransformPointer mv(new gpu::Transform());
gpu::Transform::mult(*mv, *viewTransform, *modelTransform);
batch.setModelTransform(mv);
}
if (mesh.blendshapes.isEmpty()) {