← Back to branch summary

~ubuntu-branches/ubuntu/wily/opencollada/wily

« back to all changes in this revision

Viewing changes to COLLADAMax/src/COLLADAMaxExtra.cpp

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2015-05-14 17:23:27 UTC
  • Revision ID: package-import@ubuntu.com-20150514172327-f862u8envms01fra
Tags: upstream-0.1.0~20140703.ddf8f47+dfsg1
Import upstream version 0.1.0~20140703.ddf8f47+dfsg1

Show diffs side-by-side

added added

removed removed

Lines of Context:
COLLADAMax/src/COLLADAMaxExtra.cpp
 
1
/*
 
2
    Copyright (c) 2008-2009 NetAllied Systems GmbH
 
3
 
 
4
        This file is part of COLLADAMax.
 
5
 
 
6
    Portions of the code are:
 
7
    Copyright (c) 2005-2007 Feeling Software Inc.
 
8
    Copyright (c) 2005-2007 Sony Computer Entertainment America
 
9
    
 
10
    Based on the 3dsMax COLLADASW Tools:
 
11
    Copyright (c) 2005-2006 Autodesk Media Entertainment
 
12
        
 
13
    Licensed under the MIT Open Source License, 
 
14
    for details please see LICENSE file or the website
 
15
    http://www.opensource.org/licenses/mit-license.php
 
16
*/
 
17
 
 
18
 
 
19
#include "COLLADAMaxStableHeaders.h"
 
20
#include "COLLADAMaxAnimationExporter.h"
 
21
 
 
22
#include "COLLADAMaxExtra.h"
 
23
 
 
24
 
 
25
 
 
26
namespace COLLADAMax
 
27
{
 
28
 
 
29
 
 
30
        const String Extra::TECHNIQUE_PROFILE_3DSMAX = "OpenCOLLADA3dsMax";
 
31
 
 
32
        const String Extra::TECHNIQUE_PROFILE_OPENCOLLADA = "OpenCOLLADA";
 
33
 
 
34
        const String Extra::USERDEFINED_PROPERTIES = "user_properties";
 
35
 
 
36
        const String Extra::CAST_SHADOWS_PROPERTY = "cast_shadows";
 
37
        const String Extra::RECEIVE_SHADOWS_PROPERTY = "receive_shadows";
 
38
        const String Extra::PRIMARY_VISIBILITY_PROPERTY = "primary_visibility";
 
39
        const String Extra::SECONDARY_VISIBILITY_PROPERTY = "secondary_visibility";
 
40
 
 
41
    //---------------------------------------------------------------
 
42
    Extra::Extra ( COLLADASW::StreamWriter * streamWriter, DocumentExporter * documentExporter )
 
43
            :mSW(streamWriter),
 
44
                        mAnimationExporter(documentExporter->getAnimationExporter()),
 
45
                        mOptions(documentExporter->getOptions()),
 
46
                        mExtraTechnique(0)
 
47
    {}
 
48
 
 
49
 
 
50
        //---------------------------------------------------------------
 
51
        void Extra::addAnimatedExtraParameter(const String & parameterName, const String& childName, IParamBlock2* parameters, int parameterIndex, const String& baseId)
 
52
        {
 
53
                //check if the parameterIndex is a valid index for this param block
 
54
                if ( parameters->IDtoIndex(parameterIndex) < 0 )
 
55
                        return;
 
56
 
 
57
                ParamType2 parameterType = parameters->GetParameterType(parameterIndex);
 
58
 
 
59
                TimeValue animationStart = mOptions.getAnimationStart();
 
60
 
 
61
 
 
62
                switch (parameterType)
 
63
                {
 
64
                case TYPE_BOOL:
 
65
                        mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetInt(parameterIndex, animationStart)!= false);
 
66
                        // NO ANIMATION ON BOOLEANS
 
67
                        break;
 
68
                case TYPE_INT:
 
69
                        if ( AnimationExporter::isAnimated(parameters, parameterIndex) )
 
70
                        {
 
71
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetInt(parameterIndex, animationStart) , parameterName);
 
72
                                mAnimationExporter->addAnimatedParameter(parameters, parameterIndex, baseId, parameterName, 0);
 
73
                        }
 
74
                        else
 
75
                        {
 
76
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetInt(parameterIndex, animationStart));
 
77
                        }
 
78
                        break;
 
79
                case TYPE_FLOAT:
 
80
                        if ( AnimationExporter::isAnimated(parameters, parameterIndex) )
 
81
                        {
 
82
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetFloat(parameterIndex, animationStart), parameterName);
 
83
                                mAnimationExporter->addAnimatedParameter(parameters, parameterIndex, baseId, parameterName, 0);
 
84
                        }
 
85
                        else
 
86
                        {
 
87
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetFloat(parameterIndex, animationStart));
 
88
                        }
 
89
                        break;
 
90
                default:
 
91
                        break;
 
92
                }
 
93
        }
 
94
 
 
95
 
 
96
        //---------------------------------------------------------------
 
97
        void Extra::addAnimatedExtraParameter(const String & parameterName, const String& childName, IParamBlock* parameters, int parameterIndex, const String& baseId)
 
98
        {
 
99
                if ( parameterIndex >= parameters->NumParams() )
 
100
                        return;
 
101
 
 
102
                ParamType parameterType = parameters->GetParameterType(parameterIndex);
 
103
 
 
104
                TimeValue animationStart = mOptions.getAnimationStart();
 
105
 
 
106
                // use the animation number with the GetController method
 
107
                // since the parameters enumeration doesn't reflect the param
 
108
                // block order.
 
109
                Control *controller = parameters->GetController(parameterIndex);
 
110
 
 
111
                switch (parameterType)
 
112
                {
 
113
                case TYPE_BOOL:
 
114
                        mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetInt(parameterIndex, animationStart)!= false);
 
115
                        // NO ANIMATION ON BOOLEANS
 
116
                        break;
 
117
                case TYPE_INT:
 
118
                        if ( AnimationExporter::isAnimated(parameters, parameterIndex) )
 
119
                        {
 
120
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetInt(parameterIndex, animationStart) , parameterName);
 
121
                                mAnimationExporter->addAnimatedParameter(parameters, parameterIndex, baseId, parameterName, 0);
 
122
                        }
 
123
                        else
 
124
                        {
 
125
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetInt(parameterIndex, animationStart));
 
126
                        }
 
127
                        break;
 
128
                case TYPE_FLOAT:
 
129
                        if ( AnimationExporter::isAnimated(parameters, parameterIndex) )
 
130
                        {
 
131
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetFloat(parameterIndex, animationStart), parameterName);
 
132
                                mAnimationExporter->addAnimatedParameter(parameters, parameterIndex, baseId, parameterName, 0);
 
133
                        }
 
134
                        else
 
135
                        {
 
136
                                mExtraTechnique->addExtraTechniqueChildParameter(Extra::TECHNIQUE_PROFILE_3DSMAX, childName, parameterName, parameters->GetFloat(parameterIndex, animationStart));
 
137
                        }
 
138
                        break;
 
139
                default:
 
140
                        break;
 
141
                }
 
142
        }
 
143
 
 
144
 
 
145
 
 
146
        //---------------------------------------------------------------
 
147
        void Extra::addParamBlockAnimatedExtraParameters ( const String & elementName, const ExtraParameter extraParameters[], int extraParametersCount, IParamBlock * paramBlock, const String& baseId )
 
148
        {
 
149
                for ( int i = 0; i < extraParametersCount; ++i )
 
150
                {
 
151
                        const ExtraParameter & parameter = extraParameters[ i ];
 
152
                        addAnimatedExtraParameter ( parameter.paramName, elementName, paramBlock, parameter.paramId, baseId );
 
153
                }
 
154
        }
 
155
 
 
156
        //---------------------------------------------------------------
 
157
        void Extra::addParamBlockAnimatedExtraParameters ( const String & elementName, const ExtraParameter extraParameters[], int extraParametersCount, IParamBlock2 * paramBlock, const String& baseId )
 
158
        {
 
159
                for ( int i = 0; i < extraParametersCount; ++i )
 
160
                {
 
161
                        const ExtraParameter & parameter = extraParameters[ i ];
 
162
                        addAnimatedExtraParameter ( parameter.paramName, elementName, paramBlock, parameter.paramId, baseId );
 
163
                }
 
164
        }
 
165
 
 
166
        void Extra::writeParameterBlockInfo( const String& fileName, IParamBlock* parameters )
 
167
        {
 
168
 
 
169
                std::filebuf fb;
 
170
 
 
171
                fb.open ( fileName.c_str(), std::ios::app );
 
172
 
 
173
                std::ostream os ( &fb );
 
174
 
 
175
 
 
176
                int count = parameters->NumParams();
 
177
 
 
178
 
 
179
                for (int i = 0; i<count; ++i)
 
180
                {
 
181
                        ParamType type = parameters->GetParameterType(i);
 
182
 
 
183
                        os << i << " ";
 
184
 
 
185
                        switch ( type )
 
186
                        {
 
187
 
 
188
                        case TYPE_BOOL:
 
189
                                os << "TYPE_BOOL " << parameters->GetInt ( i ) << " ";
 
190
                                break;
 
191
 
 
192
                        case TYPE_FLOAT:
 
193
                                os << "TYPE_FLOAT " << parameters->GetFloat ( i ) << " ";
 
194
                                break;
 
195
 
 
196
                        case TYPE_INT:
 
197
                                os << "TYPE_INT " << parameters->GetInt ( i ) << " ";
 
198
                                break;
 
199
                        case TYPE_RGBA:
 
200
                                Color color = parameters->GetColor(i);
 
201
                                os << "TYPE_RGBA " << color.r << " " << color.g << " " << color.b << " " ;
 
202
                                break;
 
203
 
 
204
 
 
205
                        }
 
206
 
 
207
                        os << std::endl << std::endl;
 
208
                }
 
209
 
 
210
                fb.close();
 
211
        }
 
212
 
 
213
 
 
214
        void Extra::writeParameterBlockInfo( const String& fileName, IParamBlock2* parameters )
 
215
        {
 
216
 
 
217
                std::filebuf fb;
 
218
 
 
219
                fb.open ( fileName.c_str(), std::ios::app );
 
220
 
 
221
                std::ostream os ( &fb );
 
222
 
 
223
 
 
224
                int count = parameters->NumParams();
 
225
 
 
226
 
 
227
                for (int i = 0; i<count; ++i)
 
228
                {
 
229
 
 
230
                        int parameterID = parameters->IndextoID(i);
 
231
 
 
232
                        ParamType2 type = parameters->GetParameterType(parameterID);
 
233
                        bool printName = true;
 
234
 
 
235
                        os << i << " " << parameterID << " ";
 
236
 
 
237
                        switch ( type )
 
238
                        {
 
239
 
 
240
                        case TYPE_BOOL:
 
241
                                os << "TYPE_BOOL " << parameters->GetInt ( parameterID ) << " ";
 
242
                                break;
 
243
 
 
244
                        case TYPE_FLOAT:
 
245
                                os << "TYPE_FLOAT " << parameters->GetFloat ( parameterID ) << " ";
 
246
                                break;
 
247
                        case TYPE_PCNT_FRAC:
 
248
                                os << "TYPE_PCNT_FRAC " << parameters->GetFloat ( parameterID ) << " ";
 
249
                                break;
 
250
 
 
251
                        case TYPE_INT:
 
252
                                os << "TYPE_INT " << parameters->GetInt ( parameterID ) << " ";
 
253
                                break;
 
254
                        case TYPE_RGBA:
 
255
                                {
 
256
                                        Color color = parameters->GetColor(i);
 
257
                                        os << "TYPE_RGBA " << color.r << " " << color.g << " " << color.b << " " ;
 
258
                                        break;
 
259
                                }
 
260
                        case TYPE_TEXMAP:
 
261
                                {
 
262
                                        Texmap* texmap = parameters->GetTexmap(i);
 
263
                                        os << "TYPE_TEXMAP ";
 
264
                                        if ( texmap )
 
265
                                                os << texmap->GetName();
 
266
                                        os << " " ;
 
267
                                        break;
 
268
                                }
 
269
                        default:
 
270
                                printName = false;
 
271
 
 
272
 
 
273
                        }
 
274
 
 
275
                        if ( printName )
 
276
                                os << parameters->GetLocalName ( parameterID );
 
277
 
 
278
                        os << std::endl << std::endl;
 
279
                }
 
280
 
 
281
                fb.close();
 
282
        }
 
283
 
 
284
 
 
285
 
 
286
}