Initial revision
[blender.git] / intern / SoundSystem / intern / SND_SoundObject.cpp
1 /*
2  * SND_SoundObject.cpp
3  *
4  * Implementation of the abstract sound object
5  *
6  * $Id$
7  *
8  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version 2
13  * of the License, or (at your option) any later version. The Blender
14  * Foundation also sells licenses for use in proprietary software under
15  * the Blender License.  See http://www.blender.org/BL/ for information
16  * about this.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software Foundation,
25  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
26  *
27  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
28  * All rights reserved.
29  *
30  * The Original Code is: all of this file.
31  *
32  * Contributor(s): none yet.
33  *
34  * ***** END GPL/BL DUAL LICENSE BLOCK *****
35  */
36
37 #include "SND_SoundObject.h"
38
39
40
41 SND_SoundObject::SND_SoundObject()// : m_modified(true)
42 {
43         m_samplename = "";
44         m_length = 0;
45         m_buffer = 0;
46
47         m_gain = 0.0;
48         m_pitch = 1.0;
49
50         m_mingain = 0.0;
51         m_maxgain = 1.0;
52         m_rollofffactor = 1.0;
53         m_referencedistance = 1.0;
54         
55         m_position[0] = 0.0;
56         m_position[1] = 0.0;
57         m_position[2] = 0.0;
58         m_velocity[0] = 0.0;
59         m_velocity[1] = 0.0;
60         m_velocity[2] = 0.0;
61         m_orientation[0][0] = 1.0;
62         m_orientation[0][1] = 0.0;
63         m_orientation[0][2] = 0.0;
64         m_orientation[1][0] = 0.0;
65         m_orientation[1][1] = 1.0;
66         m_orientation[1][2] = 0.0;
67         m_orientation[2][0] = 0.0;
68         m_orientation[2][1] = 0.0;
69         m_orientation[2][2] = 1.0;
70         
71         m_loopstart = 0;
72         m_loopend = 0;
73         m_loopmode = SND_LOOP_NORMAL;
74         m_is3d = true;
75         m_playstate = SND_INITIAL;
76         m_active = false;
77         m_id = -1;
78         m_lifespan = 0;
79         m_timestamp = 0;
80         m_modified = true;
81         m_running = 0;
82         m_highpriority = false;
83 }
84
85
86
87 SND_SoundObject::~SND_SoundObject()
88 {
89 }
90
91
92
93 void SND_SoundObject::StartSound()
94 {
95         m_playstate = SND_MUST_PLAY;
96 }
97
98
99
100 void SND_SoundObject::StopSound()
101 {
102         m_playstate = SND_MUST_STOP;
103 }
104
105
106
107 void SND_SoundObject::PauseSound()
108 {
109         m_playstate = SND_MUST_PAUSE;
110 }
111
112
113
114 void SND_SoundObject::DeleteWhenFinished()
115 {
116         m_playstate = SND_MUST_BE_DELETED;
117 }
118
119
120
121 void SND_SoundObject::SetGain(MT_Scalar gain)
122 {
123         m_gain = gain;
124         m_modified = true;
125 }
126
127
128
129 void SND_SoundObject::SetMinGain(MT_Scalar mingain)
130 {
131         m_mingain = mingain;
132         m_modified = true;
133 }
134
135
136
137 void SND_SoundObject::SetMaxGain(MT_Scalar maxgain)
138 {
139         m_maxgain = maxgain;
140         m_modified = true;
141 }
142
143
144
145 void SND_SoundObject::SetRollOffFactor(MT_Scalar rollofffactor)
146 {
147         m_rollofffactor = rollofffactor;
148         m_modified = true;
149 }
150
151
152
153 void SND_SoundObject::SetReferenceDistance(MT_Scalar referencedistance)
154 {
155         m_referencedistance = referencedistance;
156         m_modified = true;
157 }
158
159
160
161 void SND_SoundObject::SetPitch(MT_Scalar pitch)
162 {
163         m_pitch = pitch;
164         m_modified = true;
165 }
166
167
168
169 void SND_SoundObject::SetLoopMode(unsigned int loopmode)
170 {
171         m_loopmode = loopmode;
172         m_modified = true;
173 }
174
175
176
177 void SND_SoundObject::SetLoopStart(unsigned int loopstart)
178 {
179         m_loopstart = loopstart;
180         m_modified = true;
181 }
182
183
184
185 void SND_SoundObject::SetLoopEnd(unsigned int loopend)
186 {
187         m_loopend = loopend;
188         m_modified = true;
189 }
190
191
192
193 void SND_SoundObject::Set3D(bool threedee)
194 {
195         m_is3d = threedee;
196 }
197
198
199
200 void SND_SoundObject::SetLifeSpan()
201 {
202         m_lifespan = m_length / m_pitch;
203 }
204
205
206
207 bool SND_SoundObject::IsLifeSpanOver(MT_Scalar curtime) const
208 {
209         bool result = false;
210
211         if ((curtime - m_timestamp) > m_lifespan)
212                 result = true;
213
214         return result;
215 }
216
217
218
219 void SND_SoundObject::SetActive(bool active)
220 {
221         m_active = active;
222
223         if (!active)
224         {
225                 m_playstate = SND_STOPPED;
226                 (this)->remove();
227         }
228 }
229
230
231
232 void SND_SoundObject::SetBuffer(unsigned int buffer)
233 {
234         m_buffer = buffer;
235 }
236
237
238
239 void SND_SoundObject::SetObjectName(STR_String objectname)
240 {
241         m_objectname = objectname;
242 }
243
244
245
246 void SND_SoundObject::SetSampleName(STR_String samplename)
247 {
248         m_samplename = samplename;
249 }
250
251
252
253 void SND_SoundObject::SetLength(MT_Scalar length)
254 {
255         m_length = length;
256 }
257
258
259
260 void SND_SoundObject::SetPosition(const MT_Vector3& pos)
261 {
262         m_position = pos;
263 }
264
265
266
267 void SND_SoundObject::SetVelocity(const MT_Vector3& vel)
268 {
269         m_velocity = vel;
270 }
271
272
273
274 void SND_SoundObject::SetOrientation(const MT_Matrix3x3& orient)
275 {
276         m_orientation = orient;
277 }
278
279
280
281 void SND_SoundObject::SetPlaystate(int playstate)
282 {
283         m_playstate = playstate;
284 }
285
286
287
288 void SND_SoundObject::SetId(int id)
289 {
290         m_id = id;
291 }
292
293
294
295 void SND_SoundObject::SetTimeStamp(MT_Scalar timestamp)
296 {
297         m_timestamp = timestamp;
298 }
299
300
301
302 void SND_SoundObject::SetHighPriority(bool priority)
303 {
304         m_highpriority = priority;
305 }
306
307
308
309 bool SND_SoundObject::IsHighPriority() const
310 {
311         return m_highpriority;
312 }
313
314
315
316 bool SND_SoundObject::IsActive()const
317 {
318         return m_active;
319 }
320
321
322
323 int SND_SoundObject::GetId()const
324 {
325         return m_id;
326 }
327
328
329
330 MT_Scalar SND_SoundObject::GetLifeSpan()const
331 {
332         return m_lifespan;
333 }
334
335
336
337 MT_Scalar SND_SoundObject::GetTimestamp()const
338 {
339         return m_timestamp;
340 }
341
342
343
344 unsigned int SND_SoundObject::GetBuffer()
345 {
346         return m_buffer;
347 }
348
349
350
351 const STR_String& SND_SoundObject::GetSampleName()
352 {
353         return m_samplename; 
354 }
355
356
357
358 const STR_String& SND_SoundObject::GetObjectName()
359 {
360         return m_objectname;
361 }
362
363
364
365 MT_Scalar SND_SoundObject::GetLength() const
366 {
367         return m_length;
368 }
369
370
371
372 MT_Scalar SND_SoundObject::GetGain() const
373 {
374         return m_gain;
375 }
376
377
378
379 MT_Scalar SND_SoundObject::GetPitch() const
380 {
381         return m_pitch;
382 }
383
384
385
386 MT_Scalar SND_SoundObject::GetMinGain() const
387 {
388         return m_mingain;
389 }
390
391
392
393 MT_Scalar SND_SoundObject::GetMaxGain() const
394 {
395         return m_maxgain;
396 }
397
398
399
400 MT_Scalar SND_SoundObject::GetRollOffFactor() const
401 {
402         return m_rollofffactor;
403 }
404
405
406
407 MT_Scalar SND_SoundObject::GetReferenceDistance() const
408 {
409         return m_referencedistance;
410 }
411
412
413
414 MT_Vector3 SND_SoundObject::GetPosition() const
415 {
416         return m_position;
417 }
418
419
420
421 MT_Vector3 SND_SoundObject::GetVelocity() const
422 {
423         return m_velocity;
424 }
425
426
427
428 MT_Matrix3x3 SND_SoundObject::GetOrientation() const
429 {
430         return m_orientation;
431 }
432
433
434
435 unsigned int SND_SoundObject::GetLoopMode() const
436 {
437         return m_loopmode;
438 }
439
440
441
442 unsigned int SND_SoundObject::GetLoopStart() const
443 {
444         return m_loopstart;
445 }
446
447
448
449 unsigned int SND_SoundObject::GetLoopEnd() const
450 {
451         return m_loopend;
452 }
453
454
455
456 bool SND_SoundObject::Is3D() const
457 {
458         return m_is3d;
459 }
460
461
462
463 int SND_SoundObject::GetPlaystate() const
464 {
465         return m_playstate;
466 }
467
468
469
470 bool SND_SoundObject::IsModified() const
471 {
472         return m_modified;
473 }
474
475
476
477 void SND_SoundObject::SetModified(bool modified)
478 {
479         m_modified = modified;
480 }
481
482
483
484 void SND_SoundObject::InitRunning()
485 {
486         m_running = 0;
487 }
488
489
490
491 bool SND_SoundObject::IsRunning() const
492 {
493         bool result = false;
494
495         if (m_running > 100)
496                 result = true;
497
498         return result;
499 }
500
501
502
503 void SND_SoundObject::AddRunning()
504 {
505         ++m_running;
506 }