/* converting a CellMatrix to a MG_Matrix */ MG_Matrix FromCellMatrixToMGMatrix(const CellMatrix& aCM) { size_t vRows(aCM.RowsInStructure()), vCols(aCM.ColumnsInStructure()); MG_Matrix vMat(vRows, vCols); for(size_t i=0; i<vRows; ++i) for(size_t j=0; j<vCols; ++j) vMat(i, j) = aCM(i, j).NumericValue(); return vMat; }
bool CFont::InitModel() { static CStrAny sPlain(ST_CONST, "Plain"); static CStrAny sg_mWorld(ST_CONST, "g_mWorld"); static CStrAny sg_mView(ST_CONST, "g_mView"); static CStrAny sg_mProj(ST_CONST, "g_mProj"); static CStrAny sg_mTexTransform(ST_CONST, "g_mTexTransform"); static CStrAny sg_cMaterialDiffuse(ST_CONST, "g_cMaterialDiffuse"); static CStrAny sg_txDiffuse(ST_CONST, "g_txDiffuse"); static CStrAny sg_sDiffuse(ST_CONST, "g_sDiffuse"); ASSERT(!m_pTextModel); bool bRes; CTechnique *pTech = CGraphics::Get()->GetTechnique(sPlain); if (!pTech) return false; CSmartPtr<CGeometry> pGeom(new CGeometry()); bRes = pGeom->Init(pTech->m_pInputDesc, CGeometry::PT_TRIANGLELIST, INIT_BUFFER_CHARS * 4, INIT_BUFFER_CHARS * 6, 0, 0, CResource::RF_DYNAMIC | CResource::RF_KEEPSYSTEMCOPY, CResource::RF_DYNAMIC | CResource::RF_KEEPSYSTEMCOPY); if (!bRes) return false; CSmartPtr<CMaterial> pMaterial(new CMaterial()); bRes = pMaterial->Init(pTech, true, 0); if (!bRes) return false; CSmartPtr<CModel> pModel(new CModel()); bRes = pModel->Init(pGeom, pMaterial, 0, false); if (!bRes) return false; m_pTextModel = pModel; CMatrix<4, 4> mIdentity; mIdentity.SetDiagonal(); CMatrixVar vMat(4, 4, CMatrixVar::MVF_OWNVALUES, &mIdentity(0, 0)); m_pTextModel->SetVar(sg_mProj, vMat); m_pTextModel->SetVar(sg_mView, vMat); m_pTextModel->SetVar(sg_mWorld, vMat); CMatrix<3, 2> mTexIdentity; mTexIdentity.SetDiagonal(); CMatrixVar vTexMat(3, 2, CMatrixVar::MVF_OWNVALUES, &mTexIdentity(0, 0)); m_pTextModel->SetVar(sg_mTexTransform, vTexMat); CVar<CVector<4> > vVec4; vVec4.Val().Set(1, 1, 1, 1); m_pTextModel->SetVar(sg_cMaterialDiffuse, vVec4); CVar<CTexture *> vTexVar; vTexVar.Val() = m_pTexture; m_pTextModel->SetVar(sg_txDiffuse, vTexVar); CVar<CSampler *> vSampVar; vSampVar.Val() = CGraphics::Get()->GetSampler(CSampler::TDesc()); m_pTextModel->SetVar(sg_sDiffuse, vSampVar); ResetModel(); return true; }
void LukasKanadeOpticalFlow::drawMotionField_GPU(cv::gpu::GpuMat &imgU, cv::gpu::GpuMat &imgV, cv::gpu::GpuMat &imgMotion, int xSpace, int ySpace, float minCutoff, float maxCutoff, float multiplier, CvScalar color) { cv::Mat uMat( imgU ); cv::Mat vMat( imgV ); cv::Mat drawMat(cv::Size( imgU.size().width, imgU.size().height), CV_8UC3 ); int x = 0, y = 0; float *ptri; float deltaX = 0.0, deltaY = 0.0, angle = 0.0, hyp = 0.0; cv::Point p0, p1; for( y = ySpace; y < uMat.rows; y += ySpace ) { for(x = xSpace; x < uMat.cols; x += xSpace ) { p0.x = x; p0.y = y; ptri = uMat.ptr<float>(y); deltaX = ptri[x]; ptri = vMat.ptr<float>(y); deltaY = ptri[x]; angle = atan2(deltaY, deltaX); hyp = sqrt(deltaX*deltaX + deltaY*deltaY); if( hyp > minCutoff && hyp < maxCutoff ) { p1.x = p0.x + cvRound(multiplier*hyp*cos(angle)); p1.y = p0.y + cvRound(multiplier*hyp*sin(angle)); cv::line(drawMat,p0,p1,color,1,CV_AA,0); /* p0.x = p1.x + cvRound(2*cos(angle-M_PI + M_PI/4)); p0.y = p1.y + cvRound(2*sin(angle-M_PI + M_PI/4)); cv::line( imgMotion, p0, p1, color,1, CV_AA, 0); p0.x = p1.x + cvRound(2*cos(angle-M_PI - M_PI/4)); p0.y = p1.y + cvRound(2*sin(angle-M_PI - M_PI/4)); cv::line( imgMotion, p0, p1, color,1, CV_AA, 0); */ } } } imgMotion.upload( drawMat ); }
void LukasKanadeOpticalFlow::apply( cv::gpu::GpuMat * _gpu_frame ) { // create new local copy cv::gpu::GpuMat newMat; // convert to 8bit greyscale cv::gpu::cvtColor( *_gpu_frame, newMat, CV_BGRA2GRAY ); if( newMat.size() != last_gpu_frame.size() ) { // if the roi was resized, resie the last_gpu_frame, too last_gpu_frame = cv::gpu::GpuMat( newMat.rows, newMat.cols, CV_8UC1 ); } if( last_gpu_frame.type() == newMat.type() ) { // do the flow calculation dflow_lukaskanade.dense( last_gpu_frame, newMat, uGPU, vGPU ); } // copy the current frame to the last frame, necessary for computing the next flow newMat.copyTo( last_gpu_frame ); cv::Mat uMat( uGPU ); cv::Mat vMat( vGPU ); std::cout << "neMat type:" << newMat.type() << std::endl; cv::gpu::cvtColor( newMat, newMat, CV_GRAY2BGR ); cv::Mat drawMat( newMat.rows, newMat.cols, newMat.type() ); //drawMotionField_GPU( uGPU, vGPU, newMat, 10, 10, 0.0, 40.0, 1.0, CV_RGB( 230, 230, 230 ) ); drawColorField( uMat, vMat, drawMat ); //drawMotionField( uMat, vMat, drawMat, 10, 10, 20, 100, 1.0, cv::Scalar( 255, 0, 0 ) ); cv::cvtColor( drawMat, drawMat, CV_BGR2RGBA ); _gpu_frame->upload( drawMat ); //newMat.copyTo( *_gpu_frame ); }
//----------------------------------------------------------------------------- // Purpose: //----------------------------------------------------------------------------- void CParticleProperty::UpdateControlPoint( ParticleEffectList_t *pEffect, int iPoint, bool bInitializing ) { ParticleControlPoint_t *pPoint = &pEffect->pControlPoints[iPoint]; if ( !pPoint->hEntity.Get() ) { if ( pPoint->iAttachType == PATTACH_WORLDORIGIN && bInitializing ) { pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, Vector(1,0,0), Vector(0,1,0), Vector(0,0,1) ); pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, pPoint->vecOriginOffset ); pEffect->pParticleEffect->SetSortOrigin( pPoint->vecOriginOffset ); } pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, NULL ); return; } // Only update non-follow particles when we're initializing, // unless we're parented to something, in which case we should always update if ( !bInitializing && !pPoint->hEntity->GetMoveParent() && (pPoint->iAttachType == PATTACH_ABSORIGIN || pPoint->iAttachType == PATTACH_POINT ) ) return; if ( pPoint->iAttachType == PATTACH_CUSTOMORIGIN ) return; Vector vecOrigin, vecForward, vecRight, vecUp; float flOffset = 0.0f; bool bUsingHeadOrigin = false; #ifdef TF_CLIENT_DLL CBaseEntity *pWearable = (CBaseEntity*) pPoint->hEntity.Get(); if ( pWearable && dynamic_cast<IHasAttributes*>( pWearable ) && !pWearable->IsPlayer() ) { C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating(); if ( pAnimating ) { int bUseHeadOrigin = 0; CALL_ATTRIB_HOOK_INT_ON_OTHER( pPoint->hEntity.Get(), bUseHeadOrigin, particle_effect_use_head_origin ); if ( bUseHeadOrigin > 0 ) { int iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "bip_head" ); if ( iBone < 0 ) { iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "prp_helmet" ); if ( iBone < 0 ) { iBone = Studio_BoneIndexByName( pAnimating->GetModelPtr(), "prp_hat" ); } } if ( iBone >= 0 ) { bUsingHeadOrigin = true; const matrix3x4_t headBone = pAnimating->GetBone( iBone ); MatrixVectors( headBone, &vecForward, &vecRight, &vecUp ); MatrixPosition( headBone, vecOrigin ); CALL_ATTRIB_HOOK_FLOAT_ON_OTHER( pPoint->hEntity.Get(), flOffset, particle_effect_vertical_offset ); } } } } #endif if ( !bUsingHeadOrigin ) { switch ( pPoint->iAttachType ) { case PATTACH_POINT: case PATTACH_POINT_FOLLOW: { C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating(); Assert( pAnimating ); if ( pAnimating ) { matrix3x4_t attachmentToWorld; if ( !pAnimating->GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) ) { // try C_BaseAnimating if attach point is not on the weapon if ( !pAnimating->C_BaseAnimating::GetAttachment( pPoint->iAttachmentPoint, attachmentToWorld ) ) { Warning( "Cannot update control point %d for effect '%s'.\n", pPoint->iAttachmentPoint, pEffect->pParticleEffect->GetEffectName() ); attachmentToWorld = pAnimating->RenderableToWorldTransform(); } } VMatrix vMat(attachmentToWorld); MatrixTranslate( vMat, pPoint->vecOriginOffset ); MatrixVectors( vMat.As3x4(), &vecForward, &vecRight, &vecUp ); MatrixPosition( vMat.As3x4(), vecOrigin ); if ( pEffect->pParticleEffect->m_pDef->IsViewModelEffect() ) { FormatViewModelAttachment( vecOrigin, true ); } } } break; case PATTACH_ABSORIGIN: case PATTACH_ABSORIGIN_FOLLOW: default: { vecOrigin = pPoint->hEntity->GetAbsOrigin() + pPoint->vecOriginOffset; pPoint->hEntity->GetVectors( &vecForward, &vecRight, &vecUp ); } break; case PATTACH_ROOTBONE_FOLLOW: { C_BaseAnimating *pAnimating = pPoint->hEntity->GetBaseAnimating(); Assert( pAnimating ); if ( pAnimating ) { matrix3x4_t rootBone; if ( pAnimating->GetRootBone( rootBone ) ) { MatrixVectors( rootBone, &vecForward, &vecRight, &vecUp ); MatrixPosition( rootBone, vecOrigin ); } } } break; } } Vector vecForcedOriginOffset( 0, 0, flOffset ); pEffect->pParticleEffect->SetControlPointOrientation( pPoint->iControlPoint, vecForward, vecRight, vecUp ); pEffect->pParticleEffect->SetControlPointEntity( pPoint->iControlPoint, pPoint->hEntity ); pEffect->pParticleEffect->SetControlPoint( pPoint->iControlPoint, vecOrigin + vecForcedOriginOffset ); pEffect->pParticleEffect->SetSortOrigin( vecOrigin + vecForcedOriginOffset); }