|
|
@@ -1,1330 +0,0 @@
|
|
|
-//-----------------------------------------------------------------------------
|
|
|
-// Copyright (c) 2012 GarageGames, LLC
|
|
|
-//
|
|
|
-// Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
-// of this software and associated documentation files (the "Software"), to
|
|
|
-// deal in the Software without restriction, including without limitation the
|
|
|
-// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
|
|
|
-// sell copies of the Software, and to permit persons to whom the Software is
|
|
|
-// furnished to do so, subject to the following conditions:
|
|
|
-//
|
|
|
-// The above copyright notice and this permission notice shall be included in
|
|
|
-// all copies or substantial portions of the Software.
|
|
|
-//
|
|
|
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
|
|
-// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
|
|
-// IN THE SOFTWARE.
|
|
|
-//-----------------------------------------------------------------------------
|
|
|
-
|
|
|
-#include "platform/platform.h"
|
|
|
-#include "T3D/tsStatic.h"
|
|
|
-
|
|
|
-#include "core/resourceManager.h"
|
|
|
-#include "core/stream/bitStream.h"
|
|
|
-#include "scene/sceneRenderState.h"
|
|
|
-#include "scene/sceneManager.h"
|
|
|
-#include "scene/sceneObjectLightingPlugin.h"
|
|
|
-#include "lighting/lightManager.h"
|
|
|
-#include "math/mathIO.h"
|
|
|
-#include "ts/tsShapeInstance.h"
|
|
|
-#include "ts/tsMaterialList.h"
|
|
|
-#include "console/consoleTypes.h"
|
|
|
-#include "T3D/shapeBase.h"
|
|
|
-#include "sim/netConnection.h"
|
|
|
-#include "gfx/gfxDevice.h"
|
|
|
-#include "gfx/gfxTransformSaver.h"
|
|
|
-#include "ts/tsRenderState.h"
|
|
|
-#include "collision/boxConvex.h"
|
|
|
-#include "T3D/physics/physicsPlugin.h"
|
|
|
-#include "T3D/physics/physicsBody.h"
|
|
|
-#include "T3D/physics/physicsCollision.h"
|
|
|
-#include "materials/materialDefinition.h"
|
|
|
-#include "materials/materialManager.h"
|
|
|
-#include "materials/matInstance.h"
|
|
|
-#include "materials/materialFeatureData.h"
|
|
|
-#include "materials/materialFeatureTypes.h"
|
|
|
-#include "console/engineAPI.h"
|
|
|
-#include "T3D/accumulationVolume.h"
|
|
|
-
|
|
|
-using namespace Torque;
|
|
|
-
|
|
|
-extern bool gEditingMission;
|
|
|
-
|
|
|
-IMPLEMENT_CO_NETOBJECT_V1(TSStatic);
|
|
|
-
|
|
|
-ConsoleDocClass( TSStatic,
|
|
|
- "@brief A static object derived from a 3D model file and placed within the game world.\n\n"
|
|
|
-
|
|
|
- "TSStatic is the most basic 3D shape in Torque. Unlike StaticShape it doesn't make use of "
|
|
|
- "a datablock. It derrives directly from SceneObject. This makes TSStatic extremely light "
|
|
|
- "weight, which is why the Tools use this class when you want to drop in a DTS or DAE object.\n\n"
|
|
|
-
|
|
|
- "While a TSStatic doesn't provide any motion -- it stays were you initally put it -- it does allow for "
|
|
|
- "a single ambient animation sequence to play when the object is first added to the scene.\n\n"
|
|
|
-
|
|
|
- "@tsexample\n"
|
|
|
- "new TSStatic(Team1Base) {\n"
|
|
|
- " shapeName = \"art/shapes/desertStructures/station01.dts\";\n"
|
|
|
- " playAmbient = \"1\";\n"
|
|
|
- " receiveSunLight = \"1\";\n"
|
|
|
- " receiveLMLighting = \"1\";\n"
|
|
|
- " useCustomAmbientLighting = \"0\";\n"
|
|
|
- " customAmbientLighting = \"0 0 0 1\";\n"
|
|
|
- " collisionType = \"Visible Mesh\";\n"
|
|
|
- " decalType = \"Collision Mesh\";\n"
|
|
|
- " allowPlayerStep = \"1\";\n"
|
|
|
- " renderNormals = \"0\";\n"
|
|
|
- " forceDetail = \"-1\";\n"
|
|
|
- " position = \"315.18 -180.418 244.313\";\n"
|
|
|
- " rotation = \"0 0 1 195.952\";\n"
|
|
|
- " scale = \"1 1 1\";\n"
|
|
|
- " isRenderEnabled = \"true\";\n"
|
|
|
- " canSaveDynamicFields = \"1\";\n"
|
|
|
- "};\n"
|
|
|
- "@endtsexample\n"
|
|
|
-
|
|
|
- "@ingroup gameObjects\n"
|
|
|
-);
|
|
|
-
|
|
|
-TSStatic::TSStatic()
|
|
|
-:
|
|
|
- cubeDescId( 0 ),
|
|
|
- reflectorDesc( NULL )
|
|
|
-{
|
|
|
- mNetFlags.set(Ghostable | ScopeAlways);
|
|
|
-
|
|
|
- mTypeMask |= StaticObjectType | StaticShapeObjectType;
|
|
|
-
|
|
|
- mShapeName = "";
|
|
|
- mShapeInstance = NULL;
|
|
|
-
|
|
|
- mPlayAmbient = true;
|
|
|
- mAmbientThread = NULL;
|
|
|
-
|
|
|
- mAllowPlayerStep = false;
|
|
|
-
|
|
|
- mConvexList = new Convex;
|
|
|
-
|
|
|
- mRenderNormalScalar = 0;
|
|
|
- mForceDetail = -1;
|
|
|
-
|
|
|
- mMeshCulling = false;
|
|
|
- mUseOriginSort = false;
|
|
|
-
|
|
|
- mUseAlphaFade = false;
|
|
|
- mAlphaFadeStart = 100.0f;
|
|
|
- mAlphaFadeEnd = 150.0f;
|
|
|
- mInvertAlphaFade = false;
|
|
|
- mAlphaFade = 1.0f;
|
|
|
- mPhysicsRep = NULL;
|
|
|
-
|
|
|
- mCollisionType = CollisionMesh;
|
|
|
- mDecalType = CollisionMesh;
|
|
|
-}
|
|
|
-
|
|
|
-TSStatic::~TSStatic()
|
|
|
-{
|
|
|
- delete mConvexList;
|
|
|
- mConvexList = NULL;
|
|
|
-}
|
|
|
-
|
|
|
-ImplementEnumType( TSMeshType,
|
|
|
- "Type of mesh data available in a shape.\n"
|
|
|
- "@ingroup gameObjects" )
|
|
|
- { TSStatic::None, "None", "No mesh data." },
|
|
|
- { TSStatic::Bounds, "Bounds", "Bounding box of the shape." },
|
|
|
- { TSStatic::CollisionMesh, "Collision Mesh", "Specifically desingated \"collision\" meshes." },
|
|
|
- { TSStatic::VisibleMesh, "Visible Mesh", "Rendered mesh polygons." },
|
|
|
-EndImplementEnumType;
|
|
|
-
|
|
|
-
|
|
|
-void TSStatic::initPersistFields()
|
|
|
-{
|
|
|
- addGroup("Media");
|
|
|
-
|
|
|
- addField("shapeName", TypeShapeFilename, Offset( mShapeName, TSStatic ),
|
|
|
- "%Path and filename of the model file (.DTS, .DAE) to use for this TSStatic." );
|
|
|
-
|
|
|
- addProtectedField( "skin", TypeRealString, Offset( mAppliedSkinName, TSStatic ), &_setFieldSkin, &_getFieldSkin,
|
|
|
- "@brief The skin applied to the shape.\n\n"
|
|
|
-
|
|
|
- "'Skinning' the shape effectively renames the material targets, allowing "
|
|
|
- "different materials to be used on different instances of the same model.\n\n"
|
|
|
-
|
|
|
- "Any material targets that start with the old skin name have that part "
|
|
|
- "of the name replaced with the new skin name. The initial old skin name is "
|
|
|
- "\"base\". For example, if a new skin of \"blue\" was applied to a model "
|
|
|
- "that had material targets <i>base_body</i> and <i>face</i>, the new targets "
|
|
|
- "would be <i>blue_body</i> and <i>face</i>. Note that <i>face</i> was not "
|
|
|
- "renamed since it did not start with the old skin name of \"base\".\n\n"
|
|
|
-
|
|
|
- "To support models that do not use the default \"base\" naming convention, "
|
|
|
- "you can also specify the part of the name to replace in the skin field "
|
|
|
- "itself. For example, if a model had a material target called <i>shapemat</i>, "
|
|
|
- "we could apply a new skin \"shape=blue\", and the material target would be "
|
|
|
- "renamed to <i>bluemat</i> (note \"shape\" has been replaced with \"blue\").\n\n"
|
|
|
-
|
|
|
- "Multiple skin updates can also be applied at the same time by separating "
|
|
|
- "them with a semicolon. For example: \"base=blue;face=happy_face\".\n\n"
|
|
|
-
|
|
|
- "Material targets are only renamed if an existing Material maps to that "
|
|
|
- "name, or if there is a diffuse texture in the model folder with the same "
|
|
|
- "name as the new target.\n\n" );
|
|
|
-
|
|
|
- endGroup("Media");
|
|
|
-
|
|
|
- addGroup("Rendering");
|
|
|
-
|
|
|
- addField( "playAmbient", TypeBool, Offset( mPlayAmbient, TSStatic ),
|
|
|
- "Enables automatic playing of the animation sequence named \"ambient\" (if it exists) when the TSStatic is loaded.");
|
|
|
- addField( "meshCulling", TypeBool, Offset( mMeshCulling, TSStatic ),
|
|
|
- "Enables detailed culling of meshes within the TSStatic. Should only be used "
|
|
|
- "with large complex shapes like buildings which contain many submeshes." );
|
|
|
- addField( "originSort", TypeBool, Offset( mUseOriginSort, TSStatic ),
|
|
|
- "Enables translucent sorting of the TSStatic by its origin instead of the bounds." );
|
|
|
-
|
|
|
- endGroup("Rendering");
|
|
|
-
|
|
|
- addGroup( "Reflection" );
|
|
|
- addField( "cubeReflectorDesc", TypeRealString, Offset( cubeDescName, TSStatic ),
|
|
|
- "References a ReflectorDesc datablock that defines performance and quality properties for dynamic reflections.\n");
|
|
|
- endGroup( "Reflection" );
|
|
|
-
|
|
|
- addGroup("Collision");
|
|
|
-
|
|
|
- addField( "collisionType", TypeTSMeshType, Offset( mCollisionType, TSStatic ),
|
|
|
- "The type of mesh data to use for collision queries." );
|
|
|
- addField( "decalType", TypeTSMeshType, Offset( mDecalType, TSStatic ),
|
|
|
- "The type of mesh data used to clip decal polygons against." );
|
|
|
- addField( "allowPlayerStep", TypeBool, Offset( mAllowPlayerStep, TSStatic ),
|
|
|
- "@brief Allow a Player to walk up sloping polygons in the TSStatic (based on the collisionType).\n\n"
|
|
|
- "When set to false, the slightest bump will stop the player from walking on top of the object.\n");
|
|
|
-
|
|
|
- endGroup("Collision");
|
|
|
-
|
|
|
- addGroup( "AlphaFade" );
|
|
|
- addField( "alphaFadeEnable", TypeBool, Offset(mUseAlphaFade, TSStatic), "Turn on/off Alpha Fade" );
|
|
|
- addField( "alphaFadeStart", TypeF32, Offset(mAlphaFadeStart, TSStatic), "Distance of start Alpha Fade" );
|
|
|
- addField( "alphaFadeEnd", TypeF32, Offset(mAlphaFadeEnd, TSStatic), "Distance of end Alpha Fade" );
|
|
|
- addField( "alphaFadeInverse", TypeBool, Offset(mInvertAlphaFade, TSStatic), "Invert Alpha Fade's Start & End Distance" );
|
|
|
- endGroup( "AlphaFade" );
|
|
|
-
|
|
|
- addGroup("Debug");
|
|
|
-
|
|
|
- addField( "renderNormals", TypeF32, Offset( mRenderNormalScalar, TSStatic ),
|
|
|
- "Debug rendering mode shows the normals for each point in the TSStatic's mesh." );
|
|
|
- addField( "forceDetail", TypeS32, Offset( mForceDetail, TSStatic ),
|
|
|
- "Forces rendering to a particular detail level." );
|
|
|
-
|
|
|
- endGroup("Debug");
|
|
|
-
|
|
|
- Parent::initPersistFields();
|
|
|
-}
|
|
|
-
|
|
|
-bool TSStatic::_setFieldSkin( void *object, const char *index, const char *data )
|
|
|
-{
|
|
|
- TSStatic *ts = static_cast<TSStatic*>( object );
|
|
|
- if ( ts )
|
|
|
- ts->setSkinName( data );
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-const char *TSStatic::_getFieldSkin( void *object, const char *data )
|
|
|
-{
|
|
|
- TSStatic *ts = static_cast<TSStatic*>( object );
|
|
|
- return ts ? ts->mSkinNameHandle.getString() : "";
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::inspectPostApply()
|
|
|
-{
|
|
|
- // Apply any transformations set in the editor
|
|
|
- Parent::inspectPostApply();
|
|
|
-
|
|
|
- if(isServerObject())
|
|
|
- {
|
|
|
- setMaskBits(AdvancedStaticOptionsMask);
|
|
|
- prepCollision();
|
|
|
- }
|
|
|
-
|
|
|
- _updateShouldTick();
|
|
|
-}
|
|
|
-
|
|
|
-bool TSStatic::onAdd()
|
|
|
-{
|
|
|
- PROFILE_SCOPE(TSStatic_onAdd);
|
|
|
-
|
|
|
- if ( isServerObject() )
|
|
|
- {
|
|
|
- // Handle the old "usePolysoup" field
|
|
|
- SimFieldDictionary* fieldDict = getFieldDictionary();
|
|
|
-
|
|
|
- if ( fieldDict )
|
|
|
- {
|
|
|
- StringTableEntry slotName = StringTable->insert( "usePolysoup" );
|
|
|
-
|
|
|
- SimFieldDictionary::Entry * entry = fieldDict->findDynamicField( slotName );
|
|
|
-
|
|
|
- if ( entry )
|
|
|
- {
|
|
|
- // Was "usePolysoup" set?
|
|
|
- bool usePolysoup = dAtob( entry->value );
|
|
|
-
|
|
|
- // "usePolysoup" maps to the new VisibleMesh type
|
|
|
- if ( usePolysoup )
|
|
|
- mCollisionType = VisibleMesh;
|
|
|
-
|
|
|
- // Remove the field in favor on the new "collisionType" field
|
|
|
- fieldDict->setFieldValue( slotName, "" );
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if ( !Parent::onAdd() )
|
|
|
- return false;
|
|
|
-
|
|
|
- // Setup the shape.
|
|
|
- if ( !_createShape() )
|
|
|
- {
|
|
|
- Con::errorf( "TSStatic::onAdd() - Shape creation failed!" );
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- setRenderTransform(mObjToWorld);
|
|
|
-
|
|
|
- // Register for the resource change signal.
|
|
|
- ResourceManager::get().getChangedSignal().notify( this, &TSStatic::_onResourceChanged );
|
|
|
-
|
|
|
- addToScene();
|
|
|
-
|
|
|
- if ( isClientObject() )
|
|
|
- {
|
|
|
- mCubeReflector.unregisterReflector();
|
|
|
-
|
|
|
- if ( reflectorDesc )
|
|
|
- mCubeReflector.registerReflector( this, reflectorDesc );
|
|
|
- }
|
|
|
-
|
|
|
- _updateShouldTick();
|
|
|
-
|
|
|
- // Accumulation and environment mapping
|
|
|
- if (isClientObject() && mShapeInstance)
|
|
|
- {
|
|
|
- AccumulationVolume::addObject(this);
|
|
|
- }
|
|
|
-
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-bool TSStatic::_createShape()
|
|
|
-{
|
|
|
- // Cleanup before we create.
|
|
|
- mCollisionDetails.clear();
|
|
|
- mLOSDetails.clear();
|
|
|
- SAFE_DELETE( mPhysicsRep );
|
|
|
- SAFE_DELETE( mShapeInstance );
|
|
|
- mAmbientThread = NULL;
|
|
|
- mShape = NULL;
|
|
|
-
|
|
|
- if (!mShapeName || mShapeName[0] == '\0')
|
|
|
- {
|
|
|
- Con::errorf( "TSStatic::_createShape() - No shape name!" );
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- mShapeHash = _StringTable::hashString(mShapeName);
|
|
|
-
|
|
|
- mShape = ResourceManager::get().load(mShapeName);
|
|
|
- if ( bool(mShape) == false )
|
|
|
- {
|
|
|
- Con::errorf( "TSStatic::_createShape() - Unable to load shape: %s", mShapeName );
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- if ( isClientObject() &&
|
|
|
- !mShape->preloadMaterialList(mShape.getPath()) &&
|
|
|
- NetConnection::filesWereDownloaded() )
|
|
|
- return false;
|
|
|
-
|
|
|
- mObjBox = mShape->bounds;
|
|
|
- resetWorldBox();
|
|
|
-
|
|
|
- mShapeInstance = new TSShapeInstance( mShape, isClientObject() );
|
|
|
-
|
|
|
- if( isGhost() )
|
|
|
- {
|
|
|
- // Reapply the current skin
|
|
|
- mAppliedSkinName = "";
|
|
|
- reSkin();
|
|
|
- }
|
|
|
-
|
|
|
- prepCollision();
|
|
|
-
|
|
|
- // Find the "ambient" animation if it exists
|
|
|
- S32 ambientSeq = mShape->findSequence("ambient");
|
|
|
-
|
|
|
- if ( ambientSeq > -1 && !mAmbientThread )
|
|
|
- mAmbientThread = mShapeInstance->addThread();
|
|
|
-
|
|
|
- if ( mAmbientThread )
|
|
|
- mShapeInstance->setSequence( mAmbientThread, ambientSeq, 0);
|
|
|
-
|
|
|
- // Resolve CubeReflectorDesc.
|
|
|
- if ( cubeDescName.isNotEmpty() )
|
|
|
- {
|
|
|
- Sim::findObject( cubeDescName, reflectorDesc );
|
|
|
- }
|
|
|
- else if( cubeDescId > 0 )
|
|
|
- {
|
|
|
- Sim::findObject( cubeDescId, reflectorDesc );
|
|
|
- }
|
|
|
-
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::prepCollision()
|
|
|
-{
|
|
|
- // Let the client know that the collision was updated
|
|
|
- setMaskBits( UpdateCollisionMask );
|
|
|
-
|
|
|
- // Allow the ShapeInstance to prep its collision if it hasn't already
|
|
|
- if ( mShapeInstance )
|
|
|
- mShapeInstance->prepCollision();
|
|
|
-
|
|
|
- // Cleanup any old collision data
|
|
|
- mCollisionDetails.clear();
|
|
|
- mLOSDetails.clear();
|
|
|
- mConvexList->nukeList();
|
|
|
-
|
|
|
- if ( mCollisionType == CollisionMesh || mCollisionType == VisibleMesh )
|
|
|
- mShape->findColDetails( mCollisionType == VisibleMesh, &mCollisionDetails, &mLOSDetails );
|
|
|
-
|
|
|
- _updatePhysics();
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::_updatePhysics()
|
|
|
-{
|
|
|
- SAFE_DELETE( mPhysicsRep );
|
|
|
-
|
|
|
- if ( !PHYSICSMGR || mCollisionType == None )
|
|
|
- return;
|
|
|
-
|
|
|
- PhysicsCollision *colShape = NULL;
|
|
|
- if ( mCollisionType == Bounds )
|
|
|
- {
|
|
|
- MatrixF offset( true );
|
|
|
- offset.setPosition( mShape->center );
|
|
|
- colShape = PHYSICSMGR->createCollision();
|
|
|
- colShape->addBox( getObjBox().getExtents() * 0.5f * mObjScale, offset );
|
|
|
- }
|
|
|
- else
|
|
|
- colShape = mShape->buildColShape( mCollisionType == VisibleMesh, getScale() );
|
|
|
-
|
|
|
- if ( colShape )
|
|
|
- {
|
|
|
- PhysicsWorld *world = PHYSICSMGR->getWorld( isServerObject() ? "server" : "client" );
|
|
|
- mPhysicsRep = PHYSICSMGR->createBody();
|
|
|
- mPhysicsRep->init( colShape, 0, 0, this, world );
|
|
|
- mPhysicsRep->setTransform( getTransform() );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::onRemove()
|
|
|
-{
|
|
|
- SAFE_DELETE( mPhysicsRep );
|
|
|
-
|
|
|
- // Accumulation
|
|
|
- if ( isClientObject() && mShapeInstance )
|
|
|
- {
|
|
|
- if ( mShapeInstance->hasAccumulation() )
|
|
|
- AccumulationVolume::removeObject(this);
|
|
|
- }
|
|
|
-
|
|
|
- mConvexList->nukeList();
|
|
|
-
|
|
|
- removeFromScene();
|
|
|
-
|
|
|
- // Remove the resource change signal.
|
|
|
- ResourceManager::get().getChangedSignal().remove( this, &TSStatic::_onResourceChanged );
|
|
|
-
|
|
|
- delete mShapeInstance;
|
|
|
- mShapeInstance = NULL;
|
|
|
-
|
|
|
- mAmbientThread = NULL;
|
|
|
- if ( isClientObject() )
|
|
|
- mCubeReflector.unregisterReflector();
|
|
|
-
|
|
|
- Parent::onRemove();
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::_onResourceChanged( const Torque::Path &path )
|
|
|
-{
|
|
|
- if ( path != Path( mShapeName ) )
|
|
|
- return;
|
|
|
-
|
|
|
- _createShape();
|
|
|
- _updateShouldTick();
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::setSkinName( const char *name )
|
|
|
-{
|
|
|
- if ( !isGhost() )
|
|
|
- {
|
|
|
- if ( name[0] != '\0' )
|
|
|
- {
|
|
|
- // Use tags for better network performance
|
|
|
- // Should be a tag, but we'll convert to one if it isn't.
|
|
|
- if ( name[0] == StringTagPrefixByte )
|
|
|
- mSkinNameHandle = NetStringHandle( U32(dAtoi(name + 1)) );
|
|
|
- else
|
|
|
- mSkinNameHandle = NetStringHandle( name );
|
|
|
- }
|
|
|
- else
|
|
|
- mSkinNameHandle = NetStringHandle();
|
|
|
-
|
|
|
- setMaskBits( SkinMask );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::reSkin()
|
|
|
-{
|
|
|
- if ( isGhost() && mShapeInstance && mSkinNameHandle.isValidString() )
|
|
|
- {
|
|
|
- Vector<String> skins;
|
|
|
- String(mSkinNameHandle.getString()).split( ";", skins );
|
|
|
-
|
|
|
- for (S32 i = 0; i < skins.size(); i++)
|
|
|
- {
|
|
|
- String oldSkin( mAppliedSkinName.c_str() );
|
|
|
- String newSkin( skins[i] );
|
|
|
-
|
|
|
- // Check if the skin handle contains an explicit "old" base string. This
|
|
|
- // allows all models to support skinning, even if they don't follow the
|
|
|
- // "base_xxx" material naming convention.
|
|
|
- S32 split = newSkin.find( '=' ); // "old=new" format skin?
|
|
|
- if ( split != String::NPos )
|
|
|
- {
|
|
|
- oldSkin = newSkin.substr( 0, split );
|
|
|
- newSkin = newSkin.erase( 0, split+1 );
|
|
|
- }
|
|
|
-
|
|
|
- mShapeInstance->reSkin( newSkin, oldSkin );
|
|
|
- mAppliedSkinName = newSkin;
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::processTick( const Move *move )
|
|
|
-{
|
|
|
- if ( isServerObject() && mPlayAmbient && mAmbientThread )
|
|
|
- mShapeInstance->advanceTime( TickSec, mAmbientThread );
|
|
|
-
|
|
|
- if ( isMounted() )
|
|
|
- {
|
|
|
- MatrixF mat( true );
|
|
|
- mMount.object->getMountTransform(mMount.node, mMount.xfm, &mat );
|
|
|
- setTransform( mat );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::interpolateTick( F32 delta )
|
|
|
-{
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::advanceTime( F32 dt )
|
|
|
-{
|
|
|
- if ( mPlayAmbient && mAmbientThread )
|
|
|
- mShapeInstance->advanceTime( dt, mAmbientThread );
|
|
|
-
|
|
|
- if ( isMounted() )
|
|
|
- {
|
|
|
- MatrixF mat( true );
|
|
|
- mMount.object->getRenderMountTransform( dt, mMount.node, mMount.xfm, &mat );
|
|
|
- setRenderTransform( mat );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::_updateShouldTick()
|
|
|
-{
|
|
|
- bool shouldTick = (mPlayAmbient && mAmbientThread) || isMounted();
|
|
|
-
|
|
|
- if ( isTicking() != shouldTick )
|
|
|
- setProcessTick( shouldTick );
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::prepRenderImage( SceneRenderState* state )
|
|
|
-{
|
|
|
- if( !mShapeInstance )
|
|
|
- return;
|
|
|
-
|
|
|
- Point3F cameraOffset;
|
|
|
- getRenderTransform().getColumn(3,&cameraOffset);
|
|
|
- cameraOffset -= state->getDiffuseCameraPosition();
|
|
|
- F32 dist = cameraOffset.len();
|
|
|
- if (dist < 0.01f)
|
|
|
- dist = 0.01f;
|
|
|
-
|
|
|
- if (mUseAlphaFade)
|
|
|
- {
|
|
|
- mAlphaFade = 1.0f;
|
|
|
- if ((mAlphaFadeStart < mAlphaFadeEnd) && mAlphaFadeStart > 0.1f)
|
|
|
- {
|
|
|
- if (mInvertAlphaFade)
|
|
|
- {
|
|
|
- if (dist <= mAlphaFadeStart)
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (dist < mAlphaFadeEnd)
|
|
|
- {
|
|
|
- mAlphaFade = ((dist - mAlphaFadeStart) / (mAlphaFadeEnd - mAlphaFadeStart));
|
|
|
- }
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- if (dist >= mAlphaFadeEnd)
|
|
|
- {
|
|
|
- return;
|
|
|
- }
|
|
|
- if (dist > mAlphaFadeStart)
|
|
|
- {
|
|
|
- mAlphaFade -= ((dist - mAlphaFadeStart) / (mAlphaFadeEnd - mAlphaFadeStart));
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- F32 invScale = (1.0f/getMax(getMax(mObjScale.x,mObjScale.y),mObjScale.z));
|
|
|
-
|
|
|
- // If we're currently rendering our own reflection we
|
|
|
- // don't want to render ourselves into it.
|
|
|
- if ( mCubeReflector.isRendering() )
|
|
|
- return;
|
|
|
-
|
|
|
-
|
|
|
- if ( mForceDetail == -1 )
|
|
|
- mShapeInstance->setDetailFromDistance( state, dist * invScale );
|
|
|
- else
|
|
|
- mShapeInstance->setCurrentDetail( mForceDetail );
|
|
|
-
|
|
|
- if ( mShapeInstance->getCurrentDetail() < 0 )
|
|
|
- return;
|
|
|
-
|
|
|
- GFXTransformSaver saver;
|
|
|
-
|
|
|
- // Set up our TS render state.
|
|
|
- TSRenderState rdata;
|
|
|
- rdata.setSceneState( state );
|
|
|
- rdata.setFadeOverride( 1.0f );
|
|
|
- rdata.setOriginSort( mUseOriginSort );
|
|
|
-
|
|
|
- if ( mCubeReflector.isEnabled() )
|
|
|
- rdata.setCubemap( mCubeReflector.getCubemap() );
|
|
|
-
|
|
|
- // Acculumation
|
|
|
- rdata.setAccuTex(mAccuTex);
|
|
|
-
|
|
|
- // If we have submesh culling enabled then prepare
|
|
|
- // the object space frustum to pass to the shape.
|
|
|
- Frustum culler;
|
|
|
- if ( mMeshCulling )
|
|
|
- {
|
|
|
- culler = state->getCullingFrustum();
|
|
|
- MatrixF xfm( true );
|
|
|
- xfm.scale( Point3F::One / getScale() );
|
|
|
- xfm.mul( getRenderWorldTransform() );
|
|
|
- xfm.mul( culler.getTransform() );
|
|
|
- culler.setTransform( xfm );
|
|
|
- rdata.setCuller( &culler );
|
|
|
- }
|
|
|
-
|
|
|
- // We might have some forward lit materials
|
|
|
- // so pass down a query to gather lights.
|
|
|
- LightQuery query;
|
|
|
- query.init( getWorldSphere() );
|
|
|
- rdata.setLightQuery( &query );
|
|
|
-
|
|
|
- MatrixF mat = getRenderTransform();
|
|
|
- mat.scale( mObjScale );
|
|
|
- GFX->setWorldMatrix( mat );
|
|
|
-
|
|
|
- if ( state->isDiffusePass() && mCubeReflector.isEnabled() && mCubeReflector.getOcclusionQuery() )
|
|
|
- {
|
|
|
- RenderPassManager *pass = state->getRenderPass();
|
|
|
- OccluderRenderInst *ri = pass->allocInst<OccluderRenderInst>();
|
|
|
-
|
|
|
- ri->type = RenderPassManager::RIT_Occluder;
|
|
|
- ri->query = mCubeReflector.getOcclusionQuery();
|
|
|
- mObjToWorld.mulP( mObjBox.getCenter(), &ri->position );
|
|
|
- ri->scale.set( mObjBox.getExtents() );
|
|
|
- ri->orientation = pass->allocUniqueXform( mObjToWorld );
|
|
|
- ri->isSphere = false;
|
|
|
- state->getRenderPass()->addInst( ri );
|
|
|
- }
|
|
|
-
|
|
|
- mShapeInstance->animate();
|
|
|
- if(mShapeInstance)
|
|
|
- {
|
|
|
- if (mUseAlphaFade)
|
|
|
- {
|
|
|
- mShapeInstance->setAlphaAlways(mAlphaFade);
|
|
|
- S32 s = mShapeInstance->mMeshObjects.size();
|
|
|
-
|
|
|
- for(S32 x = 0; x < s; x++)
|
|
|
- {
|
|
|
- mShapeInstance->mMeshObjects[x].visible = mAlphaFade;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
- mShapeInstance->render( rdata );
|
|
|
-
|
|
|
- if ( mRenderNormalScalar > 0 )
|
|
|
- {
|
|
|
- ObjectRenderInst *ri = state->getRenderPass()->allocInst<ObjectRenderInst>();
|
|
|
- ri->renderDelegate.bind( this, &TSStatic::_renderNormals );
|
|
|
- ri->type = RenderPassManager::RIT_Editor;
|
|
|
- state->getRenderPass()->addInst( ri );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::_renderNormals( ObjectRenderInst *ri, SceneRenderState *state, BaseMatInstance *overrideMat )
|
|
|
-{
|
|
|
- PROFILE_SCOPE( TSStatic_RenderNormals );
|
|
|
-
|
|
|
- GFXTransformSaver saver;
|
|
|
-
|
|
|
- MatrixF mat = getRenderTransform();
|
|
|
- mat.scale( mObjScale );
|
|
|
- GFX->multWorld( mat );
|
|
|
-
|
|
|
- S32 dl = mShapeInstance->getCurrentDetail();
|
|
|
- mShapeInstance->renderDebugNormals( mRenderNormalScalar, dl );
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::onScaleChanged()
|
|
|
-{
|
|
|
- Parent::onScaleChanged();
|
|
|
-
|
|
|
- if ( mPhysicsRep )
|
|
|
- {
|
|
|
- // If the editor is enabled delay the scale operation
|
|
|
- // by a few milliseconds so that we're not rebuilding
|
|
|
- // during an active scale drag operation.
|
|
|
- if ( gEditingMission )
|
|
|
- mPhysicsRep->queueCallback( 500, Delegate<void()>( this, &TSStatic::_updatePhysics ) );
|
|
|
- else
|
|
|
- _updatePhysics();
|
|
|
- }
|
|
|
-
|
|
|
- setMaskBits( ScaleMask );
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::setTransform(const MatrixF & mat)
|
|
|
-{
|
|
|
- Parent::setTransform(mat);
|
|
|
- if ( !isMounted() )
|
|
|
- setMaskBits( TransformMask );
|
|
|
-
|
|
|
- if ( mPhysicsRep )
|
|
|
- mPhysicsRep->setTransform( mat );
|
|
|
-
|
|
|
- // Accumulation
|
|
|
- if ( isClientObject() && mShapeInstance )
|
|
|
- {
|
|
|
- if ( mShapeInstance->hasAccumulation() )
|
|
|
- AccumulationVolume::updateObject(this);
|
|
|
- }
|
|
|
-
|
|
|
- // Since this is a static it's render transform changes 1
|
|
|
- // to 1 with it's collision transform... no interpolation.
|
|
|
- setRenderTransform(mat);
|
|
|
-}
|
|
|
-
|
|
|
-U32 TSStatic::packUpdate(NetConnection *con, U32 mask, BitStream *stream)
|
|
|
-{
|
|
|
- U32 retMask = Parent::packUpdate(con, mask, stream);
|
|
|
-
|
|
|
- if ( stream->writeFlag( mask & TransformMask ) )
|
|
|
- mathWrite( *stream, getTransform() );
|
|
|
-
|
|
|
- if ( stream->writeFlag( mask & ScaleMask ) )
|
|
|
- {
|
|
|
- // Only write one bit if the scale is one.
|
|
|
- if ( stream->writeFlag( mObjScale != Point3F::One ) )
|
|
|
- mathWrite( *stream, mObjScale );
|
|
|
- }
|
|
|
-
|
|
|
- if ( stream->writeFlag( mask & UpdateCollisionMask ) )
|
|
|
- stream->write( (U32)mCollisionType );
|
|
|
-
|
|
|
- if ( stream->writeFlag( mask & SkinMask ) )
|
|
|
- con->packNetStringHandleU( stream, mSkinNameHandle );
|
|
|
-
|
|
|
- if (stream->writeFlag(mask & AdvancedStaticOptionsMask))
|
|
|
- {
|
|
|
- stream->writeString(mShapeName);
|
|
|
- stream->write((U32)mDecalType);
|
|
|
-
|
|
|
- stream->writeFlag(mAllowPlayerStep);
|
|
|
- stream->writeFlag(mMeshCulling);
|
|
|
- stream->writeFlag(mUseOriginSort);
|
|
|
-
|
|
|
- stream->write(mRenderNormalScalar);
|
|
|
-
|
|
|
- stream->write(mForceDetail);
|
|
|
-
|
|
|
- stream->writeFlag(mPlayAmbient);
|
|
|
- }
|
|
|
-
|
|
|
- if ( stream->writeFlag(mUseAlphaFade) )
|
|
|
- {
|
|
|
- stream->write(mAlphaFadeStart);
|
|
|
- stream->write(mAlphaFadeEnd);
|
|
|
- stream->write(mInvertAlphaFade);
|
|
|
- }
|
|
|
-
|
|
|
- if ( mLightPlugin )
|
|
|
- retMask |= mLightPlugin->packUpdate(this, AdvancedStaticOptionsMask, con, mask, stream);
|
|
|
-
|
|
|
- if( stream->writeFlag( reflectorDesc != NULL ) )
|
|
|
- {
|
|
|
- stream->writeRangedU32( reflectorDesc->getId(), DataBlockObjectIdFirst, DataBlockObjectIdLast );
|
|
|
- }
|
|
|
- return retMask;
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::unpackUpdate(NetConnection *con, BitStream *stream)
|
|
|
-{
|
|
|
- Parent::unpackUpdate(con, stream);
|
|
|
-
|
|
|
- if ( stream->readFlag() ) // TransformMask
|
|
|
- {
|
|
|
- MatrixF mat;
|
|
|
- mathRead( *stream, &mat );
|
|
|
- setTransform(mat);
|
|
|
- setRenderTransform(mat);
|
|
|
- }
|
|
|
-
|
|
|
- if ( stream->readFlag() ) // ScaleMask
|
|
|
- {
|
|
|
- if ( stream->readFlag() )
|
|
|
- {
|
|
|
- VectorF scale;
|
|
|
- mathRead( *stream, &scale );
|
|
|
- setScale( scale );
|
|
|
- }
|
|
|
- else
|
|
|
- setScale( Point3F::One );
|
|
|
- }
|
|
|
-
|
|
|
- if ( stream->readFlag() ) // UpdateCollisionMask
|
|
|
- {
|
|
|
- U32 collisionType = CollisionMesh;
|
|
|
-
|
|
|
- stream->read( &collisionType );
|
|
|
-
|
|
|
- // Handle it if we have changed CollisionType's
|
|
|
- if ( (MeshType)collisionType != mCollisionType )
|
|
|
- {
|
|
|
- mCollisionType = (MeshType)collisionType;
|
|
|
-
|
|
|
- if ( isProperlyAdded() && mShapeInstance )
|
|
|
- prepCollision();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (stream->readFlag()) // SkinMask
|
|
|
- {
|
|
|
- NetStringHandle skinDesiredNameHandle = con->unpackNetStringHandleU(stream);;
|
|
|
- if (mSkinNameHandle != skinDesiredNameHandle)
|
|
|
- {
|
|
|
- mSkinNameHandle = skinDesiredNameHandle;
|
|
|
- reSkin();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (stream->readFlag()) // AdvancedStaticOptionsMask
|
|
|
- {
|
|
|
- mShapeName = stream->readSTString();
|
|
|
-
|
|
|
- stream->read((U32*)&mDecalType);
|
|
|
-
|
|
|
- mAllowPlayerStep = stream->readFlag();
|
|
|
- mMeshCulling = stream->readFlag();
|
|
|
- mUseOriginSort = stream->readFlag();
|
|
|
-
|
|
|
- stream->read(&mRenderNormalScalar);
|
|
|
-
|
|
|
- stream->read(&mForceDetail);
|
|
|
- mPlayAmbient = stream->readFlag();
|
|
|
- }
|
|
|
-
|
|
|
- mUseAlphaFade = stream->readFlag();
|
|
|
- if (mUseAlphaFade)
|
|
|
- {
|
|
|
- stream->read(&mAlphaFadeStart);
|
|
|
- stream->read(&mAlphaFadeEnd);
|
|
|
- stream->read(&mInvertAlphaFade);
|
|
|
- }
|
|
|
-
|
|
|
- if ( mLightPlugin )
|
|
|
- {
|
|
|
- mLightPlugin->unpackUpdate(this, con, stream);
|
|
|
- }
|
|
|
-
|
|
|
- if( stream->readFlag() )
|
|
|
- {
|
|
|
- cubeDescId = stream->readRangedU32( DataBlockObjectIdFirst, DataBlockObjectIdLast );
|
|
|
- }
|
|
|
-
|
|
|
- if ( isProperlyAdded() )
|
|
|
- _updateShouldTick();
|
|
|
-}
|
|
|
-
|
|
|
-//----------------------------------------------------------------------------
|
|
|
-bool TSStatic::castRay(const Point3F &start, const Point3F &end, RayInfo* info)
|
|
|
-{
|
|
|
- if ( mCollisionType == None )
|
|
|
- return false;
|
|
|
-
|
|
|
- if ( !mShapeInstance )
|
|
|
- return false;
|
|
|
-
|
|
|
- if ( mCollisionType == Bounds )
|
|
|
- {
|
|
|
- F32 fst;
|
|
|
- if (!mObjBox.collideLine(start, end, &fst, &info->normal))
|
|
|
- return false;
|
|
|
-
|
|
|
- info->t = fst;
|
|
|
- info->object = this;
|
|
|
- info->point.interpolate( start, end, fst );
|
|
|
- info->material = NULL;
|
|
|
- return true;
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- RayInfo shortest = *info;
|
|
|
- RayInfo localInfo;
|
|
|
- shortest.t = 1e8f;
|
|
|
- localInfo.generateTexCoord = info->generateTexCoord;
|
|
|
-
|
|
|
- for ( U32 i = 0; i < mLOSDetails.size(); i++ )
|
|
|
- {
|
|
|
- mShapeInstance->animate( mLOSDetails[i] );
|
|
|
-
|
|
|
- if ( mShapeInstance->castRayOpcode( mLOSDetails[i], start, end, &localInfo ) )
|
|
|
- {
|
|
|
- localInfo.object = this;
|
|
|
-
|
|
|
- if (localInfo.t < shortest.t)
|
|
|
- shortest = localInfo;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (shortest.object == this)
|
|
|
- {
|
|
|
- // Copy out the shortest time...
|
|
|
- *info = shortest;
|
|
|
- return true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-bool TSStatic::castRayRendered(const Point3F &start, const Point3F &end, RayInfo *info)
|
|
|
-{
|
|
|
- if ( !mShapeInstance )
|
|
|
- return false;
|
|
|
-
|
|
|
- // Cast the ray against the currently visible detail
|
|
|
- RayInfo localInfo;
|
|
|
- bool res = mShapeInstance->castRayOpcode( mShapeInstance->getCurrentDetail(), start, end, &localInfo );
|
|
|
-
|
|
|
- if ( res )
|
|
|
- {
|
|
|
- *info = localInfo;
|
|
|
- info->object = this;
|
|
|
- return true;
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-bool TSStatic::buildPolyList(PolyListContext context, AbstractPolyList* polyList, const Box3F &box, const SphereF &)
|
|
|
-{
|
|
|
- if ( !mShapeInstance )
|
|
|
- return false;
|
|
|
-
|
|
|
- // This is safe to set even if we're not outputing
|
|
|
- polyList->setTransform( &mObjToWorld, mObjScale );
|
|
|
- polyList->setObject( this );
|
|
|
-
|
|
|
- if ( context == PLC_Export )
|
|
|
- {
|
|
|
- // Use highest detail level
|
|
|
- S32 dl = 0;
|
|
|
-
|
|
|
- // Try to call on the client so we can export materials
|
|
|
- if ( isServerObject() && getClientObject() )
|
|
|
- dynamic_cast<TSStatic*>(getClientObject())->mShapeInstance->buildPolyList( polyList, dl );
|
|
|
- else
|
|
|
- mShapeInstance->buildPolyList( polyList, dl );
|
|
|
- }
|
|
|
- else if ( context == PLC_Selection )
|
|
|
- {
|
|
|
- // Use the last rendered detail level
|
|
|
- S32 dl = mShapeInstance->getCurrentDetail();
|
|
|
- mShapeInstance->buildPolyListOpcode( dl, polyList, box );
|
|
|
- }
|
|
|
- else
|
|
|
- {
|
|
|
- // Figure out the mesh type we're looking for.
|
|
|
- MeshType meshType = ( context == PLC_Decal ) ? mDecalType : mCollisionType;
|
|
|
-
|
|
|
- if ( meshType == None )
|
|
|
- return false;
|
|
|
- else if ( meshType == Bounds )
|
|
|
- polyList->addBox( mObjBox );
|
|
|
- else if ( meshType == VisibleMesh )
|
|
|
- mShapeInstance->buildPolyList( polyList, 0 );
|
|
|
- else
|
|
|
- {
|
|
|
- // Everything else is done from the collision meshes
|
|
|
- // which may be built from either the visual mesh or
|
|
|
- // special collision geometry.
|
|
|
- for ( U32 i = 0; i < mCollisionDetails.size(); i++ )
|
|
|
- mShapeInstance->buildPolyListOpcode( mCollisionDetails[i], polyList, box );
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::buildConvex(const Box3F& box, Convex* convex)
|
|
|
-{
|
|
|
- if ( mCollisionType == None )
|
|
|
- return;
|
|
|
-
|
|
|
- if ( mShapeInstance == NULL )
|
|
|
- return;
|
|
|
-
|
|
|
- // These should really come out of a pool
|
|
|
- mConvexList->collectGarbage();
|
|
|
-
|
|
|
- if ( mCollisionType == Bounds )
|
|
|
- {
|
|
|
- // Just return a box convex for the entire shape...
|
|
|
- Convex* cc = 0;
|
|
|
- CollisionWorkingList& wl = convex->getWorkingList();
|
|
|
- for (CollisionWorkingList* itr = wl.wLink.mNext; itr != &wl; itr = itr->wLink.mNext)
|
|
|
- {
|
|
|
- if (itr->mConvex->getType() == BoxConvexType &&
|
|
|
- itr->mConvex->getObject() == this)
|
|
|
- {
|
|
|
- cc = itr->mConvex;
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
- if (cc)
|
|
|
- return;
|
|
|
-
|
|
|
- // Create a new convex.
|
|
|
- BoxConvex* cp = new BoxConvex;
|
|
|
- mConvexList->registerObject(cp);
|
|
|
- convex->addToWorkingList(cp);
|
|
|
- cp->init(this);
|
|
|
-
|
|
|
- mObjBox.getCenter(&cp->mCenter);
|
|
|
- cp->mSize.x = mObjBox.len_x() / 2.0f;
|
|
|
- cp->mSize.y = mObjBox.len_y() / 2.0f;
|
|
|
- cp->mSize.z = mObjBox.len_z() / 2.0f;
|
|
|
- }
|
|
|
- else // CollisionMesh || VisibleMesh
|
|
|
- {
|
|
|
- TSStaticPolysoupConvex::smCurObject = this;
|
|
|
-
|
|
|
- for (U32 i = 0; i < mCollisionDetails.size(); i++)
|
|
|
- mShapeInstance->buildConvexOpcode( mObjToWorld, mObjScale, mCollisionDetails[i], box, convex, mConvexList );
|
|
|
-
|
|
|
- TSStaticPolysoupConvex::smCurObject = NULL;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-SceneObject* TSStaticPolysoupConvex::smCurObject = NULL;
|
|
|
-
|
|
|
-TSStaticPolysoupConvex::TSStaticPolysoupConvex()
|
|
|
-: box( 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f ),
|
|
|
- normal( 0.0f, 0.0f, 0.0f, 0.0f ),
|
|
|
- idx( 0 ),
|
|
|
- mesh( NULL )
|
|
|
-{
|
|
|
- mType = TSPolysoupConvexType;
|
|
|
-
|
|
|
- for ( U32 i = 0; i < 4; ++i )
|
|
|
- {
|
|
|
- verts[i].set( 0.0f, 0.0f, 0.0f );
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-Point3F TSStaticPolysoupConvex::support(const VectorF& vec) const
|
|
|
-{
|
|
|
- F32 bestDot = mDot( verts[0], vec );
|
|
|
-
|
|
|
- const Point3F *bestP = &verts[0];
|
|
|
- for(S32 i=1; i<4; i++)
|
|
|
- {
|
|
|
- F32 newD = mDot(verts[i], vec);
|
|
|
- if(newD > bestDot)
|
|
|
- {
|
|
|
- bestDot = newD;
|
|
|
- bestP = &verts[i];
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return *bestP;
|
|
|
-}
|
|
|
-
|
|
|
-Box3F TSStaticPolysoupConvex::getBoundingBox() const
|
|
|
-{
|
|
|
- Box3F wbox = box;
|
|
|
- wbox.minExtents.convolve( mObject->getScale() );
|
|
|
- wbox.maxExtents.convolve( mObject->getScale() );
|
|
|
- mObject->getTransform().mul(wbox);
|
|
|
- return wbox;
|
|
|
-}
|
|
|
-
|
|
|
-Box3F TSStaticPolysoupConvex::getBoundingBox(const MatrixF& mat, const Point3F& scale) const
|
|
|
-{
|
|
|
- AssertISV(false, "TSStaticPolysoupConvex::getBoundingBox(m,p) - Not implemented. -- XEA");
|
|
|
- return box;
|
|
|
-}
|
|
|
-
|
|
|
-void TSStaticPolysoupConvex::getPolyList(AbstractPolyList *list)
|
|
|
-{
|
|
|
- // Transform the list into object space and set the pointer to the object
|
|
|
- MatrixF i( mObject->getTransform() );
|
|
|
- Point3F iS( mObject->getScale() );
|
|
|
- list->setTransform(&i, iS);
|
|
|
- list->setObject(mObject);
|
|
|
-
|
|
|
- // Add only the original collision triangle
|
|
|
- S32 base = list->addPoint(verts[0]);
|
|
|
- list->addPoint(verts[2]);
|
|
|
- list->addPoint(verts[1]);
|
|
|
-
|
|
|
- list->begin(0, (U32)idx ^ (uintptr_t)mesh);
|
|
|
- list->vertex(base + 2);
|
|
|
- list->vertex(base + 1);
|
|
|
- list->vertex(base + 0);
|
|
|
- list->plane(base + 0, base + 1, base + 2);
|
|
|
- list->end();
|
|
|
-}
|
|
|
-
|
|
|
-void TSStaticPolysoupConvex::getFeatures(const MatrixF& mat,const VectorF& n, ConvexFeature* cf)
|
|
|
-{
|
|
|
- cf->material = 0;
|
|
|
- cf->object = mObject;
|
|
|
-
|
|
|
- // For a tetrahedron this is pretty easy... first
|
|
|
- // convert everything into world space.
|
|
|
- Point3F tverts[4];
|
|
|
- mat.mulP(verts[0], &tverts[0]);
|
|
|
- mat.mulP(verts[1], &tverts[1]);
|
|
|
- mat.mulP(verts[2], &tverts[2]);
|
|
|
- mat.mulP(verts[3], &tverts[3]);
|
|
|
-
|
|
|
- // points...
|
|
|
- S32 firstVert = cf->mVertexList.size();
|
|
|
- cf->mVertexList.increment(); cf->mVertexList.last() = tverts[0];
|
|
|
- cf->mVertexList.increment(); cf->mVertexList.last() = tverts[1];
|
|
|
- cf->mVertexList.increment(); cf->mVertexList.last() = tverts[2];
|
|
|
- cf->mVertexList.increment(); cf->mVertexList.last() = tverts[3];
|
|
|
-
|
|
|
- // edges...
|
|
|
- cf->mEdgeList.increment();
|
|
|
- cf->mEdgeList.last().vertex[0] = firstVert+0;
|
|
|
- cf->mEdgeList.last().vertex[1] = firstVert+1;
|
|
|
-
|
|
|
- cf->mEdgeList.increment();
|
|
|
- cf->mEdgeList.last().vertex[0] = firstVert+1;
|
|
|
- cf->mEdgeList.last().vertex[1] = firstVert+2;
|
|
|
-
|
|
|
- cf->mEdgeList.increment();
|
|
|
- cf->mEdgeList.last().vertex[0] = firstVert+2;
|
|
|
- cf->mEdgeList.last().vertex[1] = firstVert+0;
|
|
|
-
|
|
|
- cf->mEdgeList.increment();
|
|
|
- cf->mEdgeList.last().vertex[0] = firstVert+3;
|
|
|
- cf->mEdgeList.last().vertex[1] = firstVert+0;
|
|
|
-
|
|
|
- cf->mEdgeList.increment();
|
|
|
- cf->mEdgeList.last().vertex[0] = firstVert+3;
|
|
|
- cf->mEdgeList.last().vertex[1] = firstVert+1;
|
|
|
-
|
|
|
- cf->mEdgeList.increment();
|
|
|
- cf->mEdgeList.last().vertex[0] = firstVert+3;
|
|
|
- cf->mEdgeList.last().vertex[1] = firstVert+2;
|
|
|
-
|
|
|
- // triangles...
|
|
|
- cf->mFaceList.increment();
|
|
|
- cf->mFaceList.last().normal = PlaneF(tverts[2], tverts[1], tverts[0]);
|
|
|
- cf->mFaceList.last().vertex[0] = firstVert+2;
|
|
|
- cf->mFaceList.last().vertex[1] = firstVert+1;
|
|
|
- cf->mFaceList.last().vertex[2] = firstVert+0;
|
|
|
-
|
|
|
- cf->mFaceList.increment();
|
|
|
- cf->mFaceList.last().normal = PlaneF(tverts[1], tverts[0], tverts[3]);
|
|
|
- cf->mFaceList.last().vertex[0] = firstVert+1;
|
|
|
- cf->mFaceList.last().vertex[1] = firstVert+0;
|
|
|
- cf->mFaceList.last().vertex[2] = firstVert+3;
|
|
|
-
|
|
|
- cf->mFaceList.increment();
|
|
|
- cf->mFaceList.last().normal = PlaneF(tverts[2], tverts[1], tverts[3]);
|
|
|
- cf->mFaceList.last().vertex[0] = firstVert+2;
|
|
|
- cf->mFaceList.last().vertex[1] = firstVert+1;
|
|
|
- cf->mFaceList.last().vertex[2] = firstVert+3;
|
|
|
-
|
|
|
- cf->mFaceList.increment();
|
|
|
- cf->mFaceList.last().normal = PlaneF(tverts[0], tverts[2], tverts[3]);
|
|
|
- cf->mFaceList.last().vertex[0] = firstVert+0;
|
|
|
- cf->mFaceList.last().vertex[1] = firstVert+2;
|
|
|
- cf->mFaceList.last().vertex[2] = firstVert+3;
|
|
|
-
|
|
|
- // All done!
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::onMount( SceneObject *obj, S32 node )
|
|
|
-{
|
|
|
- Parent::onMount(obj, node);
|
|
|
- _updateShouldTick();
|
|
|
-}
|
|
|
-
|
|
|
-void TSStatic::onUnmount( SceneObject *obj, S32 node )
|
|
|
-{
|
|
|
- Parent::onUnmount( obj, node );
|
|
|
- setMaskBits( TransformMask );
|
|
|
- _updateShouldTick();
|
|
|
-}
|
|
|
-
|
|
|
-//------------------------------------------------------------------------
|
|
|
-//These functions are duplicated in tsStatic and shapeBase.
|
|
|
-//They each function a little differently; but achieve the same purpose of gathering
|
|
|
-//target names/counts without polluting simObject.
|
|
|
-
|
|
|
-DefineEngineMethod( TSStatic, getTargetName, const char*, ( S32 index ),(0),
|
|
|
- "Get the name of the indexed shape material.\n"
|
|
|
- "@param index index of the material to get (valid range is 0 - getTargetCount()-1).\n"
|
|
|
- "@return the name of the indexed material.\n"
|
|
|
- "@see getTargetCount()\n")
|
|
|
-{
|
|
|
- TSStatic *obj = dynamic_cast< TSStatic* > ( object );
|
|
|
- if(obj)
|
|
|
- {
|
|
|
- // Try to use the client object (so we get the reskinned targets in the Material Editor)
|
|
|
- if ((TSStatic*)obj->getClientObject())
|
|
|
- obj = (TSStatic*)obj->getClientObject();
|
|
|
-
|
|
|
- return obj->getShapeInstance()->getTargetName(index);
|
|
|
- }
|
|
|
-
|
|
|
- return "";
|
|
|
-}
|
|
|
-
|
|
|
-DefineEngineMethod( TSStatic, getTargetCount, S32,(),,
|
|
|
- "Get the number of materials in the shape.\n"
|
|
|
- "@return the number of materials in the shape.\n"
|
|
|
- "@see getTargetName()\n")
|
|
|
-{
|
|
|
- TSStatic *obj = dynamic_cast< TSStatic* > ( object );
|
|
|
- if(obj)
|
|
|
- {
|
|
|
- // Try to use the client object (so we get the reskinned targets in the Material Editor)
|
|
|
- if ((TSStatic*)obj->getClientObject())
|
|
|
- obj = (TSStatic*)obj->getClientObject();
|
|
|
-
|
|
|
- return obj->getShapeInstance()->getTargetCount();
|
|
|
- }
|
|
|
-
|
|
|
- return -1;
|
|
|
-}
|
|
|
-
|
|
|
-// This method is able to change materials per map to with others. The material that is being replaced is being mapped to
|
|
|
-// unmapped_mat as a part of this transition
|
|
|
-
|
|
|
-DefineEngineMethod( TSStatic, changeMaterial, void, ( const char* mapTo, Material* oldMat, Material* newMat ),("",nullAsType<Material*>(),nullAsType<Material*>()),
|
|
|
- "@brief Change one of the materials on the shape.\n\n"
|
|
|
-
|
|
|
- "This method changes materials per mapTo with others. The material that "
|
|
|
- "is being replaced is mapped to unmapped_mat as a part of this transition.\n"
|
|
|
-
|
|
|
- "@note Warning, right now this only sort of works. It doesn't do a live "
|
|
|
- "update like it should.\n"
|
|
|
-
|
|
|
- "@param mapTo the name of the material target to remap (from getTargetName)\n"
|
|
|
- "@param oldMat the old Material that was mapped \n"
|
|
|
- "@param newMat the new Material to map\n\n"
|
|
|
-
|
|
|
- "@tsexample\n"
|
|
|
- "// remap the first material in the shape\n"
|
|
|
- "%mapTo = %obj.getTargetName( 0 );\n"
|
|
|
- "%obj.changeMaterial( %mapTo, 0, MyMaterial );\n"
|
|
|
- "@endtsexample\n" )
|
|
|
-{
|
|
|
- // if no valid new material, theres no reason for doing this
|
|
|
- if( !newMat )
|
|
|
- {
|
|
|
- Con::errorf("TSShape::changeMaterial failed: New material does not exist!");
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- TSMaterialList* shapeMaterialList = object->getShape()->materialList;
|
|
|
-
|
|
|
- // Check the mapTo name exists for this shape
|
|
|
- S32 matIndex = shapeMaterialList->getMaterialNameList().find_next(String(mapTo));
|
|
|
- if (matIndex < 0)
|
|
|
- {
|
|
|
- Con::errorf("TSShape::changeMaterial failed: Invalid mapTo name '%s'", mapTo);
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- // Lets remap the old material off, so as to let room for our current material room to claim its spot
|
|
|
- if( oldMat )
|
|
|
- oldMat->mMapTo = String("unmapped_mat");
|
|
|
-
|
|
|
- newMat->mMapTo = mapTo;
|
|
|
-
|
|
|
- // Map the material by name in the matmgr
|
|
|
- MATMGR->mapMaterial( mapTo, newMat->getName() );
|
|
|
-
|
|
|
- // Replace instances with the new material being traded in. Lets make sure that we only
|
|
|
- // target the specific targets per inst, this is actually doing more than we thought
|
|
|
- delete shapeMaterialList->mMatInstList[matIndex];
|
|
|
- shapeMaterialList->mMatInstList[matIndex] = newMat->createMatInstance();
|
|
|
-
|
|
|
- // Finish up preparing the material instances for rendering
|
|
|
- const GFXVertexFormat *flags = getGFXVertexFormat<GFXVertexPNTTB>();
|
|
|
- FeatureSet features = MATMGR->getDefaultFeatures();
|
|
|
- shapeMaterialList->getMaterialInst(matIndex)->init(features, flags);
|
|
|
-}
|
|
|
-
|
|
|
-DefineEngineMethod( TSStatic, getModelFile, const char *, (),,
|
|
|
- "@brief Get the model filename used by this shape.\n\n"
|
|
|
-
|
|
|
- "@return the shape filename\n\n"
|
|
|
- "@tsexample\n"
|
|
|
- "// Acquire the model filename used on this shape.\n"
|
|
|
- "%modelFilename = %obj.getModelFile();\n"
|
|
|
- "@endtsexample\n"
|
|
|
- )
|
|
|
-{
|
|
|
-<<<<<<< HEAD
|
|
|
- return object->getShapeFileName();
|
|
|
-=======
|
|
|
- return object->getShapeFileName();
|
|
|
->>>>>>> garagegames/development
|
|
|
-}
|
Marc Chapman