ST::string cdUp(ST::string path) {
// Check for root paths, we can't go up from there!
#ifdef _WIN32
if (path.substr(1) == ":\\")
return path;
#else
if (path == "/")
return path;
#endif
// Not very robust, but it works for one level of parent scanning
if (path.is_empty())
return ".." PATHSEPSTR;
// Strip the ending slash, if necessary, and then go up one dir
if (path.char_at(path.size()-1) == PATHSEP)
path = path.left(path.size() - 1);
ST::string up = path.before_last(PATHSEP);
if (path.char_at(0) == PATHSEP) {
// Absolute path specified -- make sure we keep it that way
return up + PATHSEPSTR;
} else {
// Relative path specified
return up.is_empty() ? "" : up + PATHSEPSTR;
}
}
ST::string plAnimComponentBase::GetIfaceSegmentName( bool allowNil )
{
ST::string name = GetAnimName();
if( allowNil || !name.is_empty() )
return name;
return ENTIRE_ANIMATION_NAME;
}
void FindPackages(std::vector<plFileName>& fileNames, std::vector<plFileName>& pathNames, const plFileName& path, const ST::string& parent_package=ST::null)
{
std::vector<plFileName> packages;
FindSubDirs(packages, path);
for (int i = 0; i < packages.size(); i++)
{
ST::string packageName;
if (!parent_package.is_empty())
packageName = parent_package + ".";
packageName += packages[i].AsString();
std::vector<plFileName> packageFileNames;
std::vector<plFileName> packagePathNames;
plFileName packagePath = plFileName::Join(path, packages[i]);
FindFiles(packageFileNames, packagePathNames, packagePath);
// Check for the magic file to make sure this is really a package...
if (std::find(packageFileNames.begin(), packageFileNames.end(), kModuleFile) != packageFileNames.end()) {
for (int j = 0; j < packageFileNames.size(); j++) {
fileNames.push_back(packageName+"."+packageFileNames[j].AsString());
pathNames.push_back(packagePathNames[j]);
}
FindPackages(fileNames, pathNames, packagePath, packageName);
}
}
}
void plAnimStealthNode::GetLoopPoints( float &start, float &end ) const
{
start = GetSegStart();
end = GetSegEnd();
ST::string loopName = GetLoopName();
if( !loopName.is_empty() && fCachedSegMap != nil )
GetSegMapAnimTime( loopName, fCachedSegMap, SegmentSpec::kLoop, start, end );
}
ST::string FixSlashes(const ST::string& src) {
if (src.is_empty())
return src;
ST::char_buffer dest;
char* pbuf = dest.create_writable_buffer(src.size());
memcpy(pbuf, src.c_str(), src.size() + 1);
for (char* pc = pbuf; *pc != 0; pc++) {
if (*pc == '/' || *pc == '\\')
*pc = PATHSEP;
}
return dest;
}
void plAnimStealthNode::StuffToTimeConvert( plAnimTimeConvert &convert, float maxLength )
{
ST::string segName = GetSegmentName();
bool isEntire = ( segName.is_empty() || segName.compare( ENTIRE_ANIMATION_NAME ) == 0 );
if( isEntire )
{
convert.SetBegin( 0 );
convert.SetEnd( maxLength );
}
else
{
SegmentSpec *spec = IGetSegmentSpec();
convert.SetBegin( ( spec != nil ) ? spec->fStart : 0.f );
convert.SetEnd( ( spec != nil ) ? spec->fEnd : 0.f );
}
// Even if we're not looping, set the loop points. (A responder
// could tell us later to start looping.)
if( isEntire )
convert.SetLoopPoints( 0, maxLength );
else
{
float loopStart, loopEnd;
GetLoopPoints( loopStart, loopEnd );
convert.SetLoopPoints( loopStart, loopEnd );
}
convert.Loop( GetLoop() );
// Auto-start
if( GetAutoStart() )
convert.Start( 0 );
else
convert.Stop( true );
// Stuff stop points
GetAllStopPoints( convert.GetStopPoints() );
// Ease curve stuff
if( GetEaseInType() != plAnimEaseTypes::kNoEase )
{
convert.SetEase( true, GetEaseInType(), GetEaseInMin(), GetEaseInMax(), GetEaseInLength() );
}
if( GetEaseOutType() != plAnimEaseTypes::kNoEase )
{
convert.SetEase( false, GetEaseOutType(), GetEaseOutMin(), GetEaseOutMax(), GetEaseOutLength() );
}
}
SegmentSpec *plAnimStealthNode::IGetSegmentSpec( void ) const
{
if( fCachedSegMap != nil )
{
ST::string name = GetSegmentName();
if( !name.is_empty() )
{
SegmentMap::iterator i = fCachedSegMap->find( name );
if( i != fCachedSegMap->end() )
{
SegmentSpec *spec = i->second;
return spec;
}
}
}
return nil;
}
bool GetSegMapAnimTime(const ST::string &animName, SegmentMap *segMap, SegmentSpec::SegType type, float& begin, float& end)
{
if (segMap)
{
if (!animName.is_empty() && segMap->find(animName) != segMap->end())
{
SegmentSpec *spec = (*segMap)[animName];
if (spec->fType == type)
{
if (spec->fStart != -1)
begin = spec->fStart;
if (spec->fEnd != -1)
end = spec->fEnd;
return true;
}
}
}
return false;
}
//
// Parse a variable descriptor.
// read type, name, count [default]
// return true to skip the next token read
//
bool plSDLParser::IParseVarDesc(const plFileName& fileName, hsStream* stream, char token[],
plStateDescriptor*& curDesc, plVarDescriptor*& curVar) const
{
hsAssert(curDesc, ST::format("Syntax problem with .sdl file, fileName={}", fileName).c_str());
if ( !curDesc )
return false;
bool skipNext=false;
ST::string dbgStr;
static char seps[] = "( ,)[]";
// read type, name, cnt, [default]
//
// TYPE
// create new state var, make current
//
if (*token == '$')
{
// nested sdls
char* sdlName = token+1;
plStateDescriptor* stateDesc = plSDLMgr::GetInstance()->FindDescriptor(sdlName, plSDL::kLatestVersion);
hsAssert(stateDesc, ST::format("can't find nested state desc reference {}, fileName={}",
sdlName, fileName).c_str());
curVar = new plSDVarDescriptor(stateDesc);
}
else
curVar = new plSimpleVarDescriptor;
curDesc->AddVar(curVar);
bool ok=curVar->SetType(token);
hsAssert(ok, ST::format("Variable 'type' syntax problem with .sdl file, type={}, fileName={}",
token, fileName).c_str());
dbgStr = ST::format("\tVAR Type={} ", token);
//
// NAME (foo[1])
//
if (stream->GetToken(token, kTokenLen))
{
hsAssert(strstr(token, "[") != nullptr && strstr(token, "]") != nullptr,
ST::format("invalid var syntax, missing [x], fileName={}", fileName).c_str());
char* ptr = strtok( token, seps ); // skip [
hsAssert(curVar, ST::format("Missing current var. Syntax problem with .sdl file, fileName={}", fileName).c_str());
curVar->SetName(token);
//
// COUNT
//
char* cntTok=strtok(nil, seps); // kill ]
int cnt = cntTok ? atoi(cntTok) : 0;
curVar->SetCount(cnt);
if (cnt==0)
curVar->SetVariableLength(true);
dbgStr += ST::format("Name={}[{}]", curVar->GetName(), cnt);
}
//
// optional tokens: DEFAULT, INTERNAL
//
while (stream->GetToken(token, kTokenLen))
{
if (!strcmp(token, "DEFAULT"))
{
hsAssert(curVar, ST::format("Syntax problem with .sdl file, fileName={}", fileName).c_str());
// read state var type
ST::string defaultStr;
plSimpleVarDescriptor* sVar=(plSimpleVarDescriptor*)curVar;
if (sVar)
{
int i;
for(i=0;i<sVar->GetAtomicCount();i++)
{
if (stream->GetToken(token, kTokenLen))
{
defaultStr += token;
if (i!=sVar->GetAtomicCount()-1)
defaultStr += ",";
}
}
}
if (!defaultStr.is_empty())
{
curVar->SetDefault(defaultStr);
dbgStr += " DEFAULT=" + defaultStr;
}
}
else
if (!strcmp(token, "DISPLAYOPTION"))
{
hsAssert(curVar, ST::format("Syntax problem with .sdl file, fileName={}", fileName).c_str());
dbgStr += ST_LITERAL(" ") + token;
bool read=stream->GetToken(token, kTokenLen);
if (read)
{
ST::string oldOptions=curVar->GetDisplayOptions();
if (!oldOptions.is_empty())
oldOptions += ",";
oldOptions += token;
curVar->SetDisplayOptions(oldOptions);
dbgStr += ST_LITERAL("=") + token;
if (!stricmp(token, "hidden"))
curVar->SetInternal(true);
}
else
{
hsAssert(false, ST::format("missing displayOption string, fileName={}", fileName).c_str());
}
}
else
if (!strcmp(token, "DEFAULTOPTION"))
{
hsAssert(curVar, ST::format("Syntax problem with .sdl file, fileName={}", fileName).c_str());
dbgStr += ST_LITERAL(" ") + token;
bool read=stream->GetToken(token, kTokenLen);
if (read)
{
dbgStr += ST_LITERAL("=") + token;
if (!stricmp(token, "vault"))
curVar->SetAlwaysNew(true);
}
else
{
hsAssert(false, ST::format("missing defaultOption string, fileName={}", fileName).c_str());
}
}
#if 1 // delete me in May 2003
else
if (!strcmp(token, "INTERNAL"))
{
hsAssert(curVar, ST::format("Syntax problem with .sdl file, fileName={}", fileName).c_str());
curVar->SetInternal(true);
dbgStr += ST_LITERAL(" ") + token;
}
else
if (!strcmp(token, "PHASED"))
{
hsAssert(curVar, ST::format("Syntax problem with .sdl file, fileName={}", fileName).c_str());
curVar->SetAlwaysNew(true);
dbgStr += ST_LITERAL(" ") + token;
}
#endif
else
{
skipNext=true;
break;
}
}
DebugMsg(dbgStr);
return skipNext;
}
void plSimulationMgr::ISendUpdates()
{
for (CollisionVec::iterator it = fCollideMsgs.begin(); it != fCollideMsgs.end(); ++it)
{
plCollideMsg* pMsg = *it;
DetectorLogYellow("Collision: %s was triggered by %s. Sending an %s msg", pMsg->GetReceiver(0)->GetName().c_str(),
pMsg->fOtherKey ? pMsg->fOtherKey->GetName().c_str() : "(nil)" , pMsg->fEntering ? "'enter'" : "'exit'");
plgDispatch::Dispatch()->MsgSend(pMsg);
}
fCollideMsgs.clear();
SceneMap::iterator it = fScenes.begin();
for (; it != fScenes.end(); it++)
{
NxScene* scene = it->second;
uint32_t numActors = scene->getNbActors();
NxActor** actors = scene->getActors();
for (int i = 0; i < numActors; i++)
{
plPXPhysical* physical = (plPXPhysical*)actors[i]->userData;
if (physical)
{
if (physical->GetSceneNode())
{
physical->SendNewLocation();
}
else
{
// if there's no scene node, it's not active (probably about to be collected)
const plKey physKey = physical->GetKey();
if (physKey)
{
ST::string physName = physical->GetKeyName();
if (!physName.is_empty())
{
plSimulationMgr::Log("Removing physical <%s> because of missing scene node.\n", physName.c_str());
}
}
// Remove(physical);
}
}
}
// // iterate through the db types, which are powers-of-two enums.
// for( plLOSDB db = static_cast<plLOSDB>(1) ;
// db < plSimDefs::kLOSDBMax;
// db = static_cast<plLOSDB>(db << 1) )
// {
// fLOSSolvers[db]->Resolve(fSubspace);
// }
// if(fNeedLOSCullPhase)
// {
// for( plLOSDB db = static_cast<plLOSDB>(1) ;
// db < plSimDefs::kLOSDBMax;
// db = static_cast<plLOSDB>(db << 1) )
// {
// fLOSSolvers[db]->Resolve(fSubspace);
// }
// fNeedLOSCullPhase = false;
// }
}
}
bool plAnimComponentBase::PreConvert(plMaxNode *node, plErrorMsg *pErrMsg)
{
// If this is the first time in the preconvert, reset the map
if (fNeedReset)
{
fNeedReset = false;
}
// If this node is animated, create it's modifier and key now so we can give
// it out to anyone that needs it
// if (node->IsTMAnimated() || node->IsAnimatedLight())
// {
const char *name = node->GetName();
plAGMasterMod *mod = node->GetAGMasterMod();
if (mod == nil)
{
if (!node->HasAGMod()) // Need to add this before the MasterMod, if it doesn't have one already.
{
node->AddModifier(new plAGModifier(ST::string::from_utf8(node->GetName())), IGetUniqueName(node));
}
mod = new plAGMasterMod();
plKey modKey = node->AddModifier(mod, IGetUniqueName(node));
}
fMods[node] = mod;
// }
// Small change here. We're setting up the timing specs on the
// plAGAnim object during preconvert, so that the info is available
// when actually converting the anim (and for other components
// that need it, but may or may not actually convert before us.)
// Note: if the component uses the "(Entire Animation)" segment for
// the main start/end, the start/end times won't be valid until
// we've added all keys during convert. Some cleanup might
// be necessary in this case.
ST::string animName = ST::string::from_utf8(fCompPB->GetStr(kAnimName));
if (animName.is_empty())
animName = ST_LITERAL(ENTIRE_ANIMATION_NAME);
if (fCompPB->GetInt(ParamID(kAnimUseGlobal)))
{
plAgeGlobalAnim *ageAnim = new plAgeGlobalAnim(animName, 0, 0);
ageAnim->SetGlobalVarName((char*)fCompPB->GetStr(ParamID(kAnimGlobalName)));
fAnims[node] = ageAnim;
}
else
{
plATCAnim *ATCAnim = new plATCAnim(animName, 0, 0);
plNotetrackAnim noteAnim(node, pErrMsg);
plAnimInfo info = noteAnim.GetAnimInfo(animName);
ATCAnim->SetAutoStart(fCompPB->GetInt(kAnimAutoStart));
float start = info.GetAnimStart();
float end = info.GetAnimEnd();
float initial = info.GetAnimInitial();
if (start != -1)
ATCAnim->SetStart(start);
if (end != -1)
ATCAnim->SetEnd(end);
if (initial != -1)
ATCAnim->SetInitial(initial);
if (fCompPB->GetInt(kAnimLoop))
{
ATCAnim->SetLoop(true);
ST::string loopName = ST::string::from_utf8(fCompPB->GetStr(kAnimLoopName));
float loopStart = info.GetLoopStart(loopName);
float loopEnd = info.GetLoopEnd(loopName);
ATCAnim->SetLoopStart(loopStart == -1 ? ATCAnim->GetStart() : loopStart);
ATCAnim->SetLoopEnd(loopEnd == -1 ? ATCAnim->GetEnd() : loopEnd);
}
ST::string loop;
while (!(loop = info.GetNextLoopName()).is_empty())
ATCAnim->AddLoop(loop, info.GetLoopStart(loop), info.GetLoopEnd(loop));
ST::string marker;
while (!(marker = info.GetNextMarkerName()).is_empty())
ATCAnim->AddMarker(marker, info.GetMarkerTime(marker));
float stopPoint = -1;
while ((stopPoint = info.GetNextStopPoint()) != -1)
ATCAnim->AddStopPoint(stopPoint);
ATCAnim->SetEaseInType(fCompPB->GetInt(kAnimEaseInType));
ATCAnim->SetEaseOutType(fCompPB->GetInt(kAnimEaseOutType));
ATCAnim->SetEaseInLength(fCompPB->GetFloat(kAnimEaseInLength));
ATCAnim->SetEaseInMin(fCompPB->GetFloat(kAnimEaseInMin));
ATCAnim->SetEaseInMax(fCompPB->GetFloat(kAnimEaseInMax));
ATCAnim->SetEaseOutLength(fCompPB->GetFloat(kAnimEaseOutLength));
ATCAnim->SetEaseOutMin(fCompPB->GetFloat(kAnimEaseOutMin));
ATCAnim->SetEaseOutMax(fCompPB->GetFloat(kAnimEaseOutMax));
fAnims[node] = ATCAnim;
}
return true;
}