zdoom/gzdoom-gles
0
0
Fork 0
mirror of https://github.com/ZDoom/gzdoom-gles.git synced 2024-11-15 00:51:24 +00:00
Code Issues Projects Releases Packages Wiki Activity
gzdoom-gles/src/serializer.h

299 lines
9.4 KiB
C
Raw Normal View History

- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
#ifndef __SERIALIZER_H
#define __SERIALIZER_H
#include <stdint.h>
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
#include <type_traits>
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
#include "tarray.h"
#include "r_defs.h"
- some preparations for converting the player serialization code. - converted sound and canvas texture serialization. - refactored file_zip, so that it can be used to load loose zip files and extract their compressed data directly. - added handling to FSerializer to generate and consume compressed Zip file entries. If all goes well this will allow saving savegames as Zips when the rework is done, which will make analyzing them a lot easier.
2016-09-20 21:13:12 +00:00
#include "resourcefiles/file_zip.h"
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
- converted player serializer and everything it needs. This means that everything belonging to the level snapshot will be generated in the JSON output.
2016-09-20 23:18:29 +00:00
struct ticcmd_t;
struct usercmd_t;
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
struct FWriter;
struct FReader;
extern TArray<sector_t> loadsectors;
extern TArray<line_t> loadlines;
extern TArray<side_t> loadsides;
- added object deserialization. It seems to work, at least the stuff I sampled looked like it was properly reatored and it triggers no error condition. - always make the top level object randomaccess when opening a JSON file for reading. Some things won't work right if this is opened for sequential access.
2016-09-22 22:45:41 +00:00
inline bool nullcmp(const void *buffer, size_t length)
{
const char *p = (const char *)buffer;
for (; length > 0; length--)
{
if (*p++ != 0) return false;
}
return true;
}
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
struct NumericValue
{
enum EType
{
NM_invalid,
NM_signed,
NM_unsigned,
NM_float
} type;
union
{
int64_t signedval;
uint64_t unsignedval;
double floatval;
};
bool operator !=(const NumericValue &other)
{
return type != other.type || signedval != other.signedval;
}
};
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
class FSerializer
{
public:
FWriter *w = nullptr;
FReader *r = nullptr;
int ArraySize();
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
void WriteKey(const char *key);
- added object deserialization. It seems to work, at least the stuff I sampled looked like it was properly reatored and it triggers no error condition. - always make the top level object randomaccess when opening a JSON file for reading. Some things won't work right if this is opened for sequential access.
2016-09-22 22:45:41 +00:00
void WriteObjects();
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
public:
- a few more
2016-09-19 11:36:58 +00:00
~FSerializer()
{
Close();
}
- allow the compact and pretty writers for JSON to coexist by wrapping the whole stuff into another class that calls the proper one as needed. Due to the implementation it is not possible to decide at run time how this should behave so there have to be two different objects for either mode. - savegame code handles new format.
2016-09-21 19:57:24 +00:00
bool OpenWriter(bool pretty = true);
- added object deserialization. It seems to work, at least the stuff I sampled looked like it was properly reatored and it triggers no error condition. - always make the top level object randomaccess when opening a JSON file for reading. Some things won't work right if this is opened for sequential access.
2016-09-22 22:45:41 +00:00
bool OpenReader(const char *buffer, size_t length);
bool OpenReader(FCompressedBuffer *input);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
void Close();
- made reading of objects from the savegame work. It turned out this may not be done automatically when opening the savegame - it has to be done later, after the pre-spawned map thinkers and all connected objects have been destroyed. The object deserializer also has to be rather careful about dealing with parse errors, because if something goes wrong a whole batch of uninitialized or partially initialized objects will be left behind to destroy. This means that no object class may assume that anything but the default constructor has been run on it and needs to check any variable it may reference.
2016-09-23 07:38:55 +00:00
void ReadObjects();
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
bool BeginObject(const char *name, bool randomaccess = false);
- added object deserialization. It seems to work, at least the stuff I sampled looked like it was properly reatored and it triggers no error condition. - always make the top level object randomaccess when opening a JSON file for reading. Some things won't work right if this is opened for sequential access.
2016-09-22 22:45:41 +00:00
void EndObject(bool endwarning = false);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
bool BeginArray(const char *name);
void EndArray();
- added polyobject serializer. - added sanity checks to prevent a savegame from being loaded with an incompatible map - refactored a few things to simplify serialization. - started work on main level serializer function.
2016-09-20 07:11:13 +00:00
unsigned GetSize(const char *group);
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
const char *GetKey();
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
const char *GetOutput(unsigned *len = nullptr);
- some preparations for converting the player serialization code. - converted sound and canvas texture serialization. - refactored file_zip, so that it can be used to load loose zip files and extract their compressed data directly. - added handling to FSerializer to generate and consume compressed Zip file entries. If all goes well this will allow saving savegames as Zips when the rework is done, which will make analyzing them a lot easier.
2016-09-20 21:13:12 +00:00
FCompressedBuffer GetCompressedOutput();
- added object deserialization. It seems to work, at least the stuff I sampled looked like it was properly reatored and it triggers no error condition. - always make the top level object randomaccess when opening a JSON file for reading. Some things won't work right if this is opened for sequential access.
2016-09-22 22:45:41 +00:00
FSerializer &Discard(const char *key);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
FSerializer &Args(const char *key, int *args, int *defargs, int special);
FSerializer &Terrain(const char *key, int &terrain, int *def = nullptr);
- added new serializers to several classes and moved the old ones to the dump file.
2016-09-19 10:53:42 +00:00
FSerializer &Sprite(const char *key, int32_t &spritenum, int32_t *def);
- all thinker serializers done.
2016-09-19 22:41:22 +00:00
FSerializer &StringPtr(const char *key, const char *&charptr); // This only retrieves the address but creates no permanent copy of the string unlike the regular char* serializer.
- save global savegame data to JSON as well. This is incomplete and untested, just a safety commit before going on.
2016-09-21 10:19:13 +00:00
FSerializer &AddString(const char *key, const char *charptr);
- all thinker serializers done.
2016-09-19 22:41:22 +00:00
FSerializer &ScriptNum(const char *key, int &num);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
bool isReading() const
{
return r != nullptr;
}
bool isWriting() const
{
return w != nullptr;
}
bool canSkip() const;
template<class T>
FSerializer &operator()(const char *key, T &obj)
{
return Serialize(*this, key, obj, (T*)nullptr);
}
template<class T>
FSerializer &operator()(const char *key, T &obj, T &def)
{
return Serialize(*this, key, obj, &def);
}
template<class T>
FSerializer &Array(const char *key, T *obj, int count, bool fullcompare = false)
{
- added object deserialization. It seems to work, at least the stuff I sampled looked like it was properly reatored and it triggers no error condition. - always make the top level object randomaccess when opening a JSON file for reading. Some things won't work right if this is opened for sequential access.
2016-09-22 22:45:41 +00:00
if (fullcompare && isWriting() && nullcmp(obj, count * sizeof(T)))
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
{
return *this;
}
if (BeginArray(key))
{
- fixed: array clamping may only be done when reading a savegame. - fixed generation of savegame names for level snapshots.
2016-09-22 09:51:29 +00:00
if (isReading())
{
int max = ArraySize();
if (max < count) count = max;
}
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
for (int i = 0; i < count; i++)
{
Serialize(*this, nullptr, obj[i], (T*)nullptr);
}
EndArray();
}
return *this;
}
template<class T>
FSerializer &Array(const char *key, T *obj, T *def, int count, bool fullcompare = false)
{
if (fullcompare && isWriting() && def != nullptr && !memcmp(obj, def, count * sizeof(T)))
{
return *this;
}
if (BeginArray(key))
{
- fixed: Both array serializers need the bounds check.
2016-09-22 09:53:09 +00:00
if (isReading())
{
int max = ArraySize();
if (max < count) count = max;
}
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
for (int i = 0; i < count; i++)
{
Serialize(*this, nullptr, obj[i], def ? &def[i] : nullptr);
}
EndArray();
}
return *this;
}
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
template<class T>
FSerializer &Enum(const char *key, T &obj)
{
auto val = (std::underlying_type<T>::type)obj;
Serialize(*this, key, val, nullptr);
obj = (T)val;
return *this;
}
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
};
FSerializer &Serialize(FSerializer &arc, const char *key, bool &value, bool *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, int64_t &value, int64_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, uint64_t &value, uint64_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, int32_t &value, int32_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, uint32_t &value, uint32_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, int8_t &value, int8_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, uint8_t &value, uint8_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, int16_t &value, int16_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, uint16_t &value, uint16_t *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, double &value, double *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, float &value, float *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, FTextureID &value, FTextureID *defval);
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
FSerializer &Serialize(FSerializer &arc, const char *key, DObject *&value, DObject ** /*defval*/, bool *retcode = nullptr);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
FSerializer &Serialize(FSerializer &arc, const char *key, FName &value, FName *defval);
FSerializer &Serialize(FSerializer &arc, const char *key, FSoundID &sid, FSoundID *def);
- all thinker serializers done.
2016-09-19 22:41:22 +00:00
FSerializer &Serialize(FSerializer &arc, const char *key, FString &sid, FString *def);
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
FSerializer &Serialize(FSerializer &arc, const char *key, NumericValue &sid, NumericValue *def);
- converted player serializer and everything it needs. This means that everything belonging to the level snapshot will be generated in the JSON output.
2016-09-20 23:18:29 +00:00
FSerializer &Serialize(FSerializer &arc, const char *key, ticcmd_t &sid, ticcmd_t *def);
FSerializer &Serialize(FSerializer &arc, const char *key, usercmd_t &cmd, usercmd_t *def);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
template<class T>
FSerializer &Serialize(FSerializer &arc, const char *key, T *&value, T **)
{
DObject *v = static_cast<DObject*>(value);
Serialize(arc, key, v, nullptr);
value = static_cast<T*>(v);
return arc;
}
template<class T>
FSerializer &Serialize(FSerializer &arc, const char *key, TObjPtr<T> &value, TObjPtr<T> *)
{
Serialize(arc, key, value.o, nullptr);
return arc;
}
template<class T, class TT>
FSerializer &Serialize(FSerializer &arc, const char *key, TArray<T, TT> &value, TArray<T, TT> *)
{
if (arc.isWriting())
{
if (value.Size() == 0) return arc; // do not save empty arrays
}
bool res = arc.BeginArray(key);
if (arc.isReading())
{
if (!res)
{
value.Clear();
return arc;
}
value.Resize(arc.ArraySize());
}
for (unsigned i = 0; i < value.Size(); i++)
{
Serialize(arc, nullptr, value[i], (T*)nullptr);
}
arc.EndArray();
return arc;
}
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, FPolyObj *&value, FPolyObj **defval);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, sector_t *&value, sector_t **defval);
- some preparations for converting the player serialization code. - converted sound and canvas texture serialization. - refactored file_zip, so that it can be used to load loose zip files and extract their compressed data directly. - added handling to FSerializer to generate and consume compressed Zip file entries. If all goes well this will allow saving savegames as Zips when the rework is done, which will make analyzing them a lot easier.
2016-09-20 21:13:12 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, const FPolyObj *&value, const FPolyObj **defval);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, const sector_t *&value, const sector_t **defval);
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, player_t *&value, player_t **defval);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, line_t *&value, line_t **defval);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, side_t *&value, side_t **defval);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, vertex_t *&value, vertex_t **defval);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, FDynamicColormap *&cm, FDynamicColormap **def);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, PClassActor *&clst, PClassActor **def);
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, PClass *&clst, PClass **def);
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, FStrifeDialogueNode *&node, FStrifeDialogueNode **def);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, FString *&pstr, FString **def);
template<> FSerializer &Serialize(FSerializer &arc, const char *key, FDoorAnimation *&pstr, FDoorAnimation **def);
- all thinker serializers done.
2016-09-19 22:41:22 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, char *&pstr, char **def);
- fixed incomplete hudmessage serialization. - fixed a few errors in the ACS module serializer. - reordered a few things to how they were in the old code. - optimized serialization of the level.Scrolls array to happen within the sector. This is to allow skipping 0-entries which normally constitute the vast majority of them.
2016-09-20 11:21:41 +00:00
template<> FSerializer &Serialize(FSerializer &arc, const char *key, FFont *&font, FFont **def);
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
- converted player serializer and everything it needs. This means that everything belonging to the level snapshot will be generated in the JSON output.
2016-09-20 23:18:29 +00:00
template<> inline FSerializer &Serialize(FSerializer &arc, const char *key, PClassPlayerPawn *&clst, PClassPlayerPawn **def)
{
return Serialize(arc, key, (PClassActor *&)clst, (PClassActor **)def);
}
- some preparations for converting the player serialization code. - converted sound and canvas texture serialization. - refactored file_zip, so that it can be used to load loose zip files and extract their compressed data directly. - added handling to FSerializer to generate and consume compressed Zip file entries. If all goes well this will allow saving savegames as Zips when the rework is done, which will make analyzing them a lot easier.
2016-09-20 21:13:12 +00:00
- converted the user variable serializer.
2016-09-20 16:27:47 +00:00
FSerializer &Serialize(FSerializer &arc, const char *key, FState *&state, FState **def, bool *retcode);
template<> inline FSerializer &Serialize(FSerializer &arc, const char *key, FState *&state, FState **def)
{
return Serialize(arc, key, state, def, nullptr);
}
- most thinkers are done. Some stuff about polyobject pointers is temporarily disabled right now because some of the required functions have already been pulled out.
2016-09-19 17:14:30 +00:00
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
inline FSerializer &Serialize(FSerializer &arc, const char *key, DVector3 &p, DVector3 *def)
{
return arc.Array<double>(key, &p[0], def? &(*def)[0] : nullptr, 3, true);
}
inline FSerializer &Serialize(FSerializer &arc, const char *key, DRotator &p, DRotator *def)
{
return arc.Array<DAngle>(key, &p[0], def? &(*def)[0] : nullptr, 3, true);
}
inline FSerializer &Serialize(FSerializer &arc, const char *key, DVector2 &p, DVector2 *def)
{
return arc.Array<double>(key, &p[0], def? &(*def)[0] : nullptr, 2, true);
}
inline FSerializer &Serialize(FSerializer &arc, const char *key, DAngle &p, DAngle *def)
{
return Serialize(arc, key, p.Degrees, def? &def->Degrees : nullptr);
}
inline FSerializer &Serialize(FSerializer &arc, const char *key, PalEntry &pe, PalEntry *def)
{
return Serialize(arc, key, pe.d, def? &def->d : nullptr);
}
inline FSerializer &Serialize(FSerializer &arc, const char *key, FRenderStyle &style, FRenderStyle *def)
{
- some preparations for converting the player serialization code. - converted sound and canvas texture serialization. - refactored file_zip, so that it can be used to load loose zip files and extract their compressed data directly. - added handling to FSerializer to generate and consume compressed Zip file entries. If all goes well this will allow saving savegames as Zips when the rework is done, which will make analyzing them a lot easier.
2016-09-20 21:13:12 +00:00
return arc.Array(key, &style.BlendOp, def ? &def->BlendOp : nullptr, 4);
- removed FS HUD pics. No mod in existence ever used them and a quickly thrown together test showed that the code did not even work. And since there's no reason to fix it they are gone now.
2016-09-19 08:41:21 +00:00
}
template<class T, class TT>
FSerializer &Serialize(FSerializer &arc, const char *key, TFlags<T, TT> &flags, TFlags<T, TT> *def)
{
return Serialize(arc, key, flags.Value, def? &def->Value : nullptr);
}
#endif
Reference in a new issue Copy permalink