implemented userdata plugin

2025-12-18 16:39:51 +00:00 · 2017-08-23 12:21:23 +02:00
parent efec4e5acc
commit 6d38dea0d9
9 changed files with 563 additions and 10 deletions
--- a/src/rwbase.h
+++ b/src/rwbase.h
@@ -431,6 +431,7 @@ enum PluginID
 	ID_SKYMIPMAP     = MAKEPLUGINID(VEND_CRITERIONTK, 0x10),
 	ID_SKIN          = MAKEPLUGINID(VEND_CRITERIONTK, 0x16),
 	ID_HANIMPLUGIN   = MAKEPLUGINID(VEND_CRITERIONTK, 0x1E),
+	ID_USERDATA      = MAKEPLUGINID(VEND_CRITERIONTK, 0x1F),
 	ID_MATFX         = MAKEPLUGINID(VEND_CRITERIONTK, 0x20),
 	ID_PDS           = MAKEPLUGINID(VEND_CRITERIONTK, 0x31),
 	ID_ADC           = MAKEPLUGINID(VEND_CRITERIONTK, 0x34),
--- a/src/rwuserdata.h
+++ b/src/rwuserdata.h
@@ -0,0 +1,83 @@
+namespace rw {
+
+enum UserDataType
+{
+	USERDATANA = 0,
+	USERDATAINT = 1,
+	USERDATAFLOAT = 2,
+	USERDATASTRING = 3,
+};
+
+struct UserDataArray
+{
+	char *name;
+	uint32 datatype;
+	int32 numElements;
+	void *data;
+
+	int32 getInt(int32 n) { return ((int32*)this->data)[n]; }
+	float32 getFloat(int32 n) { return ((float32*)this->data)[n]; }
+	char *getString(int32 n) { return ((char**)this->data)[n]; }
+	void setInt(int32 n, int32 i) { ((int32*)this->data)[n] = i; }
+	void setFloat(int32 n, float32 f) { ((float32*)this->data)[n] = f; }
+	void setString(int32 n, const char *s);
+
+	static int32 geometryAdd(Geometry *g, const char *name, int32 datatype, int32 numElements);
+	static void geometryRemove(Geometry *g, int32 n);
+	static int32 geometryGetCount(Geometry *g);
+	static UserDataArray *geometryGet(Geometry *g, int32 n);
+	static int32 geometryFindIndex(Geometry *g, const char *name);
+
+	static int32 frameAdd(Frame *f, const char *name, int32 datatype, int32 numElements);
+	static void frameRemove(Frame *f, int32 n);
+	static int32 frameGetCount(Frame *f);
+	static UserDataArray *frameGet(Frame *f, int32 n);
+	static int32 frameFindIndex(Frame *f, const char *name);
+
+	static int32 cameraAdd(Camera *c, const char *name, int32 datatype, int32 numElements);
+	static void cameraRemove(Camera *c, int32 n);
+	static int32 cameraGetCount(Camera *c);
+	static UserDataArray *cameraGet(Camera *c, int32 n);
+	static int32 cameraFindIndex(Camera *c, const char *name);
+
+	static int32 lightAdd(Light *l, const char *name, int32 datatype, int32 numElements);
+	static void lightRemove(Light *l, int32 n);
+	static int32 lightGetCount(Light *l);
+	static UserDataArray *lightGet(Light *l, int32 n);
+	static int32 lightFindIndex(Light *l, const char *name);
+
+	static int32 materialAdd(Material *m, const char *name, int32 datatype, int32 numElements);
+	static void materialRemove(Material *m, int32 n);
+	static int32 materialGetCount(Material *m);
+	static UserDataArray *materialGet(Material *m, int32 n);
+	static int32 materialFindIndex(Material *m, const char *name);
+
+	static int32 textureAdd(Texture *t, const char *name, int32 datatype, int32 numElements);
+	static void textureRemove(Texture *t, int32 n);
+	static int32 textureGetCount(Texture *t);
+	static UserDataArray *textureGet(Texture *t, int32 n);
+	static int32 textureFindIndex(Texture *t, const char *name);
+};
+
+struct UserDataExtension
+{
+	int32 numArrays;
+	UserDataArray *arrays;
+
+	// TODO: static accessors
+};
+
+struct UserDataGlobals
+{
+	int32 geometryOffset;
+	int32 frameOffset;
+	int32 cameraOffset;
+	int32 lightOffset;
+	int32 materialOffset;
+	int32 textureOffset;
+};
+extern UserDataGlobals userDataGlobals;
+
+void registerUserDataPlugin(void);
+
+}
--- a/src/userdata.cpp
+++ b/src/userdata.cpp
@@ -0,0 +1,354 @@
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <cassert>
+
+#include "rwbase.h"
+#include "rwerror.h"
+#include "rwplg.h"
+#include "rwpipeline.h"
+#include "rwobjects.h"
+#include "rwengine.h"
+#include "rwuserdata.h"
+
+#define PLUGIN_ID ID_USERDATA
+
+namespace rw {
+
+UserDataGlobals userDataGlobals;
+
+void
+UserDataArray::setString(int32 n, const char *s)
+{
+	int32 len;
+	char **sp = &((char**)this->data)[n];
+	free(*sp);
+	len = strlen(s)+1;
+	*sp = (char*)malloc(len);
+	if(*sp)
+		strncpy(*sp, s, len);
+}
+
+static void*
+createUserData(void *object, int32 offset, int32)
+{
+	UserDataExtension *ext = PLUGINOFFSET(UserDataExtension, object, offset);
+	ext->numArrays = 0;
+	ext->arrays = nil;
+	return object;
+}
+
+static void*
+destroyUserData(void *object, int32 offset, int32)
+{
+	int32 i, j;
+	char **strar;
+	UserDataArray *a;
+	UserDataExtension *ext = PLUGINOFFSET(UserDataExtension, object, offset);
+	a = ext->arrays;
+	for(i = 0; i < ext->numArrays; i++){
+		free(a->name);
+		switch(a->datatype){
+		case USERDATASTRING:
+			strar = (char**)a->data;
+			for(j = 0; j < a->numElements; j++)
+				free(strar[j]);
+			/* fallthrough */
+		case USERDATAINT:
+		case USERDATAFLOAT:
+			free(a->data);
+			break;
+		}
+		a++;
+	}
+	free(ext->arrays);
+	ext->numArrays = 0;
+	ext->arrays = nil;
+	return object;
+}
+
+static void*
+copyUserData(void *dst, void *src, int32 offset, int32)
+{
+	int32 i, j;
+	char **srcstrar, **dststrar;
+	UserDataArray *srca, *dsta;
+	UserDataExtension *srcext = PLUGINOFFSET(UserDataExtension, src, offset);
+	UserDataExtension *dstext = PLUGINOFFSET(UserDataExtension, dst, offset);
+	dstext->numArrays = srcext->numArrays;
+	dstext->arrays = (UserDataArray*)malloc(dstext->numArrays*sizeof(UserDataArray));
+	srca = srcext->arrays;
+	dsta = srcext->arrays;
+	for(i = 0; i < srcext->numArrays; i++){
+		int32 len = strlen(srca->name)+1;
+		dsta->name = (char*)malloc(len);
+		strncpy(dsta->name, srca->name, len);
+		dsta->datatype = srca->datatype;
+		dsta->numElements = srca->numElements;
+		switch(srca->datatype){
+		case USERDATAINT:
+			dsta->data = (int32*)malloc(sizeof(int32)*dsta->numElements);
+			memcpy(dsta->data, srca->data, sizeof(int32)*dsta->numElements);
+			break;
+		case USERDATAFLOAT:
+			dsta->data = (float32*)malloc(sizeof(float32)*dsta->numElements);
+			memcpy(dsta->data, srca->data, sizeof(float32)*dsta->numElements);
+			break;
+		case USERDATASTRING:
+			dststrar = (char**)malloc(sizeof(char*)*dsta->numElements);
+			dsta->data = dststrar;
+			for(j = 0; j < dsta->numElements; j++){
+				len = strlen(srcstrar[j])+1;
+				dststrar[j] = (char*)malloc(len);
+				strncpy(dststrar[j], srcstrar[j], len);
+			}
+			break;
+		}
+		srca++;
+		dsta++;
+	}
+	return dst;
+}
+
+static Stream*
+readUserData(Stream *stream, int32, void *object, int32 offset, int32)
+{
+	int32 i, j;
+	char **strar;
+	UserDataArray *a;
+	UserDataExtension *ext = PLUGINOFFSET(UserDataExtension, object, offset);
+	ext->numArrays = stream->readI32();
+	ext->arrays = (UserDataArray*)malloc(ext->numArrays*sizeof(UserDataArray));
+	a = ext->arrays;
+	for(i = 0; i < ext->numArrays; i++){
+		int32 len = stream->readI32();
+		a->name = (char*)malloc(len);
+		stream->read(a->name, len);
+		a->datatype = stream->readU32();
+		a->numElements = stream->readI32();
+		switch(a->datatype){
+		case USERDATAINT:
+			a->data = (int32*)malloc(sizeof(int32)*a->numElements);
+			stream->read(a->data, sizeof(int32)*a->numElements);
+			break;
+		case USERDATAFLOAT:
+			a->data = (float32*)malloc(sizeof(float32)*a->numElements);
+			stream->read(a->data, sizeof(float32)*a->numElements);
+			break;
+		case USERDATASTRING:
+			strar = (char**)malloc(sizeof(char*)*a->numElements);
+			a->data = strar;
+			for(j = 0; j < a->numElements; j++){
+				len = stream->readI32();
+				strar[j] = (char*)malloc(len);
+				stream->read(strar[j], len);
+			}
+			break;
+		}
+		a++;
+	}
+	return stream;
+}
+
+static Stream*
+writeUserData(Stream *stream, int32, void *object, int32 offset, int32)
+{
+	int32 len;
+	int32 i, j;
+	char **strar;
+	UserDataArray *a;
+	UserDataExtension *ext = PLUGINOFFSET(UserDataExtension, object, offset);
+	stream->writeI32(ext->numArrays);
+	a = ext->arrays;
+	for(i = 0; i < ext->numArrays; i++){
+		len = strlen(a->name)+1;
+		stream->writeI32(len);
+		stream->write(a->name, len);
+		stream->writeU32(a->datatype);
+		stream->writeI32(a->numElements);
+		switch(a->datatype){
+		case USERDATAINT:
+			stream->write(a->data, sizeof(int32)*a->numElements);
+			break;
+		case USERDATAFLOAT:
+			stream->write(a->data, sizeof(float32)*a->numElements);
+			break;
+		case USERDATASTRING:
+			strar = (char**)a->data;
+			for(j = 0; j < a->numElements; j++){
+				len = strlen(strar[j])+1;
+				stream->writeI32(len);
+				stream->write(strar[j], len);
+			}
+			break;
+		}
+		a++;
+	}
+	return stream;
+}
+
+static int32
+getSizeUserData(void *object, int32 offset, int32)
+{
+	int32 len;
+	int32 i, j;
+	char **strar;
+	int32 size;
+	UserDataArray *a;
+	UserDataExtension *ext = PLUGINOFFSET(UserDataExtension, object, offset);
+	if(ext->numArrays == 0)
+		return 0;
+	size = 4;	// numArrays
+	a = ext->arrays;
+	for(i = 0; i < ext->numArrays; i++){
+		len = strlen(a->name)+1;
+		size += 4 + len + 4 + 4;	// name len, name, type, numElements
+		switch(a->datatype){
+		case USERDATAINT:
+			size += sizeof(int32)*a->numElements;
+			break;
+		case USERDATAFLOAT:
+			size += sizeof(float32)*a->numElements;
+			break;
+		case USERDATASTRING:
+			strar = (char**)a->data;
+			for(j = 0; j < a->numElements; j++){
+				len = strlen(strar[j])+1;
+				size += 4 + len;	// len and string
+			}
+			break;
+		}
+		a++;
+	}
+	return size;
+}
+
+static int32
+add(UserDataExtension *ext, const char *name, int32 datatype, int32 numElements)
+{
+	int32 i;
+	int32 len;
+	int32 typesz;
+	UserDataArray *a;
+	// try to find empty slot
+	for(i = 0; i < ext->numArrays; i++)
+		if(ext->arrays[i].datatype == USERDATANA)
+			goto alloc;
+	// have to realloc
+	a = (UserDataArray*)malloc((ext->numArrays+1)*sizeof(UserDataArray));
+	if(a == nil)
+		return -1;
+	memcpy(a, ext->arrays, ext->numArrays*sizeof(UserDataArray));
+	free(ext->arrays);
+	ext->arrays = a;
+	i = ext->numArrays++;
+alloc:
+	a = &ext->arrays[i];
+	len = strlen(name)+1;
+	a->name = (char*)malloc(len+1);
+	assert(a->name);
+	strncpy(a->name, name, len);
+	a->datatype = datatype;
+	a->numElements = numElements;
+	typesz = datatype == USERDATAINT ? sizeof(int32) :
+		datatype == USERDATAFLOAT ? sizeof(float32) :
+		datatype == USERDATASTRING ? sizeof(char*) : 0;
+	a->data = malloc(typesz*numElements);
+	assert(a->data);
+	memset(a->data, 0, typesz*numElements);
+	return i;
+}
+
+static void
+remove(UserDataExtension *ext, int32 n)
+{
+	int32 i;
+	UserDataArray *a = &ext->arrays[n];
+	if(a->name){
+		free(a->name);
+		a->name = nil;
+	}
+	if(a->datatype == USERDATASTRING)
+		for(i = 0; i < a->numElements; i++)
+			free(((char**)a->data)[i]);
+	if(a->data){
+		free(a->data);
+		a->data = nil;
+	}
+	a->datatype = USERDATANA;
+	a->numElements = 0;
+}
+
+#define ACCESSOR(TYPE, NAME) \
+int32 \
+UserDataArray::##NAME##Add(TYPE *t, const char *name, int32 datatype, int32 numElements) \
+{ \
+	return add(PLUGINOFFSET(UserDataExtension, t, userDataGlobals.##NAME##Offset), \
+		name, datatype, numElements); \
+} \
+void \
+UserDataArray::##NAME##Remove(TYPE *t, int32 n) \
+{ \
+	remove(PLUGINOFFSET(UserDataExtension, t, userDataGlobals.##NAME##Offset), n); \
+} \
+int32 \
+UserDataArray::##NAME##GetCount(TYPE *t) \
+{ \
+	return PLUGINOFFSET(UserDataExtension, t, userDataGlobals.##NAME##Offset)->numArrays; \
+} \
+UserDataArray* \
+UserDataArray::##NAME##Get(TYPE *t, int32 n) \
+{ \
+	if(n >= PLUGINOFFSET(UserDataExtension, t, userDataGlobals.##NAME##Offset)->numArrays) \
+		return nil; \
+	return &PLUGINOFFSET(UserDataExtension, t, userDataGlobals.##NAME##Offset)->arrays[n]; \
+} \
+int32 \
+UserDataArray::##NAME##FindIndex(TYPE *t, const char *name) \
+{ \
+	int32 i; \
+	UserDataExtension *ext = PLUGINOFFSET(UserDataExtension, t, userDataGlobals.##NAME##Offset); \
+	for(i = 0; i < ext->numArrays; i++) \
+		if(strcmp(ext->arrays[i].name, name) == 0) \
+			return i; \
+	return -1; \
+}
+
+ACCESSOR(Geometry, geometry)
+ACCESSOR(Frame, frame)
+ACCESSOR(Camera, camera)
+ACCESSOR(Light, light)
+ACCESSOR(Material, material)
+ACCESSOR(Texture, texture)
+
+void
+registerUserDataPlugin(void)
+{
+	// TODO: World Sector
+
+	userDataGlobals.geometryOffset = Geometry::registerPlugin(sizeof(UserDataExtension),
+		ID_USERDATA, createUserData, destroyUserData, copyUserData);
+	Geometry::registerPluginStream(ID_USERDATA, readUserData, writeUserData, getSizeUserData);
+
+	userDataGlobals.frameOffset = Frame::registerPlugin(sizeof(UserDataExtension),
+		ID_USERDATA, createUserData, destroyUserData, copyUserData);
+	Frame::registerPluginStream(ID_USERDATA, readUserData, writeUserData, getSizeUserData);
+
+	userDataGlobals.cameraOffset = Camera::registerPlugin(sizeof(UserDataExtension),
+		ID_USERDATA, createUserData, destroyUserData, copyUserData);
+	Camera::registerPluginStream(ID_USERDATA, readUserData, writeUserData, getSizeUserData);
+
+	userDataGlobals.lightOffset = Light::registerPlugin(sizeof(UserDataExtension),
+		ID_USERDATA, createUserData, destroyUserData, copyUserData);
+	Light::registerPluginStream(ID_USERDATA, readUserData, writeUserData, getSizeUserData);
+
+	userDataGlobals.materialOffset = Material::registerPlugin(sizeof(UserDataExtension),
+		ID_USERDATA, createUserData, destroyUserData, copyUserData);
+	Material::registerPluginStream(ID_USERDATA, readUserData, writeUserData, getSizeUserData);
+
+	userDataGlobals.textureOffset = Texture::registerPlugin(sizeof(UserDataExtension),
+		ID_USERDATA, createUserData, destroyUserData, copyUserData);
+	Texture::registerPluginStream(ID_USERDATA, readUserData, writeUserData, getSizeUserData);
+}
+
+}