Archive/TombEngine
0
0
Fork 0
mirror of https://github.com/TombEngine/TombEngine.git synced 2025-04-28 15:57:59 +03:00
Code Issues Projects Releases Packages Wiki Activity Actions

Revert "Add functional Scale field to Pose class"

Browse source 
This reverts commit 62bf124830.
This commit is contained in:
Sezz 2024-12-30 22:04:27 +11:00
parent 62bf124830
commit 92305a5d25
14 changed files with 563 additions and 535 deletions
Download patch file Download diff file Expand all files Collapse all files

30
TombEngine/Game/Lara/lara.cpp
View file

@ -67,36 +67,6 @@ void LaraControl(ItemInfo* item, CollisionInfo* coll)
{
auto& player = GetLaraInfo(*item);
static float time = 0.0f;
static float oscillationRange = 0.0f;
static float centerValue = 1.0f;
if (IsClicked(In::Action))
{
oscillationRange = 0.4f;
time = 0.0f;
}
// Calculate the scale based on sine wave
float oscillation = (sin(time) * 0.5f + 0.5f) * oscillationRange;
item->Pose.Scale.y = centerValue - oscillation;
item->Pose.Scale.x = centerValue + oscillation;
item->Pose.Scale.z = centerValue + oscillation;
time += 0.5f;
if (time > PI_MUL_2)
time -= PI_MUL_2;
oscillationRange *= 0.96f;
/*auto delta = AxisMap[(int)InputAxis::Mouse].y;
item->Pose.Scale.y = std::max(item->Pose.Scale.y + delta, 0.01f);
if (item->Pose.Scale.y != 0.01f)
{
item->Pose.Scale.x -= delta;
item->Pose.Scale.z -= delta;
}*/
// Alert nearby creatures.
if (player.Control.Weapon.HasFired)
{

4
TombEngine/Game/Lara/lara_one_gun.cpp
View file

@ -1084,7 +1084,7 @@ void FireCrossbow(ItemInfo& laraItem, const std::optional<Pose>& pose)
void FireCrossBowFromLaserSight(ItemInfo& laraItem, GameVector* origin, GameVector* target)
{
auto orient = Geometry::GetOrientToPoint(origin->ToVector3(), target->ToVector3());
auto boltPose = Pose(origin->ToVector3i(), orient);
auto boltPose = Pose(origin->x, origin->y, origin->z, orient);
FireCrossbow(laraItem, boltPose);
}
@ -1584,7 +1584,7 @@ void HandleProjectile(ItemInfo& projectile, ItemInfo& emitter, const Vector3i& p
continue;
TriggerExplosionSparks(staticPtr->pos.Position.x, staticPtr->pos.Position.y, staticPtr->pos.Position.z, 3, -2, 0, projectile.RoomNumber);
auto pose = Pose(Vector3i(staticPtr->pos.Position.x, staticPtr->pos.Position.y - 128, staticPtr->pos.Position.z), EulerAngles(0, staticPtr->pos.Orientation.y, 0));
auto pose = Pose(staticPtr->pos.Position.x, staticPtr->pos.Position.y - 128, staticPtr->pos.Position.z, 0, staticPtr->pos.Orientation.y, 0);
TriggerShockwave(&pose, 40, 176, 64, 0, 96, 128, 16, EulerAngles::Identity, 0, true, false, false, (int)ShockwaveStyle::Normal);
}

52
TombEngine/Game/savegame.cpp
View file

@ -89,91 +89,99 @@ void SaveGame::LoadHeaders()
}
}
static Save::EulerAngles FromEulerAngles(const EulerAngles& eulers)
Save::Pose FromPose(const Pose& pose)
{
return Save::Pose(
pose.Position.x,
pose.Position.y,
pose.Position.z,
pose.Orientation.x,
pose.Orientation.y,
pose.Orientation.z);
}
Save::EulerAngles FromEulerAngles(const EulerAngles& eulers)
{
return Save::EulerAngles(eulers.x, eulers.y, eulers.z);
}
static Save::Vector2 FromVector2(const Vector2& vec)
Save::Vector2 FromVector2(const Vector2& vec)
{
return Save::Vector2(vec.x, vec.y);
}
static Save::Vector2 FromVector2i(const Vector2i& vec)
Save::Vector2 FromVector2i(const Vector2i& vec)
{
return Save::Vector2(vec.x, vec.y);
}
static Save::Vector3 FromVector3(const Vector3& vec)
Save::Vector3 FromVector3(const Vector3& vec)
{
return Save::Vector3(vec.x, vec.y, vec.z);
}
static Save::Vector3 FromVector3i(const Vector3i& vec)
Save::Vector3 FromVector3i(const Vector3i& vec)
{
return Save::Vector3(vec.x, vec.y, vec.z);
}
static Save::Vector4 FromVector4(const Vector4& vec)
Save::Vector4 FromVector4(const Vector4& vec)
{
return Save::Vector4(vec.x, vec.y, vec.z, vec.w);
}
static Save::GameVector FromGameVector(const GameVector& vec)
Save::GameVector FromGameVector(const GameVector& vec)
{
return Save::GameVector(vec.x, vec.y, vec.z, (int)vec.RoomNumber);
}
static Save::Pose FromPose(const Pose& pose)
Pose ToPose(const Save::Pose& pose)
{
return Save::Pose(FromVector3i(pose.Position), FromEulerAngles(pose.Orientation), FromVector3(pose.Scale));
return Pose(
pose.x_pos(), pose.y_pos(), pose.z_pos(),
(short)pose.x_rot(), (short)pose.y_rot(), (short)pose.z_rot());
}
static EulerAngles ToEulerAngles(const Save::EulerAngles* eulers)
EulerAngles ToEulerAngles(const Save::EulerAngles* eulers)
{
return EulerAngles((short)round(eulers->x()), (short)round(eulers->y()), (short)round(eulers->z()));
}
static Vector2 ToVector2(const Save::Vector2* vec)
Vector2 ToVector2(const Save::Vector2* vec)
{
return Vector2(vec->x(), vec->y());
}
static Vector2i ToVector2i(const Save::Vector2* vec)
Vector2i ToVector2i(const Save::Vector2* vec)
{
return Vector2i((int)round(vec->x()), (int)round(vec->y()));
}
static Vector3i ToVector3i(const Save::Vector3* vec)
Vector3i ToVector3i(const Save::Vector3* vec)
{
return Vector3i((int)round(vec->x()), (int)round(vec->y()), (int)round(vec->z()));
}
static Vector3 ToVector3(const Save::Vector3* vec)
Vector3 ToVector3(const Save::Vector3* vec)
{
return Vector3(vec->x(), vec->y(), vec->z());
}
static Vector4 ToVector4(const Save::Vector3* vec)
Vector4 ToVector4(const Save::Vector3* vec)
{
return Vector4(vec->x(), vec->y(), vec->z(), 1.0f);
}
static Vector4 ToVector4(const Save::Vector4* vec)
Vector4 ToVector4(const Save::Vector4* vec)
{
return Vector4(vec->x(), vec->y(), vec->z(), vec->w());
}
static GameVector ToGameVector(const Save::GameVector* vec)
GameVector ToGameVector(const Save::GameVector* vec)
{
return GameVector(vec->x(), vec->y(), vec->z(), (short)vec->room_number());
}
static Pose ToPose(const Save::Pose& pose)
{
return Pose(ToVector3i(&pose.position()), ToEulerAngles(&pose.orientation()), ToVector3(&pose.scale()));
}
bool SaveGame::IsSaveGameSlotValid(int slot)
{
if (slot < 0 || slot > SAVEGAME_MAX_SLOT)

57
TombEngine/Math/Objects/Pose.cpp
View file

@ -9,13 +9,54 @@ using namespace TEN::Math;
//namespace TEN::Math
//{
const Pose Pose::Zero = Pose(Vector3i::Zero, EulerAngles::Identity, Vector3::One);
const Pose Pose::Zero = Pose(Vector3i::Zero, EulerAngles::Identity);
Pose::Pose(const Vector3i& pos, const EulerAngles& orient, const Vector3& scale)
Pose::Pose()
{
}
Pose::Pose(const Vector3i& pos)
{
Position = pos;
}
Pose::Pose(int xPos, int yPos, int zPos)
{
Position = Vector3i(xPos, yPos, zPos);
}
Pose::Pose(const EulerAngles& orient)
{
Orientation = orient;
}
Pose::Pose(short xOrient, short yOrient, short zOrient)
{
Orientation = EulerAngles(xOrient, yOrient, zOrient);
}
Pose::Pose(const Vector3i& pos, const EulerAngles& orient)
{
Position = pos;
Orientation = orient;
Scale = scale;
}
Pose::Pose(const Vector3i& pos, short xOrient, short yOrient, short zOrient)
{
Position = pos;
Orientation = EulerAngles(xOrient, yOrient, zOrient);
}
Pose::Pose(int xPos, int yPos, int zPos, const EulerAngles& orient)
{
Position = Vector3i(xPos, yPos, zPos);
Orientation = orient;
}
Pose::Pose(int xPos, int yPos, int zPos, short xOrient, short yOrient, short zOrient)
{
Position = Vector3i(xPos, yPos, zPos);
Orientation = EulerAngles(xOrient, yOrient, zOrient);
}
void Pose::Translate(short headingAngle, float forward, float down, float right)
@ -33,17 +74,9 @@ using namespace TEN::Math;
Position = Geometry::TranslatePoint(Position, dir, dist);
}
Matrix Pose::ToMatrix() const
{
auto translationMatrix = Matrix::CreateTranslation(Position.ToVector3());
auto rotMatrix = Orientation.ToRotationMatrix();
auto scaleMatrix = Matrix::CreateScale(Scale);
return (scaleMatrix * rotMatrix * translationMatrix);
}
bool Pose::operator ==(const Pose& pose) const
{
return (Position == pose.Position && Orientation == pose.Orientation && Scale == pose.Scale);
return ((Position == pose.Position) && (Orientation == pose.Orientation));
}
bool Pose::operator !=(const Pose& pose) const

17
TombEngine/Math/Objects/Pose.h
View file

@ -4,7 +4,6 @@
//namespace TEN::Math
//{
// TODO: Rename to "Transform".
class Pose
{
public:
@ -12,7 +11,6 @@
Vector3i Position = Vector3i::Zero;
EulerAngles Orientation = EulerAngles::Identity;
Vector3 Scale = Vector3::One;
// Constants
@ -20,8 +18,15 @@
// Constructors
Pose() = default;
Pose(const Vector3i& pos, const EulerAngles& orient = EulerAngles::Identity, const Vector3& scale = Vector3::One);
Pose();
Pose(const Vector3i& pos);
Pose(int xPos, int yPos, int zPos);
Pose(const EulerAngles& orient);
Pose(short xOrient, short yOrient, short zOrient);
Pose(const Vector3i& pos, const EulerAngles& orient);
Pose(const Vector3i& pos, short xOrient, short yOrient, short zOrient);
Pose(int xPos, int yPos, int zPos, const EulerAngles& orient);
Pose(int xPos, int yPos, int zPos, short xOrient, short yOrient, short zOrient);
// Utilities
@ -29,10 +34,6 @@
void Translate(const EulerAngles& orient, float dist);
void Translate(const Vector3& dir, float dist);
// Converters
Matrix ToMatrix() const;
// Operators
bool operator ==(const Pose& pose) const;

2
TombEngine/Objects/TR3/Entity/SophiaLeigh.cpp
View file

@ -631,7 +631,7 @@ namespace TEN::Entities::Creatures::TR3
sphere = BoundingSphere(item.Pose.Position.ToVector3() + Vector3(0.0f, -CLICK(2), 0.0f), BLOCK(1 / 16.0f));
shockwavePos = Pose(Random::GeneratePointInSphere(sphere), item.Pose.Orientation);
auto pos = Pose(item.Pose.Position, EulerAngles::Identity);
auto pos = Pose(item.Pose.Position, 0, 0, 0);
SpawnSophiaSparks(shockwavePos.Position.ToVector3(), Vector3(SOPHIALEIGH_EFFECT_COLOR.x * UCHAR_MAX, SOPHIALEIGH_EFFECT_COLOR.y * UCHAR_MAX, SOPHIALEIGH_EFFECT_COLOR.z * UCHAR_MAX), 5, 2);
TriggerShockwave(&shockwavePos, SOPHIALEIGH_SHOCKWAVE_INNER_SIZE, SOPHIALEIGH_SHOCKWAVE_OUTER_SIZE, SOPHIALEIGH_SHOCKWAVE_SPEED,

2
TombEngine/Objects/TR4/Entity/tr4_baboon.cpp
View file

@ -132,7 +132,7 @@ namespace TEN::Entities::TR4
void BaboonDieEffect(ItemInfo* item)
{
auto pose = Pose(Vector3i(item->Pose.Position.x, item->Pose.Position.y - CLICK(0.5f), item->Pose.Position.z));
auto pose = Pose(item->Pose.Position.x, item->Pose.Position.y - CLICK(0.5f), item->Pose.Position.z);
// Trigger shockwave effect.
TriggerBaboonShockwave(pose, ANGLE(0.0f));

2
TombEngine/Renderer/Renderer.h
View file

@ -232,7 +232,7 @@ namespace TEN::Renderer
std::vector<TexturePair> _staticTextures;
std::vector<Texture2D> _spritesTextures;
Matrix _playerWorldMatrix;
Matrix _laraWorldMatrix;
// Preallocated pools of objects for avoiding new/delete.
// Items and effects are safe (can't be more than 1024 items in TR),

1
TombEngine/Renderer/RendererDrawMenu.cpp
View file

@ -1313,7 +1313,6 @@ namespace TEN::Renderer
PrintDebugMessage("DIMENSION STATS");
PrintDebugMessage("Position: %d, %d, %d", LaraItem->Pose.Position.x, LaraItem->Pose.Position.y, LaraItem->Pose.Position.z);
PrintDebugMessage("Orientation: %d, %d, %d", LaraItem->Pose.Orientation.x, LaraItem->Pose.Orientation.y, LaraItem->Pose.Orientation.z);
PrintDebugMessage("Scale: %.3f, %.3f, %.3f", LaraItem->Pose.Scale.x, LaraItem->Pose.Scale.y, LaraItem->Pose.Scale.z);
PrintDebugMessage("RoomNumber: %d", LaraItem->RoomNumber);
PrintDebugMessage("PathfindingBoxID: %d", LaraItem->BoxNumber);
PrintDebugMessage((Lara.Context.WaterSurfaceDist == -NO_HEIGHT ? "WaterSurfaceDist: N/A" : "WaterSurfaceDist: %d"), Lara.Context.WaterSurfaceDist);

8
TombEngine/Renderer/RendererFrame.cpp
View file

@ -440,10 +440,10 @@ namespace TEN::Renderer
newItem.ObjectID = item.ObjectNumber;
newItem.Color = item.Model.Color;
newItem.Position = item.Pose.Position.ToVector3();
newItem.Translation = Matrix::CreateTranslation(newItem.Position);
newItem.Translation = Matrix::CreateTranslation(newItem.Position.x, newItem.Position.y, newItem.Position.z);
newItem.Rotation = item.Pose.Orientation.ToRotationMatrix();
newItem.Scale = Matrix::CreateScale(item.Pose.Scale);
newItem.World = newItem.Scale * newItem.Rotation * newItem.Translation;
newItem.Scale = Matrix::CreateScale(1.0f);
newItem.World = newItem.Rotation * newItem.Translation;
// Disable interpolation either when renderer slot or item slot has flag.
// Renderer slot has no interpolation flag set in case it is fetched for first time (e.g. item first time in frustum).
@ -455,7 +455,6 @@ namespace TEN::Renderer
newItem.PrevPosition = newItem.Position;
newItem.PrevTranslation = newItem.Translation;
newItem.PrevRotation = newItem.Rotation;
newItem.PrevScale = newItem.Scale;
newItem.PrevWorld = newItem.World;
// Otherwise all frames until next ControlPhase will not be interpolated.
@ -471,7 +470,6 @@ namespace TEN::Renderer
newItem.InterpolatedPosition = Vector3::Lerp(newItem.PrevPosition, newItem.Position, GetInterpolationFactor(forceValue));
newItem.InterpolatedTranslation = Matrix::Lerp(newItem.PrevTranslation, newItem.Translation, GetInterpolationFactor(forceValue));
newItem.InterpolatedRotation = Matrix::Lerp(newItem.InterpolatedRotation, newItem.Rotation, GetInterpolationFactor(forceValue));
newItem.InterpolatedScale = Matrix::Lerp(newItem.InterpolatedScale, newItem.Scale, GetInterpolationFactor(forceValue));
newItem.InterpolatedWorld = Matrix::Lerp(newItem.PrevWorld, newItem.World, GetInterpolationFactor(forceValue));
for (int j = 0; j < MAX_BONES; j++)

2
TombEngine/Renderer/RendererHelper.cpp
View file

@ -458,7 +458,7 @@ namespace TEN::Renderer
if (itemNumber == LaraItem->Index)
{
auto& object = *_moveableObjects[ID_LARA];
*outMatrix = object.AnimationTransforms[jointIndex] * _playerWorldMatrix;
*outMatrix = object.AnimationTransforms[jointIndex] * _laraWorldMatrix;
}
else
{

9
TombEngine/Renderer/RendererLara.cpp
View file

@ -94,9 +94,12 @@ void Renderer::UpdateLaraAnimations(bool force)
for (auto& bone : playerObject.LinearizedBones)
bone->ExtraRotation = Quaternion::Identity;
// Set player world matrix.
_playerWorldMatrix = LaraItem->Pose.ToMatrix();
rItem.World = _playerWorldMatrix;
// Player world matrix.
auto tMatrix = Matrix::CreateTranslation(LaraItem->Pose.Position.ToVector3());
auto rotMatrix = LaraItem->Pose.Orientation.ToRotationMatrix();
_laraWorldMatrix = rotMatrix * tMatrix;
rItem.World = _laraWorldMatrix;
// Update extra head and torso rotations.
playerObject.LinearizedBones[LM_TORSO]->ExtraRotation = Lara.ExtraTorsoRot.ToQuaternion();

809
TombEngine/Specific/savegame/flatbuffers/ten_itemdata_generated.h
View file

@ -9,32 +9,6 @@
namespace TEN {
namespace Save {
struct Short;
struct ShortBuilder;
struct ShortT;
struct Int;
struct IntBuilder;
struct IntT;
struct Float;
struct FloatBuilder;
struct FloatT;
struct ShortArray;
struct ShortArrayBuilder;
struct ShortArrayT;
struct EulerAngles;
struct Vector2;
struct Vector3;
struct Vector4;
struct GameVector;
struct Pose;
struct CreatureTarget;
@ -109,6 +83,32 @@ struct ItemNumber;
struct ItemNumberBuilder;
struct ItemNumberT;
struct Short;
struct ShortBuilder;
struct ShortT;
struct Int;
struct IntBuilder;
struct IntT;
struct Float;
struct FloatBuilder;
struct FloatT;
struct ShortArray;
struct ShortArrayBuilder;
struct ShortArrayT;
struct EulerAngles;
struct Vector2;
struct Vector3;
struct Vector4;
struct GameVector;
enum class ItemData : uint8_t {
NONE = 0,
Int = 1,
@ -492,6 +492,58 @@ struct ItemDataUnion {
bool VerifyItemData(flatbuffers::Verifier &verifier, const void *obj, ItemData type);
bool VerifyItemDataVector(flatbuffers::Verifier &verifier, const flatbuffers::Vector<flatbuffers::Offset<void>> *values, const flatbuffers::Vector<uint8_t> *types);
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Pose FLATBUFFERS_FINAL_CLASS {
private:
int32_t x_pos_;
int32_t y_pos_;
int32_t z_pos_;
int32_t x_rot_;
int32_t y_rot_;
int32_t z_rot_;
public:
struct Traits;
Pose()
: x_pos_(0),
y_pos_(0),
z_pos_(0),
x_rot_(0),
y_rot_(0),
z_rot_(0) {
}
Pose(int32_t _x_pos, int32_t _y_pos, int32_t _z_pos, int32_t _x_rot, int32_t _y_rot, int32_t _z_rot)
: x_pos_(flatbuffers::EndianScalar(_x_pos)),
y_pos_(flatbuffers::EndianScalar(_y_pos)),
z_pos_(flatbuffers::EndianScalar(_z_pos)),
x_rot_(flatbuffers::EndianScalar(_x_rot)),
y_rot_(flatbuffers::EndianScalar(_y_rot)),
z_rot_(flatbuffers::EndianScalar(_z_rot)) {
}
int32_t x_pos() const {
return flatbuffers::EndianScalar(x_pos_);
}
int32_t y_pos() const {
return flatbuffers::EndianScalar(y_pos_);
}
int32_t z_pos() const {
return flatbuffers::EndianScalar(z_pos_);
}
int32_t x_rot() const {
return flatbuffers::EndianScalar(x_rot_);
}
int32_t y_rot() const {
return flatbuffers::EndianScalar(y_rot_);
}
int32_t z_rot() const {
return flatbuffers::EndianScalar(z_rot_);
}
};
FLATBUFFERS_STRUCT_END(Pose, 24);
struct Pose::Traits {
using type = Pose;
};
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(2) EulerAngles FLATBUFFERS_FINAL_CLASS {
private:
int16_t x_;
@ -668,287 +720,6 @@ struct GameVector::Traits {
using type = GameVector;
};
FLATBUFFERS_MANUALLY_ALIGNED_STRUCT(4) Pose FLATBUFFERS_FINAL_CLASS {
private:
TEN::Save::Vector3 position_;
TEN::Save::EulerAngles orientation_;
int16_t padding0__;
TEN::Save::Vector3 scale_;
public:
struct Traits;
Pose()
: position_(),
orientation_(),
padding0__(0),
scale_() {
(void)padding0__;
}
Pose(const TEN::Save::Vector3 &_position, const TEN::Save::EulerAngles &_orientation, const TEN::Save::Vector3 &_scale)
: position_(_position),
orientation_(_orientation),
padding0__(0),
scale_(_scale) {
(void)padding0__;
}
const TEN::Save::Vector3 &position() const {
return position_;
}
const TEN::Save::EulerAngles &orientation() const {
return orientation_;
}
const TEN::Save::Vector3 &scale() const {
return scale_;
}
};
FLATBUFFERS_STRUCT_END(Pose, 32);
struct Pose::Traits {
using type = Pose;
};
struct ShortT : public flatbuffers::NativeTable {
typedef Short TableType;
int16_t scalar = 0;
};
struct Short FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ShortT NativeTableType;
typedef ShortBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SCALAR = 4
};
int16_t scalar() const {
return GetField<int16_t>(VT_SCALAR, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int16_t>(verifier, VT_SCALAR) &&
verifier.EndTable();
}
ShortT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ShortT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Short> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ShortBuilder {
typedef Short Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_scalar(int16_t scalar) {
fbb_.AddElement<int16_t>(Short::VT_SCALAR, scalar, 0);
}
explicit ShortBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Short> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Short>(end);
return o;
}
};
inline flatbuffers::Offset<Short> CreateShort(
flatbuffers::FlatBufferBuilder &_fbb,
int16_t scalar = 0) {
ShortBuilder builder_(_fbb);
builder_.add_scalar(scalar);
return builder_.Finish();
}
struct Short::Traits {
using type = Short;
static auto constexpr Create = CreateShort;
};
flatbuffers::Offset<Short> CreateShort(flatbuffers::FlatBufferBuilder &_fbb, const ShortT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct IntT : public flatbuffers::NativeTable {
typedef Int TableType;
int32_t scalar = 0;
};
struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef IntT NativeTableType;
typedef IntBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SCALAR = 4
};
int32_t scalar() const {
return GetField<int32_t>(VT_SCALAR, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SCALAR) &&
verifier.EndTable();
}
IntT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(IntT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Int> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct IntBuilder {
typedef Int Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_scalar(int32_t scalar) {
fbb_.AddElement<int32_t>(Int::VT_SCALAR, scalar, 0);
}
explicit IntBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Int> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Int>(end);
return o;
}
};
inline flatbuffers::Offset<Int> CreateInt(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t scalar = 0) {
IntBuilder builder_(_fbb);
builder_.add_scalar(scalar);
return builder_.Finish();
}
struct Int::Traits {
using type = Int;
static auto constexpr Create = CreateInt;
};
flatbuffers::Offset<Int> CreateInt(flatbuffers::FlatBufferBuilder &_fbb, const IntT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FloatT : public flatbuffers::NativeTable {
typedef Float TableType;
double scalar = 0.0;
};
struct Float FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FloatT NativeTableType;
typedef FloatBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SCALAR = 4
};
double scalar() const {
return GetField<double>(VT_SCALAR, 0.0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_SCALAR) &&
verifier.EndTable();
}
FloatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FloatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Float> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FloatBuilder {
typedef Float Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_scalar(double scalar) {
fbb_.AddElement<double>(Float::VT_SCALAR, scalar, 0.0);
}
explicit FloatBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Float> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Float>(end);
return o;
}
};
inline flatbuffers::Offset<Float> CreateFloat(
flatbuffers::FlatBufferBuilder &_fbb,
double scalar = 0.0) {
FloatBuilder builder_(_fbb);
builder_.add_scalar(scalar);
return builder_.Finish();
}
struct Float::Traits {
using type = Float;
static auto constexpr Create = CreateFloat;
};
flatbuffers::Offset<Float> CreateFloat(flatbuffers::FlatBufferBuilder &_fbb, const FloatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ShortArrayT : public flatbuffers::NativeTable {
typedef ShortArray TableType;
std::vector<int16_t> arr{};
};
struct ShortArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ShortArrayT NativeTableType;
typedef ShortArrayBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ARR = 4
};
const flatbuffers::Vector<int16_t> *arr() const {
return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_ARR);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ARR) &&
verifier.VerifyVector(arr()) &&
verifier.EndTable();
}
ShortArrayT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ShortArrayT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ShortArray> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ShortArrayBuilder {
typedef ShortArray Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_arr(flatbuffers::Offset<flatbuffers::Vector<int16_t>> arr) {
fbb_.AddOffset(ShortArray::VT_ARR, arr);
}
explicit ShortArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<ShortArray> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ShortArray>(end);
return o;
}
};
inline flatbuffers::Offset<ShortArray> CreateShortArray(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int16_t>> arr = 0) {
ShortArrayBuilder builder_(_fbb);
builder_.add_arr(arr);
return builder_.Finish();
}
struct ShortArray::Traits {
using type = ShortArray;
static auto constexpr Create = CreateShortArray;
};
inline flatbuffers::Offset<ShortArray> CreateShortArrayDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int16_t> *arr = nullptr) {
auto arr__ = arr ? _fbb.CreateVector<int16_t>(*arr) : 0;
return TEN::Save::CreateShortArray(
_fbb,
arr__);
}
flatbuffers::Offset<ShortArray> CreateShortArray(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct CreatureTargetT : public flatbuffers::NativeTable {
typedef CreatureTarget TableType;
int32_t object_number = 0;
@ -2933,110 +2704,248 @@ struct ItemNumber::Traits {
flatbuffers::Offset<ItemNumber> CreateItemNumber(flatbuffers::FlatBufferBuilder &_fbb, const ItemNumberT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline ShortT *Short::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<ShortT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
struct ShortT : public flatbuffers::NativeTable {
typedef Short TableType;
int16_t scalar = 0;
};
struct Short FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ShortT NativeTableType;
typedef ShortBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SCALAR = 4
};
int16_t scalar() const {
return GetField<int16_t>(VT_SCALAR, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int16_t>(verifier, VT_SCALAR) &&
verifier.EndTable();
}
ShortT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ShortT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Short> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ShortBuilder {
typedef Short Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_scalar(int16_t scalar) {
fbb_.AddElement<int16_t>(Short::VT_SCALAR, scalar, 0);
}
explicit ShortBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Short> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Short>(end);
return o;
}
};
inline flatbuffers::Offset<Short> CreateShort(
flatbuffers::FlatBufferBuilder &_fbb,
int16_t scalar = 0) {
ShortBuilder builder_(_fbb);
builder_.add_scalar(scalar);
return builder_.Finish();
}
inline void Short::UnPackTo(ShortT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = scalar(); _o->scalar = _e; }
struct Short::Traits {
using type = Short;
static auto constexpr Create = CreateShort;
};
flatbuffers::Offset<Short> CreateShort(flatbuffers::FlatBufferBuilder &_fbb, const ShortT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct IntT : public flatbuffers::NativeTable {
typedef Int TableType;
int32_t scalar = 0;
};
struct Int FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef IntT NativeTableType;
typedef IntBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SCALAR = 4
};
int32_t scalar() const {
return GetField<int32_t>(VT_SCALAR, 0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<int32_t>(verifier, VT_SCALAR) &&
verifier.EndTable();
}
IntT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(IntT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Int> Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct IntBuilder {
typedef Int Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_scalar(int32_t scalar) {
fbb_.AddElement<int32_t>(Int::VT_SCALAR, scalar, 0);
}
explicit IntBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Int> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Int>(end);
return o;
}
};
inline flatbuffers::Offset<Int> CreateInt(
flatbuffers::FlatBufferBuilder &_fbb,
int32_t scalar = 0) {
IntBuilder builder_(_fbb);
builder_.add_scalar(scalar);
return builder_.Finish();
}
inline flatbuffers::Offset<Short> Short::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateShort(_fbb, _o, _rehasher);
struct Int::Traits {
using type = Int;
static auto constexpr Create = CreateInt;
};
flatbuffers::Offset<Int> CreateInt(flatbuffers::FlatBufferBuilder &_fbb, const IntT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct FloatT : public flatbuffers::NativeTable {
typedef Float TableType;
double scalar = 0.0;
};
struct Float FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef FloatT NativeTableType;
typedef FloatBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_SCALAR = 4
};
double scalar() const {
return GetField<double>(VT_SCALAR, 0.0);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyField<double>(verifier, VT_SCALAR) &&
verifier.EndTable();
}
FloatT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(FloatT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<Float> Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloatT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct FloatBuilder {
typedef Float Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_scalar(double scalar) {
fbb_.AddElement<double>(Float::VT_SCALAR, scalar, 0.0);
}
explicit FloatBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<Float> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<Float>(end);
return o;
}
};
inline flatbuffers::Offset<Float> CreateFloat(
flatbuffers::FlatBufferBuilder &_fbb,
double scalar = 0.0) {
FloatBuilder builder_(_fbb);
builder_.add_scalar(scalar);
return builder_.Finish();
}
inline flatbuffers::Offset<Short> CreateShort(flatbuffers::FlatBufferBuilder &_fbb, const ShortT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShortT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _scalar = _o->scalar;
return TEN::Save::CreateShort(
_fbb,
_scalar);
struct Float::Traits {
using type = Float;
static auto constexpr Create = CreateFloat;
};
flatbuffers::Offset<Float> CreateFloat(flatbuffers::FlatBufferBuilder &_fbb, const FloatT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
struct ShortArrayT : public flatbuffers::NativeTable {
typedef ShortArray TableType;
std::vector<int16_t> arr{};
};
struct ShortArray FLATBUFFERS_FINAL_CLASS : private flatbuffers::Table {
typedef ShortArrayT NativeTableType;
typedef ShortArrayBuilder Builder;
struct Traits;
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
VT_ARR = 4
};
const flatbuffers::Vector<int16_t> *arr() const {
return GetPointer<const flatbuffers::Vector<int16_t> *>(VT_ARR);
}
bool Verify(flatbuffers::Verifier &verifier) const {
return VerifyTableStart(verifier) &&
VerifyOffset(verifier, VT_ARR) &&
verifier.VerifyVector(arr()) &&
verifier.EndTable();
}
ShortArrayT *UnPack(const flatbuffers::resolver_function_t *_resolver = nullptr) const;
void UnPackTo(ShortArrayT *_o, const flatbuffers::resolver_function_t *_resolver = nullptr) const;
static flatbuffers::Offset<ShortArray> Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT* _o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
};
struct ShortArrayBuilder {
typedef ShortArray Table;
flatbuffers::FlatBufferBuilder &fbb_;
flatbuffers::uoffset_t start_;
void add_arr(flatbuffers::Offset<flatbuffers::Vector<int16_t>> arr) {
fbb_.AddOffset(ShortArray::VT_ARR, arr);
}
explicit ShortArrayBuilder(flatbuffers::FlatBufferBuilder &_fbb)
: fbb_(_fbb) {
start_ = fbb_.StartTable();
}
flatbuffers::Offset<ShortArray> Finish() {
const auto end = fbb_.EndTable(start_);
auto o = flatbuffers::Offset<ShortArray>(end);
return o;
}
};
inline flatbuffers::Offset<ShortArray> CreateShortArray(
flatbuffers::FlatBufferBuilder &_fbb,
flatbuffers::Offset<flatbuffers::Vector<int16_t>> arr = 0) {
ShortArrayBuilder builder_(_fbb);
builder_.add_arr(arr);
return builder_.Finish();
}
inline IntT *Int::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<IntT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
struct ShortArray::Traits {
using type = ShortArray;
static auto constexpr Create = CreateShortArray;
};
inline void Int::UnPackTo(IntT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = scalar(); _o->scalar = _e; }
}
inline flatbuffers::Offset<Int> Int::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateInt(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Int> CreateInt(flatbuffers::FlatBufferBuilder &_fbb, const IntT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IntT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _scalar = _o->scalar;
return TEN::Save::CreateInt(
_fbb,
_scalar);
}
inline FloatT *Float::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<FloatT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Float::UnPackTo(FloatT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = scalar(); _o->scalar = _e; }
}
inline flatbuffers::Offset<Float> Float::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloatT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFloat(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Float> CreateFloat(flatbuffers::FlatBufferBuilder &_fbb, const FloatT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _scalar = _o->scalar;
return TEN::Save::CreateFloat(
_fbb,
_scalar);
}
inline ShortArrayT *ShortArray::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<ShortArrayT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void ShortArray::UnPackTo(ShortArrayT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = arr(); if (_e) { _o->arr.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->arr[_i] = _e->Get(_i); } } }
}
inline flatbuffers::Offset<ShortArray> ShortArray::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateShortArray(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ShortArray> CreateShortArray(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShortArrayT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _arr = _fbb.CreateVector(_o->arr);
inline flatbuffers::Offset<ShortArray> CreateShortArrayDirect(
flatbuffers::FlatBufferBuilder &_fbb,
const std::vector<int16_t> *arr = nullptr) {
auto arr__ = arr ? _fbb.CreateVector<int16_t>(*arr) : 0;
return TEN::Save::CreateShortArray(
_fbb,
_arr);
arr__);
}
flatbuffers::Offset<ShortArray> CreateShortArray(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT *_o, const flatbuffers::rehasher_function_t *_rehasher = nullptr);
inline CreatureTargetT *CreatureTarget::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<CreatureTargetT>();
UnPackTo(_o.get(), _resolver);
@ -3751,6 +3660,110 @@ inline flatbuffers::Offset<ItemNumber> CreateItemNumber(flatbuffers::FlatBufferB
_num);
}
inline ShortT *Short::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<ShortT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Short::UnPackTo(ShortT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = scalar(); _o->scalar = _e; }
}
inline flatbuffers::Offset<Short> Short::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateShort(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Short> CreateShort(flatbuffers::FlatBufferBuilder &_fbb, const ShortT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShortT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _scalar = _o->scalar;
return TEN::Save::CreateShort(
_fbb,
_scalar);
}
inline IntT *Int::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<IntT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Int::UnPackTo(IntT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = scalar(); _o->scalar = _e; }
}
inline flatbuffers::Offset<Int> Int::Pack(flatbuffers::FlatBufferBuilder &_fbb, const IntT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateInt(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Int> CreateInt(flatbuffers::FlatBufferBuilder &_fbb, const IntT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const IntT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _scalar = _o->scalar;
return TEN::Save::CreateInt(
_fbb,
_scalar);
}
inline FloatT *Float::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<FloatT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void Float::UnPackTo(FloatT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = scalar(); _o->scalar = _e; }
}
inline flatbuffers::Offset<Float> Float::Pack(flatbuffers::FlatBufferBuilder &_fbb, const FloatT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateFloat(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<Float> CreateFloat(flatbuffers::FlatBufferBuilder &_fbb, const FloatT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const FloatT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _scalar = _o->scalar;
return TEN::Save::CreateFloat(
_fbb,
_scalar);
}
inline ShortArrayT *ShortArray::UnPack(const flatbuffers::resolver_function_t *_resolver) const {
auto _o = std::make_unique<ShortArrayT>();
UnPackTo(_o.get(), _resolver);
return _o.release();
}
inline void ShortArray::UnPackTo(ShortArrayT *_o, const flatbuffers::resolver_function_t *_resolver) const {
(void)_o;
(void)_resolver;
{ auto _e = arr(); if (_e) { _o->arr.resize(_e->size()); for (flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->arr[_i] = _e->Get(_i); } } }
}
inline flatbuffers::Offset<ShortArray> ShortArray::Pack(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT* _o, const flatbuffers::rehasher_function_t *_rehasher) {
return CreateShortArray(_fbb, _o, _rehasher);
}
inline flatbuffers::Offset<ShortArray> CreateShortArray(flatbuffers::FlatBufferBuilder &_fbb, const ShortArrayT *_o, const flatbuffers::rehasher_function_t *_rehasher) {
(void)_rehasher;
(void)_o;
struct _VectorArgs { flatbuffers::FlatBufferBuilder *__fbb; const ShortArrayT* __o; const flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
auto _arr = _fbb.CreateVector(_o->arr);
return TEN::Save::CreateShortArray(
_fbb,
_arr);
}
inline bool VerifyItemData(flatbuffers::Verifier &verifier, const void *obj, ItemData type) {
switch (type) {
case ItemData::NONE: {

103
TombEngine/Specific/savegame/schema/ten_itemdata.fbs
View file

@ -1,56 +1,12 @@
namespace TEN.Save;
table Short {
scalar: short;
}
table Int {
scalar: int32;
}
table Float {
scalar: double;
}
table ShortArray {
arr: [short];
}
struct EulerAngles {
x: short;
y: short;
z: short;
}
struct Vector2 {
x: float;
y: float;
}
struct Vector3 {
x: float;
y: float;
z: float;
}
struct Vector4 {
x: float;
y: float;
z: float;
w: float;
}
struct GameVector {
x: int32;
y: int32;
z: int32;
room_number: int32;
}
struct Pose {
position: Vector3;
orientation: EulerAngles;
scale: Vector3;
x_pos: int32;
y_pos: int32;
z_pos: int32;
x_rot: int32;
y_rot: int32;
z_rot: int32;
}
table CreatureTarget {
@ -232,6 +188,53 @@ table ItemNumber {
num: short;
}
table Short {
scalar: short;
}
table Int {
scalar: int32;
}
table Float {
scalar: double;
}
table ShortArray {
arr: [short];
}
struct EulerAngles {
x: short;
y: short;
z: short;
}
struct Vector2 {
x: float;
y: float;
}
struct Vector3 {
x: float;
y: float;
z: float;
}
struct Vector4 {
x: float;
y: float;
z: float;
w: float;
}
struct GameVector {
x: int32;
y: int32;
z: int32;
room_number: int32;
}
union ItemData {
Int,
Short,