Rts Port To Tgea

by Johnathan Moore · in RTS Starter Kit · 05/06/2006 (2:45 pm) · 62 replies · 1

#include <d3d9.h>
&
#include <dinput.h>
GFX->pushWorldMatrix();

   MatrixF mat = getRenderTransform();
   mat.scale( mObjScale );
   GFX->setWorldMatrix( mat );

   mShapeInstance->animate();
   mShapeInstance->render();

   GFX->popWorldMatrix();
MatrixF proj = GFX->getProjectionMatrix();

   RectI viewport = GFX->getViewport();

   // hack until new scenegraph in place
   MatrixF world = GFX->getWorldMatrix();
   TSMesh::setCamTrans( world );
   TSMesh::setSceneState( state );
   TSMesh::setGlow( image->glow );
   TSMesh::setRefract( image->sortType == SceneRenderImage::Refraction );

      // render mesh
      GFX->pushWorldMatrix();

      MatrixF mat = getRenderTransform();
      mat.scale( mObjScale );
      GFX->setWorldMatrix( mat );

      mShapeInstance->animate();
      mShapeInstance->render();

      GFX->popWorldMatrix();

   GFX->setProjectionMatrix( proj );
   GFX->setViewport( viewport );
Parent::onRender(offset, updateRect);

   RTSConnection* conn = dynamic_cast<RTSConnection*>(NetConnection::getConnectionToServer());

   if(!conn)
      return;

   // setup GL for selection info rendering
   GFX->setClipRect(updateRect);
//   dglSetClipRect(updateRect);
//   glDisable     (GL_CULL_FACE);
//   glEnable      (GL_BLEND);
//   glBlendFunc   (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
   GFX->setCullMode( GFXCullNone );
   GFX->setAlphaBlendEnable(true);
   GFX->setSrcBlend(GFXBlendSrcAlpha);
   GFX->setDestBlend(GFXBlendInvSrcAlpha);
//   glLineWidth(4.f);	// not sure what to chang ethis too or if needed

   // highlight selected objects
   for(S32 i=0; i<getSelectionSize(); i++)
   {
      if(mDragSelected.objInSet(mSelected[i]) || (const SceneObject *)mHitObject == mSelected[i])
         continue;

      drawDamage(mSelected[i]);
   }

   if(bool(mHitObject))
   {
      drawDamage(mHitObject);
   }

   // change gl states back
 //  glLineWidth(1.f);
   GFX->setCullMode (GFXCullCW);
   GFX->setAlphaBlendEnable(false);
//   glDisable( GL_BLEND );
//   glEnable(GL_CULL_FACE);

   // drag selection update based on worldEditor
   //   defined in engine/editor/worldEditor line 2379
   if(mDragSelect)
   {
      // Draw drag selection box
      //dglDrawRect(mDragRect, mDragRectColor);
		GFX->drawRect(mDragRect, mDragRectColor);

      Con::executef(this, 1, "dragClearSelection");

      Vector<SceneObject *> objects;
      gClientContainer.findObjects(0xFFFFFFFF, findObjectsCallback, &objects);
      for(S32 i = 0; i < objects.size(); i++)
      {
         SceneObject * obj = objects[i];

         // -- PROBLEM IS RIGHT HERE -pw

         Box3F box = obj->getObjBox();
         RTSConnection* conn = (RTSConnection*)NetConnection::getConnectionToServer();
         RTSCamera* camera = dynamic_cast<RTSCamera*>( conn->getControlObject() );
         F32 dist = camera->getCurrHeight();
         F32 radius = getMax( box.max.x - box.min.x, box.max.y - box.min.y );
//         F32 renderRadius = dglProjectRadius( dist, radius ) / 3.f;
         F32 renderRadius = GFX->projectRadius( dist, radius ) / 3.f;
		 RectI modifiedRect( mDragRect.point.x - renderRadius, mDragRect.point.y - renderRadius,
                             mDragRect.extent.x + renderRadius * 2, mDragRect.extent.y + renderRadius * 2 );

         //dglDrawRect( modifiedRect, ColorI( 255, 0, 0 ) );

         Point3F wPos;
         obj->getTransform().getColumn(3, &wPos);

//         dglProjectRadius( dist, radius );
		 GFX->projectRadius( dist, radius);

         Point3F sPos;
         if(project(wPos, &sPos))
            if(mDragSelect && modifiedRect.pointInRect(Point2I((S32)sPos.x, (S32)sPos.y)))
                  Con::executef(this,
                     2,
                     "updateDragSelect",
                     obj->getIdString());
      }

      // Clean up from rubber band box.
 //     glDisable(GL_BLEND);
 //     glEnable(GL_TEXTURE_2D);
	  GFX->setAlphaBlendEnable(false);
//	  I think that becomes
	   GFX->setTextureStageColorOp(0, GFXTOPModulate);
	   GFX->setTextureStageColorOp(1, GFXTOPDisable);

   }

   renderChildControls(offset, updateRect);
Point3F res;
   const SphereF wSph = obj->getWorldSphere();
   Point3F objPos = obj->getPosition();
   objPos.z += obj->getObjBox().max.z - obj->getObjBox().min.z;

   if(project(objPos, &res))
   {
      // Get distance to object from camera
      Point3F camPos, objPos;

      objPos = wSph.center;
      unproject( Point3F( 0, 0, 0), &camPos);

      F32 dist   = (camPos - objPos).len();
//      F32 width = dglProjectRadius(dist, wSph.radius) + 5;
	    F32 width = GFX->projectRadius(dist, wSph.radius) + 5;
//      Point2I offset(res.x - width / 2,(S32)(res.y - (2*dglProjectRadius(dist, wSph.radius))));
      Point2I offset(res.x - width / 2,(S32)(res.y - (2*GFX->projectRadius(dist, wSph.radius))));

      // Damage should be 0->1 (0 being no damage,or healthy), but
      // we'll just make sure here as we flip it.
      if(ShapeBase *object = dynamic_cast<ShapeBase*>(obj))
      {
         //don't draw if dead
         if (object->getDamageState() != Player::Enabled)
            return;

         F32 damage = mClampF(1 - object->getDamageValue(), 0, 1);

         // Center the bar
         RectI rect(offset, Point2I(width, mDamageRectSize.y));
         //rect.point.x -= mDamageRectSize.x / 2;

         // Draw the border
//         dglDrawRect(rect, mDamageFrameColor);
		 GFX->drawRect(rect, mDamageFrameColor);

         // Draw the damage % fill
         rect.point += Point2I(1, 1);
         rect.extent -= Point2I(1, 1);
         rect.extent.x = (S32)(rect.extent.x * damage);
         if (rect.extent.x == 1)
            rect.extent.x = 2;
         if (rect.extent.x > 0)
//            dglDrawRectFill(rect, mDamageFillColor);
				GFX->drawRectFill(rect, mDamageFillColor);
      }
   }
void setOverrideTexture(StringTableEntry f)
   {
      mOverrideFile = f;
      mOverrideTex.set(mOverrideFile,&GFXDefaultStaticDiffuseProfile);
   }
GFXTexhandle     textureHandle[NUM_TEX];
F32              mTransVal;
   StringTableEntry mOverrideFile;
   GFXTexHandle    mOverrideTex;
   TSThread *mThread;
F32 calcUV(PlaneF plane, Point3F point, F32 mr)
{
	F32 UV = ((plane.distToPlane(point) / mr) + 1.0) / 2.0;
	// Argh!!! How to ignore UVs outside [0..1] ???
//	while (UV>1.0) 
//	{UV = UV-1.0;}
	return UV;
}

AtlasDiscreteMesh *AtlasGeomChunk::BuildTris(TerrSelectionInfo Sel)
{
   AtlasDiscreteMesh *adm = new AtlasDiscreteMesh;

   // Copy indices.
   adm->mIndexCount = mIndexCount;
   adm->mIndex = new U16[mIndexCount];
   dMemcpy(adm->mIndex, mIndex, sizeof(U16)*mIndexCount);

   // Prep vertices...
   adm->mVertexCount = mVertCount;
   adm->mPos = new Point3F[mVertCount];
   adm->mTex = new Point2F[mVertCount];
   adm->mHasMorphData = false;

   AtlasDiscreteMesh *bdm = new AtlasDiscreteMesh;
   AtlasDiscreteMesh *cdm = new AtlasDiscreteMesh;
   bdm->mIndexCount = mVertCount;
   bdm->mIndex = new U16[mIndexCount];
   bdm->mVertexCount = mVertCount;
   bdm->mPos = new Point3F[mVertCount];
   bdm->mTex = new Point2F[mVertCount];

   U32 mSelVerCount = 0;
	Point3F pmin;
	Point3F pmax;
	pmin.x = Sel.pos.x-Sel.radius;
	pmin.y = Sel.pos.y-Sel.radius;
	pmin.z = Sel.pos.z-Sel.radius;
	pmax.x = Sel.pos.x+Sel.radius;
	pmax.y = Sel.pos.y+Sel.radius;
	pmax.z = Sel.pos.z+Sel.radius;

   // And swizzle vertices out...
	for(S32 i=0; i<(mIndexCount - mSkirtSkipCount) - 1; i+=3)
    {
		// Reject anything degenerate...
        if(mIndex[i+0] == mIndex[i+1] || mIndex[i+1] == mIndex[i+2] || mIndex[i+2] == mIndex[i+0])
               continue;
		// Get the plane normal
		Point3F point1 = mVert[mIndex[i+0]].point;
		Point3F point2 = mVert[mIndex[i+1]].point;
		Point3F point3 = mVert[mIndex[i+2]].point;

		Box3F box(pmin.x,pmin.y,pmin.z,pmax.x,pmax.y,pmax.z);
		if (!triBoxOverlap(box,point1,point2,point3)) {continue;}
		Point3F normal;
		mCross((point1 - point2), (point3 - point2), &normal);
		if (normal.lenSquared() < 1e-7)
		{
			//pTri->flags = 0;
			continue;
		}
		PlaneF plane(point2, normal);  // Assumes that mPlane.h normalizes incoming point
		Point3F centerPoint;
		F32 d = plane.distToPlane(Sel.pos);
		d = mFabs(d);
		if (d >= Sel.radius) {
			continue;
		}

		centerPoint = Sel.pos - plane * d;

		F32 mr = mSqrt(Sel.radiusSquared - d*d);

		Point3F normalS;
		Point3F normalT;
		mCross(plane, Point3F(1, 0, 0), &normalS);
		mCross(plane, normalS, &normalT);
		PlaneF splane(centerPoint, normalS); // Assumes that mPlane.h normalizes incoming point
		PlaneF tplane(centerPoint, normalT); // Assumes that mPlane.h normalizes incoming point

		bdm->mIndex[mSelVerCount+0] = mSelVerCount+0;
		bdm->mIndex[mSelVerCount+1] = mSelVerCount+1;
		bdm->mIndex[mSelVerCount+2] = mSelVerCount+2;
		bdm->mPos[mSelVerCount+0] = point1;
		bdm->mPos[mSelVerCount+1] = point2;
		bdm->mPos[mSelVerCount+2] = point3;
// Add Z Offset to make it appear above the terrain (there is probably a better solution)
		bdm->mPos[mSelVerCount+0].z+=0.01;
		bdm->mPos[mSelVerCount+1].z+=0.01;
		bdm->mPos[mSelVerCount+2].z+=0.01;

		bdm->mTex[mSelVerCount+0].set(calcUV(splane,point1,mr),
									  calcUV(tplane,point1,mr));
		bdm->mTex[mSelVerCount+1].set(calcUV(splane,point2,mr),
									  calcUV(tplane,point2,mr));
		bdm->mTex[mSelVerCount+2].set(calcUV(splane,point3,mr),
									  calcUV(tplane,point3,mr));

		mSelVerCount = mSelVerCount+3;

   }

   // Copy indices.
   cdm->mIndexCount = mSelVerCount;
   cdm->mIndex = new U16[mSelVerCount];

   // Prep vertices...
   cdm->mVertexCount = mSelVerCount;
   cdm->mPos = new Point3F[mSelVerCount];
   cdm->mTex = new Point2F[mSelVerCount];
   cdm->mHasMorphData = false;

	for (int ii=0;ii<mSelVerCount;ii++)
	{
		cdm->mIndex[ii] = bdm->mIndex[ii];
		cdm->mPos[ii] = bdm->mPos[ii];
		cdm->mTex[ii] = bdm->mTex[ii];
	}
	delete adm;
	delete bdm;
   // All done.
   return cdm;
}
AtlasDiscreteMesh *BuildTris(TerrSelectionInfo Sel);
AtlasDiscreteMesh *AtlasInstanceGeomTOC::BuildTris(TerrSelectionInfo Sel)
{
   PROFILE_START(AtlasInstanceGeomTOC_BuildTris);

   // We need a stack...
   FrameAllocatorMarker fm;
   StackNode *stack = (StackNode*)fm.alloc(sizeof(StackNode) * (mTreeDepth * 4 + 1));
   U32 stackDepth=0;
   AtlasDiscreteMesh *list;
   // Push the root stub into the stack.
   stack[stackDepth].stub = getStub(0, Point2I(0,0));
   stack[stackDepth].clipMask = FrustrumCuller::AllClipPlanes;
   stackDepth++;

   while(stackDepth)
   {
      // Pop top item from the stack.
      const StackNode snode = stack[--stackDepth];
      StubType *s = snode.stub;

      // Do our clipping.
      const S32 newMask = mCuller.testBoxVisibility(s->mBounds, snode.clipMask, 1.f);

      if(newMask == -1)
      {
         // Not seen, so skip this one.
         continue;
      }

      // Draw ourselves. :)
      if(getResourceStub(s)->mChunk && !s->isSplit())
      {

		Box3F bounds = getResourceStub(s)->mChunk->getBounds();
		 if (bounds.isContained(Sel.pos)) {
			list = getResourceStub(s)->mChunk->BuildTris(Sel);
		}
      }

      // If I'm not maxed out on LOD, don't draw me.
      if(!s->isSplit())
         continue;

      // Recurse.
      if(s->hasChildren())
      {
         for(S32 i=0; i<4; i++)
         {
            stack[stackDepth].stub = s->mChildren[i];
            stack[stackDepth].clipMask = newMask;
            stackDepth++;
         }
      }
   }
   PROFILE_END();
   return list;
}
AtlasDiscreteMesh *BuildTris(TerrSelectionInfo Sel);
struct TerrSelectionInfo
{
   Point3F pos;       ///< world position
   F32 radius;        ///< radius of the light
   F32 radiusSquared; ///< radius^2
   F32 r, g, b;

   F32 distSquared; // distance to camera
};

Game Development Community

Rts Port To Tgea

About the author

Recent Threads