Example #1
0
        public void DrawQuad(Texture2D texture,
                             VertexPosition2TextureColor bl,
                             VertexPosition2TextureColor br,
                             VertexPosition2TextureColor tr,
                             VertexPosition2TextureColor tl)
        {
            if (!_active)
            {
                throw new InvalidOperationException("Begin() must be called before SpriteBatch may be used for drawing.");
            }

            if (texture == null)
            {
                throw new ArgumentNullException(nameof(texture));
            }

            FlushIfNeeded(texture);

            _count++;
            EnsureBufferLargeEnough();

            int vertexOffset = (_count - 1) * 4;
            int indexOffset  = (_count - 1) * 6;

            _vertexData[vertexOffset + 0] = bl;
            _vertexData[vertexOffset + 1] = br;
            _vertexData[vertexOffset + 2] = tr;
            _vertexData[vertexOffset + 3] = tl;

            _indexData[indexOffset + 0] = (ushort)(vertexOffset + 0);
            _indexData[indexOffset + 1] = (ushort)(vertexOffset + 1);
            _indexData[indexOffset + 2] = (ushort)(vertexOffset + 2);
            _indexData[indexOffset + 3] = (ushort)(vertexOffset + 0);
            _indexData[indexOffset + 4] = (ushort)(vertexOffset + 2);
            _indexData[indexOffset + 5] = (ushort)(vertexOffset + 3);
        }
Example #2
0
        private unsafe void EnsureBufferLargeEnough()
        {
            if (_count * 4 > _vertexBufferSize)
            {
                //_log.Debug("SpriteBatch capacity increased from " + _vertexBufferSize + " to " + (int)(_vertexBufferSize * 1.5f));
                _vertexBufferSize = (int)(_vertexBufferSize * 1.5f);    // To increase capacity
                _indexBufferSize  = (int)(_vertexBufferSize * 1.5f);    // To have 2:3 ratio from vertex to index

                if (_vertexBufferSize > MAX_BATCH_SIZE * 4)
                {
                    _vertexBufferSize = MAX_BATCH_SIZE * 4;
                }

                if (_indexBufferSize > MAX_BATCH_SIZE * 6)
                {
                    _indexBufferSize = MAX_BATCH_SIZE * 6;
                }

                // Increase capacity of _vertexData
                var tempVertexData = new VertexPosition2TextureColor[_vertexData.Length];

                fixed(void *vertexSourcePtr = &_vertexData[0])
                fixed(void *vertexDestPtr = &tempVertexData[0])
                {
                    System.Buffer.MemoryCopy(vertexSourcePtr,
                                             vertexDestPtr,
                                             tempVertexData.Length * sizeof(VertexPosition2TextureColor),
                                             _vertexData.Length * sizeof(VertexPosition2TextureColor));
                }

                // Increase vertexData capacity
                _vertexData = new VertexPosition2TextureColor[_vertexBufferSize];

                fixed(void *vertexSourcePtr = &tempVertexData[0])
                fixed(void *vertexDestPtr = &_vertexData[0])
                {
                    // Store vertex data from temp array back into _vertexData
                    System.Buffer.MemoryCopy(vertexSourcePtr,
                                             vertexDestPtr,
                                             tempVertexData.Length * sizeof(VertexPosition2TextureColor),
                                             tempVertexData.Length * sizeof(VertexPosition2TextureColor));
                }

                // Increase capacity of _indexData

                var tempIndexData = new ushort[_indexData.Length];

                fixed(void *indexSourcePtr = &_indexData[0])
                fixed(void *indexDestPtr = &tempIndexData[0])
                {
                    // Store vertex data in temp array
                    System.Buffer.MemoryCopy(indexSourcePtr,
                                             indexDestPtr,
                                             _indexData.Length * sizeof(ushort),
                                             _indexData.Length * sizeof(ushort));
                }

                // Increase indexData capacity
                _indexData = new ushort[_indexBufferSize];

                fixed(void *indexSourcePtr = &tempIndexData[0])
                fixed(void *indexDestPtr = &_indexData[0])
                {
                    // Store vertex data from temp array back into _vertexData
                    System.Buffer.MemoryCopy(indexSourcePtr,
                                             indexDestPtr,
                                             tempIndexData.Length * sizeof(ushort),
                                             tempIndexData.Length * sizeof(ushort));
                }

                CreateVertexBuffer();
                CreateIndexBuffer();
            }
        }