src/gpu/ganesh/d3d/GrD3DTextureRenderTarget.cpp

/*
 * Copyright 2020 Google LLC
 *
 * Use of this source code is governed by a BSD-style license that can be
 * found in the LICENSE file.
 */

#include "src/gpu/ganesh/d3d/GrD3DTextureRenderTarget.h"

#include "src/gpu/ganesh/GrTexture.h"
#include "src/gpu/ganesh/d3d/GrD3DGpu.h"

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(
        GrD3DGpu* gpu,
        skgpu::Budgeted budgeted,
        SkISize dimensions,
        const GrD3DTextureResourceInfo& info,
        sk_sp<GrD3DResourceState> state,
        const GrD3DDescriptorHeap::CPUHandle& shaderResourceView,
        const GrD3DTextureResourceInfo& msaaInfo,
        sk_sp<GrD3DResourceState> msaaState,
        const GrD3DDescriptorHeap::CPUHandle& colorRenderTargetView,
        const GrD3DDescriptorHeap::CPUHandle& resolveRenderTargetView,
        GrMipmapStatus mipmapStatus,
        std::string_view label)
        : GrSurface(gpu, dimensions, info.fProtected, label)
        , GrD3DTextureResource(info, state)
        , GrD3DTexture(gpu, dimensions, info, state, shaderResourceView, mipmapStatus, label)
        , GrD3DRenderTarget(gpu,
                            dimensions,
                            info,
                            state,
                            msaaInfo,
                            std::move(msaaState),
                            colorRenderTargetView,
                            resolveRenderTargetView,
                            label) {
    SkASSERT(info.fProtected == msaaInfo.fProtected);
    this->registerWithCache(budgeted);
}

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(
        GrD3DGpu* gpu,
        skgpu::Budgeted budgeted,
        SkISize dimensions,
        const GrD3DTextureResourceInfo& info,
        sk_sp<GrD3DResourceState> state,
        const GrD3DDescriptorHeap::CPUHandle& shaderResourceView,
        const GrD3DDescriptorHeap::CPUHandle& renderTargetView,
        GrMipmapStatus mipmapStatus,
        std::string_view label)
        : GrSurface(gpu, dimensions, info.fProtected, label)
        , GrD3DTextureResource(info, state)
        , GrD3DTexture(gpu, dimensions, info, state, shaderResourceView, mipmapStatus, label)
        , GrD3DRenderTarget(gpu, dimensions, info, state, renderTargetView, label) {
    this->registerWithCache(budgeted);
}

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(
        GrD3DGpu* gpu,
        SkISize dimensions,
        const GrD3DTextureResourceInfo& info,
        sk_sp<GrD3DResourceState> state,
        const GrD3DDescriptorHeap::CPUHandle& shaderResourceView,
        const GrD3DTextureResourceInfo& msaaInfo,
        sk_sp<GrD3DResourceState> msaaState,
        const GrD3DDescriptorHeap::CPUHandle& colorRenderTargetView,
        const GrD3DDescriptorHeap::CPUHandle& resolveRenderTargetView,
        GrMipmapStatus mipmapStatus,
        GrWrapCacheable cacheable,
        std::string_view label)
        : GrSurface(gpu, dimensions, info.fProtected, label)
        , GrD3DTextureResource(info, state)
        , GrD3DTexture(gpu, dimensions, info, state, shaderResourceView, mipmapStatus, label)
        , GrD3DRenderTarget(gpu,
                            dimensions,
                            info,
                            state,
                            msaaInfo,
                            std::move(msaaState),
                            colorRenderTargetView,
                            resolveRenderTargetView,
                            label) {
    SkASSERT(info.fProtected == msaaInfo.fProtected);
    this->registerWithCacheWrapped(cacheable);
}

GrD3DTextureRenderTarget::GrD3DTextureRenderTarget(
        GrD3DGpu* gpu,
        SkISize dimensions,
        const GrD3DTextureResourceInfo& info,
        sk_sp<GrD3DResourceState> state,
        const GrD3DDescriptorHeap::CPUHandle& shaderResourceView,
        const GrD3DDescriptorHeap::CPUHandle& renderTargetView,
        GrMipmapStatus mipmapStatus,
        GrWrapCacheable cacheable,
        std::string_view label)
        : GrSurface(gpu, dimensions, info.fProtected, label)
        , GrD3DTextureResource(info, state)
        , GrD3DTexture(gpu, dimensions, info, state, shaderResourceView, mipmapStatus, label)
        , GrD3DRenderTarget(gpu, dimensions, info, state, renderTargetView, label) {
    this->registerWithCacheWrapped(cacheable);
}

sk_sp<GrD3DTextureRenderTarget> GrD3DTextureRenderTarget::MakeNewTextureRenderTarget(
        GrD3DGpu* gpu,
        skgpu::Budgeted budgeted,
        SkISize dimensions,
        int sampleCnt,
        const D3D12_RESOURCE_DESC& resourceDesc,
        GrProtected isProtected,
        GrMipmapStatus mipmapStatus,
        std::string_view label) {
    GrD3DTextureResourceInfo info;
    D3D12_RESOURCE_STATES initialState = sampleCnt > 1 ? D3D12_RESOURCE_STATE_RESOLVE_DEST
                                                       : D3D12_RESOURCE_STATE_RENDER_TARGET;

    D3D12_CLEAR_VALUE clearValue = {};
    clearValue.Format = resourceDesc.Format;
    clearValue.Color[0] = 0;
    clearValue.Color[1] = 0;
    clearValue.Color[2] = 0;
    clearValue.Color[3] = 0;

    if (!GrD3DTextureResource::InitTextureResourceInfo(gpu, resourceDesc, initialState,
                                                       isProtected, &clearValue, &info)) {
        return nullptr;
    }
    sk_sp<GrD3DResourceState> state(new GrD3DResourceState(
                                          static_cast<D3D12_RESOURCE_STATES>(info.fResourceState)));

    const GrD3DDescriptorHeap::CPUHandle shaderResourceView =
            gpu->resourceProvider().createShaderResourceView(info.fResource.get());

    const GrD3DDescriptorHeap::CPUHandle renderTargetView =
            gpu->resourceProvider().createRenderTargetView(info.fResource.get());

    if (sampleCnt > 1) {
        GrD3DTextureResourceInfo msInfo;
        sk_sp<GrD3DResourceState> msState;
        // created MSAA surface we assume will be used for masks, so clear to transparent black
        SkColor4f clearColor = { 0, 0, 0, 0 };
        std::tie(msInfo, msState) =
                GrD3DTextureResource::CreateMSAA(gpu, dimensions, sampleCnt, info, clearColor);
        if (!msInfo.fResource || !msState) {
            return nullptr;
        }

        const GrD3DDescriptorHeap::CPUHandle msaaRenderTargetView =
                gpu->resourceProvider().createRenderTargetView(msInfo.fResource.get());

        GrD3DTextureRenderTarget* trt = new GrD3DTextureRenderTarget(gpu,
                                                                     budgeted,
                                                                     dimensions,
                                                                     info,
                                                                     std::move(state),
                                                                     shaderResourceView,
                                                                     msInfo,
                                                                     std::move(msState),
                                                                     msaaRenderTargetView,
                                                                     renderTargetView,
                                                                     mipmapStatus,
                                                                     label);
        return sk_sp<GrD3DTextureRenderTarget>(trt);
    } else {
        GrD3DTextureRenderTarget* trt = new GrD3DTextureRenderTarget(gpu,
                                                                     budgeted,
                                                                     dimensions,
                                                                     info,
                                                                     std::move(state),
                                                                     shaderResourceView,
                                                                     renderTargetView,
                                                                     mipmapStatus,
                                                                     label);
        return sk_sp<GrD3DTextureRenderTarget>(trt);
    }
}

sk_sp<GrD3DTextureRenderTarget> GrD3DTextureRenderTarget::MakeWrappedTextureRenderTarget(
        GrD3DGpu* gpu,
        SkISize dimensions,
        int sampleCnt,
        GrWrapCacheable cacheable,
        const GrD3DTextureResourceInfo& info,
        sk_sp<GrD3DResourceState> state) {
    // TODO: If a client uses their own heap to allocate, how do we manage that?
    // Adopted textures require both image and allocation because we're responsible for freeing
    //SkASSERT(VK_NULL_HANDLE != info.fImage &&
    //         (kBorrow_GrWrapOwnership == wrapOwnership || VK_NULL_HANDLE != info.fAlloc.fMemory));

    GrMipmapStatus mipmapStatus = info.fLevelCount > 1 ? GrMipmapStatus::kDirty
                                                       : GrMipmapStatus::kNotAllocated;

    const GrD3DDescriptorHeap::CPUHandle shaderResourceView =
            gpu->resourceProvider().createShaderResourceView(info.fResource.get());

    const GrD3DDescriptorHeap::CPUHandle renderTargetView =
            gpu->resourceProvider().createRenderTargetView(info.fResource.get());

    if (sampleCnt > 1) {
        GrD3DTextureResourceInfo msInfo;
        sk_sp<GrD3DResourceState> msState;
        // for wrapped MSAA surface we assume clear to white
        SkColor4f clearColor = { 1, 1, 1, 1 };
        std::tie(msInfo, msState) =
                GrD3DTextureResource::CreateMSAA(gpu, dimensions, sampleCnt, info, clearColor);
        if (!msInfo.fResource || !msState) {
            return nullptr;
        }

        const GrD3DDescriptorHeap::CPUHandle msaaRenderTargetView =
                gpu->resourceProvider().createRenderTargetView(msInfo.fResource.get());

        GrD3DTextureRenderTarget* trt = new GrD3DTextureRenderTarget(
                gpu,
                dimensions,
                info,
                std::move(state),
                shaderResourceView,
                msInfo,
                std::move(msState),
                msaaRenderTargetView,
                renderTargetView,
                mipmapStatus,
                cacheable,
                /*label=*/"MakeWrappedTextureRenderTargetWithMSAASurface");
        return sk_sp<GrD3DTextureRenderTarget>(trt);
    } else {
        return sk_sp<GrD3DTextureRenderTarget>(
                new GrD3DTextureRenderTarget(gpu,
                                             dimensions,
                                             info,
                                             std::move(state),
                                             shaderResourceView,
                                             renderTargetView,
                                             mipmapStatus,
                                             cacheable,
                                             /*label=*/"MakeWrappedTextureRenderTarget"));
    }
}

size_t GrD3DTextureRenderTarget::onGpuMemorySize() const {
    int numColorSamples = this->numSamples();
    if (numColorSamples > 1) {
        // Add one to account for the resolve VkImage.
        ++numColorSamples;
    }
    return GrSurface::ComputeSize(this->backendFormat(), this->dimensions(),
                                  numColorSamples,  // TODO: this still correct?
                                  this->mipmapped());
}

void GrD3DTextureRenderTarget::onSetLabel() {
    GrD3DRenderTarget::onSetLabel();
}