--- /dev/null
+/*
+Copyright (C) 2001-2006, William Joseph.
+All Rights Reserved.
+
+This file is part of GtkRadiant.
+
+GtkRadiant 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.
+
+GtkRadiant 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 GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+*/
+
+#include "md3.h"
+
+#include "ifilesystem.h"
+#include "imodel.h"
+
+#include "imagelib.h"
+#include "bytestreamutils.h"
+
+#include "model.h"
+#include "ident.h"
+#include "md3normals.h"
+
+// the maximum size of game reletive pathnames
+#define MAX_QPATH 64
+
+/*
+========================================================================
+
+.MD3 triangle model file format
+
+========================================================================
+*/
+
+const unsigned char MD3_IDENT[4] = { 'I', 'D', 'P', '3', };
+#define MD3_VERSION 15
+
+// limits
+#define MD3_MAX_LODS 4
+#define MD3_MAX_TRIANGLES 8192 // per surface
+#define MD3_MAX_VERTS 4096 // per surface
+#define MD3_MAX_SHADERS 256 // per surface
+#define MD3_MAX_FRAMES 1024 // per model
+#define MD3_MAX_SURFACES 32 // per model
+#define MD3_MAX_TAGS 16 // per frame
+
+// vertex scales
+#define MD3_XYZ_SCALE (1.f / 64)
+
+typedef float float3[3];
+
+void istream_read_float3(PointerInputStream& inputStream, float3 f)
+{
+ f[0] = istream_read_float32_le(inputStream);
+ f[1] = istream_read_float32_le(inputStream);
+ f[2] = istream_read_float32_le(inputStream);
+}
+
+typedef struct md3Frame_s {
+ float3 bounds[2];
+ float3 localOrigin;
+ float radius;
+ char name[16];
+} md3Frame_t;
+
+void istream_read_md3Frame(PointerInputStream& inputStream, md3Frame_t& frame)
+{
+ istream_read_float3(inputStream, frame.bounds[0]);
+ istream_read_float3(inputStream, frame.bounds[1]);
+ istream_read_float3(inputStream, frame.localOrigin);
+ frame.radius = istream_read_float32_le(inputStream);
+ inputStream.read(reinterpret_cast<unsigned char*>(frame.name), 16);
+}
+
+typedef struct md3Tag_s {
+ char name[MAX_QPATH]; // tag name
+ float3 origin;
+ float3 axis[3];
+} md3Tag_t;
+
+void istream_read_md3Shader(PointerInputStream& inputStream, md3Tag_t& tag)
+{
+ inputStream.read(reinterpret_cast<unsigned char*>(tag.name), MAX_QPATH);
+ istream_read_float3(inputStream, tag.origin);
+ istream_read_float3(inputStream, tag.axis[0]);
+ istream_read_float3(inputStream, tag.axis[1]);
+ istream_read_float3(inputStream, tag.axis[2]);
+}
+
+/*
+** md3Surface_t
+**
+** CHUNK SIZE
+** header sizeof( md3Surface_t )
+** shaders sizeof( md3Shader_t ) * numShaders
+** triangles[0] sizeof( md3Triangle_t ) * numTriangles
+** st sizeof( md3St_t ) * numVerts
+** XyzNormals sizeof( md3XyzNormal_t ) * numVerts * numFrames
+*/
+typedef struct {
+ char ident[4]; //
+
+ char name[MAX_QPATH]; // polyset name
+
+ int flags;
+ int numFrames; // all surfaces in a model should have the same
+
+ int numShaders; // all surfaces in a model should have the same
+ int numVerts;
+
+ int numTriangles;
+ int ofsTriangles;
+
+ int ofsShaders; // offset from start of md3Surface_t
+ int ofsSt; // texture coords are common for all frames
+ int ofsXyzNormals; // numVerts * numFrames
+
+ int ofsEnd; // next surface follows
+} md3Surface_t;
+
+void istream_read_md3Surface(PointerInputStream& inputStream, md3Surface_t& surface)
+{
+ inputStream.read(reinterpret_cast<unsigned char*>(surface.ident), 4);
+ inputStream.read(reinterpret_cast<unsigned char*>(surface.name), MAX_QPATH);
+ surface.flags = istream_read_int32_le(inputStream);
+ surface.numFrames = istream_read_int32_le(inputStream);
+ surface.numShaders = istream_read_int32_le(inputStream);
+ surface.numVerts = istream_read_int32_le(inputStream);
+ surface.numTriangles = istream_read_int32_le(inputStream);
+ surface.ofsTriangles = istream_read_int32_le(inputStream);
+ surface.ofsShaders = istream_read_int32_le(inputStream);
+ surface.ofsSt = istream_read_int32_le(inputStream);
+ surface.ofsXyzNormals = istream_read_int32_le(inputStream);
+ surface.ofsEnd = istream_read_int32_le(inputStream);
+}
+
+typedef struct {
+ char name[MAX_QPATH];
+ int shaderIndex; // for in-game use
+} md3Shader_t;
+
+void istream_read_md3Shader(PointerInputStream& inputStream, md3Shader_t& shader)
+{
+ inputStream.read(reinterpret_cast<unsigned char*>(shader.name), MAX_QPATH);
+ shader.shaderIndex = istream_read_int32_le(inputStream);
+}
+
+typedef struct {
+ int indexes[3];
+} md3Triangle_t;
+
+void istream_read_md3Triangle(PointerInputStream& inputStream, md3Triangle_t& triangle)
+{
+ triangle.indexes[0] = istream_read_int32_le(inputStream);
+ triangle.indexes[1] = istream_read_int32_le(inputStream);
+ triangle.indexes[2] = istream_read_int32_le(inputStream);
+}
+
+typedef struct {
+ float st[2];
+} md3St_t;
+
+void istream_read_md3St(PointerInputStream& inputStream, md3St_t& st)
+{
+ st.st[0] = istream_read_float32_le(inputStream);
+ st.st[1] = istream_read_float32_le(inputStream);
+}
+
+typedef struct {
+ short xyz[3];
+ short normal;
+} md3XyzNormal_t;
+
+void istream_read_md3XyzNormal(PointerInputStream& inputStream, md3XyzNormal_t& xyz)
+{
+ xyz.xyz[0] = istream_read_int16_le(inputStream);
+ xyz.xyz[1] = istream_read_int16_le(inputStream);
+ xyz.xyz[2] = istream_read_int16_le(inputStream);
+ xyz.normal = istream_read_int16_le(inputStream);
+}
+
+typedef struct {
+ char ident[4];
+ int version;
+
+ char name[MAX_QPATH]; // model name
+
+ int flags;
+
+ int numFrames;
+ int numTags;
+ int numSurfaces;
+
+ int numSkins;
+
+ int ofsFrames; // offset for first frame
+ int ofsTags; // numFrames * numTags
+ int ofsSurfaces; // first surface, others follow
+
+ int ofsEnd; // end of file
+} md3Header_t;
+
+void istream_read_md3Header(PointerInputStream& inputStream, md3Header_t& header)
+{
+ inputStream.read(reinterpret_cast<unsigned char*>(header.ident), 4);
+ header.version = istream_read_int32_le(inputStream);
+ inputStream.read(reinterpret_cast<unsigned char*>(header.name), MAX_QPATH);
+ header.flags = istream_read_int32_le(inputStream);
+ header.numFrames = istream_read_int32_le(inputStream);
+ header.numTags = istream_read_int32_le(inputStream);
+ header.numSurfaces = istream_read_int32_le(inputStream);
+ header.numSkins = istream_read_int32_le(inputStream);
+ header.ofsFrames = istream_read_int32_le(inputStream);
+ header.ofsTags = istream_read_int32_le(inputStream);
+ header.ofsSurfaces = istream_read_int32_le(inputStream);
+ header.ofsEnd = istream_read_int32_le(inputStream);
+}
+
+int MD3Surface_read(Surface& surface, unsigned char* buffer)
+{
+ md3Surface_t md3Surface;
+ {
+ PointerInputStream inputStream(buffer);
+ istream_read_md3Surface(inputStream, md3Surface);
+ }
+
+ {
+ surface.vertices().reserve(md3Surface.numVerts);
+
+ PointerInputStream xyzNormalStream(buffer + md3Surface.ofsXyzNormals);
+ PointerInputStream stStream(buffer + md3Surface.ofsSt);
+
+ // read verts into vertex array - xyz, st, normal
+ for(int i = 0; i < md3Surface.numVerts; i++)
+ {
+ md3XyzNormal_t md3Xyz;
+ istream_read_md3XyzNormal(xyzNormalStream, md3Xyz);
+
+ md3St_t md3St;
+ istream_read_md3St(stStream, md3St);
+
+ surface.vertices().push_back(
+ ArbitraryMeshVertex(
+ Vertex3f( md3Xyz.xyz[0] * MD3_XYZ_SCALE, md3Xyz.xyz[1] * MD3_XYZ_SCALE, md3Xyz.xyz[2] * MD3_XYZ_SCALE),
+ DecodeNormal(reinterpret_cast<byte*>(&md3Xyz.normal)),
+ TexCoord2f(md3St.st[0], md3St.st[1])
+ )
+ );
+ }
+ }
+
+ {
+ surface.indices().reserve(md3Surface.numTriangles * 3);
+
+ PointerInputStream inputStream(buffer + md3Surface.ofsTriangles);
+ for(int i = 0; i < md3Surface.numTriangles; i++)
+ {
+ md3Triangle_t md3Triangle;
+ istream_read_md3Triangle(inputStream, md3Triangle);
+ surface.indices().insert(md3Triangle.indexes[0]);
+ surface.indices().insert(md3Triangle.indexes[1]);
+ surface.indices().insert(md3Triangle.indexes[2]);
+ }
+ }
+
+ {
+ md3Shader_t md3Shader;
+ {
+ PointerInputStream inputStream(buffer + md3Surface.ofsShaders);
+ istream_read_md3Shader(inputStream, md3Shader);
+ }
+ surface.setShader(md3Shader.name);
+ }
+
+ surface.updateAABB();
+
+ return md3Surface.ofsEnd;
+}
+
+void MD3Model_read(Model& model, unsigned char* buffer)
+{
+ md3Header_t md3Header;
+ {
+ PointerInputStream inputStream(buffer);
+ istream_read_md3Header(inputStream, md3Header);
+ }
+
+ unsigned char* surfacePosition = buffer + md3Header.ofsSurfaces;
+
+ for(int i = 0; i != md3Header.numSurfaces; ++i)
+ {
+ surfacePosition += MD3Surface_read(model.newSurface(), surfacePosition);
+ }
+
+ model.updateAABB();
+}
+
+scene::Node& MD3Model_new(unsigned char* buffer)
+{
+ ModelNode* modelNode = new ModelNode();
+ MD3Model_read(modelNode->model(), buffer);
+ return modelNode->node();
+}
+
+scene::Node& MD3Model_default()
+{
+ ModelNode* modelNode = new ModelNode();
+ Model_constructNull(modelNode->model());
+ return modelNode->node();
+}
+
+scene::Node& MD3Model_fromBuffer(unsigned char* buffer)
+{
+ if (!ident_equal(buffer, MD3_IDENT))
+ {
+ globalErrorStream() << "MD3 read error: incorrect ident\n";
+ return MD3Model_default();
+ }
+ else
+ {
+ return MD3Model_new(buffer);
+ }
+}
+
+scene::Node& loadMD3Model(ArchiveFile& file)
+{
+ ScopedArchiveBuffer buffer(file);
+ return MD3Model_fromBuffer(buffer.buffer);
+}
+
projects / voretournament / voretournament.git / blobdiff