diff --git a/ps3/rgl/include/Cg/CgCommon.h b/ps3/rgl/include/Cg/CgCommon.h index 2bd5ca6385..b7fa56afcf 100644 --- a/ps3/rgl/include/Cg/CgCommon.h +++ b/ps3/rgl/include/Cg/CgCommon.h @@ -83,8 +83,6 @@ struct _CGprogram unsigned int * samplerIndices; unsigned int * samplerUnits; - unsigned int controlFlowBools; - //binary format additions //info previously contained in platformProgram ( loadAddress + nvBinary ) CgProgramHeader header; @@ -150,9 +148,6 @@ typedef struct _CGcontext CGenum compileType; // compile manual, immediate or lazy (unused so far) - unsigned int controlFlowBoolsSharedMask; - unsigned int controlFlowBoolsShared; - // default program, fake owner of the context parameters _CGprogram defaultProgram; @@ -170,16 +165,13 @@ RGL_EXPORT void rglCgRaiseError( CGerror error ); // interface between object types extern void rglCgProgramDestroyAll( _CGcontext* c ); extern void rglCgDestroyContextParam( CgRuntimeParameter* p ); -RGL_EXPORT CgRuntimeParameter*rglCgCreateParameterInternal( _CGprogram *program, const char* name, CGtype type ); RGL_EXPORT void rglCgProgramErase( _CGprogram* prog ); // default setters void _cgRaiseInvalidParam( void *data, const void*v ); void _cgRaiseNotMatrixParam( void *data, const void*v ); void _cgIgnoreSetParam( void *dat, const void*v ); -void _cgRaiseInvalidParamIndex( void *dat, const void*v, const int index ); -void _cgRaiseNotMatrixParamIndex( void *dat, const void*v, const int index ); -void _cgIgnoreSetParamIndex( void *dat, const void*v, const int index ); +void _cgIgnoreParamIndex( void *dat, const void*v, const int index ); // cg helpers @@ -212,7 +204,6 @@ static inline bool isSampler (CGtype type) unsigned int rglCountFloatsInCgType( CGtype type ); -CGbool _cgMatrixDimensions( CGtype type, unsigned int* nrows, unsigned int* ncols ); unsigned int rglGetTypeRowCount( CGtype parameterType ); unsigned int rglGetTypeColCount( CGtype parameterType ); @@ -314,9 +305,8 @@ void rglPlatformSetFragmentRegisterBlock (unsigned int reg, unsigned int count, void rglPlatformSetBoolVertexRegisters (unsigned int values ); // names API -RGL_EXPORT unsigned int _cgHashString (const char *str); -inline static void _pullConnectedParameterValues (void *data) +static inline void _pullConnectedParameterValues (void *data) { _CGprogram *ptr = (_CGprogram*)data; // we now use a pull method to get the data into the children parameters diff --git a/ps3/rgl/src/ps3/rgl_ps3_cg.cpp b/ps3/rgl/src/ps3/rgl_ps3_cg.cpp index d6ed0c582c..f0b9d30854 100644 --- a/ps3/rgl/src/ps3/rgl_ps3_cg.cpp +++ b/ps3/rgl/src/ps3/rgl_ps3_cg.cpp @@ -834,136 +834,19 @@ unsigned int rglCountFloatsInCgType( CGtype type ) void _cgRaiseInvalidParam (void *data, const void*v ) { (void)data; - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); -} -void _cgRaiseInvalidParamIndex (void *data, const void*v, const int index ) -{ - (void)data; - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); } void _cgRaiseNotMatrixParam (void *data, const void*v ) { (void)data; - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); } -void _cgRaiseNotMatrixParamIndex( void *data, const void*v, const int index ) -{ - (void)data; - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); -} - -void _cgIgnoreSetParamIndex (void *data, const void*v, const int index ) +void _cgIgnoreParamIndex (void *data, const void*v, const int index ) { (void)data; // nothing } -CGbool _cgMatrixDimensions( CGtype type, unsigned int* nrows, unsigned int* ncols ) -{ - CGbool isMatrixType = CG_TRUE; - switch ( type ) - { - case CG_FLOAT: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_FLOAT1: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_HALF: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_HALF1: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_INT: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_INT1: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_BOOL: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_BOOL1: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_FIXED: *nrows = 1; *ncols = 1; isMatrixType = CG_FALSE; break; - case CG_FIXED1: *nrows = 1; *ncols = 2; isMatrixType = CG_FALSE; break; - - - case CG_FLOAT1x1: *nrows = 1; *ncols = 1; break; - case CG_FLOAT1x2: *nrows = 1; *ncols = 2; break; - case CG_FLOAT1x3: *nrows = 1; *ncols = 3; break; - case CG_FLOAT1x4: *nrows = 1; *ncols = 4; break; - case CG_FLOAT2x1: *nrows = 2; *ncols = 1; break; - case CG_FLOAT2x2: *nrows = 2; *ncols = 2; break; - case CG_FLOAT2x3: *nrows = 2; *ncols = 3; break; - case CG_FLOAT2x4: *nrows = 2; *ncols = 4; break; - case CG_FLOAT3x1: *nrows = 3; *ncols = 1; break; - case CG_FLOAT3x2: *nrows = 3; *ncols = 2; break; - case CG_FLOAT3x3: *nrows = 3; *ncols = 3; break; - case CG_FLOAT3x4: *nrows = 3; *ncols = 4; break; - case CG_FLOAT4x1: *nrows = 4; *ncols = 1; break; - case CG_FLOAT4x2: *nrows = 4; *ncols = 2; break; - case CG_FLOAT4x3: *nrows = 4; *ncols = 3; break; - case CG_FLOAT4x4: *nrows = 4; *ncols = 4; break; - case CG_HALF1x1: *nrows = 1; *ncols = 1; break; - case CG_HALF1x2: *nrows = 1; *ncols = 2; break; - case CG_HALF1x3: *nrows = 1; *ncols = 3; break; - case CG_HALF1x4: *nrows = 1; *ncols = 4; break; - case CG_HALF2x1: *nrows = 2; *ncols = 1; break; - case CG_HALF2x2: *nrows = 2; *ncols = 2; break; - case CG_HALF2x3: *nrows = 2; *ncols = 3; break; - case CG_HALF2x4: *nrows = 2; *ncols = 4; break; - case CG_HALF3x1: *nrows = 3; *ncols = 1; break; - case CG_HALF3x2: *nrows = 3; *ncols = 2; break; - case CG_HALF3x3: *nrows = 3; *ncols = 3; break; - case CG_HALF3x4: *nrows = 3; *ncols = 4; break; - case CG_HALF4x1: *nrows = 4; *ncols = 1; break; - case CG_HALF4x2: *nrows = 4; *ncols = 2; break; - case CG_HALF4x3: *nrows = 4; *ncols = 3; break; - case CG_HALF4x4: *nrows = 4; *ncols = 4; break; - case CG_INT1x1: *nrows = 1; *ncols = 1; break; - case CG_INT1x2: *nrows = 1; *ncols = 2; break; - case CG_INT1x3: *nrows = 1; *ncols = 3; break; - case CG_INT1x4: *nrows = 1; *ncols = 4; break; - case CG_INT2x1: *nrows = 2; *ncols = 1; break; - case CG_INT2x2: *nrows = 2; *ncols = 2; break; - case CG_INT2x3: *nrows = 2; *ncols = 3; break; - case CG_INT2x4: *nrows = 2; *ncols = 4; break; - case CG_INT3x1: *nrows = 3; *ncols = 1; break; - case CG_INT3x2: *nrows = 3; *ncols = 2; break; - case CG_INT3x3: *nrows = 3; *ncols = 3; break; - case CG_INT3x4: *nrows = 3; *ncols = 4; break; - case CG_INT4x1: *nrows = 4; *ncols = 1; break; - case CG_INT4x2: *nrows = 4; *ncols = 2; break; - case CG_INT4x3: *nrows = 4; *ncols = 3; break; - case CG_INT4x4: *nrows = 4; *ncols = 4; break; - case CG_BOOL1x1: *nrows = 1; *ncols = 1; break; - case CG_BOOL1x2: *nrows = 1; *ncols = 2; break; - case CG_BOOL1x3: *nrows = 1; *ncols = 3; break; - case CG_BOOL1x4: *nrows = 1; *ncols = 4; break; - case CG_BOOL2x1: *nrows = 2; *ncols = 1; break; - case CG_BOOL2x2: *nrows = 2; *ncols = 2; break; - case CG_BOOL2x3: *nrows = 2; *ncols = 3; break; - case CG_BOOL2x4: *nrows = 2; *ncols = 4; break; - case CG_BOOL3x1: *nrows = 3; *ncols = 1; break; - case CG_BOOL3x2: *nrows = 3; *ncols = 2; break; - case CG_BOOL3x3: *nrows = 3; *ncols = 3; break; - case CG_BOOL3x4: *nrows = 3; *ncols = 4; break; - case CG_BOOL4x1: *nrows = 4; *ncols = 1; break; - case CG_BOOL4x2: *nrows = 4; *ncols = 2; break; - case CG_BOOL4x3: *nrows = 4; *ncols = 3; break; - case CG_BOOL4x4: *nrows = 4; *ncols = 4; break; - case CG_FIXED1x1: *nrows = 1; *ncols = 1; break; - case CG_FIXED1x2: *nrows = 1; *ncols = 2; break; - case CG_FIXED1x3: *nrows = 1; *ncols = 3; break; - case CG_FIXED1x4: *nrows = 1; *ncols = 4; break; - case CG_FIXED2x1: *nrows = 2; *ncols = 1; break; - case CG_FIXED2x2: *nrows = 2; *ncols = 2; break; - case CG_FIXED2x3: *nrows = 2; *ncols = 3; break; - case CG_FIXED2x4: *nrows = 2; *ncols = 4; break; - case CG_FIXED3x1: *nrows = 3; *ncols = 1; break; - case CG_FIXED3x2: *nrows = 3; *ncols = 2; break; - case CG_FIXED3x3: *nrows = 3; *ncols = 3; break; - case CG_FIXED3x4: *nrows = 3; *ncols = 4; break; - case CG_FIXED4x1: *nrows = 4; *ncols = 1; break; - case CG_FIXED4x2: *nrows = 4; *ncols = 2; break; - case CG_FIXED4x3: *nrows = 4; *ncols = 3; break; - case CG_FIXED4x4: *nrows = 4; *ncols = 4; break; - default: *nrows = 0; *ncols = 0; break; - } - - return isMatrixType; -} - - CgRuntimeParameter* _cgGLTestArrayParameter( CGparameter paramIn, long offset, long nelements ) { CgRuntimeParameter* param = rglCgGLTestParameter( paramIn ); @@ -1014,107 +897,6 @@ static const CGenum dir_table[] = {CG_IN, CG_OUT, CG_INOUT, CG_ERROR}; RGL_EXPORT CgparameterHookFunction _cgParameterCreateHook = NULL; RGL_EXPORT CgparameterHookFunction _cgParameterDestroyHook = NULL; -static void rglCgGetParameterResourceInfo( CgRuntimeParameter *rtParameter, int arrayIndex, CGresource *resource, unsigned long *resourceIndex, unsigned short* numEmbeddedConstants) -{ - const CgParameterEntry *paramEntry = rtParameter->parameterEntry; - const CgParameterResource *paramResource = rglGetParameterResource( rtParameter->program, paramEntry ); - - const unsigned short *paramResourceTable = rtParameter->program->resources; - - if (( paramEntry->flags & CGPV_MASK ) == CGPV_VARYING ) - { - *resource = ( CGresource )paramResource->resource; - *resourceIndex = -1U; - } - else if ((( paramEntry->flags & CGPV_MASK ) & CGPV_CONSTANT ) || (( paramEntry->flags & CGPV_MASK ) & CGPV_UNIFORM ) ) - { - CGtype parameterResourceType = rglGetParameterCGtype( rtParameter->program, paramEntry ); - - if ( parameterResourceType >= CG_SAMPLER1D && parameterResourceType <= CG_SAMPLERCUBE ) - { - *resource = ( CGresource )paramResource->resource; - *resourceIndex = 0; - } - else - { - if ( parameterResourceType == CGP_SCF_BOOL ) - *resource = CG_B; - else - *resource = CG_C; - - bool bIsVertexProgram; - switch ( rtParameter->program->header.profile ) - { - case CG_PROFILE_SCE_VP_TYPEB: - case ( CGprofile )7005: - case CG_PROFILE_SCE_VP_RSX: - bIsVertexProgram = true; - break; - default: - bIsVertexProgram = false; - break; - } - - - unsigned int rows = rglGetTypeRowCount( parameterResourceType ); - if ( rows == 0 ) - rows = 1; - - *numEmbeddedConstants = 0; - - if ( bIsVertexProgram ) - { - if ( arrayIndex >= 0 ) - { - if ( paramEntry->flags & CGP_CONTIGUOUS ) - { - *resourceIndex = paramResource->resource + arrayIndex * rows; - } - else - { - unsigned short tempResIndex = *( paramResourceTable + paramResource->resource + arrayIndex * rows ); - *resourceIndex = ( tempResIndex == 0xFFFF ) ? -1U : ( int )tempResIndex; - } - } - else - { - unsigned short tempResIndex = paramResource->resource; - *resourceIndex = ( tempResIndex == 0xFFFF ) ? -1 : ( int )tempResIndex; - } - } - else - { - const unsigned short* resPtr = paramResourceTable + paramResource->resource; - if ( arrayIndex < 0 ) - arrayIndex = 0; - - int skipCount = arrayIndex * rows; - while ( skipCount ) - { - resPtr++; - int embeddedCount = *( resPtr++ ); - resPtr += embeddedCount; - skipCount--; - } - unsigned short tempResIndex = *( resPtr ); - - while (rows) - { - resPtr++; // skip register - unsigned short ecCount = *resPtr; - resPtr++; - *numEmbeddedConstants += ecCount; - resPtr += ecCount; - rows--; - } - - *resourceIndex = ( tempResIndex == 0xFFFF ) ? -1 : ( int )tempResIndex; - } - } - - } -} - static CGparameter rglAdvanceParameter( CGparameter param, int distance ) { CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); @@ -1203,47 +985,6 @@ static CGparameter rglAdvanceParameter( CGparameter param, int distance ) } } -unsigned int _cgHashString( const char *str ) -{ - unsigned int h = 0; - unsigned int g; - while ( *str ) - { - h = ( h << 4 ) + *str++; - if (( g = h & 0xf0000000 ) ) h ^= g >> 24; - h &= ~g; - } - return h; -} - -static int connection_creates_cycle( CgRuntimeParameter* paramFrom, CgRuntimeParameter* paramTo ) -{ - CgRuntimeParameter* paramHierarchyIter = paramFrom; - while ( paramHierarchyIter != NULL ) - { - if ( paramHierarchyIter == paramTo ) - { - return 1; - } - - std::vector::iterator paramConnectionTableIter = paramHierarchyIter->program->connectionTable.begin(); - while ( paramConnectionTableIter != paramHierarchyIter->program->connectionTable.end() ) - { - if ( paramConnectionTableIter->child == paramHierarchyIter ) - { - paramHierarchyIter = paramConnectionTableIter->parent; - break; - } - paramConnectionTableIter++; - } - if ( paramConnectionTableIter == paramHierarchyIter->program->connectionTable.end() ) - { - paramHierarchyIter = NULL; - } - } - return 0; -} - void rglCgDestroyContextParam( CgRuntimeParameter* ptr ) { std::vector::iterator semanticIter = ptr->program->parameterSemantics.begin(); @@ -1286,129 +1027,6 @@ void rglCgDestroyContextParam( CgRuntimeParameter* ptr ) free( ptr ); } -static void _setSamplerRuntimeParameter (void *data, const void*v, int /*index*/ ) -{ - CgRuntimeParameter *ptr = (CgRuntimeParameter*)data; - if (v) - { - *( GLuint* )ptr->pushBufferPointer = *( GLuint* )v; - } -} - -CgRuntimeParameter* rglCgCreateParameterInternal( _CGprogram *program, const char* name, CGtype type ) -{ - CgRuntimeParameter* param = NULL; - int isSampler = 0; - switch ( type ) - { - case CG_SAMPLER2D: - case CG_SAMPLER3D: - case CG_SAMPLERCUBE: - isSampler = 1; - case CG_FLOAT: // fall through - case CG_FLOAT1: - case CG_FLOAT2: - case CG_FLOAT3: - case CG_FLOAT4: - case CG_FLOAT1x1: - case CG_FLOAT2x1: - case CG_FLOAT1x2: - case CG_FLOAT3x1: - case CG_FLOAT1x3: - case CG_FLOAT4x1: - case CG_FLOAT1x4: - case CG_FLOAT2x2: - case CG_FLOAT2x3: - case CG_FLOAT3x2: - case CG_FLOAT2x4: - case CG_FLOAT4x2: - case CG_FLOAT3x3: - case CG_FLOAT3x4: - case CG_FLOAT4x3: - case CG_FLOAT4x4: - { - unsigned int size = sizeof( CgRuntimeParameter ) + sizeof( CgParameterEntry ) + - ( rglCountFloatsInCgType( type ) * sizeof( float ) ) + ( name ? strlen( name ) + 1 : 1 ); - - param = ( CgRuntimeParameter* ) malloc( size ); - - if ( !param ) { rglCgRaiseError( CG_MEMORY_ALLOC_ERROR ); return NULL; } - memset( param, 0, size ); - - CGparameter id = ( CGparameter )rglCreateName( &_CurrentContext->cgParameterNameSpace, param ); - if ( !id ) { free( param ); return NULL;} - - param->id = id; - - param->program = program; - - param->parameterEntry = ( CgParameterEntry * )(( char* )param + sizeof( CgRuntimeParameter ) ); - param->pushBufferPointer = ( void * )(( char* )param->parameterEntry + sizeof( CgParameterEntry ) ); - - CgParameterEntry* paramEntryInitializer = const_cast( param->parameterEntry ); - - paramEntryInitializer->nameOffset = ( unsigned int )(( char* )param->pushBufferPointer + rglCountFloatsInCgType( type ) * sizeof( float ) ); - - program->runtimeCreatedParameters.push_back( param ); - - if ( name ) - { - strcpy( reinterpret_cast( paramEntryInitializer->nameOffset ), name ); - } - - paramEntryInitializer->typeIndex = ( unsigned short )type; - - paramEntryInitializer->flags = 0; - paramEntryInitializer->flags |= CGP_RTCREATED; - paramEntryInitializer->flags |= CGPD_IN | CGPV_UNIFORM; - paramEntryInitializer->flags |= CGPF_GLOBAL; - - if ( isSampler ) - { - param->glType = rglCgGetSamplerGLTypeFromCgType( type ); - paramEntryInitializer->flags |= CGPF_REFERENCED; - } - - param->setterIndex = _cgRaiseInvalidParamIndex; - param->settercIndex = _cgRaiseNotMatrixParamIndex; - param->setterrIndex = _cgRaiseNotMatrixParamIndex; - param->samplerSetter = _cgRaiseInvalidParamIndex; - - switch ( type ) - { - case CG_FLOAT: - case CG_FLOAT1: case CG_FLOAT2: case CG_FLOAT3: case CG_FLOAT4: - { - unsigned int floatCount = rglCountFloatsInCgType( type ); - param->setterIndex = getVectorTypeIndexSetterFunction( 0, 0, VERTEX_PROFILE_INDEX, floatCount - 1 ); - } - break; - case CG_FLOAT1x1: case CG_FLOAT1x2: case CG_FLOAT1x3: case CG_FLOAT1x4: - case CG_FLOAT2x1: case CG_FLOAT2x2: case CG_FLOAT2x3: case CG_FLOAT2x4: - case CG_FLOAT3x1: case CG_FLOAT3x2: case CG_FLOAT3x3: case CG_FLOAT3x4: - case CG_FLOAT4x1: case CG_FLOAT4x2: case CG_FLOAT4x3: case CG_FLOAT4x4: - param->setterrIndex = getMatrixTypeIndexSetterFunction( 0, 0, VERTEX_PROFILE_INDEX, rglGetTypeRowCount( type ) - 1, rglGetTypeColCount( type ) - 1, 0 ); - param->settercIndex = getMatrixTypeIndexSetterFunction( 0, 0, VERTEX_PROFILE_INDEX, rglGetTypeRowCount( type ) - 1, rglGetTypeColCount( type ) - 1, 1 ); - break; - case CG_SAMPLER1D: case CG_SAMPLER2D: case CG_SAMPLER3D: case CG_SAMPLERRECT: case CG_SAMPLERCUBE: - param->samplerSetter = _setSamplerRuntimeParameter; - break; - case CGP_SCF_BOOL: - break; - default: - break; - } - - if ( _cgParameterCreateHook ) _cgParameterCreateHook( param ); - break; - } - default: - rglCgRaiseError( CG_INVALID_VALUE_TYPE_ERROR ); - break; - } - return param; -} - static int rglGetSizeofSubArray( const short *dimensions, int count ) { int res = 1; @@ -1628,364 +1246,9 @@ static _CGparameter *_cgGetNamedParameter( _CGprogram* progPtr, const char* name else return NULL; } + // API functions ---------------------------------------- -CG_API CGparameter cgCreateParameter( CGcontext ctx, CGtype type ) -{ - // This routine is currently (release 0.2.1) a nop. When it is changed to generate new parameters this will impact the - // debugger runtime because all cg routines that take parameters as inputs must be matched to their production. - // See the discussion of producer-consumer deficiencies in the design document for the debugger runtime (RGLPerfTool). - - // check context handle - if ( !CG_IS_CONTEXT( ctx ) ) - { - rglCgRaiseError( CG_INVALID_CONTEXT_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - _CGcontext * ctxPtr = _cgGetContextPtr( ctx ); - _CGprogram * program = &ctxPtr->defaultProgram; - CgRuntimeParameter *param = rglCgCreateParameterInternal( program, NULL, type ); - return param ? param->id : NULL; -} - -CG_API CGparameter cgCreateParameterArray( CGcontext ctx, CGtype type, int length ) -{ - // check context handle - if ( !CG_IS_CONTEXT( ctx ) ) - { - rglCgRaiseError( CG_INVALID_CONTEXT_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - - // TODO ********** - return ( CGparameter )NULL; -} - -CG_API CGparameter cgCreateParameterMultiDimArray( CGcontext ctx, CGtype type, int dim, const int* lengths ) -{ - // check context handle - if ( !CG_IS_CONTEXT( ctx ) ) - { - rglCgRaiseError( CG_INVALID_CONTEXT_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - - // TODO ********** - return ( CGparameter )NULL; -} - - -CG_API void cgDestroyParameter( CGparameter param ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return; - } - - CgRuntimeParameter *rtParam = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - - // check that the param was created via cgCreateParameter - if ( !is_created_param( rtParam ) ) - { - rglCgRaiseError( CG_PARAMETER_IS_NOT_SHARED_ERROR ); - return; - } - - // check to see if parameter is not a source before deletion - bool isConnectionParent = false; - struct _CGprogram* programIter = rtParam->program->parentContext->programList; - while ( programIter != NULL ) - { - // search the program's connection table to find if this is a parent param to anybody - std::vector::iterator paramConnectionTableIter = programIter->connectionTable.begin(); - while ( paramConnectionTableIter != programIter->connectionTable.end() ) - { - if ( paramConnectionTableIter->parent == rtParam ) - { - isConnectionParent = true; - break; - } - paramConnectionTableIter++; - } - programIter = programIter->next; - } - if ( isConnectionParent ) - { - rglCgRaiseError( CG_CANNOT_DESTROY_PARAMETER_ERROR ); - return; - } - - // this call will call a hook function to clean up the fx if needed - rglCgDestroyContextParam( rtParam ); - -} - -CG_API void cgConnectParameter( CGparameter from, CGparameter to ) -{ - // check parameter handles - if ( !CG_IS_PARAMETER( from ) || !CG_IS_PARAMETER( to ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return; - } - - // check and get parameter handles - CgRuntimeParameter *rtParamFrom = ( CgRuntimeParameter* )rglCgGLTestParameter( from ); - CgRuntimeParameter *rtParamTo = ( CgRuntimeParameter* )rglCgGLTestParameter( to ); - - // check that the param was created via cgCreateParameter - if ( !is_created_param( rtParamFrom ) ) - { - rglCgRaiseError( CG_PARAMETER_IS_NOT_SHARED_ERROR ); - return; - } - - if ( connection_creates_cycle( rtParamFrom, rtParamTo ) ) - { - rglCgRaiseError( CG_BIND_CREATES_CYCLE_ERROR ); - return; - } - - // type index is actually the offset into the block of memory following the entries - CGtype typeFrom = rglGetParameterCGtype( rtParamFrom->program, rtParamFrom->parameterEntry ); - CGtype typeTo = rglGetParameterCGtype( rtParamTo->program, rtParamTo->parameterEntry ); - if ( typeFrom != typeTo ) - { - // simple for now. - rglCgRaiseError( CG_PARAMETERS_DO_NOT_MATCH_ERROR ); - return; - } - - // (for array types) check that types match - // rglCgRaiseError(CG_ARRAY_TYPES_DO_NOT_MATCH_ERROR); - - // (for array types) check that all dimensions match - // rglCgRaiseError(CG_ARRAY_DIMENSIONS_DO_NOT_MATCH_ERROR); - - // we will need the top param to all for quick pull from arbitrarily deep hierarchies - // it gets updated if top gets disconnected from parent - // all the checks will have already happened when the initial connection was made - CgRuntimeParameter *rtParamTop = rtParamFrom; - // search parent connections in parent program and walk up to top - std::vector::iterator paramConnectionTableIter = rtParamTop->program->connectionTable.begin(); - while ( paramConnectionTableIter != rtParamTop->program->connectionTable.end() ) - { - // if this parameter is the child in a table, return its parent - if ( paramConnectionTableIter->child == rtParamTop ) - { - rtParamTop = paramConnectionTableIter->parent; - paramConnectionTableIter = rtParamTop->program->connectionTable.begin(); - } - else - { - paramConnectionTableIter++; - } - } - - // add new entry to the destination param's program's connection table - CgParameterConnection newConnection; - newConnection.child = rtParamTo; - newConnection.parent = rtParamFrom; - newConnection.top = rtParamTop; - newConnection.childOnBindSetter = _cgRaiseInvalidParamIndex; - switch ( typeTo ) - { - case CG_FLOAT: - case CG_FLOAT1: case CG_FLOAT2: case CG_FLOAT3: case CG_FLOAT4: - newConnection.childOnBindSetter = rtParamTo->setterIndex; - break; - case CG_FLOAT1x1: case CG_FLOAT1x2: case CG_FLOAT1x3: case CG_FLOAT1x4: - case CG_FLOAT2x1: case CG_FLOAT2x2: case CG_FLOAT2x3: case CG_FLOAT2x4: - case CG_FLOAT3x1: case CG_FLOAT3x2: case CG_FLOAT3x3: case CG_FLOAT3x4: - case CG_FLOAT4x1: case CG_FLOAT4x2: case CG_FLOAT4x3: case CG_FLOAT4x4: - newConnection.childOnBindSetter = rtParamTo->setterrIndex; - break; - case CG_SAMPLER1D: case CG_SAMPLER2D: case CG_SAMPLER3D: case CG_SAMPLERRECT: case CG_SAMPLERCUBE: - newConnection.childOnBindSetter = rtParamTo->samplerSetter; - break; - case CGP_SCF_BOOL: - break; - default: - break; - } - - rtParamTo->program->connectionTable.push_back( newConnection ); -} - -CG_API void cgDisconnectParameter( CGparameter param ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return; - } - - // check and get parameter handles - CgRuntimeParameter *rtParamTo = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - - // check parameter handles - if ( !CG_IS_PARAMETER( rtParamTo ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return; - } - - // search the program's connection table to find the connection info for this parameter - // each parameter only ever has one parent - std::vector::iterator paramConnectionTableIter = rtParamTo->program->connectionTable.begin(); - while ( paramConnectionTableIter != rtParamTo->program->connectionTable.end() ) - { - if ( paramConnectionTableIter->child == rtParamTo ) - break; - paramConnectionTableIter++; - } - - // if the parameter is not found in the connection table, it was never connected in the first place - if ( paramConnectionTableIter == rtParamTo->program->connectionTable.end() ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return; - } - - // parameter was found to be connected, delete its entry from the table to disconnect - rtParamTo->program->connectionTable.erase( paramConnectionTableIter ); - - // check to see if parameter is a parent to for anyone in an arbitrarily deep hierarchy - // if it is, we must update all the children's top pointers to point to this param - struct _CGprogram* programIter = rtParamTo->program->parentContext->programList; - while ( programIter != NULL ) - { - // search the connection table of all the programs in this context to find if this is a parent param to anybody - paramConnectionTableIter = programIter->connectionTable.begin(); - while ( paramConnectionTableIter != programIter->connectionTable.end() ) - { - if ( paramConnectionTableIter->parent == rtParamTo ) - { - // this is the case where rt was the parent, and now must be the top because - // it was just disconnected from its own parent - paramConnectionTableIter->top = rtParamTo; - } - paramConnectionTableIter++; - } - programIter = programIter->next; - } -} - -CG_API CGparameter cgGetConnectedParameter( CGparameter param ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - - CgRuntimeParameter* ptr = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - std::vector::iterator paramConnectionTableIter = ptr->program->connectionTable.begin(); - while ( paramConnectionTableIter != ptr->program->connectionTable.end() ) - { - // if this parameter is the child in a table, return its parent - if ( paramConnectionTableIter->child == ptr ) - return paramConnectionTableIter->parent->id; - paramConnectionTableIter++; - } - - // not found in connection table, has no parent - return NULL; -} - -CG_API int cgGetNumConnectedToParameters( CGparameter param ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return 0; - } - - int ret = 0; - CgRuntimeParameter *ptr = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - - _CGprogram* prog = ptr->program; - _CGcontext* context = prog->parentContext; - - // must iterate over all the programs in this context to see which of them - // have parameters which are connected to this parent - _CGprogram* programIter = context->programList; - while ( programIter != NULL ) - { - std::vector::iterator paramConnectionTableIter = programIter->connectionTable.begin(); - while ( paramConnectionTableIter != programIter->connectionTable.end() ) - { - // if this connection uses the param ptr as the parent, increment the count - if ( paramConnectionTableIter->parent == ptr ) - { - ret++; - } - paramConnectionTableIter++; - } - - programIter = programIter->next; - } - - return ret; -} - -CG_API CGparameter cgGetConnectedToParameter( CGparameter param, int index ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - - if ( index < 0 ) - { - rglCgRaiseError( CG_OUT_OF_ARRAY_BOUNDS_ERROR ); - return ( CGparameter )NULL; - } - - - int ret = 0; - CgRuntimeParameter *ptr = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - - _CGprogram* prog = ptr->program; - _CGcontext* context = prog->parentContext; - - // must iterate over all the programs in this context to see which of them - // have parameters which are connected to this parent - _CGprogram* programIter = context->programList; - while ( programIter != NULL ) - { - std::vector::iterator paramConnectionTableIter = programIter->connectionTable.begin(); - while ( paramConnectionTableIter != programIter->connectionTable.end() ) - { - // if this is the n'th child, where n == index, return its id - if ( paramConnectionTableIter->parent == ptr ) - { - if ( ret == index ) - { - return paramConnectionTableIter->child->id; - } - ret++; - } - paramConnectionTableIter++; - } - - programIter = programIter->next; - } - - // else the index is greater than the number of children of this parameter - rglCgRaiseError( CG_OUT_OF_ARRAY_BOUNDS_ERROR ); - - return ( CGparameter )NULL; -} - - CG_API CGparameter cgGetNamedParameter( CGprogram prog, const char* name ) { // check program handle @@ -2010,46 +1273,6 @@ CG_API CGparameter cgGetNamedParameter( CGprogram prog, const char* name ) return ( CGparameter )NULL; } -CG_API CGparameter cgGetNamedProgramParameter( CGprogram prog, CGenum name_space, const char* name ) -{ - // Same as cgGetNamedParameter, but restricts search to a specific namespace - // i.e. only return parameters of this CGprogram that are global. - // - // Valid namespaces are CG_GLOBAL and CG_PROGRAM, - - // check program handle - if ( !CG_IS_PROGRAM( prog ) ) - { - rglCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - - // check namespace - switch ( name_space ) - { - case CG_GLOBAL : - break; - case CG_PROGRAM : - break; - default : - // ********* NOTE: docs say nothing about this check. - return NULL; - break; - } - _CGprogram* progPtr = _cgGetProgPtr( prog ); - int arrayIndex = -1; - CgRuntimeParameter *param = ( CgRuntimeParameter * )_cgGetNamedParameter( progPtr, name, name_space, &arrayIndex ); - if ( param ) - { - int ret = ( int )param->id; - if ( arrayIndex != -1 ) - ret |= ( arrayIndex << CG_PARAMETERSIZE ); - return ( CGparameter )ret; - } - else - return ( CGparameter )NULL; -} - CG_API CGparameter cgGetFirstParameter( CGprogram prog, CGenum name_space ) { // check program handle @@ -2081,106 +1304,6 @@ CG_API CGparameter cgGetFirstParameter( CGprogram prog, CGenum name_space ) return ( CGparameter )NULL; } -//this function returns the parent array if the parameter passed is member of an array as well as the position in the array -//returns null other wise -static CgRuntimeParameter *rglGetArrayItemParent( CGparameter param, int *arrayIndex ) -{ - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return NULL; - - // the case of the array element is easy to solve: - if ( rtParameter > rtParameter->program->runtimeParameters ) - { - CgRuntimeParameter *previousParameter = rtParameter - 1; - if ( previousParameter->parameterEntry->flags & CGP_ARRAY ) - { - if ( previousParameter->parameterEntry->flags & CGP_UNROLLED ) - { - //that's easy, we are on the first item of the array - //the other positions will be discovered by the main loop later - if ( arrayIndex ) - *arrayIndex = 0; - return previousParameter; - } - else - { - //we have an array item - if ( arrayIndex ) - *arrayIndex = CG_GETINDEX( param ); - return previousParameter; - } - } - } - - //we are in the case where we don't have the first item of an unrolled array and where we don't have an item of a compact array - //the algorithm it to walk back the parameter list until we found the parent. - //if the parent is a structure or if there is no parent, returns NULL, else return the parent and the index, - - //get the parent of the current as well as its location - const CgParameterEntry *paramEntry = rtParameter->parameterEntry; - const CgParameterEntry *firstEntry = rtParameter->program->parametersEntries; - - //we have already treated the current entry at that point, the loop starts on the previous one, the distance is 1 - int distance = 1; - paramEntry--; - - *arrayIndex = 0; - bool haveResult = false; - while ( paramEntry >= firstEntry && !haveResult ) - { - switch ( paramEntry->flags & CGP_TYPE_MASK ) - { - case CGP_ARRAY: - //we found it - haveResult = true; - break; - case CGP_STRUCTURE: - { - const CgParameterStructure *parameterStructure = rglGetParameterStructure( rtParameter->program, paramEntry ); - if ( distance >= parameterStructure->memberCount ) - { - //the parameter is not in this structure, so I need to remove from the distance all the structure item - distance -= parameterStructure->memberCount; - //I need to patch the array Index, we have counted some items which were not in the array - //this struct should count just for one - //so basically it means we are in an array of struct if this struct is one item. - //if we only have homogeneous array, we can speed up that function, I don't do it, - //in case we extend the behaviour in the future - ( *arrayIndex ) -= parameterStructure->memberCount; - //increment the arrayIndex - ( *arrayIndex )++; - } - else - { - //so we are in the structure, not in an array - ( *arrayIndex ) = -1; - return NULL; - } - break; - } - case CGP_INTRINSIC: - //increment the arrayIndex - ( *arrayIndex )++; - break; - } - distance++; - paramEntry--; - } - - if ( haveResult ) - { - size_t offset = ( rtParameter->parameterEntry - paramEntry ); - CgRuntimeParameter *parentParameter = rtParameter - offset; - return parentParameter; - } - else - { - ( *arrayIndex ) = -1; - return NULL; - } -} - CG_API CGparameter cgGetNextParameter( CGparameter param ) { //check parameter handle @@ -2338,53 +1461,6 @@ CG_API CGparameter cgGetFirstStructParameter( CGparameter param ) return ( CGparameter )NULL; //we have a struct with 0 items ? } -CG_API CGparameter cgGetNamedStructParameter( CGparameter param, const char* name ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return ( CGparameter )NULL; - - // check input string - if ( NULL == name ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return ( CGparameter )NULL; - } - - if ( !( rtParameter->parameterEntry->flags & CGP_STRUCTURE ) ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return ( CGparameter )NULL; - } - - - const CgParameterStructure *parameterStructure = rglGetParameterStructure( rtParameter->program, rtParameter->parameterEntry ); - - int arrayIndex = -1; - CgRuntimeParameter *structParam = ( CgRuntimeParameter * )_cgGetNamedParameter( rtParameter->program, name, ( CGenum )0, &arrayIndex, rtParameter->parameterEntry + 1, parameterStructure->memberCount ); - if ( structParam ) - { - int ret = ( int )structParam->id; - if ( arrayIndex != -1 ) - ret |= ( arrayIndex << CG_PARAMETERSIZE ); - return ( CGparameter )ret; - } - else - return ( CGparameter )NULL; -} - -CG_API CGparameter cgGetFirstDependentParameter( CGparameter param ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - return ( CGparameter )NULL; -} - CG_API CGparameter cgGetArrayParameter( CGparameter param, int arrayIndex ) { // check parameter handle @@ -2423,80 +1499,6 @@ CG_API CGparameter cgGetArrayParameter( CGparameter param, int arrayIndex ) return arrayItemID; } -CG_API int cgGetArrayDimension( CGparameter param ) -{ - // return how many dimensions this array has. - // TODO: API should be an unsigned int. - - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return -1; - - // ***** NOT IN CG DOCUMENTATION, but should be **** - - // this is a rarely queried value, so we do not store it. - // instead we calculate it every time it is requested. - // recurse down the array tree until the parameter type is not CG_ARRAY - // counting the depth as we go. - - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - if (( parameterEntry->flags & CGP_ARRAY ) == 0 ) - { - // ***** NOT IN CG DOCUMENTATION, but should be **** - rglCgRaiseError( CG_ARRAY_PARAM_ERROR ); - return 0; - } - else - { - const CgParameterArray *parameterArray = rglGetParameterArray( rtParameter->program, parameterEntry ); - return ( int )parameterArray->dimensionCount; - } - return 0; -} - -CG_API CGtype cgGetArrayType( CGparameter param ) -{ - // return the type of the leaf node of this CG_ARRAY type - - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return CG_UNKNOWN_TYPE; - - // ***** NOT IN CG DOCUMENTATION, but should be **** - - // this is a rarely queried value, so we do not store it. - // instead we calculate it every time it is requested. - // recurse down the array tree until the parameter type is not CG_ARRAY - // and return the first child that is not a CG_ARRAY type. - - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - if (( parameterEntry->flags & CGP_ARRAY ) == 0 ) - { - // ***** NOT IN CG DOCUMENTATION, but should be **** - rglCgRaiseError( CG_ARRAY_PARAM_ERROR ); - return CG_UNKNOWN_TYPE; - } - else - { - //get the parameter type inside the array - rtParameter++; - parameterEntry = rtParameter->parameterEntry; - if ( parameterEntry->flags & CGP_STRUCTURE ) - { - return CG_STRUCT; - } - else - { - // when we are able to support runtime created arrays of params we must handle that here - const CgParameterResource *parameterResource = rglGetParameterResource( rtParameter->program, parameterEntry ); - return ( CGtype )parameterResource->type; - } - } - return CG_UNKNOWN_TYPE; -} - CG_API int cgGetArraySize( CGparameter param, int dimension ) { // check parameter handle @@ -2533,24 +1535,6 @@ CG_API int cgGetArraySize( CGparameter param, int dimension ) return -1; } -CG_API void cgSetArraySize( CGparameter param, int size ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - } -} - -CG_API void cgSetMultiDimArraySize( CGparameter param, const int* sizes ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - } -} - CG_API CGprogram cgGetParameterProgram( CGparameter param ) { // check parameter handle @@ -2668,193 +1652,6 @@ CG_API const char* cgGetParameterSemantic( CGparameter param ) } } -CG_API CGresource cgGetParameterBaseResource( CGparameter param ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return CG_UNDEFINED; - else - { - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - - unsigned short type = parameterEntry->flags & CGP_TYPE_MASK; - if ( type == CGP_STRUCTURE || type == CGP_ARRAY ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return CG_UNDEFINED; - } - - CGresource resource = cgGetParameterResource( param ); - return rglGetBaseResource( resource ); - } -} - -CG_API CGparameter cgGetFirstLeafParameter( CGprogram prog, CGenum name_space ) -{ - // check program handle - if ( !CG_IS_PROGRAM( prog ) ) - { - rglCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR ); - return ( CGparameter )NULL; - } - - _CGprogram* progPtr = _cgGetProgPtr( prog ); - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )progPtr->runtimeParameters; - - //find the first leaf param of the requested namespace - for ( int i = 0; i < progPtr->rtParametersCount; ++i ) - { - // check parameter handle - bool isGlobal = ( rtParameter->parameterEntry->flags & CGPF_GLOBAL ) == CGPF_GLOBAL; - if (( isGlobal && name_space == CG_GLOBAL ) || ( !isGlobal && name_space == CG_PROGRAM ) ) - { - int type = ( rtParameter->parameterEntry->flags & CGP_TYPE_MASK ); - if ( type == CGP_INTRINSIC ) - return ( CGparameter )rtParameter->id; - else if ( type == CGP_ARRAY ) - { - if ( !( rtParameter->parameterEntry->flags & CGP_UNROLLED ) ) - { - //can we have a parameter of size 0 ? - const CgParameterArray *parameterArray = rglGetParameterArray( rtParameter->program, rtParameter->parameterEntry ); - int arraySize = ( int )rglGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount ); - rtParameter++; //we move on the type parameter - if ( arraySize ) - { - //sending back ARRAY ITEM 0 here, should really use a macro to create the CGparameter handle - return rtParameter->id; - } - //else we just continue - } - //else unrolled, just continue - } - //else if (type == CGP_STRUCTURE) //just continue - } - rtParameter++; - } - return ( CGparameter )NULL; -} - -CG_API CGparameter cgGetNextLeafParameter( CGparameter param ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return ( CGparameter )NULL; - - //this parameter should be an intrinsic - if (( rtParameter->parameterEntry->flags & CGP_TYPE_MASK ) != CGP_INTRINSIC ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return ( CGparameter )NULL; - } - - // runtime created parameters are treated separately because they are in a different namespace - // as such, you never need to traverse from a program param to a runtime param, or visa-versa - // additionally, in the current implementation, we only support creation of leaf types. - if ( rtParameter->parameterEntry->flags & CGP_RTCREATED ) - { - // we have a runtime created parameter - std::vector::iterator rtCreatedIter = rtParameter->program->runtimeCreatedParameters.begin(); - while ( rtCreatedIter != rtParameter->program->runtimeCreatedParameters.end() ) - { - if ( *rtCreatedIter == rtParameter ) - { - rtCreatedIter++; - if ( rtCreatedIter == rtParameter->program->runtimeCreatedParameters.end() ) - { - break; - } - return ( *rtCreatedIter )->id; - } - rtCreatedIter++; - } - // no next parameter for this one - return ( CGparameter )NULL; - } - - // the case of the array element is easy to solve: - if ( rtParameter > rtParameter->program->runtimeParameters ) - { - CgRuntimeParameter *previousParameter = rtParameter - 1; - if (( previousParameter->parameterEntry->flags & CGP_ARRAY ) && !( previousParameter->parameterEntry->flags & CGP_UNROLLED ) ) - { - //we have an array item - int arrayIndex = CG_GETINDEX( param ); - arrayIndex++; - const CgParameterArray *parameterArray = rglGetParameterArray( previousParameter->program, previousParameter->parameterEntry ); - int arraySize = rglGetSizeofSubArray(( short* )parameterArray->dimensions, parameterArray->dimensionCount ); - if ( arrayIndex < arraySize ) - { - int ret = ( int )rtParameter->id; - ret |= ( arrayIndex << CG_PARAMETERSIZE ); - return ( CGparameter )ret; - } - //else - //we need to leave this array and continue the traversal - } - } - - bool isCurrentGlobal = ( rtParameter->parameterEntry->flags & CGPF_GLOBAL ) == CGPF_GLOBAL; - - const CgParameterEntry *endEntry = rtParameter->program->parametersEntries + rtParameter->program->rtParametersCount; - const CgParameterEntry *paramEntry = rtParameter->parameterEntry + 1; - while ( paramEntry < endEntry ) - { - size_t offset = ( paramEntry - rtParameter->parameterEntry ); - CgRuntimeParameter *nextParameter = rtParameter + offset; - bool isNextGlobal = ( nextParameter->parameterEntry->flags & CGPF_GLOBAL ) == CGPF_GLOBAL; - if ( isNextGlobal != isCurrentGlobal ) - { - paramEntry++; // let's not quit, but continue to look for a matching namespace - continue; - //return ( CGparameter )NULL; //the items are gathered by namespace, so if different namespace then we quit - } - switch ( paramEntry->flags & CGP_TYPE_MASK ) - { - case CGP_ARRAY: - { - if ( paramEntry->flags & CGP_UNROLLED ) - { - //we skip unrolled array - break; - } - else - { - //we need to go inside and send back the first array item - //check how many item do we have in the array - const CgParameterArray *parameterArray = rglGetParameterArray( rtParameter->program, paramEntry ); - int arraySize = ( int )rglGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount ); - if ( arraySize ) - { - nextParameter++; //go on the array time - //sending back ARRAY ITEM 0 here, should really use a macro to create the CGparameter handle - return nextParameter->id; - } - else - { - //no item in the array skip the item time continue - nextParameter++; //go on the array time, will be skipped - } - } - break; - } - case CGP_STRUCTURE: - { - //we just skip structures - break; - } - case CGP_INTRINSIC: - //we are done we found an intrinsic - return nextParameter->id; - break; - } - paramEntry++; - } - return ( CGparameter )NULL; -} - static bool rglPrependString( char *dst, const char *src, size_t size ) { int len = strlen( src ); @@ -2960,115 +1757,6 @@ CG_API const char* cgGetParameterName( CGparameter param ) } -CG_API CGresource cgGetParameterResource( CGparameter param ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - { - return CG_UNDEFINED; - } - - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - - if ( parameterEntry->flags & CGP_RTCREATED ) - { - // runtime created parameters do not have resources - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return CG_UNDEFINED; - } - - unsigned short type = parameterEntry->flags & CGP_TYPE_MASK; - if ( type == CGP_STRUCTURE || type == CGP_ARRAY ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return CG_UNDEFINED; - } - - // TODO ************* docs say something incoherent about returning - // CG_INVALID_VALUE if cgIsParameterReferenced() == CG_FALSE? - if ( !( parameterEntry->flags & CGPF_REFERENCED ) ) - { - return CG_UNDEFINED; - } - - int arrayIndex = -1; - if ( rtParameter > rtParameter->program->runtimeParameters ) - { - CgRuntimeParameter *previousParameter = rtParameter - 1; - if ( previousParameter->parameterEntry->flags & CGP_ARRAY ) - { - //we have an array item - arrayIndex = CG_GETINDEX( param ); - } - } - - unsigned long resourceIndex = 0; - CGresource resource = ( CGresource )0; - unsigned short numEmbeddedConstants = 0; - rglCgGetParameterResourceInfo( rtParameter, arrayIndex, &resource, &resourceIndex, &numEmbeddedConstants ); - - // this returns undefined for array items that are not allocated - if (arrayIndex >= 0 && resourceIndex == -1U && numEmbeddedConstants == 0) - return CG_UNDEFINED; - - return resource; -} - -CG_API unsigned long cgGetParameterResourceIndex( CGparameter param ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - { - return CG_UNDEFINED; - } - - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - - if ( parameterEntry->flags & CGP_RTCREATED ) - { - // runtime created parameters do not have resources - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return CG_UNDEFINED; - } - - unsigned short type = parameterEntry->flags & CGP_TYPE_MASK; - if ( type == CGP_STRUCTURE || CGP_STRUCTURE == CGP_ARRAY ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return -1U; - } - - // TODO ************* docs say something incoherent about returning - // CG_INVALID_VALUE if cgIsParameterReferenced() == CG_FALSE? - if ( !( parameterEntry->flags & CGPF_REFERENCED ) ) - { - return -1U; - } - - int arrayIndex = -1; - if ( rtParameter > rtParameter->program->runtimeParameters ) - { - CgRuntimeParameter *previousParameter = rtParameter - 1; - if ( previousParameter->parameterEntry->flags & CGP_ARRAY ) - { - //we have an array item - arrayIndex = CG_GETINDEX( param ); - } - } - - unsigned long resourceIndex = 0; - CGresource resource = ( CGresource )0; - unsigned short numEmbeddedConstants; - rglCgGetParameterResourceInfo( rtParameter, arrayIndex, &resource, &resourceIndex, &numEmbeddedConstants ); - if ( resource == CG_B || resource == CG_C ) - return ( unsigned long )resourceIndex; - else - return ( unsigned long )( resource - rglGetBaseResource( resource ) ); - -} - CG_API CGenum cgGetParameterVariability( CGparameter param ) { // check parameter handle @@ -3111,342 +1799,6 @@ CG_API CGenum cgGetParameterDirection( CGparameter param ) } } -CG_API CGbool cgIsParameterReferenced( CGparameter param ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return CG_FALSE; - else - { - return (( rtParameter->parameterEntry->flags & CGPF_REFERENCED ) != 0 ); - } -} - -CG_API CGbool cgIsParameterUsed( CGparameter param, CGhandle handle ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - - // TODO: make a more accurate and general definition of "used", including runtime created parameters. - if ( !rtParameter ) - { - return CG_FALSE; - } - - if ( !CG_IS_PROGRAM( (CGprogram)handle ) ) - { - rglCgRaiseError( CG_INVALID_PROGRAM_HANDLE_ERROR ); - return CG_FALSE; - } - - // adding support for effect handles would require moving this to RGLFX or something that would break the abstraction of that library - _CGprogram* progPtr = _cgGetProgPtr( (CGprogram)handle ); - - if ( !progPtr ) - { - return CG_FALSE; - } - - if (rtParameter->program != progPtr) - { - return CG_FALSE; - } - - return (( rtParameter->parameterEntry->flags & CGPF_REFERENCED ) != 0 ); -} - -CG_API const double* cgGetParameterValues( CGparameter paramIn, CGenum value_type, int *nvalues ) -{ - // check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( paramIn ); - if ( !rtParameter ) - return NULL; - - // check nvalues pointer - if ( NULL == nvalues ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return NULL; - } - - // check if we are trying to get the current value of a uniform that is - // unreferenced and unbound (happens when compiler folds global constants), - // we can only return the default value in this case. - if ( value_type == CG_CURRENT ) - { - int var = ( rtParameter->parameterEntry->flags & CGPV_MASK ); - if ( var == CGPV_UNIFORM && - !( rtParameter->parameterEntry->flags & CGPF_REFERENCED ) && - !( rtParameter->parameterEntry->flags & CGP_RTCREATED ) && - !( rtParameter->parameterEntry->flags & CGP_ARRAY ) ) - { - const CgParameterResource* parameterResource = rglGetParameterResource( rtParameter->program, rtParameter->parameterEntry ); - if ( parameterResource ) - { - if ( parameterResource->resource == 0xffff ) - { - value_type = CG_DEFAULT; - } - } - } - - // this is the case for const parameters that never have a push buffer allocated - // because they can not be set since they are const in the shader, so the value - // will always be the defaults. - if ( rtParameter->pushBufferPointer == NULL ) - { - value_type = CG_DEFAULT; - } - } - - // as this function returns a pointer to an array of doubles we have - // to allocate space for this array, make sure it's never re-allocated for - // this parameter, plus make sure it is deleted when the CGcontext is - // destroyed. - // - // All in all a nasty API function. - - double values[16]; - *nvalues = 0; - _CGprogram *program = rtParameter->program; - - // check value type then copy the approriate values into the local values buffer - switch ( value_type ) - { - case CG_CONSTANT: - break; - - case CG_DEFAULT: - // return contents of default value field. - { - if ( rtParameter->parameterEntry->flags & CGP_RTCREATED ) - { - // runtime created parameters do not have default values - break; - } - // if there are defaults, they will only be in the platformParam - //do a slow linear search in the constants we have - int count = program->defaultValuesIndexCount; - for ( int i = 0;i < count;i++ ) - { - int index = ( int )program->defaultValuesIndices[i].entryIndex; - CgRuntimeParameter *tmp = program->runtimeParameters + index; - if ( tmp == rtParameter ) - { - //found - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - if ( parameterEntry->flags & CGP_ARRAY ) - return NULL; - const float *itemDefaultValues = program->defaultValues + program->defaultValuesIndices[i].defaultValueIndex; - CGtype parameterResourceType = rglGetParameterCGtype( program, parameterEntry ); - unsigned int cols = rglGetTypeColCount( parameterResourceType ); - unsigned int rows = rglGetTypeRowCount( parameterResourceType ); - if ( rows == 0 ) - rows = 1; //flat types versus matrices - - // the defaults must be copied out for each row, from each successive child - for ( GLuint r = 0; r < rows; r++ ) - { - const float* src = itemDefaultValues + 4 * r;//right now default values always come by 4 - // copy the values into the local buffer, just the right number of values for the column - for ( GLuint floatIndex = 0; floatIndex < cols; ++floatIndex ) - values[floatIndex + r * cols] = src[floatIndex]; - } - *nvalues = rows * cols; - break; //loop to find the defaults of the parameter - } - } - break; - } - case CG_CURRENT: - // return contents of current value field. - // **** this is documented in cgSetParameter docs, but not the cgGetParameterValues docs. - { - if ( rtParameter->pushBufferPointer ) - { - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - if ( parameterEntry->flags & CGP_ARRAY ) - return NULL; - - CGtype parameterResourceType = rglGetParameterCGtype( program, parameterEntry ); - - unsigned int cols = rglGetTypeColCount( parameterResourceType ); - unsigned int rows = rglGetTypeRowCount( parameterResourceType ); - if ( rows == 0 ) - rows = 1; //flat types versus matrices - - int floatcount = cols * rows; - // take the padding in the matrices into account - int colCount = 4; - int paddingSize = 0; - if ( cols ) - { - colCount = cols; - paddingSize = 4 - cols; - } - - bool isInArray = false; - unsigned int testParam = ((( unsigned int )paramIn ) & CG_PARAMETERMASK ); - // array parameter handle = ( base array handle + 1 ) + ((parameter index)<< 22) - if (( testParam != ( unsigned int )paramIn ) || // masking it like this will chop the index off the array - (( rtParameter > rtParameter->program->runtimeParameters ) && ( rtParameter - 1 )->parameterEntry->flags & CGP_ARRAY ) ) // this handles the case of the first array element at index 0 (and hopefully compact arrays i think) - { - isInArray = true; - } - - // if this parameter is connected as the child to a parent parameter, - // it is possible that the values will not have been pulled into the pushbuffer yet - // if the program that owns this parameter has not been bound since the parent was set. - // pull the values, just to be sure, even though this will pull values for - // every parameter in this program. it's a slow call anyway. - _pullConnectedParameterValues( rtParameter->program ); - - float *source; - - if ( isInArray ) - { - source = ( float* )( *(( unsigned int ** )rtParameter->pushBufferPointer + CG_GETINDEX( paramIn ) ) ); - } - else - { - source = ( float* )rtParameter->pushBufferPointer; - } - - for ( int i = 0; i < floatcount; ++i ) - { - values[i] = source[i + ( i / colCount ) * paddingSize]; - } - - *nvalues = floatcount; - } - break; - } - default: - rglCgRaiseError( CG_INVALID_ENUMERANT_ERROR ); - return NULL; - break; - } - - if ( *nvalues > 0 ) - { - double *parameterValues = rtParameter->program->parentContext->currentParameterValue; - for ( int i = 0; i < *nvalues; i++ ) - { - parameterValues[i] = values[i]; - } - return parameterValues; - } - return NULL; -} - -CG_API int cgGetParameterOrdinalNumber( CGparameter param ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return CG_FALSE; - } - - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return CG_FALSE; - } - - // not implemented yet on the new runtime - // AND the spec on what this function does has actually been changed - // for globals and constants according to more recent nv documentation. - // yuck. - return -123; - - // if param of a CG_CONSTANT, return 0. We do not currently expose - // constants, and I am not sure why we would raise any error - // anyways. - -} - -CG_API CGbool cgIsParameterGlobal( CGparameter param ) -{ - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return CG_FALSE; - else - { - return (( rtParameter->parameterEntry->flags & CGPF_GLOBAL ) != 0 ); - } -} - -CG_API int cgGetParameterIndex( CGparameter param ) -{ - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return -1; - - // currently we don't support the runtime creation of array parameters so runtime created params never have an array index - if ( rtParameter->parameterEntry->flags & CGP_RTCREATED ) - return -1; - - int arrayIndex = -1; - CgRuntimeParameter *parent = rglGetArrayItemParent( param, &arrayIndex ); - if ( parent ) - return arrayIndex; - else - return -1; -} - -CG_API void cgSetParameterVariability( CGparameter param, CGenum vary ) -{ - // check parameter handle - if ( !CG_IS_PARAMETER( param ) ) - { - rglCgRaiseError( CG_INVALID_PARAM_HANDLE_ERROR ); - return; - } - - // check vary enum for validity. - switch ( vary ) - { - case CG_UNIFORM: - case CG_LITERAL: - case CG_DEFAULT: - break; - default: - rglCgRaiseError( CG_INVALID_ENUMERANT_ERROR ); - return; - } - - // check that requested variability can be applied to this param - CGenum var = cgGetParameterVariability( param ); - if ( CG_VARYING == var ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_VARIABILITY_ERROR ); - return; - } - else - { - switch ( vary ) - { - case CG_UNIFORM: - case CG_LITERAL: - // **** record the change of variability, forcing a recompile. - // **** but we're pre-compiled so it does nothing to us. - break; - case CG_DEFAULT: - // **** if the param is connected, we can change the target - // **** param back to its default variability. - // **** but we got no connected params yet. So give up. - break; - default: - rglCgRaiseError( CG_INVALID_ENUMERANT_ERROR ); - break; - } - } - return; -} - CG_API void cgSetParameterSemantic( CGparameter param, const char* semantic ) { // check parameter handle @@ -3859,40 +2211,6 @@ CG_API CGtype cgGetTypeBase( CGtype type ) return CG_UNKNOWN_TYPE; } - -CG_API CGbool cgGetTypeSizes( CGtype type, int *nrows, int *ncols ) -{ - // TODO ***************** - return _cgMatrixDimensions( type, ( unsigned int* )nrows, ( unsigned int* )ncols ); - -} - -CG_API void cgGetMatrixSize( CGtype type, int *nrows, int *ncols ) -{ - if (( nrows == 0 ) || ( ncols == 0 ) ) - { - rglCgRaiseError( CG_INVALID_POINTER_ERROR ); - return; - } - - if (( type >= CG_FLOAT1x1 && type <= CG_FLOAT4x4 ) || - ( type >= CG_HALF1x1 && type <= CG_HALF4x4 ) || - ( type >= CG_INT1x1 && type <= CG_INT4x4 ) || - ( type >= CG_BOOL1x1 && type <= CG_BOOL4x4 ) || - ( type >= CG_FIXED1x1 && type <= CG_FIXED4x4 )) - { - _cgMatrixDimensions( type, ( unsigned int* )nrows, ( unsigned int* )ncols ); - return; - } - - // type supplied is not a recognised matrix type - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - // NOTE: but fall through to return 0,0... - *nrows = 0; - *ncols = 0; - -} - /*============================================================ CG CONTEXT ============================================================ */ @@ -7063,32 +5381,6 @@ CGGL_API void cgGLSetParameterPointer( CGparameter param, pointer ); // data pointer } -CGGL_API void cgGLAttribPointer( GLuint index, GLint fsize, GLenum type, GLboolean normalize, GLsizei stride, const GLvoid *pointer ) -{ - rglVertexAttribPointerNV( - index, // attribute index - fsize, // element size - type, // GL_FLOAT - normalize, - stride, // element to element in bytes - pointer ); // data pointer -} - -CGGL_API void cgGLAttribValues( GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w ) -{ - rglVertexAttrib4fNV( index, x, y, z, w ); -} - -CGGL_API void cgGLEnableAttrib( GLuint index ) -{ - rglEnableVertexAttribArrayNV( index ); -} - -CGGL_API void cgGLDisableAttrib( GLuint index ) -{ - rglDisableVertexAttribArrayNV( index ); -} - CGGL_API void cgGLEnableClientState( CGparameter param ) { CgRuntimeParameter *_ptr = rglCgGLTestParameter( param ); @@ -7120,235 +5412,6 @@ CGGL_API void cgGLSetMatrixParameterfc( CGparameter param, const float *matrix ) ptr->settercIndex( ptr, matrix, CG_GETINDEX( param ) ); } -CGGL_API void cgGLSetMatrixParameterfr( CGparameter param, const float *matrix ) -{ - - CgRuntimeParameter *ptr = rglCgGLTestParameter( param ); - ptr->setterrIndex( ptr, matrix, CG_GETINDEX( param ) ); -} - -CGGL_API void cgGLGetMatrixParameterfr( CGparameter param, float *matrix ) -{ - - //check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return; - - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - if (( parameterEntry->flags & CGP_TYPE_MASK ) != CGP_INTRINSIC || - (( parameterEntry->flags & CGPV_MASK ) != CGPV_UNIFORM && ( parameterEntry->flags & CGPV_MASK ) != CGPV_CONSTANT ) ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return; - } - - // uniforms only - float* value = rglGetUniformValuePtr( param, rtParameter ); - if ( !value ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return; - } - - CGtype parameterType = rglGetParameterCGtype( rtParameter->program, parameterEntry ); - unsigned int rows = rglGetTypeRowCount( parameterType ); - unsigned int cols = rglGetTypeColCount( parameterType ); - - if ( rows == 0 ) - { - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - return; - } - - /* peek into argument block */ - for ( GLuint i = 0; i < rows; ++i ) - for ( GLuint j = 0; j < cols; ++j ) - matrix[i*cols + j] = value[i * 4 + j]; -} - -CGGL_API void cgGLGetMatrixParameterfc( CGparameter param, float *matrix ) -{ - - //check parameter handle - CgRuntimeParameter *rtParameter = ( CgRuntimeParameter* )rglCgGLTestParameter( param ); - if ( !rtParameter ) - return; - - const CgParameterEntry *parameterEntry = rtParameter->parameterEntry; - if (( parameterEntry->flags & CGP_TYPE_MASK ) != CGP_INTRINSIC || - (( parameterEntry->flags & CGPV_MASK ) != CGPV_UNIFORM && ( parameterEntry->flags & CGPV_MASK ) != CGPV_CONSTANT ) ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return; - } - - float* value = rglGetUniformValuePtr( param, rtParameter ); - if ( !value ) - { - rglCgRaiseError( CG_INVALID_PARAMETER_ERROR ); - return; - } - - CGtype parameterType = rglGetParameterCGtype( rtParameter->program, parameterEntry ); - unsigned int rows = rglGetTypeRowCount( parameterType ); - unsigned int cols = rglGetTypeColCount( parameterType ); - - if ( rows == 0 ) - { - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - return; - } - - /* peek into argument block */ - for ( GLuint i = 0; i < rows; ++i ) - for ( GLuint j = 0; j < cols; ++j ) - matrix[i*cols + j] = value[i + j * 4]; -} - -CGGL_API void cgGLSetMatrixParameterArrayfc( CGparameter param, - long offset, - long nelements, - const float *matrices ) -{ - - CgRuntimeParameter* _ptr = _cgGLTestArrayParameter( param, offset, nelements ); - const CgParameterEntry *parameterEntry = _ptr->parameterEntry; - - if ( nelements == 0 ) - { - const CgParameterArray *parameterArray = rglGetParameterArray( _ptr->program, parameterEntry ); - nelements = rglGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount ) - offset; - } - //we have an array here, the parameterEntry of the type is the next one - _ptr++; - //get the type stride - CGtype parameterType = rglGetParameterCGtype( _ptr->program, _ptr->parameterEntry ); - unsigned int melems = rglGetTypeRowCount( parameterType ) * rglGetTypeColCount( parameterType ); - - // loop over array elements - for ( int i = 0; i < nelements; ++i ) - { - _ptr->settercIndex( _ptr, matrices + i * melems, i + offset ); - } -} - -CGGL_API void cgGLSetMatrixParameterArrayfr( CGparameter param, - long offset, - long nelements, - const float *matrices ) -{ - - CgRuntimeParameter *_ptr = _cgGLTestArrayParameter( param, offset, nelements ); - const CgParameterEntry *parameterEntry = _ptr->parameterEntry; - - if ( nelements == 0 ) - { - const CgParameterArray *parameterArray = rglGetParameterArray( _ptr->program, parameterEntry ); - nelements = rglGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount ) - offset; - } - //we have an array here, the parameterEntry of the type is the next one - _ptr++; - //get the type stride - CGtype parameterType = rglGetParameterCGtype( _ptr->program, _ptr->parameterEntry ); - unsigned int melems = rglGetTypeRowCount( parameterType ) * rglGetTypeColCount( parameterType ); - - // loop over array elements - for ( int i = 0; i < nelements; ++i ) - { - _ptr->setterrIndex( _ptr, matrices + i * melems, i + offset ); - } -} - -CGGL_API void cgGLGetMatrixParameterArrayfc( CGparameter param, - long offset, - long nelements, - float *matrices ) -{ - CgRuntimeParameter *_ptr = _cgGLTestArrayParameter( param, offset, nelements ); - if ( RGL_LIKELY( _ptr != NULL ) ) - { - const CgParameterEntry *parameterEntry = _ptr->parameterEntry; - if ( nelements == 0 ) - { - const CgParameterArray *parameterArray = rglGetParameterArray( _ptr->program, parameterEntry ); - nelements = rglGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount ) - offset; - } - //we have an array here, the parameterEntry of the type is the next one - _ptr++; - - parameterEntry = _ptr->parameterEntry; - if (( parameterEntry->flags & CGP_TYPE_MASK ) != CGP_INTRINSIC || - (( parameterEntry->flags & CGPV_MASK ) != CGPV_UNIFORM && ( parameterEntry->flags & CGPV_MASK ) != CGPV_CONSTANT ) ) - { - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - return; - } - - int arrayID = ( int )_ptr->id; - - //get the type stride - CGtype parameterType = rglGetParameterCGtype( _ptr->program, _ptr->parameterEntry ); - unsigned int melems = rglGetTypeRowCount( parameterType ) * rglGetTypeColCount( parameterType ); - if ( !melems ) - { - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - return ; - } - // loop over array elements - for ( int i = 0; i < nelements; ++i ) - { - int arrayParameter = arrayID | (( i + offset ) << CG_PARAMETERSIZE ); - cgGLGetMatrixParameterfc(( CGparameter )arrayParameter, matrices + i*melems ); - } - } - -} - -CGGL_API void cgGLGetMatrixParameterArrayfr( CGparameter param, - long offset, - long nelements, - float *matrices ) -{ - CgRuntimeParameter *_ptr = _cgGLTestArrayParameter( param, offset, nelements ); - if ( RGL_LIKELY( _ptr != NULL ) ) - { - const CgParameterEntry *parameterEntry = _ptr->parameterEntry; - if ( nelements == 0 ) - { - const CgParameterArray *parameterArray = rglGetParameterArray( _ptr->program, parameterEntry ); - nelements = rglGetSizeofSubArray( parameterArray->dimensions, parameterArray->dimensionCount ) - offset; - } - //we have an array here, the parameterEntry of the type is the next one - _ptr++; - parameterEntry = _ptr->parameterEntry; - if (( parameterEntry->flags & CGP_TYPE_MASK ) != CGP_INTRINSIC || - (( parameterEntry->flags & CGPV_MASK ) != CGPV_UNIFORM && ( parameterEntry->flags & CGPV_MASK ) != CGPV_CONSTANT ) ) - { - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - return; - } - - int arrayID = ( int )_ptr->id; - - //get the type stride - CGtype parameterType = rglGetParameterCGtype( _ptr->program, _ptr->parameterEntry ); - unsigned int melems = rglGetTypeRowCount( parameterType ) * rglGetTypeColCount( parameterType ); - if ( !melems ) - { - rglCgRaiseError( CG_NOT_MATRIX_PARAM_ERROR ); - return ; - } - // loop over array elements - for ( int i = 0; i < nelements; ++i ) - { - int arrayParameter = arrayID | (( i + offset ) << CG_PARAMETERSIZE ); - cgGLGetMatrixParameterfr(( CGparameter )arrayParameter, matrices + i*melems ); - } - } - -} - CGGL_API void cgGLSetTextureParameter( CGparameter param, GLuint texobj ) { // According to the cg implementation from nvidia, set just stores the obj. @@ -7408,75 +5471,10 @@ CGGL_API GLenum cgGLGetTextureEnum( CGparameter param ) return GL_TEXTURE0 + parameterResource->resource - CG_TEXUNIT0; } -void cgGLSetParameter1b( CGparameter param, CGbool v ) -{ - CgRuntimeParameter* ptr = rglCgGLTestParameter( param ); - if ( !ptr->parameterEntry->flags & CGPF_REFERENCED ) //ignore - return; - - _CGprogram* program = ptr->program; - - const CgParameterResource *parameterResource = rglGetParameterResource( program, ptr->parameterEntry ); - - // not sure what to do if no program like for global effect params that can be connected - // maybe actually do the propagation?! - if ( program ) - { - unsigned short resource = parameterResource->resource; - - unsigned int isShared = ( 1 << resource ) & ( program->parentContext->controlFlowBoolsSharedMask ); - unsigned int mask = ( 1 << resource ); - - // if the parameter is shared, initialize bools from context, otherwise from program - unsigned int bools = isShared ? program->parentContext->controlFlowBoolsShared : program->controlFlowBools; - - // set or unset the appropriate bit - if ( v ) - { - bools |= mask; - } - else - { - mask = ~mask; - bools &= mask; - } - - if ( isShared ) - { - program->parentContext->controlFlowBoolsShared = bools; - } - else - { - program->controlFlowBools = bools; - } - - _CurrentContext->needValidate |= RGL_VALIDATE_VERTEX_CONSTANTS; - } -} - CGGL_API void cgGLSetDebugMode( CGbool debug ) { } -unsigned int cgGLGetRegisterCount( CGprogram program ) -{ - _CGprogram* ptr = _cgGetProgPtr( program ); - return rglGetProgramProfileIndex(( CGprofile )ptr->header.profile ) == FRAGMENT_PROFILE_INDEX ? - ptr->header.fragmentProgram.registerCount : ptr->header.vertexProgram.registerCount; -} - - -void cgGLSetRegisterCount( CGprogram program, const unsigned int regCount ) -{ - _CGprogram* ptr = _cgGetProgPtr( program ); - if ( rglGetProgramProfileIndex(( CGprofile )ptr->header.profile ) == FRAGMENT_PROFILE_INDEX ) - { - ptr->header.fragmentProgram.registerCount = regCount; - if ( _CurrentContext->BoundFragmentProgram == program ) - _CurrentContext->needValidate |= RGL_VALIDATE_FRAGMENT_PROGRAM; - } -} - /*============================================================ CG NV2ELF ============================================================ */ diff --git a/ps3/rgl/src/ps3/rgl_ps3_raster.cpp b/ps3/rgl/src/ps3/rgl_ps3_raster.cpp index 882040c744..bb5eb5f93c 100644 --- a/ps3/rgl/src/ps3/rgl_ps3_raster.cpp +++ b/ps3/rgl/src/ps3/rgl_ps3_raster.cpp @@ -770,15 +770,12 @@ void rglCreatePushBuffer(void *data) if ( containerEntry == NULL ) containerEntry = parameterEntry; - //rtParameter->setter = _cgRaiseInvalidParam; - //rtParameter->setterr = _cgRaiseNotMatrixParam; - //rtParameter->setterc = _cgRaiseNotMatrixParam; - rtParameter->samplerSetter = _cgRaiseInvalidParamIndex; + rtParameter->samplerSetter = _cgIgnoreParamIndex; //tentative - rtParameter->setterIndex = _cgRaiseInvalidParamIndex; - rtParameter->setterrIndex = _cgRaiseNotMatrixParamIndex; - rtParameter->settercIndex = _cgRaiseNotMatrixParamIndex; + rtParameter->setterIndex = _cgIgnoreParamIndex; + rtParameter->setterrIndex = _cgIgnoreParamIndex; + rtParameter->settercIndex = _cgIgnoreParamIndex; CGparameter id = ( CGparameter )rglCreateName( &_CurrentContext->cgParameterNameSpace, ( void* )rtParameter ); if ( !id ) @@ -833,7 +830,7 @@ void rglCreatePushBuffer(void *data) // the parameters should have a "validate" function instead if ( profileIndex == VERTEX_PROFILE_INDEX ) { - rtParameter->setterIndex = _cgIgnoreSetParamIndex; + rtParameter->setterIndex = _cgIgnoreParamIndex; rtParameter->samplerSetter = setSamplervp; } else @@ -1001,17 +998,17 @@ void rglCreatePushBuffer(void *data) { case CG_FLOAT: case CG_FLOAT1: case CG_FLOAT2: case CG_FLOAT3: case CG_FLOAT4: - rtParameter->setterIndex = _cgIgnoreSetParamIndex; + rtParameter->setterIndex = _cgIgnoreParamIndex; break; case CG_FLOAT1x1: case CG_FLOAT1x2: case CG_FLOAT1x3: case CG_FLOAT1x4: case CG_FLOAT2x1: case CG_FLOAT2x2: case CG_FLOAT2x3: case CG_FLOAT2x4: case CG_FLOAT3x1: case CG_FLOAT3x2: case CG_FLOAT3x3: case CG_FLOAT3x4: case CG_FLOAT4x1: case CG_FLOAT4x2: case CG_FLOAT4x3: case CG_FLOAT4x4: - rtParameter->setterrIndex = _cgIgnoreSetParamIndex; - rtParameter->settercIndex = _cgIgnoreSetParamIndex; + rtParameter->setterrIndex = _cgIgnoreParamIndex; + rtParameter->settercIndex = _cgIgnoreParamIndex; break; case CG_SAMPLER1D: case CG_SAMPLER2D: case CG_SAMPLER3D: case CG_SAMPLERRECT: case CG_SAMPLERCUBE: - rtParameter->samplerSetter = _cgIgnoreSetParamIndex; + rtParameter->samplerSetter = _cgIgnoreParamIndex; break; case CGP_SCF_BOOL: break; @@ -1023,7 +1020,7 @@ void rglCreatePushBuffer(void *data) case CG_BOOL1: case CG_BOOL2: case CG_BOOL3: case CG_BOOL4: case CG_FIXED: case CG_FIXED1: case CG_FIXED2: case CG_FIXED3: case CG_FIXED4: - rtParameter->setterIndex = _cgIgnoreSetParamIndex; + rtParameter->setterIndex = _cgIgnoreParamIndex; break; case CG_HALF1x1: case CG_HALF1x2: case CG_HALF1x3: case CG_HALF1x4: case CG_HALF2x1: case CG_HALF2x2: case CG_HALF2x3: case CG_HALF2x4: @@ -1041,8 +1038,8 @@ void rglCreatePushBuffer(void *data) case CG_FIXED2x1: case CG_FIXED2x2: case CG_FIXED2x3: case CG_FIXED2x4: case CG_FIXED3x1: case CG_FIXED3x2: case CG_FIXED3x3: case CG_FIXED3x4: case CG_FIXED4x1: case CG_FIXED4x2: case CG_FIXED4x3: case CG_FIXED4x4: - rtParameter->setterrIndex = _cgIgnoreSetParamIndex; - rtParameter->settercIndex = _cgIgnoreSetParamIndex; + rtParameter->setterrIndex = _cgIgnoreParamIndex; + rtParameter->settercIndex = _cgIgnoreParamIndex; break; // addition to be compatible with cgc 2.0 case CG_STRING: