Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++
++ #include "scatterobjectbufferhelper_p.h"
++ #include "objecthelper_p.h"
++
++ #include <QtGui/QVector2D>
++ #include <QtGui/QMatrix4x4>
++ #include <QtGui/qquaternion.h>
++
++ #include <QtCore/qmath.h>
++
++ QT_BEGIN_NAMESPACE
++
++ const GLfloat ScatterObjectBufferHelper::itemScaler = 3.0f;
++
++ ScatterObjectBufferHelper::ScatterObjectBufferHelper()
++ : m_scaleY(0.0f)
++ {
++ }
++
++ ScatterObjectBufferHelper::~ScatterObjectBufferHelper()
++ {
++ }
++
++ void ScatterObjectBufferHelper::fullLoad(ScatterSeriesRenderCache *cache, qreal dotScale)
++ {
++ m_indexCount = 0;
++
++ ObjectHelper *dotObj = cache->object();
++ const ScatterRenderItemArray &renderArray = cache->renderArray();
++ const uint renderArraySize = renderArray.size();
++
++ if (renderArraySize == 0)
++ return; // No use to go forward
++
++ uint itemCount = 0;
++ QQuaternion seriesRotation(cache->meshRotation());
++
++ if (m_meshDataLoaded) {
++ // Delete old data
++ glDeleteBuffers(1, &m_vertexbuffer);
++ glDeleteBuffers(1, &m_uvbuffer);
++ glDeleteBuffers(1, &m_normalbuffer);
++ glDeleteBuffers(1, &m_elementbuffer);
++ m_vertexbuffer = 0;
++ m_uvbuffer = 0;
++ m_normalbuffer = 0;
++ m_elementbuffer = 0;
++ m_meshDataLoaded = false;
++ }
++
++ // Index vertices
++ const QList<GLuint> indices = dotObj->indices();
++ const QList<QVector3D> indexed_vertices = dotObj->indexedvertices();
++ const QList<QVector2D> indexed_uvs = dotObj->indexedUVs();
++ const QList<QVector3D> indexed_normals = dotObj->indexedNormals();
++ const int indicesCount = indices.size();
++ const int verticeCount = indexed_vertices.size();
++ const int uvsCount = indexed_uvs.size();
++ const int normalsCount = indexed_normals.size();
++
++ float itemSize = cache->itemSize() / itemScaler;
++ if (itemSize == 0.0f)
++ itemSize = dotScale;
++ QVector3D modelScaler(itemSize, itemSize, itemSize);
++ QMatrix4x4 modelMatrix;
++ if (!seriesRotation.isIdentity()) {
++ QMatrix4x4 matrix;
++ matrix.rotate(seriesRotation);
++ modelMatrix = matrix.transposed();
++ }
++ modelMatrix.scale(modelScaler);
++
++ QList<QVector3D> scaled_vertices;
++ scaled_vertices.resize(verticeCount);
++ for (int i = 0; i < verticeCount; i++)
++ scaled_vertices[i] = (QVector4D(indexed_vertices[i]) * modelMatrix).toVector3D();
++
++ QList<GLuint> buffered_indices;
++ QList<QVector3D> buffered_vertices;
++ QList<QVector2D> buffered_uvs;
++ QList<QVector3D> buffered_normals;
++
++ buffered_indices.resize(indicesCount * renderArraySize);
++ buffered_vertices.resize(verticeCount * renderArraySize);
++ buffered_normals.resize(normalsCount * renderArraySize);
++ buffered_uvs.resize(uvsCount * renderArraySize);
++
++ if (cache->colorStyle() == Q3DTheme::ColorStyleRangeGradient)
++ createRangeGradientUVs(cache, buffered_uvs);
++ else if (cache->colorStyle() == Q3DTheme::ColorStyleObjectGradient)
++ createObjectGradientUVs(cache, buffered_uvs, indexed_vertices);
++
++ QVector2D dummyUV(0.0f, 0.0f);
++
++ cache->bufferIndices().resize(renderArraySize);
++
++ for (uint i = 0; i < renderArraySize; i++) {
++ const ScatterRenderItem &item = renderArray.at(i);
++ if (!item.isVisible())
++ continue;
++ else
++ cache->bufferIndices()[i] = itemCount;
++
++ int offset = itemCount * verticeCount;
++ if (item.rotation().isIdentity()) {
++ for (int j = 0; j < verticeCount; j++) {
++ buffered_vertices[j + offset] = scaled_vertices[j] + item.translation();
++ buffered_normals[j + offset] = indexed_normals[j];
++ }
++ } else {
++ QMatrix4x4 matrix;
++ QQuaternion totalRotation = seriesRotation * item.rotation();
++ matrix.rotate(totalRotation);
++ matrix.scale(modelScaler);
++ QMatrix4x4 itModelMatrix = matrix.inverted();
++ modelMatrix = matrix.transposed(); // Because of row-column major difference
++
++ for (int j = 0; j < verticeCount; j++) {
++ buffered_vertices[j + offset]
++ = (QVector4D(indexed_vertices[j]) * modelMatrix).toVector3D()
++ + item.translation();
++ buffered_normals[j + offset]
++ = (QVector4D(indexed_normals[j]) * itModelMatrix).toVector3D();
++ }
++ }
++
++ if (cache->colorStyle() == Q3DTheme::ColorStyleUniform) {
++ offset = itemCount * uvsCount;
++ for (int j = 0; j < uvsCount; j++)
++ buffered_uvs[j + offset] = dummyUV;
++ }
++
++ int offsetVertice = itemCount * verticeCount;
++ offset = itemCount * indicesCount;
++ for (int j = 0; j < indicesCount; j++)
++ buffered_indices[j + offset] = GLuint(indices[j] + offsetVertice);
++
++ itemCount++;
++ }
++
++ m_indexCount = indicesCount * itemCount;
++
++ if (itemCount > 0) {
++ glGenBuffers(1, &m_vertexbuffer);
++ glBindBuffer(GL_ARRAY_BUFFER, m_vertexbuffer);
++ glBufferData(GL_ARRAY_BUFFER, verticeCount * itemCount * sizeof(QVector3D),
++ &buffered_vertices.at(0),
++ GL_STATIC_DRAW);
++
++ glGenBuffers(1, &m_normalbuffer);
++ glBindBuffer(GL_ARRAY_BUFFER, m_normalbuffer);
++ glBufferData(GL_ARRAY_BUFFER, normalsCount * itemCount * sizeof(QVector3D),
++ &buffered_normals.at(0),
++ GL_STATIC_DRAW);
++
++ glGenBuffers(1, &m_uvbuffer);
++ glBindBuffer(GL_ARRAY_BUFFER, m_uvbuffer);
++ glBufferData(GL_ARRAY_BUFFER, uvsCount * itemCount * sizeof(QVector2D),
++ &buffered_uvs.at(0), GL_STATIC_DRAW);
++
++ glGenBuffers(1, &m_elementbuffer);
++ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementbuffer);
++ glBufferData(GL_ELEMENT_ARRAY_BUFFER, indicesCount * itemCount * sizeof(GLint),
++ &buffered_indices.at(0), GL_STATIC_DRAW);
++
++ glBindBuffer(GL_ARRAY_BUFFER, 0);
++ glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
++
++ m_meshDataLoaded = true;
++ }
++ }
++
++ void ScatterObjectBufferHelper::updateUVs(ScatterSeriesRenderCache *cache)
++ {
++ ObjectHelper *dotObj = cache->object();
++ const int uvsCount = dotObj->indexedUVs().size();
++ const ScatterRenderItemArray &renderArray = cache->renderArray();
++ const bool updateAll = (cache->updateIndices().size() == 0);
++ const int updateSize = updateAll ? renderArray.size() : cache->updateIndices().size();
++
++ if (!updateSize)
++ return;
++
++ QList<QVector2D> buffered_uvs;
++ buffered_uvs.resize(uvsCount * updateSize);
++
++ uint itemCount = 0;
++ if (cache->colorStyle() == Q3DTheme::ColorStyleRangeGradient) {
++ itemCount = createRangeGradientUVs(cache, buffered_uvs);
++ } else if (cache->colorStyle() == Q3DTheme::ColorStyleObjectGradient) {
++ const QList<QVector3D> indexed_vertices = dotObj->indexedvertices();
++ itemCount = createObjectGradientUVs(cache, buffered_uvs, indexed_vertices);
++ }
++
++ glBindBuffer(GL_ARRAY_BUFFER, m_uvbuffer);
++ int itemSize = uvsCount * sizeof(QVector2D);
++ if (cache->updateIndices().size()) {
++ int pos = 0;
++ for (int i = 0; i < updateSize; i++) {
++ int index = cache->updateIndices().at(i);
++ if (renderArray.at(index).isVisible()) {
++ int dataPos = cache->bufferIndices().at(index);
++ glBufferSubData(GL_ARRAY_BUFFER, itemSize * dataPos, itemSize,
++ &buffered_uvs.at(uvsCount * pos++));
++ }
++ }
++ } else {
++ glBufferData(GL_ARRAY_BUFFER, itemSize * itemCount, &buffered_uvs.at(0), GL_STATIC_DRAW);
++ }
++ glBindBuffer(GL_ARRAY_BUFFER, 0);
++ }
++
++ uint ScatterObjectBufferHelper::createRangeGradientUVs(ScatterSeriesRenderCache *cache,
++ QList<QVector2D> &buffered_uvs)
++ {
++ ObjectHelper *dotObj = cache->object();
++ const int uvsCount = dotObj->indexedUVs().size();
++ const ScatterRenderItemArray &renderArray = cache->renderArray();
++ const bool updateAll = (cache->updateIndices().size() == 0);
++ const int updateSize = updateAll ? renderArray.size() : cache->updateIndices().size();
++ const float yAdjustment = 0.1f;
++ const float flippedYAdjustment = 0.9f;
++
++ QVector2D uv;
++ uv.setX(0.0f);
++ uint pos = 0;
++ for (int i = 0; i < updateSize; i++) {
++ int index = updateAll ? i : cache->updateIndices().at(i);
++ const ScatterRenderItem &item = renderArray.at(index);
++ if (!item.isVisible())
++ continue;
++
++ float y = ((item.translation().y() + m_scaleY) * 0.5f) / m_scaleY;
++
++ // Avoid values near gradient texel boundary, as this causes artifacts
++ // with some graphics cards.
++ const float floorY = float(qFloor(y * gradientTextureHeight));
++ const float diff = (y * gradientTextureHeight) - floorY;
++ if (diff < yAdjustment)
++ y += yAdjustment / gradientTextureHeight;
++ else if (diff > flippedYAdjustment)
++ y -= yAdjustment / gradientTextureHeight;
++ uv.setY(y);
++
++ int offset = pos * uvsCount;
++ for (int j = 0; j < uvsCount; j++)
++ buffered_uvs[j + offset] = uv;
++
++ pos++;
++ }
++
++ return pos;
++ }
++
++ uint ScatterObjectBufferHelper::createObjectGradientUVs(ScatterSeriesRenderCache *cache,
++ QList<QVector2D> &buffered_uvs,
++ const QList<QVector3D> &indexed_vertices)
++ {
++ ObjectHelper *dotObj = cache->object();
++ const int uvsCount = dotObj->indexedUVs().size();
++ const ScatterRenderItemArray &renderArray = cache->renderArray();
++ const uint renderArraySize = renderArray.size();
++
++ QVector2D uv;
++ uv.setX(0.0f);
++ uint pos = 0;
++ for (uint i = 0; i < renderArraySize; i++) {
++ const ScatterRenderItem &item = renderArray.at(i);
++ if (!item.isVisible())
++ continue;
++
++ int offset = pos * uvsCount;
++ for (int j = 0; j < uvsCount; j++) {
++ uv.setY((indexed_vertices.at(j).y() + 1.0f) / 2.0f);
++ buffered_uvs[j + offset] = uv;
++ }
++
++ pos++;
++ }
++
++ return pos;
++ }
++
++ void ScatterObjectBufferHelper::update(ScatterSeriesRenderCache *cache, qreal dotScale)
++ {
++ ObjectHelper *dotObj = cache->object();
++ const ScatterRenderItemArray &renderArray = cache->renderArray();
++ const bool updateAll = (cache->updateIndices().size() == 0);
++ const int updateSize = updateAll ? renderArray.size() : cache->updateIndices().size();
++ QQuaternion seriesRotation(cache->meshRotation());
++
++ if (!updateSize)
++ return;
++
++ // Index vertices
++ const QList<QVector3D> indexed_vertices = dotObj->indexedvertices();
++ int verticeCount = indexed_vertices.size();
++
++ float itemSize = cache->itemSize() / itemScaler;
++ if (itemSize == 0.0f)
++ itemSize = dotScale;
++ QVector3D modelScaler(itemSize, itemSize, itemSize);
++ QMatrix4x4 modelMatrix;
++ if (!seriesRotation.isIdentity()) {
++ QMatrix4x4 matrix;
++ matrix.rotate(seriesRotation);
++ modelMatrix = matrix.transposed();
++ }
++ modelMatrix.scale(modelScaler);
++
++ QList<QVector3D> scaled_vertices;
++ scaled_vertices.resize(verticeCount);
++ for (int i = 0; i < verticeCount; i++)
++ scaled_vertices[i] = (QVector4D(indexed_vertices[i]) * modelMatrix).toVector3D();
++
++ QList<QVector3D> buffered_vertices;
++ buffered_vertices.resize(verticeCount * updateSize);
++
++ int itemCount = 0;
++ for (int i = 0; i < updateSize; i++) {
++ int index = updateAll ? i : cache->updateIndices().at(i);
++ const ScatterRenderItem &item = renderArray.at(index);
++ if (!item.isVisible())
++ continue;
++
++ const int offset = itemCount * verticeCount;
++ if (item.rotation().isIdentity()) {
++ for (int j = 0; j < verticeCount; j++)
++ buffered_vertices[j + offset] = scaled_vertices[j] + item.translation();
++ } else {
++ QMatrix4x4 matrix;
++ matrix.rotate(seriesRotation * item.rotation());
++ modelMatrix = matrix.transposed();
++ modelMatrix.scale(modelScaler);
++
++ for (int j = 0; j < verticeCount; j++) {
++ buffered_vertices[j + offset]
++ = (QVector4D(indexed_vertices[j]) * modelMatrix).toVector3D()
++ + item.translation();
++ }
++ }
++ itemCount++;
++ }
++
++ glBindBuffer(GL_ARRAY_BUFFER, m_vertexbuffer);
++ int sizeOfItem = verticeCount * sizeof(QVector3D);
++ if (updateAll) {
++ if (itemCount) {
++ glBufferData(GL_ARRAY_BUFFER, itemCount * sizeOfItem,
++ &buffered_vertices.at(0), GL_STATIC_DRAW);
++ }
++ } else {
++ itemCount = 0;
++ for (int i = 0; i < updateSize; i++) {
++ int index = updateAll ? i : cache->updateIndices().at(i);
++ if (renderArray.at(index).isVisible()) {
++ glBufferSubData(GL_ARRAY_BUFFER, cache->bufferIndices().at(index) * sizeOfItem,
++ sizeOfItem, &buffered_vertices.at(itemCount * verticeCount));
++ itemCount++;
++ }
++ }
++ }
++ glBindBuffer(GL_ARRAY_BUFFER, 0);
++
++ m_meshDataLoaded = true;
++ }
++
++ QT_END_NAMESPACE