Mirrors/overte-AleziaKurdis
3
0
Fork 0
mirror of https://github.com/AleziaKurdis/overte.git synced 2025-04-06 16:53:47 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #845 from HifiExperiments/colorBleed

Browse source 
Clean up GeometryCache and remove _glColor4f
This commit is contained in:
ksuprynowicz 2024-03-15 03:07:08 +01:00 committed by GitHub
commit 3d5afbdd31
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
17 changed files with 316 additions and 866 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

13
libraries/entities-renderer/src/RenderableMaterialEntityItem.cpp
View file

@ -337,21 +337,26 @@ void MaterialEntityRenderer::doRender(RenderArgs* args) {
}
// Draw!
DependencyManager::get<GeometryCache>()->renderSphere(batch);
const uint32_t compactColor = 0xFFFFFFFF;
_colorBuffer->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
DependencyManager::get<GeometryCache>()->renderShape(batch, GeometryCache::Shape::Sphere, _colorBuffer);
} else {
auto proceduralDrawMaterial = std::static_pointer_cast<graphics::ProceduralMaterial>(drawMaterial);
glm::vec4 outColor = glm::vec4(drawMaterial->getAlbedo(), drawMaterial->getOpacity());
outColor = proceduralDrawMaterial->getColor(outColor);
proceduralDrawMaterial->prepare(batch, transform.getTranslation(), transform.getScale(),
transform.getRotation(), _created, ProceduralProgramKey(outColor.a < 1.0f));
const uint32_t compactColor = GeometryCache::toCompactColor(glm::vec4(outColor));
_colorBuffer->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
if (render::ShapeKey(args->_globalShapeKey).isWireframe() || _primitiveMode == PrimitiveMode::LINES) {
DependencyManager::get<GeometryCache>()->renderWireSphere(batch, outColor);
DependencyManager::get<GeometryCache>()->renderWireShape(batch, GeometryCache::Shape::Sphere, _colorBuffer);
} else {
DependencyManager::get<GeometryCache>()->renderSphere(batch, outColor);
DependencyManager::get<GeometryCache>()->renderShape(batch, GeometryCache::Shape::Sphere, _colorBuffer);
}
}
args->_details._trianglesRendered += (int)DependencyManager::get<GeometryCache>()->getSphereTriangleCount();
args->_details._trianglesRendered += (int)DependencyManager::get<GeometryCache>()->getShapeTriangleCount(GeometryCache::Shape::Sphere);
}
void MaterialEntityRenderer::setCurrentMaterialName(const std::string& currentMaterialName) {

1
libraries/entities-renderer/src/RenderableMaterialEntityItem.h
View file

@ -67,6 +67,7 @@ private:
std::shared_ptr<NetworkMaterial> _appliedMaterial;
std::string _currentMaterialName;
gpu::BufferPointer _colorBuffer { std::make_shared<gpu::Buffer>() };
};
} }

16
libraries/entities-renderer/src/RenderableShapeEntityItem.cpp
View file

@ -131,10 +131,12 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) {
procedural->prepare(batch, transform.getTranslation(), transform.getScale(), transform.getRotation(), _created, ProceduralProgramKey(outColor.a < 1.0f));
});
const uint32_t compactColor = GeometryCache::toCompactColor(glm::vec4(outColor));
_colorBuffer->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
if (wireframe) {
geometryCache->renderWireShape(batch, geometryShape, outColor);
geometryCache->renderWireShape(batch, geometryShape, _colorBuffer);
} else {
geometryCache->renderShape(batch, geometryShape, outColor);
geometryCache->renderShape(batch, geometryShape, _colorBuffer);
}
} else if (pipelineType == Pipeline::SIMPLE) {
// FIXME, support instanced multi-shape rendering using multidraw indirect
@ -149,10 +151,12 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) {
geometryCache->renderSolidShapeInstance(args, batch, geometryShape, outColor, pipeline);
}
} else {
const uint32_t compactColor = GeometryCache::toCompactColor(glm::vec4(outColor));
_colorBuffer->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
if (wireframe) {
geometryCache->renderWireShape(batch, geometryShape, outColor);
geometryCache->renderWireShape(batch, geometryShape, _colorBuffer);
} else {
geometryCache->renderShape(batch, geometryShape, outColor);
geometryCache->renderShape(batch, geometryShape, _colorBuffer);
}
}
} else {
@ -160,7 +164,9 @@ void ShapeEntityRenderer::doRender(RenderArgs* args) {
args->_details._materialSwitches++;
}
geometryCache->renderShape(batch, geometryShape);
const uint32_t compactColor = GeometryCache::toCompactColor(glm::vec4(outColor));
_colorBuffer->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
geometryCache->renderShape(batch, geometryShape, _colorBuffer);
}
const auto triCount = geometryCache->getShapeTriangleCount(geometryShape);

2
libraries/entities-renderer/src/RenderableShapeEntityItem.h
View file

@ -42,6 +42,8 @@ private:
std::shared_ptr<graphics::ProceduralMaterial> _material { std::make_shared<graphics::ProceduralMaterial>() };
glm::vec3 _color { NAN };
float _alpha { NAN };
gpu::BufferPointer _colorBuffer { std::make_shared<gpu::Buffer>() };
};
} }

18
libraries/gpu-gl-common/src/gpu/gl/GLBackend.cpp
View file

@ -100,8 +100,6 @@ GLBackend::CommandCall GLBackend::_commandCalls[Batch::NUM_COMMANDS] =
(&::gpu::gl::GLBackend::do_glUniformMatrix3fv),
(&::gpu::gl::GLBackend::do_glUniformMatrix4fv),
(&::gpu::gl::GLBackend::do_glColor4f),
(&::gpu::gl::GLBackend::do_pushProfileRange),
(&::gpu::gl::GLBackend::do_popProfileRange),
};
@ -838,22 +836,6 @@ void GLBackend::do_glUniformMatrix4fv(const Batch& batch, size_t paramOffset) {
(void)CHECK_GL_ERROR();
}
void GLBackend::do_glColor4f(const Batch& batch, size_t paramOffset) {
glm::vec4 newColor(
batch._params[paramOffset + 3]._float,
batch._params[paramOffset + 2]._float,
batch._params[paramOffset + 1]._float,
batch._params[paramOffset + 0]._float);
if (_input._colorAttribute != newColor) {
_input._colorAttribute = newColor;
glVertexAttrib4fv(gpu::Stream::COLOR, &_input._colorAttribute.r);
_input._hasColorAttribute = true;
}
(void)CHECK_GL_ERROR();
}
void GLBackend::releaseBuffer(GLuint id, Size size) const {
Lock lock(_trashMutex);
_currentFrameTrash.buffersTrash.push_back({ id, size });

6
libraries/gpu-gl-common/src/gpu/gl/GLBackend.h
View file

@ -241,8 +241,6 @@ public:
virtual void do_glUniformMatrix3fv(const Batch& batch, size_t paramOffset) final;
virtual void do_glUniformMatrix4fv(const Batch& batch, size_t paramOffset) final;
virtual void do_glColor4f(const Batch& batch, size_t paramOffset) final;
// The State setters called by the GLState::Commands when a new state is assigned
virtual void do_setStateFillMode(int32 mode) final;
virtual void do_setStateCullMode(int32 mode) final;
@ -350,8 +348,6 @@ protected:
struct InputStageState {
bool _invalidFormat { true };
bool _lastUpdateStereoState { false };
bool _hasColorAttribute { false };
bool _hadColorAttribute { false };
FormatReference _format { GPU_REFERENCE_INIT_VALUE };
std::string _formatKey;
@ -368,8 +364,6 @@ protected:
std::array<Offset, MAX_NUM_INPUT_BUFFERS> _bufferStrides;
std::array<GLuint, MAX_NUM_INPUT_BUFFERS> _bufferVBOs;
glm::vec4 _colorAttribute { 1.0f };
BufferReference _indexBuffer;
Offset _indexBufferOffset { 0 };
Type _indexBufferType { UINT32 };

16
libraries/gpu-gl-common/src/gpu/gl/GLBackendInput.cpp
View file

@ -103,9 +103,6 @@ void GLBackend::resetInputStage() {
reset(_input._format);
_input._formatKey.clear();
_input._invalidFormat = false;
_input._hasColorAttribute = false;
_input._hadColorAttribute = false;
_input._colorAttribute = vec4(1.0f);
_input._attributeActivation.reset();
for (uint32_t i = 0; i < _input._buffers.size(); i++) {
@ -163,8 +160,6 @@ void GLBackend::updateInput() {
#endif
_input._lastUpdateStereoState = isStereoNow;
bool hasColorAttribute = _input._hasColorAttribute;
if (_input._invalidFormat) {
InputStageState::ActivationCache newActivation;
@ -194,8 +189,6 @@ void GLBackend::updateInput() {
GLenum perLocationSize = attrib._element.getLocationSize();
hasColorAttribute |= slot == Stream::COLOR;
for (GLuint locNum = 0; locNum < locationCount; ++locNum) {
GLuint attriNum = (GLuint)(slot + locNum);
newActivation.set(attriNum);
@ -226,12 +219,6 @@ void GLBackend::updateInput() {
glVertexBindingDivisor(bufferChannelNum, frequency);
#endif
}
if (!hasColorAttribute && _input._hadColorAttribute) {
// The previous input stage had a color attribute but this one doesn't, so reset the color to pure white.
_input._colorAttribute = glm::vec4(1.0f);
glVertexAttrib4fv(Stream::COLOR, &_input._colorAttribute.r);
}
}
// Manage Activation what was and what is expected now
@ -253,9 +240,6 @@ void GLBackend::updateInput() {
_stats._ISNumFormatChanges++;
}
_input._hadColorAttribute = hasColorAttribute;
_input._hasColorAttribute = false;
if (_input._invalidBuffers.any()) {
auto vbo = _input._bufferVBOs.data();
auto offset = _input._bufferOffsets.data();

13
libraries/gpu-gl/src/gpu/gl41/GL41BackendInput.cpp
View file

@ -33,8 +33,6 @@ void GL41Backend::updateInput() {
#endif
_input._lastUpdateStereoState = isStereoNow;
bool hasColorAttribute = _input._hasColorAttribute;
if (_input._invalidFormat || _input._invalidBuffers.any()) {
auto format = acquire(_input._format);
@ -110,8 +108,6 @@ void GL41Backend::updateInput() {
uintptr_t pointer = (uintptr_t)(attrib._offset + offsets[bufferNum]);
GLboolean isNormalized = attrib._element.isNormalized();
hasColorAttribute |= slot == Stream::COLOR;
for (size_t locNum = 0; locNum < locationCount; ++locNum) {
if (attrib._element.isInteger()) {
glVertexAttribIPointer(slot + (GLuint)locNum, count, type, stride,
@ -131,17 +127,8 @@ void GL41Backend::updateInput() {
}
}
}
if (!hasColorAttribute && _input._hadColorAttribute) {
// The previous input stage had a color attribute but this one doesn't, so reset the color to pure white.
_input._colorAttribute = glm::vec4(1.0f);
glVertexAttrib4fv(Stream::COLOR, &_input._colorAttribute.r);
}
}
// everything format related should be in sync now
_input._invalidFormat = false;
}
_input._hadColorAttribute = hasColorAttribute;
_input._hasColorAttribute = false;
}

13
libraries/gpu-gl/src/gpu/gl45/GL45BackendInput.cpp
View file

@ -35,8 +35,6 @@ void GL45Backend::updateInput() {
#endif
_input._lastUpdateStereoState = isStereoNow;
bool hasColorAttribute = _input._hasColorAttribute;
if (_input._invalidFormat) {
InputStageState::ActivationCache newActivation;
@ -66,8 +64,6 @@ void GL45Backend::updateInput() {
GLenum perLocationSize = attrib._element.getLocationSize();
hasColorAttribute |= slot == Stream::COLOR;
for (GLuint locNum = 0; locNum < locationCount; ++locNum) {
GLuint attriNum = (GLuint)(slot + locNum);
newActivation.set(attriNum);
@ -98,12 +94,6 @@ void GL45Backend::updateInput() {
glVertexBindingDivisor(bufferChannelNum, frequency);
#endif
}
if (!hasColorAttribute && _input._hadColorAttribute) {
// The previous input stage had a color attribute but this one doesn't, so reset the color to pure white.
_input._colorAttribute = glm::vec4(1.0f);
glVertexAttrib4fv(Stream::COLOR, &_input._colorAttribute.r);
}
}
// Manage Activation what was and what is expected now
@ -125,9 +115,6 @@ void GL45Backend::updateInput() {
_stats._ISNumFormatChanges++;
}
_input._hadColorAttribute = hasColorAttribute;
_input._hasColorAttribute = false;
if (_input._invalidBuffers.any()) {
auto vbo = _input._bufferVBOs.data();
auto offset = _input._bufferOffsets.data();

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

@ -687,15 +687,6 @@ void Batch::_glUniformMatrix4fv(int32 location, int count, uint8 transpose, cons
_params.emplace_back(location);
}
void Batch::_glColor4f(float red, float green, float blue, float alpha) {
ADD_COMMAND(glColor4f);
_params.emplace_back(alpha);
_params.emplace_back(blue);
_params.emplace_back(green);
_params.emplace_back(red);
}
void Batch::finishFrame(BufferUpdates& updates) {
PROFILE_RANGE(render_gpu, __FUNCTION__);

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

@ -287,8 +287,6 @@ public:
_glUniformMatrix3fv(location, 1, false, glm::value_ptr(v));
}
void _glColor4f(float red, float green, float blue, float alpha);
// Maybe useful but shoudln't be public. Please convince me otherwise
// Well porting to gles i need it...
void runLambda(std::function<void()> f);
@ -363,8 +361,6 @@ public:
COMMAND_glUniformMatrix3fv,
COMMAND_glUniformMatrix4fv,
COMMAND_glColor4f,
COMMAND_pushProfileRange,
COMMAND_popProfileRange,

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

@ -201,8 +201,6 @@ constexpr const char* COMMAND_NAMES[] = {
"glUniformMatrix3fv",
"glUniformMatrix4fv",
"glColor4f",
"pushProfileRange",
"popProfileRange",
};

18
libraries/graphics/src/graphics/Geometry.cpp
View file

@ -19,6 +19,8 @@ Mesh::Mesh() :
_vertexBuffer(gpu::Element(gpu::VEC3, gpu::FLOAT, gpu::XYZ)),
_indexBuffer(gpu::Element(gpu::SCALAR, gpu::UINT32, gpu::INDEX)),
_partBuffer(gpu::Element(gpu::VEC4, gpu::UINT32, gpu::PART)) {
const uint32_t compactColor = 0xFFFFFFFF;
_colorBuffer->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
}
Mesh::Mesh(const Mesh& mesh) :
@ -26,7 +28,8 @@ Mesh::Mesh(const Mesh& mesh) :
_vertexBuffer(mesh._vertexBuffer),
_attributeBuffers(mesh._attributeBuffers),
_indexBuffer(mesh._indexBuffer),
_partBuffer(mesh._partBuffer) {
_partBuffer(mesh._partBuffer),
_colorBuffer(mesh._colorBuffer) {
}
Mesh::~Mesh() {
@ -39,6 +42,13 @@ void Mesh::setVertexFormatAndStream(const gpu::Stream::FormatPointer& vf, const
auto attrib = _vertexFormat->getAttribute(gpu::Stream::POSITION);
_vertexBuffer = BufferView(vbs->getBuffers()[attrib._channel], vbs->getOffsets()[attrib._channel], vbs->getBuffers()[attrib._channel]->getSize(),
(gpu::uint16) vbs->getStrides()[attrib._channel], attrib._element);
// We require meshes to have a color attribute. If they don't, we default to white.
if (!_vertexFormat->hasAttribute(gpu::Stream::COLOR)) {
int channelNum = _vertexStream.getNumBuffers();
_vertexFormat->setAttribute(gpu::Stream::COLOR, channelNum, gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA), 0, gpu::Stream::PER_INSTANCE);
_vertexStream.addBuffer(_colorBuffer, 0, _vertexFormat->getChannels().at(channelNum)._stride);
}
}
void Mesh::setVertexBuffer(const BufferView& buffer) {
@ -98,6 +108,12 @@ void Mesh::evalVertexStream() {
_vertexStream.addBuffer(view._buffer, view._offset, stride);
channelNum++;
}
// We require meshes to have a color attribute. If they don't, we default to white.
if (!_vertexFormat->hasAttribute(gpu::Stream::COLOR)) {
_vertexFormat->setAttribute(gpu::Stream::COLOR, channelNum, gpu::Element(gpu::VEC4, gpu::NUINT8, gpu::RGBA), 0, gpu::Stream::PER_INSTANCE);
_vertexStream.addBuffer(_colorBuffer, 0, _vertexFormat->getChannels().at(channelNum)._stride);
}
}
void Mesh::setIndexBuffer(const BufferView& buffer) {

6
libraries/graphics/src/graphics/Geometry.h
View file

@ -15,6 +15,7 @@
#include <AABox.h>
#include <gpu/Forward.h>
#include <gpu/Resource.h>
#include <gpu/Stream.h>
@ -28,7 +29,6 @@ typedef glm::vec3 Vec3;
class Mesh;
using MeshPointer = std::shared_ptr< Mesh >;
class Mesh {
public:
const static Index PRIMITIVE_RESTART_INDEX = -1;
@ -142,6 +142,8 @@ public:
std::string modelName;
std::string displayName;
gpu::BufferPointer getColorBuffer() const { return _colorBuffer; }
protected:
gpu::Stream::FormatPointer _vertexFormat;
@ -154,6 +156,8 @@ protected:
BufferView _partBuffer;
gpu::BufferPointer _colorBuffer { std::make_shared<gpu::Buffer>() };
void evalVertexFormat();
void evalVertexStream();

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

File diff suppressed because it is too large Load diff

90
libraries/render-utils/src/GeometryCache.h
View file

@ -180,31 +180,10 @@ public:
void renderShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer);
void renderWireShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer);
void renderFadeShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer,
gpu::BufferPointer& fadeBuffer1, gpu::BufferPointer& fadeBuffer2, gpu::BufferPointer& fadeBuffer3);
void renderWireFadeShapeInstances(gpu::Batch& batch, Shape shape, size_t count, gpu::BufferPointer& colorBuffer,
gpu::BufferPointer& fadeBuffer1, gpu::BufferPointer& fadeBuffer2, gpu::BufferPointer& fadeBuffer3);
void renderSolidShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color,
const render::ShapePipelinePointer& pipeline);
void renderSolidShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec3& color,
const render::ShapePipelinePointer& pipeline) {
renderSolidShapeInstance(args, batch, shape, glm::vec4(color, 1.0f), pipeline);
}
const render::ShapePipelinePointer& pipeline);
void renderWireShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color,
const render::ShapePipelinePointer& pipeline);
void renderWireShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec3& color,
const render::ShapePipelinePointer& pipeline) {
renderWireShapeInstance(args, batch, shape, glm::vec4(color, 1.0f), pipeline);
}
void renderSolidFadeShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color, int fadeCategory, float fadeThreshold,
const glm::vec3& fadeNoiseOffset, const glm::vec3& fadeBaseOffset, const glm::vec3& fadeBaseInvSize,
const render::ShapePipelinePointer& pipeline);
void renderWireFadeShapeInstance(RenderArgs* args, gpu::Batch& batch, Shape shape, const glm::vec4& color, int fadeCategory, float fadeThreshold,
const glm::vec3& fadeNoiseOffset, const glm::vec3& fadeBaseOffset, const glm::vec3& fadeBaseInvSize,
const render::ShapePipelinePointer& pipeline);
void renderSolidSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
const render::ShapePipelinePointer& pipeline);
@ -213,20 +192,6 @@ public:
renderSolidSphereInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
}
void renderWireSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
const render::ShapePipelinePointer& pipeline);
void renderWireSphereInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
const render::ShapePipelinePointer& pipeline) {
renderWireSphereInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
}
void renderSolidCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
const render::ShapePipelinePointer& pipeline);
void renderSolidCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
const render::ShapePipelinePointer& pipeline) {
renderSolidCubeInstance(args, batch, glm::vec4(color, 1.0f), pipeline);
}
void renderWireCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec4& color,
const render::ShapePipelinePointer& pipeline);
void renderWireCubeInstance(RenderArgs* args, gpu::Batch& batch, const glm::vec3& color,
@ -235,24 +200,10 @@ public:
}
// Dynamic geometry
void renderShape(gpu::Batch& batch, Shape shape);
void renderWireShape(gpu::Batch& batch, Shape shape);
void renderShape(gpu::Batch& batch, Shape shape, const glm::vec4& color);
void renderWireShape(gpu::Batch& batch, Shape shape, const glm::vec4& color);
void renderShape(gpu::Batch& batch, Shape shape, gpu::BufferPointer& colorBuffer);
void renderWireShape(gpu::Batch& batch, Shape shape, gpu::BufferPointer& colorBuffer);
size_t getShapeTriangleCount(Shape shape);
void renderCube(gpu::Batch& batch);
void renderWireCube(gpu::Batch& batch);
void renderCube(gpu::Batch& batch, const glm::vec4& color);
void renderWireCube(gpu::Batch& batch, const glm::vec4& color);
size_t getCubeTriangleCount();
void renderSphere(gpu::Batch& batch);
void renderWireSphere(gpu::Batch& batch);
void renderSphere(gpu::Batch& batch, const glm::vec4& color);
void renderWireSphere(gpu::Batch& batch, const glm::vec4& color);
size_t getSphereTriangleCount();
void renderGrid(gpu::Batch& batch, const glm::vec2& minCorner, const glm::vec2& maxCorner,
int majorRows, int majorCols, float majorEdge,
int minorRows, int minorCols, float minorEdge,
@ -262,10 +213,6 @@ public:
void renderUnitQuad(gpu::Batch& batch, const glm::vec4& color, int id);
void renderUnitQuad(gpu::Batch& batch, int id) {
renderUnitQuad(batch, glm::vec4(1), id);
}
void renderQuad(gpu::Batch& batch, int x, int y, int width, int height, const glm::vec4& color, int id)
{ renderQuad(batch, glm::vec2(x,y), glm::vec2(x + width, y + height), color, id); }
@ -307,19 +254,6 @@ public:
void renderDashedLine(gpu::Batch& batch, const glm::vec3& start, const glm::vec3& end, const glm::vec4& color,
const float dash_length, const float gap_length, int id);
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2, const glm::vec3& color, int id)
{ renderLine(batch, p1, p2, glm::vec4(color, 1.0f), id); }
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2, const glm::vec4& color, int id)
{ renderLine(batch, p1, p2, color, color, id); }
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2,
const glm::vec3& color1, const glm::vec3& color2, int id)
{ renderLine(batch, p1, p2, glm::vec4(color1, 1.0f), glm::vec4(color2, 1.0f), id); }
void renderLine(gpu::Batch& batch, const glm::vec2& p1, const glm::vec2& p2,
const glm::vec4& color1, const glm::vec4& color2, int id);
void updateVertices(int id, const QVector<glm::vec2>& points, const glm::vec4& color);
void updateVertices(int id, const QVector<glm::vec2>& points, const QVector<glm::vec4>& colors);
void updateVertices(int id, const QVector<glm::vec3>& points, const glm::vec4& color);
@ -364,6 +298,8 @@ public:
graphics::MeshPointer meshFromShape(Shape geometryShape, glm::vec3 color);
static uint32_t toCompactColor(const glm::vec4& color);
private:
GeometryCache();
@ -397,6 +333,7 @@ private:
public:
static int population;
gpu::BufferPointer verticesBuffer;
gpu::BufferPointer normalBuffer;
gpu::BufferPointer colorBuffer;
gpu::BufferPointer uniformBuffer;
gpu::Stream::FormatPointer streamFormat;
@ -445,18 +382,9 @@ private:
QHash<int, Vec2FloatPairPair> _lastRegisteredGridBuffer;
QHash<int, GridBuffer> _registeredGridBuffers;
// FIXME: clean these up
static gpu::ShaderPointer _simpleShader;
static gpu::ShaderPointer _transparentShader;
static gpu::ShaderPointer _unlitShader;
static gpu::ShaderPointer _simpleFadeShader;
static gpu::ShaderPointer _unlitFadeShader;
static gpu::ShaderPointer _forwardSimpleShader;
static gpu::ShaderPointer _forwardTransparentShader;
static gpu::ShaderPointer _forwardUnlitShader;
static gpu::ShaderPointer _forwardSimpleFadeShader;
static gpu::ShaderPointer _forwardUnlitFadeShader;
// transparent, unlit, forward, fade
static std::map<std::tuple<bool, bool, bool, bool>, gpu::ShaderPointer> _shapeShaders;
// transparent, unlit, forward
static std::map<std::tuple<bool, bool, bool, graphics::MaterialKey::CullFaceMode>, render::ShapePipelinePointer> _shapePipelines;
static QHash<SimpleProgramKey, gpu::PipelinePointer> _simplePrograms;

7
libraries/render-utils/src/MeshPartPayload.cpp
View file

@ -354,12 +354,17 @@ void ModelMeshPartPayload::render(RenderArgs* args) {
outColor = procedural->getColor(outColor);
procedural->prepare(batch, transform.getTranslation(), transform.getScale(), transform.getRotation(), _created,
ProceduralProgramKey(outColor.a < 1.0f, _shapeKey.isDeformed(), _shapeKey.isDualQuatSkinned()));
batch._glColor4f(outColor.r, outColor.g, outColor.b, outColor.a);
const uint32_t compactColor = GeometryCache::toCompactColor(glm::vec4(outColor));
_drawMesh->getColorBuffer()->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
} else {
// apply material properties
if (RenderPipelines::bindMaterials(_drawMaterials, batch, args->_renderMode, args->_enableTexturing)) {
args->_details._materialSwitches++;
}
const uint32_t compactColor = 0xFFFFFFFF;
_drawMesh->getColorBuffer()->setData(sizeof(compactColor), (const gpu::Byte*) &compactColor);
}
// Draw!