mesh.h

Go to the documentation of this file.

/*
 * Dune D3D library - Tobias Alexander Franke 2011
 * For copyright and license see LICENSE
 * http://www.tobias-franke.eu
 */

#ifndef DUNE_MESH
#define DUNE_MESH

#include <D3D11.h>
#include <DirectXMath.h>

#include <memory>
#include <cassert>

#include "unicode.h"

namespace dune
{
    template<typename V>
    struct aabb
    {
    protected:
        V bb_max_;
        V bb_min_;
        DirectX::XMFLOAT4X4 world_;

    protected:
        inline void init_bb(const V& p)
        {
            bb_max_ = bb_min_ = p;
        }

        void update_bb(const V& p)
        {
            bb_max_ = max(p, bb_max_);
            bb_min_ = min(p, bb_min_);
        }

    public:
        inline V center() const { return bb_min_ + (bb_max_ - bb_min_)/2.0f; };

        inline V bb_max() const { return bb_max_; };

        inline V bb_min() const { return bb_min_; };

        inline virtual void set_world(const DirectX::XMFLOAT4X4& world)
        {
            world_ = world;
        }

        inline const DirectX::XMFLOAT4X4& world()
        {
            return world_;
        }
    };

    bool is_visible(const aabb<DirectX::XMFLOAT3>& bbox, const DirectX::XMFLOAT4X4& to_clip);

    template<typename V>
    struct mesh : public aabb<V>
    {
    public:
        virtual size_t num_vertices() = 0;

        virtual size_t num_faces() = 0;
    };

    const D3D11_INPUT_ELEMENT_DESC standard_vertex_desc[] =
    {
        { "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 },
        0
    };

    struct d3d_mesh : public mesh<DirectX::XMFLOAT3>
    {
    protected:
        ID3D11VertexShader* vs_;
        ID3D11PixelShader* ps_;

        ID3D11InputLayout* vertex_layout_;

        INT diffuse_tex_slot_;
        INT normal_tex_slot_;
        INT specular_tex_slot_;

    protected:
        /* !\brief Returns the vertex_descriptor of a basic d3d_mesh. */
        virtual const D3D11_INPUT_ELEMENT_DESC* vertex_desc() { return standard_vertex_desc; }

    public:
        d3d_mesh();
        virtual ~d3d_mesh() {}

        virtual void set_shader(ID3D11Device* device, ID3DBlob* input_binary, ID3D11VertexShader* vs, ID3D11PixelShader* ps);

        virtual void set_shader_slots(INT diffuse_tex = -1,
                                      INT normal_tex = -1,
                                      INT specular_tex = -1)
        {
            diffuse_tex_slot_  = diffuse_tex;
            normal_tex_slot_   = normal_tex;
            specular_tex_slot_ = specular_tex;
        }

        virtual void create(ID3D11Device* device, const tstring& filename) = 0;

        virtual void destroy();

        virtual void render(ID3D11DeviceContext* context, DirectX::XMFLOAT4X4* to_clip = nullptr) = 0;
    };

    void load_model(ID3D11Device* device, const tstring& file, std::shared_ptr<d3d_mesh>& ptr);
}

#endif // MESH