sceneobject.cc

五行MMORPG引擎系统V1.0

   // walk the axis
   for(U32 i = 0; i < 3; i++)
   {
      //
      if(pStart[i] < pEnd[i])
      {
         if(pEnd[i] < pMin[i] || pStart[i] > pMax[i])
            return(false);

         F32 dist = pEnd[i] - pStart[i];

         startTime = (pStart[i] < pMin[i]) ? (pMin[i] - pStart[i]) / dist : -1;
         endTime = (pEnd[i] > pMax[i]) ? (pMax[i] - pStart[i]) / dist : 1;
         side = 1;
      }
      else
      {
         if(pStart[i] < pMin[i] || pEnd[i] > pMax[i])
            return(false);

         F32 dist = pStart[i] - pEnd[i];
         startTime = (pStart[i] > pMax[i]) ? (pStart[i] - pMax[i]) / dist : -1;
         endTime = (pEnd[i] < pMin[i]) ? (pStart[i] - pMin[i]) / dist : 1;
         side = 0;
      }

      //
      if(startTime > maxStartTime)
      {
         maxStartTime = startTime;
         hitIndex = i * 2 + side;
      }
      if(endTime < minEndTime)
         minEndTime = endTime;
      if(minEndTime < maxStartTime)
         return(false);
   }

   // fail if inside
   if(maxStartTime < 0.f)
      return(false);

   //
   static Point3F boxNormals[] = {
      Point3F( 1, 0, 0),
      Point3F(-1, 0, 0),
      Point3F( 0, 1, 0),
      Point3F( 0,-1, 0),
      Point3F( 0, 0, 1),
      Point3F( 0, 0,-1),
   };

   //
   info->t = maxStartTime;
   info->object = this;
   mObjToWorld.mulV(boxNormals[hitIndex], &info->normal);
   info->material = 0;
   return(true);
}

void SceneObject::disableCollision()
{
   mCollisionCount++;
   AssertFatal(mCollisionCount < 50, "Wow, that's too much");
}

bool SceneObject::isDisplacable() const
{
   return false;
}

Point3F SceneObject::getMomentum() const
{
   AssertFatal(false, "(SceneObject::getMomentum): Should never be called, this is just a default");
   return Point3F(0, 0, 0);
}

void SceneObject::setMomentum(const Point3F&)
{
   AssertFatal(false, "(SceneObject::setMomentum): Should never be called, this is just a default");
}


F32 SceneObject::getMass() const
{
   AssertFatal(false, "(SceneObject::getMass): Should never be called, this is just a default");
   return 1.0;
}


bool SceneObject::displaceObject(const Point3F&)
{
   AssertFatal(false, "(SceneObject::displaceObject): Should never be called, this is just a default");
   return false;
}


void SceneObject::enableCollision()
{
   if (mCollisionCount)
      --mCollisionCount;
}

bool SceneObject::onAdd()
{
   if (Parent::onAdd() == false)
      return false;

   mWorldToObj = mObjToWorld;
   mWorldToObj.affineInverse();
   resetWorldBox();

   setRenderTransform(mObjToWorld);
   return true;
}

void SceneObject::addToScene()
{
   if(isClientObject())
   {
      gClientContainer.addObject(this);
      gClientSceneGraph->addObjectToScene(this);
   }
   else
   {
      gServerContainer.addObject(this);
      gServerSceneGraph->addObjectToScene(this);
   }
}

void SceneObject::onRemove()
{
   Parent::onRemove();
}

void SceneObject::inspectPostApply()
{
   if(isServerObject()) 
	{
      setTransform(getTransform());
      setScale(getScale());
   }
}

void SceneObject::removeFromScene()
{
   if (mSceneManager != NULL)
      mSceneManager->removeObjectFromScene(this);
   if (getContainer())
      getContainer()->removeObject(this);
}

#ifdef TGE_RPG
void SceneObject::faceTo(const Point3F& ptFace,bool bFaceMe)
{
	MatrixF	mat = getTransform();
   Point3F	pos = getPosition();
	Point3F	vec = ptFace - pos;

	if(!bFaceMe)
	{	
		vec.x  = -vec.x;
		vec.y  = -vec.y;
	}

   VectorF x,y(vec),z(0,0,1);
	y.normalize();
   mCross(y, z, &x);
   x.normalize();
   mCross(x, y, &z);
   z.normalize();

	mat.identity();
   mat.setColumn(0,x);
   mat.setColumn(1,y);
   mat.setColumn(2,z);

	mat.setColumn(3,pos);

	setTransform(mat);
   //setMaskBits(MoveMask | NoWarpMask);

}
#endif

void SceneObject::setTransform(const MatrixF& mat)
{
   mObjToWorld = mWorldToObj = mat;
   mWorldToObj.affineInverse();

   resetWorldBox();

   if (mSceneManager != NULL && mNumCurrZones != 0) {
      mSceneManager->zoneRemove(this);
      mSceneManager->zoneInsert(this);
      if (getContainer())
         getContainer()->checkBins(this);
   }

   if(isClientObject())
      mLightingInfo.mDirty = true;

   setRenderTransform(mat);
}

void SceneObject::setScale(const VectorF & scale)
{
   mObjScale = scale;
   setTransform(MatrixF(mObjToWorld));

   // Make sure that any subclasses of me get a chance to react to the
   // scale being changed.
   onScaleChanged();

   setMaskBits( ScaleMask );
}

void SceneObject::resetWorldBox()
{
   AssertFatal(mObjBox.isValidBox(), "Bad object box!");

   mWorldBox = mObjBox;
   mWorldBox.min.convolve(mObjScale);
   mWorldBox.max.convolve(mObjScale);
   mObjToWorld.mul(mWorldBox);

   AssertFatal(mWorldBox.isValidBox(), "Bad world box!");

   // Create mWorldSphere from mWorldBox
   mWorldBox.getCenter(&mWorldSphere.center);
   mWorldSphere.radius = (mWorldBox.max - mWorldSphere.center).len();
}

void SceneObject::setRenderTransform(const MatrixF& mat)
{
   mRenderObjToWorld = mRenderWorldToObj = mat;
   mRenderWorldToObj.affineInverse();

   AssertFatal(mObjBox.isValidBox(), "Bad object box!");
   resetRenderWorldBox();
}


void SceneObject::resetRenderWorldBox()
{
   AssertFatal(mObjBox.isValidBox(), "Bad object box!");
   mRenderWorldBox = mObjBox;
   mRenderWorldBox.min.convolve(mObjScale);
   mRenderWorldBox.max.convolve(mObjScale);
   mRenderObjToWorld.mul(mRenderWorldBox);
// #if defined(__linux__) || defined(__OpenBSD__)
//    if( !mRenderWorldBox.isValidBox() ) {
//       // reset
//       mRenderWorldBox.min.set( 0.0f, 0.0f, 0.0f );
//       mRenderWorldBox.max.set( 0.0f, 0.0f, 0.0f );
//    }
// #else
   AssertFatal(mRenderWorldBox.isValidBox(), "Bad world box!");
//#endif

   // Create mRenderWorldSphere from mRenderWorldBox
   mRenderWorldBox.getCenter(&mRenderWorldSphere.center);
   mRenderWorldSphere.radius = (mRenderWorldBox.max - mRenderWorldSphere.center).len();
}


void SceneObject::initPersistFields()
{
   Parent::initPersistFields();
   addGroup("Transform"); // MM: Added group header.
   addField("position", TypeMatrixPosition, Offset(mObjToWorld, SceneObject));
   addField("rotation", TypeMatrixRotation, Offset(mObjToWorld, SceneObject));
   addField("scale", TypePoint3F, Offset(mObjScale, SceneObject));
   endGroup("Transform"); // MM: Added group footer.
}

bool SceneObject::onSceneAdd(SceneGraph* pGraph)
{
   mSceneManager = pGraph;
   mSceneManager->zoneInsert(this);
   return true;
}

void SceneObject::onSceneRemove()
{
   mSceneManager->zoneRemove(this);
   mSceneManager = NULL;
}

void SceneObject::onScaleChanged()
{
    // Override this function where you need to specially handle something
    // when the size of your object has been changed.
}

bool SceneObject::prepRenderImage(SceneState*, const U32, const U32, const bool)
{
   return false;
}

void SceneObject::renderObject(SceneState*, SceneRenderImage*)
{
   //
}

bool SceneObject::scopeObject(const Point3F&        /*rootPosition*/,
                              const F32             /*rootDistance*/,
                              bool*                 /*zoneScopeState*/)
{
   AssertFatal(false, "Error, this should never be called on a bare (non-zonemanaging) object.  All zone managers must override this function");
   return false;
}


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

//--------------------------------------------------------------------------
// A quick note about these three functions.  They should only be called
//  on zoneManagers, but since we don't want to force every non-zoneManager
//  to implement them, they assert out instead of being pure virtual.
//
bool SceneObject::getOverlappingZones(SceneObject*, U32*, U32* numZones)
{
   AssertISV(false, "Pure virtual (essentially) function called.  Should never execute this");
   *numZones = 0;
   return false;
}

U32 SceneObject::getPointZone(const Point3F&)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
   return 0;
}

void SceneObject::transformModelview(const U32, const MatrixF&, MatrixF*)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
}

void SceneObject::transformPosition(const U32, Point3F&)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
}

bool SceneObject::computeNewFrustum(const U32, const F64*, const F64, const F64,
                                    const RectI&, F64*, RectI&, const bool)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
   return false;
}

void SceneObject::openPortal(const U32   /*portalIndex*/,
                             SceneState* /*pCurrState*/,
                             SceneState* /*pParentState*/)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
}

void SceneObject::closePortal(const U32   /*portalIndex*/,
                              SceneState* /*pCurrState*/,
                              SceneState* /*pParentState*/)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
}

void SceneObject::getWSPortalPlane(const U32 /*portalIndex*/, PlaneF*)
{
   AssertISV(false, "Error, (essentially) pure virtual function called.  Any object this is called on should override this function");
}


//----------------------------------------------------------------------------
//-------------------------------------- Container implementation
//
Container::Link::Link()
{
   next = prev = this;
}

void Container::Link::unlink()
{
   next->prev = prev;
   prev->next = next;
   next = prev = this;
}

void Container::Link::linkAfter(Container::Link* ptr)
{
   next = ptr->next;
   next->prev = this;
   prev = ptr;
   prev->next = this;
}

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


	/// container合并
#ifdef TGE_RPGCLIENT2 /// TGE_RPGClient2

Container gClientContainer;
//#define	gServerContainer	gClientContainer

#else

Container gServerContainer;
Container gClientContainer;