enum AnimationChannel -> enum class AnimationChannels

Source/Tools/AssetImporter/AssetImporter.cpp

@@ -1349,15 +1349,15 @@ void BuildAndSaveAnimations(OutModel* model)
             AnimationTrack* track = outAnim->CreateTrack(channelName);
 
             // Check which channels are used
-            track->channelMask_ = CHANNEL_NONE;
+            track->channelMask_ = AnimationChannels::None;
             if (channel->mNumPositionKeys > 1 || !posEqual)
-                track->channelMask_ |= CHANNEL_POSITION;
+                track->channelMask_ |= AnimationChannels::Position;
             if (channel->mNumRotationKeys > 1 || !rotEqual)
-                track->channelMask_ |= CHANNEL_ROTATION;
+                track->channelMask_ |= AnimationChannels::Rotation;
             if (channel->mNumScalingKeys > 1 || !scaleEqual)
-                track->channelMask_ |= CHANNEL_SCALE;
+                track->channelMask_ |= AnimationChannels::Scale;
             // Check for redundant identity scale in all keyframes and remove in that case
-            if (track->channelMask_ & CHANNEL_SCALE)
+            if (!!(track->channelMask_ & AnimationChannels::Scale))
             {
                 bool redundantScale = true;
                 for (unsigned k = 0; k < channel->mNumScalingKeys; ++k)
@@ -1372,7 +1372,7 @@ void BuildAndSaveAnimations(OutModel* model)
                     }
                 }
                 if (redundantScale)
-                    track->channelMask_ &= ~CHANNEL_SCALE;
+                    track->channelMask_ &= ~AnimationChannels::Scale;
             }
 
             if (!track->channelMask_)
@@ -1408,11 +1408,11 @@ void BuildAndSaveAnimations(OutModel* model)
                 kf.scale_ = Vector3::ONE;
 
                 // Get time for the keyframe. Adjust with animation's start time
-                if (track->channelMask_ & CHANNEL_POSITION && k < channel->mNumPositionKeys)
+                if (!!(track->channelMask_ & AnimationChannels::Position) && k < channel->mNumPositionKeys)
                     kf.time_ = ((float)channel->mPositionKeys[k].mTime - startTime);
-                else if (track->channelMask_ & CHANNEL_ROTATION && k < channel->mNumRotationKeys)
+                else if (!!(track->channelMask_ & AnimationChannels::Rotation) && k < channel->mNumRotationKeys)
                     kf.time_ = ((float)channel->mRotationKeys[k].mTime - startTime);
-                else if (track->channelMask_ & CHANNEL_SCALE && k < channel->mNumScalingKeys)
+                else if (!!(track->channelMask_ & AnimationChannels::Scale) && k < channel->mNumScalingKeys)
                     kf.time_ = ((float)channel->mScalingKeys[k].mTime - startTime);
 
                 // Make sure time stays positive
@@ -1424,11 +1424,11 @@ void BuildAndSaveAnimations(OutModel* model)
                 aiQuaternion rot;
                 boneTransform.Decompose(scale, rot, pos);
                 // Then apply the active channels
-                if (track->channelMask_ & CHANNEL_POSITION && k < channel->mNumPositionKeys)
+                if (!!(track->channelMask_ & AnimationChannels::Position) && k < channel->mNumPositionKeys)
                     pos = channel->mPositionKeys[k].mValue;
-                if (track->channelMask_ & CHANNEL_ROTATION && k < channel->mNumRotationKeys)
+                if (!!(track->channelMask_ & AnimationChannels::Rotation) && k < channel->mNumRotationKeys)
                     rot = channel->mRotationKeys[k].mValue;
-                if (track->channelMask_ & CHANNEL_SCALE && k < channel->mNumScalingKeys)
+                if (!!(track->channelMask_ & AnimationChannels::Scale) && k < channel->mNumScalingKeys)
                     scale = channel->mScalingKeys[k].mValue;
 
                 // If root bone, transform with nodes in between model root node (if any)
@@ -1446,11 +1446,11 @@ void BuildAndSaveAnimations(OutModel* model)
                         tform.Decompose(scale, rot, pos);
                 }
 
-                if (track->channelMask_ & CHANNEL_POSITION)
+                if (!!(track->channelMask_ & AnimationChannels::Position))
                     kf.position_ = ToVector3(pos);
-                if (track->channelMask_ & CHANNEL_ROTATION)
+                if (!!(track->channelMask_ & AnimationChannels::Rotation))
                     kf.rotation_ = ToQuaternion(rot);
-                if (track->channelMask_ & CHANNEL_SCALE)
+                if (!!(track->channelMask_ & AnimationChannels::Scale))
                     kf.scale_ = ToVector3(scale);
                 if (kf.time_ >= thisImportStartTime && kf.time_ <= thisImportEndTime)
                 {

Source/Tools/OgreImporter/OgreImporter.cpp

@@ -953,9 +953,9 @@ void WriteOutput(const String& outputFileName, bool exportAnimations, bool rotat
                     AnimationTrack newAnimationTrack;
                     newAnimationTrack.name_ = trackName;
                     if (!rotationsOnly)
-                        newAnimationTrack.channelMask_ = CHANNEL_POSITION | CHANNEL_ROTATION;
+                        newAnimationTrack.channelMask_ = AnimationChannels::Position | AnimationChannels::Rotation;
                     else
-                        newAnimationTrack.channelMask_ = CHANNEL_ROTATION;
+                        newAnimationTrack.channelMask_ = AnimationChannels::Rotation;
 
                     XMLElement keyFramesRoot = track.GetChild("keyframes");
                     XMLElement keyFrame = keyFramesRoot.GetChild("keyframe");
@@ -1017,17 +1017,17 @@ void WriteOutput(const String& outputFileName, bool exportAnimations, bool rotat
                 {
                     AnimationTrack& track = newAnimation.tracks_[i];
                     dest.WriteString(track.name_);
-                    dest.WriteUByte(track.channelMask_);
+                    dest.WriteUByte((u8)track.channelMask_);
                     dest.WriteUInt(track.keyFrames_.Size());
                     for (unsigned j = 0; j < track.keyFrames_.Size(); ++j)
                     {
                         AnimationKeyFrame& keyFrame = track.keyFrames_[j];
                         dest.WriteFloat(keyFrame.time_);
-                        if (track.channelMask_ & CHANNEL_POSITION)
+                        if (!!(track.channelMask_ & AnimationChannels::Position))
                             dest.WriteVector3(keyFrame.position_);
-                        if (track.channelMask_ & CHANNEL_ROTATION)
+                        if (!!(track.channelMask_ & AnimationChannels::Rotation))
                             dest.WriteQuaternion(keyFrame.rotation_);
-                        if (track.channelMask_ & CHANNEL_SCALE)
+                        if (!!(track.channelMask_ & AnimationChannels::Scale))
                             dest.WriteVector3(keyFrame.scale_);
                     }
                 }

Source/Urho3D/AngelScript/Generated_Enums.cpp

@@ -10,11 +10,11 @@
 namespace Urho3D
 {
 
-// enum AnimationChannel : unsigned char | File: ../Graphics/Animation.h
-static const unsigned char AnimationChannel_CHANNEL_NONE = CHANNEL_NONE;
-static const unsigned char AnimationChannel_CHANNEL_POSITION = CHANNEL_POSITION;
-static const unsigned char AnimationChannel_CHANNEL_ROTATION = CHANNEL_ROTATION;
-static const unsigned char AnimationChannel_CHANNEL_SCALE = CHANNEL_SCALE;
+// enum class AnimationChannels : u8 | File: ../Graphics/Animation.h
+static const u8 AnimationChannels_None = static_cast<u8>(AnimationChannels::None);
+static const u8 AnimationChannels_Position = static_cast<u8>(AnimationChannels::Position);
+static const u8 AnimationChannels_Rotation = static_cast<u8>(AnimationChannels::Rotation);
+static const u8 AnimationChannels_Scale = static_cast<u8>(AnimationChannels::Scale);
 
 // enum BoneCollisionShape : unsigned char | File: ../Graphics/Skeleton.h
 static const unsigned char BoneCollisionShape_BONECOLLISION_NONE = BONECOLLISION_NONE;
@@ -626,15 +626,14 @@ void ASRegisterGeneratedEnums(asIScriptEngine* engine)
     engine->RegisterEnumValue("AnimationBlendMode", "ABM_LERP", ABM_LERP);
     engine->RegisterEnumValue("AnimationBlendMode", "ABM_ADDITIVE", ABM_ADDITIVE);
 
-    // enum AnimationChannel : unsigned char | File: ../Graphics/Animation.h
-    engine->RegisterTypedef("AnimationChannel", "uint8");
-    engine->RegisterGlobalProperty("const uint8 CHANNEL_NONE", (void*)&AnimationChannel_CHANNEL_NONE);
-    engine->RegisterGlobalProperty("const uint8 CHANNEL_POSITION", (void*)&AnimationChannel_CHANNEL_POSITION);
-    engine->RegisterGlobalProperty("const uint8 CHANNEL_ROTATION", (void*)&AnimationChannel_CHANNEL_ROTATION);
-    engine->RegisterGlobalProperty("const uint8 CHANNEL_SCALE", (void*)&AnimationChannel_CHANNEL_SCALE);
-
-    // URHO3D_FLAGSET(AnimationChannel, AnimationChannelFlags) | File: ../Graphics/Animation.h
-    engine->RegisterTypedef("AnimationChannelFlags", "uint8");
+    // enum class AnimationChannels : u8 | File: ../Graphics/Animation.h
+    engine->RegisterTypedef("AnimationChannels", "uint8");
+    engine->SetDefaultNamespace("AnimationChannels");
+    engine->RegisterGlobalProperty("const uint8 None", (void*)&AnimationChannels_None);
+    engine->RegisterGlobalProperty("const uint8 Position", (void*)&AnimationChannels_Position);
+    engine->RegisterGlobalProperty("const uint8 Rotation", (void*)&AnimationChannels_Rotation);
+    engine->RegisterGlobalProperty("const uint8 Scale", (void*)&AnimationChannels_Scale);
+    engine->SetDefaultNamespace("");
 
     // enum AsyncLoadState | File: ../Resource/Resource.h
     engine->RegisterEnum("AsyncLoadState");

Source/Urho3D/AngelScript/Generated_Members.h

@@ -136,8 +136,8 @@ template <class T> void RegisterMembers_AnimationTrack(asIScriptEngine* engine,
     // StringHash AnimationTrack::nameHash_
     engine->RegisterObjectProperty(className, "StringHash nameHash", offsetof(T, nameHash_));
 
-    // AnimationChannelFlags AnimationTrack::channelMask_
-    engine->RegisterObjectProperty(className, "AnimationChannelFlags channelMask", offsetof(T, channelMask_));
+    // AnimationChannels AnimationTrack::channelMask_
+    engine->RegisterObjectProperty(className, "AnimationChannels channelMask", offsetof(T, channelMask_));
 
     #ifdef REGISTER_MEMBERS_MANUAL_PART_AnimationTrack
         REGISTER_MEMBERS_MANUAL_PART_AnimationTrack();

Source/Urho3D/Graphics/Animation.cpp

@@ -129,7 +129,7 @@ bool Animation::BeginLoad(Deserializer& source)
     for (unsigned i = 0; i < tracks; ++i)
     {
         AnimationTrack* newTrack = CreateTrack(source.ReadString());
-        newTrack->channelMask_ = AnimationChannelFlags(source.ReadUByte());
+        newTrack->channelMask_ = AnimationChannels(source.ReadUByte());
 
         unsigned keyFrames = source.ReadUInt();
         newTrack->keyFrames_.Resize(keyFrames);
@@ -140,11 +140,11 @@ bool Animation::BeginLoad(Deserializer& source)
         {
             AnimationKeyFrame& newKeyFrame = newTrack->keyFrames_[j];
             newKeyFrame.time_ = source.ReadFloat();
-            if (newTrack->channelMask_ & CHANNEL_POSITION)
+            if (!!(newTrack->channelMask_ & AnimationChannels::Position))
                 newKeyFrame.position_ = source.ReadVector3();
-            if (newTrack->channelMask_ & CHANNEL_ROTATION)
+            if (!!(newTrack->channelMask_ & AnimationChannels::Rotation))
                 newKeyFrame.rotation_ = source.ReadQuaternion();
-            if (newTrack->channelMask_ & CHANNEL_SCALE)
+            if (!!(newTrack->channelMask_ & AnimationChannels::Scale))
                 newKeyFrame.scale_ = source.ReadVector3();
         }
     }
@@ -220,7 +220,7 @@ bool Animation::Save(Serializer& dest) const
     {
         const AnimationTrack& track = i->second_;
         dest.WriteString(track.name_);
-        dest.WriteUByte(track.channelMask_);
+        dest.WriteUByte((u8)track.channelMask_);
         dest.WriteUInt(track.keyFrames_.Size());
 
         // Write keyframes of the track
@@ -228,11 +228,11 @@ bool Animation::Save(Serializer& dest) const
         {
             const AnimationKeyFrame& keyFrame = track.keyFrames_[j];
             dest.WriteFloat(keyFrame.time_);
-            if (track.channelMask_ & CHANNEL_POSITION)
+            if (!!(track.channelMask_ & AnimationChannels::Position))
                 dest.WriteVector3(keyFrame.position_);
-            if (track.channelMask_ & CHANNEL_ROTATION)
+            if (!!(track.channelMask_ & AnimationChannels::Rotation))
                 dest.WriteQuaternion(keyFrame.rotation_);
-            if (track.channelMask_ & CHANNEL_SCALE)
+            if (!!(track.channelMask_ & AnimationChannels::Scale))
                 dest.WriteVector3(keyFrame.scale_);
         }
     }

Source/Urho3D/Graphics/Animation.h

@@ -14,14 +14,14 @@
 namespace Urho3D
 {
 
-enum AnimationChannel : unsigned char
+enum class AnimationChannels : u8
 {
-    CHANNEL_NONE = 0x0,
-    CHANNEL_POSITION = 0x1,
-    CHANNEL_ROTATION = 0x2,
-    CHANNEL_SCALE = 0x4,
+    None     = 0,
+    Position = 1 << 0,
+    Rotation = 1 << 1,
+    Scale    = 1 << 2,
 };
-URHO3D_FLAGSET(AnimationChannel, AnimationChannelFlags);
+URHO3D_FLAGS(AnimationChannels);
 
 /// Skeletal animation keyframe.
 struct AnimationKeyFrame
@@ -77,7 +77,7 @@ struct URHO3D_API AnimationTrack
     /// Name hash.
     StringHash nameHash_;
     /// Bitmask of included data (position, rotation, scale).
-    AnimationChannelFlags channelMask_{};
+    AnimationChannels channelMask_{};
     /// Keyframes.
     Vector<AnimationKeyFrame> keyFrames_;
 };

Source/Urho3D/Graphics/AnimationState.cpp

@@ -481,7 +481,7 @@ void AnimationState::ApplyTrack(AnimationStateTrack& stateTrack, float weight, b
     }
 
     const AnimationKeyFrame* keyFrame = &track->keyFrames_[frame];
-    const AnimationChannelFlags channelMask = track->channelMask_;
+    const AnimationChannels channelMask = track->channelMask_;
 
     Vector3 newPosition;
     Quaternion newRotation;
@@ -495,38 +495,38 @@ void AnimationState::ApplyTrack(AnimationStateTrack& stateTrack, float weight, b
             timeInterval += animation_->GetLength();
         float t = timeInterval > 0.0f ? (time_ - keyFrame->time_) / timeInterval : 1.0f;
 
-        if (channelMask & CHANNEL_POSITION)
+        if (!!(channelMask & AnimationChannels::Position))
             newPosition = keyFrame->position_.Lerp(nextKeyFrame->position_, t);
-        if (channelMask & CHANNEL_ROTATION)
+        if (!!(channelMask & AnimationChannels::Rotation))
             newRotation = keyFrame->rotation_.Slerp(nextKeyFrame->rotation_, t);
-        if (channelMask & CHANNEL_SCALE)
+        if (!!(channelMask & AnimationChannels::Scale))
             newScale = keyFrame->scale_.Lerp(nextKeyFrame->scale_, t);
     }
     else
     {
-        if (channelMask & CHANNEL_POSITION)
+        if (!!(channelMask & AnimationChannels::Position))
             newPosition = keyFrame->position_;
-        if (channelMask & CHANNEL_ROTATION)
+        if (!!(channelMask & AnimationChannels::Rotation))
             newRotation = keyFrame->rotation_;
-        if (channelMask & CHANNEL_SCALE)
+        if (!!(channelMask & AnimationChannels::Scale))
             newScale = keyFrame->scale_;
     }
 
     if (blendingMode_ == ABM_ADDITIVE) // not ABM_LERP
     {
-        if (channelMask & CHANNEL_POSITION)
+        if (!!(channelMask & AnimationChannels::Position))
         {
             Vector3 delta = newPosition - stateTrack.bone_->initialPosition_;
             newPosition = node->GetPosition() + delta * weight;
         }
-        if (channelMask & CHANNEL_ROTATION)
+        if (!!(channelMask & AnimationChannels::Rotation))
         {
             Quaternion delta = newRotation * stateTrack.bone_->initialRotation_.Inverse();
             newRotation = (delta * node->GetRotation()).Normalized();
             if (!Equals(weight, 1.0f))
                 newRotation = node->GetRotation().Slerp(newRotation, weight);
         }
-        if (channelMask & CHANNEL_SCALE)
+        if (!!(channelMask & AnimationChannels::Scale))
         {
             Vector3 delta = newScale - stateTrack.bone_->initialScale_;
             newScale = node->GetScale() + delta * weight;
@@ -536,31 +536,31 @@ void AnimationState::ApplyTrack(AnimationStateTrack& stateTrack, float weight, b
     {
         if (!Equals(weight, 1.0f)) // not full weight
         {
-            if (channelMask & CHANNEL_POSITION)
+            if (!!(channelMask & AnimationChannels::Position))
                 newPosition = node->GetPosition().Lerp(newPosition, weight);
-            if (channelMask & CHANNEL_ROTATION)
+            if (!!(channelMask & AnimationChannels::Rotation))
                 newRotation = node->GetRotation().Slerp(newRotation, weight);
-            if (channelMask & CHANNEL_SCALE)
+            if (!!(channelMask & AnimationChannels::Scale))
                 newScale = node->GetScale().Lerp(newScale, weight);
         }
     }
 
     if (silent)
     {
-        if (channelMask & CHANNEL_POSITION)
+        if (!!(channelMask & AnimationChannels::Position))
             node->SetPositionSilent(newPosition);
-        if (channelMask & CHANNEL_ROTATION)
+        if (!!(channelMask & AnimationChannels::Rotation))
             node->SetRotationSilent(newRotation);
-        if (channelMask & CHANNEL_SCALE)
+        if (!!(channelMask & AnimationChannels::Scale))
             node->SetScaleSilent(newScale);
     }
     else
     {
-        if (channelMask & CHANNEL_POSITION)
+        if (!!(channelMask & AnimationChannels::Position))
             node->SetPosition(newPosition);
-        if (channelMask & CHANNEL_ROTATION)
+        if (!!(channelMask & AnimationChannels::Rotation))
             node->SetRotation(newRotation);
-        if (channelMask & CHANNEL_SCALE)
+        if (!!(channelMask & AnimationChannels::Scale))
             node->SetScale(newScale);
     }
 }