framework2

1
//
2
//  ofxFBXNode.cpp
3
//  ofxFBX-Example-Importer
4
//
5
//  Created by Nick Hardeman on 10/31/13.
6
//
7
//
8

9
#include "ofxFBXNode.h"
10

11
//----------------------------------------
12
ofxFBXNode::ofxFBXNode() {
13
//    parent          = NULL;
14
//    globalParent    = NULL;
15
//    origScale = glm::vec3(1,1,1);
16
}
17

18
//----------------------------------------
19
ofxFBXNode::~ofxFBXNode() {
20
    if( getParent() != NULL ) {
21
        clearParent();
22
    }
23
    if( mParentNode ) {
24
        mParentNode.reset();
25
    }
26
    clearChildren();
27
}
28

29
//----------------------------------------
30
ofxFBXSource::Node::NodeType ofxFBXNode::getType() {
31
    return ofxFBXSource::Node::OFX_FBX_NULL;
32
}
33

34
//----------------------------------------
35
void ofxFBXNode::setup( shared_ptr<ofxFBXSource::Node> anode ) {
36
    name = anode->getName();
37
    mSrcNode = anode;
38
    if( mSrcNode ) {
39
        setTransform( anode );
40
    }
41
}
42

43
//----------------------------------------
44
void ofxFBXNode::setTransform( shared_ptr<ofxFBXSource::Node> anode ) {
45
    setTransform( anode.get() );
46
}
47

48
//----------------------------------------
49
void ofxFBXNode::setTransform( ofxFBXSource::Node* anode ) {
50
    setPosition( anode->getPosition() );
51
    setOrientation( anode->getOrientationQuat() );
52
    setScale( anode->getScale() );
53
}
54

55
//----------------------------------------
56
string ofxFBXNode::getName() {
57
    return name;
58
}
59

60
//----------------------------------------
61
string ofxFBXNode::getFbxTypeString() {
62
    if(mSrcNode) {
63
        return mSrcNode->getFbxTypeString();
64
    }
65
    return "Unknown";
66
}
67

68
//----------------------------------------
69
void ofxFBXNode::setParentNode( shared_ptr<ofxFBXNode> anode ) {
70
    mParentNode = anode;
71
}
72

73
//----------------------------------------
74
bool ofxFBXNode::hasParentNode() {
75
    if( !mParentNode ) return false;
76
    return true;
77
}
78

79
//----------------------------------------
80
shared_ptr<ofxFBXNode> ofxFBXNode::getParentNode() {
81
    return mParentNode;
82
}
83

84
//----------------------------------------
85
void ofxFBXNode::clearChildren() {
86
    mKids.clear();
87
}
88

89
//----------------------------------------
90
void ofxFBXNode::addChild( shared_ptr<ofxFBXNode> akiddo ) {
91
    mKids.push_back( akiddo );
92
}
93

94
//----------------------------------------
95
int ofxFBXNode::getNumChildren() {
96
    return mKids.size();
97
}
98

99
//----------------------------------------
100
vector< shared_ptr<ofxFBXNode> >& ofxFBXNode::getChildren() {
101
    return mKids;
102
}
103

104
//--------------------------------------------------------------
105
string ofxFBXNode::getAsString( int aLevel ) {
106
    stringstream oStr;// = "";
107
    for( int i = 0; i < aLevel; i++ ) {
108
        oStr << "  ";
109
    }
110
    if( aLevel > 0 ) {
111
        oStr <<" '";
112
    }
113
    if( mKids.size() ) {
114
        oStr << "+ ";
115
    } else {
116
        oStr << "- ";
117
    }
118
//    string pname = "";
119
//    if( getParent() != NULL ) {
120
//        pname = " parent: " + parentBoneName;
121
//    }
122
    
123
    if( !mSrcNode ) {
124
        return oStr.str();
125
    }
126
    
127
    oStr << mSrcNode->getTypeAsString() << ": " << getName() << " fbx type: " << mSrcNode->getFbxTypeString();
128
    if( getNumChildren() > 0 ) {
129
        oStr << " kids: " << mKids.size();
130
    }
131
//    if(mSrcNode->usingKeyFrames()) {
132
//        oStr << " num keys: " << mSrcNode->getKey.size();
133
//    }
134
    oStr << endl;// "\n";
135
    
136
    for( auto& kid : mKids ) {
137
        oStr << kid->getAsString( aLevel + 1);
138
    }
139
    
140
    return oStr.str();
141
}
142

143
#pragma mark - Search
144
//--------------------------------------------------------------
145
shared_ptr<ofxFBXNode> ofxFBXNode::getNodeforName( shared_ptr<ofxFBXNode>& aBSelf, string aPath, bool bStrict ) {
146
    vector< string > tsearches;
147
    if( ofIsStringInString( aPath, ":" ) ) {
148
        tsearches = ofSplitString( aPath, ":" );
149
    } else {
150
        tsearches.push_back( aPath );
151
        if(aBSelf) {
152
            if(bStrict) {
153
                if( aBSelf->getName() == aPath ) {
154
//                    cout << "FOUND SELF" << endl;
155
                    return aBSelf;
156
                }
157
            } else {
158
                if( ofIsStringInString( aBSelf->getName(), aPath )) {
159
//                    cout << "FOUND SELF" << endl;
160
                    return aBSelf;
161
                }
162
            }
163
        }
164
    }
165
    
166
    shared_ptr<ofxFBXNode> temp;// = aBSelf;
167
    _getNodeForNameRecursive( tsearches, temp, mKids, bStrict );
168
    return temp;
169
}
170

171
//--------------------------------------------------------------
172
shared_ptr<ofxFBXNode> ofxFBXNode::getKidforName( string aPath, bool bStrict ) {
173
    
174
    vector< string > tsearches;
175
    if( ofIsStringInString( aPath, ":" ) ) {
176
        tsearches = ofSplitString( aPath, ":" );
177
    } else {
178
        tsearches.push_back( aPath );
179
    }
180
    
181
    shared_ptr<ofxFBXNode> temp;
182
    _getNodeForNameRecursive( tsearches, temp, mKids, bStrict );
183
    return temp;
184
}
185

186
//--------------------------------------------------------------
187
void ofxFBXNode::_getNodeForNameRecursive( vector<string>& aNamesToFind, shared_ptr<ofxFBXNode>& aTarget, vector< shared_ptr<ofxFBXNode> >& aElements, bool bStrict ) {
188
    
189
    for( int i = 0; i < aElements.size(); i++ ) {
190
        bool bFound = false;
191
        if(bStrict) {
192
            if( aElements[i]->getName() == aNamesToFind[0] ) {
193
                bFound = true;
194
            }
195
        } else {
196
            if( ofIsStringInString( aElements[i]->getName(), aNamesToFind[0] )) {
197
//                cout << "Found--- " << aNamesToFind[0] << " num names: " << aNamesToFind.size() << endl;
198
                bFound = true;
199
            }
200
        }
201
        
202
        if( bFound == true ) {
203
            aNamesToFind.erase( aNamesToFind.begin() );
204
            if( aNamesToFind.size() == 0 ) {//}|| aElements[i]->getNumChildren() < 1 ) {
205
                bool bgood = false;
206
                if( aElements[i] ) {
207
                    bgood = true;
208
                }
209
//                cout << "going to return one of the elements " << aNamesToFind.size() << " good: " << bgood << " " << endl;
210
                aTarget = aElements[i];
211
                break;
212
            } else {
213
                if( aElements[i]->getNumChildren() > 0 ) {
214
//                    shared_ptr<ofxFBXNode> tgroup = dynamic_pointer_cast< ofxSvgGroup >( aElements[i] );
215
                    _getNodeForNameRecursive( aNamesToFind, aTarget, aElements[i]->getChildren(), bStrict );
216
                    break;
217
                }
218
            }
219
        }
220
    }
221
}
222

223
//--------------------------------------------------------------
224
void ofxFBXNode::_getKidsForTypeRecursive( int atype, string aNameToContain, vector< shared_ptr<ofxFBXNode> >& aFoundElements, vector< shared_ptr<ofxFBXNode> >& aElements ) {
225
    
226
    for( int i = 0; i < aElements.size(); i++ ) {
227
        
228
        if( aElements[i]->getType() == atype ) {
229
            bool bFound = false;
230
            if( aNameToContain != "" ) {
231
                if( ofIsStringInString( aElements[i]->getName(), aNameToContain )) {
232
                    bFound = true;
233
                }
234
            } else {
235
                bFound = true;
236
            }
237
            if( bFound ) {
238
                aFoundElements.push_back( aElements[i] );
239
            }
240
        }
241
        
242
        if( aElements[i]->getNumChildren() > 0 ) {
243
            _getKidsForTypeRecursive( atype, aNameToContain, aFoundElements, aElements[i]->getChildren() );
244
        }
245
    }
246
}
247

248
//--------------------------------------------------------------
249
vector< shared_ptr<ofxFBXNode> > ofxFBXNode::getAllChildren() {
250
    vector< shared_ptr<ofxFBXNode> > rnodes;
251
    _getKidsRecursive( rnodes, mKids );
252
    return rnodes;
253
}
254

255
//--------------------------------------------------------------
256
void ofxFBXNode::_getKidsRecursive( vector< shared_ptr<ofxFBXNode> >& aFoundElements, vector< shared_ptr<ofxFBXNode> >& aElements ) {
257
    for( int i = 0; i < aElements.size(); i++ ) {
258
        aFoundElements.push_back( aElements[i] );
259
        
260
        if( aElements[i]->getNumChildren() > 0 ) {
261
            _getKidsRecursive( aFoundElements, aElements[i]->getChildren() );
262
        }
263
    }
264
}
265