Пример #1
0
        /// <summary>
        /// Construct an ElementBufferObject.
        /// </summary>
        /// <param name="elementType">
        /// The <see cref="DrawElementsType"/> that specify how vertices are interpreted.
        /// </param>
        /// <param name="usageMask">
        /// An <see cref="MapBufferUsageMask"/> that specify the buffer storage usage mask.
        /// </param>
        public ElementBuffer(DrawElementsType elementType, MapBufferUsageMask usageMask) :
            base(BufferTarget.ElementArrayBuffer, usageMask)
        {
            try {
                ElementsType = elementType;
                // Determine ElementsType and default RestartIndexKey
                switch (elementType)
                {
                case DrawElementsType.UnsignedByte:
                    ItemSize        = 1;
                    RestartIndexKey = 0x000000FF;
                    break;

                case DrawElementsType.UnsignedShort:
                    ItemSize        = 2;
                    RestartIndexKey = 0x0000FFFF;
                    break;

                case DrawElementsType.UnsignedInt:
                    ItemSize        = 4;
                    RestartIndexKey = 0xFFFFFFFF;
                    break;

                default:
                    throw new ArgumentException("type not supported", "elementType");
                }
            } catch {
                // Avoid finalizer assertion failure (don't call dispose since it's virtual)
                GC.SuppressFinalize(this);
                throw;
            }
        }
Пример #2
0
        /// <summary>
        /// Construct an ElementBufferObject.
        /// </summary>
        /// <param name="elementType">
        ///
        /// </param>
        /// <param name="usageMask">
        /// An <see cref="MapBufferUsageMask"/> that specify the buffer storage usage mask.
        /// </param>
        protected ElementBuffer(Type elementType, MapBufferUsageMask usageMask) :
            base(BufferTarget.ElementArrayBuffer, usageMask)
        {
            try {
                // Determine ElementsType and default RestartIndexKey
                switch (Type.GetTypeCode(elementType))
                {
                case TypeCode.Byte:
                    ElementsType    = DrawElementsType.UnsignedByte;
                    ItemSize        = 1;
                    RestartIndexKey = 0x000000FF;
                    break;

                case TypeCode.UInt16:
                    ElementsType    = DrawElementsType.UnsignedShort;
                    ItemSize        = 2;
                    RestartIndexKey = 0x0000FFFF;
                    break;

                case TypeCode.UInt32:
                    ElementsType    = DrawElementsType.UnsignedInt;
                    ItemSize        = 4;
                    RestartIndexKey = 0xFFFFFFFF;
                    break;

                default:
                    throw new ArgumentException("type not supported", nameof(elementType));
                }
            } catch {
                // Avoid finalizer assertion failure (don't call dispose since it's virtual)
                GC.SuppressFinalize(this);
                throw;
            }
        }
Пример #3
0
 /// <summary>
 /// Construct a Buffer determining its type, data usage and transfer mode.
 /// </summary>
 /// <param name="type">
 /// A <see cref="BufferTarget"/> that specify the buffer object type.
 /// </param>
 /// <param name="usageMask">
 /// An <see cref="MapBufferUsageMask"/> that specify the buffer storage usage mask.
 /// </param>
 protected Buffer(BufferTarget type, MapBufferUsageMask usageMask)
 {
     // Store the buffer object type
     Target = type;
     // Store the buffer data usage hints
     Hint = UsageMaskToHint(usageMask);
     // Guess appropriate storage flags
     _UsageMask = usageMask;
 }
Пример #4
0
 /// <summary>
 /// Construct an ArrayBufferObjectBase.
 /// </summary>
 /// <param name="bufferTarget">
 /// A <see cref="BufferTarget"/> that specify the buffer target.
 /// </param>
 /// <param name="itemSize">
 /// A <see cref="uint"/> that specifies the size of a single item, in bytes.
 /// </param>
 /// <param name="usageMask">
 /// A <see cref="MapBufferUsageMask"/> that specifies the data buffer usage mask.
 /// </param>
 protected ArrayBufferBase(BufferTarget bufferTarget, uint itemSize, MapBufferUsageMask usageMask) :
     base(bufferTarget, usageMask)
 {
     if (itemSize == 0)
     {
         throw new ArgumentException("invalid", nameof(itemSize));
     }
     ItemSize = itemSize;
 }
Пример #5
0
        /// <summary>
        /// Construct a immutable Buffer determining its type, data usage and storage mode.
        /// </summary>
        /// <param name="type">
        /// A <see cref="BufferTarget"/> that specify the buffer object type.
        /// </param>
        /// <param name="usageMask">
        /// An <see cref="MapBufferUsageMask"/> that specify the buffer storage usage mask.
        /// </param>
        protected Buffer(BufferTarget type, MapBufferUsageMask usageMask)
        {
            // Store the buffer object type
            Target = type;
            // Store the buffer usage mask
            UsageMask = usageMask;
            // Let be immutable
            Immutable = true;

            // Guess appropriate hint flags
            // Note: this flag is not actually used when buffer is immutable
            Hint = BufferUsage.StaticDraw;
        }
Пример #6
0
 /// <summary>
 /// Construct an immutable ArrayBufferInterleaved specifying its item layout on GPU side.
 /// </summary>
 /// <param name="usageMask">
 /// A <see cref="MapBufferUsageMask"/> that specifies the data buffer usage mask.
 /// </param>
 public ArrayBufferInterleaved(MapBufferUsageMask usageMask) :
     base(BufferTarget.ArrayBuffer, (uint)Marshal.SizeOf(typeof(T)), usageMask)
 {
     try {
         // Detect interleaved fields using reflection (cached)
         List <InterleavedSectionBase> typeSections = ScanTypeSections();
         // Get array sections for this instance
         _InterleavedSections = typeSections.ConvertAll(item => new InterleavedSection(this, item));
     } catch {
         // Avoid finalizer assertion failure (don't call dispose since it's virtual)
         GC.SuppressFinalize(this);
         throw;
     }
 }
Пример #7
0
        /// <summary>
        /// Get the <see cref="BufferHint"/> corresponding to a <see cref="MapBufferUsageMask"/>.
        /// </summary>
        /// <param name="hint"></param>
        /// <returns></returns>
        private static BufferUsage UsageMaskToHint(MapBufferUsageMask usageMask)
        {
            BufferUsage hint = BufferUsage.StaticDraw;

            // Common usage: map for writing before rendering
            if ((usageMask & MapBufferUsageMask.MapWriteBit) != 0)
            {
                hint = BufferUsage.DynamicDraw;
            }
            // Common usage: transform feedback
            if ((usageMask & MapBufferUsageMask.MapReadBit) != 0)
            {
                hint = BufferUsage.DynamicRead;
            }

            return(hint);
        }
Пример #8
0
        /// <summary>
        /// Create an <see cref="UniformBuffer"/> useful for backing with a buffer object the specified uniform block.
        /// </summary>
        /// <param name="uniformBlockName"></param>
        /// <param name="usageMask"></param>
        /// <returns></returns>
        public UniformBuffer CreateUniformBlock(string uniformBlockName, MapBufferUsageMask usageMask)
        {
            UniformBlockBinding uniformBlockBinding = GetUniformBlock(uniformBlockName);

            if (uniformBlockBinding == null)
            {
                throw new ArgumentException("no uniform block with such name", "uniformBlockName");
            }

            UniformBuffer uniformBuffer = new UniformBuffer(usageMask);

            // Allocate client storage
            uniformBuffer.Create(uniformBlockBinding.DataSize);
            // Map uniform names with
            MapUniformBlock(uniformBlockName, uniformBuffer);

            return(uniformBuffer);
        }
Пример #9
0
 /// <summary>
 /// Construct an ArrayBufferObjectInterleaved specifying its item layout on GPU side.
 /// </summary>
 /// <param name="usageMask">
 /// A <see cref="MapBufferUsageMask"/> that specifies the data buffer usage mask.
 /// </param>
 public ArrayBufferObjectInterleaved(MapBufferUsageMask usageMask) :
     base(usageMask)
 {
     try {
         // Determine array item size
         ItemSize = (uint)Marshal.SizeOf(typeof(T));
         // Detect interleaved fields using reflection (cached)
         List <InterleavedSectionBase> typeSections = ScanTypeSections();
         // Get array sections for this instance
         _InterleavedSections = typeSections.ConvertAll(delegate(InterleavedSectionBase item) {
             return(new InterleavedSection(this, item));
         });
     } catch {
         // Avoid finalizer assertion failure (don't call dispose since it's virtual)
         GC.SuppressFinalize(this);
         throw;
     }
 }
Пример #10
0
 public static void NamedBufferStorageEXT(uint buffer, IntPtr offset, uint size, IntPtr clientBuffer, MapBufferUsageMask flags)
 {
     Debug.Assert(Delegates.pglNamedBufferStorageExternalEXT != null, "pglNamedBufferStorageExternalEXT not implemented");
     Delegates.pglNamedBufferStorageExternalEXT(buffer, offset, size, clientBuffer, (uint)flags);
     LogCommand("glNamedBufferStorageExternalEXT", null, buffer, offset, size, clientBuffer, flags);
     DebugCheckErrors(null);
 }
Пример #11
0
 /// <summary>
 /// Construct an ShaderStorageBuffer.
 /// </summary>
 /// <param name="usageMask">
 /// A <see cref="MapBufferUsageMask"/> that specifies the data buffer usage mask.
 /// </param>
 public ShaderStorageBuffer(MapBufferUsageMask usageMask) :
     base(BufferTarget.ShaderStorageBuffer, usageMask)
 {
 }
Пример #12
0
        public static void BufferStorage(BufferTarget target, uint size, object data, MapBufferUsageMask flags)
        {
            GCHandle pin_data = GCHandle.Alloc(data, GCHandleType.Pinned);

            try {
                BufferStorage(target, size, pin_data.AddrOfPinnedObject(), flags);
            } finally {
                pin_data.Free();
            }
        }
Пример #13
0
 public static void BufferStorage(BufferTarget target, uint size, IntPtr data, MapBufferUsageMask flags)
 {
     Debug.Assert(Delegates.pglBufferStorage != null, "pglBufferStorage not implemented");
     Delegates.pglBufferStorage((int)target, size, data, (uint)flags);
     LogCommand("glBufferStorage", null, target, size, data, flags);
     DebugCheckErrors(null);
 }
Пример #14
0
 /// <summary>
 /// Construct an ElementBufferObject.
 /// </summary>
 /// <param name="elementType">
 /// The <see cref="DrawElementsType"/> that specify how vertices are interpreted.
 /// </param>
 /// <param name="usageMask">
 /// An <see cref="MapBufferUsageMask"/> that specify the buffer storage usage mask.
 /// </param>
 public ElementBuffer(DrawElementsType elementType, MapBufferUsageMask usageMask) :
     base(BufferTarget.ElementArrayBuffer, GetItemSize(elementType), usageMask)
 {
     ElementsType    = elementType;
     RestartIndexKey = GetDefaultRestartIndex(elementType);
 }
Пример #15
0
 /// <summary>
 /// Construct an UniformBufferObject.
 /// </summary>
 /// <param name="usageMask">
 /// An <see cref="MapBufferUsageMask"/> that specify the buffer storage usage mask.
 /// </param>
 public UniformBuffer(MapBufferUsageMask usageMask) :
     base(BufferTarget.UniformBuffer, usageMask)
 {
 }