自学教程：C++ DXCall函数代码示例

// Loads resourcesvoid MeshRenderer::Initialize(ID3D11Device* device, ID3D11DeviceContext* context, const Model* model){    this->device = device;    blendStates.Initialize(device);    rasterizerStates.Initialize(device);    depthStencilStates.Initialize(device);    samplerStates.Initialize(device);    meshVSConstants.Initialize(device);    meshPSConstants.Initialize(device);    shadowConstants.Initialize(device);    evsmConstants.Initialize(device);    reductionConstants.Initialize(device);    LoadShaders();    D3D11_RASTERIZER_DESC rsDesc = RasterizerStates::NoCullDesc();    rsDesc.DepthClipEnable = false;    DXCall(device->CreateRasterizerState(&rsDesc, &noZClipRSState));    D3D11_SAMPLER_DESC sampDesc = SamplerStates::AnisotropicDesc();    sampDesc.MaxAnisotropy = ShadowAnisotropy;    DXCall(device->CreateSamplerState(&sampDesc, &evsmSampler));    // Create the staging textures for reading back the reduced depth buffer    for(uint32 i = 0; i < ReadbackLatency; ++i)        reductionStagingTextures[i].Initialize(device, 1, 1, DXGI_FORMAT_R16G16_UNORM);    CreateShadowMaps();    SetModel(model);}

UploadContext ResourceUploadBegin(uint64 size){    Assert_(Device != nullptr);    size = AlignTo(size, 512);    Assert_(size <= UploadBufferSize);    Assert_(size > 0);    ClearFinishedUploads(0);    while(AllocUploadSubmission(size) == false)        ClearFinishedUploads(1);    Assert_(UploadSubmissionUsed > 0);    const uint64 submissionIdx = (UploadSubmissionStart + (UploadSubmissionUsed - 1)) % MaxUploadSubmissions;    UploadSubmission& submission = UploadSubmissions[submissionIdx];    Assert_(submission.Size == size);    DXCall(submission.CmdAllocator->Reset());    DXCall(UploadCmdList->Reset(submission.CmdAllocator, nullptr));    UploadContext context;    context.CmdList = UploadCmdList;    context.Resource = UploadBuffer;    context.CPUAddress = UploadBufferCPUAddr + submission.Offset;    context.ResourceOffset = submission.Offset;    return context;}

void Profiler::StartProfile(const wstring& name){    ProfileData& profileData = profiles[name];    Assert_(profileData.QueryStarted == false);    Assert_(profileData.QueryFinished == false);    profileData.CPUProfile = false;    profileData.Active = true;    if(profileData.DisjointQuery[currFrame] == NULL)    {        // Create the queries        D3D11_QUERY_DESC desc;        desc.Query = D3D11_QUERY_TIMESTAMP_DISJOINT;        desc.MiscFlags = 0;        DXCall(device->CreateQuery(&desc, &profileData.DisjointQuery[currFrame]));        desc.Query = D3D11_QUERY_TIMESTAMP;        DXCall(device->CreateQuery(&desc, &profileData.TimestampStartQuery[currFrame]));        DXCall(device->CreateQuery(&desc, &profileData.TimestampEndQuery[currFrame]));    }    // Start a disjoint query first    context->Begin(profileData.DisjointQuery[currFrame]);    // Insert the start timestamp    context->End(profileData.TimestampStartQuery[currFrame]);    profileData.QueryStarted = true;}

void MeshRenderer::GenAndCacheMeshInputLayout(const Model* model){	// TODO: optimize this; group meshes with the same input layout to reduce api calls    for(uint64 i = 0; i < model->Meshes().size(); ++i)    {        const Mesh& mesh = model->Meshes()[i];		VertexShaderPtr vs = _meshVertexShadersMap[&mesh];		ID3D11InputLayoutPtr inputLayout;		if (_meshInputLayouts.find(&mesh) == _meshInputLayouts.end())		{			DXCall(_device->CreateInputLayout(mesh.InputElements(), mesh.NumInputElements(),				vs->ByteCode->GetBufferPointer(), vs->ByteCode->GetBufferSize(), &inputLayout));			_meshInputLayouts.insert(std::make_pair(&mesh, inputLayout));		}		if (_meshDepthInputLayouts.find(&mesh) == _meshDepthInputLayouts.end())		{			DXCall(_device->CreateInputLayout(mesh.InputElements(), mesh.NumInputElements(),				_meshDepthVS->ByteCode->GetBufferPointer(), _meshDepthVS->ByteCode->GetBufferSize(), &inputLayout));			_meshDepthInputLayouts.insert(std::make_pair(&mesh, inputLayout));		}    }}

JBKVertexShader* JBKRender_CreateVertexShader(void* blob, int32_t sizeInBytes, JBKShaderInputElement* elements, uint32_t elementCount) {	JBKVertexShader* shader = &g_vertexShaders[g_vertexShaderCount++];	D3D11_INPUT_ELEMENT_DESC inputElementArray[16];	convertInputElements(inputElementArray, elements, elementCount);	DXCall(g_device->lpVtbl->CreateVertexShader(g_device, blob, sizeInBytes, NULL, &shader->m_shader));	DXCall(g_device->lpVtbl->CreateInputLayout(g_device, inputElementArray, elementCount, blob, sizeInBytes, &shader->m_inputLayout));	return shader;}

void JBKRender_DrawDebugText(float x, float y, const char* text, uint32_t color) {    RECT r;    r.left = (LONG)x;    r.top = (LONG)y;    r.right = r.left;    r.bottom = r.top;	DXCall( IDirect3DDevice9_BeginScene(gDevice) );	gDebugFont->lpVtbl->DrawTextA(gDebugFont, 0, text, -1, &r, DT_LEFT | DT_TOP | DT_NOCLIP, color);	DXCall( IDirect3DDevice9_EndScene(gDevice) );}

void JBKRender_DrawUserPrimitives(void* data, JBKVertexDataType datatype, JBKPrimitiveType primitivetype, uint32_t primitivecount) {	int32_t stride = 0;	DWORD fvf = DataTypeToFVF(datatype, &stride);	D3DPRIMITIVETYPE d3dprimtype = PrimitiveTypeToD3D(primitivetype);	SetupTextureStageStates(fvf);	DXCall( IDirect3DDevice9_SetFVF(gDevice, fvf) );	DXCall( IDirect3DDevice9_BeginScene(gDevice) );	DXCall( IDirect3DDevice9_DrawPrimitiveUP(gDevice, d3dprimtype, primitivecount, data, stride) );	DXCall( IDirect3DDevice9_EndScene(gDevice) );}

ID3DXMesh* Mesh::GenerateNormals(ID3DXMesh* mesh, IDirect3DDevice9* d3d9Device){    // see if we have texture coordinates    D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE];    DXCall(mesh->GetDeclaration(decl));    bool foundTexCoord = false;    for (UINT i = 0; i < MAX_FVF_DECL_SIZE; ++i)    {        if (decl[i].Stream == 0xFF)            break;        else if(decl[i].Usage == D3DDECLUSAGE_TEXCOORD && decl[i].UsageIndex == 0)        {            foundTexCoord = true;            break;        }    }    // Clone the mesh with a new declaration    D3DVERTEXELEMENT9 tcDecl[] =    {        { 0, 0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },        { 0, 12, D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,   0 },        { 0, 24, D3DDECLTYPE_FLOAT2,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },        D3DDECL_END()    };    D3DVERTEXELEMENT9 noTCDecl[] =    {        { 0, 0,  D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0 },        { 0, 12, D3DDECLTYPE_FLOAT3,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL,   0 },        { 0, 24, D3DDECLTYPE_FLOAT2,   D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0 },        D3DDECL_END()    };    D3DVERTEXELEMENT9* newDecl;    if (foundTexCoord)        newDecl = tcDecl;    else        newDecl = noTCDecl;    ID3DXMesh* clonedMesh = NULL;    UINT options = D3DXMESH_MANAGED;    if (indexType == Index32Bit)        options |= D3DXMESH_32BIT;    DXCall(mesh->CloneMesh(options, newDecl, d3d9Device, &clonedMesh));    mesh->Release();    // Generate the normals    DXCall(D3DXComputeNormals(clonedMesh, &adjacency[0]));    return clonedMesh;}

void SaveTextureAsDDS(ID3D11Resource* texture, const wchar* filePath){    ID3D11DevicePtr device;    texture->GetDevice(&device);    ID3D11DeviceContextPtr context;    device->GetImmediateContext(&context);    ScratchImage scratchImage;    DXCall(CaptureTexture(device, context, texture, scratchImage));    DXCall(SaveToDDSFile(scratchImage.GetImages(), scratchImage.GetImageCount(),                         scratchImage.GetMetadata(), DDS_FLAGS_FORCE_DX10_EXT, filePath));}

TempRenderTarget* PostProcessorBase::GetTempRenderTarget(uint32 width, uint32 height, DXGI_FORMAT format,                                                         uint32 msCount, uint32 msQuality, uint32 mipLevels,                                                         bool generateMipMaps, bool useAsUAV){    // Look through existing render targets    for (size_t i = 0; i < tempRenderTargets.size(); ++i)    {        TempRenderTarget* rt = tempRenderTargets[i];        if (!rt->InUse && rt->Width == width && rt->Height == height && rt->Format == format                && rt->MSCount == msCount && rt->MSQuality == msQuality && (rt->UAView != nullptr) == useAsUAV)        {            rt->InUse = true;            return rt;        }    }    // Didn't find one, have to make one    TempRenderTarget* rt = new TempRenderTarget();    D3D11_TEXTURE2D_DESC desc;    desc.Width = width;    desc.Height = height;    desc.ArraySize = 1;    desc.BindFlags = D3D11_BIND_SHADER_RESOURCE|D3D11_BIND_RENDER_TARGET;    if(useAsUAV)        desc.BindFlags |= D3D11_BIND_UNORDERED_ACCESS;    desc.CPUAccessFlags = 0;    desc.Format = format;    desc.MipLevels = mipLevels;    desc.MiscFlags = generateMipMaps ? D3D11_RESOURCE_MISC_GENERATE_MIPS : 0;    desc.SampleDesc.Count = msCount;    desc.SampleDesc.Quality = msQuality;    desc.Usage = D3D11_USAGE_DEFAULT;    DXCall(device->CreateTexture2D(&desc, nullptr, &rt->Texture));    DXCall(device->CreateRenderTargetView(rt->Texture, nullptr, &rt->RTView));    DXCall(device->CreateShaderResourceView(rt->Texture, nullptr, &rt->SRView));    if(useAsUAV)        device->CreateUnorderedAccessView(rt->Texture, nullptr, &rt->UAView);    else        rt->UAView = nullptr;    rt->Width = width;    rt->Height = height;    rt->MSCount = msCount;    rt->MSQuality = msQuality;    rt->Format = format;    rt->InUse = true;    tempRenderTargets.push_back(rt);    return tempRenderTargets[tempRenderTargets.size() - 1];}

    void Effect::ExtractGlobalVars(D3DX11_EFFECT_DESC& effectDesc) {        for(U32 i = 0; i < effectDesc.GlobalVariables; ++i) {            ID3DX11EffectVariable* pVar = dx11Effect->GetVariableByIndex(i);            D3DX11_EFFECT_VARIABLE_DESC varDesc;            DXCall(pVar->GetDesc(&varDesc));            ID3DX11EffectType* pType = pVar->GetType();            D3DX11_EFFECT_TYPE_DESC typeDesc;            DXCall(pType->GetDesc(&typeDesc));            AddVariable(pVar, &varDesc, &typeDesc);        }    }

void SwapChain::Reset(){    Assert_(swapChain);    if(output == nullptr)        fullScreen = false;    // Release all references    for(uint64 i = 0; i < NumBackBuffers; ++i)    {        DX12::Release(backBuffers[i].Texture.Resource);        DX12::RTVDescriptorHeap.FreePersistent(backBuffers[i].RTV);    }    if(format == DXGI_FORMAT_R8G8B8A8_UNORM_SRGB)        noSRGBFormat = DXGI_FORMAT_R8G8B8A8_UNORM;    else if(format == DXGI_FORMAT_B8G8R8A8_UNORM_SRGB)        noSRGBFormat = DXGI_FORMAT_B8G8R8A8_UNORM;    else        noSRGBFormat = format;    if(fullScreen)        PrepareFullScreenSettings();    else    {        refreshRate.Numerator = 60;        refreshRate.Denominator = 1;    }    DXCall(swapChain->SetFullscreenState(fullScreen, NULL));    DXCall(swapChain->ResizeBuffers(NumBackBuffers, width, height, noSRGBFormat,                                    DXGI_SWAP_CHAIN_FLAG_ALLOW_MODE_SWITCH |                                    DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING |                                    DXGI_SWAP_CHAIN_FLAG_FRAME_LATENCY_WAITABLE_OBJECT));    if(fullScreen)    {        DXGI_MODE_DESC mode;        mode.Format = noSRGBFormat;        mode.Width = width;        mode.Height = height;        mode.RefreshRate.Numerator = 0;        mode.RefreshRate.Denominator = 0;        mode.Scaling = DXGI_MODE_SCALING_UNSPECIFIED;        mode.ScanlineOrdering = DXGI_MODE_SCANLINE_ORDER_UNSPECIFIED;        DXCall(swapChain->ResizeTarget(&mode));    }    AfterReset();}

void SaveTextureAsPNG(ID3D11Resource* texture, const wchar* filePath){    ID3D11DevicePtr device;    texture->GetDevice(&device);    ID3D11DeviceContextPtr context;    device->GetImmediateContext(&context);    ScratchImage scratchImage;    DXCall(CaptureTexture(device, context, texture, scratchImage));    DXCall(SaveToWICFile(scratchImage.GetImages(), scratchImage.GetImageCount(), WIC_FLAGS_NONE,                         GetWICCodec(WIC_CODEC_PNG), filePath));}

void StructuredBuffer::Initialize(ID3D11Device* device, uint32 stride, uint32 numElements, bool32 dynamic, bool32 useAsUAV,                                    bool32 appendConsume, bool32 hiddenCounter, const void* initData){    Size = stride * numElements;    Stride = stride;    NumElements = numElements;    Assert_(appendConsume == false || hiddenCounter == false);    if(appendConsume || hiddenCounter)        useAsUAV = true;    D3D11_BUFFER_DESC bufferDesc;    bufferDesc.ByteWidth = stride * numElements;    bufferDesc.Usage = useAsUAV ? D3D11_USAGE_DEFAULT : dynamic ? D3D11_USAGE_DYNAMIC : D3D11_USAGE_IMMUTABLE;    bufferDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;    bufferDesc.BindFlags |= useAsUAV ? D3D11_BIND_UNORDERED_ACCESS : 0;    bufferDesc.CPUAccessFlags = useAsUAV ? 0 : dynamic ? D3D11_CPU_ACCESS_WRITE : 0;    bufferDesc.MiscFlags = D3D11_RESOURCE_MISC_BUFFER_STRUCTURED;    bufferDesc.StructureByteStride = stride;    D3D11_SUBRESOURCE_DATA subresourceData;    subresourceData.pSysMem = initData;    subresourceData.SysMemPitch = 0;    subresourceData.SysMemSlicePitch = 0;    DXCall(device->CreateBuffer(&bufferDesc, initData != nullptr ? &subresourceData : nullptr, &Buffer));    D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;    srvDesc.Format = DXGI_FORMAT_UNKNOWN;    srvDesc.ViewDimension = D3D11_SRV_DIMENSION_BUFFER;    srvDesc.Buffer.FirstElement = 0;    srvDesc.Buffer.NumElements = numElements;    DXCall(device->CreateShaderResourceView(Buffer, &srvDesc, &SRView));    if(useAsUAV)    {        D3D11_UNORDERED_ACCESS_VIEW_DESC uavDesc;        uavDesc.Format = DXGI_FORMAT_UNKNOWN;        uavDesc.ViewDimension = D3D11_UAV_DIMENSION_BUFFER;        uavDesc.Buffer.FirstElement = 0;        uavDesc.Buffer.Flags = 0;        uavDesc.Buffer.Flags |= appendConsume ? D3D11_BUFFER_UAV_FLAG_APPEND : 0;        uavDesc.Buffer.Flags |= hiddenCounter ? D3D11_BUFFER_UAV_FLAG_COUNTER : 0;        uavDesc.Buffer.NumElements = numElements;        DXCall(device->CreateUnorderedAccessView(Buffer, &uavDesc, &UAView));    }}

    void Effect::SetParam(const string& name, const I32* data, U32 offset, U32 count) {        auto it = scalarVars.find(name);        _ASSERT(it != scalarVars.end());        ID3DX11EffectScalarVariable* scalarVar = it->second;        DXCall(scalarVar->SetIntArray(data, offset, count));    }

void SwapChain::AfterReset(){    // Re-create an RTV for each back buffer    for(uint64 i = 0; i < NumBackBuffers; i++)    {        backBuffers[i].RTV = DX12::RTVDescriptorHeap.AllocatePersistent().Handles[0];        DXCall(swapChain->GetBuffer(uint32(i), IID_PPV_ARGS(&backBuffers[i].Texture.Resource)));        D3D12_RENDER_TARGET_VIEW_DESC rtvDesc = { };        rtvDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2D;        rtvDesc.Format = format;        rtvDesc.Texture2D.MipSlice = 0;        rtvDesc.Texture2D.PlaneSlice = 0;        DX12::Device->CreateRenderTargetView(backBuffers[i].Texture.Resource, &rtvDesc, backBuffers[i].RTV);        backBuffers[i].Texture.Resource->SetName(MakeString(L"Back Buffer %llu", i).c_str());        backBuffers[i].Texture.Width = width;        backBuffers[i].Texture.Height = height;        backBuffers[i].Texture.ArraySize = 1;        backBuffers[i].Texture.Format = format;        backBuffers[i].Texture.NumMips = 1;        backBuffers[i].MSAASamples = 1;    }    backBufferIdx = swapChain->GetCurrentBackBufferIndex();}

JBKNativeTextureInfo JBKRender_CreateTextureFromFile(const char* fileName) {	JBKNativeTextureInfo result = {0};	IDirect3DTexture9* texture;	D3DXIMAGE_INFO info;	DXCall( D3DXCreateTextureFromFileEx(gDevice, 		fileName, 		D3DX_DEFAULT, 		D3DX_DEFAULT, 		D3DX_DEFAULT,		0,		D3DFMT_UNKNOWN,		D3DPOOL_MANAGED,		D3DX_DEFAULT,		D3DX_DEFAULT,		0,		&info,		0,		&texture) );	result.Width = info.Width;	result.Height = info.Height;	result.Texture = texture;	return result;}

void StagingTexture2D::Initialize(ID3D11Device* device,                                    uint32 width,                                    uint32 height,                                    DXGI_FORMAT format,                                    uint32 numMipLevels,                                    uint32 multiSamples,                                    uint32 msQuality,                                    uint32 arraySize){    D3D11_TEXTURE2D_DESC desc;    desc.Width = width;    desc.Height = height;    desc.ArraySize = arraySize;    desc.BindFlags = 0;    desc.CPUAccessFlags = D3D11_CPU_ACCESS_READ;    desc.Format = format;    desc.MipLevels = numMipLevels;    desc.MiscFlags = 0;    desc.SampleDesc.Count = multiSamples;    desc.SampleDesc.Quality = msQuality;    desc.Usage = D3D11_USAGE_STAGING;    DXCall(device->CreateTexture2D(&desc, nullptr, &Texture));    Width = width;    Height = height;    NumMipLevels = numMipLevels;    MultiSamples = multiSamples;    Format = format;    ArraySize = arraySize;};