void ShaderParameterCg::Set(std::vector<glm::mat4x4> const& matrices) { if (!this->_preBuffer) { this->_preBuffer.reset(new std::vector<float>( cgGetParameterColumns(this->_param) * cgGetParameterRows(this->_param) * cgGetArrayTotalSize(this->_param) )); } std::memcpy(this->_preBuffer->data(), matrices.data(), sizeof(float) * std::min(this->_preBuffer->size(), matrices.size() * 4*4)); cgSetParameterValuefc(this->_param, (int)this->_preBuffer->size(), this->_preBuffer->data()); }
void cEffect::SetParam(const std::string &lacName, const float * lfParam, int liCount ) { static const unsigned kuiAuxiliarBuffer = 256 * 4; static float gFullArray[kuiAuxiliarBuffer]; CGparameter lParam = cgGetNamedEffectParameter(mEffect, lacName.c_str()); if (lParam) { int liNRows = cgGetParameterRows(lParam); int liNCols = cgGetParameterColumns(lParam); int liASize = cgGetArrayTotalSize(lParam); int liNTotal = liNRows*liNCols; if (liASize > 0) { liNTotal *= liASize; if ( liCount < liNTotal ) { assert(kuiAuxiliarBuffer > liNTotal); assert(kuiAuxiliarBuffer > liCount); memcpy(gFullArray, lfParam, sizeof(float) * liCount); cgSetParameterValuefr(lParam, liNTotal, gFullArray); } else { cgSetParameterValuefr(lParam, liCount, lfParam); } CGerror err = cgGetError(); if (err != CG_NO_ERROR) { OutputDebugStr(cgGetErrorString( err )); OutputDebugStr("\n"); } } } }
static void AddParameter(JSON &json, CGparameter param) { const char * const parameterName = cgGetParameterName(param); if (sVerbose) { puts(parameterName); } json.AddObject(parameterName); const CGtype type = cgGetParameterType(param); const CGtype baseType = cgGetParameterBaseType(param); int numRows = cgGetParameterRows(param); const int numColumns = cgGetParameterColumns(param); if (CG_ARRAY == type) { const int totalArraySize = cgGetArrayTotalSize(param); numRows *= totalArraySize; } json.AddString("type", cgGetTypeString(baseType)); if (1 < numRows) { json.AddValue("rows", numRows); } if (1 < numColumns) { json.AddValue("columns", numColumns); } const int maxNumElements = (numColumns * numRows); int n; if (CG_FLOAT == baseType) { float * const values = (float *)malloc(maxNumElements * sizeof(float)); const int numValues = cgGetParameterValuefr(param, maxNumElements, values); if (numValues) { for (n = 0; n < numValues; n++) { if (values[n] != 0.0f) { break; } } if (n < numValues) { json.AddArray("values", true); json.BeginData(true); for (n = 0; n < numValues; n++) { json.AddData(values[n]); } json.EndData(); json.CloseArray(true); } } free(values); } else if (CG_INT == baseType) { int * const values = (int *)malloc(maxNumElements * sizeof(int)); const int numValues = cgGetParameterValueir(param, maxNumElements, values); if (numValues) { for (n = 0; n < numValues; n++) { if (values[n]) { break; } } if (n < numValues) { json.AddArray("values", true); json.BeginData(true); for (n = 0; n < numValues; n++) { json.AddData(values[n]); } json.EndData(); json.CloseArray(true); } } free(values); } else if (CG_BOOL == baseType) { int * const values = (int *)malloc(maxNumElements * sizeof(int)); const int numValues = cgGetParameterValueir(param, maxNumElements, values); if (numValues) { for (n = 0; n < numValues; n++) { if (values[n]) { break; } } if (n < numValues) { json.AddArray("values", true); json.BeginData(true); for (n = 0; n < numValues; n++) { json.AddData(values[n]); } json.EndData(); json.CloseArray(true); } } free(values); } json.CloseObject(); // parameter }
static int PubCGparam_func (PState pstate,PubFunction_t *fn, int n) { CGparameter cgparam = NULL; if ((int)fn->upvalue > PCG_GET && (n<1 || FunctionPublish_getArg(pstate,1,LUXI_CLASS_CGPARAM,(void*)&cgparam)<1)) return FunctionPublish_returnError(pstate,"1 cgparam required"); switch((int)fn->upvalue){ case PCG_NEW: { char *name; char *nametype; CGtype cgtype; CGtype basetype; int cnt = 1; if (n < 2 || FunctionPublish_getArg(pstate,3,LUXI_CLASS_STRING,(void*)&name,LUXI_CLASS_STRING,(void*)&nametype,LUXI_CLASS_INT,(void*)&cnt)<2) return FunctionPublish_returnError(pstate,"2 strings required"); cgtype = cgGetType(nametype); basetype = cgGetTypeBase(cgtype); if (VIDCg_getConnector(name) || cgtype==CG_UNKNOWN_TYPE || (basetype != CG_FLOAT && basetype != CG_INT && basetype != CG_BOOL)) return FunctionPublish_returnError(pstate,"name already in use, or illegal cg base type (float, bool, int)"); if (cgGetTypeClass(cgtype) == CG_PARAMETERCLASS_MATRIX && basetype != CG_FLOAT) return FunctionPublish_returnError(pstate,"only float matrix parameters allowed"); cgparam = cnt > 1 ? cgCreateParameterArray(g_VID.cg.context,cgtype,cnt) : cgCreateParameter(g_VID.cg.context,cgtype); VIDCg_setConnector(name,cgparam); return FunctionPublish_returnType(pstate,LUXI_CLASS_CGPARAM,(void*)cgparam); } break; case PCG_DELETE: { int linked = cgGetNumConnectedToParameters(cgparam); if (linked == 0){ VIDCg_setConnector(cgGetParameterName(cgparam),NULL); cgDestroyParameter(cgparam); } return FunctionPublish_returnInt(pstate,linked); } break; case PCG_GET: { char *name; if (n < 1 || !FunctionPublish_getArg(pstate,1,LUXI_CLASS_STRING,(void*)&name)) return FunctionPublish_returnError(pstate,"1 string required"); cgparam = VIDCg_getConnector(name); if (cgparam) return FunctionPublish_returnType(pstate,LUXI_CLASS_CGPARAM,(void*)cgparam); else return 0; } break; case PCG_VALUE: { CGtype cgtype = cgGetParameterType(cgparam); CGtype basetype = cgGetTypeBase(cgtype); CGtype classtype = cgGetTypeClass(cgtype); lxClassType ctype; Reference ref; float *matrix; StaticArray_t *starray; int read = 0; int offset = 0; int size; int into = (int)fn->upvalue == PCG_VALUEINTO; if (n==1 || into){ int vector[4]; switch(classtype){ case CG_PARAMETERCLASS_SCALAR: case CG_PARAMETERCLASS_VECTOR: switch(basetype){ case CG_FLOAT: ctype = LUXI_CLASS_FLOAT; read = cgGetParameterValuefc(cgparam,4,(float*)vector); break; case CG_BOOL: ctype = LUXI_CLASS_BOOLEAN; read = cgGetParameterValueic(cgparam,4,vector); break; case CG_INT: ctype = LUXI_CLASS_INT; read = cgGetParameterValueic(cgparam,4,vector); break; default: return 0; } return FunctionPublish_setRet(pstate,read,ctype,(void*)vector[0],ctype,(void*)vector[1],ctype,(void*)vector[2],ctype,(void*)vector[3]); break; case CG_PARAMETERCLASS_MATRIX: if (into){ // get matrix first if (!FunctionPublish_getNArg(pstate,1,LUXI_CLASS_MATRIX44,(void*)&ref) || !Reference_get(ref,matrix)) return FunctionPublish_returnError(pstate,"1 matrix4x4 required"); } else{ // create matrix matrix = PubMatrix4x4_alloc(); ref = Reference_new(LUXI_CLASS_MATRIX44,matrix); Reference_makeVolatile(ref); } cgGetMatrixParameterfc(cgparam,matrix); return FunctionPublish_returnType(pstate,LUXI_CLASS_MATRIX44,REF2VOID(ref)); break; case CG_PARAMETERCLASS_ARRAY: ctype = basetype == CG_FLOAT ? LUXI_CLASS_FLOATARRAY : LUXI_CLASS_INTARRAY; size = cgGetParameterColumns(cgparam)*cgGetParameterRows(cgparam)*cgGetArrayTotalSize(cgparam); if (into){ // get array first if (FunctionPublish_getArgOffset(pstate,1,3,ctype,(void*)&ref,LUXI_CLASS_INT,(void*)&offset)<1 || !Reference_get(ref,starray) || offset+size > starray->count) return FunctionPublish_returnError(pstate,"1 staticarray [1 int] required (with enough space)"); } else{ // create array starray = StaticArray_new(size,ctype,NULL,NULL); } offset = LUX_MIN(offset,(starray->count-1)); read = LUX_MIN(read,(starray->count-offset)); if (ctype == LUXI_CLASS_FLOATARRAY) cgGetParameterValuefc(cgparam,read,starray->floats); else cgGetParameterValueic(cgparam,read,starray->ints); return FunctionPublish_returnType(pstate,ctype,REF2VOID(starray->ref)); } } else { // set lxVector4 vector; switch(classtype){ case CG_PARAMETERCLASS_SCALAR: case CG_PARAMETERCLASS_VECTOR: ctype = basetype == CG_FLOAT ? LUXI_CLASS_FLOAT : LUXI_CLASS_INT; read = FunctionPublish_getArgOffset(pstate,1,n-1,ctype,(void*)&vector[0],ctype,(void*)&vector[1],ctype,(void*)&vector[2],ctype,(void*)&vector[3]); if (read > 0){ switch(basetype){ case CG_FLOAT: cgSetParameterValuefc(cgparam,n-1,vector); return 0; case CG_BOOL: case CG_INT: cgSetParameterValueic(cgparam,n-1,(int*)vector); return 0; default: return 0; } } break; case CG_PARAMETERCLASS_MATRIX: if (!FunctionPublish_getNArg(pstate,1,LUXI_CLASS_MATRIX44,(void*)&ref) || !Reference_get(ref,matrix)) return FunctionPublish_returnError(pstate,"1 matrix4x4 required"); cgSetMatrixParameterfc(cgparam,matrix); return 0; case CG_PARAMETERCLASS_ARRAY: ctype = basetype == CG_FLOAT ? LUXI_CLASS_FLOATARRAY : LUXI_CLASS_INTARRAY; size = cgGetParameterColumns(cgparam)*cgGetParameterRows(cgparam)*cgGetArrayTotalSize(cgparam); if (FunctionPublish_getArgOffset(pstate,1,3,ctype,(void*)&ref,LUXI_CLASS_INT,(void*)&offset) || !Reference_get(ref,starray) || offset+size > starray->count) return FunctionPublish_returnError(pstate,"1 staticarray [2 ints] required, with enough space"); offset = LUX_MIN(offset,(starray->count-1)); if (ctype == LUXI_CLASS_FLOATARRAY) cgSetParameterValuefc(cgparam,size,&starray->floats[offset]); else cgSetParameterValueic(cgparam,size,&starray->ints[offset]); return 0; default: return 0; } } } case PCG_SIZES: return FunctionPublish_setRet(pstate,3,LUXI_CLASS_INT,(void*)cgGetParameterColumns(cgparam),LUXI_CLASS_INT,(void*)cgGetParameterRows(cgparam),LUXI_CLASS_INT,(void*)cgGetArrayTotalSize(cgparam)); default: break; } return 0; }