C++ cVector类代码示例

void cMatrix::TranslationMatrix (cVector vector)
{
  Identity ();
  m_fields[0][3] = vector.x ();
  m_fields[1][3] = vector.y ();
  m_fields[2][3] = vector.z ();
}

void cMatrix::RotationMatrix (cVector axis, float angle)    // Creates a rotation matrix
{
  float V[3];
  int i;

  axis.Normalize ();

  for (i = 0; i < 3; i++)

  V[i] = axis.field (i);

  float c = cos (angle);
  float c1 = 1.0f - c;
  float s = sin (angle);

  m_fields[0][0] = V[0] * V[0] * c1 + c;
  m_fields[1][0] = V[0] * V[1] * c1 - V[2] * s;
  m_fields[2][0] = V[0] * V[2] * c1 + V[1] * s;

  m_fields[0][1] = V[1] * V[0] * c1 + V[2] * s;
  m_fields[1][1] = V[1] * V[1] * c1 + c;
  m_fields[2][1] = V[1] * V[2] * c1 - V[0] * s;

  m_fields[0][2] = V[2] * V[0] * c1 - V[1] * s;
  m_fields[1][2] = V[2] * V[1] * c1 + V[0] * s;
  m_fields[2][2] = V[2] * V[2] * c1 + c;

  m_fields[3][3] = 1.0f;
  for (i = 0; i < 3; i++)
      {                         // fill rest with 0.0
        m_fields[i][3] = 0.0f;
        m_fields[3][i] = 0.0f;
      }
}

cVector cMatrix::ApplyRotation (cVector vector)
{
  cVector vectemp;
  for (int i = 0; i < 3; i++)
    vectemp.setField (i, m_fields[i][0] * vector.x () +
                      m_fields[i][1] * vector.y () +
                      m_fields[i][2] * vector.z ());
  return vectemp;
}

void cCritterViewer::setViewpoint(cVector toviewer, cVector lookatpoint, 
	BOOL trytoseewholeworld)
{
//First do some default setup stuff
	_fieldofviewangle = cCritterViewer::STARTFIELDOFVIEWANGLE;
	setSpeed(0.0);
#ifndef THREEDVECTORS //not THREEDVECTORS means the 2D case.
	_attitude = cMatrix(cVector2(1.0, 0.0), cVector2(0.0, 1.0), _position);
#else //THREEDVECTORS
	_attitude = cMatrix(-cVector::ZAXIS, -cVector::XAXIS, cVector::YAXIS, cVector::ZEROVECTOR);
		/* To get a reasonable default orientation, we arrange the viewer axes so that:  
		viewer x axis = world -z axis, viewer y axis = world -x axis, viewer z axis = world y axis.
		We pick this orientation so that if the viewer moves "forward" (along its tangent vector)
		it moves towards the world.  (We correct the mismatch between the coordinate systems in the 
		cCritterViewer::loadViewMatrix method, which has a long comment about this.)
		 Note that we will adjust _position (fourth column) later in this  call
		 with a moveTo, also we may rotate the _attitude a bit. */
	if (!_perspective) //Ortho view, simply move up.
	{
		_proportionofworldtoshow = 1.0; //Show all of a flat world.
		moveTo(lookatpoint + cCritterViewer::ORTHOZOFFSET * cVector::ZAXIS); // Get above the world
		_maxspeed = _maxspeedstandard = 0.5 * cCritterViewer::ORTHOZOFFSET; //Mimic perspective case.
	}
	else //_perspective
	{
		if (toviewer.isPracticallyZero()) //Not usable, so pick a real direction.
			toviewer = cVector::ZAXIS; //Default is straight up.
		if (trytoseewholeworld) /* Treat toviewer as a direction, and back off in that direction
			enough to see the whole world */
		{
			toviewer.normalize(); //Make it a unit vector.
			_proportionofworldtoshow = cCritterViewer::PROPORTIONOFWORLDTOSHOW;
			//Trying to show all of a world when flying around it, often leaves too big a space around it.
			Real furthestcornerdistance = pgame()->border().maxDistanceToCorner(lookatpoint); 
			Real tanangle = tan(_fieldofviewangle/2.0); /* We work with half the fov in this calculation, 
				the tanangle will be the ratio of visible distance to distance above the world,
				that is, tanangle = dr/dz, where
				Our dr is _proportionofworldtoshow * furthestcornerdistance, and
				our dz is the unknown seeallz height we need to back off to. 
				Swap tangangle and dz to get the next formula. */
			ASSERT(tanangle);
			Real seeallz = _proportionofworldtoshow * furthestcornerdistance / tanangle; 
			moveTo(lookatpoint + seeallz * toviewer);
		}
		else /*Not trytoseewholeworld.  In this case we don't normalize toviewer, instead	
			we treat it as a displacment from the lookatpoint. */
			moveTo(lookatpoint + toviewer);
		lookAt(lookatpoint);
		_maxspeed = _maxspeedstandard = 0.5 * (position()-lookatpoint).magnitude(); 
			/* Define the speed like this so it typically takes two seconds (1/0.5)
			to fly in to lookatpoint. */
		_lastgoodplayeroffset = position() - pgame()->pplayer()->position();
	}
#endif //THREEDVECTORS case
}

void cGraphicsMFC::vectorToPixel(cVector position, int &xpix, int &ypix, Real &zbuff)
{
/* I have to use a viewercorrection like in cGraphicsMFC::pixelToVector*/
	int tempx, tempy;
	cVector viewercorrection = _matrix.lastColumn();
	position += viewercorrection;
	_realpixelconverter.realToPixel(position.x(), position.y(), &tempx, &tempy);
	xpix = tempx;
	ypix = tempy;
	zbuff = 0.0;
}

cVector cVector::cross(cVector& in){
	sVector input = in.getVectorCoord();
	cVector ret = cVector(((m_sVectorData->y * input.z) - (m_sVectorData->z * input.y)),
		((m_sVectorData->z * input.x) - (m_sVectorData->x * input.z)),
		((m_sVectorData->x * input.y) - (m_sVectorData->y * input.x)));
	return ret;
}

void AddExcludes(pxnode pExcludes, cVector<cDetectExclude>& excludes, const char* pszProfile)
{
	if (!pExcludes)
		return;

	for (pxnode pExclude = pExcludes->first_child; pExclude; pExclude = pExclude->next)
	{
		if (pExclude->type != SBVT_STRING || !pExclude->pdata)
			continue;
		
		cStrObj path;
		path.assign(pExclude->pdata, cCP_UNICODE, pExclude->data_size);
		
		bool bFound = false;
		for (tDWORD i = 0; i < excludes.size(); ++i)
		{
			cDetectExclude& exclude = excludes[i];
			if (exclude.m_bEnable
				&& (exclude.m_nTriggers & cDetectExclude::fObjectMask)
				&& exclude.m_Object.m_strMask == path)
			{		
				if (exclude.m_aTaskList.find(pszProfile) == exclude.m_aTaskList.npos)
					exclude.m_aTaskList.push_back(pszProfile);
				bFound = true;
				break;
			}
		}
		if (bFound)
			continue;					
		
		cDetectExclude exclude;
		exclude.m_nTriggers |= cDetectExclude::fTaskList;
		exclude.m_Object.m_bRecurse = (!path.empty() && (path[path.length()-1] == '\\')) ? cTRUE : cFALSE;
		exclude.m_Object.m_strMask = path;
		exclude.m_aTaskList.push_back(pszProfile);
		excludes.push_back(exclude);
	}
}

	cVector build_condensation(const WorkSpaceGraph &graph) {
		vVector top_sort = topolog_sort< WorkSpaceGraph >(graph);
		
		in_sort.clear();
		out_sort.clear();
		used.clear();
		std::for_each(top_sort.rbegin(), top_sort.rend(), [&cond, &used, &in_sort, this] (const Vertex &v) {
			if (used.find(v) == used.end()) {
				this->dfs< Transposed >(v);
				cond.push_back(vSet(in_sort.begin(), in_sort.end()));
				in_sort.clear();
			}
		});

		return cond;
	}

float cVector::dot(cVector& in){
	sVector input = in.getVectorCoord();
	return (m_sVectorData->x * input.x) + (m_sVectorData->y * input.y) + (m_sVectorData->z*input.z);
}

bool cVector::equal(cVector& in){	
	float origin = this->length();
	float comp = in.length();
	if ((origin - comp) * (origin - comp) <= EPSILON*EPSILON) return true;
	else return false;
}

 void cParticle::SetAcceleration (cVector vector)
 {
   vec_acc[0] = vector.x ();
   vec_acc[1] = vector.y ();
   vec_acc[2] = vector.z ();
 }

void cVector::CrossProduct (cVector vector1, cVector vector2)
{
  Set (vector1.y () * vector2.z () - vector1.z () * vector2.y (), // = x
       vector1.z () * vector2.x () - vector1.x () * vector2.z (), // = y
       vector1.x () * vector2.y () - vector1.y () * vector2.x ()  // = z
    );
}

float cVector::DotProduct (cVector vector)
{
  return x () * vector.x () + y () * vector.y () + z () * vector.z ();
}

 void cParticle::Accelerate (cVector vector)
 {
   vec_speed[0] += vector.x ();
   vec_speed[1] += vector.y ();
   vec_speed[2] += vector.z ();
 }

void cDvbSubtitleBitmaps::Draw(cOsd *Osd)
{
  bool Scale = !(DoubleEqual(osdFactorX, 1.0) && DoubleEqual(osdFactorY, 1.0));
  bool AntiAlias = true;
  if (Scale && osdFactorX > 1.0 || osdFactorY > 1.0) {
     // Upscaling requires 8bpp:
     int Bpp[MAXOSDAREAS];
     for (int i = 0; i < numAreas; i++) {
         Bpp[i] = areas[i].bpp;
         areas[i].bpp = 8;
         }
     if (Osd->CanHandleAreas(areas, numAreas) != oeOk) {
        for (int i = 0; i < numAreas; i++)
            Bpp[i] = areas[i].bpp = Bpp[i];
        AntiAlias = false;
        }
     }
  if (Osd->SetAreas(areas, numAreas) == oeOk) {
     for (int i = 0; i < bitmaps.Size(); i++) {
         cBitmap *b = bitmaps[i];
         if (Scale)
            b = b->Scaled(osdFactorX, osdFactorY, AntiAlias);
         Osd->DrawBitmap(int(round(b->X0() * osdFactorX)), int(round(b->Y0() * osdFactorY)), *b);
         if (b != bitmaps[i])
            delete b;
         }
     Osd->Flush();
     }
}