mirror of
https://github.com/ZDoom/gzdoom-gles.git
synced 2024-11-25 13:41:05 +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.
This commit is contained in:
Christoph Oelckers
parent
c665cc53f9
commit
e754fae0a8
4 changed files with 213 additions and 243 deletions
|
|
@ -1220,7 +1220,6 @@ set (PCH_SOURCES
|
|||
thingdef/thingdef_properties.cpp
|
||||
thingdef/thingdef_states.cpp
|
||||
xlat/parse_xlat.cpp
|
||||
fragglescript/t_fspic.cpp
|
||||
fragglescript/t_func.cpp
|
||||
fragglescript/t_load.cpp
|
||||
fragglescript/t_oper.cpp
|
||||
|
|
|
|||
|
|
@ -1,204 +0,0 @@
|
|||
/*
|
||||
** t_fspic.cpp
|
||||
** Fragglescript HUD pics (incomplete and untested!)
|
||||
**
|
||||
**---------------------------------------------------------------------------
|
||||
** Copyright 2005 Christoph Oelckers
|
||||
** 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.
|
||||
** 3. The name of the author may not be used to endorse or promote products
|
||||
** derived from this software without specific prior written permission.
|
||||
**
|
||||
** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
|
||||
**---------------------------------------------------------------------------
|
||||
**
|
||||
*/
|
||||
|
||||
#include "t_script.h"
|
||||
#include "doomtype.h"
|
||||
#include "p_local.h"
|
||||
#include "farchive.h"
|
||||
#include "sbar.h"
|
||||
#include "v_video.h"
|
||||
|
||||
|
||||
|
||||
struct FHudPic
|
||||
{
|
||||
FTextureID texturenum;
|
||||
int xpos;
|
||||
int ypos;
|
||||
bool draw;
|
||||
|
||||
void Serialize(FArchive & arc)
|
||||
{
|
||||
arc << xpos << ypos << draw << texturenum;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
class DHUDPicManager : public DHUDMessage
|
||||
{
|
||||
// This is no real hudmessage but this way I don't need any external code to handle this
|
||||
// because the hudmessage and thinker code handles everything automatically
|
||||
DECLARE_CLASS(DHUDPicManager, DHUDMessage)
|
||||
float basetrans;
|
||||
|
||||
public:
|
||||
|
||||
TArray<FHudPic> piclist;
|
||||
|
||||
DHUDPicManager();
|
||||
~DHUDPicManager() {}
|
||||
void Serialize(FArchive & ar);
|
||||
virtual void DoDraw (int linenum, int x, int y, int hudheight, float translucent);
|
||||
void DoDraw (int, int, int, bool, int) { assert(false); }
|
||||
} ;
|
||||
|
||||
IMPLEMENT_CLASS(DHUDPicManager)
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
DHUDPicManager::DHUDPicManager()
|
||||
{
|
||||
HUDWidth=HUDHeight=0;
|
||||
basetrans=0.8f;
|
||||
//SetID(0xffffffff);
|
||||
NumLines=1;
|
||||
HoldTics=0; // stay forever!
|
||||
//logtoconsole=false;
|
||||
}
|
||||
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
void DHUDPicManager::Serialize(FArchive & ar)
|
||||
{
|
||||
Super::Serialize(ar);
|
||||
|
||||
short count=piclist.Size();
|
||||
ar << count << basetrans;
|
||||
if (ar.IsLoading()) piclist.Resize(count);
|
||||
for(int i=0;i<count;i++) piclist[i].Serialize(ar);
|
||||
}
|
||||
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
void DHUDPicManager::DoDraw (int linenum, int x, int y, int hudheight, float translucent)
|
||||
{
|
||||
for(unsigned int i=0; i<piclist.Size();i++) if (piclist[i].texturenum.isValid() && piclist[i].draw)
|
||||
{
|
||||
FTexture * tex = TexMan[piclist[i].texturenum];
|
||||
if (tex) screen->DrawTexture(tex, piclist[i].xpos, piclist[i].ypos, DTA_320x200, true,
|
||||
DTA_AlphaF, translucent*basetrans, TAG_DONE);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
static TArray<FHudPic> & GetPicList()
|
||||
{
|
||||
//TThinkerIterator<DHUDPicManager> it;
|
||||
DHUDPicManager * pm=NULL;//it.Next();
|
||||
|
||||
if (!pm) pm=new DHUDPicManager;
|
||||
return pm->piclist;
|
||||
}
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
// External interface
|
||||
//
|
||||
//======================================================================
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
int HU_GetFSPic(FTextureID texturenum, int xpos, int ypos)
|
||||
{
|
||||
TArray<FHudPic> &piclist=GetPicList();
|
||||
unsigned int i;
|
||||
|
||||
for(i=0;i<piclist.Size();i++) if (piclist[i].texturenum.isValid()) continue;
|
||||
if (i==piclist.Size()) i=piclist.Reserve(1);
|
||||
|
||||
FHudPic * pic=&piclist[i];
|
||||
|
||||
piclist[i].texturenum = texturenum;
|
||||
piclist[i].xpos = xpos;
|
||||
piclist[i].ypos = ypos;
|
||||
piclist[i].draw = false;
|
||||
return i;
|
||||
}
|
||||
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
int HU_DeleteFSPic(unsigned handle)
|
||||
{
|
||||
TArray<FHudPic> &piclist=GetPicList();
|
||||
|
||||
if(handle >= piclist.Size()) return -1;
|
||||
piclist[handle].texturenum.SetInvalid();
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
int HU_ModifyFSPic(unsigned handle, FTextureID texturenum, int xpos, int ypos)
|
||||
{
|
||||
TArray<FHudPic> &piclist=GetPicList();
|
||||
|
||||
if(handle >= piclist.Size()) return -1;
|
||||
if(!piclist[handle].texturenum.isValid()) return -1;
|
||||
|
||||
piclist[handle].texturenum = texturenum;
|
||||
piclist[handle].xpos = xpos;
|
||||
piclist[handle].ypos = ypos;
|
||||
return 0;
|
||||
}
|
||||
|
||||
//======================================================================
|
||||
//
|
||||
//======================================================================
|
||||
int HU_FSDisplay(unsigned handle, bool newval)
|
||||
{
|
||||
TArray<FHudPic> &piclist=GetPicList();
|
||||
|
||||
if(handle >= piclist.Size()) return -1;
|
||||
if(!piclist[handle].texturenum.isValid()) return -1;
|
||||
|
||||
piclist[handle].draw = newval;
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
|
@ -3647,58 +3647,24 @@ void FParser::SF_Pow()
|
|||
//==========================================================================
|
||||
|
||||
|
||||
int HU_GetFSPic(FTextureID lumpnum, int xpos, int ypos);
|
||||
int HU_DeleteFSPic(unsigned int handle);
|
||||
int HU_ModifyFSPic(unsigned int handle, FTextureID lumpnum, int xpos, int ypos);
|
||||
int HU_FSDisplay(unsigned int handle, bool newval);
|
||||
|
||||
void FParser::SF_NewHUPic()
|
||||
{
|
||||
if (CheckArgs(3))
|
||||
{
|
||||
t_return.type = svt_int;
|
||||
t_return.value.i = HU_GetFSPic(
|
||||
TexMan.GetTexture(stringvalue(t_argv[0]), FTexture::TEX_MiscPatch, FTextureManager::TEXMAN_TryAny),
|
||||
intvalue(t_argv[1]), intvalue(t_argv[2]));
|
||||
}
|
||||
// disabled because it was never used and never tested
|
||||
}
|
||||
|
||||
void FParser::SF_DeleteHUPic()
|
||||
{
|
||||
if (CheckArgs(1))
|
||||
{
|
||||
if (HU_DeleteFSPic(intvalue(t_argv[0])) == -1)
|
||||
script_error("deletehupic: Invalid sfpic handle: %i\n", intvalue(t_argv[0]));
|
||||
}
|
||||
// disabled because it was never used and never tested
|
||||
}
|
||||
|
||||
void FParser::SF_ModifyHUPic()
|
||||
{
|
||||
if (t_argc != 4)
|
||||
{
|
||||
script_error("modifyhupic: invalid number of arguments\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (HU_ModifyFSPic(intvalue(t_argv[0]),
|
||||
TexMan.GetTexture(stringvalue(t_argv[0]), FTexture::TEX_MiscPatch, FTextureManager::TEXMAN_TryAny),
|
||||
intvalue(t_argv[2]), intvalue(t_argv[3])) == -1)
|
||||
{
|
||||
script_error("modifyhypic: invalid sfpic handle %i\n", intvalue(t_argv[0]));
|
||||
}
|
||||
return;
|
||||
// disabled because it was never used and never tested
|
||||
}
|
||||
|
||||
void FParser::SF_SetHUPicDisplay()
|
||||
{
|
||||
if (t_argc != 2)
|
||||
{
|
||||
script_error("sethupicdisplay: invalud number of arguments\n");
|
||||
return;
|
||||
}
|
||||
|
||||
if (HU_FSDisplay(intvalue(t_argv[0]), intvalue(t_argv[1]) > 0 ? 1 : 0) == -1)
|
||||
script_error("sethupicdisplay: invalid pic handle %i\n", intvalue(t_argv[0]));
|
||||
// disabled because it was never used and never tested
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
209
src/serializer.h
Normal file
209
src/serializer.h
Normal file
|
|
@ -0,0 +1,209 @@
|
|||
#ifndef __SERIALIZER_H
|
||||
#define __SERIALIZER_H
|
||||
|
||||
#include <stdint.h>
|
||||
#include "tarray.h"
|
||||
#include "r_defs.h"
|
||||
|
||||
struct FWriter;
|
||||
struct FReader;
|
||||
|
||||
extern TArray<sector_t> loadsectors;
|
||||
extern TArray<line_t> loadlines;
|
||||
extern TArray<side_t> loadsides;
|
||||
extern char nulspace[];
|
||||
|
||||
|
||||
|
||||
class FSerializer
|
||||
{
|
||||
|
||||
public:
|
||||
FWriter *w = nullptr;
|
||||
FReader *r = nullptr;
|
||||
|
||||
int ArraySize();
|
||||
|
||||
public:
|
||||
|
||||
bool OpenWriter();
|
||||
bool OpenReader(const char *buffer, size_t length);
|
||||
void Close();
|
||||
void WriteKey(const char *key);
|
||||
bool BeginObject(const char *name);
|
||||
void EndObject();
|
||||
bool BeginArray(const char *name);
|
||||
void EndArray();
|
||||
void WriteObjects();
|
||||
const char *GetOutput(unsigned *len = nullptr);
|
||||
FSerializer &Args(const char *key, int *args, int *defargs, int special);
|
||||
FSerializer &Terrain(const char *key, int &terrain, int *def = nullptr);
|
||||
FSerializer &Sprite(const char *key, uint16_t &spritenum, uint16_t *def);
|
||||
FSerializer &StringPtr(const char *key, const char *&charptr); // This only retrieves the address but creates no permanent copy of the string.
|
||||
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)
|
||||
{
|
||||
if (fullcompare && isWriting() && !memcmp(obj, nulspace, count * sizeof(T)))
|
||||
{
|
||||
return *this;
|
||||
}
|
||||
|
||||
if (BeginArray(key))
|
||||
{
|
||||
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))
|
||||
{
|
||||
for (int i = 0; i < count; i++)
|
||||
{
|
||||
Serialize(*this, nullptr, obj[i], def ? &def[i] : nullptr);
|
||||
}
|
||||
EndArray();
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
};
|
||||
|
||||
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, side_t *&value, side_t **defval);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, sector_t *&value, sector_t **defval);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, player_t *&value, player_t **defval);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, line_t *&value, line_t **defval);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FTextureID &value, FTextureID *defval);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, DObject *&value, DObject ** /*defval*/);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FName &value, FName *defval);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FDynamicColormap *&cm, FDynamicColormap **def);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FSoundID &sid, FSoundID *def);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, PClassActor *&clst, PClassActor **def);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FState *&state, FState **def);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FStrifeDialogueNode *&node, FStrifeDialogueNode **def);
|
||||
FSerializer &Serialize(FSerializer &arc, const char *key, FString *&pstr, FString **def);
|
||||
|
||||
|
||||
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;
|
||||
}
|
||||
|
||||
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)
|
||||
{
|
||||
return Serialize(arc, key, style.AsDWORD, def ? &def->AsDWORD : nullptr);
|
||||
}
|
||||
|
||||
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
|
||||
Loading…
Reference in a new issue