diguyGraphicsShaderTechnique.h

Go to the documentation of this file.

/*********************************************************************
 ** Copyright (c) 1992-2015 VT MAK
 ** 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(0),
                m_custom_shader_program(0),
                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:
         **
         **    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 */