write me a c++ project that renders fbx scenes with directx11 and load scenes with assimp
- User
write me a c++ project that renders fbx scenes with directx11 and load scenes with assimp
- Assistant
Below is a complete “Hello-FBX” sample that:
• opens an FBX file with Assimp
• uploads the geometry & materials to Direct3D 11
• renders the scene with a very small lighting shaderEverything builds with one CMake command on a vanilla Visual Studio 2022 install (v143 tool-set).
Feel free to copy / fork / extend 🛠️──────────────────────────────────────── 📁 1. Directory layout ──────────────────────────────────────── HelloFbx/ ├─ CMakeLists.txt ├─ README.md ├─ Shaders/ │ ├─ VS.hlsl │ └─ PS.hlsl └─ src/ ├─ main.cpp ├─ Renderer.h / Renderer.cpp ├─ Camera.h / Camera.cpp ├─ Model.h / Model.cpp ├─ Mesh.h / Mesh.cpp └─ Shader.h / Shader.cpp
──────────────────────────────────────── 2. CMakeLists.txt (top-level) ──────────────────────────────────────── cmake_minimum_required(VERSION 3.17) project(HelloFbxDX11 LANGUAGES CXX)
2.1 ► Choose C++20 + static runtime
set(CMAKE_CXX_STANDARD 20) set(CMAKE_MSVC_RUNTIME_LIBRARY "MultiThreadedCONFIG:Debug:Debug>")
2.2 ► Fetch Assimp automatically
include(FetchContent) FetchContent_Declare( assimp GIT_REPOSITORY https://github.com/assimp/assimp.git GIT_TAG v5.3.1 ) FetchContent_MakeAvailable(assimp)
2.3 ► Source files
file(GLOB SRC CONFIGURE_DEPENDS src/.cpp src/.h) add_executable(HelloFbx ${SRC})
2.4 ► Compile shaders (only when they change)
set(SHADER_SRC Shaders/VS.hlsl Shaders/PS.hlsl ) foreach(SHADER {SHADER} NAME) set(OUT {FILE_NAME}.cso) add_custom_command( OUTPUT {CMAKE_COMMAND} -E make_directory {FILE_NAME MATCHES "VS" ? "vs_5_0" : "ps_5_0"} /E main /Fo {OUT}.asm /nologo {SHADER} ) list(APPEND SHADER_BLOBS {SHADER_BLOBS}) add_dependencies(HelloFbx Shaders)
2.5 ► libs & include
target_link_libraries(HelloFbx PRIVATE assimp d3d11 dxgi d3dcompiler )
2.6 ► Disable pesky warnings
if (MSVC) target_compile_options(HelloFbx PRIVATE /W3 /permissive-) endif()
──────────────────────────────────────── 3. Tiny math helper (uses DirectXMath, no extra lib) ──────────────────────────────────────── #include <DirectXMath.h> using namespace DirectX;
──────────────────────────────────────── 4. Shader headers ──────────────────────────────────────── src/Shader.h
#pragma once #include <d3d11.h> #include <wrl.h> #include class Shader { public: bool LoadVertexShader(ID3D11Device* d, const std::wstring& file, D3D11_INPUT_ELEMENT_DESC* desc, UINT numElems); bool LoadPixelShader (ID3D11Device* d, const std::wstring& file); void Bind(ID3D11DeviceContext* ctx); private: Microsoft::WRL::ComPtr vs_; Microsoft::WRL::ComPtr ps_; Microsoft::WRL::ComPtr layout_; };
src/Shader.cpp (excerpt)
#include "Shader.h" #include <d3dcompiler.h>
bool Shader::LoadVertexShader(ID3D11Device* d,const std::wstring& file, D3D11_INPUT_ELEMENT_DESC* desc,UINT numElems){ Microsoft::WRL::ComPtr blob; if(FAILED(D3DReadFileToBlob(file.c_str(),blob.GetAddressOf()))) return false; if(FAILED(d->CreateVertexShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, vs_.GetAddressOf()))) return false; if(FAILED(d->CreateInputLayout(desc,numElems,blob->GetBufferPointer(), blob->GetBufferSize(), layout_.GetAddressOf()))) return false; return true; } bool Shader::LoadPixelShader(ID3D11Device* d,const std::wstring& file){ Microsoft::WRL::ComPtr blob; if(FAILED(D3DReadFileToBlob(file.c_str(),blob.GetAddressOf()))) return false; return SUCCEEDED(d->CreatePixelShader(blob->GetBufferPointer(), blob->GetBufferSize(), nullptr, ps_.GetAddressOf())); } void Shader::Bind(ID3D11DeviceContext* ctx){ ctx->IASetInputLayout(layout_.Get()); ctx->VSSetShader(vs_.Get(), nullptr, 0); ctx->PSSetShader(ps_.Get(), nullptr, 0); }
──────────────────────────────────────── 5. Vertex & constant-buffer definitions ──────────────────────────────────────── struct Vertex { XMFLOAT3 pos; XMFLOAT3 norm; XMFLOAT2 uv; }; struct CB_Matrices { XMMATRIX model; XMMATRIX view; XMMATRIX proj; XMFLOAT4 lightDir; };
──────────────────────────────────────── 6. Mesh & Model (Assimp → GPU) ──────────────────────────────────────── src/Mesh.h / Mesh.cpp (core concepts)
class Mesh { public: Mesh(ID3D11Device* device, std::vector& verts, std::vector<uint32_t>& inds, ID3D11ShaderResourceView* srv) : indexCount_(inds.size()), srv_(srv) { // create vertex buffer D3D11_BUFFER_DESC vbd = {}; vbd.ByteWidth = UINT(verts.size() * sizeof(Vertex)); vbd.Usage = D3D11_USAGE_IMMUTABLE; vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER; D3D11_SUBRESOURCE_DATA vsd = {verts.data()}; device->CreateBuffer(&vbd, &vsd, vb_.GetAddressOf());
// index buffer D3D11_BUFFER_DESC ibd = vbd; ibd.ByteWidth = UINT(inds.size() * sizeof(uint32_t)); ibd.BindFlags = D3D11_BIND_INDEX_BUFFER; D3D11_SUBRESOURCE_DATA isd = {inds.data()}; device->CreateBuffer(&ibd, &isd, ib_.GetAddressOf()); } void Draw(ID3D11DeviceContext* ctx){ UINT stride = sizeof(Vertex), offset = 0; ctx->IASetVertexBuffers(0,1,vb_.GetAddressOf(),&stride,&offset); ctx->IASetIndexBuffer(ib_.Get(), DXGI_FORMAT_R32_UINT, 0); ctx->PSSetShaderResources(0,1, srv_.GetAddressOf()); ctx->DrawIndexed(indexCount_,0,0); }private: uint32_t indexCount_; Microsoft::WRL::ComPtr vb_, ib_; Microsoft::WRL::ComPtr srv_; };
src/Model.cpp (Assimp import loop – simplified)
#include "Model.h" #include <DirectXTex.h> // single-file library for WIC -> DDS #include <assimp/Importer.hpp> #include <assimp/scene.h> #include <assimp/postprocess.h>
static void ProcessNode(ID3D11Device* dev, const aiNode* node, const aiScene* scene, const std::filesystem::path& dir, std::vector<std::unique_ptr>& meshes) { // For every mesh at this node for (uint32_t i : std::span(node->mMeshes, node->mNumMeshes)) { const aiMesh* aMesh = scene->mMeshes[i]; std::vector verts; verts.reserve(aMesh->mNumVertices); for (unsigned v = 0; v < aMesh->mNumVertices; ++v) { Vertex vert; vert.pos = { aMesh->mVertices[v].x, aMesh->mVertices[v].y, aMesh->mVertices[v].z }; vert.norm = { aMesh->mNormals[v].x, aMesh->mNormals[v].y, aMesh->mNormals[v].z }; vert.uv = aMesh->HasTextureCoords(0) ? XMFLOAT2(aMesh->mTextureCoords[0][v].x, aMesh->mTextureCoords[0][v].y) : XMFLOAT2(0,0); verts.push_back(vert); } // indices std::vector<uint32_t> inds; for (unsigned f=0;fmNumFaces;++f) for(unsigned k=0;k<3;++k) inds.push_back(aMesh->mFaces[f].mIndices[k]);
// texture Microsoft::WRL::ComPtr<ID3D11ShaderResourceView> srv; if (aMesh->mMaterialIndex >= 0) { aiString texPath; scene->mMaterials[aMesh->mMaterialIndex] ->GetTexture(aiTextureType_DIFFUSE, 0, &texPath); auto file = dir / texPath.C_Str(); DirectX::TexMetadata meta; DirectX::ScratchImage img; DirectX::LoadFromWICFile(file.c_str(), DirectX::WIC_FLAGS_NONE,&meta,img); DirectX::CreateShaderResourceView(dev, img.GetImages(), img.GetImageCount(), meta, &srv); } meshes.emplace_back(std::make_unique<Mesh>(dev, verts, inds, srv.Get())); } // Recurse for (unsigned n=0;n<node->mNumChildren;++n) ProcessNode(dev, node->mChildren[n], scene, dir, meshes);}
bool Model::Load(ID3D11Device* dev, const std::filesystem::path& file) { Assimp::Importer imp; const aiScene* scene = imp.ReadFile(file.string(), aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_CalcTangentSpace); if(!scene || !scene->mRootNode) return false; auto dir = file.parent_path(); ProcessNode(dev, scene->mRootNode, scene, dir, meshes_); return true; }
void Model::Draw(ID3D11DeviceContext* ctx) { for (auto& m : meshes_) m->Draw(ctx); }
──────────────────────────────────────── 7. Renderer (device + loop) ──────────────────────────────────────── src/Renderer.h (excerpt)
class Renderer { public: bool Init(HWND hWnd, uint32_t w, uint32_t h); void Render(const Model& m, const Camera& cam); void Resize(uint32_t w, uint32_t h); private: Microsoft::WRL::ComPtr dev_; Microsoft::WRL::ComPtr ctx_; Microsoft::WRL::ComPtr swap_; Microsoft::WRL::ComPtr rtv_; Microsoft::WRL::ComPtr dsv_; Microsoft::WRL::ComPtr cb_; Shader shader_; };
src/Renderer.cpp (Init essentials)
bool Renderer::Init(HWND hWnd,uint32_t w,uint32_t h){ DXGI_SWAP_CHAIN_DESC sd = {}; sd.BufferDesc.Width = w; sd.BufferDesc.Height = h; sd.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; sd.SampleDesc.Count = 1; sd.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT; sd.BufferCount = 2; sd.OutputWindow = hWnd; sd.Windowed = TRUE;
UINT flags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;#ifdef DEBUG flags |= D3D11_CREATE_DEVICE_DEBUG; #endif if(FAILED(D3D11CreateDeviceAndSwapChain(nullptr, D3D_DRIVER_TYPE_HARDWARE,nullptr,flags,nullptr,0, D3D11_SDK_VERSION,&sd,swap.GetAddressOf(),dev_.GetAddressOf(), nullptr, ctx_.GetAddressOf()))) return false;
// RTV Microsoft::WRL::ComPtr<ID3D11Texture2D> backBuf; swap_->GetBuffer(0,IID_PPV_ARGS(backBuf.GetAddressOf())); dev_->CreateRenderTargetView(backBuf.Get(), nullptr, rtv_.GetAddressOf()); // DSV D3D11_TEXTURE2D_DESC depthDesc = {}; depthDesc.Width=w; depthDesc.Height=h; depthDesc.MipLevels=1; depthDesc.ArraySize=1; depthDesc.Format=DXGI_FORMAT_D24_UNORM_S8_UINT; depthDesc.SampleDesc.Count=1; depthDesc.BindFlags=D3D11_BIND_DEPTH_STENCIL; Microsoft::WRL::ComPtr<ID3D11Texture2D> depthTex; dev_->CreateTexture2D(&depthDesc,nullptr,depthTex.GetAddressOf()); dev_->CreateDepthStencilView(depthTex.Get(),nullptr,dsv_.GetAddressOf()); // constant buffer D3D11_BUFFER_DESC cbd = {}; cbd.ByteWidth = sizeof(CB_Matrices); cbd.Usage = D3D11_USAGE_DYNAMIC; cbd.BindFlags = D3D11_BIND_CONSTANT_BUFFER; cbd.CPUAccessFlags = D3D11_CPU_ACCESS_WRITE; dev_->CreateBuffer(&cbd,nullptr,cb_.GetAddressOf()); // compile & load shaders D3D11_INPUT_ELEMENT_DESC inputDesc[] = { {"POSITION",0,DXGI_FORMAT_R32G32B32_FLOAT,0,0, D3D11_INPUT_PER_VERTEX_DATA,0}, {"NORMAL", 0,DXGI_FORMAT_R32G32B32_FLOAT,0,12,D3D11_INPUT_PER_VERTEX_DATA,0}, {"TEXCOORD",0,DXGI_FORMAT_R32G32_FLOAT, 0,24,D3D11_INPUT_PER_VERTEX_DATA,0}, }; shader_.LoadVertexShader(dev_.Get(),L"VS.hlsl.cso",inputDesc,3); shader_.LoadPixelShader (dev_.Get(),L"PS.hlsl.cso"); ctx_->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); return true;}
void Renderer::Render(const Model& model,const Camera& cam){ float clr[4]={0.1f,0.1f,0.12f,1}; ctx_->ClearRenderTargetView(rtv_.Get(),clr); ctx_->ClearDepthStencilView(dsv_.Get(),D3D11_CLEAR_DEPTH,1,0); ctx_->OMSetRenderTargets(1,rtv_.GetAddressOf(),dsv_.Get());
// map / upload matrices D3D11_MAPPED_SUBRESOURCE map; ctx_->Map(cb_.Get(),0,D3D11_MAP_WRITE_DISCARD,0,&map); auto* cbData = reinterpret_cast<CB_Matrices*>(map.pData); cbData->model = XMMatrixTranspose(XMMatrixIdentity()); cbData->view = XMMatrixTranspose(cam.View()); cbData->proj = XMMatrixTranspose(cam.Proj()); cbData->lightDir = XMFLOAT4(-0.5f, -1.0f, -0.3f, 0.0f); ctx_->Unmap(cb_.Get(),0); ctx_->VSSetConstantBuffers(0,1,cb_.GetAddressOf()); shader_.Bind(ctx_.Get()); model.Draw(ctx_.Get()); swap_->Present(1,0);}
──────────────────────────────────────── 8. Super-mini camera ──────────────────────────────────────── class Camera { public: Camera(float w,float h):pos_(0,1,-5){ proj_=XMMatrixPerspectiveFovLH(XM_PIDIV4,w/h,0.1f,100.f); } void Update(float dt){ // WASD movement etc. (left as exercise) } XMMATRIX View() const { return XMMatrixLookAtLH(pos_, XMVectorZero(), {0,1,0}); } XMMATRIX Proj() const { return proj_; } private: XMVECTOR pos_; XMMATRIX proj_; };
──────────────────────────────────────── 9. WinMain / message-loop (main.cpp excerpt) ──────────────────────────────────────── int WINAPI wWinMain(HINSTANCE, HINSTANCE, PWSTR, int){ // 9.1 ► Register & create window (skip code for brevity) … Renderer renderer; renderer.Init(hwnd, 1280, 720);
Model fbScene; fbScene.Load(renderer.Device(), L"Assets/Sponza/sponza.fbx"); Camera cam(1280,720); MSG msg = {}; while(msg.message != WM_QUIT){ if(PeekMessage(&msg,nullptr,0,0,PM_REMOVE)){ TranslateMessage(&msg); DispatchMessage(&msg); }else{ cam.Update(0.016f); renderer.Render(fbScene, cam); } } return 0;}
──────────────────────────────────────── 10. Shaders/VS.hlsl ──────────────────────────────────────── cbuffer CB_Matrices : register(b0){ float4x4 model; float4x4 view; float4x4 proj; float4 lightDir; }; struct VSIn { float3 pos:POSITION; float3 n:NORMAL; float2 uv:TEXCOORD; }; struct PSIn { float4 pos:SV_POSITION; float3 n:NORMAL; float2 uv:TEXCOORD; }; PSIn main(VSIn i){ PSIn o; float4 wPos = mul(float4(i.pos,1),model); o.pos = mul(mul(wPos,view),proj); o.n = mul(float4(i.n,0), model).xyz; o.uv = i.uv; return o; }
Shaders/PS.hlsl ──────────────────────────────────────── Texture2D tx : register(t0); SamplerState samp : register(s0); cbuffer CB_Matrices : register(b0){ float4x4 model; float4x4 view; float4x4 proj; float4 lightDir; } float4 main(PSIn i) : SV_TARGET{ float3 norm = normalize(i.n); float diff = saturate(dot(norm, -lightDir.xyz))*0.8 + 0.2; return tx.Sample(samp, i.uv) * diff; }
──────────────────────────────────────── 11. Build & run ────────────────────────────────────────
mkdir build && cd build
cmake ..
cmake --build . --config Release
.\Release\HelloFbx.exe──────────────────────────────────────── 12. Notes & next steps ──────────────────────────────────────── • Assimp’s FBX importer is good but not perfect; test with ASCII & binary FBX.
• For big scenes use instancing & frustum culling.
• Add tangent/bitangent extraction for normal-mapped materials (aiProcess_CalcTangentSpace).
• Replace DirectXTex with DirectXTK’s WICTextureLoader or your own loader to support GPU-compressed formats.
• Enable MSAA by changing swap-chain & depth-buffer sample counts.
• Add an ImGui overlay for tweaking light / camera / diagnostics.Happy hacking & enjoy your DirectX 11 + Assimp adventure! 🚀
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.