bugfix: Fixed the memory leak when texture transforming (#6236) (#6237)

* bugfix: Fixed the memory leak when texture transforming (#6236)

---------

Co-authored-by: Kim Kulling <[email protected]>

code/PostProcessing/TextureTransform.cpp

@@ -1,7 +1,6 @@
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
-
 Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
@@ -35,27 +34,20 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
 ----------------------------------------------------------------------
 */
 
 /** @file A helper class that processes texture transformations */
 
+#include "TextureTransform.h"
+
 #include <assimp/Importer.hpp>
 #include <assimp/postprocess.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
-
-#include "TextureTransform.h"
 #include <assimp/StringUtils.h>
 
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-TextureTransformStep::TextureTransformStep() : configFlags()  {
-    // nothing to do here
-}
+namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
@@ -202,7 +194,6 @@ inline static const char* MappingModeToChar(aiTextureMapMode map) {
 void TextureTransformStep::Execute( aiScene* pScene) {
     ASSIMP_LOG_DEBUG("TransformUVCoordsProcess begin");
 
-
     /*  We build a per-mesh list of texture transformations we'll need
      *  to apply. To achieve this, we iterate through all materials,
      *  find all textures and get their transformations and UV indices.
@@ -426,7 +417,6 @@ void TextureTransformStep::Execute( aiScene* pScene) {
         // it shouldn't be too worse if we remove them.
         unsigned int size = (unsigned int)trafo.size();
         if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
-
             if (!DefaultLogger::isNullLogger()) {
                 ASSIMP_LOG_ERROR(static_cast<unsigned int>(trafo.size()), " UV channels required but just ",
                     AI_MAX_NUMBER_OF_TEXTURECOORDS, " available");
@@ -434,7 +424,6 @@ void TextureTransformStep::Execute( aiScene* pScene) {
             size = AI_MAX_NUMBER_OF_TEXTURECOORDS;
         }
 
-
         aiVector3D* old[AI_MAX_NUMBER_OF_TEXTURECOORDS];
         for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
             old[n] = mesh->mTextureCoords[n];
@@ -443,14 +432,13 @@ void TextureTransformStep::Execute( aiScene* pScene) {
         // that we're not going to need later can be overridden.
         it = trafo.begin();
         for (unsigned int n = 0; n < trafo.size();++n,++it) {
-
             if (n >= size)  {
                 // Try to use an untransformed channel for all channels we threw over board
                 UpdateUVIndex((*it).updateList,untransformed);
                 continue;
             }
 
-            outChannels++;
+            ++outChannels;
 
             // Write to the log
             if (!DefaultLogger::isNullLogger()) {
@@ -470,15 +458,18 @@ void TextureTransformStep::Execute( aiScene* pScene) {
             // Check whether we need a new buffer here
             if (mesh->mTextureCoords[n])    {
 
-                it2 = it;++it2;
+                it2 = it;
+		++it2;
                 for (unsigned int m = n+1; m < size;++m, ++it2) {
-
                     if ((*it2).uvIndex == n){
                         it2 = trafo.begin();
                         break;
                     }
                 }
-                if (it2 == trafo.begin()){
+                if (it2 == trafo.begin()) { 	            
+		    {
+                        std::unique_ptr<aiVector3D[]> oldTextureCoords(mesh->mTextureCoords[n]);
+                    }
                     mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
                 }
             }
@@ -536,13 +527,12 @@ void TextureTransformStep::Execute( aiScene* pScene) {
 
     // Print some detailed statistics into the log
     if (!DefaultLogger::isNullLogger()) {
-
         if (transformedChannels)    {
             ASSIMP_LOG_INFO("TransformUVCoordsProcess end: ", outChannels, " output channels (in: ", inChannels, ", modified: ", transformedChannels,")");
         } else {
-            ASSIMP_LOG_DEBUG("TransformUVCoordsProcess finished");
+            ASSIMP_LOG_INFO("TransformUVCoordsProcess finished");
         }
     }
 }
 
-
+} // namespace Assimp

code/PostProcessing/TextureTransform.h

@@ -1,7 +1,6 @@
 /*
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
-
 Copyright (c) 2006-2025, assimp team
 
 All rights reserved.
@@ -43,9 +42,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_TEXTURE_TRANSFORM_H_INCLUDED
 #define AI_TEXTURE_TRANSFORM_H_INCLUDED
 
-#include <assimp/BaseImporter.h>
 #include "Common/BaseProcess.h"
 
+#include <assimp/BaseImporter.h>
 #include <assimp/material.h>
 #include <list>
 
@@ -56,129 +55,103 @@ namespace Assimp {
 
 #define AI_TT_UV_IDX_LOCK_TBD   0xffffffff
 #define AI_TT_UV_IDX_LOCK_NONE  0xeeeeeeee
-
-
 #define AI_TT_ROTATION_EPSILON  ((float)AI_DEG_TO_RAD(0.5))
 
 // ---------------------------------------------------------------------------
-/** Small helper structure representing a shortcut into the material list
- *  to be able to update some values quickly.
-*/
+/** 
+ * @brief Small helper structure representing a shortcut into the material list
+ *        to be able to update some values quickly.
+ */
 struct TTUpdateInfo {
-    TTUpdateInfo() AI_NO_EXCEPT
-    : directShortcut(nullptr)
-    , mat(nullptr)
-    , semantic(0)
-    , index(0) {
-        // empty
-    }
-
     //! Direct shortcut, if available
-    unsigned int* directShortcut;
+    unsigned int* directShortcut = nullptr;
 
     //! Material
-    aiMaterial *mat;
+    aiMaterial *mat = nullptr;
 
-    //! Texture type and index
-    unsigned int semantic, index;
-};
+    //! Texture type
+    unsigned int semantic = 0;
 
+    //! Texture index
+    unsigned int index = 0;
+};
 
 // ---------------------------------------------------------------------------
-/** Helper class representing texture coordinate transformations
-*/
+/** 
+ * @brief  Helper class representing texture coordinate transformations
+ */
 struct STransformVecInfo : public aiUVTransform {
-    STransformVecInfo() AI_NO_EXCEPT
-    : uvIndex(0)
-    , mapU(aiTextureMapMode_Wrap)
-    , mapV(aiTextureMapMode_Wrap)
-    , lockedPos(AI_TT_UV_IDX_LOCK_NONE) {
-        // empty
-    }
-
     //! Source texture coordinate index
-    unsigned int uvIndex;
+    unsigned int uvIndex = 0;
+
+    //! Texture mapping mode in the u direction
+    aiTextureMapMode mapU = aiTextureMapMode_Wrap;
 
-    //! Texture mapping mode in the u, v direction
-    aiTextureMapMode mapU,mapV;
+    //! Texture mapping mode in the v direction
+    aiTextureMapMode mapV = aiTextureMapMode_Wrap;
 
     //! Locked destination UV index
     //! AI_TT_UV_IDX_LOCK_TBD - to be determined
     //! AI_TT_UV_IDX_LOCK_NONE - none (default)
-    unsigned int lockedPos;
+    unsigned int lockedPos = AI_TT_UV_IDX_LOCK_NONE;
 
     //! Update info - shortcuts into all materials
     //! that are referencing this transform setup
     std::list<TTUpdateInfo> updateList;
 
-
-    // -------------------------------------------------------------------
-    /** Compare two transform setups
-    */
-    inline bool operator== (const STransformVecInfo& other) const
-    {
+    inline bool operator== (const STransformVecInfo& other) const {
         // We use a small epsilon here
         const static float epsilon = 0.05f;
 
         if (std::fabs( mTranslation.x - other.mTranslation.x ) > epsilon ||
-            std::fabs( mTranslation.y - other.mTranslation.y ) > epsilon)
-        {
+                std::fabs( mTranslation.y - other.mTranslation.y ) > epsilon) {
             return false;
         }
 
         if (std::fabs( mScaling.x - other.mScaling.x ) > epsilon ||
-            std::fabs( mScaling.y - other.mScaling.y ) > epsilon)
-        {
+                std::fabs( mScaling.y - other.mScaling.y ) > epsilon) {
             return false;
         }
 
-        if (std::fabs( mRotation - other.mRotation) > epsilon)
-        {
+        if (std::fabs( mRotation - other.mRotation) > epsilon) {
             return false;
         }
         return true;
     }
 
-    inline bool operator!= (const STransformVecInfo& other) const
-    {
+    inline bool operator!= (const STransformVecInfo& other) const {
             return !(*this == other);
     }
 
-
     // -------------------------------------------------------------------
-    /** Returns whether this is an untransformed texture coordinate set
-    */
-    inline bool IsUntransformed() const
-    {
+    /** 
+     * @brief Returns whether this is an untransformed texture coordinate set
+     */
+    inline bool IsUntransformed() const {
         return (1.0f == mScaling.x && 1.f == mScaling.y &&
-            !mTranslation.x && !mTranslation.y &&
-            mRotation < AI_TT_ROTATION_EPSILON);
+            !mTranslation.x && !mTranslation.y && mRotation < AI_TT_ROTATION_EPSILON);
     }
 
     // -------------------------------------------------------------------
-    /** Build a 3x3 matrix from the transformations
-    */
-    inline void GetMatrix(aiMatrix3x3& mOut)
-    {
+    /** 
+     * @brief Build a 3x3 matrix from the transformations
+     */
+    inline void GetMatrix(aiMatrix3x3& mOut) {
         mOut = aiMatrix3x3();
-
-        if (1.0f != mScaling.x || 1.0f != mScaling.y)
-        {
+        if (1.0f != mScaling.x || 1.0f != mScaling.y) {
             aiMatrix3x3 mScale;
             mScale.a1 = mScaling.x;
             mScale.b2 = mScaling.y;
             mOut = mScale;
         }
-        if (mRotation)
-        {
+        if (mRotation) {
             aiMatrix3x3 mRot;
             mRot.a1 = mRot.b2 = std::cos(mRotation);
             mRot.a2 = mRot.b1 = std::sin(mRotation);
             mRot.a2 = -mRot.a2;
             mOut *= mRot;
         }
-        if (mTranslation.x || mTranslation.y)
-        {
+        if (mTranslation.x || mTranslation.y) {
             aiMatrix3x3 mTrans;
             mTrans.a3 = mTranslation.x;
             mTrans.b3 = mTranslation.y;
@@ -187,16 +160,18 @@ struct STransformVecInfo : public aiUVTransform {
     }
 };
 
-
 // ---------------------------------------------------------------------------
-/** Helper step to compute final UV coordinate sets if there are scalings
+/** 
+ * @brief Helper step to compute final UV coordinate sets if there are scalings
  *  or rotations in the original data read from the file.
-*/
-class TextureTransformStep : public BaseProcess {
+ */
+class TextureTransformStep final : public BaseProcess {
 public:
     // -------------------------------------------------------------------
-    /// The default class constructor / destructor.
-    TextureTransformStep();
+    /// The default class constructor. / 
+    TextureTransformStep() = default;
+
+    /// The default class destructor.
     ~TextureTransformStep() override = default;
 
     // -------------------------------------------------------------------
@@ -210,10 +185,11 @@ public:
 
 protected:
     // -------------------------------------------------------------------
-    /** Preprocess a specific UV transformation setup
+    /** 
+     * @brief Preprocess a specific UV transformation setup
      *
      *  @param info Transformation setup to be preprocessed.
-    */
+     */
     void PreProcessUVTransform(STransformVecInfo& info);
 
 private: