diff options
Diffstat (limited to '1.4.0/fx/include')
31 files changed, 4828 insertions, 0 deletions
diff --git a/1.4.0/fx/include/cfxAnnotatable.h b/1.4.0/fx/include/cfxAnnotatable.h new file mode 100644 index 0000000..fd251d2 --- /dev/null +++ b/1.4.0/fx/include/cfxAnnotatable.h @@ -0,0 +1,40 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_ANNOTATABLE_H +#define _CFX_ANNOTATABLE_H + + +#include <string> +#include <vector> + + +class cfxAnnotateData; +class cfxAnnotate; + + + +// cfxAnnotatable +class cfxAnnotatable +{ +public: + + cfxAnnotatable(); + virtual ~cfxAnnotatable(); + + void pushAnnotate(cfxAnnotate* annotate); + + const std::vector<cfxAnnotate*> &getAnnotateArray() const; + + protected: + + std::vector<cfxAnnotate*> annotateArray; // min 0 + +}; + + +#endif // _CFX_ANNOTATABLE_H diff --git a/1.4.0/fx/include/cfxAnnotate.h b/1.4.0/fx/include/cfxAnnotate.h new file mode 100644 index 0000000..e037df8 --- /dev/null +++ b/1.4.0/fx/include/cfxAnnotate.h @@ -0,0 +1,59 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_ANNOTATE_H +#define _CFX_ANNOTATE_H + + +#include <string> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + + +class cfxData; +class cfxEffect; +class cfxParam; +class cfxPass; +class cfxTechnique; +class cfxShader; + + +// cfxAnnotate +class cfxAnnotate +{ +public: + + cfxAnnotate(cfxData* _data, const std::string& _name); + virtual ~cfxAnnotate(); + + virtual bool apply(const cfxEffect* effect); + virtual bool apply(const cfxParam* param); + virtual bool apply(const cfxPass* pass); + virtual bool apply(const cfxTechnique* technique); + virtual bool apply(const cfxShader* shader); + + CGannotation getAnnotation() const; + + const cfxData *getData() const; + const std::string &getName() const; + +protected: + + cfxData* data; + + std::string name; + + CGannotation annotation; + +}; + + +#endif // _CFX_ANNOTATE_H diff --git a/1.4.0/fx/include/cfxBinaryUtil.h b/1.4.0/fx/include/cfxBinaryUtil.h new file mode 100644 index 0000000..e6eeeaa --- /dev/null +++ b/1.4.0/fx/include/cfxBinaryUtil.h @@ -0,0 +1,104 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_BINARYUTIL_H +#define _CFX_BINARYUTIL_H + +#include <vector> +#include <string> +#include <map> + +#include <cfxTypes.h> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +class cfxEffect; +class cfxAnnotate; +class cfxParam; +class cfxTechnique; +class cfxData; +class cfxPass; +class cfxShader; +class cfxGlPipelineSetting; +class cfxGlSamplerSetting; +class cfxMaterial; + +class cfxBinaryUtil { + +public: + static cfxBool load(const std::string& file, std::map<std::string, cfxMaterial*>& materials, + std::map<std::string, cfxEffect*>& effects, CGcontext _context = NULL ); + static cfxBool save(const std::string& file, const std::map<std::string, cfxMaterial*>& materials, + const std::map<std::string, cfxEffect*>& effects, cfxBool replace = false ); + + static void setRemotePath( const std::string &path ); + +private: // IO utility functions + // reads character by character into str until a null character is reached. + static size_t readString( std::string &str, FILE *input ); + // reads bools and does endian-ness conversion if needed + static size_t readBool( cfxBool *buf, size_t count, FILE *input ); + // reads ints and does endian-ness conversion if needed + static size_t readInt( cfxInt *buf, size_t count, FILE *input ); + // reads floats and does endian-ness conversion if needed + static size_t readFloat( cfxFloat *buf, size_t count, FILE *input ); + static size_t readToken( short &token, FILE *input); + + static size_t writeString( const std::string &str, FILE *out ); + // writes ints and does endian-ness conversion if needed + static size_t writeBool( const cfxBool *buf, size_t count, FILE *out ); + // writes ints and does endian-ness conversion if needed + static size_t writeInt( const cfxInt *buf, size_t count, FILE *out ); + // writes floats and does endian-ness conversion if needed + static size_t writeFloat( const cfxFloat *buf, size_t count, FILE *out ); + static size_t writeToken( short token, FILE *out ); + + static void endianSwap( short *s ); + static void endianSwap( cfxInt *i ); + static void endianSwap( cfxFloat *f ); + + static std::string makeRelativePath( const std::string &path, const std::string &relTo ); + +private: //read functionality + static cfxBool loadFileHeader( FILE *input ); + static cfxEffect *readEffect( FILE *input, CGcontext _context ); + static cfxAnnotate *readAnnotate( FILE *input, size_t &size, cfxEffect *effect ); + static cfxParam *readParam( short token, FILE *input, size_t &size, void *other = NULL ); + //data should be NULL pointer + static size_t readTypedData( cfxData **data, FILE *input, cfxEffect *effect ); + static cfxTechnique *readTechnique( cfxEffect *effect, FILE *input, size_t &size ); + static cfxPass *readPass( cfxTechnique *teq, FILE *input, size_t &size ); + static cfxShader *readShader( cfxPass *pass, FILE *input, size_t &size ); + static cfxGlPipelineSetting *readGlSetting( cfxPass *pass, FILE *input, size_t &size ); + static cfxGlSamplerSetting *readSamplerSetting( cfxEffect *effect, FILE *input, size_t &size ); + + static cfxMaterial *readMaterial( FILE *input, CGcontext _context, const std::map<std::string, cfxEffect*> *effects = NULL ); + +private: //write functionality + static void writeFileHeader( FILE *out ); + static void writeEffect( const cfxEffect *effect, FILE *out ); + static size_t writeAnnotate( const cfxAnnotate *an, FILE *out ); + static size_t writeParam( const cfxParam *p, FILE *out ); + static size_t writeTypedData( const cfxData *data, FILE *out ); + static size_t writeTechnique( const cfxTechnique *teq, FILE *out ); + static size_t writePass( const cfxPass *pass, FILE *out ); + static size_t writeShader( const cfxShader *shader, FILE *out ); + static size_t writeGLSetting( const cfxGlPipelineSetting *s, FILE *out ); + static size_t writeSamplerSetting( const cfxGlSamplerSetting *s, FILE *out ); + + static void writeMaterial( const cfxMaterial *material, FILE *out ); + +private: //variables + static std::string fileName; //Used upon save for creating a relative path for the includes. + static std::string remotePath; //The path to prepend for the shaders paths +}; + +#endif diff --git a/1.4.0/fx/include/cfxBindParam.h b/1.4.0/fx/include/cfxBindParam.h new file mode 100644 index 0000000..a1d925b --- /dev/null +++ b/1.4.0/fx/include/cfxBindParam.h @@ -0,0 +1,41 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_BINDPARAM_H +#define _CFX_BINDPARAM_H + +#include <string> + +#include <cfxParam.h> + +class cfxShader; +class cfxData; + + +// cfxBindParam +class cfxBindParam : public cfxParam +{ +public: + + cfxBindParam(const std::string& _name, cfxShader* _shader, cfxData* _data); + + bool apply(); + bool validate() const; + + virtual cfxParam::cfxParamTypeEnum getType() const; + const cfxData *getData() const; + +protected: + + cfxShader* shader; + cfxData* data; + +}; + + + +#endif // _CFX_BINDPARAM_H diff --git a/1.4.0/fx/include/cfxCode.h b/1.4.0/fx/include/cfxCode.h new file mode 100644 index 0000000..2693b53 --- /dev/null +++ b/1.4.0/fx/include/cfxCode.h @@ -0,0 +1,41 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_CODE_H +#define _CFX_CODE_H + +#include <string> + +class cfxEffect; + +// cfxCode +class cfxCode +{ +public: + + cfxCode(cfxEffect* _effect, const std::string& _name, + const std::string& _profile, const std::string& _code); + ~cfxCode() {}; + + bool apply(); + bool validate() const; + + +private: + + cfxEffect* effect; + + std::string name; + std::string profile; + std::string code; + + //CGprogram program; +}; + + + +#endif // _CFX_CODE_H diff --git a/1.4.0/fx/include/cfxConnectParam.h b/1.4.0/fx/include/cfxConnectParam.h new file mode 100644 index 0000000..699c5e9 --- /dev/null +++ b/1.4.0/fx/include/cfxConnectParam.h @@ -0,0 +1,49 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_CONNECTPARAM_H +#define _CFX_CONNECTPARAM_H + +#include <string> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +#include <cfxParam.h> + +class cfxShader; + +// cfxConnectParam +class cfxConnectParam : public cfxParam +{ +public: + + cfxConnectParam(const std::string& _name, cfxShader* _shader, + const std::string& _fromName); + + bool apply(); + bool validate() const; + + virtual cfxParam::cfxParamTypeEnum getType() const; + const std::string &getFromName() const; + + +private: + + cfxShader* shader; + + std::string fromName; + + CGparameter fromParameter; +}; + + + +#endif // _CFX_CONNECTPARAM_H diff --git a/1.4.0/fx/include/cfxData.h b/1.4.0/fx/include/cfxData.h new file mode 100644 index 0000000..85839d7 --- /dev/null +++ b/1.4.0/fx/include/cfxData.h @@ -0,0 +1,447 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_DATA_H +#define _CFX_DATA_H + +#include <cfxTypes.h> +#include <string> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +class cfxParam; +class cfxAnnotate; +class cfxSampler; + +// cfxData +class cfxData +{ + public: + + virtual ~cfxData() {} + + virtual CGtype getType() const = 0; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); +}; + + +// cfxDataBool +class cfxDataBool : public cfxData +{ + public: + cfxDataBool(const cfxBool& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxBool &getData() const; + + protected: + + cfxBool data; +}; + + +// cfxDataBool1 +class cfxDataBool1 : public cfxData +{ + public: + cfxDataBool1(const cfxBool1& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxBool1 &getData() const; + + protected: + + cfxBool1 data; +}; + + +// cfxDataBool2 +class cfxDataBool2 : public cfxData +{ + public: + cfxDataBool2(const cfxBool2& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxBool2 &getData() const; + + protected: + + cfxBool2 data; +}; + + +// cfxDataBool3 +class cfxDataBool3 : public cfxData +{ + public: + cfxDataBool3(const cfxBool3& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxBool3 &getData() const; + + protected: + + cfxBool3 data; +}; + + +// cfxDataBool4 +class cfxDataBool4 : public cfxData +{ + public: + cfxDataBool4(const cfxBool4& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxBool4 &getData() const; + + protected: + + cfxBool4 data; +}; + + +// cfxDataInt +class cfxDataInt : public cfxData +{ + public: + cfxDataInt(const cfxInt& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxInt &getData() const; + + protected: + + cfxInt data; +}; + + +// cfxDataInt1 +class cfxDataInt1 : public cfxData +{ + public: + cfxDataInt1(const cfxInt1& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxInt1 &getData() const; + + protected: + + cfxInt1 data; +}; + + +// cfxDataInt2 +class cfxDataInt2 : public cfxData +{ + public: + cfxDataInt2(const cfxInt2& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxInt2 &getData() const; + + protected: + + cfxInt2 data; +}; + + +// cfxDataInt3 +class cfxDataInt3 : public cfxData +{ + public: + cfxDataInt3(const cfxInt3& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxInt3 &getData() const; + + protected: + + cfxInt3 data; +}; + + +// cfxDataInt4 +class cfxDataInt4 : public cfxData +{ + public: + cfxDataInt4(const cfxInt4& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxInt4 &getData() const; + + protected: + + cfxInt4 data; +}; + + +// cfxDataFloat +class cfxDataFloat : public cfxData +{ + public: + cfxDataFloat(const cfxFloat& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat &getData() const; + + protected: + + cfxFloat data; +}; + + +// cfxDataFloat1 +class cfxDataFloat1 : public cfxData +{ + public: + cfxDataFloat1(const cfxFloat1& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat1 &getData() const; + + protected: + + cfxFloat1 data; +}; + + +// cfxDataFloat2 +class cfxDataFloat2 : public cfxData +{ + public: + cfxDataFloat2(const cfxFloat2& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat2 &getData() const; + + protected: + + cfxFloat2 data; +}; + + +// cfxDataFloat3 +class cfxDataFloat3 : public cfxData +{ + public: + cfxDataFloat3(const cfxFloat3& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat3 &getData() const; + + protected: + + cfxFloat3 data; +}; + + +// cfxDataFloat4 +class cfxDataFloat4 : public cfxData +{ + public: + cfxDataFloat4(const cfxFloat4& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat4 &getData() const; + + protected: + + cfxFloat4 data; +}; + + +// cfxDataFloat2x2 +class cfxDataFloat2x2 : public cfxData +{ + public: + cfxDataFloat2x2(const cfxFloat2x2& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat2x2 &getData() const; + + protected: + + cfxFloat2x2 data; +}; + + +// cfxDataFloat3x3 +class cfxDataFloat3x3 : public cfxData +{ + public: + cfxDataFloat3x3(const cfxFloat3x3& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat3x3 &getData() const; + + protected: + + cfxFloat3x3 data; +}; + + +// cfxDataFloat4x4 +class cfxDataFloat4x4 : public cfxData +{ + public: + cfxDataFloat4x4(const cfxFloat4x4& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + virtual bool apply(cfxAnnotate* annotate); + + const cfxFloat4x4 &getData() const; + + protected: + + cfxFloat4x4 data; +}; + + +// cfxDataSampler1D +class cfxDataSampler1D : public cfxData +{ + public: + cfxDataSampler1D(cfxSampler* _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + + const cfxSampler *getData() const; + + protected: + + cfxSampler* data; +}; + + +// cfxDataSampler2D +class cfxDataSampler2D : public cfxData +{ + public: + cfxDataSampler2D(cfxSampler* _data); + ~cfxDataSampler2D(); + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + + const cfxSampler *getData() const; + + protected: + + cfxSampler* data; +}; + + +// cfxDataSampler3D +class cfxDataSampler3D : public cfxData +{ + public: + cfxDataSampler3D(cfxSampler* _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + + const cfxSampler *getData() const; + + protected: + + cfxSampler* data; +}; + + +// cfxDataSamplerCUBE +class cfxDataSamplerCUBE : public cfxData +{ + public: + cfxDataSamplerCUBE(cfxSampler* _data); + + virtual CGtype getType() const; + virtual bool apply(cfxParam* param); + + const cfxSampler *getData() const; + + protected: + + cfxSampler* data; +}; + + +// cfxDataString +class cfxDataString : public cfxData +{ + public: + cfxDataString(const std::string& _data); + + virtual CGtype getType() const; + virtual bool apply(cfxAnnotate* annotate); + + const std::string &getData() const; + + protected: + + std::string data; +}; + + + +#endif // _CFX_DATA_H diff --git a/1.4.0/fx/include/cfxDataMaker.h b/1.4.0/fx/include/cfxDataMaker.h new file mode 100644 index 0000000..e887cc1 --- /dev/null +++ b/1.4.0/fx/include/cfxDataMaker.h @@ -0,0 +1,300 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_DATAMAKER_H +#define _CFX_DATAMAKER_H + + +#include <map> +#include <string> + +#include <cfxTypes.h> +#include <cfxSampler.h> + +class cfxData; +class domFx_basic_type_common; +class domCg_param_type; +class domFx_annotate_type_common; + + +// the data maker ends up needing to know about the effect +// because samplers (which are just data) need the effect for context +class cfxEffect; + +// cfxDataMaker +class cfxDataMaker +{ + protected: + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect* effect); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect* effect); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect* effect); + + static std::map<std::string, cfxDataMaker*> mapTypeNameToDataMaker; + + public: + + virtual ~cfxDataMaker(){} + static cfxData* makeDataForParam(domFx_basic_type_common* paramInitializer, cfxEffect*); + static cfxData* makeDataForParam(domCg_param_type* paramInitializer, cfxEffect*); + static cfxData* makeDataForAnnotate(domFx_annotate_type_common* annotateInitializer, cfxEffect*); + cfxSampler* sampler; +}; + + +// BASIC DATA MAKERS + +// cfxDataMakerBool +class cfxDataMakerBool : public cfxDataMaker +{ + protected: + cfxDataMakerBool(); + static cfxDataMakerBool maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerBool1 +class cfxDataMakerBool1 : public cfxDataMaker +{ + protected: + cfxDataMakerBool1(); + static cfxDataMakerBool1 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerBool2 +class cfxDataMakerBool2 : public cfxDataMaker +{ + protected: + cfxDataMakerBool2(); + static cfxDataMakerBool2 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerBool3 +class cfxDataMakerBool3 : public cfxDataMaker +{ + protected: + cfxDataMakerBool3(); + static cfxDataMakerBool3 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerBool4 +class cfxDataMakerBool4 : public cfxDataMaker +{ + protected: + cfxDataMakerBool4(); + static cfxDataMakerBool4 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerInt +class cfxDataMakerInt : public cfxDataMaker +{ + protected: + cfxDataMakerInt(); + static cfxDataMakerInt maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerInt1 +class cfxDataMakerInt1 : public cfxDataMaker +{ + protected: + cfxDataMakerInt1(); + static cfxDataMakerInt1 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerInt2 +class cfxDataMakerInt2 : public cfxDataMaker +{ + protected: + cfxDataMakerInt2(); + static cfxDataMakerInt2 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerInt3 +class cfxDataMakerInt3 : public cfxDataMaker +{ + protected: + cfxDataMakerInt3(); + static cfxDataMakerInt3 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerInt4 +class cfxDataMakerInt4 : public cfxDataMaker +{ + protected: + cfxDataMakerInt4(); + static cfxDataMakerInt4 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat +class cfxDataMakerFloat : public cfxDataMaker +{ + protected: + cfxDataMakerFloat(); + static cfxDataMakerFloat maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat1 +class cfxDataMakerFloat1 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat1(); + static cfxDataMakerFloat1 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat2 +class cfxDataMakerFloat2 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat2(); + static cfxDataMakerFloat2 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat3 +class cfxDataMakerFloat3 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat3(); + static cfxDataMakerFloat3 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat4 +class cfxDataMakerFloat4 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat4(); + static cfxDataMakerFloat4 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat2x2 +class cfxDataMakerFloat2x2 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat2x2(); + static cfxDataMakerFloat2x2 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat3x3 +class cfxDataMakerFloat3x3 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat3x3(); + static cfxDataMakerFloat3x3 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// cfxDataMakerFloat4x4 +class cfxDataMakerFloat4x4 : public cfxDataMaker +{ + protected: + cfxDataMakerFloat4x4(); + static cfxDataMakerFloat4x4 maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +// PARAM DATA MAKERS + + +// cfxDataMakerSampler2D +class cfxDataMakerSampler2D : public cfxDataMaker +{ + protected: + cfxDataMakerSampler2D(); + static cfxDataMakerSampler2D maker; + + virtual cfxData* makeData(domFx_basic_type_common* paramInitializer, cfxEffect*); + virtual cfxData* makeData(domCg_param_type* paramInitializer, cfxEffect*); +}; + + +// ANNOTATE DATA MAKERS + +// cfxDataMakerString +class cfxDataMakerString : public cfxDataMaker +{ + protected: + cfxDataMakerString(); + static cfxDataMakerString maker; + + virtual cfxData* makeData(domFx_annotate_type_common* annotateInitializer, cfxEffect*); +}; + + +#endif // _CFX_DATAMAKER_H diff --git a/1.4.0/fx/include/cfxEffect.h b/1.4.0/fx/include/cfxEffect.h new file mode 100644 index 0000000..3becf19 --- /dev/null +++ b/1.4.0/fx/include/cfxEffect.h @@ -0,0 +1,88 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_EFFECT_H +#define _CFX_EFFECT_H + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif +//#if defined(_POSIX_) + +//include <GL/gl.h> +//#endif + +#include <string> +#include <map> +#include "cfxTypes.h" +#include "cfxAnnotatable.h" +#include "cfxParamable.h" +#include "cfxSurface.h" +#include "cfxCode.h" +#include "cfxTechnique.h" + +// cfxEffect +class cfxEffect : public cfxAnnotatable, public cfxParamable +{ +public: + + cfxEffect(const std::string& _name, CGcontext _context); + ~cfxEffect(); + + cfxBool apply(); + cfxBool validate() const; + CGcontext getContext() const; + CGeffect getEffect() const; + const std::string& getName() const; + + void pushCode(cfxCode* code); + void pushTechnique(cfxTechnique* technique); + + void setPassState(unsigned int techniqueIndex, unsigned int passIndex); + void resetPassState(unsigned int techniqueIndex, unsigned int passIndex); + unsigned int getTechniqueCount(); + unsigned int getPassCount(unsigned int techniqueIndex); + + // this is temporary until cg api gets upgraded to set effect parameter names + void addNamedParameter(const std::string& name, CGparameter param); + CGparameter getParameterByName(const std::string& name); + + void addNamedSurface(const std::string& name, cfxSurface* surface); + cfxSurface* getSurfaceByName(const std::string& name); + std::string getSurfaceName( const cfxSurface *surface ); + + // this is temporary until cg api gets upgraded to set parameter semantics + void addSemanticParameter(const std::string& semantic, CGparameter param); + CGparameter getParameterBySemantic(const std::string& semantic); + + const std::vector<cfxTechnique*> &getTechniqueArray() const; + + const std::map<std::string, cfxSurface*> &getSurfaceMap() const; + +private: + + std::vector<cfxCode*> codeArray; // min 0 + std::vector<cfxTechnique*> techniqueArray; // min 1 + + std::string name; + + CGcontext context; + CGeffect effect; + + // this is temporary until cg api gets upgraded to set effect parameter names + std::map<std::string, CGparameter> mapNameToParameter; + std::map<std::string, cfxSurface*> mapNameToSurfacePtr; + // and semantics !?! + std::map<std::string, CGparameter> mapSemanticToParameter; + +}; + + +#endif // _CFX_EFFECT_H + diff --git a/1.4.0/fx/include/cfxError.h b/1.4.0/fx/include/cfxError.h new file mode 100644 index 0000000..c9503f6 --- /dev/null +++ b/1.4.0/fx/include/cfxError.h @@ -0,0 +1,27 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_ERROR_H +#define _CFX_ERROR_H + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +// this is used to set the cg error callback +// it will print the string if there is an error +// it will assert if there is an error in a non release build +void cfxCgErrorCallback(); + +// this is not needed (or useful in any way) when using the error callback +CGerror cfxCheckCgError(); + + +#endif // _CFX_ERROR_H + diff --git a/1.4.0/fx/include/cfxGlEnumMaps.h b/1.4.0/fx/include/cfxGlEnumMaps.h new file mode 100644 index 0000000..34882e7 --- /dev/null +++ b/1.4.0/fx/include/cfxGlEnumMaps.h @@ -0,0 +1,60 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_GLENUMMAPS_H +#define _CFX_GLENUMMAPS_H + +#include <dom/domTypes.h> +#include <dom/domGl_pipeline_settings.h> + +class cfxGlEnumMaps +{ + public: + + static int getBlendTypeEnum(int domEnum); + static int getFaceTypeEnum(int domEnum); + static int getBlendEquationTypeEnum(int domEnum); + static int getFuncTypeEnum(int domEnum); + static int getStencilOpTypeEnum(int domEnum); + + static int getModeTypeEnum(int domEnum); + static int getFogModeTypeEnum(int domEnum); + + static int getSamplerWrapTypeEnum(int domEnum); + static int getSamplerFilterTypeEnum(int domEnum); + + protected: + + + cfxGlEnumMaps(); + + // no longer need to map gl types as the dom has the right values +#if 0 + static int blendTypeEnums[GL_BLEND_TYPE_COUNT]; + static int faceTypeEnums[GL_FACE_TYPE_COUNT]; + static int blendEquationTypeEnums[GL_BLEND_EQUATION_TYPE_COUNT]; + static int funcTypeEnums[GL_FUNC_TYPE_COUNT]; + static int stencilOpTypeEnums[GL_STENCIL_OP_TYPE_COUNT]; + + static int modeTypeEnums[GL_MATERIAL_TYPE_COUNT]; + static int fogModeTypeEnums[GL_FOG_TYPE_COUNT]; +#endif + + // fx types need mapping to gl because the dom uses its own internal values + static int samplerWrapTypeEnums[FX_SAMPLER_WRAP_COMMON_COUNT]; + static int samplerFilterTypeEnums[FX_SAMPLER_FILTER_COMMON_COUNT]; + + + static bool initialized; + + static cfxGlEnumMaps initializer; +}; + + + +#endif // _CFX_GLENUMMAPS_H + diff --git a/1.4.0/fx/include/cfxGlPipelineSetting.h b/1.4.0/fx/include/cfxGlPipelineSetting.h new file mode 100644 index 0000000..4371f48 --- /dev/null +++ b/1.4.0/fx/include/cfxGlPipelineSetting.h @@ -0,0 +1,1545 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_GLPIPELINESETTING_H +#define _CFX_GLPIPELINESETTING_H + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +#include <cfxTypes.h> + +class cfxPass; +class cfxSampler; + +// cfxGlPipelineSetting +class cfxGlPipelineSetting +{ +public: + enum type_enum { + ALPHA_FUNC, + BLEND_FUNC, + BLEND_FUNC_SEPARATE, + BLEND_EQUATION, + BLEND_EQUATION_SEPARATE, + BLEND_COLOR, + CLEAR_COLOR, + CLEAR_STENCIL, + CLEAR_DEPTH, + CLIP_PLANE, + COLOR_MASK, + COLOR_MATERIAL, + CULL_FACE, + DEPTH_FUNC, + DEPTH_MASK, + DEPTH_RANGE, + FOG_MODE, + FOG_DENSITY, + FOG_START, + FOG_END, + FOG_COLOR, + FRONT_FACE, + LIGHT_MODEL_AMBEINT, + LIGHT_AMBIENT, + LIGHT_CONSTANT_ATTENUATION, + LIGHT_DIFFUSE, + LIGHT_LINEAR_ATTENUATION, + LIGHT_POSITION, + LIGHT_QUADRATIC_ATTENUATION, + LIGHT_SPECULAR, + LIGHT_SPOT_CUTOFF, + LIGHT_SPOT_DIRECTION, + LIGHT_SPOT_EXPONENT, + LINE_WIDTH, + LOGIC_OP, + MATERIAL_AMBIENT, + MATERIAL_DIFFUSE, + MATERIAL_EMISSION, + MATERIAL_SHININESS, + MATERIAL_SPECULAR, + MODEL_VIEW_MATRIX, + POINT_SIZE, + POINT_SPRITE_COORD_REPLACE, + POINT_SPRITE_R_MODE, + POLYGON_MODE, + POLYGON_OFFSET, + PROJECTION_MATRIX, + SCISSOR, + SHADE_MODEL, + STENCIL_FUNC, + STENCIL_MASK, + STENCIL_OP, + STENCIL_FUNC_SEPARATE, + STENCIL_MASK_SEPARATE, + STENCIL_OP_SEPAREATE, + TEX_GEN_S_MODE, + TEX_GEN_T_MODE, + TEX_GEN_R_MODE, + TEX_GEN_Q_MODE, + TEX_GEN_S_EYE_PLANE, + TEX_GEN_T_EYE_PLANE, + TEX_GEN_R_EYE_PLANE, + TEX_GEN_Q_EYE_PLANE, + TEX_GEN_S_OBJECT_PLANE, + TEX_GEN_T_OBJECT_PLANE, + TEX_GEN_R_OBJECT_PLANE, + TEX_GEN_Q_OBJECT_PLANE, + TEXTURE_2D, + TEXTURE_3D, + TEXTURE_CUBE_MAP, + TEXTURE_ENV_COLOR, + TEXTURE_ENV_MODE, + ALPHA_TEST_ENABLE, + BLEND_ENABLE, + CULL_FACE_ENABLE, + DEPTH_TEST_ENABLE + }; + + public: + + cfxGlPipelineSetting(cfxPass* _pass, const char* stateName, int index=-1); + virtual ~cfxGlPipelineSetting(); + + virtual cfxBool apply() = 0; + + virtual type_enum getType() const = 0; + + protected: + + cfxPass* pass; + + CGstate state; + CGstateassignment assignment; + +}; + + +// cfxGlPipelineSettingAlphaFunc +class cfxGlPipelineSettingAlphaFunc : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingAlphaFunc(cfxPass* _pass, int _func, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFunc() const; + float getValue() const; + + protected: + + int func; + float value; +}; + + +// cfxGlPipelineSettingBlendFunc +class cfxGlPipelineSettingBlendFunc : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingBlendFunc(cfxPass* _pass, int _src, int _dst); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getSrc() const; + int getDst() const; + + protected: + + int src; + int dst; +}; + + +// cfxGlPipelineSettingBlendFuncSeparate +class cfxGlPipelineSettingBlendFuncSeparate : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingBlendFuncSeparate(cfxPass* _pass, int _srcRGB, int _dstRGB, int _srcAlpha, int _dstAlpha); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getSrcRGB() const; + int getDstRGD() const; + int getSrcAlpha() const; + int getDstAlpha() const; + + protected: + + int srcRGB; + int dstRGB; + int srcAlpha; + int dstAlpha; +}; + + +// cfxGlPipelineSettingBlendEquation +class cfxGlPipelineSettingBlendEquation : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingBlendEquation(cfxPass* _pass, int _equation); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getEquation() const; + + protected: + + int equation; +}; + + +// cfxGlPipelineSettingBlendEquationSeparate +class cfxGlPipelineSettingBlendEquationSeparate : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingBlendEquationSeparate(cfxPass* _pass, int _rgb, int _alpha); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getRgb() const; + int getAlpha() const; + + protected: + + int rgb; + int alpha; +}; + + +// cfxGlPipelineSettingBlendColor +class cfxGlPipelineSettingBlendColor : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingBlendColor(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingClearColor +class cfxGlPipelineSettingClearColor : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingClearColor(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingClearStencil +class cfxGlPipelineSettingClearStencil : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingClearStencil(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingClearDepth +class cfxGlPipelineSettingClearDepth : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingClearDepth(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingClipPlane +class cfxGlPipelineSettingClipPlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingClipPlane(cfxPass* _pass, int _index, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat4 getValue() const; + + protected: + + int index; + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingColorMask +class cfxGlPipelineSettingColorMask : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingColorMask(cfxPass* _pass, cfxBool4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool4 getValue() const; + + protected: + + cfxBool4 value; +}; + + +// cfxGlPipelineSettingColorMaterial +class cfxGlPipelineSettingColorMaterial : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingColorMaterial(cfxPass* _pass, int _face, int _mode); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFace() const; + int getMode() const; + + protected: + + int face; + int mode; +}; + + +// cfxGlPipelineSettingCullFace +class cfxGlPipelineSettingCullFace : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingCullFace(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingDepthFunc +class cfxGlPipelineSettingDepthFunc : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingDepthFunc(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingDepthMask +class cfxGlPipelineSettingDepthMask : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingDepthMask(cfxPass* _pass, cfxBool _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; + + +// cfxGlPipelineSettingDepthRange +class cfxGlPipelineSettingDepthRange : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingDepthRange(cfxPass* _pass, cfxFloat2& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat2 getValue() const; + + protected: + + cfxFloat2 value; +}; + + +// cfxGlPipelineSettingFogMode +class cfxGlPipelineSettingFogMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingFogMode(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingFogDensity +class cfxGlPipelineSettingFogDensity : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingFogDensity(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingFogStart +class cfxGlPipelineSettingFogStart : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingFogStart(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingFogEnd +class cfxGlPipelineSettingFogEnd : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingFogEnd(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingFogColor +class cfxGlPipelineSettingFogColor : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingFogColor(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingFrontFace +class cfxGlPipelineSettingFrontFace : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingFrontFace(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingLightModelAmbient +class cfxGlPipelineSettingLightModelAmbient : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightModelAmbient(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingLightAmbient +class cfxGlPipelineSettingLightAmbient : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightAmbient(cfxPass* _pass, int _index, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat4 getValue() const; + + protected: + + int index; + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingLightConstantAttenuation +class cfxGlPipelineSettingLightConstantAttenuation : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightConstantAttenuation(cfxPass* _pass, int _index, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + float getValue() const; + + protected: + + int index; + float value; +}; + + +// cfxGlPipelineSettingLightDiffuse +class cfxGlPipelineSettingLightDiffuse : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightDiffuse(cfxPass* _pass, int _index, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat4 getValue() const; + + protected: + + int index; + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingLightLinearAttenuation +class cfxGlPipelineSettingLightLinearAttenuation : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightLinearAttenuation(cfxPass* _pass, int _index, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + float getValue() const; + + protected: + + int index; + float value; +}; + + +// cfxGlPipelineSettingLightPosition +class cfxGlPipelineSettingLightPosition : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightPosition(cfxPass* _pass, int _index, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat4 getValue() const; + + protected: + + int index; + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingLightQuadraticAttenuation +class cfxGlPipelineSettingLightQuadraticAttenuation : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightQuadraticAttenuation(cfxPass* _pass, int _index, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + float getValue() const; + + protected: + + int index; + float value; +}; + + +// cfxGlPipelineSettingLightSpecular +class cfxGlPipelineSettingLightSpecular : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightSpecular(cfxPass* _pass, int _index, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat4 getValue() const; + + protected: + + int index; + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingLightSpotCutoff +class cfxGlPipelineSettingLightSpotCutoff : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightSpotCutoff(cfxPass* _pass, int _index, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + float getValue() const; + + protected: + + int index; + float value; +}; + + +// cfxGlPipelineSettingLightSpotDirection +class cfxGlPipelineSettingLightSpotDirection : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightSpotDirection(cfxPass* _pass, int _index, cfxFloat3& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat3 getValue() const; + + protected: + + int index; + cfxFloat3 value; +}; + + +// cfxGlPipelineSettingLightSpotExponent +class cfxGlPipelineSettingLightSpotExponent : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLightSpotExponent(cfxPass* _pass, int _index, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + float getValue() const; + + protected: + + int index; + float value; +}; + + +// cfxGlPipelineSettingLineWidth +class cfxGlPipelineSettingLineWidth : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLineWidth(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingLogicOp +class cfxGlPipelineSettingLogicOp : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingLogicOp(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingMaterialAmbient +class cfxGlPipelineSettingMaterialAmbient : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingMaterialAmbient(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingMaterialDiffuse +class cfxGlPipelineSettingMaterialDiffuse : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingMaterialDiffuse(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingMaterialEmission +class cfxGlPipelineSettingMaterialEmission : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingMaterialEmission(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingMaterialShininess +class cfxGlPipelineSettingMaterialShininess : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingMaterialShininess(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingMaterialSpecular +class cfxGlPipelineSettingMaterialSpecular : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingMaterialSpecular(cfxPass* _pass, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingModelViewMatrix +class cfxGlPipelineSettingModelViewMatrix : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingModelViewMatrix(cfxPass* _pass, cfxFloat4x4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4x4 getValue() const; + + protected: + + cfxFloat4x4 value; +}; + + +// cfxGlPipelineSettingPointSize +class cfxGlPipelineSettingPointSize : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingPointSize(cfxPass* _pass, float _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlPipelineSettingPointSpriteCoordReplace +class cfxGlPipelineSettingPointSpriteCoordReplace : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingPointSpriteCoordReplace(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingPointSpriteRMode +class cfxGlPipelineSettingPointSpriteRMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingPointSpriteRMode(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingPolygonMode +class cfxGlPipelineSettingPolygonMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingPolygonMode(cfxPass* _pass, int _face, int _mode); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFace() const; + int getMode() const; + + protected: + + int face; + int mode; +}; + + +// cfxGlPipelineSettingPolygonOffset +class cfxGlPipelineSettingPolygonOffset : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingPolygonOffset(cfxPass* _pass, cfxFloat2& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat2 getValue() const; + + protected: + + cfxFloat2 value; +}; + + +// cfxGlPipelineSettingProjectionMatrix +class cfxGlPipelineSettingProjectionMatrix : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingProjectionMatrix(cfxPass* _pass, cfxFloat4x4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxFloat4x4 getValue() const; + + protected: + + cfxFloat4x4 value; +}; + + +// cfxGlPipelineSettingScissor +class cfxGlPipelineSettingScissor : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingScissor(cfxPass* _pass, cfxInt4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxInt4 getValue() const; + + protected: + + cfxInt4 value; +}; + + +// cfxGlPipelineSettingShadeModel +class cfxGlPipelineSettingShadeModel : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingShadeModel(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingStencilFunc +class cfxGlPipelineSettingStencilFunc : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingStencilFunc(cfxPass* _pass, int _func, int _ref, int _mask); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFunc() const; + int getRef() const; + int getMask() const; + + protected: + + int func; + int ref; + int mask; +}; + + +// cfxGlPipelineSettingStencilMask +class cfxGlPipelineSettingStencilMask : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingStencilMask(cfxPass* _pass, int _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlPipelineSettingStencilOp +class cfxGlPipelineSettingStencilOp : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingStencilOp(cfxPass* _pass, int _fail, int _zFail, int _zPass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFail() const; + int getZFail() const; + int getZPass() const; + + protected: + + int fail; + int zFail; + int zPass; +}; + + +// cfxGlPipelineSettingStencilFuncSeparate +class cfxGlPipelineSettingStencilFuncSeparate : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingStencilFuncSeparate(cfxPass* _pass, int _front, int _back, int _ref, int _mask); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFront() const; + int getBack() const; + int getRef() const; + int getMask() const; + + protected: + + int front; + int back; + int ref; + int mask; +}; + + +// cfxGlPipelineSettingStencilMaskSeparate +class cfxGlPipelineSettingStencilMaskSeparate : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingStencilMaskSeparate(cfxPass* _pass, int _face, int _mask); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFace() const; + int getMask() const; + + protected: + + int face; + int mask; +}; + + +// cfxGlPipelineSettingStencilOpSeparate +class cfxGlPipelineSettingStencilOpSeparate : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingStencilOpSeparate(cfxPass* _pass, int _face, int _fail, int _zFail, int _zPass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getFace() const; + int getFail() const; + int getZFail() const; + int getZPass() const; + + protected: + + int face; + int fail; + int zFail; + int zPass; +}; + + +// cfxGlPipelineSettingTexGenSMode +class cfxGlPipelineSettingTexGenSMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenSMode(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenTMode +class cfxGlPipelineSettingTexGenTMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenTMode(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenRMode +class cfxGlPipelineSettingTexGenRMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenRMode(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenQMode +class cfxGlPipelineSettingTexGenQMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenQMode(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenSEyePlane +class cfxGlPipelineSettingTexGenSEyePlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenSEyePlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenTEyePlane +class cfxGlPipelineSettingTexGenTEyePlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenTEyePlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenREyePlane +class cfxGlPipelineSettingTexGenREyePlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenREyePlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenQEyePlane +class cfxGlPipelineSettingTexGenQEyePlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenQEyePlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenSObjectPlane +class cfxGlPipelineSettingTexGenSObjectPlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenSObjectPlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenTObjectPlane +class cfxGlPipelineSettingTexGenTObjectPlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenTObjectPlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenRObjectPlane +class cfxGlPipelineSettingTexGenRObjectPlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenRObjectPlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexGenQObjectPlane +class cfxGlPipelineSettingTexGenQObjectPlane : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexGenQObjectPlane(cfxPass* _pass); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + protected: + +}; + + +// cfxGlPipelineSettingTexture2D +class cfxGlPipelineSettingTexture2D : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexture2D(cfxPass* _pass, int _index, cfxSampler* _sampler); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + const cfxSampler *getSampler() const; + + protected: + + int index; + cfxSampler* sampler; +}; + + +// cfxGlPipelineSettingTexture3D +class cfxGlPipelineSettingTexture3D : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTexture3D(cfxPass* _pass, int _index, cfxSampler* _sampler); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + const cfxSampler *getSampler() const; + + protected: + + int index; + cfxSampler* sampler; +}; + + +// cfxGlPipelineSettingTextureCubeMap +class cfxGlPipelineSettingTextureCubeMap : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTextureCubeMap(cfxPass* _pass, int _index, cfxSampler* _sampler); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + const cfxSampler *getSampler() const; + + protected: + + int index; + cfxSampler* sampler; +}; + + +// cfxGlPipelineSettingTextureEnvColor +class cfxGlPipelineSettingTextureEnvColor : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTextureEnvColor(cfxPass* _pass, int _index, cfxFloat4& _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + cfxFloat4 getValue() const; + + protected: + + int index; + cfxFloat4 value; +}; + + +// cfxGlPipelineSettingTextureEnvMode +class cfxGlPipelineSettingTextureEnvMode : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingTextureEnvMode(cfxPass* _pass, int _index, int _mode); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + int getIndex() const; + int getValue() const; + + protected: + + int index; + int value; +}; + + +// ENABLE / DISABLE settings + + +// cfxGlPipelineSettingAlphaTestEnable +class cfxGlPipelineSettingAlphaTestEnable : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingAlphaTestEnable(cfxPass* _pass, cfxBool _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; + + +// cfxGlPipelineSettingBlendEnable +class cfxGlPipelineSettingBlendEnable : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingBlendEnable(cfxPass* _pass, cfxBool _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; + + +// cfxGlPipelineSettingCullFaceEnable +class cfxGlPipelineSettingCullFaceEnable : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingCullFaceEnable(cfxPass* _pass, cfxBool _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; + + +// cfxGlPipelineSettingDepthTestEnable +class cfxGlPipelineSettingDepthTestEnable : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSettingDepthTestEnable(cfxPass* _pass, cfxBool _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; + + +#if 0 +// cfxGlPipelineSetting +class cfxGlPipelineSetting : public cfxGlPipelineSetting +{ + public: + + cfxGlPipelineSetting(cfxPass* _pass, cfxBool _value); + virtual cfxBool apply(); + + virtual type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; +#endif + + +#endif // _CFX_GLPIPELINESETTING_H + + diff --git a/1.4.0/fx/include/cfxGlPipelineSettingMaker.h b/1.4.0/fx/include/cfxGlPipelineSettingMaker.h new file mode 100644 index 0000000..025da99 --- /dev/null +++ b/1.4.0/fx/include/cfxGlPipelineSettingMaker.h @@ -0,0 +1,884 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_GLPIPELINESETTINGMAKER_H +#define _CFX_GLPIPELINESETTINGMAKER_H + +#include <map> +#include <string> + +class cfxGlPipelineSetting; +class cfxPass; + +class domGl_pipeline_settings; + + +// cfxGlPipelineSettingMaker +class cfxGlPipelineSettingMaker +{ + protected: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer) = 0; + static std::map<std::string, cfxGlPipelineSettingMaker*> mapTypeNameToSettingMaker; + public: + virtual ~cfxGlPipelineSettingMaker() {} + static cfxGlPipelineSetting* makeGlPipelineSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerAlphaFunc +class cfxGlPipelineSettingMakerAlphaFunc : public cfxGlPipelineSettingMaker +{ + protected: + cfxGlPipelineSettingMakerAlphaFunc(); + static cfxGlPipelineSettingMakerAlphaFunc maker; + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerBlendFunc +class cfxGlPipelineSettingMakerBlendFunc : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerBlendFunc(); + static cfxGlPipelineSettingMakerBlendFunc maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerBlendFuncSeparate +class cfxGlPipelineSettingMakerBlendFuncSeparate : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerBlendFuncSeparate(); + static cfxGlPipelineSettingMakerBlendFuncSeparate maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerBlendEquation +class cfxGlPipelineSettingMakerBlendEquation : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerBlendEquation(); + static cfxGlPipelineSettingMakerBlendEquation maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerBlendEquationSeparate +class cfxGlPipelineSettingMakerBlendEquationSeparate : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerBlendEquationSeparate(); + static cfxGlPipelineSettingMakerBlendEquationSeparate maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerBlendColor +class cfxGlPipelineSettingMakerBlendColor : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerBlendColor(); + static cfxGlPipelineSettingMakerBlendColor maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerClearColor +class cfxGlPipelineSettingMakerClearColor : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerClearColor(); + static cfxGlPipelineSettingMakerClearColor maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerClearStenciil +class cfxGlPipelineSettingMakerClearStencil : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerClearStencil(); + static cfxGlPipelineSettingMakerClearStencil maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerClearDepth +class cfxGlPipelineSettingMakerClearDepth : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerClearDepth(); + static cfxGlPipelineSettingMakerClearDepth maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerClipPlane +class cfxGlPipelineSettingMakerClipPlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerClipPlane(); + static cfxGlPipelineSettingMakerClipPlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerColorMask +class cfxGlPipelineSettingMakerColorMask : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerColorMask(); + static cfxGlPipelineSettingMakerColorMask maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerColorMaterial +class cfxGlPipelineSettingMakerColorMaterial : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerColorMaterial(); + static cfxGlPipelineSettingMakerColorMaterial maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerCullFace +class cfxGlPipelineSettingMakerCullFace : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerCullFace(); + static cfxGlPipelineSettingMakerCullFace maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerDepthFunc +class cfxGlPipelineSettingMakerDepthFunc : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerDepthFunc(); + static cfxGlPipelineSettingMakerDepthFunc maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerDepthMask +class cfxGlPipelineSettingMakerDepthMask : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerDepthMask(); + static cfxGlPipelineSettingMakerDepthMask maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerDepthRange +class cfxGlPipelineSettingMakerDepthRange : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerDepthRange(); + static cfxGlPipelineSettingMakerDepthRange maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerFogMode +class cfxGlPipelineSettingMakerFogMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerFogMode(); + static cfxGlPipelineSettingMakerFogMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerFogDensity +class cfxGlPipelineSettingMakerFogDensity : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerFogDensity(); + static cfxGlPipelineSettingMakerFogDensity maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerFogStart +class cfxGlPipelineSettingMakerFogStart : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerFogStart(); + static cfxGlPipelineSettingMakerFogStart maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerFogEnd +class cfxGlPipelineSettingMakerFogEnd : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerFogEnd(); + static cfxGlPipelineSettingMakerFogEnd maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerFogColor +class cfxGlPipelineSettingMakerFogColor : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerFogColor(); + static cfxGlPipelineSettingMakerFogColor maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerFrontFace +class cfxGlPipelineSettingMakerFrontFace : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerFrontFace(); + static cfxGlPipelineSettingMakerFrontFace maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightModelAmbient +class cfxGlPipelineSettingMakerLightModelAmbient : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightModelAmbient(); + static cfxGlPipelineSettingMakerLightModelAmbient maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightAmbient +class cfxGlPipelineSettingMakerLightAmbient : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightAmbient(); + static cfxGlPipelineSettingMakerLightAmbient maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightConstantAttenuation +class cfxGlPipelineSettingMakerLightConstantAttenuation : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightConstantAttenuation(); + static cfxGlPipelineSettingMakerLightConstantAttenuation maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightDiffuse +class cfxGlPipelineSettingMakerLightDiffuse : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightDiffuse(); + static cfxGlPipelineSettingMakerLightDiffuse maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightLinearAttenuation +class cfxGlPipelineSettingMakerLightLinearAttenuation : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightLinearAttenuation(); + static cfxGlPipelineSettingMakerLightLinearAttenuation maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightPosition +class cfxGlPipelineSettingMakerLightPosition : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightPosition(); + static cfxGlPipelineSettingMakerLightPosition maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightQuadraticAttenuation +class cfxGlPipelineSettingMakerLightQuadraticAttenuation : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightQuadraticAttenuation(); + static cfxGlPipelineSettingMakerLightQuadraticAttenuation maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightSpecular +class cfxGlPipelineSettingMakerLightSpecular : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightSpecular(); + static cfxGlPipelineSettingMakerLightSpecular maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightSpotCutoff +class cfxGlPipelineSettingMakerLightSpotCutoff : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightSpotCutoff(); + static cfxGlPipelineSettingMakerLightSpotCutoff maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightSpotDirection +class cfxGlPipelineSettingMakerLightSpotDirection : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightSpotDirection(); + static cfxGlPipelineSettingMakerLightSpotDirection maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLightSpotExponent +class cfxGlPipelineSettingMakerLightSpotExponent : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLightSpotExponent(); + static cfxGlPipelineSettingMakerLightSpotExponent maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLineWidth +class cfxGlPipelineSettingMakerLineWidth : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLineWidth(); + static cfxGlPipelineSettingMakerLineWidth maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerLogicOp +class cfxGlPipelineSettingMakerLogicOp : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerLogicOp(); + static cfxGlPipelineSettingMakerLogicOp maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerMaterialAmbient +class cfxGlPipelineSettingMakerMaterialAmbient : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerMaterialAmbient(); + static cfxGlPipelineSettingMakerMaterialAmbient maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerMaterialDiffuse +class cfxGlPipelineSettingMakerMaterialDiffuse : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerMaterialDiffuse(); + static cfxGlPipelineSettingMakerMaterialDiffuse maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerMaterialEmission +class cfxGlPipelineSettingMakerMaterialEmission : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerMaterialEmission(); + static cfxGlPipelineSettingMakerMaterialEmission maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerMaterialShininess +class cfxGlPipelineSettingMakerMaterialShininess : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerMaterialShininess(); + static cfxGlPipelineSettingMakerMaterialShininess maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerMaterialSpecular +class cfxGlPipelineSettingMakerMaterialSpecular : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerMaterialSpecular(); + static cfxGlPipelineSettingMakerMaterialSpecular maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerModelViewMatrix +class cfxGlPipelineSettingMakerModelViewMatrix : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerModelViewMatrix(); + static cfxGlPipelineSettingMakerModelViewMatrix maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerPointSize +class cfxGlPipelineSettingMakerPointSize : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerPointSize(); + static cfxGlPipelineSettingMakerPointSize maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerPointSpriteCoordReplace +class cfxGlPipelineSettingMakerPointSpriteCoordReplace : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerPointSpriteCoordReplace(); + static cfxGlPipelineSettingMakerPointSpriteCoordReplace maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerPointSpriteRMode +class cfxGlPipelineSettingMakerPointSpriteRMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerPointSpriteRMode(); + static cfxGlPipelineSettingMakerPointSpriteRMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerPolygonMode +class cfxGlPipelineSettingMakerPolygonMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerPolygonMode(); + static cfxGlPipelineSettingMakerPolygonMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerPolygonOffset +class cfxGlPipelineSettingMakerPolygonOffset : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerPolygonOffset(); + static cfxGlPipelineSettingMakerPolygonOffset maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerProjectionMatrix +class cfxGlPipelineSettingMakerProjectionMatrix : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerProjectionMatrix(); + static cfxGlPipelineSettingMakerProjectionMatrix maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerScissor +class cfxGlPipelineSettingMakerScissor : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerScissor(); + static cfxGlPipelineSettingMakerScissor maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerShadeModel +class cfxGlPipelineSettingMakerShadeModel : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerShadeModel(); + static cfxGlPipelineSettingMakerShadeModel maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerStencilFunc +class cfxGlPipelineSettingMakerStencilFunc : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerStencilFunc(); + static cfxGlPipelineSettingMakerStencilFunc maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerStencilMask +class cfxGlPipelineSettingMakerStencilMask : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerStencilMask(); + static cfxGlPipelineSettingMakerStencilMask maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerStencilOp +class cfxGlPipelineSettingMakerStencilOp : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerStencilOp(); + static cfxGlPipelineSettingMakerStencilOp maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerStencilFuncSeparate +class cfxGlPipelineSettingMakerStencilFuncSeparate : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerStencilFuncSeparate(); + static cfxGlPipelineSettingMakerStencilFuncSeparate maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerStencilMaskSeparate +class cfxGlPipelineSettingMakerStencilMaskSeparate : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerStencilMaskSeparate(); + static cfxGlPipelineSettingMakerStencilMaskSeparate maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerStencilOpSeparate +class cfxGlPipelineSettingMakerStencilOpSeparate : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerStencilOpSeparate(); + static cfxGlPipelineSettingMakerStencilOpSeparate maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenSMode +class cfxGlPipelineSettingMakerTexGenSMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenSMode(); + static cfxGlPipelineSettingMakerTexGenSMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenTMode +class cfxGlPipelineSettingMakerTexGenTMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenTMode(); + static cfxGlPipelineSettingMakerTexGenTMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenRMode +class cfxGlPipelineSettingMakerTexGenRMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenRMode(); + static cfxGlPipelineSettingMakerTexGenRMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenQMode +class cfxGlPipelineSettingMakerTexGenQMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenQMode(); + static cfxGlPipelineSettingMakerTexGenQMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenSEyePlane +class cfxGlPipelineSettingMakerTexGenSEyePlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenSEyePlane(); + static cfxGlPipelineSettingMakerTexGenSEyePlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenTEyePlane +class cfxGlPipelineSettingMakerTexGenTEyePlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenTEyePlane(); + static cfxGlPipelineSettingMakerTexGenTEyePlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenREyePlane +class cfxGlPipelineSettingMakerTexGenREyePlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenREyePlane(); + static cfxGlPipelineSettingMakerTexGenREyePlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenQEyePlane +class cfxGlPipelineSettingMakerTexGenQEyePlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenQEyePlane(); + static cfxGlPipelineSettingMakerTexGenQEyePlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenSObjectPlane +class cfxGlPipelineSettingMakerTexGenSObjectPlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenSObjectPlane(); + static cfxGlPipelineSettingMakerTexGenSObjectPlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenTObjectPlane +class cfxGlPipelineSettingMakerTexGenTObjectPlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenTObjectPlane(); + static cfxGlPipelineSettingMakerTexGenTObjectPlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenRObjectPlane +class cfxGlPipelineSettingMakerTexGenRObjectPlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenRObjectPlane(); + static cfxGlPipelineSettingMakerTexGenRObjectPlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexGenQObjectPlane +class cfxGlPipelineSettingMakerTexGenQObjectPlane : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexGenQObjectPlane(); + static cfxGlPipelineSettingMakerTexGenQObjectPlane maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexture2D +class cfxGlPipelineSettingMakerTexture2D : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexture2D(); + static cfxGlPipelineSettingMakerTexture2D maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTexture3D +class cfxGlPipelineSettingMakerTexture3D : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTexture3D(); + static cfxGlPipelineSettingMakerTexture3D maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTextureCubeMap +class cfxGlPipelineSettingMakerTextureCubeMap : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTextureCubeMap(); + static cfxGlPipelineSettingMakerTextureCubeMap maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTextureEnvColor +class cfxGlPipelineSettingMakerTextureEnvColor : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTextureEnvColor(); + static cfxGlPipelineSettingMakerTextureEnvColor maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerTextureEnvMode +class cfxGlPipelineSettingMakerTextureEnvMode : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerTextureEnvMode(); + static cfxGlPipelineSettingMakerTextureEnvMode maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// ENABLE / DISABLE settings + + +// cfxGlPipelineSettingMakerAlphaTestEnable +class cfxGlPipelineSettingMakerAlphaTestEnable : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerAlphaTestEnable(); + static cfxGlPipelineSettingMakerAlphaTestEnable maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerBlendEnable +class cfxGlPipelineSettingMakerBlendEnable : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerBlendEnable(); + static cfxGlPipelineSettingMakerBlendEnable maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerCullFaceEnable +class cfxGlPipelineSettingMakerCullFaceEnable : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerCullFaceEnable(); + static cfxGlPipelineSettingMakerCullFaceEnable maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +// cfxGlPipelineSettingMakerDepthTestEnable +class cfxGlPipelineSettingMakerDepthTestEnable : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMakerDepthTestEnable(); + static cfxGlPipelineSettingMakerDepthTestEnable maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; + + +#if 0 // template +// cfxGlPipelineSettingMaker +class cfxGlPipelineSettingMaker : public cfxGlPipelineSettingMaker +{ + private: + cfxGlPipelineSettingMaker(); + static cfxGlPipelineSettingMaker maker; + public: + virtual cfxGlPipelineSetting* makeSetting(cfxPass* pass, domGl_pipeline_settings* settingInitializer); +}; +#endif + + +#endif // _CFX_GLPIPELINESETTINGMAKER_H + diff --git a/1.4.0/fx/include/cfxGlSamplerSetting.h b/1.4.0/fx/include/cfxGlSamplerSetting.h new file mode 100644 index 0000000..3fdeb0a --- /dev/null +++ b/1.4.0/fx/include/cfxGlSamplerSetting.h @@ -0,0 +1,203 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_GLSAMPLERSETTING_H +#define _CFX_GLSAMPLERSETTING_H + +#include <cfxTypes.h> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +class cfxEffect; +class cfxParam; + + +// cfxGlSamplerSetting +class cfxGlSamplerSetting +{ +public: + enum type_enum { + WRAP_S, + WRAP_T, + MINFILTER, + MAGFILTER, + BORDER_COLOR, + GENERATE_MIPMAP, + MAX_MIP_LEVEL, + LOD_BIAS + }; + + public: + + cfxGlSamplerSetting(cfxEffect* effect, const char* stateName); + virtual ~cfxGlSamplerSetting(); + + virtual cfxBool apply(const cfxParam* param) = 0; + + virtual type_enum getType() const = 0; + + protected: + + cfxEffect* effect; + + CGstate state; + CGstateassignment assignment; + +}; + + + + +// cfxGlSamplerSettingWrapS +class cfxGlSamplerSettingWrapS : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingWrapS(cfxEffect* effect, const char* stateName, int _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlSamplerSettingWrapT +class cfxGlSamplerSettingWrapT : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingWrapT(cfxEffect* effect, const char* stateName, int _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlSamplerSettingMinFilter +class cfxGlSamplerSettingMinFilter : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingMinFilter(cfxEffect* effect, const char* stateName, int _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlSamplerSettingMagFilter +class cfxGlSamplerSettingMagFilter : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingMagFilter(cfxEffect* effect, const char* stateName, int _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + int getValue() const; + + protected: + + int value; +}; + + +// cfxGlSamplerSettingBorderColor +class cfxGlSamplerSettingBorderColor : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingBorderColor(cfxEffect* effect, const char* stateName, cfxFloat4& _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + cfxFloat4 getValue() const; + + protected: + + cfxFloat4 value; +}; + + +// cfxGlSamplerSettingGenerateMipMap +class cfxGlSamplerSettingGenerateMipMap : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingGenerateMipMap(cfxEffect* effect, const char* stateName, cfxBool _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + cfxBool getValue() const; + + protected: + + cfxBool value; +}; + + +// cfxGlSamplerSettingMaxMipLevel +class cfxGlSamplerSettingMaxMipLevel : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingMaxMipLevel(cfxEffect* effect, const char* stateName, float _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + + +// cfxGlSamplerSettingLodBias +class cfxGlSamplerSettingLodBias : public cfxGlSamplerSetting +{ + public: + + cfxGlSamplerSettingLodBias(cfxEffect* effect, const char* stateName, float _value); + virtual cfxBool apply(const cfxParam* param); + + virtual cfxGlSamplerSetting::type_enum getType() const; + + float getValue() const; + + protected: + + float value; +}; + +#endif // _CFX_GLSAMPLERSETTING_H + diff --git a/1.4.0/fx/include/cfxLinux.h b/1.4.0/fx/include/cfxLinux.h new file mode 100644 index 0000000..723839b --- /dev/null +++ b/1.4.0/fx/include/cfxLinux.h @@ -0,0 +1,43 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_LINUX_H_ +#define _CFX_LINUX_H_ + +#include <stdio.h> +//#include <sys/param.h> +#include <stdarg.h> +#include <GL/gl.h> +#include <GL/glext.h> +#include <GL/glu.h> +//#ifndef _LIB +#include <Cg/cg.h> +#include <Cg/cgGL.h> +//#else +//#include <cfxNoCg.h> +//#endif + +#include <assert.h> + +#define CG_FILE_TYPE CG_SOURCE + +#define LINUX 1 + +inline void cfxPrint(const char* str, ...) +{ + va_list valist; + char tempStr[4096]; + + va_start(valist, str); + vsprintf(tempStr, str, valist); + va_end(valist); + + printf( tempStr ); +// OutputDebugString( tempStr ); +} + +#endif diff --git a/1.4.0/fx/include/cfxLoader.h b/1.4.0/fx/include/cfxLoader.h new file mode 100644 index 0000000..4ca5135 --- /dev/null +++ b/1.4.0/fx/include/cfxLoader.h @@ -0,0 +1,85 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_LOADER_H +#define _CFX_LOADER_H + +#include <vector> +#include <map> +#include <string> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif +#include <cfxTypes.h> + +class DAE; + +#include "cfxLoader.h" +#include "cfxEffect.h" +#include "cfxMaterial.h" +#include "cfxSurface.h" +#include "cfxPlatform.h" +class cfxAnnotatable; +class cfxParamable; + + +// cfxLoader +class cfxLoader +{ + public: + + cfxLoader(); + + + // this routine will load the materials and effects from a COLLADA file and populate the maps + // it will resolve the references from materials to effects + // passing a NULL context will create a new context for this effect + static cfxBool loadMaterialsAndEffectsFromFile(const std::string& filename, std::map<std::string, cfxMaterial*>& materials, + std::map<std::string, cfxEffect*>& effects, CGcontext _context = NULL); + + // this routine will load the materials and effects and populate the maps + // it will resolve the references from materials to effects + // passing a NULL context will create a new context for this effect + static cfxBool loadMaterialsAndEffects(DAE *colladaAsset, std::map<std::string, cfxMaterial*>& materials, + std::map<std::string, cfxEffect*>& effects, CGcontext _context = NULL); + + // this routine will load the effects and populate the map + // passing a NULL context will create a new context for this effect + static cfxBool loadEffects(DAE *colladaAsset, std::map<std::string, cfxEffect*>& effects, CGcontext _context = NULL); + + // this routine will load the materials and populate the material map + // if an effects map is provided it will resolve the references from materials to effects + static cfxBool loadMaterials(DAE *colladaAsset, std::map<std::string, cfxMaterial*>& materials, + const std::map<std::string, cfxEffect*>* effects = NULL); + + // this is in the process of being deprecated + // set the COLLADA FX filename to load + // passing a NULL context will create a new context for this effect + static cfxBool loadFile(const std::string& file, std::vector<cfxEffect*>& effects, CGcontext _context = NULL); + +public: //binary load/save functionality + + static void setBinaryLoadRemotePath( const std::string &path ); + + static cfxBool loadMaterialsAndEffectsFromBinFile(const std::string& file, std::map<std::string, cfxMaterial*>& materials, + std::map<std::string, cfxEffect*>& effects, CGcontext _context = NULL); + static cfxBool saveBinFile(const std::string& file, const std::map<std::string, cfxMaterial*>& materials, + const std::map<std::string, cfxEffect*>& effects, cfxBool replace = false ); + + static void setPlatformString( const std::string &platform ); + static std::string &getPlatformString(); + private: + + static std::string platformString; +}; + + +#endif // _CFX_LOADER_H + diff --git a/1.4.0/fx/include/cfxMaterial.h b/1.4.0/fx/include/cfxMaterial.h new file mode 100644 index 0000000..b58a353 --- /dev/null +++ b/1.4.0/fx/include/cfxMaterial.h @@ -0,0 +1,65 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_MATERIAL_H +#define _CFX_MATERIAL_H + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +#include <string> +#include <map> +#include <vector> + +#include <cfxParamable.h> + +class cfxEffect; +class cfxSurface; + +// cfxMaterial +class cfxMaterial : public cfxParamable +{ +public: + + cfxMaterial(const std::string& _name, const std::string& _effectName, + cfxEffect* _effect = NULL); + + ~cfxMaterial(); + + const std::string& getName() const; + + cfxEffect* getEffect() const; + + bool setParameterValues(); + + void setEffectPassState(unsigned int techniqueIndex, unsigned int passIndex); + void resetEffectPassState(unsigned int techniqueIndex, unsigned int passIndex); + unsigned int getEffectTechniqueCount(); + unsigned int getEffectPassCount(unsigned int techniqueIndex); + + const std::string &getEffectName() const; + + void addSurface(cfxSurface* surface); + + const std::vector<cfxSurface*> &getSurfaces() const; + +private: + + std::string name; + std::string effectName; + + cfxEffect* effect; + + std::vector<cfxSurface*> surfaces; +}; + + +#endif // _CFX_MATERIAL_H + diff --git a/1.4.0/fx/include/cfxNewParam.h b/1.4.0/fx/include/cfxNewParam.h new file mode 100644 index 0000000..e6e502a --- /dev/null +++ b/1.4.0/fx/include/cfxNewParam.h @@ -0,0 +1,43 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_NEWPARAM_H +#define _CFX_NEWPARAM_H + + +#include <cfxParam.h> +#include <cfxAnnotatable.h> + +class cfxEffect; +class cfxAnnotate; +class cfxData; + +// cfxNewParam +class cfxNewParam : public cfxParam, public cfxAnnotatable +{ +public: + + cfxNewParam(cfxData* _data, const std::string& _name, cfxEffect* _effect, + const std::string& _semantic); + + virtual bool apply(); + virtual bool validate() const; + + virtual cfxParam::cfxParamTypeEnum getType() const; + const std::string &getSemantic() const; + const cfxData *getData() const; + cfxEffect* effect; + cfxData* data; + +protected: + + std::string semantic; + +}; + +#endif // _CFX_NEWPARAM_H + diff --git a/1.4.0/fx/include/cfxOSX.h b/1.4.0/fx/include/cfxOSX.h new file mode 100644 index 0000000..9da5a62 --- /dev/null +++ b/1.4.0/fx/include/cfxOSX.h @@ -0,0 +1,38 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFXOSX_H +#define _CFXOSX_H + +#include <stdio.h> +#include <stdarg.h> +#include <OpenGL/gl.h> +#include <OpenGL/glext.h> +#include <OpenGL/glu.h> +#include <CG/cg.h> +#include <CG/cgGL.h> + + +#include <assert.h> + +#define CG_FILE_TYPE CG_SOURCE + +//#define LINUX 1 + +inline void cfxPrint(const char* str, ...) +{ + va_list valist; + char tempStr[4096]; + + va_start(valist, str); + vsprintf(tempStr, str, valist); + va_end(valist); + + printf( tempStr ); +} + +#endif diff --git a/1.4.0/fx/include/cfxPS3.h b/1.4.0/fx/include/cfxPS3.h new file mode 100644 index 0000000..1834128 --- /dev/null +++ b/1.4.0/fx/include/cfxPS3.h @@ -0,0 +1,20 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_PS3_H_ +#define _CFX_PS3_H_ + +#include <PSGL/psgl.h> + +#define CG_FILE_TYPE CG_BINARY + +inline void cfxPrint(const char* str, ...) +{ + printf(str); +} + +#endif diff --git a/1.4.0/fx/include/cfxParam.h b/1.4.0/fx/include/cfxParam.h new file mode 100644 index 0000000..251d6fe --- /dev/null +++ b/1.4.0/fx/include/cfxParam.h @@ -0,0 +1,52 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_PARAM_H +#define _CFX_PARAM_H + + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif +#include <string> + +// cfxParam +class cfxParam +{ +public: + enum cfxParamTypeEnum { + CFXBINDPARAM, + CFXCONNECTPARAM, + CFXNEWPARAM, + CFXSETPARAM, + }; + +public: + + cfxParam(const std::string& _name); + virtual ~cfxParam(); + + virtual bool apply() = 0; + virtual bool validate() const = 0; + + CGparameter getParameter() const; + virtual cfxParamTypeEnum getType() const = 0; + + const std::string &getName() const; + +protected: + + std::string name; + + CGparameter parameter; + +}; + + +#endif // _CFX_PARAM_H diff --git a/1.4.0/fx/include/cfxParamable.h b/1.4.0/fx/include/cfxParamable.h new file mode 100644 index 0000000..d4a0746 --- /dev/null +++ b/1.4.0/fx/include/cfxParamable.h @@ -0,0 +1,36 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_PARAMABLE_H +#define _CFX_PARAMABLE_H + + +#include <vector> + +class cfxParam; + + +// cfxParamable +class cfxParamable +{ +public: + + cfxParamable(); + virtual ~cfxParamable(); + + void pushParam(cfxParam* param); + + const std::vector<cfxParam*> &getParamArray() const; + + protected: + + std::vector<cfxParam*> paramArray; // min 0 + +}; + + +#endif // _CFX_PARAMABLE_H diff --git a/1.4.0/fx/include/cfxPass.h b/1.4.0/fx/include/cfxPass.h new file mode 100644 index 0000000..f047b18 --- /dev/null +++ b/1.4.0/fx/include/cfxPass.h @@ -0,0 +1,64 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_PASS_H +#define _CFX_PASS_H + +#include <string> +#include <vector> + +#include <cfxAnnotatable.h> +#include <cfxParamable.h> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +class cfxGlPipelineSetting; +class cfxShader; +class cfxTechnique; + +// cfxPass +class cfxPass : public cfxAnnotatable, public cfxParamable +{ +public: + + cfxPass(cfxTechnique* _technique, const std::string& _name); + ~cfxPass(); + + bool apply(); + bool validate() const; + + void pushSetting(cfxGlPipelineSetting* setting); + void pushShader(cfxShader* shader); + + cfxTechnique* getTechnique() const; + + CGpass getPass() const; + + const std::string &getName() const; + const std::vector<cfxGlPipelineSetting*> &getSettingArray() const; + const std::vector<cfxShader*> &getShaderArray() const; + +private: + + cfxTechnique* technique; + + std::string name; + + std::vector<cfxGlPipelineSetting*> settingArray; // min 0 + + std::vector<cfxShader*> shaderArray; // min 0 + + CGpass pass; + +}; + +#endif // _CFX_PASS_H + diff --git a/1.4.0/fx/include/cfxPlatform.h b/1.4.0/fx/include/cfxPlatform.h new file mode 100644 index 0000000..a2abb8a --- /dev/null +++ b/1.4.0/fx/include/cfxPlatform.h @@ -0,0 +1,20 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_PLATFORM_H_ +#define _CFX_PLATFORM_H_ + +#include <stdio.h> + +// The CFX_PLATFORM_INCLUDE define specifies the header file which includes all platform specific information +// For windows projects this is \<cfxWin.h\> which makes this statement include <cfxWin.h> +// For Linux projects this is \<cfxLinux.h\> which makes this statement include <cfxLinux.h> +// The define is defaulted to windows in the Makefile +#include CFX_PLATFORM_INCLUDE + +#endif + diff --git a/1.4.0/fx/include/cfxSampler.h b/1.4.0/fx/include/cfxSampler.h new file mode 100644 index 0000000..dc1ca44 --- /dev/null +++ b/1.4.0/fx/include/cfxSampler.h @@ -0,0 +1,56 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_SAMPLER_H +#define _CFX_SAMPLER_H + +#include <string> +#include <vector> + +#include <cfxPlatform.h> + +class cfxEffect; +class cfxParam; +class cfxGlSamplerSetting; +class cfxSurface; + +// cfxSampler +class cfxSampler +{ + public: + + cfxSampler(const std::string& _source, cfxEffect* _effect); + virtual ~cfxSampler(); + + bool apply(cfxParam* param); + + GLuint getTextureId();// const; + + void pushSetting(cfxGlSamplerSetting* setting); + + void setGenerateMipmaps(bool _generateMipmaps); + + const std::string &getSource() const; + const std::vector<cfxGlSamplerSetting*> &getSettingArray() const; + + protected: + + std::string source; + GLuint textureId; + + cfxEffect* effect; + cfxSurface* surface; + + bool generateMipmaps; + + std::vector<cfxGlSamplerSetting*> settingArray; // min 0 + +}; + + + +#endif // _CFX_SAMPLER_H diff --git a/1.4.0/fx/include/cfxSetParam.h b/1.4.0/fx/include/cfxSetParam.h new file mode 100644 index 0000000..ebbd5f2 --- /dev/null +++ b/1.4.0/fx/include/cfxSetParam.h @@ -0,0 +1,39 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_SETPARAM_H +#define _CFX_SETPARAM_H + + +#include <cfxParam.h> + +class cfxEffect; +class cfxAnnotate; +class cfxData; + +// cfxSetparam +class cfxSetParam : public cfxParam +{ +public: + + cfxSetParam(cfxData* _data, const std::string& _name, cfxEffect* _effect); + + virtual bool apply(); + virtual bool validate() const; + + virtual cfxParam::cfxParamTypeEnum getType() const; + const cfxData *getData() const; + +protected: + + cfxEffect* effect; + cfxData* data; + +}; + +#endif // _CFX_SETPARAM_H + diff --git a/1.4.0/fx/include/cfxShader.h b/1.4.0/fx/include/cfxShader.h new file mode 100644 index 0000000..a040a83 --- /dev/null +++ b/1.4.0/fx/include/cfxShader.h @@ -0,0 +1,63 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_SHADER_H +#define _CFX_SHADER_H + +#include <string> +#include <cfxAnnotatable.h> +#include <cfxParamable.h> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +class cfxPass; + +// cfxShader +class cfxShader : public cfxAnnotatable, public cfxParamable +{ +public: + enum type_enum { + VERTEX, + FRAGMENT + }; +public: + + cfxShader(cfxPass* _pass, const std::string& _source, const std::string& _name, CGprofile _target, type_enum type); + ~cfxShader(); + bool apply(); + bool validate() const; + + cfxPass* getPass() const; + + CGprogram getProgram() const; + + const std::string &getName() const; + const std::string &getSource() const; + const CGprofile &getTarget() const; + type_enum getOriginalType() const; + +private: + + cfxPass* pass; + + std::string source; + std::string name; + + CGprofile target; + CGprogram program; + CGstate state; + CGstateassignment assignment; + + type_enum originalType; +}; + +#endif // _CFX_SHADER_H + diff --git a/1.4.0/fx/include/cfxSurface.h b/1.4.0/fx/include/cfxSurface.h new file mode 100644 index 0000000..98a66c6 --- /dev/null +++ b/1.4.0/fx/include/cfxSurface.h @@ -0,0 +1,61 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_SURFACE_H +#define _CFX_SURFACE_H + +#include <string> +#include <map> +#include <vector> + +#include <cfxPlatform.h> + +class cfxParam; + +// cfxSurface +class cfxSurface +{ +public: + + cfxSurface(const std::string& _init_from, const std::string& _format, cfxSurface* parentSurface = NULL); + ~cfxSurface(); + + bool apply(); + bool validate() const; + + const std::string& getInitFrom() const; + const std::string& getFormat() const; + + void addReferencingParam(cfxParam* param); + + // load images in some other library + // this must then be called for all loaded images so cfx can access their GL ids + static void addImage(const std::string& imageId, GLuint texId); + static void setDefaultTexture(GLuint texId); + // to retrieve tex ids lookup by image id + static GLuint getTexIdByImageId(const std::string& imageId); + + const cfxSurface* getParentSurface() const; + std::vector<cfxParam*> referencingParams; +private: + + void setSurface(const std::string& _init_from, const std::string& _format); + + std::string init_from; + std::string format; + + cfxSurface* parentSurface; + + static std::map<std::string, GLuint> mapImageIdToGlTextureObjectId; + + static GLuint defaultTexture; + +}; + + + +#endif // _CFX_SURFACE_H diff --git a/1.4.0/fx/include/cfxTechnique.h b/1.4.0/fx/include/cfxTechnique.h new file mode 100644 index 0000000..ba8a954 --- /dev/null +++ b/1.4.0/fx/include/cfxTechnique.h @@ -0,0 +1,79 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_TECHNIQUE_H +#define _CFX_TECHNIQUE_H + + +#include <cfxAnnotatable.h> +#include <cfxParamable.h> +#include <string> +#include <map> + +//#ifndef _LIB +#include <Cg/cg.h> +//#else +//#include <cfxNoCg.h> +//#endif + +class cfxEffect; +class cfxPass; +class cfxCode; +class cfxSurface; + +// cfxTechnique +class cfxTechnique : public cfxAnnotatable, public cfxParamable +{ +public: + + cfxTechnique(cfxEffect* _effect, const std::string& _name); + ~cfxTechnique(); + + bool apply(); + bool validate() const; + + cfxEffect* getEffect() const; + CGtechnique getTechnique() const; + + const char* mapNameToFullPath(const std::string& name) const; + const char* getFullPathCg(unsigned int& numCg, unsigned int indexCg) const; + + void pushPass(cfxPass* pass); + void pushInclude(const std::string& name, const std::string& uri); + void pushSurface(cfxSurface* surface); + + void setPassState(unsigned int passIndex); + void resetPassState(unsigned int passIndex); + unsigned int getPassCount() const; + + const std::map<std::string, std::string> &getIncludeMap() const; + const std::vector<cfxSurface*> &getSurfaceArray() const; + const std::string &getName() const; + const std::vector<cfxPass*> &getPassArray() const; + +private: + + cfxEffect* effect; + + // nothing to be done with code until run time compilation is supported + std::vector<cfxCode*> codeArray; + + // maps identifying name to full path + std::map<std::string, std::string> includeMap; + + std::vector<cfxPass*> passArray; + + std::vector<cfxSurface*> surfaceArray; + + std::string name; + + CGtechnique technique; + +}; + + +#endif // _CFX_TECHNIQUE_H diff --git a/1.4.0/fx/include/cfxTypes.h b/1.4.0/fx/include/cfxTypes.h new file mode 100644 index 0000000..e0b0303 --- /dev/null +++ b/1.4.0/fx/include/cfxTypes.h @@ -0,0 +1,137 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_TYPES_H +#define _CFX_TYPES_H + +#ifdef WIN32 +#define NORMAL_OS 1 +#endif + +#ifdef LINUX +#undef NORMAL_OS +#endif + +#ifdef __APPLE__ +#undef NORMAL_OS +#endif + + +typedef int cfxBool; +typedef unsigned int cfxUint; +typedef int cfxInt; +typedef int cfxError; +typedef float cfxFloat; +typedef double cfxDouble; + +typedef struct { + cfxBool b0; +} cfxBool1; + +typedef struct { + cfxBool b0; + cfxBool b1; +} cfxBool2; + +typedef struct { + cfxBool b0; + cfxBool b1; + cfxBool b2; +} cfxBool3; + +typedef struct { + cfxBool b0; + cfxBool b1; + cfxBool b2; + cfxBool b3; +} cfxBool4; + +typedef struct { + cfxInt i0; +} cfxInt1; + +typedef struct { + cfxInt i0; + cfxInt i1; +} cfxInt2; + +typedef struct { + cfxInt i0; + cfxInt i1; + cfxInt i2; +} cfxInt3; + +typedef struct { + cfxInt i0; + cfxInt i1; + cfxInt i2; + cfxInt i3; +} cfxInt4; + +typedef struct { + cfxFloat f0; +} cfxFloat1; + +typedef struct { + cfxFloat f0; + cfxFloat f1; +} cfxFloat2; + +typedef struct { + cfxFloat f0; + cfxFloat f1; + cfxFloat f2; +} cfxFloat3; + +typedef struct { + cfxFloat f0; + cfxFloat f1; + cfxFloat f2; + cfxFloat f3; +} cfxFloat4; + + +typedef struct { + cfxFloat f00; + cfxFloat f01; + cfxFloat f10; + cfxFloat f11; +} cfxFloat2x2; + +typedef struct { + cfxFloat f00; + cfxFloat f01; + cfxFloat f02; + cfxFloat f10; + cfxFloat f11; + cfxFloat f12; + cfxFloat f20; + cfxFloat f21; + cfxFloat f22; +} cfxFloat3x3; + +typedef struct { + cfxFloat f00; + cfxFloat f01; + cfxFloat f02; + cfxFloat f03; + cfxFloat f10; + cfxFloat f11; + cfxFloat f12; + cfxFloat f13; + cfxFloat f20; + cfxFloat f21; + cfxFloat f22; + cfxFloat f23; + cfxFloat f30; + cfxFloat f31; + cfxFloat f32; + cfxFloat f33; +} cfxFloat4x4; + + +#endif // _CFX_TYPES_H diff --git a/1.4.0/fx/include/cfxWin.h b/1.4.0/fx/include/cfxWin.h new file mode 100644 index 0000000..079d20e --- /dev/null +++ b/1.4.0/fx/include/cfxWin.h @@ -0,0 +1,39 @@ +/* +* Copyright 2006 Sony Computer Entertainment Inc. +* +* Licensed under the MIT Open Source License, for details please see license.txt or the website +* http://www.opensource.org/licenses/mit-license.php +* +*/ +#ifndef _CFX_WIN_H_ +#define _CFX_WIN_H_ + +#include <windows.h> +#include <gl/gl.h> +#include <gl/glext.h> +#include <gl/glu.h> +//#include <gl/glaux.h> +//#ifndef _LIB +#include <Cg/cg.h> +#include <Cg/cgGL.h> +//#else +//#include <cfxNoCg.h> +//#endif + +#include <assert.h> + +#define CG_FILE_TYPE CG_SOURCE + +inline void cfxPrint(const char* str, ...) +{ + va_list valist; + char tempStr[4096]; + + va_start(valist, str); // LMessage is the last argument before the varargs + vsprintf(tempStr, str, valist); + va_end(valist); + + OutputDebugString( tempStr ); +} + +#endif |