Cube  Check-in [14861826d4]

Overview
Comment:Move classes into separate files
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk
Files: files | file ages | folders
SHA3-256: 14861826d4c1f561aca909afe773366a46b57b20cf41fd668092dfb98d960d80
User & Date: js on 2025-03-05 23:18:28
Other Links: manifest | tags
Context
2025-03-06
00:34
Clean up menus and text drawing check-in: f17992369e user: js tags: trunk
2025-03-05
23:18
Move classes into separate files check-in: 14861826d4 user: js tags: trunk
22:42
More file handling cleanups check-in: c09457f7ad user: js tags: trunk
Changes
Hide Diffs Side-by-Side Diffs Ignore Whitespace Patch

Modified meson.build from [c0a1562e22] to [145d90f49a]. 

1

2
3

4
5
6
7
8
9







10
11
12
13
14
15
16


1
2
3
4






5
6
7
8
9
10
11
12
13
14
15
16
17
18

-
+


+
-
-
-
-
-
-
+
+
+
+
+
+
+








project('Cube', ['c', 'objcpp'],
project('Cube', ['c', 'objc', 'objcpp'],
  meson_version: '>=1.5.0')

foreach lang : ['objc', 'objcpp']
add_global_arguments(
  [
    '-fobjc-arc',
    '-fobjc-arc-exceptions'
  ],
  language: 'objcpp')
  add_global_arguments(
    [
      '-fobjc-arc',
      '-fobjc-arc-exceptions'
    ],
    language: lang)
endforeach

objfw_dep = dependency('objfw')
sdl_dep = dependency('SDL2')
sdlimage_dep = dependency('SDL2_image')
sdlmixer_dep = dependency('SDL2_mixer')
zlib_dep = dependency('zlib')
︙

Added src/Ident.h version [e4880063ad].

Added src/Ident.m version [2e1b68d918].

Added src/KeyMapping.h version [791a955c77].

Added src/KeyMapping.m version [c90f999690].

Added src/MD2.h version [4f18777375].

Added src/MD2.mm version [e752e43195].

Added src/MapModelInfo.h version [340f29da11].

Added src/MapModelInfo.m version [a1a57242f0].

Modified src/command.mm from [c9d2804930] to [2baac4db66]. 

1
2
3
4
5
6
7
8
9

10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

1
2
3
4
5
6
7


8













9
10
11
12
13
14
15








-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-








// command.cpp: implements the parsing and execution of a tiny script language
// which is largely backwards compatible with the quake console language.

#include "cube.h"

#include <memory>

enum { ID_VAR, ID_COMMAND, ID_ALIAS };

#import "Ident.h"
@interface Ident : OFObject
@property (nonatomic) int type; // one of ID_* above
@property (copy, nonatomic) OFString *name;
@property (nonatomic) int min, max;           // ID_VAR
@property (nonatomic) int *storage;           // ID_VAR
@property (nonatomic) void (*fun)();          // ID_VAR, ID_COMMAND
@property (nonatomic) int narg;               // ID_VAR, ID_COMMAND
@property (copy, nonatomic) OFString *action; // ID_ALIAS
@property (nonatomic) bool persist;
@end

@implementation Ident
@end

void
itoa(char *s, int i)
{
	sprintf_s(s)("%d", i);
}
︙

Modified src/console.mm from [20418af9a4] to [cf67d004cd]. 

1
2
3
4
5
6
7


8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16








+
+








// console.cpp: the console buffer, its display, and command line control

#include "cube.h"

#include <ctype.h>
#include <memory>

#import "KeyMapping.h"

struct cline {
	char *cref;
	int outtime;
};
vector<cline> conlines;

const int ndraw = 5;
︙
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

91
92
93
94
95
96
97




















98
99
100
101
102
103
104








-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-








		draw_text(refs[j], FONTH / 3,
		    (FONTH / 4 * 5) * (nd - j - 1) + FONTH / 3, 2);
	};
};

// keymap is defined externally in keymap.cfg

@interface KeyMapping : OFObject
@property (readonly) int code;
@property (readonly, nonatomic) OFString *name;
@property (copy, nonatomic) OFString *action;

- (instancetype)initWithCode:(int)code name:(OFString *)name;
@end

@implementation KeyMapping
- (instancetype)initWithCode:(int)code name:(OFString *)name
{
	self = [super init];

	_code = code;
	_name = [name copy];

	return self;
}
@end

static OFMutableArray<KeyMapping *> *keyMappings = nil;

void
keymap(OFString *code, OFString *key, OFString *action)
{
	if (keyMappings == nil)
		keyMappings = [[OFMutableArray alloc] init];
︙

Modified src/cube.h from [a3e2530d8c] to [10a4604932].

︙
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

111
112
113
114
115
116
117











118
119
120
121
122
123
124








-
-
-
-
-
-
-
-
-
-
-








	((x) < MINBORD || (y) < MINBORD || (x) >= ssize - MINBORD ||           \
	    (y) >= ssize - MINBORD)

struct block {
	int x, y, xs, ys;
};

@interface MapModelInfo : OFObject
@property (nonatomic) int rad, h, zoff, snap;
@property (copy, nonatomic) OFString *name;

- (instancetype)initWithRad:(int)rad
                          h:(int)h
                       zoff:(int)zoff
                       snap:(int)snap
                       name:(OFString *)name;
@end

enum {
	GUN_FIST = 0,
	GUN_SG,
	GUN_CG,
	GUN_RL,
	GUN_RIFLE,
	GUN_FIREBALL,
︙

Modified src/entities.mm from [fa2e7605f2] to [8e9438e362]. 

1
2
3


4
5
6
7
8
9
10

1
2
3
4
5
6
7
8
9
10
11
12




+
+








// entities.cpp: map entity related functions (pickup etc.)

#include "cube.h"

#import "MapModelInfo.h"

vector<entity> ents;

static OFString *entmdlnames[] = {
    @"shells",
    @"bullets",
    @"rockets",
︙

Modified src/meson.build from [d4e8fbb8fd] to [a339bbfb63]. 

1
2
3




4
5
6
7
8
9
10

1
2
3
4
5
6
7
8
9
10
11
12
13
14




+
+
+
+








executable('client',
  [
    'Cube.mm',
    'Ident.m',
    'KeyMapping.m',
    'MD2.mm',
    'MapModelInfo.m',
    'client.mm',
    'clientextras.mm',
    'clientgame.mm',
    'clients2c.mm',
    'command.mm',
    'console.mm',
    'editing.mm',
︙

Modified src/physics.mm from [186af48f2c] to [33d03da6be]. 

1
2
3
4
5
6
7


8
9
10
11
12
13
14

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16








+
+








// physics.cpp: no physics books were hurt nor consulted in the construction of
// this code. All physics computations and constants were invented on the fly
// and simply tweaked until they "felt right", and have no basis in reality.
// Collision detection is simplistic but very robust (uses discrete steps at
// fixed fps).

#include "cube.h"

#import "MapModelInfo.h"

bool
plcollide(dynent *d, dynent *o, float &headspace, float &hi,
    float &lo) // collide with player or monster
{
	if (o->state != CS_ALIVE)
		return true;
︙

Modified src/protos.h from [caa79545eb] to [1a4e5c2dba].

︙
206
207
208
209
210
211
212

213
214
215
216
217
218
219

206
207
208
209
210
211
212
213
214
215
216
217
218
219
220








+








extern void initsound();
extern void cleansound();

// rendermd2
extern void rendermodel(OFString *mdl, int frame, int range, int tex, float rad,
    float x, float y, float z, float yaw, float pitch, bool teammate,
    float scale, float speed, int snap = 0, int basetime = 0);
@class MapModelInfo;
extern MapModelInfo *getmminfo(int i);

// server
extern void initserver(bool dedicated, int uprate, const char *sdesc,
    const char *ip, const char *master, OFString *passwd, int maxcl);
extern void cleanupserver();
extern void localconnect();
︙

Modified src/rendermd2.mm from [d83bc98847] to [26b0b7264d]. 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242

243
244
245
246
247
248
249

1
2
3
4











5

























6



















7
8
9
10



















































































































































































11
12
13
14
15
16
17
18





-
-
-
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-




-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+








// rendermd2.cpp: loader code adapted from a nehe tutorial

#include "cube.h"

struct md2_header {
	int magic;
	int version;
	int skinWidth, skinHeight;
	int frameSize;
	int numSkins, numVertices, numTexcoords;
	int numTriangles, numGlCommands, numFrames;
	int offsetSkins, offsetTexcoords, offsetTriangles;
	int offsetFrames, offsetGlCommands, offsetEnd;
};

#import "MD2.h"
struct md2_vertex {
	uchar vertex[3], lightNormalIndex;
};

struct md2_frame {
	float scale[3];
	float translate[3];
	char name[16];
	md2_vertex vertices[1];
};

@interface MD2 : OFObject {
	int _numGlCommands;
	int *_glCommands;
	int _numTriangles;
	int _frameSize;
	int _numFrames;
	int _numVerts;
	char *_frames;
	OFVector3D **_mverts;
	int _displaylist;
	int _displaylistverts;
}

@property (nonatomic) MapModelInfo *mmi;
#import "MapModelInfo.h"
@property (copy, nonatomic) OFString *loadname;
@property (nonatomic) int mdlnum;
@property (nonatomic) bool loaded;

- (bool)loadWithIRI:(OFIRI *)IRI;
- (void)renderWithLight:(OFVector3D &)light
                  frame:(int)frame
                  range:(int)range
                      x:(float)x
                      y:(float)y
                      z:(float)z
                    yaw:(float)yaw
                  pitch:(float)pitch
                  scale:(float)scale
                  speed:(float)speed
                   snap:(int)snap
               basetime:(int)basetime;
- (void)scaleWithFrame:(int)frame scale:(float)scale snap:(int)snap;
@end

static OFMutableDictionary<OFString *, MD2 *> *mdllookup = nil;
static OFMutableArray<MD2 *> *mapmodels = nil;

@implementation MD2
+ (void)initialize
{
	if (self != [MD2 class])
		return;

	mdllookup = [[OFMutableDictionary alloc] init];
	mapmodels = [[OFMutableArray alloc] init];
}

- (void)dealloc
{
	if (_glCommands)
		delete[] _glCommands;
	if (_frames)
		delete[] _frames;
}

- (bool)loadWithIRI:(OFIRI *)IRI
{
	@autoreleasepool {
		OFSeekableStream *stream;
		@try {
			stream = (OFSeekableStream *)[[OFIRIHandler
			    handlerForIRI:IRI] openItemAtIRI:IRI mode:@"r"];
		} @catch (id e) {
			return false;
		}

		if (![stream isKindOfClass:[OFSeekableStream class]])
			return false;

		md2_header header;
		[stream readIntoBuffer:&header exactLength:sizeof(md2_header)];
		endianswap(
		    &header, sizeof(int), sizeof(md2_header) / sizeof(int));

		if (header.magic != 844121161 || header.version != 8)
			return false;

		_frames = new char[header.frameSize * header.numFrames];
		if (_frames == NULL)
			return false;

		[stream seekToOffset:header.offsetFrames whence:OFSeekSet];
		[stream readIntoBuffer:_frames
		           exactLength:header.frameSize * header.numFrames];

		for (int i = 0; i < header.numFrames; ++i)
			endianswap(
			    _frames + i * header.frameSize, sizeof(float), 6);

		_glCommands = new int[header.numGlCommands];
		if (_glCommands == NULL)
			return false;

		[stream seekToOffset:header.offsetGlCommands whence:OFSeekSet];
		[stream readIntoBuffer:_glCommands
		           exactLength:header.numGlCommands * sizeof(int)];
		endianswap(_glCommands, sizeof(int), header.numGlCommands);

		_numFrames = header.numFrames;
		_numGlCommands = header.numGlCommands;
		_frameSize = header.frameSize;
		_numTriangles = header.numTriangles;
		_numVerts = header.numVertices;

		[stream close];

		_mverts = new OFVector3D *[_numFrames];
		loopj(_numFrames) _mverts[j] = NULL;

		return true;
	}
}

float
snap(int sn, float f)
{
	return sn ? (float)(((int)(f + sn * 0.5f)) & (~(sn - 1))) : f;
}

- (void)scaleWithFrame:(int)frame scale:(float)scale snap:(int)sn
{
	_mverts[frame] = new OFVector3D[_numVerts];
	md2_frame *cf = (md2_frame *)((char *)_frames + _frameSize * frame);
	float sc = 16.0f / scale;
	loop(vi, _numVerts)
	{
		uchar *cv = (uchar *)&cf->vertices[vi].vertex;
		OFVector3D *v = &(_mverts[frame])[vi];
		v->x = (snap(sn, cv[0] * cf->scale[0]) + cf->translate[0]) / sc;
		v->y =
		    -(snap(sn, cv[1] * cf->scale[1]) + cf->translate[1]) / sc;
		v->z = (snap(sn, cv[2] * cf->scale[2]) + cf->translate[2]) / sc;
	}
}

- (void)renderWithLight:(OFVector3D &)light
                  frame:(int)frame
                  range:(int)range
                      x:(float)x
                      y:(float)y
                      z:(float)z
                    yaw:(float)yaw
                  pitch:(float)pitch
                  scale:(float)sc
                  speed:(float)speed
                   snap:(int)sn
               basetime:(int)basetime
{
	loopi(range) if (!_mverts[frame + i])[self scaleWithFrame:frame + i
	                                                    scale:sc
	                                                     snap:sn];

	glPushMatrix();
	glTranslatef(x, y, z);
	glRotatef(yaw + 180, 0, -1, 0);
	glRotatef(pitch, 0, 0, 1);

	glColor3fv((float *)&light);

	if (_displaylist && frame == 0 && range == 1) {
		glCallList(_displaylist);
		xtraverts += _displaylistverts;
	} else {
		if (frame == 0 && range == 1) {
			static int displaylistn = 10;
			glNewList(_displaylist = displaylistn++, GL_COMPILE);
			_displaylistverts = xtraverts;
		}

		int time = lastmillis - basetime;
		int fr1 = (int)(time / speed);
		float frac1 = (time - fr1 * speed) / speed;
		float frac2 = 1 - frac1;
		fr1 = fr1 % range + frame;
		int fr2 = fr1 + 1;
		if (fr2 >= frame + range)
			fr2 = frame;
		OFVector3D *verts1 = _mverts[fr1];
		OFVector3D *verts2 = _mverts[fr2];

		for (int *command = _glCommands; (*command) != 0;) {
			int numVertex = *command++;
			if (numVertex > 0) {
				glBegin(GL_TRIANGLE_STRIP);
			} else {
				glBegin(GL_TRIANGLE_FAN);
				numVertex = -numVertex;
			}

			loopi(numVertex)
			{
				float tu = *((float *)command++);
				float tv = *((float *)command++);
				glTexCoord2f(tu, tv);
				int vn = *command++;
				OFVector3D &v1 = verts1[vn];
				OFVector3D &v2 = verts2[vn];
#define ip(c) v1.c *frac2 + v2.c *frac1
				glVertex3f(ip(x), ip(z), ip(y));
			}

			xtraverts += numVertex;

			glEnd();
		}

		if (_displaylist) {
			glEndList();
			_displaylistverts = xtraverts - _displaylistverts;
		}
	}

	glPopMatrix();
}

const int FIRSTMDL = 20;
static const int FIRSTMDL = 20;

void
delayedload(MD2 *m)
{
	if (!m.loaded) {
		@autoreleasepool {
			OFString *path = [OFString
︙
261
262
263
264
265
266
267
268
269
270
271
272
273


274
275
276

277
278
279
280
281
282
283





284
285




286

287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302









303
304
305
306
307
308
309

30
31
32
33
34
35
36


37
38
39
40
41
42
43
44
45
46
47
48





49
50
51
52
53

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69







70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85








-
-




+
+



+


-
-
-
-
-
+
+
+
+
+
-

+
+
+
+

+









-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+








			int xs, ys;
			installtex(FIRSTMDL + m.mdlnum, IRI2, &xs, &ys, false);
			m.loaded = true;
		}
	}
}

int modelnum = 0;

MD2 *
loadmodel(OFString *name)
{
	@autoreleasepool {
		static int modelnum = 0;

		MD2 *m = mdllookup[name];
		if (m != nil)
			return m;

		m = [[MD2 alloc] init];
		m.mdlnum = modelnum++;
		MapModelInfo *mmi = [[MapModelInfo alloc] initWithRad:2
		                                                    h:2
		                                                 zoff:0
		                                                 snap:0
		                                                 name:@""];
		m.mmi = [[MapModelInfo alloc] initWithRad:2
		                                        h:2
		                                     zoff:0
		                                     snap:0
		                                     name:@""];
		m.mmi = mmi;
		m.loadname = name;

		if (mdllookup == nil)
			mdllookup = [[OFMutableDictionary alloc] init];

		mdllookup[name] = m;

		return m;
	}
}

void
mapmodel(
    OFString *rad, OFString *h, OFString *zoff, OFString *snap, OFString *name)
{
	MD2 *m = loadmodel(name);
	MapModelInfo *mmi =
	    [[MapModelInfo alloc] initWithRad:(int)rad.longLongValue
	                                    h:(int)h.longLongValue
	                                 zoff:(int)zoff.longLongValue
	                                 snap:(int)snap.longLongValue
	                                 name:m.loadname];
	m.mmi = mmi;
	m.mmi = [[MapModelInfo alloc] initWithRad:(int)rad.longLongValue
	                                        h:(int)h.longLongValue
	                                     zoff:(int)zoff.longLongValue
	                                     snap:(int)snap.longLongValue
	                                     name:m.loadname];

	if (mapmodels == nil)
		mapmodels = [[OFMutableArray alloc] init];

	[mapmodels addObject:m];
}
COMMAND(mapmodel, ARG_5STR)

void
mapmodelreset()
{
︙
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387

137
138
139
140
141
142
143




























-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

	               yaw:yaw
	             pitch:pitch
	             scale:scale
	             speed:speed
	              snap:snap
	          basetime:basetime];
}
@end

@implementation MapModelInfo
- (instancetype)initWithRad:(int)rad
                          h:(int)h
                       zoff:(int)zoff
                       snap:(int)snap
                       name:(OFString *)name
{
	self = [super init];

	_rad = rad;
	_h = h;
	_zoff = zoff;
	_snap = snap;
	_name = [name copy];

	return self;
}
@end

Fossil 2.25 [8f798279d5] 2024-11-06 12:59:09
This page was generated in about 0.023s