コード例 #1
0
        private uint PushIndexEntries(uint offset)
        {
            const GLDeviceMemoryTypeFlagBits SELECTED_TYPE_INDEX
                = GLDeviceMemoryTypeFlagBits.INDEX
                  | GLDeviceMemoryTypeFlagBits.TRANSFER_DST;

            const MgMemoryPropertyFlagBits ALL_ON =
                MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT
                | MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT
                | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT
                | MgMemoryPropertyFlagBits.HOST_CACHED_BIT
                | MgMemoryPropertyFlagBits.LAZILY_ALLOCATED_BIT;

            var info_stream = new GLDeviceMemoryTypeInfo
            {
                MemoryTypeIndex = (uint)SELECTED_TYPE_INDEX,
                Index           = offset,
                IsHosted        = false,

                MemoryPropertyFlags
                    = MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT
                      | MgMemoryPropertyFlagBits.LAZILY_ALLOCATED_BIT,

                Hint = STREAM_DRAW,
            };

            mMemoryTypes[info_stream.Index] = info_stream;

            offset += 1;

            var info_static = new GLDeviceMemoryTypeInfo
            {
                MemoryTypeIndex = (uint)SELECTED_TYPE_INDEX,
                Index           = offset,
                IsHosted        = false,

                MemoryPropertyFlags
                    = MgMemoryPropertyFlagBits.HOST_CACHED_BIT
                      | MgMemoryPropertyFlagBits.LAZILY_ALLOCATED_BIT,

                Hint = STATIC_DRAW,
            };

            mMemoryTypes[info_static.Index] = info_static;

            offset += 1;

            var info_dynamic = new GLDeviceMemoryTypeInfo
            {
                MemoryTypeIndex     = (uint)SELECTED_TYPE_INDEX,
                Index               = offset,
                IsHosted            = false,
                MemoryPropertyFlags = ALL_ON,
                Hint = DYNAMIC_DRAW,
            };

            this.mMemoryTypes[info_dynamic.Index] = info_dynamic;

            return(offset + 1);
        }
コード例 #2
0
        public BufferInfo(IMgThreadPartition partition, MgBufferUsageFlagBits usage, MgMemoryPropertyFlagBits propertyFlags, uint bufferSize)
        {
            Debug.Assert(partition != null);

            mDevice = partition.Device;
            Debug.Assert(mDevice != null);

            mUsageFlags = usage;

            mMemoryPropertyFlags = propertyFlags;

            var bufferCreateInfo = new MgBufferCreateInfo
            {
                Usage = usage,
                Size  = bufferSize,
            };

            IMgBuffer buffer;

            var device = partition.Device;

            var result = device.CreateBuffer(bufferCreateInfo, null, out buffer);

            Debug.Assert(result == Result.SUCCESS);

            MgMemoryRequirements memReqs;

            device.GetBufferMemoryRequirements(buffer, out memReqs);
            mAlignment  = memReqs.Alignment;
            mBufferSize = memReqs.Size;

            uint memoryTypeIndex;

            partition.GetMemoryType(memReqs.MemoryTypeBits, mMemoryPropertyFlags, out memoryTypeIndex);

            var memAlloc = new MgMemoryAllocateInfo
            {
                MemoryTypeIndex = memoryTypeIndex,
                AllocationSize  = memReqs.Size,
            };

            IMgDeviceMemory deviceMemory;

            result = device.AllocateMemory(memAlloc, null, out deviceMemory);
            Debug.Assert(result == Result.SUCCESS);

            buffer.BindBufferMemory(device, deviceMemory, 0);


            mBuffer       = buffer;
            mDeviceMemory = deviceMemory;

            mDescriptor = new MgDescriptorBufferInfo
            {
                Buffer = mBuffer,
                Offset = 0,
                Range  = mBufferSize,
            };
        }
コード例 #3
0
        private uint PushImageEntries(uint offset)
        {
            const MgMemoryPropertyFlagBits ALL_ON = MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT
                                                    | MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT
                                                    | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT
                                                    | MgMemoryPropertyFlagBits.HOST_CACHED_BIT
                                                    | MgMemoryPropertyFlagBits.LAZILY_ALLOCATED_BIT;

            var info = new GLDeviceMemoryTypeInfo()
            {
                Index               = offset,
                IsHosted            = true,
                MemoryTypeIndex     = (uint)GLDeviceMemoryTypeFlagBits.IMAGE,
                MemoryPropertyFlags = ALL_ON,
                Hint = 0,
            };

            this.mMemoryTypes[info.Index] = info;

            return(offset + 1);
        }
コード例 #4
0
        public bool GetMemoryType(uint typeBits, MgMemoryPropertyFlagBits memoryPropertyFlags, out uint typeIndex)
        {
            uint requirements = (uint)memoryPropertyFlags;

            // Search memtypes to find first index with those properties
            for (UInt32 i = 0; i < mDeviceMemoryProperties.MemoryTypes.Length; i++)
            {
                if ((typeBits & 1) == 1)
                {
                    // Type is available, does it match user properties?
                    if ((mDeviceMemoryProperties.MemoryTypes[i].PropertyFlags & requirements) == requirements)
                    {
                        typeIndex = i;
                        return(true);
                    }
                }
                typeBits >>= 1;
            }
            // No memory types matched, return failure
            typeIndex = 0;
            return(false);
        }
コード例 #5
0
        private bool DoPack(MgStorageBlockInfo sector, MgOptimizedStorageCreateInfo createInfo, out MgStorageBufferInstance instance)
        {
            MgBufferUsageFlagBits    bufferUsage            = 0;
            MgMemoryPropertyFlagBits deviceMemoryProperties = 0;

            var sortedList = new SortedDictionary <SortedKey, uint>();

            foreach (var attr in sector.Attributes)
            {
                bufferUsage            |= attr.Usage;
                deviceMemoryProperties |= createInfo.Allocations[attr.Index].MemoryPropertyFlags;

                var firstGroup = 0U;
                for (var i = 0U; i < mPackingOrder.Length; i += 1)
                {
                    firstGroup = i;
                    var first = (mPackingOrder[i] & createInfo.Allocations[attr.Index].Usage) > 0;
                    if (first)
                    {
                        break;
                    }
                }

                Debug.Assert(firstGroup <= mPackingOrder.Length);

                var key = new SortedKey
                {
                    Group    = firstGroup,
                    SubOrder = attr.Index,
                };
                sortedList.Add(key, attr.Index);
            }

            ulong overallSize = 0;

            var pCreateInfo = new MgBufferCreateInfo
            {
                SharingMode        = createInfo.SharingMode,
                QueueFamilyIndices = createInfo.QueueFamilyIndices,
                Size  = 0,
                Usage = bufferUsage,
            };

            // The alignment member is identical for all VkBuffer objects created with the same combination of values
            // for the usage and flags members in the VkBufferCreateInfo structure passed to vkCreateBuffer.

            var err = mConfiguration.Device.CreateBuffer(pCreateInfo, null, out IMgBuffer pZeroBuffer);

            if (err != Result.SUCCESS)
            {
                instance = null;
                return(false);
            }

            mConfiguration.Device.GetBufferMemoryRequirements(pZeroBuffer, out MgMemoryRequirements pZeroMemReqs);
            pZeroBuffer.DestroyBuffer(mConfiguration.Device, null);

            var requiredAlignment = pZeroMemReqs.Alignment;

            var mappings = new List <MgStorageBufferOffset>();

            foreach (var element in sortedList.Values)
            {
                var attr = createInfo.Allocations[element];

                var mapping = new MgStorageBufferOffset
                {
                    Index  = element,
                    Offset = UpperBounded(overallSize, requiredAlignment),
                    Size   = attr.Size,
                    Usage  = attr.Usage,
                };
                mappings.Add(mapping);

                overallSize = mapping.Offset + mapping.Size;
            }

            // Real memory allocation
            pCreateInfo.Size = overallSize;

            err = mConfiguration.Device.CreateBuffer(pCreateInfo, null, out IMgBuffer pBuffer);
            if (err != Result.SUCCESS)
            {
                instance = null;
                return(false);
            }

            mConfiguration.Device.GetBufferMemoryRequirements(pBuffer, out MgMemoryRequirements pMemReqs);

            if (mConfiguration.MemoryProperties.GetMemoryType(pMemReqs.MemoryTypeBits, deviceMemoryProperties, out uint typeIndex))
            {
                instance = new MgStorageBufferInstance
                {
                    Buffer = pBuffer,
                    Usage  = bufferUsage,
                    MemoryPropertyFlags = deviceMemoryProperties,
                    TypeIndex           = typeIndex,
                    AllocationSize      = pMemReqs.Size,
                    Mappings            = mappings.ToArray(),
                };
                return(true);
            }
            else
            {
                // CLEAN UP
                pBuffer.DestroyBuffer(mConfiguration.Device, null);
                instance = null;
                return(false);
            }
        }
コード例 #6
0
 public bool GetMemoryType(uint typeBits, MgMemoryPropertyFlagBits memoryPropertyFlags, out uint typeIndex)
 {
     typeIndex = ReturnValue;
     return(IsValid);
 }
コード例 #7
0
        // Allocate one region of memory for the uniform buffer
        private void InitializeUniforms()
        {
            MgBufferCreateInfo pCreateInfo = new MgBufferCreateInfo
            {
                Usage = MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT,
                Size  = MaxBytesPerFrame,
            };
            IMgBuffer buffer;
            var       err = mConfiguration.Device.CreateBuffer(pCreateInfo, null, out buffer);

            Debug.Assert(err == Result.SUCCESS);
            //dynamicConstantBuffer = device.CreateBuffer(MaxBytesPerFrame, (MTLResourceOptions)0);
            //dynamicConstantBuffer.Label = "UniformBuffer";

            MgMemoryRequirements uniformsMemReqs;

            mConfiguration.Device.GetBufferMemoryRequirements(buffer, out uniformsMemReqs);

            const MgMemoryPropertyFlagBits uniformPropertyFlags = MgMemoryPropertyFlagBits.HOST_COHERENT_BIT;

            uint uniformMemoryTypeIndex;

            mConfiguration.Partition.GetMemoryType(
                uniformsMemReqs.MemoryTypeBits, uniformPropertyFlags, out uniformMemoryTypeIndex);

            var uniformMemAlloc = new MgMemoryAllocateInfo
            {
                MemoryTypeIndex = uniformMemoryTypeIndex,
                AllocationSize  = uniformsMemReqs.Size,
            };

            IMgDeviceMemory deviceMemory;
            var             result = mConfiguration.Device.AllocateMemory(uniformMemAlloc, null, out deviceMemory);

            Debug.Assert(result == Result.SUCCESS);

            buffer.BindBufferMemory(mConfiguration.Device, deviceMemory, 0);

            mUniforms = new BufferInfo
            {
                Buffer       = buffer,
                DeviceMemory = deviceMemory,
                Offset       = 0,
                Length       = MaxBytesPerFrame,
            };

            IMgDescriptorSetLayout pSetLayout;
            var dslCreateInfo = new MgDescriptorSetLayoutCreateInfo
            {
                Bindings = new MgDescriptorSetLayoutBinding[]
                {
                    new MgDescriptorSetLayoutBinding
                    {
                        Binding         = 0,
                        DescriptorCount = 1,
                        DescriptorType  = MgDescriptorType.UNIFORM_BUFFER_DYNAMIC,
                        StageFlags      = MgShaderStageFlagBits.VERTEX_BIT,
                    },
                },
            };

            err = mConfiguration.Device.CreateDescriptorSetLayout(dslCreateInfo, null, out pSetLayout);

            var poolCreateInfo = new Magnesium.MgDescriptorPoolCreateInfo
            {
                MaxSets   = 1,
                PoolSizes = new MgDescriptorPoolSize[] {
                    new MgDescriptorPoolSize
                    {
                        DescriptorCount = 1,
                        Type            = MgDescriptorType.COMBINED_IMAGE_SAMPLER,
                    },
                },
            };

            err = mConfiguration.Device.CreateDescriptorPool(poolCreateInfo, null, out mDescriptorPool);

            IMgDescriptorSet[]          dSets;
            MgDescriptorSetAllocateInfo pAllocateInfo = new MgDescriptorSetAllocateInfo
            {
                DescriptorPool     = mDescriptorPool,
                DescriptorSetCount = 1,
                SetLayouts         = new IMgDescriptorSetLayout[]
                {
                    pSetLayout,
                },
            };

            mConfiguration.Device.AllocateDescriptorSets(pAllocateInfo, out dSets);
            mUniformDescriptorSet = dSets[0];

            MgWriteDescriptorSet[] writes = new MgWriteDescriptorSet[]
            {
                new MgWriteDescriptorSet
                {
                    DescriptorCount = 1,
                    DescriptorType  = MgDescriptorType.UNIFORM_BUFFER_DYNAMIC,
                    DstSet          = mUniformDescriptorSet,
                    BufferInfo      = new MgDescriptorBufferInfo[]
                    {
                        new MgDescriptorBufferInfo
                        {
                            Buffer = mUniforms.Buffer,
                            Offset = mUniforms.Offset,
                            Range  = mUniforms.Length,
                        },
                    },
                    DstBinding = 0,
                }
            };
            mConfiguration.Device.UpdateDescriptorSets(writes, null);


            mSetLayout = pSetLayout;
        }
コード例 #8
0
        void InitializeMesh()
        {
            // Generate meshes
            // Mg : Buffer

            var indicesInBytes  = (ulong)(sizeof(uint) * indicesVboData.Length);
            var vertexStride    = Marshal.SizeOf(typeof(Vector3));
            var verticesInBytes = (ulong)(vertexStride * positionVboData.Length);
            var bufferSize      = indicesInBytes + verticesInBytes;

            var bufferCreateInfo = new MgBufferCreateInfo
            {
                Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT | MgBufferUsageFlagBits.VERTEX_BUFFER_BIT,
                Size  = bufferSize,
            };

            var device = mConfiguration.Device;

            var result = device.CreateBuffer(bufferCreateInfo, null, out mBuffer);

            Debug.Assert(result == Result.SUCCESS);

            MgMemoryRequirements memReqs;

            device.GetBufferMemoryRequirements(mBuffer, out memReqs);

            const MgMemoryPropertyFlagBits memoryPropertyFlags = MgMemoryPropertyFlagBits.HOST_COHERENT_BIT;

            uint memoryTypeIndex;

            mConfiguration.Partition.GetMemoryType(
                memReqs.MemoryTypeBits, memoryPropertyFlags, out memoryTypeIndex);

            var memAlloc = new MgMemoryAllocateInfo
            {
                MemoryTypeIndex = memoryTypeIndex,
                AllocationSize  = memReqs.Size,
            };

            result = device.AllocateMemory(memAlloc, null, out mDeviceMemory);
            Debug.Assert(result == Result.SUCCESS);

            mBuffer.BindBufferMemory(device, mDeviceMemory, 0);

            // COPY INDEX DATA
            IntPtr dest;

            result = mDeviceMemory.MapMemory(device, 0, bufferSize, 0, out dest);
            Debug.Assert(result == Result.SUCCESS);

            var tempIndices = new byte[indicesInBytes];

            Buffer.BlockCopy(indicesVboData, 0, tempIndices, 0, (int)indicesInBytes);

            Marshal.Copy(tempIndices, 0, dest, (int)indicesInBytes);

            // COPY VERTEX DATA

            var vertexOffset = indicesInBytes;

            // Copy the struct to unmanaged memory.
            int offset = (int)vertexOffset;

            for (int i = 0; i < positionVboData.Length; ++i)
            {
                IntPtr localDest = IntPtr.Add(dest, offset);
                Marshal.StructureToPtr(positionVboData[i], localDest, false);
                offset += vertexStride;
            }

            mDeviceMemory.UnmapMemory(device);

            mIndices = new BufferInfo
            {
                Buffer       = mBuffer,
                DeviceMemory = mDeviceMemory,
                Offset       = 0,
                Length       = indicesInBytes,
            };

            mVertices = new BufferInfo
            {
                Buffer       = mBuffer,
                DeviceMemory = mDeviceMemory,
                Offset       = indicesInBytes,
                Length       = verticesInBytes,
            };
        }