diguyGraphicsShaderTechnique.h

Go to the documentation of this file.

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

/*********************************************************************/
#ifndef __diguyGraphicsShaderTechnique_H
#define __diguyGraphicsShaderTechnique_H


#ifdef SWIG
%module diguyGraphicsShaderTechnique
#else
#define CPLUSPLUS_ONLY
#endif

#ifdef CPLUSPLUS_ONLY

#include <diguy_constants.h>
#include <declspec_diguy.h>

class diguyGraphicsLink;
class diguyGraphicsShaderInstance;
class diguyGraphicsShaderProgram;
class bdiShaderTechnique;

#endif

typedef void diguyDrawFunc();

typedef enum
{
   DIGUY_DRAW_NONE = 0,
   DIGUY_DRAW_OPAQUE = 0x1,
   DIGUY_DRAW_TRANSPARENT = 0x2
} diguyRenderPass;

/****************************************************************************/
struct BDI_DECLSPEC_diguy diguyDrawPass
{
   diguyDrawPass() :
      m_render_pass(DIGUY_DRAW_NONE),
      m_render_mode(NULL),
      m_custom_shader_program(NULL),
      m_pre_draw(0),
      m_pre_draw_user_data(0),
      m_post_draw(0),
      m_post_draw_user_data(0)
   {}

   bool operator==(const diguyDrawPass& rhs) const
   {
     return (m_render_pass == rhs.m_render_pass &&
           m_pre_draw == rhs.m_pre_draw &&
           m_pre_draw_user_data == rhs.m_pre_draw_user_data &&
           m_post_draw == rhs.m_post_draw &&
           m_post_draw_user_data == rhs.m_post_draw_user_data);
   }

   int m_render_pass;
   const char* m_render_mode;
   const char* m_custom_shader_program;

   diguyDrawFunc* m_pre_draw;
   void* m_pre_draw_user_data;

   diguyDrawFunc* m_post_draw;
   void* m_post_draw_user_data;
};


/****************************************************************************/
struct diguyShaderPickDescription
{
   diguyShaderPickDescription() :
      m_shader_instance(NULL),
      m_current_render_pass(0),
      m_current_render_flags(0),
      m_shader_lod(-1),
      m_render_distance(0),
      m_shader_lod_bias(1),
      m_num_active_point_lights(0),
      m_use_instancing(false),
      m_custom_shader_program(NULL)
   {
      ;
   }

   int m_current_render_pass;

   int m_current_render_flags;

   int m_shader_lod;

   float m_render_distance;

   float m_shader_lod_bias;

   int m_max_quality_level;

   int m_num_active_point_lights;

   const char* m_custom_shader_program;

   bool m_use_instancing;

   diguyGraphicsShaderInstance * m_shader_instance;
};

/****************************************************************************/
class BDI_DECLSPEC_diguy diguyGraphicsShaderTechnique
{

public:

/*****************************************************************************/
   /*l
    *b  Returns:
    **
    **    the name of the shader technique.  This pointer will
    **    never be NULL.
    */
   const char* get_name();

   /*l
    *b  Description:
    **
    **    Returns the number of lod shaders the technique has.
    */
   int get_num_shader_lod_programs(bool instanced = false);

   /*l
    *b  Description:
    **
    **    Returns the shader program at a lod index.
    */
   diguyGraphicsShaderProgram* get_shader_lod_program_at_index(int index, bool instanced = false);

   /*l
    *b  Description:
    **
    **    Returns the distance that a shader lod switches out at.
    */
   float get_shader_lod_range_at_index(int index);

   /*l
    *b  Description:
    **
    **    Returns a shader based on the rendering distance.
    */
   diguyGraphicsShaderProgram * get_shader_by_distance(float distance, int max_quality_level, bool instanced = false);

   /*l
    *b  Description:
    **
    **    Returns the shader index based on the rendering distance.
    */
   int get_program_index_by_distance(float distance, int max_quality_level);

   /*l
    *b  Description:
    **
    **    Returns the shader specified for intersections.
    */
   diguyGraphicsShaderProgram* get_intersection_shader();

   /*l
    *b  Description:
    **
    **    Returns the shader specified for shadow map generation.
    */
   diguyGraphicsShaderProgram* get_shadow_pass_shader();

   /*l
    *b  Description:
    **
    **    Returns the shader specified for shadow map generation for instanced objects
    */
   diguyGraphicsShaderProgram * get_instanced_shadow_pass_shader();

/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    This function allows you create a new shader that uses the same
    **    vertex and pixel files as the one passed in. The user is then able
    **    modify the subclassed shader before calling load().
    **    This function should allow end users to create an arbitrary number of
    **    shader permutations and then return them via overriding pick_shader_program().
    **    See diguyOglGraphicsShaderTechnique::build() for an example of it's usage.
    **    Override pick_shader_program() to return a procedurally created shader.
    */
   diguyGraphicsShaderProgram * find_or_create_shader_variation(diguyGraphicsShaderProgram * program, const char * new_name);

   /*l
    *b  Description:
    **
    **    Adds an additional shader program to the technique these will get
    **    automatically updated if any of the shader uniform functions are used.
    **    These are mostly for convenience. Users will probably want their own
    **    data structures to store shader lookup tables.
    **/
   void add_additional_shader(diguyGraphicsShaderProgram* program);

   /*l
    *b  Returns:
    **    The number of shaders that have been procedurally added to the technique.
    */
   int get_num_additional_shaders();

   /*l
    *b  Returns:
    **    A pointer to the procedural shaders that has been procedurally added to
    **    the technique.
    */
   diguyGraphicsShaderProgram* get_additional_shader_at_index(int index);

/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Convenience functions. Loops through all shaders in this technique
    **    and sets uniform variables if they exist.
    **
    *b  Callable From:
    **
    *-    - C++
    *-    - Script
    */
   int set_variable_float(const char* name, float value, int set_current = 1, int set_initial = 0);
   int set_variable_vec2(const char* name, float x, float y, int set_current = 1, int set_initial = 0);
   int set_variable_vec3(const char* name, float x, float y, float z, int set_current = 1, int set_initial = 0);
   int set_variable_vec4(const char* name, float x, float y, float z, float w, int set_current = 1, int set_initial = 0);
   int set_variable_int(const char* name, int value, int set_current = 1, int set_initial = 0);

/*****************************************************************************/
   /*l
    *b  Description:
    **
    **    Allows users to use a subclass to override the default shader LOD system
    **    see diguyOglGraphicsShaderTechnique::pick_shader_program() for an example
    **    of it's usage.
    **/
   virtual diguyGraphicsShaderProgram * pick_shader_program(const diguyShaderPickDescription & desc);


   /*l
    *b  Description:
    **
    **    Allows users to do their own post shader load behavior.
    **/
   virtual void build();

#ifdef CPLUSPLUS_ONLY

   bdiShaderTechnique* get_internal_data() {return m_internal_data;}

protected:

   /*l
    **    A protected constructor.  Constructors are called automatically
    **    by DI-Guy.
    */
   diguyGraphicsShaderTechnique(void* internal_data);

   /*l
    **    A protected destructor.  Destructors are called automatically
    **    by DI-Guy.
    */
   virtual ~diguyGraphicsShaderTechnique();

private:

   /*l
    **    A pointer to internal data.
    */
   bdiShaderTechnique* m_internal_data;

   friend class bdiShaderTechnique;
   friend class bdiGeometryFactory;
#endif
};


#endif /* __diguyGraphicsShaderTechnique_H */