Method EnableSBuffers

GTE/Graphics/GL46/GL46Engine.cpp:403–517

}

void GL46Engine::EnableSBuffers(Shader const* shader, GLuint program)
{
    // Configure atomic counter buffer objects used by the shader.
    auto const& atomicCounters = shader->GetData(Shader::AtomicCounterShaderDataLookup);
    auto const& atomicCounterBuffers = shader->GetData(Shader::AtomicCounterBufferShaderDataLookup);
    for (uint32_t acbIndex = 0; acbIndex < atomicCounterBuffers.size(); ++acbIndex)
    {
        auto const& acb = atomicCounterBuffers[acbIndex];

        // Allocate a new raw buffer?
        if (acbIndex >= mAtomicCounterRawBuffers.size())
        {
            mAtomicCounterRawBuffers.push_back(nullptr);
        }

        // Look at the current raw buffer defined at this index.  Could be
        // nullptr if a new location was just inserted.
        auto& rawBuffer = mAtomicCounterRawBuffers[acbIndex];

        // If the raw buffer is not large enough, then unbind old one and
        // ready to create new one.
        if (rawBuffer && (acb.numBytes > static_cast<int32_t>(rawBuffer->GetNumBytes())))
        {
            Unbind(rawBuffer.get());
            rawBuffer = nullptr;
        }

        // Find the currently mapped GL4AtomicCounterBuffer.
        GL46AtomicCounterBuffer* gl4ACB = nullptr;
        if (rawBuffer)
        {
            gl4ACB = static_cast<GL46AtomicCounterBuffer*>(Get(rawBuffer));
        }
        else
        {
            // By definition, RawBuffer contains 4-byte elements.  We do not
            // need CPU-side storage, but we must be able to copy values
            // between buffers.
            rawBuffer = std::make_shared<RawBuffer>((acb.numBytes + 3) / 4, false);
            rawBuffer->SetUsage(Resource::Usage::DYNAMIC_UPDATE);

            // Do a manual Bind operation because this is a special mapping
            // from RawBuffer to GL4AtomicCounterBuffer.
            auto temp = GL46AtomicCounterBuffer::Create(mGEObjectCreator, rawBuffer.get());
            mGOMapMutex.lock();
            mGOMap.insert(std::make_pair(rawBuffer.get(), temp));
            mGOMapMutex.unlock();
            gl4ACB = static_cast<GL46AtomicCounterBuffer*>(temp.get());
        }

        // TODO: ShaderStorage blocks have a glShaderStorageBlockBinding()
        // call.  Uniform blocks have a glUniforBlockBinding() call.  Is there
        // something equivalent for atomic counters buffers?

        // Bind this atomic counter buffer
        gl4ACB->AttachToUnit(acb.bindPoint);
    }