コード例 #1
0
ファイル: demo.cpp プロジェクト: issakomi/mmt
void print_info()
{
camera->orthographic( 0.0f,
                      static_cast<float>(win_w),
                      0.0f,
                      static_cast<float>(win_h),
                     -1.0f,
                      1.0f);

glEnable(GL_BLEND);
cgSetMatrixParameterfc(cgshaders->get_parameter(std::string("MODELVIEWPROJECTION")), camera->m_projection);
CGpass p0 = cgGetFirstPass(cgshaders->get_technique(std::string("bmf")));
cgSetPassState(p0);

glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, bmf_texture);
std::stringstream s11;
s11 << std::fixed << std::setprecision(0)
	<< mx << std::string(" ")
	<< my << std::string(" ")
	<< tmp0	<< std::string(" ")
	<< tmp1 << std::string(" ")
	<< fps_
	<< std::ends;
BMF_DrawStringTextureVBO((unsigned int)s11.str().size(),
                          bmf_font,
                          (char *)s11.str().c_str(),
                          (float)50,
                          (float)50);

//cgResetPassState(p0);
glDisable(GL_BLEND);
glBindTexture(GL_TEXTURE_2D, GL_NONE);
}
コード例 #2
0
ファイル: Effect.cpp プロジェクト: carlixyz/engin3d
void cEffect::SetParam(const std::string &lacName, const cMatrix &lMatrix)
{
	CGparameter lParam = cgGetNamedEffectParameter(mEffect, lacName.c_str() );
	if (lParam)
	{
		cgSetMatrixParameterfc(lParam, lMatrix.AsFloatPointer() );
	}
}
コード例 #3
0
 //
 // SetFloatMat4
 //
 void CCgUniform::SetFloatMat4( 
                               const Mat4& m, EMatrixOrder Order 
                               )
 {
     if (Order == MO_COLUMN_MAJOR)
         cgSetMatrixParameterfc( m_Parameter, &m[ 0 ][ 0 ] );
     else
         cgSetMatrixParameterfr( m_Parameter, &m[ 0 ][ 0 ] );
 }
コード例 #4
0
 bool CgDxShader::setMatrixVariable(const char* name, const Matrix4& mat) {
     if(mProgram) {
         CGparameter param = cgGetNamedParameter(mProgram, name);
         if(_check_error(mContext) && param) {
             cgSetMatrixParameterfc(param, (const float*)mat.x); 
             return _check_error(mContext);
         }
     }
     return false;
 }
コード例 #5
0
ファイル: cfxData.cpp プロジェクト: mDibyo/docker-files
bool cfxDataFloat4x4::apply(cfxParam* param) 
{
  // using column major matrix setting because i think that is what is used by COLLADA
    cgSetMatrixParameterfc(param->getParameter(), &data.f00);
  return true; 
}
コード例 #6
0
ファイル: CgEffect.cpp プロジェクト: G33KatWork/GeexEngine
void CgEffect::SetMatrix(const char* name, Matrix4& m)
{
    cgSetMatrixParameterfc(this->retrieveParameter(name), m[0]);
}
コード例 #7
0
ファイル: pubclass_shader.c プロジェクト: MSylvia/luxinia1
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;
}
コード例 #8
0
ファイル: ShaderParameterCg.cpp プロジェクト: Pocsel/pocsel
 void ShaderParameterCg::Set(glm::detail::tmat4x4<float> const& matrix, bool)
 {
     cgSetMatrixParameterfc(this->_param, (float*)&matrix);
 }
コード例 #9
0
ファイル: DXWindow.cpp プロジェクト: andyreimann/gear
void
DXWindow::startFrame()
{
	// clear the back buffer to a deep blue
	mDeviceContext->ClearRenderTargetView(mBackbuffer, D3DXCOLOR(0.0f, 0.2f, 0.4f, 1.0f));

	//Refresh the Depth/Stencil view
	mDeviceContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);

	// this struct holds Windows event messages
	MSG msg;
	// wait for the next message in the queue, store the result in 'msg'
	while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
	{
		// translate keystroke messages into the right format
		TranslateMessage(&msg);

		// send the message to the WindowProc function
		DispatchMessage(&msg);
	}

	// DRAWING
	{
		///////////////**************new**************////////////////////
		//Set the World/View/Projection matrix, then send it to constant buffer in effect file
		D3DXMatrixIdentity(&mWorld);

		WVP = mWorld * mCamView * mCamProjection;

		D3DXMATRIX WVPTranspose;
		D3DXMatrixTranspose(&WVPTranspose, &WVP);


#ifndef USE_CG
		cbPerObject.WVP = WVPTranspose;
		mDeviceContext->UpdateSubresource(cbPerObjectBuffer, 0, NULL, &cbPerObject, 0, 0);
		mDeviceContext->VSSetConstantBuffers(0, 1, &cbPerObjectBuffer);
#else
		CGparameter location = cgGetNamedParameter(mVertexShaderId, "mvp");
		// Write the TRANSPOSE matrix into the shader -> LH Coordinate System!
		cgSetMatrixParameterfc(location, (float*)WVPTranspose);
		// call bind again to update data of the shader
		cgD3D11BindProgram(mVertexShaderId);
#endif		
		///////////////**************new**************////////////////////
		



		// select which vertex buffer to display
		UINT stride = sizeof(VERTEX);
		UINT offset = 0;
		mDeviceContext->IASetVertexBuffers(0, 1, &mTriangleVertexBuffer, &stride, &offset);

		// select which primtive type we are using
		mDeviceContext->IASetPrimitiveTopology(D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST);

		// draw the vertex buffer to the back buffer
		mDeviceContext->Draw(3, 0);
	}
}