C++ Orientation类代码示例

ZString GetString(int indent, const Orientation& orient)
{
    return
          "Orientation("
        + GetString(indent, orient.GetUp()) + ", "
        + GetString(indent, orient.GetForward()) + ")";
}

void ManaZoneRenderer::updateCard(CardModel* model, Card* card, int pos, int size, int hovercard)
{
	Orientation o;
	o.pos = glm::vec3(mPos.x + mWidth - CONST_CARDSEPERATION_HORI*pos - CONST_CARDSEPERATION_HORI / 2, mPos.y, mPos.z + mHeight / 2);

	if (card->mIsTapped)
		o.dir = glm::vec3(1, 0, 0);
	else
		o.dir = glm::vec3(0, 0, -1);

	if (hovercard == card->mUniqueId)
	{
		o.pos = glm::vec3(gHighlightX, gHighlightY, gHighlightZ);
		o.dir = glm::vec3(0, 0, 1);
	}

	o.up = glm::vec3(0, 1, 0);
	o.calculateQuat();

	if (hovercard == card->mUniqueId)
	{
		model->setHoverMovement(o, 1000);
	}
	else
	{
		model->setMovement(o, 1000);
	}
}

void    CmodelIGC::Update(Time now)
{
    // Model motion now handled by CclusterIGC
    float   dt = (now - m_lastUpdate);
    m_lastUpdate = now;

    if (m_visibleF)
    {
        //
        // set the thing's rotation
        //
        if (m_rotation.angle() != 0.0f)
        {
            if (m_decalF) {
                m_pThingSite->Spin(m_rotation.angle() * dt);
            }
            else
            {
                Orientation o (m_pHitTest->GetOrientation());
                o.PostRotate(m_rotation.axis(), m_rotation.angle() * dt);
                o.Renormalize();

                m_pHitTest->SetOrientation(o);
                m_pThingSite->SetOrientation(o);
            }
        }
    }
}

bool PoolTeeBox::Load(File* pf)
{
  // Get vertex.
  if (!pf->GetFloat(&m_teeVertex.x)  ||
      !pf->GetFloat(&m_teeVertex.y)  ||
      !pf->GetFloat(&m_teeVertex.z))
  {
    pf->ReportError("Failed to load tee box vertex.");
    return false;
  }

  m_bs.SetCentre(m_teeVertex);
  m_bs.SetRadius(TEE_BOX_DECAL_SIZE); 

  SetShadowSize(TEE_BOX_DECAL_SIZE); // TODO TEMP TEST
  CreateShadow();

  Orientation o;
  o.SetVertex(m_teeVertex);
  SetOrientation(o);

  TEE_BOX_DECAL_SIZE = Engine::Instance()->GetConfigFloat("golf_tee_size");

  return true;
}

    Matrix3e fromev(const energy xx,const energy yy,const energy zz,const Orientation& o) const {
        cout << "Converting " << o.ToString() << endl;
        Matrix3 intMatrix=o.GetAsMatrix();

        cout << "Rotation Matrix determinate:" << intMatrix.det().si << endl;;

	const static energy zero=0.0*Joules;
	Matrix3e in_eigen_frame(xx,  zero,zero, 
				zero,yy  ,zero, 
				zero,zero,zz   );
        //Undo the eigensystem decomposition
	Matrix3e result=intMatrix*in_eigen_frame*intMatrix.Inverted();
        return result;
    }

bool ThirdPersonCameraBase::Collision(const Orientation& before, const Orientation& after)
{
  const BoundingSphere& bs = *GetBoundingSphere();

  BoundingSphere bsBefore(before.GetVertex(), bs.GetRadius());
  BoundingSphere bsAfter(after.GetVertex(), bs.GetRadius());

  const WallPoly* pWp = m_heightServer.Intersects(bsBefore, bsAfter);
  if (pWp)
  {
    return true; // We do collide with something
  }
  return false; // No collision
}

TEST (Orientation, JSON) {
	VLOG(1) << "===Orientation JSON Test===";
	Orientation u { 20.0, -15.0, 60.0 };
	Orientation v;
	Value orient;
	
	orient = u.pack();
	VLOG_IF(orient.IsObject(), 2) << "Output JSON: " << orient;
	v.parse(orient);
	VLOG_IF(v.pack().IsObject(), 2) << "Parsed JSON: " << orient;
	EXPECT_TRUE(toleranceEquals(u.pitch, v.pitch, TOL));
	EXPECT_TRUE(toleranceEquals(u.roll, v.roll, TOL));
	EXPECT_TRUE(toleranceEquals(u.heading, v.heading, TOL));
}

int main(int argc, char **argv)
{
    QApplication app(argc, argv);
    OrientationView view;

    Orientation orientation;
    orientation.start();

    QObject::connect(&orientation, SIGNAL(orientation(qreal,qreal,qreal,qreal)),
                     &view, SLOT(orientation(qreal,qreal,qreal,qreal)));

    view.show();

    return app.exec();
}

    Position Position::operator*(const Orientation& orientation) const
    {
      Position result(*this) ;
      result.m_value = orientation.getQuaternion()*result.m_value ;

      return result ;
    }

 Force Force::operator*(const Orientation& i_orientation) const
 {
   Force result(*this) ;
   result.m_value = i_orientation.getQuaternion()* result.m_value ;
   return result ;
   
 }

int MovementComponent::turnTowards(float targetPosX, float targetPosY, float targetPosZ, float speed, bool putInQueue, const char* animName)
{	
	Vec3f target(targetPosX, targetPosY, targetPosZ);

	//if we don't want a queue, we must erase all existent movement nodes
	if(!putInQueue)
		clear();
	if(speed < 0)
		speed = m_speed; //use agent default

	//orient towards the target
	Orientation* o = new Orientation( m_eID, target, speed, false );
	o->setAnimation( (animName == 0) ? m_orientAnimName : animName );
	m_movementNodes.push_back( o );

	return o->getID();
}

void EngineStatePoolShowShot::Update()
{
  if (m_time < m_maxTime)
  {
    // POOL_ONLINE:
    // DON'T call EngineStatePoolBase::Update();
    // If the timer expires, the shot will be started, but we DON'T want to update
    //  the shot in this state, for consistency with the other (user-controlled) client.

    // If a moving ball is outside of the view frustum, pull the camera back.
    ((PoolCamera*)s_pCamera.GetPtr())->SetPoolPullBackRequired(s_movingBallNotInFrustum);
    s_movingBallNotInFrustum = false;

    GetCamera()->Update();

    if (!IsBirdsEye())
    {
      // Update the camera so it is always above the ball
      float camY = GetCamera()->GetOrientation()->GetY();
      float ballY = GetBall()->GetOrientation()->GetY();
      ballY += 1.0f; // TODO CONFIG
      if (camY < ballY)
      {
        Orientation o = *(GetCamera()->GetOrientation());
        o.SetY(ballY);
        GetCamera()->SetOrientation(o);
      }
    }
    // May call TimerExpired.....
    EngineState::Update();

    if (m_time < m_maxTime)
    {
      Assert(m_pLevel.GetPtr());
////      GetEngine()->GetDayNightSky()->Update();
      m_pLevel->GetScene()->Update();
      UpdateGameObjects();
    }
  }
  else
  {
    // DON'T update game objects
    EngineState::Update();
  }
}

	Orientation difference( Orientation other ) const{
		auto a = this->normalized();
		auto b = other.normalized();
		
		return { int8_t(b.rotation-a.rotation)
			,	a.flip_ver != b.flip_ver
			,	a.flip_hor != b.flip_hor
			};
	}

void Menu::run()
{
  Navigator<ContinuousRobotDriver> navigator;
  Orientation* orientation = Orientation::getInstance();

  gUserInterface.waitForHand();
  startMelody();

  enc_left_front_write(0);
  enc_right_front_write(0);
  enc_left_back_write(0);
  enc_right_back_write(0);
  orientation->resetHeading();

  navigator.findBox(PersistantStorage::getTargetXLocation(),
                    PersistantStorage::getTargetYLocation());
  searchFinishMelody();
  navigator.findBox(0, 0);
  stopMelody();
}

static SVGImageContext
OrientViewport(const SVGImageContext& aOldContext,
               const Orientation& aOrientation)
{
  CSSIntSize viewportSize(aOldContext.GetViewportSize());
  if (aOrientation.SwapsWidthAndHeight()) {
    swap(viewportSize.width, viewportSize.height);
  }
  return SVGImageContext(viewportSize,
                         aOldContext.GetPreserveAspectRatio());
}