int ON_String::Replace( char token1, char token2 )
{
int count = 0;
int i = Length();
while (i--)
{
if ( token1 == m_s[i] )
{
if ( 0 == count )
CopyArray();
m_s[i] = token2;
count++;
}
}
return count;
}
template<class T> static void
ConvertTo(T *data, int &n, ADIOS_DATATYPES &t, const void *readData)
{
switch(t)
{
case adios_unsigned_byte:
CopyArray((const unsigned char *)readData, data, n);
break;
case adios_byte:
CopyArray((const char *)readData, data, n);
break;
case adios_unsigned_short:
CopyArray((const unsigned short *)readData, data, n);
break;
case adios_short:
CopyArray((const short *)readData, data, n);
break;
case adios_unsigned_integer:
CopyArray((const unsigned int *)readData, data, n);
break;
case adios_integer:
CopyArray((const int *)readData, data, n);
break;
case adios_unsigned_long:
CopyArray((const unsigned long *)readData, data, n);
break;
case adios_long:
CopyArray((const long *)readData, data, n);
break;
case adios_double:
CopyArray((const double *)readData, data, n);
break;
default:
std::string str = "Inavlid variable type";
EXCEPTION1(InvalidVariableException, str);
break;
}
}
Var JavascriptGeneratorFunction::EntryAsyncFunctionImplementation(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(stackArgs, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
JavascriptLibrary* library = scriptContext->GetLibrary();
RecyclableObject* prototype = scriptContext->GetLibrary()->GetNull();
// InterpreterStackFrame takes a pointer to the args, so copy them to the recycler heap
// and use that buffer for this InterpreterStackFrame.
Field(Var)* argsHeapCopy = RecyclerNewArray(scriptContext->GetRecycler(), Field(Var), stackArgs.Info.Count);
CopyArray(argsHeapCopy, stackArgs.Info.Count, stackArgs.Values, stackArgs.Info.Count);
Arguments heapArgs(callInfo, (Var*)argsHeapCopy);
JavascriptExceptionObject* e = nullptr;
JavascriptPromiseResolveOrRejectFunction* resolve;
JavascriptPromiseResolveOrRejectFunction* reject;
JavascriptPromiseAsyncSpawnExecutorFunction* executor =
library->CreatePromiseAsyncSpawnExecutorFunction(
JavascriptPromise::EntryJavascriptPromiseAsyncSpawnExecutorFunction,
scriptContext->GetLibrary()->CreateGenerator(heapArgs, JavascriptAsyncFunction::FromVar(function)->GetGeneratorVirtualScriptFunction(), prototype),
stackArgs[0]);
JavascriptPromise* promise = library->CreatePromise();
JavascriptPromise::InitializePromise(promise, &resolve, &reject, scriptContext);
try
{
CALL_FUNCTION(scriptContext->GetThreadContext(), executor, CallInfo(CallFlags_Value, 3), library->GetUndefined(), resolve, reject);
}
catch (const JavascriptException& err)
{
e = err.GetAndClear();
}
if (e != nullptr)
{
JavascriptPromise::TryRejectWithExceptionObject(e, reject, scriptContext);
}
return promise;
}
//?? TODO: may be pass "Ext" here
void appFindGameFiles(const char *Filename, TArray<const CGameFileInfo*>& Files)
{
guard(appFindGameFiles);
if (!appContainsWildcard(Filename))
{
const CGameFileInfo* File = appFindGameFile(Filename);
if (File)
Files.Add(File);
return;
}
// here we're working with wildcard and should iterate over all files
char buf[MAX_PACKAGE_PATH];
appStrncpyz(buf, Filename, ARRAY_COUNT(buf));
// replace backslashes
bool containsPath = false;
for (char* s = buf; *s; s++)
{
char c = *s;
if (c == '\\')
{
*s = '/';
containsPath = true;
}
else if (c == '/')
{
containsPath = true;
}
}
FindPackageWildcardData findData;
findData.WildcardContainsPath = containsPath;
findData.Wildcard = buf;
appEnumGameFiles(FindPackageWildcardCallback, findData);
CopyArray(Files, findData.FoundFiles);
unguardf("wildcard=%s", Filename);
}
/* Iterative MergeSort */
void mergeSort(int A[], int B[], int n)
{
int i, width;
/* Each 1-element run in A is already "sorted". */
/* Make successively longer sorted runs of length 2, 4, 8, 16... until whole array is sorted. */
for (width = 1; width < n; width = 2 * width)
{
/* Array A is full of runs of length width. */
for (i = 0; i < n; i = i + 2 * width)
{
/* Merge two runs: A[i:i+width-1] and A[i+width:i+2*width-1] to B[] */
/* or copy A[i:n-1] to B[] ( if(i+width >= n) ) */
merge(A, i, min(i+width, n), min(i+2*width, n), B);
}
/* Now work array B is full of runs of length 2*width. */
/* Copy array B to array A for next iteration. */
/* A more efficient implementation would swap the roles of A and B */
CopyArray(B, A, n);
/* Now array A is full of runs of length 2*width. */
}
}
void StdExpansion1D::PhysTensorDeriv(const Array<OneD, const NekDouble>& inarray,
Array<OneD, NekDouble>& outarray)
{
int nquad = GetTotPoints();
DNekMatSharedPtr D = m_base[0]->GetD();
#ifdef NEKTAR_USING_DIRECT_BLAS_CALLS
if( inarray.data() == outarray.data())
{
Array<OneD, NekDouble> wsp(nquad);
CopyArray(inarray, wsp);
Blas::Dgemv('N',nquad,nquad,1.0,&(D->GetPtr())[0],nquad,
&wsp[0],1,0.0,&outarray[0],1);
}
else
{
Blas::Dgemv('N',nquad,nquad,1.0,&(D->GetPtr())[0],nquad,
&inarray[0],1,0.0,&outarray[0],1);
}
#else //NEKTAR_USING_DIRECT_BLAS_CALLS
NekVector<NekDouble> out(nquad,outarray,eWrapper);
if(inarray.data() == outarray.data()) // copy intput array
{
NekVector<NekDouble> in(nquad,inarray,eCopy);
out = (*D)*in;
}
else
{
NekVector<NekDouble> in (nquad,inarray,eWrapper);
out = (*D)*in;
}
#endif //NEKTAR_USING_DIRECT_BLAS_CALLS
}
TypePath * TypePath::Grow(Recycler * recycler)
{
uint currentPathLength = this->GetPathLength();
AssertMsg(this->GetPathSize() == currentPathLength, "Why are we growing the type path?");
// Ensure there is at least one free entry in the new path, so we can extend it.
// TypePath::New will take care of aligning this appropriately.
TypePath * clonedPath = TypePath::New(recycler, currentPathLength + 1);
clonedPath->GetData()->pathLength = (uint8)currentPathLength;
memcpy(&clonedPath->GetData()->map, &this->GetData()->map, sizeof(TinyDictionary) + currentPathLength);
CopyArray(clonedPath->assignments, currentPathLength, this->assignments, currentPathLength);
#ifdef SUPPORT_FIXED_FIELDS_ON_PATH_TYPES
// Copy fixed field info
clonedPath->singletonInstance = this->singletonInstance;
clonedPath->GetData()->maxInitializedLength = this->GetData()->maxInitializedLength;
clonedPath->GetData()->fixedFields = this->GetData()->fixedFields;
clonedPath->GetData()->usedFixedFields = this->GetData()->usedFixedFields;
#endif
return clonedPath;
}
Var
WebAssemblyTable::EntryGrow(RecyclableObject* function, CallInfo callInfo, ...)
{
PROBE_STACK(function->GetScriptContext(), Js::Constants::MinStackDefault);
ARGUMENTS(args, callInfo);
ScriptContext* scriptContext = function->GetScriptContext();
Assert(!(callInfo.Flags & CallFlags_New));
if (args.Info.Count == 0 || !WebAssemblyTable::Is(args[0]))
{
JavascriptError::ThrowTypeError(scriptContext, WASMERR_NeedTableObject);
}
WebAssemblyTable * table = WebAssemblyTable::FromVar(args[0]);
uint32 oldLength = table->m_currentLength;
Var deltaVar = args.Info.Count >= 2 ? args[1] : scriptContext->GetLibrary()->GetUndefined();
uint32 delta = WebAssembly::ToNonWrappingUint32(deltaVar, scriptContext);
if (delta > 0)
{
uint32 newLength = 0;
if (UInt32Math::Add(table->m_currentLength, delta, &newLength) || newLength > table->m_maxLength)
{
JavascriptError::ThrowRangeError(scriptContext, JSERR_ArgumentOutOfRange);
}
Field(Var) * newValues = RecyclerNewArrayZ(scriptContext->GetRecycler(), Field(Var), newLength);
CopyArray(newValues, newLength, table->m_values, table->m_currentLength);
table->m_values = newValues;
table->m_currentLength = newLength;
}
return JavascriptNumber::ToVar(oldLength, scriptContext);
}
int ON_wString::Remove( wchar_t c)
{
wchar_t* s0;
wchar_t* s1;
wchar_t* s;
int n;
if ( 0 == (s0 = m_s) )
return 0;
s1 = s0 + Length();
while( s0 < s1 )
{
if (c == *s0++)
{
// need to modify this string
n = ((int)(s0 - m_s)); // keep win64 happy with (int) cast
CopyArray(); // may change m_s if string has multiple refs
s0 = m_s + n;
s = s0-1;
s1 = m_s + Length();
while ( s0 < s1 )
{
if ( c != *s0 )
{
*s++ = *s0;
}
s0++;
}
*s = 0;
n = ((int)(s1 - s)); // keep win64 happy with (int) cast
Header()->string_length -= n;
return n;
}
}
return 0;
}
int ON_String::Replace( const char* token1, const char* token2 )
{
int count = 0;
if ( 0 != token1 && 0 != token1[0] )
{
if ( 0 == token2 )
token2 = "";
const int len1 = (int)strlen(token1);
if ( len1 > 0 )
{
const int len2 = (int)strlen(token2);
int len = Length();
if ( len >= len1 )
{
// in-place
ON_SimpleArray<int> n(32);
const char* s = m_s;
int i;
for ( i = 0; i <= len-len1; /*empty*/ )
{
if ( strncmp(s,token1,len1) )
{
s++;
i++;
}
else
{
n.Append(i);
i += len1;
s += len1;
}
}
count = n.Count();
// reserve array space - must be done even when len2 <= len1
// so that shared arrays are not corrupted.
const int newlen = len + (count*(len2-len1));
if ( 0 == newlen )
{
Destroy();
return count;
}
CopyArray();
// 24 August 2006 Dale Lear
// This used to say
// ReserveArray(newlen);
// but when newlen < len and the string had multiple
// references, the ReserveArray(newlen) call truncated
// the input array.
ReserveArray( ((newlen<len) ? len : newlen) );
int i0, i1, ni, j;
if ( len2 > len1 )
{
// copy from back to front
i1 = newlen;
i0 = len;
for ( ni =0; ni < count; ni++ )
n[ni] = n[ni] + len1;
for ( ni = count-1; ni >= 0; ni-- )
{
j = n[ni];
while ( i0 > j )
{
i0--;
i1--;
m_s[i1] = m_s[i0];
}
i1 -= len2;
i0 -= len1;
memcpy(&m_s[i1],token2,len2*sizeof(m_s[0]));
}
}
else
{
// copy from front to back
i0 = i1 = n[0];
n.Append(len);
for ( ni = 0; ni < count; ni++ )
{
if ( len2 > 0 )
{
memcpy(&m_s[i1],token2,len2*sizeof(m_s[0]));
i1 += len2;
}
i0 += len1;
j = n[ni+1];
while ( i0 < j )
{
m_s[i1++] = m_s[i0++];
}
}
}
Header()->string_length = newlen;
m_s[newlen] = 0;
}
}
}
return count;
}
char* ON_String::Array()
{
CopyArray();
return ( Header()->string_capacity > 0 ) ? m_s : 0;
}
char& ON_String::operator[](int i)
{
CopyArray();
return m_s[i];
}
FString& FString::operator=(const FString& src)
{
CopyArray(Data, src.Data);
return *this;
}
FString::FString(const FString& Other)
{
CopyArray(Data, Other.Data);
}
// Copy Constructor
VehicleRegistry::VehicleRegistry(const VehicleRegistry& vr)
{
CopyArray(vr);
}
T *DuplicateArray(const T *src, size_t count) {
T *result = AllocateArray<T>(count);
return CopyArray(result, src, count);
}
void GameDataHolder::Impl::Flush()
{
if( !FileExist( "save" ) ){
CreateDirectory( "save" );
}
UpdatePlayTime();
std::vector < char > data;
data.reserve( 30000 );
std::ofstream fOut( m_SaveDataFileName, std::ios::binary | std::ios::out );
if( !fOut ){
return;
}
CopyInt( &data, m_GameFileData.m_PlayTime );
CopyInt( &data, m_GameFileData.m_Progress );
for( int i = 0; i < GAME_DIFFICULTY_TOTAL; ++i ){
// 通常プレイの統計情報の保存
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_Play );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_AllClear );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_PlayTime );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_Progress );
for( int j = 0; j < STAGE_TOTAL; ++j ){
// 敵情報の保存
const StageStat& stage = m_GameFileData.m_Difficulty[ i ].m_NormalPlayStat.m_StageStat[ j ];
StageStat::EnemyStatMap::const_iterator it = stage.m_EnemyStat.begin();
// エントリ数の保存
CopyInt( &data, stage.m_EnemyStat.size() );
for( ; it != stage.m_EnemyStat.end(); ++it ){
// 敵の名前の長さ保存
CopyInt( &data, it->first.size() );
// 敵の名前の保存
CopyArray( &data, it->first.c_str(), it->first.size() );
// 情報の保存
CopyInt( &data, it->second.m_Destroy );
CopyInt( &data, it->second.m_Damaged );
CopyInt( &data, it->second.m_KO );
}
}
// ステージ選択プレイの統計情報の保存
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_Play );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_Clear );
CopyInt( &data, m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_PlayTime );
for( int j = 0; j < STAGE_TOTAL; ++j ){
// 敵情報の保存
const StageStat& stage = m_GameFileData.m_Difficulty[ i ].m_StageSelectionPlayStat.m_StageStat[ j ];
StageStat::EnemyStatMap::const_iterator it = stage.m_EnemyStat.begin();
// エントリ数の保存
CopyInt( &data, stage.m_EnemyStat.size() );
for( ; it != stage.m_EnemyStat.end(); ++it ){
// 敵の名前の長さ保存
CopyInt( &data, it->first.size() );
// 敵の名前の保存
CopyArray( &data, it->first.c_str(), it->first.size() );
// 情報の保存
CopyInt( &data, it->second.m_Destroy );
CopyInt( &data, it->second.m_Damaged );
CopyInt( &data, it->second.m_KO );
}
}
// スコアの保存
for( int j = 0; j < MAX_SCORE_ENTRY; ++j ){
SaveDataRecord record = m_GameFileData.m_Difficulty[ i ].m_Record[ j ];
CopyArray( &data, record.m_Name, sizeof( record.m_Name ) );
CopyInt( &data, record.m_Date.m_Year );
data.push_back( record.m_Date.m_Month );
data.push_back( record.m_Date.m_Day );
data.push_back( record.m_Date.m_Hour );
data.push_back( record.m_Date.m_Min );
data.push_back( record.m_Date.m_Sec );
for( int k = 0; k < STAGE_TOTAL; ++k ){
SaveDataRecord::StageData stage = record.m_StageData[ k ];
CopyInt( &data, stage.m_Score );
CopyInt( &data, stage.m_Killed );
CopyInt( &data, stage.m_Crystal );
CopyInt( &data, stage.m_CrystalUsed );
CopyInt( &data, stage.m_Progress );
}
CopyInt( &data, record.m_Score );
CopyInt( &data, record.m_Progress );
CopyInt( &data, record.m_Killed );
CopyInt( &data, record.m_Crystal );
CopyInt( &data, record.m_CrystalUsed );
}
}
// 圧縮
char* pBuf = new char [ data.size() * 2 ];
int compSize = 0;
MAPIL::LZ lz( 200, 3 );
lz.Compress( &data[ 0 ], data.size(), &pBuf, data.size() * 2, &compSize );
// シーザ暗号化
MAPIL::Caesar caesar( 10 );
caesar.Encrypt( pBuf, compSize );
// XOR暗号化
MAPIL::XOR xor( 60 );
xor.Encrypt( pBuf, compSize );
fOut.write( pBuf, compSize );
fOut.close();
MAPIL::SafeDeleteArray( pBuf );
}
inline void CStaticArray<Type>::operator=(const CStaticArray<Type> &arOriginal) {
CopyArray(arOriginal);
}
int ON_wString::RemoveWhiteSpace( const wchar_t* whitespace )
{
wchar_t* s0;
wchar_t* s1;
wchar_t* s;
int n;
wchar_t c;
if ( 0 == (s0 = m_s) )
return 0;
s1 = s0 + Length();
if ( whitespace && *whitespace )
{
while( s0 < s1 )
{
if (IsWhiteSpaceHelper(*s0++,whitespace))
{
// need to modify this string
n = ((int)(s0 - m_s)); // keep win64 happy with (int) cast
CopyArray(); // may change m_s if string has multiple refs
s0 = m_s + n;
s = s0-1;
s1 = m_s + Length();
while ( s0 < s1 )
{
if ( !IsWhiteSpaceHelper(*s0,whitespace) )
{
*s++ = *s0;
}
s0++;
}
*s = 0;
n = ((int)(s1 - s)); // keep win64 happy with (int) cast
Header()->string_length -= n;
return n;
}
}
}
else
{
while( s0 < s1 )
{
c = *s0++;
if ( (1 <= c && c <= 32) || 127 == c )
{
// need to modify this string
n = ((int)(s0 - m_s)); // keep win64 happy with (int) cast
CopyArray(); // may change m_s if string has multiple refs
s0 = m_s + n;
s = s0-1;
s1 = m_s + Length();
while ( s0 < s1 )
{
c = *s0;
if ( c < 1 || (c > 32 && 127 != c) )
{
*s++ = *s0;
}
s0++;
}
*s = 0;
n = ((int)(s1 - s)); // keep win64 happy with (int) cast
Header()->string_length -= n;
return n;
}
}
}
return 0;
}
int ON_wString::ReplaceWhiteSpace( wchar_t token, const wchar_t* whitespace )
{
wchar_t* s0;
wchar_t* s1;
int n;
wchar_t c;
if ( 0 == (s0 = m_s) )
return 0;
s1 = s0 + Length();
if ( whitespace && *whitespace )
{
while( s0 < s1 )
{
if (IsWhiteSpaceHelper(*s0++,whitespace))
{
// need to modify this string
n = ((int)(s0 - m_s)); // keep win64 happy with (int) cast
CopyArray(); // may change m_s if string has multiple refs
s0 = m_s + n;
s1 = m_s + Length();
s0[-1] = token;
n = 1;
while ( s0 < s1 )
{
if ( IsWhiteSpaceHelper(*s0++,whitespace) )
{
s0[-1] = token;
n++;
}
}
return n;
}
}
}
else
{
while( s0 < s1 )
{
c = *s0++;
if ( (1 <= c && c <= 32) || 127 == c )
{
// need to modify this string
n = ((int)(s0 - m_s)); // keep win64 happy with (int) cast
CopyArray(); // may change m_s if string has multiple refs
s0 = m_s + n;
s1 = m_s + Length();
s0[-1] = token;
n = 1;
while ( s0 < s1 )
{
c = *s0++;
if ( (1 <= c && c <= 32) || 127 == c )
{
s0[-1] = token;
n++;
}
}
return n;
}
}
}
return 0;
}
static void ConvertRuneAnimations(UMeshAnimation &Anim, const TArray<RJoint> &Bones,
const TArray<FRSkelAnimSeq> &Seqs)
{
guard(ConvertRuneAnimations);
int i, j;
int numBones = Bones.Num();
// create RefBones
Anim.RefBones.Empty(Bones.Num());
for (i = 0; i < Bones.Num(); i++)
{
const RJoint &SB = Bones[i];
FNamedBone *B = new(Anim.RefBones) FNamedBone;
B->Name = SB.name;
B->Flags = 0;
B->ParentIndex = SB.parent;
}
// create AnimSeqs
Anim.AnimSeqs.Empty(Seqs.Num());
Anim.Moves.Empty(Seqs.Num());
for (i = 0; i < Seqs.Num(); i++)
{
// create FMeshAnimSeq
const FRSkelAnimSeq &SS = Seqs[i];
FMeshAnimSeq *S = new(Anim.AnimSeqs) FMeshAnimSeq;
S->Name = SS.Name;
CopyArray(S->Groups, SS.Groups);
S->StartFrame = 0;
S->NumFrames = SS.NumFrames;
S->Rate = SS.Rate;
//?? S->Notifys
// create MotionChunk
MotionChunk *M = new(Anim.Moves) MotionChunk;
M->TrackTime = SS.NumFrames;
// dummy bone remap
M->AnimTracks.Empty(numBones);
// convert animation data
const byte *data = &SS.animdata[0];
for (j = 0; j < numBones; j++)
{
// prepare AnalogTrack
AnalogTrack *A = new(M->AnimTracks) AnalogTrack;
A->KeyQuat.Empty(SS.NumFrames);
A->KeyPos.Empty(SS.NumFrames);
A->KeyTime.Empty(SS.NumFrames);
}
for (int frame = 0; frame < SS.NumFrames; frame++)
{
for (int joint = 0; joint < numBones; joint++)
{
AnalogTrack &A = M->AnimTracks[joint];
FVector pos, scale;
pos.Set(0, 0, 0);
scale.Set(1, 1, 1);
FRotator rot;
rot.Set(0, 0, 0);
byte f = *data++;
int16 d;
#define GET d = data[0] + (data[1] << 8); data += 2;
#define GETF(v) { GET; v = (float)d / 256.0f; }
#define GETI(v) { GET; v = d; }
// decode position
if (f & 1) GETF(pos.X);
if (f & 2) GETF(pos.Y);
if (f & 4) GETF(pos.Z);
// decode scale
if (f & 8) { GETF(scale.X); GETF(scale.Z); }
if (f & 0x10) GETF(scale.Y);
// decode rotation
if (f & 0x20) GETI(rot.Pitch);
if (f & 0x40) GETI(rot.Yaw);
if (f & 0x80) GETI(rot.Roll);
#undef GET
#undef GETF
#undef GETI
A.KeyQuat.Add(EulerToQuat(rot));
A.KeyPos.Add(pos);
//?? notify about scale!=(1,1,1)
}
}
assert(data == &SS.animdata[0] + SS.animdata.Num());
}
unguard;
}
void USkeleton::ConvertAnims(UAnimSequence4* Seq)
{
guard(USkeleton::ConvertAnims);
CAnimSet* AnimSet = ConvertedAnim;
if (!AnimSet)
{
AnimSet = new CAnimSet(this);
ConvertedAnim = AnimSet;
// Copy bone names
AnimSet->TrackBoneNames.Empty(ReferenceSkeleton.RefBoneInfo.Num());
for (int i = 0; i < ReferenceSkeleton.RefBoneInfo.Num(); i++)
{
AnimSet->TrackBoneNames.Add(ReferenceSkeleton.RefBoneInfo[i].Name);
}
//TODO: verify if UE4 has AnimRotationOnly stuff
AnimSet->AnimRotationOnly = false;
}
if (!Seq) return; // allow calling ConvertAnims(NULL) to create empty AnimSet
// DBG("----------- Skeleton %s: %d seq, %d bones -----------\n", Name, Anims.Num(), ReferenceSkeleton.RefBoneInfo.Num());
int NumTracks = Seq->GetNumTracks();
#if DEBUG_DECOMPRESS
appPrintf("Sequence %s: %d bones, %d offsets (%g per bone), %d frames, %d compressed data\n"
" trans %s, rot %s, scale %s, key %s\n",
Seq->Name, NumTracks, Seq->CompressedTrackOffsets.Num(), Seq->CompressedTrackOffsets.Num() / (float)NumTracks,
Seq->NumFrames, Seq->CompressedByteStream.Num(),
EnumToName(Seq->TranslationCompressionFormat),
EnumToName(Seq->RotationCompressionFormat),
EnumToName(Seq->ScaleCompressionFormat),
EnumToName(Seq->KeyEncodingFormat)
);
for (int i2 = 0; i2 < Seq->CompressedTrackOffsets.Num(); /*empty*/)
{
if (Seq->KeyEncodingFormat != AKF_PerTrackCompression)
{
FName BoneName = ReferenceSkeleton.RefBoneInfo[Seq->GetTrackBoneIndex(i2/4)].Name;
int TransOffset = Seq->CompressedTrackOffsets[i2 ];
int TransKeys = Seq->CompressedTrackOffsets[i2+1];
int RotOffset = Seq->CompressedTrackOffsets[i2+2];
int RotKeys = Seq->CompressedTrackOffsets[i2+3];
appPrintf(" [%d] = trans %d[%d] rot %d[%d] - %s\n", i2/4, TransOffset, TransKeys, RotOffset, RotKeys, *BoneName);
i2 += 4;
}
else
{
FName BoneName = ReferenceSkeleton.RefBoneInfo[Seq->GetTrackBoneIndex(i2/2)].Name;
int TransOffset = Seq->CompressedTrackOffsets[i2 ];
int RotOffset = Seq->CompressedTrackOffsets[i2+1];
appPrintf(" [%d] = trans %d rot %d - %s\n", i2/2, TransOffset, RotOffset, *BoneName);
i2 += 2;
}
}
#endif // DEBUG_DECOMPRESS
// some checks
int offsetsPerBone = 4;
if (Seq->KeyEncodingFormat == AKF_PerTrackCompression)
offsetsPerBone = 2;
if (Seq->CompressedTrackOffsets.Num() != NumTracks * offsetsPerBone && !Seq->RawAnimationData.Num())
{
appNotify("AnimSequence %s has wrong CompressedTrackOffsets size (has %d, expected %d), removing track",
Seq->Name, Seq->CompressedTrackOffsets.Num(), NumTracks * offsetsPerBone);
return;
}
// create CAnimSequence
CAnimSequence *Dst = new CAnimSequence;
AnimSet->Sequences.Add(Dst);
Dst->Name = Seq->Name;
Dst->NumFrames = Seq->NumFrames;
Dst->Rate = Seq->NumFrames / Seq->SequenceLength * Seq->RateScale;
// bone tracks ...
Dst->Tracks.Empty(NumTracks);
FMemReader Reader(Seq->CompressedByteStream.GetData(), Seq->CompressedByteStream.Num());
Reader.SetupFrom(*Package);
bool HasTimeTracks = (Seq->KeyEncodingFormat == AKF_VariableKeyLerp);
for (int BoneIndex = 0; BoneIndex < ReferenceSkeleton.RefBoneInfo.Num(); BoneIndex++)
{
CAnimTrack *A = new (Dst->Tracks) CAnimTrack;
int TrackIndex = Seq->FindTrackForBoneIndex(BoneIndex);
if (TrackIndex < 0)
{
// this track has no animation, use static pose from ReferenceSkeleton
const FTransform& RefPose = ReferenceSkeleton.RefBonePose[BoneIndex];
A->KeyPos.Add(CVT(RefPose.Translation));
A->KeyQuat.Add(CVT(RefPose.Rotation));
//!! RefPose.Scale3D
continue;
}
int k;
if (!Seq->CompressedTrackOffsets.Num()) //?? or if RawAnimData.Num() != 0
{
// using RawAnimData array
assert(Seq->RawAnimationData.Num() == NumTracks);
CopyArray(A->KeyPos, CVT(Seq->RawAnimationData[TrackIndex].PosKeys));
CopyArray(A->KeyQuat, CVT(Seq->RawAnimationData[TrackIndex].RotKeys));
CopyArray(A->KeyTime, Seq->RawAnimationData[TrackIndex].KeyTimes); // may be empty
for (int k = 0; k < A->KeyTime.Num(); k++)
A->KeyTime[k] *= Dst->Rate;
continue;
}
FVector Mins, Ranges; // common ...
static const CVec3 nullVec = { 0, 0, 0 };
static const CQuat nullQuat = { 0, 0, 0, 1 };
int offsetIndex = TrackIndex * offsetsPerBone;
// PARAGON has invalid data inside some animation tracks. Not sure if game engine ignores them
// or trying to process (this game has holes in data due to wrong pointers in CompressedTrackOffsets).
// This causes garbage data to appear instead of real animation track header, with wrong compression
// method etc. We're going to skip such tracks with displaying a warning message.
if (0) // this is just a placeholder for error handler - it should be located somewhere
{
track_error:
AnimSet->Sequences.RemoveSingle(Dst);
delete Dst;
return;
}
//----------------------------------------------
// decode AKF_PerTrackCompression data
//----------------------------------------------
if (Seq->KeyEncodingFormat == AKF_PerTrackCompression)
{
// this format uses different key storage
guard(PerTrackCompression);
assert(Seq->TranslationCompressionFormat == ACF_Identity);
assert(Seq->RotationCompressionFormat == ACF_Identity);
int TransOffset = Seq->CompressedTrackOffsets[offsetIndex ];
int RotOffset = Seq->CompressedTrackOffsets[offsetIndex+1];
uint32 PackedInfo;
AnimationCompressionFormat KeyFormat;
int ComponentMask;
int NumKeys;
#define DECODE_PER_TRACK_INFO(info) \
KeyFormat = (AnimationCompressionFormat)(info >> 28); \
ComponentMask = (info >> 24) & 0xF; \
NumKeys = info & 0xFFFFFF; \
HasTimeTracks = (ComponentMask & 8) != 0;
guard(TransKeys);
// read translation keys
if (TransOffset == -1)
{
A->KeyPos.Add(nullVec);
DBG(" [%d] no translation data\n", TrackIndex);
}
else
{
Reader.Seek(TransOffset);
Reader << PackedInfo;
DECODE_PER_TRACK_INFO(PackedInfo);
A->KeyPos.Empty(NumKeys);
DBG(" [%d] trans: fmt=%d (%s), %d keys, mask %d\n", TrackIndex,
KeyFormat, EnumToName(KeyFormat), NumKeys, ComponentMask
);
if (KeyFormat == ACF_IntervalFixed32NoW)
{
// read mins/maxs
Mins.Set(0, 0, 0);
Ranges.Set(0, 0, 0);
if (ComponentMask & 1) Reader << Mins.X << Ranges.X;
if (ComponentMask & 2) Reader << Mins.Y << Ranges.Y;
if (ComponentMask & 4) Reader << Mins.Z << Ranges.Z;
}
for (k = 0; k < NumKeys; k++)
{
switch (KeyFormat)
{
// case ACF_None:
case ACF_Float96NoW:
{
FVector v;
if (ComponentMask & 7)
{
v.Set(0, 0, 0);
if (ComponentMask & 1) Reader << v.X;
if (ComponentMask & 2) Reader << v.Y;
if (ComponentMask & 4) Reader << v.Z;
}
else
{
// ACF_Float96NoW has a special case for ((ComponentMask & 7) == 0)
Reader << v;
}
A->KeyPos.Add(CVT(v));
}
break;
TPR(ACF_IntervalFixed32NoW, FVectorIntervalFixed32)
case ACF_Fixed48NoW:
{
uint16 X, Y, Z;
CVec3 v;
v.Set(0, 0, 0);
if (ComponentMask & 1)
{
Reader << X; v[0] = DecodeFixed48_PerTrackComponent<7>(X);
}
if (ComponentMask & 2)
{
Reader << Y; v[1] = DecodeFixed48_PerTrackComponent<7>(Y);
}
if (ComponentMask & 4)
{
Reader << Z; v[2] = DecodeFixed48_PerTrackComponent<7>(Z);
}
A->KeyPos.Add(v);
}
break;
case ACF_Identity:
A->KeyPos.Add(nullVec);
break;
default:
{
char buf[1024];
Seq->GetFullName(buf, 1024);
appNotify("%s: unknown translation compression method: %d (%s) - dropping track", buf, KeyFormat, EnumToName(KeyFormat));
goto track_error;
}
}
}
// align to 4 bytes
Reader.Seek(Align(Reader.Tell(), 4));
if (HasTimeTracks)
ReadTimeArray(Reader, NumKeys, A->KeyPosTime, Seq->NumFrames);
}
unguard;
guard(RotKeys);
// read rotation keys
if (RotOffset == -1)
{
A->KeyQuat.Add(nullQuat);
DBG(" [%d] no rotation data\n", TrackIndex);
}
else
{
Reader.Seek(RotOffset);
Reader << PackedInfo;
DECODE_PER_TRACK_INFO(PackedInfo);
A->KeyQuat.Empty(NumKeys);
DBG(" [%d] rot : fmt=%d (%s), %d keys, mask %d\n", TrackIndex,
KeyFormat, EnumToName(KeyFormat), NumKeys, ComponentMask
);
if (KeyFormat == ACF_IntervalFixed32NoW)
{
// read mins/maxs
Mins.Set(0, 0, 0);
Ranges.Set(0, 0, 0);
if (ComponentMask & 1) Reader << Mins.X << Ranges.X;
if (ComponentMask & 2) Reader << Mins.Y << Ranges.Y;
if (ComponentMask & 4) Reader << Mins.Z << Ranges.Z;
}
for (k = 0; k < NumKeys; k++)
{
switch (KeyFormat)
{
// TR (ACF_None, FQuat)
case ACF_Float96NoW:
{
FQuatFloat96NoW q;
Reader << q;
FQuat q2 = q; // convert
A->KeyQuat.Add(CVT(q2));
}
break;
case ACF_Fixed48NoW:
{
FQuatFixed48NoW q;
q.X = q.Y = q.Z = 32767; // corresponds to 0
if (ComponentMask & 1) Reader << q.X;
if (ComponentMask & 2) Reader << q.Y;
if (ComponentMask & 4) Reader << q.Z;
FQuat q2 = q; // convert
A->KeyQuat.Add(CVT(q2));
}
break;
TR (ACF_Fixed32NoW, FQuatFixed32NoW)
TRR(ACF_IntervalFixed32NoW, FQuatIntervalFixed32NoW)
TR (ACF_Float32NoW, FQuatFloat32NoW)
case ACF_Identity:
A->KeyQuat.Add(nullQuat);
break;
default:
{
char buf[1024];
Seq->GetFullName(buf, 1024);
appNotify("%s: unknown rotation compression method: %d (%s) - dropping track", buf, KeyFormat, EnumToName(KeyFormat));
goto track_error;
}
}
}
// align to 4 bytes
Reader.Seek(Align(Reader.Tell(), 4));
if (HasTimeTracks)
ReadTimeArray(Reader, NumKeys, A->KeyQuatTime, Seq->NumFrames);
}
unguard;
unguard;
continue;
// end of AKF_PerTrackCompression block ...
}
//----------------------------------------------
// end of AKF_PerTrackCompression decoder
//----------------------------------------------
// read animations
int TransOffset = Seq->CompressedTrackOffsets[offsetIndex ];
int TransKeys = Seq->CompressedTrackOffsets[offsetIndex+1];
int RotOffset = Seq->CompressedTrackOffsets[offsetIndex+2];
int RotKeys = Seq->CompressedTrackOffsets[offsetIndex+3];
// appPrintf("[%d:%d:%d] : %d[%d] %d[%d] %d[%d]\n", j, Seq->RotationCompressionFormat, Seq->TranslationCompressionFormat, TransOffset, TransKeys, RotOffset, RotKeys, ScaleOffset, ScaleKeys);
A->KeyPos.Empty(TransKeys);
A->KeyQuat.Empty(RotKeys);
// read translation keys
if (TransKeys)
{
Reader.Seek(TransOffset);
AnimationCompressionFormat TranslationCompressionFormat = Seq->TranslationCompressionFormat;
if (TransKeys == 1)
TranslationCompressionFormat = ACF_None; // single key is stored without compression
// read mins/ranges
if (TranslationCompressionFormat == ACF_IntervalFixed32NoW)
{
Reader << Mins << Ranges;
}
for (k = 0; k < TransKeys; k++)
{
switch (TranslationCompressionFormat)
{
TP (ACF_None, FVector)
TP (ACF_Float96NoW, FVector)
TPR(ACF_IntervalFixed32NoW, FVectorIntervalFixed32)
TP (ACF_Fixed48NoW, FVectorFixed48)
case ACF_Identity:
A->KeyPos.Add(nullVec);
break;
default:
appError("Unknown translation compression method: %d (%s)", TranslationCompressionFormat, EnumToName(TranslationCompressionFormat));
}
}
// align to 4 bytes
Reader.Seek(Align(Reader.Tell(), 4));
if (HasTimeTracks)
ReadTimeArray(Reader, TransKeys, A->KeyPosTime, Seq->NumFrames);
}
else
{
// A->KeyPos.Add(nullVec);
// appNotify("No translation keys!");
}
int main() {
int threshold=SIZE+5;
int Array1[SIZE] ={};
int Array2[SIZE] ={};
int j=0;
int noElements;
float secondsI[TRIALS]={};
float secondsQ[TRIALS]={};
clock_t end ,start;
while(j<TRIALS){
InitializeArray(Array1,SIZE);
CopyArray(Array1,Array2,SIZE);
//printf("Unsorted array\n\n");
//DisplayArray(Array1,SIZE);
//DisplayArray(Array2,SIZE);
int last = sizeof(Array1)/sizeof(Array1[0])-1;
if(j==0)printf("Threshold = %d \n",threshold);
start = clock();
//quickSort(Array, 0, last);
quickInSort(Array1, 0, last,threshold);
end = clock();
secondsI[j] = (float)(end - start) / CLOCKS_PER_SEC;
last = sizeof(Array2)/sizeof(Array2[0])-1;
threshold=threshold-10;
start = clock();
quickInSort(Array2, 0, last,threshold);
end = clock();
secondsQ[j] = (float)(end - start) / CLOCKS_PER_SEC;
//printf("Sorted array\n\n");
//DisplayArray(Array1,SIZE);
//DisplayArray(Array2,SIZE);
//printf("\n\n");
j++;
}
float avgsumI=0;
float avgsumQ=0;
int i;
for(i=0;i<TRIALS;i++){
avgsumI += secondsI[i];
}
for(i=0;i<TRIALS;i++){
avgsumQ += secondsQ[i];
}
float avgI=avgsumI/TRIALS;
float avgQ=avgsumQ/TRIALS;
printf("using QuickInSort algo with bigger threshold than size Avg Time taken for %d runs = %f sec\n",TRIALS,avgI);
printf("using QuickInSort algo with lower threshold than size(without Insertion sort) Avg Time taken for %d runs = %f sec\n",TRIALS,avgQ);
return 0;
}
void ULodMesh::Serialize(FArchive &Ar)
{
guard(ULodMesh::Serialize);
Super::Serialize(Ar);
Ar << Version << VertexCount << Verts;
if (Version <= 1 || Ar.Game == GAME_SplinterCell)
{
// skip FMeshTri2 section
TArray<FMeshTri2> tmp;
Ar << tmp;
}
#if VANGUARD
if (Ar.Game == GAME_Vanguard && Ar.ArLicenseeVer >= 9)
{
TArray<FVanguardSkin> Skins;
int unk74;
Ar << Skins << unk74;
if (Skins.Num())
CopyArray(Textures, Skins[0].Textures);
goto after_textures;
}
#endif // VANGUARD
Ar << Textures;
after_textures:
#if DEBUG_SKELMESH
for (int i = 0; i < Textures.Num(); i++) appPrintf("Tex[%d] = %s\n", i, Textures[i] ? Textures[i]->Name : "None");
#endif
#if SPLINTER_CELL
if (Ar.Game == GAME_SplinterCell && Version >= 3)
{
TArray<UObject*> unk80;
Ar << unk80;
}
#endif // SPLINTER_CELL
#if LOCO
if (Ar.Game == GAME_Loco)
{
int unk7C;
TArray<FName> unk80;
TArray<FLocoUnk2> unk8C;
TArray<FLocoUnk1> unk98;
if (Version >= 5) Ar << unk98;
if (Version >= 6) Ar << unk80;
if (Version >= 7) Ar << unk8C << unk7C;
}
#endif // LOCO
Ar << MeshScale << MeshOrigin << RotOrigin;
#if DEBUG_SKELMESH
appPrintf("Scale: %g %g %g\nOrigin: %g %g %g\nRotation: %d %d %d\n", FVECTOR_ARG(MeshScale), FVECTOR_ARG(MeshOrigin), FROTATOR_ARG(RotOrigin));
#endif
if (Version <= 1 || Ar.Game == GAME_SplinterCell)
{
// skip 2nd obsolete section
TArray<word> tmp;
Ar << tmp;
}
Ar << FaceLevel << Faces << CollapseWedgeThus << Wedges << Materials;
Ar << MeshScaleMax;
#if EOS
if (Ar.Game == GAME_EOS && Ar.ArLicenseeVer >= 42) goto lod_fields2;
#endif
Ar << LODHysteresis;
lod_fields2:
Ar << LODStrength << LODMinVerts << LODMorph << LODZDisplace;
#if SPLINTER_CELL
if (Ar.Game == GAME_SplinterCell) return;
#endif
if (Version >= 3)
{
Ar << HasImpostor << SpriteMaterial;
Ar << ImpLocation << ImpRotation << ImpScale << ImpColor;
Ar << ImpSpaceMode << ImpDrawMode << ImpLightMode;
}
if (Version >= 4)
{
Ar << SkinTesselationFactor;
}
#if LINEAGE2
if (Ar.Game == GAME_Lineage2 && Version >= 5)
{
int unk;
Ar << unk;
}
#endif // LINEAGE2
#if BATTLE_TERR
if (Ar.Game == GAME_BattleTerr && Version >= 5)
{
TArray<int> unk;
Ar << unk;
}
#endif // BATTLE_TERR
#if SWRC
if (Ar.Game == GAME_RepCommando && Version >= 7)
{
int unkD4, unkD8, unkDC, unkE0;
Ar << unkD4 << unkD8 << unkDC << unkE0;
}
#endif // SWRC
unguard;
}
void nsUInt32Array::CopyArray(nsUInt32Array *oldA)
{
CopyArray(*oldA);
}
