atifly.cpp

游戏编程精粹2第三章源码

               vertexArray[numVertices].color1.r = 255;
               vertexArray[numVertices].color1.g = 255;
               vertexArray[numVertices].color1.b = 0;
               numVertices++;
            }

            if ((j == 0) && (GetPathOrientation(&quat, x1) == TRUE))
            {
               AtiQuatToMatrix(&quat, matrix);
               GetPathPosition(&pos, x1);

               //This point
               vertexArray[numVertices].vertex.x = pos.x;
               vertexArray[numVertices].vertex.y = pos.y;
               vertexArray[numVertices].vertex.z = pos.z;
               vertexArray[numVertices].color1.r = 255;
               vertexArray[numVertices].color1.g = 255;
               vertexArray[numVertices].color1.b = 255;
               numVertices++;

               //Up Vector
               vertexArray[numVertices].vertex.x = pos.x + matrix[1]*ATI_FLY_CUBE_RADIUS*2.0f;
               vertexArray[numVertices].vertex.y = pos.y + matrix[5]*ATI_FLY_CUBE_RADIUS*2.0f;
               vertexArray[numVertices].vertex.z = pos.z + matrix[9]*ATI_FLY_CUBE_RADIUS*2.0f;
               vertexArray[numVertices].color1.r = 255;
               vertexArray[numVertices].color1.g = 255;
               vertexArray[numVertices].color1.b = 255;
               numVertices++;

               //This point
               vertexArray[numVertices].vertex.x = pos.x;
               vertexArray[numVertices].vertex.y = pos.y;
               vertexArray[numVertices].vertex.z = pos.z;
               vertexArray[numVertices].color1.r = 255;
               vertexArray[numVertices].color1.g = 255;
               vertexArray[numVertices].color1.b = 0;
               numVertices++;

               //View Vector
               vertexArray[numVertices].vertex.x = pos.x - matrix[2]*ATI_FLY_CUBE_RADIUS*4.0f;
               vertexArray[numVertices].vertex.y = pos.y - matrix[6]*ATI_FLY_CUBE_RADIUS*4.0f;
               vertexArray[numVertices].vertex.z = pos.z - matrix[10]*ATI_FLY_CUBE_RADIUS*4.0f;
               vertexArray[numVertices].color1.r = 255;
               vertexArray[numVertices].color1.g = 255;
               vertexArray[numVertices].color1.b = 0;
               numVertices++;
            }
         }
      }
      EndFlight();

      for (i=0; i<numVertices; i++)
      {
         indexArray[numIndices] = i;
         numIndices++;
      }

      /**********************************************/
      /* Draw: An example draw call from our engine */
      /**********************************************/
      //AwDraw (AWPT_LINE_LIST, sizeof(AtiVertexColor1),
      //        0, (uint8 *)vertexArray, 0, numVertices,
      //        0, indexArray,  0, numIndices);
   }

   /******************/
   /* Reset counters */
   /******************/
   numIndices = 0;
   numVertices = 0;

   /**********************************/
   /* Build draw array for traingles */
   /**********************************/
   if (mNumFlyPoints > 0)
   {
      for (i=0; i<mNumFlyPoints; i++)
      {
         AtiMatrix matrix;
         AtiQuatToMatrix(&(mOrientation[i]), matrix);
         AtiColorDWordRGBA color;

         if (i == mCurrentEditPoint)
         {
            color.r = 255;
            color.g = 255;
            color.b = 0;
            color.a = 0;
         }
         else if (i == 0)
         {
            color.r = 0;
            color.g = 255;
            color.b = 0;
            color.a = 0;
         }
         else if (i == mNumFlyPoints-1)
         {
            color.r = 255;
            color.g = 0;
            color.b = 0;
            color.a = 0;
         }
         else
         {
            color.r = 0;
            color.g = 0;
            color.b = 255;
            color.a = 0;
         }


         vertexArray[numVertices].vertex.x = mLocation[i].x + ((matrix[0] + matrix[1] + matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((matrix[4] + matrix[5] + matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((matrix[8] + matrix[9] + matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((matrix[0] - matrix[1] + matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((matrix[4] - matrix[5] + matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((matrix[8] - matrix[9] + matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((-matrix[0] - matrix[1] + matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((-matrix[4] - matrix[5] + matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((-matrix[8] - matrix[9] + matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((-matrix[0] + matrix[1] + matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((-matrix[4] + matrix[5] + matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((-matrix[8] + matrix[9] + matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((matrix[0] + matrix[1] - matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((matrix[4] + matrix[5] - matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((matrix[8] + matrix[9] - matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((matrix[0] - matrix[1] - matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((matrix[4] - matrix[5] - matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((matrix[8] - matrix[9] - matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((-matrix[0] - matrix[1] - matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((-matrix[4] - matrix[5] - matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((-matrix[8] - matrix[9] - matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         vertexArray[numVertices].vertex.x = mLocation[i].x + ((-matrix[0] + matrix[1] - matrix[2] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.y = mLocation[i].y + ((-matrix[4] + matrix[5] - matrix[6] )*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].vertex.z = mLocation[i].z + ((-matrix[8] + matrix[9] - matrix[10])*ATI_FLY_CUBE_RADIUS);
         vertexArray[numVertices].color1.color = color.color;
         numVertices++;

         indexArray[numIndices++] = numVertices-8;
         indexArray[numIndices++] = numVertices-6;
         indexArray[numIndices++] = numVertices-7;
         indexArray[numIndices++] = numVertices-8;
         indexArray[numIndices++] = numVertices-5;
         indexArray[numIndices++] = numVertices-6;

         indexArray[numIndices++] = numVertices-8;
         indexArray[numIndices++] = numVertices-3;
         indexArray[numIndices++] = numVertices-4;
         indexArray[numIndices++] = numVertices-8;
         indexArray[numIndices++] = numVertices-7;
         indexArray[numIndices++] = numVertices-3;

         indexArray[numIndices++] = numVertices-8;
         indexArray[numIndices++] = numVertices-4;
         indexArray[numIndices++] = numVertices-1;
         indexArray[numIndices++] = numVertices-8;
         indexArray[numIndices++] = numVertices-1;
         indexArray[numIndices++] = numVertices-5;

         indexArray[numIndices++] = numVertices-7;
         indexArray[numIndices++] = numVertices-2;
         indexArray[numIndices++] = numVertices-3;
         indexArray[numIndices++] = numVertices-7;
         indexArray[numIndices++] = numVertices-6;
         indexArray[numIndices++] = numVertices-2;

         indexArray[numIndices++] = numVertices-5;
         indexArray[numIndices++] = numVertices-2;
         indexArray[numIndices++] = numVertices-6;
         indexArray[numIndices++] = numVertices-5;
         indexArray[numIndices++] = numVertices-1;
         indexArray[numIndices++] = numVertices-2;

         indexArray[numIndices++] = numVertices-4;
         indexArray[numIndices++] = numVertices-2;
         indexArray[numIndices++] = numVertices-1;
         indexArray[numIndices++] = numVertices-4;
         indexArray[numIndices++] = numVertices-3;
         indexArray[numIndices++] = numVertices-2;
      }

      /**********************************************/
      /* Draw: An example draw call from our engine */
      /**********************************************/
      //AwDraw (AWPT_TRIANGLE_LIST, sizeof(AtiVertexColor1),
      //        0, (uint8 *)vertexArray, 0, numVertices,
      //        0, indexArray,  0, numIndices);
   }

   /***************/
   /* Free memory */
   /***************/
   AtiFreeArray(vertexArray);
   AtiFreeArray(indexArray);

   mInFlight    = inFlight;
   mStartTime   = startTime;
   mPausedTime  = pausedTime;
   mPaused      = paused;

   return TRUE;
}

//=============================================================================
void AtiFlyPath::SelectNearestFlyPoint (AtiVertex3 aPos)
{
   int32 i;
   float32 tmpf;
   float32 dist = 999999999999.0f;

   /**********************/
   /* Find closest point */
   /**********************/
   mCurrentEditPoint = -1;
   for (i=0; i<mNumFlyPoints; i++)
   {
      tmpf = ((mLocation[i].x - aPos.x) * (mLocation[i].x - aPos.x)) +
             ((mLocation[i].y - aPos.y) * (mLocation[i].y - aPos.y)) +
             ((mLocation[i].z - aPos.z) * (mLocation[i].z - aPos.z));

      if ((tmpf < dist) || (i == 0))
      {
         dist = tmpf;
         mCurrentEditPoint = i;
      }
   }

   if (mPaused == TRUE)
   {
      int32 point;
      float32 time;
      
      GetCurrentFlyPointInfo(&point, &time);
      mPausedTime = mStartTime + time;
   }
}

//=============================================================================
bool8 AtiFlyPath::GetCurrentFlyPoint (AtiVertex3 *aPosition, AtiQuaternion *aOrientation)
{
   if (mCurrentEditPoint < 0)
      return FALSE;

   aPosition->x = mLocation[mCurrentEditPoint].x;
   aPosition->y = mLocation[mCurrentEditPoint].y;
   aPosition->z = mLocation[mCurrentEditPoint].z;

   aOrientation->x = mOrientation[mCurrentEditPoint].x;
   aOrientation->y = mOrientation[mCurrentEditPoint].y;
   aOrientation->z = mOrientation[mCurrentEditPoint].z;
   aOrientation->w = mOrientation[mCurrentEditPoint].w;

   return TRUE;
}

//=============================================================================
bool8 AtiFlyPath::GetCurrentFlyPointInfo(int32 *aPointNumber, float32 *aPointTime)
{
   int32 i;

   if (mCurrentEditPoint < 0)
      return FALSE;

   *aPointNumber = mCurrentEditPoint;
   *aPointTime = 0.0f;
   for (i=0; i<mCurrentEditPoint; i++)
   {
      if (mLocation[i].w == 0.0)
         *aPointTime += (float32)mSampleInterval;
   }

   return TRUE;
}

//=============================================================================
void AtiFlyPath::ClearFlyPointSelection (void)
{
   if (mNumFlyPoints == 0)
      mCurrentEditPoint = -1;
   else
      mCurrentEditPoint = 0;
}

//=============================================================================
void AtiFlyPath::SetNextPath (AtiFlyPath *aPath)
{
   if (aPath != NULL)
      mNextPath = aPath;
   else
      mNextPath = this;
}

//=============================================================================
void AtiFlyPath::SetPreviousPath (AtiFlyPath *aPath)
{
   if (aPath != NULL)
      mPreviousPath = aPath;
   else
      mPreviousPath = this;
}

//=============================================================================
AtiFlyPath* AtiFlyPath::GetNextPath (void)
{
   return mNextPath;
}

//=============================================================================
AtiFlyPath* AtiFlyPath::GetPreviousPath (void)
{
   return mPreviousPath;
}

//=============================================================================
bool8 AtiFlyPath::CompilePositionsAndOrientations (void)
{
   if (CompilePositions() == FALSE)
      return FALSE;