TSE Interior Decals

This code uses the GameEntity entity to place and pass decals on/in your interior files (difs)
Basically, you're telling the entity that you will be creating an fxInteriorDecal class, and tell
it which dataBlock to use. In our case, for decals, we don't need a datablock, so we've created
a blank, generic datablock (shown below). In QuArK at least, you'll have an arrow thingy on your
entity icon, which you point at the surface getting the decal. This is used mostly because you may
have some tight geometry going on, and the code needs to know _exactly_ which surface you mean to
cover. You will also add a 'specific' to the entity (generic fielddata) telling it which texture
to use.

Keep an eye on the below version info, as I probably will update this fairly often.
Version 0.95
Updated release, I did forget a function
Known bugs: Decal occasionally flickers, getting somewhat brighter. Probably an error in how
I'm calling the GFX stuff.
Texture name must be fully qualified. A waste of bandwidth, and the cause of carpal.

We begin with ver 0.9 in case I forgot something (rushing out the door). Those who expect
plug/play, are better off waiting until at least 1.0

You will need to recompile map2dif, as I changed a few things it uses via engine.lib This WILL NOT
break existing interiors, they will load just fine along with your new graffiti covered urban hells.
Placement is not all that intuitive. You get a small icon with an arrow, and you cannot see your decal
until it is ingame. I don't know Delphi enough to patch up QuArK to show it better, but it's not to awful
difficult once you get used to it. HalfLife 1 wasnt any better at this either :)

InteriorInstance.cpp

At the top...

[b]#include "game/fx/fxInteriorDecal.h"[/b]

At the end of onAdd()

addToScene();
   [b]addChildren();[/b]
   return true;

Inside PackUpdate()

if (stream->writeFlag((mask & TransformMask) != 0)) {
         mathWrite(*stream, mObjToWorld);
         mathWrite(*stream, mObjScale);
		     [b]updateChildren();  // done server side. Client will redo its data later[/b]
      }

New functions, add anywhere
Note: addChildren is entirely based on door code, which will hopefully soon be
re-released in a more generic, useful and working manner.

[b] void InteriorInstance::addChildren()
 {

	if (bool(mInteriorRes) == false)
		return;
 
	if (isGhost())  // only add on the server!
		return;

	// First thing to do, add a group with our name
    SimObject* myObj = Sim::findObject("MissionGroup");
	SimGroup* myGroup = myObj->getGroup();
	
	// Load all the interior game objects...
	U32 i;
	for(i = 0; i < mInteriorRes->getNumGameEntities(); i++)
	{
		ItrGameEntity *pEntity = mInteriorRes->getGameEntity(i);
		ConsoleObject *obj = ConsoleObject::create(pEntity->mGameClass);
		GameBase *gb = dynamic_cast<GameBase*>(obj);

		if(!gb)
		{
			Con::errorf("Invalid game class for entity: %s", pEntity->mGameClass);
			delete obj;
			continue;
		} 
		gb->setField("dataBlock", pEntity->mDataBlock);
		gb->setModStaticFields(true);
		for(U32 j = 0; j < pEntity->mDictionary.size(); j++)
		{
			gb->setDataField(StringTable->insert(pEntity->mDictionary[j].name),
				NULL, pEntity->mDictionary[j].value); 
		}
		gb->setModStaticFields(false);
		Point3F origin = pEntity->mPos; // This is the offset from the parent

		origin.convolve(mObjScale);
		getTransform().mulP(origin);
		MatrixF xform(true);
		xform.setColumn(3, origin);
		gb->setTransform(xform);
		
		if(!gb->registerObject())
		{
			Con::errorf("Failed to register pEntity: %s: %s", pEntity->mGameClass, pEntity->mDataBlock);
			delete gb;
			continue;
		} 
		// Save the server id, for later updating
		pEntity->mId = gb->getId();

		myGroup->addObject(gb);
	}
}

void InteriorInstance::updateChildren()
{
	U32 i;

	// Load all the interior game objects...
	for(i = 0; i < mInteriorRes->getNumGameEntities(); i++)
	{
		ItrGameEntity *pEntity = mInteriorRes->getGameEntity(i);
		// This finds and works on the server object
		GameBase *obj = dynamic_cast<GameBase*>(Sim::findObject(pEntity->mId));
		if (!obj)
		{
			Con::errorf("We seem to have lost a child! (InteriorInstance::updateChildren())");
			return;
		}

		Point3F origin = pEntity->mPos;
		Point3F normal(0, 1, 0);
		origin.convolve(mObjScale);
		getTransform().mulP(origin);
		MatrixF xform(true);
		xform.setColumn(3, origin);
		obj->setTransform(xform);
		// Here we let the client know we're changing things
		obj->inspectPostApply();
	}

}[/b]

InteriorInstance.h
Somewhere...

protected:
   bool onAdd();
   void onRemove();
[b]   void addChildren();
   void updateChildren();
[/b]
   void inspectPreApply();
   void inspectPostApply();

InteriorResObjects.cpp
Somewhere...

ItrGameEntity::ItrGameEntity()
{
[b]   mId = 0;[/b]
   mDataBlock = "";
   mGameClass = "";
   mPos.set(0, 0, 0);
}

Read and write functions work better if we reverse a few things

bool ItrGameEntity::read(Stream& stream)
{
   mDataBlock = stream.readSTString();
   mGameClass = stream.readSTString();
[b]   mDictionary.read(stream);
   mathRead(stream, &mPos);
[/b]
   return (stream.getStatus() == Stream::Ok);
}

bool ItrGameEntity::write(Stream& stream) const
{
   stream.writeString(mDataBlock);
   stream.writeString(mGameClass);
[b]   mDictionary.write(stream);
   mathWrite(stream, mPos);
[/b]
   return (stream.getStatus() == Stream::Ok);
}

InteriorResObjects.h
Changing the struct size, I need more info...

struct InteriorDictEntry
{
   char name[32];
   char value[[b]128[b/]];
};

Near the end...

class ItrGameEntity
{
   public:
	    [b]U32               mId;[/b]
      StringTableEntry  mDataBlock;
      StringTableEntry  mGameClass;
      Point3F           mPos;
      InteriorDict mDictionary;

Small change in map2dif,
entitytypes.cpp

else if (pToker->tokenICmp("game_class")) {
         pToker->advanceToken(false, true);
         AssertISV(dStrlen(pToker->getToken()) < 256, avar("Error: %s is an invalid target name.  Must be less than 256", pToker->getToken()));
         dStrcpy(mGameClass, pToker->getToken());
      }
[b]     else if (pToker->tokenICmp("dataBlock")) {
         pToker->advanceToken(false, true);
         AssertISV(dStrlen(pToker->getToken()) < 256, avar("Error: %s is an invalid target name.  Must be less than 256", pToker->getToken()));
         dStrcpy(mDatablock, pToker->getToken());
      }[/b]
      else {

2 new files to add, I placed them in engine/game/fx/
Note: Not everything here is pretty, but I was really extending my skills here.
I tried to use the new GFX calls whenever I could figure them out, unfortunately
I had to drop back to PrimBuilder for most of the work. As I learn and/or am aided by
my betters, I will keep this updated with proper TSE code.
fxInteriorDecal.cpp

[b]
//-----------------------------------------------------------------------------
// Torque Game Engine
// This file is based completely on fxRenderObject, changed only as/when I needed
// to. 
// Written by Melvyn May, Started on 9th September 2002.
//
// "My code is written for the Torque community, so do your worst with it,
//	just don't rip-it-off and call it your own without even thanking me".
//
//	- Melv.
//
//-----------------------------------------------------------------------------

#include "console/consoleTypes.h"
#include "core/bitStream.h"
#include "math/mathIO.h"
#include "game/gameConnection.h"
#include "console/simBase.h"
#include "sceneGraph/sceneGraph.h"
#include "sceneGraph/sgUtil.h"
#include "fxInteriorDecal.h"
#include "gfx/primBuilder.h"


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

IMPLEMENT_CO_DATABLOCK_V1(fxInteriorDecalData);

fxInteriorDecalData::fxInteriorDecalData()
{
   mTextureName =  StringTable->insert("");
}

bool fxInteriorDecalData::onAdd()
{
   if (!Parent::onAdd())
      return false;

   return true;
}

void fxInteriorDecalData::initPersistFields()
{
   Parent::initPersistFields();

   addField( "Texture",		TypeFilename,	Offset( mTextureName,		fxInteriorDecalData ) );
}


//--------------------------------------------------------------------------
void fxInteriorDecalData::packData(BitStream* stream)
{
   Parent::packData(stream);
   stream->writeString(mTextureName);
}

void fxInteriorDecalData::unpackData(BitStream* stream)
{
   Parent::unpackData(stream);
   mTextureName = StringTable->insert(stream->readSTString());
}


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

IMPLEMENT_CO_NETOBJECT_V1(fxInteriorDecal);


//------------------------------------------------------------------------------
// Class: fxInteriorDecal
//------------------------------------------------------------------------------

fxInteriorDecal::fxInteriorDecal()
{
	// Setup NetObject.
	mTypeMask |= StaticRenderedObjectType;
	mNetFlags.set(Ghostable);

	// Texture Handle.
	mTextureHandle = NULL;
	// Texture Name.
	mTextureName = StringTable->insert("");

	mAngle = 0;

	mDatablock = NULL;

}

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

fxInteriorDecal::~fxInteriorDecal()
{
}

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

bool fxInteriorDecal::onAdd()
{
	if(!Parent::onAdd()) return(false);

	addToScene();

	// Set initial bounding box.
	//
	// NOTE:-	Set this box to completely encapsulate your object.
	//			You must reset the world box and set the render transform
	//			after changing this.
	mObjBox.min.set( -1, -0.1f, -1 );
	mObjBox.max.set(  1, +0.1f,  1 );
	// Reset the World Box.
	resetWorldBox();
	// Set the Render Transform.
	setRenderTransform(mObjToWorld);

	setViewPosition();

	return(true);
}

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

void fxInteriorDecal::setViewPosition()
{
   // Find the wall, snap to it	
  //  Not pretty, but I know of no other way. Even this, I needed forum help with. Suggestions?
	Point3F normal(0, 0, 0);
	F32 nAngle = dAtof(mAngle);
	if (nAngle == -1)
		normal.z = 1;
	else if (nAngle == -2)
		normal.z = -1;
	else {
		F32 theta = mDegToRad(nAngle);
		normal.x = 1 * cos(theta);
		normal.y = 1 * sin(theta);
	}

   Point3F startPos = getPosition();
   Point3F endPos = startPos + normal;

   RayInfo rayInfo;
   Point3F origin = getPosition();

   if (getContainer())
	   if(getContainer()->castRay( startPos, endPos, InteriorObjectType, &rayInfo ) )
       {	   
	       normal = rayInfo.normal;
	       origin = rayInfo.point;
       } 

   // setup texture verts
   Point3F vecX, vecY;
   if(mFabs(normal.z) > 0.9f)
      mCross(normal, Point3F(0.0f, 1.0f, 0.0f), &vecX);
   else
      mCross(normal, Point3F(0.0f, 0.0f, 1.0f), &vecX);

   mCross(vecX, normal, &vecY);

   normal.normalizeSafe();
   Point3F position = Point3F(origin.x + (normal.x * 0.008), origin.y + (normal.y * 0.008), origin.z + (normal.z * 0.008));

   vecX.normalizeSafe();
   vecY.normalizeSafe();

   vecX *= 1/*decalData->sizeX*/;
   vecY *= 1/*decalData->sizeY*/;

   point[0] = position + vecX + vecY;
   point[1] = position + vecX - vecY;
   point[2] = position - vecX - vecY;
   point[3] = position - vecX + vecY;
}
void fxInteriorDecal::onRemove()
{
	// Remove from Scene.
	removeFromScene();

	// Do Parent.
	Parent::onRemove();
}

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

void fxInteriorDecal::inspectPostApply()
{
	// Set Parent
	Parent::inspectPostApply();

	// Set Mask
	setMaskBits(DataMask);
}

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

bool fxInteriorDecal::prepRenderImage(	SceneState* state, const U32 stateKey, const U32 startZone,
										const bool modifyBaseZoneState)
{
	// Return if last state.
	if (isLastState(state, stateKey)) return false;
	// Set Last State.
	setLastState(state, stateKey);

   // Is Object Rendered?
   if (state->isObjectRendered(this))
   {	   
		// Yes, so get a SceneRenderImage.
		SceneRenderImage* image = new SceneRenderImage;
		// Populate it.
		image->obj = this;
		image->isTranslucent = true;
		image->sortType = SceneRenderImage::BeginSort; //::normal

		// Insert it into the scene images.
		state->insertRenderImage(image);
   }

   return false;
}

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

void fxInteriorDecal::renderObject(SceneState* state, SceneRenderImage*)
{
    GFX->setBaseRenderState();

    // set render states
    GFX->setTextureStageColorOp( 0, GFXTOPModulate );
    GFX->setTextureStageColorOp( 1, GFXTOPDisable );
    GFX->setTexture( 0, mTextureHandle );
    GFX->setZWriteEnable( false );

    // set up register combiners
    GFX->setTextureStageAlphaOp( 0, GFXTOPModulate );
    GFX->setTextureStageAlphaOp( 1, GFXTOPDisable );
    GFX->setTextureStageAlphaArg1( 0, GFXTATexture );
    GFX->setTextureStageAlphaArg2( 0, GFXTADiffuse );

    // turn on alpha test
    GFX->setAlphaTestEnable( true );
    GFX->setAlphaRef( 1 );
    GFX->setAlphaFunc( GFXCmpGreaterEqual );

    // alpha blend
    GFX->setAlphaBlendEnable( true );
    GFX->setSrcBlend( GFXBlendSrcAlpha );
    GFX->setDestBlend( GFXBlendOne );
    GFX->setDestBlend( GFXBlendInvSrcAlpha);

	ColorF fillCol(1,1,1,1);

	PrimBuild::begin(GFXTriangleFan, 4); {
		PrimBuild::texCoord2f(0, 0); PrimBuild::vertex3fv(point[0]);
        PrimBuild::texCoord2f(0, 1); PrimBuild::vertex3fv(point[1]);
        PrimBuild::texCoord2f(1, 1); PrimBuild::vertex3fv(point[2]);
        PrimBuild::texCoord2f(1, 0); PrimBuild::vertex3fv(point[3]);
    } 
	PrimBuild::end();   
	
	// restore states
	GFX->setZWriteEnable( true );
	GFX->setAlphaTestEnable( false );
	GFX->setBaseRenderState();
}
//------------------------------------------------------------------------------
void fxInteriorDecal::initPersistFields()
{
   Parent::initPersistFields();

   addField("texture", TypeFilename, Offset(mTextureName, fxInteriorDecal));
   addField("angle", TypeFilename, Offset(mAngle, fxInteriorDecal));
}
//------------------------------------------------------------------------------

U32 fxInteriorDecal::packUpdate(NetConnection * con, U32 mask, BitStream * stream)
{
	// Pack Parent.
	U32 retMask = Parent::packUpdate(con, mask, stream);

    if (stream->writeFlag(mask & DataMask))
    {
		// Write Object Transform.
	    stream->writeAffineTransform(mObjToWorld);
		// Write Texture Name.
		stream->writeString(mTextureName);
		// Angle
		stream->writeString(mAngle);
	}
	// Were done ...
	return(retMask);
}

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

void fxInteriorDecal::unpackUpdate(NetConnection * con, BitStream * stream)
{
	// Unpack Parent.
	Parent::unpackUpdate(con, stream);

	MatrixF		ObjectMatrix;

	if (stream->readFlag())
    {
		// Read Object Transform.
		stream->readAffineTransform(&ObjectMatrix);
		// Read Texture Name.
		mTextureName = StringTable->insert(stream->readSTString());
		// Read angle
		mAngle = StringTable->insert(stream->readSTString());

		// Set Transform.
		setTransform(ObjectMatrix);
		// Load the texture, if possible and if needed
		if (!mTextureHandle)
			if (*mTextureName)
				if(!mTextureHandle.set(mTextureName, &GFXDefaultStaticDiffuseProfile))      				
					Con::errorf("Unable to load texture: %s for decal!", mTextureName);
	}
	// Set viewing position
   	setViewPosition();
}
[/b]

And the header...
fxInteriorDecal.h

[b]
//-----------------------------------------------------------------------------
// Torque Game Engine
// 
// This file is based completely on fxRenderObject, changed only as/when I needed
// to.
// Written by Melvyn May, 9th September 2002.
//-----------------------------------------------------------------------------

#ifndef _FXINTERIORDECAL_H_
#define _FXINTERIORDECAL_H_

#ifndef _SCENEOBJECT_H_
#include "sim/sceneObject.h"
#endif
#include "game/gameBase.h"
#include "sim/decalmanager.h"
#include "gfx/gfxTextureHandle.h"
#include "gfx/GFXDevice.h"


struct fxInteriorDecalData: public GameBaseData {
   typedef GameBaseData Parent;

  public:
   StringTableEntry				mTextureName;

   fxInteriorDecalData();
   DECLARE_CONOBJECT(fxInteriorDecalData);
   bool onAdd();
   static void initPersistFields();
   virtual void packData  (BitStream* stream);
   virtual void unpackData(BitStream* stream);
};
//------------------------------------------------------------------------------
// Class: fxInteriorDecal
//------------------------------------------------------------------------------
class fxInteriorDecal : public GameBase
{
private:
	typedef GameBase		Parent;

protected:
	GFXTexHandle 					mTextureHandle;
	Point3F							point[4];

	// Fields.
public:
    StringTableEntry				mTextureName;
    Point3F							mPos;
    MatrixF							Transform;
    fxInteriorDecalData*            mDatablock;
	StringTableEntry				mAngle;    // easier to set this way

public:
	fxInteriorDecal();
	~fxInteriorDecal();
   enum
   {
      DataMask       = Parent::NextFreeMask << 0,
      NextFreeMask   = Parent::NextFreeMask << 1
   };
	// SceneObject
	void renderObject(SceneState*, SceneRenderImage*);
	virtual bool prepRenderImage(SceneState*, const U32 stateKey, const U32 startZone,
								const bool modifyBaseZoneState = false);

	// SimObject
	static void  initPersistFields();
	bool onAdd();
	void onRemove();
	void inspectPostApply();
    void setViewPosition();

	// NetObject
	U32 packUpdate(NetConnection *, U32, BitStream *);
	void unpackUpdate(NetConnection *, BitStream *);

	// Declare Console Object.
	DECLARE_CONOBJECT(fxInteriorDecal);
};

#endif // _fxInteriorDecal_H_
[/b]

2 small things need to be done to your scripts.
First off, we need a blank datablock, since this class is based on gamebasedata.
Originally, I did it differently, but later decided to keep everything as generic
as possible, thus keeping all GameEntity features similar in nature. Doing this,
I was able to avoid breaking old compiled difs.
anyfile.cs

datablock fxInteriorDecalData(GenericDecalData)
{
  // A blank datablock, simply so we can properly create this gamebase
  // derived object
  blank = 0;
};

The next change is actually optional. It simply prevents the decal from
being selectable in the editor, which is a good thing since any changes you
make will have no lasting effect. Up to you though...
common/editor.cs
In function editor::onAdd

// Terrain Editor
   exec("./TerrainEditorVSettingsGui.gui");

   // Ignore Replicated fxStatic Instances.
   EWorldEditor.ignoreObjClass("fxShapeReplicatedStatic");
   [b]EWorldEditor.ignoreObjClass("fxInteriorDecal");[/b]
   
   // do gui initialization...
   EditorGui.init();

Last thing to add, is changes to QuArK. If you use something else, well
you'll have to figure it out yourself.
dataTorque.qrk

Special entities.qtxfolder =
      {
        [b]game_entity:e =
        {
          origin = "0 0 0"
          angle = "360"
          ;desc = "Decal"
          datablock = "GenericDecalData"
          game_class = "fxInteriorDecal"
        }[/b]      
        MirrorSurface:e =
        {
          ;desc = "Mirror Surface Entity"
          origin = "0 0 0"
          alpha_level = "0"
        }

If all went well, your map file should look like this....

// Entity 9
// Entities:g[1] -> game_entity:e[9]
{
 "classname" "game_entity"
 "origin" "-382 -148 40"
 "angle" "360"
 "datablock" "GenericDecalData"
 "game_class" "fxInteriorDecal"
 "texture" "starter.fps/data/decals/decalgraffiti001b"
}