예제 #1
0
void CgEffect::GetVector(const char* name, Vector4* v)
{
    float values[4];
    cgGetParameterValuefc(this->retrieveParameter(name), 4, values);

    *v = Vector4(values[0], values[1], values[2], values[4]);
}
예제 #2
0
    bool CgDxShader::getFloatVectorVariable(const char* name, float4& vec) {
        if(mProgram) {
            CGparameter param = cgGetNamedParameter(mProgram, name);
            if(_check_error(mContext) && param) {
                cgGetParameterValuefc(param, 4, (float*)vec.value);
                return _check_error(mContext);

            }
        }
        return false;
    }
예제 #3
0
void CgEffect::GetFloat(const char* name, float* f)
{
    cgGetParameterValuefc(this->retrieveParameter(name), 1, f);
}
예제 #4
0
// Call ProcessInput once per frame to process input keys
void ProcessInput( bool	keys[] )
{
	// These keys we don't want to auto-repeat, so we clear them in "keys" after handling them once
	if (keys['E'] && amplitudeGlobalParameter)
	{
		float value;
		cgGetParameterValuefc(amplitudeGlobalParameter, 1, &value);
		value += 0.1f;
		cgSetParameter1f(amplitudeGlobalParameter, value);
		keys['E'] = false;
	}
	if (keys['R'] && amplitudeGlobalParameter)
	{
		float value;
		cgGetParameterValuefc(amplitudeGlobalParameter,1, &value);
		value -= 0.1f;
		cgSetParameter1f(amplitudeGlobalParameter, value);
		keys['R'] = false;
	}
	if (keys[VK_TAB] )
	{
		// When 'C' is pressed, change cameras
		_CrtRender.SetNextCamera();
		keys[VK_TAB] = false;
	}

	if ( keys['M'] )
	{
		// Speed up UI by 25%
		AdjustUISpeed(1.25f);  
		keys['M'] = false;
	}
	if ( keys['N'] )
	{
		// Slow down UI by 25%
		AdjustUISpeed(0.75f);  // Go 25% slower
		keys['N'] = false;
	}
	if (keys['Q'])
	{
		if (togglewireframe) {
			glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
			togglewireframe = FALSE;
		} else {
			glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
			togglewireframe = TRUE;
		}
		keys['Q'] = false;
	}

	if (keys['K'])
	{
		if (togglehiearchy) {
			_CrtRender.SetShowHiearchy(CrtTrue);	
			togglehiearchy = FALSE;
		} else {
			_CrtRender.SetShowHiearchy(CrtFalse);
			togglehiearchy = TRUE;
		}
		keys['K'] = false;
	}
	if (keys['L'])
	{
		if (togglelighting) {
			glDisable(GL_LIGHTING);
			togglelighting = FALSE;
		} else {
			glEnable(GL_LIGHTING);
			togglelighting = TRUE;
		}
		keys['L'] = false;
	}

	if (keys['P'] )
	{
		if (sAnimationEnable) {
			_CrtRender.SetAnimationPaused( CrtTrue );
			sAnimationEnable = false;
		}
		else { 
			_CrtRender.SetAnimationPaused( CrtFalse ); 
			sAnimationEnable = true;
		}
		keys['P'] = false;
	}
	if (keys[VK_F1])		
	{
		keys[VK_F1]=FALSE;		
		_CrtRender.Destroy();
		DestroyGLWindow();			
		fullscreen=!fullscreen;		
		// Recreate Our OpenGL Window
		if (!CreateGLWindow("Collada Viewer for PC", _CrtRender.GetScreenWidth(), _CrtRender.GetScreenHeight(),32,fullscreen))
		{
			exit(1);
		}
		if ( !_CrtRender.Load( cleaned_file_name ))
		{
			exit(0);
		}

		keys[VK_F1] = false;
	}
	
	// These keys that do a function as long as they are held down, so we don't clear "keys".
	// Remember to scale these functions by time!

	if (keys['S'])
	{
		// UI code to move the camera closer
		_CrtRender.ActiveInstanceCamera->MoveTransform(_CrtRender.GetAnimDelta() * KeyboardTranslateSpeed *0.5f, 0.0f, 0.0f);
	}

	if (keys['W'])
	{
		// UI code to move the camera farther away
		_CrtRender.ActiveInstanceCamera->MoveTransform(- _CrtRender.GetAnimDelta() * KeyboardTranslateSpeed * 0.5f, 0.0f, 0.0f);
	}

	if (keys[VK_SPACE])
	{
		// UI code to move the camera farther up
		_CrtRender.ActiveInstanceCamera->MoveTransform(0.0f, 0.0f, _CrtRender.GetAnimDelta() * KeyboardTranslateSpeed);
	}

	if (keys['X'])
	{
		// UI code to move the camera farther down
		_CrtRender.ActiveInstanceCamera->MoveTransform(0.0f, 0.0f, - _CrtRender.GetAnimDelta() * KeyboardTranslateSpeed);
	}

	if (keys['D'])
	{
		// UI code to move the camera farther right
		_CrtRender.ActiveInstanceCamera->MoveTransform(0.0f, - _CrtRender.GetAnimDelta() * KeyboardTranslateSpeed, 0.0f);
	}

	if (keys['A'])
	{
		// UI code to move the camera farther left
		_CrtRender.ActiveInstanceCamera->MoveTransform(0.0f, _CrtRender.GetAnimDelta() * KeyboardTranslateSpeed, 0.0f);
	}

	if (keys['F'])
	{
		if(togglecullingface == 0)
		{ // turn it front
			glEnable( GL_CULL_FACE );
			glCullFace(GL_FRONT);
			togglecullingface = 1;
		} else if(togglecullingface == 1)
		{ // turn it both
			glDisable( GL_CULL_FACE );
			togglecullingface = 2;
		} else 
		{ // turn it back
			glEnable( GL_CULL_FACE );
			glCullFace(GL_BACK);
			togglecullingface = 0;
		}
		keys['F'] = false;
	}
}
예제 #5
0
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;
}