8a5c538c09425178093043deea52d5d9a2ef8d74
[blender.git] / intern / audaspace / intern / AUD_AnimateableProperty.cpp
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * Copyright 2009-2011 Jörg Hermann Müller
5  *
6  * This file is part of AudaSpace.
7  *
8  * Audaspace is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * AudaSpace is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with Audaspace; if not, write to the Free Software Foundation,
20  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21  *
22  * ***** END GPL LICENSE BLOCK *****
23  */
24
25 /** \file audaspace/intern/AUD_AnimateableProperty.cpp
26  *  \ingroup audaspaceintern
27  */
28
29
30 #include "AUD_AnimateableProperty.h"
31
32 #include <cstring>
33 #include <cmath>
34
35 AUD_AnimateableProperty::AUD_AnimateableProperty(int count) :
36         AUD_Buffer(count * sizeof(float)), m_count(count), m_isAnimated(false)
37 {
38         memset(getBuffer(), 0, count * sizeof(float));
39
40         pthread_mutexattr_t attr;
41         pthread_mutexattr_init(&attr);
42         pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
43
44         pthread_mutex_init(&m_mutex, &attr);
45
46         pthread_mutexattr_destroy(&attr);
47 }
48
49 AUD_AnimateableProperty::~AUD_AnimateableProperty()
50 {
51         pthread_mutex_destroy(&m_mutex);
52 }
53
54 void AUD_AnimateableProperty::lock()
55 {
56         pthread_mutex_lock(&m_mutex);
57 }
58
59 void AUD_AnimateableProperty::unlock()
60 {
61         pthread_mutex_unlock(&m_mutex);
62 }
63
64 void AUD_AnimateableProperty::write(const float* data)
65 {
66         lock();
67
68         m_isAnimated = false;
69         memcpy(getBuffer(), data, m_count * sizeof(float));
70
71         unlock();
72 }
73
74 void AUD_AnimateableProperty::write(const float* data, int position, int count)
75 {
76         lock();
77
78         m_isAnimated = true;
79
80         int pos = getSize() / (sizeof(float) * m_count);
81
82         assureSize((count + position) * m_count * sizeof(float), true);
83
84         float* buf = getBuffer();
85
86         memcpy(buf + position * m_count, data, count * m_count * sizeof(float));
87
88         for(int i = pos; i < position; i++)
89                 memcpy(buf + i * m_count, buf + (pos - 1) * m_count, m_count * sizeof(float));
90
91         unlock();
92 }
93
94 void AUD_AnimateableProperty::read(float position, float* out)
95 {
96         lock();
97
98         if(!m_isAnimated)
99         {
100                 memcpy(out, getBuffer(), m_count * sizeof(float));
101                 unlock();
102                 return;
103         }
104
105         int last = getSize() / (sizeof(float) * m_count) - 1;
106         float t = position - floor(position);
107
108         if(position >= last)
109         {
110                 position = last;
111                 t = 0;
112         }
113
114         if(t == 0)
115         {
116                 memcpy(out, getBuffer() + int(floor(position)) * m_count, m_count * sizeof(float));
117         }
118         else
119         {
120                 int pos = int(floor(position)) * m_count;
121                 float t2 = t * t;
122                 float t3 = t2 * t;
123                 float m0, m1;
124                 float* p0;
125                 float* p1 = getBuffer() + pos;
126                 float* p2;
127                 float* p3;
128                 last *= m_count;
129
130                 if(pos == 0)
131                         p0 = p1;
132                 else
133                         p0 = p1 - m_count;
134
135                 p2 = p1 + m_count;
136                 if(pos + m_count == last)
137                         p3 = p2;
138                 else
139                         p3 = p2 + m_count;
140
141                 for(int i = 0; i < m_count; i++)
142                 {
143                         m0 = (p2[i] - p0[i]) / 2.0f;
144                         m1 = (p3[i] - p1[i]) / 2.0f;
145
146                         out[i] = (2 * t3 - 3 * t2 + 1) * p0[i] + (-2 * t3 + 3 * t2) * p1[i] +
147                                          (t3 - 2 * t2 + t) * m0 + (t3 - t2) * m1;
148                 }
149         }
150
151         unlock();
152 }
153
154 bool AUD_AnimateableProperty::isAnimated() const
155 {
156         return m_isAnimated;
157 }