public T CreateReflection <T>(IDxcBlob blob) where T : ComObject
        {
            DxcBuffer reflectionData = new DxcBuffer
            {
                Ptr      = blob.GetBufferPointer(),
                Size     = blob.GetBufferSize(),
                Encoding = Dxc.DXC_CP_ACP
            };

            CreateReflection(ref reflectionData, typeof(T).GUID, out IntPtr nativePtr).CheckError();
            return(MarshallingHelpers.FromPointer <T>(nativePtr));
        }
Esempio n. 2
0
        public unsafe Result Compile <T>(string source, string[] arguments, IDxcIncludeHandler includeHandler, out T result) where T : ComObject
        {
            IntPtr  shaderSourcePtr = Marshal.StringToHGlobalAnsi(source);
            IntPtr *argumentsPtr    = (IntPtr *)0;

            DxcBuffer buffer = new DxcBuffer
            {
                Ptr      = shaderSourcePtr,
                Size     = source.Length,
                Encoding = Dxc.DXC_CP_ACP
            };

            try
            {
                int argumentsCount = 0;
                if (arguments != null && arguments.Length > 0)
                {
                    argumentsCount = arguments.Length;
                    argumentsPtr   = Interop.AllocToPointers(arguments);
                }

                Result hr = Compile(ref buffer, (IntPtr)argumentsPtr, argumentsCount, includeHandler, typeof(T).GUID, out IntPtr nativePtr);
                if (hr.Failure)
                {
                    result = default;
                    return(hr);
                }

                result = FromPointer <T>(nativePtr);
                return(hr);
            }
            finally
            {
                if (shaderSourcePtr != IntPtr.Zero)
                {
                    Marshal.FreeHGlobal(shaderSourcePtr);
                }

                if (argumentsPtr != null)
                {
                    Interop.Free(argumentsPtr);
                }
            }
        }
        public Result CreateReflection <T>(IDxcBlob blob, out T?reflection) where T : ComObject
        {
            DxcBuffer reflectionData = new DxcBuffer
            {
                Ptr      = blob.GetBufferPointer(),
                Size     = blob.GetBufferSize(),
                Encoding = Dxc.DXC_CP_ACP
            };

            Result result = CreateReflection(ref reflectionData, typeof(T).GUID, out IntPtr nativePtr);

            if (result.Failure)
            {
                reflection = default;
                return(result);
            }

            reflection = MarshallingHelpers.FromPointer <T>(nativePtr);
            return(result);
        }
Esempio n. 4
0
        private static void Reflect(CompiledShader shader)
        {
            var buffer = new DxcBuffer
            {
                Encoding = 0,
                Ptr      = shader.Pointer,
                Size     = shader.Length
            };

            using UniqueComPtr <ID3D12ShaderReflection> reflection = default;
            Guard.ThrowIfFailed(Utils.Ptr->CreateReflection(&buffer, reflection.Iid, (void **)&reflection));

            D3D12_SHADER_DESC desc;

            Guard.ThrowIfFailed(reflection.Ptr->GetDesc(&desc));

            for (var i = 0u; i < desc.BoundResources; i++)
            {
                D3D12_SHADER_INPUT_BIND_DESC bindDesc;
                Guard.ThrowIfFailed(reflection.Ptr->GetResourceBindingDesc(i, &bindDesc));
            }
        }