-
Notifications
You must be signed in to change notification settings - Fork 1
/
ky.cpp
4856 lines (3843 loc) · 137 KB
/
ky.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
//#define KY_OUTPUT_HDR // default output .bmp image, whether need to output .hdr image
//#define KY_LOG_VAST
#include <cmath>
#include <cstdlib>
#include <cstdio>
#include <ctime>
#include <algorithm>
#include <array>
#include <concepts>
#include <exception>
#include <format>
#include <fstream>
#include <functional>
#include <iostream>
#include <memory>
#include <numbers>
#include <optional>
#include <random>
#include <source_location>
#include <string>
#include <string_view>
#include <thread>
#include <vector>
using namespace std::literals::string_literals;
#pragma region macro
#if defined(_DEBUG)
#define KY_DEBUG
#else
#define KY_RELEASE
#endif
#if defined(_WIN32) || defined(_WIN64)
#define KY_WINDOWS
#if defined(_MSC_VER)
#define KY_MSVC
#elif defined(__MINGW32__)
#define KY_MINGW
#endif
#elif defined(__linux__)
#define KY_LINUX
#elif defined(__APPLE__)
#define KY_MACOS
#endif
template <typename... Ts>
inline void _LOG(const std::source_location& location, const std::string& fmt, Ts&&... args)
{
std::string msg = std::vformat("{}(...) line{}: " + fmt,
std::make_format_args(location.function_name(), location.line(), std::forward<Ts>(args)...));
std::printf("%s", msg.c_str());
}
template <typename... Ts>
inline void _LOG_ERROR(const std::source_location& location, const std::string& fmt, Ts&&... args)
{
std::string msg = std::vformat("{}(...) line{}: " + fmt,
std::make_format_args(location.function_name(), location.line(), std::forward<Ts>(args)...));
std::printf("%s", msg.c_str());
throw std::exception(msg.c_str());
}
#define LOG(...) _LOG(std::source_location::current(), __VA_ARGS__)
#define LOG_ERROR(...) _LOG_ERROR(std::source_location::current(), __VA_ARGS__)
#define _CHECK1(condition) if(!(condition)) LOG_ERROR("{}", #condition)
#define _CHECK2(condition, msg) if(!(condition)) LOG_ERROR("{}", msg)
#define _CHECK3(condition, ...) _EXPAND( if(!(condition)) LOG_ERROR(__VA_ARGS__) )
#define _GET_MACRO(_1, _2, _3, _4, _5, NAME, ...) NAME
#define _EXPAND( x ) x
#define CHECK(...) _EXPAND( _GET_MACRO(__VA_ARGS__, _CHECK3, _CHECK3, _CHECK3, _CHECK2, _CHECK1, UNUSED) (__VA_ARGS__) )
#ifdef KY_DEBUG
#ifndef LOG_DEBUG
#define LOG_DEBUG(...) LOG(__VA_ARGS__)
#endif
#ifndef CHECK_DEBUG
#define CHECK_DEBUG(...) _EXPAND( CHECK(__VA_ARGS__) )
#endif
#else
#ifndef LOG_DEBUG
#define LOG_DEBUG(...)
#endif
#ifndef CHECK_DEBUG
#define CHECK_DEBUG(...)
#endif
#endif
#ifdef KY_LOG_VAST
#ifndef LOG_VAST
#define LOG_VAST(...) LOG(__VA_ARGS__)
#endif
#else
#ifndef LOG_VAST
#define LOG_VAST(...)
#endif
#endif
#define KY_ENUM_OPERATORS(enum_t) \
constexpr enum_t operator~(enum_t a) { return (enum_t)(~(int)a); } \
constexpr enum_t operator|(enum_t a, const enum_t b) { return (enum_t)((int)a | (int)b); } \
constexpr enum_t operator&(enum_t a, const enum_t b) { return (enum_t)((int)a & (int)b); } \
constexpr enum_t& operator|=(enum_t& a, const enum_t b) { a = a | b; return a; }; \
constexpr enum_t& operator&=(enum_t& a, const enum_t b) { a = a & b; return a; }; \
constexpr bool enum_have(enum_t group, enum_t value) { return (group & value) != (enum_t)0; }
#pragma endregion
#pragma region utility
class nocopyable_t
{
protected:
constexpr nocopyable_t() = default;
~nocopyable_t() = default;
nocopyable_t(nocopyable_t&&) = default;
nocopyable_t& operator=(nocopyable_t&&) = default;
private:
nocopyable_t(const nocopyable_t&);
nocopyable_t& operator=(const nocopyable_t&);
};
float timing_seconds(std::invocable auto function)
{
clock_t start = clock();
function();
return (float_t)(clock() - start) / CLOCKS_PER_SEC;
}
#pragma endregion
#pragma region math
//using float_t = float; // already defined in math.h
static_assert(sizeof(float_t) == 4);
using float01_t = float_t; // from 0 to 1
using unit_float_t = float_t; // 'normalized float_t', from -1 to 1
using radian_t = float_t;
using degree_t = float_t;
constexpr float_t k_epsilon = std::numeric_limits<float_t>::epsilon();
constexpr float_t k_infinity = std::numeric_limits<float_t>::infinity();
constexpr float_t k_pi = std::numbers::pi;
constexpr float_t k_2pi = 2.f * k_pi;
constexpr float_t k_pi_over2 = k_pi / 2.f;
constexpr float_t k_pi_over4 = k_pi / 4.f;
constexpr float_t k_inv_pi = std::numbers::inv_pi;
constexpr float_t k_inv_2pi = k_inv_pi / 2.f;
constexpr float_t k_inv_4pi = k_inv_pi / 4.f;
constexpr radian_t radians(degree_t degree) { return (k_pi / 180.f) * degree; }
constexpr degree_t degrees(radian_t radian) { return (180.f / k_pi) * radian; }
constexpr float_t lerp(float_t a, float_t b, float_t t) { return a + t * (b - a); }
inline bool is_infinity(std::floating_point auto x) { return std::isinf(x); }
inline bool is_nan(std::floating_point auto x) { return std::isnan(x); }
inline bool is_invalid(std::floating_point auto x) { return is_infinity(x) || is_nan(x); }
inline bool is_valid(std::floating_point auto x) { return !is_invalid(x); }
// https://stackoverflow.com/questions/17333/what-is-the-most-effective-way-for-float_t-and-double-comparison
// http://realtimecollisiondetection.net/blog/?p=89
template <typename T>
struct equal_epsilon
{
static constexpr T absolute_epsilon = std::numeric_limits<T>::epsilon();
static constexpr T relative_epsilon = std::numeric_limits<T>::epsilon();
};
template <typename T>
constexpr bool is_equal(T x, T y, T epsilon = equal_epsilon<T>::absolute_epsilon)
{
if constexpr (std::is_floating_point_v<T>)
// return std::fabs(x - y) <= std::max(absolute_epsilon, relative_epsilon * std::max(fabs(x), fabs(y)) );
return std::abs(x - y) <= epsilon * std::max({ T(1), std::abs(x), std::abs(y) });
else
return x == y;
}
#pragma endregion
#pragma region geometry
struct color_t
{
float_t r{}, g{}, b{};
color_t operator*(float_t s) const { return { r * s, g * s, b * s }; }
color_t operator/(float_t s) const { return { r / s, g / s, b / s }; }
color_t operator*=(float_t s) { r *= s, g *= s, b *= s; return *this; }
color_t operator/=(float_t s) { r /= s, g /= s, b /= s; return *this; }
color_t operator+(color_t c) const { return { r + c.r, g + c.g, b + c.b }; }
color_t operator*(color_t c) const { return { r * c.r, g * c.g, b * c.b }; }
color_t operator+=(color_t c) { r += c.r, g += c.g, b += c.b; return *this; }
color_t operator*=(color_t c) { r *= c.r, g *= c.g, b *= c.b; return *this; }
friend color_t operator*(float_t s, color_t c) { return { s * c.r, s * c.g, s * c.b }; }
float_t max_component_value() const
{
return std::max({ r, g, b });
}
float_t luminance() const
{
return
0.212671f * r +
0.715160f * g +
0.072169f * b;
}
// TODO: why allow nagetive value?
bool is_black() const { return (r <= 0) && (g <= 0) && (b <= 0); }
// for debug:
bool is_valid() const { return ::is_valid(r) && ::is_valid(g) && ::is_valid(b); }
std::string to_string() const { return std::format("[{:.3f}, {:.3f}, {:.3f}]", r, g, b); }
friend std::ostream& operator<<(std::ostream& console, color_t color)
{
console << color.to_string();
return console;
}
};
struct vec2_t
{
float_t x{}, y{};
float_t operator[](int i) const { CHECK_DEBUG(i >= 0 && i < 2); return (&x)[i]; }
vec2_t& operator+=(vec2_t v) { x += v.x; y += v.y; return *this; }
vec2_t& operator-=(vec2_t v) { x -= v.x; y -= v.y; return *this; }
vec2_t operator+(vec2_t vec2) const { return vec2_t(x + vec2.x, y + vec2.y); }
vec2_t operator-(vec2_t vec2) const { return vec2_t(x - vec2.x, y - vec2.y); }
friend vec2_t operator*(float_t s, vec2_t v) { return vec2_t(v.x * s, v.y * s); }
};
using point2_t = vec2_t;
using float2_t = vec2_t;
struct vec3_t
{
float_t x{}, y{}, z{};
float_t operator[](int i) const { CHECK_DEBUG(i >= 0 && i < 3); return (&x)[i]; }
vec3_t operator-() const { return vec3_t(-x, -y, -z); }
vec3_t& operator+=(vec3_t v) { x += v.x; y += v.y; z += v.z; return *this; }
vec3_t& operator-=(vec3_t v) { x -= v.x; y -= v.y; z -= v.z; return *this; }
vec3_t& operator*=(float_t s) { x *= s; y *= s; z *= s; return *this; }
vec3_t& operator/=(float_t s) { x /= s; y /= s; z /= s; return *this; }
vec3_t operator+(vec3_t v) const { return vec3_t(x + v.x, y + v.y, z + v.z); }
vec3_t operator-(vec3_t v) const { return vec3_t(x - v.x, y - v.y, z - v.z); }
vec3_t operator*(float_t s) const { return vec3_t(x * s, y * s, z * s); }
vec3_t operator/(float_t s) const { return vec3_t(x / s, y / s, z / s); }
// or length(), abs(), absolute_value()
float_t magnitude() const { return sqrt(magnitude_squared()); }
float_t magnitude_squared() const { return x * x + y * y + z * z; }
// unit_vec3_t& normlize() const { return *this * (1 / sqrt(x * x + y * y + z * z)); }
vec3_t normalize() const { return *this * (1 / sqrt(x * x + y * y + z * z)); }
bool is_unit() const { return is_equal(magnitude(), (float_t)1); }
float_t dot(vec3_t v) const { return x * v.x + y * v.y + z * v.z; }
vec3_t cross(vec3_t v) const
{
/*
| i j k |
| x y z |
| vx vy vz |
*/
return vec3_t(
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x);
}
operator color_t() { return { x, y, z }; }
public:
friend vec3_t operator*(float_t s, vec3_t v) { return vec3_t(v.x * s, v.y * s, v.z * s); }
friend float_t dot(vec3_t u, vec3_t v) { return u.dot(v); }
friend float_t abs_dot(vec3_t u, vec3_t v) { return std::abs(u.dot(v)); }
friend vec3_t cross(vec3_t u, vec3_t v) { return u.cross(v); }
friend vec3_t normalize(vec3_t v) { return v.normalize(); }
friend float_t cos(vec3_t u, vec3_t v) { return u.dot(v); }
friend float_t abs_cos(vec3_t u, vec3_t v) { return std::abs(u.dot(v)); }
friend vec3_t lerp(vec3_t u, vec3_t v, float_t t) { return u + t * (v - u); }
// per-component
friend vec3_t min(vec3_t a, vec3_t b)
{
return vec3_t(std::min(a.x, b.x), std::min(a.y, b.y), std::min(a.z, b.z));
}
// per-component
friend vec3_t max(vec3_t a, vec3_t b)
{
return vec3_t(std::max(a.x, b.x), std::max(a.y, b.y), std::max(a.z, b.z));
}
public:
// deubg
bool is_valid() const { return ::is_valid(x) && ::is_valid(y) && ::is_valid(z); }
bool is_zero() const { return (x == 0) && (y == 0) && (z == 0); }
bool has_negative() const { return (x < 0) || (y < 0) || (z < 0); }
bool small_than(vec3_t vec3) const { return (x < vec3.x) || (y < vec3.y) || (z < vec3.z); }
std::string to_string() const { return std::format("[{:.6f}, {:.6f}, {:.6f}]", x, y, z); }
friend std::ostream& operator<<(std::ostream& console, vec3_t vec3)
{
console << vec3.to_string();
return console;
}
};
/*
class unit_vector_t;
using direction_t = unit_vector_t;
using normal_t = unit_vector_t
*/
using point3_t = vec3_t; // object_point, world_point... we need a frame
using normal_t = vec3_t;
using unit_vec3_t = vec3_t;
using float3_t = vec3_t;
inline float_t distance(point3_t p1, point3_t p2)
{
return (p1 - p2).magnitude();
}
inline float_t distance_squared(point3_t p1, point3_t p2)
{
return (p1 - p2).magnitude_squared();
}
// TODO: confirm
/*
z(0, 0, 1)
|
| theta/
| /
| /
|/_ _ _ _ _ _ x(1, 0, 0)
/ \
/ phi\
/ \
/ \
y(0, 1, 0)
https://www.pbr-book.org/3ed-2018/Shapes/Spheres
*/
// unit direction vector -> spherical coordinate
inline radian_t spherical_theta(unit_vec3_t v)
{
return std::acos(std::clamp(v.z, (float_t)-1, (float_t)1));
}
inline radian_t spherical_phi(unit_vec3_t v)
{
float_t phi = std::atan2(v.y, v.x);
return (phi < 0) ? (phi + k_2pi) : phi;
}
// convert spherical coordinate (θ theta, φ phi) into direction vector (x, y, z)
inline vec3_t spherical_to_direction(float_t sin_theta, float_t cos_theta, float_t phi)
{
return vec3_t(
sin_theta * std::cos(phi),
sin_theta * std::sin(phi),
cos_theta);
}
// takes three basis vectors representing the x, y, and z axis and
// returns the appropriate direction vector with respect to the coordinate frame defined by them
inline vec3_t spherical_to_direction(
float_t sin_theta, float_t cos_theta, float_t phi,
vec3_t x, vec3_t y, vec3_t z)
{
return
sin_theta * std::cos(phi) * x +
sin_theta * std::sin(phi) * y +
cos_theta * z;
}
/* TODO
y z
| /
| /
| /
| /
o - - - - x
bounds3_t.max
3-------2
/| /|
4-------1 |
| | | |
| 7-----|-6
|/ |/
8-------5
bounds3_t.min
*/
class bounds3_t
{
public:
bounds3_t()
{
constexpr float_t min = std::numeric_limits<float_t>::lowest();
constexpr float_t max = std::numeric_limits<float_t>::max();
min_ = point3_t(max, max, max);
max_ = point3_t(min, min, min);
}
explicit bounds3_t(point3_t p) : min_(p), max_(p)
{
}
bounds3_t(point3_t p1, point3_t p2):
min_(std::min(p1.x, p2.x), std::min(p1.y, p2.y), std::min(p1.z, p2.z)),
max_(std::max(p1.x, p2.x), std::max(p1.y, p2.y), std::max(p1.z, p2.z))
{
}
public:
// union, merge
bounds3_t join(point3_t p) const
{
return bounds3_t(min(min_, p), max(max_, p));
}
bounds3_t join(const bounds3_t& b) const
{
return bounds3_t(min(min_, b.min_), max(max_, b.max_));
}
friend bounds3_t join(const bounds3_t& b, point3_t p) { return b.join(p); }
friend bounds3_t join(const bounds3_t& b1, const bounds3_t& b2) { return b1.join(b2); }
public:
bool contain(point3_t p) const
{
return
p.x >= min_.x && p.x <= max_.x &&
p.y >= min_.y && p.y <= max_.y &&
p.z >= min_.z && p.z <= max_.z;
}
public:
// return a sphere that hold this bounding box
void bounding_sphere(point3_t* center, float_t* radius_) const
{
*center = lerp(min_, max_, (float_t)0.5);
*radius_ = contain(*center) ? distance(*center, max_) : 0;
}
private:
point3_t min_, max_;
};
struct mat4_t
{
};
// https://github.com/SmallVCM/SmallVCM/blob/master/src/frame.hxx
class frame_t
{
public:
frame_t() = default;
frame_t(vec3_t s, vec3_t t, normal_t n) :
s_{ s.normalize() },
t_{ t.normalize() },
n_{ n.normalize() }
{
}
frame_t(normal_t n) :
n_{ n.normalize()}
{
set_from_z();
}
public:
// think if {s, t, n} is (1, 0, 0), (0, 1, 0), (0, 0, 1)
vec3_t to_local(vec3_t world_vec3) const
{
return vec3_t(
dot(s_, world_vec3),
dot(t_, world_vec3),
dot(n_, world_vec3));
}
vec3_t to_world(vec3_t local_vec3) const
{
return
s_ * local_vec3.x +
t_ * local_vec3.y +
n_ * local_vec3.z;
}
vec3_t binormal() const { return s_; }
vec3_t tangent() const { return t_; }
vec3_t normal() const { return n_; }
private:
void set_from_z()
{
vec3_t tmp_s = (std::abs(n_.x) > 0.99f) ? vec3_t(0, 1, 0) : vec3_t(1, 0, 0);
t_ = normalize(cross(n_, tmp_s));
s_ = normalize(cross(t_, n_));
}
private:
// world frame basic vector
vec3_t s_{ 1, 0, 0 }; // x
vec3_t t_{ 0, 1, 0 }; // y
normal_t n_{ 0, 0, 1 }; // z
};
class ray_t
{
public:
ray_t(point3_t origin, unit_vec3_t direction, const float_t distance = k_infinity) :
origin_{ origin },
direction_{ direction },
distance_{ distance }
{
// TODO: move to unit_vec3_t
// CHECK_DEBUG(direction_.is_unit(), "ray.direction {} magnitude {:.6f} not a unit vector",
// direction_.to_string(), direction_.magnitude());
}
point3_t origin() const { return origin_; }
unit_vec3_t direction() const { return direction_; }
float_t distance() const { return distance_; }
void set_distance(float_t distance) const { distance_ = distance; }
point3_t operator()(float_t t) const
{
CHECK_DEBUG(t >= 0);
return origin_ + t * direction_;
}
private:
point3_t origin_;
unit_vec3_t direction_; // confirm it is a unit vector
mutable float_t distance_; // distance from ray to intersection
};
class bsdf_t;
class material_t;
class area_light_t;
class surface_t;
using bsdf_uptr_t = std::unique_ptr<bsdf_t>;
// avoid self intersection
point3_t offset_ray_origin(point3_t position, normal_t normal, unit_vec3_t direction)
{
vec3_t offset = normal * 1e-2; // TODO: 1e-2
if (dot(normal, direction) < 0)
offset = -offset;
return position + offset;
}
/*
prev n light
---- ^ -----
^ | ^
\ | θ /
wo \ | / wi is unknown, sampling from bsdf or light
\ | /
\|/
-------
isect
*/
// surface intersection
class isect_t : public nocopyable_t
{
public:
isect_t() = default;
isect_t(point3_t position, normal_t normal, unit_vec3_t wo) :
position{ position },
normal{ normal },
wo{ wo }
{
}
public:
//void scattering();
const surface_t* surface() const { return surface_; }
const bsdf_t* bsdf() const { return bsdf_.get(); }
// prev <- isect, against ray's direction
color_t Le() const { return emission_; }
public:
ray_t spawn_ray(unit_vec3_t direction) const
{
return ray_t{ offset_ray_origin(position, normal, direction), direction };
}
ray_t spawn_ray_to(point3_t target) const
{
return spawn_ray(normalize(target - position));
}
ray_t spawn_ray_to(const isect_t& isect) const
{
return spawn_ray(normalize(isect.position - position));
}
public:
point3_t position{}; // world position of intersection
normal_t normal{};
unit_vec3_t wo{};
private:
const surface_t* surface_{};
bsdf_uptr_t bsdf_{};
color_t emission_{};
friend surface_t;
};
using light_isect_t = isect_t;
#pragma endregion
#pragma region sampling
// https://www.pbr-book.org/3ed-2018/Monte_Carlo_Integration/2D_Sampling_with_Multidimensional_Transformations
// https://github.com/mmp/pbrt-v3/blob/master/src/core/sampling.cpp
inline point2_t uniform_disk_sample(float2_t random)
{
float_t radius = std::sqrt(random[0]);
float_t theta = 2 * k_pi * random[1];
return radius * point2_t(std::cos(theta), std::sin(theta));
}
inline point2_t concentric_disk_sample(float2_t random)
{
// map uniform random numbers to $[-1,1]^2$
random = 2.f * random - vec2_t(1, 1);
// handle degeneracy at the origin
if (random.x == 0 && random.y == 0)
return point2_t(0, 0);
// apply concentric mapping to point
float_t radius{}, theta{};
if (std::abs(random.x) > std::abs(random.y))
{
radius = random.x;
theta = k_pi_over4 * (random.y / random.x);
}
else
{
radius = random.y;
theta = k_pi_over2 - k_pi_over4 * (random.x / random.y);
}
return radius * point2_t(std::cos(theta), std::sin(theta));
}
// cosine-weighted hemisphere sampling
inline vec3_t cosine_hemisphere_sample(float2_t random)
{
point2_t p = concentric_disk_sample(random);
float_t z = std::sqrt(std::max((float_t)0, 1 - p.x * p.x - p.y * p.y));
return vec3_t(p.x, p.y, z);
}
inline float_t cosine_hemisphere_pdf(float_t cos_theta) { return cos_theta * k_inv_pi; }
inline vec3_t uniform_hemisphere_sample(float2_t random)
{
float_t z = random[0]; // [0, 1)
float_t radius = std::sqrt(std::max((float_t)0, (float_t)1. - z * z));
float_t phi = 2 * k_pi * random[1];
return vec3_t(radius * std::cos(phi), radius * std::sin(phi), z);
}
inline float_t uniform_hemisphere_pdf() { return k_inv_2pi; }
inline vec3_t uniform_sphere_sample(float2_t random)
{
float_t z = 1 - 2 * random[0]; // (-1, 1)
float_t radius = std::sqrt(std::max((float_t)0, (float_t)1 - z * z));
float_t phi = 2 * k_pi * random[1];
return vec3_t(radius * std::cos(phi), radius * std::sin(phi), z);
}
inline float_t uniform_sphere_pdf() { return k_inv_4pi; }
/*
/ _
/ / O \
/ O O O (a sphere)
/ . \ O /
/ .
/ . theta
. _ _ _ _ _ _ _ _
*/
vec3_t uniform_cone_sample(float2_t random, float_t cos_theta_max)
{
float_t cos_theta = (1 - random[0]) + random[0] * cos_theta_max;
float_t sin_theta = std::sqrt((float_t)1 - cos_theta * cos_theta);
float_t phi = random[1] * 2 * k_pi;
return vec3_t(
std::cos(phi) * sin_theta,
std::sin(phi) * sin_theta,
cos_theta);
}
float_t uniform_cone_pdf(float_t cos_theta_max)
{
return 1 / (2 * k_pi * (1 - cos_theta_max));
}
point2_t uniform_triangle_sample(float2_t random)
{
float_t su0 = std::sqrt(random[0]);
return point2_t(1 - su0, random[1] * su0);
}
inline float_t balance_heuristic(int f_num, float_t f_pdf, int g_num, float_t g_pdf)
{
return (f_num * f_pdf) / (f_num * f_pdf + g_num * g_pdf);
}
inline float_t power_heuristic(int f_num, float_t f_pdf, int g_num, float_t g_pdf)
{
float_t f = f_num * f_pdf, g = g_num * g_pdf;
return (f * f) / (f * f + g * g);
}
#pragma endregion
#pragma region sampler
// random number generator
// https://github.com/SmallVCM/SmallVCM/blob/master/src/rng.hxx
class rng_t
{
public:
// TODO
rng_t(int seed = 1234) : rng_engine_(seed)
{
}
// [0, int_max]
int uniform_int()
{
return int_dist_(rng_engine_);
}
// [0, uint_max]
uint32_t uniform_uint()
{
return uint_dist_(rng_engine_);
}
// [0, 1)
float_t uniform_float()
{
return float_dist_(rng_engine_);
}
// [0, 1), [0, 1)
vec2_t uniform_float2()
{
return vec2_t(uniform_float(), uniform_float());
}
private:
std::mt19937_64 rng_engine_;
std::uniform_int_distribution<int> int_dist_;
std::uniform_int_distribution<uint32_t> uint_dist_;
std::uniform_real_distribution<float_t> float_dist_{ (float_t)0, (float_t)1 };
};
struct camera_sample_t
{
point2_t p_film{}; // sample point on film
// point2_t p_lens{};
};
class sampler_t
{
public:
virtual ~sampler_t() {}
sampler_t(int samples_per_pixel) :
samples_per_pixel_{ samples_per_pixel }
{
}
virtual std::unique_ptr<sampler_t> clone() = 0;
public:
virtual int ge_samples_per_pixel()
{
return samples_per_pixel_;
}
virtual void set_samples_per_pixel(int samples_per_pixel)
{
samples_per_pixel_ = samples_per_pixel;
}
public:
virtual void start_pixel()
{
current_sample_index_ = 0;
}
virtual bool next_sample()
{
current_sample_index_ += 1;
return current_sample_index_ < samples_per_pixel_;
}
public:
virtual float_t get_float() = 0;
virtual vec2_t get_float2() = 0;
virtual camera_sample_t get_camera_sample(point2_t p_film) = 0;
protected:
rng_t rng_{};
int samples_per_pixel_{};
int current_sample_index_{};
};
class debug_sampler_t : public sampler_t
{
public:
using sampler_t::sampler_t;
std::unique_ptr<sampler_t> clone() override
{
return std::make_unique<debug_sampler_t>(samples_per_pixel_);
}
public:
float_t get_float() override
{
return 0.5f;
}
vec2_t get_float2() override
{
return { 0.5f, 0.5f };
}
camera_sample_t get_camera_sample(point2_t p_film) override
{
return { p_film + vec2_t{0.5f, 0.5f} };
}
};
class random_sampler_t : public sampler_t
{
public:
using sampler_t::sampler_t;
std::unique_ptr<sampler_t> clone() override
{
return std::make_unique<random_sampler_t>(samples_per_pixel_);
}
public:
float_t get_float() override
{
return rng_.uniform_float();
}
vec2_t get_float2() override
{
return rng_.uniform_float2();
}
// TODO: coroutine
camera_sample_t get_camera_sample(point2_t p_film) override
{
return { p_film + rng_.uniform_float2() };
}
};
// TODO
class stratified_sampler_t : public sampler_t
{
public:
camera_sample_t get_camera_sample(point2_t p_film) override
{
return { p_film + rng_.uniform_float2() };
}
};
#pragma endregion
#pragma region shape
/*
z(0, 0, 1)
|
| theta/
| /
| /
|/_ _ _ _ _ _ x(1, 0, 0)
/ \
/ phi\
/ \
/ \
y(0, 1, 0)
https://www.pbr-book.org/3ed-2018/Shapes/Spheres
*/
class shape_t
{
public:
virtual ~shape_t() = default;