ExtraLock* ExtraLock::Create()
{
ExtraLock* xLock = (ExtraLock*)BSExtraData::Create(kExtraData_Lock, sizeof(ExtraLock), s_ExtraLockVtbl);
ExtraLock::Data* lockData = (ExtraLock::Data*)FormHeap_Allocate(sizeof(ExtraLock::Data));
memset(lockData, 0, sizeof(ExtraLock::Data));
xLock->data = lockData;
return xLock;
}
NiTriShape * NiTriShape::Create(NiTriShapeData * geometry)
{
void* memory = FormHeap_Allocate(sizeof(NiTriShape));
memset(memory, 0, sizeof(NiTriShape));
NiTriShape* xData = (NiTriShape*)memory;
CALL_MEMBER_FN(xData, ctor)(geometry);
return xData;
}
BGSAttackData * BGSAttackData::Create()
{
BGSAttackData *attackData = (BGSAttackData*)FormHeap_Allocate(sizeof(BGSAttackData));
if (attackData)
attackData->ctor();
return attackData;
}
// static
BSExtraData* BSExtraData::Create(UInt8 xType, UInt32 size, UInt32 vtbl)
{
void* memory = FormHeap_Allocate(size);
memset(memory, 0, size);
((UInt32*)memory)[0] = vtbl;
BSExtraData* xData = (BSExtraData*)memory;
xData->type = xType;
return xData;
}
bool ArchiveManager::ExtractArchiveFile( const char* InPath, const char* OutPath, bool AppendFilePath /*= false*/ )
{
bool Result = false;
if (InPath)
{
std::string Path(InPath);
SME::StringHelpers::MakeLower(Path);
if (Path.find("data\\") != -1)
Path = Path.substr(Path.find("data\\") + 5);
if (_FILEFINDER->FindFile(Path.c_str()) == 2)
{
ArchiveFile* ArchiveFileStream = CS_CAST(_FILEFINDER->GetFileStream(Path.c_str(), false, 0x50000), NiBinaryStream, ArchiveFile);
if (ArchiveFileStream)
{
UInt32 FileSize = ArchiveFileStream->GetFileSize();
std::string ArchiveFilePath = ArchiveFileStream->fileName;
std::string ArchiveFileName = ArchiveFilePath.substr(ArchiveFilePath.rfind("\\") + 1);
std::string FileOut = OutPath;
if (AppendFilePath)
FileOut += "\\" + ArchiveFilePath;
DeleteFile(FileOut.c_str()); // delete file as BSFile::Ctor doesn't create it anew
BSFile* TempFile = BSFile::CreateInstance(FileOut.c_str(), NiFile::kFileMode_WriteOnly, FileSize);
SME_ASSERT(TempFile);
void* Buffer = FormHeap_Allocate(FileSize);
ZeroMemory(Buffer, FileSize);
if (!ArchiveFileStream->DirectRead(Buffer, FileSize))
{
BGSEECONSOLE_MESSAGE("ArchiveManager::ExtractArchiveFile - Couldn't read file %s from archive %s", ArchiveFileStream->fileName, ArchiveFileStream->parentArchive->fileName);
}
else
{
if (!TempFile->DirectWrite(Buffer, FileSize))
{
BGSEECONSOLE_MESSAGE("ArchiveManager::ExtractArchiveFile - Couldn't write to file %s", TempFile->fileName);
}
else
Result = true;
}
TempFile->Flush();
TempFile->DeleteInstance();
ArchiveFileStream->DeleteInstance();
FormHeap_Free(Buffer);
}
}
}
return Result;
}
TESPackage::LocationData* TESPackage::LocationData::Create()
{
LocationData* data = (LocationData*)FormHeap_Allocate(sizeof(LocationData));
data->locationType = kPackLocation_CurrentLocation;
data->object.form = NULL;
data->radius = 0;
return data;
}
TESPackage::TargetData* TESPackage::TargetData::Create()
{
TargetData* data = (TargetData*)FormHeap_Allocate(sizeof(TargetData));
// fill out with same defaults as editor uses
data->count = 0;
data->target.objectCode = TESPackage::kObjectType_Activators;
data->targetType = TESPackage::kTargetType_TypeCode;
return data;
}
bool Setting::Set(const char* str)
{
if (GetType() == kSetting_String)
{
char * newVal = (char*)FormHeap_Allocate(strlen(str)+1);
if (!strcpy_s(newVal, strlen(str)+1, str)) {
data.str = newVal;
return true;
}
}
return false;
}
static bool Cmd_ToggleSpecialAnim_Execute(COMMAND_ARGS)
{
// [actor].ToggleSpecialAnim animPath bOnOff [actorBase]
char animPath[512];
TESActorBase* actorBase = NULL;
UInt32 bToggleOn = 0;
if (ExtractArgs(PASS_EXTRACT_ARGS, animPath, &bToggleOn, &actorBase))
{
TESAnimation* anim = OBLIVION_CAST(actorBase, TESActorBase, TESAnimation);
if (!anim && thisObj)
anim = OBLIVION_CAST(thisObj->baseForm, TESForm, TESAnimation);
if (anim)
{
AnimationVisitor visitor(&anim->data);
if (bToggleOn)
{
if (!visitor.FindString(animPath))
{
UInt32 sLen = strlen(animPath);
TESAnimation::AnimationNode* newNode = (TESAnimation::AnimationNode*)FormHeap_Allocate(sizeof(TESAnimation::AnimationNode));
newNode->animationName = (char*)FormHeap_Allocate(sLen + 1);
strcpy_s(newNode->animationName, sLen + 1, animPath);
newNode->next = NULL;
visitor.Append(newNode);
*result = 1;
}
}
else
* result = visitor.RemoveString(animPath) ? 1 : 0;
}
}
if (IsConsoleMode())
Console_Print("ToggleSpecialAnim %d >> %.0f", bToggleOn, *result);
return true;
}
UInt32 Script::AddVariable(TESForm * form)
{
UInt32 resultIdx = 1;
RefVariable * var = (RefVariable*)FormHeap_Allocate(sizeof(RefVariable));
var->name.Set("");
var->form = form;
var->varIdx = 0;
if(!refList.var)
{
// adding the first object
refList.var = var;
refList.next = NULL;
}
else
{
resultIdx++;
// find the last RefListEntry
RefListEntry * entry;
for(entry = &refList; entry->next; entry = entry->next, resultIdx++) ;
RefListEntry * newEntry = (RefListEntry *)FormHeap_Allocate(sizeof(RefListEntry));
newEntry->var = var;
newEntry->next = NULL;
entry->next = newEntry;
}
info.numRefs = resultIdx + 1;
return resultIdx;
}
ExtraTeleport* ExtraTeleport::Create()
{
ExtraTeleport* tele = (ExtraTeleport*)BSExtraData::Create(kExtraData_Teleport, sizeof(ExtraTeleport), s_ExtraTeleportVtbl);
// create data
ExtraTeleport::Data* data = (ExtraTeleport::Data*)FormHeap_Allocate(sizeof(ExtraTeleport::Data));
data->linkedDoor = NULL;
data->yRot = -0.0;
data->xRot = 0.0;
data->x = 0.0;
data->y = 0.0;
data->z = 0.0;
data->zRot = 0.0;
tele->data = data;
return tele;
}
TextInputJournal::TextInputJournal(char* fmtString, UInt32 maxLen, bool bAsScroll)
: TextInputMenu(maxLen, true)
{
m_inputText = kTagStrings[kHTMLTag_FONT] + kTagStrings[kHTMLTag_DIV_Left];
m_minPos = m_inputText.length(); // don't allow starting tags to be edited by user directly
m_inputText += fmtString;
// If fmtString already contains starting tags, use them instead of defaults
std::string defaultText(fmtString);
if (defaultText.length() >= m_minPos)
if (!_stricmp("<FONT face=\"", defaultText.substr(0, 12).c_str()))
if (!_stricmp("<DIV align=\"", defaultText.substr(15, 12).c_str()))
m_inputText = defaultText;
DEBUG_PRINT("Text = %s, minPos = %d", m_inputText.c_str(), m_minPos);
//Create a proxy book object (required by some of the BookMenu code)
m_dummyBook = (TESObjectBOOK*)FormHeap_Allocate(sizeof(TESObjectBOOK));
m_dummyBook->Constructor();
m_dummyBook->SetCantBeTaken(true);
m_dummyBook->SetIsScroll(bAsScroll);
}
BSShaderTextureSet * BSShaderTextureSet::Create()
{
BSShaderTextureSet * textureSet = (BSShaderTextureSet*)FormHeap_Allocate(sizeof(BSShaderTextureSet));
textureSet->ctor();
return textureSet;
}
ContainerIterLoop::ContainerIterLoop(const ForEachContext* context)
{
TESObjectREFR* contRef = OBLIVION_CAST((TESForm*)context->sourceID, TESForm, TESObjectREFR);
m_refVar = context->var;
m_iterIndex = 0;
m_invRef = InventoryReference::Create(contRef, IRefData(NULL, NULL, NULL), false);
// first: figure out what items exist by default
std::map<TESForm*, SInt32> baseObjectCounts;
TESContainer* cont = OBLIVION_CAST(contRef->baseForm, TESForm, TESContainer);
if (cont) {
for (TESContainer::Entry* cur = &cont->list; cur; cur = cur->next) {
if (cur->data && cur->data->type->typeID != kFormType_LeveledItem) {
DEBUG_PRINT("Base container has %d %s", cur->data->count, GetFullName(cur->data->type));
baseObjectCounts[cur->data->type] = cur->data->count;
}
}
// now populate the vec
ExtraContainerChanges* xChanges = (ExtraContainerChanges*)contRef->baseExtraList.GetByType(kExtraData_ContainerChanges);
if (xChanges && xChanges->data) {
for (ExtraContainerChanges::Entry* entry = xChanges->data->objList; entry; entry = entry->next) {
if (entry->data) {
TESForm* baseObj = entry->data->type;
SInt32 countDelta = entry->data->countDelta;
SInt32 actualCount = countDelta;
bool isInBaseContainer = baseObjectCounts.find(baseObj) != baseObjectCounts.end();
if (isInBaseContainer) {
baseObjectCounts[baseObj] += countDelta;
actualCount = baseObjectCounts[baseObj];
}
if (entry->data->extendData) {
UInt32 total = 0;
ExtraContainerChanges::EntryExtendData* prev = NULL;
for (ExtraContainerChanges::EntryExtendData* extend = entry->data->extendData; extend; extend = extend->next) {
if (total >= actualCount) {
break;
}
total += GetCountForExtraDataList(extend->data);
m_elements.push_back(IRefData(baseObj, entry, extend));
prev = extend;
}
SInt32 remainder = isInBaseContainer ? baseObjectCounts[baseObj] : countDelta;
remainder -= total;
if (remainder > 0) {
InventoryReference::Data::CreateForUnextendedEntry(entry, remainder, m_elements);
}
}
else {
SInt32 actualCount = countDelta;
if (isInBaseContainer) {
actualCount += baseObjectCounts[baseObj];
}
if (actualCount > 0) {
InventoryReference::Data::CreateForUnextendedEntry(entry, actualCount, m_elements);
}
}
if (isInBaseContainer) {
baseObjectCounts.erase(baseObj);
}
}
else {
// wtf??
DEBUG_PRINT("Warning: encountered NULL ExtraContainerChanges::Entry::Data pointer in ContainerIterLoop constructor.");
}
}
}
else if (baseObjectCounts.size()) {
if (!xChanges) {
xChanges = ExtraContainerChanges::Create();
}
xChanges->data = ExtraContainerChanges::Data::Create(contRef);
xChanges->data->objList = (ExtraContainerChanges::Entry*)FormHeap_Allocate(sizeof(ExtraContainerChanges::Entry));
std::map<TESForm*, SInt32>::iterator first = baseObjectCounts.begin();
xChanges->data->objList->data = ExtraContainerChanges::EntryData::Create(first->second, first->first);
xChanges->data->objList->next = NULL;
baseObjectCounts.erase(first);
}
// now add entries for objects in base but without associated ExtraContainerChanges
// these extra entries will be removed when we're done with the loop
if (baseObjectCounts.size()) {
for (std::map<TESForm*, SInt32>::iterator iter = baseObjectCounts.begin(); iter != baseObjectCounts.end(); ++iter) {
if (iter->second > 0) {
ExtraContainerChanges::Entry* entry = FORM_HEAP_ALLOCATE(ExtraContainerChanges::Entry);
entry->next = xChanges->data->objList;
xChanges->data->objList = entry;
ExtraContainerChanges::EntryData* ed = ExtraContainerChanges::EntryData::Create(0, iter->first);
ed->extendData = FORM_HEAP_ALLOCATE(ExtraContainerChanges::EntryExtendData);
ed->extendData->next = NULL;
ed->extendData->data = ExtraDataList::Create();
if (iter->second > 1) {
ExtraCount* xCount = ExtraCount::Create();
xCount->count = iter->second;
ed->extendData->data->Add(xCount);
}
entry->data = ed;
m_elements.push_back(IRefData(iter->first, entry, ed->extendData));
}
}
}
}
// initialize the iterator
SetIterator();
}
BSString* BSString::CreateInstance(const char* String)
{
BSString* NewInstance = (BSString*)FormHeap_Allocate(sizeof(BSString));
thisCall<UInt32>(0x00497900, NewInstance, String);
return NewInstance;
}
TESFile* TESFile::CreateInstance(const char* WorkingDirectory, const char* FileName, UInt8 OpenMode)
{
TESFile* NewInstance = (TESFile*)FormHeap_Allocate(sizeof(TESFile));
thisCall<UInt32>(0x00489590, NewInstance, WorkingDirectory, FileName, OpenMode);
return NewInstance;
}
void NiSkinData::BoneData::AllocateWeights(UInt32 numWeights)
{
m_pkBoneVertData = (BoneVertData *)FormHeap_Allocate(sizeof(BoneVertData) * numWeights);
memset(m_pkBoneVertData, 0, sizeof(BoneVertData) * numWeights);
}
void NiGeometryData::AllocateColors(UInt32 numVerts)
{
m_pkColor = (NiColorA *)FormHeap_Allocate(sizeof(NiColorA) * numVerts);
memset(m_pkColor, 0, sizeof(NiColorA) * numVerts);
}
void NiGeometryData::AllocateNBT(UInt32 numVerts)
{
m_pkNormal = (NiPoint3 *)FormHeap_Allocate(sizeof(NiPoint3) * 3 * numVerts);
memset(m_pkNormal, 0, sizeof(NiPoint3) * 3 * numVerts);
}
void* NiMalloc(std::size_t size)
{
return FormHeap_Allocate(size);
}
