SOL9 Sample: Direct3D12ApplicationView

SOL9 2.0 Samples

1 Screenshot


2 Source code

/*
 * Direct3D12ApplicationView.cpp 
 * Copyright (c) 2015 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED. 
 */


// 2016/11/14
// 2017/01/28 Updated to use ModuleFileName and caught macro.


#define COMMONCONTROLS_V6
#define WIN10

#include <sol/CriticalSection.h>

#include <sol/direct3d12/DirectX3D12MainView.h>
#include <sol/direct3d12/DirectX3D12View.h>
#include <sol/direct3d12/DirectXMatrix.h>
#include <sol/direct3d12/Direct3D12CommandAllocator.h>
#include <sol/direct3d12/Direct3D12RenderTargetView.h>
#include <sol/direct3d12/Direct3D12DepthStencilView.h>

#include <sol/direct3d12/Direct3D12TransformConstantBufferView.h>

#include <sol/direct3d12/Direct3D12RootSignature.h>
#include <sol/direct3d12/Direct3D12BarrieredGraphicsCommandList.h>
#include <sol/direct3d12/Direct3D12PipelineState.h>

#include <sol/direct3d12/D3D12RasterizerDesc.h>
#include <sol/direct3d12/D3D12BlendDesc.h>
#include <sol/direct3d12/D3D12GraphicsPipelineStateDesc.h>
#include <sol/direct3d12/D3D12Transform.h>

#include <sol/direct3d12/D3D12GraphicsPipelineStateDesc.h>

#include <sol/direct3d12/Direct3D12Synchronizer.h>

#include <sol/direct3d12/Direct3DX12Sphere.h>

#include <sol/direct3d12/DirectXTransform.h>
#include <sol/direct3d12/Direct3D12CommonDescriptorHeap.h>
#include <sol/direct3d12/DirectX3D12TimerThread.h>
#include "resource.h"

namespace SOL {
  
class MainView :public DirectX3D12MainView {
private:

    SmartPtr<Direct3D12CommandQueue>         commandQueue;
    SmartPtr<DirectXGISwapChain3>            swapChain;
    SmartPtr<Direct3D12CommandAllocator>     commandAllocator;
    SmartPtr<Direct3D12RenderTargetView>     renderTargetView;
    SmartPtr<Direct3D12DepthStencilView>     depthStencilView;
    SmartPtr<Direct3D12RootSignature>        rootSignature;
    SmartPtr<Direct3D12CommonDescriptorHeap>  commonDescriptorHeap;
    SmartPtr<Direct3D12TransformConstantBufferView>   constantBufferView;
    SmartPtr<Direct3D12BarrieredGraphicsCommandList>  graphicsCommandList;
    SmartPtr<Direct3D12PipelineState>        pipelineState;
    SmartPtr<Direct3D12Synchronizer>         synchronizer;
    SmartPtr<Direct3DX12Sphere>              sphere;
    
    UINT                             frameIndex;
            
    SmartPtr<DirectX3D12TimerThread> timerThread;
    
    int                              renderingInterval;
        
    DirectXTransform                 worldViewProjection;

    float                            angle;
    
    StringT<TCHAR>                   directory;

    CriticalSection                  criticalSection;
  
private:
  DirectXGISwapChain3* getSwapChain3()
  {
    return swapChain;
  }

  Direct3D12CommandQueue* getCommandQueue()
  {
    return commandQueue;
  }

    
  virtual void createPipelineState(ID3D12Device* device)
  {
    //Create a graphicPipelineStateDes.
    D3D12GraphicsPipelineStateDesc graphicsPipelineStateDesc(*rootSignature);
      
    UINT count = 0;
    const D3D12_INPUT_ELEMENT_DESC* inputElements = sphere->getInputElementDesc(count);
      
    D3D12RasterizerDesc  rasterDesc(D3D12_FILL_MODE_WIREFRAME, D3D12_CULL_MODE_NONE,  true);
      
    D3D12BlendDesc       blendDesc;
            
    graphicsPipelineStateDesc.setInputLayput(inputElements, count);
      
    graphicsPipelineStateDesc.setRasterizerState(rasterDesc);
    graphicsPipelineStateDesc.setBlendState(blendDesc);
      
    StringT<TCHAR> vsshaderFile = getShaderFilePath(directory, _T("VertexShader.cso"));
    StringT<TCHAR> psshaderFile = getShaderFilePath(directory, _T("PixelShader.cso"));

    graphicsPipelineStateDesc.setVertexShader(vsshaderFile);
    graphicsPipelineStateDesc.setPixelShader(psshaderFile);

    pipelineState = new Direct3D12PipelineState(device, graphicsPipelineStateDesc);
  }

  void setDirectXTransform()
  {
    int width  = 0;
    int height = 0;
    getClientSize(width, height);

    try {        
      XMVECTOR eye = XMVectorSet(  1.0f,  1.0f, -4.0f,  0.0f );
      XMVECTOR at  = XMVectorSet(  0.0f,  0.0f,  0.0f,  0.0f );
      XMVECTOR up  = XMVectorSet(  0.0f,  1.0f,  0.0f,  0.0f );

      worldViewProjection.world      = DirectXMatrix::rotationX( angle );
      worldViewProjection.view       = DirectXMatrix::lookAtLH(eye, at, up);
      worldViewProjection.projection = DirectXMatrix::perspectiveFovLH( XM_PIDIV2*0.3f, 
          width / (FLOAT)height, 0.01f, 100.0f );
       
      if (constantBufferView) {
        constantBufferView->update(worldViewProjection);
      }
    } catch (Exception& ex) {
      caught(ex);      
    }
  }
  
public:
  //Create a renderTargetView and a depthStencilView.
  void createViews(ID3D12Device* device, IDXGISwapChain3* swapChain,
                  int width, int height)
  {
    renderTargetView = new Direct3D12RenderTargetView(device, swapChain);
    depthStencilView = new Direct3D12DepthStencilView(device,  width, height);
  }
    
   //Delete a renderTargetView and a depthStencilView.
  void deleteViews()
  {
    if (graphicsCommandList == nullptr) {
      throw IException("GraphicsCommandList is NULL.")
    }
    graphicsCommandList->setOMRenderTargets(0, nullptr, FALSE, nullptr);

    renderTargetView = NULL;
    depthStencilView = NULL;
  }
    
  virtual void initialize()
  {
    int width  = 0;
    int height = 0;
    validateClientSize(width, height);

    DirectXGIFactory4* factory = getDXGIFactory4(); //From DirectX3D12MainView

    Direct3D12Device*  device  = getD3D12Device();  //From DirectX3D12MainView

    try {
      commandQueue             = new Direct3D12CommandQueue(*device);
 
      bool enableFullscreen    = false;
      swapChain                = new DirectXGISwapChain3(*factory, *commandQueue, 2,
                                      getWindow(), width, height, enableFullscreen);

      commandAllocator         = new Direct3D12CommandAllocator(*device);

      renderTargetView         = new Direct3D12RenderTargetView(*device, *swapChain);

      depthStencilView         = new Direct3D12DepthStencilView(*device,  width, height);
          
      graphicsCommandList      = new Direct3D12BarrieredGraphicsCommandList(*device, *commandAllocator);
        
      rootSignature            = new Direct3D12RootSignature(*device);

      commonDescriptorHeap     = new Direct3D12CommonDescriptorHeap(*device, 1);

      constantBufferView       = new Direct3D12TransformConstantBufferView(*device,
                                            commonDescriptorHeap->getCPUHandle(0) );

      synchronizer             = new Direct3D12Synchronizer(*device, *commandQueue);

      //1 Create a renderTargetView and depthStencilView
      createViews(*device, *swapChain, width, height);
        
      //2 Define your own specific initialization procedures.
      // Create your own shape
      sphere                     = new Direct3DX12Sphere(*device, 0.5f, 20, 20);
        
      //3 Create two pipelineState(wireframe and solid) from the sphere. 
      createPipelineState(*device);

      //4 Set world, view and projection to the constantBuffer.
      setDirectXTransform();

      //5 Create a rendering TimerThread.
      timerThread = new DirectX3D12TimerThread(this, renderingInterval);
      timerThread -> start();

    } catch (Exception& ex) {
        caught(ex);
    }
  }

  bool ready()
  {
    Direct3D12Device*    device          = getD3D12Device();
    DirectXGISwapChain3* swapChain       = getSwapChain3();
    Direct3D12CommandQueue* commandQueue = getCommandQueue();
      
    if (
      device                    == nullptr ||
      commandQueue              == nullptr ||
      swapChain                 == nullptr ||
        
      commandAllocator          == nullptr ||
      renderTargetView          == nullptr ||
      depthStencilView          == nullptr ||

      rootSignature             == nullptr ||
      commonDescriptorHeap      == nullptr ||
      constantBufferView        == nullptr ||
      sphere                     == nullptr ||

      graphicsCommandList       == nullptr ||
      pipelineState             == nullptr ||
      timerThread               == nullptr ||
      synchronizer              == nullptr ) {

      return false;
    }
    return true;
  }
    
  virtual void display()
  {
    int width  = 0;
    int height = 0;
    validateClientSize(width, height);
    if ( !ready() ) {
      return;
    }
    
    criticalSection.enter();
    
    angle += 0.2f;
    
    try {
        DirectXGISwapChain3*    swapChain = getSwapChain3();
        Direct3D12CommandQueue* commandQueue = getCommandQueue();
        
        setDirectXTransform();

        frameIndex = swapChain -> getCurrentBackBufferIndex();
        
        graphicsCommandList->startRendering(renderTargetView->getResource(frameIndex));

        graphicsCommandList->setDescriptorHeap(*commonDescriptorHeap);

        graphicsCommandList->setGraphicsRootSignature(*rootSignature);

        graphicsCommandList->setPipelineState(*pipelineState);
        
        graphicsCommandList->setGraphicsRootDescriptorTable(0, 
                commonDescriptorHeap->getGPUHandle(0));

        graphicsCommandList-> setRSViewport(0, 0, width, height);

        graphicsCommandList-> setRSScissorRect(0, 0, width, height);

        D3D12_CPU_DESCRIPTOR_HANDLE rtvHandle = renderTargetView->getHandle(frameIndex);
                 
        graphicsCommandList->clearRenderTargetView(rtvHandle, XMColor(0.2f, 0.2f, 0.6f, 1.0f));

        D3D12_CPU_DESCRIPTOR_HANDLE dsvHandle = *depthStencilView;
        
        graphicsCommandList->clearDepthStencilView(dsvHandle, D3D12_CLEAR_FLAG_DEPTH);
        
        graphicsCommandList->setOMRenderTargets(1, &rtvHandle, FALSE, &dsvHandle);
       
        sphere->drawIndexedInstanced(graphicsCommandList);

        graphicsCommandList->endRendering();
          
        commandQueue->executeCommandList(*graphicsCommandList);

        swapChain->present(1, 0);
        
        synchronizer->waitForCompletion();
       
    } catch (Exception& ex) {
        caught(ex);
    }
    criticalSection.leave();
  }
    
  virtual void resize(int width, int height)
  {
    Direct3D12Device*   device = getD3D12Device();
    DirectXGISwapChain3* swapChain = getSwapChain3();
    if (device           == NULL || 
        swapChain        == NULL) { 
      return ;
    }
      
    try {
    
      deleteViews();
        
      swapChain->resizeBuffers(width, height);

      createViews(*device, *swapChain, width, height);
        
    } catch (Exception& ex) {
      caught(ex);
    }
  }

public:
  MainView(Application& applet, const TCHAR* name, Args& args)
  :DirectX3D12MainView(applet, name, args),
    angle(1.0f),
    frameIndex(0),
    directory(_T("")),
    timerThread(NULL),
    renderingInterval(100)
  {
    directory = (const TCHAR*)args.get(XmNapplicationDirectory);
  
    renderingInterval  = (int) args.get(XmNrenderingInterval);

    restorePlacement();
       
    postResizeRequest();
  }
    
  ~MainView()
  {
  }
};
}

//////////////////////////////////////////////
//
void  Main(int argc, TCHAR** argv)
{
  ModuleFileName module(argv[0]);
  const TCHAR* directory = module.getDirectory();
  const TCHAR* appClass =  module.getAppName(); 

  try {    
    Application applet(appClass, argc, argv);

    Args args;
    args.set(XmNx, 0);
    args.set(XmNy, 0);
    args.set(XmNwidth,  480);
    args.set(XmNheight, 480);
    args.set(XmNapplicationDirectory, directory);
    args.set(XmNrenderingInterval, 150); //150ms

    MainView mainView(applet, appClass, args);

    mainView.realize();
    applet.run();
  } catch (Exception& ex) {
    caught(ex);
  }
}


Last modified: 1 Feb 2017

Copyright (c) 2017 Antillia.com ALL RIGHTS RESERVED.