initial stab at the shared sprite model loader. The gl texture is NOT created

but everything should be in a sane state to do so.

libs/models/sprite/sprite.c

@@ -0,0 +1,206 @@
+/*
+	sprite.c
+
+	sprite model loading
+
+	Copyright (C) 1996-1997  Id Software, Inc.
+
+	This program is free software; you can redistribute it and/or
+	modify it under the terms of the GNU General Public License
+	as published by the Free Software Foundation; either version 2
+	of the License, or (at your option) any later version.
+
+	This program is distributed in the hope that it will be useful,
+	but WITHOUT ANY WARRANTY; without even the implied warranty of
+	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+	See the GNU General Public License for more details.
+
+	You should have received a copy of the GNU General Public License
+	along with this program; if not, write to:
+
+		Free Software Foundation, Inc.
+		59 Temple Place - Suite 330
+		Boston, MA  02111-1307, USA
+
+	$Id$
+*/
+
+// models are the only shared resource between a client and server running
+// on the same machine.
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include "compat.h"
+#include "model.h"
+#include "qendian.h"
+#include "sys.h"
+#include "texture.h"
+
+//extern model_t *loadmodel;
+extern char loadname[];
+
+/*
+	Mod_LoadSpriteFrame
+*/
+void       *
+Mod_LoadSpriteFrame (void *pin, mspriteframe_t **ppframe, int framenum)
+{
+	dspriteframe_t *pinframe;
+	mspriteframe_t *pspriteframe;
+	int         width, height, size, origin[2];
+	int         texsize;
+
+	pinframe = (dspriteframe_t *) pin;
+
+	width = LittleLong (pinframe->width);
+	height = LittleLong (pinframe->height);
+	size = width * height;
+
+	pspriteframe = Hunk_AllocName (sizeof (mspriteframe_t), loadname);
+
+	texsize = varsizeof (tex_t, data, size);
+	pspriteframe->texture = Hunk_AllocName (texsize, loadname);
+	pspriteframe->gl_texturenum = -1;
+
+	*ppframe = pspriteframe;
+
+	pspriteframe->texture->width = width;
+	pspriteframe->texture->height = height;
+	origin[0] = LittleLong (pinframe->origin[0]);
+	origin[1] = LittleLong (pinframe->origin[1]);
+
+	pspriteframe->up = origin[1];
+	pspriteframe->down = origin[1] - height;
+	pspriteframe->left = origin[0];
+	pspriteframe->right = width + origin[0];
+
+	memcpy (pspriteframe->texture->data, (byte *) (pinframe + 1), size);
+
+	return (void *) ((byte *) pinframe + sizeof (dspriteframe_t) + size);
+}
+
+/*
+	Mod_LoadSpriteGroup
+*/
+void       *
+Mod_LoadSpriteGroup (void *pin, mspriteframe_t **ppframe, int framenum)
+{
+	dspritegroup_t *pingroup;
+	mspritegroup_t *pspritegroup;
+	int         i, numframes;
+	dspriteinterval_t *pin_intervals;
+	float      *poutintervals;
+	void       *ptemp;
+
+	pingroup = (dspritegroup_t *) pin;
+
+	numframes = LittleLong (pingroup->numframes);
+
+	pspritegroup = Hunk_AllocName (sizeof (mspritegroup_t) +
+								   (numframes -
+									1) * sizeof (pspritegroup->frames[0]),
+
+								   loadname);
+
+	pspritegroup->numframes = numframes;
+
+	*ppframe = (mspriteframe_t *) pspritegroup;
+
+	pin_intervals = (dspriteinterval_t *) (pingroup + 1);
+
+	poutintervals = Hunk_AllocName (numframes * sizeof (float), loadname);
+
+	pspritegroup->intervals = poutintervals;
+
+	for (i = 0; i < numframes; i++) {
+		*poutintervals = LittleFloat (pin_intervals->interval);
+		if (*poutintervals <= 0.0)
+			Sys_Error ("Mod_LoadSpriteGroup: interval<=0");
+
+		poutintervals++;
+		pin_intervals++;
+	}
+
+	ptemp = (void *) pin_intervals;
+
+	for (i = 0; i < numframes; i++) {
+		ptemp =
+			Mod_LoadSpriteFrame (ptemp, &pspritegroup->frames[i],
+								 framenum * 100 + i);
+	}
+
+	return ptemp;
+}
+
+/*
+	Mod_LoadSpriteModel
+*/
+void
+Mod_LoadSpriteModel (model_t *mod, void *buffer)
+{
+	int         i;
+	int         version;
+	dsprite_t  *pin;
+	msprite_t  *psprite;
+	int         numframes;
+	int         size;
+	dspriteframetype_t *pframetype;
+
+	pin = (dsprite_t *) buffer;
+
+	version = LittleLong (pin->version);
+	if (version != SPRITE_VERSION)
+		Sys_Error ("%s has wrong version number "
+				  "(%i should be %i)", mod->name, version, SPRITE_VERSION);
+
+	numframes = LittleLong (pin->numframes);
+	if (numframes < 1)
+		Sys_Error ("Mod_LoadSpriteModel: Invalid # of frames: %d\n", numframes);
+
+	size = varsizeof (msprite_t, frames, numframes);
+
+	psprite = Hunk_AllocName (size, loadname);
+
+	mod->cache.data = psprite;
+
+	psprite->type = LittleLong (pin->type);
+	psprite->maxwidth = LittleLong (pin->width);
+	psprite->maxheight = LittleLong (pin->height);
+	psprite->beamlength = LittleFloat (pin->beamlength);
+	mod->synctype = LittleLong (pin->synctype);
+	psprite->numframes = numframes;
+
+	mod->mins[0] = mod->mins[1] = -psprite->maxwidth / 2;
+	mod->maxs[0] = mod->maxs[1] = psprite->maxwidth / 2;
+	mod->mins[2] = -psprite->maxheight / 2;
+	mod->maxs[2] = psprite->maxheight / 2;
+
+//
+// load the frames
+//
+	mod->numframes = numframes;
+
+	pframetype = (dspriteframetype_t *) (pin + 1);
+
+	for (i = 0; i < numframes; i++) {
+		spriteframetype_t frametype;
+
+		frametype = LittleLong (pframetype->type);
+		psprite->frames[i].type = frametype;
+
+		if (frametype == SPR_SINGLE) {
+			pframetype = (dspriteframetype_t *)
+				Mod_LoadSpriteFrame (pframetype + 1,
+									 &psprite->frames[i].frameptr, i);
+		} else {
+			pframetype = (dspriteframetype_t *)
+				Mod_LoadSpriteGroup (pframetype + 1,
+									 &psprite->frames[i].frameptr, i);
+		}
+	}
+
+	mod->type = mod_sprite;
+}