BlueGit

timfa raytracer

Files

raytracer / src / npc.js

npc.js

npc.js 6.8 KiB Download Raw
1/**
2 * Paperdoll NPC billboards.
3 * Compose body+gear on CPU when view/frame changes (cell ~32×48).
4 * Project with per-pixel depth into an offscreen RGBA buffer + z-buffer,
5 * then one WebGL textured quad — avoids thousands of drawSprite calls.
6 */
7var NpcSystem =
8{
9 npcs: [],
10 bodySet: null,
11 gearSet: null,
12 ready: false,
13 cache: {},
14 worldScale: 32,
15 _overlay: null,
16 _overlayCtx: null,
17 _overlayImg: null,
18 _zbuf: null,
19 _zbufW: 0,
20 _zbufH: 0,
21
22 initEmpty: function ()
23 {
24 this.npcs = [];
25 this.cache = {};
26 this.ready = false;
27 },
28
29 addNpc: function (opts)
30 {
31 this.npcs.push({
32 x: opts.x,
33 y: opts.y,
34 facingDeg: opts.facingDeg || 0,
35 clip: opts.clip || "walk",
36 animating: opts.animating !== false,
37 time: opts.time || 0,
38 label: opts.label || "npc"
39 });
40 },
41
42 load: function (bodyBase, bodyPpda, gearBase, gearPpda)
43 {
44 var self = this;
45 return PpdaAtlasRuntime.loadSet(bodyBase, bodyPpda).then(function (body)
46 {
47 self.bodySet = body;
48 if (!gearBase)
49 {
50 self.ready = true;
51 return body;
52 }
53 return PpdaAtlasRuntime.loadSet(gearBase, gearPpda).then(function (gear)
54 {
55 PpdaLoader.assertCompatible(body.ppda, gear.ppda);
56 self.gearSet = gear;
57 self.ready = true;
58 return body;
59 });
60 });
61 },
62
63 update: function (dt)
64 {
65 for (var i = 0; i < this.npcs.length; i++)
66 {
67 if (this.npcs[i].animating)
68 { this.npcs[i].time += dt; }
69 }
70 },
71
72 composedFor: function (npc, pitch, yaw)
73 {
74 if (!this.bodySet)
75 { return null; }
76 var clip = PpdaViewFrame.findClip(this.bodySet.ppda, npc.clip);
77 var frameCount = clip ? clip.frame_count : 1;
78 var frame = PpdaViewFrame.frameIndex(npc.time, this.bodySet.ppda.fps, frameCount);
79 var key = npc.clip + "|" + frame + "|" + pitch + "|" + yaw;
80 if (this.cache[key])
81 { return this.cache[key]; }
82 var composed = PpdaAtlasRuntime.composeView(
83 this.bodySet,
84 this.gearSet,
85 npc.clip,
86 frame,
87 pitch,
88 yaw
89 );
90 this.cache[key] = composed;
91 var keys = Object.keys(this.cache);
92 if (keys.length > 96)
93 { delete this.cache[keys[0]]; }
94 return composed;
95 },
96
97 _ensureOverlay: function (w, h)
98 {
99 if (!this._overlay || this._overlay.width !== w || this._overlay.height !== h)
100 {
101 this._overlay = document.createElement("canvas");
102 this._overlay.width = w;
103 this._overlay.height = h;
104 this._overlayCtx = this._overlay.getContext("2d");
105 this._overlayImg = null;
106 this._overlayTex = null;
107 this._zbuf = new Float32Array(w * h);
108 this._zbufW = w;
109 this._zbufH = h;
110 }
111 },
112
113 /**
114 * @param {Float32Array} wallDepthPerCol length = screen width
115 */
116 draw: function (scene, player, wallDepthPerCol)
117 {
118 if (!this.ready || !this.bodySet)
119 { return; }
120
121 var w = Math.round(scene.real_size.x);
122 var h = Math.round(scene.real_size.y);
123 this._ensureOverlay(w, h);
124 var ctx = this._overlayCtx;
125 ctx.clearRect(0, 0, w, h);
126 var img = ctx.createImageData(w, h);
127 var data = img.data;
128 var zbuf = this._zbuf;
129 var i;
130 for (i = 0; i < w * h; i++)
131 {
132 var col = i % w;
133 zbuf[i] = wallDepthPerCol[col];
134 }
135
136 var ppda = this.bodySet.ppda;
137 var heightM = (ppda.height_milli || 2600) / 1000;
138 var camDist = ppda.camera_distance || 10;
139 var near = ppda.depth_near;
140 var far = ppda.depth_far;
141 var metersToWorld = this.worldScale;
142 var tint = scene.npcLight != null ? scene.npcLight : 1;
143
144 var list = this.npcs.slice().sort(function (a, b)
145 {
146 var da = (a.x - player.x) * (a.x - player.x) + (a.y - player.y) * (a.y - player.y);
147 var db = (b.x - player.x) * (b.x - player.x) + (b.y - player.y) * (b.y - player.y);
148 return db - da;
149 });
150
151 for (var ni = 0; ni < list.length; ni++)
152 {
153 var npc = list[ni];
154 var dx = npc.x - player.x;
155 var dy = npc.y - player.y;
156 var dist = Math.sqrt(dx * dx + dy * dy);
157 if (dist < 0.5 || dist > 800)
158 { continue; }
159
160 var angleTo = Math.atan2(dy, dx);
161 var delta = angleTo - player.rotation;
162 while (delta > Math.PI) { delta -= Math.PI * 2; }
163 while (delta < -Math.PI) { delta += Math.PI * 2; }
164 if (Math.abs(delta) > Math.PI * 0.55)
165 { continue; }
166
167 var relYaw = PpdaViewFrame.relativeYawDeg(player.x, player.y, npc.x, npc.y, npc.facingDeg);
168 var yaw = PpdaViewFrame.pickYaw(relYaw, ppda.yaws);
169 var pitch = Math.abs(player.pitch) < 0.25
170 ? PpdaViewFrame.nearestInList(0, ppda.pitches)
171 : PpdaViewFrame.pickPitch(player.pitch, ppda.pitches);
172
173 var composed = this.composedFor(npc, pitch, yaw);
174 if (!composed)
175 { continue; }
176
177 var spriteH = (World.size * heightM) * (h / dist) * 0.5;
178 var aspect = composed.width / Math.max(1, composed.height);
179 var spriteW = spriteH * aspect;
180 var screenX = (w / 2) + (delta / (Math.PI / 3)) * (w / 2);
181 var screenY = h / 2 + (-player.pitch * h * 0.25);
182 var left = screenX - spriteW / 2;
183 var top = screenY - spriteH / 2;
184 var cols = Math.max(1, Math.ceil(spriteW));
185
186 for (var c = 0; c < cols; c++)
187 {
188 var sx = Math.floor(left + c);
189 if (sx < 0 || sx >= w)
190 { continue; }
191 var u = (c + 0.5) / cols;
192 var texX = Math.min(composed.width - 1, Math.max(0, Math.floor(u * composed.width)));
193 var y0 = Math.floor(top);
194 var y1 = Math.ceil(top + spriteH);
195
196 for (var sy = y0; sy < y1; sy++)
197 {
198 if (sy < 0 || sy >= h)
199 { continue; }
200 var v = (sy - top + 0.5) / spriteH;
201 if (v < 0 || v >= 1)
202 { continue; }
203 var texY = Math.min(composed.height - 1, Math.max(0, Math.floor(v * composed.height)));
204 var pi = texY * composed.width + texX;
205 var a = composed.lit[pi * 4 + 3];
206 if (!a || composed.depthAlpha[pi] === 0)
207 { continue; }
208
209 var depthM = near + (composed.depthGray[pi] / 65535) * (far - near);
210 var pixelDist = dist + (depthM - camDist) * metersToWorld;
211 if (pixelDist < 0.05)
212 { pixelDist = 0.05; }
213
214 var zi = sy * w + sx;
215 if (pixelDist >= zbuf[zi])
216 { continue; }
217 zbuf[zi] = pixelDist;
218
219 var o = zi * 4;
220 data[o] = Math.min(255, Math.round(composed.lit[pi * 4] * tint));
221 data[o + 1] = Math.min(255, Math.round(composed.lit[pi * 4 + 1] * tint));
222 data[o + 2] = Math.min(255, Math.round(composed.lit[pi * 4 + 2] * tint));
223 data[o + 3] = a;
224 }
225 }
226 }
227
228 ctx.putImageData(img, 0, 0);
229 var glc = scene.glContext;
230 // Re-upload every frame (content changes).
231 if (this._overlayTex)
232 {
233 var gl = glc.gl;
234 gl.bindTexture(gl.TEXTURE_2D, this._overlayTex);
235 gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, this._overlay);
236 }
237 else
238 {
239 var prevMin = glc.textureMinFilter;
240 var prevMag = glc.textureMagFilter;
241 glc.setDefaultTextureFilter(glc.gl.NEAREST, glc.gl.NEAREST);
242 this._overlayTex = glc.getTexture(this._overlay);
243 glc.textureMinFilter = prevMin;
244 glc.textureMagFilter = prevMag;
245 }
246
247 glc.drawSprite({
248 texture: this._overlayTex,
249 x: w / 2,
250 y: h / 2,
251 w: w,
252 h: h,
253 rotationDeg: 0,
254 alpha: 1,
255 uvRect: { u0: 0, v0: 0, u1: 1, v1: 1 }
256 });
257 }
258};