Esempio n. 1
0
 private HostShaderCacheEntry()
 {
     Header   = new HostShaderCacheEntryHeader();
     CBuffers = new BufferDescriptor[0];
     SBuffers = new BufferDescriptor[0];
     Textures = new TextureDescriptor[0];
     Images   = new TextureDescriptor[0];
 }
Esempio n. 2
0
 private HostShaderCacheEntry(ShaderProgramInfo programInfo)
 {
     Header = new HostShaderCacheEntryHeader(programInfo.CBuffers.Count,
                                             programInfo.SBuffers.Count,
                                             programInfo.Textures.Count,
                                             programInfo.Images.Count,
                                             programInfo.UsesInstanceId);
     CBuffers = programInfo.CBuffers.ToArray();
     SBuffers = programInfo.SBuffers.ToArray();
     Textures = programInfo.Textures.ToArray();
     Images   = programInfo.Images.ToArray();
 }
Esempio n. 3
0
 /// <summary>
 /// Create a new instance of <see cref="HostShaderCacheEntry"/>.
 /// </summary>
 /// <param name="header">The header of the cached shader entry</param>
 /// <param name="cBuffers">Cached constant buffers</param>
 /// <param name="sBuffers">Cached storage buffers</param>
 /// <param name="textures">Cached texture descriptors</param>
 /// <param name="images">Cached image descriptors</param>
 private HostShaderCacheEntry(
     HostShaderCacheEntryHeader header,
     BufferDescriptor[] cBuffers,
     BufferDescriptor[] sBuffers,
     TextureDescriptor[] textures,
     TextureDescriptor[] images)
 {
     Header   = header;
     CBuffers = cBuffers;
     SBuffers = sBuffers;
     Textures = textures;
     Images   = images;
 }
Esempio n. 4
0
 private HostShaderCacheEntry(ShaderProgramInfo programInfo)
 {
     Header = new HostShaderCacheEntryHeader(programInfo.CBuffers.Count,
                                             programInfo.SBuffers.Count,
                                             programInfo.Textures.Count,
                                             programInfo.Images.Count,
                                             programInfo.UsesInstanceId,
                                             programInfo.UsesRtLayer,
                                             programInfo.ClipDistancesWritten,
                                             programInfo.FragmentOutputMap);
     CBuffers = programInfo.CBuffers.ToArray();
     SBuffers = programInfo.SBuffers.ToArray();
     Textures = programInfo.Textures.ToArray();
     Images = programInfo.Images.ToArray();
 }
Esempio n. 5
0
        /// <summary>
        /// Parse a raw cached user shader program into an array of shader cache entry.
        /// </summary>
        /// <param name="data">The raw cached host shader</param>
        /// <param name="programCode">The host shader program</param>
        /// <returns>An array of shader cache entry</returns>
        internal static HostShaderCacheEntry[] Parse(ReadOnlySpan <byte> data, out ReadOnlySpan <byte> programCode)
        {
            HostShaderCacheHeader fileHeader = MemoryMarshal.Read <HostShaderCacheHeader>(data);

            data = data.Slice(Unsafe.SizeOf <HostShaderCacheHeader>());

            ReadOnlySpan <HostShaderCacheEntryHeader> entryHeaders = MemoryMarshal.Cast <byte, HostShaderCacheEntryHeader>(data.Slice(0, fileHeader.Count * Unsafe.SizeOf <HostShaderCacheEntryHeader>()));

            data = data.Slice(fileHeader.Count * Unsafe.SizeOf <HostShaderCacheEntryHeader>());

            HostShaderCacheEntry[] result = new HostShaderCacheEntry[fileHeader.Count];

            for (int i = 0; i < result.Length; i++)
            {
                HostShaderCacheEntryHeader header = entryHeaders[i];

                if (!header.InUse)
                {
                    continue;
                }

                int cBufferDescriptorsSize = header.CBuffersCount * Unsafe.SizeOf <BufferDescriptor>();
                int sBufferDescriptorsSize = header.SBuffersCount * Unsafe.SizeOf <BufferDescriptor>();
                int textureDescriptorsSize = header.TexturesCount * Unsafe.SizeOf <TextureDescriptor>();
                int imageDescriptorsSize   = header.ImagesCount * Unsafe.SizeOf <TextureDescriptor>();

                ReadOnlySpan <BufferDescriptor> cBuffers = MemoryMarshal.Cast <byte, BufferDescriptor>(data.Slice(0, cBufferDescriptorsSize));
                data = data.Slice(cBufferDescriptorsSize);

                ReadOnlySpan <BufferDescriptor> sBuffers = MemoryMarshal.Cast <byte, BufferDescriptor>(data.Slice(0, sBufferDescriptorsSize));
                data = data.Slice(sBufferDescriptorsSize);

                ReadOnlySpan <TextureDescriptor> textureDescriptors = MemoryMarshal.Cast <byte, TextureDescriptor>(data.Slice(0, textureDescriptorsSize));
                data = data.Slice(textureDescriptorsSize);

                ReadOnlySpan <TextureDescriptor> imageDescriptors = MemoryMarshal.Cast <byte, TextureDescriptor>(data.Slice(0, imageDescriptorsSize));
                data = data.Slice(imageDescriptorsSize);

                result[i] = new HostShaderCacheEntry(header, cBuffers.ToArray(), sBuffers.ToArray(), textureDescriptors.ToArray(), imageDescriptors.ToArray());
            }

            programCode = data.Slice(0, fileHeader.CodeSize);

            return(result);
        }