public void Texture2D()
        {
            BlittableRGBA[] pixels = new BlittableRGBA[]
            {
                new BlittableRGBA(Color.Red), 
                new BlittableRGBA(Color.Green)
            };
            int sizeInBytes = ArraySizeInBytes.Size(pixels);
            Texture2DDescription description = new Texture2DDescription(2, 1, TextureFormat.RedGreenBlueAlpha8, false);

            using (GraphicsWindow window = Device.CreateWindow(1, 1))
            using (WritePixelBuffer writePixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, sizeInBytes))
            using (Texture2D texture = Device.CreateTexture2D(description))
            {
                writePixelBuffer.CopyFromSystemMemory(pixels);

                //
                // Create texture with pixel buffer
                //
                texture.CopyFromBuffer(writePixelBuffer, BlittableRGBA.Format, BlittableRGBA.Datatype);

                //
                // Read back pixels
                //
                using (ReadPixelBuffer readPixelBuffer = texture.CopyToBuffer(BlittableRGBA.Format, BlittableRGBA.Datatype))
                {
                    BlittableRGBA[] readPixels = readPixelBuffer.CopyToSystemMemory<BlittableRGBA>();

                    Assert.AreEqual(sizeInBytes, readPixelBuffer.SizeInBytes);
                    Assert.AreEqual(pixels[0], readPixels[0]);
                    Assert.AreEqual(pixels[1], readPixels[1]);
                    Assert.AreEqual(description, texture.Description);
                }
            }
        }
        /// <summary>
        /// Creates a 1x1 RGBA8 texture
        /// </summary>
        public static Texture2D CreateTexture(BlittableRGBA rgba)
        {
            Texture2DDescription description = new Texture2DDescription(1, 1, TextureFormat.RedGreenBlueAlpha8, false);
            Texture2D            texture     = Device.CreateTexture2D(description);

            BlittableRGBA[] pixels = new BlittableRGBA[] { rgba };

            using (WritePixelBuffer writePixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, ArraySizeInBytes.Size(pixels)))
            {
                writePixelBuffer.CopyFromSystemMemory(pixels);
                texture.CopyFromBuffer(writePixelBuffer, ImageFormat.RedGreenBlueAlpha, ImageDatatype.UnsignedByte);
            }

            return(texture);
        }
Exemple #3
0
        /// <summary>
        /// Creates a 1x1 RGBA8 texture
        /// </summary>
        public static Texture2D CreateTexture(BlittableRGBA rgba)
        {
            Texture2DDescription description = new Texture2DDescription(1, 1, TextureFormat.RedGreenBlueAlpha8, false);
            Texture2D texture = Device.CreateTexture2D(description);

            BlittableRGBA[] pixels = new BlittableRGBA[] { rgba };

            using (WritePixelBuffer writePixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, ArraySizeInBytes.Size(pixels)))
            {
                writePixelBuffer.CopyFromSystemMemory(pixels);
                texture.CopyFromBuffer(writePixelBuffer, ImageFormat.RedGreenBlueAlpha, ImageDatatype.UnsignedByte);
            }

            return texture;
        }
Exemple #4
0
        private void UpdateAll(Context context)
        {
            //
            // Since billboards were added or removed, all billboards are
            // rewritten so dirty billboards are automatically cleaned.
            //
            _dirtyBillboards.Clear();

            //
            // Create vertex array with appropriately sized vertex buffers
            //
            DisposeVertexArray();

            if (_billboards.Count != 0)
            {
                CreateVertexArray(context);

                //
                // Write vertex buffers
                //
                Vector3F[]      positions          = new Vector3F[_billboards.Count];
                Vector4H[]      textureCoordinates = new Vector4H[_billboards.Count];
                BlittableRGBA[] colors             = new BlittableRGBA[_billboards.Count];
                byte[]          origins            = new byte[_billboards.Count];
                Vector2H[]      pixelOffets        = new Vector2H[_billboards.Count];

                for (int i = 0; i < _billboards.Count; ++i)
                {
                    Billboard b = _billboards[i];

                    positions[i]          = b.Position.ToVector3F();
                    textureCoordinates[i] = new Vector4H(
                        b.TextureCoordinates.LowerLeft.X, b.TextureCoordinates.LowerLeft.Y,
                        b.TextureCoordinates.UpperRight.X, b.TextureCoordinates.UpperRight.Y);
                    colors[i]      = new BlittableRGBA(b.Color);
                    origins[i]     = BillboardOrigin(b);
                    pixelOffets[i] = b.PixelOffset;

                    b.VertexBufferOffset = i;
                    b.Dirty = false;
                }
                CopyBillboardsFromSystemMemory(positions, textureCoordinates, colors, origins, pixelOffets, 0, _billboards.Count);

                _rewriteBillboards = false;
            }
        }
Exemple #5
0
        private void UpdateDirty()
        {
            // PERFORMANCE:  Sort by buffer offset
            // PERFORMANCE:  Map buffer range
            // PERFORMANCE:  Round robin multiple buffers

            Vector3F[]      positions          = new Vector3F[_dirtyBillboards.Count];
            Vector4H[]      textureCoordinates = new Vector4H[_dirtyBillboards.Count];
            BlittableRGBA[] colors             = new BlittableRGBA[_dirtyBillboards.Count];
            byte[]          origins            = new byte[_dirtyBillboards.Count];
            Vector2H[]      pixelOffets        = new Vector2H[_dirtyBillboards.Count];

            int bufferOffset         = _dirtyBillboards[0].VertexBufferOffset;
            int previousBufferOffset = bufferOffset - 1;
            int length = 0;

            for (int i = 0; i < _dirtyBillboards.Count; ++i)
            {
                Billboard b = _dirtyBillboards[i];

                if (previousBufferOffset != b.VertexBufferOffset - 1)
                {
                    CopyBillboardsFromSystemMemory(positions, textureCoordinates, colors, origins, pixelOffets, bufferOffset, length);

                    bufferOffset = b.VertexBufferOffset;
                    length       = 0;
                }

                positions[length]          = b.Position.ToVector3F();
                textureCoordinates[length] = new Vector4H(
                    b.TextureCoordinates.LowerLeft.X, b.TextureCoordinates.LowerLeft.Y,
                    b.TextureCoordinates.UpperRight.X, b.TextureCoordinates.UpperRight.Y);
                colors[length]      = new BlittableRGBA(b.Color);
                origins[length]     = BillboardOrigin(b);
                pixelOffets[length] = b.PixelOffset;
                ++length;

                previousBufferOffset = b.VertexBufferOffset;
                b.Dirty = false;
            }
            CopyBillboardsFromSystemMemory(positions, textureCoordinates, colors, origins, pixelOffets, bufferOffset, length);

            _dirtyBillboards.Clear();
        }
 public TextureFactory(Context context, BlittableRGBA rgba)
 {
     _context = context;
     _rgba = rgba;
 }
        public void WritePixelBuffer()
        {
            BlittableRGBA[] pixels = new BlittableRGBA[]
            {
                new BlittableRGBA(Color.Red), 
                new BlittableRGBA(Color.Green), 
                new BlittableRGBA(Color.Blue), 
                new BlittableRGBA(Color.White)
            };
            int sizeInBytes = ArraySizeInBytes.Size(pixels);

            using (GraphicsWindow window = Device.CreateWindow(1, 1))
            using (WritePixelBuffer pixelBuffer = Device.CreateWritePixelBuffer(PixelBufferHint.Stream, sizeInBytes))
            {
                //
                // Verify creating pixel buffer
                //
                Assert.IsNotNull(pixelBuffer);
                Assert.AreEqual(PixelBufferHint.Stream, pixelBuffer.UsageHint);
                Assert.AreEqual(sizeInBytes, pixelBuffer.SizeInBytes);

                //
                // Verify copying entire buffer between system memory and pixel buffer
                //
                pixelBuffer.CopyFromSystemMemory(pixels);

                BlittableRGBA[] pixels2 = pixelBuffer.CopyToSystemMemory<BlittableRGBA>(0, pixelBuffer.SizeInBytes);
                Assert.AreEqual(pixels[0], pixels2[0]);
                Assert.AreEqual(pixels[1], pixels2[1]);
                Assert.AreEqual(pixels[2], pixels2[2]);

                //
                // Verify modiying a subset of the vertex buffer
                //
                BlittableRGBA modifiedPixel = new BlittableRGBA(Color.Black);
                pixelBuffer.CopyFromSystemMemory(new[] { modifiedPixel }, SizeInBytes<BlittableRGBA>.Value);

                BlittableRGBA[] pixels3 = pixelBuffer.CopyToSystemMemory<BlittableRGBA>(0, pixelBuffer.SizeInBytes);
                Assert.AreEqual(pixels[0], pixels3[0]);
                Assert.AreEqual(modifiedPixel, pixels3[1]);
                Assert.AreEqual(pixels[2], pixels3[2]);
            }
        }