BlueGit

timfa raytracer

Files

raytracer / build / game.js

game.js

game.js 59.4 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 (schema v1) for raytracer + editor.
804 * walls: tile type ids; floors/ceilings: texture id string or null (black).
805 * lights: reserved list (not rendered yet).
806 */
807var LevelFormat =
808{
809 CURRENT_VERSION: 1,
810 MAX_SIZE: 128,
811 MAX_LEVELS: 64,
812 KNOWN_TEXTURES: ["stone", "wood"],
813
814 emptyLevel: function (name, width, height)
815 {
816 width = Math.max(3, Math.min(this.MAX_SIZE, width || 10));
817 height = Math.max(3, Math.min(this.MAX_SIZE, height || 10));
818 var n = width * height;
819 var walls = [];
820 var floors = [];
821 var ceilings = [];
822 for (var i = 0; i < n; i++)
823 {
824 var x = i % width;
825 var y = Math.floor(i / width);
826 var border = x === 0 || y === 0 || x === width - 1 || y === height - 1;
827 walls.push(border ? 1 : 0);
828 floors.push(border ? null : "stone");
829 ceilings.push(border ? null : "stone");
830 }
831 return {
832 id: "level-" + Date.now().toString(36),
833 name: name || "Nieuw level",
834 width: width,
835 height: height,
836 cellSize: 32,
837 spawn: { tileX: 1, tileY: 1, yawRad: 0 },
838 walls: walls,
839 floors: floors,
840 ceilings: ceilings,
841 npcs: [],
842 lights: []
843 };
844 },
845
846 defaultPack: function ()
847 {
848 return {
849 format_version: this.CURRENT_VERSION,
850 textures: [
851 { id: "stone", url: "images/stone.png" },
852 { id: "wood", url: "images/wood.png" }
853 ],
854 levels: []
855 };
856 },
857
858 /** Migrate legacy Levels[] (tiles only) into a pack. */
859 fromLegacyLevels: function (legacyArr, npcsByLevel)
860 {
861 var pack = this.defaultPack();
862 for (var i = 0; i < (legacyArr || []).length; i++)
863 {
864 var L = legacyArr[i];
865 var n = L.width * L.height;
866 var floors = [];
867 var ceilings = [];
868 for (var t = 0; t < n; t++)
869 {
870 var solid = L.tiles[t] === 1 || L.tiles[t] === 3;
871 floors.push(solid ? null : "stone");
872 ceilings.push(solid ? null : "stone");
873 }
874 pack.levels.push({
875 id: "level-" + (i + 1),
876 name: L.name || ("Level " + (i + 1)),
877 width: L.width,
878 height: L.height,
879 cellSize: 32,
880 spawn: {
881 tileX: L.spawnX,
882 tileY: L.spawnY,
883 yawRad: 0
884 },
885 walls: L.tiles.slice(),
886 floors: floors,
887 ceilings: ceilings,
888 npcs: (npcsByLevel && npcsByLevel[i]) || [],
889 lights: []
890 });
891 }
892 return pack;
893 },
894
895 validateTextureId: function (tex, allowNull)
896 {
897 if (tex == null || tex === "")
898 { return !!allowNull; }
899 return this.KNOWN_TEXTURES.indexOf(tex) >= 0;
900 },
901
902 validateLevel: function (level, index)
903 {
904 var prefix = "level[" + (index == null ? "?" : index) + "]";
905 if (!level || typeof level !== "object")
906 { throw new Error(prefix + ": moet een object zijn"); }
907 if (!level.id || typeof level.id !== "string")
908 { throw new Error(prefix + ": id verplicht"); }
909 if (!level.name || typeof level.name !== "string")
910 { throw new Error(prefix + ": name verplicht"); }
911 var w = level.width | 0;
912 var h = level.height | 0;
913 if (w < 3 || h < 3 || w > this.MAX_SIZE || h > this.MAX_SIZE)
914 { throw new Error(prefix + ": width/height 3.." + this.MAX_SIZE); }
915 var n = w * h;
916 if (!Array.isArray(level.walls) || level.walls.length !== n)
917 { throw new Error(prefix + ": walls lengte ≠ width*height"); }
918 if (!Array.isArray(level.floors) || level.floors.length !== n)
919 { throw new Error(prefix + ": floors lengte ≠ width*height"); }
920 if (!Array.isArray(level.ceilings) || level.ceilings.length !== n)
921 { throw new Error(prefix + ": ceilings lengte ≠ width*height"); }
922 for (var i = 0; i < n; i++)
923 {
924 var wall = level.walls[i];
925 if (typeof wall !== "number" || wall !== (wall | 0) || wall < 0 || wall > 3)
926 { throw new Error(prefix + ": walls[" + i + "] ongeldig"); }
927 if (!this.validateTextureId(level.floors[i], true))
928 { throw new Error(prefix + ": floors[" + i + "] onbekende textuur"); }
929 if (!this.validateTextureId(level.ceilings[i], true))
930 { throw new Error(prefix + ": ceilings[" + i + "] onbekende textuur"); }
931 }
932 if (!level.spawn || typeof level.spawn.tileX !== "number" || typeof level.spawn.tileY !== "number")
933 { throw new Error(prefix + ": spawn.tileX/tileY verplicht"); }
934 if (level.spawn.tileX < 0 || level.spawn.tileY < 0 || level.spawn.tileX >= w || level.spawn.tileY >= h)
935 { throw new Error(prefix + ": spawn buiten de map"); }
936 if (typeof level.spawn.yawRad !== "number")
937 { level.spawn.yawRad = 0; }
938 if (!Array.isArray(level.npcs))
939 { throw new Error(prefix + ": npcs moet een array zijn"); }
940 if (!Array.isArray(level.lights))
941 { level.lights = []; }
942 if (level.cellSize == null)
943 { level.cellSize = 32; }
944 return level;
945 },
946
947 validatePack: function (pack)
948 {
949 if (!pack || typeof pack !== "object")
950 { throw new Error("pack: root moet een object zijn"); }
951 var ver = pack.format_version;
952 if (ver !== 1)
953 { throw new Error("pack: format_version " + ver + " niet ondersteund (wel: 1)"); }
954 if (!Array.isArray(pack.levels))
955 { throw new Error("pack: levels moet een array zijn"); }
956 if (pack.levels.length > this.MAX_LEVELS)
957 { throw new Error("pack: te veel levels"); }
958 if (pack.levels.length < 1)
959 { throw new Error("pack: minstens één level"); }
960 var ids = {};
961 for (var i = 0; i < pack.levels.length; i++)
962 {
963 this.validateLevel(pack.levels[i], i);
964 if (ids[pack.levels[i].id])
965 { throw new Error("pack: dubbele level-id " + pack.levels[i].id); }
966 ids[pack.levels[i].id] = true;
967 }
968 if (!Array.isArray(pack.textures))
969 { pack.textures = this.defaultPack().textures; }
970 return pack;
971 },
972
973 parse: function (jsonText)
974 {
975 var doc;
976 try
977 { doc = typeof jsonText === "string" ? JSON.parse(jsonText) : jsonText; }
978 catch (e)
979 { throw new Error("levels.json: ongeldige JSON (" + e.message + ")"); }
980 return this.validatePack(doc);
981 },
982
983 /** Runtime view used by World (tiles = walls). */
984 toRuntimeLevel: function (level)
985 {
986 return {
987 id: level.id,
988 name: level.name,
989 width: level.width,
990 height: level.height,
991 cellSize: level.cellSize || 32,
992 spawnX: level.spawn.tileX,
993 spawnY: level.spawn.tileY,
994 spawnYaw: level.spawn.yawRad || 0,
995 tiles: level.walls,
996 floors: level.floors,
997 ceilings: level.ceilings,
998 npcs: level.npcs || [],
999 lights: level.lights || []
1000 };
1001 },
1002
1003 findLevelIndex: function (pack, query)
1004 {
1005 if (query == null || query === "")
1006 { return 0; }
1007 var asNum = Number(query);
1008 if (!isNaN(asNum) && asNum === (asNum | 0) && asNum >= 0 && asNum < pack.levels.length)
1009 { return asNum; }
1010 for (var i = 0; i < pack.levels.length; i++)
1011 {
1012 if (pack.levels[i].id === query || pack.levels[i].name === query)
1013 { return i; }
1014 }
1015 return -1;
1016 },
1017
1018 cloneLevel: function (level)
1019 {
1020 return JSON.parse(JSON.stringify(level));
1021 }
1022};
1023
1024if (typeof module !== "undefined" && module.exports)
1025{ module.exports = LevelFormat; }
1026
1027/*
1028 * End File:
1029 * /workspace/raytracer-work/src/levelFormat.js
1030 */
1031
1032/*
1033 * Start File:
1034 * /workspace/raytracer-work/src/floorCast.js
1035 */
1036/**
1037 * Classic floor/ceiling casting (Lode-style) — pure math + CPU NEAREST fill.
1038 * Chosen over a grid data-texture shader because frameworkv3 is WebGL1 sprites
1039 * without a shared depth buffer; one ImageData upload stays simple and keeps
1040 * wall/NPC draw order unchanged (floor under walls).
1041 *
1042 * posZ must match wall projection: wallH = (cellSize * screenH) / dist, so the
1043 * floor at distance d sits at p = (cellSize/2 * screenH) / d from the horizon.
1044 * Using posZ = screenH/2 made rowDist ≈ 1–2 across the whole floor (one flat
1045 * texel of a 400² texture).
1046 */
1047var FloorCast =
1048{
1049 /** Camera height in projection units: (cellSize/2) * screenH. */
1050 posZ: function (screenH, cellSize)
1051 {
1052 return (cellSize * 0.5) * screenH;
1053 },
1054
1055 /**
1056 * World-space floor hit for screen pixel (sx, sy).
1057 * @returns {{wx:number,wy:number,rowDist:number,isCeiling:boolean}|null}
1058 */
1059 floorHit: function (sx, sy, screenW, screenH, playerX, playerY, rot, pitch, posZ, cellSize)
1060 {
1061 cellSize = cellSize || 32;
1062 var mid = screenH / 2 + (-pitch * screenH * 0.25);
1063 var p = sy - mid;
1064 if (p === 0)
1065 { return null; }
1066 if (posZ == null)
1067 { posZ = this.posZ(screenH, cellSize); }
1068 var rowDist = posZ / Math.abs(p);
1069 var camX = (2 * sx / screenW) - 1;
1070 // Match wall FOV: rotationalOffset ≈ camX * (π/4) at screen edges.
1071 var rayAngle = rot + camX * (Math.PI / 4);
1072 var dirX = Math.cos(rayAngle);
1073 var dirY = Math.sin(rayAngle);
1074 return {
1075 wx: playerX + dirX * rowDist,
1076 wy: playerY + dirY * rowDist,
1077 rowDist: rowDist,
1078 isCeiling: p < 0
1079 };
1080 },
1081
1082 /**
1083 * Sample NEAREST from RGBA Uint8ClampedArray tex (tw×th).
1084 * u,v in [0,1) tile space (or any real; wraps).
1085 */
1086 sampleNearest: function (rgba, tw, th, u, v)
1087 {
1088 var tx = Math.floor(((u % 1) + 1) % 1 * tw);
1089 var ty = Math.floor(((v % 1) + 1) % 1 * th);
1090 if (tx < 0) tx = 0;
1091 if (ty < 0) ty = 0;
1092 if (tx >= tw) tx = tw - 1;
1093 if (ty >= th) ty = th - 1;
1094 var o = (ty * tw + tx) * 4;
1095 return [rgba[o], rgba[o + 1], rgba[o + 2], rgba[o + 3]];
1096 },
1097
1098 /**
1099 * Count unique RGB triples in ImageData (optionally only in a rect).
1100 * Useful for tests: textured floor must not collapse to 1–2 colours.
1101 */
1102 countUniqueRgb: function (imgData, screenW, screenH, x0, y0, x1, y1)
1103 {
1104 x0 = x0 == null ? 0 : x0;
1105 y0 = y0 == null ? 0 : y0;
1106 x1 = x1 == null ? screenW : x1;
1107 y1 = y1 == null ? screenH : y1;
1108 var data = imgData.data;
1109 var seen = Object.create(null);
1110 var n = 0;
1111 for (var y = y0; y < y1; y++)
1112 {
1113 for (var x = x0; x < x1; x++)
1114 {
1115 var o = (y * screenW + x) * 4;
1116 var key = data[o] + "," + data[o + 1] + "," + data[o + 2];
1117 if (!seen[key])
1118 {
1119 seen[key] = 1;
1120 n++;
1121 }
1122 }
1123 }
1124 return n;
1125 },
1126
1127 /**
1128 * Fill ImageData with floor (below horizon) and ceiling (above).
1129 * texMap: { stone: {rgba,w,h}, wood: {...} }
1130 * level: runtime level with floors[], ceilings[], width, height, cellSize
1131 */
1132 render: function (imgData, screenW, screenH, player, level, texMap, cellSize)
1133 {
1134 cellSize = cellSize || 32;
1135 var data = imgData.data;
1136 var mid = screenH / 2 + (-player.pitch * screenH * 0.25);
1137 var posZ = this.posZ(screenH, cellSize);
1138 var lw = level.width;
1139 var lh = level.height;
1140 var floors = level.floors;
1141 var ceilings = level.ceilings;
1142
1143 // Step 2×2: NEAREST block fill — ~4× sneller, nog steeds pixelig.
1144 var step = 2;
1145 for (var sy = 0; sy < screenH; sy += step)
1146 {
1147 var p = (sy + step * 0.5) - mid;
1148 if (Math.abs(p) < 0.5)
1149 { continue; }
1150 var isCeil = p < 0;
1151 var rowDist = posZ / Math.abs(p);
1152 // Mild distance shade; keep texel contrast readable.
1153 var shade = Math.max(0.45, Math.min(1, 1.05 - rowDist / (cellSize * 40)));
1154 for (var sx = 0; sx < screenW; sx += step)
1155 {
1156 var camX = (2 * (sx + step * 0.5) / screenW) - 1;
1157 var rayAngle = player.rotation + camX * (Math.PI / 4);
1158 var wx = player.x + Math.cos(rayAngle) * rowDist;
1159 var wy = player.y + Math.sin(rayAngle) * rowDist;
1160 var cx = Math.floor(wx / cellSize);
1161 var cy = Math.floor(wy / cellSize);
1162 var r = 0, g = 0, b = 0;
1163 if (cx >= 0 && cy >= 0 && cx < lw && cy < lh)
1164 {
1165 var idx = cx + cy * lw;
1166 var texId = isCeil ? ceilings[idx] : floors[idx];
1167 if (texId && texMap[texId])
1168 {
1169 var tex = texMap[texId];
1170 // World-space UV so texels shrink toward the horizon.
1171 var u = wx / cellSize;
1172 var vv = wy / cellSize;
1173 var c = this.sampleNearest(tex.rgba, tex.w, tex.h, u, vv);
1174 r = (c[0] * shade) | 0;
1175 g = (c[1] * shade) | 0;
1176 b = (c[2] * shade) | 0;
1177 }
1178 }
1179 for (var dy = 0; dy < step && sy + dy < screenH; dy++)
1180 {
1181 for (var dx = 0; dx < step && sx + dx < screenW; dx++)
1182 {
1183 var o = ((sy + dy) * screenW + (sx + dx)) * 4;
1184 data[o] = r;
1185 data[o + 1] = g;
1186 data[o + 2] = b;
1187 data[o + 3] = 255;
1188 }
1189 }
1190 }
1191 }
1192 return imgData;
1193 }
1194};
1195
1196if (typeof module !== "undefined" && module.exports)
1197{ module.exports = FloorCast; }
1198
1199/*
1200 * End File:
1201 * /workspace/raytracer-work/src/floorCast.js
1202 */
1203
1204/*
1205 * Start File:
1206 * /workspace/raytracer-work/src/levels.js
1207 */
1208var Levels =
1209[
1210 {
1211 name: "Level 1",
1212 width: 10,
1213 height: 10,
1214 spawnX: 1,
1215 spawnY: 1,
1216 tiles:
1217 [
1218 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1219 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1220 1, 0, 1, 1, 0, 0, 3, 3, 0, 1,
1221 1, 0, 0, 1, 0, 0, 0, 0, 0, 1,
1222 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1223 1, 0, 0, 0, 0, 1, 0, 1, 0, 1,
1224 1, 0, 0, 0, 0, 1, 2, 1, 0, 1,
1225 1, 0, 1, 0, 0, 1, 3, 1, 0, 1,
1226 1, 0, 0, 0, 0, 0, 0, 0, 0, 1,
1227 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
1228 ]
1229 }
1230];
1231
1232/*
1233 * End File:
1234 * /workspace/raytracer-work/src/levels.js
1235 */
1236
1237/*
1238 * Start File:
1239 * /workspace/raytracer-work/src/tiles.js
1240 */
1241/** Tile table; Image fields filled after preload. */
1242var Tiles =
1243{
1244 Nothing:
1245 {
1246 ID: 0,
1247 Color: { R: 255, G: 255, B: 255 },
1248 Solid: false,
1249 ImageName: null
1250 },
1251 Stone:
1252 {
1253 ID: 1,
1254 Color: { R: 155, G: 155, B: 155 },
1255 Solid: true,
1256 ImageName: "stone"
1257 },
1258 Finish:
1259 {
1260 ID: 2,
1261 Color: { R: 255, G: 255, B: 0 },
1262 Solid: false,
1263 ImageName: null
1264 },
1265 Wood:
1266 {
1267 ID: 3,
1268 Color: { R: 168, G: 102, B: 50 },
1269 Solid: true,
1270 ImageName: "wood"
1271 },
1272 findByID: function (id)
1273 {
1274 for (var key in Tiles)
1275 {
1276 if (!Object.prototype.hasOwnProperty.call(Tiles, key))
1277 { continue; }
1278 var value = Tiles[key];
1279 if (value && value.ID === id)
1280 { return value; }
1281 }
1282 return null;
1283 },
1284 bindImages: function (images)
1285 {
1286 for (var key in Tiles)
1287 {
1288 if (!Object.prototype.hasOwnProperty.call(Tiles, key))
1289 { continue; }
1290 var tile = Tiles[key];
1291 if (tile && tile.ImageName && images[tile.ImageName])
1292 { tile.Image = images[tile.ImageName]; }
1293 }
1294 }
1295};
1296
1297/*
1298 * End File:
1299 * /workspace/raytracer-work/src/tiles.js
1300 */
1301
1302/*
1303 * Start File:
1304 * /workspace/raytracer-work/src/world.js
1305 */
1306var World =
1307{
1308 size: 32,
1309 level: null,
1310 pack: null,
1311 levelIndex: 0,
1312
1313 loadPack: function (pack)
1314 {
1315 this.pack = pack;
1316 },
1317
1318 loadLevel: function (indexOrId)
1319 {
1320 if (!this.pack)
1321 { throw new Error("World: geen level-pack geladen"); }
1322 var idx = typeof indexOrId === "number"
1323 ? indexOrId
1324 : LevelFormat.findLevelIndex(this.pack, indexOrId);
1325 if (idx < 0 || idx >= this.pack.levels.length)
1326 { throw new Error("World: level niet gevonden: " + indexOrId); }
1327 this.levelIndex = idx;
1328 this.level = LevelFormat.toRuntimeLevel(this.pack.levels[idx]);
1329 this.size = this.level.cellSize || 32;
1330 },
1331
1332 spawnPoint: function ()
1333 {
1334 return {
1335 x: this.level.spawnX * this.size + this.size / 2,
1336 y: this.level.spawnY * this.size + this.size / 2,
1337 yaw: this.level.spawnYaw || 0
1338 };
1339 },
1340
1341 rayCast: function (x, y, radian)
1342 {
1343 var maxDist = this.level.width + this.level.height;
1344 var cell = this.size;
1345 var tileXpercentage = 0;
1346 var tileXp = 0;
1347 var tileYp = 0;
1348
1349 var hrayX, hrayY, hoffX, hoffY, distDone, hmapX, hmapY, htileHit;
1350 var hDir = "north";
1351 distDone = 0;
1352 var aTan = -1 / Math.tan(radian);
1353
1354 if (radian > Math.PI)
1355 {
1356 hrayY = Math.floor(y / cell) * cell - 0.01;
1357 hrayX = (y - hrayY) * aTan + x;
1358 hoffY = -cell;
1359 hoffX = -hoffY * aTan;
1360 }
1361 else if (radian < Math.PI)
1362 {
1363 hrayY = Math.floor(y / cell) * cell + cell;
1364 hrayX = (y - hrayY) * aTan + x;
1365 hoffY = cell;
1366 hoffX = -hoffY * aTan;
1367 hDir = "south";
1368 }
1369 else
1370 {
1371 hrayX = x;
1372 hrayY = y;
1373 distDone = maxDist;
1374 }
1375
1376 while (distDone < maxDist)
1377 {
1378 tileXp = ((hrayX % cell) + cell) % cell / cell;
1379 tileYp = ((hrayY % cell) + cell) % cell / cell;
1380 hmapX = Math.floor(hrayX / cell);
1381 hmapY = Math.floor(hrayY / cell);
1382 var htileHitId = this.level.tiles[hmapX + hmapY * this.level.width];
1383 htileHit = Tiles.findByID(htileHitId);
1384 if (htileHit && htileHit.Solid)
1385 { distDone = maxDist; }
1386 else
1387 {
1388 hrayX += hoffX;
1389 hrayY += hoffY;
1390 distDone += 1;
1391 }
1392 }
1393
1394 switch (hDir)
1395 {
1396 case "north": tileXpercentage = tileXp; break;
1397 case "south": tileXpercentage = 1 - tileXp; break;
1398 case "east": tileXpercentage = 1 - tileYp; break;
1399 case "west": tileXpercentage = tileYp; break;
1400 }
1401
1402 var hResult = {
1403 tile: htileHit,
1404 tileX: tileXpercentage,
1405 endX: hrayX,
1406 endY: hrayY,
1407 dir: hDir
1408 };
1409
1410 var rayX, rayY, offX, offY, mapX, mapY, tileHit;
1411 var vDir = "east";
1412 var nTan = -Math.tan(radian);
1413 distDone = 0;
1414
1415 if (radian > Math.PI / 2 && radian < Math.PI * 1.5)
1416 {
1417 rayX = Math.floor(x / cell) * cell - 0.01;
1418 rayY = (x - rayX) * nTan + y;
1419 offX = -cell;
1420 offY = -offX * nTan;
1421 }
1422 else if (radian < Math.PI / 2 || radian > Math.PI * 1.5)
1423 {
1424 rayX = Math.floor(x / cell) * cell + cell;
1425 rayY = (x - rayX) * nTan + y;
1426 offX = cell;
1427 offY = -offX * nTan;
1428 vDir = "west";
1429 }
1430 else
1431 {
1432 rayX = x;
1433 rayY = y;
1434 distDone = maxDist;
1435 }
1436
1437 while (distDone < maxDist)
1438 {
1439 tileXp = ((rayX % cell) + cell) % cell / cell;
1440 tileYp = ((rayY % cell) + cell) % cell / cell;
1441 mapX = Math.floor(rayX / cell);
1442 mapY = Math.floor(rayY / cell);
1443 var tileHitId = this.level.tiles[mapX + mapY * this.level.width];
1444 tileHit = Tiles.findByID(tileHitId);
1445 if (tileHit && tileHit.Solid)
1446 { distDone = maxDist; }
1447 else
1448 {
1449 rayX += offX;
1450 rayY += offY;
1451 distDone += 1;
1452 }
1453 }
1454
1455 switch (vDir)
1456 {
1457 case "north": tileXpercentage = tileXp; break;
1458 case "south": tileXpercentage = 1 - tileXp; break;
1459 case "east": tileXpercentage = 1 - tileYp; break;
1460 case "west": tileXpercentage = tileYp; break;
1461 }
1462
1463 var vResult = {
1464 tile: tileHit,
1465 tileX: tileXpercentage,
1466 endX: rayX,
1467 endY: rayY,
1468 dir: vDir
1469 };
1470
1471 var dxH = hResult.endX - x;
1472 var dyH = hResult.endY - y;
1473 var dxV = vResult.endX - x;
1474 var dyV = vResult.endY - y;
1475 hResult.distance = Math.sqrt(dxH * dxH + dyH * dyH);
1476 vResult.distance = Math.sqrt(dxV * dxV + dyV * dyV);
1477
1478 if (hResult.distance < vResult.distance)
1479 { return hResult; }
1480 return vResult;
1481 }
1482};
1483
1484if (typeof module !== "undefined" && module.exports)
1485{
1486 module.exports = { World: World };
1487}
1488
1489/*
1490 * End File:
1491 * /workspace/raytracer-work/src/world.js
1492 */
1493
1494/*
1495 * Start File:
1496 * /workspace/raytracer-work/src/player.js
1497 */
1498var Player =
1499{
1500 x: 0,
1501 y: 0,
1502 rotation: 0,
1503 pitch: 0,
1504 /** Screen columns per frame. 240 is sharp on ~1080p and cheap (~240 drawSprite calls). */
1505 horizontalResolution: 240,
1506 gunX: 0.6,
1507 gunY: 0.6,
1508 currentGun: 0,
1509 guns: 3,
1510
1511 resetToSpawn: function ()
1512 {
1513 var spawn = World.spawnPoint();
1514 this.x = spawn.x;
1515 this.y = spawn.y;
1516 this.rotation = spawn.yaw != null ? spawn.yaw : 0;
1517 this.pitch = 0;
1518 },
1519
1520 applyLookDelta: function (movementX, movementY)
1521 {
1522 this.pitch += movementY * 0.01;
1523 this.rotation += movementX * 0.001;
1524 if (this.pitch > Math.PI)
1525 { this.pitch = Math.PI; }
1526 if (this.pitch < -Math.PI)
1527 { this.pitch = -Math.PI; }
1528 if (this.rotation > Math.PI * 2)
1529 { this.rotation -= Math.PI * 2; }
1530 if (this.rotation < 0)
1531 { this.rotation += Math.PI * 2; }
1532 },
1533
1534 /** Legacy angles: 0 = +X (east), increases toward +Y. */
1535 forwardVector: function (radian)
1536 {
1537 return { x: Math.cos(radian), y: Math.sin(radian) };
1538 },
1539
1540 tryMove: function (rot, speed, deltaTime)
1541 {
1542 if (World.rayCast(this.x, this.y, rot).distance <= 5)
1543 { return; }
1544 var forward = this.forwardVector(rot);
1545 this.x += forward.x * deltaTime * speed;
1546 this.y += forward.y * deltaTime * speed;
1547 },
1548
1549 update: function (deltaTime)
1550 {
1551 if (GameInput.isHeld(37) || GameInput.isHeld(65))
1552 {
1553 var rotL = this.rotation - Math.PI / 2;
1554 if (rotL < 0) { rotL += Math.PI * 2; }
1555 this.tryMove(rotL, 60, deltaTime);
1556 }
1557 if (GameInput.isHeld(39) || GameInput.isHeld(68))
1558 {
1559 var rotR = this.rotation + Math.PI / 2;
1560 if (rotR > Math.PI * 2) { rotR -= Math.PI * 2; }
1561 this.tryMove(rotR, 60, deltaTime);
1562 }
1563 if (GameInput.isHeld(38) || GameInput.isHeld(87))
1564 { this.tryMove(this.rotation, 60, deltaTime); }
1565 if (GameInput.isHeld(40) || GameInput.isHeld(83))
1566 {
1567 var rotB = this.rotation + Math.PI;
1568 if (rotB > Math.PI * 2) { rotB -= Math.PI * 2; }
1569 if (World.rayCast(this.x, this.y, rotB).distance > 5)
1570 {
1571 var forward = this.forwardVector(this.rotation);
1572 this.x -= forward.x * deltaTime * 40;
1573 this.y -= forward.y * deltaTime * 40;
1574 }
1575 }
1576 if (GameInput.isHeld(188))
1577 {
1578 this.horizontalResolution -= this.horizontalResolution * 0.1 * deltaTime;
1579 if (this.horizontalResolution < 30)
1580 { this.horizontalResolution = 30; }
1581 }
1582 if (GameInput.isHeld(190))
1583 {
1584 this.horizontalResolution += this.horizontalResolution * 0.1 * deltaTime;
1585 }
1586 }
1587};
1588
1589/*
1590 * End File:
1591 * /workspace/raytracer-work/src/player.js
1592 */
1593
1594/*
1595 * Start File:
1596 * /workspace/raytracer-work/src/npc.js
1597 */
1598/**
1599 * Paperdoll NPC billboards.
1600 * Compose body+gear on CPU when view/frame changes (cell ~32×48).
1601 * Project with per-pixel depth into an offscreen RGBA buffer + z-buffer,
1602 * then one WebGL textured quad — avoids thousands of drawSprite calls.
1603 */
1604var NpcSystem =
1605{
1606 npcs: [],
1607 bodySet: null,
1608 gearSet: null,
1609 ready: false,
1610 cache: {},
1611 worldScale: 32,
1612 _overlay: null,
1613 _overlayCtx: null,
1614 _overlayImg: null,
1615 _zbuf: null,
1616 _zbufW: 0,
1617 _zbufH: 0,
1618
1619 initEmpty: function ()
1620 {
1621 this.npcs = [];
1622 this.cache = {};
1623 this.ready = false;
1624 },
1625
1626 addNpc: function (opts)
1627 {
1628 this.npcs.push({
1629 x: opts.x,
1630 y: opts.y,
1631 facingDeg: opts.facingDeg || 0,
1632 clip: opts.clip || "walk",
1633 animating: opts.animating !== false,
1634 time: opts.time || 0,
1635 label: opts.label || "npc"
1636 });
1637 },
1638
1639 load: function (bodyBase, bodyPpda, gearBase, gearPpda)
1640 {
1641 var self = this;
1642 return PpdaAtlasRuntime.loadSet(bodyBase, bodyPpda).then(function (body)
1643 {
1644 self.bodySet = body;
1645 if (!gearBase)
1646 {
1647 self.ready = true;
1648 return body;
1649 }
1650 return PpdaAtlasRuntime.loadSet(gearBase, gearPpda).then(function (gear)
1651 {
1652 PpdaLoader.assertCompatible(body.ppda, gear.ppda);
1653 self.gearSet = gear;
1654 self.ready = true;
1655 return body;
1656 });
1657 });
1658 },
1659
1660 update: function (dt)
1661 {
1662 for (var i = 0; i < this.npcs.length; i++)
1663 {
1664 if (this.npcs[i].animating)
1665 { this.npcs[i].time += dt; }
1666 }
1667 },
1668
1669 composedFor: function (npc, pitch, yaw)
1670 {
1671 if (!this.bodySet)
1672 { return null; }
1673 var clip = PpdaViewFrame.findClip(this.bodySet.ppda, npc.clip);
1674 var frameCount = clip ? clip.frame_count : 1;
1675 var frame = PpdaViewFrame.frameIndex(npc.time, this.bodySet.ppda.fps, frameCount);
1676 var key = npc.clip + "|" + frame + "|" + pitch + "|" + yaw;
1677 if (this.cache[key])
1678 { return this.cache[key]; }
1679 var composed = PpdaAtlasRuntime.composeView(
1680 this.bodySet,
1681 this.gearSet,
1682 npc.clip,
1683 frame,
1684 pitch,
1685 yaw
1686 );
1687 this.cache[key] = composed;
1688 var keys = Object.keys(this.cache);
1689 if (keys.length > 96)
1690 { delete this.cache[keys[0]]; }
1691 return composed;
1692 },
1693
1694 _ensureOverlay: function (w, h)
1695 {
1696 if (!this._overlay || this._overlay.width !== w || this._overlay.height !== h)
1697 {
1698 this._overlay = document.createElement("canvas");
1699 this._overlay.width = w;
1700 this._overlay.height = h;
1701 this._overlayCtx = this._overlay.getContext("2d");
1702 this._overlayImg = null;
1703 this._overlayTex = null;
1704 this._zbuf = new Float32Array(w * h);
1705 this._zbufW = w;
1706 this._zbufH = h;
1707 }
1708 },
1709
1710 /**
1711 * @param {Float32Array} wallDepthPerCol length = screen width
1712 */
1713 draw: function (scene, player, wallDepthPerCol)
1714 {
1715 if (!this.ready || !this.bodySet)
1716 { return; }
1717
1718 var w = Math.round(scene.real_size.x);
1719 var h = Math.round(scene.real_size.y);
1720 this._ensureOverlay(w, h);
1721 var ctx = this._overlayCtx;
1722 ctx.clearRect(0, 0, w, h);
1723 var img = ctx.createImageData(w, h);
1724 var data = img.data;
1725 var zbuf = this._zbuf;
1726 var i;
1727 for (i = 0; i < w * h; i++)
1728 {
1729 var col = i % w;
1730 zbuf[i] = wallDepthPerCol[col];
1731 }
1732
1733 var ppda = this.bodySet.ppda;
1734 var heightM = (ppda.height_milli || 2600) / 1000;
1735 var camDist = ppda.camera_distance || 10;
1736 var near = ppda.depth_near;
1737 var far = ppda.depth_far;
1738 var metersToWorld = this.worldScale;
1739 var tint = scene.npcLight != null ? scene.npcLight : 1;
1740
1741 var list = this.npcs.slice().sort(function (a, b)
1742 {
1743 var da = (a.x - player.x) * (a.x - player.x) + (a.y - player.y) * (a.y - player.y);
1744 var db = (b.x - player.x) * (b.x - player.x) + (b.y - player.y) * (b.y - player.y);
1745 return db - da;
1746 });
1747
1748 for (var ni = 0; ni < list.length; ni++)
1749 {
1750 var npc = list[ni];
1751 var dx = npc.x - player.x;
1752 var dy = npc.y - player.y;
1753 var dist = Math.sqrt(dx * dx + dy * dy);
1754 if (dist < 0.5 || dist > 800)
1755 { continue; }
1756
1757 var angleTo = Math.atan2(dy, dx);
1758 var delta = angleTo - player.rotation;
1759 while (delta > Math.PI) { delta -= Math.PI * 2; }
1760 while (delta < -Math.PI) { delta += Math.PI * 2; }
1761 if (Math.abs(delta) > Math.PI * 0.55)
1762 { continue; }
1763
1764 var relYaw = PpdaViewFrame.relativeYawDeg(player.x, player.y, npc.x, npc.y, npc.facingDeg);
1765 var yaw = PpdaViewFrame.pickYaw(relYaw, ppda.yaws);
1766 var pitch = Math.abs(player.pitch) < 0.25
1767 ? PpdaViewFrame.nearestInList(0, ppda.pitches)
1768 : PpdaViewFrame.pickPitch(player.pitch, ppda.pitches);
1769
1770 var clipInfo = PpdaViewFrame.findClip(ppda, npc.clip);
1771 var frame = PpdaViewFrame.frameIndex(
1772 npc.time, ppda.fps, clipInfo ? clipInfo.frame_count : 1
1773 );
1774 var composed = this.composedFor(npc, pitch, yaw);
1775 if (!composed)
1776 { continue; }
1777
1778 var spriteH = (World.size * heightM) * (h / dist) * 0.5;
1779 var aspect = composed.width / Math.max(1, composed.height);
1780 var spriteW = spriteH * aspect;
1781 var screenX = (w / 2) + (delta / (Math.PI / 3)) * (w / 2);
1782 // Horizon + pitch (same mid as FloorCast). Visual feet (= last opaque
1783 // atlas row) sit on the floor plane at this distance.
1784 var mid = h / 2 + (-player.pitch * h * 0.25);
1785 var floorY = mid + (World.size * 0.5 * h) / dist;
1786 var left = screenX - spriteW / 2;
1787 // Feet from BODY atlas only (gear can hang below and would lift the sprite).
1788 var feetRow = composed.height - 1;
1789 var feetH = composed.height;
1790 var feetW = composed.width;
1791 var feetAlpha = composed.lit;
1792 try
1793 {
1794 var bodyLayer = PpdaAtlasRuntime.layerFromSet(
1795 this.bodySet, npc.clip, frame, pitch, yaw
1796 );
1797 feetAlpha = bodyLayer.diffuse;
1798 feetW = bodyLayer.width;
1799 feetH = bodyLayer.height;
1800 feetRow = feetH - 1;
1801 }
1802 catch (e) { /* fallback: composed */ }
1803 for (var fy = feetH - 1; fy >= 0; fy--)
1804 {
1805 var rowHit = false;
1806 for (var fx = 0; fx < feetW; fx++)
1807 {
1808 if (feetAlpha[(fy * feetW + fx) * 4 + 3] > 10)
1809 { rowHit = true; break; }
1810 }
1811 if (rowHit)
1812 { feetRow = fy; break; }
1813 }
1814 var top = floorY - ((feetRow + 0.5) / feetH) * spriteH;
1815 var cols = Math.max(1, Math.ceil(spriteW));
1816
1817 for (var c = 0; c < cols; c++)
1818 {
1819 var sx = Math.floor(left + c);
1820 if (sx < 0 || sx >= w)
1821 { continue; }
1822 var u = (c + 0.5) / cols;
1823 var texX = Math.min(composed.width - 1, Math.max(0, Math.floor(u * composed.width)));
1824 var y0 = Math.floor(top);
1825 var y1 = Math.ceil(top + spriteH);
1826
1827 for (var sy = y0; sy < y1; sy++)
1828 {
1829 if (sy < 0 || sy >= h)
1830 { continue; }
1831 var v = (sy - top + 0.5) / spriteH;
1832 if (v < 0 || v >= 1)
1833 { continue; }
1834 var texY = Math.min(composed.height - 1, Math.max(0, Math.floor(v * composed.height)));
1835 var pi = texY * composed.width + texX;
1836 var a = composed.lit[pi * 4 + 3];
1837 if (!a || composed.depthAlpha[pi] === 0)
1838 { continue; }
1839
1840 var depthM = near + (composed.depthGray[pi] / 65535) * (far - near);
1841 var pixelDist = dist + (depthM - camDist) * metersToWorld;
1842 if (pixelDist < 0.05)
1843 { pixelDist = 0.05; }
1844
1845 var zi = sy * w + sx;
1846 if (pixelDist >= zbuf[zi])
1847 { continue; }
1848 zbuf[zi] = pixelDist;
1849
1850 var o = zi * 4;
1851 data[o] = Math.min(255, Math.round(composed.lit[pi * 4] * tint));
1852 data[o + 1] = Math.min(255, Math.round(composed.lit[pi * 4 + 1] * tint));
1853 data[o + 2] = Math.min(255, Math.round(composed.lit[pi * 4 + 2] * tint));
1854 data[o + 3] = a;
1855 }
1856 }
1857 }
1858
1859 ctx.putImageData(img, 0, 0);
1860 var glc = scene.glContext;
1861 // Re-upload every frame (content changes).
1862 if (this._overlayTex)
1863 {
1864 var gl = glc.gl;
1865 gl.bindTexture(gl.TEXTURE_2D, this._overlayTex);
1866 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._overlay);
1867 }
1868 else
1869 {
1870 var prevMin = glc.textureMinFilter;
1871 var prevMag = glc.textureMagFilter;
1872 glc.setDefaultTextureFilter(glc.gl.NEAREST, glc.gl.NEAREST);
1873 this._overlayTex = glc.getTexture(this._overlay);
1874 glc.textureMinFilter = prevMin;
1875 glc.textureMagFilter = prevMag;
1876 }
1877
1878 glc.drawSprite({
1879 texture: this._overlayTex,
1880 x: w / 2,
1881 y: h / 2,
1882 w: w,
1883 h: h,
1884 rotationDeg: 0,
1885 alpha: 1,
1886 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
1887 });
1888 }
1889};
1890
1891/*
1892 * End File:
1893 * /workspace/raytracer-work/src/npc.js
1894 */
1895
1896/*
1897 * Start File:
1898 * /workspace/raytracer-work/src/raycastScene.js
1899 */
1900/**
1901 * Fullscreen WebGL raycast view on frameworkv3.
1902 * Wall strips: one source texel column per screen column, NEAREST, tinted for shading.
1903 */
1904class RaycastScene extends Scene
1905{
1906 constructor (width, height)
1907 {
1908 super(0, 0, width, height, Scene.DisplayModes.absolute);
1909 this.backgroundColor = { r: 0, g: 0, b: 0 };
1910 this.tintShader = null;
1911 this.solidTexture = null;
1912 this.gunImages = null;
1913 this._lookBound = false;
1914 this.floorTexMap = null;
1915 this._floorCanvas = null;
1916 this._floorCtx = null;
1917 this._floorTex = null;
1918 }
1919
1920 onLoad ()
1921 {
1922 const gl = this.glContext.gl;
1923 this.glContext.setDefaultTextureFilter(gl.NEAREST, gl.NEAREST);
1924
1925 this.tintShader = new Shader(Shader.DEFAULT_VERT, [
1926 "precision mediump float;",
1927 "uniform sampler2D u_texture;",
1928 "uniform float u_alpha;",
1929 "uniform vec3 u_tint;",
1930 "varying vec2 v_texCoord;",
1931 "void main() {",
1932 " vec4 color = texture2D(u_texture, v_texCoord);",
1933 " gl_FragColor = vec4(color.rgb * u_tint, color.a * u_alpha);",
1934 "}"
1935 ].join("\n"));
1936
1937 // 1x1 white for solid (untextured) walls.
1938 const c = document.createElement("canvas");
1939 c.width = 1;
1940 c.height = 1;
1941 const ctx = c.getContext("2d");
1942 ctx.fillStyle = "#ffffff";
1943 ctx.fillRect(0, 0, 1, 1);
1944 this.solidTexture = this.glContext.getTexture(c);
1945
1946 this.bindPointerLock();
1947 }
1948
1949 bindPointerLock ()
1950 {
1951 if (this._lookBound)
1952 { return; }
1953 this._lookBound = true;
1954 const canvas = this.cv_canvas;
1955 canvas.addEventListener("click", function ()
1956 {
1957 if (canvas.requestPointerLock)
1958 { canvas.requestPointerLock(); }
1959 });
1960 document.addEventListener("mousemove", function (e)
1961 {
1962 if (document.pointerLockElement === canvas)
1963 { Player.applyLookDelta(e.movementX || 0, e.movementY || 0); }
1964 });
1965 }
1966
1967 update (deltaTime)
1968 {
1969 super.update(deltaTime);
1970 Player.update(deltaTime);
1971 if (typeof NpcSystem !== "undefined")
1972 { NpcSystem.update(deltaTime); }
1973 if (Player.horizontalResolution > this.real_size.x)
1974 { Player.horizontalResolution = this.real_size.x; }
1975 }
1976
1977 draw ()
1978 {
1979 if (this.destroyed || !this.glContext)
1980 { return; }
1981
1982 this.g_fixSize();
1983 const glc = this.glContext;
1984 glc.endOffscreenPass();
1985 glc.clear(0, 0, 0, 1);
1986
1987 this.drawFloorCeiling();
1988 const wallDepth = this.drawColumns();
1989 if (typeof NpcSystem !== "undefined" && NpcSystem.ready)
1990 { NpcSystem.draw(this, Player, wallDepth); }
1991 this.drawGun();
1992 }
1993
1994
1995 setFloorTextures (texMap)
1996 {
1997 this.floorTexMap = texMap;
1998 }
1999
2000 drawFloorCeiling ()
2001 {
2002 if (!this.floorTexMap || !World.level || !World.level.floors)
2003 { return; }
2004 const w = Math.max(1, Math.round(this.real_size.x));
2005 const h = Math.max(1, Math.round(this.real_size.y));
2006 if (!this._floorCanvas || this._floorCanvas.width !== w || this._floorCanvas.height !== h)
2007 {
2008 this._floorCanvas = document.createElement("canvas");
2009 this._floorCanvas.width = w;
2010 this._floorCanvas.height = h;
2011 this._floorCtx = this._floorCanvas.getContext("2d");
2012 this._floorTex = null;
2013 }
2014 const img = this._floorCtx.createImageData(w, h);
2015 FloorCast.render(img, w, h, Player, World.level, this.floorTexMap, World.size);
2016 this._floorCtx.putImageData(img, 0, 0);
2017 const glc = this.glContext;
2018 const gl = glc.gl;
2019 if (this._floorTex)
2020 {
2021 gl.bindTexture(gl.TEXTURE_2D, this._floorTex);
2022 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._floorCanvas);
2023 }
2024 else
2025 {
2026 glc.setDefaultTextureFilter(gl.NEAREST, gl.NEAREST);
2027 this._floorTex = glc.getTexture(this._floorCanvas);
2028 }
2029 glc.drawSprite({
2030 texture: this._floorTex,
2031 x: w / 2,
2032 y: h / 2,
2033 w: w,
2034 h: h,
2035 rotationDeg: 0,
2036 alpha: 1,
2037 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
2038 });
2039 }
2040
2041 faceLight (dir)
2042 {
2043 switch (dir)
2044 {
2045 case "east": return 0.9;
2046 case "west": return 0.8;
2047 case "south": return 0.7;
2048 default: return 1.0;
2049 }
2050 }
2051
2052 drawColumns ()
2053 {
2054 const glc = this.glContext;
2055 const w = this.real_size.x;
2056 const h = this.real_size.y;
2057 const cols = Math.max(1, Math.floor(Player.horizontalResolution));
2058 const rad = Math.PI / (cols * 2);
2059 const widthLine = w / cols;
2060 const wallDepth = new Float32Array(Math.max(1, Math.round(w)));
2061 for (var zi = 0; zi < wallDepth.length; zi++)
2062 { wallDepth[zi] = 1e9; }
2063
2064 for (var i = 0; i < cols; i++)
2065 {
2066 var offsetP = -0.5 + (i / cols);
2067 var offset = offsetP * cols;
2068 var rotationalOffset = offset * rad;
2069 var rot = Player.rotation + rotationalOffset;
2070 if (rot < 0) { rot += Math.PI * 2; }
2071 if (rot > Math.PI * 2) { rot -= Math.PI * 2; }
2072
2073 var rayHit = World.rayCast(Player.x, Player.y, rot);
2074 if (!rayHit || !rayHit.tile)
2075 { continue; }
2076
2077 var light = this.faceLight(rayHit.dir);
2078 var deltaAngle = Player.rotation - rot;
2079 var dist = rayHit.distance * Math.cos(deltaAngle);
2080 if (dist < 0.0001)
2081 { dist = 0.0001; }
2082
2083 var xLine = i * widthLine;
2084 var wallH = (World.size * h) / dist;
2085 // Same horizon/pitch as FloorCast + NPC feet.
2086 var yCenter = (h / 2) + (-Player.pitch * h * 0.25);
2087
2088 var tint = [light, light, light];
2089 var htmlImage = null;
2090 var texW = 1;
2091
2092 // Z-buffer for NPC occlusion (per screen pixel column).
2093 var x0 = Math.max(0, Math.floor(xLine));
2094 var x1 = Math.min(wallDepth.length, Math.ceil(xLine + widthLine));
2095 for (var xz = x0; xz < x1; xz++)
2096 {
2097 if (dist < wallDepth[xz])
2098 { wallDepth[xz] = dist; }
2099 }
2100
2101 if (rayHit.tile.Image && rayHit.tile.Image.g_image)
2102 {
2103 htmlImage = rayHit.tile.Image.g_image;
2104 texW = htmlImage.width || 1;
2105 var uv = textureColumnUv(rayHit.tileX, texW);
2106 glc.drawSprite({
2107 texture: glc.getTexture(htmlImage),
2108 x: xLine + widthLine / 2,
2109 y: yCenter,
2110 w: widthLine,
2111 h: wallH,
2112 rotationDeg: 0,
2113 alpha: 1,
2114 uvRect: { u0: uv.u0, v0: uv.v0, u1: uv.u1, v1: uv.v1 },
2115 shader: this.tintShader,
2116 uniforms: { u_tint: tint }
2117 });
2118 }
2119 else
2120 {
2121 var c = rayHit.tile.Color || { R: 255, G: 255, B: 255 };
2122 tint = [(c.R / 255) * light, (c.G / 255) * light, (c.B / 255) * light];
2123 glc.drawSprite({
2124 texture: this.solidTexture,
2125 x: xLine + widthLine / 2,
2126 y: yCenter,
2127 w: widthLine,
2128 h: wallH,
2129 rotationDeg: 0,
2130 alpha: 1,
2131 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 },
2132 shader: this.tintShader,
2133 uniforms: { u_tint: tint }
2134 });
2135 }
2136 }
2137 return wallDepth;
2138 }
2139
2140 drawGun ()
2141 {
2142 const images = this.game && this.game.images;
2143 if (!images)
2144 { return; }
2145 var gunImg = null;
2146 switch (Player.currentGun)
2147 {
2148 case 0: gunImg = images.shotgun; break;
2149 case 1: gunImg = images.machinegun; break;
2150 case 2: gunImg = images.pulserifle; break;
2151 }
2152 if (!gunImg || !gunImg.g_image)
2153 { return; }
2154
2155 var p = this.real_size.y / 1080;
2156 var gw = p * gunImg.g_image.width;
2157 var gh = p * gunImg.g_image.height;
2158 var gx = this.real_size.x * Player.gunX + gw / 2;
2159 var gy = this.real_size.y * Player.gunY + gh / 2;
2160
2161 gunImg.draw(
2162 this,
2163 gx,
2164 gy,
2165 gw,
2166 gh,
2167 0,
2168 false,
2169 false,
2170 1,
2171 0
2172 );
2173 }
2174}
2175
2176/*
2177 * End File:
2178 * /workspace/raytracer-work/src/raycastScene.js
2179 */
2180
2181/*
2182 * Start File:
2183 * /workspace/raytracer-work/src/main.js
2184 */
2185console.log("Raytracer starting");
2186var game = new Game();
2187var levelPack = null;
2188
2189function queryLevelParam ()
2190{
2191 try
2192 {
2193 var q = new URLSearchParams(window.location.search);
2194 return q.get("level");
2195 }
2196 catch (e)
2197 { return null; }
2198}
2199
2200function extractTexPixels (img)
2201{
2202 var c = document.createElement("canvas");
2203 c.width = img.width;
2204 c.height = img.height;
2205 var ctx = c.getContext("2d");
2206 ctx.drawImage(img, 0, 0);
2207 return { rgba: ctx.getImageData(0, 0, c.width, c.height).data, w: c.width, h: c.height };
2208}
2209
2210function applyLevel (pack, indexOrId, scene)
2211{
2212 World.loadPack(pack);
2213 World.loadLevel(indexOrId);
2214 Player.resetToSpawn();
2215 NpcSystem.initEmpty();
2216 var npcs = World.level.npcs || [];
2217 for (var i = 0; i < npcs.length; i++)
2218 { NpcSystem.addNpc(npcs[i]); }
2219
2220 var body = npcs[0] && npcs[0].body ? npcs[0].body : "paperdolls/male-body/";
2221 var bodyPpda = npcs[0] && npcs[0].bodyPpda ? npcs[0].bodyPpda : "male-body-atlas.ppda";
2222 var gear = npcs[0] && npcs[0].gear ? npcs[0].gear : "paperdolls/male-sword/";
2223 var gearPpda = npcs[0] && npcs[0].gearPpda ? npcs[0].gearPpda : "male-sword-atlas.ppda";
2224 if (npcs.length)
2225 {
2226 NpcSystem.load(body, bodyPpda, gear, gearPpda).catch(function (err)
2227 { console.error("Paperdoll load failed", err); });
2228 }
2229 var title = document.getElementById("level-label");
2230 if (title)
2231 { title.textContent = World.level.name + " (" + (World.levelIndex + 1) + "/" + pack.levels.length + ")"; }
2232}
2233
2234window.onload = function ()
2235{
2236 game.preloadImagesThenStart(
2237 [
2238 { name: "stone", url: "images/stone.png" },
2239 { name: "wood", url: "images/wood.png" },
2240 { name: "shotgun", url: "images/shotgun.png" },
2241 { name: "machinegun", url: "images/machinegun.png" },
2242 { name: "pulserifle", url: "images/pulserifle.png" }
2243 ],
2244 function ()
2245 {
2246 Tiles.bindImages(game.images);
2247
2248 var packPromise;
2249 var q = null;
2250 try { q = new URLSearchParams(window.location.search); } catch (e) {}
2251 if (q && q.get("playtest") === "1")
2252 {
2253 packPromise = Promise.resolve().then(function ()
2254 {
2255 var raw = localStorage.getItem("raytracer-levels-v1");
2256 if (!raw) throw new Error("Geen editor-playtest in localStorage");
2257 return raw;
2258 });
2259 }
2260 else
2261 {
2262 packPromise = fetch("levels.json").then(function (r)
2263 {
2264 if (!r.ok)
2265 { throw new Error("levels.json HTTP " + r.status); }
2266 return r.text();
2267 });
2268 }
2269 packPromise.then(function (text)
2270 {
2271 levelPack = LevelFormat.parse(text);
2272 var w = Math.max(320, window.innerWidth - 2);
2273 var h = Math.max(240, window.innerHeight - 2);
2274 var scene = new RaycastScene(w, h);
2275 scene.npcLight = 1;
2276 scene.setFloorTextures({
2277 stone: extractTexPixels(game.images.stone.g_image),
2278 wood: extractTexPixels(game.images.wood.g_image)
2279 });
2280 game.loadScene(scene);
2281
2282 var want = queryLevelParam();
2283 var idx = LevelFormat.findLevelIndex(levelPack, want);
2284 if (idx < 0)
2285 { idx = 0; }
2286 applyLevel(levelPack, idx, scene);
2287
2288 window.addEventListener("resize", function ()
2289 {
2290 scene.size.x = Math.max(320, window.innerWidth - 2);
2291 scene.size.y = Math.max(240, window.innerHeight - 2);
2292 });
2293
2294 var prev = document.getElementById("btn-prev-level");
2295 var next = document.getElementById("btn-next-level");
2296 if (prev)
2297 {
2298 prev.onclick = function ()
2299 {
2300 var i = (World.levelIndex - 1 + levelPack.levels.length) % levelPack.levels.length;
2301 applyLevel(levelPack, i, scene);
2302 };
2303 }
2304 if (next)
2305 {
2306 next.onclick = function ()
2307 {
2308 var i = (World.levelIndex + 1) % levelPack.levels.length;
2309 applyLevel(levelPack, i, scene);
2310 };
2311 }
2312 }).catch(function (err)
2313 {
2314 console.error(err);
2315 alert("Kon levels.json niet laden: " + err.message);
2316 });
2317 }
2318 );
2319};
2320
2321/*
2322 * End File:
2323 * /workspace/raytracer-work/src/main.js
2324 */