BlueGit

timfa raytracer

Files

raytracer / build / game.js

game.js

game.js 73.2 KiB Download Raw
1
2/*
3 * Start File:
4 * /workspace/raytracer-work/src/textureColumn.js
5 */
6/**
7 * Texture-column helpers for Wolfenstein-style wall strips.
8 * Each screen column samples exactly one source pixel column.
9 */
10function textureColumnIndex (tileX, texWidth)
11{
12 if (!(texWidth > 0))
13 { return 0; }
14
15 var sx = Math.floor(Number(tileX) * texWidth);
16 if (sx < 0)
17 { sx = 0; }
18 if (sx > texWidth - 1)
19 { sx = texWidth - 1; }
20 return sx;
21}
22
23function textureColumnUv (tileX, texWidth)
24{
25 var sx = textureColumnIndex(tileX, texWidth);
26 var w = texWidth > 0 ? texWidth : 1;
27 return {
28 sx: sx,
29 sw: 1,
30 u0: sx / w,
31 u1: (sx + 1) / w,
32 v0: 0,
33 v1: 1
34 };
35}
36
37/** Face U from hit position within a cell (no +1 bias). */
38function faceTileX (hitCoord, cellSize, face)
39{
40 var local = hitCoord % cellSize;
41 if (local < 0)
42 { local += cellSize; }
43 var t = local / cellSize;
44 switch (face)
45 {
46 case "north": return t;
47 case "south": return 1 - t;
48 case "east": return 1 - t;
49 case "west": return t;
50 default: return t;
51 }
52}
53
54if (typeof module !== "undefined" && module.exports)
55{
56 module.exports = {
57 textureColumnIndex: textureColumnIndex,
58 textureColumnUv: textureColumnUv,
59 faceTileX: faceTileX
60 };
61}
62
63/*
64 * End File:
65 * /workspace/raytracer-work/src/textureColumn.js
66 */
67
68/*
69 * Start File:
70 * /workspace/raytracer-work/src/ppda/depthDecode.js
71 */
72/**
73 * Depth encodings matching Paperdoll Renderer camera::DepthFormat.
74 * Canonical compositor sample is u16 gray + u16 alpha (0..65535).
75 */
76var DepthDecode =
77{
78 EPSILON_U16: 1,
79
80 parseFormat: function (encoding, bits)
81 {
82 var enc = encoding || "gray";
83 var b = bits == null ? 16 : Number(bits);
84 if (b !== 8 && b !== 16)
85 { throw new Error("depth_bits moet 8 of 16 zijn, kreeg " + bits); }
86 if (enc !== "gray" && enc !== "rgb_bands" && enc !== "rgb_packed")
87 { throw new Error("depth_encoding onbekend: " + enc); }
88 return { encoding: enc, bits: b };
89 },
90
91 max: function (fmt)
92 { return (1 << fmt.bits) - 1; },
93
94 levels: function (fmt)
95 {
96 var m = this.max(fmt);
97 if (fmt.encoding === "gray")
98 { return m; }
99 if (fmt.encoding === "rgb_bands")
100 { return 3 * m; }
101 return Math.pow(2, 3 * fmt.bits) - 1;
102 },
103
104 decodeValue: function (fmt, c0, c1, c2)
105 {
106 var m = this.max(fmt);
107 var b = m + 1;
108 var v;
109 if (fmt.encoding === "gray")
110 { v = c0; }
111 else if (fmt.encoding === "rgb_bands")
112 { v = c0 + c1 + c2; }
113 else
114 { v = c0 * b * b + c1 * b + c2; }
115 return v / this.levels(fmt);
116 },
117
118 encodeValue: function (fmt, t)
119 {
120 t = Math.max(0, Math.min(1, Number(t) || 0));
121 var m = this.max(fmt);
122 var v = Math.round(t * this.levels(fmt));
123 if (fmt.encoding === "gray")
124 { return [v, 0, 0]; }
125 if (fmt.encoding === "rgb_bands")
126 {
127 return [
128 Math.min(v, m),
129 Math.min(Math.max(v - m, 0), m),
130 Math.min(Math.max(v - 2 * m, 0), m)
131 ];
132 }
133 var b = m + 1;
134 return [Math.floor(v / (b * b)), Math.floor(v / b) % b, v % b];
135 },
136
137 /**
138 * Decode one pixel channel tuple to canonical u16 (gray, alpha).
139 * channels: [c0,c1,c2,a] in native bit depth units.
140 */
141 decodePixelChannels: function (fmt, channels)
142 {
143 var c0 = channels[0] || 0;
144 var c1 = channels[1] || 0;
145 var c2 = channels[2] || 0;
146 var a = channels[3] != null ? channels[3] : this.max(fmt);
147 if (fmt.encoding === "rgb_bands")
148 {
149 var m = this.max(fmt);
150 if ((c1 > 0 && c0 !== m) || (c2 > 0 && c1 !== m))
151 { throw new Error("depth rgb_bands: ongeldige bandvolgorde"); }
152 }
153 var t = this.decodeValue(fmt, c0, c1, c2);
154 var scale = 65535 / this.max(fmt);
155 return {
156 gray: Math.round(t * 65535),
157 alpha: Math.round(a * scale)
158 };
159 },
160
161 /** Meters from camera using near/far and normalized t (0..1 from gray/65535). */
162 distanceMeters: function (grayU16, near, far)
163 {
164 var t = (grayU16 & 0xffff) / 65535;
165 return near + t * (far - near);
166 }
167};
168
169if (typeof module !== "undefined" && module.exports)
170{ module.exports = DepthDecode; }
171
172/*
173 * End File:
174 * /workspace/raytracer-work/src/ppda/depthDecode.js
175 */
176
177/*
178 * Start File:
179 * /workspace/raytracer-work/src/ppda/viewFrame.js
180 */
181/**
182 * Choose paperdoll view (yaw/pitch) and animation frame.
183 * Yaw 0 = character front (Paperdoll/glTF convention).
184 */
185var PpdaViewFrame =
186{
187 /**
188 * Relative viewing yaw in degrees [0,360): direction from NPC to player,
189 * minus the NPC's facing yaw (degrees, 0 = faces +X/east in world… mapped
190 * so that when the player looks at the NPC's front, relative yaw ≈ 0).
191 *
192 * World: +X east, +Y south (legacy raycaster). NPC facingYawDeg: 0 looks
193 * toward +X. Paperdoll yaw 0 is front. We map world facing so that the
194 * camera looking opposite to facing sees front.
195 */
196 relativeYawDeg: function (playerX, playerY, npcX, npcY, npcFacingDeg)
197 {
198 var dx = playerX - npcX;
199 var dy = playerY - npcY;
200 // Angle of vector NPC→player in world degrees (0=+X, 90=+Y).
201 var toPlayer = Math.atan2(dy, dx) * 180 / Math.PI;
202 if (toPlayer < 0)
203 { toPlayer += 360; }
204 // When player stands in front of NPC, toPlayer ≈ npcFacing.
205 // Paperdoll wants yaw 0 for front → relative = toPlayer - facing.
206 var rel = toPlayer - (npcFacingDeg || 0);
207 rel = ((rel % 360) + 360) % 360;
208 return rel;
209 },
210
211 nearestInList: function (value, list, circular360)
212 {
213 if (!list || !list.length)
214 { return 0; }
215 var best = list[0];
216 var bestD = Infinity;
217 for (var i = 0; i < list.length; i++)
218 {
219 var v = list[i];
220 var d = Math.abs(value - v);
221 if (circular360)
222 { d = Math.min(d, 360 - d); }
223 if (d < bestD)
224 {
225 bestD = d;
226 best = v;
227 }
228 }
229 return best;
230 },
231
232 pickYaw: function (relativeYawDeg, yaws)
233 {
234 return this.nearestInList(((relativeYawDeg % 360) + 360) % 360, yaws || [0], true);
235 },
236
237 pickPitch: function (playerPitchRad, pitches)
238 {
239 // player pitch: 0 = horizon; positive looks down in this game.
240 // Paperdoll: positive pitch = from above. Invert sign for mapping.
241 var deg = -(playerPitchRad || 0) * 180 / Math.PI;
242 return this.nearestInList(deg, pitches || [0]);
243 },
244
245 frameIndex: function (timeSec, fps, frameCount)
246 {
247 var n = Math.max(1, frameCount | 0);
248 var f = Math.max(1, fps | 0);
249 var idx = Math.floor((timeSec || 0) * f);
250 idx %= n;
251 if (idx < 0)
252 { idx += n; }
253 return idx;
254 },
255
256 findClip: function (ppda, clipTokenOrName)
257 {
258 var clips = ppda && ppda.clips || [];
259 for (var i = 0; i < clips.length; i++)
260 {
261 if (clips[i].token === clipTokenOrName || clips[i].name === clipTokenOrName)
262 { return clips[i]; }
263 }
264 return clips[0] || null;
265 },
266
267 findView: function (frame, pitch, yaw)
268 {
269 var views = frame && frame.views || [];
270 for (var i = 0; i < views.length; i++)
271 {
272 if (views[i].pitch === pitch && views[i].yaw === yaw)
273 { return views[i]; }
274 }
275 return null;
276 },
277
278 uvRect: function (view, atlasW, atlasH)
279 {
280 if (!view)
281 { return { u0: 0, v0: 0, u1: 1, v1: 1, x: 0, y: 0, w: 0, h: 0 }; }
282 var w = atlasW || 1;
283 var h = atlasH || 1;
284 return {
285 x: view.x,
286 y: view.y,
287 w: view.w,
288 h: view.h,
289 u0: view.x / w,
290 v0: view.y / h,
291 u1: (view.x + view.w) / w,
292 v1: (view.y + view.h) / h
293 };
294 }
295};
296
297if (typeof module !== "undefined" && module.exports)
298{ module.exports = PpdaViewFrame; }
299
300/*
301 * End File:
302 * /workspace/raytracer-work/src/ppda/viewFrame.js
303 */
304
305/*
306 * Start File:
307 * /workspace/raytracer-work/src/ppda/compositor.js
308 */
309/**
310 * Live body+equipment compositor — port of compositor.rs compose().
311 * Per pixel: nearest valid depth wins; ties keep lower layer index (body first).
312 * Valid = depth alpha ≠ 0 AND diffuse alpha ≠ 0.
313 */
314var PpdaCompositor =
315{
316 DEPTH_EPSILON_U16: 1,
317
318 /**
319 * @param {Array<{width,height,diffuse:Uint8ClampedArray|Uint8Array,depthGray:Uint16Array,depthAlpha:Uint16Array,normal?:Uint8Array,specular?:Uint8Array}>} layers
320 */
321 compose: function (layers)
322 {
323 if (!layers || !layers.length)
324 { throw new Error("geen lagen om te composeren"); }
325 var width = layers[0].width;
326 var height = layers[0].height;
327 var pixels = width * height;
328 if (!pixels)
329 { throw new Error("lege afmetingen"); }
330 for (var li = 0; li < layers.length; li++)
331 {
332 var L = layers[li];
333 if (L.width !== width || L.height !== height)
334 { throw new Error("laag " + li + " heeft andere afmetingen"); }
335 if (L.diffuse.length !== pixels * 4 || L.depthGray.length !== pixels || L.depthAlpha.length !== pixels)
336 { throw new Error("laag " + li + " inconsistente buffers"); }
337 }
338
339 var diffuse = new Uint8ClampedArray(pixels * 4);
340 var normal = new Uint8ClampedArray(pixels * 4);
341 var specular = new Uint8ClampedArray(pixels * 4);
342 var depthGray = new Uint16Array(pixels);
343 var depthAlpha = new Uint16Array(pixels);
344 var winner = new Uint8Array(pixels);
345 for (var i = 0; i < pixels; i++)
346 { winner[i] = 255; }
347
348 var eps = this.DEPTH_EPSILON_U16;
349 for (var i = 0; i < pixels; i++)
350 {
351 var bestDepth = null;
352 var bestLayer = null;
353 for (var layerIdx = 0; layerIdx < layers.length; layerIdx++)
354 {
355 var layer = layers[layerIdx];
356 if (layer.depthAlpha[i] === 0 || layer.diffuse[i * 4 + 3] === 0)
357 { continue; }
358 var gray = layer.depthGray[i];
359 if (bestDepth == null)
360 {
361 bestDepth = gray;
362 bestLayer = layerIdx;
363 }
364 else if (gray + eps < bestDepth)
365 {
366 bestDepth = gray;
367 bestLayer = layerIdx;
368 }
369 else if (gray <= bestDepth + eps)
370 {
371 /* tie: keep lower index */
372 }
373 }
374 if (bestLayer != null)
375 {
376 var src = layers[bestLayer];
377 var o = i * 4;
378 diffuse[o] = src.diffuse[o];
379 diffuse[o + 1] = src.diffuse[o + 1];
380 diffuse[o + 2] = src.diffuse[o + 2];
381 diffuse[o + 3] = src.diffuse[o + 3];
382 if (src.normal)
383 {
384 normal[o] = src.normal[o];
385 normal[o + 1] = src.normal[o + 1];
386 normal[o + 2] = src.normal[o + 2];
387 normal[o + 3] = src.normal[o + 3];
388 }
389 if (src.specular)
390 {
391 specular[o] = src.specular[o];
392 specular[o + 1] = src.specular[o + 1];
393 specular[o + 2] = src.specular[o + 2];
394 specular[o + 3] = src.specular[o + 3];
395 }
396 depthGray[i] = src.depthGray[i];
397 depthAlpha[i] = src.depthAlpha[i];
398 winner[i] = bestLayer;
399 }
400 }
401
402 return {
403 width: width,
404 height: height,
405 diffuse: diffuse,
406 normal: normal,
407 specular: specular,
408 depthGray: depthGray,
409 depthAlpha: depthAlpha,
410 winner: winner
411 };
412 },
413
414 /** Simple ambient+Lambert approx for preview (Preview2d-achtig, licht). */
415 relightDiffuse: function (composed, lightAmt)
416 {
417 lightAmt = lightAmt == null ? 1 : lightAmt;
418 var out = new Uint8ClampedArray(composed.diffuse.length);
419 for (var i = 0; i < composed.diffuse.length; i += 4)
420 {
421 var a = composed.diffuse[i + 3];
422 if (a === 0)
423 { continue; }
424 var ndot = 0.75;
425 if (composed.normal && composed.normal[i + 3])
426 {
427 var nx = composed.normal[i] / 255 * 2 - 1;
428 var ny = composed.normal[i + 1] / 255 * 2 - 1;
429 var nz = composed.normal[i + 2] / 255 * 2 - 1;
430 ndot = Math.max(0, nx * 0.3 + ny * 0.2 + nz * 0.9);
431 }
432 var shade = Math.min(1, 0.35 + 0.65 * ndot) * lightAmt;
433 out[i] = Math.min(255, Math.round(composed.diffuse[i] * shade));
434 out[i + 1] = Math.min(255, Math.round(composed.diffuse[i + 1] * shade));
435 out[i + 2] = Math.min(255, Math.round(composed.diffuse[i + 2] * shade));
436 out[i + 3] = a;
437 }
438 return out;
439 }
440};
441
442if (typeof module !== "undefined" && module.exports)
443{ module.exports = PpdaCompositor; }
444
445/*
446 * End File:
447 * /workspace/raytracer-work/src/ppda/compositor.js
448 */
449
450/*
451 * Start File:
452 * /workspace/raytracer-work/src/ppda/loadPpda.js
453 */
454/**
455 * Strict-enough .ppda loader for formats 1–5 (Paperdoll AtlasSet consumer).
456 */
457var PpdaLoader =
458{
459 SUPPORTED_FORMATS: [1, 2, 3, 4, 5],
460
461 parse: function (jsonText, options)
462 {
463 options = options || {};
464 var doc;
465 try
466 { doc = typeof jsonText === "string" ? JSON.parse(jsonText) : jsonText; }
467 catch (e)
468 { throw new Error("ppda: ongeldige JSON (" + e.message + ")"); }
469
470 if (!doc || typeof doc !== "object")
471 { throw new Error("ppda: root moet een object zijn"); }
472
473 var ver = doc.format_version;
474 if (this.SUPPORTED_FORMATS.indexOf(ver) < 0)
475 { throw new Error("ppda: format_version " + ver + " niet ondersteund (wel: " + this.SUPPORTED_FORMATS.join(",") + ")"); }
476
477 if (!doc.sex || !doc.settype)
478 { throw new Error("ppda: sex/settype verplicht"); }
479 if (!doc.fps || doc.fps < 1)
480 { throw new Error("ppda: fps ongeldig"); }
481 if (!doc.cell_width || !doc.cell_height)
482 { throw new Error("ppda: cell_width/height verplicht"); }
483 if (!Array.isArray(doc.pitches) || !Array.isArray(doc.yaws) || !doc.pitches.length || !doc.yaws.length)
484 { throw new Error("ppda: pitches/yaws verplicht"); }
485 if (!doc.maps || typeof doc.maps !== "object")
486 { throw new Error("ppda: maps verplicht"); }
487 ["diffuse", "depth"].forEach(function (k)
488 {
489 if (!doc.maps[k] || !doc.maps[k].file)
490 { throw new Error("ppda: maps." + k + ".file verplicht"); }
491 if (String(doc.maps[k].file).indexOf("..") >= 0 || String(doc.maps[k].file).indexOf("/") >= 0 || String(doc.maps[k].file).indexOf("\\") >= 0)
492 { throw new Error("ppda: maps." + k + ".file mag geen pad bevatten"); }
493 });
494 if (!Array.isArray(doc.clips) || !doc.clips.length)
495 { throw new Error("ppda: clips verplicht"); }
496
497 for (var ci = 0; ci < doc.clips.length; ci++)
498 {
499 var clip = doc.clips[ci];
500 if (!clip.frames || clip.frames.length !== clip.frame_count)
501 { throw new Error("ppda: clip '" + (clip.name || ci) + "' frames≠frame_count"); }
502 for (var fi = 0; fi < clip.frames.length; fi++)
503 {
504 var fr = clip.frames[fi];
505 if (!fr.views || !fr.views.length)
506 { throw new Error("ppda: frame zonder views"); }
507 for (var vi = 0; vi < fr.views.length; vi++)
508 {
509 var v = fr.views[vi];
510 if (v.w == null || v.h == null || v.x == null || v.y == null)
511 { throw new Error("ppda: view mist x/y/w/h"); }
512 }
513 }
514 }
515
516 var encoding = doc.depth_encoding;
517 var bits = doc.depth_bits;
518 if (!encoding)
519 {
520 // v1 / legacy long text in identity.depth → gray16
521 encoding = "gray";
522 bits = bits || 16;
523 }
524 else if (/gray/i.test(encoding) && encoding.indexOf("rgb_") < 0)
525 {
526 encoding = "gray";
527 }
528 else if (encoding.indexOf("rgb_bands") >= 0)
529 { encoding = "rgb_bands"; }
530 else if (encoding.indexOf("rgb_packed") >= 0)
531 { encoding = "rgb_packed"; }
532
533 var near = doc.depth_near != null ? doc.depth_near : (doc.identity && doc.identity.near);
534 var far = doc.depth_far != null ? doc.depth_far : (doc.identity && doc.identity.far);
535 if (near == null || far == null)
536 { throw new Error("ppda: depth_near/far of identity.near/far verplicht"); }
537
538 var fmt = DepthDecode.parseFormat(encoding, bits || 16);
539
540 return {
541 format_version: ver,
542 sex: doc.sex,
543 settype: doc.settype,
544 fps: doc.fps,
545 cell_width: doc.cell_width,
546 cell_height: doc.cell_height,
547 pitches: doc.pitches.slice(),
548 yaws: doc.yaws.slice(),
549 maps: doc.maps,
550 clips: doc.clips,
551 identity: doc.identity || null,
552 project: doc.project || null,
553 depth_near: Number(near),
554 depth_far: Number(far),
555 depth_format: fmt,
556 camera_distance: doc.identity && doc.identity.camera_distance != null
557 ? Number(doc.identity.camera_distance)
558 : 10,
559 height_milli: doc.identity && doc.identity.framing
560 ? doc.identity.framing.height_milli
561 : 2600,
562 raw: doc
563 };
564 },
565
566 compatKey: function (ppda)
567 {
568 var id = ppda.identity || {};
569 return {
570 sex: ppda.sex,
571 body_model_sha256: id.body_model_sha256 || "",
572 fps: ppda.fps,
573 cell_width: ppda.cell_width,
574 cell_height: ppda.cell_height,
575 pitches: ppda.pitches.join(","),
576 yaws: ppda.yaws.join(","),
577 near: ppda.depth_near,
578 far: ppda.depth_far
579 };
580 },
581
582 assertCompatible: function (a, b)
583 {
584 var ka = this.compatKey(a);
585 var kb = this.compatKey(b);
586 var keys = Object.keys(ka);
587 for (var i = 0; i < keys.length; i++)
588 {
589 var k = keys[i];
590 if (String(ka[k]) !== String(kb[k]))
591 { throw new Error("ppda incompatible: " + k + " (" + ka[k] + " vs " + kb[k] + ")"); }
592 }
593 }
594};
595
596if (typeof module !== "undefined" && module.exports)
597{ module.exports = PpdaLoader; }
598
599/*
600 * End File:
601 * /workspace/raytracer-work/src/ppda/loadPpda.js
602 */
603
604/*
605 * Start File:
606 * /workspace/raytracer-work/src/ppda/atlasRuntime.js
607 */
608/**
609 * Browser/runtime atlas set: loads PNG diffuse/normal/specular + u16 depth,
610 * extracts cells, composes body+gear on CPU (cell is 32×48 — cheap).
611 */
612var PpdaAtlasRuntime =
613{
614 _canvas: null,
615 _ctx: null,
616
617 _ensureCanvas: function ()
618 {
619 if (typeof document === "undefined")
620 { return null; }
621 if (!this._canvas)
622 {
623 this._canvas = document.createElement("canvas");
624 this._ctx = this._canvas.getContext("2d", { willReadFrequently: true });
625 }
626 return this._ctx;
627 },
628
629 loadImage: function (url)
630 {
631 return new Promise(function (resolve, reject)
632 {
633 var img = new Image();
634 img.onload = function ()
635 { resolve(img); };
636 img.onerror = function ()
637 { reject(new Error("image load failed: " + url)); };
638 img.src = url;
639 });
640 },
641
642 loadU16Depth: function (url, expectW, expectH)
643 {
644 return fetch(url).then(function (r)
645 {
646 if (!r.ok)
647 { throw new Error("depth fetch " + r.status + " " + url); }
648 return r.arrayBuffer();
649 }).then(function (buf)
650 {
651 var need = expectW * expectH * 4;
652 if (buf.byteLength < need)
653 { throw new Error("depth u16 te kort: " + buf.byteLength + " < " + need); }
654 return new Uint16Array(buf.slice(0, need));
655 });
656 },
657
658 /**
659 * @returns {Promise<{ppda, images, depthU16, baseUrl}>}
660 */
661 loadSet: function (baseUrl, ppdaFile)
662 {
663 var self = this;
664 baseUrl = baseUrl.replace(/\/?$/, "/");
665 return fetch(baseUrl + ppdaFile).then(function (r)
666 {
667 if (!r.ok)
668 { throw new Error("ppda fetch " + r.status); }
669 return r.text();
670 }).then(function (text)
671 {
672 var ppda = PpdaLoader.parse(text);
673 var maps = ppda.maps;
674 var jobs = [
675 self.loadImage(baseUrl + maps.diffuse.file),
676 maps.normal ? self.loadImage(baseUrl + maps.normal.file) : Promise.resolve(null),
677 maps.specular ? self.loadImage(baseUrl + maps.specular.file) : Promise.resolve(null)
678 ];
679 var depthFile = maps.depth.file;
680 var dw = maps.depth.width || maps.diffuse.width;
681 var dh = maps.depth.height || maps.diffuse.height;
682 if (maps.depth.storage === "u16le_ga" || /\.u16$/i.test(depthFile))
683 { jobs.push(self.loadU16Depth(baseUrl + depthFile, dw, dh)); }
684 else
685 { throw new Error("browser-loader verwacht depth als .u16 (storage=u16le_ga); got " + depthFile); }
686
687 return Promise.all(jobs).then(function (parts)
688 {
689 return {
690 ppda: ppda,
691 baseUrl: baseUrl,
692 diffuseImg: parts[0],
693 normalImg: parts[1],
694 specularImg: parts[2],
695 depthU16: parts[3],
696 depthW: dw,
697 depthH: dh
698 };
699 });
700 });
701 },
702
703 extractRgbaCell: function (img, view)
704 {
705 var ctx = this._ensureCanvas();
706 if (!ctx)
707 { throw new Error("geen canvas voor cell extract"); }
708 this._canvas.width = view.w;
709 this._canvas.height = view.h;
710 ctx.clearRect(0, 0, view.w, view.h);
711 ctx.drawImage(img, view.x, view.y, view.w, view.h, 0, 0, view.w, view.h);
712 return ctx.getImageData(0, 0, view.w, view.h).data;
713 },
714
715 extractDepthCell: function (depthU16, atlasW, view)
716 {
717 var n = view.w * view.h;
718 var gray = new Uint16Array(n);
719 var alpha = new Uint16Array(n);
720 for (var y = 0; y < view.h; y++)
721 {
722 for (var x = 0; x < view.w; x++)
723 {
724 var si = ((view.y + y) * atlasW + (view.x + x)) * 2;
725 var di = y * view.w + x;
726 gray[di] = depthU16[si];
727 alpha[di] = depthU16[si + 1];
728 }
729 }
730 return { depthGray: gray, depthAlpha: alpha };
731 },
732
733 layerFromSet: function (set, clipToken, frameIndex, pitch, yaw)
734 {
735 var clip = PpdaViewFrame.findClip(set.ppda, clipToken);
736 if (!clip)
737 { throw new Error("clip niet gevonden: " + clipToken); }
738 var frame = clip.frames[frameIndex];
739 if (!frame)
740 { throw new Error("frame " + frameIndex + " ontbreekt"); }
741 var view = PpdaViewFrame.findView(frame, pitch, yaw);
742 if (!view)
743 { throw new Error("view p" + pitch + " y" + yaw + " ontbreekt"); }
744 if (view.empty)
745 {
746 var emptyN = view.w * view.h;
747 return {
748 width: view.w,
749 height: view.h,
750 diffuse: new Uint8ClampedArray(emptyN * 4),
751 normal: new Uint8ClampedArray(emptyN * 4),
752 specular: new Uint8ClampedArray(emptyN * 4),
753 depthGray: new Uint16Array(emptyN),
754 depthAlpha: new Uint16Array(emptyN),
755 view: view
756 };
757 }
758 var diffuse = this.extractRgbaCell(set.diffuseImg, view);
759 var normal = set.normalImg ? this.extractRgbaCell(set.normalImg, view) : null;
760 var specular = set.specularImg ? this.extractRgbaCell(set.specularImg, view) : null;
761 var depth = this.extractDepthCell(set.depthU16, set.depthW, view);
762 return {
763 width: view.w,
764 height: view.h,
765 diffuse: diffuse,
766 normal: normal,
767 specular: specular,
768 depthGray: depth.depthGray,
769 depthAlpha: depth.depthAlpha,
770 view: view
771 };
772 },
773
774 composeView: function (bodySet, gearSet, clipToken, frameIndex, pitch, yaw)
775 {
776 var body = this.layerFromSet(bodySet, clipToken, frameIndex, pitch, yaw);
777 var layers = [body];
778 if (gearSet)
779 {
780 PpdaLoader.assertCompatible(bodySet.ppda, gearSet.ppda);
781 layers.push(this.layerFromSet(gearSet, clipToken, frameIndex, pitch, yaw));
782 }
783 var composed = PpdaCompositor.compose(layers);
784 composed.view = body.view;
785 composed.lit = PpdaCompositor.relightDiffuse(composed, 1);
786 return composed;
787 }
788};
789
790if (typeof module !== "undefined" && module.exports)
791{ module.exports = PpdaAtlasRuntime; }
792
793/*
794 * End File:
795 * /workspace/raytracer-work/src/ppda/atlasRuntime.js
796 */
797
798/*
799 * Start File:
800 * /workspace/raytracer-work/src/levelFormat.js
801 */
802/**
803 * Level pack format for raytracer + editor.
804 * v1: walls/floors/ceilings/npcs/lights[] (empty reserved)
805 * v2: lights fully specified + per-level ambient; migrate v1→v2.
806 */
807var LevelFormat =
808{
809 CURRENT_VERSION: 2,
810 MAX_SIZE: 128,
811 MAX_LEVELS: 64,
812 MAX_LIGHTS: 32,
813 KNOWN_TEXTURES: ["stone", "wood"],
814 DEFAULT_AMBIENT: 0.38,
815
816 emptyLight: function (x, y)
817 {
818 return {
819 id: "light-" + Date.now().toString(36),
820 x: x == null ? 48 : x,
821 y: y == null ? 48 : y,
822 z: 20,
823 color: [1, 0.9, 0.7],
824 intensity: 1.2,
825 range: 96,
826 falloff: 2
827 };
828 },
829
830 emptyLevel: function (name, width, height)
831 {
832 width = Math.max(3, Math.min(this.MAX_SIZE, width || 10));
833 height = Math.max(3, Math.min(this.MAX_SIZE, height || 10));
834 var n = width * height;
835 var walls = [];
836 var floors = [];
837 var ceilings = [];
838 for (var i = 0; i < n; i++)
839 {
840 var x = i % width;
841 var y = Math.floor(i / width);
842 var border = x === 0 || y === 0 || x === width - 1 || y === height - 1;
843 walls.push(border ? 1 : 0);
844 floors.push(border ? null : "stone");
845 ceilings.push(border ? null : "stone");
846 }
847 return {
848 id: "level-" + Date.now().toString(36),
849 name: name || "Nieuw level",
850 width: width,
851 height: height,
852 cellSize: 32,
853 ambient: this.DEFAULT_AMBIENT,
854 spawn: { tileX: 1, tileY: 1, yawRad: 0 },
855 walls: walls,
856 floors: floors,
857 ceilings: ceilings,
858 npcs: [],
859 lights: []
860 };
861 },
862
863 defaultPack: function ()
864 {
865 return {
866 format_version: this.CURRENT_VERSION,
867 textures: [
868 { id: "stone", url: "images/stone.png" },
869 { id: "wood", url: "images/wood.png" }
870 ],
871 levels: []
872 };
873 },
874
875 fromLegacyLevels: function (legacyArr, npcsByLevel)
876 {
877 var pack = this.defaultPack();
878 for (var i = 0; i < (legacyArr || []).length; i++)
879 {
880 var L = legacyArr[i];
881 var n = L.width * L.height;
882 var floors = [];
883 var ceilings = [];
884 for (var t = 0; t < n; t++)
885 {
886 var solid = L.tiles[t] === 1 || L.tiles[t] === 3;
887 floors.push(solid ? null : "stone");
888 ceilings.push(solid ? null : "stone");
889 }
890 pack.levels.push({
891 id: "level-" + (i + 1),
892 name: L.name || ("Level " + (i + 1)),
893 width: L.width,
894 height: L.height,
895 cellSize: 32,
896 ambient: this.DEFAULT_AMBIENT,
897 spawn: { tileX: L.spawnX, tileY: L.spawnY, yawRad: 0 },
898 walls: L.tiles.slice(),
899 floors: floors,
900 ceilings: ceilings,
901 npcs: (npcsByLevel && npcsByLevel[i]) || [],
902 lights: []
903 });
904 }
905 return pack;
906 },
907
908 migratePack: function (pack)
909 {
910 if (!pack || typeof pack !== "object")
911 { throw new Error("pack: root moet een object zijn"); }
912 var ver = pack.format_version;
913 if (ver === this.CURRENT_VERSION)
914 { return pack; }
915 if (ver === 1)
916 {
917 pack.format_version = 2;
918 for (var i = 0; i < (pack.levels || []).length; i++)
919 {
920 var L = pack.levels[i];
921 if (typeof L.ambient !== "number")
922 { L.ambient = this.DEFAULT_AMBIENT; }
923 if (!Array.isArray(L.lights))
924 { L.lights = []; }
925 for (var li = 0; li < L.lights.length; li++)
926 { this.normalizeLight(L.lights[li]); }
927 }
928 return pack;
929 }
930 throw new Error("pack: format_version " + ver + " niet ondersteund (wel: 1..2)");
931 },
932
933 normalizeLight: function (light)
934 {
935 if (!light || typeof light !== "object")
936 { throw new Error("light: moet een object zijn"); }
937 if (typeof light.x !== "number" || typeof light.y !== "number")
938 { throw new Error("light: x/y verplicht"); }
939 if (typeof light.z !== "number")
940 { light.z = 20; }
941 if (!Array.isArray(light.color) || light.color.length < 3)
942 { light.color = [1, 0.9, 0.7]; }
943 for (var c = 0; c < 3; c++)
944 {
945 var v = Number(light.color[c]);
946 if (!(v >= 0))
947 { v = 0; }
948 // allow 0–255 UI values
949 if (v > 1)
950 { v = v / 255; }
951 light.color[c] = v;
952 }
953 if (typeof light.intensity !== "number")
954 { light.intensity = 1; }
955 if (typeof light.range !== "number" || light.range <= 0)
956 { light.range = 96; }
957 if (typeof light.falloff !== "number")
958 { light.falloff = 2; }
959 if (!light.id || typeof light.id !== "string")
960 { light.id = "light-" + Math.floor(light.x) + "-" + Math.floor(light.y); }
961 return light;
962 },
963
964 validateTextureId: function (tex, allowNull)
965 {
966 if (tex == null || tex === "")
967 { return !!allowNull; }
968 return this.KNOWN_TEXTURES.indexOf(tex) >= 0;
969 },
970
971 validateLight: function (light, index, levelPrefix)
972 {
973 var prefix = (levelPrefix || "level") + ".lights[" + (index == null ? "?" : index) + "]";
974 try
975 { this.normalizeLight(light); }
976 catch (e)
977 { throw new Error(prefix + ": " + e.message); }
978 if (light.intensity < 0 || light.intensity > 20)
979 { throw new Error(prefix + ": intensity 0..20"); }
980 if (light.range > 2048)
981 { throw new Error(prefix + ": range te groot"); }
982 if (light.falloff < 0.5 || light.falloff > 8)
983 { throw new Error(prefix + ": falloff 0.5..8"); }
984 return light;
985 },
986
987 validateLevel: function (level, index)
988 {
989 var prefix = "level[" + (index == null ? "?" : index) + "]";
990 if (!level || typeof level !== "object")
991 { throw new Error(prefix + ": moet een object zijn"); }
992 if (!level.id || typeof level.id !== "string")
993 { throw new Error(prefix + ": id verplicht"); }
994 if (!level.name || typeof level.name !== "string")
995 { throw new Error(prefix + ": name verplicht"); }
996 var w = level.width | 0;
997 var h = level.height | 0;
998 if (w < 3 || h < 3 || w > this.MAX_SIZE || h > this.MAX_SIZE)
999 { throw new Error(prefix + ": width/height 3.." + this.MAX_SIZE); }
1000 var n = w * h;
1001 if (!Array.isArray(level.walls) || level.walls.length !== n)
1002 { throw new Error(prefix + ": walls lengte ≠ width*height"); }
1003 if (!Array.isArray(level.floors) || level.floors.length !== n)
1004 { throw new Error(prefix + ": floors lengte ≠ width*height"); }
1005 if (!Array.isArray(level.ceilings) || level.ceilings.length !== n)
1006 { throw new Error(prefix + ": ceilings lengte ≠ width*height"); }
1007 for (var i = 0; i < n; i++)
1008 {
1009 var wall = level.walls[i];
1010 if (typeof wall !== "number" || wall !== (wall | 0) || wall < 0 || wall > 3)
1011 { throw new Error(prefix + ": walls[" + i + "] ongeldig"); }
1012 if (!this.validateTextureId(level.floors[i], true))
1013 { throw new Error(prefix + ": floors[" + i + "] onbekende textuur"); }
1014 if (!this.validateTextureId(level.ceilings[i], true))
1015 { throw new Error(prefix + ": ceilings[" + i + "] onbekende textuur"); }
1016 }
1017 if (!level.spawn || typeof level.spawn.tileX !== "number" || typeof level.spawn.tileY !== "number")
1018 { throw new Error(prefix + ": spawn.tileX/tileY verplicht"); }
1019 if (level.spawn.tileX < 0 || level.spawn.tileY < 0 || level.spawn.tileX >= w || level.spawn.tileY >= h)
1020 { throw new Error(prefix + ": spawn buiten de map"); }
1021 if (typeof level.spawn.yawRad !== "number")
1022 { level.spawn.yawRad = 0; }
1023 if (!Array.isArray(level.npcs))
1024 { throw new Error(prefix + ": npcs moet een array zijn"); }
1025 if (!Array.isArray(level.lights))
1026 { level.lights = []; }
1027 if (level.lights.length > this.MAX_LIGHTS)
1028 { throw new Error(prefix + ": te veel lights"); }
1029 for (var li = 0; li < level.lights.length; li++)
1030 { this.validateLight(level.lights[li], li, prefix); }
1031 if (typeof level.ambient !== "number")
1032 { level.ambient = this.DEFAULT_AMBIENT; }
1033 if (level.ambient < 0 || level.ambient > 1)
1034 { throw new Error(prefix + ": ambient 0..1"); }
1035 if (level.cellSize == null)
1036 { level.cellSize = 32; }
1037 return level;
1038 },
1039
1040 validatePack: function (pack)
1041 {
1042 pack = this.migratePack(pack);
1043 if (pack.format_version !== this.CURRENT_VERSION)
1044 { throw new Error("pack: format_version " + pack.format_version + " niet ondersteund (wel: " + this.CURRENT_VERSION + ")"); }
1045 if (!Array.isArray(pack.levels))
1046 { throw new Error("pack: levels moet een array zijn"); }
1047 if (pack.levels.length > this.MAX_LEVELS)
1048 { throw new Error("pack: te veel levels"); }
1049 if (pack.levels.length < 1)
1050 { throw new Error("pack: minstens één level"); }
1051 var ids = {};
1052 for (var i = 0; i < pack.levels.length; i++)
1053 {
1054 this.validateLevel(pack.levels[i], i);
1055 if (ids[pack.levels[i].id])
1056 { throw new Error("pack: dubbele level-id " + pack.levels[i].id); }
1057 ids[pack.levels[i].id] = true;
1058 }
1059 if (!Array.isArray(pack.textures))
1060 { pack.textures = this.defaultPack().textures; }
1061 return pack;
1062 },
1063
1064 parse: function (jsonText)
1065 {
1066 var doc;
1067 try
1068 { doc = typeof jsonText === "string" ? JSON.parse(jsonText) : jsonText; }
1069 catch (e)
1070 { throw new Error("levels.json: ongeldige JSON (" + e.message + ")"); }
1071 return this.validatePack(doc);
1072 },
1073
1074 toRuntimeLevel: function (level)
1075 {
1076 return {
1077 id: level.id,
1078 name: level.name,
1079 width: level.width,
1080 height: level.height,
1081 cellSize: level.cellSize || 32,
1082 ambient: typeof level.ambient === "number" ? level.ambient : this.DEFAULT_AMBIENT,
1083 spawnX: level.spawn.tileX,
1084 spawnY: level.spawn.tileY,
1085 spawnYaw: level.spawn.yawRad || 0,
1086 tiles: level.walls,
1087 floors: level.floors,
1088 ceilings: level.ceilings,
1089 npcs: level.npcs || [],
1090 lights: level.lights || []
1091 };
1092 },
1093
1094 findLevelIndex: function (pack, query)
1095 {
1096 if (query == null || query === "")
1097 { return 0; }
1098 var asNum = Number(query);
1099 if (!isNaN(asNum) && asNum === (asNum | 0) && asNum >= 0 && asNum < pack.levels.length)
1100 { return asNum; }
1101 for (var i = 0; i < pack.levels.length; i++)
1102 {
1103 if (pack.levels[i].id === query || pack.levels[i].name === query)
1104 { return i; }
1105 }
1106 return -1;
1107 },
1108
1109 cloneLevel: function (level)
1110 {
1111 return JSON.parse(JSON.stringify(level));
1112 }
1113};
1114
1115if (typeof module !== "undefined" && module.exports)
1116{ module.exports = LevelFormat; }
1117
1118/*
1119 * End File:
1120 * /workspace/raytracer-work/src/levelFormat.js
1121 */
1122
1123/*
1124 * Start File:
1125 * /workspace/raytracer-work/src/floorCast.js
1126 */
1127/**
1128 * Classic floor/ceiling casting (Lode-style) — pure math + CPU NEAREST fill.
1129 * Chosen over a grid data-texture shader because frameworkv3 is WebGL1 sprites
1130 * without a shared depth buffer; one ImageData upload stays simple and keeps
1131 * wall/NPC draw order unchanged (floor under walls).
1132 *
1133 * posZ must match wall projection: wallH = (cellSize * screenH) / dist, so the
1134 * floor at distance d sits at p = (cellSize/2 * screenH) / d from the horizon.
1135 * Using posZ = screenH/2 made rowDist ≈ 1–2 across the whole floor (one flat
1136 * texel of a 400² texture).
1137 */
1138var FloorCast =
1139{
1140 /** Camera height in projection units: (cellSize/2) * screenH. */
1141 posZ: function (screenH, cellSize)
1142 {
1143 return (cellSize * 0.5) * screenH;
1144 },
1145
1146 /**
1147 * World-space floor hit for screen pixel (sx, sy).
1148 * @returns {{wx:number,wy:number,rowDist:number,isCeiling:boolean}|null}
1149 */
1150 floorHit: function (sx, sy, screenW, screenH, playerX, playerY, rot, pitch, posZ, cellSize)
1151 {
1152 cellSize = cellSize || 32;
1153 var mid = screenH / 2 + (-pitch * screenH * 0.25);
1154 var p = sy - mid;
1155 if (p === 0)
1156 { return null; }
1157 if (posZ == null)
1158 { posZ = this.posZ(screenH, cellSize); }
1159 var rowDist = posZ / Math.abs(p);
1160 var camX = (2 * sx / screenW) - 1;
1161 // Match wall FOV: rotationalOffset ≈ camX * (π/4) at screen edges.
1162 var rayAngle = rot + camX * (Math.PI / 4);
1163 var dirX = Math.cos(rayAngle);
1164 var dirY = Math.sin(rayAngle);
1165 return {
1166 wx: playerX + dirX * rowDist,
1167 wy: playerY + dirY * rowDist,
1168 rowDist: rowDist,
1169 isCeiling: p < 0
1170 };
1171 },
1172
1173 /**
1174 * Sample NEAREST from RGBA Uint8ClampedArray tex (tw×th).
1175 * u,v in [0,1) tile space (or any real; wraps).
1176 */
1177 sampleNearest: function (rgba, tw, th, u, v)
1178 {
1179 var tx = Math.floor(((u % 1) + 1) % 1 * tw);
1180 var ty = Math.floor(((v % 1) + 1) % 1 * th);
1181 if (tx < 0) tx = 0;
1182 if (ty < 0) ty = 0;
1183 if (tx >= tw) tx = tw - 1;
1184 if (ty >= th) ty = th - 1;
1185 var o = (ty * tw + tx) * 4;
1186 return [rgba[o], rgba[o + 1], rgba[o + 2], rgba[o + 3]];
1187 },
1188
1189 /**
1190 * Count unique RGB triples in ImageData (optionally only in a rect).
1191 * Useful for tests: textured floor must not collapse to 1–2 colours.
1192 */
1193 countUniqueRgb: function (imgData, screenW, screenH, x0, y0, x1, y1)
1194 {
1195 x0 = x0 == null ? 0 : x0;
1196 y0 = y0 == null ? 0 : y0;
1197 x1 = x1 == null ? screenW : x1;
1198 y1 = y1 == null ? screenH : y1;
1199 var data = imgData.data;
1200 var seen = Object.create(null);
1201 var n = 0;
1202 for (var y = y0; y < y1; y++)
1203 {
1204 for (var x = x0; x < x1; x++)
1205 {
1206 var o = (y * screenW + x) * 4;
1207 var key = data[o] + "," + data[o + 1] + "," + data[o + 2];
1208 if (!seen[key])
1209 {
1210 seen[key] = 1;
1211 n++;
1212 }
1213 }
1214 }
1215 return n;
1216 },
1217
1218 /**
1219 * Fill ImageData with floor (below horizon) and ceiling (above).
1220 * texMap: { stone: {rgba,w,h}, wood: {...} }
1221 * level: runtime level with floors[], ceilings[], width, height, cellSize
1222 */
1223 render: function (imgData, screenW, screenH, player, level, texMap, cellSize)
1224 {
1225 cellSize = cellSize || 32;
1226 var data = imgData.data;
1227 var mid = screenH / 2 + (-player.pitch * screenH * 0.25);
1228 var posZ = this.posZ(screenH, cellSize);
1229 var lw = level.width;
1230 var lh = level.height;
1231 var floors = level.floors;
1232 var ceilings = level.ceilings;
1233
1234 // Step 2×2: NEAREST block fill — ~4× sneller, nog steeds pixelig.
1235 var step = 2;
1236 for (var sy = 0; sy < screenH; sy += step)
1237 {
1238 var p = (sy + step * 0.5) - mid;
1239 if (Math.abs(p) < 0.5)
1240 { continue; }
1241 var isCeil = p < 0;
1242 var rowDist = posZ / Math.abs(p);
1243 // Mild distance shade; keep texel contrast readable.
1244 var shade = Math.max(0.45, Math.min(1, 1.05 - rowDist / (cellSize * 40)));
1245 for (var sx = 0; sx < screenW; sx += step)
1246 {
1247 var camX = (2 * (sx + step * 0.5) / screenW) - 1;
1248 var rayAngle = player.rotation + camX * (Math.PI / 4);
1249 var wx = player.x + Math.cos(rayAngle) * rowDist;
1250 var wy = player.y + Math.sin(rayAngle) * rowDist;
1251 var cx = Math.floor(wx / cellSize);
1252 var cy = Math.floor(wy / cellSize);
1253 var r = 0, g = 0, b = 0;
1254 if (cx >= 0 && cy >= 0 && cx < lw && cy < lh)
1255 {
1256 var idx = cx + cy * lw;
1257 var texId = isCeil ? ceilings[idx] : floors[idx];
1258 if (texId && texMap[texId])
1259 {
1260 var tex = texMap[texId];
1261 var u = wx / cellSize;
1262 var vv = wy / cellSize;
1263 var c = this.sampleNearest(tex.rgba, tex.w, tex.h, u, vv);
1264 var wz = isCeil ? cellSize : 0;
1265 var nrm = isCeil
1266 ? { x: 0, y: 0, z: -1 }
1267 : { x: 0, y: 0, z: 1 };
1268 var lights = level.lights || [];
1269 var ambient = level.ambient != null ? level.ambient : 0.38;
1270 var lit;
1271 if (typeof Lighting !== "undefined" && lights.length)
1272 {
1273 var los = level.tiles
1274 ? { tiles: level.tiles, width: lw, height: lh, cellSize: cellSize }
1275 : null;
1276 lit = Lighting.shadeRgb({ x: wx, y: wy, z: wz }, nrm, lights, ambient, los);
1277 }
1278 else
1279 {
1280 // No lamps: keep previous distance shade look.
1281 lit = { r: shade, g: shade, b: shade };
1282 }
1283 r = Math.min(255, (c[0] * lit.r) | 0);
1284 g = Math.min(255, (c[1] * lit.g) | 0);
1285 b = Math.min(255, (c[2] * lit.b) | 0);
1286 }
1287 }
1288 for (var dy = 0; dy < step && sy + dy < screenH; dy++)
1289 {
1290 for (var dx = 0; dx < step && sx + dx < screenW; dx++)
1291 {
1292 var o = ((sy + dy) * screenW + (sx + dx)) * 4;
1293 data[o] = r;
1294 data[o + 1] = g;
1295 data[o + 2] = b;
1296 data[o + 3] = 255;
1297 }
1298 }
1299 }
1300 }
1301 return imgData;
1302 }
1303};
1304
1305if (typeof module !== "undefined" && module.exports)
1306{ module.exports = FloorCast; }
1307
1308/*
1309 * End File:
1310 * /workspace/raytracer-work/src/floorCast.js
1311 */
1312
1313/*
1314 * Start File:
1315 * /workspace/raytracer-work/src/lighting.js
1316 */
1317/**
1318 * Point lights for the raycaster (CPU).
1319 * Walls/floor/ceiling: Lambertian N·L + distance falloff + optional grid LOS.
1320 * Paperdolls: same lights, L transformed into the .ppda view space (view=+Z)
1321 * so baked normals respond correctly (see Paperdoll compositor.rs relight).
1322 *
1323 * CPU (not a custom WebGL shader): frameworkv3 is sprite/WebGL1 without a
1324 * shared G-buffer; floor is already an ImageData upload, walls are 1px
1325 * columns, NPCs are a CPU z-buffer overlay — lighting fits those paths with
1326 * no extra GPU pipeline. Grid LOS is O(steps) per sample and capped by
1327 * light range; cheaper than raymarched shadows and enough for tile maps.
1328 */
1329var Lighting =
1330{
1331 DEFAULT_AMBIENT: 0.38,
1332 MAX_LIGHTS: 32,
1333
1334 normalize3: function (x, y, z)
1335 {
1336 var len = Math.sqrt(x * x + y * y + z * z);
1337 if (len < 1e-8)
1338 { return { x: 0, y: 0, z: 1 }; }
1339 return { x: x / len, y: y / len, z: z / len };
1340 },
1341
1342 decodeNormalRgb: function (r, g, b)
1343 {
1344 return this.normalize3(
1345 r / 255 * 2 - 1,
1346 g / 255 * 2 - 1,
1347 b / 255 * 2 - 1
1348 );
1349 },
1350
1351 /** intensity * saturate(1 - dist/range)^falloff */
1352 attenuation: function (dist, range, falloff)
1353 {
1354 if (range <= 0)
1355 { return 0; }
1356 var t = 1 - dist / range;
1357 if (t <= 0)
1358 { return 0; }
1359 var f = falloff == null ? 2 : falloff;
1360 if (f === 1)
1361 { return t; }
1362 if (f === 2)
1363 { return t * t; }
1364 return Math.pow(t, f);
1365 },
1366
1367 faceNormal: function (dir)
1368 {
1369 switch (dir)
1370 {
1371 case "north": return { x: 0, y: -1, z: 0 };
1372 case "south": return { x: 0, y: 1, z: 0 };
1373 case "east": return { x: 1, y: 0, z: 0 };
1374 case "west": return { x: -1, y: 0, z: 0 };
1375 case "floor": return { x: 0, y: 0, z: 1 };
1376 case "ceiling": return { x: 0, y: 0, z: -1 };
1377 default: return { x: 0, y: 0, z: 1 };
1378 }
1379 },
1380
1381 /**
1382 * Grid line-of-sight on the wall map (Bresenham). Endpoints are the light
1383 * and sample tiles; a solid wall strictly between blocks the ray.
1384 */
1385 hasLineOfSight: function (x0, y0, x1, y1, tiles, mapW, mapH, cellSize)
1386 {
1387 cellSize = cellSize || 32;
1388 var tx0 = Math.floor(x0 / cellSize);
1389 var ty0 = Math.floor(y0 / cellSize);
1390 var tx1 = Math.floor(x1 / cellSize);
1391 var ty1 = Math.floor(y1 / cellSize);
1392 var dx = Math.abs(tx1 - tx0);
1393 var dy = Math.abs(ty1 - ty0);
1394 var sx = tx0 < tx1 ? 1 : -1;
1395 var sy = ty0 < ty1 ? 1 : -1;
1396 var err = dx - dy;
1397 var x = tx0;
1398 var y = ty0;
1399 var steps = 0;
1400 var maxSteps = dx + dy + 2;
1401 while (!(x === tx1 && y === ty1) && steps < maxSteps)
1402 {
1403 steps++;
1404 var e2 = 2 * err;
1405 if (e2 > -dy) { err -= dy; x += sx; }
1406 if (e2 < dx) { err += dx; y += sy; }
1407 if (x === tx1 && y === ty1)
1408 { break; }
1409 if (x < 0 || y < 0 || x >= mapW || y >= mapH)
1410 { return false; }
1411 var id = tiles[x + y * mapW];
1412 if (id === 1 || id === 3)
1413 { return false; }
1414 }
1415 return true;
1416 },
1417
1418 /**
1419 * RGB multipliers (can exceed 1 before clamp by caller).
1420 * @param {{x,y,z}} pos world
1421 * @param {{x,y,z}} normal unit
1422 * @param {Array} lights
1423 * @param {number} ambient
1424 * @param {object|null} los { tiles, width, height, cellSize } or null to skip
1425 */
1426 shadeRgb: function (pos, normal, lights, ambient, los)
1427 {
1428 ambient = ambient == null ? this.DEFAULT_AMBIENT : ambient;
1429 var r = ambient;
1430 var g = ambient;
1431 var b = ambient;
1432 if (!lights || !lights.length)
1433 { return { r: r, g: g, b: b }; }
1434 var n = Math.min(lights.length, this.MAX_LIGHTS);
1435 for (var i = 0; i < n; i++)
1436 {
1437 var L = lights[i];
1438 var lx = L.x, ly = L.y, lz = L.z != null ? L.z : 16;
1439 var dx = lx - pos.x;
1440 var dy = ly - pos.y;
1441 var dz = lz - pos.z;
1442 var dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
1443 var att = this.attenuation(dist, L.range || 64, L.falloff);
1444 if (att <= 0.001)
1445 { continue; }
1446 if (los && !this.hasLineOfSight(lx, ly, pos.x, pos.y, los.tiles, los.width, los.height, los.cellSize))
1447 { continue; }
1448 var ld = this.normalize3(dx, dy, dz);
1449 var ndotl = normal.x * ld.x + normal.y * ld.y + normal.z * ld.z;
1450 if (ndotl <= 0)
1451 { continue; }
1452 var inten = (L.intensity == null ? 1 : L.intensity) * att * ndotl;
1453 var cr = L.color ? L.color[0] : 1;
1454 var cg = L.color ? L.color[1] : 1;
1455 var cb = L.color ? L.color[2] : 1;
1456 r += inten * cr;
1457 g += inten * cg;
1458 b += inten * cb;
1459 }
1460 return { r: r, g: g, b: b };
1461 },
1462
1463 /**
1464 * Transform a world-space direction (toward light) into paperdoll view space
1465 * for the chosen yaw (degrees). View +Z = toward capture camera (= front at yaw 0).
1466 * Character +Z (front) aligns with facingDeg in the XY plane; +Y = world up (Z).
1467 */
1468 worldDirToView: function (dirX, dirY, dirZ, yawDeg, facingDeg)
1469 {
1470 var face = (facingDeg || 0) * Math.PI / 180;
1471 var yaw = (yawDeg || 0) * Math.PI / 180;
1472 // Character basis in world (XY) + up Z
1473 var frontX = Math.cos(face);
1474 var frontY = Math.sin(face);
1475 var rightX = -Math.sin(face);
1476 var rightY = Math.cos(face);
1477 // Camera direction from character (char space): yaw 0 → +Z front
1478 var camCX = Math.sin(yaw);
1479 var camCZ = Math.cos(yaw);
1480 var camX = rightX * camCX + frontX * camCZ;
1481 var camY = rightY * camCX + frontY * camCZ;
1482 // viewZ = camDir (toward camera), viewY = up, viewX = viewY × viewZ
1483 var viewZx = camX, viewZy = camY, viewZz = 0;
1484 var viewYx = 0, viewYy = 0, viewYz = 1;
1485 // cross(up, viewZ) for right-handed viewX? Standard: viewX = normalize(cross(viewY?))
1486 // viewX = cross(viewY, viewZ) with viewY=up → (-viewZy, viewZx, 0) wait:
1487 // cross((0,0,1), (camX,camY,0)) = (-camY, camX, 0)
1488 var viewXx = -camY;
1489 var viewXy = camX;
1490 var viewXz = 0;
1491 var vlen = Math.sqrt(viewXx * viewXx + viewXy * viewXy);
1492 if (vlen > 1e-8)
1493 { viewXx /= vlen; viewXy /= vlen; }
1494 return this.normalize3(
1495 dirX * viewXx + dirY * viewXy + dirZ * viewXz,
1496 dirX * viewYx + dirY * viewYy + dirZ * viewYz,
1497 dirX * viewZx + dirY * viewZy + dirZ * viewZz
1498 );
1499 },
1500
1501 /**
1502 * Relight one paperdoll pixel (albedo RGB + view-space normal) with point lights.
1503 * pixelWorld ≈ NPC base + height from atlas row; depth shifts along view cam.
1504 */
1505 shadePaperdollPixel: function (albedoR, albedoG, albedoB, nr, ng, nb, pixelWorld, lights, ambient, yawDeg, facingDeg)
1506 {
1507 ambient = ambient == null ? this.DEFAULT_AMBIENT : ambient;
1508 var n = this.decodeNormalRgb(nr, ng, nb);
1509 var r = ambient * albedoR;
1510 var g = ambient * albedoG;
1511 var b = ambient * albedoB;
1512 if (!lights || !lights.length)
1513 {
1514 // Match old preview-ish fill when no lamps: slight Lambert from default view light
1515 var nd = Math.max(0, n.x * 0.3 + n.y * 0.2 + n.z * 0.9);
1516 var shade = Math.min(1, 0.35 + 0.65 * nd);
1517 return {
1518 r: Math.min(255, Math.round(albedoR * shade)),
1519 g: Math.min(255, Math.round(albedoG * shade)),
1520 b: Math.min(255, Math.round(albedoB * shade))
1521 };
1522 }
1523 var count = Math.min(lights.length, this.MAX_LIGHTS);
1524 for (var i = 0; i < count; i++)
1525 {
1526 var L = lights[i];
1527 var lx = L.x, ly = L.y, lz = L.z != null ? L.z : 16;
1528 var dx = lx - pixelWorld.x;
1529 var dy = ly - pixelWorld.y;
1530 var dz = lz - pixelWorld.z;
1531 var dist = Math.sqrt(dx * dx + dy * dy + dz * dz);
1532 var att = this.attenuation(dist, L.range || 64, L.falloff);
1533 if (att <= 0.001)
1534 { continue; }
1535 var lv = this.worldDirToView(dx, dy, dz, yawDeg, facingDeg);
1536 var ndotl = n.x * lv.x + n.y * lv.y + n.z * lv.z;
1537 if (ndotl <= 0)
1538 { continue; }
1539 var inten = (L.intensity == null ? 1 : L.intensity) * att * ndotl;
1540 var cr = L.color ? L.color[0] : 1;
1541 var cg = L.color ? L.color[1] : 1;
1542 var cb = L.color ? L.color[2] : 1;
1543 r += albedoR * inten * cr;
1544 g += albedoG * inten * cg;
1545 b += albedoB * inten * cb;
1546 }
1547 return {
1548 r: Math.min(255, Math.round(r)),
1549 g: Math.min(255, Math.round(g)),
1550 b: Math.min(255, Math.round(b))
1551 };
1552 },
1553
1554 /** Legacy wall face shade (no lamps) — keep look of pre-light builds. */
1555 legacyFaceShade: function (dir)
1556 {
1557 switch (dir)
1558 {
1559 case "east": return 0.9;
1560 case "west": return 0.8;
1561 case "south": return 0.7;
1562 default: return 1.0;
1563 }
1564 }
1565};
1566
1567if (typeof module !== "undefined" && module.exports)
1568{ module.exports = Lighting; }
1569
1570/*
1571 * End File:
1572 * /workspace/raytracer-work/src/lighting.js
1573 */
1574
1575/*
1576 * Start File:
1577 * /workspace/raytracer-work/src/levels.js
1578 */
1579var Levels =
1580[
1581 {
1582 name: "Level 1",
1583 width: 10,
1584 height: 10,
1585 spawnX: 1,
1586 spawnY: 1,
1587 tiles:
1588 [
1589 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1590 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1591 1, 0, 1, 1, 0, 0, 3, 3, 0, 1,
1592 1, 0, 0, 1, 0, 0, 0, 0, 0, 1,
1593 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1594 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1595 1, 0, 0, 0, 0, 1, 2, 1, 0, 1,
1596 1, 0, 1, 0, 0, 1, 3, 1, 0, 1,
1597 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1598 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
1599 ]
1600 }
1601];
1602
1603/*
1604 * End File:
1605 * /workspace/raytracer-work/src/levels.js
1606 */
1607
1608/*
1609 * Start File:
1610 * /workspace/raytracer-work/src/tiles.js
1611 */
1612/** Tile table; Image fields filled after preload. */
1613var Tiles =
1614{
1615 Nothing:
1616 {
1617 ID: 0,
1618 Color: { R: 255, G: 255, B: 255 },
1619 Solid: false,
1620 ImageName: null
1621 },
1622 Stone:
1623 {
1624 ID: 1,
1625 Color: { R: 155, G: 155, B: 155 },
1626 Solid: true,
1627 ImageName: "stone"
1628 },
1629 Finish:
1630 {
1631 ID: 2,
1632 Color: { R: 255, G: 255, B: 0 },
1633 Solid: false,
1634 ImageName: null
1635 },
1636 Wood:
1637 {
1638 ID: 3,
1639 Color: { R: 168, G: 102, B: 50 },
1640 Solid: true,
1641 ImageName: "wood"
1642 },
1643 findByID: function (id)
1644 {
1645 for (var key in Tiles)
1646 {
1647 if (!Object.prototype.hasOwnProperty.call(Tiles, key))
1648 { continue; }
1649 var value = Tiles[key];
1650 if (value && value.ID === id)
1651 { return value; }
1652 }
1653 return null;
1654 },
1655 bindImages: function (images)
1656 {
1657 for (var key in Tiles)
1658 {
1659 if (!Object.prototype.hasOwnProperty.call(Tiles, key))
1660 { continue; }
1661 var tile = Tiles[key];
1662 if (tile && tile.ImageName && images[tile.ImageName])
1663 { tile.Image = images[tile.ImageName]; }
1664 }
1665 }
1666};
1667
1668/*
1669 * End File:
1670 * /workspace/raytracer-work/src/tiles.js
1671 */
1672
1673/*
1674 * Start File:
1675 * /workspace/raytracer-work/src/world.js
1676 */
1677var World =
1678{
1679 size: 32,
1680 level: null,
1681 pack: null,
1682 levelIndex: 0,
1683
1684 loadPack: function (pack)
1685 {
1686 this.pack = pack;
1687 },
1688
1689 loadLevel: function (indexOrId)
1690 {
1691 if (!this.pack)
1692 { throw new Error("World: geen level-pack geladen"); }
1693 var idx = typeof indexOrId === "number"
1694 ? indexOrId
1695 : LevelFormat.findLevelIndex(this.pack, indexOrId);
1696 if (idx < 0 || idx >= this.pack.levels.length)
1697 { throw new Error("World: level niet gevonden: " + indexOrId); }
1698 this.levelIndex = idx;
1699 this.level = LevelFormat.toRuntimeLevel(this.pack.levels[idx]);
1700 this.size = this.level.cellSize || 32;
1701 },
1702
1703 spawnPoint: function ()
1704 {
1705 return {
1706 x: this.level.spawnX * this.size + this.size / 2,
1707 y: this.level.spawnY * this.size + this.size / 2,
1708 yaw: this.level.spawnYaw || 0
1709 };
1710 },
1711
1712 rayCast: function (x, y, radian)
1713 {
1714 var maxDist = this.level.width + this.level.height;
1715 var cell = this.size;
1716 var tileXpercentage = 0;
1717 var tileXp = 0;
1718 var tileYp = 0;
1719
1720 var hrayX, hrayY, hoffX, hoffY, distDone, hmapX, hmapY, htileHit;
1721 var hDir = "north";
1722 distDone = 0;
1723 var aTan = -1 / Math.tan(radian);
1724
1725 if (radian > Math.PI)
1726 {
1727 hrayY = Math.floor(y / cell) * cell - 0.01;
1728 hrayX = (y - hrayY) * aTan + x;
1729 hoffY = -cell;
1730 hoffX = -hoffY * aTan;
1731 }
1732 else if (radian < Math.PI)
1733 {
1734 hrayY = Math.floor(y / cell) * cell + cell;
1735 hrayX = (y - hrayY) * aTan + x;
1736 hoffY = cell;
1737 hoffX = -hoffY * aTan;
1738 hDir = "south";
1739 }
1740 else
1741 {
1742 hrayX = x;
1743 hrayY = y;
1744 distDone = maxDist;
1745 }
1746
1747 while (distDone < maxDist)
1748 {
1749 tileXp = ((hrayX % cell) + cell) % cell / cell;
1750 tileYp = ((hrayY % cell) + cell) % cell / cell;
1751 hmapX = Math.floor(hrayX / cell);
1752 hmapY = Math.floor(hrayY / cell);
1753 var htileHitId = this.level.tiles[hmapX + hmapY * this.level.width];
1754 htileHit = Tiles.findByID(htileHitId);
1755 if (htileHit && htileHit.Solid)
1756 { distDone = maxDist; }
1757 else
1758 {
1759 hrayX += hoffX;
1760 hrayY += hoffY;
1761 distDone += 1;
1762 }
1763 }
1764
1765 switch (hDir)
1766 {
1767 case "north": tileXpercentage = tileXp; break;
1768 case "south": tileXpercentage = 1 - tileXp; break;
1769 case "east": tileXpercentage = 1 - tileYp; break;
1770 case "west": tileXpercentage = tileYp; break;
1771 }
1772
1773 var hResult = {
1774 tile: htileHit,
1775 tileX: tileXpercentage,
1776 endX: hrayX,
1777 endY: hrayY,
1778 dir: hDir
1779 };
1780
1781 var rayX, rayY, offX, offY, mapX, mapY, tileHit;
1782 var vDir = "east";
1783 var nTan = -Math.tan(radian);
1784 distDone = 0;
1785
1786 if (radian > Math.PI / 2 && radian < Math.PI * 1.5)
1787 {
1788 rayX = Math.floor(x / cell) * cell - 0.01;
1789 rayY = (x - rayX) * nTan + y;
1790 offX = -cell;
1791 offY = -offX * nTan;
1792 }
1793 else if (radian < Math.PI / 2 || radian > Math.PI * 1.5)
1794 {
1795 rayX = Math.floor(x / cell) * cell + cell;
1796 rayY = (x - rayX) * nTan + y;
1797 offX = cell;
1798 offY = -offX * nTan;
1799 vDir = "west";
1800 }
1801 else
1802 {
1803 rayX = x;
1804 rayY = y;
1805 distDone = maxDist;
1806 }
1807
1808 while (distDone < maxDist)
1809 {
1810 tileXp = ((rayX % cell) + cell) % cell / cell;
1811 tileYp = ((rayY % cell) + cell) % cell / cell;
1812 mapX = Math.floor(rayX / cell);
1813 mapY = Math.floor(rayY / cell);
1814 var tileHitId = this.level.tiles[mapX + mapY * this.level.width];
1815 tileHit = Tiles.findByID(tileHitId);
1816 if (tileHit && tileHit.Solid)
1817 { distDone = maxDist; }
1818 else
1819 {
1820 rayX += offX;
1821 rayY += offY;
1822 distDone += 1;
1823 }
1824 }
1825
1826 switch (vDir)
1827 {
1828 case "north": tileXpercentage = tileXp; break;
1829 case "south": tileXpercentage = 1 - tileXp; break;
1830 case "east": tileXpercentage = 1 - tileYp; break;
1831 case "west": tileXpercentage = tileYp; break;
1832 }
1833
1834 var vResult = {
1835 tile: tileHit,
1836 tileX: tileXpercentage,
1837 endX: rayX,
1838 endY: rayY,
1839 dir: vDir
1840 };
1841
1842 var dxH = hResult.endX - x;
1843 var dyH = hResult.endY - y;
1844 var dxV = vResult.endX - x;
1845 var dyV = vResult.endY - y;
1846 hResult.distance = Math.sqrt(dxH * dxH + dyH * dyH);
1847 vResult.distance = Math.sqrt(dxV * dxV + dyV * dyV);
1848
1849 if (hResult.distance < vResult.distance)
1850 { return hResult; }
1851 return vResult;
1852 }
1853};
1854
1855if (typeof module !== "undefined" && module.exports)
1856{
1857 module.exports = { World: World };
1858}
1859
1860/*
1861 * End File:
1862 * /workspace/raytracer-work/src/world.js
1863 */
1864
1865/*
1866 * Start File:
1867 * /workspace/raytracer-work/src/player.js
1868 */
1869var Player =
1870{
1871 x: 0,
1872 y: 0,
1873 rotation: 0,
1874 pitch: 0,
1875 /** Screen columns per frame. 240 is sharp on ~1080p and cheap (~240 drawSprite calls). */
1876 horizontalResolution: 240,
1877 gunX: 0.6,
1878 gunY: 0.6,
1879 currentGun: 0,
1880 guns: 3,
1881
1882 resetToSpawn: function ()
1883 {
1884 var spawn = World.spawnPoint();
1885 this.x = spawn.x;
1886 this.y = spawn.y;
1887 this.rotation = spawn.yaw != null ? spawn.yaw : 0;
1888 this.pitch = 0;
1889 },
1890
1891 applyLookDelta: function (movementX, movementY)
1892 {
1893 this.pitch += movementY * 0.01;
1894 this.rotation += movementX * 0.001;
1895 if (this.pitch > Math.PI)
1896 { this.pitch = Math.PI; }
1897 if (this.pitch < -Math.PI)
1898 { this.pitch = -Math.PI; }
1899 if (this.rotation > Math.PI * 2)
1900 { this.rotation -= Math.PI * 2; }
1901 if (this.rotation < 0)
1902 { this.rotation += Math.PI * 2; }
1903 },
1904
1905 /** Legacy angles: 0 = +X (east), increases toward +Y. */
1906 forwardVector: function (radian)
1907 {
1908 return { x: Math.cos(radian), y: Math.sin(radian) };
1909 },
1910
1911 tryMove: function (rot, speed, deltaTime)
1912 {
1913 if (World.rayCast(this.x, this.y, rot).distance <= 5)
1914 { return; }
1915 var forward = this.forwardVector(rot);
1916 this.x += forward.x * deltaTime * speed;
1917 this.y += forward.y * deltaTime * speed;
1918 },
1919
1920 update: function (deltaTime)
1921 {
1922 if (GameInput.isHeld(37) || GameInput.isHeld(65))
1923 {
1924 var rotL = this.rotation - Math.PI / 2;
1925 if (rotL < 0) { rotL += Math.PI * 2; }
1926 this.tryMove(rotL, 60, deltaTime);
1927 }
1928 if (GameInput.isHeld(39) || GameInput.isHeld(68))
1929 {
1930 var rotR = this.rotation + Math.PI / 2;
1931 if (rotR > Math.PI * 2) { rotR -= Math.PI * 2; }
1932 this.tryMove(rotR, 60, deltaTime);
1933 }
1934 if (GameInput.isHeld(38) || GameInput.isHeld(87))
1935 { this.tryMove(this.rotation, 60, deltaTime); }
1936 if (GameInput.isHeld(40) || GameInput.isHeld(83))
1937 {
1938 var rotB = this.rotation + Math.PI;
1939 if (rotB > Math.PI * 2) { rotB -= Math.PI * 2; }
1940 if (World.rayCast(this.x, this.y, rotB).distance > 5)
1941 {
1942 var forward = this.forwardVector(this.rotation);
1943 this.x -= forward.x * deltaTime * 40;
1944 this.y -= forward.y * deltaTime * 40;
1945 }
1946 }
1947 if (GameInput.isHeld(188))
1948 {
1949 this.horizontalResolution -= this.horizontalResolution * 0.1 * deltaTime;
1950 if (this.horizontalResolution < 30)
1951 { this.horizontalResolution = 30; }
1952 }
1953 if (GameInput.isHeld(190))
1954 {
1955 this.horizontalResolution += this.horizontalResolution * 0.1 * deltaTime;
1956 }
1957 }
1958};
1959
1960/*
1961 * End File:
1962 * /workspace/raytracer-work/src/player.js
1963 */
1964
1965/*
1966 * Start File:
1967 * /workspace/raytracer-work/src/npc.js
1968 */
1969/**
1970 * Paperdoll NPC billboards.
1971 * Compose body+gear on CPU when view/frame changes (cell ~32×48).
1972 * Project with per-pixel depth into an offscreen RGBA buffer + z-buffer,
1973 * then one WebGL textured quad — avoids thousands of drawSprite calls.
1974 */
1975var NpcSystem =
1976{
1977 npcs: [],
1978 bodySet: null,
1979 gearSet: null,
1980 ready: false,
1981 cache: {},
1982 worldScale: 32,
1983 _overlay: null,
1984 _overlayCtx: null,
1985 _overlayImg: null,
1986 _zbuf: null,
1987 _zbufW: 0,
1988 _zbufH: 0,
1989
1990 initEmpty: function ()
1991 {
1992 this.npcs = [];
1993 this.cache = {};
1994 this.ready = false;
1995 },
1996
1997 addNpc: function (opts)
1998 {
1999 this.npcs.push({
2000 x: opts.x,
2001 y: opts.y,
2002 facingDeg: opts.facingDeg || 0,
2003 clip: opts.clip || "walk",
2004 animating: opts.animating !== false,
2005 time: opts.time || 0,
2006 label: opts.label || "npc"
2007 });
2008 },
2009
2010 load: function (bodyBase, bodyPpda, gearBase, gearPpda)
2011 {
2012 var self = this;
2013 return PpdaAtlasRuntime.loadSet(bodyBase, bodyPpda).then(function (body)
2014 {
2015 self.bodySet = body;
2016 if (!gearBase)
2017 {
2018 self.ready = true;
2019 return body;
2020 }
2021 return PpdaAtlasRuntime.loadSet(gearBase, gearPpda).then(function (gear)
2022 {
2023 PpdaLoader.assertCompatible(body.ppda, gear.ppda);
2024 self.gearSet = gear;
2025 self.ready = true;
2026 return body;
2027 });
2028 });
2029 },
2030
2031 update: function (dt)
2032 {
2033 for (var i = 0; i < this.npcs.length; i++)
2034 {
2035 if (this.npcs[i].animating)
2036 { this.npcs[i].time += dt; }
2037 }
2038 },
2039
2040 composedFor: function (npc, pitch, yaw)
2041 {
2042 if (!this.bodySet)
2043 { return null; }
2044 var clip = PpdaViewFrame.findClip(this.bodySet.ppda, npc.clip);
2045 var frameCount = clip ? clip.frame_count : 1;
2046 var frame = PpdaViewFrame.frameIndex(npc.time, this.bodySet.ppda.fps, frameCount);
2047 var key = npc.clip + "|" + frame + "|" + pitch + "|" + yaw;
2048 if (this.cache[key])
2049 { return this.cache[key]; }
2050 var composed = PpdaAtlasRuntime.composeView(
2051 this.bodySet,
2052 this.gearSet,
2053 npc.clip,
2054 frame,
2055 pitch,
2056 yaw
2057 );
2058 this.cache[key] = composed;
2059 var keys = Object.keys(this.cache);
2060 if (keys.length > 96)
2061 { delete this.cache[keys[0]]; }
2062 return composed;
2063 },
2064
2065 _ensureOverlay: function (w, h)
2066 {
2067 if (!this._overlay || this._overlay.width !== w || this._overlay.height !== h)
2068 {
2069 this._overlay = document.createElement("canvas");
2070 this._overlay.width = w;
2071 this._overlay.height = h;
2072 this._overlayCtx = this._overlay.getContext("2d");
2073 this._overlayImg = null;
2074 this._overlayTex = null;
2075 this._zbuf = new Float32Array(w * h);
2076 this._zbufW = w;
2077 this._zbufH = h;
2078 }
2079 },
2080
2081 /**
2082 * @param {Float32Array} wallDepthPerCol length = screen width
2083 */
2084 draw: function (scene, player, wallDepthPerCol)
2085 {
2086 if (!this.ready || !this.bodySet)
2087 { return; }
2088
2089 var w = Math.round(scene.real_size.x);
2090 var h = Math.round(scene.real_size.y);
2091 this._ensureOverlay(w, h);
2092 var ctx = this._overlayCtx;
2093 ctx.clearRect(0, 0, w, h);
2094 var img = ctx.createImageData(w, h);
2095 var data = img.data;
2096 var zbuf = this._zbuf;
2097 var i;
2098 for (i = 0; i < w * h; i++)
2099 {
2100 var col = i % w;
2101 zbuf[i] = wallDepthPerCol[col];
2102 }
2103
2104 var ppda = this.bodySet.ppda;
2105 var heightM = (ppda.height_milli || 2600) / 1000;
2106 var camDist = ppda.camera_distance || 10;
2107 var near = ppda.depth_near;
2108 var far = ppda.depth_far;
2109 var metersToWorld = this.worldScale;
2110 var tint = scene.npcLight != null ? scene.npcLight : 1;
2111
2112 var list = this.npcs.slice().sort(function (a, b)
2113 {
2114 var da = (a.x - player.x) * (a.x - player.x) + (a.y - player.y) * (a.y - player.y);
2115 var db = (b.x - player.x) * (b.x - player.x) + (b.y - player.y) * (b.y - player.y);
2116 return db - da;
2117 });
2118
2119 for (var ni = 0; ni < list.length; ni++)
2120 {
2121 var npc = list[ni];
2122 var dx = npc.x - player.x;
2123 var dy = npc.y - player.y;
2124 var dist = Math.sqrt(dx * dx + dy * dy);
2125 if (dist < 0.5 || dist > 800)
2126 { continue; }
2127
2128 var angleTo = Math.atan2(dy, dx);
2129 var delta = angleTo - player.rotation;
2130 while (delta > Math.PI) { delta -= Math.PI * 2; }
2131 while (delta < -Math.PI) { delta += Math.PI * 2; }
2132 if (Math.abs(delta) > Math.PI * 0.55)
2133 { continue; }
2134
2135 var relYaw = PpdaViewFrame.relativeYawDeg(player.x, player.y, npc.x, npc.y, npc.facingDeg);
2136 var yaw = PpdaViewFrame.pickYaw(relYaw, ppda.yaws);
2137 var pitch = Math.abs(player.pitch) < 0.25
2138 ? PpdaViewFrame.nearestInList(0, ppda.pitches)
2139 : PpdaViewFrame.pickPitch(player.pitch, ppda.pitches);
2140
2141 var clipInfo = PpdaViewFrame.findClip(ppda, npc.clip);
2142 var frame = PpdaViewFrame.frameIndex(
2143 npc.time, ppda.fps, clipInfo ? clipInfo.frame_count : 1
2144 );
2145 var composed = this.composedFor(npc, pitch, yaw);
2146 if (!composed)
2147 { continue; }
2148
2149 var spriteH = (World.size * heightM) * (h / dist) * 0.5;
2150 var aspect = composed.width / Math.max(1, composed.height);
2151 var spriteW = spriteH * aspect;
2152 var screenX = (w / 2) + (delta / (Math.PI / 3)) * (w / 2);
2153 // Horizon + pitch (same mid as FloorCast). Visual feet (= last opaque
2154 // atlas row) sit on the floor plane at this distance.
2155 var mid = h / 2 + (-player.pitch * h * 0.25);
2156 var floorY = mid + (World.size * 0.5 * h) / dist;
2157 var left = screenX - spriteW / 2;
2158 // Feet from BODY atlas only (gear can hang below and would lift the sprite).
2159 var feetRow = composed.height - 1;
2160 var feetH = composed.height;
2161 var feetW = composed.width;
2162 var feetAlpha = composed.diffuse;
2163 try
2164 {
2165 var bodyLayer = PpdaAtlasRuntime.layerFromSet(
2166 this.bodySet, npc.clip, frame, pitch, yaw
2167 );
2168 feetAlpha = bodyLayer.diffuse;
2169 feetW = bodyLayer.width;
2170 feetH = bodyLayer.height;
2171 feetRow = feetH - 1;
2172 }
2173 catch (e) { /* fallback: composed */ }
2174 for (var fy = feetH - 1; fy >= 0; fy--)
2175 {
2176 var rowHit = false;
2177 for (var fx = 0; fx < feetW; fx++)
2178 {
2179 if (feetAlpha[(fy * feetW + fx) * 4 + 3] > 10)
2180 { rowHit = true; break; }
2181 }
2182 if (rowHit)
2183 { feetRow = fy; break; }
2184 }
2185 var top = floorY - ((feetRow + 0.5) / feetH) * spriteH;
2186 var cols = Math.max(1, Math.ceil(spriteW));
2187
2188 for (var c = 0; c < cols; c++)
2189 {
2190 var sx = Math.floor(left + c);
2191 if (sx < 0 || sx >= w)
2192 { continue; }
2193 var u = (c + 0.5) / cols;
2194 var texX = Math.min(composed.width - 1, Math.max(0, Math.floor(u * composed.width)));
2195 var y0 = Math.floor(top);
2196 var y1 = Math.ceil(top + spriteH);
2197
2198 for (var sy = y0; sy < y1; sy++)
2199 {
2200 if (sy < 0 || sy >= h)
2201 { continue; }
2202 var v = (sy - top + 0.5) / spriteH;
2203 if (v < 0 || v >= 1)
2204 { continue; }
2205 var texY = Math.min(composed.height - 1, Math.max(0, Math.floor(v * composed.height)));
2206 var pi = texY * composed.width + texX;
2207 var a = composed.diffuse[pi * 4 + 3];
2208 if (!a || composed.depthAlpha[pi] === 0)
2209 { continue; }
2210
2211 var depthM = near + (composed.depthGray[pi] / 65535) * (far - near);
2212 var pixelDist = dist + (depthM - camDist) * metersToWorld;
2213 if (pixelDist < 0.05)
2214 { pixelDist = 0.05; }
2215
2216 var zi = sy * w + sx;
2217 if (pixelDist >= zbuf[zi])
2218 { continue; }
2219 zbuf[zi] = pixelDist;
2220
2221 var o = zi * 4;
2222 var ar = composed.diffuse[pi * 4];
2223 var ag = composed.diffuse[pi * 4 + 1];
2224 var ab = composed.diffuse[pi * 4 + 2];
2225 var lights = World.level && World.level.lights;
2226 var ambient = World.level && World.level.ambient != null
2227 ? World.level.ambient : 0.38;
2228 // Pixel world: NPC feet + height from atlas v + depth along view cam.
2229 var heightFrac = 1 - (texY + 0.5) / composed.height;
2230 var pxZ = heightFrac * heightM * metersToWorld * 0.5;
2231 var depthOff = (depthM - camDist) * metersToWorld;
2232 var face = (npc.facingDeg || 0) * Math.PI / 180;
2233 var yawR = (yaw || 0) * Math.PI / 180;
2234 var camCX = Math.sin(yawR), camCZ = Math.cos(yawR);
2235 var frontX = Math.cos(face), frontY = Math.sin(face);
2236 var rightX = -Math.sin(face), rightY = Math.cos(face);
2237 var camX = rightX * camCX + frontX * camCZ;
2238 var camY = rightY * camCX + frontY * camCZ;
2239 var lat = (u - 0.5) * (heightM * metersToWorld * 0.35);
2240 var pxWorld = {
2241 x: npc.x + (-camY) * lat + camX * depthOff,
2242 y: npc.y + (camX) * lat + camY * depthOff,
2243 z: pxZ
2244 };
2245 var nr = composed.normal ? composed.normal[pi * 4] : 128;
2246 var ng = composed.normal ? composed.normal[pi * 4 + 1] : 128;
2247 var nb = composed.normal ? composed.normal[pi * 4 + 2] : 255;
2248 var shaded;
2249 if (typeof Lighting !== "undefined")
2250 {
2251 shaded = Lighting.shadePaperdollPixel(
2252 ar, ag, ab, nr, ng, nb, pxWorld,
2253 lights || [], ambient, yaw, npc.facingDeg || 0
2254 );
2255 }
2256 else
2257 {
2258 shaded = {
2259 r: Math.min(255, Math.round(composed.lit[pi * 4] * tint)),
2260 g: Math.min(255, Math.round(composed.lit[pi * 4 + 1] * tint)),
2261 b: Math.min(255, Math.round(composed.lit[pi * 4 + 2] * tint))
2262 };
2263 }
2264 data[o] = shaded.r;
2265 data[o + 1] = shaded.g;
2266 data[o + 2] = shaded.b;
2267 data[o + 3] = a;
2268 }
2269 }
2270 }
2271
2272 ctx.putImageData(img, 0, 0);
2273 var glc = scene.glContext;
2274 // Re-upload every frame (content changes).
2275 if (this._overlayTex)
2276 {
2277 var gl = glc.gl;
2278 gl.bindTexture(gl.TEXTURE_2D, this._overlayTex);
2279 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._overlay);
2280 }
2281 else
2282 {
2283 var prevMin = glc.textureMinFilter;
2284 var prevMag = glc.textureMagFilter;
2285 glc.setDefaultTextureFilter(glc.gl.NEAREST, glc.gl.NEAREST);
2286 this._overlayTex = glc.getTexture(this._overlay);
2287 glc.textureMinFilter = prevMin;
2288 glc.textureMagFilter = prevMag;
2289 }
2290
2291 glc.drawSprite({
2292 texture: this._overlayTex,
2293 x: w / 2,
2294 y: h / 2,
2295 w: w,
2296 h: h,
2297 rotationDeg: 0,
2298 alpha: 1,
2299 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
2300 });
2301 }
2302};
2303
2304/*
2305 * End File:
2306 * /workspace/raytracer-work/src/npc.js
2307 */
2308
2309/*
2310 * Start File:
2311 * /workspace/raytracer-work/src/raycastScene.js
2312 */
2313/**
2314 * Fullscreen WebGL raycast view on frameworkv3.
2315 * Wall strips: one source texel column per screen column, NEAREST, tinted for shading.
2316 */
2317class RaycastScene extends Scene
2318{
2319 constructor (width, height)
2320 {
2321 super(0, 0, width, height, Scene.DisplayModes.absolute);
2322 this.backgroundColor = { r: 0, g: 0, b: 0 };
2323 this.tintShader = null;
2324 this.solidTexture = null;
2325 this.gunImages = null;
2326 this._lookBound = false;
2327 this.floorTexMap = null;
2328 this._floorCanvas = null;
2329 this._floorCtx = null;
2330 this._floorTex = null;
2331 }
2332
2333 onLoad ()
2334 {
2335 const gl = this.glContext.gl;
2336 this.glContext.setDefaultTextureFilter(gl.NEAREST, gl.NEAREST);
2337
2338 this.tintShader = new Shader(Shader.DEFAULT_VERT, [
2339 "precision mediump float;",
2340 "uniform sampler2D u_texture;",
2341 "uniform float u_alpha;",
2342 "uniform vec3 u_tint;",
2343 "varying vec2 v_texCoord;",
2344 "void main() {",
2345 " vec4 color = texture2D(u_texture, v_texCoord);",
2346 " gl_FragColor = vec4(color.rgb * u_tint, color.a * u_alpha);",
2347 "}"
2348 ].join("\n"));
2349
2350 // 1x1 white for solid (untextured) walls.
2351 const c = document.createElement("canvas");
2352 c.width = 1;
2353 c.height = 1;
2354 const ctx = c.getContext("2d");
2355 ctx.fillStyle = "#ffffff";
2356 ctx.fillRect(0, 0, 1, 1);
2357 this.solidTexture = this.glContext.getTexture(c);
2358
2359 this.bindPointerLock();
2360 }
2361
2362 bindPointerLock ()
2363 {
2364 if (this._lookBound)
2365 { return; }
2366 this._lookBound = true;
2367 const canvas = this.cv_canvas;
2368 canvas.addEventListener("click", function ()
2369 {
2370 if (canvas.requestPointerLock)
2371 { canvas.requestPointerLock(); }
2372 });
2373 document.addEventListener("mousemove", function (e)
2374 {
2375 if (document.pointerLockElement === canvas)
2376 { Player.applyLookDelta(e.movementX || 0, e.movementY || 0); }
2377 });
2378 }
2379
2380 update (deltaTime)
2381 {
2382 super.update(deltaTime);
2383 Player.update(deltaTime);
2384 if (typeof NpcSystem !== "undefined")
2385 { NpcSystem.update(deltaTime); }
2386 if (Player.horizontalResolution > this.real_size.x)
2387 { Player.horizontalResolution = this.real_size.x; }
2388 }
2389
2390 draw ()
2391 {
2392 if (this.destroyed || !this.glContext)
2393 { return; }
2394
2395 this.g_fixSize();
2396 const glc = this.glContext;
2397 glc.endOffscreenPass();
2398 glc.clear(0, 0, 0, 1);
2399
2400 this.drawFloorCeiling();
2401 const wallDepth = this.drawColumns();
2402 if (typeof NpcSystem !== "undefined" && NpcSystem.ready)
2403 { NpcSystem.draw(this, Player, wallDepth); }
2404 this.drawGun();
2405 }
2406
2407
2408 setFloorTextures (texMap)
2409 {
2410 this.floorTexMap = texMap;
2411 }
2412
2413 drawFloorCeiling ()
2414 {
2415 if (!this.floorTexMap || !World.level || !World.level.floors)
2416 { return; }
2417 const w = Math.max(1, Math.round(this.real_size.x));
2418 const h = Math.max(1, Math.round(this.real_size.y));
2419 if (!this._floorCanvas || this._floorCanvas.width !== w || this._floorCanvas.height !== h)
2420 {
2421 this._floorCanvas = document.createElement("canvas");
2422 this._floorCanvas.width = w;
2423 this._floorCanvas.height = h;
2424 this._floorCtx = this._floorCanvas.getContext("2d");
2425 this._floorTex = null;
2426 }
2427 const img = this._floorCtx.createImageData(w, h);
2428 FloorCast.render(img, w, h, Player, World.level, this.floorTexMap, World.size);
2429 this._floorCtx.putImageData(img, 0, 0);
2430 const glc = this.glContext;
2431 const gl = glc.gl;
2432 if (this._floorTex)
2433 {
2434 gl.bindTexture(gl.TEXTURE_2D, this._floorTex);
2435 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._floorCanvas);
2436 }
2437 else
2438 {
2439 glc.setDefaultTextureFilter(gl.NEAREST, gl.NEAREST);
2440 this._floorTex = glc.getTexture(this._floorCanvas);
2441 }
2442 glc.drawSprite({
2443 texture: this._floorTex,
2444 x: w / 2,
2445 y: h / 2,
2446 w: w,
2447 h: h,
2448 rotationDeg: 0,
2449 alpha: 1,
2450 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
2451 });
2452 }
2453
2454 faceLight (dir)
2455 {
2456 switch (dir)
2457 {
2458 case "east": return 0.9;
2459 case "west": return 0.8;
2460 case "south": return 0.7;
2461 default: return 1.0;
2462 }
2463 }
2464
2465 drawColumns ()
2466 {
2467 const glc = this.glContext;
2468 const w = this.real_size.x;
2469 const h = this.real_size.y;
2470 const cols = Math.max(1, Math.floor(Player.horizontalResolution));
2471 const rad = Math.PI / (cols * 2);
2472 const widthLine = w / cols;
2473 const wallDepth = new Float32Array(Math.max(1, Math.round(w)));
2474 for (var zi = 0; zi < wallDepth.length; zi++)
2475 { wallDepth[zi] = 1e9; }
2476
2477 for (var i = 0; i < cols; i++)
2478 {
2479 var offsetP = -0.5 + (i / cols);
2480 var offset = offsetP * cols;
2481 var rotationalOffset = offset * rad;
2482 var rot = Player.rotation + rotationalOffset;
2483 if (rot < 0) { rot += Math.PI * 2; }
2484 if (rot > Math.PI * 2) { rot -= Math.PI * 2; }
2485
2486 var rayHit = World.rayCast(Player.x, Player.y, rot);
2487 if (!rayHit || !rayHit.tile)
2488 { continue; }
2489
2490 var deltaAngle = Player.rotation - rot;
2491 var dist = rayHit.distance * Math.cos(deltaAngle);
2492 if (dist < 0.0001)
2493 { dist = 0.0001; }
2494
2495 var xLine = i * widthLine;
2496 var wallH = (World.size * h) / dist;
2497 // Same horizon/pitch as FloorCast + NPC feet.
2498 var yCenter = (h / 2) + (-Player.pitch * h * 0.25);
2499
2500 var tint;
2501 var lights = World.level && World.level.lights;
2502 if (typeof Lighting !== "undefined" && lights && lights.length)
2503 {
2504 var nrm = Lighting.faceNormal(rayHit.dir);
2505 var hitPos = {
2506 x: rayHit.endX,
2507 y: rayHit.endY,
2508 z: World.size * 0.5
2509 };
2510 var ambient = World.level.ambient != null ? World.level.ambient : Lighting.DEFAULT_AMBIENT;
2511 var los = {
2512 tiles: World.level.tiles,
2513 width: World.level.width,
2514 height: World.level.height,
2515 cellSize: World.size
2516 };
2517 var lit = Lighting.shadeRgb(hitPos, nrm, lights, ambient, los);
2518 // Soften with legacy face shade so side walls stay readable.
2519 var face = this.faceLight(rayHit.dir);
2520 tint = [Math.min(1.8, lit.r * face), Math.min(1.8, lit.g * face), Math.min(1.8, lit.b * face)];
2521 }
2522 else
2523 {
2524 var light = this.faceLight(rayHit.dir);
2525 tint = [light, light, light];
2526 }
2527 var htmlImage = null;
2528 var texW = 1;
2529
2530 // Z-buffer for NPC occlusion (per screen pixel column).
2531 var x0 = Math.max(0, Math.floor(xLine));
2532 var x1 = Math.min(wallDepth.length, Math.ceil(xLine + widthLine));
2533 for (var xz = x0; xz < x1; xz++)
2534 {
2535 if (dist < wallDepth[xz])
2536 { wallDepth[xz] = dist; }
2537 }
2538
2539 if (rayHit.tile.Image && rayHit.tile.Image.g_image)
2540 {
2541 htmlImage = rayHit.tile.Image.g_image;
2542 texW = htmlImage.width || 1;
2543 var uv = textureColumnUv(rayHit.tileX, texW);
2544 glc.drawSprite({
2545 texture: glc.getTexture(htmlImage),
2546 x: xLine + widthLine / 2,
2547 y: yCenter,
2548 w: widthLine,
2549 h: wallH,
2550 rotationDeg: 0,
2551 alpha: 1,
2552 uvRect: { u0: uv.u0, v0: uv.v0, u1: uv.u1, v1: uv.v1 },
2553 shader: this.tintShader,
2554 uniforms: { u_tint: tint }
2555 });
2556 }
2557 else
2558 {
2559 var c = rayHit.tile.Color || { R: 255, G: 255, B: 255 };
2560 tint = [(c.R / 255) * light, (c.G / 255) * light, (c.B / 255) * light];
2561 glc.drawSprite({
2562 texture: this.solidTexture,
2563 x: xLine + widthLine / 2,
2564 y: yCenter,
2565 w: widthLine,
2566 h: wallH,
2567 rotationDeg: 0,
2568 alpha: 1,
2569 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 },
2570 shader: this.tintShader,
2571 uniforms: { u_tint: tint }
2572 });
2573 }
2574 }
2575 return wallDepth;
2576 }
2577
2578 drawGun ()
2579 {
2580 const images = this.game && this.game.images;
2581 if (!images)
2582 { return; }
2583 var gunImg = null;
2584 switch (Player.currentGun)
2585 {
2586 case 0: gunImg = images.shotgun; break;
2587 case 1: gunImg = images.machinegun; break;
2588 case 2: gunImg = images.pulserifle; break;
2589 }
2590 if (!gunImg || !gunImg.g_image)
2591 { return; }
2592
2593 var p = this.real_size.y / 1080;
2594 var gw = p * gunImg.g_image.width;
2595 var gh = p * gunImg.g_image.height;
2596 var gx = this.real_size.x * Player.gunX + gw / 2;
2597 var gy = this.real_size.y * Player.gunY + gh / 2;
2598
2599 gunImg.draw(
2600 this,
2601 gx,
2602 gy,
2603 gw,
2604 gh,
2605 0,
2606 false,
2607 false,
2608 1,
2609 0
2610 );
2611 }
2612}
2613
2614/*
2615 * End File:
2616 * /workspace/raytracer-work/src/raycastScene.js
2617 */
2618
2619/*
2620 * Start File:
2621 * /workspace/raytracer-work/src/main.js
2622 */
2623console.log("Raytracer starting");
2624var game = new Game();
2625var levelPack = null;
2626
2627function queryLevelParam ()
2628{
2629 try
2630 {
2631 var q = new URLSearchParams(window.location.search);
2632 return q.get("level");
2633 }
2634 catch (e)
2635 { return null; }
2636}
2637
2638function extractTexPixels (img)
2639{
2640 var c = document.createElement("canvas");
2641 c.width = img.width;
2642 c.height = img.height;
2643 var ctx = c.getContext("2d");
2644 ctx.drawImage(img, 0, 0);
2645 return { rgba: ctx.getImageData(0, 0, c.width, c.height).data, w: c.width, h: c.height };
2646}
2647
2648function applyLevel (pack, indexOrId, scene)
2649{
2650 World.loadPack(pack);
2651 World.loadLevel(indexOrId);
2652 Player.resetToSpawn();
2653 NpcSystem.initEmpty();
2654 var npcs = World.level.npcs || [];
2655 for (var i = 0; i < npcs.length; i++)
2656 { NpcSystem.addNpc(npcs[i]); }
2657
2658 var body = npcs[0] && npcs[0].body ? npcs[0].body : "paperdolls/male-body/";
2659 var bodyPpda = npcs[0] && npcs[0].bodyPpda ? npcs[0].bodyPpda : "male-body-atlas.ppda";
2660 var gear = npcs[0] && npcs[0].gear ? npcs[0].gear : "paperdolls/male-sword/";
2661 var gearPpda = npcs[0] && npcs[0].gearPpda ? npcs[0].gearPpda : "male-sword-atlas.ppda";
2662 if (npcs.length)
2663 {
2664 NpcSystem.load(body, bodyPpda, gear, gearPpda).catch(function (err)
2665 { console.error("Paperdoll load failed", err); });
2666 }
2667 var title = document.getElementById("level-label");
2668 if (title)
2669 { title.textContent = World.level.name + " (" + (World.levelIndex + 1) + "/" + pack.levels.length + ")"; }
2670}
2671
2672window.onload = function ()
2673{
2674 game.preloadImagesThenStart(
2675 [
2676 { name: "stone", url: "images/stone.png" },
2677 { name: "wood", url: "images/wood.png" },
2678 { name: "shotgun", url: "images/shotgun.png" },
2679 { name: "machinegun", url: "images/machinegun.png" },
2680 { name: "pulserifle", url: "images/pulserifle.png" }
2681 ],
2682 function ()
2683 {
2684 Tiles.bindImages(game.images);
2685
2686 var packPromise;
2687 var q = null;
2688 try { q = new URLSearchParams(window.location.search); } catch (e) {}
2689 if (q && q.get("playtest") === "1")
2690 {
2691 packPromise = Promise.resolve().then(function ()
2692 {
2693 var raw = localStorage.getItem("raytracer-levels-v1");
2694 if (!raw) throw new Error("Geen editor-playtest in localStorage");
2695 return raw;
2696 });
2697 }
2698 else
2699 {
2700 packPromise = fetch("levels.json").then(function (r)
2701 {
2702 if (!r.ok)
2703 { throw new Error("levels.json HTTP " + r.status); }
2704 return r.text();
2705 });
2706 }
2707 packPromise.then(function (text)
2708 {
2709 levelPack = LevelFormat.parse(text);
2710 var w = Math.max(320, window.innerWidth - 2);
2711 var h = Math.max(240, window.innerHeight - 2);
2712 var scene = new RaycastScene(w, h);
2713 scene.npcLight = 1;
2714 scene.setFloorTextures({
2715 stone: extractTexPixels(game.images.stone.g_image),
2716 wood: extractTexPixels(game.images.wood.g_image)
2717 });
2718 game.loadScene(scene);
2719
2720 var want = queryLevelParam();
2721 var idx = LevelFormat.findLevelIndex(levelPack, want);
2722 if (idx < 0)
2723 { idx = 0; }
2724 applyLevel(levelPack, idx, scene);
2725
2726 window.addEventListener("resize", function ()
2727 {
2728 scene.size.x = Math.max(320, window.innerWidth - 2);
2729 scene.size.y = Math.max(240, window.innerHeight - 2);
2730 });
2731
2732 var prev = document.getElementById("btn-prev-level");
2733 var next = document.getElementById("btn-next-level");
2734 if (prev)
2735 {
2736 prev.onclick = function ()
2737 {
2738 var i = (World.levelIndex - 1 + levelPack.levels.length) % levelPack.levels.length;
2739 applyLevel(levelPack, i, scene);
2740 };
2741 }
2742 if (next)
2743 {
2744 next.onclick = function ()
2745 {
2746 var i = (World.levelIndex + 1) % levelPack.levels.length;
2747 applyLevel(levelPack, i, scene);
2748 };
2749 }
2750 }).catch(function (err)
2751 {
2752 console.error(err);
2753 alert("Kon levels.json niet laden: " + err.message);
2754 });
2755 }
2756 );
2757};
2758
2759/*
2760 * End File:
2761 * /workspace/raytracer-work/src/main.js
2762 */