diguyDx11UniformBuffer.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2024 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/

/*********************************************************************
 **
 *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 get_projection_matrix(float * matrix, int transpose) { ; }

   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;