CWE-ou-minkata/Sources/Plasma/FeatureLib/pfConsole/pfConsoleCommands.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
//////////////////////////////////////////////////////////////////////////////
//																			//
//	Actual Console Commands and Groups										//
//																			//
//////////////////////////////////////////////////////////////////////////////

#ifdef PLASMA_EXTERNAL_RELEASE
#define LIMIT_CONSOLE_COMMANDS 1
#endif


#include "pfConsoleCmd.h"
#include "plgDispatch.h"

#include "plAgeLoader/plAgeLoader.h"
#include "plNetClient/plNetClientMgr.h"
#include "plPipeline/plDebugText.h"
#include "plPipeline/plPipeDebugFlags.h"
#include "plMessage/plMovieMsg.h"
#include "plDrawable/plDrawableSpans.h"
#include "plPipeline.h"
#include "pfCamera/plCameraModifier.h"
#include "pfCamera/plVirtualCamNeu.h"
#include "pfCamera/plCameraBrain.h"
#include "plResMgr/plResManager.h"
#include "pnKeyedObject/plFixedKey.h"
#include "pnKeyedObject/plKey.h"
#include "pnKeyedObject/plKeyImp.h"
#include "pnModifier/plLogicModBase.h"
#include "plModifier/plSDLModifier.h"
#include "plSDL/plSDL.h"
#include "pfCharacter/plPlayerModifier.h"
#include "plSurface/plLayerDepth.h"
#include "plSurface/plLayerOr.h"
#include "plSurface/plLayerOr.h"
#include "plAudio/plAudioSystem.h"
#include "plAudio/plVoiceChat.h"
#include "plAudio/plWinMicLevel.h"
#include "plPipeline/plFogEnvironment.h"
#include "plPipeline/plPlates.h"
#include "plPipeline/plDynamicEnvMap.h"
#include "hsTimer.h"
#include "pnMessage/plClientMsg.h"
#include "pnMessage/plEnableMsg.h"
#include "pnMessage/plAudioSysMsg.h"
#include "plMessage/plListenerMsg.h"
#include "pfAudio/plListener.h"
#include "plMessage/plAvatarMsg.h"
#include "plMessage/plOneShotMsg.h"
#include "plVault/plVault.h"
#include "../../Apps/plClient/plClient.h"
#include "pfConsole.h"
#include "pfConsoleContext.h"
#include "plResMgr/plKeyFinder.h"
#include "plModifier/plSimpleModifier.h"
#include "plAvatar/plAvatarMgr.h"
#include "plAvatar/plAvatarTasks.h"
#include "plAvatar/plAvBrainGeneric.h"
//#include "../plHavok1/plSimulationMgr.h"

#include "plMessage/plConsoleMsg.h"
#include "plMessage/plAnimCmdMsg.h"
#include "pnMessage/plCameraMsg.h"
#include "pnMessage/plSoundMsg.h"
#include "pnMessage/plEventCallbackMsg.h"
#include "pnMessage/plNotifyMsg.h"
#include "pfAnimation/plAnimDebugList.h"

#include "pnMessage/plNodeChangeMsg.h"
#include "pnMessage/plProxyDrawMsg.h"
#include "pnMessage/plObjRefMsg.h"
#include "pnMessage/plAttachMsg.h"
#include "plMessage/plSimInfluenceMsg.h"
#include "plMessage/plSimStateMsg.h"
#include "plMessage/plLinkToAgeMsg.h"
#include "pfMessage/pfKIMsg.h"

#include "plInputCore/plInputInterfaceMgr.h"
#include "plInputCore/plInputManager.h"
#include "plInputCore/plInputDevice.h"
#include "plInputCore/plAvatarInputInterface.h"
#include "plMessage/plInputEventMsg.h"
#include "pnInputCore/plKeyMap.h"

#include "plParticleSystem/plParticleSystem.h"
#include "plParticleSystem/plConvexVolume.h"
#include "plParticleSystem/plParticleEffect.h"
#include "plParticleSystem/plParticleGenerator.h"
#include "plSurface/hsGMaterial.h"
#include "pnSceneObject/plDrawInterface.h"
#include "pnSceneObject/plCoordinateInterface.h"
#include "plScene/plSceneNode.h"
#include "plScene/plPageTreeMgr.h"
#include "plScene/plPostEffectMod.h"
#include "pnMessage/plNodeRefMsg.h"
//#include "pnMessage/plWarpMsg.h"
#include "hsResMgr.h"

#include "plParticleSystem/plParticleSystem.h"
#include "plMessage/plParticleUpdateMsg.h"

#include "plDrawable/plDynaBulletMgr.h"

#include "plGImage/plMipmap.h"
#include "plGImage/plTGAWriter.h"

#include "plGLight/plShadowCaster.h"
#include "plGLight/plShadowMaster.h"

// begin for agedefn test
#include "hsStream.h"
#include "plAgeDescription/plAgeDescription.h"
#include "plUnifiedTime/plUnifiedTime.h"
//end for agedefn test

#include "plFile/hsFiles.h"
#include "pnSceneObject/plAudioInterface.h"

#include "plStatusLog/plStatusLog.h"
#include "pnTimer/pnBuildDates.h"

#include "hsStlUtils.h"
#include "hsTemplates.h"
#include "hsUtils.h"

#include "pfPython/cyPythonInterface.h"
#include "pfPython/plPythonSDLModifier.h"

#include "plResMgr/plResManagerHelper.h"
#include "plResMgr/plResMgrSettings.h"
#include "plResMgr/plLocalization.h"


#define PF_SANITY_CHECK( cond, msg ) { if( !( cond ) ) { PrintString( msg ); return; } }

//// DO NOT REMOVE!!!!
//// This is here so Microsoft VC won't decide to "optimize" this file out
//// DO NOT REMOVE!!!!
void	pfConsoleCmdGroup::Dummy( void )
{
}
//// DO NOT REMOVE!!!!

//// Defining Console Commands ///////////////////////////////////////////////
//
//	You define console commands by using the PF_CONSOLE_CMD macro. The format
//	of the macro is:
//
//		PF_CONSOLE_CMD( groupName, functionName, "paramList", "Help string" )
//
//	Where:
//		- groupName is a string representing what command group the command
//		  is in. Subgroups are specified by an underscore, i.e. to put a command
//		  in the Draw subgroup of the Graphics group, you would specify
//		  "Graphics_Draw". Specifying "" means to put the command in the base
//		  command group--i.e. it has no group.
//		- functionName is required; it specifies the function name (really?!?!).
//		  Function names must be globally unique, so you can't have a Draw
//		  function in both the Graphics and SceneAPI groups. Sorry. :(
//		- paramList specifies the parameters and types to the function.
//		  The smallest list you can have is "", which means "no parameters".
//		  If you have parameters, it must be in a comma-delimited string.
//		  You can either specify types or labels and types, so you can say
//		  "int, float" or "int x, float value". Currently, the labels are only
//		  used when printing out usage strings, but they will be used later
//		  for auto-labeling GUI elements, so please put them in where viable.
//
//		  White space does not matter. Valid types are int, float, char, string
//		  bool (auto-conversion of "true"/"false" strings to 1 or 0) and "...".
//		  "..." is a special type that means the same as the C equivalent:
//		  "there can be zero or more parameters here and I don't care what the
//		  type is" is the gist of it.
//		- helpString is a short description of the function, which currently
//		  isn't used, but will be used in the future when implementing help
//		  (could you have guessed it? :) Please fill it in when the function
//		  name isn't obvious (i.e. SetFogColor doesn't really need one)
//	
//	The actual C code prototype looks like:
//		void	pfConsoleCmd_groupName_functionName( UInt32 numParams, pfConsoleCmdParam *params, 
//														void (*PrintString)( char * ) );
//
//	numParams is exactly what it sounds like. params is an array of console
//	parameter objects, each of which are rather nifty in that they can be cast
//	immediately to whatever type you asked for in your parameter list
//	("paramList" above). So if your paramList was "int", then params[ 0 ]
//	can be cast to an int immediately, such as int x = params[ 0 ];
//	If you attempt to cast a parameter to a type other than the one specified
//	in the paramList, you get an hsAssert saying so, so don't do it! Any
//	parameters that fall under "..." are automagically strings, but they can
//	be cast to any valid type without an assert. So basically, if you want
//	to still do your own conversion, just specify "..." as the entire paramList
//	and treat the params array as if it were an array of strings.
//
//	Thus, the net result of the paramList is that it lets the console engine
//	do the parameter parsing for you. If the paramters given to the function
//	do not match the list (this includes too many or too few parameters), a
//	usage string is printed out and the function is not called. Thus, the
//	ONLY parameter error you can possibly have is casting a parameter object
//	to a type other than you asked for. So don't do it!
//
//	(Note: this makes numParams almost obsolete; the only reason it still has
//	a use is for "...", which of course allows variable number of parameters.)
//
//	PrintString is a function that lets you print output to the on-screen
//	console. It is guaranteed to be non-null. Worst case is that it points
//	to a dummy function that does nothing, but it will *always* be valid.
//
//	To define console command groups, you use the macro:
//
//		PF_CONSOLE_GROUP( group )
//
//	where "group" is the name without quotes of the group you want to create.
//	To create a subgroup inside a group, use:
//
//		PF_CONSOLE_SUBGROUP( parent, group )
//
//	where "parent" is the parent group for the subgroup. "parent" can have
//	underscores in it just like the group of a CONSOLE_CMD, so you can say
//
//		PF_CONSOLE_SUBGROUP( Graphics_Render, Drawing )
//
//	to create the Graphics_Render_Drawing subgroup. All groups must be
//	defined before any commands that are in that group. Note that although
//	the 
//
//////////////////////////////////////////////////////////////////////////////

//
// utility functions
//
//////////////////////////////////////////////////////////////////////////////
plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString=false);
plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString=false);
plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
							   char* statusStr, bool subString=false);

//
// Find an object from name, type (int), and optionally age.
// Name can be an alias specified by saying $foo
//
plKey FindObjectByName(const char* name, int type, const char* ageName, char* statusStr, bool subString)
{
	if (!name)
	{
		if (statusStr)
			sprintf(statusStr, "Object name is nil");
		return nil;
	}
	
	if (type<0 || type>=plFactory::GetNumClasses())
	{
		if (statusStr)
			sprintf(statusStr, "Illegal class type val");
		return nil;
	}

	plKey key=nil;
	// Try restricted to our age first, if we're not given an age name. This works
	// around most of the problems associated with unused keys in pages causing the pages to be marked
	// as not loaded and thus screwing up our searches
	if( ageName == nil && plNetClientMgr::GetInstance() != nil )
	{
		const char *thisAge = plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeName();
		if (thisAge != nil)
		{
			key = plKeyFinder::Instance().StupidSearch(thisAge, nil, type, name, subString);
			if (key != nil)
			{
				if (statusStr)	
					sprintf(statusStr, "Found Object");
				return key;
			}
		}
	}
	// Fallback
	key = plKeyFinder::Instance().StupidSearch(ageName,nil,type, name, subString);

	if (!key)
	{
		if (statusStr)
			sprintf(statusStr, "Can't find object");
		return nil;
	}
	
	if (!key->ObjectIsLoaded())
	{
		if (statusStr)
			sprintf(statusStr, "Object is not loaded");
	}

	if (statusStr)	
		sprintf(statusStr, "Found Object");

	return key;
}

//
// Find a SCENEOBJECT from name, and optionally age.
// Name can be an alias specified by saying $foo.
// Will load the object if necessary.
//
plKey FindSceneObjectByName(const char* name, const char* ageName, char* statusStr, bool subString)
{
	plKey key=FindObjectByName(name, plSceneObject::Index(), ageName, statusStr, subString);
	
	if (!plSceneObject::ConvertNoRef(key ? key->ObjectIsLoaded() : nil))
	{
		if (statusStr)
			sprintf(statusStr, "Can't find SceneObject");
		return nil;
	}

	return key;
}

//
// Find an object from name, type (string) and optionally age.
// Name can be an alias specified by saying $foo
//
plKey FindObjectByNameAndType(const char* name, const char* typeName, const char* ageName, 
							   char* statusStr, bool subString)
{
	if (!typeName)
	{
		if (statusStr)
			sprintf(statusStr, "TypeName is nil");
		return nil;
	}
	
	return FindObjectByName(name, plFactory::FindClassIndex(typeName), ageName, statusStr, subString);
}

void PrintStringF(void pfun(const char *),const char * fmt, ...)
{
	va_list args;

	char buffy[512];
	va_start(args, fmt);
	vsprintf(buffy, fmt, args);
	va_end(args);
	pfun(buffy);
}

//// plDoesFileExist //////////////////////////////////////////////////////////
//	Utility function to determine whether the given file exists

static hsBool	plDoesFileExist( const char *path )
{
	hsUNIXStream	stream;


	if( !stream.Open( path, "rb" ) )
		return false;

	stream.Close();
	return true;
}


//////////////////////////////////////////////////////////////////////////////
//// Base Commands ///////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_BASE_CMD( SampleCmd1, "", "Sample command #1" )
{
	// No parameters, enforced (i.e. this function won't get called unless
	// the calling line has no parameters)
}

PF_CONSOLE_BASE_CMD( SampleCmd2, "int myValue", "Sample command #2" )
{
	// One parameter, which is an int. Note that because of the console
	// engine, we no longer have to test for the number of parameters.

	// Since we said "int" as our type, this is perfectly valid
	int		myInt = (int)params[ 0 ] * 5;

	// This will assert on run-time, since it's not an int
	float	myFloat = params[ 0 ];

	// This is also BAD, since we only specified one parameter. It'll assert
	int		test = params[ 1 ];
}

PF_CONSOLE_BASE_CMD( SampleCmd3, "int, ...", "Sample command #3" )
{
	// One parameter, which is an int, plus zero or more paramters.

	// Still perfectly valid
	int		myInt = (int)params[ 0 ] * 5;

	// Note: we have to test numParams here because ... allows no extra
	// params, so we have to make sure we have one. Note: numParams
	// INCLUDES all parameters, in this case our int.
	if( numParams > 1 )
	{
		// This is okay--any parameters via ... are strings
		char	*str = params[ 1 ];

		// This is also okay, since ... allows the params to be cast
		// to any valid type. Note that if the parameter isn't actually
		// an int, it'll behave just like atoi()--i.e. return 0
		int		value = params[ 1 ];
	}
}

#endif // LIMIT_CONSOLE_COMMANDS


#ifndef LIMIT_CONSOLE_COMMANDS

#include "plMessage/plTransitionMsg.h"

PF_CONSOLE_BASE_CMD( FadeIn, "float len, bool hold", "Sample command #1" )
{
	plTransitionMsg	*msg = TRACKED_NEW plTransitionMsg( plTransitionMsg::kFadeIn, (float)params[ 0 ], (bool)params[ 1 ] );
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_BASE_CMD( FadeOut, "float len, bool hold", "Sample command #1" )
{
	plTransitionMsg	*msg = TRACKED_NEW plTransitionMsg( plTransitionMsg::kFadeOut, (float)params[ 0 ], (bool)params[ 1 ] );
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_BASE_CMD( NextStatusLog, "", "Cycles through the status logs" )
{
	plStatusLogMgr::GetInstance().NextStatusLog();
}

PF_CONSOLE_BASE_CMD( PrevStatusLog, "", "Cycles backwards through the status logs" )
{
	plStatusLogMgr::GetInstance().PrevStatusLog();
}


PF_CONSOLE_BASE_CMD( ShowStatusLog, "string logName", "Advances the status log display to the given log" )
{
	plStatusLogMgr::GetInstance().SetCurrStatusLog( params[ 0 ] );
}

#endif // LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_BASE_CMD( DisableLogging, "", "Turns off logging" )
{
	plStatusLog::fLoggingOff = true;
}


PF_CONSOLE_BASE_CMD( EnableLogging, "", "Turns on logging" )
{
	plStatusLog::fLoggingOff = false;
}

PF_CONSOLE_BASE_CMD( DumpLogs, "string folderName", "Dumps all current logs to the folder specified, relative to the log folder" )
{
	plStatusLogMgr::GetInstance().DumpLogs( params[ 0 ] );
}


//////////////////////////////////////////////////////////////////////////////
//// Stat Gather Commands ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_GROUP( Stats )

#include "plStatGather/plProfileManagerFull.h"

PF_CONSOLE_CMD( Stats, Show,	// Group name, Function name
				"...",			// Params
				"Shows or hides a given category of statistics.\n"
				"List the valid categories using Stats.ListGroups")
{
	const char* group = nil;
	if (numParams > 0)
		group = params[0];

	if(numParams > 1)
		plProfileManagerFull::Instance().ShowLaps(params[0], params[1]);
	else
		plProfileManagerFull::Instance().ShowGroup(group);
}

PF_CONSOLE_CMD(Stats, ResetMax,	// Group name, Function name
				"",			// Params
				"Resets the max value for all stats")
{
	plProfileManagerFull::Instance().ResetMax();
}

PF_CONSOLE_CMD(Stats, ShowNext, "", "Shows the next group of stats")
{
	plProfileManagerFull::Instance().ShowNextGroup();
}

PF_CONSOLE_CMD(Stats, ShowLaps,
				"string group, string stat",
				"")
{
	plProfileManagerFull::Instance().ShowLaps(params[0], params[1]);
}

PF_CONSOLE_CMD(Stats, ListGroups, "", "Prints the names of all the stat groups to the console")
{
	plProfileManagerFull::GroupSet groups;
	plProfileManagerFull::Instance().GetGroups(groups);

	plProfileManagerFull::GroupSet::iterator it;
	for (it = groups.begin(); it != groups.end(); it++)
		PrintString((char*)*it);
}

PF_CONSOLE_CMD(Stats, ListLaps, "", "Prints the names of all the stats with laps to the console")
{
	plProfileManagerFull::LapNames laps;
	plProfileManagerFull::Instance().GetLaps(laps);

	for (int i = 0; i < laps.size(); i++)
	{
		char buf[256];
		sprintf(buf, "%s - %s", laps[i].group, laps[i].varName);
		PrintString(buf);
	}
}

PF_CONSOLE_CMD(Stats, SetLapMin, "int min", "Sets the minimum index of which lap will display")
{
	plProfileManagerFull::Instance().SetMinLap((int)params[0]);
}


PF_CONSOLE_CMD(Stats, PageDownLaps, "", "Show the next page of laps")
{
	plProfileManagerFull::Instance().PageDownLaps();
}


PF_CONSOLE_CMD(Stats, PageUpLaps, "", "Show the previous page of laps")
{
	plProfileManagerFull::Instance().PageUpLaps();
}

PF_CONSOLE_CMD(Stats, SetAvgTime, "int ms", "Sets the amount of time stats are averaged over")
{
	plProfileManager::Instance().SetAvgTime((int)params[0]);
}

PF_CONSOLE_CMD(Stats, Graph, "string stat, int min, int max", "Graphs the specified stat")
{
	plProfileManagerFull::Instance().CreateGraph(params[0], (int)params[1], (int)params[2]);
}

PF_CONSOLE_CMD(Stats, ShowDetail, "", "Shows the detail stat graph")
{
	plProfileManagerFull::Instance().ShowDetailGraph();
}

PF_CONSOLE_CMD(Stats, HideDetail, "", "Hides the detail stat graph")
{
	plProfileManagerFull::Instance().HideDetailGraph();
}

PF_CONSOLE_CMD(Stats, ResetDetailDefaults, "", "Resets the detail graph's defaults")
{
	plProfileManagerFull::Instance().ResetDefaultDetailVars();
}

PF_CONSOLE_CMD(Stats, AddDetailVar, "string stat", "Adds the specified var to the detail graph with the default range of 0->100")
{
	plProfileManagerFull::Instance().AddDetailVar(params[0], 0, 100);
}

PF_CONSOLE_CMD(Stats, AddDetailVarWithOffset, "string stat, int offset", "Adds the specified var to the detail graph with a offset and default range\n"
											  "of 0->(100-offset)")
{
	int offset = (int)params[1];
	plProfileManagerFull::Instance().AddDetailVar(params[0], -offset, 100-offset);
}

PF_CONSOLE_CMD(Stats, AddDetailVarWithRange, "string stat, int min, int max", "Adds the specified var to the detail graph")
{
	plProfileManagerFull::Instance().AddDetailVar(params[0], (int)params[1], (int)params[2]);
}

PF_CONSOLE_CMD(Stats, AddDetailVarWithOffsetAndRange, "string stat, int offset, int min, int max", "Adds the specified var to the detail graph with an\n"
													  "offset and a range of min->(max-offset)")
{
	int offset = (int)params[1];
	plProfileManagerFull::Instance().AddDetailVar(params[0], (int)params[2]-offset, (int)params[3]-offset);
}

PF_CONSOLE_CMD(Stats, RemoveDetailVar, "string stat", "Removes the specified var from the detail graph")
{
	plProfileManagerFull::Instance().RemoveDetailVar(params[0]);
}

#include "plStatGather/plAutoProfile.h"

PF_CONSOLE_CMD(Stats, AutoProfile, "...", "Performs an automated profile in all the ages. Optional: Specify an age name to do just that age")
{
	const char* ageName = nil;
	if (numParams > 0)
		ageName = params[0];

	plAutoProfile::Instance()->StartProfile(ageName);
}

PF_CONSOLE_CMD(Stats, ProfileAllAgeLoads, "", "Turns on Registry.LogReadTimes and links to each age, then exits")
{
	((plResManager*)hsgResMgr::ResMgr())->LogReadTimes(true);
	plAutoProfile::Instance()->LinkToAllAges();
}

#endif // LIMIT_CONSOLE_COMMANDS


//////////////////////////////////////////////////////////////////////////////
//// Memory  Commands ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_GROUP( Memory )

#ifdef HS_FIND_MEM_LEAKS

PF_CONSOLE_CMD( Memory, DumpAllocReport,	// Group name, Function name
				"",			// Params
				"Dump heap allocations to file." )	// Help string
{
	MemDumpAllocReport();
}


PF_CONSOLE_CMD(Memory,
			   ValidateNow,
			   "",
			   "Validate all heap allocations")
{
    MemValidateNow();
}


PF_CONSOLE_CMD(Memory,
			   SetValidation,
			   "bool on",
			   "Validate all heap allocations each time memory is alloced or freed.")
{
    MemSetValidation((bool)params[0]);
}

PF_CONSOLE_CMD(Memory,
			   DumpUsage,
			   "",
			   "Dump heap usage to file")
{
    MemDumpUsageReport();
}


#endif

#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////////////////////
//// Console Group Commands //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_GROUP( Console )

PF_CONSOLE_CMD( Console, Clear, "", "Clears the console" )
{
	pfConsole::Clear();
}

PF_CONSOLE_CMD( Console, EnableFX, "bool enable", "Enables flashy console effects" )
{
	pfConsole::EnableEffects( (hsBool)(bool)params[ 0 ] );
	if( pfConsole::AreEffectsEnabled() )
		PrintString( "Console effects enabled" );
	else
		PrintString( "Console effects disabled" );
}

PF_CONSOLE_CMD( Console, SetTextColor, "int r, int g, int b", 
				"Sets the color of normal console text" )
{
	UInt32		color = 0xff000000 | ( (int)params[ 0 ] << 16 ) | ( (int)params[ 1 ] << 8 ) | ( (int)params[ 2 ] );

	pfConsole::SetTextColor( color );
}

class DocGenIterator : public pfConsoleCmdIterator
{
	FILE *fFile;	

public:
	DocGenIterator(FILE *f) { fFile = f; }
	virtual void ProcessCmd(pfConsoleCmd* c, int depth) 
	{

		if(strncmp("SampleCmd",c->GetName(), 9) != 0)
		{
			fprintf(fFile, "<P><I>%s </I><BR>%s </P>\n",c->GetSignature(),
					c->GetHelp());
		}
	}
	virtual bool ProcessGroup(pfConsoleCmdGroup *g, int depth) 
	{
	//	if(g->GetFirstCommand() != nil)
		{
			fprintf(fFile, "<P><B><H%s>Command %sGroup %s </B></H2></P>\n",
				(depth > 0) ? "3" : "2",
				(depth > 0) ? "Sub" :"" ,
				g->GetName());
		}
		return true;
	}
};

class BriefDocGenIterator : public pfConsoleCmdIterator
{
	FILE *fFile;	
	char fGrpName[200];

public:
	BriefDocGenIterator(FILE *f) { fFile = f; strcpy(fGrpName,"");}
	virtual void ProcessCmd(pfConsoleCmd* c, int depth) 
	{

		if(strncmp("SampleCmd",c->GetName(), 9) != 0)
		{
				fprintf(fFile, "<I>%s.%s </I> - %s <BR>\n",fGrpName,c->GetSignature(),
						c->GetHelp());
		}
	}
	virtual bool ProcessGroup(pfConsoleCmdGroup *g, int depth) 
	{
	//	if(g->GetFirstCommand() != nil)
		{
			fprintf(fFile, "<BR>\n");
			if(depth <1)
				strcpy(fGrpName, g->GetName());
			else 
			{
				strcat(fGrpName,".");
				strcat(fGrpName,g->GetName());
			}

		}
		return true;
	}
};

PF_CONSOLE_CMD( Console, CreateDocumentation, "string fileName", 
				"Writes HTML documentation for the current console commands" )
{

	PrintString((char*)params[0]);


	pfConsoleCmdGroup	*group;
	FILE *f;


	f = fopen(params[0],"wt");
	if(f == nil)
	{
		PrintString("Couldn't Open File");
		return;
	}
	

	fprintf(f, "<CENTER> <H2> Console Commands for Plasma 2.0 Client </H2> <I>Built %s on %s.</I></CENTER><BR>", 
		pnBuildDates::fBuildTime, pnBuildDates::fBuildDate );

	DocGenIterator iter(f);
	group = pfConsoleCmdGroup::GetBaseGroup();
	group->IterateCommands(&iter);

	fclose(f);
	
}


PF_CONSOLE_CMD( Console, CreateBriefDocumentation, "string fileName", 
				"Writes brief HTML documentation for the current console commands" )
{

	PrintString((char*)params[0]);


	pfConsoleCmdGroup	*group;
	FILE *f;


	f = fopen(params[0],"wt");
	if(f == nil)
	{
		PrintString("Couldn't Open File");
		return;
	}

	fprintf(f, "<CENTER> <H3> Console Commands for Plasma 2.0 Client </H3> <I>Built %s on %s.</I></CENTER><BR>", 
		pnBuildDates::fBuildTime, pnBuildDates::fBuildDate );
	BriefDocGenIterator iter(f);
	group = pfConsoleCmdGroup::GetBaseGroup();
	group->IterateCommands(&iter);

	fclose(f);
	
}

PF_CONSOLE_CMD( Console, SetVar, "string name, string value", 
				"Sets the value of a given global console variable" )
{
	pfConsoleContext &ctx = pfConsoleContext::GetRootContext();


	hsBool oldF = ctx.GetAddWhenNotFound();
	ctx.SetAddWhenNotFound( true );
	ctx.SetVar( params[ 0 ], params[ 1 ] );
	ctx.SetAddWhenNotFound( oldF );
}

PF_CONSOLE_CMD( Console, PrintVar, "string name", "Prints the value of a given global console variable" )
{
	pfConsoleContext &ctx = pfConsoleContext::GetRootContext();

	Int32 idx = ctx.FindVar( params[ 0 ] );
	if( idx == -1 )
		PrintString( "Variable not found" );
	else
	{
		PrintStringF( PrintString, "The value of %s is %s", (const char *)params[ 0 ], (const char *)ctx.GetVarValue( idx ) );
	}
}

PF_CONSOLE_CMD( Console, PrintAllVars, "", "Prints the values of all global console variables" )
{
	pfConsoleContext &ctx = pfConsoleContext::GetRootContext();

	UInt32	i;

	PrintString( "Global console variables:" );
	for( i = 0; i < ctx.GetNumVars(); i++ )
	{
		PrintStringF( PrintString, "  %s: %s", (const char *)ctx.GetVarName( i ), (const char *)ctx.GetVarValue( i ) );
	}
}

PF_CONSOLE_CMD( Console, ClearAllVars, "", "Wipes the global console variable context" )
{
	pfConsoleContext &ctx = pfConsoleContext::GetRootContext();
	ctx.Clear();
	PrintString( "Global context wiped" );
}

PF_CONSOLE_CMD( Console, ExecuteFile, "string filename", "Runs the given file as if it were an .ini or .fni file" )
{
	plConsoleMsg *cMsg = TRACKED_NEW plConsoleMsg( plConsoleMsg::kExecuteFile, params[ 0 ] );
	cMsg->Send();
}

PF_CONSOLE_CMD( Console, ExecuteFileDelayed, "string filename, float timeInSecs", "Runs the given file as if it were an .ini or .fni file, but at some given point in the future" )
{
	plConsoleMsg *cMsg = TRACKED_NEW plConsoleMsg( plConsoleMsg::kExecuteFile, params[ 0 ] );
	cMsg->SetTimeStamp( hsTimer::GetSysSeconds() + (float)params[ 1 ] );
	cMsg->Send();
}

#endif // LIMIT_CONSOLE_COMMANDS


//////////////////////////////////////////////////////////////////////////////
//// Graphics Group Commands /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_GROUP( Graphics ) // Defines a main command group

#ifndef LIMIT_CONSOLE_COMMANDS

// NOTE ON THESE DEBUG FLAGS:
// Any unique prefix will work for a given flag (although the
// TAB won't fill out the rest of the command). So "noli" works
// as well as "noLightMaps". So try to make the first 4 or 5 letters of
// the string flag both unique AND meaningful. E.g. if the flag will
// disable XYZ, then "noXYZ..." is a good start for the command (as opposed
// to "disableXYZ..."). Note also, that no checking for uniqueness happens
// (because I don't feel like it), so "SetDebugFlag no" will grab the first
// of many things that start with no (currently noMultiTexture). Since verbs
// tend to get reused more than subjects, start commands with the noun instead
// of the verb. E.g. "showBufferData" and "showNormals" can be more easily distinguished
// as bufferDataShow and normalsShow.
PF_CONSOLE_CMD( Graphics,			// Group name
				SetDebugFlag,				// Function name
				"string flag, ...",		// Params
				"Sets or toggles a pipeline debug flag.\nValid flags are:\n\
\tbufferDataShow - Shows vertex/index buffer stats\n\
\tnoMultiTexture - Disables multitexturing\n\
\tnoLightMaps - Disables lightmaps\n\
\tnoRTLights - Disables runtime lighting\n\
\tnoAlphaBlending - Disables alpha blending\n\
\tnoDecals - Disables drawing of decals\n\
\tnoFaceSort - Disables alpha-blending face sorting\n\
\tnormalShow - Shows normals for all vertices\n\
\tnoShadows - Toggles shadow generation and display\n\
\tnoUpper - Toggles render of upper layers\n\
\tnoBump - Toggles bump mapping\n\
\tnoRender - Toggles all rendering\n\
\tnoLODPop - Toggles ignoring of LOD Pops\n\
\tnoPlates - Toggles rendering of plates\n\
\tmipmapColorize - Color-codes mipmap levels\n\
\tnoAnisotropy - Disables anisotropic filtering\n\
\tallBright - Overrides D3D lighting equations (forces everything emissive)\n\
\tnoProjLights - Turns off runtime projected lights\n\
\toneMaterial - Toggles using one material for the entire scene\n\
\treShaders - reload all shaders\n\
\treTex - reload all textures from sysmem\n\
\tonlyProjLights - Turns off runtime non-projected lights\n\
\tnoFog - Disable all fog" )	// Help string
{
	UInt32		flag;
	bool		on;
	char		string[ 128 ], name[ 64 ];
	int			i;

	struct 
	{ 
		char name[ 64 ]; UInt32 flag; 
	} flags[] = { { "reloadTextures", plPipeDbg::kFlagReload },
					{ "noPreShade", plPipeDbg::kFlagNoPreShade},
					{ "noMultitexture", plPipeDbg::kFlagNoMultitexture },
					{ "noLightMaps", plPipeDbg::kFlagNoLightmaps },
					{ "noRTLights", plPipeDbg::kFlagNoRuntimeLights },
					{ "noAlphaBlending", plPipeDbg::kFlagNoAlphaBlending },
					{ "noDecals", plPipeDbg::kFlagNoDecals },
					{ "noFaceSort", plPipeDbg::kFlagDontSortFaces },
					{ "noSpecular", plPipeDbg::kFlagDisableSpecular },
					{ "normalShow", plPipeDbg::kFlagShowNormals },
					{ "mipmapColorize", plPipeDbg::kFlagColorizeMipmaps },
					{ "noShadows", plPipeDbg::kFlagNoShadows },
					{ "noUpper", plPipeDbg::kFlagNoUpperLayers },
					{ "noRender", plPipeDbg::kFlagNoRender },
					{ "noLODPop", plPipeDbg::kFlagSkipVisDist },
					{ "noPlates", plPipeDbg::kFlagNoPlates },
					{ "noBump", plPipeDbg::kFlagNoBump },
					{ "noAnisotropy", plPipeDbg::kFlagNoAnisotropy },
					{ "allBright", plPipeDbg::kFlagAllBright },
					{ "noProjLights", plPipeDbg::kFlagNoApplyProjLights },
					{ "oneMaterial", plPipeDbg::kFlagSingleMat},
					{ "onlyProjLights", plPipeDbg::kFlagOnlyApplyProjLights },
					{ "noFog", plPipeDbg::kFlagNoFog }
	};
	int		numDebugFlags = sizeof( flags ) / sizeof( flags[ 0 ] );


	if( numParams > 2 )
	{
		PrintString( "Invalid parameters. Use 'SetDebugFlag flag [, true|flase]'." );
		return;
	}

	for( i = 0; i < numDebugFlags; i++ )
	{
		if( strnicmp( params[ 0 ], flags[ i ].name, strlen(params[0]) ) == 0 )
		{
			flag = flags[ i ].flag;
			strcpy( name, flags[ i ].name );
			break;
		}
	}
	if( i == numDebugFlags )
	{
		flag = atoi( params[ 0 ] );
#ifndef HS_DEBUGGING
		if( flag < 1 || flag > flags[ numDebugFlags ].flag )
		{
			PrintString( "Invalid Flag. Check help for valid flags." );
			return;
		}
#endif
		sprintf( name, "Flag %d", flag );
	}

	if( numParams == 1 )
		on = !pfConsole::GetPipeline()->IsDebugFlagSet( flag );
	else
		on = params[ 1 ];

	pfConsole::GetPipeline()->SetDebugFlag( flag, on );

	sprintf( string, "%s is now %s", name, on ? "enabled" : "disabled" );
	PrintString( string );
}



PF_CONSOLE_SUBGROUP( Graphics, VisSet )		// Creates a sub-group under a given group

PF_CONSOLE_CMD( Graphics_VisSet, Toggle, "", "Toggle using VisSets" )
{
	hsBool turnOn = !plPageTreeMgr::VisMgrEnabled();
	plPageTreeMgr::EnableVisMgr(turnOn);

	PrintStringF( PrintString, "Visibility Sets %s", turnOn ? "Enabled" : "Disabled" );
}

PF_CONSOLE_CMD( Graphics, BumpNormal, "", "Set bump mapping method to default for your hardware." )
{
	PF_SANITY_CHECK( pfConsole::GetPipeline(), "This command MUST be used in an .fni file (after pipeline initialization)" );

	if( pfConsole::GetPipeline()->GetMaxLayersAtOnce() > 3 )
	{
		pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpUV, false);
		pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpW, false);
	}
	else
	{
		pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpUV, true);
		pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpW, false);
	}
}

PF_CONSOLE_CMD( Graphics, BumpUV, "", "Set bump mapping method to GeForce2 compatible." )
{
	PF_SANITY_CHECK( pfConsole::GetPipeline(), "This command MUST be used in an .fni file (after pipeline initialization)" );

	pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpUV, true);
	pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpW, false);
}

PF_CONSOLE_CMD( Graphics, BumpW, "", "Set bump mapping method to cheapest available." )
{
	PF_SANITY_CHECK( pfConsole::GetPipeline(), "This command MUST be used in an .fni file (after pipeline initialization)" );

	pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpUV, false);
	pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagBumpW, true);
}


PF_CONSOLE_CMD( Graphics, AllowWBuffering, "", "Enables the use of w-buffering\n(w-buffering is disabled by default)." )
{
	PF_SANITY_CHECK( pfConsole::GetPipeline() == nil, "This command MUST be used in an .ini file (before pipeline initialization)" );

	extern UInt32 fDbgSetupInitFlags;


	fDbgSetupInitFlags |= 0x00000001;
	PrintString( "W-buffering enabled." );
}

PF_CONSOLE_CMD( Graphics, ForceGeForce2Quality, "", "Forces higher-level hardware down to roughly the capabilities of a GeForce 2." )
{
	PF_SANITY_CHECK( pfConsole::GetPipeline() == nil, "This command MUST be used in an .ini file (before pipeline initialization)" );

	extern UInt32 fDbgSetupInitFlags;


	fDbgSetupInitFlags |= 0x00000004;
	PrintString( "Hardware caps forced down to GeForce 2 level." );
}

#endif // LIMIT_CONSOLE_COMMANDS



//// Graphics.Shadow SubGroup /////////////////////////////////////////////
PF_CONSOLE_SUBGROUP( Graphics, Shadow )		// Creates a sub-group under a given group

PF_CONSOLE_CMD( Graphics_Shadow,
			   Enable,
			   "bool enable",
			   "Enable shadows." )
{
	bool enable = (bool)params[0];

	if (enable)
	{
		plShadowCaster::EnableShadowCast();
		PrintString("Shadows Enabled");
	}
	else
	{
		plShadowCaster::DisableShadowCast();
		PrintString("Shadows Disabled");
	}
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   Disable,
			   "", 
			   "Disable shadows." )
{
	plShadowCaster::DisableShadowCast();
	PrintString("Shadows Disabled");
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   Toggle,
			   "", 
			   "Toggle shadows." )
{
	plShadowCaster::ToggleShadowCast();
	PrintString(plShadowCaster::ShadowCastDisabled() ? "Shadows Disabled" : "Shadows Enabled");
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   Show,
			   "", 
			   "Show shadows." )
{
	hsBool on = !pfConsole::GetPipeline()->IsDebugFlagSet(plPipeDbg::kFlagShowShadowBounds);
	pfConsole::GetPipeline()->SetDebugFlag( plPipeDbg::kFlagShowShadowBounds, on );

	char	str[ 256 ];
	sprintf( str, "Shadow bounds now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   Apply,
			   "", 
			   "Toggles applying shadows (they are still computed)." )
{
	hsBool on = !pfConsole::GetPipeline()->IsDebugFlagSet(plPipeDbg::kFlagNoShadowApply);
	pfConsole::GetPipeline()->SetDebugFlag( plPipeDbg::kFlagNoShadowApply, on );

	char	str[ 256 ];
	sprintf( str, "Shadow apply now %s", on ? "disabled" : "enabled" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   MaxSize,
			   "...", 
			   "Max shadowmap size." )
{
	int size;
	if( numParams > 0 )
	{
		size = atoi( params[ 0 ] );

		plShadowMaster::SetGlobalMaxSize(size);
	}
	else
	{
		size = plShadowMaster::GetGlobalMaxSize();
	}
	char str[256];
	sprintf(str, "Max shadowmap size %d", size);
	PrintString(str);
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   MaxDist,
			   "...", 
			   "Max shadowmap vis distance." )
{
	float dist;
	if( numParams > 0 )
	{
		dist = (float)atof( params[ 0 ] );

		plShadowMaster::SetGlobalMaxDist(dist);
	}
	else
	{
		dist = plShadowMaster::GetGlobalMaxDist();
	}
	char str[256];
	sprintf(str, "Max shadowmap vis dist %f", dist);
	PrintString(str);
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   VisibleDistance,
			   "...", 
			   "Shadow quality (0 to 1)." )
{
	float parm;
	if( numParams > 0 )
	{
		parm = (float)atof( params[ 0 ] );

		plShadowMaster::SetGlobalShadowQuality(parm);
	}
	else
	{
		parm = plShadowMaster::GetGlobalShadowQuality();
	}
	char str[256];
	sprintf(str, "Shadow quality %f", parm);
	PrintString(str);
}

PF_CONSOLE_CMD( Graphics_Shadow, 
			   Blur,
			   "...", 
			   "Max shadowmap blur size." )
{
	extern hsScalar blurScale;
	if( numParams > 0 )
	{
		blurScale = (hsScalar)atof( params[ 0 ] );
	}
	else
	{
	}
	char str[256];
	sprintf(str, "Max shadowmap Blur %f", blurScale);
	PrintString(str);
}

//// Graphics.DebugText SubGroup /////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_SUBGROUP( Graphics, DebugText )		// Creates a sub-group under a given group

PF_CONSOLE_CMD( Graphics_DebugText,			// Group name
				SetFont,					// Function name
				"string face, int size",	// Params
				"Sets the font face and size used for drawing debug text" )	// Help string
{
	plDebugText::Instance().SetFont( params[ 0 ], (UInt16)(int)params[ 1 ] );
}

PF_CONSOLE_CMD( Graphics_DebugText,			// Group name
				Enable,						// Function name
				"",							// Params
				"Enables debug text drawing" )	// Help string
{
	plDebugText::Instance().SetEnable( true );
}

PF_CONSOLE_CMD( Graphics_DebugText,			// Group name
				Disable,					// Function name
				"",							// Params
				"Disables debug text drawing" )	// Help string
{
	plDebugText::Instance().SetEnable( false );
}

#endif // LIMIT_CONSOLE_COMMANDS
	

PF_CONSOLE_SUBGROUP( Graphics, Renderer )		// Creates a sub-group under a given group

PF_CONSOLE_CMD( Graphics_Renderer, SetClearColor, "float r, float g, float b", "Sets the global clear color" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	hsColorRGBA		c;

	c.Set( params[ 0 ], params[ 1 ], params[ 2 ], 1.0f );
	plClient::GetInstance()->SetClearColor( c );
}


#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_CMD( Graphics_Renderer, mfTest, "int mfDbgTest", "Reserved for internal testing" )
{
	extern int mfCurrentTest;

	mfCurrentTest = (int) params[0];

	char	str[ 256 ];
	sprintf( str, "Current test %d.", mfCurrentTest );
	PrintString( str );
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Graphics_Renderer, Gamma, "float g, ...", "Set gamma value (g or (r,g,b))" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	hsScalar g = params[0];

	if( numParams == 1 )
	{
		pfConsole::GetPipeline()->SetGamma(g);

//		char	str[ 256 ];
//		sprintf(str, "Gamma set to %g.", g);
//		PrintString(str);
	}
	else
	{
		hsScalar eR = g;
		hsScalar eG = g;
		hsScalar eB = g;

		if( numParams > 2 )
			eB = params[2];
		eG = params[1];

		pfConsole::GetPipeline()->SetGamma(eR, eG, eB);

//		char	str[ 256 ];
//		sprintf(str, "Gamma set to (%g, %g, %g).", eR, eG, eB);
//		PrintString(str);
	}
}

PF_CONSOLE_CMD( Graphics_Renderer, Gamma2, "float g", "Set gamma value (alternative ramp)" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	hsTArray<UInt16> ramp;
	ramp.SetCount(256);

	hsScalar g = params[0];

	int i;
	for( i = 0; i < 256; i++ )
	{
		hsScalar t = hsScalar(i) / 255.f;
		hsScalar sinT = sin(t * hsScalarPI / 2.f);

		hsScalar remap = t + (sinT - t) * g;
		if( remap < 0 )
			remap = 0;
		else if( remap > 1.f )
			remap = 1.f;

		ramp[i] = UInt16(remap * hsScalar(UInt16(-1)) + 0.5f);
	}

	pfConsole::GetPipeline()->SetGamma(ramp.AcquireArray());

//	char	str[ 256 ];
//	sprintf(str, "Gamma set to <alt> %g.", g);
//	PrintString(str);
}

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Graphics_Renderer, MaxCullNodes, "...", "Limit occluder processing" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	int maxCullNodes;
	if( numParams > 0 )
	{
		maxCullNodes = (int) params[0];
		pfConsole::GetPipeline()->SetMaxCullNodes(maxCullNodes);
	}
	else
	{
		maxCullNodes = pfConsole::GetPipeline()->GetMaxCullNodes();
	}

	char	str[ 256 ];
	sprintf( str, "Max Cull Nodes now %d.", maxCullNodes );
	PrintString( str );
}


#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Graphics_Renderer, SetYon, "float yon, ...", "Sets the view yon" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	hsScalar		hither, yon;


	pfConsole::GetPipeline()->GetDepth( hither, yon );

	pfConsole::GetPipeline()->SetDepth( hither, (float)params[ 0 ] );
	pfConsole::GetPipeline()->RefreshMatrices();
	
	char	str[ 256 ];
	sprintf( str, "Yon set to %4.1f.", (float)params[ 0 ] );
	PrintString( str );
}

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Graphics_Renderer, TweakZBiasScale, "float deltaScale", "Adjusts the device-dependent scale value for upper-layer z biasing" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	hsScalar		scale;

	scale = pfConsole::GetPipeline()->GetZBiasScale();
	scale += (float)params[ 0 ];
	pfConsole::GetPipeline()->SetZBiasScale( scale );
	
	char	str[ 256 ];
	sprintf( str, "Z bias scale now set to %4.2f.", (float)scale );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Renderer, SetZBiasScale, "float scale", "Sets the device-dependent scale value for upper-layer z biasing" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	pfConsole::GetPipeline()->SetZBiasScale( (float)params[ 0 ] );
	
	char	str[ 256 ];
	sprintf( str, "Z bias scale now set to %4.2f.", (float)params[ 0 ] );
	PrintString( str );
}



PF_CONSOLE_CMD( Graphics_Renderer, Overwire, "...", "Turn on (off) overlay wire rendering" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	hsBool on = false;
	UInt32 flag = plPipeDbg::kFlagOverlayWire;
	if( !numParams )
		on = !pfConsole::GetPipeline()->IsDebugFlagSet( flag );
	else
		on = (bool)params[ 0 ];

	pfConsole::GetPipeline()->SetDebugFlag( flag, on );

	char str[256];
	sprintf( str, "OverlayWire is now %s", on ? "enabled" : "disabled" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Renderer, Overdraw, "bool on", "Turn on (off) overdraw rendering" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	static plLayerDepth ld;
	static bool ldOn = false;
	if( (bool)params[0] )
	{
		if( !ldOn )
		{
			pfConsole::GetPipeline()->AppendLayerInterface( &ld, true );
			pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagNoLightmaps, true);
			ldOn = true;
		}
	}
	else
	{
		if( ldOn )
		{
			pfConsole::GetPipeline()->RemoveLayerInterface( &ld, true );
			pfConsole::GetPipeline()->SetDebugFlag(plPipeDbg::kFlagNoLightmaps, false	);
			ldOn = false;
		}
	}
}

PF_CONSOLE_CMD( Graphics_Renderer, Wireframe, "...", "Toggle or set wireframe view mode." )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	static bool			wireOn = false;
	static plLayerOr	wireLayer;


	if( numParams > 1 )
	{
		PrintString( "Invalid parameters. Use 'Wireframe [true|false]'." );
		return;
	}

	wireLayer.SetMiscFlags( hsGMatState::kMiscWireFrame );

	if( numParams == 0 )
		wireOn = !wireOn;
	else if( wireOn == (bool)params[ 0 ] )
		return;
	else
		wireOn = (bool)params[ 0 ];

	if( wireOn )
		pfConsole::GetPipeline()->AppendLayerInterface( &wireLayer );
	else
		pfConsole::GetPipeline()->RemoveLayerInterface( &wireLayer );

	char	str[ 256 ];
	sprintf( str, "Wireframe view mode is now %s.", wireOn ? "enabled" : "disabled" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Renderer, TwoSided, "...", "Toggle or set force two-sided." )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	static bool			twoSideOn = false;
	static plLayerOr	twoSideLayer;


	if( numParams > 1 )
	{
		PrintString( "Invalid parameters. Use 'TwoSided [true|false]'." );
		return;
	}

	twoSideLayer.SetMiscFlags( hsGMatState::kMiscTwoSided );

	if( numParams == 0 )
		twoSideOn = !twoSideOn;
	else if( twoSideOn == (bool)params[ 0 ] )
		return;
	else
		twoSideOn = (bool)params[ 0 ];

	if( twoSideOn )
		pfConsole::GetPipeline()->AppendLayerInterface( &twoSideLayer );
	else
		pfConsole::GetPipeline()->RemoveLayerInterface( &twoSideLayer );

	char	str[ 256 ];
	sprintf( str, "Two-sided mode is now %s.", twoSideOn ? "enabled" : "disabled" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Renderer, ResetDevice,
			   "int width, int height, int colordepth, bool Windowed, int numAASamples, int MaxAnisotropicSamples",
			   "Reset Display Device")
{
	plClient::GetInstance()->ResetDisplayDevice((int)params[0], (int)params[1], (int)params[2], (bool)params[3], (int)params[4], (int)params[5]);
}
#endif // LIMIT_CONSOLE_COMMANDS


static bool MakeUniqueFileName(const char* prefix, const char* ext, char* fileName)
{
	for (UInt32 uniqueNumber = 1; uniqueNumber < 1000; uniqueNumber++)
	{
		sprintf(fileName, "%s%03d.%s", prefix, uniqueNumber, ext);

		if (!plDoesFileExist(fileName))
			return true;
	}

	return false;
}


#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_CMD( Graphics_Renderer, TakeScreenshot, "...", "Takes a shot of the current frame and saves it to the given file" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	plMipmap		myMipmap;
	char			fileName[ 512 ];


	if( numParams > 1 )
	{
		PrintString( "Too many parameters to TakeScreenshot" );
		return;
	}
	else if( numParams == 1 )
		strcpy( fileName, (char *)params[ 0 ] );
	else
	{
		// Think up a filename
		if (!MakeUniqueFileName("screen", "tga", fileName))
		{
			PrintString( "Out of filenames for TakeScreenshot" );
			return;
		}
	}

	if( !pfConsole::GetPipeline()->CaptureScreen( &myMipmap ) )
		PrintString( "Error capturing screenshot" );
	else
	{
		char	str[ 512 ];

		plTGAWriter::Instance().WriteMipmap( fileName, &myMipmap );
		sprintf( str, "Screenshot written to '%s'.", fileName );
		PrintString( str );
	}
}

#include "pfSurface/plGrabCubeMap.h"

PF_CONSOLE_CMD( Graphics_Renderer, GrabCubeMap, 
			   "string sceneObject, string prefix", 
			   "Take cubemap from sceneObject's position and name it prefix_XX.jpg")
{
	char str[512];
	const char* objName = params[0];
	plKey key = FindSceneObjectByName(objName, nil, str);
	PrintString( str );
	if( !key )
		return;
	plSceneObject *obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !obj )
		return;

	hsColorRGBA clearColor = plClient::GetInstance()->GetClearColor();
	const char* pref = params[1];
	plGrabCubeMap grabCube;
	grabCube.GrabCube(pfConsole::GetPipeline(), obj, pref, clearColor);
}

PF_CONSOLE_CMD( Graphics_Renderer, GrabCubeCam, 
			   "string prefix", 
			   "Take cubemap from camera's position and name it prefix_XX.jpg")
{
	hsPoint3 pos = pfConsole::GetPipeline()->GetViewPositionWorld();

	hsColorRGBA clearColor = plClient::GetInstance()->GetClearColor();
	const char* pref = params[1];
	plGrabCubeMap grabCube;
	grabCube.GrabCube(pfConsole::GetPipeline(), pos, pref, clearColor);
}

#include "plJPEG/plJPEG.h"

PF_CONSOLE_CMD( Graphics_Renderer, TakeJPEGScreenshot, "...", "Takes a shot of the current frame and saves it to the given file" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	plMipmap		myMipmap;
	char			fileName[ 512 ];


	if( numParams > 2 )
	{
		PrintString( "Too many parameters to TakeScreenshot" );
		return;
	}
	else if( numParams > 0 )
		strcpy( fileName, (char *)params[ 0 ] );
	else
	{
		// Think up a filename
		if (!MakeUniqueFileName("screen", "jpg", fileName))
		{
			PrintString( "Out of filenames for TakeScreenshot" );
			return;
		}
	}

	if( !pfConsole::GetPipeline()->CaptureScreen( &myMipmap ) )
		PrintString( "Error capturing screenshot" );
	else
	{
		char	str[ 512 ];
		UInt8	quality = 75;


		if( numParams == 2 )
			quality = (int)params[ 1 ];

		plJPEG::Instance().SetWriteQuality( quality );

		if( !plJPEG::Instance().WriteToFile( fileName, &myMipmap ) )
		{
			sprintf( str, "JPEG write failed (%s).", plJPEG::Instance().GetLastError() );
		}
		else
			sprintf( str, "Screenshot written to '%s', quality of %d%%.", fileName, quality );
		PrintString( str );
	}
}

#include "plGImage/plAVIWriter.h"

PF_CONSOLE_CMD( Graphics_Renderer, AVIWrite, "...", "Saves each frame to an AVI file" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	char fileName[ 512 ];

	if( numParams > 2 )
	{
		PrintString( "Too many parameters to AVIWrite" );
		return;
	}
	else if( numParams > 0 )
		strcpy( fileName, (char *)params[ 0 ] );
	else
	{
		// Think up a filename
		if (!MakeUniqueFileName("movie", "avi", fileName))
		{
			PrintString( "Out of filenames for AVIWrite" );
			return;
		}
	}

	if (!plAVIWriter::Instance().Open(fileName, pfConsole::GetPipeline()))
		PrintString( "AVI file create failed");
}

PF_CONSOLE_CMD(Graphics_Renderer, AVIClose, "", "Stops the current AVI recording")
{
	plAVIWriter::Instance().Close();
	PrintString("Recording stopped");
}

/*
PF_CONSOLE_CMD( Graphics_Renderer, GenerateReflectMaps, "string baseObject, string baseFileName, int size", "Generates the six cubic faces of a reflection map centered on the given object" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );

	// First, create the renderTarget for the renderRequests
	plRenderTarget *target = TRACKED_NEW plRenderTarget( plRenderTarget::kIsProjected | plRenderTarget::kIsTexture, 
												params[ 2 ], params[ 2 ], 32, 24, 0 );

//	plMipmap *newMip = TRACKED_NEW plMipmap( size, size, plMipmap::kARGB32Config, 1 );


	c.Set( params[ 0 ], params[ 1 ], params[ 2 ], 1.0f );
	plClient::GetInstance()->SetClearColor( c );
}
*/

PF_CONSOLE_CMD( Graphics_Renderer, ToggleScene, "", "Toggles main scene drawing" )
{
	if( plClient::GetInstance() == nil )
	{
		PrintString( "Command invalid before client init" );
		return;
	}

	if( plClient::GetInstance()->HasFlag( plClient::kFlagDBGDisableRender ) )
	{
		plClient::GetInstance()->SetFlag( plClient::kFlagDBGDisableRender, false );
		PrintString( "Scene rendering enabled" );
	}
	else
	{
		plClient::GetInstance()->SetFlag( plClient::kFlagDBGDisableRender, true );
		PrintString( "Scene rendering disabled" );
	}
}

PF_CONSOLE_CMD( Graphics_Renderer, ToggleRenderRequests, "", "Toggles processing of pre- and post-render requests" )
{
	if( plClient::GetInstance() == nil )
	{
		PrintString( "Command invalid before client init" );
		return;
	}

	if( plClient::GetInstance()->HasFlag( plClient::kFlagDBGDisableRRequests ) )
	{
		plClient::GetInstance()->SetFlag( plClient::kFlagDBGDisableRRequests, false );
		PrintString( "Render requests enabled" );
	}
	else
	{
		plClient::GetInstance()->SetFlag( plClient::kFlagDBGDisableRRequests, true );
		PrintString( "Render requests disabled" );
	}
}

#endif // LIMIT_CONSOLE_COMMANDS

//// Graphics.Renderer.Fog Subgroup //////////////////////////////////////////

PF_CONSOLE_SUBGROUP( Graphics_Renderer, Fog )

PF_CONSOLE_CMD( Graphics_Renderer_Fog, SetDefColor, "float r, float g, float b", "Sets the default fog color" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );


	plFogEnvironment	env;
	hsColorRGBA			color;

	color.Set( params[ 0 ], params[ 1 ], params[ 2 ], 1.0f );
	env = pfConsole::GetPipeline()->GetDefaultFogEnviron();
	env.SetColor( color );
	pfConsole::GetPipeline()->SetDefaultFogEnviron( &env );
}

PF_CONSOLE_CMD( Graphics_Renderer_Fog, SetDefLinear, "float start, float end, float density", "Sets the default fog to linear" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );


	plFogEnvironment	env;

	env = pfConsole::GetPipeline()->GetDefaultFogEnviron();
	env.Set( params[ 0 ], params[ 1 ], params[ 2 ] ); 
	pfConsole::GetPipeline()->SetDefaultFogEnviron( &env );
}

PF_CONSOLE_CMD( Graphics_Renderer_Fog, SetDefExp, "float end, float density", "Sets the default fog to linear" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );


	plFogEnvironment	env;

	env = pfConsole::GetPipeline()->GetDefaultFogEnviron();
	env.SetExp( plFogEnvironment::kExpFog, params[ 0 ], params[ 1 ] ); 
	pfConsole::GetPipeline()->SetDefaultFogEnviron( &env );
}

PF_CONSOLE_CMD( Graphics_Renderer_Fog, SetDefExp2, "float end, float density", "Sets the default fog to exp^2" )
{
	hsAssert( pfConsole::GetPipeline() != nil, "Cannot use this command before pipeline initialization" );


	plFogEnvironment	env;

	env = pfConsole::GetPipeline()->GetDefaultFogEnviron();
	env.SetExp( plFogEnvironment::kExp2Fog, params[ 0 ], params[ 1 ] ); 
	pfConsole::GetPipeline()->SetDefaultFogEnviron( &env );
}

//// Graphics.Show Subgroups //////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_SUBGROUP( Graphics, Show );

PF_CONSOLE_CMD( Graphics_Show, Bounds, "", "Toggle object bounds display")
{
	hsBool on = !pfConsole::GetPipeline()->IsDebugFlagSet( plPipeDbg::kFlagShowAllBounds );
	pfConsole::GetPipeline()->SetDebugFlag( plPipeDbg::kFlagShowAllBounds, on );

	char	str[ 256 ];
	sprintf( str, "Bounds now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, Sound, "", "Toggle sound fields visible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kAudible | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kAudibleProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kAudibleProxy);

	char	str[ 256 ];
	sprintf( str, "Sounds now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, SingleSound,
				"string sceneObject", "Toggles the proxy fields for a single sound object" )
{
	char	str[ 512 ];

	const char *ageName = plAgeLoader::GetInstance()->GetCurrAgeDesc().GetAgeName();

	plKey key = FindSceneObjectByName( params[ 0 ], ageName, str, true );
	plSceneObject *obj = ( key != nil ) ? plSceneObject::ConvertNoRef( key->GetObjectPtr() ) : nil;
	if( !obj )
	{
		sprintf( str, "Cannot find sceneObject %s", (char *)params[ 0 ] );
		PrintString( str );
		return;
	}

	const plAudioInterface	*ai = obj->GetAudioInterface();
	if( ai == nil )
	{
		sprintf( str, "sceneObject %s has no audio interface", (char *)params[ 0 ] );
		PrintString( str );
		return;
	}
	plKey	aiKey = ai->GetKey();

	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg( plProxyDrawMsg::kAudible | plProxyDrawMsg::kToggle );
	msg->SetBCastFlag( plMessage::kBCastByExactType, false );
	msg->AddReceiver( aiKey );
	plgDispatch::MsgSend( msg );

	// Just in case we need to show them. Since we're toggling, we don't even know if it's being hidden and
	// thus we should turn this off. Since this is purely for debugging, the slight performance hit on this
	// is, imho, acceptable.
	pfConsole::GetPipeline()->SetDrawableTypeMask( pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kAudibleProxy );

	char str2[ 256 ];
	sprintf( str2, "Toggling proxies on sceneObject %s", (char *)params[ 0 ] );
	PrintString( str2 );
}

PF_CONSOLE_CMD( Graphics_Show, SoundOnly, "", "Toggle only sound fields visible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kAudible | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	static UInt32 oldMask = plDrawableSpans::kNormal;
	if( on )
	{
		oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kAudibleProxy);
	}
	else
	{
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);
	}
	char	str[ 256 ];
	sprintf( str, on ? "Now showing only sound proxies" : "Restoring previous render state" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, OccSnap, "", "Take snapshot of current occlusion and render (or toggle)")
{
	UInt32 flag = plPipeDbg::kFlagOcclusionSnap;
	hsBool on = !pfConsole::GetPipeline()->IsDebugFlagSet(flag);

	pfConsole::GetPipeline()->SetDebugFlag( flag, on );
	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kOccSnapProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kOccSnapProxy);

	char	str[ 256 ];
	sprintf( str, "Active Occluders now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, OccSnapOnly, "", "Take snapshot of current occlusion and render (or toggle)")
{
	UInt32 flag = plPipeDbg::kFlagOcclusionSnap;
	hsBool on = !pfConsole::GetPipeline()->IsDebugFlagSet(flag);

	static UInt32 oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();

	pfConsole::GetPipeline()->SetDebugFlag( flag, on );
	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kOccSnapProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);

	char	str[ 256 ];
	sprintf( str, "Active Occluders now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, Occluders, "", "Toggle occluder geometry visible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kOccluder | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);

	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kOccluderProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kOccluderProxy);

	char	str[ 256 ];
	sprintf( str, "Occluders now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, OccludersOnly, "", "Toggle only occluder geometry visible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kOccluder | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	static UInt32 oldMask = plDrawableSpans::kNormal;
	if( on )
	{
		oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kOccluderProxy);
	}
	else
	{
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);
	}
	char	str[ 256 ];
	sprintf( str, on ? "Now showing only occluder proxies" : "Restoring previous render state" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, Physicals, "", "Toggle Physical geometry visible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kPhysical | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kPhysicalProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kPhysicalProxy);

	char	str[ 256 ];
	sprintf( str, "Physicals now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, PhysicalsOnly, "", "Toggle only Physical geometry visible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kPhysical | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	static UInt32 oldMask = plDrawableSpans::kNormal;
	if( on )
	{
		oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kPhysicalProxy);
	}
	else
	{
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);
	}
	char	str[ 256 ];
	sprintf( str, on ? "Now showing only physics proxies" : "Restoring previous render state" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, Normal, "", "Toggle normal geometry visible")
{
	static hsBool on = true;
	if( on = !on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kNormal);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kNormal);

	char	str[ 256 ];
	sprintf( str, "Normal geometry now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, NormalOnly, "", "Toggle only normal geometry visible")
{
	static hsBool on = false;
	static UInt32 oldMask = plDrawableSpans::kNormal;
	if( on = !on )
	{
		oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kNormal);
	}
	else
	{
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);
	}
	char	str[ 256 ];
	sprintf( str, on ? "Now showing only normal geometry" : "Restoring previous render state" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, Lights, "", "Toggle visible proxies for lights")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kLight | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kLightProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kLightProxy);

	char	str[ 256 ];
	sprintf( str, "Lights now %s", on ? "visible" : "invisible" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, LightsOnly, "", "Toggle visible proxies for lights and everything else invisible")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kLight | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	static UInt32 oldMask = plDrawableSpans::kNormal;
	if( on )
	{
		oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kLightProxy);
	}
	else
	{
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);
	}
	char	str[ 256 ];
	sprintf( str, on ? "Now showing only light proxies" : "Restoring previous render state" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics_Show, Clicks, "", "Toggle visible proxies for clicks")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kCamera | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	if( on )
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() | plDrawableSpans::kCameraProxy);
	else
		pfConsole::GetPipeline()->SetDrawableTypeMask(pfConsole::GetPipeline()->GetDrawableTypeMask() & ~plDrawableSpans::kCameraProxy);

	char	str[ 256 ];
	sprintf( str, "Clicks now %s", on ? "visible" : "invisible" );
	PrintString( str );
}


PF_CONSOLE_CMD( Graphics_Show, ClickOnly, "", "Toggle visible proxies for click points")
{
	static hsBool on = false;
	plProxyDrawMsg* msg = TRACKED_NEW plProxyDrawMsg(plProxyDrawMsg::kCamera | ((on = !on) ? plProxyDrawMsg::kCreate : plProxyDrawMsg::kDestroy));
	plgDispatch::MsgSend(msg);
	static UInt32 oldMask = plDrawableSpans::kNormal;
	if( on )
	{
		oldMask = pfConsole::GetPipeline()->GetDrawableTypeMask();
		pfConsole::GetPipeline()->SetDrawableTypeMask(plDrawableSpans::kCameraProxy);
	}
	else
	{
		pfConsole::GetPipeline()->SetDrawableTypeMask(oldMask);
	}
	char	str[ 256 ];
	sprintf( str, on ? "Now showing only camera proxies" : "Restoring previous render state" );
	PrintString( str );
}

PF_CONSOLE_CMD( Graphics, ForceSecondMonitor, "bool v", "Run the game on the second monitor" )
{
	plPipeline::fInitialPipeParams.ForceSecondMonitor = (bool) params[0];
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Graphics, Width, "int w", "Initializes width" )
{
	plPipeline::fInitialPipeParams.Width = (int) params[0];
}

PF_CONSOLE_CMD( Graphics, Height, "int h", "Initializes height" )
{
	plPipeline::fInitialPipeParams.Height = (int) params[0];
}
PF_CONSOLE_CMD(Graphics, ColorDepth, "int colordepth", "Initializes color depth")
{
	plPipeline::fInitialPipeParams.ColorDepth = (int) params[0];
}

PF_CONSOLE_CMD( Graphics, Windowed, "bool w", "Initialize Windowed Mode")
{
	plPipeline::fInitialPipeParams.Windowed = (bool) params[0];
}

PF_CONSOLE_CMD( Graphics, TextureQuality, "int quality", "Initialize texture quality")
{
	int texqual = (int)params[0];
	if (texqual < 0)
		texqual = 0;
	else if (texqual > 2)
		texqual = 2;

	plPipeline::fInitialPipeParams.TextureQuality = texqual;
}

PF_CONSOLE_CMD( Graphics, AntiAliasAmount, "int aa", "Init AA Level")
{
	plPipeline::fInitialPipeParams.AntiAliasingAmount = (int) params[0];
}

PF_CONSOLE_CMD( Graphics, AnisotropicLevel, "int l", "Init Aniso Level" )
{
	plPipeline::fInitialPipeParams.AnisotropicLevel = (int) params[0];
}

PF_CONSOLE_CMD( Graphics, EnableVSync, "bool b", "Init VerticalSync" )
{
	plPipeline::fInitialPipeParams.VSync = (bool) params[0];
}

PF_CONSOLE_CMD( Graphics, EnablePlanarReflections, "bool", "Enable the draw and update of planar reflections" )
{
	bool enable = (bool)params[0];
	plDynamicCamMap::SetEnabled(enable);
}

//////////////////////////////////////////////////////////////////////////////
//// App Group Commands //////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
PF_CONSOLE_GROUP( App )		// Defines a main command group

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( App,
				Event,
				"string obj, string evType, float s, int reps",
				"string obj, string evType, float s, int reps" )
{

	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !obj )
	{
		strcat(str, " - Not Found!");
		PrintString(str);
		return;
	}

	plKey receiver = nil;
	PrintString(str);

	int i;
	for( i = 0; i < obj->GetNumModifiers(); i++ )
	{
		if( plSimpleModifier::ConvertNoRef(obj->GetModifier(i)) )
		{
			receiver = obj->GetModifier(i)->GetKey();
			break;
		}
	}
	if( !receiver )
	{
		strcat(str, " - Modifier Not Found!");
		PrintString(str);
		return;
	}

	plAnimCmdMsg* cmd = TRACKED_NEW plAnimCmdMsg;
	cmd->SetSender(plClient::GetInstance()->GetKey());
	cmd->SetCmd(plAnimCmdMsg::kAddCallbacks);
#if 1
	cmd->AddReceiver(receiver);
#else
	cmd->AddReceiver(key);
	cmd->SetBCastFlag(plMessage::kPropagateToModifiers, true);
#endif

	float secs = 0;
	int reps = 1;

	char* eventStr = params[1];
	CallbackEvent event;
	if( !_stricmp(eventStr, "Start") )
	{
		event = kStart;
	}
	else
	if( !_stricmp(eventStr, "Stop") )
	{
		event = kStop;
	}
	else
	if( !_stricmp(eventStr, "Time") )
	{
		event = kTime;
		secs = params[2];
	}
	if( numParams > 3 )
	{
		reps = params[3];
	}
	reps--;

	plEventCallbackMsg* callback = TRACKED_NEW plEventCallbackMsg(plClient::GetInstance()->GetKey(), event, 0, secs, reps);
	cmd->AddCallback(callback);
	hsRefCnt_SafeUnRef(callback);
	plgDispatch::MsgSend(cmd);
}

PF_CONSOLE_CMD( App,
				Sound,
				"string obj, string evType, float s, int reps",
				"string obj, string evType, float s, int reps" )
{

	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !obj )
	{
		strcat(str, " - Not Found!");
		PrintString(str);
		return;
	}

	PrintString(str);

	plSoundMsg* cmd = TRACKED_NEW plSoundMsg;
	cmd->SetSender(plClient::GetInstance()->GetKey());
	cmd->SetCmd(plSoundMsg::kAddCallbacks);
	cmd->AddReceiver(key);

	float secs = 0;
	int reps = -1;

	char* eventStr = params[1];
	CallbackEvent event;
	if( !_stricmp(eventStr, "Start") )
	{
		event = kStart;
	}
	else
	if( !_stricmp(eventStr, "Stop") )
	{
		event = kStop;
	}
	else
	if( !_stricmp(eventStr, "Time") )
	{
		event = kTime;
		secs = params[2];
	}
	if( numParams > 3 )
	{
		reps = params[3];
	}
	reps--;

	plEventCallbackMsg* callback = TRACKED_NEW plEventCallbackMsg(plClient::GetInstance()->GetKey(), event, 0, secs, reps);
	cmd->AddCallback(callback);
	hsRefCnt_SafeUnRef(callback);
	plgDispatch::MsgSend(cmd);
}

PF_CONSOLE_CMD( App,
				Overlay,
				"string name, ...", // paramList
				"Enable/Disable/Toggle display of named CamView object" )
{
	char str[256];
	char* name = params[0];
	plKey key = FindSceneObjectByName(name, nil, str);
	if( !key )
	{
		sprintf(str, "%s - Not Found!", name);
		PrintString(str);
		return;
	}
	plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !obj )
	{
		sprintf(str, "%s - Not Found!", name);
		PrintString(str);
		return;
	}

	int i;
	for( i = 0; i < obj->GetNumModifiers(); i++ )
	{
		if( plPostEffectMod::ConvertNoRef(obj->GetModifier(i)) )
			break;
	}
	if( i >= obj->GetNumModifiers() )
	{
		sprintf(str, "%s - No CamView Modifier found!", name);
		PrintString(str);
		return;
	}
	strcpy(str, name);

	plAnimCmdMsg* cmd = TRACKED_NEW plAnimCmdMsg(nil, obj->GetModifier(i)->GetKey(), nil);

	if( numParams > 1 )
	{
		bool on = bool(params[1]);
		if( on )
		{
			cmd->SetCmd(plAnimCmdMsg::kContinue);
			strcat(str, " - Enabled");
		}
		else
		{
			cmd->SetCmd(plAnimCmdMsg::kStop);
			strcat(str, " - Disabled");
		}
	}
	else
	{
		cmd->SetCmd(plAnimCmdMsg::kToggleState);
		strcat(str, " - Toggled");
	}
	plgDispatch::MsgSend(cmd);
	PrintString(str);
}

PF_CONSOLE_CMD( App,		// groupName
			   TimeClamp,		// fxnName
			   "float maxSecsPerFrame", // paramList
			   "Clamp elapsed game time per frame (b4 scale)" )	// helpString
{
	float s = params[0];
	hsTimer::SetTimeClamp( s );

	char str[256];
	sprintf(str, "Time clamped to %f secs", s);
	PrintString( str );
}

PF_CONSOLE_CMD( App,		// groupName
			   TimeSmoothingClamp,		// fxnName
			   "float maxSecsPerFrame", // paramList
			   "Clamp max elapsed time that we'll smooth frame deltas" )	// helpString
{
	float s = params[0];
	hsTimer::SetTimeSmoothingClamp( s );

	char str[256];
	sprintf(str, "Time smoothing clamped to %f secs", s);
	PrintString( str );
}

PF_CONSOLE_CMD( App,		// groupName
			   FrameInc,		// fxnName
			   "float msPerFrame", // paramList
			   "Advance exactly msPerFrame milliseconds each frame" )	// helpString
{
	float s = params[0];
	s *= 1.e-3f;
	hsTimer::SetFrameTimeInc( s );

	char str[256];
	sprintf(str, "Frame advancing %f per frame (in frame time)", s * 1.e3f );
	PrintString( str );
}

PF_CONSOLE_CMD( App,		// groupName
			   RealTime,		// fxnName
			   "", // paramList
			   "Run in realtime" )	// helpString
{
	hsTimer::SetRealTime( true );

	char str[256];
	sprintf(str, "Now running real time");
	PrintString( str );
}

PF_CONSOLE_CMD( App,		// groupName
			   FrameTime,		// fxnName
			   "", // paramList
			   "Run in frametime" )	// helpString
{
	hsTimer::SetRealTime( false );

	char str[256];
	sprintf(str, "Now running frame time");
	PrintString( str );
}

PF_CONSOLE_CMD( App,		// groupName
			   ScaleTime,		// fxnName
			   "float s", // paramList
			   "Scale factor for time (e.g. ScaleTime 2 doubles speed of game)" )	// helpString
{
	float s = params[0];
	hsTimer::SetTimeScale( s );

	char str[256];
	sprintf(str, "Time scaled to %4.4f percent", s * 100.f );
	PrintString( str );
}

#include "plInputCore/plSceneInputInterface.h"

PF_CONSOLE_CMD( App,		// groupName
			   ShowLOS,		// fxnName
			   "", // paramList
			   "Show object LOS hits" )	// helpString
{
	char str[256];
	if (plSceneInputInterface::fShowLOS)
	{
		plSceneInputInterface::fShowLOS = false;
		sprintf(str, "Stop displaying LOS hits");
	}
	else
	{
		plSceneInputInterface::fShowLOS = true;
		sprintf(str, "Start showing LOS hits");
	}
	PrintString( str );
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( App,			// groupName
			   Quit,			// fxnName
			   "",				// paramList
			   "Quit the client app" ) // helpString
{
	if( plClient::GetInstance() )
		PostMessage(plClient::GetInstance()->GetWindowHandle(), 
			WM_SYSCOMMAND,
			SC_CLOSE,
			0);
}

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD(App,
			   AuxInitDir,
			   "string pathName",
			   "Set an auxiliary init directory to read")
{
	if( plClient::GetInstance() )	
		plClient::GetInstance()->SetAuxInitDir(params[0]);
}


PF_CONSOLE_CMD( App,		// groupName
			   GetBuildDate,		// fxnName
			   "", // paramList
			   "Prints the date and time this build was created" )	// helpString
{
	char str[256];
	sprintf(str, "This Plasma 2.0 client built at %s on %s.", pnBuildDates::fBuildTime, pnBuildDates::fBuildDate );
	PrintString( str );
}

PF_CONSOLE_CMD( App,		// groupName
			   GetBranchDate,		// fxnName
			   "", // paramList
			   "Prints the date of the branch this code was produced from, or \"Pre-release\" if it is from the main code" )	// helpString
{
	char str[256];
	sprintf(str, "The branch date for this Plasma 2.0 client is: %s.", pnBuildDates::fBranchDate );
	PrintString( str );
}

PF_CONSOLE_CMD(App,
			   LowPriority,
			   "",
			   "Set low priority for this process")
{
	SetPriorityClass( GetCurrentProcess(), IDLE_PRIORITY_CLASS );
	PrintString( "Set process priority to lowest setting" );
}


PF_CONSOLE_CMD(App,
			   VerifyUnloaded,
			   "string age",
			   "Verify the given age is really unloaded into logfile logs/<age>.log")
{
	hsAssert(0, "Fixme");
	char* age = params[0];
	char str[256];
	sprintf(str, "%s.log", age);
//	hsgResMgr::ResMgr()->VerifyAgeUnloaded(str, age);

	sprintf(str, "Verification of age %s complete", age);
	PrintString(str);
}

#endif // LIMIT_CONSOLE_COMMANDS

#ifdef LIMIT_CONSOLE_COMMANDS // for now, disable languages in external clients
PF_CONSOLE_CMD(App,
			   SetLanguage,
			   "string language",
			   "Set the language (English, French, German, Spanish, Italian, or Japanese)")
{
	if (pfConsole::GetPipeline())
	{
		PrintString("This command must be used in an .ini file");
		return;
	}

	if (stricmp(params[0], "english") == 0)
		plLocalization::SetLanguage(plLocalization::kEnglish);
	else if (stricmp(params[0], "french") == 0)
		plLocalization::SetLanguage(plLocalization::kFrench);
	else if (stricmp(params[0], "german") == 0)
		plLocalization::SetLanguage(plLocalization::kGerman);
	else if (stricmp(params[0], "spanish") == 0)
		plLocalization::SetLanguage(plLocalization::kSpanish);
	else if (stricmp(params[0], "italian") == 0)
		plLocalization::SetLanguage(plLocalization::kItalian);
	else if (stricmp(params[0], "japanese") == 0)
		plLocalization::SetLanguage(plLocalization::kJapanese);

}
#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD(App,
			   DemoMode,
			   "",
			   "Set the app to demo mode")
{
	if (pfConsole::GetPipeline())
	{
		PrintString("This command must be used in an .ini file");
		return;
	}

	plNetClientApp::GetInstance()->SetFlagsBit(plNetClientApp::kDemoMode);
}

PF_CONSOLE_CMD(App,
			   BounceLogs,
			   "",
			   "Clear all log files.")
{
	plStatusLogMgr::GetInstance().BounceLogs();
}

//////////////////////////////////////////////////////////////////////////////
//// Dispatch Group Commands /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

#include "pfDispatchLog.h"

PF_CONSOLE_GROUP( Dispatch )		// Defines a main command group
PF_CONSOLE_SUBGROUP( Dispatch, Log )		// Creates a sub-group under a given group

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   LongReceives,		// fxnName
			   "", // paramList
			   "Log long msg receives (over 50 ms)" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->SetFlags(plDispatchLog::GetInstance()->GetFlags() | plDispatchLog::kLogLongReceives);
}

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   AddFilterType,		// fxnName
			   "string className", // paramList
			   "Adds a type filter to the Dispatch Logger" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->AddFilterType(plFactory::FindClassIndex(params[0]));
}

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   AddFilterExactType,		// fxnName
			   "string className", // paramList
			   "Adds an exact type filter to the Dispatch Logger" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->AddFilterExactType(plFactory::FindClassIndex(params[0]));
}

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   RemoveFilterType,		// fxnName
			   "string className", // paramList
			   "Removes a type filter to the Dispatch Logger" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->RemoveFilterType(plFactory::FindClassIndex(params[0]));
}

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   RemoveFilterExactType,		// fxnName
			   "string className", // paramList
			   "Removes an exact type filter to the Dispatch Logger" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->RemoveFilterExactType(plFactory::FindClassIndex(params[0]));
}

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   Include,		// fxnName
			   "", // paramList
			   "Sets Dispatch Log filters to be treated as an include list" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->SetFlags(plDispatchLog::GetInstance()->GetFlags() | plDispatchLog::kInclude);
}

PF_CONSOLE_CMD( Dispatch_Log,		// groupName
			   Exclude,		// fxnName
			   "", // paramList
			   "Sets Dispatch Log filters to be treated as an exclude list" )	// helpString
{
	plDispatchLog::InitInstance();
	plDispatchLog::GetInstance()->SetFlags(plDispatchLog::GetInstance()->GetFlags() & ~plDispatchLog::kInclude);
}

#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////////////////////
//// ResManager/Registry Commands ////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( Registry )		// Defines a main command group

PF_CONSOLE_CMD( Registry, ToggleDebugStats, "", "Toggles the debug statistics screen for the registry" )
{
	plResManagerHelper *helper = plResManagerHelper::GetInstance();
	if( helper == nil )
	{
		PrintString( "ERROR: ResManager helper object not initialized." );
		return;
	}

	static bool on = false;
	if( on )
	{
		helper->EnableDebugScreen( false );
		PrintString( "ResManager debug stats disabled" );
	}
	else
	{
		helper->EnableDebugScreen( true );
		plStatusLogMgr::GetInstance().SetCurrStatusLog( "ResManager Status" );
		PrintString( "ResManager debug stats enabled" );
	}
}

PF_CONSOLE_CMD( Registry, SetLoggingLevel, "int level", "Sets the logging level for the registry. 0 is no logging, 3 is max detail." )
{
	int newLevel = params[ 0 ];

	if( newLevel < 0 || newLevel > 4 )
	{
		PrintString( "ERROR: Invalid level specified. Valid levels are 0-3." );
		return;
	}

	plResMgrSettings::Get().SetLoggingLevel( (UInt8)newLevel );
	{
		char msg[ 128 ];
		sprintf( msg, "Registry logging set to %s", ( newLevel == 0 ) ? "none" : ( newLevel == 1 ) ? "basic" : 
														( newLevel == 2 ) ? "detailed" : ( newLevel == 3 ) ? "object-level" 
															: "object-read-level" );
		PrintString( msg );
	}
}

class plActiveRefPeekerKey : public plKeyImp
{
	public:
		UInt16      PeekNumNotifies() { return GetNumNotifyCreated(); }
		plRefMsg*   PeekNotifyCreated(int i) { return GetNotifyCreated(i); }
		hsBool      PeekIsActiveRef(int i) const { return IsActiveRef(i); }
};

// Not static so others can call it - making it even handier
void	MyHandyPrintFunction( const plKey &obj, void (*PrintString)( const char * ) )
{
	plActiveRefPeekerKey *peeker = (plActiveRefPeekerKey *)(plKeyImp *)obj;

	if( peeker->GetUoid().IsClone() )
		PrintStringF( PrintString, "%d refs on %s, clone %d:%d: loaded=%d", 
		peeker->PeekNumNotifies(), obj->GetUoid().GetObjectName(), 
		peeker->GetUoid().GetCloneID(), peeker->GetUoid().GetClonePlayerID(),
		obj->ObjectIsLoaded() ? 1 : 0);
	else
		PrintStringF( PrintString, "%d refs on %s: loaded=%d", 
		peeker->PeekNumNotifies(), obj->GetUoid().GetObjectName(), obj->ObjectIsLoaded() ? 1 : 0 );

	if( peeker->PeekNumNotifies() == 0 )
		return;

	UInt32 a, i, j, limit = 30, count = 0;
	for( a = 0; a < 2; a++ )
	{
		PrintString( ( a == 0 ) ? "  Active:" : "  Passive:" );

		for( i = 0; i < peeker->PeekNumNotifies(); i++ )
		{
			if( ( a == 0 && peeker->PeekIsActiveRef( i ) ) || ( a == 1 && !peeker->PeekIsActiveRef( i ) ) )
			{
				plRefMsg *msg = peeker->PeekNotifyCreated( i );
				if( msg != nil )
				{
					for( j = 0; j < msg->GetNumReceivers(); j++ )
					{
						if( limit == 0 )
							count++;
						else
						{
							limit--;

							const plKey rcvr = msg->GetReceiver( j );
							PrintStringF( PrintString, "    %s:%s", plFactory::GetNameOfClass( rcvr->GetUoid().GetClassType() ), rcvr->GetUoid().GetObjectName() );
						}
					}
				}
			}
		}
	}

	if( count > 0 )
		PrintStringF( PrintString, "...and %d others", count );
}

PF_CONSOLE_CMD( Registry, ListRefs, "string keyType, string keyName", "For the given key (referenced by type and name), lists all of "
			   "the objects who currently have active refs on it." )
{
	char result[ 256 ];
	plKey obj = FindObjectByNameAndType( params[ 1 ], params[ 0 ], nil, result);
	if( obj == nil )
	{
		PrintString( result );
		return;
	}

	MyHandyPrintFunction( obj, PrintString );
	
	plActiveRefPeekerKey *peeker = (plActiveRefPeekerKey *)(plKeyImp *)obj;
	if( peeker->GetNumClones() > 0 )
	{
		UInt32 i;
		for( i = 0; i < peeker->GetNumClones(); i++ )
		{
			MyHandyPrintFunction( peeker->GetCloneByIdx( i ), PrintString );
		}
	}
}

PF_CONSOLE_CMD(Registry, LogReadTimes, "", "Dumps the time for each object read to a file")
{
	((plResManager*)hsgResMgr::ResMgr())->LogReadTimes(true);
}

#endif // LIMIT_CONSOLE_COMMANDS


//////////////////////////////////////////////////////////////////////////////
//// Camera Group Commands ///////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
PF_CONSOLE_GROUP( Camera )		// Defines a main command group

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_CMD( Camera, AvatarVisible1stPerson, "bool b", "turn avatar visibility in 1st person on or off")
{
	bool b = params[0];
	plCameraBrain1_FirstPerson::fDontFade = b;
}

PF_CONSOLE_CMD( Camera, FallTimerDelay, "float b", "fall timer delay")
{
	hsScalar f = params[0];
	plVirtualCam1::fFallTimerDelay = f;
}


PF_CONSOLE_CMD( Camera, Force3rdPersonOneshots, "bool b", "force camera to 3rd person for oneshots on or off")
{
	bool b = params[0];
	plAvOneShotTask::fForce3rdPerson = b;
}

PF_CONSOLE_CMD( Camera, Force3rdPersonMultistage, "bool b", "force camera to 3rd person for multistage on or off")
{
	bool b = params[0];
	plAvBrainGeneric::fForce3rdPerson = b;
}


PF_CONSOLE_CMD( Camera,		// groupName
			   Next,		// fxnName
			   "", // paramList
			   "Set the virtual camera to go to the next camera in the scene" )	// helpString
{
	plUoid pU1( kVirtualCamera1_KEY );
	plKey fLOS1 = hsgResMgr::ResMgr()->FindKey( pU1 );
	if (fLOS1)
	{
		plVirtualCam1::ConvertNoRef(fLOS1->GetObjectPtr())->Next();
		return;
	}
	
}

PF_CONSOLE_CMD( Camera,		// groupName
			   IgnoreRegions,		// fxnName
			   "bool b", // paramList
			   "Switch on / off camera regions" )	// helpString
{
	bool b = params[0];
	
	plUoid pU1( kVirtualCamera1_KEY );
	plKey fLOS1 = hsgResMgr::ResMgr()->FindKey( pU1 );
	if (fLOS1)
	{
		plVirtualCam1::ConvertNoRef(fLOS1->GetObjectPtr())->CameraRegions(b);
		return;
	}
	
}

PF_CONSOLE_CMD( Camera,		// groupName
			   LogFOV,		// fxnName
			   "bool b", // paramList
			   "Switch on / off verbose camera FOV change logging" )	// helpString
{
	bool b = params[0];
	
	plUoid pU1( kVirtualCamera1_KEY );
	plKey fLOS1 = hsgResMgr::ResMgr()->FindKey( pU1 );
	if (fLOS1)
	{
		plVirtualCam1::ConvertNoRef(fLOS1->GetObjectPtr())->LogFOV(b);
		return;
	}
	
}

PF_CONSOLE_CMD( Camera,		// groupName
			   Prev,		// fxnName
			   "", // paramList
			   "Set the virtual camera to go to the prev camera in the scene" )	// helpString
{
	plUoid pU1( kVirtualCamera1_KEY );
	plKey fLOS1 = hsgResMgr::ResMgr()->FindKey( pU1 );
	if (fLOS1)
	{
		plVirtualCam1::ConvertNoRef(fLOS1->GetObjectPtr())->Prev();
		return;
	}

}

PF_CONSOLE_CMD( Camera,		// groupName
			   SetFOV,		// fxnName
			   "float x, float y", // paramList
			   "Set the field of view for all cameras" )	// helpString
{
	float x = params[0];
	float y = params[1];
	plUoid pU1( kVirtualCamera1_KEY );
	plKey fLOS1 = hsgResMgr::ResMgr()->FindKey( pU1 );
	if (fLOS1)
	{
		plVirtualCam1::SetFOV(x,y);
		return;
	}
}

PF_CONSOLE_CMD( Camera,		// groupName
			   Drive,		// fxnName
			   "", // paramList
			   "Toggle drive mode" )	// helpString
{
	plVirtualCam1::Instance()->Drive();
}



PF_CONSOLE_CMD( Camera,		// groupName
			   IncreaseDriveTurnRate,		// fxnName
			   "", // paramList
			   "increase drive turn rate" )	// helpString
{
	plCameraBrain1_Drive::fTurnRate += 20.0f;
	
}

PF_CONSOLE_CMD( Camera,		// groupName
			   DecreaseDriveTurnRate,		// fxnName
			   "", // paramList
			   "decrease drive turn rate" )	// helpString
{
	plCameraBrain1_Drive::fTurnRate -= 20.0f;
	if (plCameraBrain1_Drive::fTurnRate < 0.0)
		plCameraBrain1_Drive::fTurnRate = 20.0f;
	
}


PF_CONSOLE_CMD( Camera, SwitchTo, "string cameraName", "Switch to the named camera")
{
	char str[256];
	char foo[256];
	sprintf(foo, "%s_", (const char*)params[0]);
	plKey key = FindObjectByNameAndType(foo, "plCameraModifier1", nil, str, true);
	PrintString(str);

	if (key)
	{
		plCameraMsg* pMsg = TRACKED_NEW plCameraMsg;
		pMsg->SetCmd(plCameraMsg::kResponderTrigger);
		pMsg->SetCmd(plCameraMsg::kRegionPushCamera);
		pMsg->SetNewCam(key);
		pMsg->SetBCastFlag(plMessage::kBCastByExactType);
		plgDispatch::MsgSend(pMsg);
	}
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Camera,		// groupName
			   SetFallSpeeds,		// fxnName
			   "float accel, float vel, float decel", // paramList
			   "Set camera fall speeds" )	// helpString
{
	float a = params[0];
	float v = params[1];
	float d = params[2];
	plCameraBrain1::fFallAccel = a;
	plCameraBrain1::fFallVelocity = v;
	plCameraBrain1::fFallDecel = d;
}

PF_CONSOLE_CMD( Camera,		// groupName
			   SetFallPOASpeeds,		// fxnName
			   "float accel, float vel, float decel", // paramList
			   "Set camera fall speeds" )	// helpString
{
	float a = params[0];
	float v = params[1];
	float d = params[2];
	plCameraBrain1::fFallPOAAccel = a;
	plCameraBrain1::fFallPOAVelocity = v;
	plCameraBrain1::fFallPOADecel = d;
}


PF_CONSOLE_CMD( Camera,		// groupName
			   SetGlobalAccel,		// fxnName
			   "float x", // paramList
			   "Set global camera acceleration - must set Camera.UseSpeedOverrides to TRUE to see effect" )	// helpString
{
	float f = params[0];
	plVirtualCam1::Instance()->fAccel = f;
}

PF_CONSOLE_CMD( Camera,		// groupName
			   SetGlobalDecel,		// fxnName
			   "float x", // paramList
			   "Set global camera deceleration - must set Camera.UseSpeedOverrides to TRUE to see effect" )	// helpString
{
	float f = params[0];
	plVirtualCam1::Instance()->fDecel = f;
}

PF_CONSOLE_CMD( Camera,		// groupName
			   SetGlobalVelocity,		// fxnName
			   "float x", // paramList
			   "Set global camera velocity - must set Camera.UseSpeedOverrides to TRUE to see effect" )	// helpString
{
	float f = params[0];
	plVirtualCam1::Instance()->fVel = f;
}

PF_CONSOLE_CMD( Camera,		// groupName
			   UseSpeedOverrides,		// fxnName
			   "bool b", // paramList
			   "Use console overrides for accel / decel" )	// helpString
{
	bool b = params[0];
	plVirtualCam1::Instance()->fUseAccelOverride = b;
}

PF_CONSOLE_CMD( Camera, VerticalPanAlways, "bool b", "turn vertical panning on always when walking")
{
	bool b = params[0];
	plVirtualCam1::WalkPan3rdPerson = b;
}

PF_CONSOLE_CMD( Camera, FirstPersonAlways, "bool b", "always in first person")
{
	bool b = params[0];
	plVirtualCam1::StayInFirstPersonForever = b;
}


#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_CMD( Camera,		// groupName
			   Freeze,		// fxnName
			   "bool b", // paramList
			   "freeze the camera system" )	// helpString
{
	bool b = params[0];
	plVirtualCam1::Instance()->freeze = b;
}

PF_CONSOLE_CMD( Camera,		// groupName
			   AlwaysCut,		// fxnName
			   "bool b", // paramList
			   "Forces camera transitions to always cut" )	// helpString
{
	bool b = params[0];
	plVirtualCam1::Instance()->alwaysCutForColin = b;
}

#endif // LIMIT_CONSOLE_COMMANDS

////////////////////////////////////////////////////////////////////////
//// Logic Mod Group Commands ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( Logic )

static plLogicModBase *FindLogicMod(const char *name)
{
	char str[256];
	plKey key = FindObjectByNameAndType(name, "plLogicModifier", nil, str, true);
	pfConsole::AddLine(str);

	if (key)
		return plLogicModBase::ConvertNoRef(key->GetObjectPtr());

	return nil;
}

PF_CONSOLE_CMD( Logic, TriggerDetectorNum, "int detectorNum", "Triggers the detector with this number (from ListDetectors)")
{
	std::vector<std::string> activatorNames;
	plKeyFinder::Instance().GetActivatorNames(activatorNames);

	int activatorNum = params[0];
	if (activatorNum < 1 || activatorNum > activatorNames.size())
	{
		PrintString("Detector number out of range");
		return;
	}

	plLogicModBase *mod = FindLogicMod(activatorNames[activatorNum-1].c_str());
	if (mod)
		mod->ConsoleTrigger(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
}

PF_CONSOLE_CMD( Logic, TriggerDetector, "string detectorComp", "Triggers the named detector component")
{
	plLogicModBase *mod = FindLogicMod((const char*)params[0]);
	if (mod)
		mod->ConsoleTrigger(plNetClientMgr::GetInstance()->GetLocalPlayerKey());
}

PF_CONSOLE_CMD(Logic, EnableDetector, "string detectorComp, bool enable", "Enables/disables the named detector component")
{
	plLogicModBase *mod = FindLogicMod((const char*)params[0]);
	if (mod)
	{
		plEnableMsg* enableMsg = TRACKED_NEW plEnableMsg;
		enableMsg->SetCmd(params[1] ? plEnableMsg::kEnable : plEnableMsg::kDisable);
		enableMsg->SetCmd(plEnableMsg::kAll);
		enableMsg->Send(mod->GetKey());
	}
}

static void ResponderSendTrigger(plKey responderKey, int responderState, bool fastForward = false)
{
	plNotifyMsg *msg = TRACKED_NEW plNotifyMsg;

	if (fastForward)
	{
		msg->fType = plNotifyMsg::kResponderFF;
	}
	else
	{
		msg->fType = plNotifyMsg::kActivator;
	}

	msg->fState = 1;	// Triggered

	// Setup the event data in case this is a OneShot responder that needs it
	plKey playerKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	msg->AddPickEvent(playerKey, nil, true, hsPoint3(0,0,0) );

	if (responderState != -1)
		msg->AddResponderStateEvent(responderState);
	
	// Send it to the responder modifier
	msg->AddReceiver(responderKey);
	plgDispatch::MsgSend(msg);
}

PF_CONSOLE_CMD( Logic, TriggerResponderNum, "int responderNum, ...", "Triggers the responder with this number (from ListResponders). (Optional: number of the state to switch to)")
{
	if (numParams > 2)
	{
		PrintString("Too many parameters");
		return;
	}

	std::vector<std::string> responderNames;
	plKeyFinder::Instance().GetResponderNames(responderNames);

	int responderNum = params[0];
	if (responderNum < 1 || responderNum > responderNames.size())
	{
		PrintString("Responder number out of range");
		return;
	}

	int responderState = -1;
	if (numParams == 2)
	{
		responderState = params[1];
	}

	char str[256];
	plKey key = FindObjectByNameAndType(responderNames[responderNum-1].c_str(), "plResponderModifier", nil, str, true);
	PrintString(str);

	if (key)
		ResponderSendTrigger(key, responderState);
}

PF_CONSOLE_CMD( Logic, TriggerResponder, "string responderComp, ...", "Triggers the named responder component. (Optional: number of the state to switch to)")
{
	if (numParams > 2)
	{
		PrintString("Too many parameters");
		return;
	}
	
	char str[256];
	plKey key = FindObjectByNameAndType(params[0], "plResponderModifier", nil, str, true);
	PrintString(str);

	int responderState = -1;
	if (numParams == 2)
	{
		responderState = params[1];
	}

	if (key)
		ResponderSendTrigger(key, responderState);
}

PF_CONSOLE_CMD( Logic, FastForwardResponder, "string responderComp, ...", "Fastforwards the named responder component. (Optional: number of the state to switch to)")
{
	if (numParams > 2)
	{
		PrintString("Too many parameters");
		return;
	}
	
	char str[256];
	plKey key = FindObjectByNameAndType(params[0], "plResponderModifier", nil, str, true);
	PrintString(str);

	int responderState = -1;
	if (numParams == 2)
	{
		responderState = params[1];
	}

	if (key)
		ResponderSendTrigger(key, responderState, true);
}

PF_CONSOLE_CMD(Logic, ListDetectors, "", "Prints the names of the loaded detectors to the console")
{
	std::vector<std::string> activatorNames;
	plKeyFinder::Instance().GetActivatorNames(activatorNames);

	for (int i = 0; i < activatorNames.size(); i++)
	{
		char buf[256];
		sprintf(buf, "%d. %s", i+1, activatorNames[i].c_str());
		PrintString(buf);
	}
}

PF_CONSOLE_CMD(Logic, ListResponders, "", "Prints the names of the loaded responders to the console")
{
	std::vector<std::string> responderNames;
	plKeyFinder::Instance().GetResponderNames(responderNames);

	for (int i = 0; i < responderNames.size(); i++)
	{
		char buf[256];
		sprintf(buf, "%d. %s", i+1, responderNames[i].c_str());
		PrintString(buf);
	}
}

#include "plModifier/plResponderModifier.h"

PF_CONSOLE_CMD(Logic, ResponderAnimCue, "", "Toggle box being drawn on screen when a responder starts an anim")
{
	if (plResponderModifier::ToggleDebugAnimBox())
		PrintString("Responder Anim Cue On");
	else
		PrintString("Responder Anim Cue Off");
}

PF_CONSOLE_CMD(Logic, ResponderNoLog, "string prefix", "Don't log responders that begin with the specified string")
{
	plResponderModifier::NoLogString(params[0]);
}

#include "plModifier/plDetectorLog.h"
PF_CONSOLE_CMD(Logic, WriteDetectorLog, "", "Write detector log to logfile")
{
	DetectorDoLogfile();
}

#endif // LIMIT_CONSOLE_COMMANDS

////////////////////////////////////////////////////////////////////////
//// Audio System Group Commands ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////
PF_CONSOLE_GROUP( Audio )

PF_CONSOLE_CMD( Audio, Enable, "bool on", "Switch DirectX Audio on or off at runtime")
{
	bool on = params[0];
	plgAudioSys::Activate( on );
}

PF_CONSOLE_CMD( Audio, UseHardware, "bool on", "Enable audio hardware acceleration")
{
	bool on = params[0];
	plgAudioSys::SetUseHardware( on );
}

PF_CONSOLE_CMD( Audio, UseEAX, "bool on", "Enable EAX sound acceleration (requires hardware acceleration)")
{
	bool on = params[0];
	plgAudioSys::EnableEAX( on );
}

PF_CONSOLE_CMD( Audio, Initialize, "bool on", "Set to false to completely disable audio playback in plasma")
{ 
	bool on = params[0];
	plgAudioSys::SetActive(on);
}

PF_CONSOLE_CMD( Audio, Restart, "", "Restarts the audio system" )
{ 
	plgAudioSys::Restart();
}

PF_CONSOLE_CMD( Audio, MuteAll, "bool on", "Mute or unmute all sounds")
{
	plgAudioSys::SetMuted( (bool)params[ 0 ] );
}

PF_CONSOLE_CMD( Audio, SetDistanceModel, "int type", "Sets the distance model for all 3d sounds")
{
	if(plgAudioSys::Sys())
	{
		plgAudioSys::Sys()->SetDistanceModel((int) params[0]);
	}
}

PF_CONSOLE_CMD( Audio, LogStreamingUpdates, "bool on", "Logs every buffer fill for streaming sounds")
{
	plgAudioSys::SetLogStreamingUpdates((bool) params[0]);
}

PF_CONSOLE_CMD( Audio, SetAllChannelVolumes, "float soundFX, float music, float ambience, float voice, float gui", "Sets the master volume of all the given audio channels.")
{
	plgAudioSys::ASChannel	chans[ 6 ] = { plgAudioSys::kSoundFX, plgAudioSys::kBgndMusic, plgAudioSys::kAmbience, plgAudioSys::kVoice, plgAudioSys::kGUI, plgAudioSys::kNPCVoice };


	int i;

	for( i = 0; i < 5; i++ )
	{
		hsScalar	vol = (hsScalar)(float)params[ i ];
		if( vol > 1.f )
			vol = 1.f;
		else if( vol < 0.f )
			vol = 0.f;

		plgAudioSys::SetChannelVolume( chans[ i ], vol );
	}
}

PF_CONSOLE_CMD( Audio, SetChannelVolume, "string channel, float percentage", "Sets the master volume of a given audio channel\n\
Valid channels are: SoundFX, BgndMusic, Voice, GUI, NPCVoice and Ambience.")
{
	plgAudioSys::ASChannel	chan;


	if( stricmp( params[ 0 ], "SoundFX" ) == 0 )
		chan = plgAudioSys::kSoundFX;
	else if( stricmp( params[ 0 ], "BgndMusic" ) == 0 )
		chan = plgAudioSys::kBgndMusic;
	else if( stricmp( params[ 0 ], "Voice" ) == 0 )
		chan = plgAudioSys::kVoice;
	else if( stricmp( params[ 0 ], "Ambience" ) == 0 )
		chan = plgAudioSys::kAmbience;
	else if( stricmp( params[ 0 ], "GUI" ) == 0 )
		chan = plgAudioSys::kGUI;
	else if( stricmp( params[ 0 ], "NPCVoice" ) == 0 )
		chan = plgAudioSys::kNPCVoice;
	else
	{
		PrintString( "Invalid channel specified. Use SoundFX, BgndMusic, Voice, Ambience or GUI." );
		return;
	}

	hsScalar	vol = (hsScalar)(float)params[ 1 ];
	if( vol > 1.f )
		vol = 1.f;
	else if( vol < 0.f )
		vol = 0.f;

	plgAudioSys::SetChannelVolume( chan, vol );

	char	msg[ 128 ];
	switch( chan )
	{
		case plgAudioSys::kSoundFX:		sprintf( msg, "Setting SoundFX master volume to %4.2f", vol ); break;
		case plgAudioSys::kBgndMusic:	sprintf( msg, "Setting BgndMusic master volume to %4.2f", vol ); break;
		case plgAudioSys::kVoice:		sprintf( msg, "Setting Voice master volume to %4.2f", vol ); break;
		case plgAudioSys::kAmbience:	sprintf( msg, "Setting Ambience master volume to %4.2f", vol ); break;
		case plgAudioSys::kGUI:			sprintf( msg, "Setting GUI master volume to %4.2f", vol ); break;
		case plgAudioSys::kNPCVoice:	sprintf( msg, "Setting NPC Voice master volume to %4.2f", vol ); break;
	}
	PrintString( msg );
}

PF_CONSOLE_CMD( Audio, Set2D3DBias, "float bias", "Sets the 2D/3D bias when not using hardware acceleration.")
{

	hsScalar	bias = (hsScalar)(float)params[ 0 ];
	plgAudioSys::Set2D3DBias( bias );

}

PF_CONSOLE_CMD( Audio, ShowNumActiveBuffers, "bool b", "Shows the number of Direct sounds buffers in use")
{
	plgAudioSys::ShowNumBuffers((bool)params[0]);
}

PF_CONSOLE_CMD( Audio, SetDeviceName, "string deviceName", "Meant for plClient init only")
{
	plgAudioSys::SetDeviceName(params[0]);		// this will set the name of the audio system device without actually reseting it
}

PF_CONSOLE_CMD( Audio,		// groupName
			   EnableVoiceCompression,		// fxnName
			   "bool b", // paramList
			   "turn voice compression on and off" )	// helpString
{
	bool b = params[0];
	plVoiceRecorder::EnableCompression(b);

}

PF_CONSOLE_CMD( Audio,		// groupName
			   ShowIcons,		// fxnName
			   "bool b", // paramList
			   "turn voice recording icons on and off" )	// helpString
{
	bool b = params[0];
	plVoiceRecorder::EnableIcons(b);

}

PF_CONSOLE_CMD( Audio,		// groupName
			   SquelchLevel,		// fxnName
			   "float f", // paramList
			   "Set the squelch level" )	// helpString
{
	float f = params[0];
	plVoiceRecorder::SetSquelch(f);

}


PF_CONSOLE_CMD( Audio,		// groupName
			   PushToTalk,		// fxnName
			   "bool b", // paramList
			   "turn push-to-talk on or off" )	// helpString
{
	bool b = params[0];
	plVoiceRecorder::EnablePushToTalk(b);

}

PF_CONSOLE_CMD( Audio,		// groupName
			   EnableVoiceNetBroadcast,		// fxnName
			   "bool b", // paramList
			   "turn voice-over-net on and off" )	// helpString
{
	bool b = params[0];
	plVoiceRecorder::EnableNetVoice(b);

}

PF_CONSOLE_CMD( Audio,								// groupName
			   SetVoiceQuality,						// fxnName
			   "int q",								// paramList
			   "Set quality of voice encoding" )	// helpString
{
	int q = params[0];
	plVoiceRecorder::SetQuality(q);
}


PF_CONSOLE_CMD( Audio,		// groupName
			   SetVBR,		// fxnName
			   "bool q",	// paramList
			   "Toggle variable bit rate" )	// helpString
{
	bool q = params[0];
	plVoiceRecorder::SetVBR(q);
}

PF_CONSOLE_CMD( Audio,		// groupName
			   EnableVoiceRecording,		// fxnName
			   "bool b", // paramList
			   "turn voice recording on or off" )	// helpString
{
	bool b = params[0];
	plVoiceRecorder::EnableRecording(b);

}

PF_CONSOLE_CMD( Audio,
				EnableVoiceChat,
				"bool b",
				"Enable Voice chat" )
{
	plVoicePlayer::Enable((bool) params[0]);
	plVoiceRecorder::EnableRecording((bool) params[0]);
}

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Audio, NextDebugPlate, "", "Cycles through the volume displays for all registered sounds" )
{
	plgAudioSys::NextDebugSound();
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Audio, SetLoadOnDemand, "bool on", "Enable or disable load-on-demand for sounds")
{
	plSound::SetLoadOnDemand( (bool)params[ 0 ] );
}

PF_CONSOLE_CMD( Audio, SetTwoStageLOD, "bool on", "Enables or disables two-stage LOD, where sounds can be loaded into RAM but not into sound buffers. Less of a performance hit, harder on memory.")
{
	// For two-stage LOD, we want to disable LoadFromDiskOnDemand, so that we'll load into RAM at startup but not
	// into sound buffers until demanded to do so. Enabling LoadFromDiskOnDemand basically conserves as much memory
	// as possible
	plSound::SetLoadFromDiskOnDemand( !(bool)params[ 0 ] );
}

PF_CONSOLE_CMD( Audio, SetVolume,
				"string obj, float vol", "Sets the volume on a given object. 1 is max volume, 0 is silence" )
{
	char	str[ 256 ];
	plKey key = FindSceneObjectByName(params[ 0 ], nil, str);
	if( key == nil )
		return;

	plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !obj )
		return;

	const plAudioInterface	*ai = obj->GetAudioInterface();
	plKey	aiKey = ai->GetKey();

	plSoundMsg* cmd = TRACKED_NEW plSoundMsg;
	cmd->SetSender( plClient::GetInstance()->GetKey() );
	cmd->SetCmd( plSoundMsg::kSetVolume );
	cmd->fVolume = params[ 1 ];
	cmd->AddReceiver( key );
	plgDispatch::MsgSend(cmd);
}


#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Audio, IsolateSound,
				"string soundComponentName", "Mutes all sounds except the given sound. Use Audio.MuteAll false to remove the isolation." )
{
	char			str[ 512 ];
	plKey			key;
	plAudioSysMsg	*asMsg;

	key = FindSceneObjectByName( params[ 0 ], nil, str );
	if( key == nil )
	{
		sprintf( str, "Cannot find sound %s", (char *)params[ 0 ] );
		PrintString( str );
		return;
	}

	plSceneObject *obj = plSceneObject::ConvertNoRef( key->GetObjectPtr() );
	if( !obj )
	{
		sprintf( str, "Cannot get sceneObject %s", (char *)params[ 0 ] );
		PrintString( str );
		return;
	}

	const plAudioInterface	*ai = obj->GetAudioInterface();
	if( ai == nil )
	{
		sprintf( str, "sceneObject %s has no audio interface", (char *)params[ 0 ] );
		PrintString( str );
		return;
	}

	asMsg = TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kMuteAll );
	plgDispatch::MsgSend( asMsg );

	asMsg = TRACKED_NEW plAudioSysMsg( plAudioSysMsg::kUnmuteAll );
	asMsg->AddReceiver( ai->GetKey() );
	asMsg->SetBCastFlag( plMessage::kBCastByExactType, false );
	plgDispatch::MsgSend( asMsg );


	char str2[ 256 ];
	sprintf( str2, "Sounds on sceneObject %s isolated.", (char *)params[ 0 ] );
	PrintString( str2 );
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Audio, SetMicVolume, "float volume", "Sets the microphone volume, in the range of 0 to 1" )
{
	if( !plWinMicLevel::CanSetLevel() )
		PrintString( "Unable to set microphone level" );
	else
	{
		plWinMicLevel::SetLevel( (float)params[ 0 ] );
	}
}

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Audio, MCNTest, "int which", "" )
{
	if( (int)params[ 0 ] == 0 )
		plgAudioSys::ClearDebugFlags();
	else if( (int)params[ 0 ] == 1 )
		plgAudioSys::SetDebugFlag( plgAudioSys::kDisableRightSelect );
	else if( (int)params[ 0 ] == 2 )
		plgAudioSys::SetDebugFlag( plgAudioSys::kDisableLeftSelect );
}

PF_CONSOLE_CMD( Audio, Mark, "", "" )
{
	static int markNum = 0;
	plStatusLog::AddLineS( "threadfun.log", "******* Mark #%d *******", markNum++ );
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Audio, SetStreamingBufferSize, "float sizeInSecs", "Sets the size of the streaming buffer for each streaming sound." )
{
	plgAudioSys::SetStreamingBufferSize( (float)params[ 0 ] );
	PrintString( "Changes won't take effect until you restart the audio system." );
}

PF_CONSOLE_CMD( Audio, SetStreamFromRAMCutoff, "float cutoffInSecs", "Sets the cutoff between streaming from RAM and streaming directly from disk." )
{
	plgAudioSys::SetStreamFromRAMCutoff( (float)params[ 0 ] );
	PrintString( "Changes won't take effect until you restart the audio system." );
}

PF_CONSOLE_CMD( Audio, SetPriorityCutoff, "int cutoff", "Stops sounds from loading whose priority is greater than this cutoff." )
{
	plgAudioSys::SetPriorityCutoff( (int)params[ 0 ] );
}

PF_CONSOLE_CMD( Audio, EnableExtendedLogs, "bool enable", "Enables or disables the extended audio logs." )
{
	plgAudioSys::EnableExtendedLogs( (bool)params[ 0 ] );
}

PF_CONSOLE_GROUP( Listener )

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Listener, ShowDebugInfo, "bool show", "Shows or hides debugging info")
{
	plListener::ShowDebugInfo( (bool)params[ 0 ] );
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Listener, UseCameraOrientation, "", "Use the camera's orientation to orient the listener")
{
	plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kFacing, nil, true );
	set->Send();
}

PF_CONSOLE_CMD( Listener, UseCameraPosition, "", "Use the canera's position to position the listener")
{
	plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kPosition, nil, true );
	set->Send();
}

PF_CONSOLE_CMD( Listener, UseCameraVelocity, "", "Use the camera's velocity to set the listener velocity")
{
	plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kVelocity, nil, true );
	set->Send();
}

PF_CONSOLE_CMD( Listener, UsePlayerOrientation, "", "Use the player's orientation to orient the listener")
{
	plKey pKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	if( pKey )
	{
		plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kFacing, pKey, true );
		set->Send();
	}
}
PF_CONSOLE_CMD( Listener, UsePlayerPosition, "", "Use the player's position to position the listener")
{
	plKey pKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	if (pKey)
	{
		plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kPosition, pKey, true );
		set->Send();
	}
}

PF_CONSOLE_CMD( Listener, UsePlayerVelocity, "", "Use the player's velocity to set the listener velocity")
{
	plKey pKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	if (pKey)
	{
		plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVelocity, pKey, true );
		set->Send();
	}
}

PF_CONSOLE_CMD( Listener, XMode, "bool b", "Sets velocity and position to avatar, and orientation to camera")
{
	static UInt32 oldPosType = 0, oldFacingType = 0, oldVelType = 0;
	
	plSetListenerMsg *set = nil;
	plKey pKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	plListener* pListener;

	if( (bool)params[ 0 ] )
	{
		// Get the listener object
		plUoid lu(kListenerMod_KEY);
		plKey pLKey = hsgResMgr::ResMgr()->FindKey(lu);
		if (pLKey)
		{	
			pListener = plListener::ConvertNoRef(pLKey->GetObjectPtr());
		}

		if(pListener)
		{
			// Save old types
			oldPosType = pListener->GetAttachedPosType();
			oldFacingType = pListener->GetAttachedFacingType();
			oldVelType = pListener->GetAttachedVelType();
		}
		
		plStatusLog::AddLineS("audio.log", "XMode on");
		
		plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kFacing, nil, true );
		set->Send();
		if (pKey)
		{
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVelocity, pKey, true );
			set->Send();
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kPosition, pKey, true );
			set->Send();
		}
	}
	else 
	{
		if(oldPosType == plListener::kCamera)
		{
			plSetListenerMsg *set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kPosition, nil, true );
			set->Send();
		}
		else
		{
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kPosition, pKey, true );
			set->Send();
		}
		if(oldFacingType == plListener::kCamera)
		{
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kFacing, nil, true );
			set->Send();
		}
		else
		{
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kFacing, pKey, true );
			set->Send();
		}
		if(oldVelType == plListener::kCamera)
		{
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVCam | plSetListenerMsg::kVelocity, nil, true );
			set->Send();
		}
		else
		{
			set = TRACKED_NEW plSetListenerMsg( plSetListenerMsg::kVelocity, pKey, true );
			set->Send();
		}
		plStatusLog::AddLineS("audio.log", "%s, %d, %d, %d", "XMode off", oldPosType, oldFacingType, oldVelType);
	}
}



////////////////////////////////////////////////////////////////////////
//// Input System Group Commands ///////////////////////////////////////
////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( DInput )

PF_CONSOLE_CMD( DInput, UseDInput, "bool on", "Turns off DirectInput")
{
	bool on = params[0];
	plInputManager::UseDInput(on);
}


PF_CONSOLE_CMD( DInput, Config, "", "Launch DInput configuration screen")
{
	plgAudioSys::Activate(false);
	plInputEventMsg* pMsg = TRACKED_NEW plInputEventMsg;
	pMsg->fEvent = plInputEventMsg::kConfigure;
	pMsg->AddReceiver( plInputManager::GetInstance()->GetKey() );
	pMsg->SetBCastFlag(plMessage::kBCastByType, false);
	plgDispatch::MsgSend(pMsg);
}

#endif // LIMIT_CONSOLE_COMMANDS


//////////////////////////////////////////////////////////////////////////////
//// Keyboard Remapping Group Commands ///////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_GROUP( Keyboard )		// Defines a main command group

PF_CONSOLE_CMD( Keyboard, ResetBindings, "", "Resets the keyboard bindings to their defaults" )
{
	if( plInputInterfaceMgr::GetInstance() != nil )
		plInputInterfaceMgr::GetInstance()->InitDefaultKeyMap();

	PrintString( "Keyboard bindings reset" );
}


PF_CONSOLE_CMD( Keyboard, ClearBindings, "", "Resets the keyboard bindings to empty" )
{
	if( plInputInterfaceMgr::GetInstance() != nil )
		plInputInterfaceMgr::GetInstance()->ClearAllKeyMaps();

	PrintString( "Keyboard bindings destroyed" );
}

static plKeyCombo	IBindKeyToVKey( const char *string )
{
	char	str[ 16 ];
	int		i;

	plKeyCombo	combo;


	strcpy( str, string );

	// Find modifiers to set flags with
	combo.fFlags = 0;
	if( strstr( str, "_S" ) || strstr( str, "_s" ) )
		combo.fFlags |= plKeyCombo::kShift;
	if( strstr( str, "_C" ) || strstr( str, "_c" ) )
		combo.fFlags |= plKeyCombo::kCtrl;
	
	// Get rid of modififers
	for( i = 0; str[ i ] != 0 && str[ i ] != '_'; i++ );
	str[ i ] = 0;

	// Convert raw key
	combo.fKey = plKeyMap::ConvertCharToVKey( str );
	if( combo.fKey == KEY_UNMAPPED )
		combo = plKeyCombo::kUnmapped;

	// And return!
	return combo;

}

static ControlEventCode	IBindStringToCmdCode( const char *string )
{
	return plKeyMap::ConvertCharToControlCode( string );
}

PF_CONSOLE_CMD( Keyboard,		// groupName
			   BindKey,		// fxnName
			   "string key1, string action", // paramList
			   "Binds the given single key combo to the given action" )	// helpString
{
	ControlEventCode code = IBindStringToCmdCode( params[ 1 ] );
	if( code == END_CONTROLS )
	{
		PrintString( "ERROR: Invalid command name" );
		return;
	}

	if( plInputInterfaceMgr::GetInstance() != nil )
	{
		plKeyCombo key1 = IBindKeyToVKey( params[ 0 ] );
		plInputInterfaceMgr::GetInstance()->BindAction( key1, code );
	}
}

PF_CONSOLE_CMD( Keyboard,		// groupName
			   BindAction,		// fxnName
			   "string key1, string key2, string action", // paramList
			   "Binds the given two keys to the given action (you can specify 'UNDEFINED' for either key if you wish)" )	// helpString
{
	ControlEventCode code = IBindStringToCmdCode( params[ 2 ] );
	if( code == END_CONTROLS )
	{
		PrintString( "ERROR: Invalid command name" );
		return;
	}

	if( plInputInterfaceMgr::GetInstance() != nil )
	{
		plKeyCombo key1 = IBindKeyToVKey( params[ 0 ] );
		plKeyCombo key2 = IBindKeyToVKey( params[ 1 ] );
		plInputInterfaceMgr::GetInstance()->BindAction( key1, key2, code );
	}
}

PF_CONSOLE_CMD( Keyboard,		// groupName
			   BindConsoleCmd,		// fxnName
			   "string key, string command", // paramList
			   "Bind console command to key" )	// helpString
{
	plKeyCombo key = IBindKeyToVKey( params[ 0 ] );

	if( plInputInterfaceMgr::GetInstance() != nil )
		plInputInterfaceMgr::GetInstance()->BindConsoleCmd( key, params[ 1 ], plKeyMap::kFirstAlways );
}


//////////////////////////////////////////////////////////////////////////////
//// Stat Gather Commands ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_GROUP( Nav )

PF_CONSOLE_CMD( Nav, PageInNode,	// Group name, Function name
				"string roomName",			// Params
				"Pages in a scene node." )	// Help string
{
	plSynchEnabler ps(false);	// disable dirty tracking while paging in
	plClientMsg* pMsg1 = TRACKED_NEW plClientMsg(plClientMsg::kLoadRoom);
	pMsg1->AddReceiver( plClient::GetInstance()->GetKey() );
	pMsg1->AddRoomLoc(plKeyFinder::Instance().FindLocation(nil, params[0]));
	plgDispatch::MsgSend(pMsg1);
}

PF_CONSOLE_CMD( Nav, PageInNodeList,	// Group name, Function name
               "string roomNameBase",			// Params
               "Pages in all scene nodes that start with name." )	// Help string
{
	plSynchEnabler ps(false);	// disable dirty tracking while paging in

	std::string pageInNodesStr;
	pageInNodesStr += "dat\\";
	pageInNodesStr += (char*)params[0];
	pageInNodesStr += "*.prx";
	hsFolderIterator pageInNodesIter(pageInNodesStr.data(), true);

	plClientMsg* pMsg1 = TRACKED_NEW plClientMsg(plClientMsg::kLoadRoom);
	while (pageInNodesIter.NextFile()) 
	{
		char nodeName[255];
		_splitpath(pageInNodesIter.GetFileName(), NULL, NULL, nodeName, NULL);
		pMsg1->AddRoomLoc(plKeyFinder::Instance().FindLocation(nil, nodeName));
	}
	pMsg1->AddReceiver( plClient::GetInstance()->GetKey() );
	plgDispatch::MsgSend(pMsg1);
}

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_CMD( Nav, PageOutNode,	// Group name, Function name
				"string roomName",			// Params
				"pages out a scene node." )	// Help string
{
	plSynchEnabler ps(false);	// disable dirty tracking while paging out
	plClientMsg* pMsg1 = TRACKED_NEW plClientMsg(plClientMsg::kUnloadRoom);
	pMsg1->AddReceiver( plClient::GetInstance()->GetKey() );
	pMsg1->AddRoomLoc(plKeyFinder::Instance().FindLocation(nil, params[0]));
	plgDispatch::MsgSend(pMsg1);
}

PF_CONSOLE_CMD( Nav, UnloadPlayer,	// Group name, Function name
				"string objName",			// Params
				"unloads a named player" )	// Help string
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString("UnloadPlayer (console version) is currently broken. Hassle Matt.");
	// plNetClientMgr::UnloadPlayer(key);
}

PF_CONSOLE_CMD( Nav, UnloadSceneObject,	// Group name, Function name
				"string objName",			// Params
				"unloads a named scene object" )	// Help string
{

	PrintString("OBSOLETE");
}

PF_CONSOLE_CMD( Nav, MovePlayer,	// Group name, Function name
				"string playerName, string destPage",			// Params
				"moves a player from one paging unit to another" )	// Help string
{
	char str[256];
	plKey playerKey = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if( !playerKey )
		return;

	plKey nodeKey = FindObjectByName(params[1], plSceneNode::Index(), nil, str);
	PrintString(str);
	if( !nodeKey )
		return;

	plNodeChangeMsg* msg = TRACKED_NEW plNodeChangeMsg(nil, playerKey, nodeKey);
	plgDispatch::MsgSend(msg);
	sprintf(str, "%s moved to %s", (char*)params[0], (char*)params[1]);
	PrintString(str);
}

PF_CONSOLE_CMD( Nav, ExcludePage, "string pageName", "Excludes the given page from ever being loaded. Useful for debugging." )
{
	if( plNetClientMgr::GetInstance() == nil )
		PrintString( "Unable to exclude page--NetClientMgr not loaded" );
	else
	{
		char	str[ 256 ];
		sprintf( str, "Page %s excluded from load", (char *)params[ 0 ] );
		plAgeLoader::GetInstance()->AddExcludedPage( params[ 0 ] );
		PrintString( str );
	}
}

PF_CONSOLE_CMD( Nav, ClearExcludeList, "", "Clears the list of pages to exclude from loading." )
{
	if( plAgeLoader::GetInstance() != nil )
		plAgeLoader::GetInstance()->ClearPageExcludeList();
}

#endif // LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( Movie ) // Defines a main command group

PF_CONSOLE_CMD( Movie,
					Start,
				   "string filename",
				   "Start of movie with this filename" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kStart);

//#define MF_TEST_MOVIECALLBACKS
#ifdef MF_TEST_MOVIECALLBACKS
	plMovieMsg* cb = TRACKED_NEW plMovieMsg("avi/intro0.bik", plMovieMsg::kStart);
	mov->AddCallback(cb);
	mov->SetCmd(mov->GetCmd() | plMovieMsg::kAddCallbacks);
#endif // MF_TEST_MOVIECALLBACKS

	mov->Send();

	PrintStringF(PrintString, "%s now playing", filename);
}

PF_CONSOLE_CMD( Movie,
					Stop,
				   "string filename",
				   "Stop movie with this filename" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kStop);
	mov->Send();

	PrintStringF(PrintString, "%s now stopping", filename);
}

PF_CONSOLE_CMD( Movie,
					Pause,
				   "string filename",
				   "Pause movie with this filename" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kPause);
	mov->Send();

	PrintStringF(PrintString, "%s now pausing", filename);
}

PF_CONSOLE_CMD( Movie,
					Resume,
				   "string filename",
				   "Resume movie with this filename" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kResume);
	mov->Send();

	PrintStringF(PrintString, "%s now resuming", filename);
}

PF_CONSOLE_CMD( Movie,
					Move,
				   "string filename, float x, float y",
				   "Move center of movie with this filename to x,y" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kMove);
	float x = params[1];
	float y = params[2];
	mov->SetCenter(x, y);
	mov->Send();

	PrintStringF(PrintString, "%s now at %g,%g", filename, x, y);
}

PF_CONSOLE_CMD( Movie,
					Scale,
				   "string filename, float x, float y",
				   "Scale movie with this filename by x,y" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kScale);
	float x = params[1];
	float y = params[2];
	mov->SetScale(x, y);
	mov->Send();

	PrintStringF(PrintString, "%s now scaled to %g,%g", filename, x, y);
}

PF_CONSOLE_CMD( Movie,
					Alpha,
				   "string filename, float a",
				   "Set opacity of movie with this filename to a" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kOpacity);
	float a = params[1];
	mov->SetOpacity(a);
	mov->Send();

	PrintStringF(PrintString, "%s opacity now at %g", filename, a);
}

PF_CONSOLE_CMD( Movie,
					Color,
				   "string filename, float r, float g, float b",
				   "Color movie with this filename as r,g,b" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kColor);
	float r = params[1];
	float g = params[2];
	float b = params[3];
	mov->SetColor(r, g, b, 1.f);
	mov->Send();

	PrintStringF(PrintString, "%s now tinted to %g,%g,%g", filename, r, g, b);
}

PF_CONSOLE_CMD( Movie,
					Volume,
				   "string filename, float v",
				   "Set volume of movie with this filename to v" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kVolume);
	float v = params[1];
	mov->SetVolume(v);
	mov->Send();

	PrintStringF(PrintString, "%s volume now at %g", filename, v);
}

PF_CONSOLE_CMD( Movie,
					FadeIn,
				   "string filename, float secs, float r, float g, float b, float a",
				   "Fade in movie with this filename from r,g,b,a over secs seconds" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kFadeIn);
	float secs = params[1];
	float r = params[2];
	float g = params[3];
	float b = params[4];
	float a = params[5];
	mov->SetFadeInSecs(secs);
	mov->SetFadeInColor(r, g, b, a);
	mov->Send();

	PrintStringF(PrintString, "%s now fading from %g,%g,%g,%g over %g secs", filename, r, g, b, a, secs);
}

PF_CONSOLE_CMD( Movie,
					FadeOut,
				   "string filename, float secs, float r, float g, float b, float a",
				   "Fade out movie with this filename to r,g,b,a over secs seconds" )
{
	char* filename = params[0];
	plMovieMsg* mov = TRACKED_NEW plMovieMsg(filename, plMovieMsg::kFadeOut);
	float secs = params[1];
	float r = params[2];
	float g = params[3];
	float b = params[4];
	float a = params[5];
	mov->SetFadeOutSecs(secs);
	mov->SetFadeOutColor(r, g, b, a);
	mov->Send();

	PrintStringF(PrintString, "%s now fading to %g,%g,%g,%g over %g secs", filename, r, g, b, a, secs);
}



//////////////////////////////////////////////////////////////////////////////
// Test hacks for setting overall quality and clamping board capability
//////////////////////////////////////////////////////////////////////////////
PF_CONSOLE_GROUP( Quality )

PF_CONSOLE_CMD( Quality,
					Level,
				   "int quality",
				   "Fake quality slider from .ini file" )
{
	int q = params[0];
	if( q < 0 )
		q = 0;
	else if (q > 3)
		q = 3;
	plClient::GetInstance()->SetQuality(q);

	char str[256];
	sprintf(str, "Quality slider to %d", q);
	PrintString(str);
}

#include "plSurface/plShaderTable.h"

PF_CONSOLE_CMD( Quality,
					Cap,
				   "int cap",
				   "Limit graphics capability from .ini file" )
{
	int c = params[0];
	if( c < 0 )
		c = 0;
	if( c == 666 )
		plShaderTable::SetLoadFromFile(true);
	else
		plClient::GetInstance()->SetClampCap(c);

	char str[256];
	sprintf(str, "Graphics capability clamped to %d", c);
	PrintString(str);
}


//////////////////////////////////////////////////////////////////////////////
//// Geometry Object Access Console Commands (strictly for testing) ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

#include "plDrawable/plSharedMesh.h"
#include "plDrawable/plAccessGeometry.h"
#include "plDrawable/plMorphSequence.h"
#include "plAvatar/plAvatarClothing.h"

PF_CONSOLE_GROUP( Access )


/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////

static plMorphSequence* LocalMorphSequence()
{
	plKey playerKey = plNetClientMgr::GetInstance()->GetLocalPlayerKey();
	if( !playerKey )
		return nil;
	plSceneObject* playerObj = plSceneObject::ConvertNoRef(playerKey->ObjectIsLoaded());
	if( !playerObj )
		return nil;

	const plCoordinateInterface* pci = playerObj->GetCoordinateInterface();
	const plModifier* constSeq = nil;
	int i;
	for( i = 0; i < pci->GetNumChildren(); i++ )
	{
		const plSceneObject* child = pci->GetChild(i)->GetOwner();
		if( child )
		{
			int j;
			for( j = 0; j < child->GetNumModifiers(); j++ )
			{
				constSeq = child->GetModifier(j);
				if( constSeq && plMorphSequence::ConvertNoRef(constSeq) )
				{
					return (plMorphSequence*)constSeq; // safe cast, we've already checked type (plus we're const_cast'ing).
				}
			}
		}
	}
	return nil;
}

PF_CONSOLE_CMD( Access,
					Morph,
				   "string morphMod, int iLay, int iDel, float wgt",
				   "Set the weight for a morphMod" )
{
	char str[256];
	char name[256];
	char* preFix = params[0];
	sprintf(name, "%s_plMorphSequence_0", preFix);
	plKey key = FindObjectByName(name, plMorphSequence::Index(), nil, str);
	PrintString(str);
	if (!key)
		return;

	plMorphSequence* seq = plMorphSequence::ConvertNoRef(key->GetObjectPtr());

	int iLay = params[1];
	int iDel = params[2];
	float wgt = params[3];

	seq->SetWeight(iLay, iDel, wgt);

	sprintf(str, "Layer[%d][%d] = %g\n", iLay, iDel, wgt);
	PrintString(str);
}

PF_CONSOLE_CMD( Access,
					MoAct,
				   "string morphMod",
				   "Activate a morphMod" )
{
	char str[256];
	char name[256];
	char* preFix = params[0];
	sprintf(name, "%s_plMorphSequence_2", preFix);
	plKey key = FindObjectByName(name, plMorphSequence::Index(), nil, str);
	PrintString(str);
	if (!key)
		return;

	plMorphSequence* seq = plMorphSequence::ConvertNoRef(key->GetObjectPtr());

	seq->Activate();

	sprintf(str, "%s Active\n", name);
	PrintString(str);
}

PF_CONSOLE_CMD( Access,
					MoDeAct,
				   "string morphMod",
				   "Activate a morphMod" )
{
	char str[256];
	char name[256];
	char* preFix = params[0];
	sprintf(name, "%s_plMorphSequence_2", preFix);
	plKey key = FindObjectByName(name, plMorphSequence::Index(), nil, str);
	PrintString(str);
	if (!key)
		return;

	plMorphSequence* seq = plMorphSequence::ConvertNoRef(key->GetObjectPtr());

	seq->DeActivate();

	sprintf(str, "%s Unactive\n", name);
	PrintString(str);
}
//////////////////
PF_CONSOLE_CMD( Access,
					Weight,
				   "int iLay, int iDel, float wgt",
				   "Set the weight for a morphMod" )
{
	plMorphSequence* seq = LocalMorphSequence();
	if( !seq )
	{
		PrintString("Sequence not found\n");
		return;
	}

	int iLay = params[0];
	int iDel = params[1];
	float wgt = params[2];

	seq->SetWeight(iLay, iDel, wgt);
	
	char str[256];
	sprintf(str, "Layer[%d][%d] = %g\n", iLay, iDel, wgt);
	PrintString(str);
}


PF_CONSOLE_CMD( Access,
			   ZeroBrian,
			   "int BeginLay, int EndLay",
			   "Zero the morph layers from begin to end" )
{
	plMorphSequence* seq = LocalMorphSequence();
	if( !seq )
	{
		PrintString("Sequence not found\n");
		return;
	}
	
	int i;
	int s = params[0];
	int e = params[1];
	
	for(i = s; i <= e; i++)
	{
		seq->SetWeight(i, 0, 0.0);
		seq->SetWeight(i, 1, 0.0);
	}
	PrintString("Zeroed");
	
}

char *gCurrMorph = nil;

PF_CONSOLE_CMD( Access,
				SetMorphItem,
				"string itemName",
				"Set which clothing item we want to morph" )
{
	delete [] gCurrMorph;
	gCurrMorph = hsStrcpy(nil, params[0]);
}

PF_CONSOLE_CMD( Access,
			   IncBrian,
			   "int iLay, float inc",
			   "Inc the weight for a morphMod pair" )
{
	plMorphSequence* seq = LocalMorphSequence();
	if( !seq )
	{
		PrintString("Sequence not found\n");
		return;
	}

	plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(gCurrMorph);
	if( !item )
	{
		PrintString("Item not found");
		return;
	}

	plKey meshKey = item->fMeshes[0]->GetKey();
	int iLay = params[0];
	float inc = params[1];

	if (iLay >= seq->GetNumLayers(meshKey))
	{
		PrintString("Layer index too high");
		return;
	}	

	float wgtPlus;
	float wgtMinus;

	wgtPlus = seq->GetWeight(iLay,0,meshKey);
	wgtMinus = seq->GetWeight(iLay,1,meshKey);

	float val = wgtPlus - wgtMinus;

	val += inc;

	if(val > 1.0) val = 1.0;
	if(val < -1.0) val = -1.0;

	if(val > 0)
	{
		wgtPlus = val;
		wgtMinus = 0;
	}
	else
	{
		wgtMinus = -val;
		wgtPlus = 0;
	}

	seq->SetWeight(iLay, 0, wgtPlus, meshKey);
	seq->SetWeight(iLay, 1, wgtMinus, meshKey);

	char str[256];
	sprintf(str, "Layer[%d][%d] = %g\n", iLay, 0, wgtPlus);
	PrintString(str);

	sprintf(str, "Layer[%d][%d] = %g\n", iLay, 1, wgtMinus);
	PrintString(str);
}




PF_CONSOLE_CMD( Access,
					FaAct,
				   "",
				   "Activate face morphMod" )
{
	plMorphSequence* seq = LocalMorphSequence();
	if( !seq )
	{
		PrintString("Sequence not found\n");
		return;
	}

	seq->Activate();

	char str[256];
	sprintf(str, "%s Active\n", seq->GetKey()->GetName());
	PrintString(str);
}

PF_CONSOLE_CMD( Access,
					FaDeAct,
				   "",
				   "Deactivate a morphMod" )
{
	plMorphSequence* seq = LocalMorphSequence();
	if( !seq )
	{
		PrintString("Sequence not found\n");
		return;
	}

	seq->DeActivate();

	char str[256];
	sprintf(str, "%s Unactive\n", seq->GetKey()->GetName());
	PrintString(str);
}

PF_CONSOLE_CMD( Access,
					Face,
				   "string clothItem",
				   "Set face morphMod to affect a clothing item" )
{
	char str[256];
	plMorphSequence* seq = LocalMorphSequence();
	if( !seq )
	{
		PrintString("Sequence not found\n");
		return;
	}

	plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(params[0]);
	if( !item )
		return;

	seq->SetUseSharedMesh(true);
	seq->AddSharedMesh(item->fMeshes[plClothingItem::kLODHigh]);

	sprintf(str, "%s on item %s\n", seq->GetKey()->GetName(), (char *)params[0]);
	PrintString(str);
}

#include "pfSurface/plFadeOpacityMod.h"

PF_CONSOLE_CMD( Access,
					Fade,
				   "",
				   "Test fading on visibility" )
{
	hsBool disabled = !plFadeOpacityMod::GetLOSCheckDisabled();

	plFadeOpacityMod::SetLOSCheckDisabled(disabled);

	char str[256];
	sprintf(str, "LOS check now %s", disabled ? "disabled" : "enabled");
	PrintString(str);
}

PF_CONSOLE_CMD( Access,
					ObjFade,
				   "string obj, float fadeUp, float fadeDown",
				   "Test fading on visibility" )
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if( !key )
		return;

	plSceneObject* obj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !obj )
		return;

	float fadeUp = params[1];
	float fadeDown = params[2];

	plFadeOpacityMod* mod = TRACKED_NEW plFadeOpacityMod;
	mod->SetFadeUp(fadeUp);
	mod->SetFadeDown(fadeDown);

	hsgResMgr::ResMgr()->NewKey(obj->GetKey()->GetName(), mod, obj->GetKey()->GetUoid().GetLocation());

	hsgResMgr::ResMgr()->AddViaNotify(mod->GetKey(), TRACKED_NEW plObjRefMsg(obj->GetKey(), plRefMsg::kOnCreate, -1, plObjRefMsg::kModifier), plRefFlags::kActiveRef);

}

#include "plDrawable/plVisLOSMgr.h"

static plSceneObject* losObj = nil;

PF_CONSOLE_CMD( Access,
					Obj,
				   "string losObj",
				   "Set the los test marker" )
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if( !key )
		return;

	losObj = plSceneObject::ConvertNoRef(key->GetObjectPtr());
}

PF_CONSOLE_CMD( Access,
					HackLOS,
				   "string marker",
				   "Set the Los hack marker" )
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);

	plSceneObject* so = nil;
	if( key )
	{
		so = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	}

	extern void VisLOSHackBegin(plPipeline* p, plSceneObject* m);

	VisLOSHackBegin(pfConsole::GetPipeline(), so);
}

PF_CONSOLE_CMD( Access,
					HackEnd,
				   "",
				   "stop the hackage" )
{
	extern void VisLOSHackBegin(plPipeline* p, plSceneObject* m);

	VisLOSHackBegin(nil, nil);
}


PF_CONSOLE_CMD( Access,
					LOS,
					"...",
					"Fire LOS test check" )
{
	static float dist = 1.e5f;
	if( numParams > 0 )
		dist = params[0];

	hsPoint3 from = pfConsole::GetPipeline()->GetViewPositionWorld();

	Int32 sx = pfConsole::GetPipeline()->Width() / 2;
	Int32 sy = pfConsole::GetPipeline()->Height() / 2;
	hsPoint3 targ;
	pfConsole::GetPipeline()->ScreenToWorldPoint(1, 0, &sx, &sy, dist, 0, &targ);

	plVisHit hit;
	if( plVisLOSMgr::Instance()->Check(from, targ, hit) )
	{
		char buff[256];
		sprintf(buff, "(%g, %g, %g)", hit.fPos.fX, hit.fPos.fY, hit.fPos.fZ);
		PrintString(buff);

		if( losObj )
		{
			hsMatrix44 l2w = losObj->GetLocalToWorld();
			l2w.fMap[0][3] = hit.fPos.fX;
			l2w.fMap[1][3] = hit.fPos.fY;
			l2w.fMap[2][3] = hit.fPos.fZ;
			l2w.NotIdentity();
			hsMatrix44 w2l;
			l2w.GetInverse(&w2l);
			losObj->SetTransform(l2w, w2l);
		}
	}

}

#include "plMessage/plBulletMsg.h"

plSceneObject* gunObj = nil;
hsScalar gunRadius = 1.f;
hsScalar gunRange = 5000.f;

PF_CONSOLE_CMD( Access,
					Gun,
				   "string gun, float radius, ...",
				   "Fire shot along gun's z-axis, creating decal of radius <radius>, with optional max-range (def 1000)" )
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if( !key )
		return;

	plSceneObject* so = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if( !so )
		return;

	gunObj = so;

	gunRadius = params[1];

	if( numParams > 2 )
		gunRange = params[2];
}

PF_CONSOLE_CMD( Access,
					Shot,
				   "",
				   "Fire shot along gun's z-axis" )
{
	plSceneObject* so = gunObj;
	if( !so )
	{
		PrintString("Set gun object first");
		return;
	}

	hsMatrix44 l2w = so->GetLocalToWorld();
	hsVector3 dir(l2w.fMap[0][2], l2w.fMap[1][2], l2w.fMap[2][2]);
	dir.Normalize();
	hsPoint3 pos = l2w.GetTranslate();

	hsScalar radius = gunRadius;

	hsScalar range = gunRange;

	plBulletMsg* bull = TRACKED_NEW plBulletMsg(nil, nil, nil);
	bull->FireShot(pos, dir, radius, range);

	bull->Send();

	PrintString("Shot fired!");
}

PF_CONSOLE_CMD( Access,
					XShot,
				   "",
				   "Fire shot along gun's neg x-axis" )
{
	plSceneObject* so = gunObj;
	if( !so )
	{
		PrintString("Set gun object first");
		return;
	}

	hsMatrix44 l2w = so->GetLocalToWorld();
	hsVector3 dir(-l2w.fMap[0][0], -l2w.fMap[1][0], -l2w.fMap[2][0]);
	dir.Normalize();
	hsPoint3 pos = l2w.GetTranslate();

	hsScalar radius = gunRadius;

	hsScalar range = gunRange;

	plBulletMsg* bull = TRACKED_NEW plBulletMsg(nil, nil, nil);
	bull->FireShot(pos, dir, radius, range);

	bull->Send();

	PrintString("Shot fired!");
}

PF_CONSOLE_CMD( Access,
			   Party,
			   "string bull, string psys",
			   "Add particle system <psys> to bulletMgr <bull>")
{
	char str[256];
	plKey bullKey = FindObjectByName(params[0], plDynaBulletMgr::Index(), nil, str, false);
	PrintString(str);
	if( !(bullKey && bullKey->GetObjectPtr()) )
	{
		PrintString("bullet not found");
		return;
	}

	plKey sysKey = FindSceneObjectByName(params[1], nil, str);
	if( !(sysKey && sysKey->GetObjectPtr()) )
	{
		PrintString("Psys not found");
		return;
	}
	hsgResMgr::ResMgr()->AddViaNotify(sysKey, TRACKED_NEW plGenRefMsg(bullKey, plRefMsg::kOnCreate, 0, plDynaBulletMgr::kRefPartyObject), plRefFlags::kPassiveRef);

	PrintString("sys added");
}

#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////////////////////
//// WaveSet Console Commands ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

#include "plDrawable/plWaveSet7.h"
#include "plDrawable/plFixedWaterState7.h"
PF_CONSOLE_GROUP( Wave )

PF_CONSOLE_SUBGROUP( Wave, Set)		// Creates a sub-group under a given group

namespace plWaveCmd {
	enum Cmd
	{
		kWindDir,

		kGeoLen,
		kGeoChop,
		kGeoAmp,
		kGeoAngle,

		kTexLen,
		kTexChop,
		kTexAmp,
		kTexAngle,

		kNoise,

		kSpecAtten,

		kWaterTint,
		kWaterOpacity,
		kSpecularTint,
		kSpecularMute,
		kRippleScale,
		kWaterHeight,
		kWaterOffsetOpac,
		kWaterOffsetRefl,
		kWaterOffsetWave,
		kDepthFalloffOpac,
		kDepthFalloffRefl,
		kDepthFalloffWave,
		kMaxAtten,
		kMinAtten,
		kEnvCenter,
		kEnvRadius,
	};
};

typedef void PrintFunk(const char* str);

static inline hsScalar FracToPercent(hsScalar f) { return (hsScalar)(1.e2 * f); }
static inline hsScalar PercentToFrac(hsScalar f) { return (hsScalar)(1.e-2 * f); }

static inline hsScalar RadToDeg(hsScalar r) { return r * 180.f / hsScalarPI; }
static inline hsScalar DegToRad(hsScalar d) { return d * hsScalarPI / 180.f; }

static void IDisplayWaveVal(PrintFunk PrintString, plWaveSet7* wave, plWaveCmd::Cmd cmd)
{
	if( !wave )
		return;

	using namespace plWaveCmd;

	char buff[256];

	hsPoint3 pos;
	hsVector3 vec;
	hsColorRGBA col;

	plFixedWaterState7 state = wave->State();
	switch( cmd )
	{
	case kGeoLen:
		sprintf(buff, "Min/Max Geo Wavelengths = %f/%f", wave->GetGeoMinLength(), wave->GetGeoMaxLength());
		break;
	case kGeoChop:
		sprintf(buff, "Geo Choppiness = %f", FracToPercent(wave->GetGeoChop()));
		break;
	case kGeoAmp:
		sprintf(buff, "Geo Wave Amplitude to Length Ratio (%%) = %f", FracToPercent(wave->GetGeoAmpOverLen()));
		break;
	case kGeoAngle:
		sprintf(buff, "Geo Spread of waves about Wind Dir = %f degrees", RadToDeg(wave->GetGeoAngleDev()));
		break;

	case kTexLen:
		sprintf(buff, "Min/Max Tex Wavelengths = %f/%f", wave->GetTexMinLength(), wave->GetTexMaxLength());
		break;
	case kTexChop:
		sprintf(buff, "Tex Choppiness = %f", FracToPercent(wave->GetTexChop()));
		break;
	case kTexAmp:
		sprintf(buff, "Tex Wave Amplitude to Length Ratio = %f%%", FracToPercent(wave->GetTexAmpOverLen()));
		break;
	case kTexAngle:
		sprintf(buff, "Tex Spread of waves about Wind Dir = %f degrees", RadToDeg(wave->GetTexAngleDev()));
		break;
	
	case kNoise:
		sprintf(buff, "Noising texture ripples at %f %%", FracToPercent(wave->GetSpecularNoise()));
		break;
	
	case kSpecAtten:
		sprintf(buff, "Ripples fade out from %f to %f feet", wave->GetSpecularStart(), wave->GetSpecularEnd());
		break;

	case kWaterOpacity:
		sprintf(buff, "WaterOpacity = %f", FracToPercent(wave->GetWaterTint().a));
		break;
	case kRippleScale:
		sprintf(buff, "RippleScale = %f", wave->GetRippleScale());
		break;
	case kWaterHeight:
		sprintf(buff, "WaterHeight = %f", wave->GetWaterHeight());
		break;
	case kEnvRadius:
		sprintf(buff, "EnvRadius = %f", wave->GetEnvRadius());
		break;
	case kWaterOffsetOpac:
		sprintf(buff, "OpacStart = %f", -wave->GetOpacOffset());
		break;
	case kWaterOffsetRefl:
		sprintf(buff, "ReflStart = %f", -wave->GetReflOffset());
		break;
	case kWaterOffsetWave:
		sprintf(buff, "WaveStart = %f", -wave->GetWaveOffset());
		break;

	case kDepthFalloffOpac:
		sprintf(buff, "OpacEnd = %f", wave->GetOpacFalloff());
		break;
	case kDepthFalloffRefl:
		sprintf(buff, "ReflEnd = %f", wave->GetReflFalloff());
		break;
	case kDepthFalloffWave:
		sprintf(buff, "WaveEnd = %f", wave->GetWaveFalloff());
		break;

	case kWindDir:
		vec = wave->GetWindDir();
		sprintf(buff, "WindDir (%f, %f)", vec.fX, vec.fY);
		break;
	case kMinAtten:
		vec = wave->GetMinAtten();
		sprintf(buff, "MinAtten (%f, %f, %f)", vec.fX, vec.fY, vec.fZ);
		break;
	case kMaxAtten:
		vec = wave->GetMaxAtten();
		sprintf(buff, "MaxAtten (%f, %f, %f)", vec.fX, vec.fY, vec.fZ);
		break;

	case kEnvCenter:
		pos = wave->GetEnvCenter();
		sprintf(buff, "EnvCenter (%f, %f, %f)", pos.fX, pos.fY, pos.fZ);
		break;

	case kWaterTint:
		col = wave->GetWaterTint();
		sprintf(buff, "Water tint (%d, %d, %d)", 
			int(col.r * 255.9f), 
			int(col.g * 255.9f), 
			int(col.b * 255.9f));
		break;
	case kSpecularTint:
		col = wave->GetSpecularTint();
		sprintf(buff, "Specular tint (%d, %d, %d)", 
			int(col.r * 255.9f), 
			int(col.g * 255.9f), 
			int(col.b * 255.9f));
		break;
	case kSpecularMute:
		col = wave->GetSpecularTint();
		sprintf(buff, "Specular mute %f", FracToPercent(col.a));
		break;

	default:
		sprintf(buff, "Unknown parameter");
		break;
	}
	PrintString(buff);
}

static plWaveSet7* IGetWaveSet(PrintFunk PrintString, const char* name)
{
	char str[256];
	plKey waveKey = FindObjectByName(name, plWaveSet7::Index(), nil, str, false);
	PrintString(str);
	if (!waveKey)
		return nil;

	plWaveSet7* waveSet = plWaveSet7::ConvertNoRef(waveKey->ObjectIsLoaded());
	if( !waveSet )
	{
		PrintString("Found object, but it's not a Water component. Ignoring");
	}
	return waveSet;
}

static plWaveSet7* ICheckWaveParams(PrintFunk PrintString, const char* name, int numParams, int n, plWaveCmd::Cmd cmd)
{
	if( !numParams )
	{
		PrintString("Missing name of water component");
		return nil;
	}
	plWaveSet7* waveSet = IGetWaveSet(PrintString, name);
	if( waveSet && (numParams < n) )
	{
		IDisplayWaveVal(PrintString, waveSet, cmd);
		return nil;
	}
	return waveSet;
}

static hsScalar LimitVal(hsScalar val, hsScalar lo, hsScalar hi, PrintFunk PrintString)
{
	if( val < lo )
	{
		char buff[256];
		sprintf(buff, "%f too low, clamped to %f", val, lo);
		PrintString(buff);
		val = lo;
	}
	else if( val > hi )
	{
		char buff[256];
		sprintf(buff, "%f too high, clamped to %f", val, hi);
		PrintString(buff);
		val = hi;
	}
	return val;
}

static bool ISendWaveCmd1f(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
{
	plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 2, cmd);
	if( !wave )
		return false;

	using namespace plWaveCmd;

	float val = params[1];

	hsScalar secs = ( numParams > 2 ) ? params[2] : 0.f;

	switch( cmd )
	{
	case kGeoChop:
		wave->SetGeoChop(PercentToFrac(val), secs);
		break;
	case kGeoAmp:
		wave->SetGeoAmpOverLen(PercentToFrac(val), secs);
		break;
	case kGeoAngle:
		wave->SetGeoAngleDev(DegToRad(val), secs);
		break;

	case kTexChop:
		wave->SetTexChop(PercentToFrac(val), secs);
		break;
	case kTexAmp:
		wave->SetTexAmpOverLen(PercentToFrac(val), secs);
		break;
	case kTexAngle:
		wave->SetTexAngleDev(DegToRad(val), secs);
		break;

	case kNoise:
		wave->SetSpecularNoise(PercentToFrac(val), secs);
		break;

	case kWaterOpacity:
		wave->SetWaterOpacity(PercentToFrac(val), secs);
		break;
	case kSpecularMute:
		wave->SetSpecularMute(PercentToFrac(val), secs);
		break;
	case kRippleScale:
		wave->SetRippleScale(val, secs);
		break;
	case kWaterHeight:
		wave->SetWaterHeight(val, secs);
		break;
	case kEnvRadius:
		wave->SetEnvRadius(val, secs);
		break;
	case kWaterOffsetOpac:
		wave->SetOpacOffset(-val, secs);
		break;
	case kWaterOffsetRefl:
		wave->SetReflOffset(-val, secs);
		break;
	case kWaterOffsetWave:
		wave->SetWaveOffset(-val, secs);
		break;

	case kDepthFalloffOpac:
		wave->SetOpacFalloff(val, secs);
		break;
	case kDepthFalloffRefl:
		wave->SetReflFalloff(val, secs);
		break;
	case kDepthFalloffWave:
		wave->SetWaveFalloff(val, secs);
		break;

	default:
		return false;
	}
	return true;
}

static bool ISendWaveCmd2f(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
{
	plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 3, cmd);
	if( !wave )
		return false;

	using namespace plWaveCmd;

	hsScalar secs = ( numParams > 3 ) ? params[3] : 0.f;

	hsVector3 vec;
	plFixedWaterState7 state = wave->State();
	switch( cmd )
	{
	case kWindDir:
		vec = wave->GetWindDir();
		vec.fX = params[1];
		vec.fY = params[2];
		wave->SetWindDir(vec, secs);
		break;

	case kGeoLen:
		wave->SetGeoMinLength(params[1], secs);
		wave->SetGeoMaxLength(params[2], secs);
		break;

	case kTexLen:
		wave->SetTexMinLength(params[1], secs);
		wave->SetTexMaxLength(params[2], secs);
		break;

	case kSpecAtten:
		wave->SetSpecularStart(params[1], secs);
		wave->SetSpecularEnd(params[2], secs);
		break;


	default:
		return false;
	}
	return true;
}

static bool ISendWaveCmd3f(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
{
	plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 4, cmd);
	if( !wave )
		return false;

	using namespace plWaveCmd;

	float x = params[1];
	float y = params[2];
	float z = params[3];
	hsVector3 vec(x, y, z);
	hsPoint3 pos(x, y, z);

	hsScalar secs = ( numParams > 4 ) ? params[4] : 0.f;

	switch( cmd )
	{
	case kWindDir:
		wave->SetWindDir(vec, secs);
		break;
	case kMinAtten:
		wave->SetMinAtten(vec, secs);
		break;
	case kMaxAtten:
		wave->SetMaxAtten(vec, secs);
		break;

	case kEnvCenter:
		wave->SetEnvCenter(pos, secs);
		break;

	default:
		return false;
	}
	return true;
}

static bool ISendWaveCmd4c(PrintFunk PrintString, pfConsoleCmdParam* params, int numParams, plWaveCmd::Cmd cmd)
{
	plWaveSet7* wave = ICheckWaveParams(PrintString, params[0], numParams, 4, cmd);
	if( !wave )
		return false;

	using namespace plWaveCmd;

	float r = params[1];
	float g = params[2];
	float b = params[3];

	hsScalar secs = ( numParams > 4 ) ? params[4] : 0.f;

	hsColorRGBA col;
	col.Set(r / 255.f, g / 255.f, b / 255.f, 1.f);

	switch( cmd )
	{
	case kWaterTint:
		col.a = wave->GetWaterOpacity();
		wave->SetWaterTint(col, secs);
		break;
	case kSpecularTint:
		col.a = wave->GetSpecularMute();
		wave->SetSpecularTint(col, secs);
		break;

	default:
		return false;
	}
	return true;
}

PF_CONSOLE_CMD( Wave, Log,	// Group name, Function name
				"string waveSet",			// Params none
				"Toggle logging for waves" )	// Help string
{
	const char* name = params[0];
	plWaveSet7* waveSet = IGetWaveSet(PrintString, name);
	if( waveSet )
	{
		hsBool logging = !waveSet->Logging();
		if( logging )
			waveSet->StartLog();
		else
			waveSet->StopLog();

		char buff[256];
		sprintf(buff, "Logging for %s now %s", name, logging ? "on" : "off");
		PrintString(buff);
	}
}

PF_CONSOLE_CMD( Wave, Graph,	// Group name, Function name
				"string waveSet",			// Params none
				"Toggle graphing lens for waves" )	// Help string
{
	const char* name = params[0];
	plWaveSet7* waveSet = IGetWaveSet(PrintString, name);
	if( waveSet )
	{
		hsBool graphing = !waveSet->Graphing();
		if( graphing )
			waveSet->StartGraph();
		else
			waveSet->StopGraph();

		char buff[256];
		sprintf(buff, "Graphing for %s now %s", name, graphing ? "on" : "off");
		PrintString(buff);
	}
}

// Geometric wave param block 
PF_CONSOLE_CMD( Wave_Set, GeoLen,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set <min> and <max> geometric wavelengths in feet" )	// Help string
{
	ISendWaveCmd2f(PrintString, params, numParams, plWaveCmd::kGeoLen);
}

PF_CONSOLE_CMD( Wave_Set, GeoAmp,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set geometric wave ratio of Amplitude to Wavelengths (as percentage)" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kGeoAmp);
}

PF_CONSOLE_CMD( Wave_Set, GeoChop,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current geometric wave choppiness" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kGeoChop);
}

PF_CONSOLE_CMD( Wave_Set, GeoAngle,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set geometric wave angular Spread about wind direction (in degrees)" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kGeoAngle);
}

PF_CONSOLE_CMD( Wave_Set, ReflTint,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current reflection tint (r g b)" )	// Help string
{
	ISendWaveCmd4c(PrintString, params, numParams, plWaveCmd::kSpecularTint);
}

PF_CONSOLE_CMD( Wave_Set, ReflMute,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current reflection muting f (100 % no muting, 0% all gone)" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kSpecularMute);
}

// Texture wave param block

PF_CONSOLE_CMD( Wave_Set, TexLen,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set <min> and <max> texture wavelengths in feet" )	// Help string
{
	ISendWaveCmd2f(PrintString, params, numParams, plWaveCmd::kTexLen);
}

PF_CONSOLE_CMD( Wave_Set, TexAmp,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set texture wave ratio of Amplitude to Wavelengths (as percentage)" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kTexAmp);
}

PF_CONSOLE_CMD( Wave_Set, TexChop,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current texture wave choppiness" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kTexChop);
}

PF_CONSOLE_CMD( Wave_Set, Noise,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current noising of texture waves (as percentage)" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kNoise);
}

PF_CONSOLE_CMD( Wave_Set, Scale,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water ripple scale f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kRippleScale);
}

PF_CONSOLE_CMD( Wave_Set, TexAngle,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set texture wave spread about wind dir (in degrees)" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kTexAngle);
}

PF_CONSOLE_CMD( Wave_Set, SpecAtten,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set falloff of ripples from <start> to <end> in feet" )	// Help string
{
	ISendWaveCmd2f(PrintString, params, numParams, plWaveCmd::kSpecAtten);
}

// Minor water param block

PF_CONSOLE_CMD( Wave_Set, OpacStart,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water opacity start f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kWaterOffsetOpac);
}

PF_CONSOLE_CMD( Wave_Set, OpacEnd,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water opacity end f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kDepthFalloffOpac);
}

PF_CONSOLE_CMD( Wave_Set, ReflStart,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water reflection start f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kWaterOffsetRefl);
}

PF_CONSOLE_CMD( Wave_Set, ReflEnd,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water refleciton end f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kDepthFalloffRefl);
}

PF_CONSOLE_CMD( Wave_Set, WaveStart,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water wave start f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kWaterOffsetWave);
}

PF_CONSOLE_CMD( Wave_Set, WaveEnd,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water wave end f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kDepthFalloffWave);
}

// Reflection param block

PF_CONSOLE_CMD( Wave_Set, EnvCenter,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current EnvMap Center (x y z)" )	// Help string
{
	ISendWaveCmd3f(PrintString, params, numParams, plWaveCmd::kEnvCenter);
}

PF_CONSOLE_CMD( Wave_Set, Radius,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current envmap radius f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kEnvRadius);
}

// Misc. These are normally implicit by associated data (ref object or material).
PF_CONSOLE_CMD( Wave_Set, Direction,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current wind direction (x y)" )	// Help string
{
	ISendWaveCmd2f(PrintString, params, numParams, plWaveCmd::kWindDir);
}


PF_CONSOLE_CMD( Wave_Set, WaterTint,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water tint (r g b)" )	// Help string
{
	ISendWaveCmd4c(PrintString, params, numParams, plWaveCmd::kWaterTint);
}


PF_CONSOLE_CMD( Wave_Set, Opacity,	// Group name, Function name
				"string waveSet, ...",			// Params none
				"Set current water max opacity f" )	// Help string
{
	ISendWaveCmd1f(PrintString, params, numParams, plWaveCmd::kWaterOpacity);
}

#endif // LIMIT_CONSOLE_COMMANDS



//////////////////////////////////////////////////////////////////////////////
//// Object Console Commands ////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS


PF_CONSOLE_GROUP( SceneObject )

PF_CONSOLE_SUBGROUP( SceneObject, SetEnable)		// Creates a sub-group under a given group


PF_CONSOLE_CMD( SceneObject_SetEnable, Drawable,	// Group name, Function name
				"string objName, bool on",			// Params none
				"Enable or disable drawing of a sceneobject" )	// Help string
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if (!key)
		return;

	bool enable = params[1];
	
	plEnableMsg* pEMsg = TRACKED_NEW plEnableMsg;
	pEMsg->SetCmd( enable ? plEnableMsg::kEnable : plEnableMsg::kDisable );
	pEMsg->SetCmd( plEnableMsg::kDrawable );
	pEMsg->AddReceiver( key );
	plgDispatch::MsgSend( pEMsg );
}

PF_CONSOLE_CMD( SceneObject_SetEnable, Physical,	// Group name, Function name
				"string objName, bool on",			// Params none
				"Enable or disable the physical of a sceneobject" )	// Help string
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if (!key)
		return;

	bool enable = params[1];
	
	plEnableMsg* pEMsg = TRACKED_NEW plEnableMsg;
	pEMsg->SetCmd( enable ? plEnableMsg::kEnable : plEnableMsg::kDisable );
	pEMsg->SetCmd( plEnableMsg::kPhysical );
	pEMsg->AddReceiver( key );
	plgDispatch::MsgSend( pEMsg );
}
/*
PF_CONSOLE_CMD( SceneObject_SetEnable, PhysicalT,	// Group name, Function name
				"string objName, bool on",			// Params none
				"Enable or disable the physical of a sceneobject" )	// Help string
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if (!key)
		return;

	bool enable = params[1];
	
	plEventGroupEnableMsg* pMsg = TRACKED_NEW plEventGroupEnableMsg;
	if( enable )
		pMsg->SetFlags(plEventGroupEnableMsg::kCollideOn | plEventGroupEnableMsg::kReportOn);
	else
		pMsg->SetFlags(plEventGroupEnableMsg::kCollideOff | plEventGroupEnableMsg::kReportOff);

	pMsg->AddReceiver(key);
	pMsg->Send();

}
*/
PF_CONSOLE_CMD( SceneObject_SetEnable, Audible,		// Group name, Function name
				"string objName, bool on",			// Params none
				"Enable or disable the audible of a sceneobject" )	// Help string
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if (!key)
		return;

	bool enable = params[1];
	
	plEnableMsg* pEMsg = TRACKED_NEW plEnableMsg;
	pEMsg->SetCmd( enable ? plEnableMsg::kEnable : plEnableMsg::kDisable );
	pEMsg->SetCmd( plEnableMsg::kAudible );
	pEMsg->AddReceiver( key );
	plgDispatch::MsgSend( pEMsg );
}

PF_CONSOLE_CMD( SceneObject_SetEnable, All,			// Group name, Function name
				"string objName, bool on",			// Params none
				"Enable or disable all fxns of a sceneobject" )	// Help string
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	PrintString(str);
	if (!key)
		return;

	bool enable = params[1];
	
	plEnableMsg* pEMsg = TRACKED_NEW plEnableMsg;
	pEMsg->SetCmd( enable ? plEnableMsg::kEnable : plEnableMsg::kDisable );
	pEMsg->SetCmd( plEnableMsg::kAll );
	pEMsg->AddReceiver( key );
	plgDispatch::MsgSend( pEMsg );
}

PF_CONSOLE_CMD( SceneObject, Attach,			// Group name, Function name
				"string childName, string parentName",			// Params none
				"Attach child to parent" )	// Help string
{
	char str[256];

	const char* childName = params[0];
	const char* parentName = params[1];

	plKey childKey = FindSceneObjectByName(childName, nil, str);
	if( !childKey )
	{
		PrintString(str);
		return;
	}
	plSceneObject* child = plSceneObject::ConvertNoRef(childKey->GetObjectPtr());
	if( !child )
	{
		sprintf( str, "Child SceneObject not found");
		PrintString(str);
		return;
	}

	plKey parentKey = FindSceneObjectByName(parentName, nil, str);
	if( !parentKey )
	{
		PrintString(str);
		return;
	}

	plAttachMsg* attMsg = TRACKED_NEW plAttachMsg(parentKey, child, plRefMsg::kOnRequest, nil);
	plgDispatch::MsgSend(attMsg);

	sprintf(str, "%s now child of %s", childName, parentName);
	PrintString(str);

}

PF_CONSOLE_CMD( SceneObject, Detach,			// Group name, Function name
				"string childName",			// Params none
				"Detach a child from parent (if any)" )	// Help string
{
	char str[256];

	const char* childName = params[0];

	plKey childKey = FindSceneObjectByName(childName, nil, str);
	if( !childKey )
	{
		PrintString(str);
		return;
	}
	plSceneObject* child = plSceneObject::ConvertNoRef(childKey->GetObjectPtr());
	if( !child )
	{
		sprintf( str, "Child SceneObject not found");
		PrintString(str);
		return;
	}

	if( child 
		&& child->GetCoordinateInterface() 
		&& child->GetCoordinateInterface()->GetParent() 
		&& child->GetCoordinateInterface()->GetParent()->GetOwner() )
	{
		plKey parentKey = child->GetCoordinateInterface()->GetParent()->GetOwner()->GetKey();
		plAttachMsg* attMsg = TRACKED_NEW plAttachMsg(parentKey, child, plRefMsg::kOnRemove, nil);
		plgDispatch::MsgSend(attMsg);

		sprintf(str, "%s detached from %s", childName, parentKey->GetName());
		PrintString(str);
		return;
	}
	else
	{
		sprintf(str, "%s not attached to anything", childName);
		PrintString(str);
		return;
	}
}

#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////
// PHYSICS (The Havok Flavour)
//////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

#include "plPhysX/plPXPhysicalControllerCore.h"

PF_CONSOLE_GROUP( Physics )

PF_CONSOLE_CMD( Physics, Rebuild, "", "Rebuilds the avatars collision cache")
{
	plPXPhysicalControllerCore::RebuildCache();
}

PF_CONSOLE_CMD(Physics, MaxPhysicalAvatars, "int max", "Set the maximum number of avatar physicals allowed. Default = 0 (meaning no limit)")
{
	int max = params[0];
	plPXPhysicalControllerCore::SetMaxNumberOfControllers(max);
}

/*
PF_CONSOLE_CMD( Physics, SetStepsPerSecond, "int steps", "Sets the number of physics substeps per second, regardless of rendering framerate.")
{
	int newSteps = params[0];
	plSimulationMgr::GetInstance()->SetStepsPerSecond(newSteps);
}

PF_CONSOLE_CMD( Physics, GetStepsPerSecond, "", "Prints the number of physics substeps per second.")
{
	int steps = plSimulationMgr::GetInstance()->GetStepsPerSecond();

	char buffy[256];
	sprintf(buffy, "Current physics resolution is %d frames per second.", steps);
	PrintString(buffy);
}

PF_CONSOLE_CMD(Physics, SetMaxDelta, "float maxDelta", "Sets the largest frame-to-frame delta that physics will try to resolve before giving up and freezing.")
{
	float newMaxDelta = params[0];
	plSimulationMgr::GetInstance()->SetMaxDelta(newMaxDelta);
}

PF_CONSOLE_CMD(Physics, GetMaxDelta, "", "Prints the largest frame-to-frame delta that physics will try to resolve before giving up and freezing.")
{
	float oldMaxDelta = plSimulationMgr::GetInstance()->GetMaxDelta();

	char buffy[256];
	sprintf(buffy, "When (delta > %f), physics is suspended for that frame.", oldMaxDelta);
	PrintString(buffy);
}

PF_CONSOLE_CMD(Physics, SetDeactivateFreq, "float freq", "")
{
	float freq = params[0];
	plSimulationMgr::GetInstance()->SetDeactivateFreq(freq);
}

PF_CONSOLE_CMD(Physics, SetCollisionTolerance, "float tol", "Minimum distance objects must be from each other to collide.  Set from an ini file.")
{
	float tol = params[0];
	plHKPhysicsContext::SetCollisionTolerance(tol);
}

PF_CONSOLE_CMD( Physics, Suspend, "", "Toggle suspend/resume physics.")
{
	if(plSimulationMgr::GetInstance()->IsSuspended())
		plSimulationMgr::GetInstance()->Resume();
	else
		plSimulationMgr::GetInstance()->Suspend();
}

PF_CONSOLE_CMD( Physics, ShowExternal, "", "Display a snapshot of the world as Havok sees it. Requires separate debug app." )
{
	plSimulationMgr::GetInstance()->ExternalDebugDisplay();
}

//PF_CONSOLE_CMD( Physics, SetGravity, "float fpsps", "Set gravity in feet per second per second.")
//{
//	plSimulationMgr::GetInstance()->SetGravity(0,0,params[0]);
//}

PF_CONSOLE_CMD( Physics, ApplyForce, "string Object, float x, float y, float z", "Apply a force to a scene object at its center of mass.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key) 
	{
		hsVector3 force(params[1], params[2], params[3]);
		plForceMsg *m = TRACKED_NEW plForceMsg(nil, key, force);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ApplyForceAtPoint, "string Object, float forceX, float forceY, float forceZ, float pointX, float pointY, float pointZ", "Apply a force to a scene object at a particular point in world space.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil, nil);

	if(key) 
	{
		hsVector3 force(params[1], params[2], params[3]);
		hsPoint3 point(params[4], params[5], params[6]);
		plOffsetForceMsg *m = TRACKED_NEW plOffsetForceMsg(nil, key, force, point);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ApplyTorque, "string Object, float axisX, float axisY, float axisZ", "Apply a torque to a scene object about given axis. Magnitude is size of force.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		hsVector3 torque(params[1], params[2], params[3]);
		plTorqueMsg *m = TRACKED_NEW plTorqueMsg(nil, key, torque);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ApplyImpulse, "string Object, float x, float y, float z", "Apply an impulse to a scene object.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		hsVector3 impulse(params[1], params[2], params[3]);
		plImpulseMsg *m = TRACKED_NEW plImpulseMsg(nil, key, impulse);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ApplyImpulseAtPoint, "string Object, float impulseX, float impulseY, float impulseZ, float pointX, float pointY, float pointZ", "Apply an impulse to a scene object at a particular point in world space.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		hsVector3 impulse(params[1], params[2], params[3]);
		hsPoint3 point(params[4], params[5], params[6]);
		plOffsetImpulseMsg *m = TRACKED_NEW plOffsetImpulseMsg(nil, key, impulse, point);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ApplyAngularImpulse, "string Object, float x, float y, float z", "Apply a rotational impulse about the given axis a scene object. Magnitude is strength.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		hsVector3 impulse(params[1], params[2], params[3]);
		plAngularImpulseMsg *m = TRACKED_NEW plAngularImpulseMsg(nil, key, impulse);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ApplyDamping, "string Object, float dampFactor", "Reduce the velocity and spin of the object to the given percentage.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		float dampFactor = params[1];
		plDampMsg *m = TRACKED_NEW plDampMsg(nil, key, dampFactor);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, ShiftMass, "string Object, float x, float y, float z", "Shift the object's center of mass.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		hsVector3 offset(params[1], params[2], params[3]);
		plShiftMassMsg *m = TRACKED_NEW plShiftMassMsg(nil, key, offset);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, Suppress, "string Object, int doSuppress", "Remove(true) or re-add the named physical from/to the simulation.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);
	if(key)
	{
		int iDoSuppress = params[1];
		
		bool doSuppress = iDoSuppress ? true : false;
		plSimSuppressMsg *msg = TRACKED_NEW plSimSuppressMsg(nil, key, doSuppress);
		msg->Send();
	}
}

PF_CONSOLE_CMD( Physics, SetEventGroup, "string Object, int group, int status, int clearOthers", "Add to or remove from physics event group.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		int group = params[1], status = params[2], clearOthers = params[3];
		plEventGroupMsg *m = TRACKED_NEW plEventGroupMsg(nil, key, group, status, clearOthers);
		plgDispatch::MsgSend(m);
	}
}

PF_CONSOLE_CMD( Physics, Freeze, "string Object, int status", "Immobilize the given simulated object.")
{
	plKey key = FindSceneObjectByName(params[0], nil, nil);

	if(key)
	{
		int status = params[1];

		plFreezeMsg *m = TRACKED_NEW plFreezeMsg(nil, key, nil, status);

		plgDispatch::MsgSend(m);
	}
}

#include "../plHavok1/plHKCollision.h"

PF_CONSOLE_CMD( Physics, ToggleShowImpacts, "", "Shows the names of impacting physicals on screen.")
{
	plHKCollision::ToggleDisplayImpacts();
}

PF_CONSOLE_CMD( Physics, DumpRejectedBroadphase, "", "")
{
	plSimulationMgr::GetInstance()->DumpRejectedBroadPhase(true);
}

extern int gPhysicsAnimatedOptimize;
PF_CONSOLE_CMD( Physics, OptimizeAnimatedPhysicals, "int enable", "if true then dont eval non moving physical animations")
{
	gPhysicsAnimatedOptimize = params[0];
}

PF_CONSOLE_CMD( Physics, ClearLog, "", "Clear the physics log.")
{
	plSimulationMgr::ClearLog();
}
*/
#include "plPhysical/plPhysicalSDLModifier.h"

PF_CONSOLE_CMD(Physics, LogSDL, "int level", "Turn logging of physics SDL state on or off. 0=off 1=send/receive only 2=any attempt")
{
	int level = params[0];
	plPhysicalSDLModifier::SetLogLevel(level);
}

#include "plPhysX/plSimulationMgr.h"
PF_CONSOLE_CMD(Physics, ExtraProfile, "", "Toggle extra simulation profiling")
{
	char str[256];
	if (plSimulationMgr::fExtraProfile)
	{
		plSimulationMgr::fExtraProfile = false;
		sprintf(str, "Stop extra profiling");
	}
	else
	{
		plSimulationMgr::fExtraProfile = true;
		sprintf(str, "Start extra profiling");
	}
	PrintString( str );
}
PF_CONSOLE_CMD(Physics, SubworldOptimization, "", "Toggle subworld optimization")
{
	char str[256];
	if (plSimulationMgr::fSubworldOptimization)
	{
		plSimulationMgr::fSubworldOptimization = false;
		sprintf(str, "Stop subworld optimization");
	}
	else
	{
		plSimulationMgr::fSubworldOptimization = true;
		sprintf(str, "Start subworld optimization");
	}
	PrintString( str );
}
PF_CONSOLE_CMD(Physics, ClampingOnStep, "", "Toggle whether to clamp the step size on advance")
{
	char str[256];
	if (plSimulationMgr::fDoClampingOnStep)
	{
		plSimulationMgr::fDoClampingOnStep = false;
		sprintf(str, "Stop clamping the step size");
	}
	else
	{
		plSimulationMgr::fDoClampingOnStep = true;
		sprintf(str, "Start clamping the step size");
	}
	PrintString( str );
}

PF_CONSOLE_CMD(Physics, 
			   ShowControllerDebugDisplay,
			   "", 
			   "Toggle the physics controller debug display")
{
	plPXPhysicalControllerCore::fDebugDisplay = !plPXPhysicalControllerCore::fDebugDisplay;
}
PF_CONSOLE_CMD(Physics, 
			   ListAwakeActors,
			   "", 
			   "Toggles displaying the list of awake actors")
{
	plSimulationMgr::fDisplayAwakeActors= !plSimulationMgr::fDisplayAwakeActors;
}

/*
PF_CONSOLE_CMD( Physics, PlayPhysicsSounds, "bool b", "Turn physics sounds on/off.")
{
	bool b = params[0];
	plHKCollision::TogglePhysicsSounds(b);
}
*/
#endif // LIMIT_CONSOLE_COMMANDS


//////////////////////////////////////////////////////////////
// Mouse controls
//////////////////////////////////////////////////////////////


PF_CONSOLE_GROUP( Mouse )

PF_CONSOLE_CMD( Mouse, Invert, nil, "invert the mouse")
{
	plMouseDevice::SetInverted(true);
}

PF_CONSOLE_CMD( Mouse, UnInvert, nil, "un-invert the mouse")
{
	plMouseDevice::SetInverted(false);
}

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( Mouse, SetDeadZone, "float zone", "Sets the dead zone for the mouse - range is from 0.0 to 1.0")
{
	hsScalar f = params[0];
}

PF_CONSOLE_CMD( Mouse, Enable, nil, "Enable mouse input")
{
//	plCommandInterfaceModifier::GetInstance()->EnableMouseInput();
}
PF_CONSOLE_CMD( Mouse, Disable, nil, "Disable mouse input")
{
//	plCommandInterfaceModifier::GetInstance()->DisableMouseInput();
}

PF_CONSOLE_CMD( Mouse, SetFadeDelay, "float delayInSecs", "Set how long the cursor has to not move before it fades out" )
{
	if( plAvatarInputInterface::GetInstance() != nil )
		plAvatarInputInterface::GetInstance()->SetCursorFadeDelay( params[ 0 ] );
}

PF_CONSOLE_CMD( Mouse, Hide, nil, "hide mouse cursor")
{
	plMouseDevice::HideCursor(true);
}

PF_CONSOLE_CMD( Mouse, Show, nil, "hide mouse cursor")
{
	plMouseDevice::ShowCursor(true);
}

/*PF_CONSOLE_CMD( Mouse, SetScale, "float scale", "Sets the mouse scaling factor (sensitivity)" )
{
	plInputManager::GetInstance()->SetMouseScale( params[ 0 ] );
	PrintStringF( PrintString, "Mouse scale factor set to %4.2f", params[ 0 ] );
}
*/

PF_CONSOLE_CMD( Mouse, ForceHide, "bool force", "Forces the mouse to be hidden (or doesn't)" )
{
	plInputInterfaceMgr::GetInstance()->ForceCursorHidden( (bool)params[ 0 ] );
	PrintStringF( PrintString, "Mouse cursor %s", params[ 0 ] ? "forced to be hidden" : "back to normal" );
}

#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////////////////////
//// Age Group Commands //////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( Age )

PF_CONSOLE_CMD(Age, ShowSDL, "", "Prints the age SDL values")
{
	plStateDataRecord * rec = NEWZERO(plStateDataRecord);
	if (!VaultAgeGetAgeSDL(rec)) {
		PrintString("Age SDL not found");
		DEL(rec);
		return;
	}
	
	char line[2048];

	plStatusLog::AddLineS("ShowSDL.log", "-----------------------------------");
	for (unsigned i = 0; i < rec->GetNumVars(); ++i) {
		plStateVariable * var = rec->GetVar(i);
		if (plSimpleStateVariable * simple = var->GetAsSimpleStateVar()) {
			const char * name = var->GetName();
			StrPrintf(line, arrsize(line), "%s=", name);
			for (unsigned j = 0; j < simple->GetCount(); ++j) {
				char * str = simple->GetAsString(j);
				StrPack(line, str, arrsize(line));
				StrPack(line, ",", arrsize(line));
				FREE(str);
			}
			PrintString(line);
			plStatusLog::AddLineS("ShowSDL.log", "%s", line);
		}
	}	
	
	DEL(rec);
}

PF_CONSOLE_CMD( Age, GetElapsedDays, "string agedefnfile", "Gets the elapsed days and fractions" )
{
	hsUNIXStream s;
	if (!s.Open(params[0]))
	{
		PrintString("Couldn't open age defn file!");
		return;
	}

	plAgeDescription age;
	age.Read(&s);
	
	char str[256];
	plUnifiedTime current;
	current.SetToUTC();
	sprintf(str,"ElapsedTime: %f Days",age.GetAgeElapsedDays(current));

	PrintString(str);
	s.Close();
}

PF_CONSOLE_CMD( Age, GetTimeOfDay, "string agedefnfile", "Gets the elapsed days and fractions" )
{
	hsUNIXStream s;
	if (!s.Open(params[0]))
	{
		PrintString("Couldn't open age defn file!");
		return;
	}

	plAgeDescription age;
	age.Read(&s);
	
	char str[256];
	plUnifiedTime current;
	current.SetToUTC();
	sprintf(str,"TimeOfDay: %f percent",age.GetAgeTimeOfDayPercent(current));

	PrintString(str);
	s.Close();
}

PF_CONSOLE_CMD( Age, SetSDLFloat, "string varName, float value, int index", "Set the value of an age global variable" )
{
	int index = (int)params[2];

	extern const plPythonSDLModifier *ExternFindAgePySDL();
	const plPythonSDLModifier *sdlMod = ExternFindAgePySDL();
	if (!sdlMod)
		return;

	plSimpleStateVariable *var = sdlMod->GetStateCache()->FindVar(params[0]);
	if (!var)
		return;

	float v;
	var->Get(&v, index);
	var->Set((float)params[1], index);
	// set the variable in the pythonSDL also
	((plPythonSDLModifier*)sdlMod)->SetItemFromSDLVar(var);
	// set it back to original so that its different
	plSynchedObject* p = plSynchedObject::ConvertNoRef(((plSDLModifier*)sdlMod)->GetStateOwnerKey()->GetObjectPtr());
	if (p)
		p->DirtySynchState(sdlMod->GetSDLName(),plSynchedObject::kSendImmediately|plSynchedObject::kSkipLocalOwnershipCheck|plSynchedObject::kForceFullSend);
}

PF_CONSOLE_CMD( Age, SetSDLInt, "string varName, int value, int index", "Set the value of an age global variable" )
{
	int index = (int)params[2];

	extern const plPythonSDLModifier *ExternFindAgePySDL();
	const plPythonSDLModifier *sdlMod = ExternFindAgePySDL();
	if (!sdlMod)
		return;

	plSimpleStateVariable *var = sdlMod->GetStateCache()->FindVar(params[0]);
	if (!var)
		return;

	int	v;
	var->Get(&v, index);
	var->Set((int)params[1], index);
	// set the variable in the pythonSDL also
	((plPythonSDLModifier*)sdlMod)->SetItemFromSDLVar(var);
	plSynchedObject* p = plSynchedObject::ConvertNoRef(((plSDLModifier*)sdlMod)->GetStateOwnerKey()->GetObjectPtr());
	if (p)
		p->DirtySynchState(sdlMod->GetSDLName(),plSynchedObject::kSendImmediately|plSynchedObject::kSkipLocalOwnershipCheck|plSynchedObject::kForceFullSend);
}

PF_CONSOLE_CMD( Age, SetSDLBool, "string varName, bool value, int index", "Set the value of an age global variable" )
{
	int index = (int)params[2];
	
	extern const plPythonSDLModifier *ExternFindAgePySDL();
	const plPythonSDLModifier *sdlMod = ExternFindAgePySDL();
	if (!sdlMod)
		return;

	plSimpleStateVariable *var = sdlMod->GetStateCache()->FindVar(params[0]);
	if (!var)
		return;

	bool v;
	var->Get(&v, index);
	var->Set((bool)params[1], index);
	// set the variable in the pythonSDL also
	((plPythonSDLModifier*)sdlMod)->SetItemFromSDLVar(var);
	plSynchedObject* p = plSynchedObject::ConvertNoRef(((plSDLModifier*)sdlMod)->GetStateOwnerKey()->GetObjectPtr());
	if (p)
		p->DirtySynchState(sdlMod->GetSDLName(),plSynchedObject::kSendImmediately|plSynchedObject::kSkipLocalOwnershipCheck|plSynchedObject::kForceFullSend);
}

#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////////////////////
//// Particle System Group Commands /////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( ParticleSystem ) // Defines a main command group

void UpdateParticleParam(char *objName, Int32 paramID, hsScalar value, void (*PrintString)(const char *))
{
	char str[256];
	plKey key = FindSceneObjectByName(objName, nil, str);
	PrintString(str);
	if (key == nil) return;

	plSceneObject* so = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if (so == nil) return;

	int i;
	for (i = so->GetNumModifiers() - 1; i >= 0; i--)
	{
		const plParticleSystem *sys = plParticleSystem::ConvertNoRef(so->GetModifier(i));
		if (sys != nil)
		{
			plgDispatch::MsgSend(TRACKED_NEW plParticleUpdateMsg(nil, sys->GetKey(), nil, paramID, value));
			PrintString("Particle system successfully updated.");
			return;
		}
	}
	PrintString("The scene object specified has no particle system.");
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetPPS,							// Function name
				"string objName, float value",	// Params
				"Set the particles-per-second generated" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamParticlesPerSecond, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetInitialPitchRange,			// Function name
				"string objName, float value",	// Params
				"Set the initial range of pitch of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamInitPitchRange, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetInitialYawRange,				// Function name
				"string objName, float value",	// Params
				"Set the initial range of yaw of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamInitYawRange, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetInitialVelocityMin,			// Function name
				"string objName, float value",	// Params
				"Set the minimum initial velocity of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamVelMin, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetInitialVelocityMax,		// Function name
				"string objName, float value",	// Params
				"Set the maximum initial velocity of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamVelMax, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetWidth,						// Function name
				"string objName, float value",	// Params
				"Set the width of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamXSize, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetHeight,						// Function name
				"string objName, float value",	// Params
				"Set the height of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamYSize, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetScaleMin,					// Function name
				"string objName, float value",	// Params
				"Set the minimum width/height scaling of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamScaleMin, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetScaleMax,					// Function name
				"string objName, float value",	// Params
				"Set the maximum width/height scaling of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamScaleMax, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetGeneratorLife,				// Function name
				"string objName, float value",	// Params
				"Set the remaining life of the particle generator" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamGenLife, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetParticleLifeMin,				// Function name
				"string objName, float value",	// Params
				"Set the minimum lifespan of generated particles (negative values make them immortal)" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamPartLifeMin, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,					// Group name
				SetParticleLifeMax,				// Function name
				"string objName, float value",	// Params
				"Set the max lifespan of generated particles" )	// Help string
{
	UpdateParticleParam(params[0], plParticleUpdateMsg::kParamPartLifeMax, params[1], PrintString);
}

PF_CONSOLE_CMD( ParticleSystem,
			   TransferParticlesToAvatar,
			   "string objName, int numParticles",
			   "Creates a system (if necessary) on the avatar, and transfers particles" )
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	if (key == nil) 
		return;
	
	plSceneObject* so = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if (so == nil) 
		return;
	
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
		(TRACKED_NEW plParticleTransferMsg(nil, avMod->GetKey(), 0, so->GetKey(), (int)params[1]))->Send();
}

PF_CONSOLE_CMD( ParticleSystem,
			   KillParticles,
			   "string objName, float timeLeft, float num, bool useAsPercentage",
			   "Flag some particles for death." )
{
	char str[256];
	plKey key = FindSceneObjectByName(params[0], nil, str);
	if (key == nil) 
		return;
	
	plSceneObject* so = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if (so == nil) 
		return;
	
	const plParticleSystem *sys = plParticleSystem::ConvertNoRef(so->GetModifierByType(plParticleSystem::Index()));
	if (sys != nil)
	{
		UInt8 flags = (params[3] ? plParticleKillMsg::kParticleKillPercentage : 0);
		(TRACKED_NEW plParticleKillMsg(nil, sys->GetKey(), 0, params[2], params[1], flags))->Send();
	}
}


PF_CONSOLE_SUBGROUP( ParticleSystem, Flock )

static plParticleFlockEffect *FindFlock(char *objName)
{
	char str[256];
	plKey key = FindSceneObjectByName(objName, nil, str);
	
	if (key == nil)
		return nil;
	
	plSceneObject *so = plSceneObject::ConvertNoRef(key->GetObjectPtr());
	if (so == nil) 
		return nil;
	
	const plParticleSystem *sys = plParticleSystem::ConvertNoRef(so->GetModifierByType(plParticleSystem::Index()));
	if (sys == nil)
		return nil;
	
	plParticleFlockEffect *flock = plParticleFlockEffect::ConvertNoRef(sys->GetEffect(plParticleFlockEffect::Index()));
	if (flock == nil)
		return nil;
	
	return flock;
}

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetFlockOffset,
			   "string objName, float x, float y, float z",
			   "Set the flock's goal to be an offset from its sceneObject")
{
	plParticleEffect *flock = FindFlock(params[0]);
	if (flock)
	{
		(TRACKED_NEW plParticleFlockMsg(nil, flock->GetKey(), 0, plParticleFlockMsg::kFlockCmdSetOffset, params[1], params[2], params[3]))->Send();
	}
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetDissentTarget,
			   "string objName, float x, float y, float z",
			   "Set the goal for particles that leave the flock")
{
	plParticleEffect *flock = FindFlock(params[0]);
	if (flock)
	{
		(TRACKED_NEW plParticleFlockMsg(nil, flock->GetKey(), 0, plParticleFlockMsg::kFlockCmdSetDissentPoint, params[1], params[2], params[3]))->Send();
	}
}

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetConformDistance,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetInfluenceAvgRadius(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetRepelDistance,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetInfluenceRepelRadius(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetGoalDistance,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetGoalRadius(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetFullChaseDistance,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetFullChaseRadius(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetConformStr,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetConformStr(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetRepelStr,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetRepelStr(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetGoalOrbitStr,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetGoalOrbitStr(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetGoalChaseStr,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetGoalChaseStr(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetMaxOrbitSpeed,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetMaxOrbitSpeed(params[1]);
	else
		PrintString("Can't find flock effect");
}	

PF_CONSOLE_CMD( ParticleSystem_Flock,
			   SetMaxChaseSpeed,
			   "string objName, float value",
			   "")
{
	plParticleFlockEffect *flock = FindFlock(params[0]);
	if (flock)
		flock->SetMaxChaseSpeed(params[1]);
	else
		PrintString("Can't find flock effect");
}	

#endif // LIMIT_CONSOLE_COMMANDS


//////////////////////////////////////////////////////////////////////////////
//// Animation Commands		//////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP( Animation ) // Defines a main command group

void SendAnimCmdMsg(char *objName, plMessage *msg)
{
	char str[256];
	plKey key = FindSceneObjectByName(objName, nil, str);
	if (key != nil)
	{
		msg->AddReceiver(key);
		plgDispatch::MsgSend(msg);
	}
	else // message wasn't sent
		delete msg;
}


PF_CONSOLE_CMD( Animation,							// Group name
				Start,								// Function name
				"string objName, string animName",	// Params
				"Start the animation" )				// Help string
{
	plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg();
	msg->SetCmd(plAnimCmdMsg::kContinue);
	msg->SetAnimName(nil);
	msg->SetBCastFlag(plMessage::kPropagateToModifiers);
	SendAnimCmdMsg(params[0], msg);
}

PF_CONSOLE_CMD( Animation,							// Group name
				Stop,								// Function name
				"string objName, string animName",	// Params
				"Stop the animation" )				// Help string
{
	plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg();
	msg->SetCmd(plAnimCmdMsg::kStop);
	msg->SetAnimName(nil);
	msg->SetBCastFlag(plMessage::kPropagateToModifiers);
	SendAnimCmdMsg(params[0], msg);
}

PF_CONSOLE_CMD( Animation,							// Group name
				SetBlend,							// Function name
				"string objName, string animName, float blend, float rate",	// Params
				"Set the animation's blend value and rate to change" )		// Help string
{
	plAGCmdMsg *msg = TRACKED_NEW plAGCmdMsg();
	msg->SetCmd(plAGCmdMsg::kSetBlend);
	msg->fBlend = params[2];
	msg->fBlendRate = params[3];
	msg->SetAnimName(params[1]);
	msg->SetBCastFlag(plMessage::kPropagateToModifiers);
	SendAnimCmdMsg(params[0], msg);
}

PF_CONSOLE_CMD( Animation,							// Group name
				SetAmp,								// Function name
				"string objName, string animName, float amp, float rate",	// Params
				"Set the amplitude of this animation and rate to change" )	// Help string
{
	plAGCmdMsg *msg = TRACKED_NEW plAGCmdMsg();
	msg->SetCmd(plAGCmdMsg::kSetAmp);
	msg->fAmp = params[2];
	msg->fAmpRate = params[3];
	msg->SetAnimName(params[1]);
	msg->SetBCastFlag(plMessage::kPropagateToModifiers);
	SendAnimCmdMsg(params[0], msg);
}

PF_CONSOLE_CMD( Animation,							// Group name
				SetSpeed,							// Function name
				"string objName, string animName, float speed, float rate",	// Params
				"Set the speed of this animation and rate to change" )		// Help string
{
	plAnimCmdMsg *msg = TRACKED_NEW plAnimCmdMsg();
	msg->SetCmd(plAnimCmdMsg::kSetSpeed);
	msg->fSpeed = params[2];
	msg->fSpeedChangeRate = params[3];
	msg->SetAnimName(params[1]);
	msg->SetBCastFlag(plMessage::kPropagateToModifiers);
	SendAnimCmdMsg(params[0], msg);
}

PF_CONSOLE_CMD( Animation,
			   AddDebugItems,
			   "string name",
			   "Add keys with the given name (substrings ok) to our report list" )
{
	plAnimDebugList *adl = plClient::GetInstance()->fAnimDebugList;
	if (adl) 
		adl->AddObjects(params[0]);
}

PF_CONSOLE_CMD( Animation,
			   RemoveDebugItems,
			   "string name",
			   "Remove keys with the given name (substrings ok) to our report list" )
{
	plAnimDebugList *adl = plClient::GetInstance()->fAnimDebugList;
	if (adl)
		adl->RemoveObjects(params[0]);
}

PF_CONSOLE_CMD( Animation,
			   ShowDebugTimes,
			   "",
			   "Toggle the view of our debug list." )
{
	plAnimDebugList *adl = plClient::GetInstance()->fAnimDebugList;
	if (adl)
		adl->fEnabled = !adl->fEnabled;
}

PF_CONSOLE_CMD( Animation,
			   ToggleDelayedTransforms,
			   "",
			   "Toggle the possibility of delayed transform evaluation." )
{
	hsBool enabled = !plCoordinateInterface::GetDelayedTransformsEnabled();
	plCoordinateInterface::SetDelayedTransformsEnabled(enabled);

	char buff[256];
	sprintf(buff, "Potential delay of transform eval is now %s", (enabled ? "ENABLED" : "DISABLED"));
	PrintString(buff);
}

#endif // LIMIT_CONSOLE_COMMANDS

////////////////////////////////////////////////////////////////////////
// Clothing Commands
////////////////////////////////////////////////////////////////////////
#ifndef LIMIT_CONSOLE_COMMANDS

#include "plAvatar/plArmatureMod.h"
#include "plAvatar/plAvatarClothing.h"
#include "plAvatar/plClothingLayout.h"
#include "pfMessage/plClothingMsg.h"

PF_CONSOLE_GROUP( Clothing ) // Defines a main command group

PF_CONSOLE_CMD( Clothing,							// Group name
				AddItemToCloset,					// Function name
				"string itemName, float r, float g, float b, float r2, float g2, float b2",	// Params
				"Add a clothing item to your closet" )		// Help string
{
	hsTArray<plClosetItem> items;
	items.SetCount(1);
	items[0].fItem = plClothingMgr::GetClothingMgr()->FindItemByName(params[0]);
	items[0].fOptions.fTint1.Set(params[1], params[2], params[3], 1.f);
	items[0].fOptions.fTint2.Set(params[4], params[5], params[6], 1.f);

	plClothingMgr::GetClothingMgr()->AddItemsToCloset(items);
}

PF_CONSOLE_CMD( Clothing,							// Group name
				WearItem,							// Function name
				"string itemName",					// Params
				"Has your avatar wear the item of clothing specified" )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(params[0]);

	if (avMod && item)
	{
		avMod->GetClothingOutfit()->AddItem(item);
	}
}

PF_CONSOLE_CMD( Clothing,							// Group name
				RemoveItem,							// Function name
				"string itemName",					// Params
				"Has your avatar remove the item of clothing specified" )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(params[0]);
	
	if (avMod && item)
	{
		avMod->GetClothingOutfit()->RemoveItem(item);
	}
}

PF_CONSOLE_CMD( Clothing,							// Group name
				TintItem,							// Function name
				"string itemName, float red, float green, float blue, int layer",	// Params
				"Change the color of an item of clothing you're wearing" )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	plClothingItem *item = plClothingMgr::GetClothingMgr()->FindItemByName(params[0]);
	UInt8 layer;
	if ((int)params[4] == 2)
		layer = plClothingElement::kLayerTint2;
	else
		layer = plClothingElement::kLayerTint1;
	
	if (avMod && item)
	{
		avMod->GetClothingOutfit()->TintItem(item, params[1], params[2], params[3], true, true, true, true, layer);
	}
}

PF_CONSOLE_CMD( Clothing,							// Group name
				TintSkin,							// Function name
				"float red, float green, float blue",					// Params
				"Change your avatar's skin color" )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
	{
		avMod->GetClothingOutfit()->TintSkin(params[0], params[1], params[2]);
	}
}

PF_CONSOLE_CMD( Clothing,							// Group name
				AgeSkin,							// Function name
				"float age",					// Params
				"Blend (0 to 1) between young and old skin." )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
	{
		avMod->GetClothingOutfit()->SetAge(params[0]);
	}
}

PF_CONSOLE_CMD( Clothing,							// Group name
			   BlendSkin,							// Function name
			   "float blend, int layer",					// Params
			   "Set the blend (0 to 1) for a specific skin layer (1 to 6)." )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
	{
		avMod->GetClothingOutfit()->SetSkinBlend(params[0], (int)params[1] + plClothingElement::kLayerSkinBlend1 - 1);
	}
}

PF_CONSOLE_CMD( Clothing,
			   ChangeAvatar,
			   "string name",
			   "Switch your avatar to a different gender ('Male' / 'Female')" )
{
	plClothingMgr::ChangeAvatar(params[0]);
}

PF_CONSOLE_CMD( Clothing,							// Group name
			   SaveCustomizations,					// Function name
			   "",					// Params
			   "Save your customizations to the vault." )		// Help string
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
	{
		avMod->GetClothingOutfit()->WriteToVault();
	}
}

static plPlate *avatarTargetTexturePlate = nil;

PF_CONSOLE_CMD( Clothing,
			   ShowTargetTexture,
			   "...",
			   "Show/hide the texture we use for the local avatar on a square (for debugging)." )
{
	if (avatarTargetTexturePlate == nil)
	{
		plArmatureMod *avMod = nil;
		if (numParams > 0)
			avMod = plAvatarMgr::GetInstance()->FindAvatarByPlayerID((int)params[0]);
		else
			avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();			
		if (avMod)
		{
			plPlateManager::Instance().CreatePlate( &avatarTargetTexturePlate );
			avatarTargetTexturePlate->SetMaterial(avMod->GetClothingOutfit()->fMaterial);
			avatarTargetTexturePlate->SetPosition(0,0);
			avatarTargetTexturePlate->SetSize(1.9, 1.9);
			avatarTargetTexturePlate->SetVisible(true);
		}
	}
	else
	{
		plPlateManager::Instance().DestroyPlate(avatarTargetTexturePlate);
	}
}

PF_CONSOLE_CMD( Clothing,
			   WearMaintainerOutfit,
			   "",
			   "Wear the Maintainer outfit" )
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
	{
		avMod->GetClothingOutfit()->WearMaintainerOutfit();
	}
}

PF_CONSOLE_CMD( Clothing,
			   RemoveMaintainerOutfit,
			   "",
			   "Return to your normal outfit" )
{
	plArmatureMod *avMod = plAvatarMgr::GetInstance()->GetLocalAvatar();	
	if (avMod)
	{
		avMod->GetClothingOutfit()->RemoveMaintainerOutfit();
	}
}
	
#endif // LIMIT_CONSOLE_COMMANDS

//////////////////////////////////////////////////////////////////////////////
//// KI Commands /////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////

PF_CONSOLE_GROUP( KI ) // Defines a main command group


#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_CMD( KI,							// Group name
				UpgradeLevel,					// Function name
				"int level",				// Params
				"Upgrade KI to new level." )	// Help string
{
	// create the mesage to send
	pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kUpgradeKILevel );

	msg->SetIntValue((int) params[0]);

	// send it off
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_CMD( KI,							// Group name
				DowngradeLevel,				// Function name
				"int level",				// Params
				"Downgrade KI level to next lower level." )	// Help string
{
	// create the mesage to send
	pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kDowngradeKILevel );

	msg->SetIntValue((int) params[0]);

	// send it off
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_CMD( KI,								// Group name
				AllOfThePower,					// Function name
				"",								// Params
				"All the phased functionality turned on." )	// Help string
{
	// create the mesage to send
	pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kKIPhasedAllOn );

	// send it off
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_CMD( KI,								// Group name
				NoneOfThePower,					// Function name
				"",								// Params
				"All the phased functionality turned off." )	// Help string
{
	// create the mesage to send
	pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kKIPhasedAllOff );

	// send it off
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_CMD( KI,								// Group name
				AddJournal,						// Function name
				"",								// Params
				"Add the journal to the Blackbar." ) // Help string
{
	// create the message to send
	pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kAddJournalBook );

	// send if off
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_CMD( KI,								// Group name
				RemoveJournal,					// Function name
				"",								// Params
				"Removes the journal from the Blackbar." ) // Help string
{
	// create the message to send
	pfKIMsg *msg = TRACKED_NEW pfKIMsg( pfKIMsg::kRemoveJournalBook );

	// send if off
	plgDispatch::MsgSend( msg );
}

#endif // LIMIT_CONSOLE_COMMANDS

////////////////////////////////////////////////////////////////////////
// Execute a Python file command
////////////////////////////////////////////////////////////////////////

PF_CONSOLE_GROUP( Python ) // Defines a main command group

PF_CONSOLE_CMD( Python,							// Group name
				RunFile,							// Function name
				"string filename",					// Params
				"Run the specified Python file program" )		// Help string
{
	// now evaluate this mess they made
	PyObject* mymod = PythonInterface::FindModule("__main__");
	// make sure the filename doesn't have the .py extension (import doesn't need it)
	char importname[200];
	int i;
	for (i=0; i<199; i++ )
	{
		char ch = ((const char*)params[0])[i];
		// if we are at the end of the string or at a dot, truncate here
		if ( ch == '.' || ch == 0 )
			break;
		else
			importname[i] = ((const char*)params[0])[i];
	}
	importname[i] = 0;

	// create the line to execute the file
	char runline[256];
	sprintf(runline,"import %s", importname);
	PythonInterface::RunString(runline,mymod);
	std::string output;
	// get the messages
	PythonInterface::getOutputAndReset(&output);
	PrintString(output.c_str());
}


#include "pfPython/cyMisc.h"

PF_CONSOLE_CMD( Python,							// Group name
				SetLoggingLevel,				// Function name
				"int level",					// Params
				"Set the python logging print level (1-4)" )		// Help string
{
	cyMisc::SetPythonLoggingLevel((int) params[0]);
}

#ifndef LIMIT_CONSOLE_COMMANDS
#ifdef HAVE_CYPYTHONIDE
PF_CONSOLE_CMD( Python,
			    UsePythonDebugger,
				"",
				"Enables the python debugger (only works in an .ini file)" )
{
	PythonInterface::UsePythonDebugger(true);
}
#endif


#include "pfMessage/pfBackdoorMsg.h"
PF_CONSOLE_CMD( Python,
			    Backdoor,
				"string target, ...",	// Params
				"Send a debug trigger to a python file modifier" )
{
	const char* extraParms = "";
	if (numParams > 1)
		extraParms = params[1];
	pfBackdoorMsg *msg = TRACKED_NEW pfBackdoorMsg( params[0],extraParms );
	// send it off
	plgDispatch::MsgSend( msg );
}

PF_CONSOLE_CMD( Python,
			    Cheat,
				"string functions, ...",	// Params
				"Run a cheat command" )
{
	const char* extraParms = "";
	if (numParams > 1)
		extraParms = params[1];
	// now evaluate this mess they made
	PyObject* mymod = PythonInterface::FindModule("__main__");

	// create the line to execute the file
	char runline[256];
	sprintf(runline,"import xCheat;xCheat.%s('%s')", (const char*)params[0],extraParms);
	PythonInterface::RunString(runline,mymod);
	std::string output;
	// get the messages
	PythonInterface::getOutputAndReset(&output);
	PrintString(output.c_str());
}

PF_CONSOLE_CMD( Python,
			    ListCheats,
				"",					// Params - None
				"Show a list of python commands" )
{
	// now evaluate this mess they made
	PyObject* mymod = PythonInterface::FindModule("__main__");

	PythonInterface::RunString("import xCheat;xc=[x for x in dir(xCheat) if not x.startswith('_')]\nfor i in range((len(xc)/4)+1): print xc[i*4:(i*4)+4]\n",mymod);
	std::string output;
	// get the messages
	PythonInterface::getOutputAndReset(&output);
	PrintString(output.c_str());
}

#endif // LIMIT_CONSOLE_COMMANDS



#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP(Demo)

PF_CONSOLE_CMD(Demo, RecordNet, "string recType, string recName", "Records a network demo (must be set in an ini file)")
{
	if (plNetClientMgr::GetInstance()->RecordMsgs(params[0],params[1]))
		PrintString("Recording Started");
	else
		PrintString("Recording Failed");
}

PF_CONSOLE_CMD(Demo, PlayNet, "string recName", "Plays back a network demo")
{
	if (plNetClientMgr::GetInstance()->PlaybackMsgs(params[0]))
		PrintString("Playback Started");
	else
		PrintString("Playback Failed");
}
/*
#include "../plHavok1/plVehicleModifier.h"

PF_CONSOLE_GROUP(Vehicle)

PF_CONSOLE_CMD(Vehicle, ShowStats, "", "")
{
	plVehicleModifier::ShowStats();
}

PF_CONSOLE_CMD(Vehicle, SetSuspensionStrength, "float val", "10-100")
{
	float val = params[0];
	plVehicleModifier::SetSuspensionStrength(val);
}

PF_CONSOLE_CMD(Vehicle, SetSuspensionDamping, "float val", "1-8")
{
	float val = params[0];
	plVehicleModifier::SetSuspensionDamping(val);
}

PF_CONSOLE_CMD(Vehicle, SetMass, "float val", "")
{
	float val = params[0];
	plVehicleModifier::SetMass(val);
}

PF_CONSOLE_CMD(Vehicle, LoadSettings, "", "")
{
	plVehicleModifier::ReadKeyValues();
	PrintString("Loaded vehicle settings");
}

PF_CONSOLE_CMD(Vehicle, SaveSettings, "", "")
{
	plVehicleModifier::WriteKeyValues();
	PrintString("Saved vehicle settings");
}
*/
#endif // LIMIT_CONSOLE_COMMANDS


#ifndef LIMIT_CONSOLE_COMMANDS

PF_CONSOLE_GROUP(Vault)

PF_CONSOLE_CMD(Vault, Dump, "", "Prints the vault structure of current player and age to the nearest log file")
{
	VaultDump(L"Player", NetCommGetPlayer()->playerInt);
	VaultDump(L"Age", NetCommGetAge()->ageVaultId);
}

#endif

//////////////////////////////////////////////////////////////////////////////
// End.