edittsctrl.cc

五行MMORPG引擎系统V1.0

      //
      if(i){glColor4ub(a.red,a.green,a.blue,a.alpha);glBegin(GL_QUADS);} else {glColor4f(b.red,b.green,b.blue,b.alpha); glBegin(GL_LINE_LOOP);}
      glVertex3f(min.x, min.y, 0);
      glVertex3f(min.x, max.y, 0);
      glVertex3f(min.x, max.y, height);
      glVertex3f(min.x, min.y, height);
      glEnd();

      //
      if(i){glColor4ub(a.red,a.green,a.blue,a.alpha);glBegin(GL_QUADS);} else {glColor4f(b.red,b.green,b.blue,b.alpha); glBegin(GL_LINE_LOOP);}
      glVertex3f(max.x, min.y, 0);
      glVertex3f(max.x, max.y, 0);
      glVertex3f(max.x, max.y, height);
      glVertex3f(max.x, min.y, height);
      glEnd();
   }

   glDisable(GL_BLEND);
}

//#endif


//------------------------------------------------------------------------------

bool EditTSCtrl::processCameraQuery(CameraQuery * query)
{
   GameConnection* connection = dynamic_cast<GameConnection *>(NetConnection::getConnectionToServer());
   if (connection)
   {
      if (connection->getControlCameraTransform(0.032,&query->cameraMatrix)) {
         query->nearPlane = 0.1;
         query->farPlane = getMax(smVisibleDistance, 50.f);
         query->fov = 3.1415 / 2;
         query->ortho = false;

         smCamMatrix = query->cameraMatrix;
         smCamMatrix.getColumn(3,&smCamPos);
         smCamRot.set(0,0,0);
         return(true);
      }
   }
   return(false);
}

//------------------------------------------------------------------------------
// sort the surfaces: not correct when camera is inside sphere but not
// inside tesselated representation of sphere....
struct SortInfo 
{
   U32 idx;
   F32 dot;
};

static int QSORT_CALLBACK alphaSort(const void* p1, const void* p2)
{
   const SortInfo* ip1 = (const SortInfo*)p1;
   const SortInfo* ip2 = (const SortInfo*)p2;

   if(ip1->dot > ip2->dot)
      return(1);
   if(ip1->dot == ip2->dot)
      return(0);
   return(-1);
}

//------------------------------------------------------------------------------
ConsoleMethod(EditTSCtrl, renderSphere, void, 4, 5, "(Point3F pos, float radius, int subdivisions=NULL)")
{
   if(!object->mConsoleRendering)
      return;

   static Sphere sphere(Sphere::Icosahedron);

   if(!object->mConsoleFrameColor.alpha && !object->mConsoleFillColor.alpha)
      return;

   S32 sphereLevel = object->mConsoleSphereLevel;
   if(argc == 5)
      sphereLevel = dAtoi(argv[4]);

   const Sphere::TriangleMesh * mesh = sphere.getMesh(sphereLevel);

   Point3F pos;
   dSscanf(argv[2], "%g %g %g", &pos.x, &pos.y, &pos.z);

   F32 radius = dAtoi(argv[3]);

   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   // sort the surfaces back->front
   Vector<SortInfo> sortInfos;

   Point3F camNormal = object->smCamPos - pos;
   camNormal.normalize();

   sortInfos.setSize(mesh->numPoly);
   for(U32 i = 0; i < mesh->numPoly; i++)
   {
      sortInfos[i].idx = i;
      sortInfos[i].dot = mDot(camNormal, mesh->poly[i].normal);
   }
   dQsort(sortInfos.address(), sortInfos.size(), sizeof(SortInfo), alphaSort);

   // frame
   if(object->mConsoleFrameColor.alpha)
   {
      glColor4ub(object->mConsoleFrameColor.red,
                 object->mConsoleFrameColor.green,
                 object->mConsoleFrameColor.blue,
                 object->mConsoleFrameColor.alpha);

      glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

      glLineWidth(object->mConsoleLineWidth);
      glBegin(GL_TRIANGLES);
      for(U32 i = 0; i < mesh->numPoly; i++)
      {
         Sphere::Triangle & tri = mesh->poly[sortInfos[i].idx];
         for(S32 j = 2; j >= 0; j--)
            glVertex3f(tri.pnt[j].x * radius + pos.x,
                       tri.pnt[j].y * radius + pos.y,
                       tri.pnt[j].z * radius + pos.z);
      }
      glEnd();

      glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
      glLineWidth(1);
   }

   // fill
   if(object->mConsoleFillColor.alpha)
   {
      glColor4ub(object->mConsoleFillColor.red,
                 object->mConsoleFillColor.green,
                 object->mConsoleFillColor.blue,
                 object->mConsoleFillColor.alpha);

      glBegin(GL_TRIANGLES);
      for(U32 i = 0; i < mesh->numPoly; i++)
      {
         Sphere::Triangle & tri = mesh->poly[sortInfos[i].idx];
         for(S32 j = 2; j >= 0; j--)
            glVertex3f(tri.pnt[j].x * radius + pos.x,
                       tri.pnt[j].y * radius + pos.y,
                       tri.pnt[j].z * radius + pos.z);
      }
      glEnd();
   }
   glDisable(GL_BLEND);
}

ConsoleMethod( EditTSCtrl, renderCircle, void, 5, 6, "(Point3F pos, Point3F normal, float radius, int segments=NULL)")
{
   if(!object->mConsoleRendering)
      return;

   if(!object->mConsoleFrameColor.alpha && !object->mConsoleFillColor.alpha)
      return;

   Point3F pos, normal;
   dSscanf(argv[2], "%g %g %g", &pos.x, &pos.y, &pos.z);
   dSscanf(argv[3], "%g %g %g", &normal.x, &normal.y, &normal.z);

   F32 radius = dAtoi(argv[4]);

   S32 segments = object->mConsoleCircleSegments;
   if(argc == 6)
      segments = dAtoi(argv[5]);

   normal.normalize();

   AngAxisF aa;
   mCross(normal, Point3F(0,0,1), &aa.axis);
   aa.axis.normalizeSafe();
   aa.angle = mAcos(mClampF(mDot(normal, Point3F(0,0,1)), -1.f, 1.f));

   if(aa.angle == 0.f)
      aa.axis.set(0,0,1);

   MatrixF mat;
   aa.setMatrix(&mat);

   F32 step = M_2PI / segments;
   F32 angle = 0.f;

   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   Vector<Point3F> points;
   segments--;
   for(U32 i = 0; i < segments; i++)
   {
      Point3F pnt(mCos(angle), mSin(angle), 0.f);

      mat.mulP(pnt);
      pnt *= radius;
      pnt += pos;

      points.push_back(pnt);
      angle += step;
   }

   // framed
   if(object->mConsoleFrameColor.alpha)
   {
      glColor4ub(object->mConsoleFrameColor.red,
                 object->mConsoleFrameColor.green,
                 object->mConsoleFrameColor.blue,
                 object->mConsoleFrameColor.alpha);
      glLineWidth(object->mConsoleLineWidth);
      glBegin(GL_LINE_LOOP);
      for(U32 i = 0; i < points.size(); i++)
         glVertex3f(points[i].x, points[i].y, points[i].z);
      glEnd();
      glLineWidth(1);
   }

   // filled
   if(object->mConsoleFillColor.alpha)
   {
      glColor4ub(object->mConsoleFillColor.red,
                 object->mConsoleFillColor.green,
                 object->mConsoleFillColor.blue,
                 object->mConsoleFillColor.alpha);

      glBegin(GL_TRIANGLES);

      for(S32 i = 0; i < points.size(); i++)
      {
         S32 j = (i + 1) % points.size();
         glVertex3f(points[i].x, points[i].y, points[i].z);
         glVertex3f(points[j].x, points[j].y, points[j].z);
         glVertex3f(pos.x, pos.y, pos.z);
      }

      glEnd();
   }

   glDisable(GL_BLEND);
}

ConsoleMethod( EditTSCtrl, renderTriangle, void, 5, 5, "(Point3F a, Point3F b, Point3F c)")
{
   if(!object->mConsoleRendering)
      return;

   if(!object->mConsoleFrameColor.alpha && !object->mConsoleFillColor.alpha)
      return;

   Point3F pnts[3];
   for(U32 i = 0; i < 3; i++)
      dSscanf(argv[i+2], "%g %g %g", &pnts[i].x, &pnts[i].y, &pnts[i].z);

   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   // frame
   if(object->mConsoleFrameColor.alpha)
   {
      glColor4ub(object->mConsoleFrameColor.red,
                 object->mConsoleFrameColor.green,
                 object->mConsoleFrameColor.blue,
                 object->mConsoleFrameColor.alpha);
      glLineWidth(object->mConsoleLineWidth);
      glBegin(GL_LINE_LOOP);
      for(U32 i = 0; i < 3; i++)
         glVertex3f(pnts[i].x, pnts[i].y, pnts[i].z);
      glEnd();
      glLineWidth(1);
   }

   // fill
   if(object->mConsoleFillColor.alpha)
   {
      glColor4ub(object->mConsoleFillColor.red,
                 object->mConsoleFillColor.green,
                 object->mConsoleFillColor.blue,
                 object->mConsoleFillColor.alpha);

      glBegin(GL_TRIANGLES);
      for(U32 i = 0; i < 3; i++)
         glVertex3f(pnts[i].x, pnts[i].y, pnts[i].z);
      glEnd();
   }
   glDisable(GL_BLEND);
}

ConsoleMethod( EditTSCtrl, renderLine, void, 4, 5, "(Point3F start, Point3F end, int width)")
{
   if(!object->mConsoleRendering)
      return;

   if(!object->mConsoleFrameColor.alpha)
      return;

   Point3F start, end;
   dSscanf(argv[2], "%g %g %g", &start.x, &start.y, &start.z);
   dSscanf(argv[3], "%g %g %g", &end.x, &end.y, &end.z);

   S32 width = object->mConsoleLineWidth;
   if(argc == 5)
      width = dAtoi(argv[4]);

   glEnable(GL_BLEND);
   glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

   glColor4ub(object->mConsoleFrameColor.red,
              object->mConsoleFrameColor.green,
              object->mConsoleFrameColor.blue,
              object->mConsoleFrameColor.alpha);

   glLineWidth(width);

   glBegin(GL_LINES);
   glVertex3f(start.x, start.y, start.z);
   glVertex3f(end.x, end.y, end.z);
   glEnd();

   glLineWidth(1);
   glDisable(GL_BLEND);
}