radiant/brush: use std::shared_ptr
authorAntoine Fontaine <antoine.fontaine@epfl.ch>
Sun, 28 Mar 2021 11:49:11 +0000 (13:49 +0200)
committerAntoine Fontaine <antoine.fontaine@epfl.ch>
Mon, 3 May 2021 23:03:43 +0000 (01:03 +0200)
radiant/brush.h
radiant/brushtokens.h
radiant/brushxml.h
radiant/csg.cpp

index 01a61fec2c7904730565b6c8257675b442d3d1cf..7eeeb1df7aefd1b9af7c03f6fc9075659949f48e 100644 (file)
@@ -1408,8 +1408,7 @@ inline bool plane3_inside( const Plane3& self, const Plane3& other, bool selfIsL
        return true;
 }
 
-typedef SmartPointer<Face> FaceSmartPointer;
-typedef std::vector<FaceSmartPointer> Faces;
+typedef std::vector<std::shared_ptr<Face>> Faces;
 
 /// \brief Returns the unique-id of the edge adjacent to \p faceVertex in the edge-pair for the set of \p faces.
 inline FaceVertexId next_edge( const Faces& faces, FaceVertexId faceVertex ){
@@ -1888,24 +1887,24 @@ public:
        }
 
        /// \brief Appends a copy of \p face to the end of the face list.
-       Face* addFace( const Face& face ){
+       std::shared_ptr<Face> addFace( const Face& face ){
                if ( m_faces.size() == c_brush_maxFaces ) {
                        return 0;
                }
                undoSave();
-               push_back( FaceSmartPointer( new Face( face, this ) ) );
+               push_back( std::make_shared<Face>( face, this ) );
                m_faces.back()->setDetail( isDetail() );
                planeChanged();
                return m_faces.back();
        }
 
        /// \brief Appends a new face constructed from the parameters to the end of the face list.
-       Face* addPlane( const Vector3& p0, const Vector3& p1, const Vector3& p2, const char* shader, const TextureProjection& projection ){
+       std::shared_ptr<Face> addPlane( const Vector3& p0, const Vector3& p1, const Vector3& p2, const char* shader, const TextureProjection& projection ){
                if ( m_faces.size() == c_brush_maxFaces ) {
                        return 0;
                }
                undoSave();
-               push_back( FaceSmartPointer( new Face( p0, p1, p2, shader, projection, this ) ) );
+               push_back( std::make_shared<Face>( p0, p1, p2, shader, projection, this ) );
                m_faces.back()->setDetail( isDetail() );
                planeChanged();
                return m_faces.back();
@@ -1949,11 +1948,11 @@ public:
                return m_faces.end();
        }
 
-       Face* back(){
+       std::shared_ptr<Face> back(){
                return m_faces.back();
        }
 
-       const Face* back() const {
+       const std::shared_ptr<Face> back() const {
                return m_faces.back();
        }
 
index 9b4d4fab05caaf3b63f87c66666eda79894cdf9a..af95360ae874f09d5aa41e2182fb51313696c5a5 100644 (file)
@@ -509,59 +509,58 @@ bool importTokens( Tokeniser& tokeniser ){
 
                tokeniser.ungetToken();
 
-               m_brush.push_back( FaceSmartPointer( new Face( &m_brush ) ) );
+               std::shared_ptr<Face> face = std::make_shared<Face>( &m_brush );
+               m_brush.push_back( face );
 
                //!todo BP support
                tokeniser.nextLine();
 
-               Face& face = *m_brush.back();
-
                switch ( Brush::m_type )
                {
                case eBrushTypeDoom3:
                {
-                       Doom3FaceTokenImporter importer( face );
+                       Doom3FaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                case eBrushTypeQuake4:
                {
-                       Quake4FaceTokenImporter importer( face );
+                       Quake4FaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                case eBrushTypeQuake2:
                {
-                       Quake2FaceTokenImporter importer( face );
+                       Quake2FaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                case eBrushTypeQuake3:
                {
-                       Quake3FaceTokenImporter importer( face );
+                       Quake3FaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                case eBrushTypeQuake3BP:
                {
-                       Quake3BPFaceTokenImporter importer( face );
+                       Quake3BPFaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                case eBrushTypeQuake:
                {
-                       QuakeFaceTokenImporter importer( face );
+                       QuakeFaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                case eBrushTypeHalfLife:
                {
-                       HalfLifeFaceTokenImporter importer( face );
+                       HalfLifeFaceTokenImporter importer( *face );
                        RETURN_FALSE_IF_FAIL( importer.importTokens( tokeniser ) );
                }
                break;
                }
-               face.planeChanged();
+               face->planeChanged();
        }
        if ( Brush::m_type == eBrushTypeQuake3BP || Brush::m_type == eBrushTypeDoom3 || Brush::m_type == eBrushTypeQuake4 ) {
                tokeniser.nextLine();
index c1fac55bccc0cdaced23d17a5cb3ebc5a9b0e590..d7add40832f583dda5d9ebcf1effe9c91627f714 100644 (file)
@@ -351,7 +351,7 @@ void pushElement( const XMLElement& element ){
        case xml_state_t::eBrush:
                ASSERT_MESSAGE( strcmp( element.name(), "plane" ) == 0, "parse error" );
                m_xml_state.push_back( xml_state_t::eFace );
-               m_brush.push_back( FaceSmartPointer( new Face( &m_brush ) ) );
+               m_brush.push_back( std::make_shared<Face>( &m_brush ) );
                constructor( faceImporter(), makeReference( *m_brush.back() ) );
                m_brush.planeChanged();
                m_brush.shaderChanged();
index 44fefdc863484ec9759fb806724b08f04268fa8c..337b394176b80d0ffa08d06a038e46131d9c6c5c 100644 (file)
@@ -33,7 +33,7 @@
 void Face_makeBrush( Face& face, const Brush& brush, brush_vector_t& out, float offset ){
        if ( face.contributes() ) {
                out.push_back( new Brush( brush ) );
-               Face* newFace = out.back()->addFace( face );
+               std::shared_ptr<Face> newFace = out.back()->addFace( face );
                if ( newFace != 0 ) {
                        newFace->flipWinding();
                        newFace->getPlane().offset( offset );
@@ -47,7 +47,7 @@ void Face_makeRoom( Face &face, const Brush &brush, brush_vector_t &out, float o
                face.getPlane().offset( offset );
                out.push_back( new Brush( brush ) );
                face.getPlane().offset( -offset );
-               Face* newFace = out.back()->addFace( face );
+               std::shared_ptr<Face> newFace = out.back()->addFace( face );
                if ( newFace != 0 ) {
                        newFace->flipWinding();
                        newFace->planeChanged();
@@ -204,15 +204,6 @@ inline Dereference<Functor> makeDereference( const Functor& functor ){
        return Dereference<Functor>( functor );
 }
 
-typedef Face* FacePointer;
-const FacePointer c_nullFacePointer = 0;
-
-template<typename Predicate>
-Face* Brush_findIf( const Brush& brush, const Predicate& predicate ){
-       Brush::const_iterator i = std::find_if( brush.begin(), brush.end(), makeDereference( predicate ) );
-       return i == brush.end() ? c_nullFacePointer : *i; // uses c_nullFacePointer instead of 0 because otherwise gcc 4.1 attempts conversion to int
-}
-
 template<typename Caller>
 class BindArguments1
 {
@@ -262,7 +253,6 @@ typedef Function<bool ( const Face &, const Plane3 &, bool ), Face_testPlane> Fa
 /// \li flipped && brush is FRONT or ON
 bool Brush_testPlane( const Brush& brush, const Plane3& plane, bool flipped ){
        brush.evaluateBRep();
-#if 1
        for ( Brush::const_iterator i( brush.begin() ); i != brush.end(); ++i )
        {
                if ( Face_testPlane( *( *i ), plane, flipped ) ) {
@@ -270,9 +260,6 @@ bool Brush_testPlane( const Brush& brush, const Plane3& plane, bool flipped ){
                }
        }
        return true;
-#else
-       return Brush_findIf( brush, bindArguments( FaceTestPlane(), makeReference( plane ), flipped ) ) == 0;
-#endif
 }
 
 brushsplit_t Brush_classifyPlane( const Brush& brush, const Plane3& plane ){
@@ -293,24 +280,24 @@ bool Brush_subtract( const Brush& brush, const Brush& other, brush_vector_t& ret
                fragments.reserve( other.size() );
                Brush back( brush );
 
-               for ( Brush::const_iterator i( other.begin() ); i != other.end(); ++i )
+               for ( const std::shared_ptr<Face>& b : other )
                {
-                       if ( ( *i )->contributes() ) {
-                               brushsplit_t split = Brush_classifyPlane( back, ( *i )->plane3() );
+                       if ( b->contributes() ) {
+                               brushsplit_t split = Brush_classifyPlane( back, b->plane3() );
                                if ( split.counts[ePlaneFront] != 0
                                         && split.counts[ePlaneBack] != 0 ) {
                                        fragments.push_back( new Brush( back ) );
-                                       Face* newFace = fragments.back()->addFace( *( *i ) );
-                                       if ( newFace != 0 ) {
+                                       std::shared_ptr<Face> newFace = fragments.back()->addFace( *b );
+                                       if ( newFace != nullptr ) {
                                                newFace->flipWinding();
                                        }
-                                       back.addFace( *( *i ) );
+                                       back.addFace( *b );
                                }
                                else if ( split.counts[ePlaneBack] == 0 ) {
-                                       for ( brush_vector_t::iterator i = fragments.begin(); i != fragments.end(); ++i )
-                                       {
-                                               delete( *i );
+                                       for ( Brush *i : fragments ) {
+                                               delete( i );
                                        }
+                                       fragments.clear();
                                        return false;
                                }
                        }
@@ -448,7 +435,8 @@ void post( const scene::Path& path, scene::Instance& instance ) const {
                                                NodeSmartReference node( ( new BrushNode() )->node() );
                                                Brush* fragment = Node_getBrush( node );
                                                fragment->copy( *brush );
-                                               Face* newFace = fragment->addPlane( m_p0, m_p1, m_p2, m_shader, m_projection );
+                                               std::shared_ptr<Face> newFace =
+                                                       fragment->addPlane( m_p0, m_p1, m_p2, m_shader, m_projection );
                                                if ( newFace != 0 && m_split != eFront ) {
                                                        newFace->flipWinding();
                                                }
@@ -463,7 +451,7 @@ void post( const scene::Path& path, scene::Instance& instance ) const {
                                                }
                                        }
 
-                                       Face* newFace = brush->addPlane( m_p0, m_p1, m_p2, m_shader, m_projection );
+                                       std::shared_ptr<Face> newFace = brush->addPlane( m_p0, m_p1, m_p2, m_shader, m_projection );
                                        if ( newFace != 0 && m_split == eFront ) {
                                                newFace->flipWinding();
                                        }