Battlefield Play4Free Console Commands

void adClickManager.openURL( std::string );
void adClickManager.queueURL( std::string );
void admin.addAccountIdToBanList( S64, std::string );
void admin.addAccountIdToBanListForced( S64, std::string );
void admin.addKeyToBanList( S64, std::string );
std::string admin.banPlayer( std::string, std::string );
void admin.clearBanList( void );
int admin.currentLevel( void );
std::string admin.kickPlayer( std::string );
std::string admin.kickPlayerDelayed( std::string );
std::string admin.listBannedAccountIds( void );
std::string admin.listBannedKeys( void );
std::string admin.listPlayers( void );
int admin.nextLevel( int );
void admin.removeAccountIdFromBanList( S64 );
void admin.removeKeyFromBanList( S64 );
void admin.restartMap( void );
void admin.runLevel( std::string, std::string, int );
void admin.runNextLevel( void );
bool admin.switchTeamsForPlayer( int );
int admin.toggleSocketCompression( int );
bool animationBundle.abruptPlayback( bool );
void animationBundle.addAnimation( std::string );
void animationBundle.addEvent( std::string );
std::string animationBundle.attachObject( std::string );
bool animationBundle.blockInput( bool );
std::string animationBundle.fadeInSpeedKeyPoints( std::string );
float animationBundle.fadeInTime( float );
std::string animationBundle.fadeOutSpeedKeyPoints( std::string );
float animationBundle.fadeOutTime( float );
std::string animationBundle.forceStopPoints( std::string );
float animationBundle.getAnimationLength( std::string );
float animationBundle.getAnimationStartTime( std::string );
float animationBundle.getEventStartTime( std::string );
bool animationBundle.hideWeapon( bool );
bool animationBundle.hideWeaponWhenFading( bool );
bool animationBundle.isLooping( bool );
bool animationBundle.jumpToLastAnimationAtStop( bool );
float animationBundle.length( float );
std::string animationBundle.listAnimations( void );
std::string animationBundle.listEvents( void );
bool animationBundle.playBackward( bool );
bool animationBundle.playForever( bool );
dice::anim::SoundType animationBundle.playSound( dice::anim::SoundType );
void animationBundle.removeAnimation( std::string );
void animationBundle.removeEvent( std::string );
void animationBundle.setAnimationLength( std::string, float );
void animationBundle.setAnimationStartTime( std::string, float );
void animationBundle.setEventStartTime( std::string, float );
std::string animationBundle.speedKeyPoints( std::string );
float animationBundle.stickAround( float );
bool animationBundle.useNewSystem( bool );
bool animationBundle.useSpeedAsTime( bool );
float animationManager.fadeInTime( float );
int animationManager.ignoreMotherOrientation( int );
float animationManager.length( float );
bool animationManager.looping( bool );
float animationManager.noiceAmplitude( float );
int animationManager.noiceFreq( int );
float animationManager.originalLength( void );
std::string animationSystem.active( std::string );
std::string animationSystem.activeAnimation( std::string );
std::string animationSystem.activeBundle( std::string );
std::string animationSystem.activeTrigger( std::string );
std::string animationSystem.activeValueHolder( std::string );
Vec3 animationSystem.cameraSpring.amplitude( Vec3 );
Vec3 animationSystem.cameraSpring.fire( Vec3 );
Vec3 animationSystem.cameraSpring.hit( Vec3 );
Vec2 animationSystem.cameraSpring.look( Vec2 );
Vec3 animationSystem.cameraSpring.move( Vec3 );
Vec3 animationSystem.cameraSpring.stiffness( Vec3 );
bool animationSystem.cameraSpring.use( bool );
Vec3 animationSystem.cameraSpring.zoomDamping( Vec3 );
void animationSystem.create( std::string );
anim::BoneAnimation* animationSystem.createAnimation( std::string );
anim::Bundle* animationSystem.createBundle( std::string );
anim::Trigger* animationSystem.createTrigger( std::string, std::string );
void animationSystem.createValueHolder( std::string );
void animationSystem.deleteActiveBundle( void );
void animationSystem.deleteActiveTrigger( void );
void animationSystem.hide( void );
std::string animationSystem.list( void );
std::string animationSystem.listAnimations( void );
std::string animationSystem.listBundles( void );
std::string animationSystem.listTriggers( void );
std::string AnimationSystem.listTriggerTypes( void );
std::string animationSystem.listValueHolders( void );
float animationSystem.playbackModifier( float );
void animationSystem.reloadScript( void );
void animationSystem.save( std::string );
void animationSystem.saveActive( void );
void animationSystem.saveValueHolders( void );
int animationSystem.toggleIgnoreMother( int );
void animationTrigger.addBundle( std::string );
void animationTrigger.addChild( std::string );
void animationTrigger.clearValueHolder( void );
uint animationTrigger.count( uint );
float animationTrigger.fadeInTime( float );
std::string animationTrigger.getTypeName( void );
Vec2 animationTrigger.idleTime( Vec2 );
std::string animationTrigger.listBundles( void );
int animationTrigger.message( int );
int animationTrigger.overridePrio( int );
void animationTrigger.removeBundle( std::string );
void animationTrigger.removeChild( std::string );
uint animationTrigger.switchId( uint );
bool animationTrigger.triggerOnAcceleration( bool );
bool animationTrigger.useDirection( bool );
std::string animationTrigger.valueHolder( std::string );
Vec2 animationValueHolder.clamp( Vec2 );
std::string animationValueHolder.getFilename( void );
float animationValueHolder.max( float );
float animationValueHolder.min( float );
float animationValueHolder.normal( float );
unsigned int animationValueHolder.passOnMessage( unsigned int );
unsigned int animationValueHolder.stopOnMessage( unsigned int );
void animationValueHolder.values( float, float, float );
bool audioSettings.alwaysAllowSystemOpenAL( bool );
float audioSettings.effectsVolume( float );
bool audioSettings.enableEAX( bool );
bool audioSettings.englishOnlyVoices( bool );
int audioSettings.forceNumberOfVoices( int );
float audioSettings.helpVoiceVolume( float );
float audioSettings.musicVolume( float );
std::string audioSettings.provider( std::string );
std::string audioSettings.soundQuality( std::string );
void backendClient.addDesiredCommunityName( std::string );
void backendClient.clearDesiredCommunityNameList( void );
void backend.setAutoLoginTimeout( float );
void bf2Engine.playMovie( std::string, int );
bool cameraInterface.selectOrder( std::string );
void cameraInterface.setStringMap( std::string, std::string, std::string );
void cameraInterface.setVariableMap( std::string, std::string, std::string );
void chat.sayAll( std::string );
void chat.sayTeam( std::string );
void collisionManager.attachActiveToObjectInFocus( void );
void collisionManager.buildDebugCollisionMeshes( void );
void collisionManager.create( std::string );
void collisionManager.createTemplate( std::string );
void collisionManager.drawBoundingBoxes( bool );
void collisionManager.drawMeshes( bool );
void collisionManager.drawPivots( bool );
void collisionManager.drawPrimitives( bool );
void collisionManager.drawSoldierCollision( bool );
void collisionManager.drawSoldierMesh( bool );
void collisionManager.getNameOfObjectInFocus( void );
void collisionManager.identityRotateObjectInFocus( void );
void collisionManager.rotateObjectInFocusAroundAxis( uint, float );
void collisionManager.rotateObjectInFocusAroundVector( Vec3, float );
void collisionManager.setActiveLod( int );
bool collisionManager.useDeferredLoading( bool );
void combatArea.active( std::string );
void combatArea.addAreaPoint( Vec2 );
Vec3ColorFloat combatArea.color( Vec3ColorFloat );
void combatArea.create( std::string );
void combatArea.deleteActiveCombatArea( void );
std::string combatArea.getActiveCombatAreaName( void );
int combatArea.layer( int );
float combatAreaManager.damage( float );
float combatAreaManager.timeAllowedOutside( float );
void combatAreaManager.use( bool );
Vec2 combatArea.max( Vec2 );
Vec2 combatArea.min( Vec2 );
int combatArea.rushStage( int );
int combatArea.team( int );
bool combatArea.usedByPathFinding( bool );
int combatArea.vehicles( int );
bool Console.allowMultipleFileLoad( bool );
std::string Console.dumpAllConsoleMethods( std::string );
std::string Console.getActiveMethods( std::string );
std::string Console.getArgumentTypes( std::string, std::string );
std::string Console.getCategory( std::string, std::string );
std::string Console.getDelta( std::string, std::string );
std::string Console.getEnumName( std::string, std::string, int );
std::string Console.getRange( std::string, std::string );
std::string Console.getReturnType( std::string, std::string );
std::string Console.getTypeDescription( std::string, std::string );
std::string Console.hasBundledType( std::string, std::string );
std::string Console.hasRange( std::string, std::string );
std::string Console.isDynamic( std::string, std::string );
std::string Console.isSetGet( std::string, std::string );
bool Console.useRelativePaths( bool );
void controlMap.addAxisToAxisMapping( int, InputDeviceFlags, InputDeviceAxes, bool, bool );
void controlMap.addAxisToTriggerMapping( int, int, InputDeviceFlags, InputDeviceAxes, bool );
void controlMap.addButtonAndKeyToAxisMapping( int, InputDeviceFlags, InputDeviceButtons, InputDeviceFlags, InputDeviceKeys, bool );
void controlMap.addButtonsToAxisMapping( int, InputDeviceFlags, InputDeviceButtons, InputDeviceButtons, bool );
void controlMap.addButtonToTriggerMapping( int, InputDeviceFlags, InputDeviceButtons, float, bool );
void controlMap.addKeyAndButtonToAxisMapping( int, InputDeviceFlags, InputDeviceKeys, InputDeviceFlags, InputDeviceButtons, bool );
void controlMap.addKeysToAxisMapping( int, InputDeviceFlags, InputDeviceKeys, InputDeviceKeys, bool );
void controlMap.AddKeyToTriggerMapping( int, InputDeviceFlags, InputDeviceKeys, float, bool );
void controlMap.create( std::string );
bool controlMap.InvertMouse( bool );
float controlMap.keyboardSensitivity( float );
float controlMap.mouseSensitivity( float );
void controlMap.setActive( std::string );
void controlMap.setPitchFactor( float );
void controlMap.setYawFactor( float );
void customization.addGeomDependency( std::string );
void customization.addInputMesh( std::string );
void customization.addInputSlot( int );
void customization.addRemoveGroup( void );
void customization.addReplacementGroup( void );
void customization.addSlotDependency( int );
void customization.createMeshRule( std::string );
void customization.finalizeMeshRules( void );
void customization.setFrontendCamDistDefault( float );
void customization.setFrontendFov( float );
void customization.setReplacementMesh( std::string );
float decalManager.decalGeomClipAngle( float );
float decalManager.decalNormalOffset( float );
bool decalManager.drawStats( bool );
float decalManager.fadeDistance( float );
float decalManager.fadeOutAtPercentageOfTimeToLive( float );
float decalManager.startFadePercentageOfFadeDistancel( float );
float decalManager.timeToLive( float );
void demo.adjustDemoFov( float );
bool demoCameraInterface.selectOrder( std::string );
void demoCameraInterface.setStringMap( std::string, std::string, std::string );
void demoCameraInterface.setVariableMap( std::string, std::string, std::string );
void demo.recordDemo( std::string );
bool demoRecorderInterface.selectOrder( std::string );
void demoRecorderInterface.setStringMap( std::string, std::string, std::string );
void demoRecorderInterface.setVariableMap( std::string, std::string, std::string );
void demo.restartDemo( void );
void demo.shutdownDemo( void );
void demo.stopRecording( void );
void demo.toggleCameraDemo( void );
void demo.toggleDemoPauseOrPlay( void );
void demo.togglePlayerDemo( bool );
bool emoteInterface.mouseOver( int );
bool emoteInterface.selectOrder( std::string );
void emoteInterface.setStringMap( std::string, std::string, std::string );
void emoteInterface.setVariableMap( std::string, std::string, std::string );
void emoteInterface.useEmote( int );
void envmapManager.generateEnvMaps( int );
void envmapManager.loadEMIFile( std::string );
void envmapManager.save( void );
void fileManager.mountArchive( std::string, std::string );
void fileManager.mountArchive( std::string, std::string, bool );
void freeCam.changeTeam( int );
void freeCam.toggleCamera( void );
void freeCam.togglePlayer( bool );
void Game.crash( void );
void Game.crashSTL( void );
std::string game.getAccountNameFromNucleusId( __int64 );
std::string game.getVipList( void );
int game.lockFps( int );
void gameLogic.addWeaponAttachmentLocalPlayer( std::string, uint );
void gameLogic.addWeaponAttachmentToPlayers( int, std::string, uint );
void gameLogic.addWeaponAttachmentToPlayersUsingNameVariations( int, std::string, uint );
bool gameLogic.becomeSquadLeader( bool );
void gameLogic.createObject( std::string );
float gameLogic.defaultTimeToNextAIWave( float );
bool gameLogic.enableVoHelp( bool );
int gameLogic.endOfRoundBaseCredits( int );
int gameLogic.endOfRoundWinCredits( int );
float gameLogic.extraUAVVehicleFlightHeight( float );
U32 gameLogic.getDefaultNumberOfTickets( U32 );
U32 gameLogic.getDefaultNumberOfTicketsEx( U32, U32 );
float gameLogic.getForceTakeableFlagAtTickets( void );
float gameLogic.getLowTicketWarningAtTickets( void );
float gameLogic.getMinSpawnTimeModifierAttackers( void );
float gameLogic.getMinSpawnTimeModifierDefenders( void );
U32 gameLogic.getNumberOfTickets( U32 );
Vec3 gameLogic.getOverHeadCamDirAtDeathForTeam( int );
Vec3 gameLogic.getOverHeadCamDirAtEndOfRoundLoseTeam( int );
Vec3 gameLogic.getOverHeadCamDirAtEndOfRoundWinTeam( int );
Vec3 gameLogic.getOverHeadCamPosAtDeathForTeam( int );
Vec3 gameLogic.getOverHeadCamPosAtEndOfRoundLoseTeam( int );
Vec3 gameLogic.getOverHeadCamPosAtEndOfRoundWinTeam( int );
int gameLogic.getRushAttackingTeam( void );
int gameLogic.getRushDestroyObjectives( void );
int gameLogic.getShowOverHeadCamWhenDeadAtTime( void );
float gameLogic.getSpawnTimeModifierAttackers( void );
float gameLogic.getSpawnTimeModifierDefenders( void );
float gameLogic.getSpawnWaveTime( void );
std::string gameLogic.getTeamLanguage( int );
std::string gameLogic.getTeamName( int );
float gameLogic.getTicketLossAtEndPerMin( void );
float gameLogic.getTicketLossPerMin( U32 );
float gameLogic.getTicketUpdateInterval( void );
bool gameLogic.getUseSpawnWaveAttackers( void );
bool gameLogic.getUseSpawnWaveDefenders( void );
U32 gameLogic.getVehiclePrioAndMax( U32, U32, U32 );
float gameLogic.mapSize( float );
float gameLogic.maximumLevelViewDistance( float );
void gameLogic.messages.addEmoteTrigger( std::string );
int gameLogic.messages.addHelpMessage( std::string, std::string );
int gameLogic.messages.addMessage( std::string );
int gameLogic.messages.addRadioFilter( std::string, std::string );
int gameLogic.messages.addRadioVoice( std::string, std::string, std::string, std::string, int );
void gameLogic.messages.setVolumes( float, float );
float gameLogic.orbitalBombardmentHeight( float );
void gameLogic.printActiveWeaponBoneIds( void );
void gameLogic.printLocalPlayerEquipment( void );
void gameLogic.printPlayerCamCoords( void );
bool gameLogic.remoteCommand( int, int, int, int, int );
void gameLogic.removeAllWeaponAttachmentsFromPlayers( int );
void gameLogic.removeAllWeaponAttachmentsLocalPlayer( void );
void gameLogic.removeWeaponAttachmentLocalPlayer( uint );
void gameLogic.reset( void );
float gameLogic.satelliteScanReloadTime( float );
void gameLogic.setBeforeSpawnCamera( Vec3, Vec3 );
void gameLogic.setDefaultNumberOfTickets( U32, U32 );
void gameLogic.setDefaultNumberOfTicketsEx( U32, U32, U32 );
void gameLogic.setForceTakeableFlagAtTickets( float );
void gameLogic.setKit( int, KitType, std::string, std::string, std::string );
void gameLogic.setLowTicketWarningAtTickets( float );
void gameLogic.setMinSpawnTimeModifierAttackers( float );
void gameLogic.setMinSpawnTimeModifierDefenders( float );
void gameLogic.setNumberOfTickets( U32, U32 );
void gameLogic.setOverheadCamAtDeath( int, Vec3, Vec3 );
void gameLogic.setOverheadCamAtEndOfRoundLoseTeam( int, Vec3, Vec3 );
void gameLogic.setOverheadCamAtEndOfRoundWinTeam( int, Vec3, Vec3 );
void gameLogic.setOverrideTickets( U32, U32, U32 );
void gameLogic.setRushAttackingTeam( int );
void gameLogic.setRushDestroyObjectives( int );
void gameLogic.setRushKeepRemainingTicketsNextStage( int );
void gameLogic.setRushStageInfo( int, int, int, int );
void gameLogic.setShowOverHeadCamWhenDeadAtTime( int );
void gameLogic.setSpawnTimeModifierAttackers( float );
void gameLogic.setSpawnTimeModifierDefenders( float );
void gameLogic.setSpawnWaveTime( float );
void gameLogic.setTeamFlag( int, std::string );
void gameLogic.setTeamLanguage( int, std::string );
void gameLogic.setTeamName( int, std::string );
void gameLogic.setTicketLossAtEndPerMin( float );
void gameLogic.setTicketLossPerMin( U32, float );
void gameLogic.setTicketUpdateInterval( float );
void gameLogic.setUseSpawnWaveAttackers( bool );
void gameLogic.setUseSpawnWaveDefenders( bool );
void gameLogic.setValorPointsAwarded( int, int );
void gameLogic.setVehiclePrioAndMax( U32, U32, world::VehicleType, U32 );
bool gameLogic.spawnAtCameraPosition( bool );
float gameLogic.spawnObjectSpeed( float );
float gameLogic.supplyDropHeight( float );
float gameLogic.supplyDropNumSecsToLive( float );
void gameLogic.togglePause( void );
float gameLogic.uavReloadTime( float );
bool gameLogic.useColdBreath( bool );
std::string game.personaSearchGetResult( void );
void game.personaSearchStart( std::string );
void Game.radioMessage( TargetChannel, std::string );
void game.sayAll( std::string );
void game.sayTeam( int, std::string );
void game.sayToPlayerWithId( int, std::string );
void game.sayToPlayerWithName( std::string, std::string );
void gameServerSettings.setAdminScript( std::string );
void gameServerSettings.setAllowNATNegotation( bool );
void gameServerSettings.setAutoBalanceTeam( bool );
void gameServerSettings.setAutoRecord( bool );
void gameServerSettings.setAutoRecordRounds( int );
void gameServerSettings.setBandwidthChoke( int );
void gameServerSettings.setCommunityLogoURL( std::string );
void gameServerSettings.setDemoDownloadURL( std::string );
void gameServerSettings.setDemoHook( std::string );
void gameServerSettings.setDemoIndexURL( std::string );
void gameServerSettings.setEndDelay( int );
void gameServerSettings.setGameMode( std::string );
void gameServerSettings.setInterfaceIP( std::string );
void gameServerSettings.setInternet( bool );
void gameServerSettings.setManDownTime( float );
void gameServerSettings.setMaxPlayers( int );
void gameServerSettings.setMinPlayersForVoting( int );
void gameServerSettings.setPassword( std::string );
void gameServerSettings.setPunishTeamKills( bool );
void gameServerSettings.setRanked( bool );
void gameServerSettings.setRoundsPerMap( int );
void gameServerSettings.setScoreLimit( int );
void gameServerSettings.setServerName( std::string );
void gameServerSettings.setSoldierFF( int );
void gameServerSettings.setSoldierSplashFF( int );
void gameServerSettings.setSpawnTime( float );
void gameServerSettings.setSponsorLogoURL( std::string );
void gameServerSettings.setSponsorText( std::string );
void gameServerSettings.setStartDelay( int );
void gameServerSettings.setSvPunkBuster( bool );
void gameServerSettings.setTeamRatio( float );
void gameServerSettings.setTicketRatio( int );
void gameServerSettings.setTimeBeforeRestartMap( float );
void gameServerSettings.setTimeLimit( int );
void gameServerSettings.setVehicleFF( int );
void gameServerSettings.setVehicleSplashFF( int );
void gameServerSettings.setVoteTime( int );
void game.setPersonaVipStatus( std::string, __int64, bool );
void game.setPlayerVipStatus( std::string, bool );
int game.simulationRate( int );
void generalSettings.setAutoReload( bool );
void generalSettings.setCameraShake( int );
void generalSettings.setChatMessagesFilter( int );
void generalSettings.setConnectionType( int );
void generalSettings.setHelpPopups( int );
void generalSettings.setHUDTransparency( float );
void generalSettings.setKillMessagesFilter( int );
void generalSettings.setMapIconAlphaTransparency( float );
void generalSettings.setMinimapRotate( bool );
void generalSettings.setMinimapTransparency( float );
void generalSettings.setOutOfVoting( bool );
void generalSettings.setPlayedVOHelp( std::string );
void generalSettings.setRadioMessagesFilter( int );
void generalSettings.setUseArrowHelp( bool );
void generalSettings.setUseToolTip( bool );
IGeometryTemplate* geometryTemplate.active( IGeometryTemplate* );
float geometryTemplate.boundingRadiusModifier( float );
std::string geometryTemplate.bumpTextureFileName( std::string );
bool geometryTemplate.compressVertexData( bool );
IGeometryTemplate* GeometryTemplate.create( std::string, std::string );
std::string geometryTemplate.diffuseTextureFileName( std::string );
bool geometryTemplate.doNotGenerateLightmaps( bool );
void geometryTemplate.dump( void );
void geometryTemplate.dumpInstances( void );
std::string geometryTemplate.FileName( std::string );
bool geometryTemplate.hasAdditiveAlpha( bool );
bool geometryTemplate.is1p( bool );
bool geometryTemplate.is1p( bool );
bool geometryTemplate.isSuperLowTerrain( bool );
bool geometryTemplate.isTitanExterior( bool );
bool geometryTemplate.isTitanInterior( bool );
hfe::CustomItemType geometryTemplate.itemType( hfe::CustomItemType );
hfe::CustomItemType geometryTemplate.itemType( hfe::CustomItemType );
float geometryTemplate.layerId( float );
bool geometryTemplate.lightmapOverride( bool );
uint geometryTemplate.maxSkip3pLods( uint );
uint geometryTemplate.maxSkipWreckLods( uint );
int geometryTemplate.maxTextureRepeat( int );
std::string geometryTemplate.name( void );
int geometryTemplate.nrOfAnimatedUVMatrix( int );
std::string GeometryTemplate.printInfo( bool );
void geometryTemplate.setColor( Vec3 );
void geometryTemplate.setCoordinate( Vec2 );
void geometryTemplate.setLightmapSizeAll( int, int, int );
void geometryTemplate.setMaterialParallaxHeightScale( int, int, int, float );
void geometryTemplate.setMaterialReflectionScale( int, int, int, float );
void geometryTemplate.setMeshName( std::string );
void geometryTemplate.setReplacementTexture( std::string, std::string );
void geometryTemplate.setSpecularStaticGloss( int, int, int, float );
void geometryTemplate.setSubGeometryLodDistance( int, int, float );
void geometryTemplate.setVisibleLodDistance( int, float );
Vec2 geometryTemplate.simpleUVTranslation( Vec2 );
int geometryTemplate.titanExteriorPartIndex( int );
bool geometryTemplate.useRadiusForShadowDepth( bool );
bool geometryTemplate.useRadiusForShadowSpatial( bool );
bool geometryTemplate.useRimEffect( bool );
void globalSettings.setDefaultUser( std::string );
void globalSettings.setEncryptedLogin( std::string );
void globalSettings.setLastOnlineUser( std::string );
void globalSettings.setNamePrefix( std::string );
void heightmapcluster.addHeightmap( std::string, int, int );
void heightmapcluster.create( std::string );
void heightmapcluster.debugCheckMaterials( void );
bool heightmapcluster.importSurroundingRawHeightMap( std::string );
void heightmapcluster.setClusterSize( int );
void heightmapcluster.setHeightmapSize( int );
void heightmapcluster.setSeaWaterLevel( float );
float heightmapcluster.simulatedWaterDepth( float );
bool heightmapcluster.simulateWater( bool );
void heightmapcluster.smoothEdges( int, float, float );
void heightmapcluster.stitchEdges( void );
void heightmap.loadHeightData( std::string );
void heightmap.loadMaterialData( std::string );
void heightmap.setBitResolution( int );
void heightmap.setMaterialScale( int );
void heightmap.setModified( bool );
void heightmap.setScale( Vec3 );
void heightmap.setSize( int, int );
Vec3 hemiMapManager.hemiConstantColor( Vec3 );
float hemiMapManager.hemiLerpBias( float );
void hemiMapManager.loadTitanHemiMap( std::string, Vec3, int );
bool hemiMapManager.makeHemiMap( unsigned long, std::string, Vec3, float );
bool hemiMapManager.setBaseHemiMap( std::string, Vec3, float );
bool hemiMapManager.useCurrentSetting( bool );
bool hudBuilder.addNodeAlphaShowEffect( void );
bool hudBuilder.addNodeBlendEffect( int, int );
bool hudBuilder.addNodeMoveShowEffect( float, int );
bool hudBuilder.addNodeVariableMoveShowEffect( std::string, std::string );
bool hudBuilder.addObjectMarkerNodeLockTextNode( std::string );
bool hudBuilder.addTransformListNode( std::string );
bool hudBuilder.createAnimationNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createBarNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createButtonNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createCompassNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createEditNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createHoverNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createListNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createMapNode( std::string, std::string );
bool hudBuilder.createMiniMapNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createMouseOverNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createObjectMarkerNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createObjectSelectionNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createOccupiedNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createPictureNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createSliderNode( std::string, std::string, float, float, float, float );
bool hudBuilder.createSplitNode( std::string, std::string );
bool hudBuilder.createTextNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createTileNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createTransformListNode( std::string, std::string, int, int, int, int );
int hudBuilder.createTransformNode( std::string, std::string, int, int, int, int );
bool hudBuilder.createWebViewNode( std::string, std::string, int, int, int, int );
bool hudBuilder.deleteNode( void );
bool hudBuilder.newLayer( void );
meme::Node* hudBuilder.searchNodes( std::string, std::string );
bool hudBuilder.setActiveObject( std::string, std::string );
void hudBuilder.setAlphaMask( std::string );
bool hudBuilder.setAnimationNodeFrames( int );
bool hudBuilder.setAnimationNodeLoopCounts( int );
bool hudBuilder.setAnimationNodeLooping( bool );
bool hudBuilder.setAnimationNodeRotation( int );
bool hudBuilder.setAnimationNodeSpeed( int );
bool hudBuilder.setAnimationNodeTexture( std::string );
bool hudBuilder.setAnimationNodeVariableTexture( std::string );
bool hudBuilder.setBarNodeAnim( int, int, int );
bool hudBuilder.setBarNodeBorder( int, int, int, int );
bool hudBuilder.setBarNodeEffect( int, int, int, int, int );
bool hudBuilder.setBarNodeIncreaseShow( int );
bool hudBuilder.setBarNodeInverse( bool );
bool hudBuilder.setBarNodeMove( int );
bool hudBuilder.setBarNodeRotation( int );
bool hudBuilder.setBarNodeRound( int, float, float );
bool hudBuilder.setBarNodeSnap( float );
bool hudBuilder.setBarNodeSnapDir( bool );
bool hudBuilder.setBarNodeSpanValues( float, float );
bool hudBuilder.setBarNodeTexture( int, std::string );
bool hudBuilder.setBarNodeValueVariable( std::string );
bool hudBuilder.setBarNodeVariableTexture( int, std::string );
bool hudBuilder.setButtonNodeAltConCmd( std::string, int );
bool hudBuilder.setButtonNodeConCmd( std::string, int );
bool hudBuilder.setButtonNodeDebug( bool );
bool hudBuilder.setButtonNodeFunction( std::string, int );
bool hudBuilder.setButtonNodeMouseArea( int, int, int, int );
bool hudBuilder.setButtonNodeMouseOverColor( float, float, float, float );
bool hudBuilder.setButtonNodeTexture( int, std::string );
bool hudBuilder.setCommanderPos( Vec2 );
bool hudBuilder.setCommanderSize( Vec2 );
bool hudBuilder.setCompassNodeBorder( int, int, int, int );
bool hudBuilder.setCompassNodeOffset( int );
bool hudBuilder.setCompassNodeSnapOffset( int, int, int, int );
bool hudBuilder.setCompassNodeSnapTexture( bool, std::string );
bool hudBuilder.setCompassNodeTexture( int, std::string );
bool hudBuilder.setCompassNodeTextureSize( int, int );
bool hudBuilder.setCompassNodeTiltValues( int, int );
bool hudBuilder.setCompassNodeValueVariable( std::string );
bool hudBuilder.setCompassNodeVariableTexture( int, std::string );
void hudBuilder.setCPFont( std::string );
void hudBuilder.setCPFontColor( float, float, float, float );
bool hudBuilder.setEditNodeColor( float, float, float, float );
bool hudBuilder.setEditNodeData( int );
bool hudBuilder.setEditNodeFont( std::string, bool );
bool hudBuilder.setEditNodeMaxLength( int );
bool hudBuilder.setEditNodeRotation( int );
bool hudBuilder.setEditNodeString( int );
bool hudBuilder.setEditNodeTtfFont( int );
bool hudBuilder.setHoverInMiddlePos( int, int );
bool hudBuilder.setHoverMaxValue( float );
bool hudBuilder.setHoverWidthLength( float, float );
bool hudBuilder.setListNodeBackgroundColor( float, float, float, float );
bool hudBuilder.setListNodeBorder( int, int, int, int );
bool hudBuilder.setListNodeBorderColor( float, float, float, float );
bool hudBuilder.setListNodeConCmd( int, std::string );
bool hudBuilder.setListNodeData( int );
bool hudBuilder.setListNodeFont( std::string, int );
bool hudBuilder.setListNodeOutline( bool );
bool hudBuilder.setListNodeRotation( int );
bool hudBuilder.setListNodeRowSpacing( int );
bool hudBuilder.setListNodeScrollbar( int, int );
bool hudBuilder.setListNodeScrollbarBackgroundColor( float, float, float, float );
bool hudBuilder.setListNodeScrollbarColor( float, float, float, float );
bool hudBuilder.setListNodeSelectColor( float, float, float, float );
bool hudBuilder.setListNodeUseTtfStyle( int );
bool hudBuilder.setMaxiPos( Vec2 );
bool hudBuilder.setMaxiSize( Vec2 );
bool hudBuilder.setMiniPos( Vec2 );
bool hudBuilder.setMiniSize( Vec2 );
void hudBuilder.setModifyer( float );
bool hudBuilder.setMouseOverNodeConCmd( std::string, int );
bool hudBuilder.setMouseOverNodeTexture( int, std::string );
bool hudBuilder.setNodeAlphaVariable( std::string );
bool hudBuilder.setNodeColor( float, float, float, float );
bool hudBuilder.setNodeIntervalBlink( float );
bool hudBuilder.setNodeInTime( float );
bool hudBuilder.setNodeLogicShowVariable( std::string, std::string, int );
bool hudBuilder.setNodeOffset( int, int );
bool hudBuilder.setNodeOutTime( float );
bool hudBuilder.setNodePos( int, int );
bool hudBuilder.setNodePosVariable( int, std::string );
bool hudBuilder.setNodeRGBVariables( std::string, std::string, std::string );
bool hudBuilder.setNodeShowConCmd( std::string, int );
bool hudBuilder.setNodeShowVariable( std::string );
bool hudBuilder.setNodeSize( int, int );
bool hudBuilder.setNodeTimesBlink( int, int );
bool hudBuilder.setObjectMarkerNodeLockOnType( int );
bool hudBuilder.setObjectMarkerNodeLockText( bool, std::string );
bool hudBuilder.setObjectMarkerNodeLockTextOffset( int, int );
bool hudBuilder.setObjectMarkerNodeObjects( int );
bool hudBuilder.setObjectMarkerNodeRC( int );
bool hudBuilder.setObjectMarkerNodeTexture( int, std::string );
bool hudBuilder.setObjectMarkerNodeTextureSize( int, int, int );
bool hudBuilder.setObjectMarkerNodeWeapon( int );
bool hudBuilder.setObjectSelectionNodePointerSize( int, int );
bool hudBuilder.setOccupiedNodeData( int );
bool hudBuilder.setOccupiedNodePosVariable( int, std::string );
bool hudBuilder.setOccupiedNodeUseText( std::string );
bool hudBuilder.setPictureNodeAlphaMask( std::string );
bool hudBuilder.setPictureNodeBorder( int, int, int, int );
bool hudBuilder.setPictureNodeBorderColor( float, float, float, float );
bool hudBuilder.setPictureNodeCenterPoint( int, int );
bool hudBuilder.setPictureNodeDx9Texture( std::string );
bool hudBuilder.setPictureNodeExpandTimeAndSize( float, float, int, int, int );
bool hudBuilder.setPictureNodeRotateVariable( std::string );
bool hudBuilder.setPictureNodeRotation( int );
bool hudBuilder.setPictureNodeTexture( std::string );
bool hudBuilder.setPictureNodeVariableTexture( std::string );
bool hudBuilder.setRoundBarStartAndSweepAngle( int, int );
bool hudBuilder.setSliderNodeChild( std::string );
bool hudBuilder.setSliderNodeData( std::string );
bool hudBuilder.setTextNodeExpandTimeAndSize( int, float, float, int, int );
bool hudBuilder.setTextNodeKerningPx( int );
bool hudBuilder.setTextNodeOutLine( std::string );
bool hudBuilder.setTextNodeOutLineOffset( float, float );
bool hudBuilder.setTextNodeRotation( int );
bool hudBuilder.setTextNodeShakeTimeAndFrames( int, float, float, int, int );
bool hudBuilder.setTextNodeShowSadAnim( int );
bool hudBuilder.setTextNodeString( std::string );
bool hudBuilder.setTextNodeStringVariable( std::string );
bool hudBuilder.setTextNodeStyle( std::string, int );
bool hudBuilder.setTextNodeTiltTimeAndFrames( float, float, int, int );
bool hudBuilder.setTextNodeUseTtfStyle( int );
bool hudBuilder.setTileNodeOptions( int, int, int );
bool hudBuilder.setTranformListNodeOffset( int, int );
bool hudBuilder.setTranformListNodePosVariable( int, std::string );
bool hudBuilder.setTransformNodeLayer( int );
bool hudBuilder.setTruncate( bool );
bool hudBuilder.setZoomIcons( bool );
void hudItems.setBool( std::string, bool );
void hudItems.setFloat( std::string, float );
void hudItems.setString( std::string, std::string );
void hudManager.addTextureAtlas( std::string );
void hudManager.closeGame( void );
void hudManager.enableSayAllChatBox( bool );
void hudManager.enableSayPlayerChatBox( bool );
void hudManager.enableSaySquadChatBox( bool );
void hudManager.enableSayTeamChatBox( bool );
void hudManager.mouseOverEscapeMenuExitButton( bool );
void hudManager.mouseOverEscapeMenuResumeButton( bool );
void hudManager.mouseOverEscapeMenuSuicideButton( bool );
void hudManager.mouseOverSpawnMenuHomeBaseButton( bool );
void hudManager.mouseOverSpawnMenuNormalButton( bool );
void hudManager.normalSpawnSelected( bool );
void hudManager.setChatBlockedDurationTime( int );
void hudManager.setChatMaxSpamFlagCount( int );
void hudManager.setChatSpamInterval( float );
bool hudManager.setCommMousePos( int, int );
bool hudManager.setCommMouseSensitivity( int );
bool hudManager.setCommPos( int, int );
bool hudManager.setCommSize( int, int );
void hudManager.setControlPointLetterOffset( int );
void hudManager.setDisplayControlpoints( bool );
void hudManager.setDisplayTickets( bool );
void hudManager.setDone( bool );
void hudManager.setMapStatic( bool );
void hudManager.setMaximumNrOfCPs( int );
bool hudManager.setMouseTextureArtillery( std::string );
bool hudManager.setMouseTextureEmpty( std::string );
bool hudManager.setMouseTextureFull( std::string );
bool hudManager.setMouseTextureMoveTitan( std::string );
bool hudManager.setMouseTextureOrbitalStrike( std::string );
bool hudManager.setMouseTextureSupply( std::string );
bool hudManager.setMouseTextureUAV( std::string );
void hudManager.setNameTagFontNameIndices( int, int );
void hudManager.setNameTagFontPrestigeIndices( int, int );
void hudManager.setPaint( bool );
bool hudManager.setPointerMouseSensitivity( int );
bool hudManager.setPointerSize( int, int );
void hudManager.setSpottedAngle( float );
bool hudManager.setSpottedMenuPos( int, int );
bool hudManager.setSpottedMenuSize( int, int );
bool hudManager.setSpottedMousePos( int, int );
void hudManager.setTargetTop( float );
void hudManager.setUpdate( bool );
void hudManager.showIngameEscPopup( bool );
void inGameEventManager.addBlacklistId( int );
void inGameEventManager.addCustomizationId( int );
void inGameEventManager.addToGameMode( std::string );
void inGameEventManager.broadcastEvent( bool );
void inGameEventManager.createInGameEvent( InGameEventId );
float inGameEventManager.hudDisplayTime( float );
float inGameEventManager.overrideHudDisplayTime( float );
void inGameEventManager.requiredDistance( float );
void inGameEventManager.setEventPriority( InGameEventId, int );
void inGameEventManager.setGenericVarValue( float );
void inGameEventManager.setHudString( std::string );
void inGameEventManager.setName( std::string );
void inGameEventManager.setSound( std::string );
void inGameEventManager.setXPScore( int );
void ingameHelp.showIngameHelp( std::string, float );
void kitInterface.chooseKitCustom( int, int );
void kitInterface.chooseKitSelection( int, int );
void kitInterface.closeCustomInterface( int );
void kitInterface.resetInformationString( int );
void kitInterface.resetMousePic( int );
void kitInterface.selectDroppedItem( int );
void kitInterface.setHeavyArmor( int );
void kitInterface.setInformationString( int, int );
void levelsList.setVoteMapShow( int );
void levelsList.singleClick( int );
Vec3 lightManager.ambientColor( Vec3 );
float lightManager.defaultEffectLightAffectionFactor( float );
Vec3 lightManager.effectShadowColor( Vec3 );
Vec3 lightManager.effectSunColor( Vec3 );
bool lightManager.enableStencilCullerReset( bool );
bool lightManager.enableSun( bool );
std::string lightManager.groundHemi( std::string );
float lightManager.hemiLerpBias( float );
void lightManager.init( void );
float lightManager.lightCullDistance( float );
Vec2 lightManager.lightMapAmbientAlphaCutoffRange( Vec2 );
int lightManager.maxLightsPerBundledMesh( int );
int lightManager.maxLightsPerSkinnedMesh( int );
int lightManager.maxLightsPerStaticMesh( int );
int lightManager.maxLightsPerTerrainPatch( int );
Vec3 lightManager.singlePointColor( Vec3 );
float lightManager.skinnedMeshShaderLodDistance( float );
Vec3 lightManager.skyColor( Vec3 );
Vec3 lightManager.staticSkyColor( Vec3 );
Vec3 lightManager.staticSpecularColor( Vec3 );
Vec3 lightManager.staticSunColor( Vec3 );
Vec3 lightManager.sunColor( Vec3 );
Vec3 lightManager.sunDirection( Vec3 );
Vec3 lightManager.sunSpecColor( Vec3 );
Vec3 lightManager.treeAmbientColor( Vec3 );
Vec3 lightManager.treeSkyColor( Vec3 );
Vec3 lightManager.treeSunColor( Vec3 );
Vec3 lightmapGeneration.ambientColor( Vec3 );
int lightmapGeneration.blockSize( int );
float lightmapGeneration.cameraNearPlane( float );
float lightmapGeneration.directlyLightedThreshold( float );
bool lightmapGeneration.doOvergrowth( bool );
bool lightmapGeneration.enableBackfaceCulling( bool );
bool lightmapGeneration.enableIntensityLightmaps( bool );
bool lightmapGeneration.flush( void );
int lightmapGeneration.generationMethod( int );
float lightmapGeneration.getWaterSunIntensity( void );
Vec3 lightmapGeneration.GILightColor( Vec3 );
Vec3 lightmapGeneration.GILightsBaseDir( Vec3 );
float lightmapGeneration.GILightsFov( float );
float lightmapGeneration.GILightsIntensity( float );
float lightmapGeneration.GILightsShadowIntensity( float );
float lightmapGeneration.GILightsViewDistance( float );
float lightmapGeneration.GITopLightIntensity( float );
float lightmapGeneration.globalSoftness( float );
void LightmapGeneration.init( void );
void lightmapGeneration.light.create( void );
Vec3 lightmapGeneration.light.direction( Vec3 );
float lightmapGeneration.light.fov( float );
float lightmapGeneration.light.intensity( float );
bool lightmapGeneration.light.objectShadows( bool );
bool lightmapGeneration.light.selfShadowing( bool );
float lightmapGeneration.light.shadowIntensity( float );
float lightmapGeneration.light.softness( float );
float lightmapGeneration.light.viewDistance( float );
int lightmapGeneration.lightmapFormat( int );
bool lightmapGeneration.noPhongAngle( bool );
uint lightmapGeneration.numberOfGILights( uint );
float lightmapGeneration.objectPointScale( float );
bool lightmapGeneration.onlyNearest( bool );
int lightmapGeneration.phongAngleMode( int );
bool lightmapGeneration.renderTerrain( bool );
float lightmapGeneration.resolutionModifier( float );
float lightmapGeneration.sampleOffset( float );
float lightmapGeneration.shadowsNearCamera( float );
Vec3 lightmapGeneration.skyColor( Vec3 );
float lightmapGeneration.skyWhite( float );
float lightmapGeneration.sunLightFov( float );
float lightmapGeneration.sunLightIntensity( float );
float lightmapGeneration.sunLightShadowIntensity( float );
float lightmapGeneration.terrainPointScale( float );
bool lightmapGeneration.traceActiveObject( void );
bool lightmapGeneration.traceActiveObjectProgress( int, int );
bool lightmapGeneration.traceAllObjects( void );
bool lightmapGeneration.traceTerrain( void );
bool lightmapGeneration.useGITopLight( bool );
std::string lightmapGeneration.useLog( std::string );
void localProfile.addDemoBookmark( std::string, std::string, std::string, time_t );
bool localProfile.save( void );
int localProfile.setCareerPoints( int );
void localProfile.setCurrentProfileLatestAwards( std::string, std::string, std::string );
void localProfile.setCurrentProfileMuted( int );
std::string localProfile.setEAOnlineMasterAccount( std::string );
std::string localProfile.setEAOnlineSubAccount( std::string );
std::string localProfile.setEmail( std::string );
void localProfile.setItemOrder( int, int );
time_t localProfile.setLastBaseUpdate( time_t );
std::string localProfile.setName( std::string );
int localProfile.setNumTimesLoggedIn( int );
int localProfile.setRank( int );
void localProfile.setSelectedMission( int, int );
void localProfile.setTotalPlayedTime( float );
bool maplist.append( std::string, std::string, int, int );
bool maplist.appendSave( std::string, std::string, int );
bool maplist.clear( void );
bool maplist.clearSave( void );
std::string maplist.configFile( std::string );
int maplist.currentMap( void );
bool maplist.insert( int, std::string, std::string, int );
std::string maplist.list( void );
std::string maplist.listAll( void );
bool maplist.load( void );
int maplist.mapCount( void );
int maplist.remove( int );
bool maplist.save( void );
bool maplist.saveSave( void );
unsigned int material.active( unsigned int );
float material.damageLoss( float );
float material.elasticity( float );
float material.friction( float );
bool material.hasWaterPhysics( bool );
bool material.isOneSided( bool );
bool material.isSeeThrough( bool );
void materialManager.createCell( unsigned int, unsigned int );
float materialManager.damageMod( float );
void materialManager.setDecalTemplate( unsigned int, IObjectTemplate_ptrproxy );
void materialManager.setEffectTemplate( unsigned int, IObjectTemplate_ptrproxy );
void materialManager.setRadioMessage( unsigned int, std::string, double );
void materialManager.setSoundTemplate( unsigned int, IObjectTemplate_ptrproxy );
float material.maxDamageLoss( float );
float material.minDamageLoss( float );
bool material.multiplyFriction( bool );
std::string material.name( std::string );
bool material.overrideNeverPenetrate( bool );
float material.penetrationDeviation( float );
float material.projectileCollisionHardness( float );
int material.pythonEvent( int );
float material.resistance( float );
bool material.triggerRadio( bool );
int material.type( int );
void minimap.setCommanderOffset( Vec2 );
void minimap.setCurrOrderList( int );
void minimap.setDestinationBlend( int );
void minimap.setFilterColor( float, float, float, float );
void minimap.setFullScreenZoom( int );
void minimap.setPaintAllKits( void );
void minimap.setPaintAllVehicles( void );
void minimap.setPaintKit( int );
void minimap.setPaintVehicle( int );
void minimap.setSourceBlend( int );
void minimap.setZoom( void );
void minimap.toggleShowKits( void );
void miscellaneousSettings.enableMugshotUpload( bool );
void miscellaneousSettings.setMatchMakingOption( int );
std::string misc.getBuildNr( void );
void nametags.createBar( NametagItemIDs, int, int );
void nametags.createIcon( NametagItemIDs );
float nametags.deathFadeOutTime( float );
double nametags.deployableDistance( double );
Vec2 nametags.getCullDistance( TagType );
float nametags.manDownFadeOutTime( float );
float nametags.maxCallDistance( float );
float nametags.maxFriendlyDistance( float );
void nametags.setCullDistance( TagType, Vec2 );
void nametags.setTexture( int, std::string, int, int, int, int );
float nametags.vehicleNametagOffset( float );
float nametags.vehicleNametagOffsetFactor( float );
void networkableInfo.createNewInfo( std::string );
void networkableInfo.setBasePriority( float );
void networkableInfo.setForceNetworkableId( bool );
void networkableInfo.setIsUnique( bool );
void networkableInfo.setPredictionMode( PredictionMode );
void network.dumpNetworkDescriptors( void );
void network.dumpScopableDescriptors( void );
void network.makeStatisticsMark( void );
void network.saveStats( void );
Vec3 object.absolutePosition( Vec3 );
Vec3 object.absolutePositionSecondary( Vec3 );
Mat4 object.absoluteTransformation( Mat4 );
world::IObject_ptrproxy Object.active( world::IObject_ptrproxy );
float object.attenuationRange1( float );
float object.attenuationRange2( float );
Vec3 object.color( Vec3 );
float object.coneAngle1( float );
float object.coneAngle2( float );
world::IObject_ptrproxy Object.create( world::IObjectTemplate_ptrproxy, Vec3, Vec3 );
Vec3 object.direction( Vec3 );
bool object.disableChildren( bool );
float objectDrawer.collectPlanesDistance( float );
bool objectDrawer.drawDebugPlanes( bool );
float objectDrawer.faceForwardThreshold( float );
bool objectDrawer.isInsideTitanOverride( bool );
bool objectDrawer.showAllTitanParts( bool );
bool objectDrawer.showCullStats( bool );
bool objectDrawer.useExactTest( bool );
bool objectDrawer.useOcclusion( bool );
void Object.forceStart( world::IObject_ptrproxy );
void Object.forceStop( world::IObject_ptrproxy );
float object.fov( float );
bool object.geometry.GenerateLightmapForThisInstance( bool );
void object.geometry.loadMesh( std::string );
int object.geometry.subGeometry( int );
int object.geometry.subGeometryCount( void );
std::string object.geometry.technique( std::string );
IGeometryTemplate* object.geometry.template( void );
int object.getLightSourceMask( void );
int object.getVisibleTeam( void );
float object.glowFrequency( float );
float object.glowOffset( float );
int object.glowType( int );
bool object.hasCollision( bool );
bool object.hasGlow( bool );
bool object.hasUpdate( bool );
float object.HDRIntensity( float );
void object.initGrid( Vec2, Vec2, int, Vec3 );
bool object.isInGrid( bool );
bool object.isOvergrowth( bool );
bool object.isSaveable( bool );
bool object.isVisible( bool );
std::string Object.list( void );
int objectManager.drawStats( int );
void objectManager.dump( std::string );
void objectManager.printNetStatsForAllTypeOfObjects( void );
std::string object.name( std::string );
bool object.notInAI( bool );
Vec3 object.rotation( Vec3 );
Vec3 object.rotationSecondary( Vec3 );
Vec3 object.scale( Vec3 );
void object.setAsSkyLight( void );
void object.setControlPointId( int );
void object.setIsDisabledRecursive( bool );
void object.setIsInTweakModeRecursive( bool );
void object.setIsInTweakModeRecursive( bool );
void object.setIsSaveableRecursive( bool );
void object.setIsVisibleRecursive( bool );
void object.setLightSourceMask( int );
void object.setVisibleTeam( int );
const IObjectTemplate* object.template( void );
int objectTemplate.3dMapIcon( int );
int objectTemplate.3dMapIcon( int );
void objectTemplate.ability.activationDelay( float );
bool objectTemplate.ability.activeWeaponFromTemplate( bool );
void objectTemplate.ability.addDamageOverTimeItem( float, float, float, DamageOverTimeType );
void objectTemplate.ability.addDamageVehicleOverTimeItem( float, float, float );
void objectTemplate.ability.addDeviationModifierItem( float );
void objectTemplate.ability.addEatsGrenadesItem( float, float, float );
void objectTemplate.ability.addExtraAmmoItem( int, int, bool );
void objectTemplate.ability.addExtraAmmoItemToKit( int, int, bool, bool );
void objectTemplate.ability.addHealAreaItem( float, float, float, float );
void objectTemplate.ability.addHealOverTimeItem( float, float, float );
void objectTemplate.ability.addHealthStealOnDamage( float, int );
void objectTemplate.ability.addIncreasedDamageItem( float );
void objectTemplate.ability.addIncreasedFireRateMultiplierItem( uint );
void objectTemplate.ability.addInstantHealItem( float );
void objectTemplate.ability.addMarkTargetAreaItem( float, float, float, float, float, int );
void objectTemplate.ability.addMobileSpawnPointItem( float, float, int, std::string );
void objectTemplate.ability.addOverrideCritChanceAndDamage( float, float );
void objectTemplate.ability.addReloadWeaponFromTemplateItem( bool );
void objectTemplate.ability.addRepairOverTimeItem( float, float, float );
void objectTemplate.ability.addRocketPackItem( float, float, float, float, float, float );
void objectTemplate.ability.addShield( float, float, float, float, float );
void objectTemplate.ability.addSurveillanceItem( float );
void objectTemplate.ability.addUserSpeedModItemGenericSettings( float, float, float );
void objectTemplate.ability.addUserSpeedModItemPerKit( int, float );
void objectTemplate.ability.addWeaponTemplate( std::string );
float objectTemplate.ability.beaconSpawnTimeMod( float );
bool objectTemplate.ability.coolDownPersistentThroughDeath( bool );
float objectTemplate.ability.detectionLevel( float );
float objectTemplate.ability.flashDuration( float );
float objectTemplate.ability.flashInterval( float );
bool objectTemplate.ability.hasAmmoAbility( bool );
bool objectTemplate.ability.hasHealingAbility( bool );
bool objectTemplate.ability.hasRepairingAbility( bool );
bool objectTemplate.ability.hasScopeStabilizerAbility( bool );
bool objectTemplate.ability.hasZoomUpgradeAbility( bool );
bool objectTemplate.ability.hideDurationProgressBar( bool );
float objectTemplate.ability.increasedRepairAbility( float );
int objectTemplate.ability.networkableHudRevealTime( int );
bool objectTemplate.ability.networkableHudShowCloaked( bool );
bool objectTemplate.ability.networkableHudShowKit( bool );
bool objectTemplate.ability.networkableHudShowVehicle( bool );
int objectTemplate.ability.radarRadius( int );
bool objectTemplate.ability.radialRadar( bool );
float objectTemplate.ability.restoreOnDamageInflicted( float );
float objectTemplate.ability.restoreOnDamageTaken( float );
float objectTemplate.ability.restoreOnEnter( float );
float objectTemplate.ability.restoreRateModStealth( float );
bool objectTemplate.ability.seeThroughWalls( bool );
void objectTemplate.ability.setDepletionWhenPassive( float, float );
void objectTemplate.ability.setMaterialDamageMod( int, float );
void objectTemplate.ability.setOverheatMod( float );
void objectTemplate.ability.setRestoreAfterUsage( float, float );
bool objectTemplate.ability.showPlayers( bool );
bool objectTemplate.ability.showVehicles( bool );
float objectTemplate.ability.speedMod( float );
float objectTemplate.ability.sprintRechargeModifier( float );
float objectTemplate.ability.sprintUseModifier( float );
void objectTemplate.ability.userEffect( StatusEffect, float );
Vec3 objectTemplate.ability.userFlashColor( Vec3 );
void objectTemplate.ability.victimEffect( StatusEffect, float );
Vec3 objectTemplate.ability.victimFlashColor( Vec3 );
Vec3 objectTemplate.ability.weaponFlashColor( Vec3 );
std::string objectTemplate.abilityComp.name( std::string );
std::string objectTemplate.abilityHud.ammoSound( std::string );
std::string objectTemplate.abilityHud.healingSound( std::string );
std::string objectTemplate.abilityHud.repairingSound( std::string );
float objectTemplate.abilityInVehicleStrengthModifier( float );
Math::Vec3 objectTemplate.acceleration( Math::Vec3 );
float objectTemplate.acceleration( float );
int objectTemplate.activateOnEvent( int );
int objectTemplate.activateTriggerId( int );
world::IObjectTemplate_ptrproxy ObjectTemplate.active( world::IObjectTemplate_ptrproxy );
bool objectTemplate.activeDefenseEnabled( bool );
bool objectTemplate.activeOnCreate( bool );
void ObjectTemplate.activeSafe( std::string, world::IObjectTemplate_ptrproxy );
void objectTemplate.addAmmoRefillCategory( int, float );
bool objectTemplate.addChild( bool );
bool objectTemplate.addEmitterSpeed( bool );
void objectTemplate.addMatchItem( std::string );
void objectTemplate.addNotMatchItem( std::string );
void objectTemplate.addReplaceItem( std::string );
void objectTemplate.addTargetObjectTypeToWatch( int );
void objectTemplate.addTemplate( std::string );
void objectTemplate.addVehicleAnimationSystem( std::string, std::string );
void objectTemplate.addVehicleType( std::string, int, float, float );
void objectTemplate.addVehicleType( VehicleCategory );
void objectTemplate.addWorkOnMaterial( int );
int objectTemplate.affectingType( int );
bool objectTemplate.affectLightmappedObjects( bool );
Vec2 objectTemplate.AgeScaleFactorFromSpeed( Vec2 );
Vec2 objectTemplate.AgeScaleFactorRange( Vec2 );
bool objectTemplate.AgeScaleFactorUsed( bool );
float objectTemplate.aimInterpolateDistance( float );
float objectTemplate.airFlowAffect( float );
float objectTemplate.airResistance( float );
Vec4 objectTemplate.airResistanceGraph( Vec4 );
std::string objectTemplate.aiTemplate( std::string );
bool objectTemplate.alignRotationToSpeed( bool );
bool objectTemplate.allowCameraShake( bool );
bool objectTemplate.allowDucking( bool );
bool objectTemplate.allowEmoteAnimation( bool );
bool objectTemplate.allowInParachute( bool );
bool objectTemplate.allowInsideDynamicLights( bool );
bool objectTemplate.allowInsideStaticSun( bool );
bool objectTemplate.allowInSkyDive( bool );
bool objectTemplate.allowInWater( bool );
bool objectTemplate.allowSelectKitInVehicle( bool );
bool objectTemplate.allowTogglePosition( bool );
bool objectTemplate.allowZoomOnHeat( bool );
float objectTemplate.alphaCull( float );
Vec2 objectTemplate.alphaIntensityFromAltitude( Vec2 );
Vec2 objectTemplate.alphaIntensityFromEngine( Vec2 );
Vec2 objectTemplate.alphaIntensityFromRotationalSpeed( Vec2 );
Vec2 objectTemplate.alphaIntensityFromSpeed( Vec2 );
Vec2 objectTemplate.alphaIntensityFromSpeedInDof( Vec2 );
Vec2 objectTemplate.alphaIntensityRange( Vec2 );
bool objectTemplate.alphaIntensityUsed( bool );
std::string objectTemplate.alternateTemplate0( std::string );
std::string objectTemplate.alternateTemplate1( std::string );
std::string objectTemplate.alternateTemplate2( std::string );
std::string objectTemplate.alternateTemplate3( std::string );
std::string objectTemplate.alternateTemplate4( std::string );
int objectTemplate.altItemIndex( int );
Vec3 objectTemplate.altSoldierExitPosition( Vec3 );
float objectTemplate.ammo.abilityCost( float );
float objectTemplate.ammo.abilityCost( float );
float objectTemplate.ammo.abilityDrain( float );
int objectTemplate.ammo.abilityMaterial( int );
float objectTemplate.ammo.abilityRadius( float );
float objectTemplate.ammo.abilityStrength( float );
bool objectTemplate.ammo.allowReloadWithFullMag( bool );
bool objectTemplate.ammo.allowReplenish( bool );
int objectTemplate.ammo.ammoType( int );
bool objectTemplate.ammo.autoReload( bool );
bool objectTemplate.ammo.canBeDisabled( bool );
float objectTemplate.ammo.changeMagAt( float );
bool objectTemplate.ammo.continous( bool );
float objectTemplate.ammo.detectionRadiusAlways( float );
float objectTemplate.ammo.detectionRadiusRank( float );
int objectTemplate.ammo.detonateMaterial( int );
bool objectTemplate.ammo.disableOnFire( bool );
float objectTemplate.ammo.firstShotExtraTime( float );
bool objectTemplate.ammo.forceSoundPostReloadOnReload( bool );
bool objectTemplate.ammo.forceWeaponSwitchWhenNoAmmo( bool );
bool objectTemplate.ammo.instantReloadOnEnable( bool );
float objectTemplate.ammo.lastShotExtraTime( float );
std::string objectTemplate.ammo.magLinkWeapon( std::string );
int objectTemplate.ammo.magSize( int );
float objectTemplate.ammo.minimumTimeUntilReload( float );
int objectTemplate.ammo.nrOfMags( int );
bool objectTemplate.ammo.onlyActiveWhileFiring( bool );
float objectTemplate.ammo.protectionRadius( float );
int objectTemplate.ammo.reloadAmount( int );
float objectTemplate.ammo.reloadTime( float );
bool objectTemplate.ammo.reloadWithoutPlayer( bool );
ReplenishingType objectTemplate.ammo.replenishingType( ReplenishingType );
int objectTemplate.ammo.shellsConsumedPerShot( int );
bool objectTemplate.ammo.taxOnEnable( bool );
bool objectTemplate.ammo.taxOnFire( bool );
bool objectTemplate.ammo.taxOnReload( bool );
float objectTemplate.ammo.timeToStayActive( float );
bool objectTemplate.ammo.toggleWhenNoAmmo( bool );
float objectTemplate.ammo.usageInterval( float );
void objectTemplate.ammoCategoryAndCost( int, float );
float objectTemplate.ammoStorageSize( float );
Vec3 objectTemplate.anchor( Vec3 );
Vec3 objectTemplate.anchorOffset( Vec3 );
int objectTemplate.animatedUVRotation( int );
int objectTemplate.animatedUVRotationIndex( int );
float objectTemplate.animatedUVRotationRadius( float );
bool objectTemplate.animatedUVRotationReverse( bool );
Vec2 objectTemplate.animatedUVRotationScale( Vec2 );
bool objectTemplate.animatedUVTranslation( bool );
int objectTemplate.animatedUVTranslationIndex( int );
Vec2 objectTemplate.animatedUVTranslationMax( Vec2 );
bool objectTemplate.animatedUVTranslationReverse( bool );
Vec2 objectTemplate.animatedUVTranslationSize( Vec2 );
Vec2 objectTemplate.animatedUVTranslationSpeed( Vec2 );
float objectTemplate.animation.loopingFire( float );
float objectTemplate.animation.shiftDelay( float );
bool objectTemplate.animation.useShiftAnimation( bool );
bool objectTemplate.animationEnable( bool );
bool objectTemplate.animationEnable( bool );
bool objectTemplate.animationEnable( bool );
bool objectTemplate.animationEnable( bool );
int objectTemplate.animationFrameCount( int );
int objectTemplate.animationFrameCount( int );
int objectTemplate.animationFrameCount( int );
int objectTemplate.animationFrameCount( int );
int objectTemplate.animationFrameCountX( int );
int objectTemplate.animationFrameCountX( int );
int objectTemplate.animationFrameCountX( int );
int objectTemplate.animationFrameCountX( int );
int objectTemplate.animationFrameHeight( int );
int objectTemplate.animationFrameHeight( int );
int objectTemplate.animationFrameHeight( int );
int objectTemplate.animationFrameHeight( int );
int objectTemplate.animationFrameWidth( int );
int objectTemplate.animationFrameWidth( int );
int objectTemplate.animationFrameWidth( int );
int objectTemplate.animationFrameWidth( int );
bool objectTemplate.animationPlayOnce( bool );
bool objectTemplate.animationPlayOnce( bool );
bool objectTemplate.animationRandomizedStartFrame( bool );
bool objectTemplate.animationRandomizedStartFrame( bool );
bool objectTemplate.animationRandomizedStartFrame( bool );
float objectTemplate.animationSpeed( float );
float objectTemplate.animationSpeed( float );
float objectTemplate.animationSpeed( float );
float objectTemplate.animationSpeed( float );
std::string objectTemplate.animationSystem1P( std::string );
std::string objectTemplate.animationSystem1P( std::string );
std::string objectTemplate.animationSystem3P( std::string );
std::string objectTemplate.animationSystem3P( std::string );
std::string objectTemplate.animationSystem3PMale( std::string );
float objectTemplate.antenna.accelerationFactor( float );
float objectTemplate.antenna.damping( float );
Vec2 objectTemplate.antenna.maxSwayAngle( Vec2 );
std::string objectTemplate.antenna.skeleton( std::string );
float objectTemplate.antenna.stiffness( float );
int objectTemplate.areaHeal.heal3dIcon( int );
int objectTemplate.areaHeal.heal3dIconRadius( int );
float objectTemplate.areaHeal.healAmountPerUpdate( float );
bool objectTemplate.areaHeal.healFromSoldier( bool );
bool objectTemplate.areaHeal.healFromVehicle( bool );
float objectTemplate.areaHeal.healRadius( float );
bool objectTemplate.areaHeal.healSelf( bool );
bool objectTemplate.areaHeal.healSoldiers( bool );
bool objectTemplate.areaHeal.healVehicles( bool );
float objectTemplate.areaHeal.updateInterval( float );
U32 objectTemplate.areaValueTeam1( U32 );
U32 objectTemplate.areaValueTeam2( U32 );
float objectTemplate.armingDelay( float );
void objectTemplate.armor.addArmorEffect( int, std::string, Vec3, Vec3 );
void objectTemplate.armor.addArmorEffectSpectacular( int, std::string, Vec3, Vec3 );
bool objectTemplate.armor.addNametagOnDestroy( bool );
void objectTemplate.armor.addWreckArmorEffect( int, std::string, Vec3, Vec3 );
bool objectTemplate.armor.alignLastEffectToHitDirection( bool );
float objectTemplate.armor.angleMod( float );
float objectTemplate.armor.attackDamage( float );
bool objectTemplate.armor.canBeDestroyed( bool );
bool objectTemplate.armor.canBeRepaired( bool );
bool objectTemplate.armor.canBeRepairedWhenWreck( bool );
bool objectTemplate.armor.canReceiveForce( bool );
float objectTemplate.armor.criticalDamage( float );
bool objectTemplate.armor.damagePointOnDestroy( bool );
float objectTemplate.armor.deepWaterDamageDelay( float );
float objectTemplate.armor.deepWaterLevel( float );
int objectTemplate.armor.defaultMaterial( int );
float objectTemplate.armor.destroyOnParentDamageLevel( float );
float objectTemplate.armor.destroyOnRootParentDamageLevel( float );
bool objectTemplate.armor.destroyOnSpectacularDeath( bool );
bool objectTemplate.armor.disableInputOnDestroy( bool );
bool objectTemplate.armor.dontUseWreck( bool );
bool objectTemplate.armor.empDamageIgnoreRadius( bool );
float objectTemplate.armor.empDamageIgnoreRadiusModifier( float );
int objectTemplate.armor.empDamageNumStep( int );
float objectTemplate.armor.empDamageStepSize( float );
float objectTemplate.armor.empLevelTime( float );
float objectTemplate.armor.explosionDamage( float );
float objectTemplate.armor.explosionForce( float );
float objectTemplate.armor.explosionForceMax( float );
float objectTemplate.armor.explosionForceMod( float );
int objectTemplate.armor.explosionMaterial( int );
float objectTemplate.armor.explosionRadius( float );
bool objectTemplate.armor.fullChildSync( bool );
bool objectTemplate.armor.hideChildrenOnSpectacularDeath( bool );
float objectTemplate.armor.hitPoints( float );
bool objectTemplate.armor.holdsSlBeacon( bool );
float objectTemplate.armor.hpLostWhileCriticalDamage( float );
float objectTemplate.armor.hpLostWhileInDeepWater( float );
float objectTemplate.armor.hpLostWhileInWater( float );
float objectTemplate.armor.hpLostWhileUpSideDown( float );
int objectTemplate.armor.hudRepairCellNo( int );
bool objectTemplate.armor.isRushObjective( bool );
float objectTemplate.armor.maxHitPoints( float );
bool objectTemplate.armor.mirrorParentDamageLevel( bool );
float objectTemplate.armor.onlyDamageFromChildrenLevel( float );
float objectTemplate.armor.parentDamageAlive( float );
float objectTemplate.armor.parentDamageWreck( float );
float objectTemplate.armor.showDamageAsDirt( float );
float objectTemplate.armor.takeDamageFromOwnTeam( float );
bool objectTemplate.armor.takesEmpDamage( bool );
float objectTemplate.armor.timeToStayAfterDestroyed( float );
float objectTemplate.armor.timeToStayAsWreck( float );
float objectTemplate.armor.waterDamageDelay( float );
float objectTemplate.armor.waterLevel( float );
float objectTemplate.armor.wreckDelay( float );
float objectTemplate.armor.wreckExplosionDamage( float );
float objectTemplate.armor.wreckExplosionForce( float );
float objectTemplate.armor.wreckExplosionForceMax( float );
float objectTemplate.armor.wreckExplosionForceMod( float );
int objectTemplate.armor.wreckExplosionMaterial( int );
float objectTemplate.armor.wreckExplosionRadius( float );
float objectTemplate.armor.wreckHitPoints( float );
int objectTemplate.assetId( int );
int objectTemplate.assetId( int );
float objectTemplate.attackSpeed( float );
float objectTemplate.attenuationRange1( float );
float objectTemplate.attenuationRange2( float );
bool objectTemplate.audio.newStyleAudio( bool );
bool objectTemplate.audio.transformationRelativeRoot( bool );
std::string objectTemplate.autoControllerTemplateName( std::string );
float objectTemplate.autoExitTimeDelay( float );
AutoFireEvent objectTemplate.autoFire.autoFireOnEvent( AutoFireEvent );
Math::Vec3 objectTemplate.autoFire.launchSpeedVector( Math::Vec3 );
std::string objectTemplate.autoFire.projectileTemplateName( std::string );
Math::Vec3 objectTemplate.autoFire.spawnPosOffset( Math::Vec3 );
bool objectTemplate.automaticPitchStabilization( bool );
bool objectTemplate.automaticReset( bool );
bool objectTemplate.automaticYawStabilization( bool );
bool objectTemplate.autoSpawn( bool );
int objectTemplate.autoUseAbility( int );
float objectTemplate.averageTimeBetweenTests( float );
int objectTemplate.barIcon( int );
std::string objectTemplate.blendMode( std::string );
std::string objectTemplate.blockInputOnRotBundle( std::string );
int objectTemplate.boneIndex( int );
float objectTemplate.bounceDamping( float );
float objectTemplate.bounceLength( float );
float objectTemplate.bounceSensitivity( float );
float objectTemplate.bounceStrength( float );
float objectTemplate.boundingRadiusModifierWhenOccupied( float );
std::string objectTemplate.breathEffect( std::string );
std::string objectTemplate.bundleAnimationSystem( std::string );
std::string objectTemplate.bundleSkeleton( std::string );
float objectTemplate.cameraEaseOutTime( float );
float objectTemplate.cameraExpShakeAmp( float );
float objectTemplate.cameraExpShakeDelay( float );
float objectTemplate.cameraExpShakeDistMod( float );
float objectTemplate.cameraExpShakeFreq( float );
float objectTemplate.cameraExpShakeTime( float );
int objectTemplate.cameraId( int );
bool objectTemplate.cameraShake( bool );
float objectTemplate.cameraShakeForce( float );
float objectTemplate.cameraShakeMaxSpeed( float );
float objectTemplate.cameraShakeRadius( float );
float objectTemplate.cameraShakeSensitivity( float );
float objectTemplate.cameraShakeStartSpeed( float );
float objectTemplate.cameraSwayDofMax( float );
float objectTemplate.cameraSwayDofMin( float );
float objectTemplate.cameraSwayRightMax( float );
float objectTemplate.cameraSwayRightMin( float );
float objectTemplate.cameraSwayRodLength( float );
float objectTemplate.cameraSwaySensitivity( float );
float objectTemplate.cameraSwaySpringDamping( float );
float objectTemplate.cameraSwaySpringStrength( float );
bool objectTemplate.canBeSelectedInGame( bool );
bool objectTemplate.canReverse( bool );
bool objectTemplate.canSelectWhileReloading( bool );
bool objectTemplate.capMaxSpeed( bool );
bool objectTemplate.castsDynamicShadow( bool );
bool objectTemplate.castsDynamicShadow( bool );
bool objectTemplate.castsStaticShadow( bool );
Vec3 objectTemplate.centerOfCollisionOffset( Vec3 );
Vec3 objectTemplate.centerOfCollisionOffset( Vec3 );
Vec3 objectTemplate.centerOfMassOffset( Vec3 );
float objectTemplate.chance( float );
float objectTemplate.changeLodAt( float );
float objectTemplate.chargeup.chargeupTime( float );
float objectTemplate.chargeup.maxLookAngleDuringChargeup( float );
float objectTemplate.chargeup.maxMovementDuringChargeup( float );
int objectTemplate.chaseParentIndex( int );
void objectTemplate.clearTemplateList( void );
bool objectTemplate.clientHitDetection( bool );
int objectTemplate.cockpitLod( int );
U32 objectTemplate.cockpitLod( U32 );
int objectTemplate.cockpitSubGeom( int );
U32 objectTemplate.cockpitSubGeom( U32 );
bool objectTemplate.collision.bouncing( bool );
bool objectTemplate.collision.bouncing( bool );
bool objectTemplate.collision.bouncing( bool );
bool objectTemplate.collision.bouncing( bool );
bool objectTemplate.collision.hasCollisionEffect( bool );
bool objectTemplate.collision.hasCollisionEffect( bool );
bool objectTemplate.collision.hasCollisionEffect( bool );
bool objectTemplate.collision.hasCollisionEffect( bool );
bool objectTemplate.collision.isTracerDart( bool );
float objectTemplate.collision.maxStickAngle( float );
float objectTemplate.collision.restoreHP( float );
float objectTemplate.collision.resurrectDamage( float );
bool objectTemplate.collision.stickToStaticObjects( bool );
bool objectTemplate.collision.stickToTerrain( bool );
bool objectTemplate.collision.stickToVehicles( bool );
std::string objectTemplate.collisionEffectName( std::string );
bool objectTemplate.collisionEnable( bool );
U32 objectTemplate.collisionGroups( U32 );
U32 objectTemplate.collisionGroups( U32 );
void objectTemplate.collisionMesh( std::string );
std::string objectTemplate.collisionMesh( std::string );
float objectTemplate.collisionModifierJeep( float );
float objectTemplate.collisionModifierPlane( float );
float objectTemplate.collisionModifierTank( float );
int objectTemplate.collisionPart( int );
int objectTemplate.collisionPart( int );
float objectTemplate.collisionSpeedAlongNormal( float );
float objectTemplate.collisionSpeedAlongPlane( float );
Vec3ColorFloatIntensity objectTemplate.color( Vec3ColorFloatIntensity );
Vec3ColorFloat objectTemplate.color( Vec3ColorFloat );
Vec3ColorFloatIntensity objectTemplate.color1( Vec3ColorFloatIntensity );
Vec3ColorFloatIntensity objectTemplate.color2( Vec3ColorFloatIntensity );
Vec4 objectTemplate.colorBlendGraph( Vec4 );
Vec3 objectTemplate.colorTransform( Vec3 );
float objectTemplate.coneAngle1( float );
float objectTemplate.coneAngle2( float );
Vec3 objectTemplate.coneDirection( Vec3 );
float objectTemplate.coneInnerAngle( float );
float objectTemplate.coneOuterAngle( float );
float objectTemplate.coneOuterVolume( float );
float objectTemplate.constantForce( float );
Math::Vec3 objectTemplate.continousRotationSpeed( Math::Vec3 );
int objectTemplate.controlPointId( int );
int objectTemplate.controlPointId( int );
U32 objectTemplate.ControlPointId( U32 );
std::string objectTemplate.controlPointName( std::string );
std::string objectTemplate.controlPointShortName( std::string );
dice::hfe::world::VehicleCategory objectTemplate.controlsCategory( dice::hfe::world::VehicleCategory );
float objectTemplate.coolDown.coolDownTime( float );
float objectTemplate.coolDownPerSec( float );
float objectTemplate.coolingFactor( float );
bool objectTemplate.copySoldierRotationOnEnter( bool );
float objectTemplate.counterMeasureRadius( float );
IObjectTemplate* ObjectTemplate.create( std::string, std::string );
void objectTemplate.createComponent( std::string );
void objectTemplate.createComponent( std::string );
bool objectTemplate.createdInEditor( bool );
bool objectTemplate.createInvisible( bool );
bool objectTemplate.createNotInGrid( bool );
bool objectTemplate.createVisibleInEditor( bool );
int objectTemplate.crewKitIndex( int );
float objectTemplate.criticalDamageScaleModifier( float );
float objectTemplate.crouchWalkCamHeight( float );
float objectTemplate.crouchWalkCamHeightSpeed( float );
float objectTemplate.cullRadiusScale( float );
float objectTemplate.cullRadiusScale( float );
int objectTemplate.customId( int );
int objectTemplate.customLayer( int );
hfe::CustomItemType objectTemplate.customType( hfe::CustomItemType );
bool objectTemplate.CVMChase( bool );
bool objectTemplate.CVMExternTrace( bool );
bool objectTemplate.CVMFlyBy( bool );
bool objectTemplate.CVMFrontChase( bool );
bool objectTemplate.CVMInside( bool );
bool objectTemplate.CVMNose( bool );
bool objectTemplate.CVMTrace( bool );
float objectTemplate.damage( float );
float objectTemplate.damagedAmbientSoundLimit( float );
bool objectTemplate.damageMandownSoldiers( bool );
void objectTemplate.damageModifier.addVehicleType( VehicleType );
float objectTemplate.damageModifier.damageModifier( float );
bool objectTemplate.damageOwner( bool );
float objectTemplate.damageSpeed( float );
float objectTemplate.dampHorizontalVel( float );
float objectTemplate.dampHorizontalVelFactor( float );
float objectTemplate.damping( float );
Math::Vec3 objectTemplate.deAcceleration( Math::Vec3 );
float objectTemplate.deAcceleration( float );
int objectTemplate.deActivateOnEvent( int );
float objectTemplate.deathFOV( float );
bool objectTemplate.debugAutoRotate( bool );
bool objectTemplate.debugForceGearUp( bool );
std::string objectTemplate.decalNormalMapName( std::string );
std::string objectTemplate.decalTextureName( std::string );
bool objectTemplate.decreaseAngleToZero( bool );
float objectTemplate.decreaseAngleToZeroVerticalVel( float );
float objectTemplate.defaultAngleOfAttack( float );
CameraViewMode objectTemplate.defaultCameraMode( CameraViewMode );
CameraViewMode objectTemplate.defaultCameraMode( CameraViewMode );
std::string objectTemplate.defaultMatchItem( std::string );
float objectTemplate.defendRadius( float );
RandomDistribution objectTemplate.delay( RandomDistribution );
float objectTemplate.delayToActiveTimeOverride( float );
float objectTemplate.delayToUse( float );
void ObjectTemplate.delete( world::IObjectTemplate_ptrproxy );
void objectTemplate.deleteComponent( std::string );
std::string objectTemplate.destroyableWindowsTemplate( std::string );
float objectTemplate.destroyDistance( float );
int objectTemplate.destroyObjectGroupOnFlagCapture( int );
bool objectTemplate.destroyOnExit( bool );
bool objectTemplate.destroyWhenEmptyStorage( bool );
bool objectTemplate.destroyWhenOutsideCombatArea( bool );
bool objectTemplate.destroyWhenTargetLost( bool );
uint objectTemplate.detectedDuration( uint );
float objectTemplate.detectedDuration( float );
bool objectTemplate.detectedShowFriendlies( bool );
bool objectTemplate.detectedShowFriendlies( bool );
uint objectTemplate.detectedShowFriendliesRadius( uint );
float objectTemplate.detectedShowFriendliesRadius( float );
void objectTemplate.detection.addWeaponType( WeaponItemType );
float objectTemplate.detection.radius( float );
float objectTemplate.detonateDelay( float );
bool objectTemplate.detonation.allowFriendlyFireDetonation( bool );
bool objectTemplate.detonation.canPickup( bool );
float objectTemplate.detonation.criticalHitSplashDamage( float );
float objectTemplate.detonation.damageFractionToOwner( float );
float objectTemplate.detonation.detectionRadius( float );
float objectTemplate.detonation.detonateDistanceToTarget( float );
bool objectTemplate.detonation.detonateOnWaterCollision( bool );
float objectTemplate.detonation.detonationDelay( float );
std::string objectTemplate.detonation.endEffectTemplate( std::string );
float objectTemplate.detonation.explosionConeAngle( float );
float objectTemplate.detonation.explosionDamage( float );
float objectTemplate.detonation.explosionForce( float );
float objectTemplate.detonation.explosionForcePercentOnFriendlies( float );
int objectTemplate.detonation.explosionMaterial( int );
float objectTemplate.detonation.explosionRadius( float );
float objectTemplate.detonation.explosionYMod( float );
float objectTemplate.detonation.gravityConstantSoldier( float );
float objectTemplate.detonation.gravityConstantVehicle( float );
float objectTemplate.detonation.gravityRadius( float );
float objectTemplate.detonation.hotSpotRadiusPercent( float );
bool objectTemplate.detonation.isEMPWeapon( bool );
bool objectTemplate.detonation.isStompWeapon( bool );
float objectTemplate.detonation.maxDepthForExplosion( float );
bool objectTemplate.detonation.preventDetonationFromDestroyedParent( bool );
bool objectTemplate.detonation.radiusDetonateWithAirVehicles( bool );
float objectTemplate.detonation.replenishingStrength( float );
ReplenishingType objectTemplate.detonation.replenishingType( ReplenishingType );
void objectTemplate.detonation.setDamageOverTime( float, DamageOverTimeType, float, float, StatusEffect, float );
bool objectTemplate.detonation.showMineIndicationIcon( bool );
float objectTemplate.detonation.stompAngleExplosive( float );
float objectTemplate.detonation.stompAngleSoldier( float );
float objectTemplate.detonation.stompAngleVehicle( float );
float objectTemplate.detonation.stompForceExplosive( float );
float objectTemplate.detonation.stompForceSoldier( float );
float objectTemplate.detonation.stompForceVehicle( float );
float objectTemplate.detonation.triggerAngle( float );
float objectTemplate.detonation.triggerRadius( float );
RadiusTriggerType objectTemplate.detonation.triggerType( RadiusTriggerType );
float objectTemplate.detonation.triggerVictimMinSpeed( float );
bool objectTemplate.detonation.useCollisionNormal( bool );
bool objectTemplate.detonation.useMMOnEndEffect( bool );
void objectTemplate.detonation.victimSpeedModifier( int, float );
void objectTemplate.detonation.victimSpeedModifierDuration( float );
float objectTemplate.deviation.devModCrouch( float );
float objectTemplate.deviation.devModLie( float );
float objectTemplate.deviation.devModStand( float );
float objectTemplate.deviation.devModZoom( float );
float objectTemplate.deviation.devModZoom( float );
float objectTemplate.deviation.minDev( float );
float objectTemplate.deviation.minDevModZoom( float );
float objectTemplate.deviation.minDevModZoom( float );
float objectTemplate.deviation.radius( float );
void objectTemplate.deviation.setFireDev( float, float, float );
void objectTemplate.deviation.setMiscDev( float, float, float );
void objectTemplate.deviation.setSpeedDev( float, float, float, float );
void objectTemplate.deviation.setTurnDev( float, float, float, float );
float objectTemplate.deviation.subProjectileDev( float );
bool objectTemplate.deviation.syncDev( bool );
float objectTemplate.differential( float );
Vec3 objectTemplate.direction( Vec3 );
float objectTemplate.directionalScale( float );
bool objectTemplate.disableCloseSpawnPoints( bool );
void objectTemplate.disableExplosives.addDisableOnVehicleType( VehicleType );
void objectTemplate.disableExplosives.addWeaponItemType( WeaponItemType );
bool objectTemplate.disableExplosives.delayOnly( bool );
float objectTemplate.disableExplosives.delayTime( float );
bool objectTemplate.disableExplosives.disableOnRun( bool );
bool objectTemplate.disableExplosives.disableOnSprint( bool );
float objectTemplate.disableExplosives.explosiveUpdateDelay( float );
bool objectTemplate.disableInsideVehicle( bool );
bool objectTemplate.disableOnDamage( bool );
bool objectTemplate.disableOutsideVehicle( bool );
bool objectTemplate.disablePodControls( bool );
bool objectTemplate.disableSpawnPointsOnEnter( bool );
bool objectTemplate.disableWhenEmptyVehicle( bool );
float objectTemplate.disableWhenEmptyVehicleDelay( float );
bool objectTemplate.disableWhenWreck( bool );
float objectTemplate.distance( float );
bool objectTemplate.dontAllowExit( bool );
bool objectTemplate.dontClearTeamOnExit( bool );
float objectTemplate.drag( float );
RandomDistribution objectTemplate.drag( RandomDistribution );
Vec3 objectTemplate.dragModifier( Vec3 );
float objectTemplate.dragModifier( float );
Vec3 objectTemplate.dragOffset( Vec3 );
std::string objectTemplate.drawOrder( std::string );
std::string objectTemplate.drawOrder( std::string );
int objectTemplate.dudMaterial( int );
float objectTemplate.duration.duration( float );
std::string objectTemplate.effectTemplateBaseName( std::string );
float objectTemplate.emitDelay( float );
Vec3 objectTemplate.emitDirection( Vec3 );
bool objectTemplate.emitDirectionZFromSpeedDof( bool );
float objectTemplate.emitFrequency( float );
std::string objectTemplate.emitPrio( std::string );
Vec3 objectTemplate.emitRadius( Vec3 );
RandomDistribution objectTemplate.emitRangeX( RandomDistribution );
RandomDistribution objectTemplate.emitRangeY( RandomDistribution );
RandomDistribution objectTemplate.emitRangeZ( RandomDistribution );
Vec2 objectTemplate.emitScaleFactorFromAltitude( Vec2 );
Vec2 objectTemplate.emitScaleFactorFromSpeed( Vec2 );
Vec2 objectTemplate.emitScaleFactorFromSpeedInDof( Vec2 );
Vec2 objectTemplate.emitScaleFactorRange( Vec2 );
bool objectTemplate.emitScaleFactorUsed( bool );
float objectTemplate.emitSpeed( float );
Vec4 objectTemplate.emitSpeedGraph( Vec4 );
Vec2 objectTemplate.emitSpeedScaleFromAcceleration( Vec2 );
Vec2 objectTemplate.emitSpeedScaleFromAltitude( Vec2 );
Vec2 objectTemplate.emitSpeedScaleFromEngine( Vec2 );
Vec2 objectTemplate.emitSpeedScaleFromRotationalSpeed( Vec2 );
Vec2 objectTemplate.emitSpeedScaleFromSpeed( Vec2 );
Vec2 objectTemplate.emitSpeedScaleFromSpeedInDof( Vec2 );
Vec2 objectTemplate.emitSpeedScaleRange( Vec2 );
bool objectTemplate.emitSpeedScaleUsed( bool );
float objectTemplate.emitterSpeedScale( float );
std::string objectTemplate.emitterType( std::string );
float objectTemplate.emitTime( float );
hfe::TargetChannel objectTemplate.emoteHud.channel( hfe::TargetChannel );
std::string objectTemplate.emoteHud.icon( std::string );
std::string objectTemplate.emoteHud.trigger( std::string );
bool objectTemplate.enabled( bool );
bool objectTemplate.enableOnStartMessage( bool );
void objectTemplate.enemyAwareness.addAwareOfWeaponType( WeaponItemType );
float objectTemplate.enemyAwareness.awarenessDotAngle( float );
bool objectTemplate.enemyAwareness.canSeeEnemyClass( bool );
bool objectTemplate.enemyAwareness.giveEnemyAimingWarning( bool );
bool objectTemplate.enemyAwareness.isUndetectableToEnemies( bool );
bool objectTemplate.enemyAwareness.onlyWarnIfEnemyZoomed( bool );
bool objectTemplate.enemyAwareness.paintMinimapIcon( bool );
int objectTemplate.enemyAwareness.showInHudTime( int );
float objectTemplate.enemyAwareness.warningInterval( float );
float objectTemplate.enemyAwareness.warningMaxDistance( float );
std::string objectTemplate.enemyAwareness.warningMessage( std::string );
float objectTemplate.engineInfluence( float );
std::string objectTemplate.engineName( std::string );
std::string objectTemplate.engineName( std::string );
int objectTemplate.engineType( int );
bool objectTemplate.enterOnSpawn( bool );
float objectTemplate.entryRadius( float );
int objectTemplate.events( int );
float objectTemplate.exitSpeedMod( float );
bool objectTemplate.exitThroughPodLauncher( bool );
float objectTemplate.fadeInFactor( float );
float objectTemplate.fadeOutFactor( float );
int objectTemplate.fakeNameId( int );
float objectTemplate.fallDamageModifier.fallDamageMod( float );
void objectTemplate.fire.addBarrelName( std::string );
void objectTemplate.fire.addFireRate( int );
bool objectTemplate.fire.allowZoomOnROF( bool );
io::PlayerInputMap objectTemplate.fire.altFireInput( io::PlayerInputMap );
bool objectTemplate.fire.alwaysFireFromWeapon( bool );
int objectTemplate.fire.batchSize( int );
int objectTemplate.fire.burstSize( int );
bool objectTemplate.fire.busyUntilButtonRelease( bool );
float objectTemplate.fire.coneEffectAngle( float );
void objectTemplate.fire.coneEffectDamage( int, float );
float objectTemplate.fire.coneEffectDistance( float );
void objectTemplate.fire.coneEffectHeal( int, float );
bool objectTemplate.fire.coneEffectResurrect( bool );
float objectTemplate.fire.criticalHitChance( float );
float objectTemplate.fire.criticalHitDamage( float );
bool objectTemplate.fire.destroyProjectilesOnDestroy( bool );
std::string objectTemplate.fire.detonatorObject( std::string );
int objectTemplate.fire.distanceStep( int );
int objectTemplate.fire.dropLod( int );
float objectTemplate.fire.dropWeaponAfterReloadDelay( float );
float objectTemplate.fire.fireCompleteDelay( float );
bool objectTemplate.fire.fireInCameraDof( bool );
bool objectTemplate.fire.fireInCameraDofLocked( bool );
io::PlayerInputMap objectTemplate.fire.fireInput( io::PlayerInputMap );
float objectTemplate.fire.fireLaunchDelay( float );
float objectTemplate.fire.fireLaunchDelaySoft( float );
bool objectTemplate.fire.fireOnEnable( bool );
RandomDistribution objectTemplate.fire.fireStartDelay( RandomDistribution );
bool objectTemplate.fire.firesThroughHudSystem( bool );
int objectTemplate.fire.forcedWeaponList( int );
bool objectTemplate.fire.hasAlternateOrigin( bool );
int objectTemplate.fire.hideLod( int );
float objectTemplate.fire.hideWeaponAfterReloadDelay( float );
io::PlayerInputMap objectTemplate.fire.ignoreFireButton( io::PlayerInputMap );
bool objectTemplate.fire.isBarrel( std::string );
bool objectTemplate.fire.isPodLauncher( bool );
float objectTemplate.fire.maximumVehicleTiltForFire( float );
int objectTemplate.fire.maxProjectilesInWorld( int );
float objectTemplate.fire.minCamHitPosToWeaponDistance( float );
int objectTemplate.fire.minimumDistance( int );
float objectTemplate.fire.noMovementAfterFireTime( float );
float objectTemplate.fire.obstructionTestDistance( float );
bool objectTemplate.fire.onlyFireWhenProne( bool );
bool objectTemplate.fire.onlyFireWhenZoomed( bool );
Vec3 objectTemplate.fire.projectileStartPositionCrouch( Vec3 );
Vec3 objectTemplate.fire.projectileStartPositionStand( Vec3 );
Vec3 objectTemplate.fire.projectileStartPositionVehicle( Vec3 );
Vec3 objectTemplate.fire.projectileStartRotation( Vec3 );
float objectTemplate.fire.pullbackTime( float );
float objectTemplate.fire.radioMessageDelay( float );
float objectTemplate.fire.randomRotationSpeed( float );
int objectTemplate.fire.roundsPerMinute( int );
void objectTemplate.fire.setProjectileSpawnFromAbove( float, float );
float objectTemplate.fire.showWeaponAfterReloadDelay( float );
float objectTemplate.fire.showWeaponAfterReloadDelay( float );
float objectTemplate.fire.showWeaponAfterReloadDelay( float );
int objectTemplate.fire.surpressEffectOnFireStart( int );
bool objectTemplate.fire.toggleWhenFired( bool );
bool objectTemplate.fire.useDistanceCounter( bool );
bool objectTemplate.fire.useDoubleClick( bool );
bool objectTemplate.fire.useDummyProjectiles( bool );
std::string objectTemplate.firearmReplacement( std::string );
float objectTemplate.fireDelayAfterJump( float );
float objectTemplate.fireDelayFromProne( float );
bool objectTemplate.firingRemovesTracerDarts( bool );
bool objectTemplate.fixAxisSpring( bool );
std::string objectTemplate.flagTemplateTeam0( std::string );
std::string objectTemplate.flagTemplateTeam1( std::string );
std::string objectTemplate.flagTemplateTeam2( std::string );
float objectTemplate.flapLift( float );
float objectTemplate.flicker( float );
float objectTemplate.floaterMod( float );
float objectTemplate.floaterMod( float );
float objectTemplate.floatMaxLift( float );
float objectTemplate.floatMinLift( float );
float objectTemplate.follow.armingSpeed( float );
float objectTemplate.follow.changePitch( float );
float objectTemplate.follow.changeYaw( float );
float objectTemplate.follow.followTime( float );
bool objectTemplate.follow.magneticBehaviour( bool );
float objectTemplate.follow.maxPitch( float );
float objectTemplate.follow.maxYaw( float );
float objectTemplate.follow.minDist( float );
float objectTemplate.follow.predictionFactor( float );
float objectTemplate.follow.speedModifier( float );
bool objectTemplate.follow.targetActivation( bool );
float objectTemplate.follow.useTargetSpeed( float );
float objectTemplate.followKillerDistance( float );
float objectTemplate.followKillerHeight( float );
float objectTemplate.followKillerLookHeight( float );
float objectTemplate.followStiffness( float );
float objectTemplate.footLength( float );
float objectTemplate.footWidth( float );
float objectTemplate.force( float );
float objectTemplate.forceModifier.forceModifierSoldier( float );
float objectTemplate.forceModifier.forceModifierVehicle( float );
ForceType objectTemplate.forceModifier.modifiesForceType( ForceType );
bool objectTemplate.forcePreCacheObject( bool );
bool objectTemplate.forceToWaterSurface( bool );
bool objectTemplate.forceUpdate( bool );
bool objectTemplate.forwardTeamChangeToSpawnedVehicles( bool );
float objectTemplate.fOV( float );
float objectTemplate.fov( float );
bool objectTemplate.freezePlayerMovement( bool );
float objectTemplate.friLatBrakeMod( float );
float objectTemplate.gearChangeTime( float );
float objectTemplate.gearDown( float );
float objectTemplate.gearDownDelay( float );
float objectTemplate.gearDownHeight( float );
float objectTemplate.gearDownSpeed( float );
float objectTemplate.gearUp( float );
float objectTemplate.gearUpDelay( float );
float objectTemplate.gearUpHeight( float );
float objectTemplate.gearUpSpeed( float );
std::string objectTemplate.geometry( std::string );
std::string objectTemplate.geometry( std::string );
std::string objectTemplate.geometry( std::string );
std::string objectTemplate.geometry( std::string );
int objectTemplate.geometryPart( int );
int objectTemplate.geometryPart( int );
Vec3 objectTemplate.getChaseAngle( int );
float objectTemplate.getChaseDistance( int );
Vec3 objectTemplate.getChaseOffset( int );
int objectTemplate.getHeatBarType( void );
float objectTemplate.getIntermediateDistance( int );
Vec3 objectTemplate.getMinChaseAngle( int );
float objectTemplate.getMinChaseDistance( int );
Vec3 objectTemplate.getMinChaseOffset( int );
float objectTemplate.getMoveToIntermediateSpeed( int );
Math::Vec3 objectTemplate.getPosition( int );
Math::Vec3 objectTemplate.getRotation( int );
std::string objectTemplate.getTemplate( int );
float objectTemplate.getVanityCamDistance( int );
float objectTemplate.getVanityCamHeight( int );
float objectTemplate.getVanityCamLookHeight( int );
Vec3 objectTemplate.getZoomChaseAngle( int );
float objectTemplate.getZoomChaseDistance( int );
Vec3 objectTemplate.getZoomChaseOffset( int );
float objectTemplate.globalEffectLevel( float );
float objectTemplate.glowFrequency( float );
float objectTemplate.glowFrequency( float );
float objectTemplate.glowOffset( float );
float objectTemplate.glowOffset( float );
int objectTemplate.glowType( int );
int objectTemplate.glowType( int );
float objectTemplate.gravity( float );
Vec4 objectTemplate.gravityGraph( Vec4 );
float objectTemplate.gravityModifier( float );
RandomDistribution objectTemplate.gravityModifier( RandomDistribution );
PhysicsGripFlags objectTemplate.grip( PhysicsGripFlags );
float objectTemplate.groundContactVolume( float );
U32 objectTemplate.group( U32 );
int objectTemplate.groupId( int );
float objectTemplate.halfVolumeDistance( float );
float objectTemplate.handleCollisionSpeed( float );
bool objectTemplate.hasCollisionPhysics( bool );
bool objectTemplate.hasCollisionPhysics( bool );
bool objectTemplate.hasDirection( bool );
bool objectTemplate.hasExternalAbilityUseCount( bool );
bool objectTemplate.hasGlow( bool );
bool objectTemplate.hasGlow( bool );
bool objectTemplate.hasMobilePhysics( bool );
bool objectTemplate.hasMobilePhysics( bool );
bool objectTemplate.hasOnTimeEffect( bool );
void objectTemplate.hasPointPhysics( bool );
bool objectTemplate.hasRelativeOffset( bool );
void objectTemplate.hasResponsePhysics( bool );
void objectTemplate.hasResponsePhysics( bool );
bool objectTemplate.hasRestrictedExit( bool );
void objectTemplate.hasRotationalPointPhysics( bool );
float objectTemplate.HDRIntensity( float );
float objectTemplate.heal.healPercentPerStep( float );
int objectTemplate.heal.healSteps( int );
float objectTemplate.heal.stepTime( float );
float objectTemplate.healPerWave( float );
float objectTemplate.healSpeed( float );
float objectTemplate.healStorageSize( float );
int objectTemplate.healWaves( int );
float objectTemplate.heatAddWhenFire( float );
float objectTemplate.heatIncrement( float );
float objectTemplate.height( float );
std::string objectTemplate.helpHud.altHelpSoundKey( std::string );
std::string objectTemplate.helpHud.altHelpStringKey( std::string );
int objectTemplate.helpHud.closeToDistance( int );
std::string objectTemplate.helpHud.closeToHelpSoundKeyEnemy( std::string );
std::string objectTemplate.helpHud.closeToHelpSoundKeyFriendly( std::string );
std::string objectTemplate.helpHud.closeToHelpSoundKeyNeutral( std::string );
std::string objectTemplate.helpHud.closeToHelpStringKeyEnemy( std::string );
std::string objectTemplate.helpHud.closeToHelpStringKeyFriendly( std::string );
std::string objectTemplate.helpHud.closeToHelpStringKeyNeutral( std::string );
std::string objectTemplate.helpHud.helpSoundKey( std::string );
std::string objectTemplate.helpHud.helpStringKey( std::string );
std::string objectTemplate.helpHud.lowAmmoHelpSoundKey( std::string );
std::string objectTemplate.helpHud.lowAmmoHelpStringKey( std::string );
std::string objectTemplate.helpHud.lowArmorHelpSoundKey( std::string );
std::string objectTemplate.helpHud.lowArmorHelpStringKey( std::string );
int objectTemplate.hitDetection.detectionLevel( int );
float objectTemplate.hitImpactModifier( float );
bool objectTemplate.holdObject( bool );
float objectTemplate.homeBaseRadius( float );
float objectTemplate.horizontalDampAngle( float );
float objectTemplate.horizontalDampAngleFactor( float );
float objectTemplate.horizontalSpeedMagnifier( float );
std::string objectTemplate.hudElements.activeIcon( std::string );
std::string objectTemplate.hudElements.newlyActivatedIcon( std::string );
float objectTemplate.hudElements.newlyActivatedIconShowDuration( float );
std::string objectTemplate.hudShortName( std::string );
float objectTemplate.hullHeight( float );
Vec3 objectTemplate.ignoreParentRotation( Vec3 );
bool objectTemplate.ignoreParentRotationAlways( bool );
Vec3 objectTemplate.ik.poleVectorLeft( Vec3 );
Vec3 objectTemplate.ik.poleVectorRight( Vec3 );
Vec3 objectTemplate.ik.positionLeft( Vec3 );
Vec3 objectTemplate.ik.positionRight( Vec3 );
Vec3 objectTemplate.ik.rotationLeft( Vec3 );
Vec3 objectTemplate.ik.rotationRight( Vec3 );
Vec3 objectTemplate.inertiaModifier( Vec3 );
Vec3 objectTemplate.inertiaModifier( Vec3 );
Vec3 objectTemplate.inertiaModifierForWreck( Vec3 );
bool objectTemplate.inheritHeatFromPrimary( bool );
bool objectTemplate.inheritParentSpeedSoldier( bool );
bool objectTemplate.inheritParentSpeedVehicle( bool );
bool objectTemplate.initiallyWalkable( bool );
float objectTemplate.initialMaxDamage( float );
float objectTemplate.initialMinDamage( float );
float objectTemplate.initialTimeUntilTakeable( float );
io::PlayerInputMap objectTemplate.input( io::PlayerInputMap );
io::PlayerInputMap objectTemplate.inputToPitch( io::PlayerInputMap );
io::PlayerInputMap objectTemplate.inputToRoll( io::PlayerInputMap );
io::PlayerInputMap objectTemplate.inputToYaw( io::PlayerInputMap );
float objectTemplate.insideDamageFrequency( float );
float objectTemplate.insideDamageThreshold( float );
float objectTemplate.insideFOV( float );
float objectTemplate.insideFOV( float );
Vec3ColorFloatIntensity objectTemplate.insideStaticSunAmbientColor( Vec3ColorFloatIntensity );
Vec3ColorFloatIntensity objectTemplate.insideStaticSunColor( Vec3ColorFloatIntensity );
Vec3ColorFloatIntensity objectTemplate.insideStaticSunDamageColor( Vec3ColorFloatIntensity );
Vec3 objectTemplate.insideStaticSunDirection( Vec3 );
float objectTemplate.insideViewInterpolate( float );
float objectTemplate.intensity( float );
RandomDistribution objectTemplate.intensity( RandomDistribution );
int objectTemplate.interaction.3dIcon( int );
void objectTemplate.interaction.backwardStateTransitionTimers( float, float );
std::string objectTemplate.interaction.enableWeaponOnInteraction( std::string );
bool objectTemplate.interaction.enemyTeamInteractionOnly( bool );
void objectTemplate.interaction.forwardStateTransitionTimers( float, float );
std::string objectTemplate.interaction.hudMessageActivate( std::string );
std::string objectTemplate.interaction.hudMessageDeactivate( std::string );
void objectTemplate.interaction.imminentActivationThresholdTime( float );
std::string objectTemplate.interaction.interactionAnimationName( std::string );
int objectTemplate.interaction.interactionPriority( int );
GLInteractionType objectTemplate.interaction.interactionType( GLInteractionType );
float objectTemplate.interaction.maxInteractionAngle( float );
float objectTemplate.interaction.maxInteractionDistance( float );
bool objectTemplate.interaction.requiresSkill( bool );
float objectTemplate.interaction.spawnPointScoreRadius( float );
U32 objectTemplate.inventorySize( U32 );
bool objectTemplate.inverseHeatBar( bool );
bool objectTemplate.invertGear( bool );
bool objectTemplate.is3dSound( bool );
bool objectTemplate.isDefaultWeapon( bool );
bool objectTemplate.isDestructable( bool );
bool objectTemplate.isDogtagReplacement( bool );
bool objectTemplate.isDummyWeapon( bool );
bool objectTemplate.isDynamic( bool );
bool objectTemplate.isFirearmReplacement( bool );
bool objectTemplate.isHemisphere( bool );
bool objectTemplate.isHomeBase( bool );
bool objectTemplate.isLocalSystem( bool );
bool objectTemplate.isLooping( bool );
bool objectTemplate.isMajorActor( bool );
bool objectTemplate.isMissileSilo( bool );
bool objectTemplate.isNotSaveable( bool );
bool objectTemplate.isOvergrowth( bool );
bool objectTemplate.isPersistent( bool );
bool objectTemplate.isPod( bool );
bool objectTemplate.isPortalPassing( bool );
bool objectTemplate.isRetailReplacement( bool );
bool objectTemplate.isSelectable( bool );
bool objectTemplate.isSleeping( bool );
bool objectTemplate.isSleeping( bool );
bool objectTemplate.isStatic( bool );
bool objectTemplate.isStatic( bool );
bool objectTemplate.isStaticSystem( bool );
bool objectTemplate.isTeleportReferencePoint( bool );
bool objectTemplate.isTitanAmbient( bool );
bool objectTemplate.isVisible( bool );
int objectTemplate.itemIndex( int );
float objectTemplate.jumpDelayAfterProne( float );
float objectTemplate.keepProjectiles( float );
bool objectTemplate.keepUp( bool );
int objectTemplate.kitId( int );
int objectTemplate.kitTeam( int );
float objectTemplate.lastChanceSoldierExitHeight( float );
uint objectTemplate.legEnableMask( uint );
float objectTemplate.length( float );
float objectTemplate.length( float );
float objectTemplate.lesserYawAtSpeed( float );
bool objectTemplate.liftRegulated( bool );
float objectTemplate.lightMapIntensityOffset( float );
std::string objectTemplate.lightType( std::string );
std::string objectTemplate.linkedEffectContainer( std::string );
std::string ObjectTemplate.list( std::string );
float objectTemplate.listenerObstruction( float );
std::string ObjectTemplate.listTemplateClasses( void );
std::string objectTemplate.listTemplates( void );
std::string objectTemplate.listTemplates( void );
std::string objectTemplate.localizedTaskTextId( std::string );
bool objectTemplate.localOnly( bool );
bool objectTemplate.localPredictOnClient( bool );
bool objectTemplate.lockToTeam( bool );
float objectTemplate.lodDistance( float );
std::string objectTemplate.LodDistance( std::string );
float objectTemplate.lodDistance( float );
float objectTemplate.longDistance( float );
float objectTemplate.longMaxDamage( float );
float objectTemplate.longMinDamage( float );
float objectTemplate.lookAtClosestTitanOnEnter( float );
float objectTemplate.lookAtKillerSpeed( float );
float objectTemplate.lookAtKillerTime( float );
float objectTemplate.lookAtVictimSpeed( float );
float objectTemplate.lookAtVictimTime( float );
int objectTemplate.loopCount( int );
bool objectTemplate.loseControlWhenEnemyClose( bool );
int objectTemplate.lowSamples( int );
bool objectTemplate.maintainCameraOnEnter( bool );
bool objectTemplate.maintainCameraOnExit( bool );
bool objectTemplate.maintainCameraOnExitToOtherVehicle( bool );
float objectTemplate.manDownCameraOffsetInDof( float );
float objectTemplate.manDownCameraOffsetInUp( float );
void objectTemplate.mapMaterial( uint, std::string, uint );
void objectTemplate.mapMaterial( uint, std::string, uint );
float objectTemplate.mass( float );
float objectTemplate.mass( float );
int objectTemplate.material( int );
float objectTemplate.maxAngleOfAttack( float );
Vec3 objectTemplate.maxCorner( Vec3 );
float objectTemplate.maxDistance( float );
float objectTemplate.maxDistance( float );
float objectTemplate.maxDistanceUnderWaterSurface( float );
U32 objectTemplate.maxNrOfObjectSpawned( U32 );
Math::Vec3 objectTemplate.maxResetSpeed( Math::Vec3 );
Math::Vec3 objectTemplate.maxRotation( Math::Vec3 );
float objectTemplate.maxSpawnDelay( float );
Math::Vec3 objectTemplate.maxSpeed( Math::Vec3 );
float objectTemplate.maxSpeed( float );
float objectTemplate.maxTracerScaler( float );
float objectTemplate.maxTriggerDistance( float );
float objectTemplate.maxVertRegAngle( float );
float objectTemplate.mediumDistance( float );
float objectTemplate.mediumMaxDamage( float );
float objectTemplate.mediumMinDamage( float );
int objectTemplate.mediumSamples( int );
Vec3 objectTemplate.minCorner( Vec3 );
float objectTemplate.minDistance( float );
float objectTemplate.minDistanceUnderWaterSurface( float );
float objectTemplate.minHeightAdjustDistance( float );
int objectTemplate.minimumSquadSizeForSelection( int );
float objectTemplate.minimumTimeBetweenTriggering( float );
Math::Vec3 objectTemplate.minRotation( Math::Vec3 );
float objectTemplate.minSpawnDelay( float );
float objectTemplate.minTimeBetweenActivation( float );
float objectTemplate.minTracerScaler( float );
float objectTemplate.minTrailVelocity( float );
float objectTemplate.motionSensor.pingInterval( float );
float objectTemplate.motionSensor.sensingRadius( float );
float objectTemplate.motionSensor.showEnemiesDuration( float );
bool objectTemplate.movableTeamSpawn( bool );
float objectTemplate.multiply( float );
std::string objectTemplate.name( void );
int objectTemplate.nametag.3dMapIcon( int );
Vec3 objectTemplate.nametag.3dMapIconOffset( Vec3 );
int objectTemplate.nametag.color( int );
std::string objectTemplate.nametag.get3dMapIconString( int );
bool objectTemplate.nametag.glueToEdge( bool );
bool objectTemplate.nametag.glueToObjectCenter( bool );
float objectTemplate.nametag.healthActivationLevel( float );
int objectTemplate.nametag.iconSize( int );
bool objectTemplate.nametag.inverseTeamSpecific( bool );
float objectTemplate.nametag.maxDistance( float );
float objectTemplate.nametag.maxEnemyDistance( float );
bool objectTemplate.nametag.onlyShowNeutral( bool );
bool objectTemplate.nametag.opposingIcons( bool );
int objectTemplate.nametag.secondary3dMapIcon( int );
bool objectTemplate.nametag.selectable( bool );
int objectTemplate.nametag.selected3dMapIcon( int );
void objectTemplate.nametag.set3dMapIconString( int, std::string );
bool objectTemplate.nametag.show3dIcon( bool );
bool objectTemplate.Nametag.showArmor( bool );
bool objectTemplate.nametag.showDistance( bool );
bool objectTemplate.nametag.showIcon( bool );
bool objectTemplate.nametag.showIconOnTracker( bool );
bool objectTemplate.nametag.showInside( bool );
bool objectTemplate.nametag.showItem( bool );
bool objectTemplate.nametag.showName( bool );
bool objectTemplate.nametag.showOutside( bool );
bool objectTemplate.Nametag.showSupply( bool );
bool objectTemplate.nametag.teamSpecific( bool );
bool objectTemplate.Nametag.useAliveArmor( bool );
bool objectTemplate.nametag.useBoundingRadius( bool );
bool objectTemplate.nametag.useStrategicObj( bool );
bool objectTemplate.nametag.useTeamColor( bool );
float objectTemplate.nametagDetection.detectionDotAngle( float );
std::string objectTemplate.nameToLookAt( std::string );
bool objectTemplate.nearCullingEnable( bool );
std::string objectTemplate.networkableInfo( std::string );
std::string objectTemplate.networkableInfo( std::string );
bool objectTemplate.neverDrawAs1p( bool );
float objectTemplate.newCar2.brakeTorque( float );
float objectTemplate.newCar2.engineBrakeTorque( float );
float objectTemplate.newCar2.engineFeedbackMod( float );
float objectTemplate.newCar2.frictionMod( float );
float objectTemplate.newCar2.frictionTorque( float );
float objectTemplate.newCar2.maxRpm( float );
float objectTemplate.newCar2.minRpm( float );
float objectTemplate.newCar2.slopeTorqueMod( float );
bool objectTemplate.newCar2.useClutchedTorque( bool );
float objectTemplate.newCar2.wheelInertia( float );
float objectTemplate.newCar2.wheelLatDriveFrictionMod( float );
float objectTemplate.newCar2.wheelLatFrictionMod( float );
float objectTemplate.newCar2.wheelLatMinDynamicFriction( float );
float objectTemplate.newCar2.wheelLatPeakAt( float );
float objectTemplate.newCar2.wheelLatScale( float );
float objectTemplate.newCar2.wheelLongDriveFrictionMod( float );
float objectTemplate.newCar2.wheelLongFrictionMod( float );
float objectTemplate.newCar2.wheelLongMinDynamicFriction( float );
float objectTemplate.newCar2.wheelLongPeakAt( float );
float objectTemplate.newCar2.wheelLongScale( float );
int objectTemplate.nextCpId( int );
int objectTemplate.nextTaskId( int );
int objectTemplate.nextTriggerId( int );
float objectTemplate.noEffectAtPerpSpeed( float );
bool objectTemplate.noInitialCollisionWithLauncher( bool );
bool objectTemplate.noInitialCollisionWithLauncher( bool );
bool objectTemplate.noPhysics( bool );
bool objectTemplate.noPowerWhenUpsideDown( bool );
float objectTemplate.noPropellerEffectAtSpeed( float );
bool objectTemplate.noRotationFromParent( bool );
Vec3 objectTemplate.nosePos( Vec3 );
float objectTemplate.noSoldierCollisionTimer( float );
float objectTemplate.noVertRegAngle( float );
int objectTemplate.nrOfObjectToSpawn( int );
int objectTemplate.numberOfGears( int );
int objectTemplate.numNetworkedEffects( int );
int objectTemplate.numPlanes( int );
bool objectTemplate.objectShadows( bool );
Vec3 objectTemplate.offset( Vec3 );
Vec3 objectTemplate.offsetToLookAt( Vec3 );
int objectTemplate.onActivatedTriggerId( int );
WeaponItemType objectTemplate.onActivateWeaponItemType( WeaponItemType );
int objectTemplate.onDestroyNumberOfTargets( int );
int objectTemplate.onDestroyTargetsWithGroupId( int );
int objectTemplate.onlyDetonateOnMaterial( int );
float objectTemplate.onlyDetonateOnMaterialTimeLimit( float );
bool objectTemplate.onlyLoadIfGenericFirearmEquipped( bool );
U32 objectTemplate.onlyTakeableByTeam( U32 );
bool objectTemplate.onlyWhenOccupied( bool );
int objectTemplate.onMoveToCPId( int );
int objectTemplate.otherCollisionLod( int );
int objectTemplate.otherCollisionLod( int );
float objectTemplate.overheatPenalty( float );
bool objectTemplate.overrideArmingSpeed( bool );
float objectTemplate.pan( float );
float objectTemplate.ParticleMaxSize( float );
int objectTemplate.particleShaderType( int );
int objectTemplate.particleShaderType( int );
int objectTemplate.particleShaderType( int );
std::string objectTemplate.particleSystemTemplate( std::string );
std::string objectTemplate.particleType( std::string );
float objectTemplate.pauseTimeOnTaskComplete( float );
float objectTemplate.pauseTimeShowNewTask( float );
float objectTemplate.pauseTimeShowTaskComplete( float );
int objectTemplate.pcoId( int );
bool objectTemplate.penetrate.allowLiquidPenetration( bool );
bool objectTemplate.penetrate.allowSolidPenetration( bool );
float objectTemplate.percentDamage( float );
int objectTemplate.physicsFrequency( int );
float objectTemplate.physicsMod.activationDelay( float );
void objectTemplate.physicsMod.amplifiedForceSpan( float, float );
bool objectTemplate.physicsMod.amplifyCollision( bool );
void objectTemplate.physicsMod.angleSpan( int, float, float );
float objectTemplate.physicsMod.maxAllowedSpeed( float );
PhysicsType objectTemplate.physicsType( PhysicsType );
PhysicsType objectTemplate.physicsType( PhysicsType );
PhysicsType objectTemplate.physicsType( PhysicsType );
bool objectTemplate.pickupEnabled( bool );
float objectTemplate.pitch( float );
std::string objectTemplate.pitchEnvelope( std::string );
float objectTemplate.pitchOffset( float );
Vec2 objectTemplate.pivotOffset( Vec2 );
Vec2 objectTemplate.pivotOffset( Vec2 );
Math::Vec3 objectTemplate.PivotPosition( Math::Vec3 );
bool objectTemplate.playAtEventPosition( bool );
bool objectTemplate.playCaptureMessage( bool );
bool objectTemplate.playerOnEnable( bool );
std::string objectTemplate.podSpawnVehicle( std::string );
Vec3 objectTemplate.portalPassingPosition( Vec3 );
Vec3 objectTemplate.portraitCameraOffset( Vec3 );
Vec3 objectTemplate.portraitCameraTarget( Vec3 );
Vec3 objectTemplate.portraitLightPosition( Vec3 );
void objectTemplate.poseCameraPosition( int, Vec3 );
Vec3 objectTemplate.position( Vec3 );
RandomDistribution objectTemplate.positionalSpeedInDof( RandomDistribution );
RandomDistribution objectTemplate.positionalSpeedInRight( RandomDistribution );
RandomDistribution objectTemplate.positionalSpeedInUp( RandomDistribution );
Math::Vec3 objectTemplate.positionOffset( Math::Vec3 );
float objectTemplate.positionToleranceXZ( float );
VehiclePositionType objectTemplate.positionType( VehiclePositionType );
float objectTemplate.postProcess.tvDistortionFreq( float );
float objectTemplate.postProcess.tvDistortionRoll( float );
float objectTemplate.postProcess.tvDistortionScale( float );
float objectTemplate.postProcess.tvInterference( float );
bool objectTemplate.preCacheObject( bool );
float objectTemplate.preWarmTime( float );
int objectTemplate.projectileSubGeom( int );
std::string objectTemplate.projectileTemplate( std::string );
bool objectTemplate.projectOnHeightmap( bool );
bool objectTemplate.projectorApplyMask( bool );
float objectTemplate.projectorAspect( float );
float objectTemplate.projectorFar( float );
float objectTemplate.projectorFov( float );
float objectTemplate.projectorNear( float );
std::string objectTemplate.projectorTexture( std::string );
float objectTemplate.proneDelayAfterJump( float );
float objectTemplate.proneDelayFromStand( float );
float objectTemplate.pulse.fov( float );
int objectTemplate.pulse.revealTime( int );
float objectTemplate.pulse.viewDistance( float );
bool objectTemplate.pureRotational( bool );
int objectTemplate.python.onDamageEvent( int );
int objectTemplate.python.onDestroyEvent( int );
int objectTemplate.python.onRepairEvent( int );
int objectTemplate.python.onSpawnEvent( int );
std::string objectTemplate.qualityLevel( std::string );
std::string objectTemplate.QualityLevel( std::string );
float objectTemplate.radialDirection( float );
int objectTemplate.radio.closeToIndicationDist( int );
int objectTemplate.radio.closeToIndicationType( int );
std::string objectTemplate.radio.damageMessage( std::string );
int objectTemplate.radio.delay( int );
int objectTemplate.radio.destroyedGameEvent( int );
std::string objectTemplate.radio.destroyedMessage( std::string );
std::string objectTemplate.radio.enemyDestroyedMessage( std::string );
std::string objectTemplate.radio.enemyFireMessage( std::string );
std::string objectTemplate.radio.enemyNotTakeableMessage( std::string );
std::string objectTemplate.radio.enemySpawnMessage( std::string );
std::string objectTemplate.radio.enemyTakeableMessage( std::string );
std::string objectTemplate.radio.enemyTeamChangeMessage( std::string );
std::string objectTemplate.radio.failMessage( std::string );
std::string objectTemplate.radio.friendlyDestroyedMessage( std::string );
std::string objectTemplate.radio.friendlyFireMessage( std::string );
std::string objectTemplate.radio.friendlyNotTakeableMessage( std::string );
std::string objectTemplate.radio.friendlySpawnMessage( std::string );
std::string objectTemplate.radio.friendlyTakeableMessage( std::string );
std::string objectTemplate.radio.friendlyTeamChangeMessage( std::string );
bool objectTemplate.radio.indicationDistance2D( bool );
std::string objectTemplate.radio.neutralTeamChangeMessage( std::string );
std::string objectTemplate.radio.repairedMessage( std::string );
std::string objectTemplate.radio.spottedMessage( std::string );
std::string objectTemplate.radio.useMessage( std::string );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.radius( float );
float objectTemplate.ragdollLandedDelay( float );
float objectTemplate.raiseVictimCam( float );
RandomDistribution objectTemplate.randomAgeFactor( RandomDistribution );
float objectTemplate.randomColorIntensity( float );
Vec3 objectTemplate.randomDirectionAngle( Vec3 );
float objectTemplate.randomIntensity( float );
int objectTemplate.randomMode( int );
float objectTemplate.randomRadialDirection( float );
float objectTemplate.randomRotation( float );
Vec3 objectTemplate.randomRotation( Vec3 );
Vec3 objectTemplate.randomRotation( Vec3 );
float objectTemplate.randomRotation( float );
float objectTemplate.randomRotation( float );
Vec3 objectTemplate.randomRotationSpeed( Vec3 );
Vec3 objectTemplate.randomRotationSpeed( Vec3 );
float objectTemplate.randomRotationSpeed( float );
float objectTemplate.randomRotationSpeed( float );
float objectTemplate.randomSize( float );
float objectTemplate.randomSize( float );
float objectTemplate.randomSpeed( float );
float objectTemplate.randomTimeToLive( float );
RemoteControlledObjectType objectTemplate.rcType( RemoteControlledObjectType );
void objectTemplate.readBinary( std::string );
float objectTemplate.recoil.cameraRecoilSize( float );
float objectTemplate.recoil.cameraRecoilSpeed( float );
bool objectTemplate.recoil.goBackOnRecoil( bool );
bool objectTemplate.recoil.hasRecoilForce( bool );
float objectTemplate.recoil.recoilForce( float );
RandomDistribution objectTemplate.recoil.recoilForceLeftRight( RandomDistribution );
RandomDistribution objectTemplate.recoil.recoilForceUp( RandomDistribution );
float objectTemplate.recoil.recoilGraphExponent( float );
int objectTemplate.recoil.recoilGraphFrameCount( int );
float objectTemplate.recoil.recoilGraphTotalMovement( float );
float objectTemplate.recoil.recoilSize( float );
float objectTemplate.recoil.recoilSpeed( float );
float objectTemplate.recoil.recoilSpeedGB( float );
float objectTemplate.recoil.zoomModifier( float );
int objectTemplate.referencePointId( int );
float objectTemplate.refillAmmoSpeed( float );
int objectTemplate.regulateFromParent( int );
int objectTemplate.regulateFromParentPos( int );
Vec2 objectTemplate.regulatePitch( Vec2 );
Vec2 objectTemplate.regulatePitch( Vec2 );
float objectTemplate.regulatePitchFactor( float );
io::PlayerInputMap objectTemplate.regulatePitchInput( io::PlayerInputMap );
Vec2 objectTemplate.regulatePosX( Vec2 );
Vec2 objectTemplate.regulatePosY( Vec2 );
Vec2 objectTemplate.regulatePosZ( Vec2 );
Vec2 objectTemplate.regulateRoll( Vec2 );
Vec2 objectTemplate.regulateRoll( Vec2 );
float objectTemplate.regulateRollFactor( float );
io::PlayerInputMap objectTemplate.regulateRollInput( io::PlayerInputMap );
float objectTemplate.regulateToLift( float );
Vec3 objectTemplate.regulateVector( Vec3 );
Vec2 objectTemplate.regulateVerticalPos( Vec2 );
io::PlayerInputMap objectTemplate.regulateVerticalPosInput( io::PlayerInputMap );
Vec2 objectTemplate.regulateYaw( Vec2 );
float objectTemplate.regulateYawFactor( float );
io::PlayerInputMap objectTemplate.regulateYawInput( io::PlayerInputMap );
float objectTemplate.regulationTolerance( float );
RandomDistribution objectTemplate.relativePositionInDof( RandomDistribution );
RandomDistribution objectTemplate.relativePositionInRight( RandomDistribution );
RandomDistribution objectTemplate.relativePositionInUp( RandomDistribution );
Vec3 objectTemplate.relativePositionOffset( Vec3 );
uint objectTemplate.relativeYCollisionGroupInverse( uint );
bool objectTemplate.rememberExcessInput( bool );
float objectTemplate.remoteControl.activationDelay( float );
float objectTemplate.remoteControl.selfDestructAtTime( float );
float objectTemplate.remoteControl.throttleValue( float );
bool objectTemplate.removeAtPlayerDeath( bool );
void objectTemplate.removeTemplate( int );
void objectTemplate.replaceItem( std::string );
bool objectTemplate.replaceWithoutEquip( bool );
bool objectTemplate.requiresSkill( bool );
bool objectTemplate.requiresSkill( bool );
float objectTemplate.respawnDelay( float );
float objectTemplate.respawnDelay( float );
float objectTemplate.respawnDelay( float );
bool objectTemplate.restoreRotationOnExit( bool );
float objectTemplate.reverbLevel( float );
bool objectTemplate.rotateAsAnimatedUV( bool );
std::string objectTemplate.rotateAsAnimatedUVObject( std::string );
bool objectTemplate.rotateAsAnimatedUVReverse( bool );
bool objectTemplate.rotateUV( bool );
float objectTemplate.rotation( float );
Vec3 objectTemplate.rotationalForce( Vec3 );
RandomDistribution objectTemplate.rotationalSpeedInDof( RandomDistribution );
RandomDistribution objectTemplate.rotationalSpeedInRight( RandomDistribution );
RandomDistribution objectTemplate.rotationalSpeedInUp( RandomDistribution );
int objectTemplate.rotationAxle( int );
Vec4 objectTemplate.rotationGraph( Vec4 );
Vec3 objectTemplate.rotationSpeed( Vec3 );
Vec3 objectTemplate.rotationSpeed( Vec3 );
float objectTemplate.rotationSpeed( float );
float objectTemplate.rotationSpeed( float );
float objectTemplate.rotationSpeedMod( float );
float objectTemplate.rotationSpeedModBlur( float );
Math::Vec3 objectTemplate.runningAwayDistances( Math::Vec3 );
int objectTemplate.runningAwayReferencePointId( int );
float objectTemplate.saturation( float );
bool ObjectTemplate.save( world::IObjectTemplate_ptrproxy );
bool objectTemplate.saveInSeparateFile( bool );
Vec3 objectTemplate.scale( Vec3 );
bool objectTemplate.scaleInputOnCriticalDamage( bool );
float objectTemplate.score.xpDamageMod( float );
float objectTemplate.score.xpHealMod( float );
std::string objectTemplate.seatAnimationSystem( std::string );
std::string objectTemplate.seatAnimationSystem( std::string );
void objectTemplate.seatInformation( std::string, Vec3, Vec3 );
void objectTemplate.seatInformation( std::string, Vec3, Vec3 );
void objectTemplate.SeatLookLimitDown( float, bool );
float objectTemplate.seatLookLimitLeft( float );
float objectTemplate.seatLookLimitRight( float );
void objectTemplate.SeatLookLimitUp( float, bool );
float objectTemplate.seatRotateBodyStartLeft( float );
float objectTemplate.seatRotateBodyStartRight( float );
HealthTypeSeen objectTemplate.seeHealth.healthTypeSeen( HealthTypeSeen );
TeamSeen objectTemplate.seeHealth.teamSeen( TeamSeen );
float objectTemplate.seek.directionBonus( float );
float objectTemplate.seek.distLoseLock( float );
bool objectTemplate.seek.ignoreFriendly( bool );
float objectTemplate.seek.maxAngleLock( float );
float objectTemplate.seek.maxDistLock( float );
float objectTemplate.seek.reLockTime( float );
TargetType objectTemplate.seek.targetType( TargetType );
TargetType objectTemplate.seek.targetType( TargetType );
float objectTemplate.seek.trackingDelay( float );
float objectTemplate.seek.trackingDelay( float );
bool objectTemplate.selfLights( bool );
float objectTemplate.selfShadowIntensity( float );
float objectTemplate.selfShadowIntensity( float );
bool objectTemplate.selfShadows( bool );
void objectTemplate.setActiveTemplate( int );
void objectTemplate.setAIEnterOnSpawn( bool );
void objectTemplate.setAllowSpawnCloseToVehicle( bool );
void objectTemplate.setAnimationFrameHeightRelative( float );
void objectTemplate.setAnimationFrameHeightRelative( float );
void objectTemplate.setAnimationFrameHeightRelative( float );
void objectTemplate.setAnimationFrameHeightRelative( float );
void objectTemplate.setAnimationFrameWidthRelative( float );
void objectTemplate.setAnimationFrameWidthRelative( float );
void objectTemplate.setAnimationFrameWidthRelative( float );
void objectTemplate.setAnimationFrameWidthRelative( float );
void objectTemplate.setChaseAngle( Vec3, int );
void objectTemplate.setChaseDistance( float, int );
void objectTemplate.setChaseOffset( Vec3, int );
void objectTemplate.setCheckObstruction( float, float, float );
void objectTemplate.setCollisionMesh( std::string );
void objectTemplate.setEnterOnSpawn( bool );
void objectTemplate.setExplodePartAtDestroy( bool );
void objectTemplate.setFreeCamShakeParams( float, float, float );
void objectTemplate.setGearRatios( float, float, float, float, float );
void objectTemplate.setHasTarget( bool );
void objectTemplate.setHeatBarType( heatBarType );
void objectTemplate.setIfTitanChangeToWeapon( std::string, float );
void objectTemplate.setIntermediateDistance( float, int );
void objectTemplate.setIsSpawnRapeSpawnPoint( bool );
void objectTemplate.setIsTutorialSpawnPoint( bool );
void objectTemplate.setMatchItem( std::string );
void objectTemplate.setMinChaseAngle( Vec3, int );
void objectTemplate.setMinChaseDistance( float, int );
void objectTemplate.setMinChaseOffset( Vec3, int );
void objectTemplate.setMoveToIntermediateSpeed( float, int );
void objectTemplate.setNotMatchItem( std::string );
void objectTemplate.setNumWindows( int );
void objectTemplate.setObjectTemplate( int, std::string );
void objectTemplate.setOnlyForAI( bool );
void objectTemplate.setOnlyForHuman( bool );
float objectTemplate.setPlayerHealthPercent( float );
void objectTemplate.setPosition( Math::Vec3, int );
void objectTemplate.setReplaceItem( std::string );
void objectTemplate.setRotation( Math::Vec3, int );
void objectTemplate.setScatterSpawnPositions( bool );
void objectTemplate.setSkeletonCollisionBone( std::string, int, Vec3, float, float, int );
void objectTemplate.setSoldierExitLocation( Vec3, Vec3 );
void objectTemplate.setSpawnPositionOffset( Math::Vec3 );
bool objectTemplate.setTeamOnSpawn( bool );
void objectTemplate.setVanityCamDistance( float, int );
void objectTemplate.setVanityCamHeight( float, int );
void objectTemplate.setVanityCamLookHeight( float, int );
void objectTemplate.setVehicleType( dice::hfe::world::VehicleType );
void objectTemplate.setZoomChaseAngle( Vec3, int );
void objectTemplate.setZoomChaseDistance( float, int );
void objectTemplate.setZoomChaseOffset( Vec3, int );
float objectTemplate.shadowIntensity( float );
float objectTemplate.shakeFactor( float );
float objectTemplate.sharedStorageSize( float );
bool objectTemplate.showInFirstPerson( bool );
bool objectTemplate.showInFirstPerson( bool );
bool objectTemplate.showInThirdPerson( bool );
bool objectTemplate.showInThirdPerson( bool );
bool objectTemplate.showInZoomedMode( bool );
bool objectTemplate.showInZoomedMode( bool );
bool objectTemplate.showOnMinimap( bool );
float objectTemplate.size( float );
RandomDistribution objectTemplate.size( RandomDistribution );
Vec4 objectTemplate.sizeGraph( Vec4 );
Vec3 objectTemplate.sizeModifier( Vec3 );
void objectTemplate.skeleton( std::string );
void objectTemplate.skeleton1P( std::string );
void objectTemplate.skeleton3P( std::string );
void objectTemplate.skill.addInteractionSkill( GLInteractionType );
void objectTemplate.skill.addPositionTypeSkill( VehiclePositionType );
void objectTemplate.skill.addReceiveRepairFromSupplyObjectSkill( VehicleCategory );
void objectTemplate.skill.addWeaponSkill( WeaponItemType );
bool objectTemplate.snapToZeroOnNoInput( bool );
float objectTemplate.softness( float );
float objectTemplate.soldierAcceleration( float );
float objectTemplate.soldierCrawlSpeed( float );
float objectTemplate.soldierCrouchSpeed( float );
float objectTemplate.soldierDeceleration( float );
Vec3 objectTemplate.soldierExitPosition( Vec3 );
Vec3 objectTemplate.soldierExitRotation( Vec3 );
Vec3 objectTemplate.soldierExitSpeed( Vec3 );
float objectTemplate.soldierInAirSpeed( float );
float objectTemplate.soldierJumpFactor( float );
float objectTemplate.soldierJumpLengthFactor( float );
float objectTemplate.soldierRunSpeed( float );
float objectTemplate.soldierSkyDiveAtSpeed( float );
float objectTemplate.soldierSkyDiveSpeed( float );
float objectTemplate.soldierSpeedFactor( float );
float objectTemplate.soldierSprintDissipationTime( float );
float objectTemplate.soldierSprintLimit( float );
float objectTemplate.soldierSprintRecoverTime( float );
float objectTemplate.soldierSprintSpeed( float );
float objectTemplate.soldierSwimCrawlSpeed( float );
float objectTemplate.soldierSwimSpeed( float );
float objectTemplate.soldierTimeToEnableWeapon( float );
float objectTemplate.soldierWalkSpeed( float );
void objectTemplate.sound.addReloadTimeSound( int, int );
std::string objectTemplate.sound.fileName( std::string );
float objectTemplate.sound.halfVolumeDistance( float );
bool objectTemplate.sound.is3dSound( bool );
int objectTemplate.sound.loopCount( int );
int objectTemplate.sound.maxSoundsPerBurst( int );
float objectTemplate.sound.minDistance( float );
bool objectTemplate.sound.muteOnFire( bool );
bool objectTemplate.sound.noisy( bool );
float objectTemplate.sound.pan( float );
float objectTemplate.sound.pitch( float );
float objectTemplate.sound.reverbLevel( float );
int objectTemplate.sound.stopType( int );
float objectTemplate.sound.volume( float );
std::string objectTemplate.sound.volumeEnvelope( std::string );
std::string objectTemplate.soundFilename( std::string );
std::string objectTemplate.soundFilter( std::string );
std::string objectTemplate.soundFilter( std::string );
Vec2 objectTemplate.soundIntensityFromSpeed( Vec2 );
Vec2 objectTemplate.soundIntensityRange( Vec2 );
bool objectTemplate.soundIntensityUsed( bool );
float objectTemplate.soundRadius( float );
float objectTemplate.spacing( float );
bool objectTemplate.spawn.spawnInPod( bool );
float objectTemplate.spawn.spawnRadius( float );
std::string objectTemplate.spawn.spawnVehicle( std::string );
bool objectTemplate.spawnDelayAtStart( bool );
bool objectTemplate.spawnInPod( bool );
Vec3 objectTemplate.spawnOffset( Vec3 );
float objectTemplate.spawnPoint.radius( float );
bool objectTemplate.spawnUsedVehicle( bool );
Vec3ColorFloatIntensity objectTemplate.speccolor( Vec3ColorFloatIntensity );
io::PlayerInputMap objectTemplate.specialToggleWeaponInput( io::PlayerInputMap );
float objectTemplate.speed( float );
float objectTemplate.speedFromParticle( float );
bool objectTemplate.speedFromPhysics( bool );
void objectTemplate.speedModifier.addSpeedModifierType( SpeedModifierType );
float objectTemplate.speedModifier.runSoundDuration( float );
float objectTemplate.speedModifier.speedMod( float );
float objectTemplate.speedModifier.sprintSoundDuration( float );
float objectTemplate.spinWhenNoEngineInAir( float );
float objectTemplate.spottedModifier.maxDistanceBetweenEnemies( float );
float objectTemplate.spottedModifier.maxDistanceToEnemy( float );
int objectTemplate.spottedModifier.maxSpotted( int );
float objectTemplate.spottedModifier.maxSpottedFailDistance( float );
float objectTemplate.spottedModifier.spottedDotAngle( float );
float objectTemplate.sprintDissipationTime( float );
float objectTemplate.sprintDissipationTime( float );
float objectTemplate.sprintFactor( float );
float objectTemplate.sprintLimit( float );
float objectTemplate.sprintLimit( float );
float objectTemplate.sprintLossAtJump( float );
float objectTemplate.sprintRechargeDelayAfterJump( float );
float objectTemplate.sprintRecoverTime( float );
float objectTemplate.sprintRecoverTime( float );
bool objectTemplate.stampLastAction( bool );
float objectTemplate.standDelayFromProne( float );
Vec2 objectTemplate.startAgeFromSpeed( Vec2 );
Vec2 objectTemplate.startAgeRange( Vec2 );
bool objectTemplate.startAgeUsed( bool );
bool objectTemplate.startAtCreation( bool );
bool objectTemplate.startAtCreation( bool );
bool objectTemplate.startAutoRotateOnEnter( bool );
float objectTemplate.startDelay( float );
float objectTemplate.startDelay( float );
float objectTemplate.startDelay( float );
float objectTemplate.startDistance( float );
int objectTemplate.startOnEffects( int );
RandomDistribution objectTemplate.startRotation( RandomDistribution );
std::string objectTemplate.statModifier.operation( std::string );
float objectTemplate.statModifier.value( float );
void objectTemplate.statusGLEffect.effectName( StatusEffect, std::string );
float objectTemplate.stepHeight( float );
int objectTemplate.stopOnEffects( int );
bool objectTemplate.stopRegulateWhenUnoccupied( bool );
int objectTemplate.stopType( int );
int objectTemplate.strategicObject.3dMapIcon( int );
std::string objectTemplate.strategicObject.destroyedIcon( std::string );
std::string objectTemplate.strategicObject.intactIcon( std::string );
bool objectTemplate.strategicObject.isOnePiece( bool );
int objectTemplate.strategicObject.part( int );
std::string objectTemplate.strategicObject.strategicObjectName( std::string );
float objectTemplate.strength( float );
uint objectTemplate.strikeRadius( uint );
int objectTemplate.supplyGroupId( int );
void objectTemplate.supplyGroupNeeded( int, int, bool );
void objectTemplate.supplyModifier.addModifySupply( ModifiesSupplyType, float );
int objectTemplate.supplyValueNeededTeam1( int );
int objectTemplate.supplyValueNeededTeam2( int );
int objectTemplate.supplyValueTeam1( int );
int objectTemplate.supplyValueTeam2( int );
bool objectTemplate.supportsEmitter( bool );
bool objectTemplate.supportsGlow( bool );
bool objectTemplate.supportsPerPixel( bool );
bool objectTemplate.supportsPerVertex( bool );
Vec3 objectTemplate.surpressPlayerInputVector( Vec3 );
float objectTemplate.sway.gunSwayLrDirModifier( float );
float objectTemplate.sway.gunSwayLrDirThreshold( float );
float objectTemplate.sway.gunSwayLrFactor( float );
float objectTemplate.sway.gunSwayLrMax( float );
float objectTemplate.sway.gunSwayLrRandomMax( float );
float objectTemplate.sway.gunSwayLrRandomMin( float );
float objectTemplate.sway.gunSwayLrSmoothFactor( float );
float objectTemplate.sway.gunSwayLrSmoothMax( float );
float objectTemplate.sway.gunSwayLrSmoothThreshold( float );
float objectTemplate.sway.gunSwayLrSteps( float );
float objectTemplate.sway.gunSwayLrUpdateRate( float );
float objectTemplate.sway.gunSwayPitchDirModifier( float );
float objectTemplate.sway.gunSwayPitchDirThreshold( float );
float objectTemplate.sway.gunSwayPitchFactor( float );
float objectTemplate.sway.gunSwayPitchMax( float );
float objectTemplate.sway.gunSwayPitchRandomMax( float );
float objectTemplate.sway.gunSwayPitchRandomMin( float );
float objectTemplate.sway.gunSwayPitchSmoothFactor( float );
float objectTemplate.sway.gunSwayPitchSmoothMax( float );
float objectTemplate.sway.gunSwayPitchSmoothThreshold( float );
float objectTemplate.sway.gunSwayPitchSteps( float );
float objectTemplate.sway.gunSwayPitchUpdateRate( float );
bool objectTemplate.sway.gunSwayUseZoom( bool );
float objectTemplate.sway.gunSwayZoomModifier( float );
float objectTemplate.sway.stabilityDuration( float );
float objectTemplate.sway.stabilityDurationRecoverTime( float );
float objectTemplate.sway.stabilityRecoverTime( float );
float objectTemplate.sway.stabilityTime( float );
bool objectTemplate.switchPlayerOnLock( bool );
float objectTemplate.takeOverDelayTime( float );
bool objectTemplate.takeOverInput( bool );
std::string objectTemplate.target.connectionEffect( std::string );
bool objectTemplate.target.connectionEffectOnlyWhenZoomed( bool );
bool objectTemplate.target.disableFireWhenActiveMissile( bool );
bool objectTemplate.target.disableGuidanceOnReload( bool );
bool objectTemplate.target.dontLooseGuidanceOnObstruction( bool );
float objectTemplate.target.lockAngle( float );
float objectTemplate.target.lockDelay( float );
float objectTemplate.target.loseLockDelay( float );
float objectTemplate.target.maxDistance( float );
bool objectTemplate.target.notifyProjectileOnLostTarget( bool );
void objectTemplate.target.onLockChangeToWeapon( bool, std::string );
bool objectTemplate.target.setTargetAtMaxDistance( bool );
std::string objectTemplate.target.targetObjectTemplate( std::string );
TargetSystem objectTemplate.target.targetSystem( TargetSystem );
bool objectTemplate.target.useCameraDirectionToTarget( bool );
float objectTemplate.target.wireGuidedLookAheadDistance( float );
Vec3 objectTemplate.targetPosition( Vec3 );
TargetType objectTemplate.targetType( TargetType );
float objectTemplate.targetWeight( float );
int objectTemplate.taskId( int );
std::string objectTemplate.taskImageName( std::string );
TutorialTaskType objectTemplate.taskType( TutorialTaskType );
int objectTemplate.team( int );
U32 objectTemplate.team( U32 );
int objectTemplate.team( int );
int objectTemplate.team( int );
void objectTemplate.team( int );
U32 objectTemplate.team( U32 );
float objectTemplate.teamChange.changePoints( float );
int objectTemplate.teamChange.defaultMaterial( int );
float objectTemplate.teamChange.maxChangePoints( float );
bool objectTemplate.teamFromClosestCP( bool );
bool objectTemplate.teamOnVehicle( bool );
int objectTemplate.teamSpecificVisibility( int );
int objectTemplate.teleportReferencePointId( int );
std::string objectTemplate.template( std::string );
bool objectTemplate.templateHasBeenUsed( bool );
uint objectTemplate.testCount( uint );
std::string objectTemplate.textureName( std::string );
std::string objectTemplate.textureName( std::string );
std::string objectTemplate.textureName( std::string );
float objectTemplate.textureOffsetVelocity( float );
float objectTemplate.textureTileFactor( float );
float objectTemplate.ticketMultiplyer( float );
float objectTemplate.timeBetweenHealWaves( float );
float objectTemplate.timeToGetControl( float );
RandomDistribution objectTemplate.timeToLive( RandomDistribution );
RandomDistribution objectTemplate.timeToLive( RandomDistribution );
float objectTemplate.timeToLive( float );
RandomDistribution objectTemplate.timeToLive( RandomDistribution );
RandomDistribution objectTemplate.timeToLive( RandomDistribution );
float objectTemplate.timeToLive( float );
float objectTemplate.timeToLive( float );
float objectTemplate.timeToLoseControl( float );
float objectTemplate.timeUntilTakeable( float );
bool objectTemplate.toggleMouseLook( bool );
bool objectTemplate.toggleWeapon( bool );
float objectTemplate.tolerance( float );
float objectTemplate.torque( float );
float objectTemplate.tracerConvergeDistance( float );
int objectTemplate.tracerInterval( int );
float objectTemplate.tracerScaler( float );
float objectTemplate.tracerSizeModifier( float );
std::string objectTemplate.tracerTemplate( std::string );
float objectTemplate.trackTurnAcceleration( float );
float objectTemplate.trackTurnSpeed( float );
Vec3 objectTemplate.transferCameraRotation( Vec3 );
Vec3 objectTemplate.transferParentRotation( Vec3 );
RandomDistribution objectTemplate.Transparency( RandomDistribution );
Vec4 objectTemplate.transparencyGraph( Vec4 );
Vec4 objectTemplate.transparencyGraph( Vec4 );
Vec4 objectTemplate.transparencyGraph( Vec4 );
float objectTemplate.treeCollisionDiameter( float );
bool objectTemplate.triggerForEachActivatingPlayer( bool );
int objectTemplate.triggerId( int );
int objectTemplate.triggerId( int );
int objectTemplate.triggerId( int );
float objectTemplate.turnVelocity( float );
int objectTemplate.tutorialTaskId( int );
ItemContainerType objectTemplate.type( ItemContainerType );
float objectTemplate.uavVehicleFlightHeight( float );
float objectTemplate.uavVehicleRadius( float );
float objectTemplate.uavVehicleSampleResolution( float );
float objectTemplate.uavVehicleSpeed( float );
std::string objectTemplate.uavVehicleTemplate( std::string );
bool objectTemplate.unableToChangeTeam( bool );
bool objectTemplate.unstealthOnDeploy( bool );
float objectTemplate.unstealthTimeOnFire( float );
float objectTemplate.upgradeWeapon.abilityAmmoCompUsageIntervalMod( float );
float objectTemplate.upgradeWeapon.abilityAmmoCompUsageIntervalReplace( float );
void objectTemplate.upgradeWeapon.addApplyToAssetId( int );
void objectTemplate.upgradeWeapon.addApplyToWeaponItemType( WeaponItemType );
void objectTemplate.upgradeWeapon.addCustomGeometry( std::string );
void objectTemplate.upgradeWeapon.addCustomVisualAttachment( std::string, uint, uint );
int objectTemplate.upgradeWeapon.ammoCompMagSizeMod( int );
int objectTemplate.upgradeWeapon.ammoCompMagSizeReplace( int );
float objectTemplate.upgradeWeapon.ammoCompMinimumTimeUntilReloadMod( float );
float objectTemplate.upgradeWeapon.ammoCompMinimumTimeUntilReloadReplace( float );
int objectTemplate.upgradeWeapon.ammoCompNrOfMagsMod( int );
int objectTemplate.upgradeWeapon.ammoCompNrOfMagsReplace( int );
float objectTemplate.upgradeWeapon.ammoCompReloadTimeMod( float );
float objectTemplate.upgradeWeapon.ammoCompReloadTimeReplace( float );
std::string objectTemplate.upgradeWeapon.animationCompRootTriggerName1p( std::string );
std::string objectTemplate.upgradeWeapon.animationCompRootTriggerName3p( std::string );
int objectTemplate.upgradeWeapon.animationCompZoomMessageTrigger1p( int );
int objectTemplate.upgradeWeapon.animationCompZoomMessageTrigger3p( int );
UpgradeWeaponTypes objectTemplate.upgradeWeapon.appliesTo( UpgradeWeaponTypes );
bool objectTemplate.upgradeWeapon.appliesToVehicleWeapons( bool );
float objectTemplate.upgradeWeapon.detonationCompExplosionDamageMod( float );
float objectTemplate.upgradeWeapon.detonationCompExplosionForceMod( float );
float objectTemplate.upgradeWeapon.detonationCompExplosionRadiusMod( float );
float objectTemplate.upgradeWeapon.detonationCompHotSpotRadiusPercentMod( float );
float objectTemplate.upgradeWeapon.detonationCompTriggerRadiusMod( float );
float objectTemplate.upgradeWeapon.deviationCompDevModZoomMod( float );
float objectTemplate.upgradeWeapon.deviationCompDevModZoomReplace( float );
float objectTemplate.upgradeWeapon.deviationCompMinDevMod( float );
float objectTemplate.upgradeWeapon.deviationCompMinDevModZoomMod( float );
float objectTemplate.upgradeWeapon.deviationCompMinDevModZoomReplace( float );
float objectTemplate.upgradeWeapon.deviationCompMinDevReplace( float );
void objectTemplate.upgradeWeapon.deviationCompSetFireDevMod( float, float, float );
void objectTemplate.upgradeWeapon.deviationCompSetFireDevReplace( float, float, float );
int objectTemplate.upgradeWeapon.fireCompBatchSizeMod( int );
int objectTemplate.upgradeWeapon.fireCompBatchSizeReplace( int );
int objectTemplate.upgradeWeapon.fireCompMaxProjectilesInWorldMod( int );
int objectTemplate.upgradeWeapon.fireCompMaxProjectilesInWorldReplace( int );
bool objectTemplate.upgradeWeapon.isUsingSilencer( bool );
float objectTemplate.upgradeWeapon.projectileGravityModifierMod( float );
float objectTemplate.upgradeWeapon.projectileGravityModifierReplace( float );
float objectTemplate.upgradeWeapon.projectileInitialMaxDamageMod( float );
float objectTemplate.upgradeWeapon.projectileInitialMaxDamageReplace( float );
float objectTemplate.upgradeWeapon.projectileInitialMinDamageMod( float );
float objectTemplate.upgradeWeapon.projectileInitialMinDamageReplace( float );
float objectTemplate.upgradeWeapon.projectileLongDistanceMod( float );
float objectTemplate.upgradeWeapon.projectileLongDistanceReplace( float );
float objectTemplate.upgradeWeapon.projectileLongMaxDamageMod( float );
float objectTemplate.upgradeWeapon.projectileLongMaxDamageReplace( float );
float objectTemplate.upgradeWeapon.projectileLongMinDamageMod( float );
float objectTemplate.upgradeWeapon.projectileLongMinDamageReplace( float );
float objectTemplate.upgradeWeapon.projectileMediumDistanceMod( float );
float objectTemplate.upgradeWeapon.projectileMediumDistanceReplace( float );
float objectTemplate.upgradeWeapon.projectileMediumMaxDamageMod( float );
float objectTemplate.upgradeWeapon.projectileMediumMaxDamageReplace( float );
float objectTemplate.upgradeWeapon.projectileMediumMinDamageMod( float );
float objectTemplate.upgradeWeapon.projectileMediumMinDamageReplace( float );
RandomDistribution objectTemplate.upgradeWeapon.projectileTimeToLiveMod( RandomDistribution );
RandomDistribution objectTemplate.upgradeWeapon.projectileTimeToLiveReplace( RandomDistribution );
float objectTemplate.upgradeWeapon.projectileVelocityMod( float );
float objectTemplate.upgradeWeapon.projectileVelocityReplace( float );
RandomDistribution objectTemplate.upgradeWeapon.recoilCompRecoilForceLeftRightMod( RandomDistribution );
RandomDistribution objectTemplate.upgradeWeapon.recoilCompRecoilForceLeftRightReplace( RandomDistribution );
RandomDistribution objectTemplate.upgradeWeapon.recoilCompRecoilForceUpMod( RandomDistribution );
RandomDistribution objectTemplate.upgradeWeapon.recoilCompRecoilForceUpReplace( RandomDistribution );
float objectTemplate.upgradeWeapon.recoilCompZoomModifierMod( float );
float objectTemplate.upgradeWeapon.recoilCompZoomModifierReplace( float );
float objectTemplate.upgradeWeapon.targetCompMaxTargetDistanceMod( float );
float objectTemplate.upgradeWeapon.targetCompMaxTargetDistanceReplace( float );
int objectTemplate.upgradeWeapon.weaponHudAltGuiIndexReplace( int );
int objectTemplate.upgradeWeapon.weaponHudGuiIndexReplace( int );
void objectTemplate.upgradeWeapon.zoomCompAddZoomFactorReplace( float, CameraViewMode );
bool objectTemplate.upgradeWeapon.zoomCompApplyDOFOnZoomReplace( bool );
float objectTemplate.upgradeWeapon.zoomCompChangeFovDelayReplace( float );
bool objectTemplate.upgradeWeapon.zoomCompDisableMuzzleWhenZoomedReplace( bool );
bool objectTemplate.upgradeWeapon.zoomCompHideOnZoomReplace( bool );
float objectTemplate.upgradeWeapon.zoomCompMouseSpeedModReplace( float );
bool objectTemplate.upgradeWeapon.zoomCompPreventZoomWhen3PReplace( bool );
bool objectTemplate.upgradeWeapon.zoomCompUseZoomFineTuningReplace( bool );
float objectTemplate.upgradeWeapon.zoomCompZoomDelayReplace( float );
float objectTemplate.upgradeWeapon.zoomCompZoomedWeaponRenderFOVReplace( float );
int objectTemplate.upgradeWeapon.zoomCompZoomFineTuneStepsReplace( int );
bool objectTemplate.upgradeWeapon.zoomCompZoomFineTuningNeedsUnlockReplace( bool );
int objectTemplate.upgradeWeapon.zoomCompZoomLodReplace( int );
bool objectTemplate.upgradeWeapon.zoomCompZoomOutOnReloadReplace( bool );
bool objectTemplate.upgradeWeapon.zoomCompZoomWhenBusyReplace( bool );
bool objectTemplate.useAbsoluteDirection( bool );
float objectTemplate.useButtonRadius( float );
bool objectTemplate.useColorTransform( bool );
void objectTemplate.useCount.addApplyToWeaponItemType( WeaponItemType );
bool objectTemplate.usedByAi( bool );
bool objectTemplate.useDeAcceleration( bool );
bool objectTemplate.usedOnTransparentSurface( bool );
bool objectTemplate.useInstantAmmoRefillOnCategories( bool );
bool objectTemplate.useObjectCollision( bool );
bool objectTemplate.useProjectileCamera( bool );
dice::hfe::world::VehicleCategory objectTemplate.vehicleCategory( dice::hfe::world::VehicleCategory );
float objectTemplate.vehicleCollisionAngleLeftRight( float );
float objectTemplate.vehicleCollisionAngleUpMax( float );
float objectTemplate.vehicleCollisionAngleUpMin( float );
void objectTemplate.vehicleCollisionModifier( int, float, float );
float objectTemplate.vehicleCrushImpulseModifier( float );
std::string objectTemplate.vehicleHud.AbilityIcon( std::string );
void objectTemplate.vehicleHud.addAbilityIcon( std::string );
void objectTemplate.vehicleHud.addShowOnCamMode( int );
void objectTemplate.vehicleHud.addVehicleIcon( std::string );
bool objectTemplate.vehicleHud.alwaysShowOnMinimap( bool );
bool objectTemplate.vehicleHud.canBeSpotted( bool );
bool objectTemplate.vehicleHud.disableOnSprint( bool );
bool objectTemplate.vehicleHud.displaySelectionOnEnter( bool );
bool objectTemplate.vehicleHud.enablePostProcessingOnGuiIndex( bool );
bool objectTemplate.vehicleHud.getShowOnCamMode( int );
int objectTemplate.vehicleHud.guiIndex( int );
bool objectTemplate.vehicleHud.hasTurretIcon( bool );
std::string objectTemplate.vehicleHud.hudName( std::string );
std::string objectTemplate.vehicleHud.injurySound( std::string );
bool objectTemplate.vehicleHud.isCoDriver( bool );
std::string objectTemplate.vehicleHud.kitAbility( std::string );
std::string objectTemplate.vehicleHud.kitAbilityBg( std::string );
int objectTemplate.vehicleHud.maxClimbSpeed( int );
std::string objectTemplate.vehicleHud.miniMapBackgroundIcon( std::string );
std::string objectTemplate.vehicleHud.miniMapIcon( std::string );
std::string objectTemplate.vehicleHud.miniMapIconInside( std::string );
std::string objectTemplate.vehicleHud.miniMapIconLeaderSize( std::string );
Vec2 objectTemplate.vehicleHud.miniMapIconOffset( Vec2 );
Vec2 objectTemplate.vehicleHud.miniMapIconOffsetInside( Vec2 );
Vec2 objectTemplate.vehicleHud.miniMapIconSize( Vec2 );
Vec2 objectTemplate.vehicleHud.miniMapIconSizeInside( Vec2 );
std::string objectTemplate.vehicleHud.miniMapInfo( std::string );
std::string objectTemplate.vehicleHud.miniMapReloadIcon( std::string );
Vec2 objectTemplate.vehicleHud.miniMapReloadIconOffset( Vec2 );
std::string objectTemplate.vehicleHud.pantingSound( std::string );
bool objectTemplate.vehicleHud.sendDestroyedHudEvent( bool );
bool objectTemplate.vehicleHud.showCrossHair( bool );
bool objectTemplate.vehicleHud.showInfo( bool );
int objectTemplate.vehicleHud.showOnCamMode( int );
bool objectTemplate.vehicleHud.showOnEnemyMinimap( bool );
bool objectTemplate.vehicleHud.showOneSecondaryGunnerAngle( bool );
std::string objectTemplate.vehicleHud.spottedIcon( std::string );
int objectTemplate.vehicleHud.spottedIconSize( int );
bool objectTemplate.vehicleHud.standardHelpEnabled( bool );
std::string objectTemplate.vehicleHud.typeIcon( std::string );
bool objectTemplate.vehicleHud.useChildArmor( bool );
bool objectTemplate.vehicleHud.useChildHud( bool );
bool objectTemplate.vehicleHud.usePlayerIcon( bool );
bool objectTemplate.vehicleHud.useSelectionIcons( bool );
bool objectTemplate.vehicleHud.useVehicleCameraRotation( bool );
bool objectTemplate.vehicleHud.useVehicleCommRose( bool );
std::string objectTemplate.vehicleHud.vehicleIcon( std::string );
Vec2 objectTemplate.vehicleHud.vehicleIconPos( Vec2 );
int objectTemplate.vehicleHud.vehicleType( int );
bool objectTemplate.vehicleHud.zoomOnMinimap( bool );
float objectTemplate.velocity( float );
bool objectTemplate.visibleOn3dMap( bool );
bool objectTemplate.visibleOn3dMap( bool );
float objectTemplate.volume( float );
std::string objectTemplate.volumeEnvelope( std::string );
int objectTemplate.volumeGroup( int );
float objectTemplate.warningDistance( float );
std::string objectTemplate.warningHud.getFirstWarningSound( TargetType );
std::string objectTemplate.warningHud.getSecondWarningSound( TargetType );
std::string objectTemplate.warningHud.getThirdWarningSound( TargetType );
std::string objectTemplate.warningHud.getWarningIcon( TargetType );
bool objectTemplate.warningHud.getWarningType( TargetType );
void objectTemplate.warningHud.setFirstWarningSound( TargetType, std::string );
void objectTemplate.warningHud.setSecondWarningSound( TargetType, std::string );
void objectTemplate.warningHud.setThirdWarningSound( TargetType, std::string );
void objectTemplate.warningHud.setWarningIcon( TargetType, std::string );
void objectTemplate.warningHud.setWarningType( TargetType, bool );
float objectTemplate.waterHeight( float );
float objectTemplate.waterSurfaceOffset( float );
std::string objectTemplate.weaponHud.abilityIcon( std::string );
void objectTemplate.weaponHud.addShowOnCamMode( int );
std::string objectTemplate.weaponHud.altCrosshairIcon( std::string );
int objectTemplate.weaponHud.altGuiIndex( int );
std::string objectTemplate.weaponHud.altWeaponIcon( std::string );
std::string objectTemplate.weaponHud.ammoBarBackIcon( std::string );
std::string objectTemplate.weaponHud.ammoBarFrontIcon( std::string );
std::string objectTemplate.weaponHud.ammoIcon( std::string );
std::string objectTemplate.weaponHud.clipIcon( std::string );
std::string objectTemplate.weaponHud.crosshairIcon( std::string );
int objectTemplate.weaponHud.crosshairIconSize( int );
std::string objectTemplate.weaponHud.descrString( std::string );
int objectTemplate.weaponHud.deviationFactor( int );
bool objectTemplate.weaponHud.disableOnSprint( bool );
bool objectTemplate.weaponHud.displaySelectOnActivation( bool );
bool objectTemplate.weaponHud.enableMouse( bool );
int objectTemplate.weaponHud.enablePostProcessingOnGuiIndex( int );
std::string objectTemplate.weaponHud.firstLockSound( std::string );
bool objectTemplate.weaponHud.getShowOnCamMode( int );
int objectTemplate.weaponHud.guiIndex( int );
bool objectTemplate.weaponHud.hasDistanceCounter( bool );
bool objectTemplate.weaponHud.hasFireRate( bool );
bool objectTemplate.weaponHud.hasMag( bool );
bool objectTemplate.weaponHud.hasRangeFinder( bool );
bool objectTemplate.weaponHud.hasScanProgress( bool );
std::string objectTemplate.weaponHud.hudName( std::string );
bool objectTemplate.weaponHud.ignoreTargetDistance( bool );
int objectTemplate.weaponHud.maxVisualDeviation( int );
int objectTemplate.weaponHud.minVisualDeviation( int );
std::string objectTemplate.weaponHud.notAbilityIcon( std::string );
std::string objectTemplate.weaponHud.notSelectedIcon( std::string );
std::string objectTemplate.weaponHud.overheatSound( std::string );
std::string objectTemplate.weaponHud.renderedPicture( std::string );
std::string objectTemplate.weaponHud.secondLockSound( std::string );
std::string objectTemplate.weaponHud.selectIcon( std::string );
void objectTemplate.weaponHud.sendRadioMessageOnActivation( std::string );
void objectTemplate.weaponHud.sendRadioMessageOnDeploy( std::string, bool );
bool objectTemplate.weaponHud.showAmmo( bool );
bool objectTemplate.weaponHud.showBatteryIconInHud( bool );
bool objectTemplate.weaponHud.ShowClips( bool );
bool objectTemplate.weaponHud.showInfo( bool );
int objectTemplate.weaponHud.showOnCamMode( int );
std::string objectTemplate.weaponHud.specialAbilityIcon( std::string );
bool objectTemplate.weaponHud.switchGuiOnCamera( bool );
std::string objectTemplate.weaponHud.unlockIcon( std::string );
bool objectTemplate.weaponhud.useCartridgeBar( bool );
std::string objectTemplate.weaponHud.weaponIcon( std::string );
WeaponItemType objectTemplate.weaponsItemType( WeaponItemType );
WeaponItemType objectTemplate.weaponsItemType( WeaponItemType );
float objectTemplate.width( float );
float objectTemplate.windAffectionFactor( float );
float objectTemplate.windBlowTime( float );
Vec3 objectTemplate.windDirection( Vec3 );
float objectTemplate.windFalloff( float );
bool objectTemplate.windIsDynamic( bool );
float objectTemplate.windRadialFalloff( float );
float objectTemplate.windSpeed( float );
std::string objectTemplate.windType( std::string );
float objectTemplate.wingLift( float );
float objectTemplate.wingToRegulatorRatio( float );
bool objectTemplate.workOnSoldiers( bool );
bool objectTemplate.workOnSoldiers( bool );
bool objectTemplate.workOnVehicles( bool );
bool objectTemplate.workOnVehicles( bool );
float objectTemplate.worldFOV( float );
float objectTemplate.worldFOV( float );
void objectTemplate.writeBinary( std::string );
bool objectTemplate.writeZ( bool );
void objectTemplate.zoom.addZoomFactor( float, CameraViewMode );
bool objectTemplate.zoom.allowUntoggledFire( bool );
bool objectTemplate.zoom.applyDoFOnZoom( bool );
int objectTemplate.zoom.changeCameraId( int );
CameraViewMode objectTemplate.zoom.changeCameraViewMode( CameraViewMode );
float objectTemplate.zoom.changeFovDelay( float );
bool objectTemplate.zoom.disableMuzzleWhenZoomed( bool );
bool objectTemplate.zoom.hideOnZoom( bool );
float objectTemplate.zoom.mouseSpeedMod( float );
bool objectTemplate.zoom.preventZoomWhen3P( bool );
int objectTemplate.zoom.startCameraId( int );
CameraViewMode objectTemplate.zoom.startCameraViewMode( CameraViewMode );
bool objectTemplate.zoom.useProjectileCamera( bool );
bool objectTemplate.zoom.useZoomFineTuning( bool );
float objectTemplate.zoom.zoomDelay( float );
float objectTemplate.zoom.zoomedWeaponRenderFOV( float );
int objectTemplate.zoom.zoomFineTuneSteps( int );
bool objectTemplate.zoom.zoomFineTuningNeedsUnlock( bool );
int objectTemplate.zoom.zoomLod( int );
bool objectTemplate.zoom.zoomOutAfterFire( bool );
bool objectTemplate.zoom.zoomOutOnReload( bool );
bool objectTemplate.zoom.zoomWhenBusy( bool );
RandomDistribution objectTemplate.zRotation( RandomDistribution );
float objectTemplate.zRotationSnap( float );
void object.togglePause( void );
bool overgrowth.addMaterial( std::string, uint );
bool overgrowth.addType( std::string );
float overgrowth.closeDistFade( float );
float overgrowth.closeDistPercentage( float );
float overgrowth.editorEnable( float );
void overgrowth.exportToTerrainTexture( void );
void overgrowth.generateAll( void );
std::string overgrowth.getActiveMaterialName( void );
std::string overgrowth.getGeometryList( void );
float overgrowth.getLodDistance( int );
std::string overgrowth.getMaterialList( void );
std::string overgrowth.getTypeList( void );
void overgrowth.paintMaterial( float, float, float, int );
void overgrowth.paintShadowmap( float, float, float, int );
std::string overgrowth.path( std::string );
void overgrowth.postLoad( void );
void overgrowth.preLoad( void );
bool overgrowth.removeActiveMaterial( void );
bool overgrowth.removeActiveType( void );
void overgrowth.save( void );
void overgrowth.setActiveMaterial( std::string );
void overgrowth.setActiveType( std::string );
void overgrowth.setAtlasGenerationSourcePath( std::string );
float overgrowthType.density( float );
std::string overgrowthType.geometry( std::string );
float overgrowthType.minRadiusToOthers( float );
float overgrowthType.minRadiusToSame( float );
float overgrowthType.normalScale( float );
Vec2 overgrowthType.randomScale( Vec2 );
float overgrowthType.rotationScale( float );
float overgrowth.viewDistance( float );
float overgrowth.viewDistance( float );
float overgrowth.viewDistanceScale( float );
bool particleSystemManager.affectedByWind( bool );
bool particleSystemManager.drawBoundingBoxEnable( bool );
bool particleSystemManager.drawStats( bool );
bool particleSystemManager.drawStats( bool );
float particleSystemManager.nsaShimmerIntensity( float );
float particleSystemManager.nsaShimmerPhases( float );
float particleSystemManager.nsaShimmerSpeed( float );
float particleSystemManager.overdrawScale( float );
uint particleSystemManager.particleSystemShaderQuality( uint );
int particleSystemManager.qualityLevel( int );
void particleSystemManager.resetStats( void );
float particleSystemManager.shimmerIntensity( float );
float particleSystemManager.shimmerPhases( float );
float particleSystemManager.shimmerSpeed( float );
float particleSystemManager.startFadePercentageOfViewDistance( float );
float particleSystemManager.startLodPercentageOfLodDistance( float );
float particleSystemManager.trailShimmerIntensity( float );
float particleSystemManager.trailShimmerPhases( float );
float particleSystemManager.trailShimmerSpeed( float );
float particleSystemManager.viewDistance( float );
float physics.gravity( float );
IPlayer* Player.active( IPlayer* );
IPlayer* Player.create( std::string, std::string );
bool player.isAi( bool );
bool player.isNetwork( bool );
std::string Player.list( void );
std::string Player.listPlayerClasses( void );
std::string player.moveTo( Vec3 );
std::string player.name( void );
bool Player.saveAll( std::string );
bool player.setVehicleWithInputId( IObject_ptrproxy, int );
IObject_ptrproxy player.vehicle( IObject_ptrproxy );
float portraitManager.customFov( float );
void portraitManager.getPortrait( int );
bool pythonHost.reinitialize( void );
void pythonHost.sendCommand( std::string );
void radio.callForAmmo( void );
void radio.callForMedic( void );
void radio.callForRepair( void );
bool radioInterface.mouseOver( int );
bool radioInterface.selectOrder( std::string );
void radioInterface.setStringMap( std::string, std::string, std::string );
void radioInterface.setVariableMap( std::string, std::string, std::string );
void radio.sendKitMessage( void );
void radio.sendSpottedMessage( bool, world::VehicleType );
void radio.setSpottedMenuActive( void );
bool radioVehicleInterface.selectOrder( std::string );
void radioVehicleInterface.setStringMap( std::string, std::string, std::string );
void radioVehicleInterface.setVariableMap( std::string, std::string, std::string );
void ragDoll.active( bool );
void ragDoll.addAngularConstraint( int, int, int, float );
void ragDoll.addBone( int, int );
void ragDoll.addCapsuleCollision( int, int );
void ragDoll.addConstraint( int, int );
void ragDoll.addDihedralAngleConstraint( int, int, int, int, float );
void ragDoll.addDistanceLessThanConstraint( int, int, float );
void ragDoll.addForce( int, Vec3 );
void ragDoll.addJointConstraint( int, int );
void ragDoll.addParticle( int, float );
void ragDoll.drawConstraints( bool );
void ragDoll.gravity( float );
void ragDoll.linkMode( int, int );
void ragDoll.lockBone( int, int );
void ragDoll.removeConstraint( int, int );
void ragDoll.reset( void );
void ragDoll.save( void );
void ragDoll.setParticleCollisionCriteria( float, float );
void ragDoll.skeleton( std::string );
void ragDoll.toSkeleton( int, int, int );
Vec2 rainManager.angleSpeed( Vec2 );
bool rainManager.cellDisplay( bool );
void rainManager.clearChanges( void );
Vec3 rainManager.emitRadius( Vec3 );
bool rainManager.enabled( bool );
float rainManager.fadeOutRange( float );
bool rainManager.freeze( bool );
bool rainManager.getChanged( void );
bool rainManager.lineDisplay( bool );
float rainManager.lineLength( float );
Vec3 rainManager.maxDeviation( Vec3 );
float rainManager.maxRandomChange( float );
Vec3 rainManager.offset( Vec3 );
Vec4 rainManager.particleColor( Vec4 );
int rainManager.particleCount( int );
float rainManager.particleMaxSize( float );
Vec3 rainManager.particleScale( Vec3 );
float rainManager.particleSize( float );
float rainManager.particleSpeed( float );
Vec3 rainManager.particleVelocity( Vec3 );
Vec4 rainManager.pos( Vec4 );
int rainManager.randomDeviationAngleSpeed( int );
int rainManager.randomness( int );
std::string rainManager.texture( std::string );
bool rankSettings.save( void );
void rankSettings.setMaxPrestigeRotations( int );
void rankSettings.setMinLevelToActivatePrestige( int );
void rankSettings.setPrestigeLevel( int, int );
void rankSettings.setPrestigePercentAwardedOnDamage( float );
void reactiveAbilities.addYPos( float );
void reactiveAbilities.setMovementSpeed( float );
void reactiveAbilities.setStartYPos( float );
void reactiveAbilities.setXPos( float );
bool renderer.alphaToMask( bool );
float renderer.bloomFilterContrast( float );
float renderer.bloomOverlayAmount( float );
float renderer.bloomSize( float );
float renderer.bloomWeightScale( float );
Vec2 renderer.camouflageOffset( Vec2 );
Vec3 renderer.colorBrightness( Vec3 );
Vec3 renderer.defaultColorTint( Vec3 );
Vec3 renderer.defaultContrast( Vec3 );
float renderer.defaultSaturation( float );
bool renderer.disableFadeOnRoads( bool );
bool renderer.draw1pMeshes( bool );
bool renderer.drawBlurredOverlay( bool );
bool renderer.drawBundledMeshes( bool );
int renderer.drawFps( int );
bool renderer.drawGraphs( bool );
bool renderer.drawHud( bool );
bool renderer.drawNametags( bool );
bool renderer.drawObjects( bool );
bool renderer.drawOutLines( bool );
bool renderer.drawOvergrowth( bool );
bool renderer.drawParticles( bool );
bool renderer.drawPostProduction( bool );
bool renderer.drawRoads( bool );
bool renderer.drawShadows( bool );
bool renderer.drawSkinnedMeshes( bool );
bool renderer.drawSkyDome( bool );
bool renderer.drawStaticMeshes( bool );
bool renderer.drawSunFlare( bool );
bool renderer.drawTerrain( bool );
bool renderer.drawTrees( bool );
bool renderer.drawUndergrowth( bool );
void renderer.dumpScreen( std::string );
int renderer.empEffectLevel( int );
float renderer.empEnableSimpleShader( float );
float renderer.empStaticNoiseAmount( float );
float renderer.empVerticalRoll( float );
float renderer.empWarpAmount( float );
float renderer.empWarpFrequency( float );
bool renderer.enableHWOcclusion( bool );
float Renderer.fieldOfView1p( float );
Vec3 renderer.fogColor( Vec3 );
Vec4 renderer.fogStartEndAndBase( Vec4 );
Vec4 renderer.fogStartEndAndBase( Vec4 );
float renderer.globalBundleMeshLodDistanceScale( float );
float renderer.globalSkinnedMeshLodDistanceScale( float );
float renderer.globalStaticMeshLodDistanceScale( float );
bool renderer.glowEnabled( bool );
float renderer.glowStrength( float );
bool renderer.hud( bool );
float renderer.indoorBundledMeshCullDistance( float );
float renderer.indoorSkinnedMeshCullDistance( float );
void renderer.listScreenModes( void );
void renderer.makeTopWorldScreen( U32, std::string, Vec3, float );
float renderer.minCullDistance( float );
bool renderer.presentAsync( bool );
uint renderer.renderAheadLimit( uint );
float renderer.roadDepthBias( float );
float renderer.roadLodDistMod( float );
float renderer.roadSlopeScaleDepthBias( float );
void renderer.runTitanExplosion( void );
int renderer.screenMode( int );
void renderer.setColorCorrectionTexture( std::string );
void renderer.setFilmGrainSize( float );
void renderer.setFilmGrainStrength( float );
bool renderer.showBloomOverlayTexture( bool );
float renderer.tweakNearPlane( float );
float renderer.tweakNearPlane1p( float );
bool renderer.useSunScaling( bool );
bool renderer.vsync( bool );
float renderer.waterAlphaAdd( float );
float renderer.waterAlphaHeightMul( float );
float renderer.waterAnimSpeed( float );
Vec3 renderer.waterColor( Vec3 );
Vec3 renderer.waterFogColor( Vec3 );
Vec4 renderer.waterFogStartEndAndBase( Vec4 );
std::string renderer.waterNormalMap( std::string );
Vec2 renderer.waterScroll( Vec2 );
Vec4 renderer.waterSpecularColor( Vec4 );
float renderer.waterSpecularPower( float );
void responsePhysicsManager.dumpLists( void );
void scoreboard.setToggleShow( int );
void scoreboard.singleClick( int );
bool SettingsManager.boolGet( std::string );
bool SettingsManager.boolSet( std::string, bool );
float SettingsManager.floatGet( std::string );
bool SettingsManager.floatSet( std::string, float );
int SettingsManager.intGet( std::string );
bool SettingsManager.intSet( std::string, int );
std::string SettingsManager.stringGet( std::string );
bool SettingsManager.stringSet( std::string, std::string );
U32 SettingsManager.U32Get( std::string );
bool SettingsManager.U32Set( std::string, U32 );
bool shadowManager.allowAlphaShadows( bool );
float shadowManager.alphaShadowThreshold( float );
float shadowManager.dropShadowClipHeightOffset( float );
bool shadowManager.dynamic1pShadowsEnabled( bool );
bool shadowManager.dynamicShadowsEnabled( bool );
bool shadowManager.dynamicStaticMeshShadowsEnabled( bool );
float shadowManager.lightmapIntensityBias( float );
float shadowManager.shadow80Line( float );
float shadowManager.shadowIntensityBias( float );
int shadowManager.shadowMapBitDepth( int );
float shadowManager.shadowMapDepthBias( float );
float shadowManager.shadowMapDepthDistance( float );
bool shadowManager.shadowMapIncludeStaticMeshes( bool );
int shadowManager.shadowMapObjectSize( int );
int shadowManager.shadowMapSize( int );
float shadowManager.shadowMapSlopeBias( float );
bool shadowManager.shadowMergeDynamicShadowFrustums( bool );
float shadowManager.shadowOccluderOversizeFactor( float );
float shadowManager.shadowPSMFovY( float );
bool shadowManager.shadowPSMUseSlideback( bool );
bool shadowManager.shadowPSMUseUnitCubeClipping( bool );
float shadowManager.shadowPSMZFarOffset( float );
float shadowManager.shadowPSMZMinInfinityZ( float );
float shadowManager.shadowPSMZNearOffset( float );
bool shadowManager.shadowShowFrustums( bool );
float shadowManager.shadowTSMFocus( float );
float shadowManager.shadowUpdateFactor( float );
bool shadowManager.shadowUpdatesEnabled( bool );
bool shadowManager.useLSSMOptimizations( bool );
bool shadowManager.usePSMOptimizations( bool );
void skinnedMeshRenderer.setCustomTextureCoordOffsetAndScale( CustomItemType, uint, Vec4 );
ShaderQuality skinnedMeshRenderer.shaderQuality( ShaderQuality );
Vec2 skyDome.cloudLerpFactors( Vec2 );
std::string skyDome.cloudTemplate( std::string );
std::string skyDome.cloudTexture( std::string );
std::string skyDome.cloudTexture2( std::string );
float skyDome.domeMaxOffset( float );
float skyDome.domeOffset( float );
float skyDome.domeRotation( float );
float skyDome.domeScale( float );
float skyDome.domeSize( float );
Vec2 skyDome.fadeCloudsDistances( Vec2 );
Vec3 skyDome.flareDirection( Vec3 );
Vec3 skyDome.flareDirScale( Vec3 );
float skyDome.flareFadeAdd( float );
float skyDome.flareFadeMul( float );
std::string skyDome.flareTemplate( std::string );
std::string skyDome.flareTexture( std::string );
bool skyDome.hasCloudLayer( bool );
bool skyDome.hasCloudLayer2( bool );
Vec2 skyDome.scrollDirection( Vec2 );
Vec2 skyDome.scrollDirection2( Vec2 );
std::string skyDome.SkyDomeName( std::string );
std::string skyDome.skyTemplate( std::string );
std::string skyDome.skyTexture( std::string );
void sound.addMenuSound( std::string, std::string, float, bool, bool );
void sound.addSound( std::string );
void sound.addTrigger( std::string );
float sound.dopplerEffect( float );
std::string sound.getAllSoundTemplates( void );
std::string sound.getProperty( std::string );
float sound.getVolumeForGroup( int );
SoundInitResult sound.initialize( int, std::string, int );
bool sound.interactiveMode( bool );
float sound.listenerReverb( float );
bool sound.loadMusic( std::string );
float sound.masterVolume( float );
bool sound.playMusic( void );
void sound.playSound( std::string );
void sound.removeAllTriggers( void );
void sound.setLoseEORloadingMusicDelay( float );
void sound.setMuteLevel( int, float );
void sound.setProperty( std::string, float );
void sound.setReverb( std::string );
void sound.setVolumeForGroup( int, float );
void sound.setWinEORloadingMusicDelay( float );
bool sound.showSoundSources( bool );
bool sound.showStats( bool );
bool sound.stopMusic( float );
void sound.stopSound( std::string );
void sound.tinnitusSetup( std::string, float, float, float, float );
void sound.tweakTemplate( std::string, float, float, float, float, float );
void sound.windSetup( std::string, float );
void spawnManager.commitSuicide( void );
void spawnManager.setPlayerKit( int );
void spawnManager.setPlayerSpawnPoint( int );
void spawnManager.setPlayerTeam( int );
void spawnManager.toggleMembers( bool );
bool staticMeshRenderer.allowAnisoFiltering( bool );
std::string staticMeshRenderer.convertLightmapName( std::string );
bool staticMeshRenderer.enableLightIndexes( bool );
bool staticMeshRenderer.enableLightMapAtlas( bool );
bool staticMeshRenderer.enableNewLightmapNames( bool );
bool staticMeshRenderer.enableRendering( bool );
bool staticMeshRenderer.enableUnifiedIndexlist( bool );
bool staticMeshRenderer.materialCullingEnabled( bool );
int staticMeshRenderer.maxLightMappedLod( int );
bool staticMeshRenderer.noLods( bool );
void storeAds.blacklistItem( int );
void storeAds.enableAds( bool );
int storeAds.itemExpirationThreshold( int );
int storeAds.itemUseCountThreshold( int );
void storeAds.pushNextAd( std::string );
void storeAds.registerContextualAd( std::string, std::string, int );
void storeAds.show( bool );
void store.setErrorColor( float, float, float );
void store.setStatusTextDuration( float );
void store.setSuccessColor( float, float, float );
void store.show( bool );
std::string sv.adminScript( std::string );
bool sv.allowExternalViews( bool );
bool sv.allowFreeCam( bool );
bool sv.allowNATNegotiation( void );
bool sv.allowNoseCam( bool );
std::string sv.allowSpectators( bool );
bool sv.autoBalanceTeam( bool );
std::string sv.autoDemoHook( void );
bool sv.autoRecord( bool );
int sv.bandwidthChoke( void );
std::string sv.bannerURL( std::string );
std::string sv.communityLogoURL( std::string );
std::string sv.configFile( std::string );
std::string sv.demoDownloadURL( void );
std::string sv.demoIndexURL( void );
int sv.demoQuality( void );
int sv.endDelay( int );
int sv.endOfRoundDelay( int );
bool sv.friendlyFireWithMines( bool );
bool sv.hitIndicator( bool );
std::string sv.interfaceIP( void );
std::string sv.internet( bool );
float sv.killAssistThreshold( void );
bool sv.load( void );
float sv.manDownTime( float );
ConnectionType sv.maxConnectionType( ConnectionType );
std::string sv.maxPlayers( int );
std::string sv.maxPlayersSave( int );
int sv.minPlayersForVoting( int );
float sv.notEnoughPlayersRestartDelay( float );
int sv.numPlayersNeededToStart( int );
std::string sv.password( std::string );
std::string sv.passwordSave( std::string );
std::string sv.prodDataCenter( std::string );
bool sv.punkBuster( bool );
int sv.radioBlockedDurationTime( int );
int sv.radioMaxSpamFlagCount( int );
int sv.radioSpamInterval( int );
std::string sv.ranked( bool );
bool sv.rankedSave( bool );
int sv.roundsPerMap( int );
bool sv.save( void );
bool sv.saveSave( void );
int sv.scoreLimit( int );
std::string sv.serverCommunity( std::string );
std::string sv.serverIP( std::string );
std::string sv.serverName( std::string );
std::string sv.serverPort( int );
std::string sv.serverType( std::string );
void sv.setRoundsPerMapSave( int );
void sv.setServerNameSave( std::string );
void sv.setTicketRatioSave( int );
void sv.setVipSlotsSave( int );
void sv.setWelcomeMessageSave( std::string );
int sv.soldierFriendlyFire( int );
int sv.soldierSplashFriendlyFire( int );
float sv.spawnTime( float );
std::string sv.sponsorLogoURL( std::string );
std::string sv.sponsorText( std::string );
int sv.startDelay( int );
float sv.teamRatioPercent( float );
int sv.ticketRatio( int );
float sv.timeBeforeRestartMap( float );
int sv.timeLimit( int );
int sv.tkNumPunishToKick( void );
bool sv.tkPunishByDefault( bool );
bool sv.tkPunishEnabled( bool );
bool sv.useSpawnVehicleWhenPlayerSpawns( void );
int sv.valorPointsForLoss( void );
int sv.valorPointsForWin( void );
int sv.valorPointsOnLevelUp( void );
int sv.vehicleFriendlyFire( int );
int sv.vehicleSplashFriendlyFire( int );
int sv.vipSlots( int );
int sv.voteTime( int );
bool sv.votingEnabled( bool );
std::string sv.welcomeMessage( std::string );
void terrain.create( std::string );
int terrainCuller.baseCellSize( int );
int terrainCuller.cullerType( int );
int terrainCuller.detailCullMaxLevel( int );
float terrainCuller.lod0SwitchStart( float );
float terrainCuller.lod0SwitchStop( float );
float terrainCuller.lod1SwitchStart( float );
float terrainCuller.lod1SwitchStop( float );
float terrainCuller.lod2Start( float );
int terrainCuller.lodSwitchDistance( int );
int terrainCuller.materialLodDistance( int );
bool terrainCuller.updateLodLevel( bool );
int terrain.forceRenderStyle( int );
void terrain.init( void );
void terrain.load( std::string );
float terrain.waterAlphaAdd( float );
float terrain.waterAlphaHeightMul( float );
float terrain.waterAnimSpeed( float );
Vec3 terrain.waterColor( Vec3 );
std::string terrain.waterNormalMap( std::string );
int terrain.waterQuality( int );
Vec2 terrain.waterScroll( Vec2 );
Vec4 terrain.waterSpecularColor( Vec4 );
float terrain.waterSpecularPower( float );
float terrain.waterSunIntensity( float );
std::string texturemanager.customTextureSuffix( std::string );
bool undergrowth.dynamicShadowsEnable( bool );
bool undergrowth.enabled( bool );
void undergrowth.load( std::string );
void undergrowth.reload( void );
bool undergrowth.simpleShaderEnable( bool );
uint undergrowth.test( uint );
float undergrowth.test2( float );
float undergrowth.viewDistanceFade( float );
float undergrowth.viewDistanceScale( float );
uint undergrowth.zPassPatchCount( uint );
void Vars.set( std::string, std::string );
void videoSettings.setAntialiasing( std::string );
void videoSettings.setDynamicLightingQuality( int );
void videoSettings.setDynamicShadowsQuality( int );
void videoSettings.setEffectsQuality( int );
void videoSettings.setGeometryQuality( int );
void videoSettings.setLightingQuality( int );
void videoSettings.setResolution( std::string );
void videoSettings.setStartInFullscreen( bool );
void videoSettings.setTerrainQuality( int );
void videoSettings.setTextureFilteringQuality( int );
void videoSettings.setTextureQuality( int );
void videoSettings.setUseBloom( bool );
void videoSettings.setVideoOptionScheme( int );
void videoSettings.setViewDistanceScale( float );
Vec3 windManager.globalWindDirection( Vec3 );
float windManager.globalWindSpeed( float );