← Back to branch summary

~ubuntu-branches/ubuntu/trusty/blender/trusty

« back to all changes in this revision

Viewing changes to source/gameengine/Expressions/FloatValue.cpp

  • Committer: Package Import Robot
  • Author(s): Jeremy Bicha
  • Date: 2013-03-06 12:08:47 UTC
  • mfrom: (1.5.1) (14.1.8 experimental)
  • Revision ID: package-import@ubuntu.com-20130306120847-frjfaryb2zrotwcg
Tags: 2.66a-1ubuntu1
https://launchpad.net/bugs/1076930
https://launchpad.net/bugs/1089256
https://launchpad.net/bugs/1052743
https://launchpad.net/bugs/999024
* Resynchronize with Debian (LP: #1076930, #1089256, #1052743, #999024,
  #1122888, #1147084)
* debian/control:
  - Lower build-depends on libavcodec-dev since we're not
    doing the libav9 transition in Ubuntu yet

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/gameengine/Expressions/FloatValue.cpp
120
120
{
121
121
        CValue *ret;
122
122
        
123
 
        switch(dtype)
124
 
        {
125
 
        case VALUE_INT_TYPE:
126
 
                {
127
 
                        switch (op)
128
 
                        {
129
 
                        case VALUE_MOD_OPERATOR:
130
 
                                ret = new CFloatValue(fmod(((CIntValue *) val)->GetInt(), m_float));
131
 
                                break;
132
 
                        case VALUE_ADD_OPERATOR:
133
 
                                ret = new CFloatValue(((CIntValue *) val)->GetInt() + m_float);
134
 
                                break;
135
 
                        case VALUE_SUB_OPERATOR:
136
 
                                ret = new CFloatValue(((CIntValue *) val)->GetInt() - m_float);
137
 
                                break;
138
 
                        case VALUE_MUL_OPERATOR:
139
 
                                ret = new CFloatValue(((CIntValue *) val)->GetInt() * m_float);
140
 
                                break;
141
 
                        case VALUE_DIV_OPERATOR:
142
 
                                if (m_float == 0)
143
 
                                        ret = new CErrorValue("Division by zero");
144
 
                                else
145
 
                                        ret = new CFloatValue (((CIntValue *) val)->GetInt() / m_float);
146
 
                                break;
147
 
                        case VALUE_EQL_OPERATOR:
148
 
                                ret = new CBoolValue(((CIntValue *) val)->GetInt() == m_float);
149
 
                                break;
150
 
                        case VALUE_NEQ_OPERATOR:
151
 
                                ret = new CBoolValue(((CIntValue *) val)->GetInt() != m_float);
152
 
                                break;
153
 
                        case VALUE_GRE_OPERATOR:
154
 
                                ret = new CBoolValue(((CIntValue *) val)->GetInt() > m_float);
155
 
                                break;
156
 
                        case VALUE_LES_OPERATOR:
157
 
                                ret = new CBoolValue(((CIntValue *) val)->GetInt() < m_float);
158
 
                                break;
159
 
                        case VALUE_GEQ_OPERATOR:
160
 
                                ret = new CBoolValue(((CIntValue *) val)->GetInt() >= m_float);
161
 
                                break;
162
 
                        case VALUE_LEQ_OPERATOR:
163
 
                                ret = new CBoolValue(((CIntValue *) val)->GetInt() <= m_float);
164
 
                                break;
165
 
                        default:
166
 
                                ret = new CErrorValue("illegal operator. please send a bug report.");
167
 
                                break;
168
 
                        }
169
 
                        break;
170
 
                }
171
 
        case VALUE_EMPTY_TYPE:
172
 
        case VALUE_FLOAT_TYPE:
173
 
                {
174
 
                        switch (op)
175
 
                        {
176
 
                        case VALUE_MOD_OPERATOR:
177
 
                                ret = new CFloatValue(fmod(((CFloatValue *) val)->GetFloat(), m_float));
178
 
                                break;
179
 
                        case VALUE_ADD_OPERATOR:
180
 
                                ret = new CFloatValue(((CFloatValue *) val)->GetFloat() + m_float);
181
 
                                break;
182
 
                        case VALUE_SUB_OPERATOR:
183
 
                                ret = new CFloatValue(((CFloatValue *) val)->GetFloat() - m_float);
184
 
                                break;
185
 
                        case VALUE_MUL_OPERATOR:
186
 
                                ret = new CFloatValue(((CFloatValue *) val)->GetFloat() * m_float);
187
 
                                break;
188
 
                        case VALUE_DIV_OPERATOR:
189
 
                                if (m_float == 0)
190
 
                                        ret = new CErrorValue("Division by zero");
191
 
                                else
192
 
                                        ret = new CFloatValue (((CFloatValue *) val)->GetFloat() / m_float);
193
 
                                break;
194
 
                        case VALUE_EQL_OPERATOR:
195
 
                                ret = new CBoolValue(((CFloatValue *) val)->GetFloat() == m_float);
196
 
                                break;
197
 
                        case VALUE_NEQ_OPERATOR:
198
 
                                ret = new CBoolValue(((CFloatValue *) val)->GetFloat() != m_float);
199
 
                                break;
200
 
                        case VALUE_GRE_OPERATOR:
201
 
                                ret = new CBoolValue(((CFloatValue *) val)->GetFloat() > m_float);
202
 
                                break;
203
 
                        case VALUE_LES_OPERATOR:
204
 
                                ret = new CBoolValue(((CFloatValue *) val)->GetFloat() < m_float);
205
 
                                break;
206
 
                        case VALUE_GEQ_OPERATOR:
207
 
                                ret = new CBoolValue(((CFloatValue *) val)->GetFloat() >= m_float);
208
 
                                break;
209
 
                        case VALUE_LEQ_OPERATOR:
210
 
                                ret = new CBoolValue(((CFloatValue *) val)->GetFloat() <= m_float);
211
 
                                break;
212
 
                        case VALUE_NEG_OPERATOR:
213
 
                                ret = new CFloatValue (-m_float);
214
 
                                break;
215
 
                        case VALUE_POS_OPERATOR:
216
 
                                ret = new CFloatValue (m_float);
217
 
                                break;
218
 
                                
219
 
                        default:
220
 
                                ret = new CErrorValue("illegal operator. please send a bug report.");
221
 
                                break;
222
 
                        }
223
 
                        break;
224
 
                }
225
 
        case VALUE_STRING_TYPE:
226
 
                {
227
 
                        switch(op)
228
 
                        {
229
 
                        case VALUE_ADD_OPERATOR:
230
 
                                ret = new CStringValue(val->GetText() + GetText(),"");
231
 
                                break;
232
 
                        case VALUE_EQL_OPERATOR:
233
 
                        case VALUE_NEQ_OPERATOR:
234
 
                        case VALUE_GRE_OPERATOR:
235
 
                        case VALUE_LES_OPERATOR:
236
 
                        case VALUE_GEQ_OPERATOR:
237
 
                        case VALUE_LEQ_OPERATOR:
238
 
                                ret = new CErrorValue("[Cannot compare string with float]" + op2str(op) + GetText());
239
 
                                break;
240
 
                        default:
241
 
                                ret =  new CErrorValue("[operator not allowed on strings]" + op2str(op) + GetText());
242
 
                                break;
243
 
                        }
244
 
                        break;
245
 
                }
246
 
        case VALUE_BOOL_TYPE:
247
 
                ret =  new CErrorValue("[operator not valid on boolean and float]" + op2str(op) + GetText());
248
 
                break;
249
 
        case VALUE_ERROR_TYPE:
250
 
                ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
251
 
                break;
252
 
        default:
253
 
                ret = new CErrorValue("illegal type. contact your dealer (if any)");
254
 
                break;
 
123
        switch (dtype) {
 
124
                case VALUE_INT_TYPE:
 
125
                {
 
126
                        switch (op) {
 
127
                                case VALUE_MOD_OPERATOR:
 
128
                                        ret = new CFloatValue(fmod(((CIntValue *) val)->GetInt(), m_float));
 
129
                                        break;
 
130
                                case VALUE_ADD_OPERATOR:
 
131
                                        ret = new CFloatValue(((CIntValue *) val)->GetInt() + m_float);
 
132
                                        break;
 
133
                                case VALUE_SUB_OPERATOR:
 
134
                                        ret = new CFloatValue(((CIntValue *) val)->GetInt() - m_float);
 
135
                                        break;
 
136
                                case VALUE_MUL_OPERATOR:
 
137
                                        ret = new CFloatValue(((CIntValue *) val)->GetInt() * m_float);
 
138
                                        break;
 
139
                                case VALUE_DIV_OPERATOR:
 
140
                                        if (m_float == 0)
 
141
                                                ret = new CErrorValue("Division by zero");
 
142
                                        else
 
143
                                                ret = new CFloatValue (((CIntValue *) val)->GetInt() / m_float);
 
144
                                        break;
 
145
                                case VALUE_EQL_OPERATOR:
 
146
                                        ret = new CBoolValue(((CIntValue *) val)->GetInt() == m_float);
 
147
                                        break;
 
148
                                case VALUE_NEQ_OPERATOR:
 
149
                                        ret = new CBoolValue(((CIntValue *) val)->GetInt() != m_float);
 
150
                                        break;
 
151
                                case VALUE_GRE_OPERATOR:
 
152
                                        ret = new CBoolValue(((CIntValue *) val)->GetInt() > m_float);
 
153
                                        break;
 
154
                                case VALUE_LES_OPERATOR:
 
155
                                        ret = new CBoolValue(((CIntValue *) val)->GetInt() < m_float);
 
156
                                        break;
 
157
                                case VALUE_GEQ_OPERATOR:
 
158
                                        ret = new CBoolValue(((CIntValue *) val)->GetInt() >= m_float);
 
159
                                        break;
 
160
                                case VALUE_LEQ_OPERATOR:
 
161
                                        ret = new CBoolValue(((CIntValue *) val)->GetInt() <= m_float);
 
162
                                        break;
 
163
                                default:
 
164
                                        ret = new CErrorValue("illegal operator. please send a bug report.");
 
165
                                        break;
 
166
                        }
 
167
                        break;
 
168
                }
 
169
                case VALUE_EMPTY_TYPE:
 
170
                case VALUE_FLOAT_TYPE:
 
171
                {
 
172
                        switch (op) {
 
173
                                case VALUE_MOD_OPERATOR:
 
174
                                        ret = new CFloatValue(fmod(((CFloatValue *) val)->GetFloat(), m_float));
 
175
                                        break;
 
176
                                case VALUE_ADD_OPERATOR:
 
177
                                        ret = new CFloatValue(((CFloatValue *) val)->GetFloat() + m_float);
 
178
                                        break;
 
179
                                case VALUE_SUB_OPERATOR:
 
180
                                        ret = new CFloatValue(((CFloatValue *) val)->GetFloat() - m_float);
 
181
                                        break;
 
182
                                case VALUE_MUL_OPERATOR:
 
183
                                        ret = new CFloatValue(((CFloatValue *) val)->GetFloat() * m_float);
 
184
                                        break;
 
185
                                case VALUE_DIV_OPERATOR:
 
186
                                        if (m_float == 0)
 
187
                                                ret = new CErrorValue("Division by zero");
 
188
                                        else
 
189
                                                ret = new CFloatValue (((CFloatValue *) val)->GetFloat() / m_float);
 
190
                                        break;
 
191
                                case VALUE_EQL_OPERATOR:
 
192
                                        ret = new CBoolValue(((CFloatValue *) val)->GetFloat() == m_float);
 
193
                                        break;
 
194
                                case VALUE_NEQ_OPERATOR:
 
195
                                        ret = new CBoolValue(((CFloatValue *) val)->GetFloat() != m_float);
 
196
                                        break;
 
197
                                case VALUE_GRE_OPERATOR:
 
198
                                        ret = new CBoolValue(((CFloatValue *) val)->GetFloat() > m_float);
 
199
                                        break;
 
200
                                case VALUE_LES_OPERATOR:
 
201
                                        ret = new CBoolValue(((CFloatValue *) val)->GetFloat() < m_float);
 
202
                                        break;
 
203
                                case VALUE_GEQ_OPERATOR:
 
204
                                        ret = new CBoolValue(((CFloatValue *) val)->GetFloat() >= m_float);
 
205
                                        break;
 
206
                                case VALUE_LEQ_OPERATOR:
 
207
                                        ret = new CBoolValue(((CFloatValue *) val)->GetFloat() <= m_float);
 
208
                                        break;
 
209
                                case VALUE_NEG_OPERATOR:
 
210
                                        ret = new CFloatValue (-m_float);
 
211
                                        break;
 
212
                                case VALUE_POS_OPERATOR:
 
213
                                        ret = new CFloatValue (m_float);
 
214
                                        break;
 
215
 
 
216
                                default:
 
217
                                        ret = new CErrorValue("illegal operator. please send a bug report.");
 
218
                                        break;
 
219
                        }
 
220
                        break;
 
221
                }
 
222
                case VALUE_STRING_TYPE:
 
223
                {
 
224
                        switch (op) {
 
225
                                case VALUE_ADD_OPERATOR:
 
226
                                        ret = new CStringValue(val->GetText() + GetText(),"");
 
227
                                        break;
 
228
                                case VALUE_EQL_OPERATOR:
 
229
                                case VALUE_NEQ_OPERATOR:
 
230
                                case VALUE_GRE_OPERATOR:
 
231
                                case VALUE_LES_OPERATOR:
 
232
                                case VALUE_GEQ_OPERATOR:
 
233
                                case VALUE_LEQ_OPERATOR:
 
234
                                        ret = new CErrorValue("[Cannot compare string with float]" + op2str(op) + GetText());
 
235
                                        break;
 
236
                                default:
 
237
                                        ret =  new CErrorValue("[operator not allowed on strings]" + op2str(op) + GetText());
 
238
                                        break;
 
239
                        }
 
240
                        break;
 
241
                }
 
242
                case VALUE_BOOL_TYPE:
 
243
                        ret =  new CErrorValue("[operator not valid on boolean and float]" + op2str(op) + GetText());
 
244
                        break;
 
245
                case VALUE_ERROR_TYPE:
 
246
                        ret = new CErrorValue(val->GetText() + op2str(op) + GetText());
 
247
                        break;
 
248
                default:
 
249
                        ret = new CErrorValue("illegal type. contact your dealer (if any)");
 
250
                        break;
255
251
        }
256
252
        return ret;
257
253
}
314
310
 
315
311
 
316
312
#ifdef WITH_PYTHON
317
 
PyObject* CFloatValue::ConvertValueToPython()
 
313
PyObject *CFloatValue::ConvertValueToPython()
318
314
{
319
315
        return PyFloat_FromDouble(m_float);
320
316
}