Blender V5.3
kernel/geom/object.h
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2011-2022 Blender Foundation
2 *
3 * SPDX-License-Identifier: Apache-2.0 */
4
5/* Object Primitive
6 *
7 * All mesh and curve primitives are part of an object. The same mesh and curves
8 * may be instanced multiple times by different objects.
9 *
10 * If the mesh is not instanced multiple times, the object will not be explicitly
11 * stored as a primitive in the BVH, rather the bare triangles are curved are
12 * directly primitives in the BVH with world space locations applied, and the object
13 * ID is looked up afterwards. */
14
15#pragma once
16
17#include "kernel/globals.h"
18#include "kernel/types.h"
19
21
22/* Object attributes, for now a fixed size and contents */
23
28
30
31/* Object to world space transformation */
32
34 const int object,
35 enum ObjectTransform type)
36{
37 if (type == OBJECT_INVERSE_TRANSFORM) {
38 return kernel_data_fetch(objects, object).itfm;
39 }
40 return kernel_data_fetch(objects, object).tfm;
41}
42
43/* Object to world space transformation for motion vectors */
44
46 const int object,
47 enum ObjectVectorTransform type)
48{
49 const int offset = object * OBJECT_MOTION_PASS_SIZE + (int)type;
50 return kernel_data_fetch(object_motion_pass, offset);
51}
52
53/* Motion blurred object transformations */
54
55#ifdef __OBJECT_MOTION__
56ccl_device_inline Transform object_fetch_transform_motion(KernelGlobals kg,
57 const int object,
58 const float time)
59{
60 const uint motion_offset = kernel_data_fetch(objects, object).motion_offset;
61 const ccl_global DecomposedTransform *motion = &kernel_data_fetch(object_motion, motion_offset);
62 const int num_steps = kernel_data_fetch(objects, object).num_tfm_steps;
63
64 Transform tfm;
65 transform_motion_array_interpolate(&tfm, motion, num_steps, time);
66
67 return tfm;
68}
69#endif /* __OBJECT_MOTION__ */
70
72 const int object,
73 const float time,
75{
76#ifdef __OBJECT_MOTION__
77 const uint object_flag = kernel_data_fetch(object_flag, object);
78 if (object_flag & SD_OBJECT_MOTION) {
79 /* if we do motion blur */
80 Transform tfm = object_fetch_transform_motion(kg, object, time);
81
82 if (itfm) {
83 *itfm = transform_inverse(tfm);
84 }
85
86 return tfm;
87 }
88
89#endif /* __OBJECT_MOTION__ */
90
92 if (itfm) {
94 }
95
96 return tfm;
97}
98
99/* Get transform matrix for shading point. */
100
102 const ccl_private ShaderData *sd)
103{
104#ifdef __OBJECT_MOTION__
105 return (sd->object_flag & SD_OBJECT_MOTION) ?
106 sd->ob_tfm_motion :
108#else
109 return object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
110#endif
111}
112
114 const ccl_private ShaderData *sd)
115{
116#ifdef __OBJECT_MOTION__
117 return (sd->object_flag & SD_OBJECT_MOTION) ?
118 sd->ob_itfm_motion :
120#else
121 return object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM);
122#endif
123}
124
130
131/* Transform position from object to world space */
132
133template<class T>
135 const ccl_private ShaderData *sd,
136 ccl_private T *P)
137{
138#ifdef __OBJECT_MOTION__
139 if (sd->object_flag & SD_OBJECT_MOTION) {
140 *P = transform_point_auto(&sd->ob_tfm_motion, *P);
141 return;
142 }
143#endif
144
145 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
146 *P = transform_point(&tfm, *P);
147}
148
149/* Transform position from world to object space */
150
151template<class T>
153 const ccl_private ShaderData *sd,
154 ccl_private T *P)
155{
156#ifdef __OBJECT_MOTION__
157 if (sd->object_flag & SD_OBJECT_MOTION) {
158 *P = transform_point_auto(&sd->ob_itfm_motion, *P);
159 return;
160 }
161#endif
162
163 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM);
164 *P = transform_point(&tfm, *P);
165}
166
167/* Convenience wrapper that checks for OBJECT_NONE before transforming.
168 * Works with both plain types (float3) and dual types (dual3). */
169template<class Float3Type>
171 KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private Float3Type *P)
172{
173 if (sd->object != OBJECT_NONE) {
175 }
176}
177
178/* Transform normal from world to object space */
179
181 const ccl_private ShaderData *sd,
183{
184#ifdef __OBJECT_MOTION__
185 if (sd->object_flag & SD_OBJECT_MOTION) {
186 if (sd->object != OBJECT_NONE) {
187 *N = safe_normalize(transform_direction_transposed_auto(&sd->ob_tfm_motion, *N));
188 }
189 return;
190 }
191#endif
192
193 if (sd->object != OBJECT_NONE) {
194 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
196 }
197}
198
199/* Transform normal from object to world space */
200template<class T>
202 const ccl_private ShaderData *sd,
203 ccl_private T *N)
204{
205#ifdef __OBJECT_MOTION__
206 if (sd->object_flag & SD_OBJECT_MOTION) {
207 *N = normalize(transform_direction_transposed_auto(&sd->ob_itfm_motion, *N));
208 return;
209 }
210#endif
211
212 if (sd->object != OBJECT_NONE) {
213 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM);
215 }
216}
217
219{
220 return ((object_flag & SD_OBJECT_NEGATIVE_SCALE) && (object_flag & SD_OBJECT_TRANSFORM_APPLIED));
221}
222
223/* Transform direction vector from object to world space */
224
226 const ccl_private ShaderData *sd,
228{
229#ifdef __OBJECT_MOTION__
230 if (sd->object_flag & SD_OBJECT_MOTION) {
231 *D = transform_direction_auto(&sd->ob_tfm_motion, *D);
232 return;
233 }
234#endif
235
236 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
237 *D = transform_direction(&tfm, *D);
238}
239
240/* Transform direction vector from world to object space */
241
243 const ccl_private ShaderData *sd,
245{
246#ifdef __OBJECT_MOTION__
247 if (sd->object_flag & SD_OBJECT_MOTION) {
248 *D = transform_direction_auto(&sd->ob_itfm_motion, *D);
249 return;
250 }
251#endif
252
253 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_INVERSE_TRANSFORM);
254 *D = transform_direction(&tfm, *D);
255}
256
257/* Object center position */
258
260{
261 if (sd->object == OBJECT_NONE) {
262 return make_float3(0.0f, 0.0f, 0.0f);
263 }
264
265#ifdef __OBJECT_MOTION__
266 if (sd->object_flag & SD_OBJECT_MOTION) {
267 return make_float3(sd->ob_tfm_motion.x.w, sd->ob_tfm_motion.y.w, sd->ob_tfm_motion.z.w);
268 }
269#endif
270
271 const Transform tfm = object_fetch_transform(kg, sd->object, OBJECT_TRANSFORM);
272 return make_float3(tfm.x.w, tfm.y.w, tfm.z.w);
273}
274
275/* Color of the object */
276
278{
279 if (object == OBJECT_NONE) {
280 return make_float3(0.0f, 0.0f, 0.0f);
281 }
282
283 const ccl_global KernelObject *kobject = &kernel_data_fetch(objects, object);
284 return make_float3(kobject->color[0], kobject->color[1], kobject->color[2]);
285}
286
287/* Alpha of the object */
288
290{
291 if (object == OBJECT_NONE) {
292 return 0.0f;
293 }
294
295 return kernel_data_fetch(objects, object).alpha;
296}
297
298/* Pass ID number of object */
299
301{
302 if (object == OBJECT_NONE) {
303 return 0.0f;
304 }
305
306 return kernel_data_fetch(objects, object).pass_id;
307}
308
309/* Light-group of object. */
310
312{
313 if (object == OBJECT_NONE) {
314 return LIGHTGROUP_NONE;
315 }
316
317 return kernel_data_fetch(objects, object).lightgroup;
318}
319
320/* Per object random number for shader variation */
321
323{
324 if (object == OBJECT_NONE) {
325 return 0.0f;
326 }
327
328 return kernel_data_fetch(objects, object).random_number;
329}
330
331/* Particle ID from which this object was generated */
332
334{
335 if (object == OBJECT_NONE) {
336 return 0;
337 }
338
339 return kernel_data_fetch(objects, object).particle_index;
340}
341
342/* Generated texture coordinate on surface from where object was instanced */
343
345{
346 if (object == OBJECT_NONE) {
347 return make_float3(0.0f, 0.0f, 0.0f);
348 }
349
350 const ccl_global KernelObject *kobject = &kernel_data_fetch(objects, object);
351 return make_float3(
352 kobject->dupli_generated[0], kobject->dupli_generated[1], kobject->dupli_generated[2]);
353}
354
355/* UV texture coordinate on surface from where object was instanced */
356
358{
359 if (object == OBJECT_NONE) {
360 return make_float3(0.0f, 0.0f, 0.0f);
361 }
362
363 const ccl_global KernelObject *kobject = &kernel_data_fetch(objects, object);
364 return make_float3(kobject->dupli_uv[0], kobject->dupli_uv[1], 0.0f);
365}
366
367/* Volume density */
368
370{
371 if (object == OBJECT_NONE) {
372 return 1.0f;
373 }
374
375 if (kernel_data_fetch(objects, object).primitive_type & PRIMITIVE_TRIANGLE) {
376 return kernel_data_fetch(objects, object).mesh_volume.volume_density;
377 }
378
379 return 1.0f;
380}
381
382/* Pass ID for shader */
383
385{
386 return kernel_data_fetch(shaders, (sd->shader & SHADER_MASK)).pass_id;
387}
388
389/* Cryptomatte ID */
390
392{
393 if (object == OBJECT_NONE) {
394 return 0.0f;
395 }
396
397 return kernel_data_fetch(objects, object).cryptomatte_object;
398}
399
401{
402 if (object == OBJECT_NONE) {
403 return 0;
404 }
405
406 return kernel_data_fetch(objects, object).cryptomatte_asset;
407}
408
409/* Particle data from which object was instanced */
410
412{
413 return kernel_data_fetch(particles, particle).index;
414}
415
416ccl_device float particle_age(KernelGlobals kg, const int particle)
417{
418 return kernel_data_fetch(particles, particle).age;
419}
420
421ccl_device float particle_lifetime(KernelGlobals kg, const int particle)
422{
423 return kernel_data_fetch(particles, particle).lifetime;
424}
425
426ccl_device float particle_size(KernelGlobals kg, const int particle)
427{
428 return kernel_data_fetch(particles, particle).size;
429}
430
432{
433 return kernel_data_fetch(particles, particle).rotation;
434}
435
437{
438 return make_float3(kernel_data_fetch(particles, particle).location);
439}
440
442{
443 return make_float3(kernel_data_fetch(particles, particle).velocity);
444}
445
447{
448 return make_float3(kernel_data_fetch(particles, particle).angular_velocity);
449}
450
451/* Object intersection in BVH */
452
454{
455 const float ooeps = 8.271806E-25f;
456 return make_float3((fabsf(dir.x) > ooeps) ? dir.x : copysignf(ooeps, dir.x),
457 (fabsf(dir.y) > ooeps) ? dir.y : copysignf(ooeps, dir.y),
458 (fabsf(dir.z) > ooeps) ? dir.z : copysignf(ooeps, dir.z));
459}
460
462{
463 return reciprocal(dir);
464}
465
466/* Transform ray into object space to enter static object in BVH */
467
469 const int object,
470 const ccl_private Ray *ray,
472 ccl_private float3 *dir,
473 ccl_private float3 *idir)
474{
476
477 *P = transform_point(&tfm, ray->P);
478
479 *dir = bvh_clamp_direction(transform_direction(&tfm, ray->D));
480 *idir = bvh_inverse_direction(*dir);
481}
482
483#ifdef __OBJECT_MOTION__
484/* Transform ray into object space to enter motion blurred object in BVH */
485
486ccl_device_inline void bvh_instance_motion_push(KernelGlobals kg,
487 const int object,
488 const ccl_private Ray *ray,
490 ccl_private float3 *dir,
491 ccl_private float3 *idir)
492{
493 Transform tfm;
494 object_fetch_transform_motion_test(kg, object, ray->time, &tfm);
495
496 *P = transform_point(&tfm, ray->P);
497
498 *dir = bvh_clamp_direction(transform_direction(&tfm, ray->D));
499 *idir = bvh_inverse_direction(*dir);
500}
501
502#endif
503
504/* Transform ray to exit static object in BVH. */
505
508 ccl_private float3 *dir,
509 ccl_private float3 *idir)
510{
511 *P = ray->P;
512 *dir = bvh_clamp_direction(ray->D);
513 *idir = bvh_inverse_direction(*dir);
514}
515
#define D
#define transform_direction_transposed_auto
#define transform_point_auto
#define kernel_data_fetch(name, index)
#define transform_direction_auto
#define OBJECT_NONE
#define OBJECT_MOTION_PASS_SIZE
#define ccl_private
#define ccl_device_inline
#define LIGHTGROUP_NONE
#define ccl_global
#define CCL_NAMESPACE_END
ccl_device_forceinline float3 make_float3(const float x, const float y, const float z)
#define copysignf(x, y)
VecBase< float, D > normalize(VecOp< float, D >) RET
float3 transform_direction(float3x3 mat, float3 direction)
float3 transform_point(float3x3 mat, float3 point)
VecT safe_normalize(VecT vector)
ccl_device_inline float3 object_dupli_uv(KernelGlobals kg, const int object)
ccl_device_inline int object_particle_id(KernelGlobals kg, const int object)
ccl_device int shader_pass_id(KernelGlobals kg, const ccl_private ShaderData *sd)
ObjectTransform
@ OBJECT_INVERSE_TRANSFORM
@ OBJECT_TRANSFORM
ccl_device_inline Transform object_get_inverse_transform(KernelGlobals kg, const ccl_private ShaderData *sd)
ccl_device_inline float object_volume_density(KernelGlobals kg, const int object)
ccl_device_inline Transform lamp_get_inverse_transform(KernelGlobals kg, const ccl_global KernelLight *klight)
ccl_device_inline float object_cryptomatte_id(KernelGlobals kg, const int object)
ccl_device_inline void object_dir_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *D)
ccl_device float4 particle_rotation(KernelGlobals kg, const int particle)
ccl_device_inline int object_lightgroup(KernelGlobals kg, const int object)
ccl_device_inline void bvh_instance_push(KernelGlobals kg, const int object, const ccl_private Ray *ray, ccl_private float3 *P, ccl_private float3 *dir, ccl_private float3 *idir)
ccl_device float3 particle_location(KernelGlobals kg, const int particle)
ccl_device float particle_lifetime(KernelGlobals kg, const int particle)
ccl_device float particle_age(KernelGlobals kg, const int particle)
ccl_device_inline uint particle_index(KernelGlobals kg, const int particle)
ccl_device_inline Transform object_fetch_transform(KernelGlobals kg, const int object, enum ObjectTransform type)
ccl_device_inline float3 object_color(KernelGlobals kg, const int object)
ccl_device_inline float3 bvh_inverse_direction(const float3 dir)
ccl_device_inline Transform object_get_transform(KernelGlobals kg, const ccl_private ShaderData *sd)
ccl_device_inline bool object_negative_scale_applied(const uint object_flag)
ccl_device float3 particle_velocity(KernelGlobals kg, const int particle)
ccl_device_inline float3 bvh_clamp_direction(const float3 dir)
ccl_device_inline void object_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *N)
ccl_device_inline float object_alpha(KernelGlobals kg, const int object)
ccl_device_inline Transform object_fetch_motion_pass_transform(KernelGlobals kg, const int object, enum ObjectVectorTransform type)
ccl_device float3 particle_angular_velocity(KernelGlobals kg, const int particle)
ccl_device_inline float object_cryptomatte_asset_id(KernelGlobals kg, const int object)
ccl_device_inline float3 object_dupli_generated(KernelGlobals kg, const int object)
ccl_device_inline float object_pass_id(KernelGlobals kg, const int object)
ccl_device_inline void object_inverse_position_transform_if_object(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private Float3Type *P)
ccl_device_inline void object_inverse_position_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *P)
ccl_device float particle_size(KernelGlobals kg, const int particle)
ccl_device_inline void object_position_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private T *P)
ccl_device_inline void object_inverse_dir_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *D)
ccl_device_inline void object_inverse_normal_transform(KernelGlobals kg, const ccl_private ShaderData *sd, ccl_private float3 *N)
ObjectVectorTransform
@ OBJECT_PASS_MOTION_PRE
@ OBJECT_PASS_MOTION_POST
ccl_device_inline float3 object_location(KernelGlobals kg, const ccl_private ShaderData *sd)
ccl_device_inline Transform object_fetch_transform_motion_test(KernelGlobals kg, const int object, const float time, ccl_private Transform *itfm)
ccl_device_inline void bvh_instance_pop(const ccl_private Ray *ray, ccl_private float3 *P, ccl_private float3 *dir, ccl_private float3 *idir)
ccl_device_inline float object_random_number(KernelGlobals kg, const int object)
@ PRIMITIVE_TRIANGLE
@ SD_OBJECT_MOTION
@ SD_OBJECT_NEGATIVE_SCALE
@ SD_OBJECT_TRANSFORM_APPLIED
@ SHADER_MASK
ccl_device_inline float3 reciprocal(const float3 a)
Definition math_float3.h:36
#define N
#define T
unsigned int uint
Definition BKE_text.h:55
#define fabsf
#define ccl_device
float4 y
Definition transform.h:53
float4 x
Definition transform.h:53
float4 z
Definition transform.h:53
float z
Definition sky_math.h:136
float y
Definition sky_math.h:136
float x
Definition sky_math.h:136
float w
Definition sky_math.h:225
ccl_device_inline T transform_direction_transposed(const ccl_private Transform *t, const T a)
Definition transform.h:176
ccl_device void transform_motion_array_interpolate(ccl_private Transform *tfm, const ccl_global DecomposedTransform *motion, const int numsteps, const float time)
Definition transform.h:629
ccl_device_inline Transform transform_inverse(const Transform tfm)
Definition transform.h:563