Merged JSR-231 branch on to the main JOGL trunk. The main trunk now

contains the evolving JSR-231 Reference Implementation and the JSR-231
branch is permanently closed.


git-svn-id: file:///usr/local/projects/SUN/JOGL/git-svn/svn-server-sync/jogl/trunk@401 232f8b59-042b-4e1e-8c03-345bb8c30851

10 files changed, 429 insertions, 165 deletions

diff --git a/make/stub_includes/cg/CG/cg.h b/make/stub_includes/cg/CG/cg.h
index 5ff03872f..fe1cf2a75 100644
--- a/make/stub_includes/cg/CG/cg.h
+++ b/make/stub_includes/cg/CG/cg.h
@@ -8,7 +8,7 @@
 
 /*
  *
- * Copyright (c) 2002, NVIDIA Corporation.
+ * Copyright (c) 2002-2004, NVIDIA Corporation.
  * 
  *  
  * 
@@ -62,15 +62,7 @@
 #define _cg_h
 
 
-#define CG_VERSION_1_2                1
-#define CG_VERSION_NUM                1200
-
-
-//
-// This #define foreces the old API for now.  This will be removed soon, but
-// the user will still have the ability to enable it.
-//
-// #define CG_DEPRECATED_1_1_API 1
+#define CG_VERSION_NUM                1400
 
 // Set up for either Win32 import/export/lib.
 #ifndef CGDLL_API
@@ -103,7 +95,15 @@ typedef int CGbool;
 typedef struct _CGcontext *CGcontext;
 typedef struct _CGprogram *CGprogram;
 typedef struct _CGparameter *CGparameter;
+typedef struct _CGeffect *CGeffect;
+typedef struct _CGtechnique *CGtechnique;
+typedef struct _CGpass *CGpass;
+typedef struct _CGstate *CGstate;
+typedef struct _CGstateassignment *CGstateassignment;
+typedef struct _CGannotation *CGannotation;
+typedef void *CGhandle;
 
+typedef CGbool (*CGstatecallback)(CGstateassignment);
 
 //!!! PREPROCESS BEGIN
 
@@ -114,7 +114,8 @@ typedef enum
   CG_ARRAY,
 
   CG_TYPE_START_ENUM = 1024,
-//# define CG_DATATYPE_MACRO(name, compiler_name, enum_name, ncols, nrows) enum_name ,
+// # define CG_DATATYPE_MACRO(name, compiler_name, enum_name, base_name, ncols, nrows, pc) \
+//   enum_name ,
 
 #include <CG/cg_datatypes.h>
 
@@ -122,7 +123,9 @@ typedef enum
 
 typedef enum
  {
-//# define CG_BINDLOCATION_MACRO(name,enum_name,compiler_name,enum_int,addressable,param_type) enum_name = enum_int,
+// # define CG_BINDLOCATION_MACRO(name,enum_name,compiler_name,\
+//                                enum_int,addressable,param_type) \
+//   enum_name = enum_int,
 
 #include <CG/cg_bindlocations.h>
 
@@ -135,7 +138,8 @@ typedef enum
   CG_PROFILE_START = 6144,
   CG_PROFILE_UNKNOWN,
 
-//# define CG_PROFILE_MACRO(name, compiler_id, compiler_id_caps, compiler_opt,int_id,vertex_profile) CG_PROFILE_##compiler_id_caps = int_id,
+// # define CG_PROFILE_MACRO(name, compiler_id, compiler_id_caps, compiler_opt,int_id,vertex_profile) \
+//    CG_PROFILE_##compiler_id_caps = int_id,
   
 #include <CG/cg_profiles.h>
 
@@ -144,15 +148,29 @@ typedef enum
 
 typedef enum
  {
-//# define CG_ERROR_MACRO(code, enum_name, new_enum_name, message) new_enum_name = code,
+// # define CG_ERROR_MACRO(code, enum_name, message) \
+//    enum_name = code,
 # include <CG/cg_errors.h>
  } CGerror;
 
+typedef enum
+ {
+  CG_PARAMETERCLASS_UNKNOWN = 0,
+  CG_PARAMETERCLASS_SCALAR,
+  CG_PARAMETERCLASS_VECTOR,
+  CG_PARAMETERCLASS_MATRIX,
+  CG_PARAMETERCLASS_STRUCT,
+  CG_PARAMETERCLASS_ARRAY,
+  CG_PARAMETERCLASS_SAMPLER,
+  CG_PARAMETERCLASS_OBJECT
+ } CGparameterclass;
+
 //!!! PREPROCESS END
 
 typedef enum
  {
-//# define CG_ENUM_MACRO(enum_name, enum_val) enum_name = enum_val,
+// # define CG_ENUM_MACRO(enum_name, enum_val) \
+//    enum_name = enum_val,
 # include <CG/cg_enums.h>
  } CGenum;
 
@@ -163,6 +181,7 @@ extern "C" {
 #endif
 
 typedef void (*CGerrorCallbackFunc)(void);
+typedef void (*CGerrorHandlerFunc)(CGcontext ctx, CGerror err, void *data);
 
 /*************************************************************************/
 /*** Functions                                                         ***/
@@ -176,7 +195,9 @@ CGDLL_API CGcontext cgCreateContext(void);
 CGDLL_API void cgDestroyContext(CGcontext ctx); 
 CGDLL_API CGbool cgIsContext(CGcontext ctx);
 CGDLL_API const char *cgGetLastListing(CGcontext ctx);
+CGDLL_API void cgSetLastListing(CGhandle handle, const char *listing);
 CGDLL_API void cgSetAutoCompile(CGcontext ctx, CGenum flag);
+CGDLL_API CGenum cgGetAutoCompile(CGcontext ctx);
 
 /*** Program functions ***/
 CGDLL_API CGprogram cgCreateProgram(CGcontext ctx, 
@@ -203,6 +224,9 @@ CGDLL_API void cgCompileProgram(CGprogram program);
 CGDLL_API CGbool cgIsProgramCompiled(CGprogram program); 
 CGDLL_API const char *cgGetProgramString(CGprogram prog, CGenum pname); 
 CGDLL_API CGprofile cgGetProgramProfile(CGprogram prog); 
+CGDLL_API void cgSetProgramProfile(CGprogram prog, CGprofile profile);
+
+CGDLL_API void cgSetPassProgramParameters(CGprogram);
 
 /*** Parameter functions ***/
 
@@ -242,6 +266,7 @@ CGDLL_API CGparameter cgGetArrayParameter(CGparameter aparam, int index);
 CGDLL_API int cgGetArrayDimension(CGparameter param);
 CGDLL_API CGtype cgGetArrayType(CGparameter param);
 CGDLL_API int cgGetArraySize(CGparameter param, int dimension);
+CGDLL_API int cgGetArrayTotalSize(CGparameter param);
 CGDLL_API void cgSetArraySize(CGparameter param, int size);
 CGDLL_API void cgSetMultiDimArraySize(CGparameter param, const int *sizes);
 
@@ -250,6 +275,10 @@ CGDLL_API CGcontext cgGetParameterContext(CGparameter param);
 CGDLL_API CGbool cgIsParameter(CGparameter param);
 CGDLL_API const char *cgGetParameterName(CGparameter param);
 CGDLL_API CGtype cgGetParameterType(CGparameter param);
+CGDLL_API CGtype cgGetParameterBaseType(CGparameter param);
+CGDLL_API CGparameterclass cgGetParameterClass(CGparameter param);
+CGDLL_API int cgGetParameterRows(CGparameter param);
+CGDLL_API int cgGetParameterColumns(CGparameter param);
 CGDLL_API CGtype cgGetParameterNamedType(CGparameter param);
 CGDLL_API const char *cgGetParameterSemantic(CGparameter param);
 CGDLL_API CGresource cgGetParameterResource(CGparameter param);
@@ -258,9 +287,25 @@ CGDLL_API unsigned long cgGetParameterResourceIndex(CGparameter param);
 CGDLL_API CGenum cgGetParameterVariability(CGparameter param);
 CGDLL_API CGenum cgGetParameterDirection(CGparameter param);
 CGDLL_API CGbool cgIsParameterReferenced(CGparameter param);
+CGDLL_API CGbool cgIsParameterUsed(CGparameter param, CGhandle handle);
 CGDLL_API const double *cgGetParameterValues(CGparameter param, 
                                              CGenum value_type,
                                              int *nvalues);
+CGDLL_API void cgSetParameterValuedr(CGparameter param, int n, const double *vals);
+CGDLL_API void cgSetParameterValuedc(CGparameter param, int n, const double *vals);
+CGDLL_API void cgSetParameterValuefr(CGparameter param, int n, const float *vals);
+CGDLL_API void cgSetParameterValuefc(CGparameter param, int n, const float *vals);
+CGDLL_API void cgSetParameterValueir(CGparameter param, int n, const int *vals);
+CGDLL_API void cgSetParameterValueic(CGparameter param, int n, const int *vals);
+CGDLL_API int cgGetParameterValuedr(CGparameter param, int n, double *vals);
+CGDLL_API int cgGetParameterValuedc(CGparameter param, int n, double *vals);
+CGDLL_API int cgGetParameterValuefr(CGparameter param, int n, float *vals);
+CGDLL_API int cgGetParameterValuefc(CGparameter param, int n, float *vals);
+CGDLL_API int cgGetParameterValueir(CGparameter param, int n, int *vals);
+CGDLL_API int cgGetParameterValueic(CGparameter param, int n, int *vals);
+CGDLL_API const char *cgGetStringParameterValue(CGparameter param);
+CGDLL_API void cgSetStringParameterValue(CGparameter param, const char *str);
+
 CGDLL_API int cgGetParameterOrdinalNumber(CGparameter param);
 CGDLL_API CGbool cgIsParameterGlobal(CGparameter param);
 CGDLL_API int cgGetParameterIndex(CGparameter param);
@@ -268,7 +313,6 @@ CGDLL_API int cgGetParameterIndex(CGparameter param);
 CGDLL_API void cgSetParameterVariability(CGparameter param, CGenum vary);
 CGDLL_API void cgSetParameterSemantic(CGparameter param, const char *semantic);
 
-
 CGDLL_API void cgSetParameter1f(CGparameter param, float x);
 CGDLL_API void cgSetParameter2f(CGparameter param, float x, float y);
 CGDLL_API void cgSetParameter3f(CGparameter param, float x, float y, float z);
@@ -288,8 +332,20 @@ CGDLL_API void cgSetParameter4d(CGparameter param,
                                 double y, 
                                 double z,
                                 double w);
-
-
+CGDLL_API void cgSetParameter1i(CGparameter param, int x);
+CGDLL_API void cgSetParameter2i(CGparameter param, int x, int y);
+CGDLL_API void cgSetParameter3i(CGparameter param, int x, int y, int z);
+CGDLL_API void cgSetParameter4i(CGparameter param, 
+                                int x, 
+                                int y, 
+                                int z,
+                                int w);
+
+
+CGDLL_API void cgSetParameter1iv(CGparameter param, const int *v);
+CGDLL_API void cgSetParameter2iv(CGparameter param, const int *v);
+CGDLL_API void cgSetParameter3iv(CGparameter param, const int *v);
+CGDLL_API void cgSetParameter4iv(CGparameter param, const int *v);
 CGDLL_API void cgSetParameter1fv(CGparameter param, const float *v);
 CGDLL_API void cgSetParameter2fv(CGparameter param, const float *v);
 CGDLL_API void cgSetParameter3fv(CGparameter param, const float *v);
@@ -299,21 +355,29 @@ CGDLL_API void cgSetParameter2dv(CGparameter param, const double *v);
 CGDLL_API void cgSetParameter3dv(CGparameter param, const double *v);
 CGDLL_API void cgSetParameter4dv(CGparameter param, const double *v);
 
+CGDLL_API void cgSetMatrixParameterir(CGparameter param, const int *matrix);
 CGDLL_API void cgSetMatrixParameterdr(CGparameter param, const double *matrix);
 CGDLL_API void cgSetMatrixParameterfr(CGparameter param, const float *matrix);
+CGDLL_API void cgSetMatrixParameteric(CGparameter param, const int *matrix);
 CGDLL_API void cgSetMatrixParameterdc(CGparameter param, const double *matrix);
 CGDLL_API void cgSetMatrixParameterfc(CGparameter param, const float *matrix);
 
+CGDLL_API void cgGetMatrixParameterir(CGparameter param, int *matrix);
+CGDLL_API void cgGetMatrixParameterdr(CGparameter param, double *matrix);
+CGDLL_API void cgGetMatrixParameterfr(CGparameter param, float *matrix);
+CGDLL_API void cgGetMatrixParameteric(CGparameter param, int *matrix);
+CGDLL_API void cgGetMatrixParameterdc(CGparameter param, double *matrix);
+CGDLL_API void cgGetMatrixParameterfc(CGparameter param, float *matrix);
 
 /*** Type Functions ***/
 
 CGDLL_API const char *cgGetTypeString(CGtype type);
 CGDLL_API CGtype cgGetType(const char *type_string);
 
-CGDLL_API CGtype cgGetNamedUserType(CGprogram program, const char *name);
+CGDLL_API CGtype cgGetNamedUserType(CGhandle handle, const char *name);
 
-CGDLL_API int cgGetNumUserTypes(CGprogram program);
-CGDLL_API CGtype cgGetUserType(CGprogram program, int index);
+CGDLL_API int cgGetNumUserTypes(CGhandle handle);
+CGDLL_API CGtype cgGetUserType(CGhandle handle, int index);
 
 CGDLL_API int cgGetNumParentTypes(CGtype type);
 CGDLL_API CGtype cgGetParentType(CGtype type, int index);
@@ -339,27 +403,134 @@ CGDLL_API CGprofile cgGetProfile(const char *profile_string);
 /*** Error Functions ***/
 
 CGDLL_API CGerror cgGetError(void);
+CGDLL_API CGerror cgGetFirstError(void);
 CGDLL_API const char *cgGetErrorString(CGerror error);
 CGDLL_API const char *cgGetLastErrorString(CGerror *error);
 CGDLL_API void cgSetErrorCallback(CGerrorCallbackFunc func);
 CGDLL_API CGerrorCallbackFunc cgGetErrorCallback(void);
+CGDLL_API void cgSetErrorHandler(CGerrorHandlerFunc func, void *data);
+CGDLL_API CGerrorHandlerFunc cgGetErrorHandler(void **data);
 
 /*** Misc Functions ***/
 
 CGDLL_API const char *cgGetString(CGenum sname);
 
 
-/*** Support for deprecated Cg 1.1 API ***/
-
-CGDLL_API CGparameter cgGetNextParameter_depr1_1(CGparameter current);
-CGDLL_API CGparameter cgGetNextLeafParameter_depr1_1(CGparameter current);
-
-#ifdef CG_DEPRECATED_1_1_API
-
-#define cgGetNextParameter cgGetNextParameter_depr1_1
-#define cgGetNextLeafParameter cgGetNextLeafParameter_depr1_1
-
-#endif
+/*** CgFX Functions ***/
+
+CGDLL_API CGeffect cgCreateEffect(CGcontext, const char *code, const char **args);
+CGDLL_API CGeffect cgCreateEffectFromFile(CGcontext, const char *filename,
+                                          const char **args);
+CGDLL_API void cgDestroyEffect(CGeffect);
+CGDLL_API CGcontext cgGetEffectContext(CGeffect);
+CGDLL_API CGbool cgIsEffect(CGeffect effect);
+
+CGDLL_API CGeffect cgGetFirstEffect(CGcontext);
+CGDLL_API CGeffect cgGetNextEffect(CGeffect);
+
+CGDLL_API CGprogram cgCreateProgramFromEffect(CGeffect effect,
+                                              CGprofile profile,
+                                              const char *entry,
+                                              const char **args);
+
+CGDLL_API CGtechnique cgGetFirstTechnique(CGeffect);
+CGDLL_API CGtechnique cgGetNextTechnique(CGtechnique);
+CGDLL_API CGtechnique cgGetNamedTechnique(CGeffect, const char *name);
+CGDLL_API const char *cgGetTechniqueName(CGtechnique);
+CGDLL_API CGbool cgIsTechnique(CGtechnique);
+CGDLL_API CGbool cgValidateTechnique(CGtechnique);
+CGDLL_API CGbool cgIsTechniqueValidated(CGtechnique);
+CGDLL_API CGeffect cgGetTechniqueEffect(CGtechnique);
+
+CGDLL_API CGpass cgGetFirstPass(CGtechnique);
+CGDLL_API CGpass cgGetNamedPass(CGtechnique, const char *name);
+CGDLL_API CGpass cgGetNextPass(CGpass);
+CGDLL_API CGbool cgIsPass(CGpass);
+CGDLL_API const char *cgGetPassName(CGpass); 
+CGDLL_API CGtechnique cgGetPassTechnique(CGpass);
+
+CGDLL_API void cgSetPassState(CGpass);
+CGDLL_API void cgResetPassState(CGpass);
+
+CGDLL_API CGstateassignment cgGetFirstStateAssignment(CGpass);
+CGDLL_API CGstateassignment cgGetNamedStateAssignment(CGpass, const char *name);
+CGDLL_API CGstateassignment cgGetNextStateAssignment(CGstateassignment);
+CGDLL_API CGbool cgIsStateAssignment(CGstateassignment);
+CGDLL_API CGbool cgCallStateSetCallback(CGstateassignment);
+CGDLL_API CGbool cgCallStateValidateCallback(CGstateassignment);
+CGDLL_API CGbool cgCallStateResetCallback(CGstateassignment);
+CGDLL_API CGpass cgGetStateAssignmentPass(CGstateassignment);
+CGDLL_API CGparameter cgGetSamplerStateAssignmentParameter(CGstateassignment);
+
+CGDLL_API const float *cgGetFloatStateAssignmentValues(CGstateassignment, int *nVals);
+CGDLL_API const int *cgGetIntStateAssignmentValues(CGstateassignment, int *nVals);
+CGDLL_API const CGbool *cgGetBoolStateAssignmentValues(CGstateassignment, int *nVals);
+CGDLL_API const char *cgGetStringStateAssignmentValue(CGstateassignment);
+CGDLL_API CGprogram cgGetProgramStateAssignmentValue(CGstateassignment);
+CGDLL_API CGparameter cgGetTextureStateAssignmentValue(CGstateassignment);
+CGDLL_API CGparameter cgGetSamplerStateAssignmentValue(CGstateassignment);
+CGDLL_API int cgGetStateAssignmentIndex(CGstateassignment);
+
+CGDLL_API int cgGetNumDependentStateAssignmentParameters(CGstateassignment);
+CGDLL_API CGparameter cgGetDependentStateAssignmentParameter(CGstateassignment, int index);
+
+CGDLL_API CGstate cgGetStateAssignmentState(CGstateassignment);
+CGDLL_API CGstate cgGetSamplerStateAssignmentState(CGstateassignment);
+
+CGDLL_API CGstate cgCreateState(CGcontext, const char *name, CGtype);
+CGDLL_API CGstate cgCreateArrayState(CGcontext, const char *name, CGtype, int nelems);
+CGDLL_API void cgSetStateCallbacks(CGstate, CGstatecallback set, CGstatecallback reset,
+                                   CGstatecallback validate);
+CGDLL_API CGstatecallback cgGetStateSetCallback(CGstate);
+CGDLL_API CGstatecallback cgGetStateResetCallback(CGstate);
+CGDLL_API CGstatecallback cgGetStateValidateCallback(CGstate);
+CGDLL_API CGtype cgGetStateType(CGstate);
+CGDLL_API const char *cgGetStateName(CGstate);
+CGDLL_API CGstate cgGetNamedState(CGcontext, const char *name);
+CGDLL_API CGstate cgGetFirstState(CGcontext);
+CGDLL_API CGstate cgGetNextState(CGstate);
+CGDLL_API CGbool cgIsState(CGstate);
+CGDLL_API void cgAddStateEnumerant(CGstate, const char *name, int value);
+
+CGDLL_API CGstate cgCreateSamplerState(CGcontext, const char *name, CGtype);
+CGDLL_API CGstate cgCreateArraySamplerState(CGcontext, const char *name, CGtype, int nelems);
+CGDLL_API CGstate cgGetNamedSamplerState(CGcontext, const char *name);
+CGDLL_API CGstate cgGetFirstSamplerState(CGcontext);
+
+CGDLL_API CGstateassignment cgGetFirstSamplerStateAssignment(CGparameter);
+CGDLL_API CGstateassignment cgGetNamedSamplerStateAssignment(CGparameter, const char *);
+CGDLL_API void cgSetSamplerState(CGparameter);
+
+CGDLL_API CGparameter cgGetNamedEffectParameter(CGeffect, const char *);
+CGDLL_API CGparameter cgGetFirstLeafEffectParameter(CGeffect);
+CGDLL_API CGparameter cgGetFirstEffectParameter(CGeffect);
+CGDLL_API CGparameter cgGetEffectParameterBySemantic(CGeffect, const char *);
+
+CGDLL_API CGannotation cgGetFirstTechniqueAnnotation(CGtechnique);
+CGDLL_API CGannotation cgGetFirstPassAnnotation(CGpass);
+CGDLL_API CGannotation cgGetFirstParameterAnnotation(CGparameter);
+CGDLL_API CGannotation cgGetFirstProgramAnnotation(CGprogram);
+CGDLL_API CGannotation cgGetNextAnnotation(CGannotation);
+
+CGDLL_API CGannotation cgGetNamedTechniqueAnnotation(CGtechnique, const char *);
+CGDLL_API CGannotation cgGetNamedPassAnnotation(CGpass, const char *);
+CGDLL_API CGannotation cgGetNamedParameterAnnotation(CGparameter, const char *);
+CGDLL_API CGannotation cgGetNamedProgramAnnotation(CGprogram, const char *);
+
+CGDLL_API CGbool cgIsAnnotation(CGannotation);
+
+CGDLL_API const char *cgGetAnnotationName(CGannotation);
+CGDLL_API CGtype cgGetAnnotationType(CGannotation);
+
+CGDLL_API const float *cgGetFloatAnnotationValues(CGannotation, int *nvalues);
+CGDLL_API const int *cgGetIntAnnotationValues(CGannotation, int *nvalues);
+CGDLL_API const char *cgGetStringAnnotationValue(CGannotation);
+CGDLL_API const int *cgGetBooleanAnnotationValues(CGannotation, int *nvalues);
+
+CGDLL_API int cgGetNumDependentAnnotationParameters(CGannotation);
+CGDLL_API CGparameter cgGetDependentAnnotationParameter(CGannotation, int index);
+
+CGDLL_API void cgEvaluateProgram(CGprogram, float *, int ncomps, int nx, int ny, int nz);
 
 #endif
 
@@ -367,5 +538,4 @@ CGDLL_API CGparameter cgGetNextLeafParameter_depr1_1(CGparameter current);
 }
 #endif
 
-
 #endif
diff --git a/make/stub_includes/cg/CG/cg_datatypes.h b/make/stub_includes/cg/CG/cg_datatypes.h
index a728ca638..2eb0ff85a 100644
--- a/make/stub_includes/cg/CG/cg_datatypes.h
+++ b/make/stub_includes/cg/CG/cg_datatypes.h
@@ -69,124 +69,124 @@
  *     compiler_name : The name of the data type within the compiler syntax.
  *     enum_name     : The C enumerant.
  *     nrows         : Number of rows for matrix types.  Should be 0 other-wise.
- *     ncols         : Number of columns for matrix types.  Should be 0 
- *                     other-wise.
+ *     ncols         : Number of columns for scalar, vector, and matrix types.
  *   
  */
 
 
 
-/*CG_DATATYPE_MACRO(Half,half,*/CG_HALF,//0,1)
-/*CG_DATATYPE_MACRO(Half2,half2,*/CG_HALF2,//0,2)
-/*CG_DATATYPE_MACRO(Half3,half3,*/CG_HALF3,//0,3)
-/*CG_DATATYPE_MACRO(Half4,half4,*/CG_HALF4,//0,4)
-/*CG_DATATYPE_MACRO(Half1x1,half1x1,*/CG_HALF1x1,//1,1)
-/*CG_DATATYPE_MACRO(Half1x2,half1x2,*/CG_HALF1x2,//1,2)
-/*CG_DATATYPE_MACRO(Half1x3,half1x3,*/CG_HALF1x3,//1,3)
-/*CG_DATATYPE_MACRO(Half1x4,half1x4,*/CG_HALF1x4,//1,4)
-/*CG_DATATYPE_MACRO(Half2x1,half2x1,*/CG_HALF2x1,//2,1)
-/*CG_DATATYPE_MACRO(Half2x2,half2x2,*/CG_HALF2x2,//2,2)
-/*CG_DATATYPE_MACRO(Half2x3,half2x3,*/CG_HALF2x3,//2,3)
-/*CG_DATATYPE_MACRO(Half2x4,half2x4,*/CG_HALF2x4,//2,4)
-/*CG_DATATYPE_MACRO(Half3x1,half3x1,*/CG_HALF3x1,//3,1)
-/*CG_DATATYPE_MACRO(Half3x2,half3x2,*/CG_HALF3x2,//3,2)
-/*CG_DATATYPE_MACRO(Half3x3,half3x3,*/CG_HALF3x3,//3,3)
-/*CG_DATATYPE_MACRO(Half3x4,half3x4,*/CG_HALF3x4,//3,4)
-/*CG_DATATYPE_MACRO(Half4x1,half4x1,*/CG_HALF4x1,//4,1)
-/*CG_DATATYPE_MACRO(Half4x2,half4x2,*/CG_HALF4x2,//4,2)
-/*CG_DATATYPE_MACRO(Half4x3,half4x3,*/CG_HALF4x3,//4,3)
-/*CG_DATATYPE_MACRO(Half4x4,half4x4,*/CG_HALF4x4,//4,4)
-/*CG_DATATYPE_MACRO(Float,float,*/CG_FLOAT,//0,1)
-/*CG_DATATYPE_MACRO(Float2,float2,*/CG_FLOAT2,//0,2)
-/*CG_DATATYPE_MACRO(Float3,float3,*/CG_FLOAT3,//0,3)
-/*CG_DATATYPE_MACRO(Float4,float4,*/CG_FLOAT4,//0,4)
-/*CG_DATATYPE_MACRO(Float1x1,float1x1,*/CG_FLOAT1x1,//1,1)
-/*CG_DATATYPE_MACRO(Float1x2,float1x2,*/CG_FLOAT1x2,//1,2)
-/*CG_DATATYPE_MACRO(Float1x3,float1x3,*/CG_FLOAT1x3,//1,3)
-/*CG_DATATYPE_MACRO(Float1x4,float1x4,*/CG_FLOAT1x4,//1,4)
-/*CG_DATATYPE_MACRO(Float2x1,float2x1,*/CG_FLOAT2x1,//2,1)
-/*CG_DATATYPE_MACRO(Float2x2,float2x2,*/CG_FLOAT2x2,//2,2)
-/*CG_DATATYPE_MACRO(Float2x3,float2x3,*/CG_FLOAT2x3,//2,3)
-/*CG_DATATYPE_MACRO(Float2x4,float2x4,*/CG_FLOAT2x4,//2,4)
-/*CG_DATATYPE_MACRO(Float3x1,float3x1,*/CG_FLOAT3x1,//3,1)
-/*CG_DATATYPE_MACRO(Float3x2,float3x2,*/CG_FLOAT3x2,//3,2)
-/*CG_DATATYPE_MACRO(Float3x3,float3x3,*/CG_FLOAT3x3,//3,3)
-/*CG_DATATYPE_MACRO(Float3x4,float3x4,*/CG_FLOAT3x4,//3,4)
-/*CG_DATATYPE_MACRO(Float4x1,float4x1,*/CG_FLOAT4x1,//4,1)
-/*CG_DATATYPE_MACRO(Float4x2,float4x2,*/CG_FLOAT4x2,//4,2)
-/*CG_DATATYPE_MACRO(Float4x3,float4x3,*/CG_FLOAT4x3,//4,3)
-/*CG_DATATYPE_MACRO(Float4x4,float4x4,*/CG_FLOAT4x4,//4,4)
-/*CG_DATATYPE_MACRO(Sampler1D,sampler1D,*/CG_SAMPLER1D,//0,0)
-/*CG_DATATYPE_MACRO(Sampler2D,sampler2D,*/CG_SAMPLER2D,//0,0)
-/*CG_DATATYPE_MACRO(Sampler3D,sampler3D,*/CG_SAMPLER3D,//0,0)
-/*CG_DATATYPE_MACRO(SamplerRECT,samplerRECT,*/CG_SAMPLERRECT,//0,0)
-/*CG_DATATYPE_MACRO(SamplerCUBE,samplerCUBE,*/CG_SAMPLERCUBE,//0,0)
-/*CG_DATATYPE_MACRO(Fixed,fixed,*/CG_FIXED,//0,1)
-/*CG_DATATYPE_MACRO(Fixed2,fixed2,*/CG_FIXED2,//0,2)
-/*CG_DATATYPE_MACRO(Fixed3,fixed3,*/CG_FIXED3,//0,3)
-/*CG_DATATYPE_MACRO(Fixed4,fixed4,*/CG_FIXED4,//0,4)
-/*CG_DATATYPE_MACRO(Fixed1x1,fixed1x1,*/CG_FIXED1x1,//1,1)
-/*CG_DATATYPE_MACRO(Fixed1x2,fixed1x2,*/CG_FIXED1x2,//1,2)
-/*CG_DATATYPE_MACRO(Fixed1x3,fixed1x3,*/CG_FIXED1x3,//1,3)
-/*CG_DATATYPE_MACRO(Fixed1x4,fixed1x4,*/CG_FIXED1x4,//1,4)
-/*CG_DATATYPE_MACRO(Fixed2x1,fixed2x1,*/CG_FIXED2x1,//2,1)
-/*CG_DATATYPE_MACRO(Fixed2x2,fixed2x2,*/CG_FIXED2x2,//2,2)
-/*CG_DATATYPE_MACRO(Fixed2x3,fixed2x3,*/CG_FIXED2x3,//2,3)
-/*CG_DATATYPE_MACRO(Fixed2x4,fixed2x4,*/CG_FIXED2x4,//2,4)
-/*CG_DATATYPE_MACRO(Fixed3x1,fixed3x1,*/CG_FIXED3x1,//3,1)
-/*CG_DATATYPE_MACRO(Fixed3x2,fixed3x2,*/CG_FIXED3x2,//3,2)
-/*CG_DATATYPE_MACRO(Fixed3x3,fixed3x3,*/CG_FIXED3x3,//3,3)
-/*CG_DATATYPE_MACRO(Fixed3x4,fixed3x4,*/CG_FIXED3x4,//3,4)
-/*CG_DATATYPE_MACRO(Fixed4x1,fixed4x1,*/CG_FIXED4x1,//4,1)
-/*CG_DATATYPE_MACRO(Fixed4x2,fixed4x2,*/CG_FIXED4x2,//4,2)
-/*CG_DATATYPE_MACRO(Fixed4x3,fixed4x3,*/CG_FIXED4x3,//4,3)
-/*CG_DATATYPE_MACRO(Fixed4x4,fixed4x4,*/CG_FIXED4x4,//4,4)
-/*CG_DATATYPE_MACRO(Half1,half1,*/CG_HALF1,//0,1)
-/*CG_DATATYPE_MACRO(Float1,float1,*/CG_FLOAT1,//0,1)
-/*CG_DATATYPE_MACRO(Fixed1,fixed1,*/CG_FIXED1,//0,1)
-/*CG_DATATYPE_MACRO(Int,int,*/CG_INT,//0,1)
-/*CG_DATATYPE_MACRO(Int1,int1,*/CG_INT1,//0,1)
-/*CG_DATATYPE_MACRO(Int2,int2,*/CG_INT2,//0,2)
-/*CG_DATATYPE_MACRO(Int3,int3,*/CG_INT3,//0,3)
-/*CG_DATATYPE_MACRO(Int4,int4,*/CG_INT4,//0,4)
-/*CG_DATATYPE_MACRO(Int1x1,int1x1,*/CG_INT1x1,//1,1)
-/*CG_DATATYPE_MACRO(Int1x2,int1x2,*/CG_INT1x2,//1,2)
-/*CG_DATATYPE_MACRO(Int1x3,int1x3,*/CG_INT1x3,//1,3)
-/*CG_DATATYPE_MACRO(Int1x4,int1x4,*/CG_INT1x4,//1,4)
-/*CG_DATATYPE_MACRO(Int2x1,int2x1,*/CG_INT2x1,//2,1)
-/*CG_DATATYPE_MACRO(Int2x2,int2x2,*/CG_INT2x2,//2,2)
-/*CG_DATATYPE_MACRO(Int2x3,int2x3,*/CG_INT2x3,//2,3)
-/*CG_DATATYPE_MACRO(Int2x4,int2x4,*/CG_INT2x4,//2,4)
-/*CG_DATATYPE_MACRO(Int3x1,int3x1,*/CG_INT3x1,//3,1)
-/*CG_DATATYPE_MACRO(Int3x2,int3x2,*/CG_INT3x2,//3,2)
-/*CG_DATATYPE_MACRO(Int3x3,int3x3,*/CG_INT3x3,//3,3)
-/*CG_DATATYPE_MACRO(Int3x4,int3x4,*/CG_INT3x4,//3,4)
-/*CG_DATATYPE_MACRO(Int4x1,int4x1,*/CG_INT4x1,//4,1)
-/*CG_DATATYPE_MACRO(Int4x2,int4x2,*/CG_INT4x2,//4,2)
-/*CG_DATATYPE_MACRO(Int4x3,int4x3,*/CG_INT4x3,//4,3)
-/*CG_DATATYPE_MACRO(Int4x4,int4x4,*/CG_INT4x4,//4,4)
-/*CG_DATATYPE_MACRO(Bool,bool,*/CG_BOOL,//0,1)
-/*CG_DATATYPE_MACRO(Bool1,bool1,*/CG_BOOL1,//0,1)
-/*CG_DATATYPE_MACRO(Bool2,bool2,*/CG_BOOL2,//0,2)
-/*CG_DATATYPE_MACRO(Bool3,bool3,*/CG_BOOL3,//0,3)
-/*CG_DATATYPE_MACRO(Bool4,bool4,*/CG_BOOL4,//0,4)
-/*CG_DATATYPE_MACRO(Bool1x1,bool1x1,*/CG_BOOL1x1,//1,1)
-/*CG_DATATYPE_MACRO(Bool1x2,bool1x2,*/CG_BOOL1x2,//1,2)
-/*CG_DATATYPE_MACRO(Bool1x3,bool1x3,*/CG_BOOL1x3,//1,3)
-/*CG_DATATYPE_MACRO(Bool1x4,bool1x4,*/CG_BOOL1x4,//1,4)
-/*CG_DATATYPE_MACRO(Bool2x1,bool2x1,*/CG_BOOL2x1,//2,1)
-/*CG_DATATYPE_MACRO(Bool2x2,bool2x2,*/CG_BOOL2x2,//2,2)
-/*CG_DATATYPE_MACRO(Bool2x3,bool2x3,*/CG_BOOL2x3,//2,3)
-/*CG_DATATYPE_MACRO(Bool2x4,bool2x4,*/CG_BOOL2x4,//2,4)
-/*CG_DATATYPE_MACRO(Bool3x1,bool3x1,*/CG_BOOL3x1,//3,1)
-/*CG_DATATYPE_MACRO(Bool3x2,bool3x2,*/CG_BOOL3x2,//3,2)
-/*CG_DATATYPE_MACRO(Bool3x3,bool3x3,*/CG_BOOL3x3,//3,3)
-/*CG_DATATYPE_MACRO(Bool3x4,bool3x4,*/CG_BOOL3x4,//3,4)
-/*CG_DATATYPE_MACRO(Bool4x1,bool4x1,*/CG_BOOL4x1,//4,1)
-/*CG_DATATYPE_MACRO(Bool4x2,bool4x2,*/CG_BOOL4x2,//4,2)
-/*CG_DATATYPE_MACRO(Bool4x3,bool4x3,*/CG_BOOL4x3,//4,3)
-/*CG_DATATYPE_MACRO(Bool4x4,bool4x4,*/CG_BOOL4x4,//4,4)
+/*CG_DATATYPE_MACRO(Half,half,*/CG_HALF,//CG_HALF,0,1,CG_PARAMETERCLASS_SCALAR)
+/*CG_DATATYPE_MACRO(Half2,half2,*/CG_HALF2,//CG_HALF,0,2,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Half3,half3,*/CG_HALF3,//CG_HALF,0,3,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Half4,half4,*/CG_HALF4,//CG_HALF,0,4,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Half1x1,half1x1,*/CG_HALF1x1,//CG_HALF,1,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half1x2,half1x2,*/CG_HALF1x2,//CG_HALF,1,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half1x3,half1x3,*/CG_HALF1x3,//CG_HALF,1,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half1x4,half1x4,*/CG_HALF1x4,//CG_HALF,1,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half2x1,half2x1,*/CG_HALF2x1,//CG_HALF,2,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half2x2,half2x2,*/CG_HALF2x2,//CG_HALF,2,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half2x3,half2x3,*/CG_HALF2x3,//CG_HALF,2,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half2x4,half2x4,*/CG_HALF2x4,//CG_HALF,2,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half3x1,half3x1,*/CG_HALF3x1,//CG_HALF,3,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half3x2,half3x2,*/CG_HALF3x2,//CG_HALF,3,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half3x3,half3x3,*/CG_HALF3x3,//CG_HALF,3,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half3x4,half3x4,*/CG_HALF3x4,//CG_HALF,3,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half4x1,half4x1,*/CG_HALF4x1,//CG_HALF,4,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half4x2,half4x2,*/CG_HALF4x2,//CG_HALF,4,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half4x3,half4x3,*/CG_HALF4x3,//CG_HALF,4,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half4x4,half4x4,*/CG_HALF4x4,//CG_HALF,4,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float,float,*/CG_FLOAT,//CG_FLOAT,0,1,CG_PARAMETERCLASS_SCALAR)
+/*CG_DATATYPE_MACRO(Float2,float2,*/CG_FLOAT2,//CG_FLOAT,0,2,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Float3,float3,*/CG_FLOAT3,//CG_FLOAT,0,3,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Float4,float4,*/CG_FLOAT4,//CG_FLOAT,0,4,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Float1x1,float1x1,*/CG_FLOAT1x1,//CG_FLOAT,1,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float1x2,float1x2,*/CG_FLOAT1x2,//CG_FLOAT,1,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float1x3,float1x3,*/CG_FLOAT1x3,//CG_FLOAT,1,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float1x4,float1x4,*/CG_FLOAT1x4,//CG_FLOAT,1,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float2x1,float2x1,*/CG_FLOAT2x1,//CG_FLOAT,2,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float2x2,float2x2,*/CG_FLOAT2x2,//CG_FLOAT,2,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float2x3,float2x3,*/CG_FLOAT2x3,//CG_FLOAT,2,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float2x4,float2x4,*/CG_FLOAT2x4,//CG_FLOAT,2,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float3x1,float3x1,*/CG_FLOAT3x1,//CG_FLOAT,3,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float3x2,float3x2,*/CG_FLOAT3x2,//CG_FLOAT,3,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float3x3,float3x3,*/CG_FLOAT3x3,//CG_FLOAT,3,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float3x4,float3x4,*/CG_FLOAT3x4,//CG_FLOAT,3,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float4x1,float4x1,*/CG_FLOAT4x1,//CG_FLOAT,4,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float4x2,float4x2,*/CG_FLOAT4x2,//CG_FLOAT,4,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float4x3,float4x3,*/CG_FLOAT4x3,//CG_FLOAT,4,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Float4x4,float4x4,*/CG_FLOAT4x4,//CG_FLOAT,4,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Sampler1D,sampler1D,*/CG_SAMPLER1D,//CG_SAMPLER1D,0,0,CG_PARAMETERCLASS_SAMPLER)
+/*CG_DATATYPE_MACRO(Sampler2D,sampler2D,*/CG_SAMPLER2D,//CG_SAMPLER2D,0,0,CG_PARAMETERCLASS_SAMPLER)
+/*CG_DATATYPE_MACRO(Sampler3D,sampler3D,*/CG_SAMPLER3D,//CG_SAMPLER3D,0,0,CG_PARAMETERCLASS_SAMPLER)
+/*CG_DATATYPE_MACRO(SamplerRECT,samplerRECT,*/CG_SAMPLERRECT,//CG_SAMPLERRECT,0,0,CG_PARAMETERCLASS_SAMPLER)
+/*CG_DATATYPE_MACRO(SamplerCUBE,samplerCUBE,*/CG_SAMPLERCUBE,//CG_SAMPLERCUBE,0,0,CG_PARAMETERCLASS_SAMPLER)
+/*CG_DATATYPE_MACRO(Fixed,fixed,*/CG_FIXED,//CG_FIXED,0,1,CG_PARAMETERCLASS_SCALAR)
+/*CG_DATATYPE_MACRO(Fixed2,fixed2,*/CG_FIXED2,//CG_FIXED,0,2,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Fixed3,fixed3,*/CG_FIXED3,//CG_FIXED,0,3,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Fixed4,fixed4,*/CG_FIXED4,//CG_FIXED,0,4,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Fixed1x1,fixed1x1,*/CG_FIXED1x1,//CG_FIXED,1,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed1x2,fixed1x2,*/CG_FIXED1x2,//CG_FIXED,1,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed1x3,fixed1x3,*/CG_FIXED1x3,//CG_FIXED,1,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed1x4,fixed1x4,*/CG_FIXED1x4,//CG_FIXED,1,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed2x1,fixed2x1,*/CG_FIXED2x1,//CG_FIXED,2,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed2x2,fixed2x2,*/CG_FIXED2x2,//CG_FIXED,2,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed2x3,fixed2x3,*/CG_FIXED2x3,//CG_FIXED,2,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed2x4,fixed2x4,*/CG_FIXED2x4,//CG_FIXED,2,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed3x1,fixed3x1,*/CG_FIXED3x1,//CG_FIXED,3,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed3x2,fixed3x2,*/CG_FIXED3x2,//CG_FIXED,3,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed3x3,fixed3x3,*/CG_FIXED3x3,//CG_FIXED,3,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed3x4,fixed3x4,*/CG_FIXED3x4,//CG_FIXED,3,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed4x1,fixed4x1,*/CG_FIXED4x1,//CG_FIXED,4,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed4x2,fixed4x2,*/CG_FIXED4x2,//CG_FIXED,4,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed4x3,fixed4x3,*/CG_FIXED4x3,//CG_FIXED,4,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Fixed4x4,fixed4x4,*/CG_FIXED4x4,//CG_FIXED,4,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Half1,half1,*/CG_HALF1,//CG_HALF,0,1,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Float1,float1,*/CG_FLOAT1,//CG_FLOAT,0,1,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Fixed1,fixed1,*/CG_FIXED1,//CG_FIXED,0,1,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Int,int,*/CG_INT,//CG_INT,0,1,CG_PARAMETERCLASS_SCALAR)
+/*CG_DATATYPE_MACRO(Int1,int1,*/CG_INT1,//CG_INT,0,1,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Int2,int2,*/CG_INT2,//CG_INT,0,2,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Int3,int3,*/CG_INT3,//CG_INT,0,3,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Int4,int4,*/CG_INT4,//CG_INT,0,4,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Int1x1,int1x1,*/CG_INT1x1,//CG_INT,1,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int1x2,int1x2,*/CG_INT1x2,//CG_INT,1,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int1x3,int1x3,*/CG_INT1x3,//CG_INT,1,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int1x4,int1x4,*/CG_INT1x4,//CG_INT,1,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int2x1,int2x1,*/CG_INT2x1,//CG_INT,2,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int2x2,int2x2,*/CG_INT2x2,//CG_INT,2,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int2x3,int2x3,*/CG_INT2x3,//CG_INT,2,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int2x4,int2x4,*/CG_INT2x4,//CG_INT,2,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int3x1,int3x1,*/CG_INT3x1,//CG_INT,3,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int3x2,int3x2,*/CG_INT3x2,//CG_INT,3,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int3x3,int3x3,*/CG_INT3x3,//CG_INT,3,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int3x4,int3x4,*/CG_INT3x4,//CG_INT,3,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int4x1,int4x1,*/CG_INT4x1,//CG_INT,4,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int4x2,int4x2,*/CG_INT4x2,//CG_INT,4,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int4x3,int4x3,*/CG_INT4x3,//CG_INT,4,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Int4x4,int4x4,*/CG_INT4x4,//CG_INT,4,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool,bool,*/CG_BOOL,//CG_BOOL,0,1,CG_PARAMETERCLASS_SCALAR)
+/*CG_DATATYPE_MACRO(Bool1,bool1,*/CG_BOOL1,//CG_BOOL,0,1,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Bool2,bool2,*/CG_BOOL2,//CG_BOOL,0,2,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Bool3,bool3,*/CG_BOOL3,//CG_BOOL,0,3,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Bool4,bool4,*/CG_BOOL4,//CG_BOOL,0,4,CG_PARAMETERCLASS_VECTOR)
+/*CG_DATATYPE_MACRO(Bool1x1,bool1x1,*/CG_BOOL1x1,//CG_BOOL,1,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool1x2,bool1x2,*/CG_BOOL1x2,//CG_BOOL,1,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool1x3,bool1x3,*/CG_BOOL1x3,//CG_BOOL,1,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool1x4,bool1x4,*/CG_BOOL1x4,//CG_BOOL,1,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool2x1,bool2x1,*/CG_BOOL2x1,//CG_BOOL,2,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool2x2,bool2x2,*/CG_BOOL2x2,//CG_BOOL,2,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool2x3,bool2x3,*/CG_BOOL2x3,//CG_BOOL,2,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool2x4,bool2x4,*/CG_BOOL2x4,//CG_BOOL,2,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool3x1,bool3x1,*/CG_BOOL3x1,//CG_BOOL,3,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool3x2,bool3x2,*/CG_BOOL3x2,//CG_BOOL,3,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool3x3,bool3x3,*/CG_BOOL3x3,//CG_BOOL,3,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool3x4,bool3x4,*/CG_BOOL3x4,//CG_BOOL,3,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool4x1,bool4x1,*/CG_BOOL4x1,//CG_BOOL,4,1,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool4x2,bool4x2,*/CG_BOOL4x2,//CG_BOOL,4,2,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool4x3,bool4x3,*/CG_BOOL4x3,//CG_BOOL,4,3,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(Bool4x4,bool4x4,*/CG_BOOL4x4,//CG_BOOL,4,4,CG_PARAMETERCLASS_MATRIX)
+/*CG_DATATYPE_MACRO(String,string,*/CG_STRING,//CG_STRING,0,1,CG_PARAMETERCLASS_OBJECT)
+/*CG_DATATYPE_MACRO(Program,program,*/CG_PROGRAM_TYPE,//CG_PROGRAM_TYPE,0,0,CG_PARAMETERCLASS_OBJECT)
+/*CG_DATATYPE_MACRO(Texture,texture,*/CG_TEXTURE,//CG_TEXTURE,0,0,CG_PARAMETERCLASS_OBJECT)
 
 //#undef CG_DATATYPE_MACRO
-
-
diff --git a/make/stub_includes/cg/CG/cg_enums.h b/make/stub_includes/cg/CG/cg_enums.h
index 24d97a320..cb7262feb 100755
--- a/make/stub_includes/cg/CG/cg_enums.h
+++ b/make/stub_includes/cg/CG/cg_enums.h
@@ -89,7 +89,9 @@
 /*CG_ENUM_MACRO(*/CG_CURRENT=/*, */4117,//)
 /*CG_ENUM_MACRO(*/CG_LITERAL=/*, */4118,//)
 /*CG_ENUM_MACRO(*/CG_VERSION=/*, */4119,//)
+/*CG_ENUM_MACRO(*/CG_ROW_MAJOR=/*, */4120,//)
+/*CG_ENUM_MACRO(*/CG_COLUMN_MAJOR=/*, */4121,//)
 
-#undef CG_ENUM_MACRO
+// #undef CG_ENUM_MACRO
 
 
diff --git a/make/stub_includes/cg/CG/cg_errors.h b/make/stub_includes/cg/CG/cg_errors.h
index 2ad510f8f..c785da252 100644
--- a/make/stub_includes/cg/CG/cg_errors.h
+++ b/make/stub_includes/cg/CG/cg_errors.h
@@ -8,7 +8,7 @@
 
 /*
  *
- * Copyright (c) 2002, NVIDIA Corporation.
+ * Copyright (c) 2002-2004, NVIDIA Corporation.
  * 
  *  
  * 
@@ -278,5 +278,70 @@ CG_TYPE_IS_NOT_DEFINED_IN_PROGRAM_ERROR=
                "source parameter is not defined within the given program "
                "or does not match the type with the same name in the program.")*/
 
+CG_INVALID_EFFECT_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/40,/*
+               CG_INVALID_EFFECT_HANDLE_ERROR,
+               "Invalid effect handle.")*/
+
+CG_INVALID_STATE_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/41,/*
+               CG_INVALID_STATE_HANDLE_ERROR,
+               "Invalid state handle.")*/
+
+CG_INVALID_STATE_ASSIGNMENT_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/42,/*
+               CG_INVALID_STATE_ASSIGNMENT_HANDLE_ERROR,
+               "Invalid stateassignment handle.")*/
+
+CG_INVALID_PASS_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/43,/*
+               CG_INVALID_PASS_HANDLE_ERROR,
+               "Invalid pass handle.")*/
+
+CG_INVALID_ANNOTATION_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/44,/*
+               CG_INVALID_ANNOTATION_HANDLE_ERROR,
+               "Invalid annotation handle.")*/
+
+CG_INVALID_TECHNIQUE_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/45,/*
+               CG_INVALID_TECHNIQUE_HANDLE_ERROR,
+               "Invalid technique handle.")*/
+
+CG_INVALID_PARAMETER_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/46,/*
+               CG_INVALID_PARAMETER_HANDLE_ERROR,
+               "Invalid parameter handle.")*/
+
+CG_STATE_ASSIGNMENT_TYPE_MISMATCH_ERROR=
+/*CG_ERROR_MACRO(*/47,/*
+               CG_STATE_ASSIGNMENT_TYPE_MISMATCH_ERROR,
+               "Invalid parameter handle.")*/
+
+CG_INVALID_FUNCTION_HANDLE_ERROR=
+/*CG_ERROR_MACRO(*/48,/*
+               CG_INVALID_FUNCTION_HANDLE_ERROR,
+               "Invalid function handle.")*/
+
+CG_INVALID_TECHNIQUE_ERROR=
+/*CG_ERROR_MACRO(*/49,/*
+               CG_INVALID_TECHNIQUE_ERROR,
+               "Technique did not pass validation.")*/
+
+CG_INVALID_POINTER_ERROR=
+/*CG_ERROR_MACRO(*/50,/*
+               CG_INVALID_POINTER_ERROR,
+               "The supplied pointer is NULL.")*/
+
+CG_NOT_ENOUGH_DATA_ERROR=
+/*CG_ERROR_MACRO(*/51,/*
+               CG_NOT_ENOUGH_DATA_ERROR,
+               "Not enough data was provided.")*/
+
+CG_NON_NUMERIC_PARAMETER_ERROR=
+/*CG_ERROR_MACRO(*/52,/*
+               CG_NON_NUMERIC_PARAMETER_ERROR,
+               "The parameter is not of a numeric type.")*/
+
 //#undef CG_ERROR_MACRO
 
diff --git a/make/stub_includes/cg/CG/cg_profiles.h b/make/stub_includes/cg/CG/cg_profiles.h
index c77f45229..8217a569a 100644
--- a/make/stub_includes/cg/CG/cg_profiles.h
+++ b/make/stub_includes/cg/CG/cg_profiles.h
@@ -91,6 +91,7 @@
 /*CG_PROFILE_MACRO(DX9Pixel20,ps_2_0,*/CG_PROFILE_PS_2_0=/*,"ps_2_0",*/6162,//0)
 /*CG_PROFILE_MACRO(DX9Pixel2x,ps_2_x,*/CG_PROFILE_PS_2_X=/*,"ps_2_x",*/6163,//0)
 
+/*CG_PROFILE_MACRO(Generic,           generic,*/ GENERIC=/*, "generic",*/ 7002,//0)
 
 //#undef CG_PROFILE_MACRO
 #undef CG_IN_PROFILES_INCLUDE
diff --git a/make/stub_includes/macosx/cglext.c b/make/stub_includes/macosx/cglext.c
new file mode 100755
index 000000000..14010fcc4
--- /dev/null
+++ b/make/stub_includes/macosx/cglext.c
@@ -0,0 +1 @@
+#include <cglext.h>
diff --git a/make/stub_includes/win32/wglext.c b/make/stub_includes/win32/wglext.c
new file mode 100755
index 000000000..9c6120411
--- /dev/null
+++ b/make/stub_includes/win32/wglext.c
@@ -0,0 +1,13 @@
+#define GLAPI
+
+// Define GL_GLEXT_PROTOTYPES so that the OpenGL extension prototypes in
+// "glext.h" are parsed.
+#define GL_GLEXT_PROTOTYPES
+
+#include <GL/gl.h>
+
+// Bring in the wgl extensions
+#define WGL_WGLEXT_PROTOTYPES
+#define SKIP_WGL_HANDLE_DEFINITIONS
+#include <windows.h>
+#include <GL/wglext.h>
diff --git a/make/stub_includes/win32/windows.h b/make/stub_includes/win32/windows.h
index fa4ae1c95..e2d78deef 100644
--- a/make/stub_includes/win32/windows.h
+++ b/make/stub_includes/win32/windows.h
@@ -4,6 +4,7 @@
 #define FAR
 #define WINBASEAPI
 #define WINGDIAPI
+#define WINUSERAPI
 #define WINAPI
 #define APIENTRY
 #define CONST const
diff --git a/make/stub_includes/win32/wingdi.h b/make/stub_includes/win32/wingdi.h
index 2141135e7..35f754178 100644
--- a/make/stub_includes/win32/wingdi.h
+++ b/make/stub_includes/win32/wingdi.h
@@ -144,6 +144,25 @@ typedef struct tagPIXELFORMATDESCRIPTOR
 #define ERROR_PROC_NOT_FOUND             127
 #define ERROR_INVALID_WINDOW_HANDLE      1400
 
+/*
+ * ShowWindow() Commands
+ */
+#define SW_HIDE             0
+#define SW_SHOWNORMAL       1
+#define SW_NORMAL           1
+#define SW_SHOWMINIMIZED    2
+#define SW_SHOWMAXIMIZED    3
+#define SW_MAXIMIZE         3
+#define SW_SHOWNOACTIVATE   4
+#define SW_SHOW             5
+#define SW_MINIMIZE         6
+#define SW_SHOWMINNOACTIVE  7
+#define SW_SHOWNA           8
+#define SW_RESTORE          9
+#define SW_SHOWDEFAULT      10
+#define SW_FORCEMINIMIZE    11
+#define SW_MAX              11
+
 // Windows routines
 WINBASEAPI DWORD WINAPI GetLastError(VOID);
 WINBASEAPI HMODULE WINAPI LoadLibraryA(LPCSTR lpLibFileName);
@@ -183,10 +202,11 @@ WINGDIAPI BOOL    WINAPI DeleteDC(HDC);
 WINGDIAPI BOOL    WINAPI DeleteObject(HGDIOBJ);
 WINGDIAPI HGDIOBJ WINAPI SelectObject(HDC, HGDIOBJ);
 
-// Routines for creation of a dummy device context and OpenGL context
-// for the purposes of getting wglChoosePixelFormatARB and associated
-// routines
-WINGDIAPI HDC     WINAPI GetDC(HDC);
-WINGDIAPI HDC     WINAPI CreateDummyWindow(int,int,int,int);
-WINGDIAPI VOID    WINAPI DestroyDummyWindow(HWND,HDC);
-WINGDIAPI VOID    WINAPI NativeEventLoop();
+// Routines for creation of a dummy window, device context and OpenGL
+// context for the purposes of getting wglChoosePixelFormatARB and
+// associated routines
+HDC                    CreateDummyWindow(int,int,int,int);
+WINUSERAPI BOOL WINAPI ShowWindow(HWND hWnd, int nCmdShow);
+WINUSERAPI HDC  WINAPI GetDC(HWND);
+WINUSERAPI int  WINAPI ReleaseDC(HWND hWnd, HDC hDC);
+WINUSERAPI BOOL WINAPI DestroyWindow(HWND hWnd);
diff --git a/make/stub_includes/common/gl-impl.c b/make/stub_includes/x11/glxext.c
index 53221a21a..67906a088 100644
--- a/make/stub_includes/common/gl-impl.c
+++ b/make/stub_includes/x11/glxext.c
@@ -12,12 +12,3 @@
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <GL/glxext.h>
-
-// Bring in the wgl extensions
-#define WGL_WGLEXT_PROTOTYPES
-#define SKIP_WGL_HANDLE_DEFINITIONS
-#include <windows.h>
-#include <GL/wglext.h>
-
-// Bring in the Mac OS X cgl extensions
-#include <GL/cglext.h>