GPU instancing

[GaussGun3000]

I know there's one similar thread, but I'd like an answer for my exact case, if possible.
I have a loaded glb model (vsg::ref_ptr<vsg::Node> _model) and an array of matrices with randomized per-instance scale and rotation (<vsg::dmat4Array> _matrices or std::vector<vsg::dmat4> _matrices).
What would be the most straight-forward way to instantiate _matrices.size() amount of _model, one for every transform described in _matrices, so that they're drawn in single draw call (aka using GPU instancing)?

[robertosfield]

I have had a chance to write it up yet, but part of the 3D Tiles 1.0 work I recently checked into VSG/vsgXchange master included a new vsg::InstanceNode that is coupled to vsg::InstanceDraw and vsg::InstanceDrawIndexed. These new classes enable more flexible GPU instancing, adding higher level instancing support that provided by the lower level mesh drawing classes.

The InstanceNode class provides the high level interface to the translation, rotations and scale arrays, while the InstanceDraw/InstanceDrawIndexed pass the instance arrays to Vulkan in the appropriate way. You can have multiple InstanceNode nodes sharing the same subgraph, which is used by 3D Tiles when rendering things like trees or lampposts, so that different tiles that require different number and values of instancing positions, but can share the same lower level scene graph.

The new [vsgXchange::gltf](https://github.com/vsg-dev/vsgXchange/blob/master/include/vsgXchange/gltf.h] loader now supports a mode where it'll build the loaded model with InstanceDraw/InstanceDrawIndexed, enabling the calling code to add the required vsg::InstanceNode to decorate the loaded subgraphs. There are restrictions on what type of subgraphs are suitable for instancing in this way, and the new gltf loader aims to keep things compatible with InstanceNode when this mode is enabled.

The implementation of the .i3dm format in the new vsgXchange 3DTiles code provides an example of the set up of the vsg::InstanceNode and how to tell the vsgXchange::gltf loader that it should create a subgraph suitable for use with InstanceNode. The relevant code can be found at in vsgXchange/src/3DTiles/i3dm.cpp. The code is:

    // if required decorate the model to provide multiple instances, or provide the global translation.
    if (gpuInstancing)
    {
        // compute the centre of all positions
        vsg::dvec3 instance_center;

        if (featureTable->POSITION)
        {
            for (size_t i = 0; i*3 < featureTable->POSITION.values.size(); ++i)
            {
                const auto& values = featureTable->POSITION.values;
                instance_center += vsg::dvec3(values[i*3 + 0], values[i*3 + 1], values[i*3 + 2]);
            }
            instance_center /= static_cast<double>(featureTable->POSITION.values.size()/3);

            rtc_center += instance_center;
        }
        else if (featureTable->POSITION_QUANTIZED)
        {
            for (size_t i = 0; i*3 < featureTable->POSITION_QUANTIZED.values.size(); ++i)
            {
                const auto& values = featureTable->POSITION_QUANTIZED.values;
                vsg::dvec3 quantizedPosition(static_cast<double>(values[i*3 + 0]), static_cast<double>(values[i*3 + 1]), static_cast<double>(values[i*3 + 2]));
                instance_center += quantizeOffset + quantizedPosition * quantizeScale;
            }

            instance_center /= static_cast<double>(featureTable->POSITION_QUANTIZED.values.size()/3);

            rtc_center += instance_center;
        }

        auto translations = vsg::vec3Array::create(featureTable->INSTANCES_LENGTH);
        auto rotations = vsg::quatArray::create(featureTable->INSTANCES_LENGTH);
        auto scales = vsg::vec3Array::create(featureTable->INSTANCES_LENGTH);

        auto instanceNode = vsg::InstanceNode::create();
        instanceNode->firstInstance = 0;
        instanceNode->instanceCount = featureTable->INSTANCES_LENGTH;
        instanceNode->setTranslations(translations);
        instanceNode->setRotations(rotations);
        instanceNode->setScales(scales);
        instanceNode->child = model;

        for(uint32_t i=0; i<featureTable->INSTANCES_LENGTH; ++i)
        {
            vsg::dvec3 translation, scale;
            vsg::dquat rotation;
            getTransformComponents(i, translation, rotation, scale);

            translations->set(i, vsg::vec3(translation - instance_center));
            rotations->set(i, vsg::quat(rotation));
            scales->set(i, vsg::vec3(scale));
        }

        if (rtc_center != vsg::dvec3())
        {
            auto transform = vsg::MatrixTransform::create();
            transform->addChild(instanceNode);
            transform->matrix = vsg::translate(rtc_center);
            model = transform;
        }
        else
        {
            model = instanceNode;
        }
    }

The code is very much hot off the presses. I can't provide detailed support on this as I have heap of work to get on with.

[robertosfield]

I thinks so. You'll need VSG and vsgXchange master. They'll be part of the up coming VSG-1.1.11 release.

[GaussGun3000]

@robertosfield
I tried applying individual rotations to each instance, and it might be that each instance is not rotated locally. I can't exactly verify that as it's happening on rocky lib scene, all I can see is that instances disappear after I try to normalize instances against earth normal vector

[robertosfield]

I am afraid I can't help with debugging this, you are the only one with the code, data and the results in front of you.

[GaussGun3000]

I am afraid I can't help with debugging this, you are the only one with the code, data and the results in front of you.

All I want to know is whether instances are rotated locally or relative to world center (if you provide no other parent tranforms)

[robertosfield]

The shader standard.vert shows the way the translation, rotation and scale are applied:

#ifdef VSG_INSTANCE_SCALE
    vertex.xyz = vertex.xyz * vsg_Scale;
#endif

#ifdef VSG_INSTANCE_ROTATION
    vertex.xyz = rotate(vsg_Rotation, vertex.xyz);
    normal.xyz = rotate(vsg_Rotation, normal.xyz);
#endif

#ifdef VSG_INSTANCE_TRANSLATION
    vertex.xyz = vertex.xyz + vsg_Translation;
#endif

So the local vertex is first scaled, then it's rotated then it's translated, then the modelview matrix is applied.

So it's rotated locally.