Exemplo n.º 1
0
        /// <summary>
        /// Function to copy the contents of a byte array into the memory pointed at by the pointer.
        /// </summary>
        /// <typeparam name="T">Type of data in the array.</typeparam>
        /// <param name="destination">Destination pointer.</param>
        /// <param name="source">Source array to copy from.</param>
        /// <param name="sourceIndex">Index to start copying from in the source array.</param>
        /// <param name="size">Number of bytes to copy.</param>
        /// <remarks>Since a pointer doesn't have a size associated with it, care must be taken to not overstep the bounds of the data pointed at by the pointer.</remarks>
        /// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="source"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown if the size + sourceIndex is greater than the number of elements in the source parameter.
        /// <para>-or-</para>
        /// <para>Thrown if the sourceIndex is less than 0.</para>
        /// </exception>
        public static void CopyFrom <T>(this IntPtr destination, T[] source, int sourceIndex, int size)
            where T : struct
        {
#if DEBUG
            int typeSize = DirectAccess.SizeOf <T>();

            if (destination == IntPtr.Zero)
            {
                throw new ArgumentNullException("destination");
            }

            if (source == null)
            {
                throw new ArgumentNullException("source");
            }

            if (sourceIndex < 0)
            {
                throw new ArgumentOutOfRangeException("sourceIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, sourceIndex,
                                                                    source.Length));
            }

            if ((sourceIndex * typeSize) + size > source.Length * typeSize)
            {
                throw new ArgumentOutOfRangeException("sourceIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE,
                                                                    sourceIndex * typeSize + size,
                                                                    source.Length));
            }
#endif

            DirectAccess.WriteArray(destination, source, sourceIndex, size);
        }
Exemplo n.º 2
0
        /// <summary>
        /// Function to copy the contents of a byte array into the memory pointed at by the pointer.
        /// </summary>
        /// <param name="destination">Destination pointer.</param>
        /// <param name="source">Source array to copy from.</param>
        /// <param name="sourceIndex">Index to start copying from in the source array.</param>
        /// <param name="size">Number of bytes to copy.</param>
        /// <remarks>Since a pointer doesn't have a size associated with it, care must be taken to not overstep the bounds of the data pointed at by the pointer.</remarks>
        /// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="source"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown if the size + sourceIndex is greater than the number of elements in the source parameter.
        /// <para>-or-</para>
        /// <para>Thrown if the sourceIndex is less than 0.</para>
        /// </exception>
        public static void CopyFrom(this IntPtr destination, byte[] source, int sourceIndex, int size)
        {
            if (destination == IntPtr.Zero)
            {
                return;
            }

#if DEBUG
            if (destination == IntPtr.Zero)
            {
                throw new ArgumentNullException("destination");
            }

            if (source == null)
            {
                throw new ArgumentNullException("destination");
            }

            if (sourceIndex < 0)
            {
                throw new ArgumentOutOfRangeException("sourceIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, sourceIndex,
                                                                    source.Length));
            }

            if (sourceIndex + size > source.Length)
            {
                throw new ArgumentOutOfRangeException("sourceIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, sourceIndex + size,
                                                                    source.Length));
            }
#endif

            DirectAccess.WriteArray(destination, source, sourceIndex, size);
        }
Exemplo n.º 3
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WorldViewProjection"/> class.
        /// </summary>
        /// <param name="graphics">The graphics interface to use.</param>
        public WorldViewProjection(GorgonGraphics graphics)
        {
            Matrix dummy = Matrix.Identity;

            _projViewBuffer = graphics.Buffers.CreateConstantBuffer("WVPBuffer",
                                                                    new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <ViewProjectionData>(),
                Usage       = BufferUsage.Default
            });

            _viewProj = new ViewProjectionData
            {
                Projection     = Matrix.Identity,
                View           = Matrix.Identity,
                ViewProjection = Matrix.Identity
            };

            _projViewBuffer.Update(ref _viewProj);

            _worldBuffer = graphics.Buffers.CreateConstantBuffer("WorldBuffer", ref dummy, BufferUsage.Default);

            _camData.CameraLookAt = new Vector3(0, 0, -1.0f);
            _camData.CameraUp     = new Vector3(0, 1, 0);
            _cameraBuffer         = graphics.Buffers.CreateConstantBuffer("CameraBuffer", ref _camData, BufferUsage.Default);

            graphics.Shaders.VertexShader.ConstantBuffers[0] = _projViewBuffer;
            graphics.Shaders.VertexShader.ConstantBuffers[1] = _worldBuffer;
            graphics.Shaders.PixelShader.ConstantBuffers[0]  = _cameraBuffer;
        }
Exemplo n.º 4
0
        /// <summary>
        /// Function to update the buffer with data.
        /// </summary>
        /// <typeparam name="T">Type of data, must be a value type.</typeparam>
        /// <param name="values">Values to write to the buffer.</param>
        /// <param name="offset">Offset in the buffer, in bytes, to write at.</param>
        /// <param name="deferred">[Optional] The deferred context used to update the buffer.</param>
        /// <remarks>This method can only be used with buffers that have Default usage.  Other buffer usages will thrown an exception.
        /// <para>
        /// If the <paramref name="deferred"/> parameter is NULL (Nothing in VB.Net), the immediate context will be used to update the buffer.  If it is non-NULL, then it
        /// will use the specified deferred context.
        /// <para>If you are using a deferred context, it is necessary to use that context to update the buffer because 2 threads may not access the same resource at the same time.
        /// Passing a separate deferred context will alleviate that.</para>
        /// </para>
        /// </remarks>
        /// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="values"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="GorgonLibrary.GorgonException">Thrown when the buffer usage is not set to default.</exception>
        public void Update <T>(T[] values, int offset, GorgonGraphics deferred = null)
            where T : struct
        {
            GorgonDebug.AssertNull(values, "values");

#if DEBUG
            if (Settings.Usage != BufferUsage.Default)
            {
                throw new GorgonException(GorgonResult.AccessDenied, Resources.GORGFX_NOT_DEFAULT_USAGE);
            }
#endif
            if (deferred == null)
            {
                deferred = Graphics;
            }

            deferred.Context.UpdateSubresource(values, D3DResource, 0, 0, 0, new D3D11.ResourceRegion
            {
                Left   = offset,
                Right  = offset + DirectAccess.SizeOf <T>() * values.Length,
                Top    = 0,
                Bottom = 1,
                Front  = 0,
                Back   = 1
            });
        }
Exemplo n.º 5
0
        /// <summary>
        /// Function to register a raw input device.
        /// </summary>
        /// <param name="device">Device information.</param>
        /// <returns>TRUE if successful, FALSE if not.</returns>
        public static bool RegisterRawInputDevices(RAWINPUTDEVICE device)
        {
            var devices = new RAWINPUTDEVICE[1];                        // Raw input devices.

            devices[0] = device;
            return(RegisterRawInputDevices(devices, 1, DirectAccess.SizeOf <RAWINPUTDEVICE>()));
        }
Exemplo n.º 6
0
        /// <summary>
        /// Function to copy the contents of the pointer to a byte array.
        /// </summary>
        /// <typeparam name="T">Type of data in the array.</typeparam>
        /// <param name="source">Source pointer.</param>
        /// <param name="destination">Destination array of bytes.</param>
        /// <param name="destinationIndex">Index in the array to start writing at.</param>
        /// <param name="size">Size of the data to copy, in bytes.</param>
        /// <remarks>Since a pointer doesn't have a size associated with it, care must be taken to not overstep the bounds of the data pointed at by the pointer.</remarks>
        /// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="destination"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown if the size + destinationIndex is greater than the number of elements in the destination parameter.
        /// <para>-or-</para>
        /// <para>Thrown if the destinationIndex is less than 0.</para>
        /// </exception>
        public static void CopyTo <T>(this IntPtr source, T[] destination, int destinationIndex, int size)
            where T : struct
        {
#if DEBUG
            int sizeInBytes = DirectAccess.SizeOf <T>();

            if (source == IntPtr.Zero)
            {
                throw new ArgumentNullException("source");
            }

            if (destination == null)
            {
                throw new ArgumentNullException("destination");
            }

            if (destinationIndex < 0)
            {
                throw new ArgumentOutOfRangeException("destinationIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, destinationIndex, destination.Length * sizeInBytes));
            }

            if ((destinationIndex * sizeInBytes) + size > destination.Length * DirectAccess.SizeOf <T>())
            {
                throw new ArgumentOutOfRangeException("destinationIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, destinationIndex + size, destination.Length * sizeInBytes));
            }
#endif

            DirectAccess.ReadArray(source, destination, destinationIndex, size);
        }
Exemplo n.º 7
0
        /// <summary>
        /// Function to determine if this codec can read the file or not.
        /// </summary>
        /// <param name="stream">Stream used to read the file information.</param>
        /// <returns>
        /// TRUE if the codec can read the file, FALSE if not.
        /// </returns>
        /// <exception cref="System.IO.IOException">Thrown when the <paramref name="stream"/> is write-only or if the stream cannot perform seek operations.</exception>
        /// <exception cref="System.IO.EndOfStreamException">Thrown when an attempt to read beyond the end of the stream is made.</exception>
        public override bool IsReadable(Stream stream)
        {
            TGAHeader header;
            long      position = 0;

            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            if (!stream.CanRead)
            {
                throw new IOException(Resources.GORGFX_STREAM_READ_ONLY);
            }

            if (!stream.CanSeek)
            {
                throw new IOException(Resources.GORGFX_STREAM_NO_SEEK);
            }

            if (stream.Length - stream.Position < DirectAccess.SizeOf <TGAHeader>())
            {
                return(false);
            }

            try
            {
                position = stream.Position;
                var reader = new GorgonBinaryReader(stream, true);
                header = reader.ReadValue <TGAHeader>();
            }
            finally
            {
                stream.Position = position;
            }

            if ((header.ColorMapType != 0) || (header.ColorMapLength != 0))
            {
                return(false);
            }

            if ((header.Descriptor & (TGADescriptor.Interleaved2Way | TGADescriptor.Interleaved4Way)) != 0)
            {
                return(false);
            }

            if ((header.Width <= 0) || (header.Height <= 0))
            {
                return(false);
            }

            if ((header.ImageType != TGAImageType.TrueColor) && (header.ImageType != TGAImageType.TrueColorRLE) &&
                (header.ImageType != TGAImageType.BlackAndWhite) && (header.ImageType != TGAImageType.BlackAndWhiteRLE))
            {
                return(false);
            }

            return(((header.ImageType != TGAImageType.BlackAndWhite) && (header.ImageType != TGAImageType.BlackAndWhiteRLE)) ||
                   (header.BPP == 8));
        }
Exemplo n.º 8
0
        /// <summary>
        /// Function to set application specific data on the resource.
        /// </summary>
        /// <typeparam name="T">Type of data to copy into the resource.  The data must be a value type.</typeparam>
        /// <param name="guid">GUID to associate with the data.</param>
        /// <param name="data">Data to set.</param>
        /// <remarks>Set <paramref name="data"/> to NULL (Nothing in VB.Net) to remove the data from the resource.</remarks>
        public void SetApplicationData <T>(Guid guid, T?data)
            where T : struct
        {
            IntPtr dataPtr = IntPtr.Zero;

            if (D3DResource == null)
            {
                return;
            }

            int bytes = DirectAccess.SizeOf <T>();

            try
            {
                if (data != null)
                {
                    T value = data.Value;
                    dataPtr = Marshal.AllocHGlobal(bytes);
                    dataPtr.Write(ref value);
                    D3DResource.SetPrivateData(guid, bytes, dataPtr);
                }
                else
                {
                    D3DResource.SetPrivateData(guid, 0, IntPtr.Zero);
                }
            }
            finally
            {
                if (dataPtr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(dataPtr);
                }
            }
        }
Exemplo n.º 9
0
        /// <summary>
        /// Initializes a new instance of the <see cref="WorldViewProjection"/> class.
        /// </summary>
        /// <param name="graphics">The graphics interface to use.</param>
        public Light(GorgonGraphics graphics)
        {
            _lightData[0].Attenuation   = 6.0f;
            _lightData[0].LightColor    = GorgonColor.White;
            _lightData[0].LightPosition = Vector3.Zero;
            _lightData[0].SpecularColor = GorgonColor.White;
            _lightData[0].SpecularPower = 512.0f;

            _buffer = graphics.Buffers.CreateConstantBuffer("LightBuffer",
                                                            new GorgonConstantBufferSettings
            {
                SizeInBytes = LightData.Size * _lightData.Length,
                Usage       = BufferUsage.Default
            });

            _lightStore = new GorgonDataStream(_buffer.SizeInBytes);
            unsafe
            {
                DirectAccess.ZeroMemory(_lightStore.UnsafePointer, _buffer.SizeInBytes);
                var data = (LightData *)_lightStore.UnsafePointer;
                *   data = _lightData[0];
            }

            _buffer.Update(_lightStore);

            graphics.Shaders.PixelShader.ConstantBuffers[1] = _buffer;
        }
Exemplo n.º 10
0
        /// <summary>
        /// Function to return application specific data from the resource.
        /// </summary>
        /// <typeparam name="T">Type of data to copy into the resource.  The data must be a value type.</typeparam>
        /// <param name="guid">GUID to associate with the data.</param>
        /// <returns>The application specific data stored in the resource, or NULL.</returns>
        public T?GetApplicationData <T>(Guid guid)
            where T : struct
        {
            IntPtr dataPtr = IntPtr.Zero;

            if (D3DResource == null)
            {
                return(null);
            }

            try
            {
                int bytes = DirectAccess.SizeOf <T>();
                dataPtr = Marshal.AllocHGlobal(bytes);

                if (dataPtr == IntPtr.Zero)
                {
                    return(null);
                }

                D3DResource.GetPrivateData(guid, ref bytes, dataPtr);
                T result;
                dataPtr.Read(out result);

                return(result);
            }
            finally
            {
                if (dataPtr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(dataPtr);
                }
            }
        }
Exemplo n.º 11
0
        /// <summary>
        /// Function to create a index buffer.
        /// </summary>
        /// <param name="name">The name of the buffer.</param>
        /// <param name="data">Data used to initialize the buffer.</param>
        /// <param name="usage">[Optional] Usage of the buffer.</param>
        /// <param name="is32Bit">[Optional] TRUE to indicate that we're using 32 bit indices, FALSE to use 16 bit indices </param>
        /// <typeparam name="T">Type of data in the array.  Must be a value type.</typeparam>
        /// <returns>A new index buffer.</returns>
        /// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="name"/> is NULL (Nothing in VB.Net).
        /// <para>-or-</para>
        /// <para>Thrown when the <paramref name="data"/> parameter is NULL.</para>
        /// </exception>
        /// <exception cref="GorgonLibrary.GorgonException">Thrown when the buffer could not be created.</exception>
        /// <exception cref="System.ArgumentException">Thrown when the <paramref name="name"/> parameter is empty.</exception>
        /// <remarks>If creating an immutable index buffer, be sure to pre-populate it via the initialData parameter.
        /// <para>This method should only be called from an immediate graphics context, if it is called from a deferred context an exception will be thrown.</para>
        /// </remarks>
        public GorgonIndexBuffer CreateIndexBuffer <T>(string name, T[] data, BufferUsage usage = BufferUsage.Default, bool is32Bit = true)
            where T : struct
        {
            if (data == null)
            {
                throw new ArgumentNullException("data");
            }

            if (data.Length == 0)
            {
                throw new ArgumentException(Resources.GORGFX_PARAMETER_MUST_NOT_BE_EMPTY, "data");
            }

            int size = data.Length * DirectAccess.SizeOf <T>();

            using (var dataStream = new GorgonDataStream(data))
            {
                return(CreateIndexBuffer(name, new GorgonIndexBufferSettings
                {
                    SizeInBytes = size,
                    IsOutput = false,
                    Usage = usage,
                    Use32BitIndices = is32Bit
                }, dataStream));
            }
        }
Exemplo n.º 12
0
        /// <summary>
        /// Function to enumerate raw input devices.
        /// </summary>
        /// <returns>An array of raw input device structures.</returns>
        public unsafe static RAWINPUTDEVICELIST[] EnumerateInputDevices()
        {
            int deviceCount = 0;
            int structSize  = DirectAccess.SizeOf <RAWINPUTDEVICELIST>();

            if (GetRawInputDeviceList(IntPtr.Zero, ref deviceCount, structSize) < 0)
            {
                throw new Win32Exception();
            }

            if (deviceCount == 0)
            {
                return(new RAWINPUTDEVICELIST[0]);
            }

            RAWINPUTDEVICELIST *deviceListPtr = stackalloc RAWINPUTDEVICELIST[deviceCount];

            if (GetRawInputDeviceList((IntPtr)deviceListPtr, ref deviceCount, structSize) < 0)
            {
                throw new Win32Exception();
            }

            var result = new RAWINPUTDEVICELIST[deviceCount];

            fixed(RAWINPUTDEVICELIST *resultPtr = &result[0])
            {
                DirectAccess.MemoryCopy(resultPtr, deviceListPtr, structSize * deviceCount);
            }

            return(result);
        }
Exemplo n.º 13
0
        /// <summary>
        /// Function called when the effect is being initialized.
        /// </summary>
        /// <remarks>
        /// Use this method to set up the effect upon its creation.  For example, this method could be used to create the required shaders for the effect.
        /// </remarks>
        protected override void OnInitialize()
        {
            base.OnInitialize();

            _xOffsets   = new Vector4[13];
            _yOffsets   = new Vector4[13];
            _kernel     = new float[13];
            _blurBuffer = Graphics.ImmediateContext.Buffers.CreateConstantBuffer("Gorgon2DGaussianBlurEffect Constant Buffer",
                                                                                 new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <Vector4>() * _xOffsets.Length
            });
            _blurStaticBuffer = Graphics.ImmediateContext.Buffers.CreateConstantBuffer("Gorgon2DGaussianBlurEffect Static Constant Buffer",
                                                                                       new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <Vector4>() * (_kernel.Length + 1)
            });

            _blurKernelStream = new GorgonDataStream(_blurStaticBuffer.SizeInBytes);

            Passes[0].PixelShader = Graphics.ImmediateContext.Shaders.CreateShader <GorgonPixelShader>("Effect.PS.GaussBlur", "GorgonPixelShaderGaussBlur", "#GorgonInclude \"Gorgon2DShaders\"");

            UpdateKernel();

            _blurSprite = Gorgon2D.Renderables.CreateSprite("Gorgon2DGaussianBlurEffect Sprite", new GorgonSpriteSettings
            {
                Size = BlurRenderTargetsSize
            });

            _blurSprite.BlendingMode  = BlendingMode.None;
            _blurSprite.SmoothingMode = SmoothingMode.Smooth;
            _blurSprite.TextureRegion = new RectangleF(0, 0, 1, 1);
        }
Exemplo n.º 14
0
        /// <summary>
        /// Function to copy the contents of the pointer to a byte array.
        /// </summary>
        /// <param name="source">Source pointer.</param>
        /// <param name="destination">Destination array of bytes.</param>
        /// <param name="destinationIndex">Index in the array to start writing at.</param>
        /// <param name="size">Size of the data to copy.</param>
        /// <remarks>Since a pointer doesn't have a size associated with it, care must be taken to not overstep the bounds of the data pointed at by the pointer.</remarks>
        /// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="destination"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown if the size + destinationIndex is greater than the number of elements in the destination parameter.
        /// <para>-or-</para>
        /// <para>Thrown if the destinationIndex is less than 0.</para>
        /// </exception>
        public static void CopyTo(this IntPtr source, byte[] destination, int destinationIndex, int size)
        {
            if (source == IntPtr.Zero)
            {
                return;
            }

#if DEBUG
            if (destination == null)
            {
                throw new ArgumentNullException("destination");
            }

            if (destinationIndex < 0)
            {
                throw new ArgumentOutOfRangeException("destinationIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, destinationIndex, destination.Length));
            }

            if (destinationIndex + size > destination.Length)
            {
                throw new ArgumentOutOfRangeException("destinationIndex",
                                                      string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, destinationIndex + size, destination.Length));
            }
#endif
            DirectAccess.ReadArray(source, destination, destinationIndex, size);
        }
Exemplo n.º 15
0
        private byte ReadRegister(byte register)
        {
            var buffer = new byte[1];

            DirectAccess.WriteRead(new[] { register }, buffer);

            return(buffer[0]);
        }
Exemplo n.º 16
0
        /// <summary>
        /// Function to write a range of generic values.
        /// </summary>
        /// <typeparam name="T">Type of value to write.  Must be a value type.</typeparam>
        /// <param name="value">Array of values to write.</param>
        /// <param name="startIndex">Starting index in the array.</param>
        /// <param name="count">Number of array elements to copy.</param>
        /// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="value"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the <paramref name="startIndex"/> parameter is less than 0.
        /// <para>-or-</para>
        /// <para>Thrown when the startIndex parameter is equal to or greater than the number of elements in the value parameter.</para>
        /// <para>-or-</para>
        /// <para>Thrown when the sum of startIndex and <paramref name="count"/> is greater than the number of elements in the value parameter.</para>
        /// </exception>
        /// <exception cref="System.IO.IOException">Thrown when the stream is read-only.</exception>
        public unsafe void WriteRange <T>(T[] value, int startIndex, int count)
            where T : struct
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            if ((value.Length == 0) || (count <= 0))
            {
                return;
            }

            if (startIndex < 0)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_VALUE_IS_LESS_THAN, startIndex, 0));
            }

            if (startIndex >= value.Length)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_VALUE_IS_GREATER_THAN, startIndex, value.Length));
            }

            if (startIndex + count > value.Length)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_VALUE_IS_LESS_THAN, startIndex + count, value.Length));
            }

            int typeSize = DirectAccess.SizeOf <T>();
            int offset   = typeSize * startIndex;
            int size     = typeSize * count;

            // Allocate our temporary buffer if we haven't already.
            if (_tempBuffer == null)
            {
                _tempBuffer = new byte[GorgonChunkedFormat.TempBufferSize];
            }

            fixed(byte *tempBufferPointer = &_tempBuffer[0])
            {
                while (size > 0)
                {
                    int blockSize = size > GorgonChunkedFormat.TempBufferSize ? GorgonChunkedFormat.TempBufferSize : size;

                    // Read our array into our temporary byte buffer.
                    DirectAccess.ReadArray(tempBufferPointer, value, offset, blockSize);

                    offset += blockSize;
                    size   -= size;

                    // Write the temporary byte buffer to the stream.
                    Write(_tempBuffer, 0, blockSize);
                }
            }
        }
Exemplo n.º 17
0
        /// <summary>
        /// Function to write a range of generic values.
        /// </summary>
        /// <typeparam name="T">Type of value to write.  Must be a value type.</typeparam>
        /// <param name="value">Array of values to write.</param>
        /// <param name="startIndex">Starting index in the array.</param>
        /// <param name="count">Number of array elements to copy.</param>
        /// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="value"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the <paramref name="startIndex"/> parameter is less than 0.
        /// <para>-or-</para>
        /// <para>Thrown when the startIndex parameter is equal to or greater than the number of elements in the value parameter.</para>
        /// <para>-or-</para>
        /// <para>Thrown when the sum of startIndex and <paramref name="count"/> is greater than the number of elements in the value parameter.</para>
        /// </exception>
        /// <exception cref="System.IO.IOException">Thrown when the stream is read-only.</exception>
        public unsafe void WriteRange <T>(T[] value, int startIndex, int count)
            where T : struct
        {
            ValidateAccess(true);

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            if ((value.Length == 0) || (count <= 0))
            {
                return;
            }

            if ((startIndex < 0) || (startIndex >= value.Length))
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, startIndex,
                                                                    value.Length));
            }

            if (startIndex + count > value.Length)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, startIndex + count,
                                                                    value.Length));
            }

            int typeSize = DirectAccess.SizeOf <T>();
            int offset   = typeSize * startIndex;
            int size     = typeSize * count;

            // Allocate our temporary buffer if we haven't already.
            if (TempBuffer == null)
            {
                TempBuffer = new byte[TempBufferSize];
            }

            fixed(byte *tempBufferPointer = &TempBuffer[0])
            {
                while (size > 0)
                {
                    int blockSize = size > TempBufferSize ? TempBufferSize : size;

                    // Read our array into our temporary byte buffer.
                    DirectAccess.WriteArray(tempBufferPointer, value, offset, blockSize);

                    offset += blockSize;
                    size   -= size;

                    // Write the temporary byte buffer to the stream.
                    Write(TempBuffer, 0, blockSize);
                }
            }
        }
Exemplo n.º 18
0
        /// <summary>
        /// Function to read a range of generic values.
        /// </summary>
        /// <typeparam name="T">Type of value to read.  Must be a value type.</typeparam>
        /// <param name="value">Array of values to read.</param>
        /// <param name="startIndex">Starting index in the array.</param>
        /// <param name="count">Number of array elements to copy.</param>
        /// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="value"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the <paramref name="startIndex"/> parameter is less than 0.
        /// <para>-or-</para>
        /// <para>Thrown when the startIndex parameter is equal to or greater than the number of elements in the value parameter.</para>
        /// <para>-or-</para>
        /// <para>Thrown when the sum of startIndex and <paramref name="count"/> is greater than the number of elements in the value parameter.</para>
        /// </exception>
        /// <exception cref="System.IO.IOException">Thrown when the stream is write-only.</exception>
        public unsafe void ReadRange <T>(T[] value, int startIndex, int count)
            where T : struct
        {
            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            if ((value.Length == 0) || (count <= 0))
            {
                return;
            }

            if (startIndex < 0)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_VALUE_IS_LESS_THAN, startIndex, 0));
            }

            if (startIndex >= value.Length)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_VALUE_IS_GREATER_THAN, startIndex, value.Length));
            }

            if (startIndex + count > value.Length)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_VALUE_IS_LESS_THAN, startIndex + count, value.Length));
            }

            int typeSize = DirectAccess.SizeOf <T>();
            int size     = typeSize * count;
            int offset   = startIndex * typeSize;

            if (_tempBuffer == null)
            {
                _tempBuffer = new byte[GorgonChunkedFormat.TempBufferSize];
            }

            fixed(byte *tempBufferPointer = &_tempBuffer[0])
            {
                while (size > 0)
                {
                    int blockSize = size > GorgonChunkedFormat.TempBufferSize ? GorgonChunkedFormat.TempBufferSize : size;

                    // Read the data from the stream as byte values.
                    Read(_tempBuffer, 0, blockSize);

                    // Copy into our array.
                    DirectAccess.ReadArray(tempBufferPointer, value, offset, blockSize);

                    offset += blockSize;
                    size   -= blockSize;
                }
            }
        }
Exemplo n.º 19
0
        /// <summary>
        /// Function to copy the contents of a byte array into the memory pointed at by the pointer.
        /// </summary>
        /// <typeparam name="T">Type of data in the array.</typeparam>
        /// <param name="destination">Destination pointer.</param>
        /// <param name="source">Source array to copy from.</param>
        /// <remarks>Since a pointer doesn't have a size associated with it, care must be taken to not overstep the bounds of the data pointed at by the pointer.</remarks>
        /// <exception cref="System.ArgumentNullException">Thrown if the <paramref name="source"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown if the size + sourceIndex is greater than the number of elements in the source parameter.
        /// <para>-or-</para>
        /// <para>Thrown if the sourceIndex is less than 0.</para>
        /// </exception>
        public static void CopyFrom <T>(this IntPtr destination, T[] source)
            where T : struct
        {
#if DEBUG
            if (source == null)
            {
                throw new ArgumentNullException("source");
            }
#endif

            CopyFrom(destination, source, 0, source.Length * DirectAccess.SizeOf <T>());
        }
Exemplo n.º 20
0
        /// <summary>
        /// Function to read a range of generic values.
        /// </summary>
        /// <typeparam name="T">Type of value to read.  Must be a value type.</typeparam>
        /// <param name="value">Array of values to read.</param>
        /// <param name="startIndex">Starting index in the array.</param>
        /// <param name="count">Number of array elements to copy.</param>
        /// <exception cref="System.ArgumentNullException">Thrown when the <paramref name="value"/> parameter is NULL (Nothing in VB.Net).</exception>
        /// <exception cref="System.ArgumentOutOfRangeException">Thrown when the <paramref name="startIndex"/> parameter is less than 0.
        /// <para>-or-</para>
        /// <para>Thrown when the startIndex parameter is equal to or greater than the number of elements in the value parameter.</para>
        /// <para>-or-</para>
        /// <para>Thrown when the sum of startIndex and <paramref name="count"/> is greater than the number of elements in the value parameter.</para>
        /// </exception>
        /// <exception cref="System.IO.IOException">Thrown when the stream is write-only.</exception>
        public unsafe void ReadRange <T>(T[] value, int startIndex, int count)
            where T : struct
        {
            ValidateAccess(false);

            if (value == null)
            {
                throw new ArgumentNullException("value");
            }

            if ((value.Length == 0) || (count <= 0))
            {
                return;
            }

            if ((startIndex < 0) || (startIndex >= value.Length))
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, startIndex,
                                                                    value.Length));
            }

            if (startIndex + count > value.Length)
            {
                throw new ArgumentOutOfRangeException(string.Format(Resources.GOR_INDEX_OUT_OF_RANGE, startIndex + count,
                                                                    value.Length));
            }

            int typeSize = DirectAccess.SizeOf <T>();
            int size     = typeSize * count;
            int offset   = startIndex * typeSize;

            if (TempBuffer == null)
            {
                TempBuffer = new byte[TempBufferSize];
            }

            fixed(byte *tempBufferPointer = &TempBuffer[0])
            {
                while (size > 0)
                {
                    int blockSize = size > TempBufferSize ? TempBufferSize : size;

                    // Read the data from the stream as byte values.
                    Read(TempBuffer, 0, blockSize);

                    // Copy into our array.
                    DirectAccess.ReadArray(tempBufferPointer, value, offset, blockSize);

                    offset += blockSize;
                    size   -= blockSize;
                }
            }
        }
Exemplo n.º 21
0
        /// <summary>
        /// Function called when the effect is being initialized.
        /// </summary>
        /// <remarks>
        /// Use this method to set up the effect upon its creation.  For example, this method could be used to create the required shaders for the effect.
        /// <para>When creating a custom effect, use this method to initialize the effect.  Do not put initialization code in the effect constructor.</para>
        /// </remarks>
        protected override void OnInitialize()
        {
            base.OnInitialize();
            Passes[0].PixelShader = Graphics.ImmediateContext.Shaders.CreateShader <GorgonPixelShader>("Effect.2D.SobelEdgeDetect.PS", "GorgonPixelShaderSobelEdge", "#GorgonInclude \"Gorgon2DShaders\"");

            _sobelBuffer = Graphics.ImmediateContext.Buffers.CreateConstantBuffer("Gorgon2DSobelEdgeDetectEffect Constant Buffer",
                                                                                  new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <Settings>()
            });
            _settings = new Settings(Color.Black, Vector2.Zero, 0.75f);
        }
Exemplo n.º 22
0
 /// <summary>
 /// Function to create a structured buffer and initialize it with data.
 /// </summary>
 /// <param name="name">The name of the structured buffer.</param>
 /// <param name="value">Value to write to the buffer.</param>
 /// <param name="usage">Usage for the buffer.</param>
 /// <returns>A new structured buffer.</returns>
 /// <typeparam name="T">Type of data to write.  Must be a value type.</typeparam>
 /// <remarks>This method should only be called from an immediate graphics context, if it is called from a deferred context an exception will be thrown.</remarks>
 /// <exception cref="GorgonLibrary.GorgonException">Thrown when the buffer could not be created.</exception>
 public GorgonStructuredBuffer CreateStructuredBuffer <T>(string name, T value, BufferUsage usage)
     where T : struct
 {
     using (var stream = GorgonDataStream.ValueToStream(value))
     {
         return(CreateStructuredBuffer(name, new GorgonStructuredBufferSettings
         {
             Usage = usage,
             SizeInBytes = DirectAccess.SizeOf <T>(),
             StructureSize = DirectAccess.SizeOf <T>()
         }, stream));
     }
 }
Exemplo n.º 23
0
        /// <summary>
        /// Function called when the effect is being initialized.
        /// </summary>
        /// <remarks>
        /// Use this method to set up the effect upon its creation.  For example, this method could be used to create the required shaders for the effect.
        /// <para>When creating a custom effect, use this method to initialize the effect.  Do not put initialization code in the effect constructor.</para>
        /// </remarks>
        protected override void OnInitialize()
        {
            base.OnInitialize();

            Passes[0].PixelShader = Graphics.ImmediateContext.Shaders.CreateShader <GorgonPixelShader>("Effect.2D.Wave.PS", "GorgonPixelShaderWaveEffect", "#GorgonInclude \"Gorgon2DShaders\"");

            _waveBuffer = Graphics.ImmediateContext.Buffers.CreateConstantBuffer("Gorgon2DWaveEffect Constant Buffer",
                                                                                 new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <Settings>()
            });

            _settings = new Settings(10.0f, 50.0f, 0.0f, 100.0f, WaveType.Horizontal);
        }
        private void Reconfigure()
        {
            DirectAccess.Write(new[] { CTRL_REG0, (byte)0 });  // normal mode, FIFO disabled, high-pass filter disabled

            DirectAccess.Write(new[] { CTRL_REG1, (byte)((byte)AccelerationDataRate | (byte)AccelerationDataUpdateMode | (byte)AccelerationAxes) });
            DirectAccess.Write(new[] { CTRL_REG2, (byte)AccelerationScale });

            DirectAccess.Write(new[] { CTRL_REG3, (byte)0 }); // interrupt 1 disabled
            DirectAccess.Write(new[] { CTRL_REG4, (byte)0 }); // interrupt 2 disabled

            DirectAccess.Write(new[] { CTRL_REG5, (byte)((byte)MagneticResolution | (byte)MagneticDataRate) });
            DirectAccess.Write(new[] { CTRL_REG6, (byte)MagneticScale });
            DirectAccess.Write(new[] { CTRL_REG7, (byte)MagneticMode });
        }
Exemplo n.º 25
0
        /// <summary>
        /// Function to read file meta data.
        /// </summary>
        /// <param name="stream">Stream used to read the metadata.</param>
        /// <returns>
        /// The image meta data as a <see cref="GorgonLibrary.Graphics.IImageSettings">IImageSettings</see> value.
        /// </returns>
        /// <exception cref="System.IO.IOException">Thrown when the <paramref name="stream"/> is write-only or if the stream cannot perform seek operations.
        /// <para>-or-</para>
        /// <para>Thrown if the file is corrupt or can't be read by the codec.</para>
        /// </exception>
        /// <exception cref="System.IO.EndOfStreamException">Thrown when an attempt to read beyond the end of the stream is made.</exception>
        public override IImageSettings GetMetaData(Stream stream)
        {
            long position   = 0;
            int  headerSize = DirectAccess.SizeOf <TGAHeader>();

            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            if (!stream.CanRead)
            {
                throw new IOException(Resources.GORGFX_STREAM_WRITE_ONLY);
            }

            if (!stream.CanSeek)
            {
                throw new IOException(Resources.GORGFX_STREAM_NO_SEEK);
            }

            if (stream.Length - stream.Position < sizeof(uint) + DirectAccess.SizeOf <TGAHeader>())
            {
                throw new EndOfStreamException(Resources.GORGFX_STREAM_EOF);
            }

            try
            {
                position = stream.Position;

                TGAConversionFlags conversion;
                var gorgonDataStream = stream as GorgonDataStream;
                if (gorgonDataStream != null)
                {
                    return(ReadHeader(gorgonDataStream, out conversion));
                }

                using (var memoryStream = new GorgonDataStream(headerSize))
                {
                    memoryStream.ReadFromStream(stream, headerSize);
                    memoryStream.Position = 0;
                    return(ReadHeader(memoryStream, out conversion));
                }
            }
            finally
            {
                stream.Position = position;
            }
        }
Exemplo n.º 26
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Sphere" /> class.
        /// </summary>
        /// <param name="graphics">Graphics interface to use.</param>
        /// <param name="radius">Radius of the sphere</param>
        /// <param name="textureCoordinates">The texture coordinates to apply to the sphere.</param>
        /// <param name="angle">The angle of rotation, in degrees.</param>
        /// <param name="ringCount">Number of rings in the sphere.</param>
        /// <param name="segmentCount">Number of segments in the sphere.</param>
        public Sphere(GorgonGraphics graphics, float radius, RectangleF textureCoordinates, Vector3 angle, int ringCount = 8, int segmentCount = 16)
        {
            Quaternion orientation;

            // Calculate number of vertices and indices required for our sphere.
            PrimitiveType = PrimitiveType.TriangleList;
            VertexCount   = (ringCount + 1) * (segmentCount + 1);
            IndexCount    = 6 * ringCount * (segmentCount + 1);
            TriangleCount = IndexCount / 3;

            Quaternion.RotationYawPitchRoll(angle.Y.Radians(), angle.X.Radians(), angle.Z.Radians(), out orientation);
            Matrix.RotationQuaternion(ref orientation, out _orientation);

            unsafe
            {
                using (var vertexData = new GorgonDataStream(VertexCount * Vertex3D.Size))
                    using (var normalData = new GorgonDataStream(VertexCount * 2 * Vector4.SizeInBytes))
                        using (var indexData = new GorgonDataStream(IndexCount * DirectAccess.SizeOf <int>()))
                        {
                            GetVertices((Vertex3D *)vertexData.UnsafePointer, (int *)indexData.UnsafePointer, normalData.UnsafePointer, radius, textureCoordinates, ringCount, segmentCount);

                            VertexBuffer = graphics.Buffers.CreateVertexBuffer("SphereVertexBuffer",
                                                                               new GorgonBufferSettings
                            {
                                Usage       = BufferUsage.Immutable,
                                SizeInBytes = (int)vertexData.Length
                            },
                                                                               vertexData);

                            IndexBuffer = graphics.Buffers.CreateIndexBuffer("SphereIndexBuffer",
                                                                             new GorgonIndexBufferSettings
                            {
                                Usage           = BufferUsage.Immutable,
                                Use32BitIndices = true,
                                SizeInBytes     = (int)indexData.Length
                            },
                                                                             indexData);

                            Normals = graphics.Buffers.CreateVertexBuffer("NormalsBuffer",
                                                                          new GorgonBufferSettings
                            {
                                Usage       = BufferUsage.Immutable,
                                SizeInBytes = (int)normalData.Length
                            },
                                                                          normalData);
                        }
            }
        }
Exemplo n.º 27
0
        /// <summary>
        /// Function to write a single value type to the buffer.
        /// </summary>
        /// <typeparam name="T">Type of value type.</typeparam>
        /// <param name="data">Value type data to write into the buffer.</param>
        /// <param name="deferred">[Optional] A deferred context to use when updating the buffer.</param>
        /// <remarks>
        /// This overload is useful for directly copying a value into the buffer without needing a data stream.  If the type of value is a
        /// struct and contains reference types (arrays, strings, and objects), then these members will not be copied.  Some form of
        /// marshalling will be required in order to copy structures with reference types.
        /// <para>
        /// If the <paramref name="deferred"/> parameter is NULL (Nothing in VB.Net), the immediate context will be used to update the buffer.  If it is non-NULL, then it
        /// will use the specified deferred context to clear the render target.
        /// <para>If you are using a deferred context, it is necessary to use that context to update the buffer because 2 threads may not access the same resource at the same time.
        /// Passing a separate deferred context will alleviate that.</para>
        /// </para>
        /// <para>This will only work on buffers created with a usage type of [Default].</para>
        /// </remarks>
        /// <exception cref="GorgonLibrary.GorgonException">Thrown when the buffer does not have a usage of Default.</exception>
        public void Update <T>(ref T data, GorgonGraphics deferred = null)
            where T : struct
        {
#if DEBUG
            if (Settings.Usage != BufferUsage.Default)
            {
                throw new GorgonException(GorgonResult.AccessDenied, Resources.GORGFX_NOT_DEFAULT_USAGE);
            }
#endif

            if (deferred == null)
            {
                deferred = Graphics;
            }

            deferred.Context.UpdateSubresource(ref data, D3DResource, 0, DirectAccess.SizeOf <T>());
        }
Exemplo n.º 28
0
        private void Reconfigure()
        {
            // XL Axen (SD: XYZ) gesetzt, Soft iron algorithmus aus
            DirectAccess.Write(new[] { CTRL9_XL, (byte)LSM6DS3AccelerationAxes });

            // Set Block data update (SD: disabled)
            DirectAccess.Write(new[] { CTRL3_C, (byte)LSM6DS3BlockDataUpdate });

            // XL Daterate gesetzt (SD: 416HZ), XL Skalierung gesetzt (SD: 2g), AnalogFilterBandwith gesetzt (Standard 400hz)
            DirectAccess.Write(new[] { CTRL1_XL, (byte)((byte)LSM6DS3AccelerationDataRate | (byte)LSM6DS3AccelerationScale | (byte)LSM6DS3AccelerationAnalogFilterBandwith) });

            // G Axen (SD: XYZ) aktiviert, embedded functions disabled
            DirectAccess.Write(new[] { CTRL10_C, (byte)LSM6DS3GyroAxes });

            // G Datenrate gesetzt (SD: 416HZ), G Skalierung gesetzt (SD: 250dps)
            DirectAccess.Write(new[] { CTRL2_G, (byte)((byte)LSM6DS3GyroDataRate | (byte)LSM6DS3GyroScale) });
        }
Exemplo n.º 29
0
        /// <summary>
        /// Function called when the effect is being initialized.
        /// </summary>
        /// <remarks>
        /// Use this method to set up the effect upon its creation.  For example, this method could be used to create the required shaders for the effect.
        /// <para>When creating a custom effect, use this method to initialize the effect.  Do not put initialization code in the effect constructor.</para>
        /// </remarks>
        protected override void OnInitialize()
        {
            base.OnInitialize();

            _point = Gorgon2D.Renderables.CreatePoint("Effect.OldFilm.DustPoint", Vector2.Zero, GorgonColor.Black);

            // Create pixel shader.
            Passes[0].PixelShader = Graphics.Shaders.CreateShader <GorgonPixelShader>("Effect.OldFilm.PS",
                                                                                      "GorgonPixelShaderFilmGrain", Encoding.UTF8.GetString(Resources.FilmGrain));

            _timingBuffer = Graphics.Buffers.CreateConstantBuffer("Effect.OldFilm.TimingBuffer", new GorgonConstantBufferSettings
            {
                SizeInBytes = 16
            });

            _scratchBuffer = Graphics.Buffers.CreateConstantBuffer("Effect.OldFilm.ScratchSettingsBuffer",
                                                                   new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <ScratchSettings>()
            });

            _sepiaBuffer = Graphics.Buffers.CreateConstantBuffer("Effect.OldFilm.SepaSettingsBuffer",
                                                                 new GorgonConstantBufferSettings
            {
                SizeInBytes = DirectAccess.SizeOf <SepiaSettings>()
            });

            DirtPercent = 5;
            DirtAmount  = 10;

            _scratchSettings = new ScratchSettings
            {
                ScratchIntensity   = 0.49f,
                ScratchScrollSpeed = 0.01f,
                ScratchVisibleTime = 0.003f,
                ScratchWidth       = 0.01f
            };

            _sepiaSettings = new SepiaSettings
            {
                SepiaDesaturationAmount = 0.0f,
                SepiaToneAmount         = 0.5f,
                SepiaLightColor         = new GorgonColor(1, 0.9f, 0.65f, 1.0f),
                SepiaDarkColor          = new GorgonColor(0.2f, 0.102f, 0, 1.0f)
            };
        }
Exemplo n.º 30
0
        /// <summary>
        /// Function to retrieve device information.
        /// </summary>
        /// <param name="deviceHandle">Device handle.</param>
        /// <returns>The device information structure.</returns>
        public static unsafe RID_DEVICE_INFO GetDeviceInfo(IntPtr deviceHandle)
        {
            int dataSize = DirectAccess.SizeOf <RID_DEVICE_INFO>();

            byte *data = stackalloc byte[dataSize];

            if (GetRawInputDeviceInfo(deviceHandle, RawInputCommand.DeviceInfo, (IntPtr)data, ref dataSize) < 0)
            {
                throw new Win32Exception();
            }

            RID_DEVICE_INFO result;

            DirectAccess.MemoryCopy(&result, data, dataSize);

            return(result);
        }