Panda3D

Loading...
Searching...
No Matches
cLerpNodePathInterval.I
Go to the documentation of this file.
1/**
2 * PANDA 3D SOFTWARE
3 * Copyright (c) Carnegie Mellon University. All rights reserved.
4 *
5 * All use of this software is subject to the terms of the revised BSD
6 * license. You should have received a copy of this license along
7 * with this source code in a file named "LICENSE."
8 *
9 * @file cLerpNodePathInterval.I
10 * @author drose
11 * @date 2002-08-27
12 */
13
14/**
15 * Returns the node being lerped.
16 */
17INLINE const NodePath &CLerpNodePathInterval::
18 get_node() const {
19 return _node;
20}
21
22/**
23 * Returns the "other" node, which the lerped node is being moved relative to.
24 * If this is an empty node path, the lerped node is being moved in its own
25 * coordinate system.
26 */
27INLINE const NodePath &CLerpNodePathInterval::
28 get_other() const {
29 return _other;
30}
31
32/**
33 * Indicates the initial position of the lerped node. This is meaningful only
34 * if set_end_pos() is also called. This parameter is optional; if
35 * unspecified, the value will be taken from the node's actual position at the
36 * time the lerp is performed.
37 */
38INLINE void CLerpNodePathInterval::
39 set_start_pos(const LVecBase3 &pos) {
40 nassertv(!pos.is_nan());
41 _start_pos = pos;
42 _flags |= F_start_pos;
43}
44
45/**
46 * Indicates that the position of the node should be lerped, and specifies the
47 * final position of the node. This should be called before
48 * priv_initialize(). If this is not called, the node's position will not be
49 * affected by the lerp.
50 */
51INLINE void CLerpNodePathInterval::
52 set_end_pos(const LVecBase3 &pos) {
53 nassertv(!pos.is_nan());
54 _end_pos = pos;
55 _flags |= F_end_pos;
56}
57
58/**
59 * Indicates the initial rotation of the lerped node. This is meaningful only
60 * if either set_end_hpr() or set_end_quat() is also called. This parameter
61 * is optional; if unspecified, the value will be taken from the node's actual
62 * rotation at the time the lerp is performed.
63 */
64INLINE void CLerpNodePathInterval::
65 set_start_hpr(const LVecBase3 &hpr) {
66 nassertv(!hpr.is_nan());
67 _start_hpr = hpr;
68 _flags = (_flags & ~(F_slerp_setup | F_start_quat)) | F_start_hpr;
69}
70
71/**
72 * Indicates that the rotation of the node should be lerped, and specifies the
73 * final rotation of the node. This should be called before
74 * priv_initialize().
75 *
76 * This replaces a previous call to set_end_quat(). If neither set_end_hpr()
77 * nor set_end_quat() is called, the node's rotation will not be affected by
78 * the lerp.
79 */
80INLINE void CLerpNodePathInterval::
81 set_end_hpr(const LVecBase3 &hpr) {
82 nassertv(!hpr.is_nan());
83 _end_hpr = hpr;
84 _flags = (_flags & ~F_end_quat) | F_end_hpr;
85}
86
87/**
88 * Indicates that the rotation of the node should be lerped, and specifies the
89 * final rotation of the node. This should be called before
90 * priv_initialize().
91 *
92 * This special function is overloaded to accept a quaternion, even though the
93 * function name is set_end_hpr(). The quaternion will be implicitly
94 * converted to a HPR trio, and the lerp will be performed in HPR space,
95 * componentwise.
96 */
97INLINE void CLerpNodePathInterval::
98 set_end_hpr(const LQuaternion &quat) {
99 nassertv(!quat.is_nan());
100 _end_hpr = quat.get_hpr();
101 _flags = (_flags & ~F_end_quat) | F_end_hpr;
102}
103
104/**
105 * Indicates the initial rotation of the lerped node. This is meaningful only
106 * if either set_end_quat() or set_end_hpr() is also called. This parameter
107 * is optional; if unspecified, the value will be taken from the node's actual
108 * rotation at the time the lerp is performed.
109 *
110 * The given quaternion needs to be normalized.
111 */
112INLINE void CLerpNodePathInterval::
113 set_start_quat(const LQuaternion &quat) {
114 nassertv(!quat.is_nan());
115 _start_quat = quat;
116 _flags = (_flags & ~(F_slerp_setup | F_start_hpr)) | F_start_quat;
117}
118
119/**
120 * Indicates that the rotation of the node should be lerped, and specifies the
121 * final rotation of the node. This should be called before
122 * priv_initialize().
123 *
124 * This replaces a previous call to set_end_hpr(). If neither set_end_quat()
125 * nor set_end_hpr() is called, the node's rotation will not be affected by
126 * the lerp.
127 *
128 * This special function is overloaded to accept a HPR trio, even though the
129 * function name is set_end_quat(). The HPR will be implicitly converted to a
130 * quaternion, and the lerp will be performed in quaternion space, as a
131 * spherical lerp.
132 */
133INLINE void CLerpNodePathInterval::
134 set_end_quat(const LVecBase3 &hpr) {
135 nassertv(!hpr.is_nan());
136 _end_quat.set_hpr(hpr);
137 _flags = (_flags & ~(F_slerp_setup | F_end_hpr)) | F_end_quat;
138}
139
140/**
141 * Indicates that the rotation of the node should be lerped, and specifies the
142 * final rotation of the node. This should be called before
143 * priv_initialize().
144 *
145 * This replaces a previous call to set_end_hpr(). If neither set_end_quat()
146 * nor set_end_hpr() is called, the node's rotation will not be affected by
147 * the lerp.
148 *
149 * The given quaternion needs to be normalized.
150 */
151INLINE void CLerpNodePathInterval::
152 set_end_quat(const LQuaternion &quat) {
153 nassertv(!quat.is_nan());
154 _end_quat = quat;
155 _flags = (_flags & ~(F_slerp_setup | F_end_hpr)) | F_end_quat;
156}
157
158/**
159 * Indicates the initial scale of the lerped node. This is meaningful only if
160 * set_end_scale() is also called. This parameter is optional; if
161 * unspecified, the value will be taken from the node's actual scale at the
162 * time the lerp is performed.
163 */
164INLINE void CLerpNodePathInterval::
165 set_start_scale(const LVecBase3 &scale) {
166 nassertv(!scale.is_nan());
167 _start_scale = scale;
168 _flags |= F_start_scale;
169}
170
171/**
172 * Indicates the initial scale of the lerped node. This is meaningful only if
173 * set_end_scale() is also called. This parameter is optional; if
174 * unspecified, the value will be taken from the node's actual scale at the
175 * time the lerp is performed.
176 */
177INLINE void CLerpNodePathInterval::
178 set_start_scale(PN_stdfloat scale) {
179 nassertv(!cnan(scale));
180 set_start_scale(LVecBase3(scale, scale, scale));
181}
182
183/**
184 * Indicates that the scale of the node should be lerped, and specifies the
185 * final scale of the node. This should be called before priv_initialize().
186 * If this is not called, the node's scale will not be affected by the lerp.
187 */
188INLINE void CLerpNodePathInterval::
189 set_end_scale(const LVecBase3 &scale) {
190 nassertv(!scale.is_nan());
191 _end_scale = scale;
192 _flags |= F_end_scale;
193}
194
195/**
196 * Indicates that the scale of the node should be lerped, and specifies the
197 * final scale of the node. This should be called before priv_initialize().
198 * If this is not called, the node's scale will not be affected by the lerp.
199 */
200INLINE void CLerpNodePathInterval::
201 set_end_scale(PN_stdfloat scale) {
202 nassertv(!cnan(scale));
203 set_end_scale(LVecBase3(scale, scale, scale));
204}
205
206/**
207 * Indicates the initial shear of the lerped node. This is meaningful only if
208 * set_end_shear() is also called. This parameter is optional; if
209 * unspecified, the value will be taken from the node's actual shear at the
210 * time the lerp is performed.
211 */
212INLINE void CLerpNodePathInterval::
213 set_start_shear(const LVecBase3 &shear) {
214 nassertv(!shear.is_nan());
215 _start_shear = shear;
216 _flags |= F_start_shear;
217}
218
219/**
220 * Indicates that the shear of the node should be lerped, and specifies the
221 * final shear of the node. This should be called before priv_initialize().
222 * If this is not called, the node's shear will not be affected by the lerp.
223 */
224INLINE void CLerpNodePathInterval::
225 set_end_shear(const LVecBase3 &shear) {
226 nassertv(!shear.is_nan());
227 _end_shear = shear;
228 _flags |= F_end_shear;
229}
230
231/**
232 * Indicates the initial color of the lerped node. This is meaningful only if
233 * set_end_color() is also called. This parameter is optional; if
234 * unspecified, the value will be taken from the node's actual color at the
235 * time the lerp is performed.
236 */
237INLINE void CLerpNodePathInterval::
238 set_start_color(const LVecBase4 &color) {
239 nassertv(!color.is_nan());
240 _start_color = color;
241 _flags |= F_start_color;
242}
243
244/**
245 * Indicates that the color of the node should be lerped, and specifies the
246 * final color of the node. This should be called before priv_initialize().
247 * If this is not called, the node's color will not be affected by the lerp.
248 */
249INLINE void CLerpNodePathInterval::
250 set_end_color(const LVecBase4 &color) {
251 nassertv(!color.is_nan());
252 _end_color = color;
253 _flags |= F_end_color;
254}
255
256/**
257 * Indicates the initial color scale of the lerped node. This is meaningful
258 * only if set_end_color_scale() is also called. This parameter is optional;
259 * if unspecified, the value will be taken from the node's actual color scale
260 * at the time the lerp is performed.
261 */
262INLINE void CLerpNodePathInterval::
263 set_start_color_scale(const LVecBase4 &color_scale) {
264 nassertv(!color_scale.is_nan());
265 _start_color_scale = color_scale;
266 _flags |= F_start_color_scale;
267}
268
269/**
270 * Indicates that the color scale of the node should be lerped, and specifies
271 * the final color scale of the node. This should be called before
272 * priv_initialize(). If this is not called, the node's color scale will not
273 * be affected by the lerp.
274 */
275INLINE void CLerpNodePathInterval::
276 set_end_color_scale(const LVecBase4 &color_scale) {
277 nassertv(!color_scale.is_nan());
278 _end_color_scale = color_scale;
279 _flags |= F_end_color_scale;
280}
281
282/**
283 * Indicates the texture stage that is adjusted by tex_offset, tex_rotate,
284 * and/or tex_scale. If this is not set, the default is the default texture
285 * stage.
286 */
287INLINE void CLerpNodePathInterval::
288 set_texture_stage(TextureStage *stage) {
289 _texture_stage = stage;
290}
291
292/**
293 * Indicates the initial UV offset of the lerped node. This is meaningful
294 * only if set_end_tex_offset() is also called. This parameter is optional;
295 * if unspecified, the value will be taken from the node's actual UV offset at
296 * the time the lerp is performed.
297 */
298INLINE void CLerpNodePathInterval::
299 set_start_tex_offset(const LVecBase2 &tex_offset) {
300 nassertv(!tex_offset.is_nan());
301 _start_tex_offset = tex_offset;
302 _flags |= F_start_tex_offset;
303}
304
305/**
306 * Indicates that the UV offset of the node should be lerped, and specifies
307 * the final UV offset of the node. This should be called before
308 * priv_initialize(). If this is not called, the node's UV offset will not be
309 * affected by the lerp.
310 */
311INLINE void CLerpNodePathInterval::
312 set_end_tex_offset(const LVecBase2 &tex_offset) {
313 nassertv(!tex_offset.is_nan());
314 _end_tex_offset = tex_offset;
315 _flags |= F_end_tex_offset;
316}
317
318/**
319 * Indicates the initial UV rotate of the lerped node. This is meaningful
320 * only if set_end_tex_rotate() is also called. This parameter is optional;
321 * if unspecified, the value will be taken from the node's actual UV rotate at
322 * the time the lerp is performed.
323 */
324INLINE void CLerpNodePathInterval::
325 set_start_tex_rotate(PN_stdfloat tex_rotate) {
326 nassertv(!cnan(tex_rotate));
327 _start_tex_rotate = tex_rotate;
328 _flags |= F_start_tex_rotate;
329}
330
331/**
332 * Indicates that the UV rotate of the node should be lerped, and specifies
333 * the final UV rotate of the node. This should be called before
334 * priv_initialize(). If this is not called, the node's UV rotate will not be
335 * affected by the lerp.
336 */
337INLINE void CLerpNodePathInterval::
338 set_end_tex_rotate(PN_stdfloat tex_rotate) {
339 nassertv(!cnan(tex_rotate));
340 _end_tex_rotate = tex_rotate;
341 _flags |= F_end_tex_rotate;
342}
343
344/**
345 * Indicates the initial UV scale of the lerped node. This is meaningful only
346 * if set_end_tex_scale() is also called. This parameter is optional; if
347 * unspecified, the value will be taken from the node's actual UV scale at the
348 * time the lerp is performed.
349 */
350INLINE void CLerpNodePathInterval::
351 set_start_tex_scale(const LVecBase2 &tex_scale) {
352 nassertv(!tex_scale.is_nan());
353 _start_tex_scale = tex_scale;
354 _flags |= F_start_tex_scale;
355}
356
357/**
358 * Indicates that the UV scale of the node should be lerped, and specifies the
359 * final UV scale of the node. This should be called before
360 * priv_initialize(). If this is not called, the node's UV scale will not be
361 * affected by the lerp.
362 */
363INLINE void CLerpNodePathInterval::
364 set_end_tex_scale(const LVecBase2 &tex_scale) {
365 nassertv(!tex_scale.is_nan());
366 _end_tex_scale = tex_scale;
367 _flags |= F_end_tex_scale;
368}
369
370/**
371 * Changes the override value that will be associated with any state changes
372 * applied by the lerp. If this lerp is changing state (for instance, a color
373 * lerp or a tex matrix lerp), then the new attributes created by this lerp
374 * will be assigned the indicated override value when they are applied to the
375 * node.
376 */
377INLINE void CLerpNodePathInterval::
378 set_override(int override) {
379 _override = override;
380}
381
382/**
383 * Returns the override value that will be associated with any state changes
384 * applied by the lerp. See set_override().
385 */
386INLINE int CLerpNodePathInterval::
387 get_override() const {
388 return _override;
389}
CLerpNodePathInterval::set_start_scale
void set_start_scale(const LVecBase3 &scale)
Indicates the initial scale of the lerped node.
Definition cLerpNodePathInterval.I:165
CLerpNodePathInterval::set_start_color_scale
void set_start_color_scale(const LVecBase4 &color_scale)
Indicates the initial color scale of the lerped node.
Definition cLerpNodePathInterval.I:263
CLerpNodePathInterval::set_start_hpr
void set_start_hpr(const LVecBase3 &hpr)
Indicates the initial rotation of the lerped node.
Definition cLerpNodePathInterval.I:65
CLerpNodePathInterval::set_end_quat
void set_end_quat(const LVecBase3 &hpr)
Indicates that the rotation of the node should be lerped, and specifies the final rotation of the nod...
Definition cLerpNodePathInterval.I:134
CLerpNodePathInterval::get_node
const NodePath & get_node() const
Returns the node being lerped.
Definition cLerpNodePathInterval.I:18
CLerpNodePathInterval::get_override
int get_override() const
Returns the override value that will be associated with any state changes applied by the lerp.
Definition cLerpNodePathInterval.I:387
CLerpNodePathInterval::set_start_color
void set_start_color(const LVecBase4 &color)
Indicates the initial color of the lerped node.
Definition cLerpNodePathInterval.I:238
CLerpNodePathInterval::set_end_pos
void set_end_pos(const LVecBase3 &pos)
Indicates that the position of the node should be lerped, and specifies the final position of the nod...
Definition cLerpNodePathInterval.I:52
CLerpNodePathInterval::set_start_tex_offset
void set_start_tex_offset(const LVecBase2 &tex_offset)
Indicates the initial UV offset of the lerped node.
Definition cLerpNodePathInterval.I:299
CLerpNodePathInterval::set_start_tex_scale
void set_start_tex_scale(const LVecBase2 &tex_scale)
Indicates the initial UV scale of the lerped node.
Definition cLerpNodePathInterval.I:351
CLerpNodePathInterval::set_end_tex_offset
void set_end_tex_offset(const LVecBase2 &tex_offset)
Indicates that the UV offset of the node should be lerped, and specifies the final UV offset of the n...
Definition cLerpNodePathInterval.I:312
CLerpNodePathInterval::set_override
void set_override(int override)
Changes the override value that will be associated with any state changes applied by the lerp.
Definition cLerpNodePathInterval.I:378
CLerpNodePathInterval::set_end_scale
void set_end_scale(const LVecBase3 &scale)
Indicates that the scale of the node should be lerped, and specifies the final scale of the node.
Definition cLerpNodePathInterval.I:189
CLerpNodePathInterval::set_start_quat
void set_start_quat(const LQuaternion &quat)
Indicates the initial rotation of the lerped node.
Definition cLerpNodePathInterval.I:113
CLerpNodePathInterval::set_start_tex_rotate
void set_start_tex_rotate(PN_stdfloat tex_rotate)
Indicates the initial UV rotate of the lerped node.
Definition cLerpNodePathInterval.I:325
CLerpNodePathInterval::set_texture_stage
void set_texture_stage(TextureStage *stage)
Indicates the texture stage that is adjusted by tex_offset, tex_rotate, and/or tex_scale.
Definition cLerpNodePathInterval.I:288
CLerpNodePathInterval::get_other
const NodePath & get_other() const
Returns the "other" node, which the lerped node is being moved relative to.
Definition cLerpNodePathInterval.I:28
CLerpNodePathInterval::set_end_shear
void set_end_shear(const LVecBase3 &shear)
Indicates that the shear of the node should be lerped, and specifies the final shear of the node.
Definition cLerpNodePathInterval.I:225
CLerpNodePathInterval::set_start_pos
void set_start_pos(const LVecBase3 &pos)
Indicates the initial position of the lerped node.
Definition cLerpNodePathInterval.I:39
CLerpNodePathInterval::set_end_tex_scale
void set_end_tex_scale(const LVecBase2 &tex_scale)
Indicates that the UV scale of the node should be lerped, and specifies the final UV scale of the nod...
Definition cLerpNodePathInterval.I:364
CLerpNodePathInterval::set_end_tex_rotate
void set_end_tex_rotate(PN_stdfloat tex_rotate)
Indicates that the UV rotate of the node should be lerped, and specifies the final UV rotate of the n...
Definition cLerpNodePathInterval.I:338
CLerpNodePathInterval::set_end_color_scale
void set_end_color_scale(const LVecBase4 &color_scale)
Indicates that the color scale of the node should be lerped, and specifies the final color scale of t...
Definition cLerpNodePathInterval.I:276
CLerpNodePathInterval::set_start_shear
void set_start_shear(const LVecBase3 &shear)
Indicates the initial shear of the lerped node.
Definition cLerpNodePathInterval.I:213
CLerpNodePathInterval::set_end_hpr
void set_end_hpr(const LVecBase3 &hpr)
Indicates that the rotation of the node should be lerped, and specifies the final rotation of the nod...
Definition cLerpNodePathInterval.I:81
CLerpNodePathInterval::set_end_color
void set_end_color(const LVecBase4 &color)
Indicates that the color of the node should be lerped, and specifies the final color of the node.
Definition cLerpNodePathInterval.I:250
NodePath
NodePath is the fundamental system for disambiguating instances, and also provides a higher-level int...
Definition nodePath.h:159
TextureStage
Defines the properties of a named stage of the multitexture pipeline.
Definition textureStage.h:35