1.support texture

2.resize backbuffer when window resize

Author: wetstreet

res/shaders/hlsl/shaders.hlsl

@@ -39,10 +39,11 @@ VS_Output vs_main(VS_Input input)
 
 float4 ps_main(VS_Output input) : SV_Target
 {
-    //return mytexture.Sample(mysampler, input.uv);
-    float NdotL = max(0, dot(input.worldNormal, _MainLightPosition));
+    float3 albedo = mytexture.Sample(mysampler, input.uv).rgb;
 
-    float3 finalColor = NdotL;
+    float nl = max(0, dot(input.worldNormal, _MainLightPosition));
+
+    float3 finalColor = nl * albedo * _MainLightColor.rgb;
 
     return float4(finalColor, 1);
 }

src/common/Texture.cpp

@@ -10,18 +10,21 @@ glm::vec2 Texture::vec2_zero = glm::vec2(0, 0);
 glm::vec2 Texture::vec2_one = glm::vec2(1, 1);
 
 std::shared_ptr<Texture> Texture::white_tex;
+std::shared_ptr<Texture> Texture::brick_tex;
 std::shared_ptr<Texture> Texture::normal_tex;
 
 void Texture::Init()
 {
 	white_tex = std::make_shared<Texture>("res/obj/white_texture.png");
 	normal_tex = std::make_shared<Texture>("res/obj/normal_texture.png");
+	brick_tex = std::make_shared<Texture>("res/obj/brick.png");
 }
 
 void Texture::Uninit()
 {
 	white_tex = nullptr;
 	normal_tex = nullptr;
+	brick_tex = nullptr;
 }
 
 void FlipYTexture(const unsigned int width, const unsigned int height, float* data) {

src/common/Texture.h

@@ -33,6 +33,7 @@ class Texture
         GLenum type = GL_UNSIGNED_BYTE;
 
         static std::shared_ptr<Texture> white_tex;
+        static std::shared_ptr<Texture> brick_tex;
         static std::shared_ptr<Texture> normal_tex;
 
     private:

src/d3d11/D3D11Renderer.cpp

@@ -100,9 +100,62 @@ void D3D11Renderer::RegisterMesh(Mesh* mesh)
 
 void D3D11Renderer::UnregisterMesh(Mesh* mesh)
 {
+    std::shared_ptr<D3D11Mesh> d3d11mesh = meshDict[mesh];
+    d3d11mesh->vertexBuffer->Release();
+    d3d11mesh->indexBuffer->Release();
     meshDict.erase(mesh);
 }
 
+void D3D11Renderer::RegisterTexture(Texture* tex)
+{
+    if (tex->bytes == nullptr)
+        return;
+    ID3D11ShaderResourceView* textureView;
+    {
+        D3D11_TEXTURE2D_DESC textureDesc = {};
+        textureDesc.Width = tex->width;
+        textureDesc.Height = tex->height;
+        textureDesc.MipLevels = 1;
+        textureDesc.ArraySize = 1;
+        textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM_SRGB;
+        textureDesc.SampleDesc.Count = 1;
+        textureDesc.Usage = D3D11_USAGE_IMMUTABLE;
+        textureDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE;
+
+        D3D11_SUBRESOURCE_DATA textureSubresourceData = {};
+        textureSubresourceData.pSysMem = tex->bytes;
+        textureSubresourceData.SysMemPitch = 4 * tex->width;
+
+        ID3D11Texture2D* texture;
+        pd3dDevice->CreateTexture2D(&textureDesc, &textureSubresourceData, &texture);
+
+        pd3dDevice->CreateShaderResourceView(texture, nullptr, &textureView);
+        texture->Release();
+    }
+
+    std::shared_ptr<TextureData> texData = std::make_shared<TextureData>();
+    texData->srv = textureView;
+    texDict[tex] = texData;
+}
+
+void D3D11Renderer::UnregisterTexture(Texture* texture)
+{
+    if (texture->bytes == nullptr)
+        return;
+    std::shared_ptr<TextureData> texData = texDict[texture];
+    texData->srv->Release();
+    texDict.erase(texture);
+}
+
+void D3D11Renderer::BindTexture(Texture& texture, GLuint slot)
+{
+    if (texture.bytes == nullptr)
+        return;
+    std::shared_ptr<TextureData> texdata = texDict[&texture];
+    pd3dDeviceContext->PSSetShaderResources(0, 1, &texdata->srv);
+    pd3dDeviceContext->PSSetSamplers(0, 1, &samplerState);
+}
+
 void D3D11Renderer::CreateBackBuffer()
 {
     ID3D11Texture2D* pBackBuffer;
@@ -111,6 +164,23 @@ void D3D11Renderer::CreateBackBuffer()
     pBackBuffer->Release();
 }
 
+void D3D11Renderer::UpdateBackBuffer(int width, int height)
+{
+    pd3dDeviceContext->OMSetRenderTargets(0, 0, 0);
+    mainRenderTargetView->Release();
+
+    HRESULT res = pSwapChain->ResizeBuffers(0, 0, 0, DXGI_FORMAT_UNKNOWN, 0);
+    assert(SUCCEEDED(res));
+
+    ID3D11Texture2D* d3d11FrameBuffer;
+    res = pSwapChain->GetBuffer(0, __uuidof(ID3D11Texture2D), (void**)&d3d11FrameBuffer);
+    assert(SUCCEEDED(res));
+
+    res = pd3dDevice->CreateRenderTargetView(d3d11FrameBuffer, NULL, &mainRenderTargetView);
+    assert(SUCCEEDED(res));
+    d3d11FrameBuffer->Release();
+}
+
 void D3D11Renderer::CreateRenderTarget()
 {
     D3D11_TEXTURE2D_DESC textureDesc;
@@ -293,6 +363,21 @@ bool D3D11Renderer::InitRender()
         pd3dDevice->CreateDepthStencilState(&depthStencilDesc, &depthStencilState);
     }
 
+    // Create Sampler State
+    {
+        D3D11_SAMPLER_DESC samplerDesc = {};
+        samplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT;
+        samplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_BORDER;
+        samplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_BORDER;
+        samplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_BORDER;
+        samplerDesc.BorderColor[0] = 1.0f;
+        samplerDesc.BorderColor[1] = 1.0f;
+        samplerDesc.BorderColor[2] = 1.0f;
+        samplerDesc.BorderColor[3] = 1.0f;
+        samplerDesc.ComparisonFunc = D3D11_COMPARISON_NEVER;
+
+        pd3dDevice->CreateSamplerState(&samplerDesc, &samplerState);
+    }
 
     return true;
 }
@@ -301,15 +386,6 @@ D3D11Renderer::~D3D11Renderer()
 {
 }
 
-void D3D11Renderer::RegisterTexture(Texture* texture)
-{
-}
-
-void D3D11Renderer::BindTexture(Texture& texture, GLuint slot)
-{
-    std::cout << "bind texture" << std::endl;
-}
-
 int D3D11Renderer::GetObjectID(int x, int y)
 {
 	return 0;
@@ -396,9 +472,8 @@ void D3D11Renderer::Render(Scene& scene)
                     pd3dDeviceContext->Unmap(PSConstantBuffer, 0);
                 }
 
+                BindTexture(*Texture::brick_tex, 0);
 
-                //pd3dDeviceContext->PSSetShaderResources(0, 1, &textureView);
-                //pd3dDeviceContext->PSSetSamplers(0, 1, &samplerState);
 
                 DrawMesh(*mesh);
             }

src/d3d11/D3D11Renderer.h

@@ -35,6 +35,12 @@ class D3D11Mesh
     UINT offset;
 };
 
+class TextureData
+{
+public:
+    ID3D11ShaderResourceView* srv;
+};
+
 class D3D11Renderer : public RealtimeRenderer
 {
 public:
@@ -51,6 +57,7 @@ class D3D11Renderer : public RealtimeRenderer
     void CleanupDeviceD3D();
 
     void CreateBackBuffer();
+    void UpdateBackBuffer(int width, int height);
 
     void CreateRenderTarget();
     void CleanupRenderTarget();
@@ -64,7 +71,7 @@ class D3D11Renderer : public RealtimeRenderer
     virtual void RegisterMesh(Mesh* mesh);
     //virtual void RegisterSkybox(Skybox* skybox);
 
-    //virtual void UnregisterTexture(Texture* texture);
+    virtual void UnregisterTexture(Texture* texture);
     virtual void UnregisterMesh(Mesh* mesh);
     //virtual void UnregisterSkybox(Skybox* skybox);
 
@@ -110,6 +117,8 @@ class D3D11Renderer : public RealtimeRenderer
     ID3D11PixelShader* pixelShader;
 
     std::unordered_map<Mesh*, std::shared_ptr<D3D11Mesh>> meshDict;
+    std::unordered_map<Texture*, std::shared_ptr<TextureData>> texDict;
+    ID3D11SamplerState* samplerState;
 
     ID3D11InputLayout* inputLayout;
     ID3D11Buffer* VSConstantBuffer;

src/main_d3d11.cpp

@@ -24,6 +24,10 @@ void MeshUnregister(Mesh* mesh) { pD3D11Renderer->UnregisterMesh(mesh); }
 void SkyboxUnregister(Skybox* skybox) { pD3D11Renderer->UnregisterSkybox(skybox); }
 void TextureBind(Texture& tex, GLuint slot) { pD3D11Renderer->BindTexture(tex, slot); }
 
+void OnResizeFrame(GLFWwindow* window, int width, int height) {
+    pD3D11Renderer->UpdateBackBuffer(width, height);
+}
+
 // Main code
 int main(int, char**)
 {
@@ -35,7 +39,7 @@ int main(int, char**)
         std::cout << "Creat window error" << std::endl;
         return -1;
     }
-    //glfwSetFramebufferSizeCallback(window, OnResizeFrame);
+    glfwSetFramebufferSizeCallback(window, OnResizeFrame);
 
     auto hwnd = glfwGetWin32Window(window);
 
@@ -48,7 +52,7 @@ int main(int, char**)
     MeshUnregisterFunction = MeshUnregister;
     TextureBindFunction = TextureBind;
 
-    pD3D11Renderer = std::make_shared< D3D11Renderer>();
+    pD3D11Renderer = std::make_shared<D3D11Renderer>();
 
     D3D11Renderer& d3d11Renderer = *pD3D11Renderer;
 
@@ -84,9 +88,9 @@ int main(int, char**)
 
     Camera camera(width, height, glm::vec3(0.0f, 0.0f, 5.0f));
     Scene scene(camera);
-    /*
-    Shader::Init();
-    Texture::Init();*/
+    
+    //Shader::Init();
+    Texture::Init();
 
     RasterizerRenderer rasterizerRenderer;
     RayTracerRenderer raytracer;
@@ -132,6 +136,8 @@ int main(int, char**)
         glfwPollEvents();
     }
 
+    Texture::Uninit();
+
     ImGui_ImplDX11_Shutdown();
     ImGui_ImplGlfw_Shutdown();
     ImGui::DestroyContext();