Working on rejiggering the heightfield tiles.

Andrzej Kapolka committed 12 years ago

Commit 2c0f8ff1 parent 10315f15 files · +100 −46Browse files

Showing the changes to interface/src/MetavoxelSystem.cpp (1 of 5 files). Show all

Unified · Split

     if (_heightTextureID == 0) {
         glGenTextures(1, &_heightTextureID);
         glBindTexture(GL_TEXTURE_2D, _heightTextureID);
+        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
         glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, WHITE_COLOR);
         } else {
             int colorSize = glm::sqrt(_color.size() / 3);
             glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, colorSize, colorSize, 0, GL_RGB, GL_UNSIGNED_BYTE, _color.constData());
             if (_clearAfterLoading) {
                 _color.clear();
         }
     }
     // create the buffer objects lazily
-    int sizeWithSkirt = _heightSize + 2;
+    int innerSize = _heightSize - 2;
-    int vertexCount = sizeWithSkirt * sizeWithSkirt;
+    int vertexCount = _heightSize * _heightSize;
-    int rows = sizeWithSkirt - 1;
+    int rows = _heightSize - 1;
     int indexCount = rows * rows * 4;
     BufferPair& bufferPair = _bufferPairs[_heightSize];
     if (!bufferPair.first.isCreated()) {
         QVector<HeightfieldPoint> vertices(vertexCount);
         HeightfieldPoint* point = vertices.data();
-        float step = 1.0f / (_heightSize - 1);
+        float vertexStep = 1.0f / (innerSize - 1);
-        float z = -step;
+        float z = -vertexStep;
-        for (int i = 0; i < sizeWithSkirt; i++, z += step) {
+        float textureStep = 1.0f / _heightSize;
-            float x = -step;
+        float t = textureStep / 2.0f;
+        for (int i = 0; i < _heightSize; i++, z += vertexStep, t += textureStep) {
+            float x = -vertexStep;
+            float s = textureStep / 2.0f;
             const float SKIRT_LENGTH = 0.25f;
-            float baseY = (i == 0 || i == sizeWithSkirt - 1) ? -SKIRT_LENGTH : 0.0f;
+            float baseY = (i == 0 || i == _heightSize - 1) ? -SKIRT_LENGTH : 0.0f;
-            for (int j = 0; j < sizeWithSkirt; j++, point++, x += step) {
+            for (int j = 0; j < _heightSize; j++, point++, x += vertexStep, s += textureStep) {
-                point->vertex = glm::vec3(x, (j == 0 || j == sizeWithSkirt - 1) ? -SKIRT_LENGTH : baseY, z);
+                point->vertex = glm::vec3(x, (j == 0 || j == _heightSize - 1) ? -SKIRT_LENGTH : baseY, z);
-                point->textureCoord = glm::vec2(x, z);
+                point->textureCoord = glm::vec2(s, t);
             }
         }
         QVector<int> indices(indexCount);
         int* index = indices.data();
         for (int i = 0; i < rows; i++) {
-            int lineIndex = i * sizeWithSkirt;
+            int lineIndex = i * _heightSize;
-            int nextLineIndex = (i + 1) * sizeWithSkirt;
+            int nextLineIndex = (i + 1) * _heightSize;
             for (int j = 0; j < rows; j++) {
                 *index++ = lineIndex + j;
                 *index++ = nextLineIndex + j;
     glBindTexture(GL_TEXTURE_2D, _heightTextureID);
-    int heightScaleLocation;
+    if (!cursor) {
-    if (cursor) {
+        DefaultMetavoxelRendererImplementation::getHeightfieldProgram().setUniformValue(
-        heightScaleLocation = DefaultMetavoxelRendererImplementation::getCursorHeightScaleLocation();
+            DefaultMetavoxelRendererImplementation::getHeightScaleLocation(), 1.0f / _heightSize);
-    } else {
+        DefaultMetavoxelRendererImplementation::getHeightfieldProgram().setUniformValue(
-        heightScaleLocation = DefaultMetavoxelRendererImplementation::getHeightScaleLocation();
+            DefaultMetavoxelRendererImplementation::getColorScaleLocation(), (float)_heightSize / innerSize);
         glActiveTexture(GL_TEXTURE1);
         glBindTexture(GL_TEXTURE_2D, _colorTextureID);
     }
-    DefaultMetavoxelRendererImplementation::getHeightfieldProgram().setUniformValue(heightScaleLocation, 1.0f / _heightSize);
     glDrawRangeElements(GL_QUADS, 0, vertexCount - 1, indexCount, GL_UNSIGNED_INT, 0);
     if (!cursor) {
         _heightfieldProgram.setUniformValue("heightMap", 0);
         _heightfieldProgram.setUniformValue("diffuseMap", 1);
         _heightScaleLocation = _heightfieldProgram.uniformLocation("heightScale");
+        _colorScaleLocation = _heightfieldProgram.uniformLocation("colorScale");
         _heightfieldProgram.release();
         _heightfieldCursorProgram.addShaderFromSourceFile(QGLShader::Vertex, Application::resourcesPath() +
         _heightfieldCursorProgram.bind();
         _heightfieldCursorProgram.setUniformValue("heightMap", 0);
-        _cursorHeightScaleLocation = _heightfieldCursorProgram.uniformLocation("heightScale");
         _heightfieldCursorProgram.release();
     }
 }
             Application::getInstance()->getMetavoxels()->getHeightfieldBufferAttribute(), lod) {
 }
+class BorderFetchVisitor : public MetavoxelVisitor {
+public:
+    BorderFetchVisitor(const MetavoxelLOD& lod, QByteArray& height);
+    virtual int visit(MetavoxelInfo& info);
+private:
+    QByteArray& _height;
+};
+BorderFetchVisitor::BorderFetchVisitor(const MetavoxelLOD& lod, QByteArray& height) :
+    MetavoxelVisitor(QVector<AttributePointer>() << AttributeRegistry::getInstance()->getHeightfieldAttribute(),
+        QVector<AttributePointer>(), lod),
+    _height(height) {
+}
+int BorderFetchVisitor::visit(MetavoxelInfo& info) {
+    if (!info.isLeaf) {
+        return DEFAULT_ORDER;
+    }
+    return STOP_RECURSION;
+}
 int HeightfieldAugmentVisitor::visit(MetavoxelInfo& info) {
     if (info.isLeaf) {
         HeightfieldBuffer* buffer = NULL;
         HeightfieldDataPointer height = info.inputValues.at(0).getInlineValue<HeightfieldDataPointer>();
         if (height) {
+            const QByteArray& heightContents = height->getContents();
+            int size = glm::sqrt(heightContents.size());
+            int extendedSize = size + 3;
+            QByteArray extendedHeightContents(extendedSize * extendedSize, 0);
+            char* dest = extendedHeightContents.data() + extendedSize + 1;
+            const char* src = heightContents.constData();
+            for (int z = 0; z < size; z++, src += size, dest += extendedSize) {
+                memcpy(dest, src, size);
+            }
+            QByteArray extendedColorContents;
             HeightfieldDataPointer color = info.inputValues.at(1).getInlineValue<HeightfieldDataPointer>();
-            buffer = new HeightfieldBuffer(info.minimum, info.size, height->getContents(),
+            if (color) {
-                color ? color->getContents() : QByteArray());
+                const QByteArray& colorContents = color->getContents();
+                const int BYTES_PER_PIXEL = 3;
+                int colorSize = glm::sqrt(colorContents.size() / BYTES_PER_PIXEL);
+                int extendedColorSize = colorSize + 1;
+                extendedColorContents = QByteArray(extendedColorSize * extendedColorSize * BYTES_PER_PIXEL, 0);
+                char* dest = extendedColorContents.data();
+                const char* src = colorContents.constData();
+                int srcStride = colorSize * BYTES_PER_PIXEL;
+                int destStride = extendedColorSize * BYTES_PER_PIXEL;
+                for (int z = 0; z < colorSize; z++, src += srcStride, dest += destStride) {
+                    memcpy(dest, src, srcStride);
+                }
+            }
+            buffer = new HeightfieldBuffer(info.minimum, info.size, extendedHeightContents, extendedColorContents);
         }
         info.outputValues[0] = AttributeValue(_outputs.at(0), encodeInline(BufferDataPointer(buffer)));
         return STOP_RECURSION;
 int DefaultMetavoxelRendererImplementation::_pointScaleLocation;
 ProgramObject DefaultMetavoxelRendererImplementation::_heightfieldProgram;
 int DefaultMetavoxelRendererImplementation::_heightScaleLocation;
+int DefaultMetavoxelRendererImplementation::_colorScaleLocation;
 ProgramObject DefaultMetavoxelRendererImplementation::_heightfieldCursorProgram;
-int DefaultMetavoxelRendererImplementation::_cursorHeightScaleLocation;
 static void enableClipPlane(GLenum plane, float x, float y, float z, float w) {
     GLdouble coefficients[] = { x, y, z, w };