Import aap/librw @ masterHEADmaster

Snapshot for re3/reVC vendoring, per @lzcnt.
Source: https://github.com/aap/librw (master).

1 files changed, 275 insertions, 0 deletions

diff --git a/src/rwengine.h b/src/rwengine.h
new file mode 100644
index 0000000..995f3ce
--- /dev/null
+++ b/src/rwengine.h
@@ -0,0 +1,275 @@
+namespace rw {
+
+// uhhhm..... why are these not actual functions?
+enum DeviceReq
+{
+	// Device initialization before Engine/Driver plugins are opened
+	DEVICEINIT,
+	// Device de-initialization after Engine/Driver plugins are closed
+	DEVICETERM,
+
+	// Device/Context creation
+	DEVICEOPEN,
+	// Device/Context shutdown
+	DEVICECLOSE,
+
+	// Device initialization after Engine/Driver plugins are opened
+	DEVICEFINALIZE,
+	// TODO? counterpart to FINALIZE?
+
+	// Video adapters
+	DEVICEGETNUMSUBSYSTEMS,
+	DEVICEGETCURRENTSUBSYSTEM,
+	DEVICESETSUBSYSTEM,
+	DEVICEGETSUBSSYSTEMINFO,
+
+	// Video modes
+	DEVICEGETNUMVIDEOMODES,
+	DEVICEGETCURRENTVIDEOMODE,
+	DEVICESETVIDEOMODE,
+	DEVICEGETVIDEOMODEINFO,
+
+	// Multisampling
+	DEVICEGETMAXMULTISAMPLINGLEVELS,
+	DEVICEGETMULTISAMPLINGLEVELS,
+	DEVICESETMULTISAMPLINGLEVELS,
+
+};
+
+typedef int DeviceSystem(DeviceReq req, void *arg, int32 n);
+
+struct Camera;
+struct Image;
+struct Texture;
+struct Raster;
+class ObjPipeline;
+
+// This is for the render device, we only have one
+struct Device
+{
+	float32 zNear, zFar;
+	void  (*beginUpdate)(Camera*);
+	void  (*endUpdate)(Camera*);
+	void  (*clearCamera)(Camera*, RGBA *col, uint32 mode);
+	void  (*showRaster)(Raster *raster, uint32 flags);
+	bool32 (*rasterRenderFast)(Raster *raster, int32 x, int32 y);
+	void  (*setRenderState)(int32 state, void *value);
+	void *(*getRenderState)(int32 state);
+
+	void   (*im2DRenderLine)(void *vertices, int32 numVertices, int32 vert1, int32 vert2);
+	void   (*im2DRenderTriangle)(void *vertices, int32 numVertices, int32 vert1, int32 vert2, int32 vert3);
+	void   (*im2DRenderPrimitive)(PrimitiveType primType, void *vertices, int32 numVertices);
+	void   (*im2DRenderIndexedPrimitive)(PrimitiveType primType, void *vertices, int32 numVertices, void *indices, int32 numIndices);
+
+	void (*im3DTransform)(void *vertices, int32 numVertices, Matrix *world, uint32 flags);
+	void (*im3DRenderPrimitive)(PrimitiveType primType);
+	void (*im3DRenderIndexedPrimitive)(PrimitiveType primType, void *indices, int32 numIndices);
+	void (*im3DEnd)(void);
+
+	DeviceSystem *system;
+};
+
+// This is for platform-dependent but portable things
+// so the engine has one for every platform
+struct Driver
+{
+	ObjPipeline *defaultPipeline;
+	int32 rasterNativeOffset;
+
+	Raster* (*rasterCreate)(Raster*);
+	uint8 *(*rasterLock)(Raster*, int32 level, int32 lockMode);
+	void   (*rasterUnlock)(Raster*, int32 level);
+	uint8 *(*rasterLockPalette)(Raster*, int32 lockMode);
+	void   (*rasterUnlockPalette)(Raster*);
+	int32  (*rasterNumLevels)(Raster*);
+	bool32 (*imageFindRasterFormat)(Image *img, int32 type,
+		int32 *width, int32 *height, int32 *depth, int32 *format);
+	bool32 (*rasterFromImage)(Raster*, Image*);
+	Image *(*rasterToImage)(Raster*);
+
+	static PluginList s_plglist[NUM_PLATFORMS];
+	static int32 registerPlugin(int32 platform, int32 size, uint32 id,
+	                            Constructor ctor, Destructor dtor){
+		return s_plglist[platform].registerPlugin(size, id,
+		                                          ctor, dtor, nil);
+	}
+};
+
+struct EngineOpenParams;
+
+enum MemHint
+{
+	MEMDUR_NA = 0,
+	// used inside function
+	MEMDUR_FUNCTION = 0x10000,
+	// used for one frame
+	MEMDUR_FRAME = 0x20000,
+	// used for longer time
+	MEMDUR_EVENT = 0x30000,
+	// used while the engine is running
+	MEMDUR_GLOBAL = 0x40000
+};
+
+struct MemoryFunctions
+{
+	void *(*rwmalloc)(size_t sz, uint32 hint);
+	void *(*rwrealloc)(void *p, size_t sz, uint32 hint);
+	void  (*rwfree)(void *p);
+	// These are temporary until we have better error handling
+	// TODO: Maybe don't put them here since they shouldn't really be switched out
+	void *(*rwmustmalloc)(size_t sz, uint32 hint);
+	void *(*rwmustrealloc)(void *p, size_t sz, uint32 hint);
+};
+
+struct FileFunctions
+{
+	void *(*rwfopen)(const char *path, const char *mode);
+	int (*rwfclose)(void *fp);
+	int (*rwfseek)(void *fp, long offset, int whence);
+	long (*rwftell)(void *fp);
+	size_t (*rwfread)(void *ptr, size_t size, size_t nmemb, void *fp);
+	size_t (*rwfwrite)(const void *ptr, size_t size, size_t nmemb, void *fp);
+	int (*rwfeof)(void *fp);
+};
+
+struct SubSystemInfo
+{
+	char name[80];
+};
+
+enum VideoModeFlags
+{
+	VIDEOMODEEXCLUSIVE = 1
+};
+
+struct VideoMode
+{
+	int32 width;
+	int32 height;
+	int32 depth;
+	uint32 flags;
+};
+
+struct Camera;
+struct World;
+
+// This is for platform independent things
+// TODO: move more stuff into this
+struct Engine
+{
+	enum State {
+		Dead = 0,
+		Initialized,
+		Opened,
+		Started
+	};
+	Camera *currentCamera;
+	World *currentWorld;
+	LinkList frameDirtyList;
+	FileFunctions filefuncs;
+
+	// Dynamically allocated because of plugins
+	Driver *driver[NUM_PLATFORMS];
+	Device device;
+	ObjPipeline *dummyDefaultPipeline;
+
+	// These must always be available
+	static MemoryFunctions memfuncs;
+	static State state;
+
+	static bool32 init(MemoryFunctions *memfuncs = nil);
+	static bool32 open(EngineOpenParams*);
+	static bool32 start(void);
+	static void term(void);
+	static void close(void);
+	static void stop(void);
+
+	static int32 getNumSubSystems(void);
+	static int32 getCurrentSubSystem(void);
+	static bool32 setSubSystem(int32 subsys);
+	static SubSystemInfo *getSubSystemInfo(SubSystemInfo *info, int32 subsys);
+
+	static int32 getNumVideoModes(void);
+	static int32 getCurrentVideoMode(void);
+	static bool32 setVideoMode(int32 mode);
+	static VideoMode *getVideoModeInfo(VideoMode *info, int32 mode);
+
+	static uint32 getMaxMultiSamplingLevels(void);
+	static uint32 getMultiSamplingLevels(void);
+	static bool32 setMultiSamplingLevels(uint32 levels);
+
+	static PluginList s_plglist;
+	static int32 registerPlugin(int32 size, uint32 id,
+	                            Constructor ctor, Destructor dtor){
+		return s_plglist.registerPlugin(size, id, ctor, dtor, nil);
+	}
+};
+
+extern Engine *engine;
+
+#define RWTOSTR_(X) #X
+#define RWTOSTR(X) RWTOSTR_(X)
+#define RWHERE "file: " __FILE__ " line: " RWTOSTR(__LINE__)
+
+extern const char *allocLocation;
+
+inline void *malloc_LOC(size_t sz, uint32 hint, const char *here) { allocLocation = here; return rw::Engine::memfuncs.rwmalloc(sz,hint); }
+inline void *realloc_LOC(void *p, size_t sz, uint32 hint, const char *here) { allocLocation = here; return rw::Engine::memfuncs.rwrealloc(p,sz,hint); }
+inline void *mustmalloc_LOC(size_t sz, uint32 hint, const char *here) { allocLocation = here; return rw::Engine::memfuncs.rwmustmalloc(sz,hint); }
+inline void *mustrealloc_LOC(void *p, size_t sz, uint32 hint, const char *here) { allocLocation = here; return rw::Engine::memfuncs.rwmustrealloc(p,sz,hint); }
+
+char *strdup_LOC(const char *s, uint32 hint, const char *here);
+
+#define rwMalloc(s, h) rw::malloc_LOC(s,h,RWHERE)
+#define rwMallocT(t, s, h) (t*)rw::malloc_LOC((s)*sizeof(t),h,RWHERE)
+#define rwRealloc(p, s, h) rw::realloc_LOC(p,s,h,RWHERE)
+#define rwReallocT(t, p, s, h) (t*)rw::realloc_LOC(p,(s)*sizeof(t),h,RWHERE)
+#define rwFree(p) rw::Engine::memfuncs.rwfree(p)
+#define rwNew(s, h) rw::mustmalloc_LOC(s,h,RWHERE)
+#define rwNewT(t, s, h) (t*)rw::mustmalloc_LOC((s)*sizeof(t),h,RWHERE)
+#define rwResize(p, s, h) rw::mustrealloc_LOC(p,s,h,RWHERE)
+#define rwResizeT(t, p, s, h) (t*)rw::mustrealloc_LOC(p,(s)*sizeof(t),h,RWHERE)
+#define rwStrdup(s, h) rw::strdup_LOC(s,h,RWHERE)
+
+extern MemoryFunctions defaultMemfuncs;
+extern MemoryFunctions managedMemfuncs;
+void printleaks(void);	// when using managed mem funcs
+
+namespace null {
+	void beginUpdate(Camera*);
+	void endUpdate(Camera*);
+	void clearCamera(Camera*, RGBA *col, uint32 mode);
+	void showRaster(Raster*, uint32 flags);
+
+	void   setRenderState(int32 state, void *value);
+	void  *getRenderState(int32 state);
+
+	bool32 rasterRenderFast(Raster *raster, int32 x, int32 y);
+
+	Raster *rasterCreate(Raster*);
+	uint8 *rasterLock(Raster*, int32 level, int32 lockMode);
+	void   rasterUnlock(Raster*, int32 level);
+	uint8 *rasterLockPalette(Raster*, int32 lockMode);
+	void   rasterUnlockPalette(Raster*);
+	int32  rasterNumLevels(Raster*);
+	bool32 imageFindRasterFormat(Image *img, int32 type,
+		int32 *width, int32 *height, int32 *depth, int32 *format);
+	bool32 rasterFromImage(Raster*, Image*);
+	Image *rasterToImage(Raster*);
+
+	void im2DRenderLine(void*, int32, int32, int32);
+	void im2DRenderTriangle(void*, int32, int32, int32, int32);
+	void im2DRenderPrimitive(PrimitiveType, void*, int32);
+	void im2DRenderIndexedPrimitive(PrimitiveType, void*, int32, void*, int32);
+
+	void im3DTransform(void *vertices, int32 numVertices, Matrix *world, uint32 flags);
+	void im3DRenderPrimitive(PrimitiveType primType);
+	void im3DRenderIndexedPrimitive(PrimitiveType primType, void *indices, int32 numIndices);
+	void im3DEnd(void);
+
+	int deviceSystem(DeviceReq req, void *arg0, int32 n);
+
+	extern Device renderdevice;
+}
+
+}