erebus

view liberebus/src/camera.cc @ 35:4901cf062c70

find changesets by author, revision, files, or words in the commit message
added COPYING and augmented the README file
author John Tsiombikas <nuclear@member.fsf.org>
date Mon, 09 Jun 2014 07:24:22 +0300
parents e2d9bf168a41
children c4d48a21bc4a
line source
1 #include <stdio.h>
2 #include <math.h>
3 #include "camera.h"
4
5 #define DEFAULT_FOV DEG_TO_RAD(50)
6
7 static void calc_sample_pos_rec(int sidx, float xsz, float ysz, float *pos);
8
9 Camera::Camera()
10 {
11 vfov = DEFAULT_FOV;
12 cached_matrix_valid = false;
13 }
14
15 Camera::Camera(const Vector3 &p)
16 : pos(p)
17 {
18 vfov = DEFAULT_FOV;
19 cached_matrix_valid = false;
20 }
21
22 Camera::~Camera()
23 {
24 }
25
26 void Camera::set_fov(float vfov)
27 {
28 this->vfov = vfov;
29 }
30
31 float Camera::get_fov() const
32 {
33 return vfov;
34 }
35
36 void Camera::set_position(const Vector3 &pos)
37 {
38 this->pos = pos;
39 cached_matrix_valid = false; // invalidate the cached matrix
40 }
41
42 const Vector3 &Camera::get_position() const
43 {
44 return pos;
45 }
46
47 const Matrix4x4 &Camera::get_matrix() const
48 {
49 if(!cached_matrix_valid) {
50 calc_matrix(&cached_matrix);
51 cached_matrix_valid = true;
52 }
53 return cached_matrix;
54 }
55
56 Vector2 Camera::calc_sample_pos(int x, int y, int xsz, int ysz, int sample) const
57 {
58 float ppos[2];
59 float aspect = (float)xsz / (float)ysz;
60
61 float pwidth = 2.0 * aspect / (float)xsz;
62 float pheight = 2.0 / (float)ysz;
63
64 ppos[0] = (float)x * pwidth - aspect;
65 ppos[1] = 1.0 - (float)y * pheight;
66
67 calc_sample_pos_rec(sample, pwidth, pheight, ppos);
68 return Vector2(ppos[0], ppos[1]);
69 }
70
71 Ray Camera::get_primary_ray(int x, int y, int xsz, int ysz, int sample) const
72 {
73 Vector2 ppos = calc_sample_pos(x, y, xsz, ysz, sample);
74
75 Ray ray;
76 ray.origin = pos;
77 ray.dir.x = ppos.x;
78 ray.dir.y = ppos.y;
79 ray.dir.z = 1.0 / tan(vfov / 2.0);
80 ray.dir.normalize();
81
82 // transform the ray direction with the camera matrix
83 Matrix4x4 mat = get_matrix();
84 mat.m[0][3] = mat.m[1][3] = mat.m[2][3] = mat.m[3][0] = mat.m[3][1] = mat.m[3][2] = 0.0;
85 mat.m[3][3] = 1.0;
86
87 ray.dir = ray.dir.transformed(mat);
88 return ray;
89 }
90
91 TargetCamera::TargetCamera() {}
92
93 TargetCamera::TargetCamera(const Vector3 &pos, const Vector3 &targ)
94 : Camera(pos), target(targ)
95 {
96 }
97
98 void TargetCamera::set_target(const Vector3 &targ)
99 {
100 target = targ;
101 cached_matrix_valid = false; // invalidate the cached matrix
102 }
103
104 const Vector3 &TargetCamera::get_target() const
105 {
106 return target;
107 }
108
109 void TargetCamera::calc_matrix(Matrix4x4 *mat) const
110 {
111 Vector3 up{0, 1, 0};
112 Vector3 dir = (target - pos).normalized();
113
114 if(1.0 - fabs(dot_product(dir, up)) < 1e-4) {
115 up = Vector3(0, 0, 1);
116 }
117
118 Vector3 right = cross_product(up, dir).normalized();
119 up = cross_product(dir, right);
120
121 *mat = Matrix4x4(
122 right.x, up.x, dir.x, pos.x,
123 right.y, up.y, dir.y, pos.y,
124 right.z, up.z, dir.z, pos.z,
125 0.0, 0.0, 0.0, 1.0);
126 }
127
128 void FlyCamera::input_move(float x, float y, float z)
129 {
130 static const Vector3 vfwd(0, 0, 1), vright(1, 0, 0);
131
132 Vector3 k = vfwd.transformed(rot);
133 Vector3 i = vright.transformed(rot);
134 Vector3 j = cross_product(k, i);
135
136 pos += i * x + j * y + k * z;
137 cached_matrix_valid = false;
138 }
139
140 void FlyCamera::input_rotate(float x, float y, float z)
141 {
142 Vector3 axis(x, y, z);
143 float axis_len = axis.length();
144 if(fabs(axis_len) < 1e-5) {
145 return;
146 }
147 rot.rotate(axis / axis_len, -axis_len);
148 rot.normalize();
149
150 cached_matrix_valid = false;
151 }
152
153 void FlyCamera::calc_matrix(Matrix4x4 *mat) const
154 {
155 Matrix4x4 tmat;
156 tmat.set_translation(pos);
157
158 Matrix3x3 rmat = rot.get_rotation_matrix();
159
160 *mat = tmat * Matrix4x4(rmat);
161 }
162
163 /* generates a sample position for sample number sidx, in the unit square
164 * by recursive subdivision and jittering
165 */
166 static void calc_sample_pos_rec(int sidx, float xsz, float ysz, float *pos)
167 {
168 static const float subpt[4][2] = {
169 {-0.25, -0.25}, {0.25, -0.25}, {-0.25, 0.25}, {0.25, 0.25}
170 };
171
172 if(!sidx) {
173 return;
174 }
175
176 /* determine which quadrant to recurse into */
177 int quadrant = ((sidx - 1) % 4);
178 pos[0] += subpt[quadrant][0] * xsz;
179 pos[1] += subpt[quadrant][1] * ysz;
180
181 calc_sample_pos_rec((sidx - 1) / 4, xsz / 2, ysz / 2, pos);
182 }