hlslSm3FXShader.h

//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+


#ifndef HLSL_SM3_FX_SHADER2_H
#define HLSL_SM3_FX_SHADER2_H

#include <vector>
#include <string>

#include <IAshliFX.h>
#include <IAshli.h>

#include "Shader.h"
#include "Observer.h"
#include "glExtensions.h"

class hlslSm3FXShader : public shader {

  struct uniform;
  public:

    hlslSm3FXShader( );
    virtual ~hlslSm3FXShader();

  //
  // Shader loading and management routines
  //
  //  These routines are intended to deal with the realities of deferred processing
  // in the Maya environemnt. The shader file ideally needs to be parsed and parameters
  // extracted prior to the availability of a GL context. This forces shader compilation
  // to be defered until first use.
  //
    bool createFromFile( const char *filename);
    bool createFromFX( IAshliFX *fx);
  protected:
    bool parseParameters( const IAshliFX *fx);
    DataType parseUniformType( const char *type);
    Semantic parseUniformSemantic( const char *semantic);
    SamplerType parseSamplerType( const char *type);
    void parseExpression( uniform &u, const char *exp);
    
    void updateHandles(); //configure the handles for the uniforms, etc.
    bool buildShaders(); //build the shaders that we had to defer compilation on
    virtual const char* getVertexShader( int pass) {return NULL;};
    virtual const char* getPixelShader( int pass) {return NULL;};

  public:
    virtual bool valid();
    virtual int passCount();
    virtual int techniqueCount();
    virtual const char* techniqueName( int n);
    virtual bool build();
    virtual void bind();
        virtual void setShapeDependentState();
    virtual void unbind();
    virtual void setTechnique( int t);
    virtual void setPass( int p);

    //need to have queries for attribs and uniforms
    virtual int uniformCount();
    virtual int samplerCount();
    virtual int attributeCount();
    virtual const char* uniformName(int i);
    virtual DataType uniformType(int i);
    virtual Semantic uniformSemantic(int i);
    virtual const char* samplerName(int i);
    virtual SamplerType samplerType(int i);
    virtual const char* attributeName(int i);
    virtual DataType attributeType(int i);
    virtual int attributeHandle(int i) {return 0;};

    //need set functions for current values
    virtual void updateUniformBool( int i, bool val);
    virtual void updateUniformInt( int i, int val);
    virtual void updateUniformFloat( int i, float val);
    virtual void updateUniformBVec( int i, const bool* val);
    virtual void updateUniformIVec( int i, const int* val);
    virtual void updateUniformVec( int i, const float* val);
    virtual void updateUniformMat( int i, const float* val);
    virtual void updateUniformMat( int i, const double* val);
    virtual void updateSampler( int i, unsigned int val);

    //predefined attributes
    virtual bool usesColor();
    virtual bool usesNormal();
    virtual bool usesTexCoord( int set);
    virtual bool usesTangent();
    virtual bool usesBinormal();
    virtual int tangentSlot();
    virtual int binormalSlot();

    //error reporting
    virtual const char* errorString();

  private:

    void deleteShaders();

    stateObserver *m_observer;
    
    std::vector<GLuint> m_programList;
    std::vector<GLuint> m_fShaderList;
    std::vector<GLuint> m_vShaderList;

    //these are to hold the ASHLI/ASHLIFX data
    int m_techniqueCount;
    std::vector<std::string> m_techniqueNames;
    std::vector<int> m_passCount; //per technique
    std::vector<int> m_techniqueOffset; //where does this technique begin
    std::vector<std::string> m_vertexShaders; // vertex shader strings
    std::vector<std::string> m_fragmentShaders; // fragment shader strings
    std::vector<std::string> m_orgVertexShaders; // vertex shader strings
    std::vector<std::string> m_orgFragmentShaders; // fragment shader strings
    std::vector<passState*> m_stateList;

    bool m_valid;


    int m_activePass;
    int m_activeTechnique;

    struct uniform {
      std::string name; //should switch to a string or MString
      DataType type;
      Semantic usage; //handles semantic values
      std::vector<GLint> handle; //will need to switch to a vector to handle Multipass
      union {
        float fVal[16];
        int iVal[4];
      };
      union {
        float fDefault[16];
        int iDefault[4];
      };
      bool dirty;
    };

    struct attribute {
      std::string name;
      DataType type;
      int handle;
    };

    struct sampler {
      std::string name;
      SamplerType type;
      std::vector<GLint> handle;
      GLuint texObject; 
      std::vector<int> texUnit; //will need to switch to a vector to handle Multipass
      bool dirty;
    };

    std::vector<uniform> m_uniformList;
    std::vector<attribute> m_attributeList;
    std::vector<sampler> m_samplerList;

    bool m_stale;

    bool m_color;
    bool m_normal;
    bool m_tangent;
    bool m_binormal;
    unsigned int m_texMask;

    int m_tangentSlot;
    int m_binormalSlot;

    std::string m_error;

};

#endif /* HLSL_SM3_FX_SHADER_H */