102 Dalmatians: Puppies to the Rescue
Decompilation Source Reference | GitLab repository
Loading...
Searching...
No Matches
projection.c
Go to the documentation of this file.
1/* Recovered game implementation; original addresses identify provenance. */
13#include "pcdogs/math/types.h"
14#include <math.h>
15#include <stdarg.h>
16#include <string.h>
17
18// Original pcdogs.exe: 0x415ed0
19// Builds the floating-point software clipping planes from the viewport dimensions and focal depth, including the stored near-plane distance.
20void Camera_SetupClipPlanes(float projection_depth_or_focal, int32_t viewport_w, int32_t viewport_h)
21{
22 float near_clip_distance =
24 // Convert horizontal FOV to normalized coordinate: fVar3 = horizontal_half_angle
25 struct Math_Vec3F corner_a;
26
27 corner_a.z = projection_depth_or_focal;
28
29 struct Math_Vec3F corner_b;
30
31 corner_b.z = projection_depth_or_focal;
32 // Setup NEAR PLANE: (0, 0, 1, d) - always points straight forward (into screen)
33 __builtin_memcpy(&data_19a95ec, &near_clip_distance, sizeof(float));
34
35 // FRUSTUM SETUP: Builds 5 clip planes (near, left, right, top, bottom) from FOV/aspect ratio. Plane format:
36 // float normal(X,Y,Z) + distance. Stored in g_cameraFrustum.
37 float half_width = (float)((long double)viewport_w * (long double)0.5f);
38 struct Math_Vec3F eye_origin;
39
40 __builtin_memset(&eye_origin, 0, 0xc);
42 data_19a95e4 = 0;
43 // Calculate LEFT PLANE normal using CalculateFaceNormal (cross product of edge vectors)
45 projection_depth_or_focal = (float)((long double)viewport_h * (long double)0.5f);
46
47 long double negative_half_width = -((long double)half_width);
48
49 corner_b.x = (float)negative_half_width;
50 corner_a.x = (float)negative_half_width;
51 corner_b.y = projection_depth_or_focal;
52
53 // Store left plane with small epsilon distance (0x358637bd) for numerical stability
54 long double negative_half_height = -((long double)projection_depth_or_focal);
55
56 corner_a.y = (float)negative_half_height;
57
58 struct Math_Vec3F out_normal;
59
60 Math_CalculateFaceNormal(&out_normal, &eye_origin, &corner_b, &corner_a);
61
62 float left_normal_y = out_normal.y;
63 float left_normal_z = out_normal.z;
64
65 // Calculate RIGHT PLANE normal
66 camera_clip_planes[0].normal.x = out_normal.x;
67 camera_clip_planes[0].normal.y = left_normal_y;
68 camera_clip_planes[0].normal.z = left_normal_z;
69 corner_b.x = half_width;
70 corner_b.y = (float)negative_half_height;
72 // Calculate BOTTOM PLANE normal
73 Math_CalculateFaceNormal(&out_normal, &eye_origin, &corner_a, &corner_b);
74
75 float upper_normal_y = out_normal.y;
76 float upper_normal_z = out_normal.z;
77
78 camera_near_clip_plane.normal.x = out_normal.x;
79 camera_near_clip_plane.normal.y = upper_normal_y;
80 // Calculate TOP PLANE normal - completes frustum pyramid definition
81 camera_near_clip_plane.normal.z = upper_normal_z;
82 corner_a.x = half_width;
83 corner_a.y = projection_depth_or_focal;
85 Math_CalculateFaceNormal(&out_normal, &eye_origin, &corner_b, &corner_a);
86
87 float right_normal_y = out_normal.y;
88
89 camera_clip_planes[1].normal.x = out_normal.x;
90
91 float right_normal_z = out_normal.z;
92
93 camera_clip_planes[1].normal.y = right_normal_y;
94 camera_clip_planes[1].normal.z = right_normal_z;
95 corner_b.x = (float)negative_half_width;
96 corner_b.y = projection_depth_or_focal;
98 Math_CalculateFaceNormal(&out_normal, &eye_origin, &corner_a, &corner_b);
99
100 float lower_normal_y = out_normal.y;
101 float lower_normal_z = out_normal.z;
102
103 camera_clip_planes[2].normal.x = out_normal.x;
104 camera_clip_planes[2].normal.y = lower_normal_y;
105 camera_clip_planes[2].normal.z = lower_normal_z;
107}
108
109// Original pcdogs.exe: 0x418ac0
110// Updates projection scales, the optional Direct3D projection transform, software clipping planes and reciprocal depth. The no-device path preserves the focal argument's raw-bit interpretation.
112{
113 uint32_t focal_bits = (uint32_t)camera->focal_distance;
114
116 camera->near_clip_distance_q6 = focal_bits / (uint32_t)g_cameraProjectionDivisor;
117
118 float focal_argument;
119
120 memcpy(&focal_argument, &focal_bits, sizeof focal_argument);
121
122 if (g_d3dDevice7)
123 {
124 long double focal = (long double)camera->focal_distance / MATH_Q12_SCALE_LONG_DOUBLE;
125
126 focal_argument = (float)focal;
127
128 float x_scale = (float)(focal * 2 / camera->viewport.w);
129 float y_scale = (float)((long double)focal_argument * -2 / camera->viewport.h);
130
131 memcpy(&camera_projection_matrix_x_scale, &x_scale, sizeof x_scale);
132 memcpy(&camera_projection_matrix_y_scale, &y_scale, sizeof y_scale);
136 g_d3dDevice7->lpVtbl->SetTransform(g_d3dDevice7, 3, (D3DMATRIX *)&camera_projection_matrix_x_scale);
137 }
138
140 Camera_SetupClipPlanes(focal_argument, camera->viewport.w, camera->viewport.h);
141 memcpy(&g_reciprocalZ, &focal_argument, sizeof focal_argument);
142}
143
144// Original pcdogs.exe: 0x4444b0
145// Rebuilds fixed-point frustum directions when the focal distance changes, then refreshes projection state.
146void Camera_UpdateProjection(struct Camera_Runtime *camera, int32_t focal_distance)
147{
148 if (camera->focal_distance != focal_distance)
149 {
150 camera->focal_distance = focal_distance;
151 Camera_BuildViewMatrix(&camera->frustum_dirs, &camera->viewport.w, focal_distance);
152 }
153
155}
156
157// Original pcdogs.exe: 0x4444e0
158// Computes the four fixed-point frustum side directions from the viewport bounds and focal distance, retaining the native zero-length cases.
159void Camera_BuildViewMatrix(struct Camera_FrustumDirTable *frustum_dirs, int16_t *viewport_size, int32_t focal_distance)
160{
161 frustum_dirs->v[0].dir.x = 0;
162 frustum_dirs->v[0].dir.y = 0;
163 frustum_dirs->v[0].dir.z = MATH_Q12_ONE;
164
165 int32_t focal_q6 = focal_distance >> 6;
166 int32_t half_height_q6 = ((int32_t)viewport_size[1] & ~1) * 32;
167 int32_t half_width_q6 = ((int32_t)viewport_size[0] & ~1) * 32;
168 int32_t left_delta_y = -2 * half_height_q6;
169 int32_t top_delta_x = 2 * half_width_q6;
170 int32_t right_delta_y = 2 * half_height_q6;
171 int32_t bottom_delta_x = -2 * half_width_q6;
172 struct Math_Vec3I32 normals[4] = {
173 {-(int32_t)(((int64_t)focal_q6 * left_delta_y) >> MATH_Q12_SHIFT), 0,
174 (int32_t)(((int64_t)left_delta_y * -half_width_q6) >> MATH_Q12_SHIFT)},
175 {0, (int32_t)(((int64_t)top_delta_x * focal_q6) >> MATH_Q12_SHIFT),
176 -(int32_t)(((int64_t)-half_height_q6 * top_delta_x) >> MATH_Q12_SHIFT)},
177 {-(int32_t)(((int64_t)focal_q6 * right_delta_y) >> MATH_Q12_SHIFT), 0,
178 (int32_t)(((int64_t)right_delta_y * half_width_q6) >> MATH_Q12_SHIFT)},
179 {0, (int32_t)(((int64_t)bottom_delta_x * focal_q6) >> MATH_Q12_SHIFT),
180 -(int32_t)(((int64_t)half_height_q6 * bottom_delta_x) >> MATH_Q12_SHIFT)}};
181
182 const int plane_indices[4] = {1, 4, 2, 3};
183
184 for (int side = 0; side < 4; ++side)
185 {
186 int32_t x = normals[side].x;
187 int32_t y = normals[side].y;
188 int32_t z = normals[side].z;
189 uint64_t squared_length = (uint64_t)((int64_t)x * x) +
190 (uint64_t)((int64_t)y * y) + (uint64_t)((int64_t)z * z);
191 int32_t length = Math_SqrtFP12((uint32_t)(squared_length >> MATH_Q12_SHIFT));
192 int16_t unit_x = 0, unit_y = 0, unit_z = 0;
193
194 if (length)
195 {
196 int32_t inverse_length = INT64_C(0x100000000) / length;
197
198 unit_x = (int16_t)((int32_t)(((int64_t)inverse_length * x) >> MATH_Q12_SHIFT) >> 8);
199 unit_y = (int16_t)((int32_t)(((int64_t)inverse_length * y) >> MATH_Q12_SHIFT) >> 8);
200 unit_z = (int16_t)((int32_t)(((int64_t)inverse_length * z) >> MATH_Q12_SHIFT) >> 8);
201 }
202
203 frustum_dirs->v[plane_indices[side]].dir.x = unit_x;
204 frustum_dirs->v[plane_indices[side]].dir.y = unit_y;
205 frustum_dirs->v[plane_indices[side]].dir.z = unit_z;
206 }
207}
208
209// Original pcdogs.exe: 0x4449b0
210// Calculates focal distance from half the field-of-view angle. A zero half-angle returns zero; native division faults remain for a zero divisor or overflowing signed quotient.
211int32_t Camera_CalculateClipDistance(struct Camera_Runtime *camera, int16_t fov)
212{
213 int32_t half_fov = fov >> 1;
214
215 if (!half_fov)
216 return 0;
217
218 int32_t cosine = Math_SinQ14(MATH_ANGLE_QUARTER_TURN - half_fov) >> 2;
219 int32_t half_width_q12 = ((int32_t)camera->viewport.w * MATH_Q12_ONE) >> 1;
220 int32_t projected = (int32_t)((uint64_t)((int64_t)half_width_q12 * cosine) >> MATH_Q12_SHIFT);
221 int32_t sine = Math_SinQ14(half_fov) >> 2;
222 uint32_t low = (uint32_t)projected << MATH_Q12_SHIFT;
223 int32_t high = projected >> (32 - MATH_Q12_SHIFT);
224
225 /* The original IDIV leaves the dividend and divisor intact on either #DE. */
226 __asm__ volatile("idivl %%ecx" : "+a"(low), "+d"(high) : "c"(sine) : "cc");
227 return (int32_t)low;
228}
229
230// Original pcdogs.exe: 0x444a20
231// Sets the default field of view and returns its calculated focal distance.
233{
234 // Calculate clip distance based on FOV and update camera projection
236
237 // Store FOV value 0x30f at camera+10 (camera FOV field)
239}
240
241// Original pcdogs.exe: 0x444a40
242// Stores the viewport rectangle and optionally updates projection using the current or default field of view.
243void Camera_SetViewport(int16_t viewport_x, int16_t viewport_y, int16_t viewport_w, int16_t viewport_h, int32_t apply_projection)
244{
245 g_cameraData.viewport.x = viewport_x;
246 g_cameraData.viewport.y = viewport_y;
247 g_cameraData.viewport.h = viewport_h;
248 g_cameraData.viewport.w = viewport_w;
249
250 if (!apply_projection)
251 return;
252
253 int16_t fov = g_cameraData.fov;
254
255 g_cameraData.focal_distance = 0;
256
257 if (!fov)
258 {
260
261 return;
262 }
263
266}
#define CAMERA_FLOAT_ONE_BITS
Definition constants.h:61
#define CAMERA_PROJECTION_NEAR_W_BITS
Definition constants.h:62
#define CAMERA_DEFAULT_FOV_ANGLE
Definition constants.h:59
#define CAMERA_PROJECTION_FAR_W_BITS
Definition constants.h:63
#define CAMERA_CLIP_PLANE_EPSILON
Definition constants.h:60
#define CAMERA_MAX_RENDER_DISTANCE_Q12
Definition constants.h:58
#define camera_projection_matrix_far_w
Definition globals.h:60
#define camera_projection_matrix_y_scale
Definition globals.h:51
#define camera_near_clip_plane
Definition globals.h:87
#define g_cameraProjectionDivisor
Definition globals.h:27
#define camera_clip_planes
Definition globals.h:84
#define camera_projection_matrix_x_scale
Definition globals.h:48
#define camera_projection_matrix_one
Definition globals.h:57
#define Camera_SetupClipPlanes_NearClipDistanceSource
Definition globals.h:90
#define g_cameraData
Definition globals.h:63
#define camera_projection_matrix_near_w
Definition globals.h:54
#define graphics_d3d_state
Definition globals.h:308
#define MATH_Q12_SHIFT
Definition constants.h:8
#define MATH_ANGLE_QUARTER_TURN
Definition constants.h:15
#define MATH_Q12_ONE
Definition constants.h:9
#define MATH_Q12_SCALE_LONG_DOUBLE
Definition constants.h:7
int32_t Math_SinQ14(int32_t angle)
int32_t Math_SqrtFP12(uint32_t value)
struct Math_Vec3F * Math_CalculateFaceNormal(struct Math_Vec3F *out_normal, struct Math_Vec3F const *point0, struct Math_Vec3F const *point1, struct Math_Vec3F const *point2)
Definition fixed_point.c:35
#define data_19a95ec
Definition opaque_data.h:57
#define data_19a95e4
Definition opaque_data.h:51
#define data_19a95e8
Definition opaque_data.h:54
void Camera_UpdateProjection(struct Camera_Runtime *camera, int32_t focal_distance)
Definition projection.c:146
int32_t Camera_CalculateClipDistance(struct Camera_Runtime *camera, int16_t fov)
Definition projection.c:211
int32_t Camera_SetDefaultFOV(struct Camera_Runtime *camera)
Definition projection.c:232
void Camera_SetupProjection(struct Camera_Runtime *camera)
Definition projection.c:111
void Camera_BuildViewMatrix(struct Camera_FrustumDirTable *frustum_dirs, int16_t *viewport_size, int32_t focal_distance)
Definition projection.c:159
void Camera_SetViewport(int16_t viewport_x, int16_t viewport_y, int16_t viewport_w, int16_t viewport_h, int32_t apply_projection)
Definition projection.c:243
void Camera_SetupClipPlanes(float projection_depth_or_focal, int32_t viewport_w, int32_t viewport_h)
Definition projection.c:20
struct Math_Vec3I16 dir
Definition types.h:148
struct Camera_FrustumDirEntry v[0x5]
Definition types.h:208
int32_t max_render_distance_q12
Definition types.h:271
struct Camera_FrustumDirTable frustum_dirs
Definition types.h:265
struct Math_ViewportI16 viewport
Definition types.h:264
int32_t focal_distance
Definition types.h:261
int16_t fov
Definition types.h:260
int32_t near_clip_distance_q6
Definition types.h:270
float z
Definition types.h:448
float y
Definition types.h:447
float x
Definition types.h:446
int16_t z
Definition types.h:460
int16_t x
Definition types.h:458
int16_t y
Definition types.h:459
int32_t y
Definition types.h:471
int32_t x
Definition types.h:470
int32_t z
Definition types.h:472
int16_t h
Definition types.h:509
int16_t w
Definition types.h:508
#define g_d3dDevice7
Definition values.h:792
#define g_reciprocalZ
Definition values.h:813