コード例 #1
0
ファイル: Chunk.cs プロジェクト: ylyking/RdcFileRepack
        public override void Load(ChunkMeta meta, BinaryReader br)
        {
            base.Load(meta, br);

            parentId   = br.ReadUInt64(); // pResource
            pDesc      = D3D11Reader.Read_D3D11_Nullable <D3D11_SHADER_RESOURCE_VIEW_DESC>(br);
            resourceId = br.ReadUInt64(); // pView;
        }
コード例 #2
0
        public virtual void GetDesc(
            out D3D11_SHADER_RESOURCE_VIEW_DESC pDesc
            )
        {
            var fp = GetFunctionPointer(8);

            if (m_GetDescFunc == null)
            {
                m_GetDescFunc = (GetDescFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(GetDescFunc));
            }

            m_GetDescFunc(m_ptr, out pDesc);
        }
コード例 #3
0
ファイル: ID3D11Device.cs プロジェクト: ousttrue/ShrimpDX
        public virtual int CreateShaderResourceView(
            ID3D11Resource pResource,
            ref D3D11_SHADER_RESOURCE_VIEW_DESC pDesc,
            out ID3D11ShaderResourceView ppSRView
            )
        {
            var fp = GetFunctionPointer(7);

            if (m_CreateShaderResourceViewFunc == null)
            {
                m_CreateShaderResourceViewFunc = (CreateShaderResourceViewFunc)Marshal.GetDelegateForFunctionPointer(fp, typeof(CreateShaderResourceViewFunc));
            }
            ppSRView = new ID3D11ShaderResourceView();
            return(m_CreateShaderResourceViewFunc(m_ptr, pResource != null ? pResource.Ptr : IntPtr.Zero, ref pDesc, out ppSRView.PtrForNew));
        }
コード例 #4
0
ファイル: Program.cs プロジェクト: videolan/libvlcsharp
        static bool UpdateOuput(IntPtr opaque, RenderConfig *config, ref OutputConfig output)
        {
            ReleaseTextures();

            var renderFormat = DXGI_FORMAT_R8G8B8A8_UNORM;

            var texDesc = new D3D11_TEXTURE2D_DESC
            {
                MipLevels  = 1,
                SampleDesc = new DXGI_SAMPLE_DESC {
                    Count = 1
                },
                BindFlags      = (uint)(D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE),
                Usage          = D3D11_USAGE_DEFAULT,
                CPUAccessFlags = 0,
                ArraySize      = 1,
                Format         = renderFormat,
                Height         = config->Height,
                Width          = config->Width,
                MiscFlags      = (uint)(D3D11_RESOURCE_MISC_SHARED | D3D11_RESOURCE_MISC_SHARED_NTHANDLE)
            };

            fixed(ID3D11Texture2D **texture = &_texture)
            ThrowIfFailed(_d3dDevice->CreateTexture2D(&texDesc, null, texture));

            IDXGIResource1 *sharedResource = null;
            var             iid            = IID_IDXGIResource1;

            _texture->QueryInterface(&iid, (void **)&sharedResource);

            fixed(void *handle = &_sharedHandle)
            ThrowIfFailed(sharedResource->CreateSharedHandle(null, DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE, null, (IntPtr *)handle));

            sharedResource->Release();

            ID3D11Device1 *d3d11VLC1;

            iid = IID_ID3D11Device1;
            _d3deviceVLC->QueryInterface(&iid, (void **)&d3d11VLC1);

            iid = IID_ID3D11Texture2D;

            fixed(ID3D11Texture2D **texture = &_textureVLC)
            ThrowIfFailed(d3d11VLC1->OpenSharedResource1(_sharedHandle, &iid, (void **)texture));

            d3d11VLC1->Release();

            var shaderResourceViewDesc = new D3D11_SHADER_RESOURCE_VIEW_DESC
            {
                ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D,
                Format        = texDesc.Format
            };

            shaderResourceViewDesc.Texture2D.MipLevels = 1;

            ID3D11Resource *res;

            iid = IID_ID3D11Resource;
            _texture->QueryInterface(&iid, (void **)&res);
            fixed(ID3D11ShaderResourceView **tsi = &_textureShaderInput)
            {
                ThrowIfFailed(_d3dDevice->CreateShaderResourceView(res, &shaderResourceViewDesc, tsi));
                res->Release();
                _d3dctx->PSSetShaderResources(0, 1, tsi);
            }

            var renderTargetViewDesc = new D3D11_RENDER_TARGET_VIEW_DESC
            {
                Format        = texDesc.Format,
                ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D
            };

            iid = IID_ID3D11Resource;
            _textureVLC->QueryInterface(&iid, (void **)&res);

            fixed(ID3D11RenderTargetView **trt = &_textureRenderTarget)
            {
                ThrowIfFailed(_d3deviceVLC->CreateRenderTargetView(res, &renderTargetViewDesc, trt));
                res->Release();
                _d3dctxVLC->OMSetRenderTargets(1, trt, null);
            }

            output.Union.DxgiFormat = (int)renderFormat;
            output.FullRange        = true;
            output.ColorSpace       = ColorSpace.BT709;
            output.ColorPrimaries   = ColorPrimaries.BT709;
            output.TransferFunction = TransferFunction.SRGB;

            return(true);
        }
コード例 #5
0
ファイル: D3D11Reader.cs プロジェクト: ylyking/RdcFileRepack
    public static object Read_D3D11_SHADER_RESOURCE_VIEW_DESC(BinaryReader br)
    {
        D3D11_SHADER_RESOURCE_VIEW_DESC desc = new D3D11_SHADER_RESOURCE_VIEW_DESC();

        desc.offset = br.BaseStream.Position;

        desc.Format        = (DXGI_FORMAT)br.ReadUInt32();
        desc.ViewDimension = (D3D_SRV_DIMENSION)br.ReadInt32();

        switch (desc.ViewDimension)
        {
        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_UNKNOWN:
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_BUFFER:
            desc.Buffer = new D3D11_BUFFER_SRV();
            desc.Buffer.FirstElement = br.ReadUInt32();
            desc.Buffer.NumElements  = br.ReadUInt32();

            desc.Buffer.ElementOffset = desc.Buffer.FirstElement;
            desc.Buffer.ElementWidth  = desc.Buffer.NumElements;
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE1D:
            desc.Texture1D = new D3D11_TEX1D_SRV();
            desc.Texture1D.MostDetailedMip = br.ReadUInt32();
            desc.Texture1D.MipLevels       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE1DARRAY:
            desc.Texture1DArray = new D3D11_TEX1D_ARRAY_SRV();
            desc.Texture1DArray.MostDetailedMip = br.ReadUInt32();
            desc.Texture1DArray.MipLevels       = br.ReadUInt32();
            desc.Texture1DArray.FirstArraySlice = br.ReadUInt32();
            desc.Texture1DArray.ArraySize       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE2D:
            desc.Texture2D = new D3D11_TEX2D_SRV();
            desc.Texture2D.MostDetailedMip = br.ReadUInt32();
            desc.Texture2D.MipLevels       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE2DARRAY:
            desc.Texture2DArray = new D3D11_TEX2D_ARRAY_SRV();
            desc.Texture2DArray.MostDetailedMip = br.ReadUInt32();
            desc.Texture2DArray.MipLevels       = br.ReadUInt32();
            desc.Texture2DArray.FirstArraySlice = br.ReadUInt32();
            desc.Texture2DArray.ArraySize       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE2DMS:
            desc.Texture2DMS = new D3D11_TEX2DMS_SRV();
            desc.Texture2DMS.UnusedField_NothingToDefine = 0;     // dummy
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE2DMSARRAY:
            desc.Texture2DMSArray = new D3D11_TEX2DMS_ARRAY_SRV();
            desc.Texture2DMSArray.FirstArraySlice = br.ReadUInt32();
            desc.Texture2DMSArray.ArraySize       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURE3D:
            desc.Texture3D = new D3D11_TEX3D_SRV();
            desc.Texture3D.MostDetailedMip = br.ReadUInt32();
            desc.Texture3D.MipLevels       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURECUBE:
            desc.TextureCube = new D3D11_TEXCUBE_SRV();
            desc.TextureCube.MostDetailedMip = br.ReadUInt32();
            desc.TextureCube.MipLevels       = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_TEXTURECUBEARRAY:
            desc.TextureCubeArray = new D3D11_TEXCUBE_ARRAY_SRV();
            desc.TextureCubeArray.MostDetailedMip  = br.ReadUInt32();
            desc.TextureCubeArray.MipLevels        = br.ReadUInt32();
            desc.TextureCubeArray.First2DArrayFace = br.ReadUInt32();
            desc.TextureCubeArray.NumCubes         = br.ReadUInt32();
            break;

        case D3D_SRV_DIMENSION.D3D11_SRV_DIMENSION_BUFFEREX:
            desc.BufferEx = new D3D11_BUFFEREX_SRV();
            desc.BufferEx.FirstElement = br.ReadUInt32();
            desc.BufferEx.NumElements  = br.ReadUInt32();
            desc.BufferEx.Flags        = br.ReadUInt32();
            break;

        default:
            throw new Exception($"Unrecognised SRV Dimension {desc.ViewDimension}");
        }

        desc.length = br.BaseStream.Position - desc.offset;
        return(desc);
    }