Cube  Diff

Annotate Patch Side-by-side Diff

Differences From Artifact [154658a1d9]:

To Artifact [86ca5a8f24]:

︙
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

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








-
+

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

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

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

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

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

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

-
+

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

-
-
-
+
+
+

-
-
+
+

-
+

-
+
+








cleangl()
{
	if (qsphere)
		gluDeleteQuadric(qsphere);
}

bool
installtex(int tnum, char *texname, int &xs, int &ys, bool clamp)
installtex(int tnum, OFIRI *IRI, int *xs, int *ys, bool clamp)
{
	@autoreleasepool {
	SDL_Surface *s = IMG_Load(texname);
	if (s == NULL) {
		conoutf(@"couldn't load texture %s", texname);
		return false;
	}
		SDL_Surface *s =
		    IMG_Load(IRI.fileSystemRepresentation.UTF8String);
		if (s == NULL) {
			conoutf(
			    @"couldn't load texture %s", IRI.string.UTF8String);
			return false;
		}

	if (s->format->BitsPerPixel != 24) {
		SDL_PixelFormat *format =
		    SDL_AllocFormat(SDL_PIXELFORMAT_RGB24);
		if (format == NULL) {
			conoutf(@"texture cannot be converted to 24bpp: %s",
		if (s->format->BitsPerPixel != 24) {
			SDL_PixelFormat *format =
			    SDL_AllocFormat(SDL_PIXELFORMAT_RGB24);
			if (format == NULL) {
				conoutf(
				    @"texture cannot be converted to 24bpp: %s",
			    texname);
			return false;
		}
				    IRI.string.UTF8String);
				return false;
			}

		@try {
			SDL_Surface *converted =
			    SDL_ConvertSurface(s, format, 0);
			if (converted == NULL) {
				conoutf(
				    @"texture cannot be converted to 24bpp: %s",
			@try {
				SDL_Surface *converted =
				    SDL_ConvertSurface(s, format, 0);
				if (converted == NULL) {
					conoutf(@"texture cannot be converted "
					        @"to 24bpp: %s",
				    texname);
				return false;
			}
					    IRI.string.UTF8String);
					return false;
				}

			SDL_FreeSurface(s);
			s = converted;
		} @finally {
			SDL_FreeFormat(format);
		}
	}
				SDL_FreeSurface(s);
				s = converted;
			} @finally {
				SDL_FreeFormat(format);
			}
		}

	// loopi(s->w*s->h*3) { uchar *p = (uchar *)s->pixels+i; *p = 255-*p; };
	glBindTexture(GL_TEXTURE_2D, tnum);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
	    clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
	    clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
	    GL_LINEAR_MIPMAP_LINEAR); // NEAREST);
	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
		// loopi(s->w*s->h*3) { uchar *p = (uchar *)s->pixels+i; *p =
		// 255-*p; };
		glBindTexture(GL_TEXTURE_2D, tnum);
		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,
		    clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,
		    clamp ? GL_CLAMP_TO_EDGE : GL_REPEAT);
		glTexParameteri(
		    GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
		    GL_LINEAR_MIPMAP_LINEAR); // NEAREST);
		glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);

	xs = s->w;
	ys = s->h;
	while (xs > glmaxtexsize || ys > glmaxtexsize) {
		xs /= 2;
		ys /= 2;
	}
		*xs = s->w;
		*ys = s->h;
		while (*xs > glmaxtexsize || *ys > glmaxtexsize) {
			*xs /= 2;
			*ys /= 2;
		}

	void *scaledimg = s->pixels;
		void *scaledimg = s->pixels;

	if (xs != s->w) {
		conoutf(@"warning: quality loss: scaling %s",
		    texname); // for voodoo cards under linux
		scaledimg = alloc(xs * ys * 3);
		gluScaleImage(GL_RGB, s->w, s->h, GL_UNSIGNED_BYTE, s->pixels,
		    xs, ys, GL_UNSIGNED_BYTE, scaledimg);
	}
		if (*xs != s->w) {
			conoutf(@"warning: quality loss: scaling %s",
			    IRI.string
			        .UTF8String); // for voodoo cards under linux
			scaledimg = alloc(*xs * *ys * 3);
			gluScaleImage(GL_RGB, s->w, s->h, GL_UNSIGNED_BYTE,
			    s->pixels, *xs, *ys, GL_UNSIGNED_BYTE, scaledimg);
		}

	if (gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, xs, ys, GL_RGB,
	        GL_UNSIGNED_BYTE, scaledimg))
		fatal(@"could not build mipmaps");
		if (gluBuild2DMipmaps(GL_TEXTURE_2D, GL_RGB, *xs, *ys, GL_RGB,
		        GL_UNSIGNED_BYTE, scaledimg))
			fatal(@"could not build mipmaps");

	if (xs != s->w)
		free(scaledimg);
		if (*xs != s->w)
			free(scaledimg);

	SDL_FreeSurface(s);
		SDL_FreeSurface(s);

	return true;
		return true;
	}
}

// management of texture slots
// each texture slot can have multople texture frames, of which currently only
// the first is used additional frames can be used for various shaders

const int MAXTEX = 1000;
︙
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

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
250


251
252
253
254
255
256
257
258
259
260








-





-
+





-
-
+
+

-
-
-
-
+
+
+
+






-
-
+
+

-
-
+
+







+
+
-
+

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








	@autoreleasepool {
		int num = curtexnum++, frame = (int)aframe.longLongValue;
		if (num < 0 || num >= 256 || frame < 0 || frame >= MAXFRAMES)
			return;
		mapping[num][frame] = 1;
		char *n = mapname[num][frame];
		strcpy_s(n, name.UTF8String);
		path(n);
	}
}
COMMAND(texture, ARG_2STR)

int
lookuptexture(int tex, int &xs, int &ys)
lookuptexture(int tex, int *xs, int *ys)
{
	int frame = 0; // other frames?
	int tid = mapping[tex][frame];

	if (tid >= FIRSTTEX) {
		xs = texx[tid - FIRSTTEX];
		ys = texy[tid - FIRSTTEX];
		*xs = texx[tid - FIRSTTEX];
		*ys = texy[tid - FIRSTTEX];
		return tid;
	};

	xs = ys = 16;
	if (!tid)
	}

	*xs = *ys = 16;
	if (tid == 0)
		return 1; // crosshair :)

	loopi(curtex) // lazily happens once per "texture" command, basically
	{
		if (strcmp(mapname[tex][frame], texname[i]) == 0) {
			mapping[tex][frame] = tid = i + FIRSTTEX;
			xs = texx[i];
			ys = texy[i];
			*xs = texx[i];
			*ys = texy[i];
			return tid;
		};
	};
		}
	}

	if (curtex == MAXTEX)
		fatal(@"loaded too many textures");

	int tnum = curtex + FIRSTTEX;
	strcpy_s(texname[curtex], mapname[tex][frame]);

	@autoreleasepool {
		OFString *path =
	sprintf_sd(name)("packages%c%s", PATHDIV, texname[curtex]);
		    [OFString stringWithFormat:@"packages/%s", texname[curtex]];

	if (installtex(tnum, name, xs, ys)) {
		mapping[tex][frame] = tnum;
		texx[curtex] = xs;
		texy[curtex] = ys;
		curtex++;
		return tnum;
	} else {
		return mapping[tex][frame] = FIRSTTEX; // temp fix
		if (installtex(tnum,
		        [Cube.sharedInstance.gameDataIRI
		            IRIByAppendingPathComponent:path],
		        xs, ys, false)) {
			mapping[tex][frame] = tnum;
			texx[curtex] = *xs;
			texy[curtex] = *ys;
			curtex++;
			return tnum;
		} else {
			return mapping[tex][frame] = FIRSTTEX; // temp fix
	};
};
		}
	}
}

void
setupworld()
{
	glEnableClientState(GL_VERTEX_ARRAY);
	glEnableClientState(GL_COLOR_ARRAY);
	glEnableClientState(GL_TEXTURE_COORD_ARRAY);
︙
414
415
416
417
418
419
420
421

422
423
424
425
426
427
428

427
428
429
430
431
432
433

434
435
436
437
438
439
440
441








-
+








	glMatrixMode(GL_MODELVIEW);

	transplayer();

	glEnable(GL_TEXTURE_2D);

	int xs, ys;
	skyoglid = lookuptexture(DEFAULT_SKY, xs, ys);
	skyoglid = lookuptexture(DEFAULT_SKY, &xs, &ys);

	resetcubes();

	curvert = 0;
	strips.setsize(0);

	render_world(player1->o.x, player1->o.y, player1->o.z,
︙
Fossil 2.25 [8f798279d5] 2024-11-06 12:59:09
This page was generated in about 0.015s