SOL9 Sample: Direct3D12FullScreenOrbitersWithMultiplePipelineStates

SOL9 2.0 Samples

1 Screenshot


2 Source code

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


// 2016/11/10
// This is a fullscreen version of the sample program  
//in "usr/src/direct3d12/Direct3D12OrbitersWithMultiplePipelineStats".

// 2017/01/15 Updated display and setDirectXTransform methods.
// 2017/01/28 Updated to use ModuleFileName class and caught macro.
// 2017/01/28 Updated to use ModuleFileName class and caught macro.

#define COMMONCONTROLS_V6
#define WIN10

#include <sol/Stdio.h>
#include <sol/PushButton.h>
#include <sol/Label.h>
#include <sol/CriticalSection.h>
#include <sol/SystemMetrics.h>
#include <sol/CharModuleFileName.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/Direct3D12TextureRootSignature.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/D3D12ResourceBarrier.h>
#include <sol/direct3d12/D3D12Transform.h>

#include <sol/direct3d12/D3D12GraphicsPipelineStateDesc.h>

#include <sol/direct3d12/Direct3D12Synchronizer.h>

#include <sol/direct3d12/Direct3D12ShaderResourceView.h>
#include <sol/direct3d12/Direct3D12Sampler.h>

#include <sol/direct3d12/Direct3DX12Sphere.h>
#include <sol/direct3d12/Direct3DX12Torus.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:
    static const int MAX_PIPELINE_STATE = 2;

    enum FILLMODE {
      FILL_MODE_WIREFRAME = 0,
      FILL_MODE_SOLID     = 1,  
    };

    SmartPtr<PushButton>                     quit;
    SmartPtr<Label>                          label;
    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[MAX_PIPELINE_STATE];
    SmartPtr<Direct3D12Synchronizer>         synchronizer;
    SmartPtr<Direct3DX12Sphere>              sphere;
    SmartPtr<Direct3DX12Torus>               torus;
    SmartPtr<DirectX3D12TimerThread>         timerThread;
  
    UINT                            frameIndex;
    int                             pipelineCount;
    int                             renderingInterval;
    DirectXTransform                worldViewProjection;
    int                             angle;
    StringT<TCHAR>                  directory;
    static const int                CIRCLE_ANGLE = 360;
    CriticalSection                 criticalSection;
    bool                            fullscreened;

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

    Direct3D12CommandQueue* getCommandQueue()
    {
      return commandQueue;
    }

  virtual void createWireFramePipelineState(ID3D12Device* device, Direct3DX12Shape* shape)
  {
      //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[pipelineCount++] = new Direct3D12PipelineState(device, graphicsPipelineStateDesc);
  }
    
  virtual void createSolidPipelineState(ID3D12Device* device, Direct3DX12Shape* shape)
  {
      //Create a graphicPipelineStateDes.
      D3D12GraphicsPipelineStateDesc graphicsPipelineStateDesc(*rootSignature);
      
      UINT count = 0;
      const D3D12_INPUT_ELEMENT_DESC* inputElements = sphere->getInputElementDesc(count);
      
      D3D12RasterizerDesc  rasterDesc(D3D12_FILL_MODE_SOLID, 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[pipelineCount] = new Direct3D12PipelineState(device, graphicsPipelineStateDesc);
  }

  float SIN(int degree)
  {
      float radian = (float)degree * MATH_PI / 180.0f;
      return (float)sin(radian);
  }
  
  float COS(int degree)
  { 
      float radian = (float)degree * MATH_PI / 180.0f;
      return (float)cos(radian);
  }
      
  XMFLOAT3 getOrbitPosition(int pos)
  {
    static XMFLOAT3  vertices[CIRCLE_ANGLE] = {};
    UINT count = _countof(vertices);  
    static bool initialized = false;
    //Describe a circular orbit.
    if (!initialized) { 
        float px     = 0.0f;
        float py     = 0.0f;
        float radius = 2.0f;

        for (UINT i = 0; i<count - 1; i += 2) {
          vertices[i    ] = XMFLOAT3(px + radius * COS(i    ), py + radius * SIN(i    ), 0.5f);
          vertices[i + 1] = XMFLOAT3(px + radius * COS(i + 1), py + radius * SIN(i + 1), 0.5f);
        }
        initialized = true;
    }
      
    if (pos > CIRCLE_ANGLE) {
      pos = 0;
    }
    return vertices[pos];          
  }

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

    try {        
      XMFLOAT3 position = getOrbitPosition(angle);
        
      DirectXMatrix world = DirectXMatrix::scaling( 1.0f, 1.0f, 1.0f);
      DirectXMatrix m = DirectXMatrix::translation(position.x, position.y, position.z);
      world += m;

      XMVECTOR eye = XMVectorSet(  2.0f,  3.0f, -6.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      = world;
      worldViewProjection.view       = DirectXMatrix::lookAtLH(eye, at, up);
      worldViewProjection.projection = DirectXMatrix::perspectiveFovLH( XM_PIDIV2*0.3f, 
          (FLOAT)width /(FLOAT)height, 0.01f, 100.0f );
       
      if (constantBufferView != nullptr) {
        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 = true;
        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(CBV_HANDLE) );

        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);
        
        torus                    = new Direct3DX12Torus(*device, 0.2f, 1.0f, 30, 30);
        
        //3 Create two pipelineState(wireframe and solid) from the sphere. 
        createWireFramePipelineState(*device, sphere);
        
        createSolidPipelineState(*device, sphere);

        //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 ||
        torus                     == 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();
      
    try {
      DirectXGISwapChain3*    swapChain = getSwapChain3();
      Direct3D12CommandQueue* commandQueue = getCommandQueue();
      static const int INCREMENT = 2;
      if (angle <(CIRCLE_ANGLE - INCREMENT) ) {
          angle += INCREMENT;
      } else {
          angle = INCREMENT;
      }
      
      setDirectXTransform();
        
      frameIndex = swapChain -> getCurrentBackBufferIndex();
        
      graphicsCommandList->startRendering(renderTargetView->getResource(frameIndex));

      graphicsCommandList->setDescriptorHeap(*commonDescriptorHeap);

      graphicsCommandList->setGraphicsRootSignature(*rootSignature);

      graphicsCommandList->setPipelineState(*pipelineState[FILL_MODE_WIREFRAME]);
        
      graphicsCommandList->setGraphicsRootDescriptorTable(CBV_HANDLE, 
                commonDescriptorHeap->getGPUHandle(CBV_HANDLE));

      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);
        
      //Draw the sphere on the worldViewProjection by wireFrame mode.
      sphere -> drawIndexedInstanced(graphicsCommandList);
       
      //Draw the torus on the worldViewProjection by solid mode.
      graphicsCommandList->setPipelineState(*pipelineState[FILL_MODE_SOLID]);
 
      torus->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 (30),
    frameIndex(0),
    directory(_T("")),
    pipelineCount(0),
    renderingInterval(100),
    fullscreened(false)
  {
    // Change a style of this window to be no-captiion.    
    LONG style = getWindowLong(GWL_STYLE);
    style &= ~WS_CAPTION;
    setWindowLong(GWL_STYLE, style| WS_POPUP);

    directory = (const TCHAR*)args.get(XmNapplicationDirectory);
      
    renderingInterval = (int)args.get(XmNrenderingInterval);
 
    for(int i = 0; i<MAX_PIPELINE_STATE; i++) {
      pipelineState[i] = NULL; 
    }

    //Create a quit pushbutton.
    Args ar;
    ar.set(XmNx, 10);
    ar.set(XmNy, 10);
    ar.set(XmNwidth, 120);
    ar.set(XmNheight, 30);
    quit = new PushButton(this, _T("QUIT"), ar);
    quit->addCallback(XmNactivateCallback, this,
        (Callback)&MainView::exit, NULL);
    //Create a label.
    ar.reset();
    ar.set(XmNx, 200);
    ar.set(XmNy, 200);
    ar.set(XmNwidth, 400);
    ar.set(XmNheight, 30);
    ar.set(XmNtextColor, RGB(0xff, 0, 0));
    ar.set(XmNtextAlignment, DT_LEFT); //DT_CENTER);

    ar.set(XmNlabelString, _T("Torus and Sphere Orbiters. Hello world. こんにちは世界"));
    label = new Label(this, _T(""), ar);
    
    postResizeRequest();
  }
    
  ~MainView()
  {
  }
};
}

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

  try {    
    SystemMetrics metrics;
    int width  = metrics.fullScreenWidth();
    int height = metrics.fullScreenHeight();

    Application applet(appClass, argc, argv);

    Args args;
    args.set(XmNx, 0);
    args.set(XmNy, 0);
    args.set(XmNwidth,  width);
    args.set(XmNheight, height);
    args.set(XmNapplicationDirectory, directory);
    args.set(XmNrenderingInterval, 100);  //100ms

    MainView mainView(applet, appClass, args);

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


Last modified: 1 Feb 2017

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