diguyDx11UniformBuffer.h

Go to the documentation of this file.

/*********************************************************************
 **
 *2  diguyDx9Util
 **
 **    Utilities for accessing the Direct3D device and a matrix stack.
 **
 **    s_d3dDevice9 must be assigned the Direct3D device.
 **    s_d3dMatStack must be created using D3DXCreateMatrixStack
 */

#pragma  once
#include <d3d11.h>
#include <DirectXMath.h>
#include <diguyUniformBufferUpdater.h>

DirectX::XMMATRIX float_to_mat(const float * matrix);

/*
 *  Convenience function to create an orientation matrix using a Euler
 *   rotation triplet.  Angles are in degrees.
 */
//extern void fillOrientationMatrix(D3DXMATRIX* orientMat, const float rotDeg[]);
/*
enum diguyOglBufferIndexes
{
DIGUY_UBO_TRANSFORM_INDEX,
DIGUY_UBO_MATERIAL_INDEX,
DIGUY_UBO_PER_FRAME_INDEX,
};


struct diguyOglUboMaterial
{
glm::vec4 ambient;
glm::vec4 diffuse;
glm::vec4 emissivity;
glm::vec4 specular;
float shininess;
};

struct diguyOglUboFog
{
diguyOglUboFog() {
mode = 0.0f;
start = 0.0f;
end = 100.0f;
density = .0001f;
}
// note 4 floats which is fine for alignment
float mode;
float start;
float end;
float density;
glm::vec4 color;
};

struct diguyOglUboLight
{
diguyOglUboLight() : diffuse(1.0f, 1.0f, 1.0f, 1.0f){
falloff_r = 0.0f;
falloff_rsq = 0.0f;
spot_angle = 0.0f;
spot_exponent = 0.0f;
}
glm::vec4 position;
glm::vec4 direction;
glm::vec4 ambient;
glm::vec4 diffuse;
glm::vec4 specular;
float  falloff_r;
float  falloff_rsq;
float  spot_angle;
float  spot_exponent;
};

const int DIGUY_OGL_MAX_NUM_LIGHTS = 8;

struct diguyOglPerFrameUniformBuffer
{
diguyOglPerFrameUniformBuffer() :
global_ambient(.2, .2, .2, 0),
num_active_lights(1)
{
lights[0].direction[0] = .7f;
lights[0].direction[1] = .7f;
lights[0].direction[2] = .7f;
}

glm::vec4 global_ambient;
diguyOglUboLight lights[DIGUY_OGL_MAX_NUM_LIGHTS];

diguyOglUboFog fog;

diguyShadowMapParams shadow_params;

int num_active_lights;

};

struct diguyOglMaterialUniformBuffer
{
diguyOglUboMaterial material;
};

struct diguyOglTransformUniformBuffer
{
glm::mat4 ufrm_ProjectionMatrix;        // needed by instancing
glm::mat4 ufrm_ViewMatrix;
glm::mat4 ufrm_ModelMatrix;
glm::mat4 ufrm_ModelViewMatrix;
glm::mat4 ufrm_ModelViewProjectionMatrix;
glm::mat4 ufrm_TextureMatrix;

// size problem? need to fix the padding
// this isn't actually used currently
glm::mat3 ufrm_NormalMatrix;

};*/

struct DiguyRenderingData
{
        DiguyRenderingData();
        ID3D11Device* pd3dDevice;
        ID3D11DeviceContext * pImmediateContext;
        DirectX::XMMATRIX mWorldViewProjection;
        DirectX::XMMATRIX mBaseMatrix;
        DirectX::XMMATRIX mLinkMatrix;
        const float * m_skinned_matrix_data;
        int m_num_mats;
        int m_skinned_data_needs_update;
};


#pragma pack(push,1)
struct CB_VS_DIGUY_PER_OBJECT
{
        int ufrm_apply_matrices_flag;
        int ufrm_spec_map_enabled;
        int padding[2];

        DirectX::XMFLOAT4X4  m_mWorldViewProjection;
        DirectX::XMFLOAT4X4  ufrm_link_matrix;
        DirectX::XMFLOAT4X3  ufrm_link_matrices[50];

        //      float shininess;
        //      DirectX::XMFLOAT4X4  m_mWorld;
};

struct CB_VS_DIGUY_MATERIAL
{
        DirectX::XMFLOAT4    m_MaterialAmbientColor;
        DirectX::XMFLOAT4    m_MaterialDiffuseColor;
        DirectX::XMFLOAT4    m_MaterialSpecularColor;
        DirectX::XMFLOAT4    m_MaterialEmissionColor;
};

class diguyDx11UniformBufferUpdater : public diguyUniformBufferUpdater
{
public:
        diguyDx11UniformBufferUpdater();
        virtual ~diguyDx11UniformBufferUpdater();
        /*
        diguyOglPerFrameUniformBuffer m_per_frame_ubo;

        diguyOglTransformUniformBuffer m_transform_stack_ubo;

        diguyOglMaterialUniformBuffer m_material_ubo;

        GLhandleARB m_uniform_transform_buffer_object;
        GLhandleARB m_uniform_material_buffer_object;
        GLhandleARB m_uniform_per_frame_buffer_object;
        */
        virtual void initialize();

        virtual void update(){ ; }

        virtual void set_model_matrix(const float * matrix){
                m_model_matrix = float_to_mat(matrix);
        }
        virtual void set_view_matrix(const float * matrix){
                m_view_matrix = float_to_mat(matrix);
        }
        virtual void get_view_matrix(float * matrix, int transpose){ ; }

        virtual void set_projection_matrix(const float * matrix){
                m_projection_matrix = float_to_mat(matrix);
        }
        virtual void set_texture_matrix(const float * matrix){ ; }
        virtual void set_material(const diguyGraphicsMaterial * material);
        virtual void set_material_color(float r, float g, float b, float a){ ; }
        virtual void set_material_spec(float r, float g, float b, float shine){ ; }

        virtual void set_fog(const  diguyViewFog * fog){ ; }

        virtual void set_global_ambient_light(float r, float g, float b){ ; }

        virtual void set_use_global_ambient_material(int val){ m_use_global_ambient_material = val; }
        virtual int get_use_global_ambient_material(){ return m_use_global_ambient_material; }

        virtual void set_global_ambient_material(float r, float g, float b){ ; }
        virtual void get_global_ambient_material(float *r, float *g, float *b){ ; }

        virtual void set_light(int index, const diguyLightRenderDesc * light){ ; }
        virtual void set_num_active_lights(int num_lights){ ; }
        virtual void set_shadow_map_params(const diguyShadowMapParams * shadow_params){ ; }
        virtual void set_eye_position(float x, float y, float z){ ; }

        DirectX::XMMATRIX m_model_matrix;
        DirectX::XMMATRIX m_view_matrix;
        DirectX::XMMATRIX m_projection_matrix;

        ID3D11Buffer*                       m_pcbVSPerObject11;
        ID3D11Buffer*                       m_pcbVSMaterial;

private:
        int m_per_frame_uniforms_needs_update;
        int m_transform_stack_needs_update;

        const diguyGraphicsMaterial * m_last_material;
        int m_use_global_ambient_material;
        //glm::vec4 m_global_ambient_material;

};
extern DiguyRenderingData s_diguy_dx11;


//extern ID3DXConstantTable* s_constantTable;