diff --git a/Engine/source/ts/collada/colladaAppNode.cpp b/Engine/source/ts/collada/colladaAppNode.cpp index fdf56c775..c66df325e 100644 --- a/Engine/source/ts/collada/colladaAppNode.cpp +++ b/Engine/source/ts/collada/colladaAppNode.cpp @@ -99,7 +99,7 @@ ColladaAppNode::ColladaAppNode(const domNode* node, ColladaAppNode* parent) case COLLADA_TYPE::MATRIX: case COLLADA_TYPE::LOOKAT: nodeTransforms.increment(); - nodeTransforms.last().element = node->getContents()[iChild]; + nodeTransforms.last().mElement = node->getContents()[iChild]; break; } } @@ -232,7 +232,7 @@ MatrixF ColladaAppNode::getTransform(F32 time) MatrixF mat(true); // Convert the transform element to a MatrixF - switch (nodeTransforms[iTxfm].element->getElementType()) { + switch (nodeTransforms[iTxfm].mElement->getElementType()) { case COLLADA_TYPE::TRANSLATE: mat = vecToMatrixF(nodeTransforms[iTxfm].getValue(time)); break; case COLLADA_TYPE::SCALE: mat = vecToMatrixF(nodeTransforms[iTxfm].getValue(time)); break; case COLLADA_TYPE::ROTATE: mat = vecToMatrixF(nodeTransforms[iTxfm].getValue(time)); break; diff --git a/Engine/source/ts/collada/colladaAppSequence.cpp b/Engine/source/ts/collada/colladaAppSequence.cpp index 6f65a01bf..a3ccc6864 100644 --- a/Engine/source/ts/collada/colladaAppSequence.cpp +++ b/Engine/source/ts/collada/colladaAppSequence.cpp @@ -88,7 +88,7 @@ void ColladaAppSequence::setAnimationActive(const domAnimation* anim, bool activ domChannel* channel = anim->getChannel_array()[iChannel]; AnimData* animData = reinterpret_cast(channel->getUserData()); if (animData) - animData->enabled = active; + animData->mEnabled = active; } // Recurse into child animations diff --git a/Engine/source/ts/collada/colladaExtensions.h b/Engine/source/ts/collada/colladaExtensions.h index 40e490267..0d440a3f7 100644 --- a/Engine/source/ts/collada/colladaExtensions.h +++ b/Engine/source/ts/collada/colladaExtensions.h @@ -108,9 +108,9 @@ protected: /// Get the value of the named animated parameter (use defaultVal if parameter not found) template void get(const char* name, AnimatedElement& value, T defaultVal) { - value.defaultVal = defaultVal; + value.mDefaultVal = defaultVal; if (const domAny* param = findParam(name)) - value.element = param; + value.mElement = param; } public: diff --git a/Engine/source/ts/collada/colladaShapeLoader.cpp b/Engine/source/ts/collada/colladaShapeLoader.cpp index 07d2b7a40..b7047b336 100644 --- a/Engine/source/ts/collada/colladaShapeLoader.cpp +++ b/Engine/source/ts/collada/colladaShapeLoader.cpp @@ -160,14 +160,14 @@ void ColladaShapeLoader::processAnimation(const domAnimation* anim, F32& maxEndT // @todo:don't care about the input param names for now. Could // validate against the target type.... if (dStrEqual(input->getSemantic(), "INPUT")) { - data.input.initFromSource(source); + data.mInput.initFromSource(source); // Adjust the maximum sequence end time - maxEndTime = getMax(maxEndTime, data.input.getFloatValue((S32)data.input.size()-1)); + maxEndTime = getMax(maxEndTime, data.mInput.getFloatValue((S32)data.mInput.size()-1)); // Detect the frame rate (minimum time between keyframes) - for (S32 iFrame = 1; iFrame < data.input.size(); iFrame++) + for (S32 iFrame = 1; iFrame < data.mInput.size(); iFrame++) { - F32 delta = data.input.getFloatValue( iFrame ) - data.input.getFloatValue( iFrame-1 ); + F32 delta = data.mInput.getFloatValue( iFrame ) - data.mInput.getFloatValue( iFrame-1 ); if ( delta < 0 ) { daeErrorHandler::get()->handleError(avar(" INPUT '%s' " @@ -178,13 +178,13 @@ void ColladaShapeLoader::processAnimation(const domAnimation* anim, F32& maxEndT } } else if (dStrEqual(input->getSemantic(), "OUTPUT")) - data.output.initFromSource(source); + data.mOutput.initFromSource(source); else if (dStrEqual(input->getSemantic(), "IN_TANGENT")) - data.inTangent.initFromSource(source); + data.mInTangent.initFromSource(source); else if (dStrEqual(input->getSemantic(), "OUT_TANGENT")) - data.outTangent.initFromSource(source); + data.mOutTangent.initFromSource(source); else if (dStrEqual(input->getSemantic(), "INTERPOLATION")) - data.interpolation.initFromSource(source); + data.mInterpolation.initFromSource(source); } // Set initial value for visibility targets that were added automatically (in colladaUtils.cpp @@ -192,11 +192,11 @@ void ColladaShapeLoader::processAnimation(const domAnimation* anim, F32& maxEndT { domAny* visTarget = daeSafeCast(target); if (visTarget && dStrEqual(visTarget->getValue(), "")) - visTarget->setValue(avar("%g", data.output.getFloatValue(0))); + visTarget->setValue(avar("%g", data.mOutput.getFloatValue(0))); } // Ignore empty animations - if (data.input.size() == 0) { + if (data.mInput.size() == 0) { channel->setUserData(0); delete targetChannels->last(); targetChannels->pop_back(); diff --git a/Engine/source/ts/collada/colladaUtils.cpp b/Engine/source/ts/collada/colladaUtils.cpp index 0c409fc95..647d94164 100644 --- a/Engine/source/ts/collada/colladaUtils.cpp +++ b/Engine/source/ts/collada/colladaUtils.cpp @@ -248,27 +248,27 @@ BasePrimitive* BasePrimitive::get(const daeElement* element) void AnimData::parseTargetString(const char* target, S32 fullCount, const char* elements[]) { // Assume targeting all elements at offset 0 - targetValueCount = fullCount; - targetValueOffset = 0; + mTargetValueCount = fullCount; + mTargetValueOffset = 0; // Check for array syntax: (n) or (n)(m) if (const char* p = dStrchr(target, '(')) { S32 indN, indM; if (dSscanf(p, "(%d)(%d)", &indN, &indM) == 2) { - targetValueOffset = (indN * 4) + indM; // @todo: 4x4 matrix only - targetValueCount = 1; + mTargetValueOffset = (indN * 4) + indM; // @todo: 4x4 matrix only + mTargetValueCount = 1; } else if (dSscanf(p, "(%d)", &indN) == 1) { - targetValueOffset = indN; - targetValueCount = 1; + mTargetValueOffset = indN; + mTargetValueCount = 1; } } else if (const char* p = dStrrchr(target, '.')) { // Check for named elements for (S32 iElem = 0; elements[iElem][0] != 0; iElem++) { if (!dStrcmp(p, elements[iElem])) { - targetValueOffset = iElem; - targetValueCount = 1; + mTargetValueOffset = iElem; + mTargetValueCount = 1; break; } } @@ -327,47 +327,47 @@ F32 AnimData::invertParamCubic(F32 param, F32 x0, F32 x1, F32 x2, F32 x3) const void AnimData::interpValue(F32 t, U32 offset, double* value) const { // handle degenerate animation data - if (input.size() == 0) + if (mInput.size() == 0) { *value = 0.0f; return; } - else if (input.size() == 1) + else if (mInput.size() == 1) { - *value = output.getStringArrayData(0)[offset]; + *value = mOutput.getStringArrayData(0)[offset]; return; } // clamp time to valid range - F32 curveStart = input.getFloatValue(0); - F32 curveEnd = input.getFloatValue(input.size()-1); + F32 curveStart = mInput.getFloatValue(0); + F32 curveEnd = mInput.getFloatValue(mInput.size()-1); t = mClampF(t, curveStart, curveEnd); // find the index of the input keyframe BEFORE 't' S32 index; - for (index = 0; index < input.size()-2; index++) { - if (input.getFloatValue(index + 1) > t) + for (index = 0; index < mInput.size()-2; index++) { + if (mInput.getFloatValue(index + 1) > t) break; } // get the data for the two control points either side of 't' Point2F v0; - v0.x = input.getFloatValue(index); - v0.y = output.getStringArrayData(index)[offset]; + v0.x = mInput.getFloatValue(index); + v0.y = mOutput.getStringArrayData(index)[offset]; Point2F v3; - v3.x = input.getFloatValue(index + 1); - v3.y = output.getStringArrayData(index + 1)[offset]; + v3.x = mInput.getFloatValue(index + 1); + v3.y = mOutput.getStringArrayData(index + 1)[offset]; // If spline interpolation is specified but the tangents are not available, // default to LINEAR. - const char* interp_method = interpolation.getStringValue(index); + const char* interp_method = mInterpolation.getStringValue(index); if (dStrEqual(interp_method, "BEZIER") || dStrEqual(interp_method, "HERMITE") || dStrEqual(interp_method, "CARDINAL")) { - const double* inArray = inTangent.getStringArrayData(index + 1); - const double* outArray = outTangent.getStringArrayData(index); + const double* inArray = mInTangent.getStringArrayData(index + 1); + const double* outArray = mOutTangent.getStringArrayData(index); if (!inArray || !outArray) interp_method = "LINEAR"; } @@ -398,17 +398,17 @@ void AnimData::interpValue(F32 t, U32 offset, double* value) const v2 = v3; if (index > 0) { - v0.x = input.getFloatValue(index-1); - v0.y = output.getStringArrayData(index-1)[offset]; + v0.x = mInput.getFloatValue(index-1); + v0.y = mOutput.getStringArrayData(index-1)[offset]; } else { // mirror P1 through P0 v0 = v1 + (v1 - v2); } - if (index < (input.size()-2)) { - v3.x = input.getFloatValue(index+2); - v3.y = output.getStringArrayData(index+2)[offset]; + if (index < (mInput.size()-2)) { + v3.x = mInput.getFloatValue(index+2); + v3.y = mOutput.getStringArrayData(index+2)[offset]; } else { // mirror P0 through P1 @@ -416,10 +416,10 @@ void AnimData::interpValue(F32 t, U32 offset, double* value) const } } else { - const double* inArray = inTangent.getStringArrayData(index + 1); - const double* outArray = outTangent.getStringArrayData(index); + const double* inArray = mInTangent.getStringArrayData(index + 1); + const double* outArray = mOutTangent.getStringArrayData(index); - if (output.stride() == inTangent.stride()) { + if (mOutput.stride() == mInTangent.stride()) { // This degenerate form (1D control points) does 2 things wrong: // 1) it does not specify the key (time) value // 2) the control point is specified as a tangent for both bezier and hermite @@ -458,27 +458,27 @@ void AnimData::interpValue(F32 t, U32 offset, double* value) const void AnimData::interpValue(F32 t, U32 offset, const char** value) const { - if (input.size() == 0) + if (mInput.size() == 0) *value = ""; - else if (input.size() == 1) - *value = output.getStringValue(0); + else if (mInput.size() == 1) + *value = mOutput.getStringValue(0); else { // clamp time to valid range - F32 curveStart = input.getFloatValue(0); - F32 curveEnd = input.getFloatValue(input.size()-1); + F32 curveStart = mInput.getFloatValue(0); + F32 curveEnd = mInput.getFloatValue(mInput.size()-1); t = mClampF(t, curveStart, curveEnd); // find the index of the input keyframe BEFORE 't' S32 index; - for (index = 0; index < input.size()-2; index++) { - if (input.getFloatValue(index + 1) > t) + for (index = 0; index < mInput.size()-2; index++) { + if (mInput.getFloatValue(index + 1) > t) break; } // String values only support STEP interpolation, so just get the // value at the input keyframe - *value = output.getStringValue(index); + *value = mOutput.getStringValue(index); } } diff --git a/Engine/source/ts/collada/colladaUtils.h b/Engine/source/ts/collada/colladaUtils.h index 3cfe0908c..8a8643973 100644 --- a/Engine/source/ts/collada/colladaUtils.h +++ b/Engine/source/ts/collada/colladaUtils.h @@ -678,32 +678,32 @@ template<> inline F32 convert(const char* value) { return convert(value) /// Collada animation data struct AnimChannels : public Vector { - daeElement *element; - AnimChannels(daeElement* el) : element(el) + daeElement *mElement; + AnimChannels(daeElement* el) : mElement(el) { - element->setUserData(this); + mElement->setUserData(this); } ~AnimChannels() { - if (element) - element->setUserData(0); + if (mElement) + mElement->setUserData(0); } }; struct AnimData { - bool enabled; ///!< Used to select animation channels for the current clip + bool mEnabled; ///!< Used to select animation channels for the current clip - _SourceReader input; - _SourceReader output; + _SourceReader mInput; + _SourceReader mOutput; - _SourceReader inTangent; - _SourceReader outTangent; + _SourceReader mInTangent; + _SourceReader mOutTangent; - _SourceReader interpolation; + _SourceReader mInterpolation; - U32 targetValueOffset; ///< Offset into the target element (for arrays of values) - U32 targetValueCount; ///< Number of values animated (from OUTPUT source array) + U32 mTargetValueOffset; ///< Offset into the target element (for arrays of values) + U32 mTargetValueCount; ///< Number of values animated (from OUTPUT source array) /// Get the animation channels for the Collada element (if any) static AnimChannels* getAnimChannels(const daeElement* element) @@ -711,7 +711,7 @@ struct AnimData return element ? (AnimChannels*)const_cast(element)->getUserData() : 0; } - AnimData() : enabled(false) { } + AnimData() : mEnabled(false) { } void parseTargetString(const char* target, S32 fullCount, const char* elements[]); @@ -735,13 +735,13 @@ struct AnimData template struct AnimatedElement { - const daeElement* element; ///< The Collada element (can be NULL) - T defaultVal; ///< Default value (used when element is NULL) + const daeElement* mElement; ///< The Collada element (can be NULL) + T mDefaultVal; ///< Default value (used when element is NULL) - AnimatedElement(const daeElement* e=0) : element(e) { } + AnimatedElement(const daeElement* e=0) : mElement(e) { } /// Check if the element has any animations channels - bool isAnimated() { return (AnimData::getAnimChannels(element) != 0); } + bool isAnimated() { return (AnimData::getAnimChannels(mElement) != 0); } bool isAnimated(F32 start, F32 end) { return isAnimated(); } /// Get the value of the element at the specified time @@ -749,17 +749,17 @@ struct AnimatedElement { // If the element is NULL, just use the default (handy for profiles which // may or may not be present in the document) - T value(defaultVal); - if (const domAny* param = daeSafeCast(const_cast(element))) { + T value(mDefaultVal); + if (const domAny* param = daeSafeCast(const_cast(mElement))) { // If the element is not animated, just use its current value value = convert(param->getValue()); // Animate the value - const AnimChannels* channels = AnimData::getAnimChannels(element); + const AnimChannels* channels = AnimData::getAnimChannels(mElement); if (channels && (time >= 0)) { for (S32 iChannel = 0; iChannel < channels->size(); iChannel++) { const AnimData* animData = (*channels)[iChannel]; - if (animData->enabled) + if (animData->mEnabled) animData->interpValue(time, 0, &value); } } @@ -779,19 +779,19 @@ template struct AnimatedElementList : public AnimatedElement // Get the value of the element list at the specified time T getValue(F32 time) { - T vec(this->defaultVal); - if (this->element) { + T vec(this->mDefaultVal); + if (this->mElement) { // Get a copy of the vector - vec = *(T*)const_cast(this->element)->getValuePointer(); + vec = *(T*)const_cast(this->mElement)->getValuePointer(); // Animate the vector - const AnimChannels* channels = AnimData::getAnimChannels(this->element); + const AnimChannels* channels = AnimData::getAnimChannels(this->mElement); if (channels && (time >= 0)) { for (S32 iChannel = 0; iChannel < channels->size(); iChannel++) { const AnimData* animData = (*channels)[iChannel]; - if (animData->enabled) { - for (S32 iValue = 0; iValue < animData->targetValueCount; iValue++) - animData->interpValue(time, iValue, &vec[animData->targetValueOffset + iValue]); + if (animData->mEnabled) { + for (S32 iValue = 0; iValue < animData->mTargetValueCount; iValue++) + animData->interpValue(time, iValue, &vec[animData->mTargetValueOffset + iValue]); } } }