CWE-ou-minkata/Sources/Tools/MaxMain/plPhysicalProps.cpp

/*==LICENSE==*

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

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

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

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

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

*==LICENSE==*/
#include "HeadSpin.h"
#include "plPhysicalProps.h"
#include "../plPhysical/plSimDefs.h"
// For plBoundsType
#include "../pnSceneObject/plSimulationInterface.h"

#include "plMaxNode.h"
#include "../MaxExport/plErrorMsg.h"

/** These enums are used to indicate which parameters are ignorable and can
    be overridden.
    We can't use the "PhysFlags," below, for this, because those only cover boolean properties.
    *** We should use the same enum for both and just not worry that some of the enums aren't
        usable as "ignore" flags, -- the readability & simplification gain would be worth it. */
enum CanIgnore
{
    kMemberGroup                = 0x1,
    kBounceGroup                = 0x2,
    kReportGroup                = 0x4,
    kMass                       = 0x8,      
    kFriction                   = 0x10,
    kRestitution                = 0x20,
    kBoundsType                 = 0x40,
    kProxyNode                  = 0x80,
    kPinned                     = 0x100,
    kAlignToOwner               = 0x200,
    kCameraAvoid                = 0x400,
    kPhysAnim                   = 0x800,
    kCanIgnoreLOSBlockCamera    = 0x1000,
    kCanIgnoreLOSBlockUI        = 0x2000,
    kCanIgnoreLOSUIItem         = 0x4000,
    kCanIgnoreLOSBlockCustom    = 0x8000,
    kCanIgnoreLOSShootable      = 0x10000,
    kCanIgnoreLOSAvatarWalkable = 0x20000,
    kCanIgnoreLOSSwimRegion     = 0x40000,

    kAll                        = 0xffffffff
};

enum PhysFlags
{
    kFlagPinned             = 0x1,
    kFlagAlignToOwner       = 0x2,
    kFlagCameraAvoid        = 0x4,
    kFlagPhysAnim           = 0x8,
    kFlagStartInactive      = 0x10,
    kFlagNoSynchronize      = 0x20,
    kFlagLOSBlockCamera     = 0x40,
    kFlagLOSBlockUI         = 0x80,
    kFlagLOSUIItem          = 0x100,
    kFlagLOSBlockCustom     = 0x200,
    kFlagLOSShootable       = 0x400,
    kFlagLOSAvatarWalkable  = 0x800,
    kFlagLOSSwimRegion      = 0x1000,
};

plPhysicalProps::plPhysicalProps() :
    fUsed(false),
    fCanIgnore(kAll),
    fGroup(0),
    fReportGroup(0),
    fMass(0),
    fFriction(0),
    fRestitution(0),
    fBoundsType(plSimDefs::kHullBounds),
    fProxyNode(nil),
    fFlags(0),
    fSubworld(nil),
    fNoSynchronize(0),
    fStartInactive(0),
    fAvAnimPushable(0)
{
}

bool plPhysicalProps::SetGroup(UInt32 group, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetParam(fGroup, group, kMemberGroup, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetReportGroup(UInt32 notifyGroup, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetParam(fReportGroup, notifyGroup, kReportGroup, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetMass(float mass, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    if(mass != 0.0f)
    {
        if (!GetPinned())
            node->SetMovable(true);
        node->SetForceLocal(true);
    }
    return ISetParam(fMass, mass, kMass, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetFriction(float friction, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetParam(fFriction, friction, kFriction, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetRestitution(float restitution, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetParam(fRestitution, restitution, kRestitution, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetBoundsType(int boundsType, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    hsAssert(boundsType >= 1 && boundsType < plSimDefs::kNumBounds, "Bad bounds type");
    return ISetParam(fBoundsType, boundsType, kBoundsType, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetProxyNode(plMaxNode *proxyNode, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    if( proxyNode )
        proxyNode->SetDrawable(false);

    return ISetParam(fProxyNode, proxyNode, kProxyNode, canIgnore, node, errMsg);
}

bool plPhysicalProps::IGetFlagParam(int flagType)
{
    return ((fFlags & flagType) != 0);
}

bool plPhysicalProps::ISetFlagParam(bool val, int flagType, int type, bool canIgnore, plMaxNode *node, plErrorMsg *errMsg)
{
    bool ourVal = IGetFlagParam(flagType);
    if (ISetParam(ourVal, val, type, canIgnore, node, errMsg))
    {
        if (ourVal)
            fFlags |= flagType;
        else
            fFlags &= ~flagType;
        return true;
    }
    
    return false;
}

bool plPhysicalProps::SetPinned(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagPinned, kPinned, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetLOSBlockCamera(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSBlockCamera, kCanIgnoreLOSBlockCamera, canIgnore, node, errMsg);
}

bool plPhysicalProps::GetLOSBlockCamera()
{
    return IGetFlagParam(kFlagLOSBlockCamera);
}

bool plPhysicalProps::SetLOSBlockUI(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSBlockUI, kCanIgnoreLOSBlockUI, canIgnore, node, errMsg);
}

bool plPhysicalProps::GetLOSBlockUI()
{
    return IGetFlagParam(kFlagLOSBlockUI);
}

bool plPhysicalProps::SetLOSUIItem(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSUIItem, kCanIgnoreLOSUIItem, canIgnore, node, errMsg); 
}

bool plPhysicalProps::GetLOSUIItem()
{
    return IGetFlagParam(kFlagLOSUIItem);
}

bool plPhysicalProps::SetLOSBlockCustom(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSBlockCustom, kCanIgnoreLOSBlockCustom, canIgnore, node, errMsg);
}

bool plPhysicalProps::GetLOSBlockCustom()
{
    return IGetFlagParam(kFlagLOSBlockCustom);
}

bool plPhysicalProps::SetCameraAvoidFlag(bool allowLOS, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(allowLOS, kFlagCameraAvoid, kCameraAvoid, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetLOSShootable(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSShootable, kCanIgnoreLOSShootable, canIgnore, node, errMsg);
}
bool plPhysicalProps::GetLOSShootable()
{
    return IGetFlagParam(kFlagLOSShootable);
}

bool plPhysicalProps::SetLOSAvatarWalkable(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSAvatarWalkable, kCanIgnoreLOSAvatarWalkable, canIgnore, node, errMsg);
}

bool plPhysicalProps::GetLOSAvatarWalkable()
{
    return IGetFlagParam(kFlagLOSAvatarWalkable);
}

bool plPhysicalProps::SetLOSSwimRegion(bool status, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(status, kFlagLOSSwimRegion, kCanIgnoreLOSSwimRegion, canIgnore, node, errMsg);
}

bool plPhysicalProps::GetLOSSwimRegion()
{
    return IGetFlagParam(kFlagLOSSwimRegion);
}

//bool plPhysicalProps::SetUILOSFlag(bool allowLOS, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
//{
//  return ISetFlagParam(allowLOS, kFlagUILOS, kUILOS, canIgnore, node, errMsg);
//}

bool plPhysicalProps::SetAlignToOwner(bool alignToOwner, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(alignToOwner, kFlagAlignToOwner, kAlignToOwner, canIgnore, node, errMsg);
}

bool plPhysicalProps::SetSubworld(plMaxNode* subworld)
{
    // Note that we do *not* set fUsed, because we don't (necessarily) want a physical for this node.
    // We just want to remember that it is a subworld.
    fSubworld = subworld;
    return true;
}

bool plPhysicalProps::SetPhysAnim(bool anim, plMaxNode *node, plErrorMsg *errMsg, bool canIgnore)
{
    return ISetFlagParam(anim, kFlagPhysAnim, kPhysAnim, canIgnore, node, errMsg);
}

bool plPhysicalProps::GetPinned()
{
    return IGetFlagParam(kFlagPinned);
}

bool plPhysicalProps::GetCameraAvoid()
{
    return IGetFlagParam(kFlagCameraAvoid);
}

bool plPhysicalProps::GetAlignToOwner()
{
    return IGetFlagParam(kFlagAlignToOwner);
}

bool plPhysicalProps::GetPhysAnim()
{
    return IGetFlagParam(kFlagPhysAnim);
}

void plPhysicalProps::SetCanIgnore(UInt32 type, bool canIgnore)
{
    if (canIgnore)
        fCanIgnore |= type;
    else
        fCanIgnore &= ~type;
}

bool plPhysicalProps::CanIgnore(UInt32 type)
{
    return ((fCanIgnore & type) != 0);
}

void plPhysicalProps::IDisplayErrorMsg(plMaxNode *node, plErrorMsg *errMsg)
{
    if (!errMsg->IsBogus())
    {
        errMsg->Set(true,
            "Physics Conflict",
            "The node \"%s\" has a conflict in its physical settings.\nMake sure the physical components on it are compatible.",
            node->GetName()).Show();
    }
}