id
int64 0
755k
| file_name
stringlengths 3
109
| file_path
stringlengths 13
185
| content
stringlengths 31
9.38M
| size
int64 31
9.38M
| language
stringclasses 1
value | extension
stringclasses 11
values | total_lines
int64 1
340k
| avg_line_length
float64 2.18
149k
| max_line_length
int64 7
2.22M
| alphanum_fraction
float64 0
1
| repo_name
stringlengths 6
65
| repo_stars
int64 100
47.3k
| repo_forks
int64 0
12k
| repo_open_issues
int64 0
3.4k
| repo_license
stringclasses 9
values | repo_extraction_date
stringclasses 92
values | exact_duplicates_redpajama
bool 2
classes | near_duplicates_redpajama
bool 2
classes | exact_duplicates_githubcode
bool 2
classes | exact_duplicates_stackv2
bool 1
class | exact_duplicates_stackv1
bool 2
classes | near_duplicates_githubcode
bool 2
classes | near_duplicates_stackv1
bool 2
classes | near_duplicates_stackv2
bool 1
class |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
34,812
|
loadingr.cpp
|
OpenMW_openmw/components/esm4/loadingr.cpp
|
/*
Copyright (C) 2016, 2018, 2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadingr.hpp"
#include <cstring>
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Ingredient::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
{
if (mFullName.empty())
{
reader.getLocalizedString(mFullName);
break;
}
else // in TES4 subsequent FULL records are script effect names
{
// FIXME: should be part of a struct?
std::string scriptEffectName;
if (!reader.getZString(scriptEffectName))
throw std::runtime_error("INGR FULL data read error");
mScriptEffect.push_back(scriptEffectName);
break;
}
}
case ESM::fourCC("DATA"):
{
// if (reader.esmVersion() == ESM::VER_094 || reader.esmVersion() == ESM::VER_170)
if (subHdr.dataSize == 8) // FO3 is size 4 even though VER_094
reader.get(mData);
else
reader.get(mData.weight);
break;
}
case ESM::fourCC("ICON"):
reader.getZString(mIcon);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("ENIT"):
reader.get(mEnchantment);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("SCIT"):
{
reader.get(mEffect);
reader.adjustFormId(mEffect.formId);
break;
}
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("EFID"):
case ESM::fourCC("EFIT"):
case ESM::fourCC("OBND"):
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("YNAM"):
case ESM::fourCC("ZNAM"):
case ESM::fourCC("ETYP"): // FO3
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
{
reader.skipSubRecordData();
break;
}
default:
throw std::runtime_error("ESM4::INGR::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Ingredient::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Ingredient::blank()
//{
// }
| 4,675
|
C++
|
.cpp
| 121
| 27.330579
| 114
| 0.553426
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,813
|
loaddial.cpp
|
OpenMW_openmw/components/esm4/loaddial.cpp
|
/*
Copyright (C) 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loaddial.hpp"
#include <cstring>
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Dialogue::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mTopicName);
break;
case ESM::fourCC("QSTI"):
reader.getFormId(mQuests.emplace_back());
break;
case ESM::fourCC("QSTR"): // Seems never used in TES4
reader.getFormId(mQuestsRemoved.emplace_back());
break;
case ESM::fourCC("DATA"):
{
if (subHdr.dataSize == 4) // TES5
{
std::uint8_t dummy;
reader.get(dummy);
if (dummy != 0)
mDoAllBeforeRepeat = true;
}
reader.get(mDialType); // TES4/FO3/FONV/TES5
if (subHdr.dataSize >= 2) // FO3/FONV/TES5
reader.get(mDialFlags);
if (subHdr.dataSize >= 3) // TES5
reader.skipSubRecordData(1); // unknown
break;
}
case ESM::fourCC("PNAM"):
reader.get(mPriority);
break; // FO3/FONV
case ESM::fourCC("TDUM"):
reader.getZString(mTextDumb);
break; // FONV
case ESM::fourCC("SCRI"):
case ESM::fourCC("INFC"): // FONV info connection
case ESM::fourCC("INFX"): // FONV info index
case ESM::fourCC("QNAM"): // TES5
case ESM::fourCC("BNAM"): // TES5
case ESM::fourCC("SNAM"): // TES5
case ESM::fourCC("TIFC"): // TES5
case ESM::fourCC("KNAM"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::DIAL::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Dialogue::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Dialogue::blank()
//{
// }
| 3,589
|
C++
|
.cpp
| 89
| 30.247191
| 114
| 0.589552
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,814
|
loadanio.cpp
|
OpenMW_openmw/components/esm4/loadanio.cpp
|
/*
Copyright (C) 2016, 2018 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadanio.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::AnimObject::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("BNAM"):
reader.getZString(mUnloadEvent);
break;
case ESM::fourCC("DATA"):
reader.getFormId(mIdleAnim);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::ANIO::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::AnimObject::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::AnimObject::blank()
//{
// }
| 2,563
|
C++
|
.cpp
| 65
| 31.661538
| 114
| 0.646822
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,815
|
loadlgtm.cpp
|
OpenMW_openmw/components/esm4/loadlgtm.cpp
|
/*
Copyright (C) 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
Also see https://tes5edit.github.io/fopdoc/ for FO3/FONV specific details.
*/
#include "loadlgtm.hpp"
#include <cfloat> // FLT_MAX for gcc
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::LightingTemplate::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("DATA"):
if (subHdr.dataSize == 36) // TES4
reader.get(&mLighting, 36);
if (subHdr.dataSize == 40) // FO3/FONV
reader.get(mLighting);
else if (subHdr.dataSize == 92) // TES5
{
reader.get(mLighting);
reader.skipSubRecordData(52); // FIXME
}
else
reader.skipSubRecordData(); // throw?
break;
case ESM::fourCC("DALC"): // TES5
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::LGTM::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::LightingTemplate::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::LightingTemplate::blank()
//{
// }
| 2,665
|
C++
|
.cpp
| 65
| 33
| 114
| 0.646308
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,816
|
loadarmo.cpp
|
OpenMW_openmw/components/esm4/loadarmo.cpp
|
/*
Copyright (C) 2016, 2018-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadarmo.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Armor::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
uint16_t currentIndex = 0xFFFF;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DATA"):
{
switch (subHdr.dataSize)
{
case 14: // TES4
reader.get(mData);
break;
case 12: // FO3, FNV, FO4
reader.get(mData.value);
reader.get(mData.health);
reader.get(mData.weight);
break;
case 8: // TES5
reader.get(mData.value);
reader.get(mData.weight);
break;
default:
reader.skipSubRecordData();
break;
}
break;
}
case ESM::fourCC("INDX"): // FO4
{
reader.get(currentIndex);
break;
}
case ESM::fourCC("MODL"):
{
if (subHdr.dataSize == 4)
{
// Assuming TES5
if (currentIndex == 0xFFFF)
reader.getFormId(mAddOns.emplace_back());
// FO4
else
{
if (mAddOns.size() <= currentIndex)
mAddOns.resize(currentIndex + 1);
reader.getFormId(mAddOns[currentIndex]);
}
}
else
{
if (!reader.getZString(mModelMale))
throw std::runtime_error("ARMO MODL data read error");
}
break;
}
case ESM::fourCC("MOD2"):
reader.getZString(mModelMaleWorld);
break;
case ESM::fourCC("MOD3"):
reader.getZString(mModelFemale);
break;
case ESM::fourCC("MOD4"):
reader.getZString(mModelFemaleWorld);
break;
case ESM::fourCC("ICON"):
reader.getZString(mIconMale);
break;
case ESM::fourCC("MICO"):
reader.getZString(mMiniIconMale);
break;
case ESM::fourCC("ICO2"):
reader.getZString(mIconFemale);
break;
case ESM::fourCC("MIC2"):
reader.getZString(mMiniIconFemale);
break;
case ESM::fourCC("BMDT"):
if (subHdr.dataSize == 8) // FO3
{
reader.get(mArmorFlags);
reader.get(mGeneralFlags);
mGeneralFlags &= 0x000000ff;
mGeneralFlags |= TYPE_FO3;
}
else // TES4
{
reader.get(mArmorFlags);
mGeneralFlags = (mArmorFlags & 0x00ff0000) >> 16;
mGeneralFlags |= TYPE_TES4;
}
break;
case ESM::fourCC("BODT"):
{
reader.get(mArmorFlags);
uint32_t flags = 0;
if (subHdr.dataSize == 12)
reader.get(flags);
reader.get(mGeneralFlags); // skill
mGeneralFlags &= 0x0000000f; // 0 (light), 1 (heavy) or 2 (none)
if (subHdr.dataSize == 12)
mGeneralFlags |= (flags & 0x0000000f) << 3;
mGeneralFlags |= TYPE_TES5;
break;
}
case ESM::fourCC("BOD2"):
// FO4, TES5
if (subHdr.dataSize == 4 || subHdr.dataSize == 8)
{
reader.get(mArmorFlags);
if (subHdr.dataSize == 8)
{
reader.get(mGeneralFlags);
mGeneralFlags &= 0x0000000f; // 0 (light), 1 (heavy) or 2 (none)
mGeneralFlags |= TYPE_TES5;
}
}
else
{
reader.skipSubRecordData();
}
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("ANAM"):
reader.get(mEnchantmentPoints);
break;
case ESM::fourCC("ENAM"):
reader.getFormId(mEnchantment);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("DESC"):
reader.getLocalizedString(mText);
break;
case ESM::fourCC("YNAM"):
reader.getFormId(mPickUpSound);
break;
case ESM::fourCC("ZNAM"):
reader.getFormId(mDropSound);
break;
case ESM::fourCC("MODT"):
case ESM::fourCC("MO2B"):
case ESM::fourCC("MO3B"):
case ESM::fourCC("MO4B"):
case ESM::fourCC("MO2T"):
case ESM::fourCC("MO2S"):
case ESM::fourCC("MO3T"):
case ESM::fourCC("MO4T"):
case ESM::fourCC("MO4S"):
case ESM::fourCC("OBND"):
case ESM::fourCC("RNAM"): // race formid
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("TNAM"):
case ESM::fourCC("DNAM"):
case ESM::fourCC("BAMT"):
case ESM::fourCC("BIDS"):
case ESM::fourCC("ETYP"):
case ESM::fourCC("BMCT"):
case ESM::fourCC("EAMT"):
case ESM::fourCC("EITM"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("REPL"): // FO3
case ESM::fourCC("BIPL"): // FO3
case ESM::fourCC("MODD"): // FO3
case ESM::fourCC("MOSD"): // FO3
case ESM::fourCC("MODS"): // FO3
case ESM::fourCC("MO3S"): // FO3
case ESM::fourCC("BNAM"): // FONV
case ESM::fourCC("SNAM"): // FONV
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
case ESM::fourCC("APPR"): // FO4
case ESM::fourCC("DAMA"): // FO4
case ESM::fourCC("FNAM"): // FO4
case ESM::fourCC("INRD"): // FO4
case ESM::fourCC("PTRN"): // FO4
case ESM::fourCC("OBTE"): // FO4 object template start
case ESM::fourCC("OBTF"):
case ESM::fourCC("OBTS"):
case ESM::fourCC("STOP"): // FO4 object template end
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::ARMO::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
// if ((mArmorFlags&0xffff) == 0x02) // only hair
// std::cout << "only hair " << mEditorId << std::endl;
}
// void ESM4::Armor::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Armor::blank()
//{
// }
| 9,197
|
C++
|
.cpp
| 239
| 24.225941
| 114
| 0.479991
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,817
|
loadltex.cpp
|
OpenMW_openmw/components/esm4/loadltex.cpp
|
/*
Copyright (C) 2015-2016, 2018 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadltex.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::LandTexture::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("HNAM"):
{
switch (subHdr.dataSize)
{
case 3: // TES4, FO3, FNV
reader.get(mHavokMaterial);
[[fallthrough]];
case 2:
reader.get(mHavokFriction);
reader.get(mHavokRestitution);
break;
default:
reader.skipSubRecordData();
break;
}
break;
}
case ESM::fourCC("ICON"):
reader.getZString(mTextureFile);
break; // Oblivion only?
case ESM::fourCC("SNAM"):
reader.get(mTextureSpecular);
break;
case ESM::fourCC("GNAM"):
reader.getFormId(mGrass.emplace_back());
break;
case ESM::fourCC("TNAM"):
reader.getFormId(mTexture);
break; // TES5, FO4
case ESM::fourCC("MNAM"):
reader.getFormId(mMaterial);
break; // TES5, FO4
case ESM::fourCC("INAM"):
reader.get(mMaterialFlags);
break; // SSE
default:
throw std::runtime_error("ESM4::LTEX::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::LandTexture::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::LandTexture::blank()
//{
// }
| 3,182
|
C++
|
.cpp
| 82
| 28.341463
| 114
| 0.588083
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,818
|
loadappa.cpp
|
OpenMW_openmw/components/esm4/loadappa.cpp
|
/*
Copyright (C) 2016, 2018-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadappa.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Apparatus::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DATA"):
if (reader.esmVersion() == ESM::VER_094 || reader.esmVersion() == ESM::VER_170)
{
reader.get(mData.value);
reader.get(mData.weight);
}
else
{
reader.get(mData.type);
reader.get(mData.value);
reader.get(mData.weight);
reader.get(mData.quality);
}
break;
case ESM::fourCC("ICON"):
reader.getZString(mIcon);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("DESC"):
reader.getLocalizedString(mText);
break;
case ESM::fourCC("MODT"):
case ESM::fourCC("OBND"):
case ESM::fourCC("QUAL"):
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::APPA::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Apparatus::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Apparatus::blank()
//{
// }
| 3,237
|
C++
|
.cpp
| 84
| 28.488095
| 114
| 0.59376
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,819
|
loadacti.cpp
|
OpenMW_openmw/components/esm4/loadacti.cpp
|
/*
Copyright (C) 2016, 2018, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadacti.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Activator::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("SNAM"):
reader.getFormId(mLoopingSound);
break;
case ESM::fourCC("VNAM"):
reader.getFormId(mActivationSound);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("INAM"):
reader.getFormId(mRadioTemplate);
break; // FONV
case ESM::fourCC("RNAM"):
reader.getFormId(mRadioStation);
break;
case ESM::fourCC("XATO"):
reader.getZString(mActivationPrompt);
break; // FONV
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
case ESM::fourCC("FNAM"):
case ESM::fourCC("KNAM"):
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("OBND"):
case ESM::fourCC("PNAM"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("WNAM"):
case ESM::fourCC("CTDA"):
case ESM::fourCC("CIS1"):
case ESM::fourCC("CIS2"):
case ESM::fourCC("CITC"):
case ESM::fourCC("NVNM"):
case ESM::fourCC("ATTX"): // FO4
case ESM::fourCC("FTYP"): // FO4
case ESM::fourCC("NTRM"): // FO4
case ESM::fourCC("PTRN"): // FO4
case ESM::fourCC("PRPS"): // FO4
case ESM::fourCC("RADR"): // FO4
case ESM::fourCC("STCP"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::ACTI::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Activator::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Activator::blank()
//{
// }
| 4,338
|
C++
|
.cpp
| 109
| 29.550459
| 114
| 0.57529
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,820
|
loadbptd.cpp
|
OpenMW_openmw/components/esm4/loadbptd.cpp
|
/*
Copyright (C) 2019-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadbptd.hpp"
#include <cstring>
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::BodyPartData::BodyPart::clear()
{
mPartName.clear();
mNodeName.clear();
mVATSTarget.clear();
mIKStartNode.clear();
std::memset(&mData, 0, sizeof(BPND));
mLimbReplacementModel.clear();
mGoreEffectsTarget.clear();
}
void ESM4::BodyPartData::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
BodyPart bodyPart;
bodyPart.clear();
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("BPTN"):
reader.getLocalizedString(bodyPart.mPartName);
break;
case ESM::fourCC("BPNN"):
reader.getZString(bodyPart.mNodeName);
break;
case ESM::fourCC("BPNT"):
reader.getZString(bodyPart.mVATSTarget);
break;
case ESM::fourCC("BPNI"):
reader.getZString(bodyPart.mIKStartNode);
break;
case ESM::fourCC("BPND"):
if (subHdr.dataSize == sizeof(bodyPart.mData))
reader.get(bodyPart.mData);
// FIXME: FO4
else
reader.skipSubRecordData();
break;
case ESM::fourCC("NAM1"):
reader.getZString(bodyPart.mLimbReplacementModel);
break;
case ESM::fourCC("NAM4"): // FIXME: assumed occurs last
reader.getZString(bodyPart.mGoreEffectsTarget); // target bone
mBodyParts.push_back(bodyPart); // FIXME: possible without copying?
bodyPart.clear();
break;
case ESM::fourCC("NAM5"):
case ESM::fourCC("RAGA"): // ragdoll
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("BNAM"): // FO4
case ESM::fourCC("CNAM"): // FO4
case ESM::fourCC("DNAM"): // FO4
case ESM::fourCC("ENAM"): // FO4
case ESM::fourCC("FNAM"): // FO4
case ESM::fourCC("INAM"): // FO4
case ESM::fourCC("JNAM"): // FO4
case ESM::fourCC("NAM2"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::BPTD::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
// if (mEditorId == "DefaultBodyPartData")
// std::cout << "BPTD: " << mEditorId << std::endl; // FIXME: testing only
}
// void ESM4::BodyPartData::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::BodyPartData::blank()
//{
// }
| 4,421
|
C++
|
.cpp
| 111
| 30.441441
| 114
| 0.60326
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,821
|
loadterm.cpp
|
OpenMW_openmw/components/esm4/loadterm.cpp
|
/*
Copyright (C) 2019-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadterm.hpp"
#include <stdexcept>
#include "reader.hpp"
// #include "writer.hpp"
void ESM4::Terminal::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DESC"):
reader.getLocalizedString(mText);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("PNAM"):
reader.getFormId(mPasswordNote);
break;
case ESM::fourCC("SNAM"):
if (subHdr.dataSize == 4)
reader.getFormId(mSound);
// FIXME: FO4 sound marker params
else
reader.skipSubRecordData();
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("RNAM"):
reader.getZString(mResultText);
break;
case ESM::fourCC("DNAM"): // difficulty
case ESM::fourCC("ANAM"): // flags
case ESM::fourCC("CTDA"):
case ESM::fourCC("CIS1"):
case ESM::fourCC("CIS2"):
case ESM::fourCC("INAM"):
case ESM::fourCC("ITXT"): // Menu Item
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("SCDA"):
case ESM::fourCC("SCHR"):
case ESM::fourCC("SCRO"):
case ESM::fourCC("SCRV"):
case ESM::fourCC("SCTX"):
case ESM::fourCC("SCVR"):
case ESM::fourCC("SLSD"):
case ESM::fourCC("TNAM"):
case ESM::fourCC("OBND"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("BSIZ"): // FO4
case ESM::fourCC("BTXT"): // FO4
case ESM::fourCC("COCT"): // FO4
case ESM::fourCC("CNTO"): // FO4
case ESM::fourCC("FNAM"): // FO4
case ESM::fourCC("ISIZ"): // FO4
case ESM::fourCC("ITID"): // FO4
case ESM::fourCC("MNAM"): // FO4
case ESM::fourCC("NAM0"): // FO4
case ESM::fourCC("PRPS"): // FO4
case ESM::fourCC("PTRN"): // FO4
case ESM::fourCC("UNAM"): // FO4
case ESM::fourCC("VNAM"): // FO4
case ESM::fourCC("WBDT"): // FO4
case ESM::fourCC("WNAM"): // FO4
case ESM::fourCC("XMRK"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::TERM::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Terminal::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Terminal::blank()
//{
// }
| 4,535
|
C++
|
.cpp
| 113
| 29.716814
| 114
| 0.565079
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,822
|
loadmisc.cpp
|
OpenMW_openmw/components/esm4/loadmisc.cpp
|
/*
Copyright (C) 2016, 2018, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadmisc.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::MiscItem::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("ICON"):
reader.getZString(mIcon);
break;
case ESM::fourCC("MICO"):
reader.getZString(mMiniIcon);
break; // FO3
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("DATA"):
reader.get(mData);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("YNAM"):
reader.getFormId(mPickUpSound);
break;
case ESM::fourCC("ZNAM"):
reader.getFormId(mDropSound);
break;
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("OBND"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("RNAM"): // FONV
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
case ESM::fourCC("CDIX"): // FO4
case ESM::fourCC("CVPA"): // FO4
case ESM::fourCC("FIMD"): // FO4
case ESM::fourCC("PTRN"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::MISC::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::MiscItem::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::MiscItem::blank()
//{
// }
| 3,858
|
C++
|
.cpp
| 98
| 29.428571
| 114
| 0.584045
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,823
|
loadnavi.cpp
|
OpenMW_openmw/components/esm4/loadnavi.cpp
|
/*
Copyright (C) 2015-2016, 2018, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadnavi.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Navigation::IslandInfo::load(ESM4::Reader& reader)
{
reader.get(minX);
reader.get(minY);
reader.get(minZ);
reader.get(maxX);
reader.get(maxY);
reader.get(maxZ);
std::uint32_t count;
reader.get(count); // countTriangle;
if (count)
{
triangles.resize(count);
// std::cout << "NVMI island triangles " << std::dec << count << std::endl; // FIXME
for (std::vector<Navigation::Triangle>::iterator it = triangles.begin(); it != triangles.end(); ++it)
{
reader.get(*it);
}
}
reader.get(count); // countVertex;
if (count)
{
verticies.resize(count);
for (std::vector<ESM4::Vertex>::iterator it = verticies.begin(); it != verticies.end(); ++it)
{
reader.get(*it);
// FIXME: debugging only
#if 0
std::string padding;
padding.insert(0, reader.stackSize()*2, ' ');
std::cout << padding << "NVMI vert " << std::dec << (*it).x << ", " << (*it).y << ", " << (*it).z << std::endl;
#endif
}
}
}
void ESM4::Navigation::NavMeshInfo::load(ESM4::Reader& reader)
{
std::uint32_t count;
reader.getFormId(formId);
reader.get(flags);
reader.get(x);
reader.get(y);
reader.get(z);
// FIXME: for debugging only
#if 0
std::string padding;
if (flags == ESM4::FLG_Modified)
padding.insert(0, 2, '-');
else if (flags == ESM4::FLG_Unmodified)
padding.insert(0, 4, '.');
padding.insert(0, reader.stackSize()*2, ' ');
std::cout << padding << "NVMI formId: 0x" << std::hex << formId << std::endl;
std::cout << padding << "NVMI flags: " << std::hex << flags << std::endl;
std::cout << padding << "NVMI center: " << std::dec << x << ", " << y << ", " << z << std::endl;
#endif
reader.get(flagPrefMerges);
reader.get(count); // countMerged;
if (count)
{
// std::cout << "NVMI countMerged " << std::dec << count << std::endl;
formIdMerged.resize(count);
for (ESM::FormId& value : formIdMerged)
reader.getFormId(value);
}
reader.get(count); // countPrefMerged;
if (count)
{
// std::cout << "NVMI countPrefMerged " << std::dec << count << std::endl;
formIdPrefMerged.resize(count);
for (ESM::FormId& value : formIdPrefMerged)
reader.getFormId(value);
}
reader.get(count); // countLinkedDoors;
if (count)
{
// std::cout << "NVMI countLinkedDoors " << std::dec << count << std::endl;
linkedDoors.resize(count);
for (std::vector<DoorRef>::iterator it = linkedDoors.begin(); it != linkedDoors.end(); ++it)
{
reader.get(*it);
}
}
unsigned char island;
reader.get(island);
if (island)
{
Navigation::IslandInfo island2;
island2.load(reader);
islandInfo.push_back(island2); // Maybe don't use a vector for just one entry?
}
// else if (flags == FLG_Island) // FIXME: debug only
// std::cerr << "nvmi no island but has 0x20 flag" << std::endl;
reader.get(locationMarker);
reader.getFormId(worldSpaceId);
// FLG_Tamriel = 0x0000003c, // grid info follows, possibly Tamriel?
// FLG_Morrowind = 0x01380000, // grid info follows, probably Skywind
// FIXME: this check doesn't work because `getFormId` changes the index of content file.
if (worldSpaceId == ESM::FormId{ 0x3c, 0 } || worldSpaceId == ESM::FormId{ 0x380000, 1 })
{
Grid grid;
reader.get(grid.y); // NOTE: reverse order
reader.get(grid.x);
cellGrid = grid;
// FIXME: debugging only
#if 0
std::string padding;
padding.insert(0, reader.stackSize()*2, ' ');
if (worldSpaceId == ESM4::FLG_Morrowind)
std::cout << padding << "NVMI MW: X " << std::dec << cellGrid.grid.x << ", Y " << cellGrid.grid.y << std::endl;
else
std::cout << padding << "NVMI SR: X " << std::dec << cellGrid.grid.x << ", Y " << cellGrid.grid.y << std::endl;
#endif
}
else
{
ESM::FormId cellId;
reader.getFormId(cellId);
cellGrid = cellId;
#if 0
if (worldSpaceId == 0) // interior
std::cout << "NVMI Interior: cellId " << std::hex << cellGrid.cellId << std::endl;
else
std::cout << "NVMI FormID: cellId " << std::hex << cellGrid.cellId << std::endl;
#endif
}
}
// NVPP data seems to be organised this way (total is 0x64 = 100)
//
// (0) total | 0x1 | formid (index 0) | count | formid's
// (1) | count | formid's
// (2) | count | formid's
// (3) | count | formid's
// (4) | count | formid's
// (5) | count | formid's
// (6) | count | formid's
// (7) | count | formid's
// (8) | count | formid's
// (9) | count | formid's
// (10) | 0x1 | formid (index 1) | count | formid's
// (11) | count | formid's
// (12) | count | formid's
// (13) | count | formid's
// (14) | count | formid's
// (15) | count | formid's
// ...
//
// (88) | count | formid's
// (89) | count | formid's
//
// Here the pattern changes (final count is 0xa = 10)
//
// (90) | 0x1 | formid (index 9) | count | formid | index
// (91) | formid | index
// (92) | formid | index
// (93) | formid | index
// (94) | formid | index
// (95) | formid | index
// (96) | formid | index
// (97) | formid | index
// (98) | formid | index
// (99) | formid | index
//
// Note that the index values are not sequential, i.e. the first index value
// (i.e. row 90) for Update.esm is 2.
//
// Also note that there's no list of formid's following the final node (index 9)
//
// The same 10 formids seem to be used for the indices, but not necessarily
// with the same index value (but only Update.esm differs?)
//
// formid cellid X Y Editor ID other formids in same X,Y S U D D
// -------- ------ --- --- --------------------------- ---------------------------- - - - -
// 00079bbf 9639 5 -4 WhiterunExterior17 00079bc3 0 6 0 0
// 0010377b 8ed5 6 24 DawnstarWesternMineExterior 1 1 1 1
// 000a3f44 9577 -22 2 RoriksteadEdge 2 9 2 2
// 00100f4b 8ea2 26 25 WinterholdExterior01 00100f4a, 00100f49 3 3 3 3
// 00103120 bc8e 42 -22 (near Riften) 4 2 4 4
// 00105e9a 929d -18 24 SolitudeExterior03 5 0 5 5
// 001030cb 7178 -40 1 SalviusFarmExterior01 (east of Markarth) 6 8 6 6
// 00098776 980b 4 -19 HelgenExterior 000cce3d 7 5 7 7
// 000e88cc 93de -9 14 (near Morthal) 0010519e, 0010519d, 000e88d2 8 7 8 8
// 000b87df b51d 33 5 WindhelmAttackStart05 9 4 9 9
//
void ESM4::Navigation::load(ESM4::Reader& reader)
{
// mFormId = reader.hdr().record.getFormId();
// mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
bool isFONV = esmVer == ESM::VER_132 || esmVer == ESM::VER_133 || esmVer == ESM::VER_134;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"): // seems to be unused?
{
if (!reader.getZString(mEditorId))
throw std::runtime_error("NAVI EDID data read error");
break;
}
case ESM::fourCC("NVPP"):
{
// FIXME: FO4 updates the format
if (reader.hasFormVersion() && (esmVer == ESM::VER_095 || esmVer == ESM::VER_100))
{
reader.skipSubRecordData();
break;
}
std::uint32_t total;
std::uint32_t count;
reader.get(total);
if (!total)
{
reader.get(count); // throw away
break;
}
if (total >= 10)
total -= 10; // HACK
else
throw std::runtime_error("expected total amount of chunks >= 0xa");
std::uint32_t node = 0;
bool nodeFound = false;
for (std::uint32_t i = 0; i < total; ++i)
{
std::vector<ESM::FormId> preferredPaths;
reader.get(count);
if (count == 1)
{
reader.get(node);
reader.get(count);
nodeFound = true;
}
if (count > 0)
{
preferredPaths.resize(count);
for (ESM::FormId& value : preferredPaths)
reader.getFormId(value);
}
if (!nodeFound)
throw std::runtime_error("node not found");
mPreferredPaths.push_back(std::make_pair(node, preferredPaths));
#if 0
std::cout << "node " << std::hex << node // FIXME: debugging only
<< ", count " << count << ", i " << std::dec << i << std::endl;
#endif
}
reader.get(count);
if (count != 1)
throw std::runtime_error("expected separator");
reader.get(node); // HACK
std::vector<ESM::FormId> preferredPaths;
mPreferredPaths.push_back(std::make_pair(node, preferredPaths)); // empty
#if 0
std::cout << "node " << std::hex << node // FIXME: debugging only
<< ", count " << 0 << std::endl;
#endif
reader.get(count); // HACK
if (count != 10)
throw std::runtime_error("expected 0xa");
std::uint32_t index;
for (std::uint32_t i = 0; i < count; ++i)
{
reader.get(node);
reader.get(index);
#if 0
std::cout << "node " << std::hex << node // FIXME: debugging only
<< ", index " << index << ", i " << std::dec << total+i << std::endl;
#endif
ESM::FormId nodeFormId = ESM::FormId::fromUint32(node); // should we apply reader.adjustFormId?
// std::pair<std::map<FormId, std::uint32_t>::iterator, bool> res =
mPathIndexMap.emplace(nodeFormId, index);
// FIXME: this throws if more than one file is being loaded
// if (!res.second)
// throw std::runtime_error ("node already exists in the preferred path index map");
}
break;
}
case ESM::fourCC("NVER"):
{
std::uint32_t version; // always the same? (0x0c)
reader.get(version); // TODO: store this or use it for merging?
// std::cout << "NAVI version " << std::dec << version << std::endl;
break;
}
case ESM::fourCC("NVMI"): // multiple
{
// Can only read TES4 navmesh data
// Note FO4 FIXME above
if (esmVer == ESM::VER_094 || esmVer == ESM::VER_170 || isFONV || esmVer == ESM::VER_100)
{
reader.skipSubRecordData();
break;
}
// std::cout << "\nNVMI start" << std::endl;
NavMeshInfo nvmi;
nvmi.load(reader);
mNavMeshInfo.push_back(nvmi);
break;
}
case ESM::fourCC("NVSI"): // from Dawnguard onwards
case ESM::fourCC("NVCI"): // FO3
{
reader.skipSubRecordData(); // FIXME:
break;
}
default:
{
throw std::runtime_error("ESM4::NAVI::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
}
// void ESM4::Navigation::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Navigation::blank()
//{
// }
| 14,444
|
C++
|
.cpp
| 342
| 33.403509
| 123
| 0.497512
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,824
|
loadnavm.cpp
|
OpenMW_openmw/components/esm4/loadnavm.cpp
|
/*
Copyright (C) 2015-2016, 2018, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadnavm.hpp"
#include <cstring>
#include <stdexcept>
#include <components/debug/debuglog.hpp>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::NavMesh::NVNMstruct::load(ESM4::Reader& reader)
{
// std::cout << "start: divisor " << std::dec << divisor << ", segments " << triSegments.size() << //std::endl;
//"this 0x" << this << std::endl; // FIXME
std::uint32_t count;
reader.get(unknownNVER);
reader.get(unknownLCTN);
reader.getFormId(worldSpaceId);
// FLG_Tamriel = 0x0000003c, // grid info follows, possibly Tamriel?
// FLG_Morrowind = 0x01380000, // grid info follows, probably Skywind
// FIXME: this check doesn't work because `getFormId` adjusts content file index
if (worldSpaceId == ESM::FormId{ 0x3c, 0 } || worldSpaceId == ESM::FormId{ 380000, 1 })
{
// ^
// Y | X Y Index
// | 0,0 0
// 1 |23 0,1 1
// 0 |01 1,0 2
// +--- 1,1 3
// 01 ->
// X
//
// e.g. Dagonfel X:13,14,15,16 Y:43,44,45,46 (Morrowind X:7 Y:22)
//
// Skywind: -4,-3 -2,-1 0,1 2,3 4,5 6,7
// Morrowind: -2 -1 0 1 2 3
//
// Formula seems to be floor(Skywind coord / 2) <cmath>
//
Grid grid;
reader.get(grid.y); // NOTE: reverse order
reader.get(grid.x);
cellGrid = grid;
// FIXME: debugging only
#if 0
std::string padding;
padding.insert(0, reader.stackSize()*2, ' ');
if (worldSpaceId == ESM4::FLG_Morrowind)
std::cout << padding << "NVNM MW: X " << std::dec << cellGrid.grid.x << ", Y " << cellGrid.grid.y << std::endl;
else
std::cout << padding << "NVNM SR: X " << std::dec << cellGrid.grid.x << ", Y " << cellGrid.grid.y << std::endl;
#endif
}
else
{
ESM::FormId cellId;
reader.getFormId(cellId);
cellGrid = cellId;
#if 0
std::string padding; // FIXME
padding.insert(0, reader.stackSize()*2, ' ');
if (worldSpaceId == 0) // interior
std::cout << padding << "NVNM Interior: cellId " << std::hex << cellGrid.cellId << std::endl;
else
std::cout << padding << "NVNM FormID: cellId " << std::hex << cellGrid.cellId << std::endl;
#endif
}
reader.get(count); // numVerticies
if (count)
{
verticies.resize(count);
for (std::vector<Vertex>::iterator it = verticies.begin(); it != verticies.end(); ++it)
{
reader.get(*it);
// FIXME: debugging only
#if 0
//if (reader.hdr().record.id == 0x2004ecc) // FIXME
std::cout << "nvnm vert " << (*it).x << ", " << (*it).y << ", " << (*it).z << std::endl;
#endif
}
}
reader.get(count); // numTriangles;
if (count)
{
triangles.resize(count);
for (std::vector<Triangle>::iterator it = triangles.begin(); it != triangles.end(); ++it)
{
reader.get(*it);
}
}
reader.get(count); // numExtConn;
if (count)
{
extConns.resize(count);
for (std::vector<ExtConnection>::iterator it = extConns.begin(); it != extConns.end(); ++it)
{
reader.get(*it);
// FIXME: debugging only
#if 0
std::cout << "nvnm ext 0x" << std::hex << (*it).navMesh << std::endl;
#endif
}
}
reader.get(count); // numDoorTriangles;
if (count)
{
doorTriangles.resize(count);
for (std::vector<DoorTriangle>::iterator it = doorTriangles.begin(); it != doorTriangles.end(); ++it)
{
reader.get(*it);
}
}
reader.get(count); // numCoverTriangles;
if (count)
{
coverTriangles.resize(count);
for (std::vector<std::uint16_t>::iterator it = coverTriangles.begin(); it != coverTriangles.end(); ++it)
{
reader.get(*it);
}
}
// abs((maxX - minX) / divisor) = Max X Distance
reader.get(divisor); // FIXME: latest over-writes old
reader.get(maxXDist); // FIXME: update with formula
reader.get(maxYDist);
reader.get(minX); // FIXME: use std::min
reader.get(minY);
reader.get(minZ);
reader.get(maxX);
reader.get(maxY);
reader.get(maxZ);
// FIXME: should check remaining size here
// there are divisor^2 segments, each segment is a vector of triangle indices
for (unsigned int i = 0; i < divisor * divisor; ++i)
{
reader.get(count); // NOTE: count may be zero
std::vector<std::uint16_t> indices;
indices.resize(count);
for (std::vector<std::uint16_t>::iterator it = indices.begin(); it != indices.end(); ++it)
{
reader.get(*it);
}
triSegments.push_back(indices);
}
if (triSegments.size() != divisor * divisor)
throw std::runtime_error("Triangle segments size is not the square of divisor");
#if 0
if (triSegments.size() != divisor*divisor)
std::cout << "divisor " << std::dec << divisor << ", segments " << triSegments.size() << //std::endl;
"this 0x" << this << std::endl;
#endif
}
void ESM4::NavMesh::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
// std::cout << "NavMesh 0x" << std::hex << this << std::endl; // FIXME
// FIXME: debugging only
#if 0
std::string padding;
padding.insert(0, reader.stackSize()*2, ' ');
std::cout << padding << "NAVM flags 0x" << std::hex << reader.hdr().record.flags << std::endl;
std::cout << padding << "NAVM id 0x" << std::hex << reader.hdr().record.id << std::endl;
#endif
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("NVNM"):
{
// See FIXME in ESM4::Navigation::load.
// FO4 updates the format
if (reader.hasFormVersion() && (esmVer == ESM::VER_095 || esmVer == ESM::VER_100))
{
reader.skipSubRecordData();
break;
}
NVNMstruct nvnm;
nvnm.load(reader);
mData.push_back(nvnm); // FIXME try swap
break;
}
case ESM::fourCC("ONAM"):
case ESM::fourCC("PNAM"):
case ESM::fourCC("NNAM"):
case ESM::fourCC("NVER"): // FO3
case ESM::fourCC("DATA"): // FO3
case ESM::fourCC("NVVX"): // FO3
case ESM::fourCC("NVTR"): // FO3
case ESM::fourCC("NVCA"): // FO3
case ESM::fourCC("NVDP"): // FO3
case ESM::fourCC("NVGD"): // FO3
case ESM::fourCC("NVEX"): // FO3
case ESM::fourCC("EDID"): // FO3
case ESM::fourCC("MNAM"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::NAVM::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
// std::cout << "num nvnm " << std::dec << mData.size() << std::endl; // FIXME
}
// void ESM4::NavMesh::save(ESM4::Writer& writer) const
//{
// }
void ESM4::NavMesh::blank() {}
| 8,589
|
C++
|
.cpp
| 225
| 30.755556
| 123
| 0.569698
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,825
|
loadmset.cpp
|
OpenMW_openmw/components/esm4/loadmset.cpp
|
/*
Copyright (C) 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadmset.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::MediaSet::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getZString(mFullName);
break;
case ESM::fourCC("NAM1"):
reader.get(mSetType);
break;
case ESM::fourCC("PNAM"):
reader.get(mEnabled);
break;
case ESM::fourCC("NAM2"):
reader.getZString(mSet2);
break;
case ESM::fourCC("NAM3"):
reader.getZString(mSet3);
break;
case ESM::fourCC("NAM4"):
reader.getZString(mSet4);
break;
case ESM::fourCC("NAM5"):
reader.getZString(mSet5);
break;
case ESM::fourCC("NAM6"):
reader.getZString(mSet6);
break;
case ESM::fourCC("NAM7"):
reader.getZString(mSet7);
break;
case ESM::fourCC("HNAM"):
reader.getFormId(mSoundIntro);
break;
case ESM::fourCC("INAM"):
reader.getFormId(mSoundOutro);
break;
case ESM::fourCC("NAM8"):
reader.get(mLevel8);
break;
case ESM::fourCC("NAM9"):
reader.get(mLevel9);
break;
case ESM::fourCC("NAM0"):
reader.get(mLevel0);
break;
case ESM::fourCC("ANAM"):
reader.get(mLevelA);
break;
case ESM::fourCC("BNAM"):
reader.get(mLevelB);
break;
case ESM::fourCC("CNAM"):
reader.get(mLevelC);
break;
case ESM::fourCC("JNAM"):
reader.get(mBoundaryDayOuter);
break;
case ESM::fourCC("KNAM"):
reader.get(mBoundaryDayMiddle);
break;
case ESM::fourCC("LNAM"):
reader.get(mBoundaryDayInner);
break;
case ESM::fourCC("MNAM"):
reader.get(mBoundaryNightOuter);
break;
case ESM::fourCC("NNAM"):
reader.get(mBoundaryNightMiddle);
break;
case ESM::fourCC("ONAM"):
reader.get(mBoundaryNightInner);
break;
case ESM::fourCC("DNAM"):
reader.get(mTime1);
break;
case ESM::fourCC("ENAM"):
reader.get(mTime2);
break;
case ESM::fourCC("FNAM"):
reader.get(mTime3);
break;
case ESM::fourCC("GNAM"):
reader.get(mTime4);
break;
case ESM::fourCC("DATA"):
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::MSET::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::MediaSet::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::MediaSet::blank()
//{
// }
| 4,753
|
C++
|
.cpp
| 131
| 24.473282
| 114
| 0.540998
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,826
|
loadtxst.cpp
|
OpenMW_openmw/components/esm4/loadtxst.cpp
|
/*
Copyright (C) 2019, 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadtxst.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::TextureSet::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FLTR"): // FO76
reader.getZString(mFilter);
break;
case ESM::fourCC("TX00"):
reader.getZString(mDiffuse);
break;
case ESM::fourCC("TX01"):
reader.getZString(mNormalMap);
break;
case ESM::fourCC("TX02"):
// This is a "wrinkle map" in FO4/76
reader.getZString(mEnvMask);
break;
case ESM::fourCC("TX03"):
// This is a glow map in FO4/76
reader.getZString(mToneMap);
break;
case ESM::fourCC("TX04"):
// This is a height map in FO4/76
reader.getZString(mDetailMap);
break;
case ESM::fourCC("TX05"):
reader.getZString(mEnvMap);
break;
case ESM::fourCC("TX06"):
reader.getZString(mMultiLayer);
break;
case ESM::fourCC("TX07"):
// This is a "smooth specular" map in FO4/76
reader.getZString(mSpecular);
break;
case ESM::fourCC("TX08"): // FO76
reader.getZString(mSpecular);
break;
case ESM::fourCC("TX09"): // FO76
reader.getZString(mLighting);
break;
case ESM::fourCC("TX10"): // FO76
reader.getZString(mFlow);
break;
case ESM::fourCC("DNAM"):
reader.get(mDataFlags);
break;
case ESM::fourCC("MNAM"):
reader.getZString(mMaterial);
break;
case ESM::fourCC("DODT"): // Decal data
case ESM::fourCC("OBND"): // object bounds
case ESM::fourCC("OPDS"): // Object placement defaults, FO76
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::TXST::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::TextureSet::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::TextureSet::blank()
//{
// }
| 3,865
|
C++
|
.cpp
| 98
| 28.928571
| 114
| 0.584554
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,827
|
loaddobj.cpp
|
OpenMW_openmw/components/esm4/loaddobj.cpp
|
/*
Copyright (C) 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
Also see https://tes5edit.github.io/fopdoc/ for FO3/FONV specific details.
*/
#include "loaddobj.hpp"
#include <cstring>
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::DefaultObj::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break; // "DefaultObjectManager"
case ESM::fourCC("DATA"):
reader.getFormId(mData.stimpack);
reader.getFormId(mData.superStimpack);
reader.getFormId(mData.radX);
reader.getFormId(mData.radAway);
reader.getFormId(mData.morphine);
reader.getFormId(mData.perkParalysis);
reader.getFormId(mData.playerFaction);
reader.getFormId(mData.mysteriousStrangerNPC);
reader.getFormId(mData.mysteriousStrangerFaction);
reader.getFormId(mData.defaultMusic);
reader.getFormId(mData.battleMusic);
reader.getFormId(mData.deathMusic);
reader.getFormId(mData.successMusic);
reader.getFormId(mData.levelUpMusic);
reader.getFormId(mData.playerVoiceMale);
reader.getFormId(mData.playerVoiceMaleChild);
reader.getFormId(mData.playerVoiceFemale);
reader.getFormId(mData.playerVoiceFemaleChild);
reader.getFormId(mData.eatPackageDefaultFood);
reader.getFormId(mData.everyActorAbility);
reader.getFormId(mData.drugWearsOffImageSpace);
// below FONV only
if (subHdr.dataSize == 136) // FONV 136/4 = 34 formid
{
reader.getFormId(mData.doctorsBag);
reader.getFormId(mData.missFortuneNPC);
reader.getFormId(mData.missFortuneFaction);
reader.getFormId(mData.meltdownExplosion);
reader.getFormId(mData.unarmedForwardPA);
reader.getFormId(mData.unarmedBackwardPA);
reader.getFormId(mData.unarmedLeftPA);
reader.getFormId(mData.unarmedRightPA);
reader.getFormId(mData.unarmedCrouchPA);
reader.getFormId(mData.unarmedCounterPA);
reader.getFormId(mData.spotterEffect);
reader.getFormId(mData.itemDetectedEfect);
reader.getFormId(mData.cateyeMobileEffectNYI);
}
break;
case ESM::fourCC("DNAM"):
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::DOBJ::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::DefaultObj::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::DefaultObj::blank()
//{
// }
| 4,302
|
C++
|
.cpp
| 92
| 35.771739
| 114
| 0.643317
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,828
|
loadclfm.cpp
|
OpenMW_openmw/components/esm4/loadclfm.cpp
|
/*
Copyright (C) 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadclfm.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Colour::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("CNAM"):
reader.get(mColour.red);
reader.get(mColour.green);
reader.get(mColour.blue);
reader.get(mColour.custom);
break;
case ESM::fourCC("FNAM"):
reader.get(mPlayable);
break;
case ESM::fourCC("CTDA"):
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::CLFM::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Colour::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Colour::blank()
//{
// }
| 2,427
|
C++
|
.cpp
| 62
| 31.564516
| 114
| 0.654484
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,829
|
loadlvlc.cpp
|
OpenMW_openmw/components/esm4/loadlvlc.cpp
|
/*
Copyright (C) 2016, 2018, 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadlvlc.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::LevelledCreature::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("TNAM"):
reader.getFormId(mTemplate);
break;
case ESM::fourCC("LVLD"):
reader.get(mChanceNone);
break;
case ESM::fourCC("LVLF"):
reader.get(mLvlCreaFlags);
break;
case ESM::fourCC("LVLO"):
{
LVLO lvlo;
if (subHdr.dataSize != 12)
{
if (subHdr.dataSize == 8)
{
reader.get(lvlo.level);
reader.get(lvlo.item);
reader.get(lvlo.count);
// std::cout << "LVLC " << mEditorId << " LVLO lev " << lvlo.level << ", item " << lvlo.item
// << /g", count " << lvlo.count << std::endl;
// FIXME: seems to happen only once, don't add to mLvlObject
// LVLC TesKvatchCreature LVLO lev 1, item 1393819648, count 2
// 0x0001, 0x5314 0000, 0x0002
break;
}
else
throw std::runtime_error("ESM4::LVLC::load - " + mEditorId + " LVLO size error");
}
else
reader.get(lvlo);
reader.adjustFormId(lvlo.item);
mLvlObject.push_back(lvlo);
break;
}
case ESM::fourCC("OBND"): // FO3
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::LVLC::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
bool ESM4::LevelledCreature::calcAllLvlLessThanPlayer() const
{
if (mHasLvlCreaFlags)
return (mLvlCreaFlags & 0x01) != 0;
else
return (mChanceNone & 0x80) != 0; // FIXME: 0x80 is just a guess
}
bool ESM4::LevelledCreature::calcEachItemInCount() const
{
if (mHasLvlCreaFlags)
return (mLvlCreaFlags & 0x02) != 0;
else
return true; // FIXME: just a guess
}
std::int8_t ESM4::LevelledCreature::chanceNone() const
{
if (mHasLvlCreaFlags)
return mChanceNone;
else
return (mChanceNone & 0x7f); // FIXME: 0x80 is just a guess
}
// void ESM4::LevelledCreature::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::LevelledCreature::blank()
//{
// }
| 4,195
|
C++
|
.cpp
| 109
| 28.458716
| 116
| 0.583047
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,830
|
loadrefr.cpp
|
OpenMW_openmw/components/esm4/loadrefr.cpp
|
/*
Copyright (C) 2015-2016, 2018, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadrefr.hpp"
#include <stdexcept>
#include "reader.hpp"
// #include "writer.hpp"
void ESM4::Reference::load(ESM4::Reader& reader)
{
mId = reader.hdr().record.getFormId();
reader.adjustFormId(mId);
mFlags = reader.hdr().record.flags;
mParent = reader.currCell();
ESM::FormId mid;
ESM::FormId sid;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("NAME"):
{
ESM::FormId BaseId;
reader.getFormId(BaseId);
mBaseObj = BaseId;
break;
}
case ESM::fourCC("DATA"):
reader.get(mPos);
break;
case ESM::fourCC("XSCL"):
reader.get(mScale);
break;
case ESM::fourCC("XOWN"):
{
switch (subHdr.dataSize)
{
case 4:
reader.getFormId(mOwner);
break;
case 12:
{
reader.getFormId(mOwner);
std::uint32_t dummy;
reader.get(dummy); // Unknown
reader.get(dummy); // No crime flag, FO4
break;
}
default:
reader.skipSubRecordData();
break;
}
break;
}
case ESM::fourCC("XGLB"):
reader.getFormId(mGlobal);
break;
case ESM::fourCC("XRNK"):
reader.get(mFactionRank);
break;
case ESM::fourCC("XESP"):
{
reader.getFormId(mEsp.parent);
reader.get(mEsp.flags);
// std::cout << "REFR parent: " << formIdToString(mEsp.parent) << " ref " << formIdToString(mFormId)
// << ", 0x" << std::hex << (mEsp.flags & 0xff) << std::endl;// FIXME
break;
}
case ESM::fourCC("XTEL"):
{
switch (subHdr.dataSize)
{
case 28:
case 32: // FO3, FNV, TES5
case 36: // FO4
{
reader.getFormId(mDoor.destDoor);
reader.get(mDoor.destPos);
mDoor.flags = 0;
if (subHdr.dataSize >= 32)
{
reader.get(mDoor.flags);
if (subHdr.dataSize == 36)
reader.getFormId(mDoor.transitionInterior);
}
break;
}
default:
reader.skipSubRecordData();
break;
}
break;
}
case ESM::fourCC("XSED"):
{
// 1 or 4 bytes
if (subHdr.dataSize == 1)
{
uint8_t data;
reader.get(data);
// std::cout << "REFR XSED " << std::hex << (int)data << std::endl;
break;
}
else if (subHdr.dataSize == 4)
{
uint32_t data;
reader.get(data);
// std::cout << "REFR XSED " << std::hex << (int)data << std::endl;
break;
}
// std::cout << "REFR XSED dataSize: " << subHdr.dataSize << std::endl;// FIXME
reader.skipSubRecordData();
break;
}
case ESM::fourCC("XLOD"):
{
// 12 bytes
if (subHdr.dataSize == 12)
{
float data, data2, data3;
reader.get(data);
reader.get(data2);
reader.get(data3);
// bool hasVisibleWhenDistantFlag = (mFlags & 0x00008000) != 0; // currently unused
// some are trees, e.g. 000E03B6, mBaseObj 00022F32, persistent, visible when distant
// some are doors, e.g. 000270F7, mBaseObj 000CD338, persistent, initially disabled
// (this particular one is an Oblivion Gate)
// std::cout << "REFR XLOD " << std::hex << (int)data << " " << (int)data2 << " " << (int)data3 <<
// std::endl;
break;
}
// std::cout << "REFR XLOD dataSize: " << subHdr.dataSize << std::endl;// FIXME
reader.skipSubRecordData();
break;
}
case ESM::fourCC("XACT"):
{
if (subHdr.dataSize == 4)
{
uint32_t data;
reader.get(data);
// std::cout << "REFR XACT " << std::hex << (int)data << std::endl;
break;
}
// std::cout << "REFR XACT dataSize: " << subHdr.dataSize << std::endl;// FIXME
reader.skipSubRecordData();
break;
}
case ESM::fourCC("XRTM"): // formId
{
// seems like another ref, e.g. 00064583 has base object 00000034 which is "XMarkerHeading"
// e.g. some are doors (prob. quest related)
// MS94OblivionGateRef XRTM : 00097C88
// MQ11SkingradGate XRTM : 00064583
// MQ11ChorrolGate XRTM : 00188770
// MQ11LeyawiinGate XRTM : 0018AD7C
// MQ11AnvilGate XRTM : 0018D452
// MQ11BravilGate XRTM : 0018AE1B
// e.g. some are XMarkerHeading
// XRTM : 000A4DD7 in OblivionRDCavesMiddleA05 (maybe spawn points?)
ESM::FormId marker;
reader.getFormId(marker);
// std::cout << "REFR " << mEditorId << " XRTM : " << formIdToString(marker) << std::endl;// FIXME
break;
}
case ESM::fourCC("TNAM"): // reader.get(mMapMarker); break;
{
if (subHdr.dataSize != sizeof(mMapMarker))
// reader.skipSubRecordData(); // FIXME: FO3
reader.getFormId(mid);
else
reader.get(mMapMarker); // TES4
break;
}
case ESM::fourCC("XMRK"):
mIsMapMarker = true;
break; // all have mBaseObj 0x00000010 "MapMarker"
case ESM::fourCC("FNAM"):
{
// std::cout << "REFR " << ESM::printName(subHdr.typeId) << " skipping..."
// << subHdr.dataSize << std::endl;
reader.skipSubRecordData();
break;
}
case ESM::fourCC("XTRG"): // formId
{
reader.getFormId(mTargetRef);
// std::cout << "REFR XRTG : " << formIdToString(id) << std::endl;// FIXME
break;
}
case ESM::fourCC("CNAM"):
reader.getFormId(mAudioLocation);
break; // FONV
case ESM::fourCC("XRDO"): // FO3
{
// FIXME: completely different meaning in FO4
reader.get(mRadio.rangeRadius);
reader.get(mRadio.broadcastRange);
reader.get(mRadio.staticPercentage);
reader.getFormId(mRadio.posReference);
break;
}
case ESM::fourCC("SCRO"): // FO3
{
reader.getFormId(sid);
// if (mFormId == 0x0016b74B)
// std::cout << "REFR SCRO : " << formIdToString(sid) << std::endl;// FIXME
break;
}
case ESM::fourCC("XLOC"):
{
mIsLocked = true;
std::int8_t dummy; // FIXME: very poor code
reader.get(mLockLevel);
reader.get(dummy);
reader.get(dummy);
reader.get(dummy);
ESM::FormId keyForm;
reader.getFormId(keyForm);
mKey = keyForm;
reader.get(dummy); // flag?
reader.get(dummy);
reader.get(dummy);
reader.get(dummy);
if (subHdr.dataSize == 16)
reader.skipSubRecordData(4); // Oblivion (sometimes), flag?
else if (subHdr.dataSize == 20) // Skyrim, FO3
reader.skipSubRecordData(8); // flag?
break;
}
case ESM::fourCC("XCNT"):
{
reader.get(mCount);
break;
}
// lighting
case ESM::fourCC("LNAM"): // lighting template formId
case ESM::fourCC("XLIG"): // struct, FOV, fade, etc
case ESM::fourCC("XEMI"): // LIGH formId
case ESM::fourCC("XRDS"): // Radius or Radiance
case ESM::fourCC("XRGB"):
case ESM::fourCC("XRGD"): // tangent data?
case ESM::fourCC("XALP"): // alpha cutoff
//
case ESM::fourCC("XPCI"): // formId
case ESM::fourCC("XLCM"):
case ESM::fourCC("ONAM"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("XPRM"):
case ESM::fourCC("INAM"):
case ESM::fourCC("PDTO"):
case ESM::fourCC("SCHR"):
case ESM::fourCC("SCTX"):
case ESM::fourCC("XAPD"):
case ESM::fourCC("XAPR"):
case ESM::fourCC("XCVL"):
case ESM::fourCC("XCZA"):
case ESM::fourCC("XCZC"):
case ESM::fourCC("XEZN"):
case ESM::fourCC("XFVC"):
case ESM::fourCC("XHTW"):
case ESM::fourCC("XIS2"):
case ESM::fourCC("XLCN"):
case ESM::fourCC("XLIB"):
case ESM::fourCC("XLKR"):
case ESM::fourCC("XLRM"):
case ESM::fourCC("XLRT"):
case ESM::fourCC("XLTW"):
case ESM::fourCC("XMBO"):
case ESM::fourCC("XMBP"):
case ESM::fourCC("XMBR"):
case ESM::fourCC("XNDP"):
case ESM::fourCC("XOCP"):
case ESM::fourCC("XPOD"):
case ESM::fourCC("XPTL"):
case ESM::fourCC("XPPA"):
case ESM::fourCC("XPRD"):
case ESM::fourCC("XPWR"):
case ESM::fourCC("XRMR"):
case ESM::fourCC("XSPC"):
case ESM::fourCC("XTNM"):
case ESM::fourCC("XTRI"):
case ESM::fourCC("XWCN"):
case ESM::fourCC("XWCU"):
case ESM::fourCC("XATR"):
case ESM::fourCC("XHLT"): // Unofficial Oblivion Patch
case ESM::fourCC("XCHG"): // thievery.exp
case ESM::fourCC("XHLP"): // FO3
case ESM::fourCC("XAMT"): // FO3
case ESM::fourCC("XAMC"): // FO3
case ESM::fourCC("XRAD"): // FO3
case ESM::fourCC("XIBS"): // FO3
case ESM::fourCC("XORD"): // FO3
case ESM::fourCC("XCLP"): // FO3
case ESM::fourCC("SCDA"): // FO3
case ESM::fourCC("RCLR"): // FO3
case ESM::fourCC("BNAM"): // FONV
case ESM::fourCC("MMRK"): // FONV
case ESM::fourCC("MNAM"): // FONV
case ESM::fourCC("NNAM"): // FONV
case ESM::fourCC("XATO"): // FONV
case ESM::fourCC("SCRV"): // FONV
case ESM::fourCC("SCVR"): // FONV
case ESM::fourCC("SLSD"): // FONV
case ESM::fourCC("XSRF"): // FONV
case ESM::fourCC("XSRD"): // FONV
case ESM::fourCC("WMI1"): // FONV
case ESM::fourCC("XLRL"): // Unofficial Skyrim Patch
case ESM::fourCC("XASP"): // FO4
case ESM::fourCC("XATP"): // FO4
case ESM::fourCC("XBSD"): // FO4
case ESM::fourCC("XCVR"): // FO4
case ESM::fourCC("XCZR"): // FO4
case ESM::fourCC("XLKT"): // FO4
case ESM::fourCC("XLYR"): // FO4
case ESM::fourCC("XMSP"): // FO4
case ESM::fourCC("XPDD"): // FO4
case ESM::fourCC("XPLK"): // FO4
case ESM::fourCC("XRFG"): // FO4
case ESM::fourCC("XWPG"): // FO4
case ESM::fourCC("XWPN"): // FO4
// if (mFormId == 0x0007e90f) // XPRM XPOD
// if (mBaseObj == 0x17) //XPRM XOCP occlusion plane data XMBO bound half extents
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::REFR::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
// if (mFormId == 0x0016B74B) // base is TACT vCasinoUltraLuxeRadio in cell ULCasino
// std::cout << "REFR SCRO " << formIdToString(sid) << std::endl;
}
// void ESM4::Reference::save(ESM4::Writer& writer) const
//{
// }
void ESM4::Reference::blank() {}
| 14,803
|
C++
|
.cpp
| 359
| 26.498607
| 118
| 0.467522
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,831
|
loadrace.cpp
|
OpenMW_openmw/components/esm4/loadrace.cpp
|
/*
Copyright (C) 2016, 2018-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadrace.hpp"
#include <cstring>
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Race::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
bool isTES4 = (esmVer == ESM::VER_080 || esmVer == ESM::VER_100) && !reader.hasFormVersion();
bool isFONV = esmVer == ESM::VER_132 || esmVer == ESM::VER_133 || esmVer == ESM::VER_134;
bool isFO3 = false;
bool isMale = false;
int curr_part = -1; // 0 = head, 1 = body, 2 = egt, 3 = hkx
std::uint32_t currentIndex = 0xffffffff;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
// std::cout << "RACE " << ESM::printName(subHdr.typeId) << std::endl;
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
{
reader.getZString(mEditorId);
// TES4
// Sheogorath 0x0005308E
// GoldenSaint 0x0001208F
// DarkSeducer 0x0001208E
// VampireRace 0x00000019
// Dremora 0x00038010
// Argonian 0x00023FE9
// Nord 0x000224FD
// Breton 0x000224FC
// WoodElf 0x000223C8
// Khajiit 0x000223C7
// DarkElf 0x000191C1
// Orc 0x000191C0
// HighElf 0x00019204
// Redguard 0x00000D43
// Imperial 0x00000907
break;
}
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DESC"):
{
if (subHdr.dataSize == 1) // FO3?
{
reader.skipSubRecordData();
break;
}
reader.getLocalizedString(mDesc);
break;
}
case ESM::fourCC("SPLO"): // bonus spell formid (TES5 may have SPCT and multiple SPLO)
reader.getFormId(mBonusSpells.emplace_back());
break;
case ESM::fourCC("DATA"): // ?? different length for TES5
{
// DATA:size 128
// 0f 0f ff 00 ff 00 ff 00 ff 00 ff 00 ff 00 00 00
// 9a 99 99 3f 00 00 80 3f 00 00 80 3f 00 00 80 3f
// 48 89 10 00 00 00 40 41 00 00 00 00 00 00 48 43
// 00 00 48 43 00 00 80 3f 9a 99 19 3f 00 00 00 40
// 01 00 00 00 ff ff ff ff ff ff ff ff 00 00 00 00
// ff ff ff ff 00 00 00 00 00 00 20 41 00 00 a0 40
// 00 00 a0 40 00 00 80 42 ff ff ff ff 00 00 00 00
// 00 00 00 00 9a 99 99 3e 00 00 a0 40 02 00 00 00
#if 0
unsigned char mDataBuf[256/*bufSize*/];
reader.get(mDataBuf, subHdr.dataSize);
std::ostringstream ss;
ss << ESM::printName(subHdr.typeId) << ":size " << subHdr.dataSize << "\n";
for (unsigned int i = 0; i < subHdr.dataSize; ++i)
{
//if (mDataBuf[i] > 64 && mDataBuf[i] < 91)
//ss << (char)(mDataBuf[i]) << " ";
//else
ss << std::setfill('0') << std::setw(2) << std::hex << (int)(mDataBuf[i]);
if ((i & 0x000f) == 0xf)
ss << "\n";
else if (i < 256/*bufSize*/-1)
ss << " ";
}
std::cout << ss.str() << std::endl;
#else
if (subHdr.dataSize == 36) // TES4/FO3/FONV
{
if (!isTES4 && !isFONV && !mIsTES5)
isFO3 = true;
std::uint8_t skill;
std::uint8_t bonus;
for (unsigned int i = 0; i < 8; ++i)
{
reader.get(skill);
reader.get(bonus);
mSkillBonus[static_cast<SkillIndex>(skill)] = bonus;
}
reader.get(mHeightMale);
reader.get(mHeightFemale);
reader.get(mWeightMale);
reader.get(mWeightFemale);
reader.get(mRaceFlags);
}
else if (subHdr.dataSize == 128 || subHdr.dataSize == 164) // TES5
{
mIsTES5 = true;
std::uint8_t skill;
std::uint8_t bonus;
for (unsigned int i = 0; i < 7; ++i)
{
reader.get(skill);
reader.get(bonus);
mSkillBonus[static_cast<SkillIndex>(skill)] = bonus;
}
std::uint16_t unknown;
reader.get(unknown);
reader.get(mHeightMale);
reader.get(mHeightFemale);
reader.get(mWeightMale);
reader.get(mWeightFemale);
reader.get(mRaceFlags);
// FIXME
float dummy;
reader.get(dummy); // starting health
reader.get(dummy); // starting magicka
reader.get(dummy); // starting stamina
reader.get(dummy); // base carry weight
reader.get(dummy); // base mass
reader.get(dummy); // accleration rate
reader.get(dummy); // decleration rate
uint32_t dummy2;
reader.get(dummy2); // size
reader.get(dummy2); // head biped object
reader.get(dummy2); // hair biped object
reader.get(dummy); // injured health % (0.f..1.f)
reader.get(dummy2); // shield biped object
reader.get(dummy); // health regen
reader.get(dummy); // magicka regen
reader.get(dummy); // stamina regen
reader.get(dummy); // unarmed damage
reader.get(dummy); // unarmed reach
reader.get(dummy2); // body biped object
reader.get(dummy); // aim angle tolerance
reader.get(dummy2); // unknown
reader.get(dummy); // angular accleration rate
reader.get(dummy); // angular tolerance
reader.get(dummy2); // flags
if (subHdr.dataSize == 164)
{
reader.get(dummy2); // unknown 1
reader.get(dummy2); // unknown 2
reader.get(dummy2); // unknown 3
reader.get(dummy2); // unknown 4
reader.get(dummy2); // unknown 5
reader.get(dummy2); // unknown 6
reader.get(dummy2); // unknown 7
reader.get(dummy2); // unknown 8
reader.get(dummy2); // unknown 9
}
}
else
{
reader.skipSubRecordData();
// std::cout << "RACE " << ESM::printName(subHdr.typeId) << " skipping..." << subHdr.dataSize <<
// std::endl;
}
#endif
break;
}
case ESM::fourCC("DNAM"):
{
reader.getFormId(mDefaultHair[0]); // male
reader.getFormId(mDefaultHair[1]); // female
break;
}
case ESM::fourCC("CNAM"):
// CNAM SNAM VNAM
// Sheogorath 0x0 0000 98 2b 10011000 00101011
// Golden Saint 0x3 0011 26 46 00100110 01000110
// Dark Seducer 0xC 1100 df 55 11011111 01010101
// Vampire Race 0x0 0000 77 44 01110111 10001000
// Dremora 0x7 0111 bf 32 10111111 00110010
// Argonian 0x0 0000 dc 3c 11011100 00111100
// Nord 0x5 0101 b6 03 10110110 00000011
// Breton 0x5 0101 48 1d 01001000 00011101 00000000 00000907 (Imperial)
// Wood Elf 0xD 1101 2e 4a 00101110 01001010 00019204 00019204 (HighElf)
// khajiit 0x5 0101 54 5b 01010100 01011011 00023FE9 00023FE9 (Argonian)
// Dark Elf 0x0 0000 72 54 01110010 01010100 00019204 00019204 (HighElf)
// Orc 0xC 1100 74 09 01110100 00001001 000224FD 000224FD (Nord)
// High Elf 0xF 1111 e6 21 11100110 00100001
// Redguard 0xD 1101 a9 61 10101001 01100001
// Imperial 0xD 1101 8e 35 10001110 00110101
{
reader.skipSubRecordData();
break;
}
case ESM::fourCC("PNAM"):
reader.get(mFaceGenMainClamp);
break; // 0x40A00000 = 5.f
case ESM::fourCC("UNAM"):
reader.get(mFaceGenFaceClamp);
break; // 0x40400000 = 3.f
case ESM::fourCC("ATTR"): // Only in TES4?
{
if (subHdr.dataSize == 2) // FO3?
{
reader.skipSubRecordData();
break;
}
reader.get(mAttribMale.strength);
reader.get(mAttribMale.intelligence);
reader.get(mAttribMale.willpower);
reader.get(mAttribMale.agility);
reader.get(mAttribMale.speed);
reader.get(mAttribMale.endurance);
reader.get(mAttribMale.personality);
reader.get(mAttribMale.luck);
reader.get(mAttribFemale.strength);
reader.get(mAttribFemale.intelligence);
reader.get(mAttribFemale.willpower);
reader.get(mAttribFemale.agility);
reader.get(mAttribFemale.speed);
reader.get(mAttribFemale.endurance);
reader.get(mAttribFemale.personality);
reader.get(mAttribFemale.luck);
break;
}
// [0..9]-> ICON
// NAM0 -> INDX -> MODL --+
// ^ -> MODB |
// | |
// +-------------+
//
case ESM::fourCC("NAM0"): // start marker head data /* 1 */
{
curr_part = 0; // head part
if (isFO3 || isFONV)
{
mHeadParts.resize(8);
mHeadPartsFemale.resize(8);
}
else if (isTES4)
mHeadParts.resize(9); // assumed based on Construction Set
else // Optimized for TES5
{
mHeadPartIdsMale.resize(5);
mHeadPartIdsFemale.resize(5);
}
currentIndex = 0xffffffff;
break;
}
case ESM::fourCC("INDX"):
{
reader.get(currentIndex);
// FIXME: below check is rather useless
// if (headpart)
//{
// if (currentIndex > 8)
// throw std::runtime_error("ESM4::RACE::load - too many head part " + currentIndex);
//}
// else // bodypart
//{
// if (currentIndex > 4)
// throw std::runtime_error("ESM4::RACE::load - too many body part " + currentIndex);
//}
break;
}
case ESM::fourCC("MODL"):
{
if (currentIndex == 0xffffffff)
{
reader.skipSubRecordData();
}
else if (curr_part == 0) // head part
{
if (isMale || isTES4)
reader.getZString(mHeadParts[currentIndex].mesh);
else
reader.getZString(mHeadPartsFemale[currentIndex].mesh); // TODO: check TES4
// TES5 keeps head part formid in mHeadPartIdsMale and mHeadPartIdsFemale
}
else if (curr_part == 1) // body part
{
if (isMale)
reader.getZString(mBodyPartsMale[currentIndex].mesh);
else
reader.getZString(mBodyPartsFemale[currentIndex].mesh);
// TES5 seems to have no body parts at all, instead keep EGT models
}
// else if (curr_part == 2) // egt
// {
// // std::cout << mEditorId << " egt " << currentIndex << std::endl; // FIXME
// reader.skipSubRecordData(); // FIXME TES5 egt
// }
else
{
// std::cout << mEditorId << " hkx " << currentIndex << std::endl; // FIXME
reader.skipSubRecordData(); // FIXME TES5 hkx
}
break;
}
case ESM::fourCC("MODB"):
reader.skipSubRecordData();
break; // always 0x0000?
case ESM::fourCC("ICON"):
{
if (currentIndex == 0xffffffff)
{
reader.skipSubRecordData();
}
else if (curr_part == 0) // head part
{
if (isMale || isTES4)
reader.getZString(mHeadParts[currentIndex].texture);
else
reader.getZString(mHeadPartsFemale[currentIndex].texture); // TODO: check TES4
}
else if (curr_part == 1) // body part
{
if (isMale)
reader.getZString(mBodyPartsMale[currentIndex].texture);
else
reader.getZString(mBodyPartsFemale[currentIndex].texture);
}
else
reader.skipSubRecordData(); // FIXME TES5
break;
}
//
case ESM::fourCC("NAM1"): // start marker body data /* 4 */
{
if (isFO3 || isFONV)
{
curr_part = 1; // body part
mBodyPartsMale.resize(4);
mBodyPartsFemale.resize(4);
}
else if (isTES4)
{
curr_part = 1; // body part
mBodyPartsMale.resize(5); // 0 = upper body, 1 = legs, 2 = hands, 3 = feet, 4 = tail
mBodyPartsFemale.resize(5); // 0 = upper body, 1 = legs, 2 = hands, 3 = feet, 4 = tail
}
else // TES5
curr_part = 2; // for TES5 NAM1 indicates the start of EGT model
if (isTES4)
currentIndex = 4; // FIXME: argonian tail mesh without preceeding INDX
else
currentIndex = 0xffffffff;
break;
}
case ESM::fourCC("MNAM"):
isMale = true;
break; /* 2, 5, 7 */
case ESM::fourCC("FNAM"):
isMale = false;
break; /* 3, 6, 8 */
//
case ESM::fourCC("HNAM"):
{
// FIXME: this is a texture name in FO4
if (subHdr.dataSize % sizeof(ESM::FormId32) != 0)
reader.skipSubRecordData();
else
{
std::size_t numHairChoices = subHdr.dataSize / sizeof(ESM::FormId32);
mHairChoices.resize(numHairChoices);
for (unsigned int i = 0; i < numHairChoices; ++i)
reader.getFormId(mHairChoices.at(i));
}
break;
}
case ESM::fourCC("ENAM"):
{
std::size_t numEyeChoices = subHdr.dataSize / sizeof(ESM::FormId32);
mEyeChoices.resize(numEyeChoices);
for (unsigned int i = 0; i < numEyeChoices; ++i)
reader.getFormId(mEyeChoices.at(i));
break;
}
case ESM::fourCC("FGGS"):
{
if (isMale || isTES4)
{
mSymShapeModeCoefficients.resize(50);
for (std::size_t i = 0; i < 50; ++i)
reader.get(mSymShapeModeCoefficients.at(i));
}
else
{
mSymShapeModeCoeffFemale.resize(50);
for (std::size_t i = 0; i < 50; ++i)
reader.get(mSymShapeModeCoeffFemale.at(i));
}
break;
}
case ESM::fourCC("FGGA"):
{
if (isMale || isTES4)
{
mAsymShapeModeCoefficients.resize(30);
for (std::size_t i = 0; i < 30; ++i)
reader.get(mAsymShapeModeCoefficients.at(i));
}
else
{
mAsymShapeModeCoeffFemale.resize(30);
for (std::size_t i = 0; i < 30; ++i)
reader.get(mAsymShapeModeCoeffFemale.at(i));
}
break;
}
case ESM::fourCC("FGTS"):
{
if (isMale || isTES4)
{
mSymTextureModeCoefficients.resize(50);
for (std::size_t i = 0; i < 50; ++i)
reader.get(mSymTextureModeCoefficients.at(i));
}
else
{
mSymTextureModeCoeffFemale.resize(50);
for (std::size_t i = 0; i < 50; ++i)
reader.get(mSymTextureModeCoeffFemale.at(i));
}
break;
}
//
case ESM::fourCC("SNAM"): // skipping...2 // only in TES4?
{
reader.skipSubRecordData();
break;
}
case ESM::fourCC("XNAM"):
{
ESM::FormId race;
std::int32_t adjustment;
reader.getFormId(race);
reader.get(adjustment);
mDisposition[race] = adjustment;
break;
}
case ESM::fourCC("VNAM"):
{
if (subHdr.dataSize == 8) // TES4
{
reader.getFormId(mVNAM[0]); // For TES4 seems to be 2 race formids
reader.getFormId(mVNAM[1]);
}
else if (subHdr.dataSize == 4) // TES5
{
// equipment type flags meant to be uint32 ??? GLOB reference? shows up in
// SCRO in sript records and CTDA in INFO records
uint32_t dummy;
reader.get(dummy);
}
else
{
reader.skipSubRecordData();
// std::cout << "RACE " << ESM::printName(subHdr.typeId) << " skipping..." << subHdr.dataSize <<
// std::endl;
}
break;
}
//
case ESM::fourCC("ANAM"): // TES5
{
if (isMale)
reader.getZString(mModelMale);
else
reader.getZString(mModelFemale);
break;
}
case ESM::fourCC("KSIZ"):
reader.get(mNumKeywords);
break;
case ESM::fourCC("KWDA"):
{
ESM::FormId formid;
for (unsigned int i = 0; i < mNumKeywords; ++i)
reader.getFormId(formid);
break;
}
//
case ESM::fourCC("WNAM"): // ARMO FormId
{
reader.getFormId(mSkin);
// std::cout << mEditorId << " skin " << formIdToString(mSkin) << std::endl; // FIXME
break;
}
case ESM::fourCC("BODT"): // body template
{
reader.get(mBodyTemplate.bodyPart);
reader.get(mBodyTemplate.flags);
reader.get(mBodyTemplate.unknown1); // probably padding
reader.get(mBodyTemplate.unknown2); // probably padding
reader.get(mBodyTemplate.unknown3); // probably padding
reader.get(mBodyTemplate.type);
break;
}
case ESM::fourCC("BOD2"):
{
if (subHdr.dataSize == 8 || subHdr.dataSize == 4) // TES5, FO4
{
reader.get(mBodyTemplate.bodyPart);
mBodyTemplate.flags = 0;
mBodyTemplate.unknown1 = 0; // probably padding
mBodyTemplate.unknown2 = 0; // probably padding
mBodyTemplate.unknown3 = 0; // probably padding
mBodyTemplate.type = 0;
if (subHdr.dataSize == 8)
reader.get(mBodyTemplate.type);
}
else
{
reader.skipSubRecordData();
}
break;
}
case ESM::fourCC("HEAD"): // TES5
{
ESM::FormId formId;
reader.getFormId(formId);
if (currentIndex != 0xffffffff)
{
// FIXME: no order? head, mouth, eyes, brow, hair
if (isMale)
{
if (currentIndex >= mHeadPartIdsMale.size())
mHeadPartIdsMale.resize(currentIndex + 1);
mHeadPartIdsMale[currentIndex] = formId;
}
else
{
if (currentIndex >= mHeadPartIdsFemale.size())
mHeadPartIdsFemale.resize(currentIndex + 1);
mHeadPartIdsFemale[currentIndex] = formId;
}
}
// std::cout << mEditorId << (isMale ? " male head " : " female head ")
// << formIdToString(formId) << " " << currentIndex << std::endl; // FIXME
break;
}
case ESM::fourCC("NAM3"): // start of hkx model
{
curr_part = 3; // for TES5 NAM3 indicates the start of hkx model
break;
}
// Not sure for what this is used - maybe to indicate which slots are in use? e.g.:
//
// ManakinRace HEAD
// ManakinRace Hair
// ManakinRace BODY
// ManakinRace Hands
// ManakinRace Forearms
// ManakinRace Amulet
// ManakinRace Ring
// ManakinRace Feet
// ManakinRace Calves
// ManakinRace SHIELD
// ManakinRace
// ManakinRace LongHair
// ManakinRace Circlet
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace DecapitateHead
// ManakinRace Decapitate
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace
// ManakinRace FX0
case ESM::fourCC("NAME"): // TES5 biped object names (x32)
{
std::string name;
reader.getZString(name);
// std::cout << mEditorId << " " << name << std::endl;
break;
}
case ESM::fourCC("MTNM"): // movement type
case ESM::fourCC("ATKD"): // attack data
case ESM::fourCC("ATKE"): // attach event
case ESM::fourCC("GNAM"): // body part data
case ESM::fourCC("NAM4"): // material type
case ESM::fourCC("NAM5"): // unarmed impact?
case ESM::fourCC("LNAM"): // close loot sound
case ESM::fourCC("QNAM"): // equipment slot formid
case ESM::fourCC("HCLF"): // default hair colour
case ESM::fourCC("UNES"): // unarmed equipment slot formid
case ESM::fourCC("TINC"):
case ESM::fourCC("TIND"):
case ESM::fourCC("TINI"):
case ESM::fourCC("TINL"):
case ESM::fourCC("TINP"):
case ESM::fourCC("TINT"):
case ESM::fourCC("TINV"):
case ESM::fourCC("TIRS"):
case ESM::fourCC("PHWT"):
case ESM::fourCC("AHCF"):
case ESM::fourCC("AHCM"):
case ESM::fourCC("MPAI"):
case ESM::fourCC("MPAV"):
case ESM::fourCC("DFTF"):
case ESM::fourCC("DFTM"):
case ESM::fourCC("FLMV"):
case ESM::fourCC("FTSF"):
case ESM::fourCC("FTSM"):
case ESM::fourCC("MTYP"):
case ESM::fourCC("NAM7"):
case ESM::fourCC("NAM8"):
case ESM::fourCC("PHTN"):
case ESM::fourCC("RNAM"):
case ESM::fourCC("RNMV"):
case ESM::fourCC("RPRF"):
case ESM::fourCC("RPRM"):
case ESM::fourCC("SNMV"):
case ESM::fourCC("SPCT"):
case ESM::fourCC("SPED"):
case ESM::fourCC("SWMV"):
case ESM::fourCC("WKMV"):
case ESM::fourCC("SPMV"):
case ESM::fourCC("ATKR"):
case ESM::fourCC("CTDA"):
case ESM::fourCC("CIS1"):
case ESM::fourCC("CIS2"):
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
//
case ESM::fourCC("YNAM"): // FO3
case ESM::fourCC("NAM2"): // FO3
case ESM::fourCC("VTCK"): // FO3
case ESM::fourCC("MODD"): // FO3
case ESM::fourCC("ONAM"): // FO3
case ESM::fourCC("APPR"): // FO4
case ESM::fourCC("ATKS"): // FO4
case ESM::fourCC("ATKT"): // FO4
case ESM::fourCC("ATKW"): // FO4
case ESM::fourCC("BMMP"): // FO4
case ESM::fourCC("BSMB"): // FO4
case ESM::fourCC("BSMP"): // FO4
case ESM::fourCC("BSMS"): // FO4
case ESM::fourCC("FMRI"): // FO4
case ESM::fourCC("FMRN"): // FO4
case ESM::fourCC("HLTX"): // FO4
case ESM::fourCC("MLSI"): // FO4
case ESM::fourCC("MPGN"): // FO4
case ESM::fourCC("MPGS"): // FO4
case ESM::fourCC("MPPC"): // FO4
case ESM::fourCC("MPPF"): // FO4
case ESM::fourCC("MPPI"): // FO4
case ESM::fourCC("MPPK"): // FO4
case ESM::fourCC("MPPM"): // FO4
case ESM::fourCC("MPPN"): // FO4
case ESM::fourCC("MPPT"): // FO4
case ESM::fourCC("MSID"): // FO4
case ESM::fourCC("MSM0"): // FO4
case ESM::fourCC("MSM1"): // FO4
case ESM::fourCC("NNAM"): // FO4
case ESM::fourCC("NTOP"): // FO4
case ESM::fourCC("PRPS"): // FO4
case ESM::fourCC("PTOP"): // FO4
case ESM::fourCC("QSTI"): // FO4
case ESM::fourCC("RBPC"): // FO4
case ESM::fourCC("SADD"): // FO4
case ESM::fourCC("SAKD"): // FO4
case ESM::fourCC("SAPT"): // FO4
case ESM::fourCC("SGNM"): // FO4
case ESM::fourCC("SRAC"): // FO4
case ESM::fourCC("SRAF"): // FO4
case ESM::fourCC("STCP"): // FO4
case ESM::fourCC("STKD"): // FO4
case ESM::fourCC("TETI"): // FO4
case ESM::fourCC("TTEB"): // FO4
case ESM::fourCC("TTEC"): // FO4
case ESM::fourCC("TTED"): // FO4
case ESM::fourCC("TTEF"): // FO4
case ESM::fourCC("TTET"): // FO4
case ESM::fourCC("TTGE"): // FO4
case ESM::fourCC("TTGP"): // FO4
case ESM::fourCC("UNWP"): // FO4
case ESM::fourCC("WMAP"): // FO4
case ESM::fourCC("ZNAM"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::RACE::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Race::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Race::blank()
//{
// }
| 30,634
|
C++
|
.cpp
| 731
| 26.101231
| 116
| 0.453772
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,832
|
loadflst.cpp
|
OpenMW_openmw/components/esm4/loadflst.cpp
|
/*
Copyright (C) 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadflst.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::FormIdList::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("LNAM"):
reader.getFormId(mObjects.emplace_back());
break;
default:
throw std::runtime_error("ESM4::FLST::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::FormIdList::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::FormIdList::blank()
//{
// }
| 2,118
|
C++
|
.cpp
| 53
| 33.830189
| 114
| 0.689235
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,833
|
loadsbsp.cpp
|
OpenMW_openmw/components/esm4/loadsbsp.cpp
|
/*
Copyright (C) 2016, 2018, 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadsbsp.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::SubSpace::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("DNAM"):
{
reader.get(mDimension.x);
reader.get(mDimension.y);
reader.get(mDimension.z);
break;
}
default:
throw std::runtime_error("ESM4::SBSP::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::SubSpace::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::SubSpace::blank()
//{
// }
| 2,104
|
C++
|
.cpp
| 54
| 32.703704
| 114
| 0.68106
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,834
|
loadligh.cpp
|
OpenMW_openmw/components/esm4/loadligh.cpp
|
/*
Copyright (C) 2016, 2018, 2020-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadligh.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Light::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DATA"):
{
if (subHdr.dataSize != 32 && subHdr.dataSize != 48 && subHdr.dataSize != 64)
{
reader.skipSubRecordData();
break;
}
reader.get(mData.time);
reader.get(mData.radius);
reader.get(mData.colour);
reader.get(mData.flags);
reader.get(mData.falloff);
reader.get(mData.FOV);
// TES5, FO4
if (subHdr.dataSize >= 48)
{
reader.get(mData.nearClip);
reader.get(mData.frequency);
reader.get(mData.intensityAmplitude);
reader.get(mData.movementAmplitude);
if (subHdr.dataSize == 64)
{
reader.get(mData.constant);
reader.get(mData.scalar);
reader.get(mData.exponent);
reader.get(mData.godRaysNearClip);
}
}
reader.get(mData.value);
reader.get(mData.weight);
break;
}
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("ICON"):
reader.getZString(mIcon);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("SNAM"):
reader.getFormId(mSound);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("FNAM"):
reader.get(mFade);
break;
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("OBND"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("LNAM"): // FO4
case ESM::fourCC("MICO"): // FO4
case ESM::fourCC("NAM0"): // FO4
case ESM::fourCC("PRPS"): // FO4
case ESM::fourCC("PTRN"): // FO4
case ESM::fourCC("WGDR"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::LIGH::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Light::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Light::blank()
//{
// }
| 4,912
|
C++
|
.cpp
| 125
| 27.36
| 114
| 0.543132
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,835
|
loadclas.cpp
|
OpenMW_openmw/components/esm4/loadclas.cpp
|
/*
Copyright (C) 2016, 2018, 2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadclas.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Class::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DESC"):
reader.getLocalizedString(mDesc);
break;
case ESM::fourCC("ICON"):
reader.getZString(mIcon);
break;
case ESM::fourCC("DATA"):
case ESM::fourCC("ATTR"):
case ESM::fourCC("PRPS"):
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::CLAS::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Class::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Class::blank()
//{
// }
| 2,390
|
C++
|
.cpp
| 61
| 31.885246
| 114
| 0.658179
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,836
|
loadglob.cpp
|
OpenMW_openmw/components/esm4/loadglob.cpp
|
/*
Copyright (C) 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadglob.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::GlobalVariable::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("XALG"): // FO76
reader.get(mExtraFlags2);
break;
case ESM::fourCC("FNAM"):
reader.get(mType);
break;
case ESM::fourCC("FLTV"):
reader.get(mValue);
break;
case ESM::fourCC("NTWK"): // FO76
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::GLOB::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::GlobalVariable::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::GlobalVariable::blank()
//{
// }
| 2,312
|
C++
|
.cpp
| 59
| 32.084746
| 114
| 0.662651
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,837
|
loadarma.cpp
|
OpenMW_openmw/components/esm4/loadarma.cpp
|
/*
Copyright (C) 2019, 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadarma.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::ArmorAddon::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("MOD2"):
reader.getZString(mModelMale);
break;
case ESM::fourCC("MOD3"):
reader.getZString(mModelFemale);
break;
case ESM::fourCC("MOD4"):
case ESM::fourCC("MOD5"):
{
std::string model;
reader.getZString(model);
break;
}
case ESM::fourCC("NAM0"):
reader.getFormId(mTextureMale);
break;
case ESM::fourCC("NAM1"):
reader.getFormId(mTextureFemale);
break;
case ESM::fourCC("RNAM"):
reader.getFormId(mRacePrimary);
break;
case ESM::fourCC("MODL"):
if ((esmVer == ESM::VER_094 || esmVer == ESM::VER_170) && subHdr.dataSize == 4) // TES5
reader.getFormId(mRaces.emplace_back());
else
reader.skipSubRecordData(); // FIXME: this should be mModelMale for FO3/FONV
break;
case ESM::fourCC("BODT"): // body template
reader.get(mBodyTemplate.bodyPart);
reader.get(mBodyTemplate.flags);
reader.get(mBodyTemplate.unknown1); // probably padding
reader.get(mBodyTemplate.unknown2); // probably padding
reader.get(mBodyTemplate.unknown3); // probably padding
reader.get(mBodyTemplate.type);
break;
case ESM::fourCC("BOD2"): // TES5+
reader.get(mBodyTemplate.bodyPart);
mBodyTemplate.flags = 0;
mBodyTemplate.unknown1 = 0; // probably padding
mBodyTemplate.unknown2 = 0; // probably padding
mBodyTemplate.unknown3 = 0; // probably padding
mBodyTemplate.type = 0;
if (subHdr.dataSize == 8)
reader.get(mBodyTemplate.type);
break;
case ESM::fourCC("DNAM"):
if (subHdr.dataSize == 12)
{
std::uint16_t unknownInt16;
std::uint8_t unknownInt8;
reader.get(mMalePriority);
reader.get(mFemalePriority);
reader.get(mWeightSliderMale);
reader.get(mWeightSliderFemale);
reader.get(unknownInt16);
reader.get(mDetectionSoundValue);
reader.get(unknownInt8);
reader.get(mWeaponAdjust);
}
else
reader.skipSubRecordData();
break;
case ESM::fourCC("MO2T"): // FIXME: should group with MOD2
case ESM::fourCC("MO2S"): // FIXME: should group with MOD2
case ESM::fourCC("MO2C"): // FIXME: should group with MOD2
case ESM::fourCC("MO2F"): // FIXME: should group with MOD2
case ESM::fourCC("MO3T"): // FIXME: should group with MOD3
case ESM::fourCC("MO3S"): // FIXME: should group with MOD3
case ESM::fourCC("MO3C"): // FIXME: should group with MOD3
case ESM::fourCC("MO3F"): // FIXME: should group with MOD3
case ESM::fourCC("MOSD"): // FO3 // FIXME: should group with MOD3
case ESM::fourCC("MO4T"): // FIXME: should group with MOD4
case ESM::fourCC("MO4S"): // FIXME: should group with MOD4
case ESM::fourCC("MO4C"): // FIXME: should group with MOD4
case ESM::fourCC("MO4F"): // FIXME: should group with MOD4
case ESM::fourCC("MO5T"):
case ESM::fourCC("MO5S"):
case ESM::fourCC("MO5C"):
case ESM::fourCC("MO5F"):
case ESM::fourCC("NAM2"): // txst formid male
case ESM::fourCC("NAM3"): // txst formid female
case ESM::fourCC("SNDD"): // footset sound formid
case ESM::fourCC("BMDT"): // FO3
case ESM::fourCC("DATA"): // FO3
case ESM::fourCC("ETYP"): // FO3
case ESM::fourCC("FULL"): // FO3
case ESM::fourCC("ICO2"): // FO3 // female
case ESM::fourCC("ICON"): // FO3 // male
case ESM::fourCC("MODT"): // FO3 // FIXME: should group with MODL
case ESM::fourCC("MODS"): // FO3 // FIXME: should group with MODL
case ESM::fourCC("MODD"): // FO3 // FIXME: should group with MODL
case ESM::fourCC("OBND"): // FO3
case ESM::fourCC("BSMB"): // FO4
case ESM::fourCC("BSMP"): // FO4
case ESM::fourCC("BSMS"): // FO4
case ESM::fourCC("ONAM"): // FO4
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::ARMA::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::ArmorAddon::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::ArmorAddon::blank()
//{
// }
| 6,738
|
C++
|
.cpp
| 147
| 33.659864
| 114
| 0.56615
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,838
|
loadaspc.cpp
|
OpenMW_openmw/components/esm4/loadaspc.cpp
|
/*
Copyright (C) 2020 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadaspc.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::AcousticSpace::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("ANAM"):
reader.get(mEnvironmentType);
break;
case ESM::fourCC("SNAM"):
reader.getFormId(mAmbientLoopSounds.emplace_back());
break;
case ESM::fourCC("RDAT"):
reader.getFormId(mSoundRegion);
break;
case ESM::fourCC("INAM"):
reader.get(mIsInterior);
break;
case ESM::fourCC("XTRI"):
std::uint8_t isInterior;
reader.get(isInterior);
mIsInterior = isInterior;
break;
case ESM::fourCC("WNAM"):
{
// usually 0 for FONV (maybe # of close Actors for Walla to trigger) (4 bytes)
// Weather attenuation in FO4 (2 bytes)
reader.skipSubRecordData();
break;
}
case ESM::fourCC("BNAM"): // TES5 reverb formid
case ESM::fourCC("OBND"):
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::ASPC::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::AcousticSpace::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::AcousticSpace::blank()
//{
// }
| 2,973
|
C++
|
.cpp
| 75
| 30.746667
| 114
| 0.62578
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,839
|
loadnpc.cpp
|
OpenMW_openmw/components/esm4/loadnpc.cpp
|
/*
Copyright (C) 2016-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadnpc.hpp"
#include <cstring>
#include <stdexcept>
#include <string> // getline
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Npc::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
mIsTES4 = (esmVer == ESM::VER_080 || esmVer == ESM::VER_100) && !reader.hasFormVersion();
mIsFONV = esmVer == ESM::VER_132 || esmVer == ESM::VER_133 || esmVer == ESM::VER_134;
// mIsTES5 = esmVer == ESM::VER_094 || esmVer == ESM::VER_170; // WARN: FO3 is also VER_094
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break; // not for TES5, see Race
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("CNTO"):
{
InventoryItem inv; // FIXME: use unique_ptr here?
reader.get(inv);
reader.adjustFormId(inv.item);
mInventory.push_back(inv);
break;
}
case ESM::fourCC("SPLO"):
reader.getFormId(mSpell.emplace_back());
break;
case ESM::fourCC("PKID"):
reader.getFormId(mAIPackages.emplace_back());
break;
case ESM::fourCC("SNAM"):
{
// FO4, FO76
if (subHdr.dataSize == 5)
reader.get(&mFaction, 5);
else
reader.get(mFaction);
reader.adjustFormId(mFaction.faction);
break;
}
case ESM::fourCC("RNAM"):
reader.getFormId(mRace);
break;
case ESM::fourCC("CNAM"):
reader.getFormId(mClass);
break;
case ESM::fourCC("HNAM"):
reader.getFormId(mHair);
break; // not for TES5
case ESM::fourCC("ENAM"):
reader.getFormId(mEyes);
break;
//
case ESM::fourCC("INAM"):
reader.getFormId(mDeathItem);
break;
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
//
case ESM::fourCC("AIDT"):
{
if (subHdr.dataSize != 12)
{
reader.skipSubRecordData(); // FIXME: process the subrecord rather than skip
break;
}
reader.get(mAIData); // TES4
break;
}
case ESM::fourCC("ACBS"):
{
switch (subHdr.dataSize)
{
case 20: // FO4
mIsFO4 = true;
[[fallthrough]];
case 16: // TES4
case 24: // FO3/FNV, TES5
reader.get(&mBaseConfig, subHdr.dataSize);
break;
default:
reader.skipSubRecordData();
break;
}
break;
}
case ESM::fourCC("DATA"):
{
if (subHdr.dataSize == 0)
break;
if (subHdr.dataSize == 33)
reader.get(&mData, 33); // FIXME: check packing
else // FIXME FO3
reader.skipSubRecordData();
break;
}
case ESM::fourCC("ZNAM"):
reader.getFormId(mCombatStyle);
break;
case ESM::fourCC("CSCR"):
reader.getFormId(mSoundBase);
break;
case ESM::fourCC("CSDI"):
reader.getFormId(mSound);
break;
case ESM::fourCC("CSDC"):
reader.get(mSoundChance);
break;
case ESM::fourCC("WNAM"):
{
// FIXME: should be read into mWornArmor for FO4
if (reader.esmVersion() == ESM::VER_094 || reader.esmVersion() == ESM::VER_170)
reader.getFormId(mWornArmor);
else
reader.get(mFootWeight);
break;
}
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("KFFZ"):
{
// Seems to be only below 3, and only happens 3 times while loading TES4:
// Forward_SheogorathWithCane.kf
// TurnLeft_SheogorathWithCane.kf
// TurnRight_SheogorathWithCane.kf
if (!reader.getZeroTerminatedStringArray(mKf))
throw std::runtime_error("NPC_ KFFZ data read error");
break;
}
case ESM::fourCC("LNAM"):
reader.get(mHairLength);
break;
case ESM::fourCC("HCLR"):
{
reader.get(mHairColour.red);
reader.get(mHairColour.green);
reader.get(mHairColour.blue);
reader.get(mHairColour.custom);
break;
}
case ESM::fourCC("TPLT"):
reader.getFormId(mBaseTemplate);
break;
case ESM::fourCC("FGGS"):
{
mSymShapeModeCoefficients.resize(50);
for (std::size_t i = 0; i < 50; ++i)
reader.get(mSymShapeModeCoefficients.at(i));
break;
}
case ESM::fourCC("FGGA"):
{
mAsymShapeModeCoefficients.resize(30);
for (std::size_t i = 0; i < 30; ++i)
reader.get(mAsymShapeModeCoefficients.at(i));
break;
}
case ESM::fourCC("FGTS"):
{
mSymTextureModeCoefficients.resize(50);
for (std::size_t i = 0; i < 50; ++i)
reader.get(mSymTextureModeCoefficients.at(i));
break;
}
case ESM::fourCC("FNAM"):
{
reader.get(mFgRace);
// std::cout << "race " << mEditorId << " " << mRace << std::endl; // FIXME
// std::cout << "fg race " << mEditorId << " " << mFgRace << std::endl; // FIXME
break;
}
case ESM::fourCC("PNAM"): // FO3/FONV/TES5
reader.getFormId(mHeadParts.emplace_back());
break;
case ESM::fourCC("HCLF"): // TES5 hair colour
{
reader.getFormId(mHairColourId);
break;
}
case ESM::fourCC("BCLF"):
{
reader.getFormId(mBeardColourId);
break;
}
case ESM::fourCC("COCT"): // TES5
{
std::uint32_t count;
reader.get(count);
break;
}
case ESM::fourCC("DOFT"):
reader.getFormId(mDefaultOutfit);
break;
case ESM::fourCC("SOFT"):
reader.getFormId(mSleepOutfit);
break;
case ESM::fourCC("DPLT"):
reader.getFormId(mDefaultPkg);
break; // AI package list
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
case ESM::fourCC("NAM6"): // height mult
case ESM::fourCC("NAM7"): // weight mult
case ESM::fourCC("ATKR"):
case ESM::fourCC("CRIF"):
case ESM::fourCC("CSDT"):
case ESM::fourCC("DNAM"):
case ESM::fourCC("ECOR"):
case ESM::fourCC("ANAM"):
case ESM::fourCC("ATKD"):
case ESM::fourCC("ATKE"):
case ESM::fourCC("FTST"):
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("NAM5"):
case ESM::fourCC("NAM8"):
case ESM::fourCC("NAM9"):
case ESM::fourCC("NAMA"):
case ESM::fourCC("OBND"):
case ESM::fourCC("PRKR"):
case ESM::fourCC("PRKZ"):
case ESM::fourCC("QNAM"):
case ESM::fourCC("SPCT"):
case ESM::fourCC("TIAS"):
case ESM::fourCC("TINC"):
case ESM::fourCC("TINI"):
case ESM::fourCC("TINV"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("VTCK"):
case ESM::fourCC("GNAM"):
case ESM::fourCC("SHRT"):
case ESM::fourCC("SPOR"):
case ESM::fourCC("EAMT"): // FO3
case ESM::fourCC("NAM4"): // FO3
case ESM::fourCC("COED"): // FO3
case ESM::fourCC("APPR"): // FO4
case ESM::fourCC("ATKS"): // FO4
case ESM::fourCC("ATKT"): // FO4
case ESM::fourCC("ATKW"): // FO4
case ESM::fourCC("ATTX"): // FO4
case ESM::fourCC("FTYP"): // FO4
case ESM::fourCC("LTPT"): // FO4
case ESM::fourCC("LTPC"): // FO4
case ESM::fourCC("MWGT"): // FO4
case ESM::fourCC("NTRM"): // FO4
case ESM::fourCC("PFRN"): // FO4
case ESM::fourCC("PRPS"): // FO4
case ESM::fourCC("PTRN"): // FO4
case ESM::fourCC("STCP"): // FO4
case ESM::fourCC("TETI"): // FO4
case ESM::fourCC("TEND"): // FO4
case ESM::fourCC("TPTA"): // FO4
case ESM::fourCC("OBTE"): // FO4 object template start
case ESM::fourCC("OBTF"): //
case ESM::fourCC("OBTS"): //
case ESM::fourCC("STOP"): // FO4 object template end
case ESM::fourCC("OCOR"): // FO4 new package lists start
case ESM::fourCC("GWOR"): //
case ESM::fourCC("FCPL"): //
case ESM::fourCC("RCLR"): // FO4 new package lists end
case ESM::fourCC("CS2D"): // FO4 actor sound subrecords
case ESM::fourCC("CS2E"): //
case ESM::fourCC("CS2F"): //
case ESM::fourCC("CS2H"): //
case ESM::fourCC("CS2K"): // FO4 actor sound subrecords end
case ESM::fourCC("MSDK"): // FO4 morph subrecords start
case ESM::fourCC("MSDV"): //
case ESM::fourCC("MRSV"): //
case ESM::fourCC("FMRI"): //
case ESM::fourCC("FMRS"): //
case ESM::fourCC("FMIN"): // FO4 morph subrecords end
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::NPC_::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Npc::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Npc::blank()
//{
// }
| 12,723
|
C++
|
.cpp
| 325
| 25.566154
| 114
| 0.486628
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,840
|
loadweap.cpp
|
OpenMW_openmw/components/esm4/loadweap.cpp
|
/*
Copyright (C) 2016, 2018-2021 cc9cii
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
cc9cii cc9c@iinet.net.au
Much of the information on the data structures are based on the information
from Tes4Mod:Mod_File_Format and Tes5Mod:File_Formats but also refined by
trial & error. See http://en.uesp.net/wiki for details.
*/
#include "loadweap.hpp"
#include <stdexcept>
#include "reader.hpp"
//#include "writer.hpp"
void ESM4::Weapon::load(ESM4::Reader& reader)
{
mId = reader.getFormIdFromHeader();
mFlags = reader.hdr().record.flags;
std::uint32_t esmVer = reader.esmVersion();
bool isFONV = esmVer == ESM::VER_132 || esmVer == ESM::VER_133 || esmVer == ESM::VER_134;
while (reader.getSubRecordHeader())
{
const ESM4::SubRecordHeader& subHdr = reader.subRecordHeader();
switch (subHdr.typeId)
{
case ESM::fourCC("EDID"):
reader.getZString(mEditorId);
break;
case ESM::fourCC("FULL"):
reader.getLocalizedString(mFullName);
break;
case ESM::fourCC("DATA"):
{
// if (reader.esmVersion() == ESM::VER_094 || reader.esmVersion() == ESM::VER_170)
if (subHdr.dataSize == 10) // FO3 has 15 bytes even though VER_094
{
reader.get(mData.value);
reader.get(mData.weight);
reader.get(mData.damage);
}
else if (isFONV || subHdr.dataSize == 15)
{
reader.get(mData.value);
reader.get(mData.health);
reader.get(mData.weight);
reader.get(mData.damage);
reader.get(mData.clipSize);
}
else
{
reader.get(mData.type);
reader.get(mData.speed);
reader.get(mData.reach);
reader.get(mData.flags);
reader.get(mData.value);
reader.get(mData.health);
reader.get(mData.weight);
reader.get(mData.damage);
}
break;
}
case ESM::fourCC("MODL"):
reader.getZString(mModel);
break;
case ESM::fourCC("ICON"):
reader.getZString(mIcon);
break;
case ESM::fourCC("MICO"):
reader.getZString(mMiniIcon);
break; // FO3
case ESM::fourCC("SCRI"):
reader.getFormId(mScriptId);
break;
case ESM::fourCC("ANAM"):
reader.get(mEnchantmentPoints);
break;
case ESM::fourCC("ENAM"):
reader.getFormId(mEnchantment);
break;
case ESM::fourCC("MODB"):
reader.get(mBoundRadius);
break;
case ESM::fourCC("DESC"):
reader.getLocalizedString(mText);
break;
case ESM::fourCC("YNAM"):
reader.getFormId(mPickUpSound);
break;
case ESM::fourCC("ZNAM"):
reader.getFormId(mDropSound);
break;
case ESM::fourCC("MODT"): // Model data
case ESM::fourCC("MODC"):
case ESM::fourCC("MODS"):
case ESM::fourCC("MODF"): // Model data end
case ESM::fourCC("BAMT"):
case ESM::fourCC("BIDS"):
case ESM::fourCC("INAM"):
case ESM::fourCC("CNAM"):
case ESM::fourCC("CRDT"):
case ESM::fourCC("DNAM"):
case ESM::fourCC("EAMT"):
case ESM::fourCC("EITM"):
case ESM::fourCC("ETYP"):
case ESM::fourCC("KSIZ"):
case ESM::fourCC("KWDA"):
case ESM::fourCC("NAM8"):
case ESM::fourCC("NAM9"):
case ESM::fourCC("OBND"):
case ESM::fourCC("SNAM"):
case ESM::fourCC("TNAM"):
case ESM::fourCC("UNAM"):
case ESM::fourCC("VMAD"):
case ESM::fourCC("VNAM"):
case ESM::fourCC("WNAM"):
case ESM::fourCC("XNAM"): // Dawnguard only?
case ESM::fourCC("NNAM"):
case ESM::fourCC("NAM0"): // FO3
case ESM::fourCC("REPL"): // FO3
case ESM::fourCC("MOD2"): // FO3
case ESM::fourCC("MO2T"): // FO3
case ESM::fourCC("MO2S"): // FO3
case ESM::fourCC("NAM6"): // FO3
case ESM::fourCC("MOD4"): // First person model data
case ESM::fourCC("MO4T"):
case ESM::fourCC("MO4S"):
case ESM::fourCC("MO4C"):
case ESM::fourCC("MO4F"): // First person model data end
case ESM::fourCC("BIPL"): // FO3
case ESM::fourCC("NAM7"): // FO3
case ESM::fourCC("MOD3"): // FO3
case ESM::fourCC("MO3T"): // FO3
case ESM::fourCC("MO3S"): // FO3
case ESM::fourCC("MODD"): // FO3
// case ESM::fourCC("MOSD"): // FO3
case ESM::fourCC("DAMC"): // Destructible
case ESM::fourCC("DEST"):
case ESM::fourCC("DMDC"):
case ESM::fourCC("DMDL"):
case ESM::fourCC("DMDT"):
case ESM::fourCC("DMDS"):
case ESM::fourCC("DSTA"):
case ESM::fourCC("DSTD"):
case ESM::fourCC("DSTF"): // Destructible end
case ESM::fourCC("VATS"): // FONV
case ESM::fourCC("VANM"): // FONV
case ESM::fourCC("MWD1"): // FONV
case ESM::fourCC("MWD2"): // FONV
case ESM::fourCC("MWD3"): // FONV
case ESM::fourCC("MWD4"): // FONV
case ESM::fourCC("MWD5"): // FONV
case ESM::fourCC("MWD6"): // FONV
case ESM::fourCC("MWD7"): // FONV
case ESM::fourCC("WMI1"): // FONV
case ESM::fourCC("WMI2"): // FONV
case ESM::fourCC("WMI3"): // FONV
case ESM::fourCC("WMS1"): // FONV
case ESM::fourCC("WMS2"): // FONV
case ESM::fourCC("WNM1"): // FONV
case ESM::fourCC("WNM2"): // FONV
case ESM::fourCC("WNM3"): // FONV
case ESM::fourCC("WNM4"): // FONV
case ESM::fourCC("WNM5"): // FONV
case ESM::fourCC("WNM6"): // FONV
case ESM::fourCC("WNM7"): // FONV
case ESM::fourCC("EFSD"): // FONV DeadMoney
case ESM::fourCC("APPR"): // FO4
case ESM::fourCC("DAMA"): // FO4
case ESM::fourCC("FLTR"): // FO4
case ESM::fourCC("FNAM"): // FO4
case ESM::fourCC("INRD"): // FO4
case ESM::fourCC("LNAM"): // FO4
case ESM::fourCC("MASE"): // FO4
case ESM::fourCC("PTRN"): // FO4
case ESM::fourCC("STCP"): // FO4
case ESM::fourCC("WAMD"): // FO4
case ESM::fourCC("WZMD"): // FO4
case ESM::fourCC("OBTE"): // FO4 object template start
case ESM::fourCC("OBTF"):
case ESM::fourCC("OBTS"):
case ESM::fourCC("STOP"): // FO4 object template end
reader.skipSubRecordData();
break;
default:
throw std::runtime_error("ESM4::WEAP::load - Unknown subrecord " + ESM::printName(subHdr.typeId));
}
}
}
// void ESM4::Weapon::save(ESM4::Writer& writer) const
//{
// }
// void ESM4::Weapon::blank()
//{
// }
| 8,473
|
C++
|
.cpp
| 204
| 29.034314
| 114
| 0.515078
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,841
|
debugdraw.cpp
|
OpenMW_openmw/components/debug/debugdraw.cpp
|
#include "debugdraw.hpp"
#include <components/sceneutil/nodecallback.hpp>
#include <components/shader/shadermanager.hpp>
#include <osg/Array>
#include <osg/Drawable>
#include <osg/GLExtensions>
#include <osg/Geometry>
#include <osg/Program>
#include <osg/Uniform>
#include <osg/Vec3>
static osg::Vec3 sphereCoordToCartesian(float theta, float phi, float r)
{
osg::Vec3 returnVec = osg::Vec3(0.0, 0.0, 0.0);
float phiToHorizontal = osg::PI_2 - phi;
returnVec.x() = std::cos(theta);
returnVec.y() = std::sin(theta);
returnVec.z() = std::sin(phiToHorizontal);
returnVec.x() *= std::cos(phiToHorizontal);
returnVec.y() *= std::cos(phiToHorizontal);
returnVec.x() *= r;
returnVec.z() *= r;
returnVec.y() *= r;
return returnVec;
}
static void generateWireCube(osg::Geometry& geom, float dim)
{
osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array;
osg::Vec2i indexPos[] = { osg::Vec2i(0, 0), osg::Vec2i(1, 0), osg::Vec2i(1, 1), osg::Vec2i(0, 1) };
for (int i = 0; i < 4; i++)
{
osg::Vec3 vert1 = osg::Vec3(indexPos[i].x() - 0.5, indexPos[i].y() - 0.5, 0.5);
int next = (i + 1) % 4;
osg::Vec3 vert2 = osg::Vec3(indexPos[next].x() - 0.5, indexPos[next].y() - 0.5, 0.5);
vertices->push_back(vert1 * dim);
vertices->push_back(vert2 * dim);
vert1.z() *= -1;
vert2.z() *= -1;
vertices->push_back(vert1 * dim);
vertices->push_back(vert2 * dim);
auto vert3 = vert1;
vert3.z() *= -1;
vertices->push_back(vert1 * dim);
vertices->push_back(vert3 * dim);
}
for (std::size_t i = 0; i < vertices->size(); i++)
{
normals->push_back(osg::Vec3(1., 1., 1.));
}
geom.setVertexArray(vertices);
geom.setNormalArray(normals, osg::Array::BIND_PER_VERTEX);
geom.addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES, 0, vertices->size()));
}
static void generateCube(osg::Geometry& geom, float dim)
{
osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array;
osg::ref_ptr<osg::DrawElementsUShort> indices = new osg::DrawElementsUShort(osg::DrawElementsUShort::TRIANGLES, 0);
for (int i_face = 0; i_face < 6; i_face++)
{
osg::Vec3f normale(0., 0., 0.);
osg::Vec3f u(0., 0., 0.);
osg::Vec3f v(0., 0., 0.);
int axis = i_face / 2;
int dir = i_face % 2 == 0 ? -1 : 1;
float float_dir = dir;
normale[axis] = float_dir;
u[(axis + 1) % 3] = 1.0;
v[(axis + 2) % 3] = 1.0;
for (int i_point = 0; i_point < 4; i_point++)
{
float iu = i_point % 2 == 1
? float_dir
: -float_dir; // This is to get the right triangle orientation when the normal changes*
float iv = i_point / 2 == 1 ? 1.0 : -1.0;
osg::Vec3f point = (u * iu) + (v * iv);
point = (point + normale);
point = point * (dim * 0.5f);
vertices->push_back(point);
normals->push_back(normale);
}
int start_vertex(i_face * 4);
int newFace1[] = { start_vertex, start_vertex + 1, start_vertex + 2 };
for (int i = 0; i < 3; i++)
{
indices->push_back(newFace1[i]);
}
int newFace2[] = { start_vertex + 2, start_vertex + 1, start_vertex + 3 };
for (int i = 0; i < 3; i++)
{
indices->push_back(newFace2[i]);
}
}
geom.setVertexArray(vertices);
geom.setNormalArray(normals, osg::Array::BIND_PER_VERTEX);
geom.addPrimitiveSet(indices);
}
static void generateCylinder(osg::Geometry& geom, float radius, float height, int subdiv)
{
osg::ref_ptr<osg::Vec3Array> vertices = new osg::Vec3Array;
osg::ref_ptr<osg::Vec3Array> normals = new osg::Vec3Array;
osg::ref_ptr<osg::DrawElementsUShort> indices = new osg::DrawElementsUShort(osg::DrawElementsUShort::TRIANGLES, 0);
int vertexCount = subdiv * 4 + 2; // 2 discs + top and bottom + 2 center
indices->reserve(vertexCount);
int iVertex = 0;
int beginTop = iVertex;
auto topNormal = osg::Vec3(0., 0., 1.);
// top disk
for (int i = 0; i < subdiv; i++)
{
float theta = (float(i) / float(subdiv)) * osg::PI * 2.;
osg::Vec3 pos = sphereCoordToCartesian(theta, osg::PI_2f, 1.);
pos *= radius;
pos.z() = height / 2.;
vertices->push_back(pos);
normals->push_back(topNormal);
iVertex += 1;
}
auto centerTop = iVertex;
// centerTop
{
vertices->push_back(osg::Vec3(0., 0., height / 2.));
normals->push_back(topNormal);
iVertex += 1;
}
auto centerBot = iVertex;
// centerBot
{
vertices->push_back(osg::Vec3(0., 0., -height / 2));
normals->push_back(-topNormal);
iVertex += 1;
}
// bottom disk
auto begin_bot = iVertex;
for (int i = 0; i < subdiv; i++)
{
float theta = float(i) / float(subdiv) * osg::PI * 2.;
osg::Vec3 pos = sphereCoordToCartesian(theta, osg::PI_2f, 1.);
pos *= radius;
pos.z() = -height / 2.;
vertices->push_back(pos);
normals->push_back(-topNormal);
iVertex += 1;
}
// sides
int beginSide = iVertex;
for (int i = 0; i < subdiv; i++)
{
float theta = float(i) / float(subdiv) * osg::PI * 2.;
osg::Vec3 normal = sphereCoordToCartesian(theta, osg::PI_2f, 1.);
auto posTop = normal;
posTop *= radius;
auto posBot = posTop;
posTop.z() = height / 2.;
posBot.z() = -height / 2.;
vertices->push_back(posTop);
normals->push_back(normal);
iVertex += 1;
vertices->push_back(posBot);
normals->push_back(normal);
iVertex += 1;
}
// create triangles sides
for (int i = 0; i < subdiv; i++)
{
auto next_vert = (i + 1) % subdiv;
auto v1 = (beginSide + 2 * i);
auto v2 = (beginSide + 2 * i + 1);
auto v3 = (beginSide + 2 * next_vert);
auto v4 = (beginSide + 2 * next_vert + 1);
indices->push_back(v1);
indices->push_back(v2);
indices->push_back(v4);
indices->push_back(v4);
indices->push_back(v3);
indices->push_back(v1);
}
for (int i = 0; i < subdiv; i++)
{
auto next_vert = (i + 1) % subdiv;
auto top1 = (beginTop + i);
auto top2 = (beginTop + next_vert);
auto bot1 = (begin_bot + i);
auto bot2 = (begin_bot + next_vert);
indices->push_back(top2);
indices->push_back(centerTop);
indices->push_back(top1);
indices->push_back(bot1);
indices->push_back(centerBot);
indices->push_back(bot2);
}
geom.setVertexArray(vertices);
geom.setNormalArray(normals, osg::Array::BIND_PER_VERTEX);
geom.addPrimitiveSet(indices);
}
static int getIndexBufferReadFromFrame(const unsigned int& nFrame)
{
return nFrame % 2;
}
static int getIndexBufferWriteFromFrame(const unsigned int& nFrame)
{
return (nFrame + 1) % 2;
}
namespace Debug
{
static void makeLineInstance(osg::Geometry& lines)
{
auto vertices = new osg::Vec3Array;
auto color = new osg::Vec3Array;
lines.setDataVariance(osg::Object::STATIC);
lines.setUseVertexBufferObjects(true);
lines.setUseDisplayList(false);
lines.setCullingActive(false);
lines.setVertexArray(vertices);
lines.setNormalArray(color, osg::Array::BIND_PER_VERTEX);
lines.addPrimitiveSet(new osg::DrawArrays(osg::PrimitiveSet::LINES, 0, vertices->size()));
}
DebugCustomDraw::DebugCustomDraw()
{
mLinesToDraw = new osg::Geometry();
makeLineInstance(*mLinesToDraw);
}
DebugCustomDraw::DebugCustomDraw(const DebugCustomDraw& copy, const osg::CopyOp& copyop)
: Drawable(copy, copyop)
, mShapesToDraw(copy.mShapesToDraw)
, mLinesToDraw(copy.mLinesToDraw)
, mCubeGeometry(copy.mCubeGeometry)
, mCylinderGeometry(copy.mCylinderGeometry)
, mWireCubeGeometry(copy.mWireCubeGeometry)
{
}
void DebugCustomDraw::drawImplementation(osg::RenderInfo& renderInfo) const
{
auto state = renderInfo.getState();
osg::GLExtensions* ext = osg::GLExtensions::Get(state->getContextID(), true);
const osg::StateSet* stateSet = getStateSet();
const osg::Program::PerContextProgram& pcp = *state->getLastAppliedProgramObject();
auto transLocation = pcp.getUniformLocation(stateSet->getUniform("trans")->getNameID());
auto colLocation = pcp.getUniformLocation(stateSet->getUniform("color")->getNameID());
auto scaleLocation = pcp.getUniformLocation(stateSet->getUniform("scale")->getNameID());
auto normalAsColorLocation = pcp.getUniformLocation(stateSet->getUniform("useNormalAsColor")->getNameID());
auto drawPrimitive = [&](const osg::Drawable* primitive, const osg::Vec3f& pos, const osg::Vec3f& color,
const osg::Vec3f& scale, const bool normalAsColor) {
ext->glUniform3f(transLocation, pos.x(), pos.y(), pos.z());
ext->glUniform3f(colLocation, color.x(), color.y(), color.z());
ext->glUniform3f(scaleLocation, scale.x(), scale.y(), scale.z());
ext->glUniform1i(normalAsColorLocation, normalAsColor);
primitive->drawImplementation(renderInfo);
};
drawPrimitive(mLinesToDraw, { 0.f, 0.f, 0.f }, { 1.f, 1.f, 1.f }, { 1.f, 1.f, 1.f }, true);
for (const auto& shapeToDraw : mShapesToDraw)
{
const osg::Geometry* geometry = nullptr;
switch (shapeToDraw.mDrawShape)
{
case DrawShape::Cube:
geometry = mCubeGeometry;
break;
case DrawShape::Cylinder:
geometry = mCylinderGeometry;
break;
case DrawShape::WireCube:
geometry = mWireCubeGeometry;
break;
}
drawPrimitive(geometry, shapeToDraw.mPosition, shapeToDraw.mColor, shapeToDraw.mDims, false);
}
mShapesToDraw.clear();
static_cast<osg::Vec3Array*>(mLinesToDraw->getVertexArray())->clear();
static_cast<osg::Vec3Array*>(mLinesToDraw->getNormalArray())->clear();
static_cast<osg::DrawArrays*>(mLinesToDraw->getPrimitiveSet(0))->setCount(0);
pcp.resetAppliedUniforms();
}
}
Debug::DebugDrawer::DebugDrawer(const DebugDrawer& copy, const osg::CopyOp& copyop)
: Node(copy, copyop)
, mCurrentFrame(copy.mCurrentFrame)
, mCustomDebugDrawer(copy.mCustomDebugDrawer)
{
}
Debug::DebugDrawer::DebugDrawer(Shader::ShaderManager& shaderManager)
{
auto program = shaderManager.getProgram("debug");
setCullingActive(false);
osg::StateSet* stateset = getOrCreateStateSet();
stateset->addUniform(new osg::Uniform("color", osg::Vec3f(1., 1., 1.)));
stateset->addUniform(new osg::Uniform("trans", osg::Vec3f(0., 0., 0.)));
stateset->addUniform(new osg::Uniform("scale", osg::Vec3f(1., 1., 1.)));
stateset->addUniform(new osg::Uniform("useNormalAsColor", false));
stateset->addUniform(new osg::Uniform("useAdvancedShader", true));
stateset->setAttributeAndModes(program, osg::StateAttribute::ON);
stateset->setMode(GL_DEPTH_TEST, GL_TRUE);
stateset->setMode(GL_CULL_FACE, GL_TRUE);
auto cubeGeometry = new osg::Geometry;
cubeGeometry->setSupportsDisplayList(false);
cubeGeometry->setUseVertexBufferObjects(true);
generateCube(*cubeGeometry, 1.);
auto cylinderGeom = new osg::Geometry;
cylinderGeom->setSupportsDisplayList(false);
cylinderGeom->setUseVertexBufferObjects(true);
generateCylinder(*cylinderGeom, .5, 1., 20);
auto wireCube = new osg::Geometry;
wireCube->setSupportsDisplayList(false);
wireCube->setUseVertexBufferObjects(true);
generateWireCube(*wireCube, 1.);
for (std::size_t i = 0; i < mCustomDebugDrawer.size(); i++)
{
mCustomDebugDrawer[i] = new DebugCustomDraw();
mCustomDebugDrawer[i]->setStateSet(stateset);
mCustomDebugDrawer[i]->mWireCubeGeometry = wireCube;
mCustomDebugDrawer[i]->mCubeGeometry = cubeGeometry;
mCustomDebugDrawer[i]->mCylinderGeometry = cylinderGeom;
}
}
void Debug::DebugDrawer::traverse(osg::NodeVisitor& nv)
{
mCurrentFrame = nv.getTraversalNumber();
mCustomDebugDrawer[getIndexBufferReadFromFrame(mCurrentFrame)]->accept(nv);
}
void Debug::DebugDrawer::drawCube(osg::Vec3f mPosition, osg::Vec3f mDims, osg::Vec3f mColor)
{
mCustomDebugDrawer[getIndexBufferWriteFromFrame(mCurrentFrame)]->mShapesToDraw.push_back(
{ mPosition, mDims, mColor, DrawShape::Cube });
}
void Debug::DebugDrawer::drawCubeMinMax(osg::Vec3f min, osg::Vec3f max, osg::Vec3f color)
{
osg::Vec3 dims = max - min;
osg::Vec3 pos = min + dims * 0.5f;
drawCube(pos, dims, color);
}
void Debug::DebugDrawer::addDrawCall(const DrawCall& draw)
{
mCustomDebugDrawer[getIndexBufferWriteFromFrame(mCurrentFrame)]->mShapesToDraw.push_back(draw);
}
void Debug::DebugDrawer::addLine(const osg::Vec3& start, const osg::Vec3& end, const osg::Vec3 color)
{
const int indexWrite = getIndexBufferWriteFromFrame(mCurrentFrame);
const auto& lines = mCustomDebugDrawer[indexWrite]->mLinesToDraw;
auto vertices = static_cast<osg::Vec3Array*>(lines->getVertexArray());
auto colors = static_cast<osg::Vec3Array*>(lines->getNormalArray());
auto primitive = static_cast<osg::DrawArrays*>(lines->getPrimitiveSet(0));
vertices->push_back(start);
vertices->push_back(end);
vertices->dirty();
colors->push_back(color);
colors->push_back(color);
colors->dirty();
primitive->setCount(vertices->size());
}
| 14,072
|
C++
|
.cpp
| 349
| 33.295129
| 119
| 0.626856
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,842
|
gldebug.cpp
|
OpenMW_openmw/components/debug/gldebug.cpp
|
// This file is based heavily on code from
// https://github.com/ThermalPixel/osgdemos/blob/master/osgdebug/EnableGLDebugOperation.cpp The original licence is
// included below:
/*
Copyright (c) 2014, Andreas Klein
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
The views and conclusions contained in the software and documentation are those
of the authors and should not be interpreted as representing official policies,
either expressed or implied, of the FreeBSD Project.
*/
#include "gldebug.hpp"
#include <cstdlib>
#include <memory>
#include <components/debug/debuglog.hpp>
// OpenGL constants not provided by OSG:
#include <SDL_opengl_glext.h>
namespace Debug
{
void GL_APIENTRY debugCallback(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
const GLchar* message, const void* userParam)
{
#ifdef GL_DEBUG_OUTPUT
std::string srcStr;
switch (source)
{
case GL_DEBUG_SOURCE_API:
srcStr = "API";
break;
case GL_DEBUG_SOURCE_WINDOW_SYSTEM:
srcStr = "WINDOW_SYSTEM";
break;
case GL_DEBUG_SOURCE_SHADER_COMPILER:
srcStr = "SHADER_COMPILER";
break;
case GL_DEBUG_SOURCE_THIRD_PARTY:
srcStr = "THIRD_PARTY";
break;
case GL_DEBUG_SOURCE_APPLICATION:
srcStr = "APPLICATION";
break;
case GL_DEBUG_SOURCE_OTHER:
srcStr = "OTHER";
break;
default:
srcStr = "UNDEFINED";
break;
}
std::string typeStr;
Level logSeverity = Warning;
switch (type)
{
case GL_DEBUG_TYPE_ERROR:
typeStr = "ERROR";
logSeverity = Error;
break;
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
typeStr = "DEPRECATED_BEHAVIOR";
logSeverity = Warning;
break;
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
typeStr = "UNDEFINED_BEHAVIOR";
logSeverity = Warning;
break;
case GL_DEBUG_TYPE_PORTABILITY:
typeStr = "PORTABILITY";
logSeverity = Debug;
break;
case GL_DEBUG_TYPE_PERFORMANCE:
typeStr = "PERFORMANCE";
logSeverity = Debug;
break;
case GL_DEBUG_TYPE_OTHER:
typeStr = "OTHER";
logSeverity = Debug;
break;
default:
typeStr = "UNDEFINED";
break;
}
Log(logSeverity) << "OpenGL " << typeStr << " [" << srcStr << "]: " << message;
#endif
}
class PushDebugGroup
{
public:
static std::unique_ptr<PushDebugGroup> sInstance;
void(GL_APIENTRY* glPushDebugGroup)(GLenum source, GLuint id, GLsizei length, const GLchar* message);
void(GL_APIENTRY* glPopDebugGroup)(void);
bool valid() { return glPushDebugGroup && glPopDebugGroup; }
};
std::unique_ptr<PushDebugGroup> PushDebugGroup::sInstance{ std::make_unique<PushDebugGroup>() };
EnableGLDebugOperation::EnableGLDebugOperation()
: osg::GraphicsOperation("EnableGLDebugOperation", false)
{
}
void EnableGLDebugOperation::operator()(osg::GraphicsContext* graphicsContext)
{
#ifdef GL_DEBUG_OUTPUT
OpenThreads::ScopedLock<OpenThreads::Mutex> lock(mMutex);
unsigned int contextID = graphicsContext->getState()->getContextID();
typedef void(GL_APIENTRY * DEBUGPROC)(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length,
const GLchar* message, const void* userParam);
typedef void(GL_APIENTRY * GLDebugMessageControlFunction)(
GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint* ids, GLboolean enabled);
typedef void(GL_APIENTRY * GLDebugMessageCallbackFunction)(DEBUGPROC, const void* userParam);
GLDebugMessageControlFunction glDebugMessageControl = nullptr;
GLDebugMessageCallbackFunction glDebugMessageCallback = nullptr;
if (osg::isGLExtensionSupported(contextID, "GL_KHR_debug"))
{
osg::setGLExtensionFuncPtr(glDebugMessageCallback, "glDebugMessageCallback");
osg::setGLExtensionFuncPtr(glDebugMessageControl, "glDebugMessageControl");
osg::setGLExtensionFuncPtr(PushDebugGroup::sInstance->glPushDebugGroup, "glPushDebugGroup");
osg::setGLExtensionFuncPtr(PushDebugGroup::sInstance->glPopDebugGroup, "glPopDebugGroup");
}
else if (osg::isGLExtensionSupported(contextID, "GL_ARB_debug_output"))
{
osg::setGLExtensionFuncPtr(glDebugMessageCallback, "glDebugMessageCallbackARB");
osg::setGLExtensionFuncPtr(glDebugMessageControl, "glDebugMessageControlARB");
}
else if (osg::isGLExtensionSupported(contextID, "GL_AMD_debug_output"))
{
osg::setGLExtensionFuncPtr(glDebugMessageCallback, "glDebugMessageCallbackAMD");
osg::setGLExtensionFuncPtr(glDebugMessageControl, "glDebugMessageControlAMD");
}
if (glDebugMessageCallback && glDebugMessageControl)
{
glEnable(GL_DEBUG_OUTPUT);
glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_ERROR, GL_DEBUG_SEVERITY_MEDIUM, 0, nullptr, true);
glDebugMessageCallback(debugCallback, nullptr);
Log(Info) << "OpenGL debug callback attached.";
}
else
#endif
Log(Error) << "Unable to attach OpenGL debug callback.";
}
bool shouldDebugOpenGL()
{
const char* env = std::getenv("OPENMW_DEBUG_OPENGL");
if (!env)
return false;
std::string str(env);
if (str.length() == 0)
return true;
return str.find("OFF") == std::string::npos && str.find('0') == std::string::npos
&& str.find("NO") == std::string::npos;
}
DebugGroup::DebugGroup(const std::string& message, GLuint id)
#ifdef GL_DEBUG_OUTPUT
: mSource(GL_DEBUG_SOURCE_APPLICATION)
#else
: mSource(0x824A)
#endif
, mId(id)
, mMessage(message)
{
}
DebugGroup::DebugGroup(const DebugGroup& debugGroup, const osg::CopyOp& copyop)
: osg::StateAttribute(debugGroup, copyop)
, mSource(debugGroup.mSource)
, mId(debugGroup.mId)
, mMessage(debugGroup.mMessage)
{
}
void DebugGroup::apply(osg::State& state) const
{
if (!PushDebugGroup::sInstance->valid())
{
Log(Error) << "OpenGL debug groups not supported on this system, or OPENMW_DEBUG_OPENGL environment "
"variable not set.";
return;
}
auto& attributeVec = state.getAttributeVec(this);
auto& lastAppliedStack = sLastAppliedStack[state.getContextID()];
size_t firstNonMatch = 0;
while (firstNonMatch < lastAppliedStack.size()
&& ((firstNonMatch < attributeVec.size()
&& lastAppliedStack[firstNonMatch] == attributeVec[firstNonMatch].first)
|| lastAppliedStack[firstNonMatch] == this))
firstNonMatch++;
for (size_t i = lastAppliedStack.size(); i > firstNonMatch; --i)
lastAppliedStack[i - 1]->pop(state);
lastAppliedStack.resize(firstNonMatch);
lastAppliedStack.reserve(attributeVec.size());
for (size_t i = firstNonMatch; i < attributeVec.size(); ++i)
{
const DebugGroup* group = static_cast<const DebugGroup*>(attributeVec[i].first);
group->push(state);
lastAppliedStack.push_back(group);
}
if (lastAppliedStack.empty() || !(lastAppliedStack.back() == this))
{
push(state);
lastAppliedStack.push_back(this);
}
}
int DebugGroup::compare(const StateAttribute& sa) const
{
COMPARE_StateAttribute_Types(DebugGroup, sa);
COMPARE_StateAttribute_Parameter(mSource);
COMPARE_StateAttribute_Parameter(mId);
COMPARE_StateAttribute_Parameter(mMessage);
return 0;
}
void DebugGroup::releaseGLObjects(osg::State* state) const
{
if (state)
sLastAppliedStack.erase(state->getContextID());
else
sLastAppliedStack.clear();
}
bool DebugGroup::isValid() const
{
return mSource || mId || mMessage.length();
}
void DebugGroup::push(osg::State& state) const
{
if (isValid())
PushDebugGroup::sInstance->glPushDebugGroup(mSource, mId, mMessage.size(), mMessage.c_str());
}
void DebugGroup::pop(osg::State& state) const
{
if (isValid())
PushDebugGroup::sInstance->glPopDebugGroup();
}
std::map<unsigned int, std::vector<const DebugGroup*>> DebugGroup::sLastAppliedStack{};
}
| 10,305
|
C++
|
.cpp
| 243
| 33.300412
| 117
| 0.647534
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,843
|
debuglog.cpp
|
OpenMW_openmw/components/debug/debuglog.cpp
|
#include "debuglog.hpp"
#include <mutex>
#include <components/files/conversion.hpp>
#include <components/misc/strings/conversion.hpp>
static std::mutex sLock;
Debug::Level Log::sMinDebugLevel = Debug::All;
bool Log::sWriteLevel = false;
Log::Log(Debug::Level level)
: mShouldLog(level <= sMinDebugLevel)
{
// No need to hold the lock if there will be no logging anyway
if (!mShouldLog)
return;
// Locks a global lock while the object is alive
sLock.lock();
if (!sWriteLevel)
return;
std::cout << static_cast<unsigned char>(level);
}
Log::~Log()
{
if (!mShouldLog)
return;
std::cout << std::endl;
sLock.unlock();
}
Log& Log::operator<<(const std::filesystem::path& rhs)
{
if (mShouldLog)
std::cout << Files::pathToUnicodeString(rhs);
return *this;
}
Log& Log::operator<<(const std::u8string& rhs)
{
if (mShouldLog)
std::cout << Misc::StringUtils::u8StringToString(rhs);
return *this;
}
Log& Log::operator<<(const std::u8string_view rhs)
{
if (mShouldLog)
std::cout << Misc::StringUtils::u8StringToString(rhs);
return *this;
}
Log& Log::operator<<(const char8_t* rhs)
{
if (mShouldLog)
std::cout << Misc::StringUtils::u8StringToString(rhs);
return *this;
}
| 1,301
|
C++
|
.cpp
| 50
| 22.1
| 66
| 0.671533
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,844
|
debugging.cpp
|
OpenMW_openmw/components/debug/debugging.cpp
|
#include "debugging.hpp"
#include <chrono>
#include <deque>
#include <fstream>
#include <iostream>
#include <memory>
#ifdef _MSC_VER
// TODO: why is this necessary? this has /external:I
#pragma warning(push)
#pragma warning(disable : 4702)
#endif
#include <boost/iostreams/stream.hpp>
#ifdef _MSC_VER
#pragma warning(pop)
#endif
#include <components/crashcatcher/crashcatcher.hpp>
#include <components/files/conversion.hpp>
#include <components/misc/strings/conversion.hpp>
#include <components/misc/strings/lower.hpp>
#ifdef _WIN32
#include <components/crashcatcher/windows_crashcatcher.hpp>
#include <components/files/conversion.hpp>
#include <components/misc/windows.hpp>
#include <Knownfolders.h>
#pragma push_macro("FAR")
#pragma push_macro("NEAR")
#undef FAR
#define FAR
#undef NEAR
#define NEAR
#include <Shlobj.h>
#pragma pop_macro("NEAR")
#pragma pop_macro("FAR")
#endif
#include <SDL_messagebox.h>
namespace Debug
{
#ifdef _WIN32
bool isRedirected(DWORD nStdHandle)
{
DWORD fileType = GetFileType(GetStdHandle(nStdHandle));
return (fileType == FILE_TYPE_DISK) || (fileType == FILE_TYPE_PIPE);
}
bool attachParentConsole()
{
if (GetConsoleWindow() != nullptr)
return true;
bool inRedirected = isRedirected(STD_INPUT_HANDLE);
bool outRedirected = isRedirected(STD_OUTPUT_HANDLE);
bool errRedirected = isRedirected(STD_ERROR_HANDLE);
// Note: Do not spend three days reinvestigating this PowerShell bug thinking its our bug.
// https://gitlab.com/OpenMW/openmw/-/merge_requests/408#note_447467393
// The handles look valid, but GetFinalPathNameByHandleA can't tell what files they go to and writing to them
// doesn't work.
if (AttachConsole(ATTACH_PARENT_PROCESS))
{
fflush(stdout);
fflush(stderr);
std::cout.flush();
std::cerr.flush();
// this looks dubious but is really the right way
if (!inRedirected)
{
_wfreopen(L"CON", L"r", stdin);
freopen("CON", "r", stdin);
std::cin.clear();
}
if (!outRedirected)
{
_wfreopen(L"CON", L"w", stdout);
freopen("CON", "w", stdout);
std::cout.clear();
}
if (!errRedirected)
{
_wfreopen(L"CON", L"w", stderr);
freopen("CON", "w", stderr);
std::cerr.clear();
}
return true;
}
return false;
}
#endif
static LogListener logListener;
void setLogListener(LogListener listener)
{
logListener = std::move(listener);
}
class DebugOutputBase : public boost::iostreams::sink
{
public:
virtual std::streamsize write(const char* str, std::streamsize size)
{
if (size <= 0)
return size;
std::string_view msg{ str, static_cast<size_t>(size) };
// Skip debug level marker
Level level = All;
if (Log::sWriteLevel)
{
level = getLevelMarker(msg[0]);
msg = msg.substr(1);
}
char prefix[32];
std::size_t prefixSize;
{
prefix[0] = '[';
const auto now = std::chrono::system_clock::now();
const auto time = std::chrono::system_clock::to_time_t(now);
tm time_info{};
#ifdef _WIN32
(void)localtime_s(&time_info, &time);
#else
(void)localtime_r(&time, &time_info);
#endif
prefixSize = std::strftime(prefix + 1, sizeof(prefix) - 1, "%T", &time_info) + 1;
char levelLetter = " EWIVD*"[int(level)];
const auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();
prefixSize += snprintf(prefix + prefixSize, sizeof(prefix) - prefixSize, ".%03u %c] ",
static_cast<unsigned>(ms % 1000), levelLetter);
}
while (!msg.empty())
{
if (msg[0] == 0)
break;
size_t lineSize = 1;
while (lineSize < msg.size() && msg[lineSize - 1] != '\n')
lineSize++;
writeImpl(prefix, prefixSize, level);
writeImpl(msg.data(), lineSize, level);
if (logListener)
logListener(level, std::string_view(prefix, prefixSize), std::string_view(msg.data(), lineSize));
msg = msg.substr(lineSize);
}
return size;
}
virtual ~DebugOutputBase() = default;
protected:
static Level getLevelMarker(char marker)
{
if (0 <= marker && static_cast<unsigned>(marker) < static_cast<unsigned>(All))
return static_cast<Level>(marker);
return All;
}
virtual std::streamsize writeImpl(const char* str, std::streamsize size, Level debugLevel)
{
return size;
}
};
#if defined _WIN32 && defined _DEBUG
class DebugOutput : public DebugOutputBase
{
public:
std::streamsize writeImpl(const char* str, std::streamsize size, Level debugLevel)
{
// Make a copy for null termination
std::string tmp(str, static_cast<unsigned int>(size));
// Write string to Visual Studio Debug output
OutputDebugString(tmp.c_str());
return size;
}
virtual ~DebugOutput() = default;
};
#else
namespace
{
struct Record
{
std::string mValue;
Level mLevel;
};
std::deque<Record> globalBuffer;
Color getColor(Level level)
{
switch (level)
{
case Error:
return Red;
case Warning:
return Yellow;
case Info:
return Reset;
case Verbose:
return DarkGray;
case Debug:
return DarkGray;
case All:
return Reset;
}
return Reset;
}
bool useColoredOutput()
{
#if defined(_WIN32)
if (std::getenv("NO_COLOR") != nullptr)
return false;
DWORD mode;
if (GetConsoleMode(GetStdHandle(STD_ERROR_HANDLE), &mode) && mode & ENABLE_VIRTUAL_TERMINAL_PROCESSING)
return true;
// some console emulators may not use the Win32 API, so try the Unixy approach
return std::getenv("TERM") != nullptr && GetFileType(GetStdHandle(STD_ERROR_HANDLE)) == FILE_TYPE_CHAR;
#else
return std::getenv("TERM") != nullptr && std::getenv("NO_COLOR") == nullptr && isatty(fileno(stderr));
#endif
}
class Identity
{
public:
explicit Identity(std::ostream& stream)
: mStream(stream)
{
}
void write(const char* str, std::streamsize size, Level /*level*/)
{
mStream.write(str, size);
mStream.flush();
}
private:
std::ostream& mStream;
};
class Coloured
{
public:
explicit Coloured(std::ostream& stream)
: mStream(stream)
// TODO: check which stream is stderr?
, mUseColor(useColoredOutput())
{
}
void write(const char* str, std::streamsize size, Level level)
{
if (mUseColor)
mStream << "\033[0;" << getColor(level) << 'm';
mStream.write(str, size);
if (mUseColor)
mStream << "\033[0;" << Reset << 'm';
mStream.flush();
}
private:
std::ostream& mStream;
bool mUseColor;
};
class Buffer
{
public:
explicit Buffer(std::size_t capacity, std::deque<Record>& buffer)
: mCapacity(capacity)
, mBuffer(buffer)
{
}
void write(const char* str, std::streamsize size, Level debugLevel)
{
while (mBuffer.size() >= mCapacity)
mBuffer.pop_front();
mBuffer.push_back(Record{ std::string(str, size), debugLevel });
}
private:
std::size_t mCapacity;
std::deque<Record>& mBuffer;
};
template <class First, class Second>
class Tee : public DebugOutputBase
{
public:
explicit Tee(First first, Second second)
: mFirst(first)
, mSecond(second)
{
}
std::streamsize writeImpl(const char* str, std::streamsize size, Level debugLevel) override
{
mFirst.write(str, size, debugLevel);
mSecond.write(str, size, debugLevel);
return size;
}
private:
First mFirst;
Second mSecond;
};
}
#endif
static std::unique_ptr<std::ostream> rawStdout = nullptr;
static std::unique_ptr<std::ostream> rawStderr = nullptr;
static std::unique_ptr<std::mutex> rawStderrMutex = nullptr;
static std::ofstream logfile;
#if defined(_WIN32) && defined(_DEBUG)
static boost::iostreams::stream_buffer<DebugOutput> sb;
#else
static boost::iostreams::stream_buffer<Tee<Identity, Coloured>> standardOut;
static boost::iostreams::stream_buffer<Tee<Identity, Coloured>> standardErr;
static boost::iostreams::stream_buffer<Tee<Buffer, Coloured>> bufferedOut;
static boost::iostreams::stream_buffer<Tee<Buffer, Coloured>> bufferedErr;
#endif
std::ostream& getRawStdout()
{
return rawStdout ? *rawStdout : std::cout;
}
std::ostream& getRawStderr()
{
return rawStderr ? *rawStderr : std::cerr;
}
Misc::Locked<std::ostream&> getLockedRawStderr()
{
return Misc::Locked<std::ostream&>(*rawStderrMutex, getRawStderr());
}
Level getDebugLevel()
{
if (const char* env = getenv("OPENMW_DEBUG_LEVEL"))
{
const std::string_view value(env);
if (value == "ERROR")
return Error;
if (value == "WARNING")
return Warning;
if (value == "INFO")
return Info;
if (value == "VERBOSE")
return Verbose;
if (value == "DEBUG")
return Debug;
}
return Verbose;
}
void setupLogging(const std::filesystem::path& logDir, std::string_view appName)
{
Log::sMinDebugLevel = getDebugLevel();
Log::sWriteLevel = true;
#if !(defined(_WIN32) && defined(_DEBUG))
const std::string logName = Misc::StringUtils::lowerCase(appName) + ".log";
logfile.open(logDir / logName, std::ios::out);
Identity log(logfile);
for (const Record& v : globalBuffer)
log.write(v.mValue.data(), v.mValue.size(), v.mLevel);
globalBuffer.clear();
standardOut.open(Tee(log, Coloured(*rawStdout)));
standardErr.open(Tee(log, Coloured(*rawStderr)));
std::cout.rdbuf(&standardOut);
std::cerr.rdbuf(&standardErr);
#endif
#ifdef _WIN32
if (Crash::CrashCatcher::instance())
{
Crash::CrashCatcher::instance()->updateDumpPath(logDir);
}
#endif
}
int wrapApplication(
int (*innerApplication)(int argc, char* argv[]), int argc, char* argv[], std::string_view appName)
{
#if defined _WIN32
(void)attachParentConsole();
#endif
rawStdout = std::make_unique<std::ostream>(std::cout.rdbuf());
rawStderr = std::make_unique<std::ostream>(std::cerr.rdbuf());
rawStderrMutex = std::make_unique<std::mutex>();
#if defined(_WIN32) && defined(_DEBUG)
// Redirect cout and cerr to VS debug output when running in debug mode
sb.open(DebugOutput());
std::cout.rdbuf(&sb);
std::cerr.rdbuf(&sb);
#else
constexpr std::size_t bufferCapacity = 1024;
bufferedOut.open(Tee(Buffer(bufferCapacity, globalBuffer), Coloured(*rawStdout)));
bufferedErr.open(Tee(Buffer(bufferCapacity, globalBuffer), Coloured(*rawStderr)));
std::cout.rdbuf(&bufferedOut);
std::cerr.rdbuf(&bufferedErr);
#endif
int ret = 0;
try
{
if (const auto env = std::getenv("OPENMW_DISABLE_CRASH_CATCHER");
env == nullptr || Misc::StringUtils::toNumeric<int>(env, 0) == 0)
{
#if defined(_WIN32)
const std::string crashDumpName = Misc::StringUtils::lowerCase(appName) + "-crash.dmp";
const std::string freezeDumpName = Misc::StringUtils::lowerCase(appName) + "-freeze.dmp";
std::filesystem::path dumpDirectory = std::filesystem::temp_directory_path();
PWSTR userProfile = nullptr;
if (SUCCEEDED(SHGetKnownFolderPath(FOLDERID_Profile, 0, nullptr, &userProfile)))
{
dumpDirectory = userProfile;
}
CoTaskMemFree(userProfile);
Crash::CrashCatcher crashy(argc, argv, dumpDirectory, crashDumpName, freezeDumpName);
#else
const std::string crashLogName = Misc::StringUtils::lowerCase(appName) + "-crash.log";
// install the crash handler as soon as possible.
crashCatcherInstall(argc, argv, std::filesystem::temp_directory_path() / crashLogName);
#endif
ret = innerApplication(argc, argv);
}
else
ret = innerApplication(argc, argv);
}
catch (const std::exception& e)
{
#if (defined(__APPLE__) || defined(__linux) || defined(__unix) || defined(__posix))
if (!isatty(fileno(stdin)))
#endif
SDL_ShowSimpleMessageBox(0, (std::string(appName) + ": Fatal error").c_str(), e.what(), nullptr);
Log(Debug::Error) << "Fatal error: " << e.what();
ret = 1;
}
// Restore cout and cerr
std::cout.rdbuf(rawStdout->rdbuf());
std::cerr.rdbuf(rawStderr->rdbuf());
Log::sMinDebugLevel = All;
Log::sWriteLevel = false;
return ret;
}
}
| 14,755
|
C++
|
.cpp
| 412
| 25.533981
| 118
| 0.556334
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,845
|
esmterrain.cpp
|
OpenMW_openmw/components/esm/esmterrain.cpp
|
#include "esmterrain.hpp"
#include <components/esm3/loadland.hpp>
#include <components/esm4/loadland.hpp>
#include <components/misc/constants.hpp>
namespace
{
constexpr std::uint16_t textures[ESM::LandRecordData::sLandNumTextures]{ 0 };
std::unique_ptr<const ESM::LandRecordData> loadData(const ESM::Land& land, int loadFlags)
{
std::unique_ptr<ESM::LandRecordData> result = std::make_unique<ESM::LandRecordData>();
land.loadData(loadFlags, *result);
return result;
}
}
namespace ESM
{
LandData::LandData() = default;
}
ESM::LandData::LandData(const ESM::Land& land, int loadFlags)
: mData(loadData(land, loadFlags))
, mLoadFlags(mData->mDataLoaded)
, mMinHeight(mData->mMinHeight)
, mMaxHeight(mData->mMaxHeight)
, mSize(Constants::CellSizeInUnits)
, mLandSize(ESM::Land::LAND_SIZE)
, mPlugin(land.getPlugin())
, mHeights(mData->mHeights)
, mNormals(mData->mNormals)
, mColors(mData->mColours)
, mTextures(mData->mTextures)
{
}
ESM::LandData::LandData(const ESM4::Land& land, int /*loadFlags*/)
: mLoadFlags(land.mDataTypes) // ESM4::Land is always fully loaded. TODO: implement lazy loading
, mHeightsData(ESM4::Land::sLandNumVerts)
, mMinHeight(std::numeric_limits<float>::max())
, mMaxHeight(std::numeric_limits<float>::lowest())
, mSize(Constants::ESM4CellSizeInUnits)
, mLandSize(ESM4::Land::sVertsPerSide)
, mNormals(land.mVertNorm)
, mColors(land.mVertColr)
, mTextures(textures)
{
float rowOffset = land.mHeightMap.heightOffset;
for (int y = 0; y < mLandSize; y++)
{
rowOffset += land.mHeightMap.gradientData[y * mLandSize];
const float heightY = rowOffset * ESM4::Land::sHeightScale;
mHeightsData[y * mLandSize] = heightY;
mMinHeight = std::min(mMinHeight, heightY);
mMaxHeight = std::max(mMaxHeight, heightY);
float colOffset = rowOffset;
for (int x = 1; x < mLandSize; x++)
{
colOffset += land.mHeightMap.gradientData[y * mLandSize + x];
const float heightX = colOffset * ESM4::Land::sHeightScale;
mMinHeight = std::min(mMinHeight, heightX);
mMaxHeight = std::max(mMaxHeight, heightX);
mHeightsData[x + y * mLandSize] = heightX;
}
}
mHeights = mHeightsData;
}
namespace ESM
{
LandData::~LandData() = default;
}
| 2,413
|
C++
|
.cpp
| 67
| 30.686567
| 100
| 0.676798
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,846
|
formid.cpp
|
OpenMW_openmw/components/esm/formid.cpp
|
#include "formid.hpp"
#include <charconv>
#include <cstring>
std::string ESM::FormId::toString(std::string_view prefix) const
{
std::string res;
res.resize(prefix.length() + 20);
std::memcpy(res.data(), prefix.data(), prefix.size());
char* buf = res.data() + prefix.size();
uint64_t value;
if (hasContentFile())
{
if ((mIndex & 0xff000000) != 0)
throw std::invalid_argument("Invalid FormId index value: " + std::to_string(mIndex));
value = mIndex | (static_cast<uint64_t>(mContentFile) << 24);
}
else
{
*(buf++) = '@';
value = mIndex | (static_cast<uint64_t>(-mContentFile - 1) << 32);
}
*(buf++) = '0';
*(buf++) = 'x';
const auto r = std::to_chars(buf, res.data() + res.size(), value, 16);
if (r.ec != std::errc())
throw std::system_error(std::make_error_code(r.ec), "ESM::FormId::toString failed");
res.resize(r.ptr - res.data());
return res;
}
uint32_t ESM::FormId::toUint32() const
{
if (isSet() && !hasContentFile())
throw std::runtime_error("Generated FormId can not be converted to 32bit format");
if (mContentFile > 0xfe)
throw std::runtime_error("FormId with mContentFile > 0xFE can not be converted to 32bit format");
return (mIndex & 0xffffff) | ((hasContentFile() ? mContentFile : 0xff) << 24);
}
| 1,360
|
C++
|
.cpp
| 37
| 31.675676
| 105
| 0.611364
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,847
|
esmbridge.cpp
|
OpenMW_openmw/components/esm/esmbridge.cpp
|
#include <components/esm/esmbridge.hpp>
#include <components/esm3/loadcell.hpp>
#include <components/esm4/loadcell.hpp>
namespace ESM
{
const ESM4::Cell& CellVariant::getEsm4() const
{
auto cell4 = std::get<const ESM4::Cell*>(mVariant);
return *cell4;
}
const ESM::Cell& CellVariant::getEsm3() const
{
auto cell = std::get<const ESM::Cell*>(mVariant);
return *cell;
}
}
| 428
|
C++
|
.cpp
| 16
| 22.125
| 59
| 0.658537
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,848
|
util.cpp
|
OpenMW_openmw/components/esm/util.cpp
|
#include "util.hpp"
#include <components/esm3/loadland.hpp>
#include <components/esm4/loadland.hpp>
osg::Vec2f ESM::indexToPosition(const ESM::ExteriorCellLocation& cellIndex, bool centre)
{
const int cellSize = ESM::getCellSize(cellIndex.mWorldspace);
float x = static_cast<float>(cellSize * cellIndex.mX);
float y = static_cast<float>(cellSize * cellIndex.mY);
if (centre)
{
x += cellSize / 2;
y += cellSize / 2;
}
return osg::Vec2f(x, y);
}
int ESM::getLandSize(ESM::RefId worldspaceId)
{
return isEsm4Ext(worldspaceId) ? ESM4::Land::sVertsPerSide : ESM::Land::LAND_SIZE;
}
| 631
|
C++
|
.cpp
| 19
| 29.368421
| 88
| 0.70132
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,849
|
common.cpp
|
OpenMW_openmw/components/esm/common.cpp
|
#include <cstdint>
#include <string>
namespace ESM
{
std::string printName(const std::uint32_t typeId)
{
unsigned char typeName[4];
typeName[0] = typeId & 0xff;
typeName[1] = (typeId >> 8) & 0xff;
typeName[2] = (typeId >> 16) & 0xff;
typeName[3] = (typeId >> 24) & 0xff;
return std::string((char*)typeName, 4);
}
}
| 377
|
C++
|
.cpp
| 14
| 21.5
| 53
| 0.576177
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,850
|
format.cpp
|
OpenMW_openmw/components/esm/format.cpp
|
#include "format.hpp"
#include <cstring>
#include <istream>
#include <stdexcept>
#include <string>
namespace ESM
{
namespace
{
bool isValidFormat(std::uint32_t value)
{
return value == static_cast<std::uint32_t>(Format::Tes3)
|| value == static_cast<std::uint32_t>(Format::Tes4);
}
Format toFormat(std::uint32_t value)
{
if (!isValidFormat(value))
throw std::runtime_error("Invalid format: " + std::to_string(value));
return static_cast<Format>(value);
}
}
Format readFormat(std::istream& stream)
{
std::uint32_t format = 0;
stream.read(reinterpret_cast<char*>(&format), sizeof(format));
if (stream.gcount() != sizeof(format))
throw std::runtime_error("Not enough bytes to read file header");
return toFormat(format);
}
Format parseFormat(std::string_view value)
{
if (value.size() != sizeof(std::uint32_t))
throw std::logic_error("Invalid format value: " + std::string(value));
std::uint32_t format;
std::memcpy(&format, value.data(), sizeof(std::uint32_t));
return toFormat(format);
}
}
| 1,234
|
C++
|
.cpp
| 38
| 25.026316
| 85
| 0.593619
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,851
|
generatedrefid.cpp
|
OpenMW_openmw/components/esm/generatedrefid.cpp
|
#include "generatedrefid.hpp"
#include "serializerefid.hpp"
#include <ostream>
namespace ESM
{
std::string GeneratedRefId::toString() const
{
std::string result;
result.resize(getHexIntegralSizeWith0x(mValue), '\0');
serializeHexIntegral(mValue, 0, result);
return result;
}
std::string GeneratedRefId::toDebugString() const
{
std::string result;
serializeRefIdValue(mValue, generatedRefIdPrefix, result);
return result;
}
std::ostream& operator<<(std::ostream& stream, GeneratedRefId value)
{
return stream << value.toDebugString();
}
}
| 643
|
C++
|
.cpp
| 23
| 22.391304
| 72
| 0.674797
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,852
|
esm3exteriorcellrefid.cpp
|
OpenMW_openmw/components/esm/esm3exteriorcellrefid.cpp
|
#include "esm3exteriorcellrefid.hpp"
#include "serializerefid.hpp"
#include <limits>
#include <ostream>
#include <sstream>
namespace ESM
{
std::string ESM3ExteriorCellRefId::toString() const
{
constexpr std::size_t separator = 1;
std::string result;
result.resize(separator + getDecIntegralCapacity(mX) + separator + getDecIntegralCapacity(mY), '\0');
result[0] = '#';
const std::size_t endX = serializeDecIntegral(mX, separator, result);
result[endX] = ' ';
const std::size_t endY = serializeDecIntegral(mY, endX + separator, result);
result.resize(endY);
return result;
}
std::string ESM3ExteriorCellRefId::toDebugString() const
{
constexpr std::size_t separator = 1;
std::string result;
serializeRefIdPrefix(
getDecIntegralCapacity(mX) + separator + getDecIntegralCapacity(mY), esm3ExteriorCellRefIdPrefix, result);
const std::size_t endX = serializeDecIntegral(mX, esm3ExteriorCellRefIdPrefix.size(), result);
result[endX] = ':';
const std::size_t endY = serializeDecIntegral(mY, endX + separator, result);
result.resize(endY);
return result;
}
std::ostream& operator<<(std::ostream& stream, ESM3ExteriorCellRefId value)
{
return stream << value.toDebugString();
}
}
| 1,367
|
C++
|
.cpp
| 36
| 31.527778
| 118
| 0.671439
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,853
|
stringrefid.cpp
|
OpenMW_openmw/components/esm/stringrefid.cpp
|
#include "stringrefid.hpp"
#include "serializerefid.hpp"
#include <charconv>
#include <iomanip>
#include <mutex>
#include <ostream>
#include <sstream>
#include <system_error>
#include <unordered_set>
#include "components/misc/guarded.hpp"
#include "components/misc/strings/algorithm.hpp"
#include "components/misc/utf8stream.hpp"
namespace ESM
{
namespace
{
using StringsSet = std::unordered_set<std::string, Misc::StringUtils::CiHash, Misc::StringUtils::CiEqual>;
const std::string emptyString;
Misc::ScopeGuarded<StringsSet>& getRefIds()
{
static Misc::ScopeGuarded<StringsSet> refIds;
return refIds;
}
Misc::NotNullPtr<const std::string> getOrInsertString(std::string_view id)
{
const auto locked = getRefIds().lock();
auto it = locked->find(id);
if (it == locked->end())
it = locked->emplace(id).first;
return &*it;
}
void addHex(unsigned char value, std::string& result)
{
const std::size_t size = 2 + getHexIntegralSize(value);
const std::size_t shift = result.size();
result.resize(shift + size);
result[shift] = '\\';
result[shift + 1] = 'x';
const auto [end, ec] = std::to_chars(result.data() + shift + 2, result.data() + result.size(), value, 16);
if (ec != std::errc())
throw std::system_error(std::make_error_code(ec));
}
}
StringRefId::StringRefId()
: mValue(&emptyString)
{
}
StringRefId::StringRefId(std::string_view value)
: mValue(getOrInsertString(value))
{
}
bool StringRefId::operator==(std::string_view rhs) const noexcept
{
return Misc::StringUtils::ciEqual(*mValue, rhs);
}
bool StringRefId::operator<(StringRefId rhs) const noexcept
{
return Misc::StringUtils::ciLess(*mValue, *rhs.mValue);
}
bool operator<(StringRefId lhs, std::string_view rhs) noexcept
{
return Misc::StringUtils::ciLess(*lhs.mValue, rhs);
}
bool operator<(std::string_view lhs, StringRefId rhs) noexcept
{
return Misc::StringUtils::ciLess(lhs, *rhs.mValue);
}
std::ostream& operator<<(std::ostream& stream, StringRefId value)
{
return stream << value.toDebugString();
}
std::string StringRefId::toDebugString() const
{
std::string result;
result.reserve(2 + mValue->size());
result.push_back('"');
const unsigned char* ptr = reinterpret_cast<const unsigned char*>(mValue->data());
const unsigned char* const end = reinterpret_cast<const unsigned char*>(mValue->data() + mValue->size());
while (ptr != end)
{
if (Utf8Stream::isAscii(*ptr))
{
if (std::isprint(*ptr) && *ptr != '\t' && *ptr != '\n' && *ptr != '\r')
result.push_back(*ptr);
else
addHex(*ptr, result);
++ptr;
continue;
}
const auto [octets, first] = Utf8Stream::getOctetCount(*ptr);
const auto [chr, next] = Utf8Stream::decode(ptr + 1, end, first, octets);
if (chr == Utf8Stream::sBadChar())
{
while (ptr != std::min(end, ptr + octets))
{
addHex(*ptr, result);
++ptr;
}
continue;
}
result.append(ptr, next);
ptr = next;
}
result.push_back('"');
return result;
}
bool StringRefId::startsWith(std::string_view prefix) const
{
return Misc::StringUtils::ciStartsWith(*mValue, prefix);
}
bool StringRefId::endsWith(std::string_view suffix) const
{
return Misc::StringUtils::ciEndsWith(*mValue, suffix);
}
bool StringRefId::contains(std::string_view subString) const
{
return Misc::StringUtils::ciFind(*mValue, subString) != std::string_view::npos;
}
std::optional<StringRefId> StringRefId::deserializeExisting(std::string_view value)
{
const auto locked = getRefIds().lock();
auto it = locked->find(value);
if (it == locked->end())
return {};
StringRefId id;
id.mValue = &*it;
return id;
}
}
| 4,443
|
C++
|
.cpp
| 129
| 25.697674
| 118
| 0.572061
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,854
|
attr.cpp
|
OpenMW_openmw/components/esm/attr.cpp
|
#include "attr.hpp"
#include <components/esm3/esmreader.hpp>
#include <components/esm3/esmwriter.hpp>
#include <stdexcept>
namespace ESM
{
const Attribute::AttributeID Attribute::Strength("Strength");
const Attribute::AttributeID Attribute::Intelligence("Intelligence");
const Attribute::AttributeID Attribute::Willpower("Willpower");
const Attribute::AttributeID Attribute::Agility("Agility");
const Attribute::AttributeID Attribute::Speed("Speed");
const Attribute::AttributeID Attribute::Endurance("Endurance");
const Attribute::AttributeID Attribute::Personality("Personality");
const Attribute::AttributeID Attribute::Luck("Luck");
static const RefId sAttributes[Attribute::Length] = {
Attribute::Strength,
Attribute::Intelligence,
Attribute::Willpower,
Attribute::Agility,
Attribute::Speed,
Attribute::Endurance,
Attribute::Personality,
Attribute::Luck,
};
RefId Attribute::indexToRefId(int index)
{
if (index < 0 || index >= Length)
return RefId();
return sAttributes[index];
}
int Attribute::refIdToIndex(RefId id)
{
for (int i = 0; i < Length; ++i)
{
if (sAttributes[i] == id)
return i;
}
return -1;
}
void Attribute::load(ESMReader& esm, bool& isDeleted)
{
throw std::runtime_error("Attribute loading not yet implemented");
}
void Attribute::save(ESMWriter& esm, bool isDeleted) const
{
throw std::runtime_error("Attribute saving not yet implemented");
}
}
| 1,631
|
C++
|
.cpp
| 48
| 27.479167
| 74
| 0.664127
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,855
|
refid.cpp
|
OpenMW_openmw/components/esm/refid.cpp
|
#include "refid.hpp"
#include "serializerefid.hpp"
#include "components/misc/strings/lower.hpp"
#include <charconv>
#include <ostream>
#include <sstream>
#include <stdexcept>
#include <system_error>
#include <variant>
namespace ESM
{
namespace
{
const std::string emptyString;
struct GetRefString
{
const std::string& operator()(EmptyRefId /*v*/) const { return emptyString; }
const std::string& operator()(StringRefId v) const { return v.getValue(); }
template <class T>
const std::string& operator()(const T& v) const
{
std::ostringstream stream;
stream << "RefId is not a string: " << v;
throw std::runtime_error(stream.str());
}
};
struct IsEqualToString
{
const std::string_view mRhs;
bool operator()(StringRefId v) const noexcept { return v == mRhs; }
template <class T>
bool operator()(const T& /*v*/) const noexcept
{
return false;
}
};
struct IsLessThanString
{
const std::string_view mRhs;
bool operator()(StringRefId v) const noexcept { return v < mRhs; }
template <class T>
bool operator()(const T& /*v*/) const noexcept
{
return false;
}
};
struct IsGreaterThanString
{
const std::string_view mLhs;
bool operator()(StringRefId v) const noexcept { return mLhs < v; }
template <class T>
bool operator()(const T& /*v*/) const noexcept
{
return true;
}
};
struct StartsWith
{
const std::string_view mPrefix;
bool operator()(StringRefId v) const { return v.startsWith(mPrefix); }
template <class T>
bool operator()(const T& /*v*/) const
{
return false;
}
};
struct EndsWith
{
const std::string_view mSuffix;
bool operator()(StringRefId v) const { return v.endsWith(mSuffix); }
template <class T>
bool operator()(const T& /*v*/) const
{
return false;
}
};
struct Contains
{
const std::string_view mSubString;
bool operator()(StringRefId v) const { return v.contains(mSubString); }
template <class T>
bool operator()(const T& /*v*/) const
{
return false;
}
};
struct SerializeText
{
std::string operator()(ESM::EmptyRefId /*v*/) const { return std::string(); }
std::string operator()(ESM::StringRefId v) const { return Misc::StringUtils::lowerCase(v.getValue()); }
std::string operator()(ESM::FormId v) const { return v.toString(formIdRefIdPrefix); }
template <class T>
std::string operator()(const T& v) const
{
return v.toDebugString();
}
};
}
bool RefId::operator==(std::string_view rhs) const
{
return std::visit(IsEqualToString{ rhs }, mValue);
}
bool operator<(RefId lhs, std::string_view rhs)
{
return std::visit(IsLessThanString{ rhs }, lhs.mValue);
}
bool operator<(std::string_view lhs, RefId rhs)
{
return std::visit(IsGreaterThanString{ lhs }, rhs.mValue);
}
RefId RefId::stringRefId(std::string_view value)
{
if (value.empty())
return RefId();
return RefId(StringRefId(value));
}
const std::string& RefId::getRefIdString() const
{
return std::visit(GetRefString{}, mValue);
}
std::string RefId::toString() const
{
return std::visit([](auto v) { return v.toString(); }, mValue);
}
std::string RefId::toDebugString() const
{
return std::visit(
[](auto v) {
if constexpr (std::is_same_v<decltype(v), FormId>)
return v.toString(formIdRefIdPrefix);
else
return v.toDebugString();
},
mValue);
}
bool RefId::startsWith(std::string_view prefix) const
{
return std::visit(StartsWith{ prefix }, mValue);
}
bool RefId::endsWith(std::string_view suffix) const
{
return std::visit(EndsWith{ suffix }, mValue);
}
bool RefId::contains(std::string_view subString) const
{
return std::visit(Contains{ subString }, mValue);
}
std::string RefId::serialize() const
{
std::string result(sizeof(mValue), '\0');
std::memcpy(result.data(), &mValue, sizeof(mValue));
return result;
}
ESM::RefId RefId::deserialize(std::string_view value)
{
if (value.size() != sizeof(ESM::RefId::mValue))
throw std::runtime_error("Invalid value size to deserialize: " + std::to_string(value.size()));
ESM::RefId result;
std::memcpy(&result.mValue, value.data(), sizeof(result.mValue));
return result;
}
std::string RefId::serializeText() const
{
return std::visit(SerializeText{}, mValue);
}
ESM::RefId RefId::deserializeText(std::string_view value)
{
if (value.empty())
return ESM::RefId();
if (value.starts_with(formIdRefIdPrefix))
{
uint64_t v = deserializeHexIntegral<uint64_t>(formIdRefIdPrefix.size(), value);
uint32_t index = static_cast<uint32_t>(v) & 0xffffff;
int contentFile = static_cast<int>(v >> 24);
return ESM::FormId{ index, contentFile };
}
if (value.starts_with(generatedRefIdPrefix))
return ESM::RefId::generated(deserializeHexIntegral<std::uint64_t>(generatedRefIdPrefix.size(), value));
if (value.starts_with(indexRefIdPrefix))
{
ESM::RecNameInts recordType{};
std::memcpy(&recordType, value.data() + indexRefIdPrefix.size(), sizeof(recordType));
return ESM::RefId::index(recordType,
deserializeHexIntegral<std::uint32_t>(indexRefIdPrefix.size() + sizeof(recordType) + 1, value));
}
if (value.starts_with(esm3ExteriorCellRefIdPrefix))
{
if (value.size() < esm3ExteriorCellRefIdPrefix.size() + 3)
throw std::runtime_error("Invalid ESM3ExteriorCellRefId format: not enough size");
const std::size_t separator = value.find(':', esm3ExteriorCellRefIdPrefix.size() + 1);
if (separator == std::string_view::npos)
throw std::runtime_error("Invalid ESM3ExteriorCellRefId format: coordinates separator is not found");
const std::int32_t x
= deserializeDecIntegral<std::int32_t>(esm3ExteriorCellRefIdPrefix.size(), separator, value);
const std::int32_t y = deserializeDecIntegral<std::int32_t>(separator + 1, value.size(), value);
return ESM::ESM3ExteriorCellRefId(x, y);
}
if (auto id = ESM::StringRefId::deserializeExisting(value))
return *id;
return {};
}
}
| 7,370
|
C++
|
.cpp
| 202
| 26.475248
| 117
| 0.566854
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,856
|
luascripts.cpp
|
OpenMW_openmw/components/esm/luascripts.cpp
|
#include "luascripts.hpp"
#include "components/esm3/esmreader.hpp"
#include "components/esm3/esmwriter.hpp"
#include <components/lua/serialization.hpp>
// List of all records, that are related to Lua.
//
// Records:
// LUAL - LuaScriptsCfg - list of all scripts (in content files)
// LUAM - MWLua::LuaManager (in saves)
//
// Subrecords:
// LUAF - LuaScriptCfg::mFlags and ESM::RecNameInts list
// LUAW - Simulation time and last generated RefNum
// LUAE - Start of MWLua::LocalEvent or MWLua::GlobalEvent (eventName)
// LUAS - VFS path to a Lua script
// LUAD - Serialized Lua variable
// LUAT - MWLua::ScriptsContainer::Timer
// LUAC - Name of a timer callback (string)
// LUAR - Attach script to a specific record (LuaScriptCfg::PerRecordCfg)
// LUAI - Attach script to a specific instance (LuaScriptCfg::PerRefCfg)
void ESM::saveLuaBinaryData(ESMWriter& esm, const std::string& data)
{
if (data.empty())
return;
esm.startSubRecord("LUAD");
esm.write(data.data(), data.size());
esm.endRecord("LUAD");
}
std::string ESM::loadLuaBinaryData(ESMReader& esm)
{
std::string data;
if (esm.isNextSub("LUAD"))
{
esm.getSubHeader();
data.resize(esm.getSubSize());
esm.getExact(data.data(), data.size());
}
return data;
}
static bool readBool(ESM::ESMReader& esm)
{
char c;
esm.getT<char>(c);
return c != 0;
}
void ESM::LuaScriptsCfg::load(ESMReader& esm)
{
while (esm.isNextSub("LUAS"))
{
mScripts.emplace_back();
ESM::LuaScriptCfg& script = mScripts.back();
script.mScriptPath = VFS::Path::Normalized(esm.getHString());
esm.getSubNameIs("LUAF");
esm.getSubHeader();
if (esm.getSubSize() < 4 || (esm.getSubSize() % 4 != 0))
esm.fail("Incorrect LUAF size");
esm.getT(script.mFlags);
script.mTypes.resize((esm.getSubSize() - 4) / 4);
for (uint32_t& type : script.mTypes)
esm.getT(type);
script.mInitializationData = loadLuaBinaryData(esm);
while (esm.isNextSub("LUAR"))
{
esm.getSubHeader();
script.mRecords.emplace_back();
ESM::LuaScriptCfg::PerRecordCfg& recordCfg = script.mRecords.back();
recordCfg.mAttach = readBool(esm);
recordCfg.mRecordId = esm.getRefId(esm.getSubSize() - 1);
recordCfg.mInitializationData = loadLuaBinaryData(esm);
}
while (esm.isNextSub("LUAI"))
{
esm.getSubHeader();
script.mRefs.emplace_back();
ESM::LuaScriptCfg::PerRefCfg& refCfg = script.mRefs.back();
refCfg.mAttach = readBool(esm);
esm.getT<uint32_t>(refCfg.mRefnumIndex);
esm.getT<int32_t>(refCfg.mRefnumContentFile);
refCfg.mInitializationData = loadLuaBinaryData(esm);
}
}
}
void ESM::LuaScriptsCfg::adjustRefNums(const ESMReader& esm)
{
auto adjustRefNumFn = [&esm](int contentFile) -> int {
if (contentFile == 0)
return esm.getIndex();
else if (contentFile > 0 && contentFile <= static_cast<int>(esm.getParentFileIndices().size()))
return esm.getParentFileIndices()[contentFile - 1];
else
throw std::runtime_error("Incorrect contentFile index");
};
lua_State* L = luaL_newstate();
LuaUtil::BasicSerializer serializer(adjustRefNumFn);
auto adjustLuaData = [&](std::string& data) {
if (data.empty())
return;
sol::object luaData = LuaUtil::deserialize(L, data, &serializer);
data = LuaUtil::serialize(luaData, &serializer);
};
for (LuaScriptCfg& script : mScripts)
{
adjustLuaData(script.mInitializationData);
for (LuaScriptCfg::PerRecordCfg& recordCfg : script.mRecords)
adjustLuaData(recordCfg.mInitializationData);
for (LuaScriptCfg::PerRefCfg& refCfg : script.mRefs)
{
adjustLuaData(refCfg.mInitializationData);
refCfg.mRefnumContentFile = adjustRefNumFn(refCfg.mRefnumContentFile);
}
}
lua_close(L);
}
void ESM::LuaScriptsCfg::save(ESMWriter& esm) const
{
for (const LuaScriptCfg& script : mScripts)
{
esm.writeHNString("LUAS", script.mScriptPath);
esm.startSubRecord("LUAF");
esm.writeT<uint32_t>(script.mFlags);
for (uint32_t type : script.mTypes)
esm.writeT<uint32_t>(type);
esm.endRecord("LUAF");
saveLuaBinaryData(esm, script.mInitializationData);
for (const LuaScriptCfg::PerRecordCfg& recordCfg : script.mRecords)
{
esm.startSubRecord("LUAR");
esm.writeT<char>(recordCfg.mAttach ? 1 : 0);
esm.writeHRefId(recordCfg.mRecordId);
esm.endRecord("LUAR");
saveLuaBinaryData(esm, recordCfg.mInitializationData);
}
for (const LuaScriptCfg::PerRefCfg& refCfg : script.mRefs)
{
esm.startSubRecord("LUAI");
esm.writeT<char>(refCfg.mAttach ? 1 : 0);
esm.writeT<uint32_t>(refCfg.mRefnumIndex);
esm.writeT<int32_t>(refCfg.mRefnumContentFile);
esm.endRecord("LUAI");
saveLuaBinaryData(esm, refCfg.mInitializationData);
}
}
}
void ESM::LuaScripts::load(ESMReader& esm)
{
while (esm.isNextSub("LUAS"))
{
VFS::Path::Normalized name(esm.getHString());
std::string data = loadLuaBinaryData(esm);
std::vector<LuaTimer> timers;
while (esm.isNextSub("LUAT"))
{
esm.getSubHeader();
LuaTimer timer;
esm.getT(timer.mType);
esm.getT(timer.mTime);
timer.mCallbackName = esm.getHNString("LUAC");
timer.mCallbackArgument = loadLuaBinaryData(esm);
timers.push_back(std::move(timer));
}
mScripts.push_back({ std::move(name), std::move(data), std::move(timers) });
}
}
void ESM::LuaScripts::save(ESMWriter& esm) const
{
for (const LuaScript& script : mScripts)
{
esm.writeHNString("LUAS", script.mScriptPath);
saveLuaBinaryData(esm, script.mData);
for (const LuaTimer& timer : script.mTimers)
{
esm.startSubRecord("LUAT");
esm.writeT(timer.mType);
esm.writeT(timer.mTime);
esm.endRecord("LUAT");
esm.writeHNString("LUAC", timer.mCallbackName);
if (!timer.mCallbackArgument.empty())
saveLuaBinaryData(esm, timer.mCallbackArgument);
}
}
}
| 6,567
|
C++
|
.cpp
| 181
| 28.801105
| 103
| 0.630711
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,857
|
indexrefid.cpp
|
OpenMW_openmw/components/esm/indexrefid.cpp
|
#include "indexrefid.hpp"
#include "serializerefid.hpp"
#include <ostream>
namespace ESM
{
std::string IndexRefId::toString() const
{
std::string result;
constexpr std::size_t separator = 1;
result.resize(sizeof(mRecordType) + separator + getHexIntegralSizeWith0x(mValue), '\0');
std::memcpy(result.data(), &mRecordType, sizeof(mRecordType));
result[sizeof(mRecordType)] = ':';
serializeHexIntegral(mValue, sizeof(mRecordType) + separator, result);
return result;
}
std::string IndexRefId::toDebugString() const
{
std::string result;
constexpr std::size_t separator = 1;
serializeRefIdPrefix(
sizeof(mRecordType) + separator + getHexIntegralSizeWith0x(mValue), indexRefIdPrefix, result);
std::memcpy(result.data() + indexRefIdPrefix.size(), &mRecordType, sizeof(mRecordType));
result[indexRefIdPrefix.size() + sizeof(mRecordType)] = ':';
serializeHexIntegral(mValue, indexRefIdPrefix.size() + sizeof(mRecordType) + separator, result);
return result;
}
std::ostream& operator<<(std::ostream& stream, IndexRefId value)
{
return stream << value.toDebugString();
}
}
| 1,236
|
C++
|
.cpp
| 31
| 33.290323
| 106
| 0.674167
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,858
|
myguidatamanager.cpp
|
OpenMW_openmw/components/myguiplatform/myguidatamanager.cpp
|
#include "myguidatamanager.hpp"
#include <stdexcept>
#include <string>
#include <MyGUI_DataFileStream.h>
#include <components/files/conversion.hpp>
#include <components/vfs/manager.hpp>
namespace
{
class DataStream final : public MyGUI::DataStream
{
public:
explicit DataStream(std::unique_ptr<std::istream>&& stream)
: MyGUI::DataStream(stream.get())
, mOwnedStream(std::move(stream))
{
}
private:
std::unique_ptr<std::istream> mOwnedStream;
};
}
namespace osgMyGUI
{
void DataManager::setResourcePath(const std::filesystem::path& path)
{
mResourcePath = path;
}
DataManager::DataManager(const std::string& resourcePath, const VFS::Manager* vfs)
: mResourcePath(resourcePath)
, mVfs(vfs)
{
}
MyGUI::IDataStream* DataManager::getData(const std::string& name) const
{
return new DataStream(mVfs->get(Files::pathToUnicodeString(mResourcePath / name)));
}
void DataManager::freeData(MyGUI::IDataStream* data)
{
delete data;
}
bool DataManager::isDataExist(const std::string& name) const
{
return mVfs->exists(Files::pathToUnicodeString(mResourcePath / name));
}
const MyGUI::VectorString& DataManager::getDataListNames(const std::string& pattern) const
{
throw std::runtime_error("DataManager::getDataListNames is not implemented - VFS is used");
}
std::string DataManager::getDataPath(const std::string& name) const
{
if (name.empty())
{
return Files::pathToUnicodeString(mResourcePath);
}
if (!isDataExist(name))
return {};
return Files::pathToUnicodeString(mResourcePath / name);
}
}
| 1,780
|
C++
|
.cpp
| 58
| 24.586207
| 99
| 0.665299
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,859
|
myguitexture.cpp
|
OpenMW_openmw/components/myguiplatform/myguitexture.cpp
|
#include "myguitexture.hpp"
#include <stdexcept>
#include <osg/StateSet>
#include <osg/Texture2D>
#include <components/debug/debuglog.hpp>
#include <components/resource/imagemanager.hpp>
namespace osgMyGUI
{
OSGTexture::OSGTexture(const std::string& name, Resource::ImageManager* imageManager)
: mName(name)
, mImageManager(imageManager)
, mFormat(MyGUI::PixelFormat::Unknow)
, mUsage(MyGUI::TextureUsage::Default)
, mNumElemBytes(0)
, mWidth(0)
, mHeight(0)
{
}
OSGTexture::OSGTexture(osg::Texture2D* texture, osg::StateSet* injectState)
: mImageManager(nullptr)
, mTexture(texture)
, mInjectState(injectState)
, mFormat(MyGUI::PixelFormat::Unknow)
, mUsage(MyGUI::TextureUsage::Default)
, mNumElemBytes(0)
, mWidth(texture->getTextureWidth())
, mHeight(texture->getTextureHeight())
{
}
OSGTexture::~OSGTexture() {}
void OSGTexture::createManual(int width, int height, MyGUI::TextureUsage usage, MyGUI::PixelFormat format)
{
GLenum glfmt = GL_NONE;
size_t numelems = 0;
switch (format.getValue())
{
case MyGUI::PixelFormat::L8:
glfmt = GL_LUMINANCE;
numelems = 1;
break;
case MyGUI::PixelFormat::L8A8:
glfmt = GL_LUMINANCE_ALPHA;
numelems = 2;
break;
case MyGUI::PixelFormat::R8G8B8:
glfmt = GL_RGB;
numelems = 3;
break;
case MyGUI::PixelFormat::R8G8B8A8:
glfmt = GL_RGBA;
numelems = 4;
break;
}
if (glfmt == GL_NONE)
throw std::runtime_error("Texture format not supported");
mTexture = new osg::Texture2D();
mTexture->setTextureSize(width, height);
mTexture->setSourceFormat(glfmt);
mTexture->setSourceType(GL_UNSIGNED_BYTE);
mWidth = width;
mHeight = height;
mTexture->setFilter(osg::Texture::MIN_FILTER, osg::Texture::LINEAR);
mTexture->setFilter(osg::Texture::MAG_FILTER, osg::Texture::LINEAR);
mTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mFormat = format;
mUsage = usage;
mNumElemBytes = numelems;
}
void OSGTexture::destroy()
{
mTexture = nullptr;
mFormat = MyGUI::PixelFormat::Unknow;
mUsage = MyGUI::TextureUsage::Default;
mNumElemBytes = 0;
mWidth = 0;
mHeight = 0;
}
void OSGTexture::loadFromFile(const std::string& fname)
{
if (!mImageManager)
throw std::runtime_error("No imagemanager set");
osg::ref_ptr<osg::Image> image(mImageManager->getImage(VFS::Path::Normalized(fname)));
mTexture = new osg::Texture2D(image);
mTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mTexture->setTextureWidth(image->s());
mTexture->setTextureHeight(image->t());
// disable mip-maps
mTexture->setFilter(osg::Texture2D::MIN_FILTER, osg::Texture2D::LINEAR);
mWidth = image->s();
mHeight = image->t();
mUsage = MyGUI::TextureUsage::Static;
}
void OSGTexture::saveToFile(const std::string& fname)
{
Log(Debug::Warning) << "Would save image to file " << fname;
}
void* OSGTexture::lock(MyGUI::TextureUsage /*access*/)
{
if (!mTexture.valid())
throw std::runtime_error("Texture is not created");
if (mLockedImage.valid())
throw std::runtime_error("Texture already locked");
mLockedImage = new osg::Image();
mLockedImage->allocateImage(mTexture->getTextureWidth(), mTexture->getTextureHeight(),
mTexture->getTextureDepth(), mTexture->getSourceFormat(), mTexture->getSourceType());
return mLockedImage->data();
}
void OSGTexture::unlock()
{
if (!mLockedImage.valid())
throw std::runtime_error("Texture not locked");
mLockedImage->flipVertical();
// mTexture might be in use by the draw thread, so create a new texture instead and use that.
osg::ref_ptr<osg::Texture2D> newTexture = new osg::Texture2D;
newTexture->setTextureSize(getWidth(), getHeight());
newTexture->setSourceFormat(mTexture->getSourceFormat());
newTexture->setSourceType(mTexture->getSourceType());
newTexture->setFilter(osg::Texture::MIN_FILTER, mTexture->getFilter(osg::Texture::MIN_FILTER));
newTexture->setFilter(osg::Texture::MAG_FILTER, mTexture->getFilter(osg::Texture::MAG_FILTER));
newTexture->setWrap(osg::Texture::WRAP_S, mTexture->getWrap(osg::Texture::WRAP_S));
newTexture->setWrap(osg::Texture::WRAP_T, mTexture->getWrap(osg::Texture::WRAP_T));
newTexture->setImage(mLockedImage.get());
// Tell the texture it can get rid of the image for static textures (since
// they aren't expected to update much at all).
newTexture->setUnRefImageDataAfterApply(mUsage.isValue(MyGUI::TextureUsage::Static) ? true : false);
mTexture = newTexture;
mLockedImage = nullptr;
}
// Render-to-texture not currently implemented.
MyGUI::IRenderTarget* OSGTexture::getRenderTarget()
{
return nullptr;
}
void OSGTexture::setShader(const std::string& _shaderName)
{
Log(Debug::Warning) << "OSGTexture::setShader is not implemented";
}
}
| 5,752
|
C++
|
.cpp
| 140
| 32.342857
| 110
| 0.627865
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,860
|
additivelayer.cpp
|
OpenMW_openmw/components/myguiplatform/additivelayer.cpp
|
#include "additivelayer.hpp"
#include <osg/BlendFunc>
#include <osg/StateSet>
#include "myguirendermanager.hpp"
namespace osgMyGUI
{
AdditiveLayer::AdditiveLayer()
{
mStateSet = new osg::StateSet;
mStateSet->setAttributeAndModes(new osg::BlendFunc(osg::BlendFunc::SRC_ALPHA, osg::BlendFunc::ONE));
}
AdditiveLayer::~AdditiveLayer()
{
// defined in .cpp file since we can't delete incomplete types
}
void AdditiveLayer::renderToTarget(MyGUI::IRenderTarget* _target, bool _update)
{
RenderManager& renderManager = static_cast<RenderManager&>(MyGUI::RenderManager::getInstance());
renderManager.setInjectState(mStateSet.get());
MyGUI::OverlappedLayer::renderToTarget(_target, _update);
renderManager.setInjectState(nullptr);
}
}
| 828
|
C++
|
.cpp
| 23
| 30.565217
| 108
| 0.715723
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,861
|
scalinglayer.cpp
|
OpenMW_openmw/components/myguiplatform/scalinglayer.cpp
|
#include "scalinglayer.hpp"
#include <MyGUI_RenderManager.h>
#include <algorithm>
namespace osgMyGUI
{
/// @brief the ProxyRenderTarget allows to adjust the pixel scale and offset for a "source" render target.
class ProxyRenderTarget : public MyGUI::IRenderTarget
{
public:
/// @param target The target to render to.
/// @param viewSize The size of the underlying layer node to render.
/// @param hoffset The horizontal rendering offset, specified as an offset from the left screen edge in range
/// 0-1.
/// @param voffset The vertical rendering offset, specified as an offset from the top screen edge in range 0-1.
ProxyRenderTarget(MyGUI::IRenderTarget* target, MyGUI::IntSize viewSize, float hoffset, float voffset)
: mTarget(target)
, mViewSize(viewSize)
, mHOffset(hoffset)
, mVOffset(voffset)
{
}
void begin() override { mTarget->begin(); }
void end() override { mTarget->end(); }
void doRender(MyGUI::IVertexBuffer* _buffer, MyGUI::ITexture* _texture, size_t _count) override
{
mTarget->doRender(_buffer, _texture, _count);
}
const MyGUI::RenderTargetInfo& getInfo() const override
{
mInfo = mTarget->getInfo();
mInfo.hOffset = mHOffset;
mInfo.vOffset = mVOffset;
mInfo.pixScaleX = 1.f / mViewSize.width;
mInfo.pixScaleY = 1.f / mViewSize.height;
return mInfo;
}
private:
MyGUI::IRenderTarget* mTarget;
MyGUI::IntSize mViewSize;
float mHOffset, mVOffset;
mutable MyGUI::RenderTargetInfo mInfo;
};
MyGUI::ILayerItem* ScalingLayer::getLayerItemByPoint(int _left, int _top) const
{
screenToLayerCoords(_left, _top);
return OverlappedLayer::getLayerItemByPoint(_left, _top);
}
void ScalingLayer::screenToLayerCoords(int& _left, int& _top) const
{
float scale = getScaleFactor(mViewSize);
if (scale <= 0.f)
return;
MyGUI::IntSize globalViewSize = MyGUI::RenderManager::getInstance().getViewSize();
_left -= globalViewSize.width / 2;
_top -= globalViewSize.height / 2;
_left = static_cast<int>(_left / scale);
_top = static_cast<int>(_top / scale);
_left += mViewSize.width / 2;
_top += mViewSize.height / 2;
}
float ScalingLayer::getScaleFactor(const MyGUI::IntSize& _layerViewSize)
{
MyGUI::IntSize viewSize = MyGUI::RenderManager::getInstance().getViewSize();
float w = static_cast<float>(viewSize.width);
float h = static_cast<float>(viewSize.height);
float heightScale = (h / _layerViewSize.height);
float widthScale = (w / _layerViewSize.width);
return std::min(widthScale, heightScale);
}
MyGUI::IntPoint ScalingLayer::getPosition(int _left, int _top) const
{
screenToLayerCoords(_left, _top);
return MyGUI::IntPoint(_left, _top);
}
void ScalingLayer::renderToTarget(MyGUI::IRenderTarget* _target, bool _update)
{
MyGUI::IntSize globalViewSize = MyGUI::RenderManager::getInstance().getViewSize();
MyGUI::IntSize viewSize = globalViewSize;
float scale = getScaleFactor(mViewSize);
viewSize.width = static_cast<int>(viewSize.width / scale);
viewSize.height = static_cast<int>(viewSize.height / scale);
float hoffset = (globalViewSize.width - mViewSize.width * getScaleFactor(mViewSize)) / 2.f
/ static_cast<float>(globalViewSize.width);
float voffset = (globalViewSize.height - mViewSize.height * getScaleFactor(mViewSize)) / 2.f
/ static_cast<float>(globalViewSize.height);
ProxyRenderTarget proxy(_target, viewSize, hoffset, voffset);
MyGUI::OverlappedLayer::renderToTarget(&proxy, _update);
}
void ScalingLayer::resizeView(const MyGUI::IntSize& _viewSize)
{
// do nothing
}
void ScalingLayer::deserialization(MyGUI::xml::ElementPtr _node, MyGUI::Version _version)
{
MyGUI::OverlappedLayer::deserialization(_node, _version);
MyGUI::xml::ElementEnumerator info = _node->getElementEnumerator();
while (info.next())
{
if (info->getName() == "Property")
{
auto key = info->findAttribute("key");
auto value = info->findAttribute("value");
if (key == "Size")
{
mViewSize = MyGUI::IntSize::parse(value);
}
}
}
}
}
| 4,687
|
C++
|
.cpp
| 110
| 33.690909
| 119
| 0.628132
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,862
|
myguiplatform.cpp
|
OpenMW_openmw/components/myguiplatform/myguiplatform.cpp
|
#include "myguiplatform.hpp"
#include "myguidatamanager.hpp"
#include "myguiloglistener.hpp"
#include "myguirendermanager.hpp"
#include "components/files/conversion.hpp"
namespace osgMyGUI
{
Platform::Platform(osgViewer::Viewer* viewer, osg::Group* guiRoot, Resource::ImageManager* imageManager,
const VFS::Manager* vfs, float uiScalingFactor, const std::filesystem::path& resourcePath,
const std::filesystem::path& logName)
: mLogFacility(logName.empty() ? nullptr : std::make_unique<LogFacility>(logName, false))
, mLogManager(std::make_unique<MyGUI::LogManager>())
, mDataManager(std::make_unique<DataManager>(Files::pathToUnicodeString(resourcePath), vfs))
, mRenderManager(std::make_unique<RenderManager>(viewer, guiRoot, imageManager, uiScalingFactor))
{
if (mLogFacility != nullptr)
mLogManager->addLogSource(mLogFacility->getSource());
mRenderManager->initialise();
}
Platform::~Platform() = default;
void Platform::shutdown()
{
mRenderManager->shutdown();
}
RenderManager* Platform::getRenderManagerPtr()
{
return mRenderManager.get();
}
DataManager* Platform::getDataManagerPtr()
{
return mDataManager.get();
}
}
| 1,285
|
C++
|
.cpp
| 33
| 33.030303
| 108
| 0.704509
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,863
|
myguirendermanager.cpp
|
OpenMW_openmw/components/myguiplatform/myguirendermanager.cpp
|
#include "myguirendermanager.hpp"
#include <MyGUI_Timer.h>
#include <osg/Drawable>
#include <osg/TexMat>
#include <osg/Texture2D>
#include <osgViewer/Viewer>
#include <osgGA/GUIEventHandler>
#include <components/resource/imagemanager.hpp>
#include <components/sceneutil/nodecallback.hpp>
#include <components/shader/shadermanager.hpp>
#include "myguitexture.hpp"
#define MYGUI_PLATFORM_LOG_SECTION "Platform"
#define MYGUI_PLATFORM_LOG(level, text) MYGUI_LOGGING(MYGUI_PLATFORM_LOG_SECTION, level, text)
#define MYGUI_PLATFORM_EXCEPT(dest) \
do \
{ \
MYGUI_PLATFORM_LOG(Critical, dest); \
std::ostringstream stream; \
stream << dest << "\n"; \
MYGUI_BASE_EXCEPT(stream.str().c_str(), "MyGUI"); \
} while (0)
#define MYGUI_PLATFORM_ASSERT(exp, dest) \
do \
{ \
if (!(exp)) \
{ \
MYGUI_PLATFORM_LOG(Critical, dest); \
std::ostringstream stream; \
stream << dest << "\n"; \
MYGUI_BASE_EXCEPT(stream.str().c_str(), "MyGUI"); \
} \
} while (0)
namespace osgMyGUI
{
class Drawable : public osg::Drawable
{
osgMyGUI::RenderManager* mParent;
osg::ref_ptr<osg::StateSet> mStateSet;
public:
// Stage 0: update widget animations and controllers. Run during the Update traversal.
class FrameUpdate : public SceneUtil::NodeCallback<FrameUpdate>
{
public:
FrameUpdate()
: mRenderManager(nullptr)
{
}
void setRenderManager(osgMyGUI::RenderManager* renderManager) { mRenderManager = renderManager; }
void operator()(osg::Node*, osg::NodeVisitor*) { mRenderManager->update(); }
private:
osgMyGUI::RenderManager* mRenderManager;
};
// Stage 1: collect draw calls. Run during the Cull traversal.
class CollectDrawCalls : public SceneUtil::NodeCallback<CollectDrawCalls>
{
public:
CollectDrawCalls()
: mRenderManager(nullptr)
{
}
void setRenderManager(osgMyGUI::RenderManager* renderManager) { mRenderManager = renderManager; }
void operator()(osg::Node*, osg::NodeVisitor*) { mRenderManager->collectDrawCalls(); }
private:
osgMyGUI::RenderManager* mRenderManager;
};
// Stage 2: execute the draw calls. Run during the Draw traversal. May run in parallel with the update traversal
// of the next frame.
void drawImplementation(osg::RenderInfo& renderInfo) const override
{
osg::State* state = renderInfo.getState();
state->pushStateSet(mStateSet);
state->apply();
state->disableAllVertexArrays();
state->setClientActiveTextureUnit(0);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
mReadFrom = (mReadFrom + 1) % sNumBuffers;
const std::vector<Batch>& vec = mBatchVector[mReadFrom];
for (std::vector<Batch>::const_iterator it = vec.begin(); it != vec.end(); ++it)
{
const Batch& batch = *it;
osg::VertexBufferObject* vbo = batch.mVertexBuffer;
if (batch.mStateSet)
{
state->pushStateSet(batch.mStateSet);
state->apply();
}
// A GUI element without an associated texture would be extremely rare.
// It is worth it to use a dummy 1x1 black texture sampler instead of either adding a conditional or
// relinking shaders.
osg::Texture2D* texture = batch.mTexture;
if (texture)
state->applyTextureAttribute(0, texture);
else
state->applyTextureAttribute(0, mDummyTexture);
osg::GLBufferObject* bufferobject = state->isVertexBufferObjectSupported()
? vbo->getOrCreateGLBufferObject(state->getContextID())
: nullptr;
if (bufferobject)
{
state->bindVertexBufferObject(bufferobject);
glVertexPointer(3, GL_FLOAT, sizeof(MyGUI::Vertex), reinterpret_cast<char*>(0));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(MyGUI::Vertex), reinterpret_cast<char*>(12));
glTexCoordPointer(2, GL_FLOAT, sizeof(MyGUI::Vertex), reinterpret_cast<char*>(16));
}
else
{
glVertexPointer(3, GL_FLOAT, sizeof(MyGUI::Vertex),
reinterpret_cast<const char*>(vbo->getArray(0)->getDataPointer()));
glColorPointer(4, GL_UNSIGNED_BYTE, sizeof(MyGUI::Vertex),
reinterpret_cast<const char*>(vbo->getArray(0)->getDataPointer()) + 12);
glTexCoordPointer(2, GL_FLOAT, sizeof(MyGUI::Vertex),
reinterpret_cast<const char*>(vbo->getArray(0)->getDataPointer()) + 16);
}
glDrawArrays(GL_TRIANGLES, 0, batch.mVertexCount);
if (batch.mStateSet)
{
state->popStateSet();
state->apply();
}
}
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
glDisableClientState(GL_COLOR_ARRAY);
state->popStateSet();
state->unbindVertexBufferObject();
state->dirtyAllVertexArrays();
state->disableAllVertexArrays();
}
public:
Drawable(osgMyGUI::RenderManager* parent = nullptr)
: mParent(parent)
, mWriteTo(0)
, mReadFrom(0)
{
setSupportsDisplayList(false);
osg::ref_ptr<CollectDrawCalls> collectDrawCalls = new CollectDrawCalls;
collectDrawCalls->setRenderManager(mParent);
setCullCallback(collectDrawCalls);
osg::ref_ptr<FrameUpdate> frameUpdate = new FrameUpdate;
frameUpdate->setRenderManager(mParent);
setUpdateCallback(frameUpdate);
mStateSet = new osg::StateSet;
mStateSet->setMode(GL_LIGHTING, osg::StateAttribute::OFF);
mStateSet->setTextureMode(0, GL_TEXTURE_2D, osg::StateAttribute::ON);
mStateSet->setMode(GL_DEPTH_TEST, osg::StateAttribute::OFF);
mStateSet->setMode(GL_BLEND, osg::StateAttribute::ON);
mDummyTexture = new osg::Texture2D;
mDummyTexture->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
mDummyTexture->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
mDummyTexture->setInternalFormat(GL_RGB);
mDummyTexture->setTextureSize(1, 1);
// need to flip tex coords since MyGUI uses DirectX convention of top left image origin
osg::Matrix flipMat;
flipMat.preMultTranslate(osg::Vec3f(0, 1, 0));
flipMat.preMultScale(osg::Vec3f(1, -1, 1));
mStateSet->setTextureAttribute(0, new osg::TexMat(flipMat), osg::StateAttribute::ON);
}
Drawable(const Drawable& copy, const osg::CopyOp& copyop = osg::CopyOp::SHALLOW_COPY)
: osg::Drawable(copy, copyop)
, mParent(copy.mParent)
, mStateSet(copy.mStateSet)
, mWriteTo(0)
, mReadFrom(0)
, mDummyTexture(copy.mDummyTexture)
{
}
// Defines the necessary information for a draw call
struct Batch
{
// May be empty
osg::ref_ptr<osg::Texture2D> mTexture;
osg::ref_ptr<osg::VertexBufferObject> mVertexBuffer;
// need to hold on to this too as the mVertexBuffer does not hold a ref to its own array
osg::ref_ptr<osg::Array> mArray;
// optional
osg::ref_ptr<osg::StateSet> mStateSet;
size_t mVertexCount;
};
void addBatch(const Batch& batch) { mBatchVector[mWriteTo].push_back(batch); }
void clear()
{
mWriteTo = (mWriteTo + 1) % sNumBuffers;
mBatchVector[mWriteTo].clear();
}
osg::StateSet* getDrawableStateSet() { return mStateSet; }
META_Object(osgMyGUI, Drawable)
private:
// 2 would be enough in most cases, use 4 to get stereo working
static const int sNumBuffers = 4;
// double buffering approach, to avoid the need for synchronization with the draw thread
std::vector<Batch> mBatchVector[sNumBuffers];
int mWriteTo;
mutable int mReadFrom;
osg::ref_ptr<osg::Texture2D> mDummyTexture;
};
class OSGVertexBuffer : public MyGUI::IVertexBuffer
{
osg::ref_ptr<osg::VertexBufferObject> mBuffer[2];
osg::ref_ptr<osg::UByteArray> mVertexArray[2];
size_t mNeedVertexCount;
unsigned int mCurrentBuffer;
bool mUsed; // has the mCurrentBuffer been submitted to the rendering thread
void destroy();
osg::UByteArray* create();
public:
OSGVertexBuffer();
virtual ~OSGVertexBuffer() {}
void markUsed();
osg::Array* getVertexArray();
osg::VertexBufferObject* getVertexBuffer();
void setVertexCount(size_t count) override;
size_t getVertexCount() const override;
MyGUI::Vertex* lock() override;
void unlock() override;
};
OSGVertexBuffer::OSGVertexBuffer()
: mNeedVertexCount(0)
, mCurrentBuffer(0)
, mUsed(false)
{
}
void OSGVertexBuffer::markUsed()
{
mUsed = true;
}
void OSGVertexBuffer::setVertexCount(size_t count)
{
if (count == mNeedVertexCount)
return;
mNeedVertexCount = count;
}
size_t OSGVertexBuffer::getVertexCount() const
{
return mNeedVertexCount;
}
MyGUI::Vertex* OSGVertexBuffer::lock()
{
if (mUsed)
{
mCurrentBuffer = (mCurrentBuffer + 1) % 2;
mUsed = false;
}
osg::UByteArray* array = mVertexArray[mCurrentBuffer];
if (!array)
{
array = create();
}
else if (array->size() != mNeedVertexCount * sizeof(MyGUI::Vertex))
{
array->resize(mNeedVertexCount * sizeof(MyGUI::Vertex));
}
return (MyGUI::Vertex*)&(*array)[0];
}
void OSGVertexBuffer::unlock()
{
mVertexArray[mCurrentBuffer]->dirty();
mBuffer[mCurrentBuffer]->dirty();
}
osg::UByteArray* OSGVertexBuffer::create()
{
mVertexArray[mCurrentBuffer] = new osg::UByteArray(mNeedVertexCount * sizeof(MyGUI::Vertex));
mBuffer[mCurrentBuffer] = new osg::VertexBufferObject;
mBuffer[mCurrentBuffer]->setDataVariance(osg::Object::DYNAMIC);
mBuffer[mCurrentBuffer]->setUsage(GL_DYNAMIC_DRAW);
// NB mBuffer does not own the array
mBuffer[mCurrentBuffer]->setArray(0, mVertexArray[mCurrentBuffer].get());
return mVertexArray[mCurrentBuffer];
}
osg::Array* OSGVertexBuffer::getVertexArray()
{
return mVertexArray[mCurrentBuffer];
}
osg::VertexBufferObject* OSGVertexBuffer::getVertexBuffer()
{
return mBuffer[mCurrentBuffer];
}
// ---------------------------------------------------------------------------
RenderManager::RenderManager(
osgViewer::Viewer* viewer, osg::Group* sceneroot, Resource::ImageManager* imageManager, float scalingFactor)
: mViewer(viewer)
, mSceneRoot(sceneroot)
, mImageManager(imageManager)
, mUpdate(false)
, mIsInitialise(false)
, mInvScalingFactor(1.f)
, mInjectState(nullptr)
{
if (scalingFactor != 0.f)
mInvScalingFactor = 1.f / scalingFactor;
}
RenderManager::~RenderManager()
{
MYGUI_PLATFORM_LOG(Info, "* Shutdown: " << getClassTypeName());
if (mGuiRoot.valid())
mSceneRoot->removeChild(mGuiRoot.get());
mGuiRoot = nullptr;
mSceneRoot = nullptr;
mViewer = nullptr;
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully shutdown");
mIsInitialise = false;
}
void RenderManager::initialise()
{
MYGUI_PLATFORM_ASSERT(!mIsInitialise, getClassTypeName() << " initialised twice");
MYGUI_PLATFORM_LOG(Info, "* Initialise: " << getClassTypeName());
mVertexFormat = MyGUI::VertexColourType::ColourABGR;
mUpdate = false;
mDrawable = new Drawable(this);
osg::ref_ptr<osg::Camera> camera = new osg::Camera();
camera->setReferenceFrame(osg::Transform::ABSOLUTE_RF);
camera->setProjectionResizePolicy(osg::Camera::FIXED);
camera->setProjectionMatrix(osg::Matrix::identity());
camera->setViewMatrix(osg::Matrix::identity());
camera->setRenderOrder(osg::Camera::POST_RENDER);
camera->setClearMask(GL_NONE);
mDrawable->setCullingActive(false);
camera->addChild(mDrawable.get());
mGuiRoot = camera;
mSceneRoot->addChild(mGuiRoot.get());
osg::ref_ptr<osg::Viewport> vp = mViewer->getCamera()->getViewport();
setViewSize(vp->width(), vp->height());
MYGUI_PLATFORM_LOG(Info, getClassTypeName() << " successfully initialized");
mIsInitialise = true;
}
void RenderManager::shutdown()
{
mGuiRoot->removeChildren(0, mGuiRoot->getNumChildren());
mSceneRoot->removeChild(mGuiRoot);
}
void RenderManager::enableShaders(Shader::ShaderManager& shaderManager)
{
auto program = shaderManager.getProgram("gui");
mDrawable->getDrawableStateSet()->setAttributeAndModes(program, osg::StateAttribute::ON);
mDrawable->getDrawableStateSet()->addUniform(new osg::Uniform("diffuseMap", 0));
}
MyGUI::IVertexBuffer* RenderManager::createVertexBuffer()
{
return new OSGVertexBuffer();
}
void RenderManager::destroyVertexBuffer(MyGUI::IVertexBuffer* buffer)
{
delete buffer;
}
void RenderManager::begin()
{
mDrawable->clear();
// variance will be recomputed based on textures being rendered in this frame
mDrawable->setDataVariance(osg::Object::STATIC);
}
void RenderManager::doRender(MyGUI::IVertexBuffer* buffer, MyGUI::ITexture* texture, size_t count)
{
Drawable::Batch batch;
batch.mVertexCount = count;
batch.mVertexBuffer = static_cast<OSGVertexBuffer*>(buffer)->getVertexBuffer();
batch.mArray = static_cast<OSGVertexBuffer*>(buffer)->getVertexArray();
static_cast<OSGVertexBuffer*>(buffer)->markUsed();
if (OSGTexture* osgtexture = static_cast<OSGTexture*>(texture))
{
batch.mTexture = osgtexture->getTexture();
if (batch.mTexture->getDataVariance() == osg::Object::DYNAMIC)
mDrawable->setDataVariance(osg::Object::DYNAMIC); // only for this frame, reset in begin()
if (!mInjectState && osgtexture->getInjectState())
batch.mStateSet = osgtexture->getInjectState();
}
if (mInjectState)
batch.mStateSet = mInjectState;
mDrawable->addBatch(batch);
}
void RenderManager::setInjectState(osg::StateSet* stateSet)
{
mInjectState = stateSet;
}
void RenderManager::end() {}
void RenderManager::update()
{
static MyGUI::Timer timer;
static unsigned long last_time = timer.getMilliseconds();
unsigned long now_time = timer.getMilliseconds();
unsigned long time = now_time - last_time;
onFrameEvent((float)((double)(time) / (double)1000));
last_time = now_time;
}
void RenderManager::collectDrawCalls()
{
begin();
onRenderToTarget(this, mUpdate);
end();
mUpdate = false;
}
void RenderManager::setViewSize(int width, int height)
{
if (width < 1)
width = 1;
if (height < 1)
height = 1;
mGuiRoot->setViewport(0, 0, width, height);
mViewSize.set(width * mInvScalingFactor, height * mInvScalingFactor);
mInfo.maximumDepth = 1;
mInfo.hOffset = 0;
mInfo.vOffset = 0;
mInfo.aspectCoef = float(mViewSize.height) / float(mViewSize.width);
mInfo.pixScaleX = 1.0f / float(mViewSize.width);
mInfo.pixScaleY = 1.0f / float(mViewSize.height);
onResizeView(mViewSize);
mUpdate = true;
}
bool RenderManager::isFormatSupported(MyGUI::PixelFormat /*format*/, MyGUI::TextureUsage /*usage*/)
{
return true;
}
MyGUI::ITexture* RenderManager::createTexture(const std::string& name)
{
const auto it = mTextures.insert_or_assign(name, OSGTexture(name, mImageManager)).first;
return &it->second;
}
void RenderManager::destroyTexture(MyGUI::ITexture* texture)
{
if (texture == nullptr)
return;
const auto item = mTextures.find(texture->getName());
MYGUI_PLATFORM_ASSERT(item != mTextures.end(), "Texture '" << texture->getName() << "' not found");
mTextures.erase(item);
}
MyGUI::ITexture* RenderManager::getTexture(const std::string& name)
{
if (name.empty())
return nullptr;
const auto item = mTextures.find(name);
if (item == mTextures.end())
{
MyGUI::ITexture* tex = createTexture(name);
tex->loadFromFile(name);
return tex;
}
return &item->second;
}
bool RenderManager::checkTexture(MyGUI::ITexture* _texture)
{
// We support external textures that aren't registered via this manager, so can't implement this method
// sensibly.
return true;
}
void RenderManager::registerShader(
const std::string& _shaderName, const std::string& _vertexProgramFile, const std::string& _fragmentProgramFile)
{
MYGUI_PLATFORM_LOG(Warning, "osgMyGUI::RenderManager::registerShader is not implemented");
}
}
| 19,999
|
C++
|
.cpp
| 450
| 34.597778
| 120
| 0.563783
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,864
|
myguiloglistener.cpp
|
OpenMW_openmw/components/myguiplatform/myguiloglistener.cpp
|
#include "myguiloglistener.hpp"
#include <iomanip>
#include <components/debug/debuglog.hpp>
namespace osgMyGUI
{
void CustomLogListener::open()
{
mStream.open(mFileName, std::ios_base::out);
if (!mStream.is_open())
Log(Debug::Error) << "Unable to create MyGUI log with path " << mFileName;
}
void CustomLogListener::close()
{
if (mStream.is_open())
mStream.close();
}
void CustomLogListener::flush()
{
if (mStream.is_open())
mStream.flush();
}
void CustomLogListener::log(std::string_view _section, MyGUI::LogLevel _level, const struct tm* _time,
std::string_view _message, std::string_view _file, int _line)
{
if (mStream.is_open())
{
std::string_view separator = " | ";
mStream << std::setw(2) << std::setfill('0') << _time->tm_hour << ":" << std::setw(2) << std::setfill('0')
<< _time->tm_min << ":" << std::setw(2) << std::setfill('0') << _time->tm_sec << separator
<< _section << separator << _level.print() << separator << _message << separator << _file
<< separator << _line << std::endl;
}
}
MyGUI::LogLevel LogFacility::getCurrentLogLevel() const
{
switch (Log::sMinDebugLevel)
{
case Debug::Error:
return MyGUI::LogLevel::Error;
case Debug::Warning:
return MyGUI::LogLevel::Warning;
default:
return MyGUI::LogLevel::Info;
}
}
}
| 1,599
|
C++
|
.cpp
| 46
| 25.956522
| 118
| 0.541397
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,865
|
bulletnifloader.cpp
|
OpenMW_openmw/components/nifbullet/bulletnifloader.cpp
|
#include "bulletnifloader.hpp"
#include <cassert>
#include <sstream>
#include <tuple>
#include <variant>
#include <vector>
#include <components/debug/debuglog.hpp>
#include <components/files/conversion.hpp>
#include <components/misc/convert.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/nif/extra.hpp>
#include <components/nif/nifstream.hpp>
#include <components/nif/node.hpp>
#include <components/nif/parent.hpp>
namespace
{
bool pathFileNameStartsWithX(const std::string& path)
{
const std::size_t slashpos = path.find_last_of("/\\");
const std::size_t letterPos = slashpos == std::string::npos ? 0 : slashpos + 1;
return letterPos < path.size() && (path[letterPos] == 'x' || path[letterPos] == 'X');
}
}
namespace NifBullet
{
osg::ref_ptr<Resource::BulletShape> BulletNifLoader::load(Nif::FileView nif)
{
mShape = new Resource::BulletShape;
mCompoundShape.reset();
mAvoidCompoundShape.reset();
mShape->mFileHash = nif.getHash();
const size_t numRoots = nif.numRoots();
std::vector<const Nif::NiAVObject*> roots;
for (size_t i = 0; i < numRoots; ++i)
{
const Nif::Record* r = nif.getRoot(i);
if (!r)
continue;
const Nif::NiAVObject* node = dynamic_cast<const Nif::NiAVObject*>(r);
if (node)
roots.emplace_back(node);
}
mShape->mFileName = nif.getFilename();
if (roots.empty())
{
warn("Found no root nodes in NIF file " + mShape->mFileName.value());
return mShape;
}
for (const Nif::NiAVObject* node : roots)
if (findBoundingBox(*node))
break;
HandleNodeArgs args;
// files with the name convention xmodel.nif usually have keyframes stored in a separate file xmodel.kf (see
// Animation::addAnimSource). assume all nodes in the file will be animated
// TODO: investigate whether this should and could be optimized.
args.mAnimated = pathFileNameStartsWithX(mShape->mFileName);
for (const Nif::NiAVObject* node : roots)
handleRoot(nif, *node, args);
if (mCompoundShape)
mShape->mCollisionShape = std::move(mCompoundShape);
if (mAvoidCompoundShape)
mShape->mAvoidCollisionShape = std::move(mAvoidCompoundShape);
return mShape;
}
// Find a bounding box in the node hierarchy to use for actor collision
bool BulletNifLoader::findBoundingBox(const Nif::NiAVObject& node)
{
if (Misc::StringUtils::ciEqual(node.mName, "Bounding Box"))
{
if (node.mBounds.mType == Nif::BoundingVolume::Type::BOX_BV
&& std::ranges::all_of(node.mBounds.mBox.mExtents._v, [](float extent) { return extent > 0.f; }))
{
mShape->mCollisionBox.mExtents = node.mBounds.mBox.mExtents;
mShape->mCollisionBox.mCenter = node.mBounds.mBox.mCenter;
}
else
{
warn("Invalid Bounding Box node bounds in file " + mShape->mFileName.value());
}
return true;
}
if (auto ninode = dynamic_cast<const Nif::NiNode*>(&node))
for (const auto& child : ninode->mChildren)
if (!child.empty() && findBoundingBox(child.get()))
return true;
return false;
}
void BulletNifLoader::handleRoot(Nif::FileView nif, const Nif::NiAVObject& node, HandleNodeArgs args)
{
// Gamebryo/Bethbryo meshes
if (nif.getVersion() >= Nif::NIFStream::generateVersion(10, 0, 1, 0))
{
// Handle BSXFlags
const Nif::NiIntegerExtraData* bsxFlags = nullptr;
for (const auto& e : node.getExtraList())
{
if (e->recType == Nif::RC_BSXFlags)
{
bsxFlags = static_cast<const Nif::NiIntegerExtraData*>(e.getPtr());
break;
}
}
// Collision flag
if (!bsxFlags || !(bsxFlags->mData & 2))
return;
// Editor marker flag
if (bsxFlags->mData & 32)
args.mHasMarkers = true;
// FIXME: hack, using rendered geometry instead of Bethesda Havok data
args.mAutogenerated = true;
}
// Pre-Gamebryo meshes
else
{
// Handle RootCollisionNode
const Nif::NiNode* colNode = nullptr;
if (const Nif::NiNode* ninode = dynamic_cast<const Nif::NiNode*>(&node))
{
for (const auto& child : ninode->mChildren)
{
if (!child.empty() && child.getPtr()->recType == Nif::RC_RootCollisionNode)
{
colNode = static_cast<const Nif::NiNode*>(child.getPtr());
break;
}
}
}
args.mAutogenerated = colNode == nullptr;
// Check for extra data
for (const auto& e : node.getExtraList())
{
if (e->recType == Nif::RC_NiStringExtraData)
{
// String markers may contain important information
// affecting the entire subtree of this node
auto sd = static_cast<const Nif::NiStringExtraData*>(e.getPtr());
// Editor marker flag
if (sd->mData == "MRK")
args.mHasTriMarkers = true;
else if (Misc::StringUtils::ciStartsWith(sd->mData, "NC"))
{
// NC prefix is case-insensitive but the second C in NCC flag needs be uppercase.
// Collide only with camera.
if (sd->mData.length() > 2 && sd->mData[2] == 'C')
mShape->mVisualCollisionType = Resource::VisualCollisionType::Camera;
// No collision.
else
mShape->mVisualCollisionType = Resource::VisualCollisionType::Default;
}
}
}
// FIXME: BulletNifLoader should never have to provide rendered geometry for camera collision
if (colNode && colNode->mChildren.empty())
{
args.mAutogenerated = true;
mShape->mVisualCollisionType = Resource::VisualCollisionType::Camera;
}
}
handleNode(node, nullptr, args);
}
void BulletNifLoader::handleNode(const Nif::NiAVObject& node, const Nif::Parent* parent, HandleNodeArgs args)
{
// TODO: allow on-the fly collision switching via toggling this flag
if (node.recType == Nif::RC_NiCollisionSwitch && !node.collisionActive())
return;
for (Nif::NiTimeControllerPtr ctrl = node.mController; !ctrl.empty(); ctrl = ctrl->mNext)
{
if (args.mAnimated)
break;
if (!ctrl->isActive())
continue;
switch (ctrl->recType)
{
case Nif::RC_NiKeyframeController:
case Nif::RC_NiPathController:
case Nif::RC_NiRollController:
args.mAnimated = true;
break;
default:
continue;
}
}
if (node.recType == Nif::RC_RootCollisionNode)
{
if (args.mAutogenerated)
{
// Encountered a RootCollisionNode inside an autogenerated mesh.
// We treat empty RootCollisionNodes as NCC flag (set collisionType to `Camera`)
// and generate the camera collision shape based on rendered geometry.
if (mShape->mVisualCollisionType == Resource::VisualCollisionType::Camera)
return;
// Otherwise we'll want to notify the user.
Log(Debug::Info) << "BulletNifLoader: RootCollisionNode is not attached to the root node in "
<< mShape->mFileName << ". Treating it as a NiNode.";
}
else
{
args.mIsCollisionNode = true;
}
}
// Don't collide with AvoidNode shapes
if (node.recType == Nif::RC_AvoidNode)
args.mAvoid = true;
if (args.mAutogenerated || args.mIsCollisionNode)
{
auto geometry = dynamic_cast<const Nif::NiGeometry*>(&node);
if (geometry)
handleGeometry(*geometry, parent, args);
}
// For NiNodes, loop through children
if (const Nif::NiNode* ninode = dynamic_cast<const Nif::NiNode*>(&node))
{
const Nif::Parent currentParent{ *ninode, parent };
for (const auto& child : ninode->mChildren)
{
if (!child.empty())
{
assert(std::find(child->mParents.begin(), child->mParents.end(), ninode) != child->mParents.end());
handleNode(child.get(), ¤tParent, args);
}
// For NiSwitchNodes and NiFltAnimationNodes, only use the first child
// TODO: must synchronize with the rendering scene graph somehow
// Doing this for NiLODNodes is unsafe (the first level might not be the closest)
if (node.recType == Nif::RC_NiSwitchNode || node.recType == Nif::RC_NiFltAnimationNode)
break;
}
}
}
void BulletNifLoader::handleGeometry(
const Nif::NiGeometry& niGeometry, const Nif::Parent* nodeParent, HandleNodeArgs args)
{
// This flag comes from BSXFlags
if (args.mHasMarkers && Misc::StringUtils::ciStartsWith(niGeometry.mName, "EditorMarker"))
return;
// This flag comes from Morrowind
if (args.mHasTriMarkers && Misc::StringUtils::ciStartsWith(niGeometry.mName, "Tri EditorMarker"))
return;
if (!niGeometry.mSkin.empty())
args.mAnimated = false;
std::unique_ptr<btCollisionShape> childShape = niGeometry.getCollisionShape();
if (childShape == nullptr)
return;
osg::Matrixf transform = niGeometry.mTransform.toMatrix();
for (const Nif::Parent* parent = nodeParent; parent != nullptr; parent = parent->mParent)
transform *= parent->mNiNode.mTransform.toMatrix();
if (childShape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
{
auto scaledShape = std::make_unique<Resource::ScaledTriangleMeshShape>(
static_cast<btBvhTriangleMeshShape*>(childShape.get()), Misc::Convert::toBullet(transform.getScale()));
std::ignore = childShape.release();
childShape = std::move(scaledShape);
}
else
{
childShape->setLocalScaling(Misc::Convert::toBullet(transform.getScale()));
}
transform.orthoNormalize(transform);
btTransform trans;
trans.setOrigin(Misc::Convert::toBullet(transform.getTrans()));
for (int i = 0; i < 3; ++i)
for (int j = 0; j < 3; ++j)
trans.getBasis()[i][j] = transform(j, i);
if (!args.mAvoid)
{
if (!mCompoundShape)
mCompoundShape.reset(new btCompoundShape);
if (args.mAnimated)
mShape->mAnimatedShapes.emplace(niGeometry.recIndex, mCompoundShape->getNumChildShapes());
mCompoundShape->addChildShape(trans, childShape.get());
}
else
{
if (!mAvoidCompoundShape)
mAvoidCompoundShape.reset(new btCompoundShape);
mAvoidCompoundShape->addChildShape(trans, childShape.get());
}
std::ignore = childShape.release();
}
} // namespace NifBullet
| 12,129
|
C++
|
.cpp
| 279
| 31.089606
| 119
| 0.563183
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,866
|
node.cpp
|
OpenMW_openmw/components/nif/node.cpp
|
#include "node.hpp"
#include <cstdint>
#include <BulletCollision/CollisionShapes/btTriangleMesh.h>
#include <components/misc/convert.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/resource/bulletshape.hpp>
#include "data.hpp"
#include "exception.hpp"
#include "physics.hpp"
#include "property.hpp"
namespace
{
void triBasedGeomToBtTriangleMesh(btTriangleMesh& mesh, const Nif::NiTriBasedGeomData& data)
{
// FIXME: copying vertices/indices individually is unreasonable
const std::vector<osg::Vec3f>& vertices = data.mVertices;
mesh.preallocateVertices(static_cast<int>(vertices.size()));
for (const osg::Vec3f& vertex : vertices)
mesh.findOrAddVertex(Misc::Convert::toBullet(vertex), false);
mesh.preallocateIndices(static_cast<int>(data.mNumTriangles) * 3);
}
void trianglesToBtTriangleMesh(btTriangleMesh& mesh, const std::vector<unsigned short>& triangles)
{
for (std::size_t i = 0; i < triangles.size(); i += 3)
mesh.addTriangleIndices(triangles[i + 0], triangles[i + 1], triangles[i + 2]);
}
void stripsToBtTriangleMesh(btTriangleMesh& mesh, const std::vector<std::vector<unsigned short>>& strips)
{
for (const auto& strip : strips)
{
if (strip.size() < 3)
continue;
unsigned short a;
unsigned short b = strip[0];
unsigned short c = strip[1];
for (size_t i = 2; i < strip.size(); i++)
{
a = b;
b = c;
c = strip[i];
if (a == b || b == c || a == c)
continue;
if (i % 2 == 0)
mesh.addTriangleIndices(a, b, c);
else
mesh.addTriangleIndices(a, c, b);
}
}
}
}
namespace Nif
{
void BoundingVolume::read(NIFStream* nif)
{
nif->read(mType);
switch (mType)
{
case BASE_BV:
break;
case SPHERE_BV:
{
nif->read(mSphere);
break;
}
case BOX_BV:
{
nif->read(mBox.mCenter);
nif->read(mBox.mAxes);
nif->read(mBox.mExtents);
break;
}
case CAPSULE_BV:
{
nif->read(mCapsule.mCenter);
nif->read(mCapsule.mAxis);
nif->read(mCapsule.mExtent);
nif->read(mCapsule.mRadius);
break;
}
case LOZENGE_BV:
{
nif->read(mLozenge.mRadius);
if (nif->getVersion() >= NIFStream::generateVersion(4, 2, 1, 0))
{
nif->read(mLozenge.mExtent0);
nif->read(mLozenge.mExtent1);
}
nif->read(mLozenge.mCenter);
nif->read(mLozenge.mAxis0);
nif->read(mLozenge.mAxis1);
break;
}
case UNION_BV:
{
mChildren.resize(nif->get<uint32_t>());
for (BoundingVolume& child : mChildren)
child.read(nif);
break;
}
case HALFSPACE_BV:
{
mHalfSpace.mPlane = osg::Plane(nif->get<osg::Vec4f>());
if (nif->getVersion() >= NIFStream::generateVersion(4, 2, 1, 0))
nif->read(mHalfSpace.mOrigin);
break;
}
default:
{
throw Nif::Exception(
"Unhandled BoundingVolume type: " + std::to_string(mType), nif->getFile().getFilename());
}
}
}
void NiAVObject::read(NIFStream* nif)
{
NiObjectNET::read(nif);
if (nif->getBethVersion() <= 26)
mFlags = nif->get<uint16_t>();
else
nif->read(mFlags);
nif->read(mTransform.mTranslation);
nif->read(mTransform.mRotation);
nif->read(mTransform.mScale);
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0))
nif->read(mVelocity);
if (nif->getBethVersion() <= NIFFile::BethVersion::BETHVER_FO3)
readRecordList(nif, mProperties);
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0) && nif->get<bool>())
mBounds.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
mCollision.read(nif);
}
void NiAVObject::post(Reader& nif)
{
NiObjectNET::post(nif);
postRecordList(nif, mProperties);
mCollision.post(nif);
}
void NiAVObject::setBone()
{
mIsBone = true;
}
void NiNode::read(NIFStream* nif)
{
NiAVObject::read(nif);
readRecordList(nif, mChildren);
if (nif->getBethVersion() < NIFFile::BethVersion::BETHVER_FO4)
readRecordList(nif, mEffects);
// FIXME: stopgap solution until we figure out what Oblivion does if it does anything
if (nif->getVersion() > NIFFile::NIFVersion::VER_MW && nif->getVersion() < NIFFile::NIFVersion::VER_BGS)
return;
// Discard transformations for the root node, otherwise some meshes
// occasionally get wrong orientation. Only for NiNode-s for now, but
// can be expanded if needed.
// FIXME: if node 0 is *not* the only root node, this must not happen.
// FIXME: doing this here is awful.
// We want to do this on world scene graph level rather than local scene graph level.
if (recIndex == 0 && !Misc::StringUtils::ciEqual(mName, "bip01"))
{
mTransform = Nif::NiTransform::getIdentity();
}
}
void NiNode::post(Reader& nif)
{
NiAVObject::post(nif);
postRecordList(nif, mChildren);
postRecordList(nif, mEffects);
for (auto& child : mChildren)
{
// Why would a unique list of children contain empty refs?
if (!child.empty())
child->mParents.push_back(this);
}
}
void NiGeometry::MaterialData::read(NIFStream* nif)
{
if (nif->getVersion() < NIFStream::generateVersion(10, 0, 1, 0))
return;
if (nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 5))
mNames.resize(nif->get<uint32_t>());
else if (nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 3))
mNames.resize(nif->get<bool>());
nif->readVector(mNames, mNames.size());
nif->readVector(mExtra, mNames.size());
if (nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 5))
nif->read(mActive);
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS)
nif->read(mNeedsUpdate);
}
void NiGeometry::read(NIFStream* nif)
{
NiAVObject::read(nif);
mData.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
mSkin.read(nif);
mMaterial.read(nif);
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS
&& nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
{
mShaderProperty.read(nif);
mAlphaProperty.read(nif);
}
}
void NiGeometry::post(Reader& nif)
{
NiAVObject::post(nif);
mData.post(nif);
mSkin.post(nif);
mShaderProperty.post(nif);
mAlphaProperty.post(nif);
if (recType != RC_NiParticles && !mSkin.empty())
nif.setUseSkinning(true);
if (!mData.empty())
{
switch (recType)
{
case RC_NiTriShape:
case RC_BSLODTriShape:
case RC_BSSegmentedTriShape:
if (mData->recType != RC_NiTriShapeData)
mData = NiGeometryDataPtr(nullptr);
break;
case RC_NiTriStrips:
if (mData->recType != RC_NiTriStripsData)
mData = NiGeometryDataPtr(nullptr);
break;
case RC_NiParticles:
if (mData->recType != RC_NiParticlesData)
mData = NiGeometryDataPtr(nullptr);
break;
case RC_NiLines:
if (mData->recType != RC_NiLinesData)
mData = NiGeometryDataPtr(nullptr);
break;
default:
break;
}
}
}
std::unique_ptr<btCollisionShape> NiTriShape::getCollisionShape() const
{
if (mData.empty() || mData->mVertices.empty())
return nullptr;
std::vector<const std::vector<unsigned short>*> triangleLists;
std::vector<const std::vector<std::vector<unsigned short>>*> stripsLists;
auto data = static_cast<const NiTriShapeData*>(mData.getPtr());
const Nif::NiSkinPartition* partitions = nullptr;
if (!mSkin.empty())
partitions = mSkin->getPartitions();
if (partitions)
{
triangleLists.reserve(partitions->mPartitions.size());
stripsLists.reserve(partitions->mPartitions.size());
for (auto& partition : partitions->mPartitions)
{
triangleLists.push_back(&partition.mTrueTriangles);
stripsLists.push_back(&partition.mTrueStrips);
}
}
else if (data->mNumTriangles != 0)
triangleLists.push_back(&data->mTriangles);
// This makes a perhaps dangerous assumption that NiSkinPartition will never have more than 65536 triangles.
auto mesh = std::make_unique<btTriangleMesh>();
triBasedGeomToBtTriangleMesh(*mesh, *data);
for (const auto triangles : triangleLists)
trianglesToBtTriangleMesh(*mesh, *triangles);
for (const auto strips : stripsLists)
stripsToBtTriangleMesh(*mesh, *strips);
if (mesh->getNumTriangles() == 0)
return nullptr;
auto shape = std::make_unique<Resource::TriangleMeshShape>(mesh.get(), true);
std::ignore = mesh.release();
return shape;
}
std::unique_ptr<btCollisionShape> NiTriStrips::getCollisionShape() const
{
if (mData.empty() || mData->mVertices.empty())
return nullptr;
std::vector<const std::vector<unsigned short>*> triangleLists;
std::vector<const std::vector<std::vector<unsigned short>>*> stripsLists;
auto data = static_cast<const NiTriStripsData*>(mData.getPtr());
const Nif::NiSkinPartition* partitions = nullptr;
if (!mSkin.empty())
partitions = mSkin->getPartitions();
if (partitions)
{
triangleLists.reserve(partitions->mPartitions.size());
stripsLists.reserve(partitions->mPartitions.size());
for (auto& partition : partitions->mPartitions)
{
triangleLists.push_back(&partition.mTrueTriangles);
stripsLists.push_back(&partition.mTrueStrips);
}
}
else if (data->mNumTriangles != 0)
stripsLists.push_back(&data->mStrips);
auto mesh = std::make_unique<btTriangleMesh>();
triBasedGeomToBtTriangleMesh(*mesh, *data);
for (const auto triangles : triangleLists)
trianglesToBtTriangleMesh(*mesh, *triangles);
for (const auto strips : stripsLists)
stripsToBtTriangleMesh(*mesh, *strips);
if (mesh->getNumTriangles() == 0)
return nullptr;
auto shape = std::make_unique<Resource::TriangleMeshShape>(mesh.get(), true);
std::ignore = mesh.release();
return shape;
}
std::unique_ptr<btCollisionShape> NiLines::getCollisionShape() const
{
return nullptr;
}
std::unique_ptr<btCollisionShape> NiParticles::getCollisionShape() const
{
return nullptr;
}
void BSSegmentedTriShape::SegmentData::read(NIFStream* nif)
{
nif->read(mFlags);
nif->read(mStartIndex);
nif->read(mNumTriangles);
}
void BSSegmentedTriShape::read(NIFStream* nif)
{
NiTriShape::read(nif);
mSegments.resize(nif->get<uint32_t>());
for (SegmentData& segment : mSegments)
segment.read(nif);
}
void BSLODTriShape::read(NIFStream* nif)
{
NiTriBasedGeom::read(nif);
nif->readArray(mLOD);
}
void NiCamera::read(NIFStream* nif)
{
NiAVObject::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mCameraFlags);
nif->read(mLeft);
nif->read(mRight);
nif->read(mTop);
nif->read(mBottom);
nif->read(mNearDist);
nif->read(mFarDist);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mOrthographic);
nif->read(mVLeft);
nif->read(mVRight);
nif->read(mVTop);
nif->read(mVBottom);
nif->read(mLODAdjust);
mScene.read(nif);
nif->skip(4); // Unused
if (nif->getVersion() >= NIFStream::generateVersion(4, 2, 1, 0))
nif->skip(4); // Unused
}
void NiCamera::post(Reader& nif)
{
NiAVObject::post(nif);
mScene.post(nif);
}
void NiSwitchNode::read(NIFStream* nif)
{
NiNode::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mSwitchFlags);
nif->read(mInitialIndex);
}
void NiLODNode::read(NIFStream* nif)
{
NiSwitchNode::read(nif);
if (nif->getVersion() > NIFStream::generateVersion(10, 0, 1, 0))
{
nif->skip(4); // NiLODData, unsupported at the moment
return;
}
if (nif->getVersion() >= NIFFile::NIFVersion::VER_MW)
nif->read(mLODCenter);
mLODLevels.resize(nif->get<uint32_t>());
for (LODRange& level : mLODLevels)
{
nif->read(level.mMinRange);
nif->read(level.mMaxRange);
}
}
void NiFltAnimationNode::read(NIFStream* nif)
{
NiSwitchNode::read(nif);
nif->read(mDuration);
}
void NiSortAdjustNode::read(NIFStream* nif)
{
NiNode::read(nif);
mMode = static_cast<SortingMode>(nif->get<uint32_t>());
if (nif->getVersion() <= NIFStream::generateVersion(20, 0, 0, 3))
mSubSorter.read(nif);
}
void NiSortAdjustNode::post(Reader& nif)
{
NiNode::post(nif);
mSubSorter.post(nif);
}
void NiBillboardNode::read(NIFStream* nif)
{
NiNode::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
mMode = nif->get<uint16_t>() & 0x7;
else
mMode = (mFlags >> 5) & 0x3;
}
void NiDefaultAVObjectPalette::read(NIFStream* nif)
{
mScene.read(nif);
uint32_t numObjects;
nif->read(numObjects);
for (uint32_t i = 0; i < numObjects; i++)
mObjects[nif->getSizedString()].read(nif);
}
void NiDefaultAVObjectPalette::post(Reader& nif)
{
mScene.post(nif);
for (auto& object : mObjects)
object.second.post(nif);
}
void BSTreeNode::read(NIFStream* nif)
{
NiNode::read(nif);
readRecordList(nif, mBones1);
readRecordList(nif, mBones2);
}
void BSTreeNode::post(Reader& nif)
{
NiNode::post(nif);
postRecordList(nif, mBones1);
postRecordList(nif, mBones2);
}
void BSMultiBoundNode::read(NIFStream* nif)
{
NiNode::read(nif);
mMultiBound.read(nif);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_SKY)
mCullingType = static_cast<BSCPCullingType>(nif->get<uint32_t>());
}
void BSMultiBoundNode::post(Reader& nif)
{
NiNode::post(nif);
mMultiBound.post(nif);
}
void BSTriShape::read(NIFStream* nif)
{
NiAVObject::read(nif);
nif->read(mBoundingSphere);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
nif->readArray(mBoundMinMax);
mSkin.read(nif);
mShaderProperty.read(nif);
mAlphaProperty.read(nif);
mVertDesc.read(nif);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
mTriangles.resize(nif->get<uint32_t>() * 3);
else
mTriangles.resize(nif->get<uint16_t>() * 3);
mVertData.resize(nif->get<uint16_t>());
nif->read(mDataSize);
if (mDataSize > 0)
{
for (auto& vertex : mVertData)
vertex.read(nif, mVertDesc.mFlags);
nif->readVector(mTriangles, mTriangles.size());
}
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
{
nif->read(mParticleDataSize);
if (mParticleDataSize > 0)
{
nif->readVector(mParticleVerts, mVertData.size() * 3);
nif->readVector(mParticleNormals, mVertData.size() * 3);
nif->readVector(mParticleTriangles, mTriangles.size());
}
}
}
void BSTriShape::post(Reader& nif)
{
NiAVObject::post(nif);
mSkin.post(nif);
mShaderProperty.post(nif);
mAlphaProperty.post(nif);
if (!mSkin.empty())
nif.setUseSkinning(true);
}
void BSDynamicTriShape::read(NIFStream* nif)
{
BSTriShape::read(nif);
nif->read(mDynamicDataSize);
// nifly style.
// Consider complaining if mDynamicDataSize * 16 != mVertData.size()?
nif->readVector(mDynamicData, mVertData.size());
}
void BSMeshLODTriShape::read(NIFStream* nif)
{
BSTriShape::read(nif);
nif->readArray(mLOD);
}
void BSSubIndexTriShape::SubSegment::read(NIFStream* nif)
{
nif->read(mStartIndex);
nif->read(mNumPrimitives);
nif->read(mArrayIndex);
nif->skip(4); // Unknown
}
void BSSubIndexTriShape::Segment::read(NIFStream* nif)
{
nif->read(mStartIndex);
nif->read(mNumPrimitives);
nif->read(mParentArrayIndex);
mSubSegments.resize(nif->get<uint32_t>());
for (SubSegment& subsegment : mSubSegments)
subsegment.read(nif);
}
void BSSubIndexTriShape::SubSegmentDataRecord::read(NIFStream* nif)
{
nif->read(mUserSlotID);
nif->read(mMaterial);
nif->readVector(mExtraData, nif->get<uint32_t>());
}
void BSSubIndexTriShape::SubSegmentData::read(NIFStream* nif)
{
uint32_t numArrayIndices;
nif->read(numArrayIndices);
mDataRecords.resize(nif->get<uint32_t>());
nif->readVector(mArrayIndices, numArrayIndices);
for (SubSegmentDataRecord& dataRecord : mDataRecords)
dataRecord.read(nif);
mSSFFile = nif->getSizedString(nif->get<uint16_t>());
}
void BSSubIndexTriShape::Segmentation::read(NIFStream* nif)
{
nif->read(mNumPrimitives);
mSegments.resize(nif->get<uint32_t>());
nif->read(mNumTotalSegments);
for (Segment& segment : mSegments)
segment.read(nif);
if (mSegments.size() < mNumTotalSegments)
mSubSegmentData.read(nif);
}
void BSSubIndexTriShape::read(NIFStream* nif)
{
BSTriShape::read(nif);
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
{
mSegments.resize(nif->get<uint32_t>());
for (BSSegmentedTriShape::SegmentData& segment : mSegments)
segment.read(nif);
}
else if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4 && mDataSize > 0)
mSegmentation.read(nif);
}
void BSVertexDesc::read(NIFStream* nif)
{
uint64_t data;
nif->read(data);
mVertexDataSize = (data & 0xF) >> 0x00;
mDynamicVertexSize = (data & 0xF0) >> 0x04;
mUV1Offset = (data & 0xF00) >> 0x08;
mUV2Offset = (data & 0xF000) >> 0x0C;
mNormalOffset = (data & 0xF0000) >> 0x10;
mTangentOffset = (data & 0xF00000) >> 0x14;
mColorOffset = (data & 0xF000000) >> 0x18;
mSkinningDataOffset = (data & 0xF0000000) >> 0x1C;
mLandscapeDataOffset = (data & 0xF00000000) >> 0x20;
mEyeDataOffset = (data & 0xF000000000) >> 0x24;
mFlags = (data & 0xFFF00000000000) >> 0x2C;
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
mFlags |= BSVertexDesc::VertexAttribute::Full_Precision;
}
void BSVertexData::read(NIFStream* nif, uint16_t flags)
{
bool fullPrecision = flags & BSVertexDesc::VertexAttribute::Full_Precision;
bool hasVertex = flags & BSVertexDesc::VertexAttribute::Vertex;
bool hasTangent = flags & BSVertexDesc::VertexAttribute::Tangents;
bool hasUV = flags & BSVertexDesc::VertexAttribute::UVs;
bool hasNormal = flags & BSVertexDesc::VertexAttribute::Normals;
bool hasVertexColor = flags & BSVertexDesc::VertexAttribute::Vertex_Colors;
bool hasSkinData = flags & BSVertexDesc::VertexAttribute::Skinned;
bool hasEyeData = flags & BSVertexDesc::VertexAttribute::Eye_Data;
if (hasVertex)
{
if (fullPrecision)
nif->read(mVertex);
else
nif->readArray(mHalfVertex);
}
if (hasUV)
nif->readArray(mUV);
if (hasNormal)
{
nif->readArray(mNormal);
if (hasTangent)
nif->readArray(mTangent);
}
if (hasVertexColor)
nif->readArray(mVertColor);
if (hasSkinData)
{
nif->readArray(mBoneWeights);
nif->readArray(mBoneIndices);
}
if (hasEyeData)
nif->read(mEyeData);
}
void BSValueNode::read(NIFStream* nif)
{
NiNode::read(nif);
nif->read(mValue);
nif->read(mValueFlags);
}
void BSOrderedNode::read(NIFStream* nif)
{
NiNode::read(nif);
nif->read(mAlphaSortBound);
nif->read(mStaticBound);
}
void BSRangeNode::read(NIFStream* nif)
{
NiNode::read(nif);
nif->read(mMin);
nif->read(mMax);
nif->read(mCurrent);
}
void BSResourceID::read(NIFStream* nif)
{
nif->read(mFileHash);
nif->readArray(mExtension);
nif->read(mDirectoryHash);
}
void BSDistantObjectInstance::read(NIFStream* nif)
{
mResourceID.read(nif);
nif->skip(12 * nif->get<uint32_t>()); // Unknown data
mTransforms.resize(nif->get<uint32_t>());
for (osg::Matrixf& transform : mTransforms)
{
std::array<float, 16> mat;
nif->readArray(mat);
transform.set(mat.data());
}
}
void BSShaderTextureArray::read(NIFStream* nif)
{
nif->skip(1); // Unknown
mTextureArrays.resize(nif->get<uint32_t>());
for (std::vector<std::string>& textureArray : mTextureArrays)
nif->getSizedStrings(textureArray, nif->get<uint32_t>());
}
void BSDistantObjectInstancedNode::read(NIFStream* nif)
{
BSMultiBoundNode::read(nif);
mInstances.resize(nif->get<uint32_t>());
for (BSDistantObjectInstance& instance : mInstances)
instance.read(nif);
for (BSShaderTextureArray& textureArray : mShaderTextureArrays)
textureArray.read(nif);
}
}
| 23,965
|
C++
|
.cpp
| 665
| 26.178947
| 116
| 0.573228
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,867
|
property.cpp
|
OpenMW_openmw/components/nif/property.cpp
|
#include "property.hpp"
#include "data.hpp"
#include "texture.hpp"
namespace Nif
{
void NiTextureTransform::read(NIFStream* nif)
{
nif->read(mOffset);
nif->read(mScale);
nif->read(mRotation);
mTransformMethod = static_cast<Method>(nif->get<uint32_t>());
nif->read(mOrigin);
}
void NiTexturingProperty::Texture::read(NIFStream* nif)
{
nif->read(mEnabled);
if (!mEnabled)
return;
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
mSourceTexture.read(nif);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
nif->read(mClamp);
nif->read(mFilter);
}
else
{
uint16_t flags;
nif->read(flags);
mClamp = flags & 0xF;
mFilter = (flags >> 4) & 0xF;
}
if (nif->getVersion() >= NIFStream::generateVersion(20, 5, 0, 4))
nif->read(mMaxAnisotropy);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
nif->read(mUVSet);
// PS2 filtering settings
if (nif->getVersion() <= NIFStream::generateVersion(10, 4, 0, 1))
nif->skip(4);
if (nif->getVersion() <= NIFStream::generateVersion(4, 1, 0, 12))
nif->skip(2); // Unknown
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
{
nif->read(mHasTransform);
if (mHasTransform)
mTransform.read(nif);
}
}
void NiTexturingProperty::Texture::post(Reader& nif)
{
mSourceTexture.post(nif);
}
void NiTexturingProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB_OLD
|| nif->getVersion() >= NIFStream::generateVersion(20, 1, 0, 2))
nif->read(mFlags);
if (nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 1))
mApplyMode = static_cast<ApplyMode>(nif->get<uint32_t>());
mTextures.resize(nif->get<uint32_t>());
for (size_t i = 0; i < mTextures.size(); i++)
{
mTextures[i].read(nif);
if (i == 5 && mTextures[5].mEnabled)
{
nif->read(mEnvMapLumaBias);
nif->read(mBumpMapMatrix);
}
else if (i == 7 && mTextures[7].mEnabled && nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 5))
nif->read(mParallaxOffset);
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
{
mShaderTextures.resize(nif->get<uint32_t>());
mShaderIds.resize(mShaderTextures.size());
for (size_t i = 0; i < mShaderTextures.size(); i++)
{
mShaderTextures[i].read(nif);
if (mShaderTextures[i].mEnabled)
nif->read(mShaderIds[i]);
}
}
}
void NiTexturingProperty::post(Reader& nif)
{
NiProperty::post(nif);
for (Texture& tex : mTextures)
tex.post(nif);
for (Texture& tex : mShaderTextures)
tex.post(nif);
}
void BSSPParallaxParams::read(NIFStream* nif)
{
nif->read(mMaxPasses);
nif->read(mScale);
}
void BSSPRefractionParams::read(NIFStream* nif)
{
nif->read(mStrength);
nif->read(mPeriod);
}
void BSShaderProperty::read(NIFStream* nif)
{
if (nif->getBethVersion() < NIFFile::BethVersion::BETHVER_F76 && recType == RC_BSLightingShaderProperty)
nif->read(mType);
NiShadeProperty::read(nif);
if (nif->getUserVersion() <= 11)
{
nif->read(mType);
nif->read(mShaderFlags1);
nif->read(mShaderFlags2);
nif->read(mEnvMapScale);
return;
}
if (!mName.empty() && nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
return;
if (nif->getBethVersion() <= 131)
{
nif->read(mShaderFlags1);
nif->read(mShaderFlags2);
}
else
{
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76 && recType == RC_BSLightingShaderProperty)
{
nif->read(mType);
// Remap FO76+ shader types to FO4 system so that we can actually use them
// TODO: NifTools spec doesn't do anything about the misplaced EyeEnvmap. Bug or feature?
switch (mType)
{
case 3:
mType = static_cast<uint32_t>(BSLightingShaderType::ShaderType_FaceTint);
break;
case 4:
mType = static_cast<uint32_t>(BSLightingShaderType::ShaderType_SkinTint);
break;
case 5:
mType = static_cast<uint32_t>(BSLightingShaderType::ShaderType_HairTint);
break;
case 12:
mType = static_cast<uint32_t>(BSLightingShaderType::ShaderType_EyeEnvmap);
break;
case 17:
mType = static_cast<uint32_t>(BSLightingShaderType::ShaderType_Terrain);
break;
default:
break;
}
}
uint32_t numShaderFlags1 = 0, numShaderFlags2 = 0;
nif->read(numShaderFlags1);
if (nif->getBethVersion() >= 152)
nif->read(numShaderFlags2);
nif->readVector(mShaderFlags1Hashes, numShaderFlags1);
nif->readVector(mShaderFlags2Hashes, numShaderFlags2);
}
nif->read(mUVOffset);
nif->read(mUVScale);
}
void BSShaderLightingProperty::read(NIFStream* nif)
{
BSShaderProperty::read(nif);
if (nif->getUserVersion() <= 11)
nif->read(mClamp);
}
void BSShaderPPLightingProperty::read(NIFStream* nif)
{
BSShaderLightingProperty::read(nif);
mTextureSet.read(nif);
if (nif->getUserVersion() == 11)
{
if (nif->getBethVersion() >= 15)
mRefraction.read(nif);
if (nif->getBethVersion() >= 25)
mParallax.read(nif);
}
else if (nif->getUserVersion() >= 12)
nif->read(mEmissiveColor);
}
void BSShaderPPLightingProperty::post(Reader& nif)
{
BSShaderLightingProperty::post(nif);
mTextureSet.post(nif);
}
void BSShaderNoLightingProperty::read(NIFStream* nif)
{
BSShaderLightingProperty::read(nif);
mFilename = nif->getSizedString();
if (nif->getBethVersion() >= 27)
nif->read(mFalloffParams);
}
void SkyShaderProperty::read(NIFStream* nif)
{
BSShaderLightingProperty::read(nif);
mFilename = nif->getSizedString();
mSkyObjectType = static_cast<SkyObjectType>(nif->get<uint32_t>());
}
void TallGrassShaderProperty::read(NIFStream* nif)
{
BSShaderProperty::read(nif);
mFilename = nif->getSizedString();
}
void TileShaderProperty::read(NIFStream* nif)
{
BSShaderLightingProperty::read(nif);
mFilename = nif->getSizedString();
}
void BSSPLuminanceParams::read(NIFStream* nif)
{
nif->read(mLumEmittance);
nif->read(mExposureOffset);
nif->read(mFinalExposureMin);
nif->read(mFinalExposureMax);
}
void BSSPWetnessParams::read(NIFStream* nif)
{
nif->read(mSpecScale);
nif->read(mSpecPower);
nif->read(mMinVar);
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_FO4)
nif->read(mEnvMapScale);
nif->read(mFresnelPower);
nif->read(mMetalness);
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO4)
nif->skip(4); // Unknown
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
nif->skip(4); // Unknown
}
void BSSPMLParallaxParams::read(NIFStream* nif)
{
nif->read(mInnerLayerThickness);
nif->read(mRefractionScale);
nif->read(mInnerLayerTextureScale);
nif->read(mEnvMapScale);
}
void BSSPTranslucencyParams::read(NIFStream* nif)
{
nif->read(mSubsurfaceColor);
nif->read(mTransmissiveScale);
nif->read(mTurbulence);
nif->read(mThickObject);
nif->read(mMixAlbedo);
}
void BSLightingShaderProperty::read(NIFStream* nif)
{
BSShaderProperty::read(nif);
if (!mName.empty() && nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
return;
mTextureSet.read(nif);
nif->read(mEmissive);
nif->read(mEmissiveMult);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
nif->read(mRootMaterial);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_STF)
nif->skip(4); // Unknown float
nif->read(mClamp);
nif->read(mAlpha);
nif->read(mRefractionStrength);
if (nif->getBethVersion() < NIFFile::BethVersion::BETHVER_FO4)
nif->read(mGlossiness);
else
nif->read(mSmoothness);
nif->read(mSpecular);
nif->read(mSpecStrength);
if (nif->getBethVersion() < NIFFile::BethVersion::BETHVER_FO4)
nif->readArray(mLightingEffects);
else if (nif->getBethVersion() <= 139)
{
nif->read(mSubsurfaceRolloff);
nif->read(mRimlightPower);
if (mRimlightPower == std::numeric_limits<float>::max())
nif->read(mBacklightPower);
}
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
{
nif->read(mGrayscaleToPaletteScale);
nif->read(mFresnelPower);
mWetness.read(nif);
}
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
{
mLuminance.read(nif);
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_F76)
{
nif->read(mDoTranslucency);
if (mDoTranslucency)
mTranslucency.read(nif);
if (nif->get<uint8_t>() != 0)
{
mTextureArrays.resize(nif->get<uint32_t>());
for (std::vector<std::string>& textureArray : mTextureArrays)
nif->getSizedStrings(textureArray, nif->get<uint32_t>());
}
}
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_STF)
{
nif->skip(4); // Unknown
nif->skip(4); // Unknown
nif->skip(2); // Unknown
}
}
switch (static_cast<BSLightingShaderType>(mType))
{
case BSLightingShaderType::ShaderType_EnvMap:
if (nif->getBethVersion() <= 139)
nif->read(mEnvMapScale);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
{
nif->read(mUseSSR);
nif->read(mWetnessUseSSR);
}
break;
case BSLightingShaderType::ShaderType_SkinTint:
nif->read(mSkinTintColor);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
nif->read(mSkinTintAlpha);
break;
case BSLightingShaderType::ShaderType_HairTint:
nif->read(mHairTintColor);
break;
case BSLightingShaderType::ShaderType_ParallaxOcc:
mParallax.read(nif);
break;
case BSLightingShaderType::ShaderType_MultiLayerParallax:
mMultiLayerParallax.read(nif);
break;
case BSLightingShaderType::ShaderType_SparkleSnow:
nif->read(mSparkle);
break;
case BSLightingShaderType::ShaderType_EyeEnvmap:
nif->read(mCubeMapScale);
nif->read(mLeftEyeReflectionCenter);
nif->read(mRightEyeReflectionCenter);
break;
default:
break;
}
}
void BSLightingShaderProperty::post(Reader& nif)
{
BSShaderProperty::post(nif);
mTextureSet.post(nif);
}
void BSEffectShaderProperty::read(NIFStream* nif)
{
BSShaderProperty::read(nif);
if (!mName.empty() && nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
return;
mSourceTexture = nif->getSizedString();
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_STF)
nif->skip(4); // Unknown
uint32_t miscParams = nif->get<uint32_t>();
mClamp = miscParams & 0xFF;
mLightingInfluence = (miscParams >> 8) & 0xFF;
mEnvMapMinLOD = (miscParams >> 16) & 0xFF;
nif->read(mFalloffParams);
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_F76)
nif->read(mRefractionPower);
nif->read(mBaseColor);
nif->read(mBaseColorScale);
nif->read(mFalloffDepth);
mGreyscaleTexture = nif->getSizedString();
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
{
mEnvMapTexture = nif->getSizedString();
mNormalTexture = nif->getSizedString();
mEnvMaskTexture = nif->getSizedString();
nif->read(mEnvMapScale);
}
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
{
mReflectanceTexture = nif->getSizedString();
mLightingTexture = nif->getSizedString();
nif->read(mEmittanceColor);
mEmitGradientTexture = nif->getSizedString();
mLuminance.read(nif);
}
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_STF)
{
nif->skip(7); // Unknown bytes
nif->skip(6 * sizeof(float)); // Unknown floats
nif->skip(1); // Unknown byte
}
}
void BSSkyShaderProperty::read(NIFStream* nif)
{
BSShaderProperty::read(nif);
mFilename = nif->getSizedString();
mSkyObjectType = static_cast<SkyObjectType>(nif->get<uint32_t>());
}
void BSWaterShaderProperty::read(NIFStream* nif)
{
BSShaderProperty::read(nif);
nif->read(mFlags);
}
void NiAlphaProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
nif->read(mFlags);
nif->read(mThreshold);
}
void NiDitherProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
nif->read(mFlags);
}
void NiFogProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
nif->read(mFlags);
nif->read(mFogDepth);
nif->read(mColour);
}
void NiMaterialProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB_OLD)
nif->read(mFlags);
if (nif->getBethVersion() < 26)
{
nif->read(mAmbient);
nif->read(mDiffuse);
}
nif->read(mSpecular);
nif->read(mEmissive);
nif->read(mGlossiness);
nif->read(mAlpha);
if (nif->getBethVersion() >= 22)
nif->read(mEmissiveMult);
}
void NiShadeProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
if (nif->getBethVersion() <= NIFFile::BethVersion::BETHVER_FO3)
nif->read(mFlags);
}
void NiSpecularProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
mEnable = nif->get<uint16_t>() & 1;
}
void NiStencilProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB_OLD)
nif->read(mFlags);
mEnabled = nif->get<uint8_t>() != 0;
mTestFunction = static_cast<TestFunc>(nif->get<uint32_t>());
nif->read(mStencilRef);
nif->read(mStencilMask);
mFailAction = static_cast<Action>(nif->get<uint32_t>());
mZFailAction = static_cast<Action>(nif->get<uint32_t>());
mPassAction = static_cast<Action>(nif->get<uint32_t>());
mDrawMode = static_cast<DrawMode>(nif->get<uint32_t>());
}
else
{
nif->read(mFlags);
mEnabled = mFlags & 0x1;
mFailAction = static_cast<Action>((mFlags >> 1) & 0x7);
mZFailAction = static_cast<Action>((mFlags >> 4) & 0x7);
mPassAction = static_cast<Action>((mFlags >> 7) & 0x7);
mDrawMode = static_cast<DrawMode>((mFlags >> 10) & 0x3);
mTestFunction = static_cast<TestFunc>((mFlags >> 12) & 0x7);
nif->read(mStencilRef);
nif->read(mStencilMask);
}
}
void NiVertexColorProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
nif->read(mFlags);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
mVertexMode = static_cast<VertexMode>(nif->get<uint32_t>());
mLightingMode = static_cast<LightMode>(nif->get<uint32_t>());
}
else
{
mVertexMode = static_cast<VertexMode>((mFlags >> 4) & 0x3);
mLightingMode = static_cast<LightMode>((mFlags >> 3) & 0x1);
}
}
void NiWireframeProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
mEnable = nif->get<uint16_t>() & 1;
}
void NiZBufferProperty::read(NIFStream* nif)
{
NiProperty::read(nif);
nif->read(mFlags);
if (nif->getVersion() >= NIFStream::generateVersion(4, 1, 0, 12)
&& nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
nif->read(mTestFunction);
else
mTestFunction = (mFlags >> 2) & 0x7;
}
}
| 18,336
|
C++
|
.cpp
| 502
| 25.788845
| 117
| 0.553726
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,868
|
data.cpp
|
OpenMW_openmw/components/nif/data.cpp
|
#include "data.hpp"
#include <components/debug/debuglog.hpp>
#include "exception.hpp"
#include "nifkey.hpp"
#include "node.hpp"
namespace Nif
{
void NiGeometryData::read(NIFStream* nif)
{
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 114))
nif->read(mGroupId);
nif->read(mNumVertices);
bool isPSysData = false;
switch (recType)
{
case RC_NiPSysData:
case RC_NiMeshPSysData:
case RC_BSStripPSysData:
isPSysData = true;
break;
default:
break;
}
bool hasData = !isPSysData || nif->getBethVersion() < NIFFile::BethVersion::BETHVER_FO3;
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
{
nif->read(mKeepFlags);
nif->read(mCompressFlags);
}
if (nif->get<bool>() && hasData)
nif->readVector(mVertices, mNumVertices);
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
{
nif->read(mDataFlags);
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS
&& nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
nif->read(mMaterialHash);
}
if (nif->get<bool>() && hasData)
{
nif->readVector(mNormals, mNumVertices);
if (mDataFlags & DataFlag_HasTangents)
{
nif->readVector(mTangents, mNumVertices);
nif->readVector(mBitangents, mNumVertices);
}
}
nif->read(mBoundingSphere);
if (nif->get<bool>() && hasData)
nif->readVector(mColors, mNumVertices);
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0))
nif->read(mDataFlags);
// In 4.0.0.2 the flags field corresponds to the number of UV sets.
// In later revisions the part that corresponds to the number is narrower.
uint16_t numUVs = mDataFlags;
if (nif->getVersion() > NIFFile::NIFVersion::VER_MW)
{
numUVs &= DataFlag_NumUVsMask;
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() > 0)
numUVs &= DataFlag_HasUV;
}
else if (!nif->get<bool>())
numUVs = 0;
if (hasData)
{
mUVList.resize(numUVs);
for (std::vector<osg::Vec2f>& list : mUVList)
{
nif->readVector(list, mNumVertices);
// flip the texture coordinates to convert them to the OpenGL convention of bottom-left image origin
for (osg::Vec2f& uv : list)
uv.y() = 1.f - uv.y();
}
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
{
nif->read(mConsistencyType);
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 4))
nif->skip(4); // Additional data
}
}
void NiTriBasedGeomData::read(NIFStream* nif)
{
NiGeometryData::read(nif);
nif->read(mNumTriangles);
}
void NiTriShapeData::read(NIFStream* nif)
{
NiTriBasedGeomData::read(nif);
uint32_t numIndices;
nif->read(numIndices);
if (nif->getVersion() > NIFFile::NIFVersion::VER_OB_OLD && !nif->get<bool>())
numIndices = 0;
nif->readVector(mTriangles, numIndices);
mMatchGroups.resize(nif->get<uint16_t>());
for (auto& group : mMatchGroups)
nif->readVector(group, nif->get<uint16_t>());
}
void NiTriStripsData::read(NIFStream* nif)
{
NiTriBasedGeomData::read(nif);
uint16_t numStrips;
nif->read(numStrips);
std::vector<uint16_t> lengths;
nif->readVector(lengths, numStrips);
if (nif->getVersion() > NIFFile::NIFVersion::VER_OB_OLD && !nif->get<bool>())
numStrips = 0;
mStrips.resize(numStrips);
for (int i = 0; i < numStrips; i++)
nif->readVector(mStrips[i], lengths[i]);
}
void NiLinesData::read(NIFStream* nif)
{
NiGeometryData::read(nif);
std::vector<uint8_t> flags;
nif->readVector(flags, mNumVertices);
// Can't construct a line from a single vertex.
if (mNumVertices < 2)
return;
// There can't be more than 2 indices for each vertex
mLines.reserve(mNumVertices * 2);
// Convert connectivity flags into usable geometry. The last element needs special handling.
for (uint16_t i = 0; i < mNumVertices - 1; ++i)
{
if (flags[i] & 1)
{
mLines.emplace_back(i);
mLines.emplace_back(i + 1);
}
}
// If there are just two vertices, they can be connected twice. Probably isn't critical.
if (flags[mNumVertices - 1] & 1)
{
mLines.emplace_back(mNumVertices - 1);
mLines.emplace_back(0);
}
mLines.shrink_to_fit();
}
void NiPosData::read(NIFStream* nif)
{
mKeyList = std::make_shared<Vector3KeyMap>();
mKeyList->read(nif);
}
void NiUVData::read(NIFStream* nif)
{
for (FloatKeyMapPtr& keys : mKeyList)
{
keys = std::make_shared<FloatKeyMap>();
keys->read(nif);
}
}
void NiFloatData::read(NIFStream* nif)
{
mKeyList = std::make_shared<FloatKeyMap>();
mKeyList->read(nif);
}
void NiPixelFormat::read(NIFStream* nif)
{
mFormat = static_cast<Format>(nif->get<uint32_t>());
if (nif->getVersion() <= NIFStream::generateVersion(10, 4, 0, 1))
{
nif->readArray(mColorMasks);
nif->read(mBitsPerPixel);
nif->readArray(mCompareBits);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mPixelTiling);
}
else
{
mBitsPerPixel = nif->get<uint8_t>();
nif->read(mRendererHint);
nif->read(mExtraData);
nif->read(mFlags);
nif->read(mPixelTiling);
if (nif->getVersion() >= NIFStream::generateVersion(20, 3, 0, 4))
nif->read(mUseSrgb);
for (int i = 0; i < 4; i++)
mChannels[i].read(nif);
}
}
void NiPixelFormat::ChannelData::read(NIFStream* nif)
{
mType = static_cast<Type>(nif->get<uint32_t>());
mConvention = static_cast<Convention>(nif->get<uint32_t>());
nif->read(mBitsPerChannel);
nif->read(mSigned);
}
void NiPixelData::read(NIFStream* nif)
{
mPixelFormat.read(nif);
mPalette.read(nif);
mMipmaps.resize(nif->get<uint32_t>());
nif->read(mBytesPerPixel);
for (Mipmap& mip : mMipmaps)
{
nif->read(mip.mWidth);
nif->read(mip.mHeight);
nif->read(mip.mOffset);
}
uint32_t numPixels;
nif->read(numPixels);
if (nif->getVersion() >= NIFStream::generateVersion(10, 4, 0, 2))
nif->read(mNumFaces);
nif->readVector(mData, numPixels * mNumFaces);
}
void NiPixelData::post(Reader& nif)
{
mPalette.post(nif);
}
void NiColorData::read(NIFStream* nif)
{
mKeyMap = std::make_shared<Vector4KeyMap>();
mKeyMap->read(nif);
}
void NiVisData::read(NIFStream* nif)
{
mKeys = std::make_shared<std::map<float, bool>>();
uint32_t numKeys;
nif->read(numKeys);
for (size_t i = 0; i < numKeys; i++)
{
float time;
char value;
nif->read(time);
nif->read(value);
(*mKeys)[time] = (value != 0);
}
}
void NiSkinInstance::read(NIFStream* nif)
{
mData.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 101))
mPartitions.read(nif);
mRoot.read(nif);
readRecordList(nif, mBones);
}
void NiSkinInstance::post(Reader& nif)
{
mData.post(nif);
mPartitions.post(nif);
mRoot.post(nif);
postRecordList(nif, mBones);
if (mData.empty() || mRoot.empty())
throw Nif::Exception("NiSkinInstance missing root or data", nif.getFilename());
if (mBones.size() != mData->mBones.size())
throw Nif::Exception("Mismatch in NiSkinData bone count", nif.getFilename());
for (auto& bone : mBones)
{
if (bone.empty())
throw Nif::Exception("Oops: Missing bone! Don't know how to handle this.", nif.getFilename());
bone->setBone();
}
}
const Nif::NiSkinPartition* NiSkinInstance::getPartitions() const
{
const Nif::NiSkinPartition* partitions = nullptr;
if (!mPartitions.empty())
partitions = mPartitions.getPtr();
else if (!mData.empty() && !mData->mPartitions.empty())
partitions = mData->mPartitions.getPtr();
return partitions;
}
void BSDismemberSkinInstance::read(NIFStream* nif)
{
NiSkinInstance::read(nif);
mParts.resize(nif->get<uint32_t>());
for (BodyPart& part : mParts)
{
nif->read(part.mFlags);
nif->read(part.mType);
}
}
void BSSkinInstance::read(NIFStream* nif)
{
mRoot.read(nif);
mData.read(nif);
readRecordList(nif, mBones);
nif->readVector(mScales, nif->get<uint32_t>());
}
void BSSkinInstance::post(Reader& nif)
{
mRoot.post(nif);
mData.post(nif);
postRecordList(nif, mBones);
if (mData.empty() || mRoot.empty())
throw Nif::Exception("BSSkin::Instance missing root or data", nif.getFilename());
if (mBones.size() != mData->mBones.size())
throw Nif::Exception("Mismatch in BSSkin::BoneData bone count", nif.getFilename());
for (auto& bone : mBones)
{
if (bone.empty())
throw Nif::Exception("Oops: Missing bone! Don't know how to handle this.", nif.getFilename());
bone->setBone();
}
}
void NiSkinData::read(NIFStream* nif)
{
nif->read(mTransform);
uint32_t numBones;
nif->read(numBones);
bool hasVertexWeights = true;
if (nif->getVersion() >= NIFFile::NIFVersion::VER_MW)
{
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 0))
mPartitions.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(4, 2, 1, 0))
nif->read(hasVertexWeights);
}
mBones.resize(numBones);
for (BoneInfo& bi : mBones)
{
nif->read(bi.mTransform);
nif->read(bi.mBoundSphere);
uint16_t numVertices;
nif->read(numVertices);
if (!hasVertexWeights)
continue;
bi.mWeights.resize(numVertices);
for (auto& [vertex, weight] : bi.mWeights)
{
nif->read(vertex);
nif->read(weight);
}
}
}
void NiSkinData::post(Reader& nif)
{
mPartitions.post(nif);
}
void BSSkinBoneData::read(NIFStream* nif)
{
mBones.resize(nif->get<uint32_t>());
for (BoneInfo& bone : mBones)
{
nif->read(bone.mBoundSphere);
nif->read(bone.mTransform);
}
}
void NiSkinPartition::read(NIFStream* nif)
{
mPartitions.resize(nif->get<uint32_t>());
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
{
nif->read(mDataSize);
nif->read(mVertexSize);
mVertexDesc.read(nif);
mVertexData.resize(mDataSize / mVertexSize);
for (auto& vertexData : mVertexData)
vertexData.read(nif, mVertexDesc.mFlags);
}
for (auto& partition : mPartitions)
partition.read(nif);
}
void NiSkinPartition::Partition::read(NIFStream* nif)
{
uint16_t numVertices, numTriangles, numBones, numStrips, bonesPerVertex;
nif->read(numVertices);
nif->read(numTriangles);
nif->read(numBones);
nif->read(numStrips);
nif->read(bonesPerVertex);
nif->readVector(mBones, numBones);
bool hasPresenceFlags = nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0);
if (!hasPresenceFlags || nif->get<bool>())
nif->readVector(mVertexMap, numVertices);
if (!hasPresenceFlags || nif->get<bool>())
nif->readVector(mWeights, static_cast<size_t>(numVertices) * bonesPerVertex);
std::vector<unsigned short> stripLengths;
nif->readVector(stripLengths, numStrips);
if (!hasPresenceFlags || nif->get<bool>())
{
if (numStrips)
{
mStrips.resize(numStrips);
for (size_t i = 0; i < numStrips; i++)
nif->readVector(mStrips[i], stripLengths[i]);
}
else
nif->readVector(mTriangles, numTriangles * 3);
}
if (nif->get<uint8_t>() != 0)
nif->readVector(mBoneIndices, static_cast<size_t>(numVertices) * bonesPerVertex);
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
{
nif->read(mLODLevel);
nif->read(mGlobalVB);
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_SSE)
{
mVertexDesc.read(nif);
nif->readVector(mTrueTriangles, numTriangles * 3);
}
}
// Not technically a part of the loading process
if (mTrueTriangles.empty() && !mVertexMap.empty())
{
if (!mStrips.empty())
{
mTrueStrips = mStrips;
for (auto& strip : mTrueStrips)
for (auto& index : strip)
index = mVertexMap[index];
}
else if (!mTriangles.empty())
{
mTrueTriangles = mTriangles;
for (unsigned short& index : mTrueTriangles)
index = mVertexMap[index];
}
}
}
void NiMorphData::read(NIFStream* nif)
{
uint32_t numMorphs, numVerts;
nif->read(numMorphs);
nif->read(numVerts);
nif->read(mRelativeTargets);
mMorphs.resize(numMorphs);
for (MorphData& morph : mMorphs)
{
morph.mKeyFrames = std::make_shared<FloatKeyMap>();
morph.mKeyFrames->read(nif, /*morph*/ true);
nif->readVector(morph.mVertices, numVerts);
}
}
void NiKeyframeData::read(NIFStream* nif)
{
mRotations = std::make_shared<QuaternionKeyMap>();
mRotations->read(nif);
if (mRotations->mInterpolationType == InterpolationType_XYZ)
{
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 0))
mAxisOrder = static_cast<AxisOrder>(nif->get<uint32_t>());
mXRotations = std::make_shared<FloatKeyMap>();
mYRotations = std::make_shared<FloatKeyMap>();
mZRotations = std::make_shared<FloatKeyMap>();
mXRotations->read(nif);
mYRotations->read(nif);
mZRotations->read(nif);
}
mTranslations = std::make_shared<Vector3KeyMap>();
mTranslations->read(nif);
mScales = std::make_shared<FloatKeyMap>();
mScales->read(nif);
}
void NiPalette::read(NIFStream* nif)
{
bool useAlpha = nif->get<uint8_t>() != 0;
uint32_t alphaMask = useAlpha ? 0 : 0xFF000000;
uint32_t numEntries;
nif->read(numEntries);
// Fill the entire palette with black even if there isn't enough entries.
mColors.resize(numEntries > 256 ? numEntries : 256);
for (uint32_t i = 0; i < numEntries; i++)
{
nif->read(mColors[i]);
mColors[i] |= alphaMask;
}
}
void NiStringPalette::read(NIFStream* nif)
{
mPalette = nif->getStringPalette();
if (nif->get<uint32_t>() != mPalette.size())
Log(Debug::Warning) << "NIFFile Warning: Failed size check in NiStringPalette. File: "
<< nif->getFile().getFilename();
}
void NiBoolData::read(NIFStream* nif)
{
mKeyList = std::make_shared<BoolKeyMap>();
mKeyList->read(nif);
}
void NiBSplineData::read(NIFStream* nif)
{
nif->readVector(mFloatControlPoints, nif->get<uint32_t>());
nif->readVector(mCompactControlPoints, nif->get<uint32_t>());
}
void NiBSplineBasisData::read(NIFStream* nif)
{
nif->read(mNumControlPoints);
}
void NiAdditionalGeometryData::read(NIFStream* nif)
{
nif->read(mNumVertices);
mBlockInfos.resize(nif->get<uint32_t>());
for (DataStream& info : mBlockInfos)
info.read(nif);
mBlocks.resize(nif->get<uint32_t>());
for (DataBlock& block : mBlocks)
block.read(nif, recType == RC_BSPackedAdditionalGeometryData);
}
void NiAdditionalGeometryData::DataStream::read(NIFStream* nif)
{
nif->read(mType);
nif->read(mUnitSize);
nif->read(mTotalSize);
nif->read(mStride);
nif->read(mBlockIndex);
nif->read(mBlockOffset);
nif->read(mFlags);
}
void NiAdditionalGeometryData::DataBlock::read(NIFStream* nif, bool bsPacked)
{
nif->read(mValid);
if (!mValid)
return;
nif->read(mBlockSize);
nif->readVector(mBlockOffsets, nif->get<uint32_t>());
nif->readVector(mDataSizes, nif->get<uint32_t>());
nif->readVector(mData, mDataSizes.size() * mBlockSize);
if (bsPacked)
{
nif->read(mShaderIndex);
nif->read(mTotalSize);
}
}
void BSMultiBound::read(NIFStream* nif)
{
mData.read(nif);
}
void BSMultiBound::post(Reader& nif)
{
mData.post(nif);
}
void BSMultiBoundAABB::read(NIFStream* nif)
{
nif->read(mPosition);
nif->read(mExtents);
}
void BSMultiBoundOBB::read(NIFStream* nif)
{
nif->read(mCenter);
nif->read(mSize);
nif->read(mRotation);
}
void BSMultiBoundSphere::read(NIFStream* nif)
{
nif->read(mSphere);
}
void BSAnimNote::read(NIFStream* nif)
{
mType = static_cast<Type>(nif->get<uint32_t>());
nif->read(mTime);
if (mType == Type::GrabIK)
{
nif->read(mArm);
}
else if (mType == Type::LookIK)
{
nif->read(mGain);
nif->read(mState);
}
}
void BSAnimNotes::read(NIFStream* nif)
{
mList.resize(nif->get<uint16_t>());
for (auto& note : mList)
note.read(nif);
}
void BSAnimNotes::post(Reader& nif)
{
postRecordList(nif, mList);
}
} // Namespace
| 19,383
|
C++
|
.cpp
| 562
| 24.802491
| 116
| 0.555633
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,869
|
physics.cpp
|
OpenMW_openmw/components/nif/physics.cpp
|
#include "physics.hpp"
#include "data.hpp"
#include "node.hpp"
#include <array>
namespace Nif
{
/// Non-record data types
void bhkWorldObjCInfoProperty::read(NIFStream* nif)
{
nif->read(mData);
nif->read(mSize);
nif->read(mCapacityAndFlags);
}
void bhkWorldObjectCInfo::read(NIFStream* nif)
{
nif->skip(4); // Unused
mPhaseType = static_cast<BroadPhaseType>(nif->get<uint8_t>());
nif->skip(3); // Unused
mProperty.read(nif);
}
void HavokMaterial::read(NIFStream* nif)
{
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB_OLD)
nif->skip(4); // Unknown
nif->read(mMaterial);
}
void HavokFilter::read(NIFStream* nif)
{
nif->read(mLayer);
nif->read(mFlags);
nif->read(mGroup);
}
void hkSubPartData::read(NIFStream* nif)
{
mHavokFilter.read(nif);
nif->read(mNumVertices);
mHavokMaterial.read(nif);
}
void bhkEntityCInfo::read(NIFStream* nif)
{
mResponseType = static_cast<hkResponseType>(nif->get<uint8_t>());
nif->skip(1); // Unused
nif->read(mProcessContactDelay);
}
void hkpMoppCode::read(NIFStream* nif)
{
uint32_t dataSize;
nif->read(dataSize);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mOffset);
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
nif->read(mBuildType);
nif->readVector(mData, dataSize);
}
void TriangleData::read(NIFStream* nif)
{
nif->readArray(mTriangle);
nif->read(mWeldingInfo);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
nif->read(mNormal);
}
void bhkMeshMaterial::read(NIFStream* nif)
{
mHavokMaterial.read(nif);
mHavokFilter.read(nif);
}
void bhkQsTransform::read(NIFStream* nif)
{
nif->read(mTranslation);
nif->read(mRotation);
}
void bhkCMSBigTri::read(NIFStream* nif)
{
nif->readArray(mTriangle);
nif->read(mMaterial);
nif->read(mWeldingInfo);
}
void bhkCMSChunk::read(NIFStream* nif)
{
nif->read(mTranslation);
nif->read(mMaterialIndex);
nif->read(mReference);
nif->read(mTransformIndex);
nif->readVector(mVertices, nif->get<uint32_t>());
nif->readVector(mIndices, nif->get<uint32_t>());
nif->readVector(mStrips, nif->get<uint32_t>());
nif->readVector(mWeldingInfos, nif->get<uint32_t>());
}
void bhkRigidBodyCInfo::read(NIFStream* nif)
{
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
{
nif->skip(4); // Unused
mHavokFilter.read(nif);
nif->skip(4); // Unused
if (nif->getBethVersion() != NIFFile::BethVersion::BETHVER_FO4)
{
if (nif->getBethVersion() >= 83)
nif->skip(4); // Unused
mResponseType = static_cast<hkResponseType>(nif->get<uint8_t>());
nif->skip(1); // Unused
nif->read(mProcessContactDelay);
}
}
if (nif->getBethVersion() < 83)
nif->skip(4); // Unused
nif->read(mTranslation);
nif->read(mRotation);
nif->read(mLinearVelocity);
nif->read(mAngularVelocity);
// A bit hacky, but this is the only instance where a 3x3 matrix has padding.
for (int i = 0; i < 3; i++)
{
nif->read(mInertiaTensor.mValues[i], 3);
nif->skip(4); // Padding
}
nif->read(mCenter);
nif->read(mMass);
nif->read(mLinearDamping);
nif->read(mAngularDamping);
if (nif->getBethVersion() >= 83)
{
if (nif->getBethVersion() != NIFFile::BethVersion::BETHVER_FO4)
nif->read(mTimeFactor);
nif->read(mGravityFactor);
}
nif->read(mFriction);
if (nif->getBethVersion() >= 83)
nif->read(mRollingFrictionMult);
nif->read(mRestitution);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
{
nif->read(mMaxLinearVelocity);
nif->read(mMaxAngularVelocity);
if (nif->getBethVersion() != NIFFile::BethVersion::BETHVER_FO4)
nif->read(mPenetrationDepth);
}
mMotionType = static_cast<hkMotionType>(nif->get<uint8_t>());
if (nif->getBethVersion() < 83)
mDeactivatorType = static_cast<hkDeactivatorType>(nif->get<uint8_t>());
else
nif->read(mEnableDeactivation);
mSolverDeactivation = static_cast<hkSolverDeactivation>(nif->get<uint8_t>());
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_FO4)
{
nif->skip(1);
nif->read(mPenetrationDepth);
nif->read(mTimeFactor);
nif->skip(4);
mResponseType = static_cast<hkResponseType>(nif->get<uint8_t>());
nif->skip(1); // Unused
nif->read(mProcessContactDelay);
}
mQualityType = static_cast<hkQualityType>(nif->get<uint8_t>());
if (nif->getBethVersion() >= 83)
{
nif->read(mAutoRemoveLevel);
nif->read(mResponseModifierFlags);
nif->read(mNumContactPointShapeKeys);
nif->read(mForceCollidedOntoPPU);
}
if (nif->getBethVersion() == NIFFile::BethVersion::BETHVER_FO4)
nif->skip(3); // Unused
else
nif->skip(12); // Unused
}
void bhkConstraintCInfo::read(NIFStream* nif)
{
nif->get<uint32_t>(); // Number of entities, unused
mEntityA.read(nif);
mEntityB.read(nif);
mPriority = static_cast<ConstraintPriority>(nif->get<uint32_t>());
}
void bhkConstraintCInfo::post(Reader& nif)
{
mEntityA.post(nif);
mEntityB.post(nif);
}
void bhkPositionConstraintMotor::read(NIFStream* nif)
{
nif->read(mMinForce);
nif->read(mMaxForce);
nif->read(mTau);
nif->read(mDamping);
nif->read(mProportionalRecoveryVelocity);
nif->read(mConstantRecoveryVelocity);
nif->read(mEnabled);
}
void bhkVelocityConstraintMotor::read(NIFStream* nif)
{
nif->read(mMinForce);
nif->read(mMaxForce);
nif->read(mTau);
nif->read(mTargetVelocity);
nif->read(mUseVelocityTarget);
nif->read(mEnabled);
}
void bhkSpringDamperConstraintMotor::read(NIFStream* nif)
{
nif->read(mMinForce);
nif->read(mMaxForce);
nif->read(mSpringConstant);
nif->read(mSpringDamping);
nif->read(mEnabled);
}
void bhkConstraintMotorCInfo::read(NIFStream* nif)
{
mType = static_cast<hkMotorType>(nif->get<uint8_t>());
switch (mType)
{
case hkMotorType::Motor_Position:
mPositionMotor.read(nif);
break;
case hkMotorType::Motor_Velocity:
mVelocityMotor.read(nif);
break;
case hkMotorType::Motor_SpringDamper:
mSpringDamperMotor.read(nif);
break;
case hkMotorType::Motor_None:
default:
break;
}
}
void bhkRagdollConstraintCInfo::read(NIFStream* nif)
{
if (nif->getBethVersion() <= 16)
{
nif->read(mDataA.mPivot);
nif->read(mDataA.mPlane);
nif->read(mDataA.mTwist);
nif->read(mDataB.mPivot);
nif->read(mDataB.mPlane);
nif->read(mDataB.mTwist);
}
else
{
nif->read(mDataA.mTwist);
nif->read(mDataA.mPlane);
nif->read(mDataA.mMotor);
nif->read(mDataA.mPivot);
nif->read(mDataB.mTwist);
nif->read(mDataB.mPlane);
nif->read(mDataB.mMotor);
nif->read(mDataB.mPivot);
}
nif->read(mConeMaxAngle);
nif->read(mPlaneMinAngle);
nif->read(mPlaneMaxAngle);
nif->read(mTwistMinAngle);
nif->read(mTwistMaxAngle);
nif->read(mMaxFriction);
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() > 16)
mMotor.read(nif);
}
void bhkHingeConstraintCInfo::read(NIFStream* nif)
{
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
nif->read(mDataA.mPivot);
nif->read(mDataA.mPerpAxis1);
nif->read(mDataA.mPerpAxis2);
nif->read(mDataB.mPivot);
nif->read(mDataB.mAxis);
}
else
{
nif->read(mDataA.mAxis);
nif->read(mDataA.mPerpAxis1);
nif->read(mDataA.mPerpAxis2);
nif->read(mDataA.mPivot);
nif->read(mDataB.mAxis);
nif->read(mDataB.mPerpAxis1);
nif->read(mDataB.mPerpAxis2);
nif->read(mDataB.mPivot);
}
}
void bhkLimitedHingeConstraintCInfo::read(NIFStream* nif)
{
if (nif->getBethVersion() <= 16)
{
nif->read(mDataA.mPivot);
nif->read(mDataA.mAxis);
nif->read(mDataA.mPerpAxis1);
nif->read(mDataA.mPerpAxis2);
nif->read(mDataB.mPivot);
nif->read(mDataB.mAxis);
nif->read(mDataB.mPerpAxis2);
}
else
{
nif->read(mDataA.mAxis);
nif->read(mDataA.mPerpAxis1);
nif->read(mDataA.mPerpAxis2);
nif->read(mDataA.mPivot);
nif->read(mDataB.mAxis);
nif->read(mDataB.mPerpAxis1);
nif->read(mDataB.mPerpAxis2);
nif->read(mDataB.mPivot);
}
nif->read(mMinAngle);
nif->read(mMaxAngle);
nif->read(mMaxFriction);
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() > 16)
mMotor.read(nif);
}
void bhkBallAndSocketConstraintCInfo::read(NIFStream* nif)
{
nif->read(mPivotA);
nif->read(mPivotB);
}
void bhkStiffSpringConstraintCInfo::read(NIFStream* nif)
{
nif->read(mPivotA);
nif->read(mPivotB);
nif->read(mLength);
}
void bhkPrismaticConstraintCInfo::read(NIFStream* nif)
{
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
nif->read(mDataA.mPivot);
nif->read(mDataA.mRotation);
nif->read(mDataA.mPlane);
nif->read(mDataA.mSliding);
nif->read(mDataB.mSliding);
nif->read(mDataB.mPivot);
nif->read(mDataB.mRotation);
nif->read(mDataB.mPlane);
}
else
{
nif->read(mDataA.mSliding);
nif->read(mDataA.mRotation);
nif->read(mDataA.mPlane);
nif->read(mDataA.mPivot);
nif->read(mDataB.mSliding);
nif->read(mDataB.mRotation);
nif->read(mDataB.mPlane);
nif->read(mDataB.mPivot);
}
nif->read(mMinDistance);
nif->read(mMaxDistance);
nif->read(mFriction);
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() >= 17)
mMotor.read(nif);
}
void bhkMalleableConstraintCInfo::read(NIFStream* nif)
{
mType = static_cast<hkConstraintType>(nif->get<uint32_t>());
mInfo.read(nif);
switch (mType)
{
case hkConstraintType::BallAndSocket:
mBallAndSocketInfo.read(nif);
break;
case hkConstraintType::Hinge:
mHingeInfo.read(nif);
break;
case hkConstraintType::LimitedHinge:
mLimitedHingeInfo.read(nif);
break;
case hkConstraintType::Prismatic:
mPrismaticInfo.read(nif);
break;
case hkConstraintType::Ragdoll:
mRagdollInfo.read(nif);
break;
case hkConstraintType::StiffSpring:
mStiffSpringInfo.read(nif);
break;
default:
throw Nif::Exception(
"Unrecognized constraint type in bhkMalleableConstraint", nif->getFile().getFilename());
}
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
nif->read(mTau);
nif->read(mDamping);
}
else
{
nif->read(mStrength);
}
}
void bhkWrappedConstraintData::read(NIFStream* nif)
{
mType = static_cast<hkConstraintType>(nif->get<uint32_t>());
mInfo.read(nif);
switch (mType)
{
case hkConstraintType::BallAndSocket:
mBallAndSocketInfo.read(nif);
break;
case hkConstraintType::Hinge:
mHingeInfo.read(nif);
break;
case hkConstraintType::LimitedHinge:
mLimitedHingeInfo.read(nif);
break;
case hkConstraintType::Prismatic:
mPrismaticInfo.read(nif);
break;
case hkConstraintType::Ragdoll:
mRagdollInfo.read(nif);
break;
case hkConstraintType::StiffSpring:
mStiffSpringInfo.read(nif);
break;
case hkConstraintType::Malleable:
mMalleableInfo.read(nif);
break;
default:
throw Nif::Exception(
"Unrecognized constraint type in bhkWrappedConstraintData", nif->getFile().getFilename());
}
}
void bhkConstraintChainCInfo::read(NIFStream* nif)
{
readRecordList(nif, mEntities);
mInfo.read(nif);
}
void bhkConstraintChainCInfo::post(Reader& nif)
{
postRecordList(nif, mEntities);
}
/// Record types
void bhkCollisionObject::read(NIFStream* nif)
{
NiCollisionObject::read(nif);
nif->read(mFlags);
mBody.read(nif);
}
void bhkNPCollisionObject::read(NIFStream* nif)
{
NiCollisionObject::read(nif);
nif->read(mFlags);
mData.read(nif);
nif->read(mBodyID);
}
void bhkNPCollisionObject::post(Reader& nif)
{
NiCollisionObject::post(nif);
mData.post(nif);
}
void bhkBlendCollisionObject::read(NIFStream* nif)
{
bhkCollisionObject::read(nif);
nif->read(mHeirGain);
nif->read(mVelGain);
if (nif->getBethVersion() <= 8)
nif->skip(8); // Unknown
}
void bhkPhysicsSystem::read(NIFStream* nif)
{
nif->readVector(mData, nif->get<uint32_t>());
}
void bhkRagdollSystem::read(NIFStream* nif)
{
nif->readVector(mData, nif->get<uint32_t>());
}
void bhkWorldObject::read(NIFStream* nif)
{
mShape.read(nif);
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB_OLD)
nif->skip(4); // Unknown
mHavokFilter.read(nif);
mWorldObjectInfo.read(nif);
}
void bhkWorldObject::post(Reader& nif)
{
mShape.post(nif);
}
void bhkEntity::read(NIFStream* nif)
{
bhkWorldObject::read(nif);
mInfo.read(nif);
}
void bhkBvTreeShape::read(NIFStream* nif)
{
mShape.read(nif);
}
void bhkBvTreeShape::post(Reader& nif)
{
mShape.post(nif);
}
void bhkMoppBvTreeShape::read(NIFStream* nif)
{
bhkBvTreeShape::read(nif);
nif->skip(12); // Unused
nif->read(mScale);
mMopp.read(nif);
}
void bhkNiTriStripsShape::read(NIFStream* nif)
{
mHavokMaterial.read(nif);
nif->read(mRadius);
nif->skip(20); // Unused
nif->read(mGrowBy);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mScale);
readRecordList(nif, mData);
uint32_t numFilters;
nif->read(numFilters);
mHavokFilters.resize(numFilters);
for (HavokFilter& filter : mHavokFilters)
filter.read(nif);
}
void bhkNiTriStripsShape::post(Reader& nif)
{
postRecordList(nif, mData);
}
void bhkPackedNiTriStripsShape::read(NIFStream* nif)
{
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
uint16_t numSubshapes;
nif->read(numSubshapes);
mSubshapes.resize(numSubshapes);
for (hkSubPartData& subshape : mSubshapes)
subshape.read(nif);
}
nif->read(mUserData);
nif->skip(4); // Unused
nif->read(mRadius);
nif->skip(4); // Unused
nif->read(mScale);
nif->skip(20); // Duplicates of the two previous fields
mData.read(nif);
}
void bhkPackedNiTriStripsShape::post(Reader& nif)
{
mData.post(nif);
}
void hkPackedNiTriStripsData::read(NIFStream* nif)
{
uint32_t numTriangles;
nif->read(numTriangles);
mTriangles.resize(numTriangles);
for (uint32_t i = 0; i < numTriangles; i++)
mTriangles[i].read(nif);
uint32_t numVertices;
nif->read(numVertices);
bool compressed = false;
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS)
nif->read(compressed);
if (!compressed)
nif->readVector(mVertices, numVertices);
else
nif->skip(6 * numVertices); // Half-precision vectors are not currently supported
if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS)
{
uint16_t numSubshapes;
nif->read(numSubshapes);
mSubshapes.resize(numSubshapes);
for (hkSubPartData& subshape : mSubshapes)
subshape.read(nif);
}
}
void bhkSphereRepShape::read(NIFStream* nif)
{
mHavokMaterial.read(nif);
}
void bhkConvexShape::read(NIFStream* nif)
{
bhkSphereRepShape::read(nif);
nif->read(mRadius);
}
void bhkConvexListShape::read(NIFStream* nif)
{
readRecordList(nif, mSubShapes);
mMaterial.read(nif);
nif->read(mRadius);
nif->skip(8); // Unknown
mChildShapeProperty.read(nif);
nif->read(mUseCachedAABB);
nif->read(mClosestPointMinDistance);
}
void bhkConvexListShape::post(Reader& nif)
{
postRecordList(nif, mSubShapes);
}
void bhkConvexSweepShape::read(NIFStream* nif)
{
mShape.read(nif);
mMaterial.read(nif);
nif->read(mRadius);
nif->skip(12); // Unknown
}
void bhkConvexSweepShape::post(Reader& nif)
{
mShape.post(nif);
}
void bhkConvexVerticesShape::read(NIFStream* nif)
{
bhkConvexShape::read(nif);
mVerticesProperty.read(nif);
mNormalsProperty.read(nif);
nif->readVector(mVertices, nif->get<uint32_t>());
nif->readVector(mNormals, nif->get<uint32_t>());
}
void bhkConvexTransformShape::read(NIFStream* nif)
{
mShape.read(nif);
mHavokMaterial.read(nif);
nif->read(mRadius);
nif->skip(8); // Unused
std::array<float, 16> mat;
nif->readArray(mat);
mTransform.set(mat.data());
}
void bhkConvexTransformShape::post(Reader& nif)
{
mShape.post(nif);
}
void bhkBoxShape::read(NIFStream* nif)
{
bhkConvexShape::read(nif);
nif->skip(8); // Unused
nif->read(mExtents);
nif->skip(4); // Unused
}
void bhkCapsuleShape::read(NIFStream* nif)
{
bhkConvexShape::read(nif);
nif->skip(8); // Unused
nif->read(mPoint1);
nif->read(mRadius1);
nif->read(mPoint2);
nif->read(mRadius2);
}
void bhkCylinderShape::read(NIFStream* nif)
{
bhkConvexShape::read(nif);
nif->skip(8); // Unused
nif->read(mVertexA);
nif->read(mVertexB);
nif->read(mCylinderRadius);
nif->skip(12); // Unused
}
void bhkHeightfieldShape::read(NIFStream* nif)
{
mHavokMaterial.read(nif);
}
void bhkPlaneShape::read(NIFStream* nif)
{
bhkHeightfieldShape::read(nif);
nif->skip(12); // Unused
mPlane = osg::Plane(nif->get<osg::Vec4f>());
nif->read(mExtents);
nif->read(mCenter);
}
void bhkMeshShape::read(NIFStream* nif)
{
nif->skip(8); // Unknown
nif->read(mRadius);
nif->skip(8); // Unknown
nif->read(mScale);
mShapeProperties.resize(nif->get<uint32_t>());
for (bhkWorldObjCInfoProperty& property : mShapeProperties)
property.read(nif);
nif->skip(12); // Unknown
readRecordList(nif, mDataList);
}
void bhkMeshShape::post(Reader& nif)
{
postRecordList(nif, mDataList);
}
void bhkMultiSphereShape::read(NIFStream* nif)
{
bhkSphereRepShape::read(nif);
mShapeProperty.read(nif);
nif->readVector(mSpheres, nif->get<uint32_t>());
}
void bhkListShape::read(NIFStream* nif)
{
readRecordList(nif, mSubshapes);
mHavokMaterial.read(nif);
mChildShapeProperty.read(nif);
mChildFilterProperty.read(nif);
uint32_t numFilters;
nif->read(numFilters);
mHavokFilters.resize(numFilters);
for (HavokFilter& filter : mHavokFilters)
filter.read(nif);
}
void bhkCompressedMeshShape::read(NIFStream* nif)
{
mTarget.read(nif);
nif->read(mUserData);
nif->read(mRadius);
nif->skip(4); // Unknown
nif->read(mScale);
nif->skip(4); // Radius
nif->skip(16); // Scale
mData.read(nif);
}
void bhkCompressedMeshShape::post(Reader& nif)
{
mTarget.post(nif);
mData.post(nif);
}
void bhkCompressedMeshShapeData::read(NIFStream* nif)
{
nif->read(mBitsPerIndex);
nif->read(mBitsPerWIndex);
nif->read(mMaskWIndex);
nif->read(mMaskIndex);
nif->read(mError);
nif->read(mAabbMin);
nif->read(mAabbMax);
nif->read(mWeldingType);
nif->read(mMaterialType);
nif->skip(nif->get<uint32_t>() * 4); // Unused
nif->skip(nif->get<uint32_t>() * 4); // Unused
nif->skip(nif->get<uint32_t>() * 4); // Unused
uint32_t numMaterials;
nif->read(numMaterials);
mMaterials.resize(numMaterials);
for (bhkMeshMaterial& material : mMaterials)
material.read(nif);
nif->skip(4); // Unused
uint32_t numTransforms;
nif->read(numTransforms);
mChunkTransforms.resize(numTransforms);
for (bhkQsTransform& transform : mChunkTransforms)
transform.read(nif);
nif->readVector(mBigVerts, nif->get<uint32_t>());
uint32_t numBigTriangles;
nif->read(numBigTriangles);
mBigTris.resize(numBigTriangles);
for (bhkCMSBigTri& tri : mBigTris)
tri.read(nif);
uint32_t numChunks;
nif->read(numChunks);
mChunks.resize(numChunks);
for (bhkCMSChunk& chunk : mChunks)
chunk.read(nif);
nif->skip(4); // Unused
}
void bhkRigidBody::read(NIFStream* nif)
{
bhkEntity::read(nif);
mInfo.read(nif);
readRecordList(nif, mConstraints);
if (nif->getBethVersion() < 76)
nif->read(mBodyFlags);
else
mBodyFlags = nif->get<uint16_t>();
}
void bhkAabbPhantom::read(NIFStream* nif)
{
bhkPhantom::read(nif);
nif->skip(8); // Unused
nif->read(mAabbMin);
nif->read(mAabbMax);
}
void bhkSimpleShapePhantom::read(NIFStream* nif)
{
bhkShapePhantom::read(nif);
nif->skip(8); // Unused
std::array<float, 16> mat;
nif->readArray(mat);
mTransform.set(mat.data());
}
void bhkConstraint::read(NIFStream* nif)
{
mInfo.read(nif);
}
void bhkConstraint::post(Reader& nif)
{
mInfo.post(nif);
}
void bhkRagdollConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkHingeConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkLimitedHingeConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkBallAndSocketConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkBallSocketConstraintChain::read(NIFStream* nif)
{
uint32_t numPivots = nif->get<uint32_t>();
if (numPivots % 2 != 0)
throw Nif::Exception(
"Invalid number of constraints in bhkBallSocketConstraintChain", nif->getFile().getFilename());
mConstraints.resize(numPivots / 2);
for (bhkBallAndSocketConstraintCInfo& info : mConstraints)
info.read(nif);
nif->read(mTau);
nif->read(mDamping);
nif->read(mConstraintForceMixing);
nif->read(mMaxErrorDistance);
mConstraintChainInfo.read(nif);
}
void bhkBallSocketConstraintChain::post(Reader& nif)
{
mConstraintChainInfo.post(nif);
}
void bhkStiffSpringConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkPrismaticConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkMalleableConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
}
void bhkBreakableConstraint::read(NIFStream* nif)
{
bhkConstraint::read(nif);
mConstraint.read(nif);
nif->read(mThreshold);
nif->read(mRemoveWhenBroken);
}
void bhkUnaryAction::read(NIFStream* nif)
{
mEntity.read(nif);
nif->skip(8); // Unused
}
void bhkUnaryAction::post(Reader& nif)
{
mEntity.post(nif);
}
void bhkLiquidAction::read(NIFStream* nif)
{
nif->skip(12); // Unused
nif->read(mInitialStickForce);
nif->read(mStickStrength);
nif->read(mNeighborDistance);
nif->read(mNeighborStrength);
}
void bhkOrientHingedBodyAction::read(NIFStream* nif)
{
bhkUnaryAction::read(nif);
nif->skip(8); // Unused
nif->read(mHingeAxisLS);
nif->read(mForwardLS);
nif->read(mStrength);
nif->read(mDamping);
nif->skip(8); // Unused
}
void bhkRagdollTemplate::read(NIFStream* nif)
{
Extra::read(nif);
readRecordList(nif, mBones);
}
void bhkRagdollTemplate::post(Reader& nif)
{
Extra::post(nif);
postRecordList(nif, mBones);
}
void bhkRagdollTemplateData::read(NIFStream* nif)
{
nif->read(mName);
nif->read(mMass);
nif->read(mRestitution);
nif->read(mFriction);
nif->read(mRadius);
mHavokMaterial.read(nif);
mConstraints.resize(nif->get<uint32_t>());
for (bhkWrappedConstraintData& constraint : mConstraints)
constraint.read(nif);
}
void bhkPoseArray::BoneTransform::read(NIFStream* nif)
{
nif->read(mTranslation);
nif->read(mRotation);
nif->read(mScale);
}
void bhkPoseArray::read(NIFStream* nif)
{
nif->readVector(mBones, nif->get<uint32_t>());
mPoses.resize(nif->get<uint32_t>());
for (std::vector<BoneTransform>& pose : mPoses)
{
pose.resize(nif->get<uint32_t>());
for (BoneTransform& transform : pose)
transform.read(nif);
}
}
} // Namespace
| 28,292
|
C++
|
.cpp
| 901
| 22.442841
| 111
| 0.573981
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,870
|
base.cpp
|
OpenMW_openmw/components/nif/base.cpp
|
#include "base.hpp"
namespace Nif
{
void Extra::read(NIFStream* nif)
{
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
nif->read(mName);
else if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0))
{
mNext.read(nif);
nif->read(mRecordSize);
}
}
void NiObjectNET::read(NIFStream* nif)
{
nif->read(mName);
if (nif->getVersion() < NIFStream::generateVersion(10, 0, 1, 0))
mExtra.read(nif);
else
readRecordList(nif, mExtraList);
mController.read(nif);
}
void NiObjectNET::post(Reader& nif)
{
mExtra.post(nif);
postRecordList(nif, mExtraList);
mController.post(nif);
}
ExtraList NiObjectNET::getExtraList() const
{
ExtraList list = mExtraList;
for (ExtraPtr extra = mExtra; !extra.empty(); extra = extra->mNext)
list.emplace_back(extra);
return list;
}
}
| 1,013
|
C++
|
.cpp
| 36
| 20.583333
| 77
| 0.571429
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,871
|
controller.cpp
|
OpenMW_openmw/components/nif/controller.cpp
|
#include "controller.hpp"
#include "data.hpp"
#include "exception.hpp"
#include "node.hpp"
#include "particle.hpp"
#include "texture.hpp"
namespace Nif
{
void NiTimeController::read(NIFStream* nif)
{
mNext.read(nif);
nif->read(mFlags);
nif->read(mFrequency);
nif->read(mPhase);
nif->read(mTimeStart);
nif->read(mTimeStop);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
mTarget.read(nif);
}
void NiTimeController::post(Reader& nif)
{
mNext.post(nif);
mTarget.post(nif);
}
void ControlledBlock::read(NIFStream* nif)
{
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mTargetName = nif->getSizedString();
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 106))
mInterpolator.read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(20, 5, 0, 0))
mController.read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
return;
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 110))
{
mBlendInterpolator.read(nif);
nif->read(mBlendIndex);
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 106) && nif->getBethVersion() > 0)
nif->read(mPriority);
if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0)
&& nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 0))
{
mStringPalette.read(nif);
nif->read(mNodeNameOffset);
nif->read(mPropertyTypeOffset);
nif->read(mControllerTypeOffset);
nif->read(mControllerIdOffset);
nif->read(mInterpolatorIdOffset);
}
else
{
nif->read(mNodeName);
nif->read(mPropertyType);
nif->read(mControllerType);
nif->read(mControllerId);
nif->read(mInterpolatorId);
}
}
void ControlledBlock::post(Reader& nif)
{
mInterpolator.post(nif);
mController.post(nif);
mBlendInterpolator.post(nif);
mStringPalette.post(nif);
// TODO: probably should fill the strings with string palette contents here
}
void NiSequence::read(NIFStream* nif)
{
nif->read(mName);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
{
nif->read(mAccumRootName);
mTextKeys.read(nif);
}
mControlledBlocks.resize(nif->get<uint32_t>());
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 106))
nif->read(mArrayGrowBy);
for (ControlledBlock& block : mControlledBlocks)
block.read(nif);
}
void NiSequence::post(Reader& nif)
{
mTextKeys.post(nif);
for (ControlledBlock& block : mControlledBlocks)
block.post(nif);
}
void NiControllerSequence::read(NIFStream* nif)
{
NiSequence::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
return;
nif->read(mWeight);
mTextKeys.read(nif);
mExtrapolationMode = static_cast<NiTimeController::ExtrapolationMode>(nif->get<uint32_t>());
nif->read(mFrequency);
if (nif->getVersion() <= NIFStream::generateVersion(10, 4, 0, 1))
nif->read(mPhase);
nif->read(mStartTime);
nif->read(mStopTime);
if (nif->getVersion() == NIFStream::generateVersion(10, 1, 0, 106))
nif->read(mPlayBackwards);
mManager.read(nif);
nif->read(mAccumRootName);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 113)
&& nif->getVersion() <= NIFStream::generateVersion(20, 1, 0, 0))
mStringPalette.read(nif);
else if (nif->getVersion() >= NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() >= 24)
{
if (nif->getBethVersion() >= 29)
mAnimNotesList.resize(nif->get<uint16_t>());
else
mAnimNotesList.resize(1);
for (auto& notes : mAnimNotesList)
notes.read(nif);
}
}
void NiControllerSequence::post(Reader& nif)
{
NiSequence::post(nif);
mManager.post(nif);
mStringPalette.post(nif);
}
void NiInterpController::read(NIFStream* nif)
{
NiTimeController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 104)
&& nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 108))
nif->read(mManagerControlled);
}
void NiSingleInterpController::read(NIFStream* nif)
{
NiInterpController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 104))
mInterpolator.read(nif);
}
void NiSingleInterpController::post(Reader& nif)
{
NiInterpController::post(nif);
mInterpolator.post(nif);
}
void NiParticleInfo::read(NIFStream* nif)
{
nif->read(mVelocity);
if (nif->getVersion() <= NIFStream::generateVersion(10, 4, 0, 1))
nif->read(mRotationAxis);
nif->read(mAge);
nif->read(mLifespan);
nif->read(mLastUpdate);
nif->read(mSpawnGeneration);
nif->read(mCode);
}
void NiParticleSystemController::read(NIFStream* nif)
{
NiTimeController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
nif->read(mSpeed);
nif->read(mSpeedVariation);
nif->read(mDeclination);
nif->read(mDeclinationVariation);
nif->read(mPlanarAngle);
nif->read(mPlanarAngleVariation);
nif->read(mInitialNormal);
nif->read(mInitialColor);
nif->read(mInitialSize);
nif->read(mEmitStartTime);
nif->read(mEmitStopTime);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
{
mResetParticleSystem = nif->get<uint8_t>() != 0;
nif->read(mBirthRate);
}
nif->read(mLifetime);
nif->read(mLifetimeVariation);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
nif->read(mEmitFlags);
nif->read(mEmitterDimensions);
mEmitter.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
{
nif->read(mNumSpawnGenerations);
nif->read(mPercentageSpawned);
nif->read(mSpawnMultiplier);
nif->read(mSpawnSpeedChaos);
nif->read(mSpawnDirChaos);
mParticles.resize(nif->get<uint16_t>());
nif->read(mNumValid);
for (NiParticleInfo& particle : mParticles)
particle.read(nif);
nif->skip(4); // NiEmitterModifier link
}
mModifier.read(nif);
mCollider.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 15))
nif->read(mStaticTargetBound);
}
void NiParticleSystemController::post(Reader& nif)
{
NiTimeController::post(nif);
mEmitter.post(nif);
mModifier.post(nif);
mCollider.post(nif);
}
void NiMaterialColorController::read(NIFStream* nif)
{
NiPoint3InterpController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
mTargetColor = static_cast<TargetColor>(nif->get<uint16_t>() & 3);
else
mTargetColor = static_cast<TargetColor>((mFlags >> 4) & 3);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiMaterialColorController::post(Reader& nif)
{
NiPoint3InterpController::post(nif);
mData.post(nif);
}
void NiLookAtController::read(NIFStream* nif)
{
NiTimeController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mLookAtFlags);
mLookAt.read(nif);
}
void NiLookAtController::post(Reader& nif)
{
NiTimeController::post(nif);
mLookAt.post(nif);
}
void NiPathController::read(NIFStream* nif)
{
NiTimeController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mPathFlags);
else
mPathFlags = (mFlags >> 4);
nif->read(mBankDirection);
nif->read(mMaxBankAngle);
nif->read(mSmoothing);
nif->read(mFollowAxis);
mPathData.read(nif);
mPercentData.read(nif);
}
void NiPathController::post(Reader& nif)
{
NiTimeController::post(nif);
mPathData.post(nif);
mPercentData.post(nif);
}
void NiUVController::read(NIFStream* nif)
{
NiTimeController::read(nif);
nif->read(mUvSet);
mData.read(nif);
}
void NiUVController::post(Reader& nif)
{
NiTimeController::post(nif);
mData.post(nif);
}
void NiKeyframeController::read(NIFStream* nif)
{
NiSingleInterpController::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiKeyframeController::post(Reader& nif)
{
NiSingleInterpController::post(nif);
mData.post(nif);
}
void NiMultiTargetTransformController::read(NIFStream* nif)
{
NiInterpController::read(nif);
mExtraTargets.resize(nif->get<uint16_t>());
for (NiAVObjectPtr& extraTarget : mExtraTargets)
extraTarget.read(nif);
}
void NiMultiTargetTransformController::post(Reader& nif)
{
NiInterpController::post(nif);
postRecordList(nif, mExtraTargets);
}
void NiAlphaController::read(NIFStream* nif)
{
NiFloatInterpController::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiAlphaController::post(Reader& nif)
{
NiFloatInterpController::post(nif);
mData.post(nif);
}
void NiRollController::read(NIFStream* nif)
{
NiSingleInterpController::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiRollController::post(Reader& nif)
{
NiSingleInterpController::post(nif);
mData.post(nif);
}
void NiGeomMorpherController::read(NIFStream* nif)
{
NiInterpController::read(nif);
if (nif->getVersion() >= NIFFile::NIFVersion::VER_OB_OLD)
mUpdateNormals = nif->get<uint16_t>() & 1;
mData.read(nif);
if (nif->getVersion() < NIFFile::NIFVersion::VER_MW)
return;
mAlwaysActive = nif->get<uint8_t>() != 0;
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 105))
return;
if (nif->getVersion() <= NIFFile::NIFVersion::VER_OB)
{
readRecordList(nif, mInterpolators);
if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0) && nif->getBethVersion() >= 10)
nif->skip(4 * nif->get<uint32_t>()); // Unknown
return;
}
mInterpolators.resize(nif->get<uint32_t>());
mWeights.resize(mInterpolators.size());
for (size_t i = 0; i < mInterpolators.size(); i++)
{
mInterpolators[i].read(nif);
nif->read(mWeights[i]);
}
}
void NiGeomMorpherController::post(Reader& nif)
{
NiInterpController::post(nif);
mData.post(nif);
postRecordList(nif, mInterpolators);
}
void NiVisController::read(NIFStream* nif)
{
NiBoolInterpController::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiVisController::post(Reader& nif)
{
NiBoolInterpController::post(nif);
mData.post(nif);
}
void NiFlipController::read(NIFStream* nif)
{
NiFloatInterpController::read(nif);
mTexSlot = static_cast<NiTexturingProperty::TextureType>(nif->get<uint32_t>());
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
{
nif->read(mTimeStart);
nif->read(mDelta);
}
readRecordList(nif, mSources);
}
void NiFlipController::post(Reader& nif)
{
NiFloatInterpController::post(nif);
postRecordList(nif, mSources);
}
void NiTextureTransformController::read(NIFStream* nif)
{
NiFloatInterpController::read(nif);
nif->read(mShaderMap);
mTexSlot = static_cast<NiTexturingProperty::TextureType>(nif->get<uint32_t>());
nif->read(mTransformMember);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiTextureTransformController::post(Reader& nif)
{
NiFloatInterpController::post(nif);
mData.post(nif);
}
void NiBoneLODController::read(NIFStream* nif)
{
NiTimeController::read(nif);
nif->read(mLOD);
mNodeGroups.resize(nif->get<uint32_t>());
nif->read(mNumNodeGroups);
for (NiAVObjectList& group : mNodeGroups)
readRecordList(nif, group);
if (nif->getBethVersion() != 0 || nif->getVersion() < NIFStream::generateVersion(4, 2, 2, 0))
return;
mSkinnedShapeGroups.resize(nif->get<uint32_t>());
for (std::vector<SkinInfo>& group : mSkinnedShapeGroups)
{
group.resize(nif->get<uint32_t>());
for (SkinInfo& info : group)
{
info.mShape.read(nif);
info.mSkin.read(nif);
}
}
readRecordList(nif, mShapeGroups);
}
void NiBoneLODController::post(Reader& nif)
{
NiTimeController::post(nif);
for (NiAVObjectList& group : mNodeGroups)
postRecordList(nif, group);
for (std::vector<SkinInfo>& group : mSkinnedShapeGroups)
{
for (SkinInfo& info : group)
{
info.mShape.post(nif);
info.mSkin.post(nif);
}
}
postRecordList(nif, mShapeGroups);
}
void bhkBlendController::read(NIFStream* nif)
{
NiTimeController::read(nif);
uint32_t numKeys;
nif->read(numKeys);
// Is this possible?
if (numKeys != 0)
throw Nif::Exception(
"Unsupported keys in bhkBlendController " + std::to_string(recIndex), nif->getFile().getFilename());
}
void BSEffectShaderPropertyFloatController::read(NIFStream* nif)
{
NiFloatInterpController::read(nif);
nif->read(mControlledVariable);
}
void BSEffectShaderPropertyColorController::read(NIFStream* nif)
{
NiPoint3InterpController::read(nif);
nif->read(mControlledColor);
}
void BSKeyframeController::read(NIFStream* nif)
{
NiKeyframeController::read(nif);
mData2.read(nif);
}
void BSKeyframeController::post(Reader& nif)
{
NiKeyframeController::post(nif);
mData2.post(nif);
}
void BSLagBoneController::read(NIFStream* nif)
{
NiTimeController::read(nif);
nif->read(mLinearVelocity);
nif->read(mLinearRotation);
nif->read(mMaximumDistance);
}
void BSProceduralLightningController::read(NIFStream* nif)
{
NiTimeController::read(nif);
mGenerationInterp.read(nif);
mMutationInterp.read(nif);
mSubdivisionInterp.read(nif);
mNumBranchesInterp.read(nif);
mNumBranchesVarInterp.read(nif);
mLengthInterp.read(nif);
mLengthVarInterp.read(nif);
mWidthInterp.read(nif);
mArcOffsetInterp.read(nif);
nif->read(mSubdivisions);
nif->read(mNumBranches);
nif->read(mNumBranchesVar);
nif->read(mLength);
nif->read(mLengthVar);
nif->read(mWidth);
nif->read(mChildWidthMult);
nif->read(mArcOffset);
nif->read(mFadeMainBolt);
nif->read(mFadeChildBolts);
nif->read(mAnimateArcOffset);
mShaderProperty.read(nif);
}
void BSProceduralLightningController::post(Reader& nif)
{
NiTimeController::post(nif);
mGenerationInterp.post(nif);
mMutationInterp.post(nif);
mSubdivisionInterp.post(nif);
mNumBranchesInterp.post(nif);
mNumBranchesVarInterp.post(nif);
mLengthInterp.post(nif);
mLengthVarInterp.post(nif);
mWidthInterp.post(nif);
mArcOffsetInterp.post(nif);
mShaderProperty.post(nif);
}
void NiControllerManager::read(NIFStream* nif)
{
NiTimeController::read(nif);
nif->read(mCumulative);
readRecordList(nif, mSequences);
mObjectPalette.read(nif);
}
void NiControllerManager::post(Reader& nif)
{
NiTimeController::post(nif);
postRecordList(nif, mSequences);
mObjectPalette.post(nif);
}
void NiExtraDataController::read(NIFStream* nif)
{
NiSingleInterpController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0))
nif->read(mExtraDataName);
}
void NiFloatExtraDataController::read(NIFStream* nif)
{
NiExtraDataController::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 104))
return;
// Unknown
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 0))
{
uint8_t numExtraBytes;
nif->read(numExtraBytes);
nif->skip(7);
nif->skip(numExtraBytes);
}
mData.read(nif);
}
void NiFloatExtraDataController::post(Reader& nif)
{
NiExtraDataController::post(nif);
mData.post(nif);
}
void NiFloatsExtraDataController::read(NIFStream* nif)
{
NiExtraDataController::read(nif);
nif->read(mFloatsExtraDataIndex);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
}
void NiFloatsExtraDataController::post(Reader& nif)
{
NiExtraDataController::post(nif);
mData.post(nif);
}
void NiFloatsExtraDataPoint3Controller::read(NIFStream* nif)
{
NiExtraDataController::read(nif);
nif->read(mFloatsExtraDataIndex);
}
void NiPathInterpolator::read(NIFStream* nif)
{
nif->read(mFlags);
nif->read(mBankDirection);
nif->read(mMaxBankAngle);
nif->read(mSmoothing);
nif->read(mFollowAxis);
mPathData.read(nif);
mPercentData.read(nif);
}
void NiPathInterpolator::post(Reader& nif)
{
mPathData.post(nif);
mPercentData.post(nif);
}
void NiLookAtInterpolator::read(NIFStream* nif)
{
nif->read(mLookAtFlags);
mLookAt.read(nif);
nif->read(mLookAtName);
if (nif->getVersion() <= NIFStream::generateVersion(20, 4, 0, 12))
nif->read(mTransform);
mTranslation.read(nif);
mRoll.read(nif);
mScale.read(nif);
}
void NiLookAtInterpolator::post(Reader& nif)
{
mLookAt.post(nif);
mTranslation.post(nif);
mRoll.post(nif);
mScale.post(nif);
}
void NiBlendInterpolator::read(NIFStream* nif)
{
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 112))
{
nif->read(mFlags);
mItems.resize(nif->get<uint8_t>());
nif->read(mWeightThreshold);
if (!(mFlags & Flag_ManagerControlled))
{
mInterpCount = nif->get<uint8_t>();
mSingleIndex = nif->get<uint8_t>();
mHighPriority = nif->get<int8_t>();
mNextHighPriority = nif->get<int8_t>();
nif->read(mSingleTime);
nif->read(mHighWeightsSum);
nif->read(mNextHighWeightsSum);
nif->read(mHighEaseSpinner);
for (Item& item : mItems)
item.read(nif);
}
return;
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 110))
{
mItems.resize(nif->get<uint8_t>());
for (Item& item : mItems)
item.read(nif);
if (nif->get<bool>())
mFlags |= Flag_ManagerControlled;
nif->read(mWeightThreshold);
if (nif->get<bool>())
mFlags |= Flag_OnlyUseHighestWeight;
mInterpCount = nif->get<uint8_t>();
mSingleIndex = nif->get<uint8_t>();
mSingleInterpolator.read(nif);
nif->read(mSingleTime);
mHighPriority = nif->get<int8_t>();
mNextHighPriority = nif->get<int8_t>();
return;
}
mItems.resize(nif->get<uint16_t>());
nif->read(mArrayGrowBy);
for (Item& item : mItems)
item.read(nif);
if (nif->get<bool>())
mFlags |= Flag_ManagerControlled;
nif->read(mWeightThreshold);
if (nif->get<bool>())
mFlags |= Flag_OnlyUseHighestWeight;
nif->read(mInterpCount);
nif->read(mSingleIndex);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 108))
{
mSingleInterpolator.read(nif);
nif->read(mSingleTime);
}
nif->read(mHighPriority);
nif->read(mNextHighPriority);
}
void NiBlendInterpolator::post(Reader& nif)
{
for (Item& item : mItems)
item.post(nif);
mSingleInterpolator.post(nif);
}
void NiBlendInterpolator::Item::read(NIFStream* nif)
{
mInterpolator.read(nif);
nif->read(mWeight);
nif->read(mNormalizedWeight);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 110))
mPriority = nif->get<int8_t>();
else
nif->read(mPriority);
nif->read(mEaseSpinner);
}
void NiBlendInterpolator::Item::post(Reader& nif)
{
mInterpolator.post(nif);
}
void NiBSplineInterpolator::read(NIFStream* nif)
{
nif->read(mStartTime);
nif->read(mStopTime);
mSplineData.read(nif);
mBasisData.read(nif);
}
void NiBSplineInterpolator::post(Reader& nif)
{
mSplineData.post(nif);
mBasisData.post(nif);
}
void NiBSplineFloatInterpolator::read(NIFStream* nif)
{
NiBSplineInterpolator::read(nif);
nif->read(mValue);
nif->read(mHandle);
}
void NiBSplineCompFloatInterpolator::read(NIFStream* nif)
{
NiBSplineFloatInterpolator::read(nif);
nif->read(mOffset);
nif->read(mHalfRange);
}
void NiBSplinePoint3Interpolator::read(NIFStream* nif)
{
NiBSplineInterpolator::read(nif);
nif->read(mValue);
nif->read(mHandle);
}
void NiBSplineCompPoint3Interpolator::read(NIFStream* nif)
{
NiBSplinePoint3Interpolator::read(nif);
nif->read(mOffset);
nif->read(mHalfRange);
}
void NiBSplineTransformInterpolator::read(NIFStream* nif)
{
NiBSplineInterpolator::read(nif);
nif->read(mValue);
nif->read(mTranslationHandle);
nif->read(mRotationHandle);
nif->read(mScaleHandle);
}
void NiBSplineCompTransformInterpolator::read(NIFStream* nif)
{
NiBSplineTransformInterpolator::read(nif);
nif->read(mTranslationOffset);
nif->read(mTranslationHalfRange);
nif->read(mRotationOffset);
nif->read(mRotationHalfRange);
nif->read(mScaleOffset);
nif->read(mScaleHalfRange);
}
void BSTreadTransform::read(NIFStream* nif)
{
nif->read(mName);
nif->read(mTransform1);
nif->read(mTransform2);
}
void BSTreadTransfInterpolator::read(NIFStream* nif)
{
mTransforms.resize(nif->get<uint32_t>());
for (BSTreadTransform& transform : mTransforms)
transform.read(nif);
mData.read(nif);
}
void BSTreadTransfInterpolator::post(Reader& nif)
{
mData.post(nif);
}
}
| 24,720
|
C++
|
.cpp
| 734
| 24.885559
| 116
| 0.593899
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,872
|
extra.cpp
|
OpenMW_openmw/components/nif/extra.cpp
|
#include "extra.hpp"
namespace Nif
{
void NiExtraData::read(NIFStream* nif)
{
Extra::read(nif);
nif->readVector(mData, mRecordSize);
}
void NiStringsExtraData::read(NIFStream* nif)
{
Extra::read(nif);
nif->getSizedStrings(mData, nif->get<uint32_t>());
}
void NiTextKeyExtraData::read(NIFStream* nif)
{
Extra::read(nif);
uint32_t numKeys;
nif->read(numKeys);
mList.resize(numKeys);
for (TextKey& key : mList)
{
nif->read(key.mTime);
nif->read(key.mText);
}
}
void NiVertWeightsExtraData::read(NIFStream* nif)
{
Extra::read(nif);
nif->skip(nif->get<uint16_t>() * sizeof(float)); // vertex weights I guess
}
void BSBound::read(NIFStream* nif)
{
Extra::read(nif);
nif->read(mCenter);
nif->read(mExtents);
}
void BSFurnitureMarker::LegacyFurniturePosition::read(NIFStream* nif)
{
nif->read(mOffset);
nif->read(mOrientation);
nif->read(mPositionRef);
nif->skip(1); // Position ref 2
}
void BSFurnitureMarker::FurniturePosition::read(NIFStream* nif)
{
nif->read(mOffset);
nif->read(mHeading);
nif->read(mType);
nif->read(mEntryPoint);
}
void BSFurnitureMarker::read(NIFStream* nif)
{
Extra::read(nif);
uint32_t num;
nif->read(num);
if (nif->getBethVersion() <= NIFFile::BethVersion::BETHVER_FO3)
{
mLegacyMarkers.resize(num);
for (auto& marker : mLegacyMarkers)
marker.read(nif);
}
else
{
mMarkers.resize(num);
for (auto& marker : mMarkers)
marker.read(nif);
}
}
void BSInvMarker::read(NIFStream* nif)
{
Extra::read(nif);
float rotX = nif->get<uint16_t>() / 1000.f;
float rotY = nif->get<uint16_t>() / 1000.f;
float rotZ = nif->get<uint16_t>() / 1000.f;
mRotation = osg::Quat(rotX, osg::X_AXIS, rotY, osg::Y_AXIS, rotZ, osg::Z_AXIS);
nif->read(mScale);
}
void BSBehaviorGraphExtraData::read(NIFStream* nif)
{
Extra::read(nif);
nif->read(mFile);
nif->read(mControlsBaseSkeleton);
}
void BSBoneLODExtraData::read(NIFStream* nif)
{
Extra::read(nif);
mData.resize(nif->get<uint32_t>());
for (BoneLOD& lod : mData)
lod.read(nif);
}
void BSBoneLODExtraData::BoneLOD::read(NIFStream* nif)
{
nif->read(mDistance);
nif->read(mBone);
}
void BSDecalPlacementVectorExtraData::read(NIFStream* nif)
{
NiFloatExtraData::read(nif);
mBlocks.resize(nif->get<uint16_t>());
for (Block& block : mBlocks)
block.read(nif);
}
void BSDecalPlacementVectorExtraData::Block::read(NIFStream* nif)
{
nif->readVector(mPoints, nif->get<uint16_t>());
nif->readVector(mNormals, mPoints.size());
}
void BSClothExtraData::read(NIFStream* nif)
{
nif->readVector(mData, nif->get<uint32_t>());
}
void BSCollisionQueryProxyExtraData::read(NIFStream* nif)
{
nif->readVector(mData, nif->get<uint32_t>());
}
void BSConnectPoint::Point::read(NIFStream* nif)
{
mParent = nif->getSizedString();
mName = nif->getSizedString();
nif->read(mTransform.mRotation);
nif->read(mTransform.mTranslation);
nif->read(mTransform.mScale);
}
void BSConnectPoint::Parents::read(NIFStream* nif)
{
NiExtraData::read(nif);
mPoints.resize(nif->get<uint32_t>());
for (Point& point : mPoints)
point.read(nif);
}
void BSConnectPoint::Children::read(NIFStream* nif)
{
NiExtraData::read(nif);
nif->read(mSkinned);
nif->getSizedStrings(mPointNames, nif->get<uint32_t>());
}
void BSPackedGeomDataCombined::read(NIFStream* nif)
{
nif->read(mGrayscaleToPaletteScale);
nif->read(mTransform);
nif->read(mBoundingSphere);
}
void BSPackedGeomObject::read(NIFStream* nif)
{
nif->read(mFileHash);
nif->read(mDataOffset);
}
void BSPackedSharedGeomData::read(NIFStream* nif)
{
nif->read(mNumVertices);
nif->read(mLODLevels);
nif->read(mLOD0TriCount);
nif->read(mLOD0TriOffset);
nif->read(mLOD1TriCount);
nif->read(mLOD1TriOffset);
nif->read(mLOD2TriCount);
nif->read(mLOD2TriOffset);
mCombined.resize(nif->get<uint32_t>());
for (BSPackedGeomDataCombined& data : mCombined)
data.read(nif);
mVertexDesc.read(nif);
}
void BSPackedCombinedSharedGeomDataExtra::read(NIFStream* nif)
{
NiExtraData::read(nif);
mVertexDesc.read(nif);
nif->read(mNumVertices);
nif->read(mNumTriangles);
nif->read(mFlags1);
nif->read(mFlags2);
mObjects.resize(nif->get<uint32_t>());
for (BSPackedGeomObject& object : mObjects)
object.read(nif);
mObjectData.resize(mObjects.size());
for (BSPackedSharedGeomData& objectData : mObjectData)
objectData.read(nif);
}
}
| 5,364
|
C++
|
.cpp
| 178
| 22.292135
| 87
| 0.59188
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,873
|
particle.cpp
|
OpenMW_openmw/components/nif/particle.cpp
|
#include "particle.hpp"
#include "data.hpp"
namespace Nif
{
void NiParticleModifier::read(NIFStream* nif)
{
mNext.read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
mController.read(nif);
}
void NiParticleModifier::post(Reader& nif)
{
mNext.post(nif);
mController.post(nif);
}
void NiParticleGrowFade::read(NIFStream* nif)
{
NiParticleModifier::read(nif);
nif->read(mGrowTime);
nif->read(mFadeTime);
}
void NiParticleColorModifier::read(NIFStream* nif)
{
NiParticleModifier::read(nif);
mData.read(nif);
}
void NiParticleColorModifier::post(Reader& nif)
{
NiParticleModifier::post(nif);
mData.post(nif);
}
void NiGravity::read(NIFStream* nif)
{
NiParticleModifier::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(3, 3, 0, 13))
nif->read(mDecay);
nif->read(mForce);
mType = static_cast<ForceType>(nif->get<uint32_t>());
nif->read(mPosition);
nif->read(mDirection);
}
void NiParticleBomb::read(NIFStream* nif)
{
NiParticleModifier::read(nif);
nif->read(mRange);
nif->read(mDuration);
nif->read(mStrength);
nif->read(mStartTime);
mDecayType = static_cast<DecayType>(nif->get<uint32_t>());
mSymmetryType = static_cast<SymmetryType>(nif->get<uint32_t>());
nif->read(mPosition);
nif->read(mDirection);
}
void NiParticleCollider::read(NIFStream* nif)
{
NiParticleModifier::read(nif);
nif->read(mBounceFactor);
if (nif->getVersion() >= NIFStream::generateVersion(4, 2, 0, 2))
{
nif->read(mSpawnOnCollision);
nif->read(mDieOnCollision);
}
}
void NiPlanarCollider::read(NIFStream* nif)
{
NiParticleCollider::read(nif);
nif->read(mExtents);
nif->read(mPosition);
nif->read(mXVector);
nif->read(mYVector);
nif->read(mPlaneNormal);
nif->read(mPlaneDistance);
}
void NiSphericalCollider::read(NIFStream* nif)
{
NiParticleCollider::read(nif);
nif->read(mRadius);
nif->read(mCenter);
}
void NiParticleRotation::read(NIFStream* nif)
{
NiParticleModifier::read(nif);
nif->read(mRandomInitialAxis);
nif->read(mInitialAxis);
nif->read(mRotationSpeed);
}
void NiParticlesData::read(NIFStream* nif)
{
NiGeometryData::read(nif);
// Should always match the number of vertices in theory, but doesn't:
// see mist.nif in Mistify mod (https://www.nexusmods.com/morrowind/mods/48112).
if (nif->getVersion() <= NIFFile::NIFVersion::VER_MW)
nif->read(mNumParticles);
bool isBs202 = nif->getVersion() == NIFFile::NIFVersion::VER_BGS && nif->getBethVersion() != 0;
uint16_t numRadii = 1;
if (nif->getVersion() > NIFStream::generateVersion(10, 0, 1, 0))
numRadii = (nif->get<bool>() && !isBs202) ? mNumVertices : 0;
nif->readVector(mRadii, numRadii);
nif->read(mActiveCount);
if (nif->get<bool>() && !isBs202)
nif->readVector(mSizes, mNumVertices);
if (nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 0))
{
if (nif->get<bool>() && !isBs202)
nif->readVector(mRotations, mNumVertices);
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 4))
{
if (nif->get<bool>() && !isBs202)
nif->readVector(mRotationAngles, mNumVertices);
if (nif->get<bool>() && !isBs202)
nif->readVector(mRotationAxes, mNumVertices);
if (isBs202)
{
nif->read(mHasTextureIndices);
uint32_t numSubtextureOffsets;
if (nif->getBethVersion() <= NIFFile::BethVersion::BETHVER_FO3)
numSubtextureOffsets = nif->get<uint8_t>();
else
nif->read(numSubtextureOffsets);
nif->readVector(mSubtextureOffsets, numSubtextureOffsets);
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO3)
{
nif->read(mAspectRatio);
nif->read(mAspectFlags);
nif->read(mAspectRatio2);
nif->read(mAspectSpeed);
nif->read(mAspectSpeed2);
}
}
}
}
}
void NiRotatingParticlesData::read(NIFStream* nif)
{
NiParticlesData::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(4, 2, 2, 0) && nif->get<bool>())
nif->readVector(mRotations, mNumVertices);
}
void BSMasterParticleSystem::read(NIFStream* nif)
{
NiNode::read(nif);
nif->read(mMaxEmitters);
readRecordList(nif, mParticleSystems);
}
void BSMasterParticleSystem::post(Reader& nif)
{
NiNode::post(nif);
postRecordList(nif, mParticleSystems);
}
void NiParticleSystem::read(NIFStream* nif)
{
// Weird loading to account for inheritance differences starting from SSE
if (nif->getBethVersion() < NIFFile::BethVersion::BETHVER_SSE)
NiParticles::read(nif);
else
{
NiAVObject::read(nif);
nif->read(mBoundingSphere);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
nif->readArray(mBoundMinMax);
mSkin.read(nif);
mShaderProperty.read(nif);
mAlphaProperty.read(nif);
mVertDesc.read(nif);
}
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_SKY)
{
nif->readArray(mNearFar);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_SSE)
mData.read(nif);
}
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
{
nif->read(mWorldSpace);
readRecordList(nif, mModifiers);
}
}
void NiParticleSystem::post(Reader& nif)
{
NiParticles::post(nif);
postRecordList(nif, mModifiers);
}
void NiPSysData::read(NIFStream* nif)
{
NiParticlesData::read(nif);
bool hasData = nif->getBethVersion() < NIFFile::BethVersion::BETHVER_FO3;
if (hasData)
{
mParticles.resize(mNumVertices);
for (NiParticleInfo& info : mParticles)
info.read(nif);
}
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO4)
nif->skip(12); // Unknown
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 2) && nif->get<bool>() && hasData)
nif->readVector(mRotationSpeeds, mNumVertices);
if (nif->getVersion() != NIFStream::generateVersion(20, 2, 0, 7) || nif->getBethVersion() == 0)
{
nif->read(mNumAddedParticles);
nif->read(mAddedParticlesBase);
}
}
void NiMeshPSysData::read(NIFStream* nif)
{
NiPSysData::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 2, 0, 0))
{
nif->read(mDefaultPoolSize);
nif->read(mFillPoolsOnLoad);
nif->readVector(mGenerations, nif->get<uint32_t>());
}
mParticleMeshes.read(nif);
}
void NiMeshPSysData::post(Reader& nif)
{
NiPSysData::post(nif);
mParticleMeshes.post(nif);
}
void BSStripPSysData::read(NIFStream* nif)
{
NiPSysData::read(nif);
nif->read(mMaxPointCount);
nif->read(mStartCapSize);
nif->read(mEndCapSize);
nif->read(mDoZPrepass);
}
void NiPSysModifier::read(NIFStream* nif)
{
nif->read(mName);
mOrder = static_cast<NiPSysModifierOrder>(nif->get<uint32_t>());
mTarget.read(nif);
nif->read(mActive);
}
void NiPSysModifier::post(Reader& nif)
{
mTarget.post(nif);
}
void NiPSysAgeDeathModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mSpawnOnDeath);
mSpawnModifier.read(nif);
}
void NiPSysAgeDeathModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mSpawnModifier.post(nif);
}
void NiPSysBombModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
mBombObject.read(nif);
nif->read(mBombAxis);
nif->read(mRange);
nif->read(mStrength);
mDecayType = static_cast<DecayType>(nif->get<uint32_t>());
mSymmetryType = static_cast<SymmetryType>(nif->get<uint32_t>());
}
void NiPSysBombModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mBombObject.post(nif);
}
void NiPSysBoundUpdateModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mUpdateSkip);
}
void NiPSysColorModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
mData.read(nif);
}
void NiPSysColorModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mData.post(nif);
}
void NiPSysDragModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
mDragObject.read(nif);
nif->read(mDragAxis);
nif->read(mPercentage);
nif->read(mRange);
nif->read(mRangeFalloff);
}
void NiPSysDragModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mDragObject.post(nif);
}
void NiPSysGravityModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
mGravityObject.read(nif);
nif->read(mGravityAxis);
nif->read(mDecay);
nif->read(mStrength);
mForceType = static_cast<ForceType>(nif->get<uint32_t>());
nif->read(mTurbulence);
nif->read(mTurbulenceScale);
if (nif->getBethVersion() >= 17)
nif->read(mWorldAligned);
}
void NiPSysGravityModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mGravityObject.post(nif);
}
void NiPSysGrowFadeModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mGrowTime);
nif->read(mGrowGeneration);
nif->read(mFadeTime);
nif->read(mFadeGeneration);
if (nif->getVersion() == NIFFile::NIFVersion::VER_BGS
&& nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO3)
nif->read(mBaseScale);
}
void NiPSysMeshUpdateModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
readRecordList(nif, mMeshes);
}
void NiPSysMeshUpdateModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
postRecordList(nif, mMeshes);
}
void NiPSysRotationModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mRotationSpeed);
if (nif->getVersion() >= NIFStream::generateVersion(20, 0, 0, 2))
{
nif->read(mRotationSpeedVariation);
if (nif->getBethVersion() > NIFFile::BethVersion::BETHVER_FO4)
nif->skip(17); // Unknown
nif->read(mRotationAngle);
nif->read(mRotationAngleVariation);
nif->read(mRandomRotSpeedSign);
}
nif->read(mRandomAxis);
nif->read(mAxis);
}
void NiPSysSpawnModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mNumSpawnGenerations);
nif->read(mPercentageSpawned);
nif->read(mMinNumToSpawn);
nif->read(mMaxNumToSpawn);
nif->read(mSpawnSpeedVariation);
nif->read(mSpawnDirVariation);
nif->read(mLifespan);
nif->read(mLifespanVariation);
}
void BSParentVelocityModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mDamping);
}
void BSPSysHavokUpdateModifier::read(NIFStream* nif)
{
NiPSysMeshUpdateModifier::read(nif);
mModifier.read(nif);
}
void BSPSysHavokUpdateModifier::post(Reader& nif)
{
NiPSysMeshUpdateModifier::post(nif);
mModifier.post(nif);
}
void BSPSysInheritVelocityModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
mInheritObject.read(nif);
nif->read(mInheritChance);
nif->read(mVelocityMult);
nif->read(mVelcoityVariation);
}
void BSPSysInheritVelocityModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mInheritObject.post(nif);
}
void BSPSysLODModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mLODStartDistance);
nif->read(mLODEndDistance);
nif->read(mEndEmitScale);
nif->read(mEndSize);
}
void BSPSysRecycleBoundModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mBoundOffset);
nif->read(mBoundExtents);
mBoundObject.read(nif);
}
void BSPSysRecycleBoundModifier::post(Reader& nif)
{
NiPSysModifier::post(nif);
mBoundObject.post(nif);
}
void BSPSysScaleModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->readVector(mScales, nif->get<uint32_t>());
}
void BSPSysSimpleColorModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mFadeInPercent);
nif->read(mFadeOutPercent);
nif->read(mColor1EndPercent);
nif->read(mColor1StartPercent);
nif->read(mColor2EndPercent);
nif->read(mColor2StartPercent);
nif->readVector(mColors, 3);
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_F76)
nif->skip(52); // Unknown
}
void BSPSysStripUpdateModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mUpdateDeltaTime);
}
void BSPSysSubTexModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mStartFrame);
nif->read(mStartFrameFudge);
nif->read(mEndFrame);
nif->read(mLoopStartFrame);
nif->read(mLoopStartFrameFudge);
nif->read(mFrameCount);
nif->read(mFrameCountFudge);
}
void BSWindModifier::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mStrength);
}
void NiPSysEmitter::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
nif->read(mSpeed);
nif->read(mSpeedVariation);
nif->read(mDeclination);
nif->read(mDeclinationVariation);
nif->read(mPlanarAngle);
nif->read(mPlanarAngleVariation);
nif->read(mInitialColor);
nif->read(mInitialRadius);
if (nif->getVersion() >= NIFStream::generateVersion(10, 4, 0, 1))
nif->read(mRadiusVariation);
nif->read(mLifespan);
nif->read(mLifespanVariation);
}
void NiPSysVolumeEmitter::read(NIFStream* nif)
{
NiPSysEmitter::read(nif);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
mEmitterObject.read(nif);
}
void NiPSysVolumeEmitter::post(Reader& nif)
{
NiPSysEmitter::post(nif);
mEmitterObject.post(nif);
}
void NiPSysBoxEmitter::read(NIFStream* nif)
{
NiPSysVolumeEmitter::read(nif);
nif->read(mWidth);
nif->read(mHeight);
nif->read(mDepth);
}
void NiPSysCylinderEmitter::read(NIFStream* nif)
{
NiPSysVolumeEmitter::read(nif);
nif->read(mRadius);
nif->read(mHeight);
}
void NiPSysMeshEmitter::read(NIFStream* nif)
{
NiPSysEmitter::read(nif);
readRecordList(nif, mEmitterMeshes);
nif->read(mInitialVelocityType);
nif->read(mEmissionType);
nif->read(mEmissionAxis);
}
void NiPSysMeshEmitter::post(Reader& nif)
{
NiPSysEmitter::post(nif);
postRecordList(nif, mEmitterMeshes);
}
void NiPSysSphereEmitter::read(NIFStream* nif)
{
NiPSysVolumeEmitter::read(nif);
nif->read(mRadius);
}
void NiPSysModifierCtlr::read(NIFStream* nif)
{
NiSingleInterpController::read(nif);
nif->read(mModifierName);
}
void NiPSysEmitterCtlr::read(NIFStream* nif)
{
NiPSysModifierCtlr::read(nif);
if (nif->getVersion() <= NIFStream::generateVersion(10, 1, 0, 103))
mData.read(nif);
else
mVisInterpolator.read(nif);
}
void NiPSysEmitterCtlr::post(Reader& nif)
{
NiPSysModifierCtlr::post(nif);
mData.post(nif);
mVisInterpolator.post(nif);
}
void BSPSysMultiTargetEmitterCtlr::read(NIFStream* nif)
{
NiPSysEmitterCtlr::read(nif);
nif->read(mMaxEmitters);
mMasterPSys.read(nif);
}
void BSPSysMultiTargetEmitterCtlr::post(Reader& nif)
{
NiPSysEmitterCtlr::post(nif);
mMasterPSys.post(nif);
}
void NiPSysEmitterCtlrData::read(NIFStream* nif)
{
mFloatKeyList = std::make_shared<FloatKeyMap>();
mVisKeyList = std::make_shared<BoolKeyMap>();
uint32_t numVisKeys;
nif->read(numVisKeys);
for (size_t i = 0; i < numVisKeys; i++)
mVisKeyList->mKeys[nif->get<float>()].mValue = nif->get<uint8_t>() != 0;
}
void NiPSysCollider::read(NIFStream* nif)
{
nif->read(mBounce);
nif->read(mCollideSpawn);
nif->read(mCollideDie);
mSpawnModifier.read(nif);
mParent.read(nif);
mNextCollider.read(nif);
mColliderObject.read(nif);
}
void NiPSysCollider::post(Reader& nif)
{
mSpawnModifier.post(nif);
mParent.post(nif);
mNextCollider.post(nif);
mColliderObject.post(nif);
}
void NiPSysColliderManager::read(NIFStream* nif)
{
NiPSysModifier::read(nif);
mCollider.read(nif);
}
void NiPSysColliderManager::post(Reader& nif)
{
NiPSysModifier::post(nif);
mCollider.post(nif);
}
void NiPSysSphericalCollider::read(NIFStream* nif)
{
NiPSysCollider::read(nif);
nif->read(mRadius);
}
void NiPSysPlanarCollider::read(NIFStream* nif)
{
NiPSysCollider::read(nif);
nif->read(mWidth);
nif->read(mHeight);
nif->read(mXAxis);
nif->read(mYAxis);
}
}
| 18,864
|
C++
|
.cpp
| 584
| 23.731164
| 104
| 0.598003
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,874
|
nifstream.cpp
|
OpenMW_openmw/components/nif/nifstream.cpp
|
#include "nifstream.hpp"
#include <span>
#include "niffile.hpp"
#include "../to_utf8/to_utf8.hpp"
namespace
{
// Read a range of elements into a dynamic buffer per-element
// This one should be used if the type cannot be read contiguously
// (e.g. quaternions)
template <class T>
void readRange(Nif::NIFStream& stream, T* dest, size_t size)
{
for (T& value : std::span(dest, size))
stream.read(value);
}
// Read a range of elements into a dynamic buffer
// This one should be used if the type can be read contiguously as an array of a different type
// (e.g. osg::VecXf can be read as a float array of X elements)
template <class elementType, size_t numElements, class T>
void readAlignedRange(Files::IStreamPtr& stream, T* dest, size_t size)
{
static_assert(std::is_standard_layout_v<T>);
static_assert(std::alignment_of_v<T> == std::alignment_of_v<elementType>);
static_assert(sizeof(T) == sizeof(elementType) * numElements);
Nif::readDynamicBufferOfType(stream, reinterpret_cast<elementType*>(dest), size * numElements);
}
}
namespace Nif
{
unsigned int NIFStream::getVersion() const
{
return mReader.getVersion();
}
unsigned int NIFStream::getUserVersion() const
{
return mReader.getUserVersion();
}
unsigned int NIFStream::getBethVersion() const
{
return mReader.getBethVersion();
}
std::string NIFStream::getSizedString(size_t length)
{
std::string str(length, '\0');
mStream->read(str.data(), length);
if (mStream->bad())
throw std::runtime_error("Failed to read sized string of " + std::to_string(length) + " chars");
size_t end = str.find('\0');
if (end != std::string::npos)
str.erase(end);
if (mEncoder)
str = mEncoder->getUtf8(str, ToUTF8::BufferAllocationPolicy::UseGrowFactor, mBuffer);
return str;
}
void NIFStream::getSizedStrings(std::vector<std::string>& vec, size_t size)
{
vec.resize(size);
for (size_t i = 0; i < vec.size(); i++)
vec[i] = getSizedString();
}
std::string NIFStream::getVersionString()
{
std::string result;
std::getline(*mStream, result);
if (mStream->bad())
throw std::runtime_error("Failed to read version string");
return result;
}
std::string NIFStream::getStringPalette()
{
size_t size = get<uint32_t>();
std::string str(size, '\0');
mStream->read(str.data(), size);
if (mStream->bad())
throw std::runtime_error("Failed to read string palette of " + std::to_string(size) + " chars");
return str;
}
template <>
void NIFStream::read<osg::Vec2f>(osg::Vec2f& vec)
{
readBufferOfType(mStream, vec._v);
}
template <>
void NIFStream::read<osg::Vec3f>(osg::Vec3f& vec)
{
readBufferOfType(mStream, vec._v);
}
template <>
void NIFStream::read<osg::Vec4f>(osg::Vec4f& vec)
{
readBufferOfType(mStream, vec._v);
}
template <>
void NIFStream::read<Matrix3>(Matrix3& mat)
{
readBufferOfType<9>(mStream, reinterpret_cast<float*>(&mat.mValues));
}
template <>
void NIFStream::read<osg::Quat>(osg::Quat& quat)
{
std::array<float, 4> data;
readArray(data);
quat.w() = data[0];
quat.x() = data[1];
quat.y() = data[2];
quat.z() = data[3];
}
template <>
void NIFStream::read<osg::BoundingSpheref>(osg::BoundingSpheref& sphere)
{
read(sphere.center());
read(sphere.radius());
}
template <>
void NIFStream::read<NiTransform>(NiTransform& transform)
{
read(transform.mRotation);
read(transform.mTranslation);
read(transform.mScale);
}
template <>
void NIFStream::read<NiQuatTransform>(NiQuatTransform& transform)
{
read(transform.mTranslation);
read(transform.mRotation);
read(transform.mScale);
if (getVersion() >= generateVersion(10, 1, 0, 110))
return;
if (!get<bool>())
transform.mTranslation = osg::Vec3f();
if (!get<bool>())
transform.mRotation = osg::Quat();
if (!get<bool>())
transform.mScale = 1.f;
}
template <>
void NIFStream::read<bool>(bool& data)
{
if (getVersion() < generateVersion(4, 1, 0, 0))
data = get<int32_t>() != 0;
else
data = get<int8_t>() != 0;
}
template <>
void NIFStream::read<std::string>(std::string& str)
{
if (getVersion() < generateVersion(20, 1, 0, 1))
str = getSizedString();
else
str = mReader.getString(get<uint32_t>());
}
template <>
void NIFStream::read<osg::Vec2f>(osg::Vec2f* dest, size_t size)
{
readAlignedRange<float, 2>(mStream, dest, size);
}
template <>
void NIFStream::read<osg::Vec3f>(osg::Vec3f* dest, size_t size)
{
readAlignedRange<float, 3>(mStream, dest, size);
}
template <>
void NIFStream::read<osg::Vec4f>(osg::Vec4f* dest, size_t size)
{
readAlignedRange<float, 4>(mStream, dest, size);
}
template <>
void NIFStream::read<Matrix3>(Matrix3* dest, size_t size)
{
readAlignedRange<float, 9>(mStream, dest, size);
}
template <>
void NIFStream::read<osg::Quat>(osg::Quat* dest, size_t size)
{
readRange(*this, dest, size);
}
template <>
void NIFStream::read<osg::BoundingSpheref>(osg::BoundingSpheref* dest, size_t size)
{
readRange(*this, dest, size);
}
template <>
void NIFStream::read<NiTransform>(NiTransform* dest, size_t size)
{
readRange(*this, dest, size);
}
template <>
void NIFStream::read<NiQuatTransform>(NiQuatTransform* dest, size_t size)
{
readRange(*this, dest, size);
}
template <>
void NIFStream::read<bool>(bool* dest, size_t size)
{
if (getVersion() < generateVersion(4, 1, 0, 0))
{
for (bool& value : std::span(dest, size))
value = get<int32_t>() != 0;
}
else
{
for (bool& value : std::span(dest, size))
value = get<int8_t>() != 0;
}
}
template <>
void NIFStream::read<std::string>(std::string* dest, size_t size)
{
if (getVersion() < generateVersion(20, 1, 0, 1))
{
for (std::string& value : std::span(dest, size))
value = getSizedString();
}
else
{
for (std::string& value : std::span(dest, size))
value = mReader.getString(get<uint32_t>());
}
}
}
| 6,906
|
C++
|
.cpp
| 220
| 24.190909
| 108
| 0.585564
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,875
|
effect.cpp
|
OpenMW_openmw/components/nif/effect.cpp
|
#include "effect.hpp"
#include "node.hpp"
#include "texture.hpp"
namespace Nif
{
void NiDynamicEffect::read(NIFStream* nif)
{
NiAVObject::read(nif);
if (nif->getVersion() > NIFFile::VER_MW && nif->getVersion() < nif->generateVersion(10, 1, 0, 0))
return;
if (nif->getBethVersion() >= NIFFile::BethVersion::BETHVER_FO4)
return;
if (nif->getVersion() >= nif->generateVersion(10, 1, 0, 106))
nif->read(mSwitchState);
size_t numAffectedNodes = nif->get<uint32_t>();
nif->skip(numAffectedNodes * 4);
}
void NiLight::read(NIFStream* nif)
{
NiDynamicEffect::read(nif);
nif->read(mDimmer);
nif->read(mAmbient);
nif->read(mDiffuse);
nif->read(mSpecular);
}
void NiPointLight::read(NIFStream* nif)
{
NiLight::read(nif);
nif->read(mConstantAttenuation);
nif->read(mLinearAttenuation);
nif->read(mQuadraticAttenuation);
}
void NiSpotLight::read(NIFStream* nif)
{
NiPointLight::read(nif);
nif->read(mOuterSpotAngle);
if (nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 5))
nif->read(mInnerSpotAngle);
nif->read(mExponent);
}
void NiTextureEffect::read(NIFStream* nif)
{
NiDynamicEffect::read(nif);
nif->read(mProjectionRotation);
nif->read(mProjectionPosition);
nif->read(mFilterMode);
if (nif->getVersion() >= NIFStream::generateVersion(20, 5, 0, 4))
nif->read(mMaxAnisotropy);
nif->read(mClampMode);
mTextureType = static_cast<TextureType>(nif->get<uint32_t>());
mCoordGenType = static_cast<CoordGenType>(nif->get<uint32_t>());
mTexture.read(nif);
nif->read(mEnableClipPlane);
mClipPlane = osg::Plane(nif->get<osg::Vec4f>());
if (nif->getVersion() <= NIFStream::generateVersion(10, 2, 0, 0))
nif->skip(4); // PS2-specific shorts
if (nif->getVersion() <= NIFStream::generateVersion(4, 1, 0, 12))
nif->skip(2); // Unknown short
}
void NiTextureEffect::post(Reader& nif)
{
NiDynamicEffect::post(nif);
mTexture.post(nif);
}
}
| 2,266
|
C++
|
.cpp
| 65
| 27.015385
| 105
| 0.601648
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,876
|
niffile.cpp
|
OpenMW_openmw/components/nif/niffile.cpp
|
#include "niffile.hpp"
#include <components/debug/debuglog.hpp>
#include <components/files/hash.hpp>
#include <algorithm>
#include <array>
#include <limits>
#include <map>
#include <sstream>
#include <stdexcept>
#include "controller.hpp"
#include "data.hpp"
#include "effect.hpp"
#include "exception.hpp"
#include "extra.hpp"
#include "node.hpp"
#include "particle.hpp"
#include "physics.hpp"
#include "property.hpp"
#include "texture.hpp"
namespace Nif
{
Reader::Reader(NIFFile& file, const ToUTF8::StatelessUtf8Encoder* encoder)
: mVersion(file.mVersion)
, mUserVersion(file.mUserVersion)
, mBethVersion(file.mBethVersion)
, mFilename(file.mPath)
, mHash(file.mHash)
, mRecords(file.mRecords)
, mRoots(file.mRoots)
, mUseSkinning(file.mUseSkinning)
, mEncoder(encoder)
{
}
template <typename NodeType, RecordType recordType>
static std::unique_ptr<Record> construct()
{
auto result = std::make_unique<NodeType>();
result->recType = recordType;
return result;
}
using CreateRecord = std::unique_ptr<Record> (*)();
/// These are all the record types we know how to read.
static std::map<std::string, CreateRecord> makeFactory()
{
return {
// 4.0.0.2 refers to Bethesda variant of NetImmerse 4.0.0.2 file format
// Gamebryo refers to files newer than 4.0.0.2
// Bethesda refers to custom records Bethesda introduced post-4.0.0.2
// NODES
// NiNode-like nodes, 4.0.0.2
{ "NiNode", &construct<NiNode, RC_NiNode> },
{ "AvoidNode", &construct<NiNode, RC_AvoidNode> },
{ "NiBillboardNode", &construct<NiBillboardNode, RC_NiBillboardNode> },
{ "NiBSAnimationNode", &construct<NiNode, RC_NiBSAnimationNode> },
{ "NiBSParticleNode", &construct<NiNode, RC_NiBSParticleNode> },
{ "NiCollisionSwitch", &construct<NiNode, RC_NiCollisionSwitch> },
{ "NiSortAdjustNode", &construct<NiSortAdjustNode, RC_NiSortAdjustNode> },
{ "RootCollisionNode", &construct<NiNode, RC_RootCollisionNode> },
// NiNode-like nodes, Bethesda
{ "BSBlastNode", &construct<BSRangeNode, RC_NiNode> },
{ "BSDamageStage", &construct<BSRangeNode, RC_NiNode> },
{ "BSDebrisNode", &construct<BSRangeNode, RC_NiNode> },
{ "BSDistantObjectInstancedNode",
&construct<BSDistantObjectInstancedNode, RC_BSDistantObjectInstancedNode> },
{ "BSFadeNode", &construct<NiNode, RC_NiNode> },
{ "BSLeafAnimNode", &construct<NiNode, RC_NiNode> },
{ "BSMasterParticleSystem", &construct<BSMasterParticleSystem, RC_NiNode> },
{ "BSMultiBoundNode", &construct<BSMultiBoundNode, RC_NiNode> },
{ "BSOrderedNode", &construct<BSOrderedNode, RC_NiNode> },
{ "BSRangeNode", &construct<BSRangeNode, RC_NiNode> },
{ "BSTreeNode", &construct<BSTreeNode, RC_NiNode> },
{ "BSValueNode", &construct<BSValueNode, RC_NiNode> },
// Switch nodes, 4.0.0.2
{ "NiSwitchNode", &construct<NiSwitchNode, RC_NiSwitchNode> },
{ "NiFltAnimationNode", &construct<NiFltAnimationNode, RC_NiFltAnimationNode> },
{ "NiLODNode", &construct<NiLODNode, RC_NiLODNode> },
// NiSequence nodes, 4.0.0.2
{ "NiSequenceStreamHelper", &construct<NiSequenceStreamHelper, RC_NiSequenceStreamHelper> },
// NiSequence nodes, Gamebryo
{ "NiSequence", &construct<NiSequence, RC_NiSequence> },
{ "NiControllerSequence", &construct<NiControllerSequence, RC_NiControllerSequence> },
// Other nodes, 4.0.0.2
{ "NiCamera", &construct<NiCamera, RC_NiCamera> },
// ACCUMULATORS
// 4.0.0.2
{ "NiAlphaAccumulator", &construct<NiAlphaAccumulator, RC_NiAlphaAccumulator> },
{ "NiClusterAccumulator", &construct<NiClusterAccumulator, RC_NiClusterAccumulator> },
// CONTROLLERS
// 4.0.0.2
{ "NiAlphaController", &construct<NiAlphaController, RC_NiAlphaController> },
{ "NiBSPArrayController", &construct<NiBSPArrayController, RC_NiBSPArrayController> },
{ "NiFlipController", &construct<NiFlipController, RC_NiFlipController> },
{ "NiGeomMorpherController", &construct<NiGeomMorpherController, RC_NiGeomMorpherController> },
{ "NiKeyframeController", &construct<NiKeyframeController, RC_NiKeyframeController> },
{ "NiLookAtController", &construct<NiLookAtController, RC_NiLookAtController> },
// FIXME: NiLightColorController should have its own struct
{ "NiLightColorController", &construct<NiMaterialColorController, RC_NiLightColorController> },
{ "NiMaterialColorController", &construct<NiMaterialColorController, RC_NiMaterialColorController> },
{ "NiPathController", &construct<NiPathController, RC_NiPathController> },
{ "NiRollController", &construct<NiRollController, RC_NiRollController> },
{ "NiUVController", &construct<NiUVController, RC_NiUVController> },
{ "NiVisController", &construct<NiVisController, RC_NiVisController> },
// Gamebryo
{ "NiBoneLODController", &construct<NiBoneLODController, RC_NiBoneLODController> },
{ "NiControllerManager", &construct<NiControllerManager, RC_NiControllerManager> },
{ "NiLightDimmerController", &construct<NiFloatInterpController, RC_NiLightDimmerController> },
{ "NiTransformController", &construct<NiKeyframeController, RC_NiKeyframeController> },
{ "NiTextureTransformController",
&construct<NiTextureTransformController, RC_NiTextureTransformController> },
{ "NiMultiTargetTransformController",
&construct<NiMultiTargetTransformController, RC_NiMultiTargetTransformController> },
// Extra data controllers, Gamebryo
{ "NiColorExtraDataController", &construct<NiExtraDataController, RC_NiColorExtraDataController> },
{ "NiFloatExtraDataController", &construct<NiFloatExtraDataController, RC_NiFloatExtraDataController> },
{ "NiFloatsExtraDataController", &construct<NiFloatsExtraDataController, RC_NiFloatsExtraDataController> },
{ "NiFloatsExtraDataPoint3Controller",
&construct<NiFloatsExtraDataPoint3Controller, RC_NiFloatsExtraDataPoint3Controller> },
// Bethesda
{ "BSFrustumFOVController", &construct<NiFloatInterpController, RC_BSFrustumFOVController> },
{ "BSKeyframeController", &construct<BSKeyframeController, RC_BSKeyframeController> },
{ "BSLagBoneController", &construct<BSLagBoneController, RC_BSLagBoneController> },
{ "BSProceduralLightningController",
&construct<BSProceduralLightningController, RC_BSProceduralLightningController> },
{ "BSMaterialEmittanceMultController",
&construct<NiFloatInterpController, RC_BSMaterialEmittanceMultController> },
{ "BSNiAlphaPropertyTestRefController",
&construct<NiFloatInterpController, RC_BSNiAlphaPropertyTestRefController> },
{ "BSRefractionFirePeriodController",
&construct<NiSingleInterpController, RC_BSRefractionFirePeriodController> },
{ "BSRefractionStrengthController",
&construct<NiFloatInterpController, RC_BSRefractionStrengthController> },
{ "BSEffectShaderPropertyColorController",
&construct<BSEffectShaderPropertyColorController, RC_BSEffectShaderPropertyColorController> },
{ "BSEffectShaderPropertyFloatController",
&construct<BSEffectShaderPropertyFloatController, RC_BSEffectShaderPropertyFloatController> },
{ "BSLightingShaderPropertyColorController",
&construct<BSEffectShaderPropertyColorController, RC_BSLightingShaderPropertyColorController> },
{ "BSLightingShaderPropertyFloatController",
&construct<BSEffectShaderPropertyFloatController, RC_BSLightingShaderPropertyFloatController> },
{ "BSLightingShaderPropertyUShortController",
&construct<BSEffectShaderPropertyFloatController, RC_BSLightingShaderPropertyUShortController> },
{ "bhkBlendController", &construct<bhkBlendController, RC_bhkBlendController> },
{ "NiBSBoneLODController", &construct<NiBoneLODController, RC_NiBoneLODController> },
{ "NiLightRadiusController", &construct<NiFloatInterpController, RC_NiLightRadiusController> },
// Interpolators, Gamebryo
{ "NiBSplineCompFloatInterpolator",
&construct<NiBSplineCompFloatInterpolator, RC_NiBSplineCompFloatInterpolator> },
{ "NiBSplineCompPoint3Interpolator",
&construct<NiBSplineCompPoint3Interpolator, RC_NiBSplineCompPoint3Interpolator> },
{ "NiBSplineCompTransformInterpolator",
&construct<NiBSplineCompTransformInterpolator, RC_NiBSplineCompTransformInterpolator> },
{ "NiBSplineTransformInterpolator",
&construct<NiBSplineTransformInterpolator, RC_NiBSplineTransformInterpolator> },
{ "NiBlendBoolInterpolator", &construct<NiBlendBoolInterpolator, RC_NiBlendBoolInterpolator> },
{ "NiBlendFloatInterpolator", &construct<NiBlendFloatInterpolator, RC_NiBlendFloatInterpolator> },
{ "NiBlendPoint3Interpolator", &construct<NiBlendPoint3Interpolator, RC_NiBlendPoint3Interpolator> },
{ "NiBlendTransformInterpolator",
&construct<NiBlendTransformInterpolator, RC_NiBlendTransformInterpolator> },
{ "NiBoolInterpolator", &construct<NiBoolInterpolator, RC_NiBoolInterpolator> },
{ "NiBoolTimelineInterpolator", &construct<NiBoolInterpolator, RC_NiBoolTimelineInterpolator> },
{ "NiColorInterpolator", &construct<NiColorInterpolator, RC_NiColorInterpolator> },
{ "NiFloatInterpolator", &construct<NiFloatInterpolator, RC_NiFloatInterpolator> },
{ "NiLookAtInterpolator", &construct<NiLookAtInterpolator, RC_NiLookAtInterpolator> },
{ "NiPathInterpolator", &construct<NiPathInterpolator, RC_NiPathInterpolator> },
{ "NiPoint3Interpolator", &construct<NiPoint3Interpolator, RC_NiPoint3Interpolator> },
{ "NiTransformInterpolator", &construct<NiTransformInterpolator, RC_NiTransformInterpolator> },
// Interpolators, Bethesda
{ "BSRotAccumTransfInterpolator", &construct<NiTransformInterpolator, RC_BSRotAccumTransfInterpolator> },
{ "BSTreadTransfInterpolator", &construct<BSTreadTransfInterpolator, RC_BSTreadTransfInterpolator> },
// DATA
// 4.0.0.2
{ "NiColorData", &construct<NiColorData, RC_NiColorData> },
{ "NiFloatData", &construct<NiFloatData, RC_NiFloatData> },
{ "NiKeyframeData", &construct<NiKeyframeData, RC_NiKeyframeData> },
{ "NiMorphData", &construct<NiMorphData, RC_NiMorphData> },
{ "NiPalette", &construct<NiPalette, RC_NiPalette> },
{ "NiPixelData", &construct<NiPixelData, RC_NiPixelData> },
{ "NiPosData", &construct<NiPosData, RC_NiPosData> },
{ "NiSourceTexture", &construct<NiSourceTexture, RC_NiSourceTexture> },
{ "NiUVData", &construct<NiUVData, RC_NiUVData> },
{ "NiVisData", &construct<NiVisData, RC_NiVisData> },
// Gamebryo
{ "NiAdditionalGeometryData", &construct<NiAdditionalGeometryData, RC_NiAdditionalGeometryData> },
{ "NiBoolData", &construct<NiBoolData, RC_NiBoolData> },
{ "NiBSplineData", &construct<NiBSplineData, RC_NiBSplineData> },
{ "NiBSplineBasisData", &construct<NiBSplineBasisData, RC_NiBSplineBasisData> },
{ "NiDefaultAVObjectPalette", &construct<NiDefaultAVObjectPalette, RC_NiDefaultAVObjectPalette> },
{ "NiTransformData", &construct<NiKeyframeData, RC_NiKeyframeData> },
// Bethesda
{ "BSAnimNote", &construct<BSAnimNote, RC_BSAnimNote> },
{ "BSAnimNotes", &construct<BSAnimNotes, RC_BSAnimNotes> },
{ "BSPackedAdditionalGeometryData",
&construct<NiAdditionalGeometryData, RC_BSPackedAdditionalGeometryData> },
{ "BSShaderTextureSet", &construct<BSShaderTextureSet, RC_BSShaderTextureSet> },
// DYNAMIC EFFECTS
// 4.0.0.2
{ "NiAmbientLight", &construct<NiLight, RC_NiLight> },
{ "NiDirectionalLight", &construct<NiLight, RC_NiLight> },
{ "NiPointLight", &construct<NiPointLight, RC_NiLight> },
{ "NiSpotLight", &construct<NiSpotLight, RC_NiLight> },
{ "NiTextureEffect", &construct<NiTextureEffect, RC_NiTextureEffect> },
// EXTRA DATA
// 4.0.0.2
{ "NiExtraData", &construct<NiExtraData, RC_NiExtraData> },
{ "NiStringExtraData", &construct<NiStringExtraData, RC_NiStringExtraData> },
{ "NiTextKeyExtraData", &construct<NiTextKeyExtraData, RC_NiTextKeyExtraData> },
{ "NiVertWeightsExtraData", &construct<NiVertWeightsExtraData, RC_NiVertWeightsExtraData> },
// Gamebryo
{ "NiBinaryExtraData", &construct<NiBinaryExtraData, RC_NiBinaryExtraData> },
{ "NiBooleanExtraData", &construct<NiBooleanExtraData, RC_NiBooleanExtraData> },
{ "NiColorExtraData", &construct<NiVectorExtraData, RC_NiColorExtraData> },
{ "NiFloatExtraData", &construct<NiFloatExtraData, RC_NiFloatExtraData> },
{ "NiFloatsExtraData", &construct<NiFloatsExtraData, RC_NiFloatsExtraData> },
{ "NiIntegerExtraData", &construct<NiIntegerExtraData, RC_NiIntegerExtraData> },
{ "NiIntegersExtraData", &construct<NiIntegersExtraData, RC_NiIntegersExtraData> },
{ "NiVectorExtraData", &construct<NiVectorExtraData, RC_NiVectorExtraData> },
{ "NiStringsExtraData", &construct<NiStringsExtraData, RC_NiStringsExtraData> },
{ "NiStringPalette", &construct<NiStringPalette, RC_NiStringPalette> },
// Bethesda bounds
{ "BSBound", &construct<BSBound, RC_BSBound> },
{ "BSMultiBound", &construct<BSMultiBound, RC_BSMultiBound> },
{ "BSMultiBoundAABB", &construct<BSMultiBoundAABB, RC_BSMultiBoundAABB> },
{ "BSMultiBoundOBB", &construct<BSMultiBoundOBB, RC_BSMultiBoundOBB> },
{ "BSMultiBoundSphere", &construct<BSMultiBoundSphere, RC_BSMultiBoundSphere> },
// Bethesda markers
{ "BSFurnitureMarker", &construct<BSFurnitureMarker, RC_BSFurnitureMarker> },
{ "BSFurnitureMarkerNode", &construct<BSFurnitureMarker, RC_BSFurnitureMarker> },
{ "BSInvMarker", &construct<BSInvMarker, RC_BSInvMarker> },
// Other Bethesda records
{ "BSExtraData", &construct<BSExtraData, RC_BSExtraData> },
{ "BSBehaviorGraphExtraData", &construct<BSBehaviorGraphExtraData, RC_BSBehaviorGraphExtraData> },
{ "BSBoneLODExtraData", &construct<BSBoneLODExtraData, RC_BSBoneLODExtraData> },
{ "BSClothExtraData", &construct<BSClothExtraData, RC_BSClothExtraData> },
{ "BSCollisionQueryProxyExtraData",
&construct<BSCollisionQueryProxyExtraData, RC_BSCollisionQueryProxyExtraData> },
{ "BSConnectPoint::Children", &construct<BSConnectPoint::Children, RC_BSConnectPointChildren> },
{ "BSConnectPoint::Parents", &construct<BSConnectPoint::Parents, RC_BSConnectPointParents> },
{ "BSDecalPlacementVectorExtraData",
&construct<BSDecalPlacementVectorExtraData, RC_BSDecalPlacementVectorExtraData> },
{ "BSDistantObjectExtraData", &construct<BSDistantObjectExtraData, RC_BSDistantObjectExtraData> },
{ "BSDistantObjectLargeRefExtraData",
&construct<BSDistantObjectLargeRefExtraData, RC_BSDistantObjectLargeRefExtraData> },
{ "BSEyeCenterExtraData", &construct<BSEyeCenterExtraData, RC_BSEyeCenterExtraData> },
{ "BSPackedCombinedSharedGeomDataExtra",
&construct<BSPackedCombinedSharedGeomDataExtra, RC_BSPackedCombinedSharedGeomDataExtra> },
{ "BSPositionData", &construct<BSPositionData, RC_BSPositionData> },
{ "BSWArray", &construct<BSWArray, RC_BSWArray> },
{ "BSXFlags", &construct<NiIntegerExtraData, RC_BSXFlags> },
// GEOMETRY
// 4.0.0.2
{ "NiLines", &construct<NiLines, RC_NiLines> },
{ "NiLinesData", &construct<NiLinesData, RC_NiLinesData> },
{ "NiSkinData", &construct<NiSkinData, RC_NiSkinData> },
{ "NiSkinInstance", &construct<NiSkinInstance, RC_NiSkinInstance> },
{ "NiSkinPartition", &construct<NiSkinPartition, RC_NiSkinPartition> },
{ "NiTriShape", &construct<NiTriShape, RC_NiTriShape> },
{ "NiTriShapeData", &construct<NiTriShapeData, RC_NiTriShapeData> },
{ "NiTriStrips", &construct<NiTriStrips, RC_NiTriStrips> },
{ "NiTriStripsData", &construct<NiTriStripsData, RC_NiTriStripsData> },
// Bethesda
{ "BSDismemberSkinInstance", &construct<BSDismemberSkinInstance, RC_BSDismemberSkinInstance> },
{ "BSSkin::Instance", &construct<BSSkinInstance, RC_BSSkinInstance> },
{ "BSSkin::BoneData", &construct<BSSkinBoneData, RC_BSSkinBoneData> },
{ "BSTriShape", &construct<BSTriShape, RC_BSTriShape> },
{ "BSDynamicTriShape", &construct<BSDynamicTriShape, RC_BSDynamicTriShape> },
{ "BSLODTriShape", &construct<BSLODTriShape, RC_BSLODTriShape> },
{ "BSMeshLODTriShape", &construct<BSMeshLODTriShape, RC_BSMeshLODTriShape> },
{ "BSSegmentedTriShape", &construct<BSSegmentedTriShape, RC_BSSegmentedTriShape> },
{ "BSSubIndexTriShape", &construct<BSSubIndexTriShape, RC_BSSubIndexTriShape> },
// PARTICLES
// Geometry, 4.0.0.2
{ "NiAutoNormalParticles", &construct<NiParticles, RC_NiParticles> },
{ "NiAutoNormalParticlesData", &construct<NiParticlesData, RC_NiParticlesData> },
{ "NiParticles", &construct<NiParticles, RC_NiParticles> },
{ "NiParticlesData", &construct<NiParticlesData, RC_NiParticlesData> },
{ "NiRotatingParticles", &construct<NiParticles, RC_NiParticles> },
{ "NiRotatingParticlesData", &construct<NiRotatingParticlesData, RC_NiParticlesData> },
// Geometry, Gamebryo
{ "NiParticleSystem", &construct<NiParticleSystem, RC_NiParticleSystem> },
{ "NiMeshParticleSystem", &construct<NiParticleSystem, RC_NiParticleSystem> },
{ "NiPSysData", &construct<NiPSysData, RC_NiPSysData> },
{ "NiMeshPSysData", &construct<NiMeshPSysData, RC_NiMeshPSysData> },
// Geometry, Bethesda
{ "BSStripParticleSystem", &construct<NiParticleSystem, RC_BSStripParticleSystem> },
{ "BSStripPSysData", &construct<BSStripPSysData, RC_BSStripPSysData> },
// Modifiers, 4.0.0.2
{ "NiGravity", &construct<NiGravity, RC_NiGravity> },
{ "NiParticleBomb", &construct<NiParticleBomb, RC_NiParticleBomb> },
{ "NiParticleColorModifier", &construct<NiParticleColorModifier, RC_NiParticleColorModifier> },
{ "NiParticleGrowFade", &construct<NiParticleGrowFade, RC_NiParticleGrowFade> },
{ "NiParticleRotation", &construct<NiParticleRotation, RC_NiParticleRotation> },
// Modifiers, Gamebryo
{ "NiPSysAgeDeathModifier", &construct<NiPSysAgeDeathModifier, RC_NiPSysAgeDeathModifier> },
{ "NiPSysBombModifier", &construct<NiPSysBombModifier, RC_NiPSysBombModifier> },
{ "NiPSysBoundUpdateModifier", &construct<NiPSysBoundUpdateModifier, RC_NiPSysBoundUpdateModifier> },
{ "NiPSysColorModifier", &construct<NiPSysColorModifier, RC_NiPSysColorModifier> },
{ "NiPSysDragModifier", &construct<NiPSysDragModifier, RC_NiPSysDragModifier> },
{ "NiPSysGravityModifier", &construct<NiPSysGravityModifier, RC_NiPSysGravityModifier> },
{ "NiPSysGrowFadeModifier", &construct<NiPSysGrowFadeModifier, RC_NiPSysGrowFadeModifier> },
{ "NiPSysPositionModifier", &construct<NiPSysModifier, RC_NiPSysPositionModifier> },
{ "NiPSysRotationModifier", &construct<NiPSysRotationModifier, RC_NiPSysRotationModifier> },
{ "NiPSysSpawnModifier", &construct<NiPSysSpawnModifier, RC_NiPSysSpawnModifier> },
{ "NiPSysMeshUpdateModifier", &construct<NiPSysMeshUpdateModifier, RC_NiPSysMeshUpdateModifier> },
// Modifiers, Bethesda
{ "BSParentVelocityModifier", &construct<BSParentVelocityModifier, RC_BSParentVelocityModifier> },
{ "BSPSysHavokUpdateModifier", &construct<BSPSysHavokUpdateModifier, RC_BSPSysHavokUpdateModifier> },
{ "BSPSysInheritVelocityModifier",
&construct<BSPSysInheritVelocityModifier, RC_BSPSysInheritVelocityModifier> },
{ "BSPSysLODModifier", &construct<BSPSysLODModifier, RC_BSPSysLODModifier> },
{ "BSPSysRecycleBoundModifier", &construct<BSPSysRecycleBoundModifier, RC_BSPSysRecycleBoundModifier> },
{ "BSPSysScaleModifier", &construct<BSPSysScaleModifier, RC_BSPSysScaleModifier> },
{ "BSPSysSimpleColorModifier", &construct<BSPSysSimpleColorModifier, RC_BSPSysSimpleColorModifier> },
{ "BSPSysStripUpdateModifier", &construct<BSPSysStripUpdateModifier, RC_BSPSysStripUpdateModifier> },
{ "BSPSysSubTexModifier", &construct<BSPSysSubTexModifier, RC_BSPSysSubTexModifier> },
{ "BSWindModifier", &construct<BSWindModifier, RC_BSWindModifier> },
// Emitters, Gamebryo
{ "NiPSysBoxEmitter", &construct<NiPSysBoxEmitter, RC_NiPSysBoxEmitter> },
{ "NiPSysCylinderEmitter", &construct<NiPSysCylinderEmitter, RC_NiPSysCylinderEmitter> },
{ "NiPSysMeshEmitter", &construct<NiPSysMeshEmitter, RC_NiPSysMeshEmitter> },
{ "NiPSysSphereEmitter", &construct<NiPSysSphereEmitter, RC_NiPSysSphereEmitter> },
// Emitters, Bethesda
{ "BSPSysArrayEmitter", &construct<NiPSysVolumeEmitter, RC_BSPSysArrayEmitter> },
// Modifier controllers, Gamebryo
{ "NiPSysAirFieldAirFrictionCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysAirFieldAirFrictionCtlr> },
{ "NiPSysAirFieldInheritVelocityCtlr",
&construct<NiPSysModifierFloatCtlr, RC_NiPSysAirFieldInheritVelocityCtlr> },
{ "NiPSysAirFieldSpreadCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysAirFieldSpreadCtlr> },
{ "NiPSysEmitterCtlr", &construct<NiPSysEmitterCtlr, RC_NiPSysEmitterCtlr> },
{ "NiPSysEmitterDeclinationCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterDeclinationCtlr> },
{ "NiPSysEmitterDeclinationVarCtlr",
&construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterDeclinationVarCtlr> },
{ "NiPSysEmitterInitialRadiusCtlr",
&construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterInitialRadiusCtlr> },
{ "NiPSysEmitterLifeSpanCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterLifeSpanCtlr> },
{ "NiPSysEmitterPlanarAngleCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterPlanarAngleCtlr> },
{ "NiPSysEmitterPlanarAngleVarCtlr",
&construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterPlanarAngleVarCtlr> },
{ "NiPSysEmitterSpeedCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysEmitterSpeedCtlr> },
{ "NiPSysFieldAttenuationCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysFieldAttenuationCtlr> },
{ "NiPSysFieldMagnitudeCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysFieldMagnitudeCtlr> },
{ "NiPSysFieldMaxDistanceCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysFieldMaxDistanceCtlr> },
{ "NiPSysGravityStrengthCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysGravityStrengthCtlr> },
{ "NiPSysInitialRotSpeedCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysInitialRotSpeedCtlr> },
{ "NiPSysInitialRotSpeedVarCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysInitialRotSpeedVarCtlr> },
{ "NiPSysInitialRotAngleCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysInitialRotAngleCtlr> },
{ "NiPSysInitialRotAngleVarCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysInitialRotAngleVarCtlr> },
{ "NiPSysModifierActiveCtlr", &construct<NiPSysModifierBoolCtlr, RC_NiPSysModifierActiveCtlr> },
{ "NiPSysRotDampeningCtlr", &construct<NiPSysModifierFloatCtlr, RC_NiPSysRotDampeningCtlr> },
// Modifier controllers, Bethesda
{ "BSPSysMultiTargetEmitterCtlr",
&construct<BSPSysMultiTargetEmitterCtlr, RC_BSPSysMultiTargetEmitterCtlr> },
// Modifier controller data, Gamebryo
{ "NiPSysEmitterCtlrData", &construct<NiPSysEmitterCtlrData, RC_NiPSysEmitterCtlrData> },
// Colliders, 4.0.0.2
{ "NiPlanarCollider", &construct<NiPlanarCollider, RC_NiPlanarCollider> },
{ "NiSphericalCollider", &construct<NiSphericalCollider, RC_NiSphericalCollider> },
// Colliders, Gamebryo
{ "NiPSysColliderManager", &construct<NiPSysColliderManager, RC_NiPSysColliderManager> },
{ "NiPSysPlanarCollider", &construct<NiPSysPlanarCollider, RC_NiPSysPlanarCollider> },
{ "NiPSysSphericalCollider", &construct<NiPSysSphericalCollider, RC_NiPSysSphericalCollider> },
// Particle system controllers, 4.0.0.2
{ "NiParticleSystemController", &construct<NiParticleSystemController, RC_NiParticleSystemController> },
// Particle system controllers, Gamebryo
{ "NiPSysResetOnLoopCtlr", &construct<NiTimeController, RC_NiPSysResetOnLoopCtlr> },
{ "NiPSysUpdateCtlr", &construct<NiTimeController, RC_NiPSysUpdateCtlr> },
// PHYSICS
// Collision objects, Gamebryo
{ "NiCollisionObject", &construct<NiCollisionObject, RC_NiCollisionObject> },
// Collision objects, Bethesda
{ "bhkCollisionObject", &construct<bhkCollisionObject, RC_bhkCollisionObject> },
{ "bhkPCollisionObject", &construct<bhkCollisionObject, RC_bhkCollisionObject> },
{ "bhkSPCollisionObject", &construct<bhkCollisionObject, RC_bhkCollisionObject> },
{ "bhkNPCollisionObject", &construct<bhkNPCollisionObject, RC_bhkCollisionObject> },
{ "bhkBlendCollisionObject", &construct<bhkBlendCollisionObject, RC_bhkBlendCollisionObject> },
// Constraint records, Bethesda
{ "bhkBallAndSocketConstraint", &construct<bhkBallAndSocketConstraint, RC_bhkBallAndSocketConstraint> },
{ "bhkBallSocketConstraintChain",
&construct<bhkBallSocketConstraintChain, RC_bhkBallSocketConstraintChain> },
{ "bhkHingeConstraint", &construct<bhkHingeConstraint, RC_bhkHingeConstraint> },
{ "bhkLimitedHingeConstraint", &construct<bhkLimitedHingeConstraint, RC_bhkLimitedHingeConstraint> },
{ "bhkRagdollConstraint", &construct<bhkRagdollConstraint, RC_bhkRagdollConstraint> },
{ "bhkStiffSpringConstraint", &construct<bhkStiffSpringConstraint, RC_bhkStiffSpringConstraint> },
{ "bhkPrismaticConstraint", &construct<bhkPrismaticConstraint, RC_bhkPrismaticConstraint> },
{ "bhkMalleableConstraint", &construct<bhkMalleableConstraint, RC_bhkMalleableConstraint> },
{ "bhkBreakableConstraint", &construct<bhkBreakableConstraint, RC_bhkBreakableConstraint> },
// Physics body records, Bethesda
{ "bhkRigidBody", &construct<bhkRigidBody, RC_bhkRigidBody> },
{ "bhkRigidBodyT", &construct<bhkRigidBody, RC_bhkRigidBodyT> },
// Physics geometry records, Bethesda
{ "bhkBoxShape", &construct<bhkBoxShape, RC_bhkBoxShape> },
{ "bhkCapsuleShape", &construct<bhkCapsuleShape, RC_bhkCapsuleShape> },
{ "bhkCylinderShape", &construct<bhkCylinderShape, RC_bhkCylinderShape> },
{ "bhkCompressedMeshShape", &construct<bhkCompressedMeshShape, RC_bhkCompressedMeshShape> },
{ "bhkCompressedMeshShapeData", &construct<bhkCompressedMeshShapeData, RC_bhkCompressedMeshShapeData> },
{ "bhkConvexListShape", &construct<bhkConvexListShape, RC_bhkConvexListShape> },
{ "bhkConvexSweepShape", &construct<bhkConvexSweepShape, RC_bhkConvexSweepShape> },
{ "bhkConvexTransformShape", &construct<bhkConvexTransformShape, RC_bhkConvexTransformShape> },
{ "bhkConvexVerticesShape", &construct<bhkConvexVerticesShape, RC_bhkConvexVerticesShape> },
{ "bhkListShape", &construct<bhkListShape, RC_bhkListShape> },
{ "bhkMoppBvTreeShape", &construct<bhkMoppBvTreeShape, RC_bhkMoppBvTreeShape> },
{ "bhkMeshShape", &construct<bhkMeshShape, RC_bhkMeshShape> },
{ "bhkMultiSphereShape", &construct<bhkMultiSphereShape, RC_bhkMultiSphereShape> },
{ "bhkNiTriStripsShape", &construct<bhkNiTriStripsShape, RC_bhkNiTriStripsShape> },
{ "bhkPackedNiTriStripsShape", &construct<bhkPackedNiTriStripsShape, RC_bhkPackedNiTriStripsShape> },
{ "hkPackedNiTriStripsData", &construct<hkPackedNiTriStripsData, RC_hkPackedNiTriStripsData> },
{ "bhkPlaneShape", &construct<bhkPlaneShape, RC_bhkPlaneShape> },
{ "bhkSphereShape", &construct<bhkSphereShape, RC_bhkSphereShape> },
{ "bhkTransformShape", &construct<bhkConvexTransformShape, RC_bhkConvexTransformShape> },
// Phantom records, Bethesda
{ "bhkAabbPhantom", &construct<bhkAabbPhantom, RC_bhkAabbPhantom> },
{ "bhkSimpleShapePhantom", &construct<bhkSimpleShapePhantom, RC_bhkSimpleShapePhantom> },
// Physics system records, Bethesda
{ "bhkPhysicsSystem", &construct<bhkPhysicsSystem, RC_bhkPhysicsSystem> },
{ "bhkRagdollSystem", &construct<bhkRagdollSystem, RC_bhkRagdollSystem> },
// Action records
{ "bhkLiquidAction", &construct<bhkLiquidAction, RC_bhkLiquidAction> },
{ "bhkOrientHingedBodyAction", &construct<bhkOrientHingedBodyAction, RC_bhkOrientHingedBodyAction> },
// Ragdoll template records
{ "bhkRagdollTemplate", &construct<bhkRagdollTemplate, RC_bhkRagdollTemplate> },
{ "bhkRagdollTemplateData", &construct<bhkRagdollTemplateData, RC_bhkRagdollTemplateData> },
// Other records
{ "bhkPoseArray", &construct<bhkPoseArray, RC_bhkPoseArray> },
// PROPERTIES
// 4.0.0.2
{ "NiAlphaProperty", &construct<NiAlphaProperty, RC_NiAlphaProperty> },
{ "NiDitherProperty", &construct<NiDitherProperty, RC_NiDitherProperty> },
{ "NiFogProperty", &construct<NiFogProperty, RC_NiFogProperty> },
{ "NiMaterialProperty", &construct<NiMaterialProperty, RC_NiMaterialProperty> },
{ "NiShadeProperty", &construct<NiShadeProperty, RC_NiShadeProperty> },
{ "NiSpecularProperty", &construct<NiSpecularProperty, RC_NiSpecularProperty> },
{ "NiStencilProperty", &construct<NiStencilProperty, RC_NiStencilProperty> },
{ "NiTexturingProperty", &construct<NiTexturingProperty, RC_NiTexturingProperty> },
{ "NiVertexColorProperty", &construct<NiVertexColorProperty, RC_NiVertexColorProperty> },
{ "NiWireframeProperty", &construct<NiWireframeProperty, RC_NiWireframeProperty> },
{ "NiZBufferProperty", &construct<NiZBufferProperty, RC_NiZBufferProperty> },
// Shader properties, Bethesda
{ "BSShaderProperty", &construct<BSShaderProperty, RC_BSShaderProperty> },
{ "BSShaderPPLightingProperty", &construct<BSShaderPPLightingProperty, RC_BSShaderPPLightingProperty> },
{ "BSShaderNoLightingProperty", &construct<BSShaderNoLightingProperty, RC_BSShaderNoLightingProperty> },
{ "BSDistantTreeShaderProperty", &construct<BSShaderProperty, RC_BSDistantTreeShaderProperty> },
{ "BSLightingShaderProperty", &construct<BSLightingShaderProperty, RC_BSLightingShaderProperty> },
{ "BSEffectShaderProperty", &construct<BSEffectShaderProperty, RC_BSEffectShaderProperty> },
{ "BSSkyShaderProperty", &construct<BSSkyShaderProperty, RC_BSSkyShaderProperty> },
{ "BSWaterShaderProperty", &construct<BSWaterShaderProperty, RC_BSWaterShaderProperty> },
{ "DistantLODShaderProperty", &construct<BSShaderProperty, RC_DistantLODShaderProperty> },
{ "HairShaderProperty", &construct<BSShaderProperty, RC_HairShaderProperty> },
{ "Lighting30ShaderProperty", &construct<BSShaderPPLightingProperty, RC_BSShaderPPLightingProperty> },
{ "SkyShaderProperty", &construct<SkyShaderProperty, RC_SkyShaderProperty> },
{ "TallGrassShaderProperty", &construct<TallGrassShaderProperty, RC_TallGrassShaderProperty> },
{ "TileShaderProperty", &construct<TileShaderProperty, RC_TileShaderProperty> },
{ "VolumetricFogShaderProperty", &construct<BSShaderProperty, RC_VolumetricFogShaderProperty> },
{ "WaterShaderProperty", &construct<BSShaderProperty, RC_WaterShaderProperty> },
};
}
/// Make the factory map used for parsing the file
static const std::map<std::string, CreateRecord> factories = makeFactory();
std::string Reader::versionToString(std::uint32_t version)
{
int major = (version >> 24) & 0xFF;
int minor = (version >> 16) & 0xFF;
int patch = (version >> 8) & 0xFF;
int rev = version & 0xFF;
std::stringstream stream;
stream << major << "." << minor << "." << patch << "." << rev;
return stream.str();
}
void Reader::parse(Files::IStreamPtr&& stream)
{
const bool writeDebug = sWriteNifDebugLog;
if (writeDebug)
Log(Debug::Verbose) << "NIF Debug: Reading file: '" << mFilename << "'";
const std::array<std::uint64_t, 2> fileHash = Files::getHash(mFilename, *stream);
mHash.append(reinterpret_cast<const char*>(fileHash.data()), fileHash.size() * sizeof(std::uint64_t));
NIFStream nif(*this, std::move(stream), mEncoder);
// Check the header string
std::string head = nif.getVersionString();
static const std::array<std::string, 2> verStrings = {
"NetImmerse File Format",
"Gamebryo File Format",
};
const bool supportedHeader = std::any_of(verStrings.begin(), verStrings.end(),
[&](const std::string& verString) { return head.starts_with(verString); });
if (!supportedHeader)
throw Nif::Exception("Invalid NIF header: " + head, mFilename);
// Get BCD version
nif.read(mVersion);
// 4.0.0.0 is an older, practically identical version of the format.
// It's not used by Morrowind assets but Morrowind supports it.
static const std::array<uint32_t, 2> supportedVers = {
NIFStream::generateVersion(4, 0, 0, 0),
NIFFile::VER_MW,
};
const bool supportedVersion
= std::find(supportedVers.begin(), supportedVers.end(), mVersion) != supportedVers.end();
if (!supportedVersion && !sLoadUnsupportedFiles)
throw Nif::Exception("Unsupported NIF version: " + versionToString(mVersion), mFilename);
const bool hasEndianness = mVersion >= NIFStream::generateVersion(20, 0, 0, 4);
const bool hasUserVersion = mVersion >= NIFStream::generateVersion(10, 0, 1, 8);
const bool hasRecTypeListings = mVersion >= NIFStream::generateVersion(5, 0, 0, 1);
const bool hasRecTypeHashes = mVersion == NIFStream::generateVersion(20, 3, 1, 2);
const bool hasRecordSizes = mVersion >= NIFStream::generateVersion(20, 2, 0, 5);
const bool hasGroups = mVersion >= NIFStream::generateVersion(5, 0, 0, 6);
const bool hasStringTable = mVersion >= NIFStream::generateVersion(20, 1, 0, 1);
const bool hasRecordSeparators
= mVersion >= NIFStream::generateVersion(10, 0, 0, 0) && mVersion < NIFStream::generateVersion(10, 2, 0, 0);
// Record type list
std::vector<std::string> recTypes;
// Record type mapping for each record
std::vector<std::uint16_t> recTypeIndices;
{
std::uint8_t endianness = 1;
if (hasEndianness)
nif.read(endianness);
// TODO: find some big-endian files and investigate the difference
if (endianness == 0)
throw Nif::Exception("Big endian NIF files are unsupported", mFilename);
}
if (hasUserVersion)
nif.read(mUserVersion);
mRecords.resize(nif.get<std::uint32_t>());
// Bethesda stream header
{
bool hasBSStreamHeader = false;
if (mVersion == NIFFile::VER_OB_OLD)
hasBSStreamHeader = true;
else if (mUserVersion >= 3 && mVersion >= NIFStream::generateVersion(10, 1, 0, 0))
{
if (mVersion <= NIFFile::VER_OB || mVersion == NIFFile::VER_BGS)
hasBSStreamHeader = mUserVersion <= 11 || mVersion >= NIFFile::VER_OB;
}
if (hasBSStreamHeader)
{
nif.read(mBethVersion);
nif.getExportString(); // Author
if (mBethVersion >= 131)
nif.get<std::uint32_t>(); // Unknown
else
nif.getExportString(); // Process script
nif.getExportString(); // Export script
if (mBethVersion >= 103)
nif.getExportString(); // Max file path
}
}
if (writeDebug)
{
std::stringstream versionInfo;
versionInfo << "NIF Debug: Version: " << versionToString(mVersion);
if (mUserVersion)
versionInfo << "\nUser version: " << mUserVersion;
if (mBethVersion)
versionInfo << "\nBSStream version: " << mBethVersion;
Log(Debug::Verbose) << versionInfo.str();
}
if (hasRecTypeListings)
{
// TODO: 20.3.1.2 uses DJB hashes instead of strings
if (hasRecTypeHashes)
throw Nif::Exception("Hashed record types are unsupported", mFilename);
else
{
nif.getSizedStrings(recTypes, nif.get<std::uint16_t>());
nif.readVector(recTypeIndices, mRecords.size());
}
}
if (hasRecordSizes) // Record sizes
{
std::vector<std::uint32_t> recSizes; // Currently unused
nif.readVector(recSizes, mRecords.size());
}
if (hasStringTable)
{
std::uint32_t stringNum, maxStringLength;
nif.read(stringNum);
nif.read(maxStringLength);
nif.getSizedStrings(mStrings, stringNum);
}
if (hasGroups)
{
std::vector<std::uint32_t> groups; // Currently unused
nif.readVector(groups, nif.get<std::uint32_t>());
}
for (std::size_t i = 0; i < mRecords.size(); i++)
{
std::unique_ptr<Record> r;
std::string rec = hasRecTypeListings ? recTypes[recTypeIndices[i]] : nif.get<std::string>();
if (rec.empty())
{
std::stringstream error;
error << "Record type is blank (index " << i << ")";
throw Nif::Exception(error.str(), mFilename);
}
// Record separator. Some Havok records in Oblivion do not have it.
if (hasRecordSeparators && !rec.starts_with("bhk") && nif.get<int32_t>())
throw Nif::Exception("Non-zero separator precedes " + rec + ", index " + std::to_string(i), mFilename);
const auto entry = factories.find(rec);
if (entry == factories.end())
throw Nif::Exception("Unknown record type " + rec, mFilename);
r = entry->second();
if (writeDebug)
Log(Debug::Verbose) << "NIF Debug: Reading record of type " << rec << ", index " << i;
assert(r != nullptr);
assert(r->recType != RC_MISSING);
r->recName = std::move(rec);
r->recIndex = i;
r->read(&nif);
mRecords[i] = std::move(r);
}
// Determine which records are roots
mRoots.resize(nif.get<uint32_t>());
for (std::size_t i = 0; i < mRoots.size(); i++)
{
std::int32_t idx;
nif.read(idx);
if (idx >= 0 && static_cast<std::size_t>(idx) < mRecords.size())
{
mRoots[i] = mRecords[idx].get();
}
else
{
mRoots[i] = nullptr;
Log(Debug::Warning) << "NIFFile Warning: Root " << i + 1 << " does not point to a record: index " << idx
<< ". File: " << mFilename;
}
}
// Once parsing is done, do post-processing.
for (const auto& record : mRecords)
record->post(*this);
}
void Reader::setUseSkinning(bool skinning)
{
mUseSkinning = skinning;
}
std::atomic_bool Reader::sLoadUnsupportedFiles = false;
std::atomic_bool Reader::sWriteNifDebugLog = false;
void Reader::setLoadUnsupportedFiles(bool load)
{
sLoadUnsupportedFiles = load;
}
void Reader::setWriteNifDebugLog(bool value)
{
sWriteNifDebugLog = value;
}
std::string Reader::getString(std::uint32_t index) const
{
if (index == std::numeric_limits<std::uint32_t>::max())
return std::string();
return mStrings.at(index);
}
}
| 42,845
|
C++
|
.cpp
| 649
| 53.801233
| 120
| 0.663142
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,877
|
texture.cpp
|
OpenMW_openmw/components/nif/texture.cpp
|
#include "texture.hpp"
#include "data.hpp"
namespace Nif
{
void NiSourceTexture::read(NIFStream* nif)
{
NiTexture::read(nif);
nif->read(mExternal);
bool hasData = nif->getVersion() >= NIFStream::generateVersion(10, 0, 1, 4);
if (!hasData && !mExternal)
hasData = nif->get<uint8_t>() != 0;
if (mExternal || nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 0))
nif->read(mFile);
if (hasData)
mData.read(nif);
mPrefs.mPixelLayout = static_cast<PixelLayout>(nif->get<uint32_t>());
mPrefs.mUseMipMaps = static_cast<MipMapFormat>(nif->get<uint32_t>());
mPrefs.mAlphaFormat = static_cast<AlphaFormat>(nif->get<uint32_t>());
nif->read(mIsStatic);
if (nif->getVersion() >= NIFStream::generateVersion(10, 1, 0, 103))
{
nif->read(mDirectRendering);
if (nif->getVersion() >= NIFStream::generateVersion(20, 2, 0, 4))
nif->read(mPersistRenderData);
}
}
void NiSourceTexture::post(Reader& nif)
{
NiTexture::post(nif);
mData.post(nif);
}
void BSShaderTextureSet::read(NIFStream* nif)
{
nif->getSizedStrings(mTextures, nif->get<uint32_t>());
}
}
| 1,289
|
C++
|
.cpp
| 36
| 27.833333
| 86
| 0.591787
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,878
|
installopcodes.cpp
|
OpenMW_openmw/components/interpreter/installopcodes.cpp
|
#include "installopcodes.hpp"
#include <functional>
#include "controlopcodes.hpp"
#include "genericopcodes.hpp"
#include "interpreter.hpp"
#include "localopcodes.hpp"
#include "mathopcodes.hpp"
#include "miscopcodes.hpp"
namespace Interpreter
{
void installOpcodes(Interpreter& interpreter)
{
// generic
interpreter.installSegment0<OpPushInt>(0);
interpreter.installSegment5<OpIntToFloat>(3);
interpreter.installSegment5<OpFloatToInt>(6);
interpreter.installSegment5<OpNegateInt>(7);
interpreter.installSegment5<OpNegateFloat>(8);
interpreter.installSegment5<OpIntToFloat1>(17);
interpreter.installSegment5<OpFloatToInt1>(18);
// local variables, global variables & literals
interpreter.installSegment5<OpStoreLocalShort>(0);
interpreter.installSegment5<OpStoreLocalLong>(1);
interpreter.installSegment5<OpStoreLocalFloat>(2);
interpreter.installSegment5<OpFetchIntLiteral>(4);
interpreter.installSegment5<OpFetchFloatLiteral>(5);
interpreter.installSegment5<OpFetchLocalShort>(21);
interpreter.installSegment5<OpFetchLocalLong>(22);
interpreter.installSegment5<OpFetchLocalFloat>(23);
interpreter.installSegment5<OpStoreGlobalShort>(39);
interpreter.installSegment5<OpStoreGlobalLong>(40);
interpreter.installSegment5<OpStoreGlobalFloat>(41);
interpreter.installSegment5<OpFetchGlobalShort>(42);
interpreter.installSegment5<OpFetchGlobalLong>(43);
interpreter.installSegment5<OpFetchGlobalFloat>(44);
interpreter.installSegment5<OpStoreMemberShort<false>>(59);
interpreter.installSegment5<OpStoreMemberLong<false>>(60);
interpreter.installSegment5<OpStoreMemberFloat<false>>(61);
interpreter.installSegment5<OpFetchMemberShort<false>>(62);
interpreter.installSegment5<OpFetchMemberLong<false>>(63);
interpreter.installSegment5<OpFetchMemberFloat<false>>(64);
interpreter.installSegment5<OpStoreMemberShort<true>>(65);
interpreter.installSegment5<OpStoreMemberLong<true>>(66);
interpreter.installSegment5<OpStoreMemberFloat<true>>(67);
interpreter.installSegment5<OpFetchMemberShort<true>>(68);
interpreter.installSegment5<OpFetchMemberLong<true>>(69);
interpreter.installSegment5<OpFetchMemberFloat<true>>(70);
// math
interpreter.installSegment5<OpAddInt<Type_Integer>>(9);
interpreter.installSegment5<OpAddInt<Type_Float>>(10);
interpreter.installSegment5<OpSubInt<Type_Integer>>(11);
interpreter.installSegment5<OpSubInt<Type_Float>>(12);
interpreter.installSegment5<OpMulInt<Type_Integer>>(13);
interpreter.installSegment5<OpMulInt<Type_Float>>(14);
interpreter.installSegment5<OpDivInt<Type_Integer>>(15);
interpreter.installSegment5<OpDivInt<Type_Float>>(16);
interpreter.installSegment5<OpCompare<Type_Integer, std::equal_to<Type_Integer>>>(26);
interpreter.installSegment5<OpCompare<Type_Integer, std::not_equal_to<Type_Integer>>>(27);
interpreter.installSegment5<OpCompare<Type_Integer, std::less<Type_Integer>>>(28);
interpreter.installSegment5<OpCompare<Type_Integer, std::less_equal<Type_Integer>>>(29);
interpreter.installSegment5<OpCompare<Type_Integer, std::greater<Type_Integer>>>(30);
interpreter.installSegment5<OpCompare<Type_Integer, std::greater_equal<Type_Integer>>>(31);
interpreter.installSegment5<OpCompare<Type_Float, std::equal_to<Type_Float>>>(32);
interpreter.installSegment5<OpCompare<Type_Float, std::not_equal_to<Type_Float>>>(33);
interpreter.installSegment5<OpCompare<Type_Float, std::less<Type_Float>>>(34);
interpreter.installSegment5<OpCompare<Type_Float, std::less_equal<Type_Float>>>(35);
interpreter.installSegment5<OpCompare<Type_Float, std::greater<Type_Float>>>(36);
interpreter.installSegment5<OpCompare<Type_Float, std::greater_equal<Type_Float>>>(37);
// control structures
interpreter.installSegment5<OpReturn>(20);
interpreter.installSegment5<OpSkipZero>(24);
interpreter.installSegment5<OpSkipNonZero>(25);
interpreter.installSegment0<OpJumpForward>(1);
interpreter.installSegment0<OpJumpBackward>(2);
// misc
interpreter.installSegment3<OpMessageBox>(0);
interpreter.installSegment5<OpReport>(58);
}
}
| 4,493
|
C++
|
.cpp
| 79
| 49.037975
| 99
| 0.740808
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,879
|
runtime.cpp
|
OpenMW_openmw/components/interpreter/runtime.cpp
|
#include "runtime.hpp"
#include "program.hpp"
#include <cassert>
#include <cstring>
#include <stdexcept>
namespace Interpreter
{
int Runtime::getIntegerLiteral(int index) const
{
if (index < 0 || mProgram->mIntegers.size() <= static_cast<std::size_t>(index))
throw std::out_of_range("Invalid integer index");
return mProgram->mIntegers[static_cast<std::size_t>(index)];
}
float Runtime::getFloatLiteral(int index) const
{
if (index < 0 || mProgram->mFloats.size() <= static_cast<std::size_t>(index))
throw std::out_of_range("Invalid float index");
return mProgram->mFloats[static_cast<std::size_t>(index)];
}
std::string_view Runtime::getStringLiteral(int index) const
{
if (index < 0 || mProgram->mStrings.size() <= static_cast<std::size_t>(index))
throw std::out_of_range("Invalid string literal index");
return mProgram->mStrings[static_cast<std::size_t>(index)];
}
void Runtime::configure(const Program& program, Context& context)
{
clear();
mContext = &context;
mProgram = &program;
mPC = 0;
}
void Runtime::clear()
{
mContext = nullptr;
mProgram = nullptr;
mStack.clear();
}
void Runtime::push(const Data& data)
{
mStack.push_back(data);
}
void Runtime::push(Type_Integer value)
{
Data data;
data.mInteger = value;
push(data);
}
void Runtime::push(Type_Float value)
{
Data data;
data.mFloat = value;
push(data);
}
void Runtime::pop()
{
if (mStack.empty())
throw std::runtime_error("stack underflow");
mStack.pop_back();
}
Data& Runtime::operator[](int index)
{
if (index < 0 || index >= static_cast<int>(mStack.size()))
throw std::runtime_error("stack index out of range");
return mStack[mStack.size() - index - 1];
}
Context& Runtime::getContext()
{
assert(mContext);
return *mContext;
}
}
| 2,115
|
C++
|
.cpp
| 72
| 22.569444
| 87
| 0.595556
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,880
|
interpreter.cpp
|
OpenMW_openmw/components/interpreter/interpreter.cpp
|
#include "interpreter.hpp"
#include <cassert>
#include <stdexcept>
#include <string>
#include "opcodes.hpp"
#include "program.hpp"
namespace Interpreter
{
[[noreturn]] static void abortUnknownCode(int segment, int opcode)
{
const std::string error = "unknown opcode " + std::to_string(opcode) + " in segment " + std::to_string(segment);
throw std::runtime_error(error);
}
[[noreturn]] static void abortUnknownSegment(Type_Code code)
{
const std::string error = "opcode outside of the allocated segment range: " + std::to_string(code);
throw std::runtime_error(error);
}
template <typename T>
auto& getDispatcher(const T& segment, unsigned int seg, int opcode)
{
auto it = segment.find(opcode);
if (it == segment.end())
{
abortUnknownCode(seg, opcode);
}
return it->second;
}
void Interpreter::execute(Type_Code code)
{
unsigned int segSpec = code >> 30;
switch (segSpec)
{
case 0:
{
const int opcode = code >> 24;
const unsigned int arg0 = code & 0xffffff;
return getDispatcher(mSegment0, 0, opcode)->execute(mRuntime, arg0);
}
case 2:
{
const int opcode = (code >> 20) & 0x3ff;
const unsigned int arg0 = code & 0xfffff;
return getDispatcher(mSegment2, 2, opcode)->execute(mRuntime, arg0);
}
}
segSpec = code >> 26;
switch (segSpec)
{
case 0x30:
{
const int opcode = (code >> 8) & 0x3ffff;
const unsigned int arg0 = code & 0xff;
return getDispatcher(mSegment3, 3, opcode)->execute(mRuntime, arg0);
}
case 0x32:
{
const int opcode = code & 0x3ffffff;
return getDispatcher(mSegment5, 5, opcode)->execute(mRuntime);
}
}
abortUnknownSegment(code);
}
void Interpreter::begin()
{
if (mRunning)
{
mCallstack.push(mRuntime);
mRuntime.clear();
}
else
{
mRunning = true;
}
}
void Interpreter::end()
{
if (mCallstack.empty())
{
mRuntime.clear();
mRunning = false;
}
else
{
mRuntime = mCallstack.top();
mCallstack.pop();
}
}
void Interpreter::run(const Program& program, Context& context)
{
begin();
try
{
mRuntime.configure(program, context);
while (mRuntime.getPC() >= 0 && static_cast<std::size_t>(mRuntime.getPC()) < program.mInstructions.size())
{
const Type_Code instruction = program.mInstructions[mRuntime.getPC()];
mRuntime.setPC(mRuntime.getPC() + 1);
execute(instruction);
}
}
catch (...)
{
end();
throw;
}
end();
}
}
| 3,167
|
C++
|
.cpp
| 109
| 19.33945
| 120
| 0.518445
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,881
|
defines.cpp
|
OpenMW_openmw/components/interpreter/defines.cpp
|
#include "defines.hpp"
#include <algorithm>
#include <sstream>
#include <string>
#include <string_view>
#include <tuple>
#include <vector>
#include <components/debug/debuglog.hpp>
#include <components/misc/strings/algorithm.hpp>
namespace
{
bool check(std::string_view str, std::string_view escword, size_t& i, size_t& start)
{
bool found = Misc::StringUtils::ciStartsWith(str, escword);
if (found)
{
i += escword.length();
start = i + 1;
}
return found;
}
std::vector<std::string> globals;
const std::initializer_list<std::tuple<std::string_view, std::string_view>> sActionBindings{
{ "actionslideright", "#{sRight}" },
{ "actionreadymagic", "#{sReady_Magic}" },
{ "actionprevweapon", "#{sPrevWeapon}" },
{ "actionnextweapon", "#{sNextWeapon}" },
{ "actiontogglerun", "#{sAuto_Run}" },
{ "actionslideleft", "#{sLeft}" },
{ "actionreadyitem", "#{sReady_Weapon}" },
{ "actionprevspell", "#{sPrevSpell}" },
{ "actionnextspell", "#{sNextSpell}" },
{ "actionrestmenu", "#{sRestKey}" },
{ "actionmenumode", "#{sInventory}" },
{ "actionactivate", "#{sActivate}" },
{ "actionjournal", "#{sJournal}" },
{ "actionforward", "#{sForward}" },
{ "actioncrouch", "#{sCrouch_Sneak}" },
{ "actionjump", "#{sJump}" },
{ "actionback", "#{sBack}" },
{ "actionuse", "#{sUse}" },
{ "actionrun", "#{sRun}" },
};
using ContextMethod = std::string_view (Interpreter::Context::*)() const;
const std::initializer_list<std::tuple<std::string_view, std::pair<ContextMethod, ContextMethod>>> sContextMethods{
{ "nextpcrank", { &Interpreter::Context::getPCNextRank, nullptr } },
{ "pcnextrank", { &Interpreter::Context::getPCNextRank, nullptr } },
{ "faction", { &Interpreter::Context::getNPCFaction, nullptr } },
{ "pcclass", { &Interpreter::Context::getPCClass, &Interpreter::Context::getPCClass } },
{ "pcname", { &Interpreter::Context::getPCName, &Interpreter::Context::getPCName } },
{ "pcrace", { &Interpreter::Context::getPCRace, &Interpreter::Context::getPCRace } },
{ "pcrank", { &Interpreter::Context::getPCRank, nullptr } },
{ "class", { &Interpreter::Context::getNPCClass, &Interpreter::Context::getPCClass } },
{ "cell", { &Interpreter::Context::getCurrentCellName, &Interpreter::Context::getCurrentCellName } },
{ "race", { &Interpreter::Context::getNPCRace, &Interpreter::Context::getPCRace } },
{ "rank", { &Interpreter::Context::getNPCRank, nullptr } },
{ "name", { &Interpreter::Context::getActorName, &Interpreter::Context::getPCName } },
};
bool longerStr(std::string_view a, std::string_view b)
{
return a.length() > b.length();
}
bool findReplacement(std::string_view temp, size_t& i, size_t& start, Interpreter::Context& context,
std::ostringstream& retval, bool dialogue)
{
for (const auto& [name, binding] : sActionBindings)
{
if (check(temp, name, i, start))
{
retval << context.getActionBinding(binding);
return true;
}
}
if (check(temp, "pccrimelevel", i, start))
{
retval << context.getPCBounty();
return true;
}
for (const auto& [name, methods] : sContextMethods)
{
const auto& method = dialogue ? methods.first : methods.second;
if (check(temp, name, i, start))
{
if (method) // Not all variables are available outside of dialogue
retval << (context.*method)();
return true;
}
}
return false;
}
std::string fixDefinesReal(std::string_view text, bool dialogue, Interpreter::Context& context)
{
size_t start = 0;
std::ostringstream retval;
for (size_t i = 0; i < text.length(); ++i)
{
char eschar = text[i];
if (eschar == '%' || eschar == '^')
{
retval << text.substr(start, i - start);
std::string_view temp = text.substr(i + 1);
bool found = false;
try
{
found = findReplacement(temp, i, start, context, retval, dialogue);
/* Not a builtin, try global variables */
if (!found)
{
/* if list of globals is empty, grab it and sort it by descending string length */
if (globals.empty())
{
globals = context.getGlobals();
sort(globals.begin(), globals.end(), longerStr);
}
for (const std::string& global : globals)
{
found = check(temp, global, i, start);
if (found)
{
char type = context.getGlobalType(global);
switch (type)
{
case 's':
retval << context.getGlobalShort(global);
break;
case 'l':
retval << context.getGlobalLong(global);
break;
case 'f':
retval << context.getGlobalFloat(global);
break;
}
break;
}
}
}
}
catch (std::exception& e)
{
Log(Debug::Error) << "Error: Failed to replace escape character, with the following error: "
<< e.what();
Log(Debug::Error) << "Full text below:\n" << text;
}
// Not found, or error
if (!found)
{
/* leave unmodified */
i += 1;
start = i;
retval << eschar;
}
}
}
retval << text.substr(start, text.length() - start);
return retval.str();
}
}
namespace Interpreter
{
std::string fixDefinesDialog(std::string_view text, Context& context)
{
return fixDefinesReal(text, true, context);
}
std::string fixDefinesMsgBox(std::string_view text, Context& context)
{
return fixDefinesReal(text, false, context);
}
std::string fixDefinesBook(std::string_view text, Context& context)
{
return fixDefinesReal(text, false, context);
}
}
| 7,127
|
C++
|
.cpp
| 172
| 27.866279
| 119
| 0.490849
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,882
|
translation.cpp
|
OpenMW_openmw/components/translation/translation.cpp
|
#include "translation.hpp"
#include <fstream>
namespace Translation
{
Storage::Storage()
: mEncoder(nullptr)
{
}
void Storage::loadTranslationData(const Files::Collections& dataFileCollections, std::string_view esmFileName)
{
std::string esmNameNoExtension(Misc::StringUtils::lowerCase(esmFileName));
// changing the extension
size_t dotPos = esmNameNoExtension.rfind('.');
if (dotPos != std::string::npos)
esmNameNoExtension.resize(dotPos);
loadData(mCellNamesTranslations, esmNameNoExtension, ".cel", dataFileCollections);
loadData(mPhraseForms, esmNameNoExtension, ".top", dataFileCollections);
loadData(mTopicIDs, esmNameNoExtension, ".mrk", dataFileCollections);
}
void Storage::loadData(ContainerType& container, const std::string& fileNameNoExtension,
const std::string& extension, const Files::Collections& dataFileCollections)
{
std::string fileName = fileNameNoExtension + extension;
if (dataFileCollections.getCollection(extension).doesExist(fileName))
{
std::ifstream stream(dataFileCollections.getCollection(extension).getPath(fileName).c_str());
if (!stream.is_open())
throw std::runtime_error("failed to open translation file: " + fileName);
loadDataFromStream(container, stream);
}
}
void Storage::loadDataFromStream(ContainerType& container, std::istream& stream)
{
std::string line;
while (!stream.eof() && !stream.fail())
{
std::getline(stream, line);
if (!line.empty() && *line.rbegin() == '\r')
line.resize(line.size() - 1);
if (!line.empty())
{
const std::string_view utf8 = mEncoder->getUtf8(line);
size_t tab_pos = utf8.find('\t');
if (tab_pos != std::string::npos && tab_pos > 0 && tab_pos < utf8.size() - 1)
{
const std::string_view key = utf8.substr(0, tab_pos);
const std::string_view value = utf8.substr(tab_pos + 1);
if (!key.empty() && !value.empty())
container.emplace(key, value);
}
}
}
}
std::string_view Storage::translateCellName(std::string_view cellName) const
{
auto entry = mCellNamesTranslations.find(cellName);
if (entry == mCellNamesTranslations.end())
return cellName;
return entry->second;
}
std::string_view Storage::topicID(std::string_view phrase) const
{
std::string_view result = topicStandardForm(phrase);
// seeking for the topic ID
auto topicIDIterator = mTopicIDs.find(result);
if (topicIDIterator != mTopicIDs.end())
result = topicIDIterator->second;
return result;
}
std::string_view Storage::topicStandardForm(std::string_view phrase) const
{
auto phraseFormsIterator = mPhraseForms.find(phrase);
if (phraseFormsIterator != mPhraseForms.end())
return phraseFormsIterator->second;
else
return phrase;
}
void Storage::setEncoder(ToUTF8::Utf8Encoder* encoder)
{
mEncoder = encoder;
}
bool Storage::hasTranslation() const
{
return !mCellNamesTranslations.empty() || !mTopicIDs.empty() || !mPhraseForms.empty();
}
}
| 3,491
|
C++
|
.cpp
| 86
| 31.186047
| 114
| 0.616795
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,883
|
technique.cpp
|
OpenMW_openmw/components/fx/technique.cpp
|
#include "technique.hpp"
#include <array>
#include <string>
#include <utility>
#include <osg/Texture1D>
#include <osg/Texture2D>
#include <osg/Texture3D>
#include <SDL_opengl_glext.h>
#include <components/debug/debuglog.hpp>
#include <components/files/conversion.hpp>
#include <components/misc/strings/algorithm.hpp>
#include <components/resource/imagemanager.hpp>
#include <components/stereo/multiview.hpp>
#include <components/vfs/manager.hpp>
#include "parse_constants.hpp"
namespace
{
struct ProxyTextureData
{
osg::Texture::WrapMode wrap_s = osg::Texture::CLAMP_TO_EDGE;
osg::Texture::WrapMode wrap_t = osg::Texture::CLAMP_TO_EDGE;
osg::Texture::WrapMode wrap_r = osg::Texture::CLAMP_TO_EDGE;
osg::Texture::FilterMode min_filter = osg::Texture::LINEAR_MIPMAP_LINEAR;
osg::Texture::FilterMode mag_filter = osg::Texture::LINEAR;
osg::Texture::InternalFormatMode compression = osg::Texture::USE_IMAGE_DATA_FORMAT;
std::optional<int> source_format;
std::optional<int> source_type;
std::optional<int> internal_format;
};
}
namespace fx
{
namespace
{
VFS::Path::Normalized makeFilePath(std::string_view name)
{
std::string fileName(name);
fileName += Technique::sExt;
VFS::Path::Normalized result(Technique::sSubdir);
result /= fileName;
return result;
}
}
Technique::Technique(const VFS::Manager& vfs, Resource::ImageManager& imageManager, std::string name, int width,
int height, bool ubo, bool supportsNormals)
: mName(std::move(name))
, mFilePath(makeFilePath(mName))
, mLastModificationTime(std::filesystem::file_time_type::clock::now())
, mWidth(width)
, mHeight(height)
, mVFS(vfs)
, mImageManager(imageManager)
, mUBO(ubo)
, mSupportsNormals(supportsNormals)
{
clear();
}
void Technique::clear()
{
mTextures.clear();
mStatus = Status::Uncompiled;
mValid = false;
mHDR = false;
mNormals = false;
mLights = false;
mEnabled = true;
mPassMap.clear();
mPasses.clear();
mPassKeys.clear();
mDefinedUniforms.clear();
mRenderTargets.clear();
mLastAppliedType = Pass::Type::None;
mFlags = 0;
mShared.clear();
mAuthor = {};
mDescription = {};
mVersion = {};
mGLSLExtensions.clear();
mGLSLVersion = mUBO ? 330 : 120;
mGLSLProfile.clear();
mDynamic = false;
}
std::string Technique::getBlockWithLineDirective()
{
auto block = mLexer->getLastJumpBlock();
std::string content = std::string(block.content);
content = "\n#line " + std::to_string(block.line + 1) + "\n" + std::string(block.content) + "\n";
return content;
}
Technique::UniformMap::iterator Technique::findUniform(const std::string& name)
{
return std::find_if(mDefinedUniforms.begin(), mDefinedUniforms.end(),
[&name](const auto& uniform) { return uniform->mName == name; });
}
bool Technique::compile()
{
clear();
if (!mVFS.exists(mFilePath))
{
Log(Debug::Error) << "Could not load technique, file does not exist '" << mFilePath << "'";
mStatus = Status::File_Not_exists;
return false;
}
try
{
std::string source(std::istreambuf_iterator<char>(*mVFS.get(getFileName())), {});
parse(std::move(source));
if (mPassKeys.empty())
error("no pass list found, ensure you define one in a 'technique' block");
int swaps = 0;
for (auto& name : mPassKeys)
{
auto it = mPassMap.find(name);
if (it == mPassMap.end())
error(
Misc::StringUtils::format("pass '%s' was found in the pass list, but there was no matching "
"'fragment', 'vertex' or 'compute' block",
std::string(name)));
if (mLastAppliedType != Pass::Type::None && mLastAppliedType != it->second->mType)
{
swaps++;
if (swaps == 2)
Log(Debug::Warning) << "compute and pixel shaders are being swapped multiple times in shader "
"chain, this can lead to serious performance drain.";
}
else
mLastAppliedType = it->second->mType;
if (Stereo::getMultiview())
{
mGLSLExtensions.insert("GL_OVR_multiview");
mGLSLExtensions.insert("GL_OVR_multiview2");
mGLSLExtensions.insert("GL_EXT_texture_array");
}
it->second->compile(*this, mShared);
if (!it->second->mTarget.empty())
{
auto rtIt = mRenderTargets.find(it->second->mTarget);
if (rtIt == mRenderTargets.end())
error(Misc::StringUtils::format("target '%s' not defined", std::string(it->second->mTarget)));
}
mPasses.emplace_back(it->second);
}
if (mPasses.empty())
error("invalid pass list, no passes defined for technique");
mValid = true;
}
catch (const std::runtime_error& e)
{
clear();
mStatus = Status::Parse_Error;
mLastError = "Failed parsing technique '" + getName() + "' " + e.what();
Log(Debug::Error) << mLastError;
}
return mValid;
}
std::string Technique::getName() const
{
return mName;
}
bool Technique::setLastModificationTime(std::filesystem::file_time_type timeStamp)
{
const bool isDirty = timeStamp != mLastModificationTime;
mLastModificationTime = timeStamp;
return isDirty;
}
[[noreturn]] void Technique::error(const std::string& msg)
{
mLexer->error(msg);
}
template <>
void Technique::parseBlockImp<Lexer::Shared>()
{
if (!mLexer->jump())
error(Misc::StringUtils::format("unterminated 'shared' block, expected closing brackets"));
if (!mShared.empty())
error("repeated 'shared' block, only one allowed per technique file");
mShared = getBlockWithLineDirective();
}
template <>
void Technique::parseBlockImp<Lexer::Technique>()
{
if (!mPassKeys.empty())
error("exactly one 'technique' block can appear per file");
while (!isNext<Lexer::Close_bracket>() && !isNext<Lexer::Eof>())
{
expect<Lexer::Literal>();
auto key = std::get<Lexer::Literal>(mToken).value;
expect<Lexer::Equal>();
if (key == "passes")
mPassKeys = parseLiteralList<Lexer::Comma>();
else if (key == "version")
mVersion = parseString();
else if (key == "description")
mDescription = parseString();
else if (key == "author")
mAuthor = parseString();
else if (key == "glsl_version")
{
int version = parseInteger();
if (mUBO && version > 330)
mGLSLVersion = version;
}
else if (key == "flags")
mFlags = parseFlags();
else if (key == "hdr")
mHDR = parseBool();
else if (key == "pass_normals")
mNormals = parseBool() && mSupportsNormals;
else if (key == "pass_lights")
mLights = parseBool();
else if (key == "glsl_profile")
{
expect<Lexer::String>();
mGLSLProfile = std::string(std::get<Lexer::String>(mToken).value);
}
else if (key == "glsl_extensions")
{
for (const auto& ext : parseLiteralList<Lexer::Comma>())
mGLSLExtensions.emplace(ext);
}
else if (key == "dynamic")
mDynamic = parseBool();
else
error(Misc::StringUtils::format("unexpected key '%s'", std::string{ key }));
expect<Lexer::SemiColon>();
}
if (mPassKeys.empty())
error("pass list in 'technique' block cannot be empty.");
}
template <>
void Technique::parseBlockImp<Lexer::Render_Target>()
{
if (mRenderTargets.count(mBlockName))
error(Misc::StringUtils::format("redeclaration of render target '%s'", std::string(mBlockName)));
fx::Types::RenderTarget rt;
rt.mTarget->setTextureSize(mWidth, mHeight);
rt.mTarget->setSourceFormat(GL_RGB);
rt.mTarget->setInternalFormat(GL_RGB);
rt.mTarget->setSourceType(GL_UNSIGNED_BYTE);
rt.mTarget->setWrap(osg::Texture::WRAP_S, osg::Texture::CLAMP_TO_EDGE);
rt.mTarget->setWrap(osg::Texture::WRAP_T, osg::Texture::CLAMP_TO_EDGE);
rt.mTarget->setName(std::string(mBlockName));
while (!isNext<Lexer::Close_bracket>() && !isNext<Lexer::Eof>())
{
expect<Lexer::Literal>();
auto key = std::get<Lexer::Literal>(mToken).value;
expect<Lexer::Equal>();
if (key == "min_filter")
rt.mTarget->setFilter(osg::Texture2D::MIN_FILTER, parseFilterMode());
else if (key == "mag_filter")
rt.mTarget->setFilter(osg::Texture2D::MAG_FILTER, parseFilterMode());
else if (key == "wrap_s")
rt.mTarget->setWrap(osg::Texture2D::WRAP_S, parseWrapMode());
else if (key == "wrap_t")
rt.mTarget->setWrap(osg::Texture2D::WRAP_T, parseWrapMode());
else if (key == "width_ratio")
rt.mSize.mWidthRatio = parseFloat();
else if (key == "height_ratio")
rt.mSize.mHeightRatio = parseFloat();
else if (key == "width")
rt.mSize.mWidth = parseInteger();
else if (key == "height")
rt.mSize.mHeight = parseInteger();
else if (key == "internal_format")
rt.mTarget->setInternalFormat(parseInternalFormat());
else if (key == "source_type")
rt.mTarget->setSourceType(parseSourceType());
else if (key == "source_format")
rt.mTarget->setSourceFormat(parseSourceFormat());
else if (key == "mipmaps")
rt.mMipMap = parseBool();
else if (key == "clear_color")
rt.mClearColor = parseVec<osg::Vec4f, Lexer::Vec4>();
else
error(Misc::StringUtils::format("unexpected key '%s'", std::string(key)));
expect<Lexer::SemiColon>();
}
mRenderTargets.emplace(mBlockName, std::move(rt));
}
template <>
void Technique::parseBlockImp<Lexer::Vertex>()
{
if (!mLexer->jump())
error(Misc::StringUtils::format("unterminated 'vertex' block, expected closing brackets"));
auto& pass = mPassMap[mBlockName];
if (!pass)
pass = std::make_shared<fx::Pass>();
pass->mName = mBlockName;
if (pass->mCompute)
error(Misc::StringUtils::format("'compute' block already defined. Usage is ambiguous."));
else if (!pass->mVertex)
pass->mVertex = new osg::Shader(osg::Shader::VERTEX, getBlockWithLineDirective());
else
error(Misc::StringUtils::format("duplicate vertex shader for block '%s'", std::string(mBlockName)));
pass->mType = Pass::Type::Pixel;
}
template <>
void Technique::parseBlockImp<Lexer::Fragment>()
{
if (!mLexer->jump())
error(Misc::StringUtils::format("unterminated 'fragment' block, expected closing brackets"));
auto& pass = mPassMap[mBlockName];
if (!pass)
pass = std::make_shared<fx::Pass>();
pass->mUBO = mUBO;
pass->mName = mBlockName;
if (pass->mCompute)
error(Misc::StringUtils::format("'compute' block already defined. Usage is ambiguous."));
else if (!pass->mFragment)
pass->mFragment = new osg::Shader(osg::Shader::FRAGMENT, getBlockWithLineDirective());
else
error(Misc::StringUtils::format("duplicate vertex shader for block '%s'", std::string(mBlockName)));
pass->mType = Pass::Type::Pixel;
}
template <>
void Technique::parseBlockImp<Lexer::Compute>()
{
if (!mLexer->jump())
error(Misc::StringUtils::format("unterminated 'compute' block, expected closing brackets"));
auto& pass = mPassMap[mBlockName];
if (!pass)
pass = std::make_shared<fx::Pass>();
pass->mName = mBlockName;
if (pass->mFragment)
error(Misc::StringUtils::format("'fragment' block already defined. Usage is ambiguous."));
else if (pass->mVertex)
error(Misc::StringUtils::format("'vertex' block already defined. Usage is ambiguous."));
else if (!pass->mFragment)
pass->mCompute = new osg::Shader(osg::Shader::COMPUTE, getBlockWithLineDirective());
else
error(Misc::StringUtils::format("duplicate vertex shader for block '%s'", std::string(mBlockName)));
pass->mType = Pass::Type::Compute;
}
template <class T>
void Technique::parseSampler()
{
if (findUniform(std::string(mBlockName)) != mDefinedUniforms.end())
error(Misc::StringUtils::format("redeclaration of uniform '%s'", std::string(mBlockName)));
ProxyTextureData proxy;
osg::ref_ptr<osg::Texture> sampler;
constexpr bool is1D = std::is_same_v<Lexer::Sampler_1D, T>;
constexpr bool is3D = std::is_same_v<Lexer::Sampler_3D, T>;
Types::SamplerType type;
while (!isNext<Lexer::Close_bracket>() && !isNext<Lexer::Eof>())
{
expect<Lexer::Literal>();
auto key = asLiteral();
expect<Lexer::Equal>();
if (!is1D && key == "min_filter")
proxy.min_filter = parseFilterMode();
else if (!is1D && key == "mag_filter")
proxy.mag_filter = parseFilterMode();
else if (key == "wrap_s")
proxy.wrap_s = parseWrapMode();
else if (key == "wrap_t")
proxy.wrap_t = parseWrapMode();
else if (is3D && key == "wrap_r")
proxy.wrap_r = parseWrapMode();
else if (key == "compression")
proxy.compression = parseCompression();
else if (key == "source_type")
proxy.source_type = parseSourceType();
else if (key == "source_format")
proxy.source_format = parseSourceFormat();
else if (key == "internal_format")
proxy.internal_format = parseInternalFormat();
else if (key == "source")
{
expect<Lexer::String>();
const osg::ref_ptr<osg::Image> image
= mImageManager.getImage(VFS::Path::Normalized(std::get<Lexer::String>(mToken).value), is3D);
if constexpr (is1D)
{
type = Types::SamplerType::Texture_1D;
sampler = new osg::Texture1D(image);
}
else if constexpr (is3D)
{
type = Types::SamplerType::Texture_3D;
sampler = new osg::Texture3D(image);
}
else
{
type = Types::SamplerType::Texture_2D;
sampler = new osg::Texture2D(image);
}
}
else
error(Misc::StringUtils::format("unexpected key '%s'", std::string{ key }));
expect<Lexer::SemiColon>();
}
if (!sampler)
error(Misc::StringUtils::format(
"%s '%s' requires a filename", std::string(T::repr), std::string{ mBlockName }));
if (!is1D)
{
sampler->setFilter(osg::Texture::MIN_FILTER, proxy.min_filter);
sampler->setFilter(osg::Texture::MAG_FILTER, proxy.mag_filter);
}
if (is3D)
sampler->setWrap(osg::Texture::WRAP_R, proxy.wrap_r);
sampler->setWrap(osg::Texture::WRAP_S, proxy.wrap_s);
sampler->setWrap(osg::Texture::WRAP_T, proxy.wrap_t);
sampler->setInternalFormatMode(proxy.compression);
if (proxy.internal_format.has_value())
sampler->setInternalFormat(proxy.internal_format.value());
if (proxy.source_type.has_value())
sampler->setSourceType(proxy.source_type.value());
if (proxy.internal_format.has_value())
sampler->setSourceFormat(proxy.internal_format.value());
sampler->setName(std::string{ mBlockName });
sampler->setResizeNonPowerOfTwoHint(false);
mTextures.emplace_back(sampler);
std::shared_ptr<Types::UniformBase> uniform = std::make_shared<Types::UniformBase>();
uniform->mSamplerType = type;
uniform->mName = std::string(mBlockName);
mDefinedUniforms.emplace_back(std::move(uniform));
}
template <class SrcT, class T>
SrcT Technique::getUniformValue()
{
constexpr bool isVec
= std::is_same_v<osg::Vec2f, SrcT> || std::is_same_v<osg::Vec3f, SrcT> || std::is_same_v<osg::Vec4f, SrcT>;
constexpr bool isFloat = std::is_same_v<float, SrcT>;
constexpr bool isInt = std::is_same_v<int, SrcT>;
constexpr bool isBool = std::is_same_v<bool, SrcT>;
static_assert(isVec || isFloat || isInt || isBool, "Unsupported type");
if constexpr (isVec)
{
return parseVec<SrcT, T>();
}
else if constexpr (isFloat)
{
return parseFloat();
}
else if constexpr (isInt)
{
return parseInteger();
}
else if constexpr (isBool)
{
return parseBool();
}
error(Misc::StringUtils::format("failed setting uniform type"));
}
template <class SrcT, class T>
void Technique::parseUniform()
{
if (findUniform(std::string(mBlockName)) != mDefinedUniforms.end())
error(Misc::StringUtils::format("redeclaration of uniform '%s'", std::string(mBlockName)));
std::shared_ptr<Types::UniformBase> uniform = std::make_shared<Types::UniformBase>();
Types::Uniform<SrcT> data = Types::Uniform<SrcT>();
while (!isNext<Lexer::Close_bracket>() && !isNext<Lexer::Eof>())
{
expect<Lexer::Literal>();
auto key = asLiteral();
expect<Lexer::Equal>("error parsing config for uniform block");
if (key == "default")
{
data.mDefault = getUniformValue<SrcT, T>();
}
else if (key == "size")
{
if constexpr (std::is_same_v<bool, SrcT>)
error("bool arrays currently unsupported");
int size = parseInteger();
if (size > 1)
data.mArray = std::vector<SrcT>(size);
}
else if (key == "min")
{
data.mMin = getUniformValue<SrcT, T>();
}
else if (key == "max")
{
data.mMax = getUniformValue<SrcT, T>();
}
else if (key == "step")
uniform->mStep = parseFloat();
else if (key == "static")
uniform->mStatic = parseBool();
else if (key == "description")
{
uniform->mDescription = parseString();
}
else if (key == "header")
{
uniform->mHeader = parseString();
}
else if (key == "display_name")
{
uniform->mDisplayName = parseString();
}
else if (key == "widget_type")
{
parseWidgetType<SrcT, T>(data);
}
else
error(Misc::StringUtils::format("unexpected key '%s'", std::string{ key }));
expect<Lexer::SemiColon>();
}
if (data.isArray())
uniform->mStatic = false;
uniform->mName = std::string(mBlockName);
uniform->mData = data;
uniform->mTechniqueName = mName;
if (data.mArray)
{
if constexpr (!std::is_same_v<bool, SrcT>)
{
if (auto cached = Settings::ShaderManager::get().getValue<std::vector<SrcT>>(mName, uniform->mName))
uniform->setValue(cached.value());
}
}
else if (auto cached = Settings::ShaderManager::get().getValue<SrcT>(mName, uniform->mName))
{
uniform->setValue(cached.value());
}
mDefinedUniforms.emplace_back(std::move(uniform));
}
template <>
void Technique::parseBlockImp<Lexer::Sampler_1D>()
{
parseSampler<Lexer::Sampler_1D>();
}
template <>
void Technique::parseBlockImp<Lexer::Sampler_2D>()
{
parseSampler<Lexer::Sampler_2D>();
}
template <>
void Technique::parseBlockImp<Lexer::Sampler_3D>()
{
parseSampler<Lexer::Sampler_3D>();
}
template <>
void Technique::parseBlockImp<Lexer::Uniform_Bool>()
{
parseUniform<bool, bool>();
}
template <>
void Technique::parseBlockImp<Lexer::Uniform_Float>()
{
parseUniform<float, float>();
}
template <>
void Technique::parseBlockImp<Lexer::Uniform_Int>()
{
parseUniform<int, int>();
}
template <>
void Technique::parseBlockImp<Lexer::Uniform_Vec2>()
{
parseUniform<osg::Vec2f, Lexer::Vec2>();
}
template <>
void Technique::parseBlockImp<Lexer::Uniform_Vec3>()
{
parseUniform<osg::Vec3f, Lexer::Vec3>();
}
template <>
void Technique::parseBlockImp<Lexer::Uniform_Vec4>()
{
parseUniform<osg::Vec4f, Lexer::Vec4>();
}
template <class T>
void Technique::expect(const std::string& err)
{
mToken = mLexer->next();
if (!std::holds_alternative<T>(mToken))
{
if (err.empty())
error(Misc::StringUtils::format("Expected %s", std::string(T::repr)));
else
error(Misc::StringUtils::format("%s. Expected %s", err, std::string(T::repr)));
}
}
template <class T, class T2>
void Technique::expect(const std::string& err)
{
mToken = mLexer->next();
if (!std::holds_alternative<T>(mToken) && !std::holds_alternative<T2>(mToken))
{
if (err.empty())
error(Misc::StringUtils::format(
"%s. Expected %s or %s", err, std::string(T::repr), std::string(T2::repr)));
else
error(Misc::StringUtils::format("Expected %s or %s", std::string(T::repr), std::string(T2::repr)));
}
}
template <class T>
bool Technique::isNext()
{
return std::holds_alternative<T>(mLexer->peek());
}
void Technique::parse(std::string&& buffer)
{
mBuffer = std::move(buffer);
Misc::StringUtils::replaceAll(mBuffer, "\r\n", "\n");
mLexer = std::make_unique<Lexer::Lexer>(mBuffer);
for (auto t = mLexer->next(); !std::holds_alternative<Lexer::Eof>(t); t = mLexer->next())
{
std::visit(
[this](auto&& arg) {
using T = std::decay_t<decltype(arg)>;
if constexpr (std::is_same_v<Lexer::Shared, T>)
parseBlock<Lexer::Shared>(false);
else if constexpr (std::is_same_v<Lexer::Technique, T>)
parseBlock<Lexer::Technique>(false);
else if constexpr (std::is_same_v<Lexer::Render_Target, T>)
parseBlock<Lexer::Render_Target>();
else if constexpr (std::is_same_v<Lexer::Vertex, T>)
parseBlock<Lexer::Vertex>();
else if constexpr (std::is_same_v<Lexer::Fragment, T>)
parseBlock<Lexer::Fragment>();
else if constexpr (std::is_same_v<Lexer::Compute, T>)
parseBlock<Lexer::Compute>();
else if constexpr (std::is_same_v<Lexer::Sampler_1D, T>)
parseBlock<Lexer::Sampler_1D>();
else if constexpr (std::is_same_v<Lexer::Sampler_2D, T>)
parseBlock<Lexer::Sampler_2D>();
else if constexpr (std::is_same_v<Lexer::Sampler_3D, T>)
parseBlock<Lexer::Sampler_3D>();
else if constexpr (std::is_same_v<Lexer::Uniform_Bool, T>)
parseBlock<Lexer::Uniform_Bool>();
else if constexpr (std::is_same_v<Lexer::Uniform_Float, T>)
parseBlock<Lexer::Uniform_Float>();
else if constexpr (std::is_same_v<Lexer::Uniform_Int, T>)
parseBlock<Lexer::Uniform_Int>();
else if constexpr (std::is_same_v<Lexer::Uniform_Vec2, T>)
parseBlock<Lexer::Uniform_Vec2>();
else if constexpr (std::is_same_v<Lexer::Uniform_Vec3, T>)
parseBlock<Lexer::Uniform_Vec3>();
else if constexpr (std::is_same_v<Lexer::Uniform_Vec4, T>)
parseBlock<Lexer::Uniform_Vec4>();
else
error("invalid top level block");
},
t);
}
}
template <class T>
void Technique::parseBlock(bool named)
{
mBlockName = T::repr;
if (named)
{
expect<Lexer::Literal>("name is required for preceeding block decleration");
mBlockName = std::get<Lexer::Literal>(mToken).value;
if (isNext<Lexer::Open_Parenthesis>())
parseBlockHeader();
}
expect<Lexer::Open_bracket>();
parseBlockImp<T>();
expect<Lexer::Close_bracket>();
}
template <class TDelimeter>
std::vector<std::string_view> Technique::parseLiteralList()
{
std::vector<std::string_view> data;
while (!isNext<Lexer::Eof>())
{
expect<Lexer::Literal>();
data.emplace_back(std::get<Lexer::Literal>(mToken).value);
if (!isNext<TDelimeter>())
break;
mLexer->next();
}
return data;
}
void Technique::parseBlockHeader()
{
expect<Lexer::Open_Parenthesis>();
if (isNext<Lexer::Close_Parenthesis>())
{
mLexer->next();
return;
}
auto& pass = mPassMap[mBlockName];
if (!pass)
pass = std::make_shared<fx::Pass>();
while (!isNext<Lexer::Eof>())
{
expect<Lexer::Literal>("invalid key in block header");
std::string_view key = std::get<Lexer::Literal>(mToken).value;
expect<Lexer::Equal>();
if (key == "target")
{
expect<Lexer::Literal>();
pass->mTarget = std::get<Lexer::Literal>(mToken).value;
}
else if (key == "rt1")
{
expect<Lexer::Literal>();
pass->mRenderTargets[0] = std::get<Lexer::Literal>(mToken).value;
}
else if (key == "rt2")
{
expect<Lexer::Literal>();
pass->mRenderTargets[1] = std::get<Lexer::Literal>(mToken).value;
}
else if (key == "rt3")
{
expect<Lexer::Literal>();
pass->mRenderTargets[2] = std::get<Lexer::Literal>(mToken).value;
}
else if (key == "blend")
{
expect<Lexer::Open_Parenthesis>();
osg::BlendEquation::Equation blendEq = parseBlendEquation();
expect<Lexer::Comma>();
osg::BlendFunc::BlendFuncMode blendSrc = parseBlendFuncMode();
expect<Lexer::Comma>();
osg::BlendFunc::BlendFuncMode blendDest = parseBlendFuncMode();
expect<Lexer::Close_Parenthesis>();
pass->mBlendSource = blendSrc;
pass->mBlendDest = blendDest;
if (blendEq != osg::BlendEquation::FUNC_ADD)
pass->mBlendEq = blendEq;
}
else
error(Misc::StringUtils::format("unrecognized key '%s' in block header", std::string(key)));
mToken = mLexer->next();
if (std::holds_alternative<Lexer::Comma>(mToken))
{
if (std::holds_alternative<Lexer::Close_Parenthesis>(mLexer->peek()))
error(Misc::StringUtils::format("leading comma in '%s' is not allowed", std::string(mBlockName)));
else
continue;
}
if (std::holds_alternative<Lexer::Close_Parenthesis>(mToken))
return;
}
error("malformed block header");
}
std::string_view Technique::asLiteral() const
{
return std::get<Lexer::Literal>(mToken).value;
}
FlagsType Technique::parseFlags()
{
auto parseBit = [this](std::string_view term) {
for (const auto& [identifer, bit] : constants::TechniqueFlag)
{
if (Misc::StringUtils::ciEqual(term, identifer))
return bit;
}
error(Misc::StringUtils::format("unrecognized flag '%s'", std::string(term)));
};
FlagsType flag = 0;
for (const auto& bit : parseLiteralList<Lexer::Comma>())
flag |= parseBit(bit);
return flag;
}
osg::Texture::FilterMode Technique::parseFilterMode()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::FilterMode)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized filter mode '%s'", std::string{ asLiteral() }));
}
osg::Texture::WrapMode Technique::parseWrapMode()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::WrapMode)
{
if (asLiteral() == identifer)
return mode;
}
if (asLiteral() == "clamp")
error(
"unsupported wrap mode 'clamp'; 'clamp_to_edge' was likely intended, look for an updated shader or "
"contact author");
error(Misc::StringUtils::format("unrecognized wrap mode '%s'", std::string{ asLiteral() }));
}
osg::Texture::InternalFormatMode Technique::parseCompression()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::Compression)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized compression '%s'", std::string{ asLiteral() }));
}
int Technique::parseInternalFormat()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::InternalFormat)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized internal format '%s'", std::string{ asLiteral() }));
}
int Technique::parseSourceType()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::SourceType)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized source type '%s'", std::string{ asLiteral() }));
}
int Technique::parseSourceFormat()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::SourceFormat)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized source format '%s'", std::string{ asLiteral() }));
}
osg::BlendEquation::Equation Technique::parseBlendEquation()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::BlendEquation)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized blend equation '%s'", std::string{ asLiteral() }));
}
osg::BlendFunc::BlendFuncMode Technique::parseBlendFuncMode()
{
expect<Lexer::Literal>();
for (const auto& [identifer, mode] : constants::BlendFunc)
{
if (asLiteral() == identifer)
return mode;
}
error(Misc::StringUtils::format("unrecognized blend function '%s'", std::string{ asLiteral() }));
}
template <class SrcT, class T>
void Technique::parseWidgetType(Types::Uniform<SrcT>& uniform)
{
expect<Lexer::Literal>();
if (asLiteral() == "choice")
{
/* Example usage
widget_type = choice(
"Option A": <T>,
"Option B": <T>,
"Option C": <T>
);
*/
expect<Lexer::Open_Parenthesis>();
std::vector<fx::Types::Choice<SrcT>> choices;
while (!isNext<Lexer::Eof>())
{
fx::Types::Choice<SrcT> choice;
choice.mLabel = parseString();
expect<Lexer::Equal>();
choice.mValue = getUniformValue<SrcT, T>();
choices.push_back(choice);
if (isNext<Lexer::Comma>())
{
mToken = mLexer->next();
// Handle leading comma
if (isNext<Lexer::Close_Parenthesis>())
{
break;
}
continue;
}
break;
}
uniform.mChoices = std::move(choices);
expect<Lexer::Close_Parenthesis>();
}
else
{
error(Misc::StringUtils::format("unrecognized widget type '%s'", std::string{ asLiteral() }));
}
}
bool Technique::parseBool()
{
mToken = mLexer->next();
if (std::holds_alternative<Lexer::True>(mToken))
return true;
if (std::holds_alternative<Lexer::False>(mToken))
return false;
error("expected 'true' or 'false' as boolean value");
}
std::string_view Technique::parseString()
{
expect<Lexer::String>();
return std::get<Lexer::String>(mToken).value;
}
float Technique::parseFloat()
{
mToken = mLexer->next();
if (std::holds_alternative<Lexer::Float>(mToken))
return std::get<Lexer::Float>(mToken).value;
if (std::holds_alternative<Lexer::Integer>(mToken))
return static_cast<float>(std::get<Lexer::Integer>(mToken).value);
error("expected float value");
}
int Technique::parseInteger()
{
expect<Lexer::Integer>();
return std::get<Lexer::Integer>(mToken).value;
}
template <class OSGVec, class T>
OSGVec Technique::parseVec()
{
expect<T>();
expect<Lexer::Open_Parenthesis>();
OSGVec value;
for (int i = 0; i < OSGVec::num_components; ++i)
{
value[i] = parseFloat();
if (i < OSGVec::num_components - 1)
expect<Lexer::Comma>();
}
expect<Lexer::Close_Parenthesis>("check definition of the vector");
return value;
}
}
| 36,579
|
C++
|
.cpp
| 924
| 28.090909
| 119
| 0.539186
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,884
|
stateupdater.cpp
|
OpenMW_openmw/components/fx/stateupdater.cpp
|
#include "stateupdater.hpp"
#include <osg/BufferIndexBinding>
#include <osg/BufferObject>
#include <components/resource/scenemanager.hpp>
namespace fx
{
std::string StateUpdater::sDefinition = UniformData::getDefinition("_omw_data");
StateUpdater::StateUpdater(bool useUBO)
: mUseUBO(useUBO)
{
}
void StateUpdater::setDefaults(osg::StateSet* stateset)
{
if (mUseUBO)
{
osg::ref_ptr<osg::UniformBufferObject> ubo = new osg::UniformBufferObject;
osg::ref_ptr<osg::BufferTemplate<UniformData::BufferType>> data
= new osg::BufferTemplate<UniformData::BufferType>();
data->setBufferObject(ubo);
osg::ref_ptr<osg::UniformBufferBinding> ubb = new osg::UniformBufferBinding(
static_cast<int>(Resource::SceneManager::UBOBinding::PostProcessor), data, 0, mData.getGPUSize());
stateset->setAttributeAndModes(ubb, osg::StateAttribute::ON);
}
else
{
const auto createUniform = [&](const auto& v) {
using T = std::decay_t<decltype(v)>;
std::string name = "omw." + std::string(T::sName);
stateset->addUniform(new osg::Uniform(name.c_str(), mData.get<T>()));
};
std::apply([&](const auto&... v) { (createUniform(v), ...); }, mData.getData());
}
}
void StateUpdater::apply(osg::StateSet* stateset, osg::NodeVisitor* nv)
{
if (mUseUBO)
{
osg::UniformBufferBinding* ubb = dynamic_cast<osg::UniformBufferBinding*>(
stateset->getAttribute(osg::StateAttribute::UNIFORMBUFFERBINDING,
static_cast<int>(Resource::SceneManager::UBOBinding::PostProcessor)));
if (!ubb)
throw std::runtime_error("StateUpdater::apply: failed to get an UniformBufferBinding!");
auto& dest = static_cast<osg::BufferTemplate<UniformData::BufferType>*>(ubb->getBufferData())->getData();
mData.copyTo(dest);
ubb->getBufferData()->dirty();
}
else
{
const auto setUniform = [&](const auto& v) {
using T = std::decay_t<decltype(v)>;
std::string name = "omw." + std::string(T::sName);
stateset->getUniform(name)->set(mData.get<T>());
};
std::apply([&](const auto&... v) { (setUniform(v), ...); }, mData.getData());
}
if (mPointLightBuffer)
mPointLightBuffer->applyUniforms(nv->getTraversalNumber(), stateset);
}
}
| 2,609
|
C++
|
.cpp
| 59
| 33.898305
| 117
| 0.591088
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,885
|
widgets.cpp
|
OpenMW_openmw/components/fx/widgets.cpp
|
#include "widgets.hpp"
#include <components/widgets/box.hpp>
namespace
{
template <class T, class WidgetT>
void createVectorWidget(
const std::shared_ptr<fx::Types::UniformBase>& uniform, MyGUI::Widget* client, fx::Widgets::UniformBase* base)
{
int height = client->getHeight();
base->setSize(base->getSize().width, (base->getSize().height - height) + (height * T::num_components));
client->setSize(client->getSize().width, height * T::num_components);
for (int i = 0; i < T::num_components; ++i)
{
auto* widget = client->createWidget<WidgetT>(
"MW_ValueEditNumber", { 0, height * i, client->getWidth(), height }, MyGUI::Align::Default);
widget->setData(uniform, static_cast<fx::Widgets::Index>(i));
base->addItem(widget);
}
}
}
namespace fx
{
namespace Widgets
{
void EditBool::setValue(bool value)
{
mCheckbutton->setCaptionWithReplacing(value ? "#{Interface:On}" : "#{Interface:Off}");
mFill->setVisible(value);
mUniform->setValue<bool>(value);
}
void EditBool::setValueFromUniform()
{
setValue(mUniform->template getValue<bool>());
}
void EditBool::toDefault()
{
setValue(mUniform->getDefault<bool>());
}
void EditBool::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mCheckbutton, "Checkbutton");
assignWidget(mFill, "Fill");
mCheckbutton->eventMouseButtonClick += MyGUI::newDelegate(this, &EditBool::notifyMouseButtonClick);
}
void EditBool::notifyMouseButtonClick(MyGUI::Widget* sender)
{
setValue(!mUniform->getValue<bool>());
}
template <class T>
void EditChoice::setValue(const T& value)
{
// Update the combo view
for (size_t i = 0; i < this->mChoices->getItemCount(); i++)
{
if (*this->mChoices->getItemDataAt<T>(i) == value)
{
this->mChoices->setIndexSelected(i);
break;
}
}
mUniform->template setValue<T>(value);
}
void EditChoice::notifyComboBoxChanged(MyGUI::ComboBox* sender, size_t pos)
{
std::visit(
[this, sender, pos](auto&& data) {
using T = typename std::decay_t<decltype(data)>::value_type;
setValue<T>(*sender->getItemDataAt<T>(pos));
},
mUniform->mData);
}
void EditChoice::setValueFromUniform()
{
std::visit(
[this](auto&& data) {
using T = typename std::decay_t<decltype(data)>::value_type;
size_t index = 0;
for (const auto& choice : data.mChoices)
{
this->mChoices->addItem(choice.mLabel, choice.mValue);
if (choice.mValue == mUniform->template getValue<T>())
{
this->mChoices->setIndexSelected(index);
}
index++;
}
setValue(mUniform->template getValue<T>());
},
mUniform->mData);
}
void EditChoice::toDefault()
{
std::visit(
[this](auto&& data) {
using T = typename std::decay_t<decltype(data)>::value_type;
setValue(mUniform->template getDefault<T>());
},
mUniform->mData);
}
void EditChoice::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mChoices, "Choices");
mChoices->eventComboChangePosition += MyGUI::newDelegate(this, &EditChoice::notifyComboBoxChanged);
}
void UniformBase::init(const std::shared_ptr<fx::Types::UniformBase>& uniform)
{
if (uniform->mDisplayName.empty())
mLabel->setCaption(uniform->mName);
else
mLabel->setCaptionWithReplacing(uniform->mDisplayName);
if (uniform->mDescription.empty())
{
mLabel->setUserString("ToolTipType", "");
}
else
{
mLabel->setUserString("ToolTipType", "Layout");
mLabel->setUserString("ToolTipLayout", "TextToolTip");
mLabel->setUserString("Caption_Text", uniform->mDescription);
}
std::visit(
[this, &uniform](auto&& arg) {
using T = typename std::decay_t<decltype(arg)>::value_type;
if (arg.mChoices.size() > 0)
{
auto* widget = mClient->createWidget<EditChoice>("MW_ValueEditChoice",
{ 0, 0, mClient->getWidth(), mClient->getHeight() }, MyGUI::Align::Stretch);
widget->setData(uniform);
mBases.emplace_back(widget);
}
else
{
if constexpr (std::is_same_v<osg::Vec4f, T>)
{
createVectorWidget<T, EditNumberFloat4>(uniform, mClient, this);
}
else if constexpr (std::is_same_v<osg::Vec3f, T>)
{
createVectorWidget<T, EditNumberFloat3>(uniform, mClient, this);
}
else if constexpr (std::is_same_v<osg::Vec2f, T>)
{
createVectorWidget<T, EditNumberFloat2>(uniform, mClient, this);
}
else if constexpr (std::is_same_v<T, float>)
{
auto* widget = mClient->createWidget<EditNumberFloat>("MW_ValueEditNumber",
{ 0, 0, mClient->getWidth(), mClient->getHeight() }, MyGUI::Align::Stretch);
widget->setData(uniform);
mBases.emplace_back(widget);
}
else if constexpr (std::is_same_v<T, int>)
{
auto* widget = mClient->createWidget<EditNumberInt>("MW_ValueEditNumber",
{ 0, 0, mClient->getWidth(), mClient->getHeight() }, MyGUI::Align::Stretch);
widget->setData(uniform);
mBases.emplace_back(widget);
}
else if constexpr (std::is_same_v<T, bool>)
{
auto* widget = mClient->createWidget<EditBool>("MW_ValueEditBool",
{ 0, 0, mClient->getWidth(), mClient->getHeight() }, MyGUI::Align::Stretch);
widget->setData(uniform);
mBases.emplace_back(widget);
}
}
mReset->eventMouseButtonClick += MyGUI::newDelegate(this, &UniformBase::notifyResetClicked);
for (EditBase* base : mBases)
base->setValueFromUniform();
},
uniform->mData);
}
void UniformBase::addItem(EditBase* item)
{
mBases.emplace_back(item);
}
void UniformBase::toDefault()
{
for (EditBase* base : mBases)
{
if (base)
base->toDefault();
}
}
void UniformBase::notifyResetClicked(MyGUI::Widget* sender)
{
toDefault();
}
void UniformBase::initialiseOverride()
{
Base::initialiseOverride();
assignWidget(mReset, "Reset");
assignWidget(mLabel, "Label");
assignWidget(mClient, "Client");
}
}
}
| 8,278
|
C++
|
.cpp
| 199
| 25.859296
| 118
| 0.481979
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,886
|
lexer.cpp
|
OpenMW_openmw/components/fx/lexer.cpp
|
#include "lexer.hpp"
#include <cctype>
#include <cstdlib>
#include <optional>
#include <string>
#include <string_view>
#include <components/fx/lexer_types.hpp>
#include <components/misc/strings/format.hpp>
namespace fx
{
namespace Lexer
{
Lexer::Lexer(std::string_view buffer)
: mHead(buffer.data())
, mTail(mHead + buffer.length())
, mAbsolutePos(0)
, mColumn(0)
, mLine(0)
, mBuffer(buffer)
, mLastToken(Eof{})
{
}
Token Lexer::next()
{
if (mLookahead)
{
auto token = *mLookahead;
drop();
return token;
}
mLastToken = scanToken();
return mLastToken;
}
Token Lexer::peek()
{
if (!mLookahead)
mLookahead = scanToken();
return *mLookahead;
}
void Lexer::drop()
{
mLookahead = std::nullopt;
}
std::optional<std::string_view> Lexer::jump()
{
bool multi = false;
bool single = false;
auto start = mHead;
std::size_t level = 1;
mLastJumpBlock.line = mLine;
if (head() == '}')
{
mLastJumpBlock.content = {};
return mLastJumpBlock.content;
}
for (; mHead != mTail; advance())
{
if (head() == '\n')
{
mLine++;
mColumn = 0;
if (single)
{
single = false;
continue;
}
}
else if (multi && head() == '*' && peekChar('/'))
{
multi = false;
advance();
continue;
}
else if (multi || single)
{
continue;
}
else if (head() == '/' && peekChar('/'))
{
single = true;
advance();
continue;
}
else if (head() == '/' && peekChar('*'))
{
multi = true;
advance();
continue;
}
if (head() == '{')
level++;
else if (head() == '}')
level--;
if (level == 0)
{
mHead--;
mLine--;
auto sv = std::string_view{ start, static_cast<std::string_view::size_type>(mHead + 1 - start) };
mLastJumpBlock.content = sv;
return sv;
}
}
mLastJumpBlock = {};
return std::nullopt;
}
Lexer::Block Lexer::getLastJumpBlock() const
{
return mLastJumpBlock;
}
[[noreturn]] void Lexer::error(const std::string& msg)
{
throw LexerException(Misc::StringUtils::format("Line %zu Col %zu. %s", mLine + 1, mColumn, msg));
}
void Lexer::advance()
{
mAbsolutePos++;
mHead++;
mColumn++;
}
char Lexer::head()
{
return *mHead;
}
bool Lexer::peekChar(char c)
{
if (mHead == mTail)
return false;
return *(mHead + 1) == c;
}
Token Lexer::scanToken()
{
while (true)
{
if (mHead == mTail)
return { Eof{} };
if (head() == '\n')
{
mLine++;
mColumn = 0;
}
if (!std::isspace(head()))
break;
advance();
}
if (head() == '\"')
return scanStringLiteral();
if (std::isalpha(head()))
return scanLiteral();
if (std::isdigit(head()) || head() == '.' || head() == '-')
return scanNumber();
switch (head())
{
case '=':
advance();
return { Equal{} };
case '{':
advance();
return { Open_bracket{} };
case '}':
advance();
return { Close_bracket{} };
case '(':
advance();
return { Open_Parenthesis{} };
case ')':
advance();
return { Close_Parenthesis{} };
case '\"':
advance();
return { Quote{} };
case ':':
advance();
return { Colon{} };
case ';':
advance();
return { SemiColon{} };
case '|':
advance();
return { VBar{} };
case ',':
advance();
return { Comma{} };
default:
error(Misc::StringUtils::format("unexpected token <%c>", head()));
}
}
Token Lexer::scanLiteral()
{
auto start = mHead;
advance();
while (mHead != mTail && (std::isalnum(head()) || head() == '_'))
advance();
std::string_view value{ start, static_cast<std::string_view::size_type>(mHead - start) };
if (value == "shared")
return Shared{};
if (value == "technique")
return Technique{};
if (value == "render_target")
return Render_Target{};
if (value == "vertex")
return Vertex{};
if (value == "fragment")
return Fragment{};
if (value == "compute")
return Compute{};
if (value == "sampler_1d")
return Sampler_1D{};
if (value == "sampler_2d")
return Sampler_2D{};
if (value == "sampler_3d")
return Sampler_3D{};
if (value == "uniform_bool")
return Uniform_Bool{};
if (value == "uniform_float")
return Uniform_Float{};
if (value == "uniform_int")
return Uniform_Int{};
if (value == "uniform_vec2")
return Uniform_Vec2{};
if (value == "uniform_vec3")
return Uniform_Vec3{};
if (value == "uniform_vec4")
return Uniform_Vec4{};
if (value == "true")
return True{};
if (value == "false")
return False{};
if (value == "vec2")
return Vec2{};
if (value == "vec3")
return Vec3{};
if (value == "vec4")
return Vec4{};
return Literal{ value };
}
Token Lexer::scanStringLiteral()
{
advance(); // consume quote
auto start = mHead;
bool terminated = false;
for (; mHead != mTail; advance())
{
if (head() == '\"')
{
terminated = true;
advance();
break;
}
}
if (!terminated)
error("unterminated string");
return String{ { start, static_cast<std::string_view::size_type>(mHead - start - 1) } };
}
Token Lexer::scanNumber()
{
double buffer;
char* endPtr;
buffer = std::strtod(mHead, &endPtr);
if (endPtr == nullptr)
error("critical error while parsing number");
const char* tmp = mHead;
mHead = endPtr;
for (; tmp != endPtr; ++tmp)
{
if ((*tmp == '.'))
return Float{ static_cast<float>(buffer) };
}
return Integer{ static_cast<int>(buffer) };
}
}
}
| 8,510
|
C++
|
.cpp
| 271
| 16.745387
| 117
| 0.373444
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,887
|
pass.cpp
|
OpenMW_openmw/components/fx/pass.cpp
|
#include "pass.hpp"
#include <sstream>
#include <string>
#include <unordered_set>
#include <osg/BindImageTexture>
#include <osg/FrameBufferObject>
#include <osg/Program>
#include <osg/Shader>
#include <osg/State>
#include <osg/StateSet>
#include <components/resource/scenemanager.hpp>
#include <components/sceneutil/lightmanager.hpp>
#include <components/settings/values.hpp>
#include <components/stereo/multiview.hpp>
#include <components/version/version.hpp>
#include "stateupdater.hpp"
#include "technique.hpp"
namespace
{
constexpr char s_DefaultVertex[] = R"GLSL(
#if OMW_USE_BINDINGS
omw_In vec2 omw_Vertex;
#endif
omw_Out vec2 omw_TexCoord;
void main()
{
omw_Position = vec4(omw_Vertex.xy, 0.0, 1.0);
omw_TexCoord = omw_Position.xy * 0.5 + 0.5;
})GLSL";
constexpr char s_DefaultVertexMultiview[] = R"GLSL(
layout(num_views = 2) in;
#if OMW_USE_BINDINGS
omw_In vec2 omw_Vertex;
#endif
omw_Out vec2 omw_TexCoord;
void main()
{
omw_Position = vec4(omw_Vertex.xy, 0.0, 1.0);
omw_TexCoord = omw_Position.xy * 0.5 + 0.5;
})GLSL";
}
namespace fx
{
Pass::Pass(Pass::Type type, Pass::Order order, bool ubo)
: mCompiled(false)
, mType(type)
, mOrder(order)
, mLegacyGLSL(true)
, mUBO(ubo)
{
}
std::string Pass::getPassHeader(Technique& technique, std::string_view preamble, bool fragOut)
{
std::string header = R"GLSL(
#version @version @profile
@extensions
@uboStruct
#define OMW_API_VERSION @apiVersion
#define OMW_REVERSE_Z @reverseZ
#define OMW_RADIAL_FOG @radialFog
#define OMW_EXPONENTIAL_FOG @exponentialFog
#define OMW_HDR @hdr
#define OMW_NORMALS @normals
#define OMW_USE_BINDINGS @useBindings
#define OMW_MULTIVIEW @multiview
#define omw_In @in
#define omw_Out @out
#define omw_Position @position
#define omw_Texture1D @texture1D
#define omw_Texture2D @texture2D
#define omw_Texture3D @texture3D
#define omw_Vertex @vertex
#define omw_FragColor @fragColor
@fragBinding
uniform @builtinSampler omw_SamplerLastShader;
uniform @builtinSampler omw_SamplerLastPass;
uniform @builtinSampler omw_SamplerDepth;
uniform @builtinSampler omw_SamplerNormals;
uniform @builtinSampler omw_SamplerDistortion;
uniform vec4 omw_PointLights[@pointLightCount];
uniform int omw_PointLightsCount;
#if OMW_MULTIVIEW
uniform mat4 projectionMatrixMultiView[2];
uniform mat4 invProjectionMatrixMultiView[2];
#endif
int omw_GetPointLightCount()
{
return omw_PointLightsCount;
}
vec3 omw_GetPointLightWorldPos(int index)
{
return omw_PointLights[(index * 3)].xyz;
}
vec3 omw_GetPointLightDiffuse(int index)
{
return omw_PointLights[(index * 3) + 1].xyz;
}
vec3 omw_GetPointLightAttenuation(int index)
{
return omw_PointLights[(index * 3) + 2].xyz;
}
float omw_GetPointLightRadius(int index)
{
return omw_PointLights[(index * 3) + 2].w;
}
#if @ubo
layout(std140) uniform _data { _omw_data omw; };
#else
uniform _omw_data omw;
#endif
mat4 omw_ProjectionMatrix()
{
#if OMW_MULTIVIEW
return projectionMatrixMultiView[gl_ViewID_OVR];
#else
return omw.projectionMatrix;
#endif
}
mat4 omw_InvProjectionMatrix()
{
#if OMW_MULTIVIEW
return invProjectionMatrixMultiView[gl_ViewID_OVR];
#else
return omw.invProjectionMatrix;
#endif
}
float omw_GetDepth(vec2 uv)
{
#if OMW_MULTIVIEW
float depth = omw_Texture2D(omw_SamplerDepth, vec3(uv, gl_ViewID_OVR)).r;
#else
float depth = omw_Texture2D(omw_SamplerDepth, uv).r;
#endif
#if OMW_REVERSE_Z
return 1.0 - depth;
#else
return depth;
#endif
}
vec4 omw_GetLastShader(vec2 uv)
{
#if OMW_MULTIVIEW
return omw_Texture2D(omw_SamplerLastShader, vec3(uv, gl_ViewID_OVR));
#else
return omw_Texture2D(omw_SamplerLastShader, uv);
#endif
}
vec4 omw_GetLastPass(vec2 uv)
{
#if OMW_MULTIVIEW
return omw_Texture2D(omw_SamplerLastPass, vec3(uv, gl_ViewID_OVR));
#else
return omw_Texture2D(omw_SamplerLastPass, uv);
#endif
}
vec3 omw_GetNormals(vec2 uv)
{
#if OMW_MULTIVIEW
return omw_Texture2D(omw_SamplerNormals, vec3(uv, gl_ViewID_OVR)).rgb * 2.0 - 1.0;
#else
return omw_Texture2D(omw_SamplerNormals, uv).rgb * 2.0 - 1.0;
#endif
}
vec3 omw_GetNormalsWorldSpace(vec2 uv)
{
return (vec4(omw_GetNormals(uv), 0.0) * omw.viewMatrix).rgb;
}
vec3 omw_GetWorldPosFromUV(vec2 uv)
{
float depth = omw_GetDepth(uv);
#if (OMW_REVERSE_Z == 1)
float flippedDepth = 1.0 - depth;
#else
float flippedDepth = depth * 2.0 - 1.0;
#endif
vec4 clip_space = vec4(uv * 2.0 - 1.0, flippedDepth, 1.0);
vec4 world_space = omw.invViewMatrix * (omw.invProjectionMatrix * clip_space);
return world_space.xyz / world_space.w;
}
float omw_GetLinearDepth(vec2 uv)
{
#if (OMW_REVERSE_Z == 1)
float depth = omw_GetDepth(uv);
float dist = omw.near * omw.far / (omw.far + depth * (omw.near - omw.far));
#else
float depth = omw_GetDepth(uv) * 2.0 - 1.0;
float dist = 2.0 * omw.near * omw.far / (omw.far + omw.near - depth * (omw.far - omw.near));
#endif
return dist;
}
float omw_EstimateFogCoverageFromUV(vec2 uv)
{
#if OMW_RADIAL_FOG
vec3 uvPos = omw_GetWorldPosFromUV(uv);
float dist = length(uvPos - omw.eyePos.xyz);
#else
float dist = omw_GetLinearDepth(uv);
#endif
#if OMW_EXPONENTIAL_FOG
float fogValue = 1.0 - exp(-2.0 * max(0.0, dist - omw.fogNear/2.0) / (omw.fogFar - omw.fogNear/2.0));
#else
float fogValue = clamp((dist - omw.fogNear) / (omw.fogFar - omw.fogNear), 0.0, 1.0);
#endif
return fogValue;
}
#if OMW_HDR
uniform sampler2D omw_EyeAdaptation;
#endif
float omw_GetEyeAdaptation()
{
#if OMW_HDR
return omw_Texture2D(omw_EyeAdaptation, vec2(0.5, 0.5)).r;
#else
return 1.0;
#endif
}
)GLSL";
std::stringstream extBlock;
for (const auto& extension : technique.getGLSLExtensions())
extBlock << "#ifdef " << extension << '\n'
<< "\t#extension " << extension << ": enable" << '\n'
<< "#endif" << '\n';
const std::vector<std::pair<std::string, std::string>> defines
= { { "@pointLightCount", std::to_string(SceneUtil::PPLightBuffer::sMaxPPLightsArraySize) },
{ "@apiVersion", std::to_string(Version::getPostprocessingApiRevision()) },
{ "@version", std::to_string(technique.getGLSLVersion()) },
{ "@multiview", Stereo::getMultiview() ? "1" : "0" },
{ "@builtinSampler", Stereo::getMultiview() ? "sampler2DArray" : "sampler2D" },
{ "@profile", technique.getGLSLProfile() }, { "@extensions", extBlock.str() },
{ "@uboStruct", StateUpdater::getStructDefinition() }, { "@ubo", mUBO ? "1" : "0" },
{ "@normals", technique.getNormals() ? "1" : "0" },
{ "@reverseZ", SceneUtil::AutoDepth::isReversed() ? "1" : "0" },
{ "@radialFog", Settings::fog().mRadialFog ? "1" : "0" },
{ "@exponentialFog", Settings::fog().mExponentialFog ? "1" : "0" },
{ "@hdr", technique.getHDR() ? "1" : "0" }, { "@in", mLegacyGLSL ? "varying" : "in" },
{ "@out", mLegacyGLSL ? "varying" : "out" }, { "@position", "gl_Position" },
{ "@texture1D", mLegacyGLSL ? "texture1D" : "texture" },
{ "@texture2D", mLegacyGLSL ? "texture2D" : "texture" },
{ "@texture3D", mLegacyGLSL ? "texture3D" : "texture" },
{ "@vertex", mLegacyGLSL ? "gl_Vertex" : "_omw_Vertex" },
{ "@fragColor", mLegacyGLSL ? "gl_FragColor" : "_omw_FragColor" },
{ "@useBindings", mLegacyGLSL ? "0" : "1" },
{ "@fragBinding", mLegacyGLSL ? "" : "out vec4 omw_FragColor;" } };
for (const auto& [define, value] : defines)
for (size_t pos = header.find(define); pos != std::string::npos; pos = header.find(define))
header.replace(pos, define.size(), value);
for (const auto& target : mRenderTargets)
header.append("uniform sampler2D " + std::string(target) + ";");
for (auto& uniform : technique.getUniformMap())
if (auto glsl = uniform->getGLSL())
header.append(glsl.value());
header.append(preamble);
return header;
}
void Pass::prepareStateSet(osg::StateSet* stateSet, const std::string& name) const
{
osg::ref_ptr<osg::Program> program = new osg::Program;
if (mType == Type::Pixel)
{
program->addShader(new osg::Shader(*mVertex));
program->addShader(new osg::Shader(*mFragment));
}
else if (mType == Type::Compute)
{
program->addShader(new osg::Shader(*mCompute));
}
if (mUBO)
program->addBindUniformBlock("_data", static_cast<int>(Resource::SceneManager::UBOBinding::PostProcessor));
program->setName(name);
if (!mLegacyGLSL)
{
program->addBindFragDataLocation("_omw_FragColor", 0);
program->addBindAttribLocation("_omw_Vertex", 0);
}
stateSet->setAttribute(program);
if (mBlendSource && mBlendDest)
stateSet->setAttributeAndModes(new osg::BlendFunc(mBlendSource.value(), mBlendDest.value()));
if (mBlendEq)
stateSet->setAttributeAndModes(new osg::BlendEquation(mBlendEq.value()));
}
void Pass::dirty()
{
mVertex = nullptr;
mFragment = nullptr;
mCompute = nullptr;
mCompiled = false;
}
void Pass::compile(Technique& technique, std::string_view preamble)
{
if (mCompiled)
return;
mLegacyGLSL = technique.getGLSLVersion() < 330;
if (mType == Type::Pixel)
{
if (!mVertex)
mVertex = new osg::Shader(
osg::Shader::VERTEX, Stereo::getMultiview() ? s_DefaultVertexMultiview : s_DefaultVertex);
mVertex->setShaderSource(getPassHeader(technique, preamble).append(mVertex->getShaderSource()));
mFragment->setShaderSource(getPassHeader(technique, preamble, true).append(mFragment->getShaderSource()));
mVertex->setName(mName);
mFragment->setName(mName);
}
else if (mType == Type::Compute)
{
mCompute->setShaderSource(getPassHeader(technique, preamble).append(mCompute->getShaderSource()));
mCompute->setName(mName);
}
mCompiled = true;
}
}
| 10,721
|
C++
|
.cpp
| 310
| 28.474194
| 119
| 0.63675
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,888
|
textedit.cpp
|
OpenMW_openmw/components/lua_ui/textedit.cpp
|
#include "textedit.hpp"
#include "alignment.hpp"
namespace LuaUi
{
void LuaTextEdit::initialize()
{
mEditBox = createWidget<MyGUI::EditBox>("LuaTextEdit", MyGUI::IntCoord(0, 0, 0, 0), MyGUI::Align::Default);
mEditBox->eventEditTextChange += MyGUI::newDelegate(this, &LuaTextEdit::textChange);
mEditBox->setMaxTextLength(std::numeric_limits<std::size_t>::max());
registerEvents(mEditBox);
WidgetExtension::initialize();
}
void LuaTextEdit::deinitialize()
{
mEditBox->eventEditTextChange -= MyGUI::newDelegate(this, &LuaTextEdit::textChange);
clearEvents(mEditBox);
WidgetExtension::deinitialize();
}
void LuaTextEdit::updateProperties()
{
mEditBox->setFontHeight(propertyValue("textSize", 10));
mEditBox->setTextColour(propertyValue("textColor", MyGUI::Colour(0, 0, 0, 1)));
mEditBox->setEditWordWrap(propertyValue("wordWrap", false));
Alignment horizontal(propertyValue("textAlignH", Alignment::Start));
Alignment vertical(propertyValue("textAlignV", Alignment::Start));
mEditBox->setTextAlign(alignmentToMyGui(horizontal, vertical));
mMultiline = propertyValue("multiline", false);
mEditBox->setEditMultiLine(mMultiline);
bool readOnly = propertyValue("readOnly", false);
mEditBox->setEditStatic(readOnly);
mAutoSize = (readOnly || !mMultiline) && propertyValue("autoSize", false);
// change caption last, for multiline and wordwrap to apply
mEditBox->setCaption(propertyValue("text", std::string()));
WidgetExtension::updateProperties();
}
void LuaTextEdit::textChange(MyGUI::EditBox*)
{
triggerEvent("textChanged", sol::make_object(lua(), mEditBox->getCaption().asUTF8()));
}
void LuaTextEdit::updateCoord()
{
WidgetExtension::updateCoord();
mEditBox->setSize(widget()->getSize());
}
void LuaTextEdit::updateChildren()
{
WidgetExtension::updateChildren();
// otherwise it won't be focusable
mEditBox->detachFromWidget();
mEditBox->attachToWidget(this);
}
MyGUI::IntSize LuaTextEdit::calculateSize() const
{
MyGUI::IntSize normalSize = WidgetExtension::calculateSize();
if (mAutoSize)
{
mEditBox->setSize(normalSize);
int targetHeight = mMultiline ? mEditBox->getTextSize().height : mEditBox->getFontHeight();
normalSize.height = std::max(normalSize.height, targetHeight);
}
return normalSize;
}
}
| 2,606
|
C++
|
.cpp
| 63
| 33.920635
| 115
| 0.671016
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,889
|
widget.cpp
|
OpenMW_openmw/components/lua_ui/widget.cpp
|
#include "widget.hpp"
#include <SDL_events.h>
#include <components/sdlutil/sdlmappings.hpp>
namespace LuaUi
{
WidgetExtension::WidgetExtension()
: mForcePosition(false)
, mForceSize(false)
, mPropagateEvents(true)
, mVisible(true)
, mLua(nullptr)
, mWidget(nullptr)
, mSlot(this)
, mLayout(sol::nil)
, mProperties(sol::nil)
, mTemplateProperties(sol::nil)
, mExternal(sol::nil)
, mParent(nullptr)
, mTemplateChild(false)
, mElementRoot(false)
{
}
void WidgetExtension::initialize(lua_State* lua, MyGUI::Widget* self, bool isRoot)
{
mLua = lua;
mWidget = self;
mElementRoot = isRoot;
initialize();
updateTemplate();
}
void WidgetExtension::initialize()
{
// \todo might be more efficient to only register these if there are Lua callbacks
registerEvents(mWidget);
}
void WidgetExtension::deinitialize()
{
clearCallbacks();
clearEvents(mWidget);
for (WidgetExtension* w : mChildren)
w->deinitialize();
for (WidgetExtension* w : mTemplateChildren)
w->deinitialize();
}
void WidgetExtension::registerEvents(MyGUI::Widget* w)
{
w->eventKeyButtonPressed += MyGUI::newDelegate(this, &WidgetExtension::keyPress);
w->eventKeyButtonReleased += MyGUI::newDelegate(this, &WidgetExtension::keyRelease);
w->eventMouseButtonClick += MyGUI::newDelegate(this, &WidgetExtension::mouseClick);
w->eventMouseButtonDoubleClick += MyGUI::newDelegate(this, &WidgetExtension::mouseDoubleClick);
w->eventMouseButtonPressed += MyGUI::newDelegate(this, &WidgetExtension::mousePress);
w->eventMouseButtonReleased += MyGUI::newDelegate(this, &WidgetExtension::mouseRelease);
w->eventMouseMove += MyGUI::newDelegate(this, &WidgetExtension::mouseMove);
w->eventMouseDrag += MyGUI::newDelegate(this, &WidgetExtension::mouseDrag);
w->eventMouseSetFocus += MyGUI::newDelegate(this, &WidgetExtension::focusGain);
w->eventMouseLostFocus += MyGUI::newDelegate(this, &WidgetExtension::focusLoss);
w->eventKeySetFocus += MyGUI::newDelegate(this, &WidgetExtension::focusGain);
w->eventKeyLostFocus += MyGUI::newDelegate(this, &WidgetExtension::focusLoss);
}
void WidgetExtension::clearEvents(MyGUI::Widget* w)
{
w->eventKeyButtonPressed.clear();
w->eventKeyButtonReleased.clear();
w->eventMouseButtonClick.clear();
w->eventMouseButtonDoubleClick.clear();
w->eventMouseButtonPressed.clear();
w->eventMouseButtonReleased.clear();
w->eventMouseMove.clear();
w->eventMouseDrag.clear();
w->eventMouseSetFocus.clear();
w->eventMouseLostFocus.clear();
w->eventKeySetFocus.clear();
w->eventKeyLostFocus.clear();
}
void WidgetExtension::reset()
{
// detach all children from the slot widget, in case it gets destroyed
for (auto& w : mChildren)
w->widget()->detachFromWidget();
}
void WidgetExtension::updateVisible()
{
// workaround for MyGUI bug
// parent visibility doesn't affect added children
MyGUI::Widget* parent = widget()->getParent();
bool inheritedVisible = mVisible && (parent == nullptr || parent->getInheritedVisible());
widget()->setVisible(inheritedVisible);
}
void WidgetExtension::attach(WidgetExtension* ext)
{
if (ext->mParent != this)
{
if (ext->mParent)
{
auto children = ext->mParent->children();
std::erase(children, this);
ext->mParent->setChildren(children);
}
ext->detachFromParent();
}
ext->mParent = this;
ext->mTemplateChild = false;
ext->widget()->attachToWidget(mSlot->widget());
}
void WidgetExtension::attachTemplate(WidgetExtension* ext)
{
ext->mParent = this;
ext->mTemplateChild = true;
ext->widget()->attachToWidget(widget());
}
void WidgetExtension::detachFromParent()
{
mParent = nullptr;
widget()->detachFromWidget();
widget()->detachFromLayer();
}
WidgetExtension* WidgetExtension::findDeep(std::string_view flagName)
{
for (WidgetExtension* w : mChildren)
{
WidgetExtension* result = w->findDeep(flagName);
if (result != nullptr)
return result;
}
if (externalValue(flagName, false))
return this;
return nullptr;
}
void WidgetExtension::findAll(std::string_view flagName, std::vector<WidgetExtension*>& result)
{
if (externalValue(flagName, false))
result.push_back(this);
for (WidgetExtension* w : mChildren)
w->findAll(flagName, result);
}
WidgetExtension* WidgetExtension::findDeepInTemplates(std::string_view flagName)
{
for (WidgetExtension* w : mTemplateChildren)
{
WidgetExtension* result = w->findDeep(flagName);
if (result != nullptr)
return result;
}
return nullptr;
}
std::vector<WidgetExtension*> WidgetExtension::findAllInTemplates(std::string_view flagName)
{
std::vector<WidgetExtension*> result;
for (WidgetExtension* w : mTemplateChildren)
w->findAll(flagName, result);
return result;
}
sol::table WidgetExtension::makeTable() const
{
return sol::table(lua(), sol::create);
}
sol::object WidgetExtension::keyEvent(MyGUI::KeyCode code) const
{
auto keySym = SDL_Keysym();
keySym.sym = SDLUtil::myGuiKeyToSdl(code);
keySym.scancode = SDL_GetScancodeFromKey(keySym.sym);
keySym.mod = SDL_GetModState();
return sol::make_object(lua(), keySym);
}
sol::object WidgetExtension::mouseEvent(
int left, int top, MyGUI::MouseButton button = MyGUI::MouseButton::None) const
{
osg::Vec2f position(left, top);
MyGUI::IntPoint absolutePosition = mWidget->getAbsolutePosition();
osg::Vec2f offset = position - osg::Vec2f(absolutePosition.left, absolutePosition.top);
sol::table table = makeTable();
int sdlButton = SDLUtil::myGuiMouseButtonToSdl(button);
table["position"] = position;
table["offset"] = offset;
if (sdlButton != 0) // nil if no button was pressed
table["button"] = sdlButton;
return table;
}
void WidgetExtension::setChildren(const std::vector<WidgetExtension*>& children)
{
mChildren.resize(children.size());
for (size_t i = 0; i < children.size(); ++i)
{
mChildren[i] = children[i];
attach(mChildren[i]);
}
updateChildren();
}
void WidgetExtension::setTemplateChildren(const std::vector<WidgetExtension*>& children)
{
mTemplateChildren.resize(children.size());
for (size_t i = 0; i < children.size(); ++i)
{
mTemplateChildren[i] = children[i];
attachTemplate(mTemplateChildren[i]);
}
updateTemplate();
}
void WidgetExtension::updateTemplate()
{
WidgetExtension* slot = findDeepInTemplates("slot");
if (slot == nullptr)
mSlot = this;
else
mSlot = slot->mSlot;
}
void WidgetExtension::setCallback(const std::string& name, const LuaUtil::Callback& callback)
{
mCallbacks[name] = callback;
}
void WidgetExtension::clearCallbacks()
{
mCallbacks.clear();
}
MyGUI::IntCoord WidgetExtension::forcedCoord()
{
return mForcedCoord;
}
void WidgetExtension::forceCoord(const MyGUI::IntCoord& offset)
{
mForcePosition = true;
mForceSize = true;
mForcedCoord = offset;
}
void WidgetExtension::forcePosition(const MyGUI::IntPoint& pos)
{
mForcePosition = true;
mForcedCoord = pos;
}
void WidgetExtension::forceSize(const MyGUI::IntSize& size)
{
mForceSize = true;
mForcedCoord = size;
}
void WidgetExtension::clearForced()
{
mForcePosition = false;
mForceSize = false;
}
void WidgetExtension::updateCoord()
{
updateVisible();
MyGUI::IntCoord oldCoord = mWidget->getCoord();
MyGUI::IntCoord newCoord = calculateCoord();
if (oldCoord != newCoord)
mWidget->setCoord(newCoord);
updateChildrenCoord();
}
void WidgetExtension::setProperties(const sol::object& props)
{
mProperties = props;
updateProperties();
}
void WidgetExtension::updateProperties()
{
mPropagateEvents = propertyValue("propagateEvents", true);
mAbsoluteCoord = propertyValue("position", MyGUI::IntPoint());
mAbsoluteCoord = propertyValue("size", MyGUI::IntSize());
mRelativeCoord = propertyValue("relativePosition", MyGUI::FloatPoint());
mRelativeCoord = propertyValue("relativeSize", MyGUI::FloatSize());
mAnchor = propertyValue("anchor", MyGUI::FloatSize());
mVisible = propertyValue("visible", true);
mWidget->setVisible(mVisible);
mWidget->setPointer(propertyValue("pointer", std::string("arrow")));
mWidget->setAlpha(propertyValue("alpha", 1.f));
mWidget->setInheritsAlpha(propertyValue("inheritAlpha", true));
}
void WidgetExtension::updateChildrenCoord()
{
for (WidgetExtension* w : mTemplateChildren)
w->updateCoord();
for (WidgetExtension* w : mChildren)
w->updateCoord();
}
MyGUI::IntSize WidgetExtension::parentSize() const
{
if (!mParent)
return widget()->getParentSize(); // size of the layer
if (mTemplateChild)
return mParent->templateScalingSize();
else
return mParent->childScalingSize();
}
MyGUI::IntSize WidgetExtension::calculateSize() const
{
if (mForceSize)
return mForcedCoord.size();
MyGUI::IntSize pSize = parentSize();
MyGUI::IntSize newSize;
newSize = mAbsoluteCoord.size();
newSize.width += mRelativeCoord.width * pSize.width;
newSize.height += mRelativeCoord.height * pSize.height;
return newSize;
}
MyGUI::IntPoint WidgetExtension::calculatePosition(const MyGUI::IntSize& size) const
{
if (mForcePosition)
return mForcedCoord.point();
MyGUI::IntSize pSize = parentSize();
MyGUI::IntPoint newPosition;
newPosition = mAbsoluteCoord.point();
newPosition.left += mRelativeCoord.left * pSize.width - mAnchor.width * size.width;
newPosition.top += mRelativeCoord.top * pSize.height - mAnchor.height * size.height;
return newPosition;
}
MyGUI::IntCoord WidgetExtension::calculateCoord() const
{
MyGUI::IntCoord newCoord;
newCoord = calculateSize();
newCoord = calculatePosition(newCoord.size());
return newCoord;
}
MyGUI::IntSize WidgetExtension::childScalingSize() const
{
return mSlot->widget()->getSize();
}
MyGUI::IntSize WidgetExtension::templateScalingSize() const
{
return widget()->getSize();
}
void WidgetExtension::triggerEvent(std::string_view name, sol::object argument) const
{
auto it = mCallbacks.find(name);
if (it != mCallbacks.end())
it->second.call(argument, mLayout);
}
void WidgetExtension::keyPress(MyGUI::Widget*, MyGUI::KeyCode code, MyGUI::Char ch)
{
if (code == MyGUI::KeyCode::None)
{
propagateEvent("textInput", [ch](auto w) {
MyGUI::UString uString;
uString.push_back(static_cast<MyGUI::UString::unicode_char>(ch));
return sol::make_object(w->lua(), uString.asUTF8());
});
}
else
propagateEvent("keyPress", [code](auto w) { return w->keyEvent(code); });
}
void WidgetExtension::keyRelease(MyGUI::Widget*, MyGUI::KeyCode code)
{
propagateEvent("keyRelease", [code](auto w) { return w->keyEvent(code); });
}
void WidgetExtension::mouseMove(MyGUI::Widget*, int left, int top)
{
propagateEvent("mouseMove", [left, top](auto w) { return w->mouseEvent(left, top); });
}
void WidgetExtension::mouseDrag(MyGUI::Widget*, int left, int top, MyGUI::MouseButton button)
{
propagateEvent("mouseMove", [left, top, button](auto w) { return w->mouseEvent(left, top, button); });
}
void WidgetExtension::mouseClick(MyGUI::Widget* _widget)
{
propagateEvent("mouseClick", [](auto) { return sol::nil; });
}
void WidgetExtension::mouseDoubleClick(MyGUI::Widget* _widget)
{
propagateEvent("mouseDoubleClick", [](auto) { return sol::nil; });
}
void WidgetExtension::mousePress(MyGUI::Widget*, int left, int top, MyGUI::MouseButton button)
{
propagateEvent("mousePress", [left, top, button](auto w) { return w->mouseEvent(left, top, button); });
}
void WidgetExtension::mouseRelease(MyGUI::Widget*, int left, int top, MyGUI::MouseButton button)
{
propagateEvent("mouseRelease", [left, top, button](auto w) { return w->mouseEvent(left, top, button); });
}
void WidgetExtension::focusGain(MyGUI::Widget*, MyGUI::Widget*)
{
propagateEvent("focusGain", [](auto) { return sol::nil; });
}
void WidgetExtension::focusLoss(MyGUI::Widget*, MyGUI::Widget*)
{
propagateEvent("focusLoss", [](auto) { return sol::nil; });
}
}
| 13,926
|
C++
|
.cpp
| 376
| 29.050532
| 113
| 0.631123
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,890
|
content.cpp
|
OpenMW_openmw/components/lua_ui/content.cpp
|
#include "content.hpp"
#include "element.hpp"
namespace LuaUi
{
sol::protected_function loadContentConstructor(LuaUtil::LuaState* state)
{
sol::protected_function loader = state->loadInternalLib("content");
sol::set_environment(state->newInternalLibEnvironment(), loader);
sol::table metatable = LuaUtil::LuaState::throwIfError(loader()).get<sol::table>();
if (metatable["new"].get_type() != sol::type::function)
throw std::logic_error("Expected function");
return metatable["new"].get<sol::protected_function>();
}
bool isValidContent(const sol::object& object)
{
if (object.is<Element>())
return true;
if (object.get_type() != sol::type::table)
return false;
sol::table table = object;
return table.traverse_get<sol::optional<bool>>(sol::metatable_key, "__Content").value_or(false);
}
}
| 923
|
C++
|
.cpp
| 23
| 33.304348
| 104
| 0.646993
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,891
|
util.cpp
|
OpenMW_openmw/components/lua_ui/util.cpp
|
#include "util.hpp"
#include <MyGUI_FactoryManager.h>
#include "adapter.hpp"
#include "container.hpp"
#include "flex.hpp"
#include "image.hpp"
#include "text.hpp"
#include "textedit.hpp"
#include "widget.hpp"
#include "window.hpp"
#include "element.hpp"
#include "registerscriptsettings.hpp"
namespace LuaUi
{
void registerAllWidgets()
{
MyGUI::FactoryManager::getInstance().registerFactory<LuaAdapter>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaWidget>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaText>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaTextEdit>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaWindow>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaImage>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaTileRect>("BasisSkin");
MyGUI::FactoryManager::getInstance().registerFactory<LuaContainer>("Widget");
MyGUI::FactoryManager::getInstance().registerFactory<LuaFlex>("Widget");
}
const std::unordered_map<std::string, std::string>& widgetTypeToName()
{
static std::unordered_map<std::string, std::string> types{
{ "LuaWidget", "Widget" },
{ "LuaText", "Text" },
{ "LuaTextEdit", "TextEdit" },
{ "LuaWindow", "Window" },
{ "LuaImage", "Image" },
{ "LuaFlex", "Flex" },
{ "LuaContainer", "Container" },
};
return types;
}
void clearGameInterface()
{
while (!Element::sGameElements.empty())
Element::erase(Element::sGameElements.begin()->second.get());
}
void clearMenuInterface()
{
while (!Element::sMenuElements.empty())
Element::erase(Element::sMenuElements.begin()->second.get());
}
}
| 1,903
|
C++
|
.cpp
| 50
| 31.54
| 87
| 0.656369
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,892
|
adapter.cpp
|
OpenMW_openmw/components/lua_ui/adapter.cpp
|
#include "adapter.hpp"
#include <MyGUI_Gui.h>
#include "container.hpp"
#include "element.hpp"
namespace LuaUi
{
namespace
{
sol::state luaState;
}
LuaAdapter::LuaAdapter()
: mElement(nullptr)
, mContainer(nullptr)
{
mContainer = MyGUI::Gui::getInstancePtr()->createWidget<LuaContainer>(
"", MyGUI::IntCoord(), MyGUI::Align::Default, "", "");
mContainer->initialize(luaState, mContainer, false);
mContainer->widget()->eventChangeCoord += MyGUI::newDelegate(this, &LuaAdapter::containerChangedCoord);
mContainer->widget()->attachToWidget(this);
}
void LuaAdapter::containerChangedCoord(MyGUI::Widget*)
{
setSize(mContainer->getSize());
}
void LuaAdapter::attach(const std::shared_ptr<Element>& element)
{
detachElement();
mElement = element;
attachElement();
setSize(mContainer->widget()->getSize());
// workaround for MyGUI bug
// parent visibility doesn't affect added children
setVisible(!getVisible());
setVisible(!getVisible());
}
void LuaAdapter::detach()
{
detachElement();
setSize({ 0, 0 });
}
void LuaAdapter::attachElement()
{
if (!mElement.get())
return;
if (!mElement->mRoot)
throw std::logic_error("Attempting to use a destroyed UI Element");
mContainer->setChildren({ mElement->mRoot });
mElement->mRoot->updateCoord();
mContainer->updateCoord();
}
void LuaAdapter::detachElement()
{
mContainer->setChildren({});
if (mElement && mElement->mRoot)
mElement->mRoot->widget()->detachFromWidget();
mElement = nullptr;
}
}
| 1,779
|
C++
|
.cpp
| 58
| 23.637931
| 111
| 0.616598
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,893
|
resources.cpp
|
OpenMW_openmw/components/lua_ui/resources.cpp
|
#include "resources.hpp"
#include <components/vfs/pathutil.hpp>
namespace LuaUi
{
std::shared_ptr<TextureResource> ResourceManager::registerTexture(TextureData data)
{
VFS::Path::normalizeFilenameInPlace(data.mPath);
TextureResources& list = mTextures[data.mPath];
list.push_back(std::make_shared<TextureResource>(data));
return list.back();
}
void ResourceManager::clear()
{
mTextures.clear();
}
}
| 467
|
C++
|
.cpp
| 16
| 23.9375
| 87
| 0.693512
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,894
|
element.cpp
|
OpenMW_openmw/components/lua_ui/element.cpp
|
#include "element.hpp"
#include <MyGUI_Gui.h>
#include "content.hpp"
#include "util.hpp"
#include "widget.hpp"
namespace LuaUi
{
namespace
{
namespace LayoutKeys
{
constexpr std::string_view type = "type";
constexpr std::string_view name = "name";
constexpr std::string_view layer = "layer";
constexpr std::string_view templateLayout = "template";
constexpr std::string_view props = "props";
constexpr std::string_view events = "events";
constexpr std::string_view content = "content";
constexpr std::string_view external = "external";
}
const std::string defaultWidgetType = "LuaWidget";
constexpr uint64_t maxDepth = 250;
std::string widgetType(const sol::table& layout)
{
sol::object typeField = LuaUtil::getFieldOrNil(layout, LayoutKeys::type);
std::string type = LuaUtil::getValueOrDefault(typeField, defaultWidgetType);
sol::object templateTypeField
= LuaUtil::getFieldOrNil(layout, LayoutKeys::templateLayout, LayoutKeys::type);
if (templateTypeField != sol::nil)
{
std::string templateType = LuaUtil::getValueOrDefault(templateTypeField, defaultWidgetType);
if (typeField != sol::nil && templateType != type)
throw std::logic_error(std::string("Template layout type ") + type
+ std::string(" doesn't match template type ") + templateType);
type = std::move(templateType);
}
return type;
}
void destroyWidget(WidgetExtension* ext)
{
ext->deinitialize();
MyGUI::Gui::getInstancePtr()->destroyWidget(ext->widget());
}
void destroyChild(WidgetExtension* ext)
{
if (!ext->isRoot())
destroyWidget(ext);
else
ext->detachFromParent();
}
void detachElements(WidgetExtension* ext)
{
auto predicate = [](WidgetExtension* child) {
if (child->isRoot())
return true;
detachElements(child);
return false;
};
ext->detachChildrenIf(predicate);
ext->detachTemplateChildrenIf(predicate);
}
void destroyRoot(WidgetExtension* ext)
{
detachElements(ext);
destroyWidget(ext);
}
void updateRootCoord(WidgetExtension* ext)
{
WidgetExtension* root = ext;
while (root->getParent())
root = root->getParent();
root->updateCoord();
}
WidgetExtension* pluckElementRoot(const sol::object& child, uint64_t depth)
{
std::shared_ptr<Element> element = child.as<std::shared_ptr<Element>>();
if (element->mState == Element::Destroyed || element->mState == Element::Destroy)
throw std::logic_error("Using a destroyed element as a layout child");
// child Element was created in the same frame and its action hasn't been processed yet
if (element->mState == Element::New)
element->create(depth + 1);
WidgetExtension* root = element->mRoot;
assert(root);
return root;
}
WidgetExtension* createWidget(const sol::table& layout, bool isRoot, uint64_t depth);
void updateWidget(WidgetExtension* ext, const sol::table& layout, uint64_t depth);
std::vector<WidgetExtension*> updateContent(
const std::vector<WidgetExtension*>& children, const sol::object& contentObj, uint64_t depth)
{
++depth;
std::vector<WidgetExtension*> result;
if (contentObj == sol::nil)
{
for (WidgetExtension* w : children)
destroyChild(w);
return result;
}
ContentView content(LuaUtil::cast<sol::table>(contentObj));
result.resize(content.size());
size_t minSize = std::min(children.size(), content.size());
std::vector<WidgetExtension*> toDestroy;
for (size_t i = 0; i < minSize; i++)
{
WidgetExtension* ext = children[i];
sol::object child = content.at(i);
if (child.is<Element>())
{
WidgetExtension* root = pluckElementRoot(child, depth);
if (ext != root)
toDestroy.emplace_back(ext);
result[i] = root;
}
else
{
sol::table newLayout = child.as<sol::table>();
if (ext->widget()->getTypeName() == widgetType(newLayout))
{
updateWidget(ext, newLayout, depth);
}
else
{
toDestroy.emplace_back(ext);
ext = createWidget(newLayout, false, depth);
}
result[i] = ext;
}
}
for (size_t i = minSize; i < content.size(); i++)
{
sol::object child = content.at(i);
if (child.is<Element>())
result[i] = pluckElementRoot(child, depth);
else
result[i] = createWidget(child.as<sol::table>(), false, depth);
}
// Don't destroy anything until element creation has had a chance to throw
for (size_t i = minSize; i < children.size(); i++)
destroyChild(children[i]);
for (WidgetExtension* ext : toDestroy)
destroyChild(ext);
return result;
}
void setTemplate(WidgetExtension* ext, const sol::object& templateLayout, uint64_t depth)
{
++depth;
sol::object props = LuaUtil::getFieldOrNil(templateLayout, LayoutKeys::props);
ext->setTemplateProperties(props);
sol::object content = LuaUtil::getFieldOrNil(templateLayout, LayoutKeys::content);
ext->setTemplateChildren(updateContent(ext->templateChildren(), content, depth));
}
void setEventCallbacks(WidgetExtension* ext, const sol::object& eventsObj)
{
ext->clearCallbacks();
if (eventsObj == sol::nil)
return;
if (!eventsObj.is<sol::table>())
throw std::logic_error("The \"events\" layout field must be a table of callbacks");
auto events = eventsObj.as<sol::table>();
events.for_each([ext](const sol::object& name, const sol::object& callback) {
if (name.is<std::string>() && LuaUtil::Callback::isLuaCallback(callback))
ext->setCallback(name.as<std::string>(), LuaUtil::Callback::fromLua(callback));
else if (!name.is<std::string>())
Log(Debug::Warning) << "UI event key must be a string";
else
Log(Debug::Warning) << "UI event handler for key \"" << name.as<std::string>()
<< "\" must be an openmw.async.callback";
});
}
WidgetExtension* createWidget(const sol::table& layout, bool isRoot, uint64_t depth)
{
static auto widgetTypeMap = widgetTypeToName();
std::string type = widgetType(layout);
if (widgetTypeMap.find(type) == widgetTypeMap.end())
throw std::logic_error(std::string("Invalid widget type ") += type);
std::string name = layout.get_or(LayoutKeys::name, std::string());
MyGUI::Widget* widget
= MyGUI::Gui::getInstancePtr()->createWidgetT(type, {}, {}, MyGUI::Align::Default, {}, name);
WidgetExtension* ext = dynamic_cast<WidgetExtension*>(widget);
if (!ext)
throw std::runtime_error("Invalid widget!");
ext->initialize(layout.lua_state(), widget, isRoot);
updateWidget(ext, layout, depth);
return ext;
}
void updateWidget(WidgetExtension* ext, const sol::table& layout, uint64_t depth)
{
if (depth >= maxDepth)
throw std::runtime_error("Maximum layout depth exceeded, probably caused by a circular reference");
ext->reset();
ext->setLayout(layout);
ext->setExternal(layout.get<sol::object>(LayoutKeys::external));
setTemplate(ext, layout.get<sol::object>(LayoutKeys::templateLayout), depth);
ext->setProperties(layout.get<sol::object>(LayoutKeys::props));
setEventCallbacks(ext, layout.get<sol::object>(LayoutKeys::events));
ext->setChildren(updateContent(ext->children(), layout.get<sol::object>(LayoutKeys::content), depth));
ext->updateCoord();
}
std::string setLayer(WidgetExtension* ext, const sol::table& layout)
{
MyGUI::ILayer* layerNode = ext->widget()->getLayer();
std::string_view currentLayer;
if (layerNode)
currentLayer = layerNode->getName();
std::string newLayer = layout.get_or(LayoutKeys::layer, std::string());
if (!newLayer.empty() && !MyGUI::LayerManager::getInstance().isExist(newLayer))
throw std::logic_error(std::string("Layer ") + newLayer + " doesn't exist");
else if (newLayer != currentLayer)
{
MyGUI::LayerManager::getInstance().attachToLayerNode(newLayer, ext->widget());
}
return newLayer;
}
}
std::map<Element*, std::shared_ptr<Element>> Element::sMenuElements;
std::map<Element*, std::shared_ptr<Element>> Element::sGameElements;
Element::Element(sol::table layout)
: mRoot(nullptr)
, mLayout(std::move(layout))
, mLayer()
, mState(Element::New)
{
}
std::shared_ptr<Element> Element::make(sol::table layout, bool menu)
{
std::shared_ptr<Element> ptr(new Element(std::move(layout)));
auto& container = menu ? sMenuElements : sGameElements;
container[ptr.get()] = ptr;
return ptr;
}
void Element::erase(Element* element)
{
element->destroy();
sMenuElements.erase(element);
sGameElements.erase(element);
}
void Element::create(uint64_t depth)
{
if (mState == New)
{
assert(!mRoot);
mRoot = createWidget(layout(), true, depth);
mLayer = setLayer(mRoot, layout());
updateRootCoord(mRoot);
mState = Created;
}
}
void Element::update()
{
if (mState == Update)
{
assert(mRoot);
if (mRoot->widget()->getTypeName() != widgetType(layout()))
{
destroyRoot(mRoot);
WidgetExtension* parent = mRoot->getParent();
auto children = parent->children();
auto it = std::find(children.begin(), children.end(), mRoot);
assert(it != children.end());
try
{
mRoot = createWidget(layout(), true, 0);
*it = mRoot;
}
catch (...)
{
// Remove mRoot from its parent's children even if we couldn't replace it
children.erase(it);
parent->setChildren(children);
mRoot = nullptr;
throw;
}
parent->setChildren(children);
mRoot->updateCoord();
}
else
{
updateWidget(mRoot, layout(), 0);
}
mLayer = setLayer(mRoot, layout());
updateRootCoord(mRoot);
mState = Created;
}
}
void Element::destroy()
{
if (mState != Destroyed)
{
if (mRoot != nullptr)
{
// If someone decided to destroy an element used as another element's content, we need to detach it
// first so the parent doesn't end up holding a stale pointer
if (WidgetExtension* parent = mRoot->getParent())
parent->detachChildrenIf([&](WidgetExtension* child) { return child == mRoot; });
destroyRoot(mRoot);
mRoot = nullptr;
}
mLayout = sol::make_object(mLayout.lua_state(), sol::nil);
}
mState = Destroyed;
}
}
| 12,886
|
C++
|
.cpp
| 302
| 29.612583
| 115
| 0.537953
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,895
|
image.cpp
|
OpenMW_openmw/components/lua_ui/image.cpp
|
#include "image.hpp"
#include <MyGUI_RenderManager.h>
#include "resources.hpp"
namespace LuaUi
{
void LuaTileRect::_setAlign(const MyGUI::IntSize& _oldsize)
{
mCoord.set(0, 0, mCroppedParent->getWidth(), mCroppedParent->getHeight());
mTileSize = mSetTileSize;
// zero tilesize stands for not tiling
if (mTileSize.width == 0)
mTileSize.width = mCoord.width;
if (mTileSize.height == 0)
mTileSize.height = mCoord.height;
// mCoord could be zero, prevent division by 0
// use arbitrary large numbers to prevent performance issues
if (mTileSize.width <= 0)
mTileSize.width = 1e7;
if (mTileSize.height <= 0)
mTileSize.height = 1e7;
MyGUI::TileRect::_updateView();
}
void LuaImage::initialize()
{
changeWidgetSkin("LuaImage");
mTileRect = dynamic_cast<LuaTileRect*>(getSubWidgetMain());
WidgetExtension::initialize();
}
void LuaImage::updateProperties()
{
deleteAllItems();
TextureResource* resource = propertyValue<TextureResource*>("resource", nullptr);
MyGUI::IntCoord atlasCoord;
if (resource)
{
atlasCoord
= MyGUI::IntCoord(static_cast<int>(resource->mOffset.x()), static_cast<int>(resource->mOffset.y()),
static_cast<int>(resource->mSize.x()), static_cast<int>(resource->mSize.y()));
setImageTexture(resource->mPath);
}
bool tileH = propertyValue("tileH", false);
bool tileV = propertyValue("tileV", false);
MyGUI::ITexture* texture = MyGUI::RenderManager::getInstance().getTexture(_getTextureName());
MyGUI::IntSize textureSize;
if (texture != nullptr)
textureSize = MyGUI::IntSize(texture->getWidth(), texture->getHeight());
if (atlasCoord.width == 0)
atlasCoord.width = textureSize.width;
if (atlasCoord.height == 0)
atlasCoord.height = textureSize.height;
mTileRect->updateSize(MyGUI::IntSize(tileH ? atlasCoord.width : 0, tileV ? atlasCoord.height : 0));
setImageTile(atlasCoord.size());
setImageCoord(atlasCoord);
setColour(propertyValue("color", MyGUI::Colour(1, 1, 1, 1)));
WidgetExtension::updateProperties();
}
}
| 2,364
|
C++
|
.cpp
| 57
| 32.719298
| 115
| 0.62887
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,896
|
scriptsettings.cpp
|
OpenMW_openmw/components/lua_ui/scriptsettings.cpp
|
#include "scriptsettings.hpp"
#include <map>
#include <sol/sol.hpp>
#include "adapter.hpp"
#include "element.hpp"
#include "registerscriptsettings.hpp"
namespace LuaUi
{
namespace
{
std::vector<sol::table> allPages;
ScriptSettingsPage parse(const sol::table& options)
{
auto name = options.get_or("name", std::string());
auto searchHints = options.get_or("searchHints", std::string());
auto element = options.get_or<std::shared_ptr<LuaUi::Element>>("element", nullptr);
if (name.empty())
Log(Debug::Warning) << "A script settings page has an empty name";
if (!element.get())
Log(Debug::Warning) << "A script settings page has no UI element assigned";
return { std::move(name), std::move(searchHints), std::move(element) };
}
}
size_t scriptSettingsPageCount()
{
return allPages.size();
}
ScriptSettingsPage scriptSettingsPageAt(size_t index)
{
return parse(allPages[index]);
}
void registerSettingsPage(const sol::table& options)
{
allPages.push_back(options);
}
void removeSettingsPage(const sol::table& options)
{
std::erase_if(allPages, [options](const sol::table& it) { return it == options; });
}
void clearSettings()
{
allPages.clear();
}
void attachPageAt(size_t index, LuaAdapter* adapter)
{
adapter->detach();
if (index < allPages.size())
{
ScriptSettingsPage page = parse(allPages[index]);
if (page.mElement.get())
adapter->attach(page.mElement);
}
}
}
| 1,704
|
C++
|
.cpp
| 54
| 24.240741
| 95
| 0.605119
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,897
|
text.cpp
|
OpenMW_openmw/components/lua_ui/text.cpp
|
#include "text.hpp"
#include "alignment.hpp"
namespace LuaUi
{
LuaText::LuaText()
: mAutoSized(true)
{
}
void LuaText::initialize()
{
changeWidgetSkin("LuaText");
setEditStatic(true);
setVisibleHScroll(false);
setVisibleVScroll(false);
WidgetExtension::initialize();
}
void LuaText::updateProperties()
{
mAutoSized = propertyValue("autoSize", true);
setCaption(propertyValue("text", std::string()));
setFontHeight(propertyValue("textSize", 10));
setTextColour(propertyValue("textColor", MyGUI::Colour(0, 0, 0, 1)));
setEditMultiLine(propertyValue("multiline", false));
setEditWordWrap(propertyValue("wordWrap", false));
Alignment horizontal(propertyValue("textAlignH", Alignment::Start));
Alignment vertical(propertyValue("textAlignV", Alignment::Start));
setTextAlign(alignmentToMyGui(horizontal, vertical));
setTextShadow(propertyValue("textShadow", false));
setTextShadowColour(propertyValue("textShadowColor", MyGUI::Colour(0, 0, 0, 1)));
WidgetExtension::updateProperties();
}
void LuaText::setCaption(const MyGUI::UString& caption)
{
MyGUI::TextBox::setCaption(caption);
if (mAutoSized)
updateCoord();
}
MyGUI::IntSize LuaText::calculateSize() const
{
if (mAutoSized)
return getTextSize();
else
return WidgetExtension::calculateSize();
}
}
| 1,529
|
C++
|
.cpp
| 45
| 26.688889
| 89
| 0.654447
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,898
|
window.cpp
|
OpenMW_openmw/components/lua_ui/window.cpp
|
#include "window.hpp"
#include <MyGUI_Delegate.h>
#include <MyGUI_MouseButton.h>
#include <MyGUI_Types.h>
namespace LuaUi
{
LuaWindow::LuaWindow()
: mCaption(nullptr)
{
}
void LuaWindow::updateTemplate()
{
for (auto& [w, _] : mActionWidgets)
{
w->eventMouseButtonPressed.clear();
w->eventMouseDrag.clear();
}
mActionWidgets.clear();
WidgetExtension* captionWidget = findDeepInTemplates("caption");
mCaption = dynamic_cast<LuaText*>(captionWidget);
if (mCaption)
mActionWidgets.emplace(mCaption->widget(), mCaption);
for (WidgetExtension* ext : findAllInTemplates("action"))
mActionWidgets.emplace(ext->widget(), ext);
for (auto& [w, _] : mActionWidgets)
{
w->eventMouseButtonPressed += MyGUI::newDelegate(this, &LuaWindow::notifyMousePress);
w->eventMouseDrag += MyGUI::newDelegate(this, &LuaWindow::notifyMouseDrag);
}
WidgetExtension::updateTemplate();
}
void LuaWindow::updateProperties()
{
if (mCaption)
mCaption->setCaption(propertyValue("caption", std::string()));
mMoveResize = MyGUI::IntCoord();
clearForced();
WidgetExtension::updateProperties();
}
void LuaWindow::notifyMousePress(MyGUI::Widget* sender, int left, int top, MyGUI::MouseButton id)
{
if (id != MyGUI::MouseButton::Left)
return;
mPreviousMouse.left = left;
mPreviousMouse.top = top;
WidgetExtension* ext = mActionWidgets[sender];
mChangeScale = MyGUI::IntCoord(
ext->externalValue("move", MyGUI::IntPoint(1, 1)), ext->externalValue("resize", MyGUI::IntSize(0, 0)));
}
void LuaWindow::notifyMouseDrag(MyGUI::Widget* sender, int left, int top, MyGUI::MouseButton id)
{
if (id != MyGUI::MouseButton::Left)
return;
MyGUI::IntCoord change = mChangeScale;
change.left *= (left - mPreviousMouse.left);
change.top *= (top - mPreviousMouse.top);
change.width *= (left - mPreviousMouse.left);
change.height *= (top - mPreviousMouse.top);
mMoveResize = mMoveResize + change;
forceCoord(mMoveResize);
updateCoord();
mPreviousMouse.left = left;
mPreviousMouse.top = top;
sol::table table = makeTable();
table["position"] = osg::Vec2f(mCoord.left, mCoord.top);
table["size"] = osg::Vec2f(mCoord.width, mCoord.height);
triggerEvent("windowDrag", table);
}
}
| 2,609
|
C++
|
.cpp
| 69
| 29.666667
| 115
| 0.624257
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,899
|
alignment.cpp
|
OpenMW_openmw/components/lua_ui/alignment.cpp
|
#include "alignment.hpp"
namespace LuaUi
{
MyGUI::Align alignmentToMyGui(Alignment horizontal, Alignment vertical)
{
MyGUI::Align align(MyGUI::Align::Center);
if (horizontal == Alignment::Start)
align |= MyGUI::Align::Left;
if (horizontal == Alignment::End)
align |= MyGUI::Align::Right;
if (vertical == Alignment::Start)
align |= MyGUI::Align::Top;
if (vertical == Alignment::End)
align |= MyGUI::Align::Bottom;
return align;
}
}
| 540
|
C++
|
.cpp
| 17
| 24.352941
| 75
| 0.595785
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,900
|
container.cpp
|
OpenMW_openmw/components/lua_ui/container.cpp
|
#include "container.hpp"
#include <algorithm>
namespace LuaUi
{
void LuaContainer::updateChildren()
{
WidgetExtension::updateChildren();
updateSizeToFit();
}
MyGUI::IntSize LuaContainer::childScalingSize() const
{
return MyGUI::IntSize();
}
MyGUI::IntSize LuaContainer::templateScalingSize() const
{
return mInnerSize;
}
void LuaContainer::updateSizeToFit()
{
MyGUI::IntSize innerSize = MyGUI::IntSize();
for (const auto w : children())
{
MyGUI::IntCoord coord = w->calculateCoord();
innerSize.width = std::max(innerSize.width, coord.left + coord.width);
innerSize.height = std::max(innerSize.height, coord.top + coord.height);
}
MyGUI::IntSize outerSize = innerSize;
for (const auto w : templateChildren())
{
MyGUI::IntCoord coord = w->calculateCoord();
outerSize.width = std::max(outerSize.width, coord.left + coord.width);
outerSize.height = std::max(outerSize.height, coord.top + coord.height);
}
mInnerSize = innerSize;
mOuterSize = outerSize;
}
MyGUI::IntSize LuaContainer::calculateSize() const
{
return mOuterSize;
}
void LuaContainer::updateCoord()
{
updateSizeToFit();
WidgetExtension::updateCoord();
}
}
| 1,402
|
C++
|
.cpp
| 46
| 23.23913
| 84
| 0.622683
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,901
|
layers.cpp
|
OpenMW_openmw/components/lua_ui/layers.cpp
|
#include "layers.hpp"
#include <components/debug/debuglog.hpp>
namespace LuaUi
{
size_t Layer::indexOf(std::string_view name)
{
for (size_t i = 0; i < count(); i++)
if (at(i)->getName() == name)
return i;
return count();
}
void Layer::insert(size_t index, std::string_view name, Options options)
{
if (index > count())
throw std::logic_error("Invalid layer index");
if (indexOf(name) < count())
Log(Debug::Error) << "Layer \"" << name << "\" already exists";
else
{
auto layer = MyGUI::LayerManager::getInstance().createLayerAt(std::string(name), "OverlappedLayer", index);
auto overlappedLayer = dynamic_cast<MyGUI::OverlappedLayer*>(layer);
overlappedLayer->setPick(options.mInteractive);
}
}
}
| 868
|
C++
|
.cpp
| 25
| 26.88
| 119
| 0.579762
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,902
|
flex.cpp
|
OpenMW_openmw/components/lua_ui/flex.cpp
|
#include "flex.hpp"
namespace LuaUi
{
void LuaFlex::updateProperties()
{
mHorizontal = propertyValue("horizontal", false);
mAutoSized = propertyValue("autoSize", true);
mAlign = propertyValue("align", Alignment::Start);
mArrange = propertyValue("arrange", Alignment::Start);
WidgetExtension::updateProperties();
}
namespace
{
int alignSize(int container, int content, Alignment alignment)
{
int alignedPosition = 0;
{
switch (alignment)
{
case Alignment::Start:
alignedPosition = 0;
break;
case Alignment::Center:
alignedPosition = (container - content) / 2;
break;
case Alignment::End:
alignedPosition = container - content;
break;
}
}
return alignedPosition;
}
float getGrow(WidgetExtension* w)
{
return std::max(0.0f, w->externalValue("grow", 0.0f));
}
}
void LuaFlex::updateChildren()
{
float totalGrow = 0;
MyGUI::IntSize childrenSize;
for (auto* w : children())
{
w->clearForced();
MyGUI::IntSize size = w->calculateSize();
primary(childrenSize) += primary(size);
secondary(childrenSize) = std::max(secondary(childrenSize), secondary(size));
totalGrow += getGrow(w);
}
mChildrenSize = childrenSize;
MyGUI::IntSize flexSize = calculateSize();
int growSize = 0;
float growFactor = 0;
if (totalGrow > 0)
{
growSize = primary(flexSize) - primary(childrenSize);
growFactor = growSize / totalGrow;
}
MyGUI::IntPoint childPosition;
primary(childPosition) = alignSize(primary(flexSize) - growSize, primary(childrenSize), mAlign);
for (auto* w : children())
{
MyGUI::IntSize size = w->calculateSize();
primary(size) += static_cast<int>(growFactor * getGrow(w));
float stretch = std::clamp(w->externalValue("stretch", 0.0f), 0.0f, 1.0f);
secondary(size) = std::max(secondary(size), static_cast<int>(stretch * secondary(flexSize)));
secondary(childPosition) = alignSize(secondary(flexSize), secondary(size), mArrange);
w->forcePosition(childPosition);
w->forceSize(size);
w->updateCoord();
primary(childPosition) += primary(size);
}
WidgetExtension::updateChildren();
}
MyGUI::IntSize LuaFlex::childScalingSize() const
{
// Call the base method to prevent relativeSize feedback loop
MyGUI::IntSize size = WidgetExtension::calculateSize();
if (mAutoSized)
primary(size) = 0;
return size;
}
MyGUI::IntSize LuaFlex::calculateSize() const
{
MyGUI::IntSize size = WidgetExtension::calculateSize();
if (mAutoSized)
{
primary(size) = std::max(primary(size), primary(mChildrenSize));
secondary(size) = std::max(secondary(size), secondary(mChildrenSize));
}
return size;
}
void LuaFlex::updateCoord()
{
updateChildren();
WidgetExtension::updateCoord();
}
}
| 3,484
|
C++
|
.cpp
| 98
| 24.94898
| 105
| 0.559964
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,903
|
windows_crashcatcher.cpp
|
OpenMW_openmw/components/crashcatcher/windows_crashcatcher.cpp
|
#include "windows_crashcatcher.hpp"
#include <cassert>
#include <cwchar>
#include <sstream>
#include <thread>
#include "windows_crashmonitor.hpp"
#include "windows_crashshm.hpp"
#include "windowscrashdumppathhelpers.hpp"
#include <SDL_messagebox.h>
#include <components/misc/strings/conversion.hpp>
namespace Crash
{
namespace
{
template <class T, std::size_t N>
void writePathToShm(T (&buffer)[N], const std::filesystem::path& path)
{
memset(buffer, 0, sizeof(buffer));
const auto str = path.u8string();
size_t length = str.length();
if (length >= sizeof(buffer))
length = sizeof(buffer) - 1;
strncpy_s(buffer, sizeof(buffer), Misc::StringUtils::u8StringToString(str).c_str(), length);
}
}
HANDLE duplicateHandle(HANDLE handle)
{
HANDLE duplicate;
if (!DuplicateHandle(
GetCurrentProcess(), handle, GetCurrentProcess(), &duplicate, 0, TRUE, DUPLICATE_SAME_ACCESS))
{
throw std::runtime_error("Crash monitor could not duplicate handle");
}
return duplicate;
}
CrashCatcher* CrashCatcher::sInstance = nullptr;
CrashCatcher::CrashCatcher(int argc, char** argv, const std::filesystem::path& dumpPath,
const std::filesystem::path& crashDumpName, const std::filesystem::path& freezeDumpName)
{
assert(sInstance == nullptr); // don't allow two instances
sInstance = this;
HANDLE shmHandle = nullptr;
for (int i = 0; i < argc; ++i)
{
if (strcmp(argv[i], "--crash-monitor"))
continue;
if (i >= argc - 1)
throw std::runtime_error("Crash monitor is missing the SHM handle argument");
sscanf(argv[i + 1], "%p", &shmHandle);
break;
}
if (!shmHandle)
{
setupIpc();
startMonitorProcess(dumpPath, crashDumpName, freezeDumpName);
installHandler();
}
else
{
CrashMonitor(shmHandle).run();
exit(0);
}
}
CrashCatcher::~CrashCatcher()
{
sInstance = nullptr;
if (mShm && mSignalMonitorEvent)
{
shmLock();
mShm->mEvent = CrashSHM::Event::Shutdown;
shmUnlock();
SetEvent(mSignalMonitorEvent);
}
if (mShmHandle)
CloseHandle(mShmHandle);
}
void CrashCatcher::updateDumpPath(const std::filesystem::path& dumpPath)
{
shmLock();
writePathToShm(mShm->mStartup.mDumpDirectoryPath, dumpPath);
shmUnlock();
}
void CrashCatcher::updateDumpNames(
const std::filesystem::path& crashDumpName, const std::filesystem::path& freezeDumpName)
{
shmLock();
writePathToShm(mShm->mStartup.mCrashDumpFileName, crashDumpName);
writePathToShm(mShm->mStartup.mFreezeDumpFileName, freezeDumpName);
shmUnlock();
}
void CrashCatcher::setupIpc()
{
SECURITY_ATTRIBUTES attributes;
ZeroMemory(&attributes, sizeof(attributes));
attributes.bInheritHandle = TRUE;
mSignalAppEvent = CreateEventW(&attributes, FALSE, FALSE, NULL);
mSignalMonitorEvent = CreateEventW(&attributes, FALSE, FALSE, NULL);
mShmHandle = CreateFileMappingW(INVALID_HANDLE_VALUE, &attributes, PAGE_READWRITE, HIWORD(sizeof(CrashSHM)),
LOWORD(sizeof(CrashSHM)), NULL);
if (mShmHandle == nullptr)
throw std::runtime_error("Failed to allocate crash catcher shared memory");
mShm = reinterpret_cast<CrashSHM*>(MapViewOfFile(mShmHandle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(CrashSHM)));
if (mShm == nullptr)
throw std::runtime_error("Failed to map crash catcher shared memory");
mShmMutex = CreateMutexW(&attributes, FALSE, NULL);
if (mShmMutex == nullptr)
throw std::runtime_error("Failed to create crash catcher shared memory mutex");
}
void CrashCatcher::shmLock()
{
if (WaitForSingleObject(mShmMutex, CrashCatcherTimeout) != WAIT_OBJECT_0)
throw std::runtime_error("SHM lock timed out");
}
void CrashCatcher::shmUnlock()
{
ReleaseMutex(mShmMutex);
}
void CrashCatcher::waitMonitor()
{
if (WaitForSingleObject(mSignalAppEvent, CrashCatcherTimeout) != WAIT_OBJECT_0)
throw std::runtime_error("Waiting for monitor failed");
}
void CrashCatcher::signalMonitor()
{
SetEvent(mSignalMonitorEvent);
}
void CrashCatcher::installHandler()
{
SetUnhandledExceptionFilter(vectoredExceptionHandler);
}
void CrashCatcher::startMonitorProcess(const std::filesystem::path& dumpPath,
const std::filesystem::path& crashDumpName, const std::filesystem::path& freezeDumpName)
{
std::wstring executablePath;
DWORD copied = 0;
do
{
executablePath.resize(executablePath.size() + MAX_PATH);
copied = GetModuleFileNameW(nullptr, executablePath.data(), static_cast<DWORD>(executablePath.size()));
} while (copied >= executablePath.size());
executablePath.resize(copied);
writePathToShm(mShm->mStartup.mDumpDirectoryPath, dumpPath);
writePathToShm(mShm->mStartup.mCrashDumpFileName, crashDumpName);
writePathToShm(mShm->mStartup.mFreezeDumpFileName, freezeDumpName);
// note that we don't need to lock the SHM here, the other process has not started yet
mShm->mEvent = CrashSHM::Event::Startup;
mShm->mStartup.mShmMutex = duplicateHandle(mShmMutex);
mShm->mStartup.mAppProcessHandle = duplicateHandle(GetCurrentProcess());
mShm->mStartup.mAppMainThreadId = GetThreadId(GetCurrentThread());
mShm->mStartup.mSignalApp = duplicateHandle(mSignalAppEvent);
mShm->mStartup.mSignalMonitor = duplicateHandle(mSignalMonitorEvent);
std::wstringstream ss;
ss << "--crash-monitor " << std::hex << duplicateHandle(mShmHandle);
std::wstring arguments(ss.str());
STARTUPINFOW si;
ZeroMemory(&si, sizeof(si));
PROCESS_INFORMATION pi;
ZeroMemory(&pi, sizeof(pi));
if (!CreateProcessW(executablePath.data(), arguments.data(), NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi))
throw std::runtime_error("Could not start crash monitor process");
CloseHandle(pi.hProcess);
CloseHandle(pi.hThread);
waitMonitor();
}
LONG CrashCatcher::vectoredExceptionHandler(PEXCEPTION_POINTERS info)
{
switch (info->ExceptionRecord->ExceptionCode)
{
case EXCEPTION_SINGLE_STEP:
case EXCEPTION_BREAKPOINT:
case DBG_PRINTEXCEPTION_C:
return EXCEPTION_EXECUTE_HANDLER;
}
if (!sInstance)
return EXCEPTION_EXECUTE_HANDLER;
sInstance->handleVectoredException(info);
_Exit(1);
}
void CrashCatcher::handleVectoredException(PEXCEPTION_POINTERS info)
{
shmLock();
mShm->mEvent = CrashSHM::Event::Crashed;
mShm->mCrashed.mThreadId = GetCurrentThreadId();
mShm->mCrashed.mContext = *info->ContextRecord;
mShm->mCrashed.mExceptionRecord = *info->ExceptionRecord;
shmUnlock();
signalMonitor();
// must remain until monitor has finished
waitMonitor();
std::string message = "OpenMW has encountered a fatal error.\nCrash log saved to '"
+ Misc::StringUtils::u8StringToString(getCrashDumpPath(*mShm).u8string())
+ "'.\nPlease report this to https://gitlab.com/OpenMW/openmw/issues !";
SDL_ShowSimpleMessageBox(0, "Fatal Error", message.c_str(), nullptr);
}
} // namespace Crash
| 7,904
|
C++
|
.cpp
| 195
| 31.825641
| 116
| 0.643771
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,904
|
windowscrashdumppathhelpers.cpp
|
OpenMW_openmw/components/crashcatcher/windowscrashdumppathhelpers.cpp
|
#include "windowscrashdumppathhelpers.hpp"
#include <components/misc/strings/conversion.hpp>
namespace Crash
{
std::filesystem::path getCrashDumpPath(const CrashSHM& crashShm)
{
return (std::filesystem::path(Misc::StringUtils::stringToU8String(crashShm.mStartup.mDumpDirectoryPath))
/ Misc::StringUtils::stringToU8String(crashShm.mStartup.mCrashDumpFileName))
.make_preferred();
}
std::filesystem::path getFreezeDumpPath(const CrashSHM& crashShm)
{
return (std::filesystem::path(Misc::StringUtils::stringToU8String(crashShm.mStartup.mDumpDirectoryPath))
/ Misc::StringUtils::stringToU8String(crashShm.mStartup.mFreezeDumpFileName))
.make_preferred();
}
}
| 746
|
C++
|
.cpp
| 17
| 37.529412
| 112
| 0.735537
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,905
|
crashcatcher.cpp
|
OpenMW_openmw/components/crashcatcher/crashcatcher.cpp
|
#include <algorithm>
#include <cstring>
#include <filesystem>
#include <fstream>
#include <optional>
#include <span>
#include <errno.h>
#include <limits.h>
#include <pthread.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/param.h>
#include <sys/ptrace.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/utsname.h>
#include <sys/wait.h>
#include <unistd.h>
#include <components/debug/debuglog.hpp>
#include <components/files/conversion.hpp>
#include <SDL_messagebox.h>
#ifdef __linux__
#include <sys/prctl.h>
#include <sys/ucontext.h>
#ifndef PR_SET_PTRACER
#define PR_SET_PTRACER 0x59616d61
#endif
#elif defined(__APPLE__) || defined(__FreeBSD__) || defined(__OpenBSD__)
#include <signal.h>
#endif
#if defined(__APPLE__)
#include <cassert>
#include <libproc.h>
#include <sys/sysctl.h>
#endif
#if defined(__FreeBSD__)
#include <sys/sysctl.h>
#include <sys/user.h>
#endif
#include "crashcatcher.hpp"
static const char fatal_err[] = "\n\n*** Fatal Error ***\n";
static const char pipe_err[] = "!!! Failed to create pipe\n";
static const char fork_err[] = "!!! Failed to fork debug process\n";
static const char exec_err[] = "!!! Failed to exec debug process\n";
#ifndef PATH_MAX /* Not all platforms (GNU Hurd) have this. */
#define PATH_MAX 256
#endif
static char argv0[PATH_MAX];
static struct
{
int signum;
pid_t pid;
std::optional<siginfo_t> siginfo;
} crash_info;
namespace
{
constexpr char crash_switch[] = "--cc-handle-crash";
struct SignalInfo
{
int mCode;
const char* mDescription;
const char* mName = "";
};
constexpr SignalInfo signals[] = {
{ SIGSEGV, "Segmentation fault", "SIGSEGV" },
{ SIGILL, "Illegal instruction", "SIGILL" },
{ SIGFPE, "FPU exception", "SIGFPE" },
{ SIGBUS, "System BUS error", "SIGBUS" },
{ SIGABRT, "Abnormal termination condition", "SIGABRT" },
};
constexpr SignalInfo sigIllCodes[] = {
#if !defined(__FreeBSD__) && !defined(__FreeBSD_kernel__)
{ ILL_ILLOPC, "Illegal opcode" },
{ ILL_ILLOPN, "Illegal operand" },
{ ILL_ILLADR, "Illegal addressing mode" },
{ ILL_ILLTRP, "Illegal trap" },
{ ILL_PRVOPC, "Privileged opcode" },
{ ILL_PRVREG, "Privileged register" },
{ ILL_COPROC, "Coprocessor error" },
{ ILL_BADSTK, "Internal stack error" },
#endif
};
constexpr SignalInfo sigFpeCodes[] = {
{ FPE_INTDIV, "Integer divide by zero" },
{ FPE_INTOVF, "Integer overflow" },
{ FPE_FLTDIV, "Floating point divide by zero" },
{ FPE_FLTOVF, "Floating point overflow" },
{ FPE_FLTUND, "Floating point underflow" },
{ FPE_FLTRES, "Floating point inexact result" },
{ FPE_FLTINV, "Floating point invalid operation" },
{ FPE_FLTSUB, "Subscript out of range" },
};
constexpr SignalInfo sigSegvCodes[] = {
#ifndef __FreeBSD__
{ SEGV_MAPERR, "Address not mapped to object" },
{ SEGV_ACCERR, "Invalid permissions for mapped object" },
#endif
};
constexpr SignalInfo sigBusCodes[] = {
#ifndef __FreeBSD__
{ BUS_ADRALN, "Invalid address alignment" },
{ BUS_ADRERR, "Non-existent physical address" },
{ BUS_OBJERR, "Object specific hardware error" },
#endif
};
const char* findSignalDescription(std::span<const SignalInfo> info, int code)
{
const auto it = std::find_if(info.begin(), info.end(), [&](const SignalInfo& v) { return v.mCode == code; });
return it == info.end() ? "" : it->mDescription;
}
struct Close
{
void operator()(const int* value) { close(*value); }
};
struct CloseFile
{
void operator()(FILE* value) { fclose(value); }
};
struct Remove
{
void operator()(const char* value) { remove(value); }
};
template <class T>
bool printDebuggerInfo(pid_t pid)
{
// Create a temp file to put gdb commands into.
// Note: POSIX.1-2008 declares that the file should be already created with mode 0600 by default.
// Modern systems implement it and suggest to do not touch masks in multithreaded applications.
// So CoverityScan warning is valid only for ancient versions of stdlib.
char scriptPath[64];
std::snprintf(scriptPath, sizeof(scriptPath), "/tmp/%s-script-XXXXXX", T::sName);
#ifdef __COVERITY__
umask(0600);
#endif
const int fd = mkstemp(scriptPath);
if (fd == -1)
{
printf("Failed to call mkstemp: %s\n", std::generic_category().message(errno).c_str());
return false;
}
std::unique_ptr<const char, Remove> tempFile(scriptPath);
std::unique_ptr<const int, Close> scopedFd(&fd);
FILE* const file = fdopen(fd, "w");
if (file == nullptr)
{
printf("Failed to open file for %s output \"%s\": %s\n", T::sName, scriptPath,
std::generic_category().message(errno).c_str());
return false;
}
std::unique_ptr<FILE, CloseFile> scopedFile(file);
if (fprintf(file, "%s", T::sScript) < 0)
{
printf("Failed to write debugger script to file \"%s\": %s\n", scriptPath,
std::generic_category().message(errno).c_str());
return false;
}
scopedFile = nullptr;
scopedFd = nullptr;
char command[128];
snprintf(command, sizeof(command), T::sCommandTemplate, pid, scriptPath);
printf("Executing: %s\n", command);
fflush(stdout);
const int ret = system(command);
const bool result = (ret == 0);
if (ret == -1)
printf(
"\nFailed to create a crash report: %s.\n"
"Please make sure that '%s' is installed and present in PATH then crash again.\n"
"Current PATH: %s\n",
std::generic_category().message(errno).c_str(), T::sName, getenv("PATH"));
else if (ret != 0)
printf(
"\nFailed to create a crash report.\n"
"Please make sure that '%s' is installed and present in PATH then crash again.\n"
"Current PATH: %s\n",
T::sName, getenv("PATH"));
fflush(stdout);
return result;
}
struct Gdb
{
static constexpr char sName[] = "gdb";
static constexpr char sScript[] = R"(shell echo ""
shell echo "* Loaded Libraries"
info sharedlibrary
shell echo ""
shell echo "* Threads"
info threads
shell echo ""
shell echo "* FPU Status"
info float
shell echo ""
shell echo "* Registers"
info registers
shell echo ""
shell echo "* Backtrace"
thread apply all backtrace full 1000
detach
quit
)";
static constexpr char sCommandTemplate[] = "gdb --pid %d --quiet --batch --command %s";
};
struct Lldb
{
static constexpr char sName[] = "lldb";
static constexpr char sScript[] = R"(script print("\n* Loaded Libraries")
image list
script print('\n* Threads')
thread list
script print('\n* Registers')
register read --all
script print('\n* Backtrace')
script print(''.join(f'{t}\n' + ''.join(''.join([f' {f}\n', ''.join(f' {s}\n' for s in f.statics), ''.join(f' {v}\n' for v in f.variables)]) for f in t.frames) for t in lldb.process.threads))
detach
quit
)";
static constexpr char sCommandTemplate[] = "lldb --attach-pid %d --batch --source %s";
};
void printProcessInfo(pid_t pid)
{
if (printDebuggerInfo<Gdb>(pid))
return;
if (printDebuggerInfo<Lldb>(pid))
return;
}
}
static void printSystemInfo(void)
{
#ifdef __unix__
struct utsname info;
if (uname(&info) == -1)
printf("Failed to get system information: %s\n", std::generic_category().message(errno).c_str());
else
printf("System: %s %s %s %s %s\n", info.sysname, info.nodename, info.release, info.version, info.machine);
fflush(stdout);
#endif
}
static size_t safe_write(int fd, const void* buf, size_t len)
{
size_t ret = 0;
while (ret < len)
{
const ssize_t rem = write(fd, (const char*)buf + ret, len - ret);
if (rem == -1)
{
if (errno == EINTR)
continue;
break;
}
ret += rem;
}
return ret;
}
static void crash_catcher(int signum, siginfo_t* siginfo, void* /*context*/)
{
/* Make sure the effective uid is the real uid */
if (getuid() != geteuid())
{
raise(signum);
return;
}
safe_write(STDERR_FILENO, fatal_err, sizeof(fatal_err) - 1);
int fd[2];
if (pipe(fd) == -1)
{
safe_write(STDERR_FILENO, pipe_err, sizeof(pipe_err) - 1);
raise(signum);
return;
}
crash_info.signum = signum;
crash_info.pid = getpid();
if (siginfo == nullptr)
crash_info.siginfo = std::nullopt;
else
crash_info.siginfo = *siginfo;
const pid_t dbg_pid = fork();
/* Fork off to start a crash handler */
switch (dbg_pid)
{
/* Error */
case -1:
safe_write(STDERR_FILENO, fork_err, sizeof(fork_err) - 1);
raise(signum);
return;
case 0:
dup2(fd[0], STDIN_FILENO);
close(fd[0]);
close(fd[1]);
execl(argv0, argv0, crash_switch, nullptr);
safe_write(STDERR_FILENO, exec_err, sizeof(exec_err) - 1);
_exit(1);
default:
#ifdef __linux__
prctl(PR_SET_PTRACER, dbg_pid, 0, 0, 0);
#endif
safe_write(fd[1], &crash_info, sizeof(crash_info));
close(fd[0]);
close(fd[1]);
/* Wait; we'll be killed when gdb is done */
do
{
int status;
if (waitpid(dbg_pid, &status, 0) == dbg_pid && (WIFEXITED(status) || WIFSIGNALED(status)))
{
/* The debug process died before it could kill us */
raise(signum);
break;
}
} while (1);
}
}
[[noreturn]] static void handleCrash(const char* logfile)
{
if (fread(&crash_info, sizeof(crash_info), 1, stdin) != 1)
{
fprintf(stderr, "Failed to retrieve info from crashed process: %s\n",
std::generic_category().message(errno).c_str());
exit(1);
}
const char* sigdesc = findSignalDescription(signals, crash_info.signum);
if (crash_info.siginfo.has_value())
{
switch (crash_info.signum)
{
case SIGSEGV:
sigdesc = findSignalDescription(sigSegvCodes, crash_info.siginfo->si_code);
break;
case SIGFPE:
sigdesc = findSignalDescription(sigFpeCodes, crash_info.siginfo->si_code);
break;
case SIGILL:
sigdesc = findSignalDescription(sigIllCodes, crash_info.siginfo->si_code);
break;
case SIGBUS:
sigdesc = findSignalDescription(sigBusCodes, crash_info.siginfo->si_code);
break;
}
}
fprintf(stderr, "%s (signal %i)\n", sigdesc, crash_info.signum);
if (crash_info.siginfo.has_value())
fprintf(stderr, "Address: %p\n", crash_info.siginfo->si_addr);
fputc('\n', stderr);
/* Create crash log file and redirect shell output to it */
if (freopen(logfile, "wa", stdout) != stdout)
{
fprintf(stderr, "Could not create %s following signal: %s\n", logfile,
std::generic_category().message(errno).c_str());
exit(1);
}
fprintf(stderr, "Generating %s and killing process %d, please wait... ", logfile, crash_info.pid);
printf(
"*** Fatal Error ***\n"
"%s (signal %i)\n",
sigdesc, crash_info.signum);
if (crash_info.siginfo.has_value())
printf("Address: %p\n", crash_info.siginfo->si_addr);
fputc('\n', stdout);
fflush(stdout);
printSystemInfo();
fflush(stdout);
if (crash_info.pid > 0)
{
printProcessInfo(crash_info.pid);
kill(crash_info.pid, SIGKILL);
}
// delay between killing of the crashed process and showing the message box to
// work around occasional X server lock-up. this can only be a bug in X11 since
// even faulty applications shouldn't be able to freeze the X server.
usleep(100000);
const std::string message = "OpenMW has encountered a fatal error.\nCrash log saved to '" + std::string(logfile)
+ "'.\n Please report this to https://gitlab.com/OpenMW/openmw/issues !";
SDL_ShowSimpleMessageBox(0, "Fatal Error", message.c_str(), nullptr);
exit(0);
}
static void getExecPath(char** argv)
{
#if defined(__FreeBSD__)
int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1 };
size_t size = sizeof(argv0);
if (sysctl(mib, 4, argv0, &size, nullptr, 0) == 0)
return;
Log(Debug::Warning) << "Failed to call sysctl: " << std::generic_category().message(errno);
#endif
#if defined(__APPLE__)
if (proc_pidpath(getpid(), argv0, sizeof(argv0)) > 0)
return;
Log(Debug::Warning) << "Failed to call proc_pidpath: " << std::generic_category().message(errno);
#endif
const char* statusPaths[] = { "/proc/self/exe", "/proc/self/file", "/proc/curproc/exe", "/proc/curproc/file" };
memset(argv0, 0, sizeof(argv0));
for (const char* path : statusPaths)
{
if (readlink(path, argv0, sizeof(argv0)) != -1)
return;
Log(Debug::Warning) << "Failed to call readlink for \"" << path
<< "\": " << std::generic_category().message(errno);
}
if (argv[0][0] == '/')
{
snprintf(argv0, sizeof(argv0), "%s", argv[0]);
return;
}
if (getcwd(argv0, sizeof(argv0)) == nullptr)
{
Log(Debug::Error) << "Failed to call getcwd: " << std::generic_category().message(errno);
return;
}
const int cwdlen = strlen(argv0);
snprintf(argv0 + cwdlen, sizeof(argv0) - cwdlen, "/%s", argv[0]);
}
static bool crashCatcherInstallHandlers(char** argv)
{
getExecPath(argv);
/* Set an alternate signal stack so SIGSEGVs caused by stack overflows
* still run */
static char* altstack = new char[SIGSTKSZ];
stack_t altss;
altss.ss_sp = altstack;
altss.ss_flags = 0;
altss.ss_size = SIGSTKSZ;
if (sigaltstack(&altss, nullptr) == -1)
{
Log(Debug::Error) << "Failed to call sigaltstack: " << std::generic_category().message(errno);
return false;
}
struct sigaction sa;
memset(&sa, 0, sizeof(sa));
sa.sa_sigaction = crash_catcher;
sa.sa_flags = SA_RESETHAND | SA_NODEFER | SA_SIGINFO | SA_ONSTACK;
if (sigemptyset(&sa.sa_mask) == -1)
{
Log(Debug::Error) << "Failed to call sigemptyset: " << std::generic_category().message(errno);
return false;
}
for (const SignalInfo& signal : signals)
{
if (sigaction(signal.mCode, &sa, nullptr) == -1)
{
Log(Debug::Error) << "Failed to call sigaction for signal " << signal.mName << " (" << signal.mCode
<< "): " << std::generic_category().message(errno);
return false;
}
}
return true;
}
namespace
{
#if defined(__APPLE__)
bool isDebuggerPresent(const auto& info)
{
return (info.kp_proc.p_flag & P_TRACED) != 0;
}
#elif defined(__FreeBSD__)
bool isDebuggerPresent(const auto& info)
{
return (info.ki_flag & P_TRACED) != 0;
}
#endif
}
static bool isDebuggerPresent()
{
#if defined(__linux__)
std::filesystem::path procstatus = std::filesystem::path("/proc/self/status");
if (std::filesystem::exists(procstatus))
{
std::ifstream file((procstatus));
while (!file.eof())
{
std::string word;
file >> word;
if (word == "TracerPid:")
{
file >> word;
return word != "0";
}
}
}
return false;
#elif defined(__APPLE__) || defined(__FreeBSD__)
struct kinfo_proc info;
std::memset(&info, 0, sizeof(info));
// Initialize mib, which tells sysctl the info we want, in this case
// we're looking for information about a specific process ID.
int mib[4] = { CTL_KERN, KERN_PROC, KERN_PROC_PID, getpid() };
size_t size = sizeof(info);
if (sysctl(mib, std::size(mib), &info, &size, nullptr, 0) == -1)
{
Log(Debug::Warning) << "Failed to call sysctl, assuming no debugger: "
<< std::generic_category().message(errno);
return false;
}
return isDebuggerPresent(info);
#else
return false;
#endif
}
void crashCatcherInstall(int argc, char** argv, const std::filesystem::path& crashLogPath)
{
if (argc == 2 && strcmp(argv[1], crash_switch) == 0)
handleCrash(Files::pathToUnicodeString(crashLogPath).c_str());
if (isDebuggerPresent())
return;
if (crashCatcherInstallHandlers(argv))
Log(Debug::Info) << "Crash handler installed";
else
Log(Debug::Warning) << "Installing crash handler failed";
}
| 17,310
|
C++
|
.cpp
| 509
| 27.314342
| 198
| 0.596925
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,906
|
windows_crashmonitor.cpp
|
OpenMW_openmw/components/crashcatcher/windows_crashmonitor.cpp
|
#include "windows_crashmonitor.hpp"
#include <Psapi.h>
#include <components/misc/windows.hpp>
#include <DbgHelp.h>
#include <memory>
#include <thread>
#include <SDL_messagebox.h>
#include "windows_crashcatcher.hpp"
#include "windows_crashshm.hpp"
#include "windowscrashdumppathhelpers.hpp"
#include <components/debug/debuglog.hpp>
#include <components/misc/strings/conversion.hpp>
namespace Crash
{
std::unordered_map<HWINEVENTHOOK, CrashMonitor*> CrashMonitor::smEventHookOwners{};
using IsHungAppWindowFn = BOOL(WINAPI*)(HWND hwnd);
// Obtains the pointer to user32.IsHungAppWindow, this function may be removed in the future.
// See: https://docs.microsoft.com/en-us/windows/win32/api/winuser/nf-winuser-ishungappwindow
static IsHungAppWindowFn getIsHungAppWindow() noexcept
{
auto user32Handle = LoadLibraryA("user32.dll");
if (user32Handle == nullptr)
return nullptr;
return reinterpret_cast<IsHungAppWindowFn>(GetProcAddress(user32Handle, "IsHungAppWindow"));
}
static const IsHungAppWindowFn sIsHungAppWindow = getIsHungAppWindow();
CrashMonitor::CrashMonitor(HANDLE shmHandle)
: mShmHandle(shmHandle)
{
mShm = reinterpret_cast<CrashSHM*>(MapViewOfFile(mShmHandle, FILE_MAP_ALL_ACCESS, 0, 0, sizeof(CrashSHM)));
if (mShm == nullptr)
throw std::runtime_error("Failed to map crash monitor shared memory");
// accessing SHM without lock is OK here, the parent waits for a signal before continuing
mShmMutex = mShm->mStartup.mShmMutex;
mAppProcessHandle = mShm->mStartup.mAppProcessHandle;
mAppMainThreadId = mShm->mStartup.mAppMainThreadId;
mSignalAppEvent = mShm->mStartup.mSignalApp;
mSignalMonitorEvent = mShm->mStartup.mSignalMonitor;
}
CrashMonitor::~CrashMonitor()
{
if (mShm)
UnmapViewOfFile(mShm);
// the handles received from the app are duplicates, we must close them
if (mShmHandle)
CloseHandle(mShmHandle);
if (mShmMutex)
CloseHandle(mShmMutex);
if (mSignalAppEvent)
CloseHandle(mSignalAppEvent);
if (mSignalMonitorEvent)
CloseHandle(mSignalMonitorEvent);
}
void CrashMonitor::shmLock()
{
if (WaitForSingleObject(mShmMutex, CrashCatcherTimeout) != WAIT_OBJECT_0)
throw std::runtime_error("SHM monitor lock timed out");
}
void CrashMonitor::shmUnlock()
{
ReleaseMutex(mShmMutex);
}
void CrashMonitor::signalApp() const
{
SetEvent(mSignalAppEvent);
}
bool CrashMonitor::waitApp() const
{
return WaitForSingleObject(mSignalMonitorEvent, CrashCatcherTimeout) == WAIT_OBJECT_0;
}
bool CrashMonitor::isAppAlive() const
{
DWORD code = 0;
GetExitCodeProcess(mAppProcessHandle, &code);
return code == STILL_ACTIVE;
}
bool CrashMonitor::isAppFrozen()
{
MSG message;
// Allow the event hook callback to run
PeekMessage(&message, nullptr, 0, 0, PM_NOREMOVE);
if (!mAppWindowHandle)
{
EnumWindows(
[](HWND handle, LPARAM param) -> BOOL {
CrashMonitor& crashMonitor = *(CrashMonitor*)param;
DWORD processId;
if (GetWindowThreadProcessId(handle, &processId) == crashMonitor.mAppMainThreadId
&& processId == GetProcessId(crashMonitor.mAppProcessHandle))
{
if (GetWindow(handle, GW_OWNER) == 0)
{
crashMonitor.mAppWindowHandle = handle;
return false;
}
}
return true;
},
(LPARAM)this);
if (mAppWindowHandle)
{
DWORD processId;
GetWindowThreadProcessId(mAppWindowHandle, &processId);
HWINEVENTHOOK eventHookHandle = SetWinEventHook(
EVENT_OBJECT_DESTROY, EVENT_OBJECT_DESTROY, nullptr,
[](HWINEVENTHOOK hWinEventHook, DWORD event, HWND windowHandle, LONG objectId, LONG childId,
DWORD eventThread, DWORD eventTime) {
CrashMonitor& crashMonitor = *smEventHookOwners[hWinEventHook];
if (event == EVENT_OBJECT_DESTROY && windowHandle == crashMonitor.mAppWindowHandle
&& objectId == OBJID_WINDOW && childId == INDEXID_CONTAINER)
{
crashMonitor.mAppWindowHandle = nullptr;
smEventHookOwners.erase(hWinEventHook);
UnhookWinEvent(hWinEventHook);
}
},
processId, mAppMainThreadId, WINEVENT_OUTOFCONTEXT);
smEventHookOwners[eventHookHandle] = this;
}
else
return false;
}
if (sIsHungAppWindow != nullptr)
return sIsHungAppWindow(mAppWindowHandle);
else
{
BOOL debuggerPresent;
if (CheckRemoteDebuggerPresent(mAppProcessHandle, &debuggerPresent) && debuggerPresent)
return false;
if (SendMessageTimeoutA(mAppWindowHandle, WM_NULL, 0, 0, 0, 5000, nullptr) == 0)
return GetLastError() == ERROR_TIMEOUT;
}
return false;
}
void CrashMonitor::run()
{
try
{
// app waits for monitor start up, let it continue
signalApp();
bool running = true;
bool frozen = false;
while (isAppAlive() && running && !mFreezeAbort)
{
if (isAppFrozen())
{
if (!frozen)
{
showFreezeMessageBox();
frozen = true;
}
}
else if (frozen)
{
hideFreezeMessageBox();
frozen = false;
}
if (!mFreezeAbort && waitApp())
{
shmLock();
switch (mShm->mEvent)
{
case CrashSHM::Event::None:
break;
case CrashSHM::Event::Crashed:
handleCrash(false);
running = false;
break;
case CrashSHM::Event::Shutdown:
running = false;
break;
case CrashSHM::Event::Startup:
break;
}
shmUnlock();
}
}
if (frozen)
hideFreezeMessageBox();
if (mFreezeAbort)
{
handleCrash(true);
TerminateProcess(mAppProcessHandle, 0xDEAD);
std::string message = "OpenMW appears to have frozen.\nCrash log saved to '"
+ Misc::StringUtils::u8StringToString(getFreezeDumpPath(*mShm).u8string())
+ "'.\nPlease report this to https://gitlab.com/OpenMW/openmw/issues !";
SDL_ShowSimpleMessageBox(0, "Fatal Error", message.c_str(), nullptr);
}
}
catch (...)
{
Log(Debug::Error) << "Exception in crash monitor, exiting";
}
signalApp();
}
void CrashMonitor::handleCrash(bool isFreeze)
{
DWORD processId = GetProcessId(mAppProcessHandle);
const char* env = getenv("OPENMW_FULL_MEMDUMP");
try
{
HMODULE dbghelp = LoadLibraryA("dbghelp.dll");
if (dbghelp == NULL)
return;
using MiniDumpWirteDumpFn = BOOL(WINAPI*)(HANDLE hProcess, DWORD ProcessId, HANDLE hFile,
MINIDUMP_TYPE DumpType, PMINIDUMP_EXCEPTION_INFORMATION ExceptionParam,
PMINIDUMP_USER_STREAM_INFORMATION UserStreamParam, PMINIDUMP_CALLBACK_INFORMATION CallbackParam);
MiniDumpWirteDumpFn miniDumpWriteDump = (MiniDumpWirteDumpFn)GetProcAddress(dbghelp, "MiniDumpWriteDump");
if (miniDumpWriteDump == NULL)
return;
std::wstring utf16Path = (isFreeze ? getFreezeDumpPath(*mShm) : getCrashDumpPath(*mShm)).native();
if (utf16Path.empty())
return;
if (utf16Path.length() > MAX_PATH)
utf16Path = LR"(\\?\)" + utf16Path;
HANDLE hCrashLog = CreateFileW(utf16Path.c_str(), GENERIC_READ | GENERIC_WRITE, 0, nullptr, CREATE_ALWAYS,
FILE_ATTRIBUTE_NORMAL, nullptr);
if (hCrashLog == NULL || hCrashLog == INVALID_HANDLE_VALUE)
return;
if (auto err = GetLastError(); err != ERROR_ALREADY_EXISTS && err != 0)
return;
EXCEPTION_POINTERS exp;
exp.ContextRecord = &mShm->mCrashed.mContext;
exp.ExceptionRecord = &mShm->mCrashed.mExceptionRecord;
MINIDUMP_EXCEPTION_INFORMATION infos = {};
infos.ThreadId = mShm->mCrashed.mThreadId;
infos.ExceptionPointers = &exp;
infos.ClientPointers = FALSE;
MINIDUMP_TYPE type = (MINIDUMP_TYPE)(MiniDumpWithDataSegs | MiniDumpWithHandleData);
if (env)
type = static_cast<MINIDUMP_TYPE>(type | MiniDumpWithFullMemory);
miniDumpWriteDump(mAppProcessHandle, processId, hCrashLog, type, &infos, 0, 0);
}
catch (const std::exception& e)
{
Log(Debug::Error) << "CrashMonitor: " << e.what();
}
catch (...)
{
Log(Debug::Error) << "CrashMonitor: unknown exception";
}
}
void CrashMonitor::showFreezeMessageBox()
{
std::thread messageBoxThread([&]() {
SDL_MessageBoxButtonData button = { SDL_MESSAGEBOX_BUTTON_RETURNKEY_DEFAULT, 0, "Abort" };
SDL_MessageBoxData messageBoxData = { SDL_MESSAGEBOX_ERROR, nullptr, "OpenMW appears to have frozen",
"OpenMW appears to have frozen. Press Abort to terminate it and generate a crash dump.\nIf OpenMW "
"hasn't actually frozen, this message box will disappear a within a few seconds of it becoming "
"responsive.",
1, &button, nullptr };
int buttonId;
if (SDL_ShowMessageBox(&messageBoxData, &buttonId) == 0 && buttonId == 0)
mFreezeAbort = true;
});
mFreezeMessageBoxThreadId = GetThreadId(messageBoxThread.native_handle());
messageBoxThread.detach();
}
void CrashMonitor::hideFreezeMessageBox()
{
if (!mFreezeMessageBoxThreadId)
return;
EnumWindows(
[](HWND handle, LPARAM param) -> BOOL {
CrashMonitor& crashMonitor = *(CrashMonitor*)param;
DWORD processId;
if (GetWindowThreadProcessId(handle, &processId) == crashMonitor.mFreezeMessageBoxThreadId
&& processId == GetCurrentProcessId())
PostMessage(handle, WM_CLOSE, 0, 0);
return true;
},
(LPARAM)this);
mFreezeMessageBoxThreadId = 0;
}
} // namespace Crash
| 11,652
|
C++
|
.cpp
| 275
| 29.272727
| 118
| 0.565954
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,907
|
editor.cpp
|
OpenMW_openmw/apps/opencs/editor.cpp
|
#include "editor.hpp"
#include <QApplication>
#include <QFileInfo>
#include <QLocalServer>
#include <QLocalSocket>
#include <QMessageBox>
#include <QRegularExpression>
#include <boost/program_options.hpp>
#include <exception>
#include <apps/opencs/model/doc/document.hpp>
#include <apps/opencs/model/doc/documentmanager.hpp>
#include <apps/opencs/view/doc/adjusterwidget.hpp>
#include <apps/opencs/view/doc/filedialog.hpp>
#include <apps/opencs/view/doc/newgame.hpp>
#include <apps/opencs/view/doc/startup.hpp>
#include <apps/opencs/view/prefs/dialogue.hpp>
#include <apps/opencs/view/tools/merge.hpp>
#ifdef _WIN32
#include <components/misc/windows.hpp>
#endif
#include <components/debug/debugging.hpp>
#include <components/debug/debuglog.hpp>
#include <components/esm3/esmreader.hpp>
#include <components/esm3/loadtes3.hpp>
#include <components/fallback/fallback.hpp>
#include <components/fallback/validate.hpp>
#include <components/files/qtconversion.hpp>
#include <components/misc/rng.hpp>
#include <components/nifosg/nifloader.hpp>
#include <components/settings/settings.hpp>
#include <components/to_utf8/to_utf8.hpp>
#include "view/doc/viewmanager.hpp"
using namespace Fallback;
CS::Editor::Editor(int argc, char** argv)
: mConfigVariables(readConfiguration())
, mSettingsState(mCfgMgr)
, mDocumentManager(mCfgMgr)
, mPid(std::filesystem::temp_directory_path() / "openmw-cs.pid")
, mLockFile(QFileInfo(Files::pathToQString(mPid)).absoluteFilePath() + ".lock")
, mMerge(mDocumentManager)
, mIpcServerName("org.openmw.OpenCS")
, mServer(nullptr)
, mClientSocket(nullptr)
{
std::pair<Files::PathContainer, std::vector<std::string>> config = readConfig();
mViewManager = new CSVDoc::ViewManager(mDocumentManager);
if (argc > 1)
{
mFileToLoad = argv[1];
mDataDirs = config.first;
}
NifOsg::Loader::setShowMarkers(true);
mDocumentManager.setFileData(config.first, config.second);
mNewGame.setLocalData(mLocal);
mFileDialog.setLocalData(mLocal);
mMerge.setLocalData(mLocal);
connect(&mDocumentManager, &CSMDoc::DocumentManager::documentAdded, this, &Editor::documentAdded);
connect(
&mDocumentManager, &CSMDoc::DocumentManager::documentAboutToBeRemoved, this, &Editor::documentAboutToBeRemoved);
connect(&mDocumentManager, &CSMDoc::DocumentManager::lastDocumentDeleted, this, &Editor::lastDocumentDeleted);
connect(mViewManager, &CSVDoc::ViewManager::newGameRequest, this, &Editor::createGame);
connect(mViewManager, &CSVDoc::ViewManager::newAddonRequest, this, &Editor::createAddon);
connect(mViewManager, &CSVDoc::ViewManager::loadDocumentRequest, this, &Editor::loadDocument);
connect(mViewManager, &CSVDoc::ViewManager::editSettingsRequest, this, &Editor::showSettings);
connect(mViewManager, &CSVDoc::ViewManager::mergeDocument, this, &Editor::mergeDocument);
connect(&mStartup, &CSVDoc::StartupDialogue::createGame, this, &Editor::createGame);
connect(&mStartup, &CSVDoc::StartupDialogue::createAddon, this, &Editor::createAddon);
connect(&mStartup, &CSVDoc::StartupDialogue::loadDocument, this, &Editor::loadDocument);
connect(&mStartup, &CSVDoc::StartupDialogue::editConfig, this, &Editor::showSettings);
connect(&mFileDialog, &CSVDoc::FileDialog::signalOpenFiles, this,
[this](const std::filesystem::path& savePath) { this->openFiles(savePath); });
connect(&mFileDialog, &CSVDoc::FileDialog::signalCreateNewFile, this, &Editor::createNewFile);
connect(&mFileDialog, &CSVDoc::FileDialog::rejected, this, &Editor::cancelFileDialog);
connect(&mNewGame, &CSVDoc::NewGameDialogue::createRequest, this, &Editor::createNewGame);
connect(&mNewGame, &CSVDoc::NewGameDialogue::cancelCreateGame, this, &Editor::cancelCreateGame);
}
CS::Editor::~Editor()
{
delete mViewManager;
mLockFile.unlock();
mPidFile.close();
if (mServer && std::filesystem::exists(mPid))
std::filesystem::remove(mPid);
}
boost::program_options::variables_map CS::Editor::readConfiguration()
{
boost::program_options::variables_map variables;
boost::program_options::options_description desc("Syntax: openmw-cs <options>\nAllowed options");
auto addOption = desc.add_options();
addOption("data",
boost::program_options::value<Files::MaybeQuotedPathContainer>()
->default_value(Files::MaybeQuotedPathContainer(), "data")
->multitoken()
->composing());
addOption("data-local",
boost::program_options::value<Files::MaybeQuotedPathContainer::value_type>()->default_value(
Files::MaybeQuotedPathContainer::value_type(), ""));
addOption("encoding", boost::program_options::value<std::string>()->default_value("win1252"));
addOption("fallback-archive",
boost::program_options::value<std::vector<std::string>>()
->default_value(std::vector<std::string>(), "fallback-archive")
->multitoken());
addOption("fallback",
boost::program_options::value<FallbackMap>()->default_value(FallbackMap(), "")->multitoken()->composing(),
"fallback values");
Files::ConfigurationManager::addCommonOptions(desc);
boost::program_options::notify(variables);
mCfgMgr.readConfiguration(variables, desc, false);
Settings::Manager::load(mCfgMgr, true);
Debug::setupLogging(mCfgMgr.getLogPath(), "OpenMW-CS");
return variables;
}
std::pair<Files::PathContainer, std::vector<std::string>> CS::Editor::readConfig(bool quiet)
{
boost::program_options::variables_map& variables = mConfigVariables;
Fallback::Map::init(variables["fallback"].as<FallbackMap>().mMap);
mEncodingName = variables["encoding"].as<std::string>();
mDocumentManager.setEncoding(ToUTF8::calculateEncoding(mEncodingName));
mFileDialog.setEncoding(QString::fromUtf8(mEncodingName.c_str()));
mDocumentManager.setResourceDir(mResources = variables["resources"]
.as<Files::MaybeQuotedPath>()
.u8string()); // This call to u8string is redundant, but required
// to build on MSVC 14.26 due to implementation bugs.
Files::PathContainer dataDirs, dataLocal;
if (!variables["data"].empty())
{
dataDirs = asPathContainer(variables["data"].as<Files::MaybeQuotedPathContainer>());
}
Files::PathContainer::value_type local(variables["data-local"]
.as<Files::MaybeQuotedPathContainer::value_type>()
.u8string()); // This call to u8string is redundant, but required to
// build on MSVC 14.26 due to implementation bugs.
if (!local.empty())
{
std::filesystem::create_directories(local);
dataLocal.push_back(local);
}
mCfgMgr.filterOutNonExistingPaths(dataDirs);
mCfgMgr.filterOutNonExistingPaths(dataLocal);
if (!dataLocal.empty())
mLocal = dataLocal[0];
else
{
QMessageBox messageBox;
messageBox.setWindowTitle(tr("No local data path available"));
messageBox.setIcon(QMessageBox::Critical);
messageBox.setStandardButtons(QMessageBox::Ok);
messageBox.setText(
tr("<br><b>OpenCS is unable to access the local data directory. This may indicate a faulty configuration "
"or a broken install.</b>"));
messageBox.exec();
QApplication::exit(1);
}
dataDirs.insert(dataDirs.end(), dataLocal.begin(), dataLocal.end());
dataDirs.insert(dataDirs.begin(), mResources / "vfs");
// iterate the data directories and add them to the file dialog for loading
mFileDialog.addFiles(dataDirs);
return std::make_pair(dataDirs, variables["fallback-archive"].as<std::vector<std::string>>());
}
void CS::Editor::createGame()
{
mStartup.hide();
if (mNewGame.isHidden())
mNewGame.show();
mNewGame.raise();
mNewGame.activateWindow();
}
void CS::Editor::cancelCreateGame()
{
if (!mDocumentManager.isEmpty())
return;
mNewGame.hide();
if (mStartup.isHidden())
mStartup.show();
mStartup.raise();
mStartup.activateWindow();
}
void CS::Editor::createAddon()
{
mStartup.hide();
mFileDialog.clearFiles();
readConfig(/*quiet*/ true);
mFileDialog.showDialog(CSVDoc::ContentAction_New);
}
void CS::Editor::cancelFileDialog()
{
if (!mDocumentManager.isEmpty())
return;
mFileDialog.hide();
if (mStartup.isHidden())
mStartup.show();
mStartup.raise();
mStartup.activateWindow();
}
void CS::Editor::loadDocument()
{
mStartup.hide();
mFileDialog.clearFiles();
readConfig(/*quiet*/ true);
mFileDialog.showDialog(CSVDoc::ContentAction_Edit);
}
void CS::Editor::openFiles(
const std::filesystem::path& savePath, const std::vector<std::filesystem::path>& discoveredFiles)
{
std::vector<std::filesystem::path> files;
if (discoveredFiles.empty())
{
for (const QString& path : mFileDialog.selectedFilePaths())
{
files.emplace_back(Files::pathFromQString(path));
}
}
else
{
files = discoveredFiles;
}
mDocumentManager.addDocument(files, savePath, false);
mFileDialog.hide();
}
void CS::Editor::createNewFile(const std::filesystem::path& savePath)
{
std::vector<std::filesystem::path> files;
for (const QString& path : mFileDialog.selectedFilePaths())
{
files.emplace_back(Files::pathFromQString(path));
}
files.push_back(savePath);
mDocumentManager.addDocument(files, savePath, true);
mFileDialog.hide();
}
void CS::Editor::createNewGame(const std::filesystem::path& file)
{
std::vector<std::filesystem::path> files;
files.push_back(file);
mDocumentManager.addDocument(files, file, true);
mNewGame.hide();
}
void CS::Editor::showStartup()
{
if (mStartup.isHidden())
mStartup.show();
mStartup.raise();
mStartup.activateWindow();
}
void CS::Editor::showSettings()
{
if (mSettings.isHidden())
mSettings.show();
mSettings.move(QCursor::pos());
mSettings.raise();
mSettings.activateWindow();
}
bool CS::Editor::makeIPCServer()
{
try
{
bool pidExists = std::filesystem::exists(mPid);
mPidFile.open(mPid);
if (!mLockFile.tryLock())
{
Log(Debug::Error) << "Error: OpenMW-CS is already running.";
return false;
}
#ifdef _WIN32
mPidFile << GetCurrentProcessId() << std::endl;
#else
mPidFile << getpid() << std::endl;
#endif
mServer = new QLocalServer(this);
if (pidExists)
{
// hack to get the temp directory path
mServer->listen("dummy");
QString fullPath = mServer->fullServerName();
mServer->close();
fullPath.remove(QRegularExpression("dummy$"));
fullPath += mIpcServerName;
const auto path = Files::pathFromQString(fullPath);
if (exists(path))
{
// TODO: compare pid of the current process with that in the file
Log(Debug::Info) << "Detected unclean shutdown.";
// delete the stale file
if (remove(path))
Log(Debug::Error) << "Error: can not remove stale connection file.";
}
}
}
catch (const std::exception& e)
{
Log(Debug::Error) << "Error: " << e.what();
return false;
}
if (mServer->listen(mIpcServerName))
{
connect(mServer, &QLocalServer::newConnection, this, &Editor::showStartup);
return true;
}
mServer->close();
mServer = nullptr;
return false;
}
void CS::Editor::connectToIPCServer()
{
mClientSocket = new QLocalSocket(this);
mClientSocket->connectToServer(mIpcServerName);
mClientSocket->close();
}
int CS::Editor::run()
{
if (mLocal.empty())
return 1;
Misc::Rng::init();
QApplication::setQuitOnLastWindowClosed(true);
if (mFileToLoad.empty())
{
mStartup.show();
}
else
{
ESM::ESMReader fileReader;
ToUTF8::Utf8Encoder encoder(ToUTF8::calculateEncoding(mEncodingName));
fileReader.setEncoder(&encoder);
fileReader.open(mFileToLoad);
std::vector<std::filesystem::path> discoveredFiles;
for (const auto& item : fileReader.getGameFiles())
{
for (const auto& path : mDataDirs)
{
if (auto masterPath = path / item.name; std::filesystem::exists(masterPath))
{
discoveredFiles.emplace_back(std::move(masterPath));
break;
}
}
}
discoveredFiles.push_back(mFileToLoad);
const auto extension = Files::pathToQString(mFileToLoad.extension()).toLower();
if (extension == ".esm")
{
mFileToLoad.replace_extension(".omwgame");
mDocumentManager.addDocument(discoveredFiles, mFileToLoad, false);
}
else if (extension == ".esp")
{
mFileToLoad.replace_extension(".omwaddon");
mDocumentManager.addDocument(discoveredFiles, mFileToLoad, false);
}
else
{
openFiles(mFileToLoad, discoveredFiles);
}
}
return QApplication::exec();
}
void CS::Editor::documentAdded(CSMDoc::Document* document)
{
mViewManager->addView(document);
}
void CS::Editor::documentAboutToBeRemoved(CSMDoc::Document* document)
{
if (mMerge.getDocument() == document)
mMerge.cancel();
}
void CS::Editor::lastDocumentDeleted()
{
QApplication::quit();
}
void CS::Editor::mergeDocument(CSMDoc::Document* document)
{
mMerge.configure(document);
mMerge.show();
mMerge.raise();
mMerge.activateWindow();
}
| 14,133
|
C++
|
.cpp
| 375
| 30.96
| 120
| 0.667984
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,908
|
main.cpp
|
OpenMW_openmw/apps/opencs/main.cpp
|
#include "editor.hpp"
#include <exception>
#include <string>
#include <QIcon>
#include <QSurfaceFormat>
#include <osg/DisplaySettings>
#include <components/debug/debugging.hpp>
#include <components/platform/application.hpp>
#include <components/platform/platform.hpp>
#include "model/doc/messages.hpp"
#include "model/world/disabletag.hpp"
#include "model/world/universalid.hpp"
#ifdef Q_OS_MAC
#include <QDir>
#endif
Q_DECLARE_METATYPE(std::string)
class QEvent;
class QObject;
void setQSurfaceFormat()
{
osg::DisplaySettings* ds = osg::DisplaySettings::instance().get();
QSurfaceFormat format = QSurfaceFormat::defaultFormat();
format.setVersion(2, 1);
format.setRenderableType(QSurfaceFormat::OpenGL);
format.setDepthBufferSize(24);
format.setSamples(ds->getMultiSamples());
format.setStencilBufferSize(ds->getMinimumNumStencilBits());
format.setSwapBehavior(QSurfaceFormat::DoubleBuffer);
QSurfaceFormat::setDefaultFormat(format);
}
int runApplication(int argc, char* argv[])
{
Platform::init();
#ifdef Q_OS_MAC
setenv("OSG_GL_TEXTURE_STORAGE", "OFF", 0);
#endif
Q_INIT_RESOURCE(resources);
#ifdef WIN32
Q_INIT_RESOURCE(dark);
#endif
qRegisterMetaType<std::string>("std::string");
qRegisterMetaType<CSMWorld::UniversalId>("CSMWorld::UniversalId");
qRegisterMetaType<CSMWorld::DisableTag>("CSMWorld::DisableTag");
qRegisterMetaType<CSMDoc::Message>("CSMDoc::Message");
setQSurfaceFormat();
QCoreApplication::setAttribute(Qt::AA_ShareOpenGLContexts);
Platform::Application application(argc, argv);
application.setWindowIcon(QIcon(":openmw-cs"));
CS::Editor editor(argc, argv);
#ifdef __linux__
setlocale(LC_NUMERIC, "C");
#endif
if (!editor.makeIPCServer())
{
editor.connectToIPCServer();
return 0;
}
return editor.run();
}
int main(int argc, char* argv[])
{
return Debug::wrapApplication(&runApplication, argc, argv, "OpenMW-CS");
}
| 1,985
|
C++
|
.cpp
| 63
| 28.142857
| 76
| 0.746449
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,909
|
refidcollection.cpp
|
OpenMW_openmw/apps/opencs/model/world/refidcollection.cpp
|
#include "refidcollection.hpp"
#include <algorithm>
#include <memory>
#include <stdexcept>
#include <string_view>
#include <type_traits>
#include <apps/opencs/model/world/columnbase.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refiddata.hpp>
#include <components/esm3/loadacti.hpp>
#include <components/esm3/loadalch.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadlevlist.hpp>
#include <components/esm3/loadligh.hpp>
#include <components/esm3/loadlock.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadprob.hpp>
#include <components/esm3/loadrepa.hpp>
#include <components/esm3/loadstat.hpp>
#include <components/esm3/loadweap.hpp>
#include "columns.hpp"
#include "nestedcoladapterimp.hpp"
#include "nestedtablewrapper.hpp"
#include "refidadapter.hpp"
#include "refidadapterimp.hpp"
CSMWorld::RefIdColumn::RefIdColumn(int columnId, Display displayType, int flag, bool editable, bool userEditable)
: NestableColumn(columnId, displayType, flag)
, mEditable(editable)
, mUserEditable(userEditable)
{
}
bool CSMWorld::RefIdColumn::isEditable() const
{
return mEditable;
}
bool CSMWorld::RefIdColumn::isUserEditable() const
{
return mUserEditable;
}
const CSMWorld::RefIdAdapter& CSMWorld::RefIdCollection::findAdapter(UniversalId::Type type) const
{
std::map<UniversalId::Type, RefIdAdapter*>::const_iterator iter = mAdapters.find(type);
if (iter == mAdapters.end())
throw std::logic_error("unsupported type in RefIdCollection");
return *iter->second;
}
CSMWorld::RefIdCollection::RefIdCollection()
{
BaseColumns baseColumns;
mColumns.emplace_back(
Columns::ColumnId_Id, ColumnBase::Display_Id, ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue, false, false);
baseColumns.mId = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Modification, ColumnBase::Display_RecordState,
ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue, true, false);
baseColumns.mModified = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_RecordType, ColumnBase::Display_RefRecordType,
ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue, false, false);
baseColumns.mType = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Blocked, ColumnBase::Display_Boolean,
ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_Refresh);
baseColumns.mBlocked = &mColumns.back();
ModelColumns modelColumns(baseColumns);
mColumns.emplace_back(Columns::ColumnId_Persistent, ColumnBase::Display_Boolean);
modelColumns.mPersistence = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Model, ColumnBase::Display_Mesh);
modelColumns.mModel = &mColumns.back();
NameColumns nameColumns(modelColumns);
// Only items that can be placed in a container have the 32 character limit, but enforce
// that for all referenceable types for now.
mColumns.emplace_back(Columns::ColumnId_Name, ColumnBase::Display_String32);
nameColumns.mName = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Script, ColumnBase::Display_Script);
nameColumns.mScript = &mColumns.back();
InventoryColumns inventoryColumns(nameColumns);
mColumns.emplace_back(Columns::ColumnId_Icon, ColumnBase::Display_Icon);
inventoryColumns.mIcon = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Weight, ColumnBase::Display_Float);
inventoryColumns.mWeight = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_GoldValue, ColumnBase::Display_Integer);
inventoryColumns.mValue = &mColumns.back();
IngredientColumns ingredientColumns(inventoryColumns);
mColumns.emplace_back(Columns::ColumnId_EffectList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
ingredientColumns.mEffects = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> ingredientEffectsMap;
ingredientEffectsMap.insert(std::make_pair(UniversalId::Type_Ingredient, new IngredEffectRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), ingredientEffectsMap);
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_EffectId, ColumnBase::Display_IngredEffectId));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_Skill, ColumnBase::Display_EffectSkill));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_Attribute, ColumnBase::Display_EffectAttribute));
// nested table
PotionColumns potionColumns(inventoryColumns);
mColumns.emplace_back(Columns::ColumnId_EffectList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
potionColumns.mEffects = &mColumns.back(); // see refidadapterimp.hpp
std::map<UniversalId::Type, NestedRefIdAdapterBase*> effectsMap;
effectsMap.insert(
std::make_pair(UniversalId::Type_Potion, new EffectsRefIdAdapter<ESM::Potion>(UniversalId::Type_Potion)));
mNestedAdapters.emplace_back(&mColumns.back(), effectsMap);
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_EffectId, ColumnBase::Display_EffectId));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_Skill, ColumnBase::Display_EffectSkill));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_Attribute, ColumnBase::Display_EffectAttribute));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_EffectRange, ColumnBase::Display_EffectRange));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_EffectArea, ColumnBase::Display_String));
mColumns.back().addColumn(
new NestedChildColumn(Columns::ColumnId_Duration, ColumnBase::Display_Integer)); // reuse from light
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_MinMagnitude, ColumnBase::Display_Integer));
mColumns.back().addColumn(new NestedChildColumn(Columns::ColumnId_MaxMagnitude, ColumnBase::Display_Integer));
EnchantableColumns enchantableColumns(inventoryColumns);
mColumns.emplace_back(Columns::ColumnId_Enchantment, ColumnBase::Display_Enchantment);
enchantableColumns.mEnchantment = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_EnchantmentPoints, ColumnBase::Display_Integer);
enchantableColumns.mEnchantmentPoints = &mColumns.back();
ToolColumns toolsColumns(inventoryColumns);
mColumns.emplace_back(Columns::ColumnId_Quality, ColumnBase::Display_Float);
toolsColumns.mQuality = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Charges, ColumnBase::Display_Integer);
toolsColumns.mUses = &mColumns.back();
ActorColumns actorsColumns(nameColumns);
mColumns.emplace_back(Columns::ColumnId_AiHello, ColumnBase::Display_UnsignedInteger16);
actorsColumns.mHello = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_AiFlee, ColumnBase::Display_UnsignedInteger8);
actorsColumns.mFlee = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_AiFight, ColumnBase::Display_UnsignedInteger8);
actorsColumns.mFight = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_AiAlarm, ColumnBase::Display_UnsignedInteger8);
actorsColumns.mAlarm = &mColumns.back();
// Nested table
mColumns.emplace_back(
Columns::ColumnId_ActorInventory, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
actorsColumns.mInventory = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> inventoryMap;
inventoryMap.insert(
std::make_pair(UniversalId::Type_Npc, new NestedInventoryRefIdAdapter<ESM::NPC>(UniversalId::Type_Npc)));
inventoryMap.insert(std::make_pair(
UniversalId::Type_Creature, new NestedInventoryRefIdAdapter<ESM::Creature>(UniversalId::Type_Creature)));
mNestedAdapters.emplace_back(&mColumns.back(), inventoryMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_InventoryItemId, CSMWorld::ColumnBase::Display_Referenceable));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_ItemCount, CSMWorld::ColumnBase::Display_Integer));
// Nested table
mColumns.emplace_back(Columns::ColumnId_SpellList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
actorsColumns.mSpells = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> spellsMap;
spellsMap.insert(
std::make_pair(UniversalId::Type_Npc, new NestedSpellRefIdAdapter<ESM::NPC>(UniversalId::Type_Npc)));
spellsMap.insert(std::make_pair(
UniversalId::Type_Creature, new NestedSpellRefIdAdapter<ESM::Creature>(UniversalId::Type_Creature)));
mNestedAdapters.emplace_back(&mColumns.back(), spellsMap);
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_SpellId, CSMWorld::ColumnBase::Display_Spell));
// Nested table
mColumns.emplace_back(
Columns::ColumnId_NpcDestinations, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
actorsColumns.mDestinations = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> destMap;
destMap.insert(
std::make_pair(UniversalId::Type_Npc, new NestedTravelRefIdAdapter<ESM::NPC>(UniversalId::Type_Npc)));
destMap.insert(std::make_pair(
UniversalId::Type_Creature, new NestedTravelRefIdAdapter<ESM::Creature>(UniversalId::Type_Creature)));
mNestedAdapters.emplace_back(&mColumns.back(), destMap);
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_DestinationCell, CSMWorld::ColumnBase::Display_Cell));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PosX, CSMWorld::ColumnBase::Display_Float));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PosY, CSMWorld::ColumnBase::Display_Float));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PosZ, CSMWorld::ColumnBase::Display_Float));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_RotX, CSMWorld::ColumnBase::Display_Double));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_RotY, CSMWorld::ColumnBase::Display_Double));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_RotZ, CSMWorld::ColumnBase::Display_Double));
// Nested table
mColumns.emplace_back(Columns::ColumnId_AiPackageList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
actorsColumns.mAiPackages = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> aiMap;
aiMap.insert(std::make_pair(UniversalId::Type_Npc, new ActorAiRefIdAdapter<ESM::NPC>(UniversalId::Type_Npc)));
aiMap.insert(
std::make_pair(UniversalId::Type_Creature, new ActorAiRefIdAdapter<ESM::Creature>(UniversalId::Type_Creature)));
mNestedAdapters.emplace_back(&mColumns.back(), aiMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_AiPackageType, CSMWorld::ColumnBase::Display_AiPackageType));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AiWanderDist, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AiDuration, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AiWanderToD, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle2, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle3, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle4, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle5, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle6, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle7, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle8, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Idle9, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AiWanderRepeat, CSMWorld::ColumnBase::Display_Boolean));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_AiActivateName, CSMWorld::ColumnBase::Display_String32));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AiTargetId, CSMWorld::ColumnBase::Display_String32));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AiTargetCell, CSMWorld::ColumnBase::Display_String));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PosX, CSMWorld::ColumnBase::Display_Float));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PosY, CSMWorld::ColumnBase::Display_Float));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PosZ, CSMWorld::ColumnBase::Display_Float));
static const struct
{
int mName;
unsigned int mFlag;
} sServiceTable[] = { { Columns::ColumnId_BuysWeapons, ESM::NPC::Weapon },
{ Columns::ColumnId_BuysArmor, ESM::NPC::Armor }, { Columns::ColumnId_BuysClothing, ESM::NPC::Clothing },
{ Columns::ColumnId_BuysBooks, ESM::NPC::Books }, { Columns::ColumnId_BuysIngredients, ESM::NPC::Ingredients },
{ Columns::ColumnId_BuysLockpicks, ESM::NPC::Picks }, { Columns::ColumnId_BuysProbes, ESM::NPC::Probes },
{ Columns::ColumnId_BuysLights, ESM::NPC::Lights }, { Columns::ColumnId_BuysApparati, ESM::NPC::Apparatus },
{ Columns::ColumnId_BuysRepairItems, ESM::NPC::RepairItem },
{ Columns::ColumnId_BuysMiscItems, ESM::NPC::Misc }, { Columns::ColumnId_BuysPotions, ESM::NPC::Potions },
{ Columns::ColumnId_BuysMagicItems, ESM::NPC::MagicItems }, { Columns::ColumnId_SellsSpells, ESM::NPC::Spells },
{ Columns::ColumnId_Trainer, ESM::NPC::Training }, { Columns::ColumnId_Spellmaking, ESM::NPC::Spellmaking },
{ Columns::ColumnId_EnchantingService, ESM::NPC::Enchanting },
{ Columns::ColumnId_RepairService, ESM::NPC::Repair }, { -1, 0 } };
for (int i = 0; sServiceTable[i].mName != -1; ++i)
{
mColumns.emplace_back(sServiceTable[i].mName, ColumnBase::Display_Boolean);
actorsColumns.mServices.insert(std::make_pair(&mColumns.back(), sServiceTable[i].mFlag));
}
mColumns.emplace_back(Columns::ColumnId_AutoCalc, ColumnBase::Display_Boolean,
ColumnBase::Flag_Table | ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_Refresh);
const RefIdColumn* autoCalc = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_ApparatusType, ColumnBase::Display_ApparatusType);
const RefIdColumn* apparatusType = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_ArmorType, ColumnBase::Display_ArmorType);
const RefIdColumn* armorType = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Health, ColumnBase::Display_Integer);
const RefIdColumn* health = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_ArmorValue, ColumnBase::Display_Integer);
const RefIdColumn* armor = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_BookType, ColumnBase::Display_BookType);
const RefIdColumn* bookType = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Skill, ColumnBase::Display_SkillId);
const RefIdColumn* skill = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Text, ColumnBase::Display_LongString);
const RefIdColumn* text = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_ClothingType, ColumnBase::Display_ClothingType);
const RefIdColumn* clothingType = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_WeightCapacity, ColumnBase::Display_Float);
const RefIdColumn* weightCapacity = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_OrganicContainer, ColumnBase::Display_Boolean);
const RefIdColumn* organic = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Respawn, ColumnBase::Display_Boolean);
const RefIdColumn* respawn = &mColumns.back();
// Nested table
mColumns.emplace_back(
Columns::ColumnId_ContainerContent, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
const RefIdColumn* content = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> contMap;
contMap.insert(std::make_pair(
UniversalId::Type_Container, new NestedInventoryRefIdAdapter<ESM::Container>(UniversalId::Type_Container)));
mNestedAdapters.emplace_back(&mColumns.back(), contMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_InventoryItemId, CSMWorld::ColumnBase::Display_Referenceable));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_ItemCount, CSMWorld::ColumnBase::Display_Integer));
CreatureColumns creatureColumns(actorsColumns);
mColumns.emplace_back(Columns::ColumnId_CreatureType, ColumnBase::Display_CreatureType);
creatureColumns.mType = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Scale, ColumnBase::Display_Float);
creatureColumns.mScale = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_ParentCreature, ColumnBase::Display_Creature);
creatureColumns.mOriginal = &mColumns.back();
static const struct
{
int mName;
unsigned int mFlag;
} sCreatureFlagTable[] = { { Columns::ColumnId_Biped, ESM::Creature::Bipedal },
{ Columns::ColumnId_HasWeapon, ESM::Creature::Weapon }, { Columns::ColumnId_Swims, ESM::Creature::Swims },
{ Columns::ColumnId_Flies, ESM::Creature::Flies }, { Columns::ColumnId_Walks, ESM::Creature::Walks },
{ Columns::ColumnId_Essential, ESM::Creature::Essential }, { -1, 0 } };
// for re-use in NPC records
const RefIdColumn* essential = nullptr;
for (int i = 0; sCreatureFlagTable[i].mName != -1; ++i)
{
mColumns.emplace_back(sCreatureFlagTable[i].mName, ColumnBase::Display_Boolean);
creatureColumns.mFlags.insert(std::make_pair(&mColumns.back(), sCreatureFlagTable[i].mFlag));
switch (sCreatureFlagTable[i].mFlag)
{
case ESM::Creature::Essential:
essential = &mColumns.back();
break;
}
}
mColumns.emplace_back(Columns::ColumnId_BloodType, ColumnBase::Display_BloodType);
// For re-use in NPC records.
const RefIdColumn* bloodType = &mColumns.back();
creatureColumns.mBloodType = bloodType;
creatureColumns.mFlags.insert(std::make_pair(respawn, ESM::Creature::Respawn));
// Nested table
mColumns.emplace_back(
Columns::ColumnId_CreatureAttributes, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
creatureColumns.mAttributes = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> creaAttrMap;
creaAttrMap.insert(std::make_pair(UniversalId::Type_Creature, new CreatureAttributesRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), creaAttrMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_Attribute, CSMWorld::ColumnBase::Display_Attribute, false, false));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_AttributeValue, CSMWorld::ColumnBase::Display_Integer));
// Nested table
mColumns.emplace_back(
Columns::ColumnId_CreatureAttack, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
creatureColumns.mAttacks = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> attackMap;
attackMap.insert(std::make_pair(UniversalId::Type_Creature, new CreatureAttackRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), attackMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_CreatureAttack, CSMWorld::ColumnBase::Display_Integer, false, false));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_MinAttack, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_MaxAttack, CSMWorld::ColumnBase::Display_Integer));
// Nested list
mColumns.emplace_back(Columns::ColumnId_CreatureMisc, ColumnBase::Display_NestedHeader,
ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_List);
creatureColumns.mMisc = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> creaMiscMap;
creaMiscMap.insert(std::make_pair(UniversalId::Type_Creature, new CreatureMiscRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), creaMiscMap);
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Level, CSMWorld::ColumnBase::Display_Integer,
ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_Refresh));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Health, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Mana, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Fatigue, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_SoulPoints, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_CombatState, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_MagicState, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_StealthState, CSMWorld::ColumnBase::Display_Integer));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Gold, CSMWorld::ColumnBase::Display_Integer));
mColumns.emplace_back(Columns::ColumnId_OpenSound, ColumnBase::Display_Sound);
const RefIdColumn* openSound = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_CloseSound, ColumnBase::Display_Sound);
const RefIdColumn* closeSound = &mColumns.back();
LightColumns lightColumns(inventoryColumns);
mColumns.emplace_back(Columns::ColumnId_Duration, ColumnBase::Display_Integer);
lightColumns.mTime = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Radius, ColumnBase::Display_Integer);
lightColumns.mRadius = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Colour, ColumnBase::Display_Colour);
lightColumns.mColor = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Sound, ColumnBase::Display_Sound);
lightColumns.mSound = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_EmitterType, ColumnBase::Display_EmitterType);
lightColumns.mEmitterType = &mColumns.back();
static const struct
{
int mName;
unsigned int mFlag;
} sLightFlagTable[]
= { { Columns::ColumnId_Dynamic, ESM::Light::Dynamic }, { Columns::ColumnId_Portable, ESM::Light::Carry },
{ Columns::ColumnId_NegativeLight, ESM::Light::Negative }, { Columns::ColumnId_Fire, ESM::Light::Fire },
{ Columns::ColumnId_OffByDefault, ESM::Light::OffDefault }, { -1, 0 } };
for (int i = 0; sLightFlagTable[i].mName != -1; ++i)
{
mColumns.emplace_back(sLightFlagTable[i].mName, ColumnBase::Display_Boolean);
lightColumns.mFlags.insert(std::make_pair(&mColumns.back(), sLightFlagTable[i].mFlag));
}
mColumns.emplace_back(Columns::ColumnId_IsKey, ColumnBase::Display_Boolean);
const RefIdColumn* key = &mColumns.back();
NpcColumns npcColumns(actorsColumns);
mColumns.emplace_back(Columns::ColumnId_Race, ColumnBase::Display_Race);
npcColumns.mRace = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Class, ColumnBase::Display_Class);
npcColumns.mClass = &mColumns.back();
// NAME32 enforced in IdCompletionDelegate::createEditor()
mColumns.emplace_back(Columns::ColumnId_Faction, ColumnBase::Display_Faction);
npcColumns.mFaction = &mColumns.back();
mColumns.emplace_back(Columns::Columnid_Hair, ColumnBase::Display_BodyPart);
npcColumns.mHair = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Head, ColumnBase::Display_BodyPart);
npcColumns.mHead = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_Gender, ColumnBase::Display_GenderNpc);
npcColumns.mGender = &mColumns.back();
npcColumns.mFlags.insert(std::make_pair(essential, ESM::NPC::Essential));
npcColumns.mFlags.insert(std::make_pair(respawn, ESM::NPC::Respawn));
npcColumns.mFlags.insert(std::make_pair(autoCalc, ESM::NPC::Autocalc));
// Re-used from Creature records.
npcColumns.mBloodType = bloodType;
// Need a way to add a table of stats and values (rather than adding a long list of
// entries in the dialogue subview) E.g. attributes+stats(health, mana, fatigue), skills
// These needs to be driven from the autocalculated setting.
// Nested table
mColumns.emplace_back(Columns::ColumnId_NpcAttributes, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
npcColumns.mAttributes = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> attrMap;
attrMap.insert(std::make_pair(UniversalId::Type_Npc, new NpcAttributesRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), attrMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_Attribute, CSMWorld::ColumnBase::Display_Attribute, false, false));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_UChar, CSMWorld::ColumnBase::Display_UnsignedInteger8));
// Nested table
mColumns.emplace_back(Columns::ColumnId_NpcSkills, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
npcColumns.mSkills = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> skillsMap;
skillsMap.insert(std::make_pair(UniversalId::Type_Npc, new NpcSkillsRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), skillsMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_Skill, CSMWorld::ColumnBase::Display_SkillId, false, false));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_UChar, CSMWorld::ColumnBase::Display_UnsignedInteger8));
// Nested list
mColumns.emplace_back(Columns::ColumnId_NpcMisc, ColumnBase::Display_NestedHeader,
ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_List);
npcColumns.mMisc = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> miscMap;
miscMap.insert(std::make_pair(UniversalId::Type_Npc, new NpcMiscRefIdAdapter()));
mNestedAdapters.emplace_back(&mColumns.back(), miscMap);
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Level, CSMWorld::ColumnBase::Display_SignedInteger16));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_Health, CSMWorld::ColumnBase::Display_UnsignedInteger16));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Mana, CSMWorld::ColumnBase::Display_UnsignedInteger16));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_Fatigue, CSMWorld::ColumnBase::Display_UnsignedInteger16));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_NpcDisposition, CSMWorld::ColumnBase::Display_UnsignedInteger8));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_NpcReputation, CSMWorld::ColumnBase::Display_UnsignedInteger8));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_NpcRank, CSMWorld::ColumnBase::Display_UnsignedInteger8));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_Gold, CSMWorld::ColumnBase::Display_Integer));
WeaponColumns weaponColumns(enchantableColumns);
mColumns.emplace_back(Columns::ColumnId_WeaponType, ColumnBase::Display_WeaponType);
weaponColumns.mType = &mColumns.back();
weaponColumns.mHealth = health;
mColumns.emplace_back(Columns::ColumnId_WeaponSpeed, ColumnBase::Display_Float);
weaponColumns.mSpeed = &mColumns.back();
mColumns.emplace_back(Columns::ColumnId_WeaponReach, ColumnBase::Display_Float);
weaponColumns.mReach = &mColumns.back();
for (int i = 0; i < 3; ++i)
{
const RefIdColumn** column
= i == 0 ? weaponColumns.mChop : (i == 1 ? weaponColumns.mSlash : weaponColumns.mThrust);
for (int j = 0; j < 2; ++j)
{
mColumns.emplace_back(Columns::ColumnId_MinChop + i * 2 + j, ColumnBase::Display_Integer);
column[j] = &mColumns.back();
}
}
static const struct
{
int mName;
unsigned int mFlag;
} sWeaponFlagTable[] = { { Columns::ColumnId_Magical, ESM::Weapon::Magical },
{ Columns::ColumnId_Silver, ESM::Weapon::Silver }, { -1, 0 } };
for (int i = 0; sWeaponFlagTable[i].mName != -1; ++i)
{
mColumns.emplace_back(sWeaponFlagTable[i].mName, ColumnBase::Display_Boolean);
weaponColumns.mFlags.insert(std::make_pair(&mColumns.back(), sWeaponFlagTable[i].mFlag));
}
// Nested table
mColumns.emplace_back(Columns::ColumnId_PartRefList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
const RefIdColumn* partRef = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> partMap;
partMap.insert(
std::make_pair(UniversalId::Type_Armor, new BodyPartRefIdAdapter<ESM::Armor>(UniversalId::Type_Armor)));
partMap.insert(std::make_pair(
UniversalId::Type_Clothing, new BodyPartRefIdAdapter<ESM::Clothing>(UniversalId::Type_Clothing)));
mNestedAdapters.emplace_back(&mColumns.back(), partMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_PartRefType, CSMWorld::ColumnBase::Display_PartRefType));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PartRefMale, CSMWorld::ColumnBase::Display_BodyPart));
mColumns.back().addColumn(new RefIdColumn(Columns::ColumnId_PartRefFemale, CSMWorld::ColumnBase::Display_BodyPart));
LevListColumns creatureLevListColumns(baseColumns);
LevListColumns itemLevListColumns(baseColumns);
std::map<UniversalId::Type, NestedRefIdAdapterBase*> creatureLevListMap, itemLevListMap;
creatureLevListMap.insert(std::make_pair(UniversalId::Type_CreatureLevelledList,
new NestedLevListRefIdAdapter<ESM::CreatureLevList>(UniversalId::Type_CreatureLevelledList)));
itemLevListMap.insert(std::make_pair(UniversalId::Type_ItemLevelledList,
new NestedLevListRefIdAdapter<ESM::ItemLevList>(UniversalId::Type_ItemLevelledList)));
// Levelled creature nested table
mColumns.emplace_back(Columns::ColumnId_LevelledList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
creatureLevListColumns.mLevList = &mColumns.back();
mNestedAdapters.emplace_back(&mColumns.back(), creatureLevListMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledCreatureId, CSMWorld::ColumnBase::Display_Referenceable));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledItemLevel, CSMWorld::ColumnBase::Display_Integer));
// Levelled item nested table
mColumns.emplace_back(Columns::ColumnId_LevelledList, ColumnBase::Display_NestedHeader, ColumnBase::Flag_Dialogue);
itemLevListColumns.mLevList = &mColumns.back();
mNestedAdapters.emplace_back(&mColumns.back(), itemLevListMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledItemId, CSMWorld::ColumnBase::Display_Referenceable));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledItemLevel, CSMWorld::ColumnBase::Display_Integer));
// Shared levelled list nested list
mColumns.emplace_back(Columns::ColumnId_LevelledList, ColumnBase::Display_NestedHeader,
ColumnBase::Flag_Dialogue | ColumnBase::Flag_Dialogue_List);
creatureLevListColumns.mNestedListLevList = &mColumns.back();
itemLevListColumns.mNestedListLevList = &mColumns.back();
std::map<UniversalId::Type, NestedRefIdAdapterBase*> nestedListLevListMap;
nestedListLevListMap.insert(std::make_pair(UniversalId::Type_CreatureLevelledList,
new NestedListLevListRefIdAdapter<ESM::CreatureLevList>(UniversalId::Type_CreatureLevelledList)));
nestedListLevListMap.insert(std::make_pair(UniversalId::Type_ItemLevelledList,
new NestedListLevListRefIdAdapter<ESM::ItemLevList>(UniversalId::Type_ItemLevelledList)));
mNestedAdapters.emplace_back(&mColumns.back(), nestedListLevListMap);
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledItemTypeEach, CSMWorld::ColumnBase::Display_Boolean));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledItemType, CSMWorld::ColumnBase::Display_Boolean));
mColumns.back().addColumn(
new RefIdColumn(Columns::ColumnId_LevelledItemChanceNone, CSMWorld::ColumnBase::Display_UnsignedInteger8));
mAdapters.insert(std::make_pair(
UniversalId::Type_Activator, new NameRefIdAdapter<ESM::Activator>(UniversalId::Type_Activator, nameColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_Potion, new PotionRefIdAdapter(potionColumns, autoCalc)));
mAdapters.insert(std::make_pair(UniversalId::Type_Apparatus,
new ApparatusRefIdAdapter(inventoryColumns, apparatusType, toolsColumns.mQuality)));
mAdapters.insert(std::make_pair(
UniversalId::Type_Armor, new ArmorRefIdAdapter(enchantableColumns, armorType, health, armor, partRef)));
mAdapters.insert(
std::make_pair(UniversalId::Type_Book, new BookRefIdAdapter(enchantableColumns, bookType, skill, text)));
mAdapters.insert(std::make_pair(
UniversalId::Type_Clothing, new ClothingRefIdAdapter(enchantableColumns, clothingType, partRef)));
mAdapters.insert(std::make_pair(UniversalId::Type_Container,
new ContainerRefIdAdapter(nameColumns, weightCapacity, organic, respawn, content)));
mAdapters.insert(std::make_pair(UniversalId::Type_Creature, new CreatureRefIdAdapter(creatureColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_Door, new DoorRefIdAdapter(nameColumns, openSound, closeSound)));
mAdapters.insert(std::make_pair(UniversalId::Type_Ingredient, new IngredientRefIdAdapter(ingredientColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_CreatureLevelledList,
new LevelledListRefIdAdapter<ESM::CreatureLevList>(
UniversalId::Type_CreatureLevelledList, creatureLevListColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_ItemLevelledList,
new LevelledListRefIdAdapter<ESM::ItemLevList>(UniversalId::Type_ItemLevelledList, itemLevListColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_Light, new LightRefIdAdapter(lightColumns)));
mAdapters.insert(std::make_pair(
UniversalId::Type_Lockpick, new ToolRefIdAdapter<ESM::Lockpick>(UniversalId::Type_Lockpick, toolsColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_Miscellaneous, new MiscRefIdAdapter(inventoryColumns, key)));
mAdapters.insert(std::make_pair(UniversalId::Type_Npc, new NpcRefIdAdapter(npcColumns)));
mAdapters.insert(std::make_pair(
UniversalId::Type_Probe, new ToolRefIdAdapter<ESM::Probe>(UniversalId::Type_Probe, toolsColumns)));
mAdapters.insert(std::make_pair(
UniversalId::Type_Repair, new ToolRefIdAdapter<ESM::Repair>(UniversalId::Type_Repair, toolsColumns)));
mAdapters.insert(std::make_pair(
UniversalId::Type_Static, new ModelRefIdAdapter<ESM::Static>(UniversalId::Type_Static, modelColumns)));
mAdapters.insert(std::make_pair(UniversalId::Type_Weapon, new WeaponRefIdAdapter(weaponColumns)));
}
CSMWorld::RefIdCollection::~RefIdCollection()
{
for (std::map<UniversalId::Type, RefIdAdapter*>::iterator iter(mAdapters.begin()); iter != mAdapters.end(); ++iter)
delete iter->second;
for (std::vector<std::pair<const ColumnBase*, std::map<UniversalId::Type, NestedRefIdAdapterBase*>>>::iterator iter(
mNestedAdapters.begin());
iter != mNestedAdapters.end(); ++iter)
{
for (std::map<UniversalId::Type, NestedRefIdAdapterBase*>::iterator it((iter->second).begin());
it != (iter->second).end(); ++it)
delete it->second;
}
}
int CSMWorld::RefIdCollection::getSize() const
{
return mData.getSize();
}
ESM::RefId CSMWorld::RefIdCollection::getId(int index) const
{
return ESM::RefId::stringRefId(getData(index, 0).toString().toUtf8().constData());
}
int CSMWorld::RefIdCollection::getIndex(const ESM::RefId& id) const
{
int index = searchId(id);
if (index == -1)
throw std::runtime_error("ID is not found in RefId collection: " + id.toDebugString());
return index;
}
int CSMWorld::RefIdCollection::getColumns() const
{
return mColumns.size();
}
const CSMWorld::ColumnBase& CSMWorld::RefIdCollection::getColumn(int column) const
{
return mColumns.at(column);
}
QVariant CSMWorld::RefIdCollection::getData(int index, int column) const
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(index);
const RefIdAdapter& adaptor = findAdapter(localIndex.second);
return adaptor.getData(&mColumns.at(column), mData, localIndex.first);
}
QVariant CSMWorld::RefIdCollection::getNestedData(int row, int column, int subRow, int subColumn) const
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
return nestedAdapter.getNestedData(&mColumns.at(column), mData, localIndex.first, subRow, subColumn);
}
void CSMWorld::RefIdCollection::setData(int index, int column, const QVariant& data)
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(index);
const RefIdAdapter& adaptor = findAdapter(localIndex.second);
adaptor.setData(&mColumns.at(column), mData, localIndex.first, data);
}
void CSMWorld::RefIdCollection::setNestedData(int row, int column, const QVariant& data, int subRow, int subColumn)
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
nestedAdapter.setNestedData(&mColumns.at(column), mData, localIndex.first, data, subRow, subColumn);
}
void CSMWorld::RefIdCollection::removeRows(int index, int count)
{
mData.erase(index, count);
}
void CSMWorld::RefIdCollection::removeNestedRows(int row, int column, int subRow)
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
nestedAdapter.removeNestedRow(&mColumns.at(column), mData, localIndex.first, subRow);
}
void CSMWorld::RefIdCollection::appendBlankRecord(const ESM::RefId& id, UniversalId::Type type)
{
mData.appendRecord(type, id, false);
}
int CSMWorld::RefIdCollection::searchId(const ESM::RefId& id) const
{
const RefIdData::LocalIndex localIndex = mData.searchId(id);
if (localIndex.first == -1)
return -1;
return mData.localToGlobalIndex(localIndex);
}
void CSMWorld::RefIdCollection::replace(int index, std::unique_ptr<RecordBase> record)
{
mData.getRecord(mData.globalToLocalIndex(index)).assign(*record.release());
}
void CSMWorld::RefIdCollection::cloneRecord(
const ESM::RefId& origin, const ESM::RefId& destination, const CSMWorld::UniversalId::Type type)
{
std::unique_ptr<RecordBase> newRecord = mData.getRecord(mData.searchId(origin)).modifiedCopy();
auto adapter = mAdapters.find(type);
assert(adapter != mAdapters.end());
adapter->second->setId(*newRecord, destination.getRefIdString());
mData.insertRecord(std::move(newRecord), type, destination);
}
bool CSMWorld::RefIdCollection::touchRecord(const ESM::RefId& id)
{
throw std::runtime_error("RefIdCollection::touchRecord is unimplemented");
return false;
}
void CSMWorld::RefIdCollection::appendRecord(std::unique_ptr<RecordBase> record, UniversalId::Type type)
{
auto id = findAdapter(type).getId(*record.get());
int index = mData.getAppendIndex(type);
mData.appendRecord(type, id, false);
mData.getRecord(mData.globalToLocalIndex(index)).assign(*record.release());
}
const CSMWorld::RecordBase& CSMWorld::RefIdCollection::getRecord(const ESM::RefId& id) const
{
return mData.getRecord(mData.searchId(id));
}
const CSMWorld::RecordBase& CSMWorld::RefIdCollection::getRecord(int index) const
{
return mData.getRecord(mData.globalToLocalIndex(index));
}
void CSMWorld::RefIdCollection::load(ESM::ESMReader& reader, bool base, UniversalId::Type type)
{
mData.load(reader, base, type);
}
int CSMWorld::RefIdCollection::getAppendIndex(const ESM::RefId& id, UniversalId::Type type) const
{
return mData.getAppendIndex(type);
}
std::vector<ESM::RefId> CSMWorld::RefIdCollection::getIds(bool listDeleted) const
{
return mData.getIds(listDeleted);
}
bool CSMWorld::RefIdCollection::reorderRows(int baseIndex, const std::vector<int>& newOrder)
{
return false;
}
void CSMWorld::RefIdCollection::save(int index, ESM::ESMWriter& writer) const
{
mData.save(index, writer);
}
const CSMWorld::RefIdData& CSMWorld::RefIdCollection::getDataSet() const
{
return mData;
}
int CSMWorld::RefIdCollection::getNestedRowsCount(int row, int column) const
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
return nestedAdapter.getNestedRowsCount(&mColumns.at(column), mData, localIndex.first);
}
int CSMWorld::RefIdCollection::getNestedColumnsCount(int row, int column) const
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
return nestedAdapter.getNestedColumnsCount(&mColumns.at(column), mData);
}
CSMWorld::NestableColumn* CSMWorld::RefIdCollection::getNestableColumn(int column)
{
return &mColumns.at(column);
}
void CSMWorld::RefIdCollection::addNestedRow(int row, int col, int position)
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(col), localIndex.second);
nestedAdapter.addNestedRow(&mColumns.at(col), mData, localIndex.first, position);
}
void CSMWorld::RefIdCollection::setNestedTable(int row, int column, const CSMWorld::NestedTableWrapperBase& nestedTable)
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
nestedAdapter.setNestedTable(&mColumns.at(column), mData, localIndex.first, nestedTable);
}
CSMWorld::NestedTableWrapperBase* CSMWorld::RefIdCollection::nestedTable(int row, int column) const
{
RefIdData::LocalIndex localIndex = mData.globalToLocalIndex(row);
const CSMWorld::NestedRefIdAdapterBase& nestedAdapter = getNestedAdapter(mColumns.at(column), localIndex.second);
return nestedAdapter.nestedTable(&mColumns.at(column), mData, localIndex.first);
}
const CSMWorld::NestedRefIdAdapterBase& CSMWorld::RefIdCollection::getNestedAdapter(
const CSMWorld::ColumnBase& column, UniversalId::Type type) const
{
for (std::vector<std::pair<const ColumnBase*, std::map<UniversalId::Type, NestedRefIdAdapterBase*>>>::const_iterator
iter(mNestedAdapters.begin());
iter != mNestedAdapters.end(); ++iter)
{
if ((iter->first) == &column)
{
std::map<UniversalId::Type, NestedRefIdAdapterBase*>::const_iterator it = (iter->second).find(type);
if (it == (iter->second).end())
throw std::runtime_error("No such type in the nestedadapters");
return *it->second;
}
}
throw std::runtime_error("No such column in the nestedadapters");
}
void CSMWorld::RefIdCollection::copyTo(int index, RefIdCollection& target) const
{
mData.copyTo(index, target.mData);
}
| 44,511
|
C++
|
.cpp
| 723
| 56.320885
| 120
| 0.756652
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,910
|
commandmacro.cpp
|
OpenMW_openmw/apps/opencs/model/world/commandmacro.cpp
|
#include "commandmacro.hpp"
#include <QUndoCommand>
#include <QUndoStack>
CSMWorld::CommandMacro::CommandMacro(QUndoStack& undoStack, const QString& description)
: mUndoStack(undoStack)
, mDescription(description)
, mStarted(false)
{
}
CSMWorld::CommandMacro::~CommandMacro()
{
if (mStarted)
mUndoStack.endMacro();
}
void CSMWorld::CommandMacro::push(QUndoCommand* command)
{
if (!mStarted)
{
mUndoStack.beginMacro(mDescription.isEmpty() ? command->text() : mDescription);
mStarted = true;
}
mUndoStack.push(command);
}
| 582
|
C++
|
.cpp
| 23
| 21.608696
| 87
| 0.721519
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
34,911
|
actoradapter.cpp
|
OpenMW_openmw/apps/opencs/model/world/actoradapter.cpp
|
#include "actoradapter.hpp"
#include <QModelIndex>
#include <algorithm>
#include <string>
#include <string_view>
#include <vector>
#include <apps/opencs/model/prefs/state.hpp>
#include <apps/opencs/model/world/columns.hpp>
#include <apps/opencs/model/world/idcollection.hpp>
#include <apps/opencs/model/world/record.hpp>
#include <apps/opencs/model/world/refidcollection.hpp>
#include <apps/opencs/model/world/universalid.hpp>
#include <components/esm3/loadarmo.hpp>
#include <components/esm3/loadclot.hpp>
#include <components/esm3/loadcont.hpp>
#include <components/esm3/loadcrea.hpp>
#include <components/esm3/loadnpc.hpp>
#include <components/esm3/loadrace.hpp>
#include <components/esm3/mappings.hpp>
#include <components/settings/settings.hpp>
#include "data.hpp"
namespace CSMWorld
{
const ESM::RefId& ActorAdapter::RaceData::getId() const
{
return mId;
}
bool ActorAdapter::RaceData::isBeast() const
{
return mIsBeast;
}
ActorAdapter::RaceData::RaceData()
{
mIsBeast = false;
}
bool ActorAdapter::RaceData::handlesPart(ESM::PartReferenceType type) const
{
switch (type)
{
case ESM::PRT_Skirt:
case ESM::PRT_Shield:
case ESM::PRT_RPauldron:
case ESM::PRT_LPauldron:
case ESM::PRT_Weapon:
return false;
default:
return true;
}
}
const ESM::RefId& ActorAdapter::RaceData::getFemalePart(ESM::PartReferenceType index) const
{
return mFemaleParts[ESM::getMeshPart(index)];
}
const ESM::RefId& ActorAdapter::RaceData::getMalePart(ESM::PartReferenceType index) const
{
return mMaleParts[ESM::getMeshPart(index)];
}
const osg::Vec2f& ActorAdapter::RaceData::getGenderWeightHeight(bool isFemale)
{
return isFemale ? mWeightsHeights.mFemaleWeightHeight : mWeightsHeights.mMaleWeightHeight;
}
bool ActorAdapter::RaceData::hasDependency(const ESM::RefId& id) const
{
return mDependencies.find(id) != mDependencies.end();
}
void ActorAdapter::RaceData::setFemalePart(ESM::BodyPart::MeshPart index, const ESM::RefId& partId)
{
mFemaleParts[index] = partId;
addOtherDependency(partId);
}
void ActorAdapter::RaceData::setMalePart(ESM::BodyPart::MeshPart index, const ESM::RefId& partId)
{
mMaleParts[index] = partId;
addOtherDependency(partId);
}
void ActorAdapter::RaceData::addOtherDependency(const ESM::RefId& id)
{
if (!id.empty())
mDependencies.emplace(id);
}
void ActorAdapter::RaceData::reset_data(const ESM::RefId& id, const WeightsHeights& raceStats, bool isBeast)
{
mId = id;
mIsBeast = isBeast;
mWeightsHeights = raceStats;
for (auto& str : mFemaleParts)
str = ESM::RefId();
for (auto& str : mMaleParts)
str = ESM::RefId();
mDependencies.clear();
// Mark self as a dependency
addOtherDependency(id);
}
ActorAdapter::ActorData::ActorData()
{
mCreature = false;
mFemale = false;
}
const ESM::RefId& ActorAdapter::ActorData::getId() const
{
return mId;
}
bool ActorAdapter::ActorData::isCreature() const
{
return mCreature;
}
bool ActorAdapter::ActorData::isFemale() const
{
return mFemale;
}
std::string ActorAdapter::ActorData::getSkeleton() const
{
if (mCreature || !mSkeletonOverride.empty())
return "meshes\\" + mSkeletonOverride;
bool beast = mRaceData ? mRaceData->isBeast() : false;
if (beast)
return CSMPrefs::get()["Models"]["baseanimkna"].toString();
else if (mFemale)
return CSMPrefs::get()["Models"]["baseanimfemale"].toString();
else
return CSMPrefs::get()["Models"]["baseanim"].toString();
}
ESM::RefId ActorAdapter::ActorData::getPart(ESM::PartReferenceType index) const
{
auto it = mParts.find(index);
if (it == mParts.end())
{
if (mRaceData && mRaceData->handlesPart(index))
{
if (mFemale)
{
// Note: we should use male parts for females as fallback
if (const ESM::RefId femalePart = mRaceData->getFemalePart(index); !femalePart.empty())
return femalePart;
}
return mRaceData->getMalePart(index);
}
return {};
}
return it->second.first;
}
const osg::Vec2f& ActorAdapter::ActorData::getRaceWeightHeight() const
{
return mRaceData->getGenderWeightHeight(isFemale());
}
bool ActorAdapter::ActorData::hasDependency(const ESM::RefId& id) const
{
return mDependencies.find(id) != mDependencies.end();
}
void ActorAdapter::ActorData::setPart(ESM::PartReferenceType index, const ESM::RefId& partId, int priority)
{
auto it = mParts.find(index);
if (it != mParts.end())
{
if (it->second.second >= priority)
return;
}
mParts[index] = std::make_pair(partId, priority);
addOtherDependency(partId);
}
void ActorAdapter::ActorData::addOtherDependency(const ESM::RefId& id)
{
if (!id.empty())
mDependencies.emplace(id);
}
void ActorAdapter::ActorData::reset_data(
const ESM::RefId& id, const std::string& skeleton, bool isCreature, bool isFemale, RaceDataPtr raceData)
{
mId = id;
mCreature = isCreature;
mFemale = isFemale;
mSkeletonOverride = skeleton;
mRaceData = raceData;
mParts.clear();
mDependencies.clear();
// Mark self and race as a dependency
addOtherDependency(id);
if (raceData)
addOtherDependency(raceData->getId());
}
ActorAdapter::ActorAdapter(Data& data)
: mReferenceables(data.getReferenceables())
, mRaces(data.getRaces())
, mBodyParts(data.getBodyParts())
{
// Setup qt slots and signals
QAbstractItemModel* refModel = data.getTableModel(UniversalId::Type_Referenceable);
connect(refModel, &QAbstractItemModel::rowsInserted, this, &ActorAdapter::handleReferenceablesInserted);
connect(refModel, &QAbstractItemModel::dataChanged, this, &ActorAdapter::handleReferenceableChanged);
connect(refModel, &QAbstractItemModel::rowsAboutToBeRemoved, this,
&ActorAdapter::handleReferenceablesAboutToBeRemoved);
QAbstractItemModel* raceModel = data.getTableModel(UniversalId::Type_Race);
connect(raceModel, &QAbstractItemModel::rowsInserted, this, &ActorAdapter::handleRacesAboutToBeRemoved);
connect(raceModel, &QAbstractItemModel::dataChanged, this, &ActorAdapter::handleRaceChanged);
connect(raceModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &ActorAdapter::handleRacesAboutToBeRemoved);
QAbstractItemModel* partModel = data.getTableModel(UniversalId::Type_BodyPart);
connect(partModel, &QAbstractItemModel::rowsInserted, this, &ActorAdapter::handleBodyPartsInserted);
connect(partModel, &QAbstractItemModel::dataChanged, this, &ActorAdapter::handleBodyPartChanged);
connect(
partModel, &QAbstractItemModel::rowsAboutToBeRemoved, this, &ActorAdapter::handleBodyPartsAboutToBeRemoved);
}
ActorAdapter::ActorDataPtr ActorAdapter::getActorData(const ESM::RefId& id)
{
// Return cached actor data if it exists
ActorDataPtr data = mCachedActors.get(id);
if (data)
{
return data;
}
// Create the actor data
data = std::make_shared<ActorData>();
setupActor(id, data);
mCachedActors.insert(id, data);
return data;
}
void ActorAdapter::handleReferenceablesInserted(const QModelIndex& parent, int start, int end)
{
// Only rows added at the top level are pertinent. Others are caught by dataChanged handler.
if (!parent.isValid())
{
for (int row = start; row <= end; ++row)
{
auto refId = mReferenceables.getId(row);
markDirtyDependency(refId);
}
}
// Update affected
updateDirty();
}
void ActorAdapter::handleReferenceableChanged(const QModelIndex& topLeft, const QModelIndex& botRight)
{
int start = getHighestIndex(topLeft).row();
int end = getHighestIndex(botRight).row();
// A change to record status (ex. Deleted) returns an invalid botRight
if (end == -1)
end = start;
// Handle each record
for (int row = start; row <= end; ++row)
{
auto refId = mReferenceables.getId(row);
markDirtyDependency(refId);
}
// Update affected
updateDirty();
}
void ActorAdapter::handleReferenceablesAboutToBeRemoved(const QModelIndex& parent, int start, int end)
{
// Only rows at the top are pertinent.
if (!parent.isValid())
{
for (int row = start; row <= end; ++row)
{
auto refId = mReferenceables.getId(row);
markDirtyDependency(refId);
}
}
}
void ActorAdapter::handleReferenceablesRemoved(const QModelIndex& parent, int start, int end)
{
// Changes specified in handleReferenceablesAboutToBeRemoved
updateDirty();
}
void ActorAdapter::handleRacesInserted(const QModelIndex& parent, int start, int end)
{
// Only rows added at the top are pertinent.
if (!parent.isValid())
{
for (int row = start; row <= end; ++row)
{
auto raceId = mReferenceables.getId(row);
markDirtyDependency(raceId);
}
}
// Update affected
updateDirty();
}
void ActorAdapter::handleRaceChanged(const QModelIndex& topLeft, const QModelIndex& botRight)
{
int start = getHighestIndex(topLeft).row();
int end = getHighestIndex(botRight).row();
// A change to record status (ex. Deleted) returns an invalid botRight
if (end == -1)
end = start;
for (int row = start; row <= end; ++row)
{
auto raceId = mRaces.getId(row);
markDirtyDependency(raceId);
}
// Update affected
updateDirty();
}
void ActorAdapter::handleRacesAboutToBeRemoved(const QModelIndex& parent, int start, int end)
{
// Only changes at the top are pertinent.
if (!parent.isValid())
{
for (int row = start; row <= end; ++row)
{
auto raceId = mRaces.getId(row);
markDirtyDependency(raceId);
}
}
}
void ActorAdapter::handleRacesRemoved(const QModelIndex& parent, int start, int end)
{
// Changes specified in handleRacesAboutToBeRemoved
updateDirty();
}
void ActorAdapter::handleBodyPartsInserted(const QModelIndex& parent, int start, int end)
{
// Only rows added at the top are pertinent.
if (!parent.isValid())
{
for (int row = start; row <= end; ++row)
{
// Race specified by part may need update
auto& record = mBodyParts.getRecord(row);
if (!record.isDeleted())
{
markDirtyDependency(record.get().mRace);
}
auto partId = mBodyParts.getId(row);
markDirtyDependency(partId);
}
}
// Update affected
updateDirty();
}
void ActorAdapter::handleBodyPartChanged(const QModelIndex& topLeft, const QModelIndex& botRight)
{
int start = getHighestIndex(topLeft).row();
int end = getHighestIndex(botRight).row();
// A change to record status (ex. Deleted) returns an invalid botRight
if (end == -1)
end = start;
for (int row = start; row <= end; ++row)
{
// Race specified by part may need update
auto& record = mBodyParts.getRecord(row);
if (!record.isDeleted())
{
markDirtyDependency(record.get().mRace);
}
// Update entries with a tracked dependency
auto partId = mBodyParts.getId(row);
markDirtyDependency(partId);
}
// Update affected
updateDirty();
}
void ActorAdapter::handleBodyPartsAboutToBeRemoved(const QModelIndex& parent, int start, int end)
{
// Only changes at the top are pertinent.
if (!parent.isValid())
{
for (int row = start; row <= end; ++row)
{
auto partId = mBodyParts.getId(row);
markDirtyDependency(partId);
}
}
}
void ActorAdapter::handleBodyPartsRemoved(const QModelIndex& parent, int start, int end)
{
// Changes specified in handleBodyPartsAboutToBeRemoved
updateDirty();
}
QModelIndex ActorAdapter::getHighestIndex(QModelIndex index) const
{
while (index.parent().isValid())
index = index.parent();
return index;
}
ActorAdapter::RaceDataPtr ActorAdapter::getRaceData(const ESM::RefId& id)
{
// Return cached race data if it exists
RaceDataPtr data = mCachedRaces.get(id);
if (data)
return data;
// Create the race data
data = std::make_shared<RaceData>();
setupRace(id, data);
mCachedRaces.insert(id, data);
return data;
}
void ActorAdapter::setupActor(const ESM::RefId& id, ActorDataPtr data)
{
int index = mReferenceables.searchId(id);
if (index == -1)
{
// Record does not exist
data->reset_data(id);
emit actorChanged(id);
return;
}
auto& record = mReferenceables.getRecord(index);
if (record.isDeleted())
{
// Record is deleted and therefore not accessible
data->reset_data(id);
emit actorChanged(id);
return;
}
const int TypeColumn = mReferenceables.findColumnIndex(Columns::ColumnId_RecordType);
int type = mReferenceables.getData(index, TypeColumn).toInt();
if (type == UniversalId::Type_Creature)
{
// Valid creature record
setupCreature(id, std::move(data));
emit actorChanged(id);
}
else if (type == UniversalId::Type_Npc)
{
// Valid npc record
setupNpc(id, std::move(data));
emit actorChanged(id);
}
else
{
// Wrong record type
data->reset_data(id);
emit actorChanged(id);
}
}
void ActorAdapter::setupRace(const ESM::RefId& id, RaceDataPtr data)
{
int index = mRaces.searchId(id);
if (index == -1)
{
// Record does not exist
data->reset_data(id);
return;
}
auto& raceRecord = mRaces.getRecord(index);
if (raceRecord.isDeleted())
{
// Record is deleted, so not accessible
data->reset_data(id);
return;
}
auto& race = raceRecord.get();
WeightsHeights scaleStats = { osg::Vec2f(race.mData.mMaleWeight, race.mData.mMaleHeight),
osg::Vec2f(race.mData.mFemaleWeight, race.mData.mFemaleHeight) };
data->reset_data(id, scaleStats, race.mData.mFlags & ESM::Race::Beast);
// Setup body parts
for (int i = 0; i < mBodyParts.getSize(); ++i)
{
auto& partRecord = mBodyParts.getRecord(i);
if (partRecord.isDeleted())
{
// Record is deleted, so not accessible.
continue;
}
auto& part = partRecord.get();
if (part.mRace == id && part.mData.mType == ESM::BodyPart::MT_Skin && !ESM::isFirstPersonBodyPart(part))
{
auto type = (ESM::BodyPart::MeshPart)part.mData.mPart;
bool female = part.mData.mFlags & ESM::BodyPart::BPF_Female;
if (female)
data->setFemalePart(type, part.mId);
else
data->setMalePart(type, part.mId);
}
}
}
void ActorAdapter::setupNpc(const ESM::RefId& id, ActorDataPtr data)
{
// Common setup, record is known to exist and is not deleted
int index = mReferenceables.searchId(id);
auto& npc = dynamic_cast<const Record<ESM::NPC>&>(mReferenceables.getRecord(index)).get();
RaceDataPtr raceData = getRaceData(npc.mRace);
data->reset_data(id, "", false, !npc.isMale(), std::move(raceData));
// Add head and hair
data->setPart(ESM::PRT_Head, npc.mHead, 0);
data->setPart(ESM::PRT_Hair, npc.mHair, 0);
// Add inventory items
for (auto& item : npc.mInventory.mList)
{
if (item.mCount <= 0)
continue;
auto itemId = item.mItem;
addNpcItem(itemId, data);
}
}
void ActorAdapter::addNpcItem(const ESM::RefId& itemId, ActorDataPtr data)
{
int index = mReferenceables.searchId(itemId);
if (index == -1)
{
// Item does not exist yet
data->addOtherDependency(itemId);
return;
}
auto& record = mReferenceables.getRecord(index);
if (record.isDeleted())
{
// Item cannot be accessed yet
data->addOtherDependency(itemId);
return;
}
// Convenience function to add a parts list to actor data
auto addParts = [&](const std::vector<ESM::PartReference>& list, int priority) {
for (auto& part : list)
{
ESM::RefId partId;
auto partType = (ESM::PartReferenceType)part.mPart;
if (data->isFemale())
partId = part.mFemale;
if (partId.empty())
partId = part.mMale;
data->setPart(partType, partId, priority);
// An another vanilla quirk: hide hairs if an item replaces Head part
if (partType == ESM::PRT_Head)
data->setPart(ESM::PRT_Hair, ESM::RefId(), priority);
}
};
int TypeColumn = mReferenceables.findColumnIndex(Columns::ColumnId_RecordType);
int type = mReferenceables.getData(index, TypeColumn).toInt();
if (type == UniversalId::Type_Armor)
{
auto& armor = dynamic_cast<const Record<ESM::Armor>&>(record).get();
addParts(armor.mParts.mParts, 1);
// Changing parts could affect what is picked for rendering
data->addOtherDependency(itemId);
}
else if (type == UniversalId::Type_Clothing)
{
auto& clothing = dynamic_cast<const Record<ESM::Clothing>&>(record).get();
std::vector<ESM::PartReferenceType> parts;
if (clothing.mData.mType == ESM::Clothing::Robe)
{
parts = { ESM::PRT_Groin, ESM::PRT_Skirt, ESM::PRT_RLeg, ESM::PRT_LLeg, ESM::PRT_RUpperarm,
ESM::PRT_LUpperarm, ESM::PRT_RKnee, ESM::PRT_LKnee, ESM::PRT_RForearm, ESM::PRT_LForearm,
ESM::PRT_Cuirass };
}
else if (clothing.mData.mType == ESM::Clothing::Skirt)
{
parts = { ESM::PRT_Groin, ESM::PRT_RLeg, ESM::PRT_LLeg };
}
std::vector<ESM::PartReference> reservedList;
for (const auto& p : parts)
{
ESM::PartReference pr;
pr.mPart = p;
reservedList.emplace_back(pr);
}
int priority = parts.size();
addParts(clothing.mParts.mParts, priority);
addParts(reservedList, priority);
// Changing parts could affect what is picked for rendering
data->addOtherDependency(itemId);
}
}
void ActorAdapter::setupCreature(const ESM::RefId& id, ActorDataPtr data)
{
// Record is known to exist and is not deleted
int index = mReferenceables.searchId(id);
auto& creature = dynamic_cast<const Record<ESM::Creature>&>(mReferenceables.getRecord(index)).get();
data->reset_data(id, creature.mModel, true);
}
void ActorAdapter::markDirtyDependency(const ESM::RefId& dep)
{
for (auto raceIt : mCachedRaces)
{
if (raceIt->hasDependency(dep))
mDirtyRaces.emplace(raceIt->getId());
}
for (auto actorIt : mCachedActors)
{
if (actorIt->hasDependency(dep))
mDirtyActors.emplace(actorIt->getId());
}
}
void ActorAdapter::updateDirty()
{
// Handle races before actors, since actors are dependent on race
for (auto& race : mDirtyRaces)
{
RaceDataPtr data = mCachedRaces.get(race);
if (data)
{
setupRace(race, std::move(data));
// Race was changed. Need to mark actor dependencies as dirty.
// Cannot use markDirtyDependency because that would invalidate
// the current iterator.
for (auto actorIt : mCachedActors)
{
if (actorIt->hasDependency(race))
mDirtyActors.emplace(actorIt->getId());
}
}
}
mDirtyRaces.clear();
for (auto& actor : mDirtyActors)
{
ActorDataPtr data = mCachedActors.get(actor);
if (data)
{
setupActor(actor, std::move(data));
}
}
mDirtyActors.clear();
}
}
| 22,364
|
C++
|
.cpp
| 604
| 27.221854
| 120
| 0.590775
|
OpenMW/openmw
| 5,318
| 933
| 0
|
GPL-3.0
|
9/20/2024, 9:26:25 PM (Europe/Amsterdam)
| false
| false
| false
| false
| false
| false
| false
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.