spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

  void Renderer::initialize(HWND wnd) throw(Exception)
  {
    if(!wnd)
      throw(Exception(EXC_BASE, L"Can't initialize Renderer with [wnd=NULL]"));
    window_ = wnd;

    direct3d_ = Direct3DCreate9(D3D_SDK_VERSION);
    if(!direct3d_)
      throw(Exception(EXC_BASE, L"Wasn't able to create D3D-Interface"));
    
    RECT temp;
    GetClientRect(window_, &temp);
    window_width_     = temp.right - temp.left;
    window_height_    = temp.bottom - temp.top;

    D3DPRESENT_PARAMETERS pp;
    ZeroMemory(&pp, sizeof(D3DPRESENT_PARAMETERS));
    pp.BackBufferWidth              = window_width_;
    pp.BackBufferHeight             = window_height_;
    pp.BackBufferFormat             = D3DFMT_A8R8G8B8;
    pp.BackBufferCount              = 1;
    pp.MultiSampleType              = D3DMULTISAMPLE_NONE;
    pp.MultiSampleQuality           = 0;
    pp.SwapEffect                   = D3DSWAPEFFECT_DISCARD;
    pp.hDeviceWindow                = window_;
    pp.Windowed                     = true;
    pp.EnableAutoDepthStencil       = TRUE;
    pp.AutoDepthStencilFormat       = D3DFMT_D24S8;
    pp.Flags                        = 0;
    pp.FullScreen_RefreshRateInHz   = D3DPRESENT_RATE_DEFAULT;
    pp.PresentationInterval         = D3DPRESENT_INTERVAL_ONE;

    if(FAILED(direct3d_->CreateDevice(0, D3DDEVTYPE_HAL, window_, D3DCREATE_HARDWARE_VERTEXPROCESSING, 
      &pp, &device_)))
      throw(Exception(EXC_BASE, L"failed to create a D3D-Device"));

    initialized_ = true;

    device_->SetRenderState(D3DRS_LIGHTING, FALSE);
    device_->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
    device_->SetRenderState(D3DRS_DITHERENABLE, TRUE);
    device_->SetRenderState(D3DRS_ZENABLE, TRUE);
    device_->SetRenderState(D3DRS_AMBIENT, 0x0);

    prepareShaderStuff();
  }

C-/C++-Quelltext

  void Renderer::prepareShaderStuff()
  {
    D3DVERTEXELEMENT9 vd[] = 
    {
      {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 tvd[] = 
    {
      {0, 0, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITIONT, 0},
      {0, 16, D3DDECLTYPE_D3DCOLOR, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_COLOR, 0},
      {0, 20, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0},
      D3DDECL_END()
    };

    device_->CreateVertexDeclaration(vd, &vertex_decl_);
    device_->CreateVertexDeclaration(tvd, &transformed_vertex_decl_);

    loadVertexShader(static_cast<__uint>(VT_STANDARD), std::wstring(L"vertex.vsh"), false);
    loadVertexShader(static_cast<__uint>(VT_TRANSFORMED), std::wstring(L"tvertex.vsh"), false);
    //wir haben nur einen Pixelshader für alle Vertextypen -> dieser kommt an position 0

    loadPixelShader(0, std::wstring(L"pixel.psh"), false);

    setVertexType(VT_STANDARD);

  }

C-/C++-Quelltext

  void Renderer::loadVertexShader(__uint array_pos, std::wstring const& filename, 
    bool compiled) throw(Exception)
  {
    HANDLE file, map;
    DWORD* vs;
    LPD3DXBUFFER    code = NULL;
    LPD3DXBUFFER    debug = NULL;

    if(compiled)
    {
      file = CreateFileW(filename.c_str(), GENERIC_READ, 0, 0, OPEN_EXISTING, 
        FILE_ATTRIBUTE_NORMAL, NULL);
      if(file == INVALID_HANDLE_VALUE) 
        throw(Exception(EXC_BASE, L"Wasn't able to laod a vertex-shader"));

      map = CreateFileMapping(file, 0, PAGE_READONLY, 0, 0, 0);
      vs = static_cast<DWORD*>(MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0));
    }
    else
    {
      if(FAILED(D3DXAssembleShaderFromFileW(filename.c_str(), NULL, NULL, D3DXSHADER_DEBUG, 
        &code, &debug)))
        throw(Exception(EXC_BASE, L"Wasn't able to compile vertex-shader from file"));
      vs = static_cast<DWORD*>(code->GetBufferPointer());
    }

    if(FAILED(device_->CreateVertexShader(vs, &vertexshader_[array_pos])))
      throw(Exception(EXC_BASE, L"Wasn't able to set vertex-shader"));

    if(compiled)
    {
      UnmapViewOfFile(vs);
      CloseHandle(map);
      CloseHandle(file);
    }

  }

C-/C++-Quelltext

  void Renderer::setVertexType(VertexType vt) throw(Exception)
  {
    if(vt == VT_STANDARD)
    {
      if(FAILED(device_->SetVertexDeclaration(vertex_decl_)))
        throw(Exception(EXC_BASE, L"Failed to set vertex declaration to normal"));
      if(FAILED(device_->SetVertexShader(vertexshader_[static_cast<__uint>(VT_STANDARD)])))
        throw(Exception(EXC_BASE, L"Failed to set the standard-vetex-shader"));
    }
    else if(vt == VT_TRANSFORMED)
    {
      if(FAILED(device_->SetVertexDeclaration(transformed_vertex_decl_)))
        throw(Exception(EXC_BASE, L"Failed to set vertex declaration to transformed"));
      if(FAILED(device_->SetVertexShader(vertexshader_[static_cast<__uint>(VT_TRANSFORMED)])))
        throw(Exception(EXC_BASE, L"Failed to set the transformed vertex-shader"));
    }
    if(FAILED(device_->SetPixelShader(pixelshader_[0])))
      throw(Exception(EXC_BASE, L"Failed to set the pixel-shader"));
  }