Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Apr 28, 2011, 7:15:14 AM (14 years ago)
Author:
rgrieder
Message:

Merged kicklib2 branch back to trunk (includes former branches ois_update, mac_osx and kicklib).

Notes for updating

Linux:
You don't need an extra package for CEGUILua and Tolua, it's already shipped with CEGUI.
However you do need to make sure that the OgreRenderer is installed too with CEGUI 0.7 (may be a separate package).
Also, Orxonox now recognises if you install the CgProgramManager (a separate package available on newer Ubuntu on Debian systems).

Windows:
Download the new dependency packages versioned 6.0 and use these. If you have problems with that or if you don't like the in game console problem mentioned below, you can download the new 4.3 version of the packages (only available for Visual Studio 2005/2008).

Key new features:

  • *Support for Mac OS X*
  • Visual Studio 2010 support
  • Bullet library update to 2.77
  • OIS library update to 1.3
  • Support for CEGUI 0.7 —> Support for Arch Linux and even SuSE
  • Improved install target
  • Compiles now with GCC 4.6
  • Ogre Cg Shader plugin activated for Linux if available
  • And of course lots of bug fixes

There are also some regressions:

  • No support for CEGUI 0.5, Ogre 1.4 and boost 1.35 - 1.39 any more
  • In game console is not working in main menu for CEGUI 0.7
  • Tolua (just the C lib, not the application) and CEGUILua libraries are no longer in our repository. —> You will need to get these as well when compiling Orxonox
  • And of course lots of new bugs we don't yet know about
Location:
code/trunk/src/libraries/util
Files:
11 edited

Legend:

Unmodified
Added
Removed

  • code/trunk/src/libraries/util/CMakeLists.txt

    r7449 r8351  
    1919
    2020SET_SOURCE_FILES(UTIL_SRC_FILES
    21   Clock.cc
    22   Exception.cc
    23   ExprParser.cc
    24   Math.cc
    25   MultiType.cc
    26   Scope.cc
    27   StringUtils.cc
    2821COMPILATION_BEGIN StableCompilation.cc
    2922  Clipboard.cc
     23  Clock.cc
    3024  Convert.cc
    3125  CRC32.cc
     26  ExprParser.cc
    3227  OutputHandler.cc
     28  Scope.cc
    3329  ScopedSingletonManager.cc
    3430  SharedPtr.cc
    35   SignalHandler.cc
    3631  Sleep.cc
    3732  SmallObjectAllocator.cc
    3833  SubString.cc
    3934COMPILATION_END
     35
     36  MultiType.cc
     37  Exception.cc
     38  Math.cc
     39  SignalHandler.cc
     40  StringUtils.cc
    4041)
    4142
    42 IF(GCC_NO_SYSTEM_HEADER_SUPPORT)
    43   # Get around displaying a few hundred lines of warning code
    44   SET_SOURCE_FILES_PROPERTIES(MultiType.cc PROPERTIES COMPILE_FLAGS "-w")
    45 ENDIF()
    4643IF(MSVC)
    4744  # Simply using #pragma warning(disable:4244) doesn't really disable it

  • code/trunk/src/libraries/util/Convert.h

    r7401 r8351  
    143143    struct ConverterFallback
    144144    {
    145         FORCEINLINE static bool convert(ToType* output, const FromType& input)
     145        ORX_FORCEINLINE static bool convert(ToType* output, const FromType& input)
    146146        {
    147147            COUT(2) << "Could not convert value of type " << typeid(FromType).name()
    … …  
    155155    struct ConverterFallback<FromType*, ToType*>
    156156    {
    157         FORCEINLINE static bool convert(ToType** output, FromType* const input)
     157        ORX_FORCEINLINE static bool convert(ToType** output, FromType* const input)
    158158        {
    159159            ToType* temp = dynamic_cast<ToType*>(input);
    … …  
    182182struct ConverterStringStream
    183183{
    184     FORCEINLINE static bool convert(ToType* output, const FromType& input)
     184    ORX_FORCEINLINE static bool convert(ToType* output, const FromType& input)
    185185    {
    186186        return orxonox::ConverterFallback<FromType, ToType>::convert(output, input);
    … …  
    198198    /// Fallback operator <<() (delegates to orxonox::ConverterFallback)
    199199    template <class FromType>
    200     FORCEINLINE bool operator <<(std::ostream& outstream,  const FromType& input)
     200    ORX_FORCEINLINE bool operator <<(std::ostream& outstream,  const FromType& input)
    201201    {
    202202        std::string temp;
    … …  
    215215struct ConverterStringStream<FromType, std::string>
    216216{
    217     FORCEINLINE static bool convert(std::string* output, const FromType& input)
     217    ORX_FORCEINLINE static bool convert(std::string* output, const FromType& input)
    218218    {
    219219        using namespace fallbackTemplates;
    … …  
    241241    /// Fallback operator >>() (delegates to orxonox::ConverterFallback)
    242242    template <class ToType>
    243     FORCEINLINE bool operator >>(std::istream& instream, ToType& output)
     243    ORX_FORCEINLINE bool operator >>(std::istream& instream, ToType& output)
    244244    {
    245245        std::string input(static_cast<std::istringstream&>(instream).str());
    … …  
    252252struct ConverterStringStream<std::string, ToType>
    253253{
    254     FORCEINLINE static bool convert(ToType* output, const std::string& input)
     254    ORX_FORCEINLINE static bool convert(ToType* output, const std::string& input)
    255255    {
    256256        using namespace fallbackTemplates;
    … …  
    276276    /// %Template delegates to ::ConverterStringStream
    277277    template <class FromType, class ToType>
    278     FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<false>)
     278    ORX_FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<false>)
    279279    {
    280280        return ConverterStringStream<FromType, ToType>::convert(output, input);
    … …  
    283283    /// Makes an implicit cast from \a FromType to \a ToType
    284284    template <class FromType, class ToType>
    285     FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<true>)
     285    ORX_FORCEINLINE bool convertImplicitely(ToType* output, const FromType& input, Loki::Int2Type<true>)
    286286    {
    287287        (*output) = static_cast<ToType>(input);
    … …  
    303303    {
    304304        enum { probe = ImplicitConversion<FromType, ToType>::exists };
    305         FORCEINLINE static bool convert(ToType* output, const FromType& input)
     305        ORX_FORCEINLINE static bool convert(ToType* output, const FromType& input)
    306306        {
    307307            // Use the probe's value to delegate to the right function
    … …  
    327327    */
    328328    template <class FromType, class ToType>
    329     FORCEINLINE bool convertValue(ToType* output, const FromType& input)
     329    ORX_FORCEINLINE bool convertValue(ToType* output, const FromType& input)
    330330    {
    331331        return ConverterExplicit<FromType, ToType>::convert(output, input);
    … …  
    348348    */
    349349    template<class FromType, class ToType>
    350     FORCEINLINE bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
     350    ORX_FORCEINLINE bool convertValue(ToType* output, const FromType& input, const ToType& fallback)
    351351    {
    352352        if (convertValue(output, input))
    … …  
    361361    /// Directly returns the converted value, but uses the fallback on failure. @see convertValue
    362362    template<class FromType, class ToType>
    363     FORCEINLINE ToType getConvertedValue(const FromType& input, const ToType& fallback)
     363    ORX_FORCEINLINE ToType getConvertedValue(const FromType& input, const ToType& fallback)
    364364    {
    365365        ToType output;
    … …  
    380380    */
    381381    template<class ToType, class FromType>
    382     FORCEINLINE ToType multi_cast(const FromType& input)
     382    ORX_FORCEINLINE ToType multi_cast(const FromType& input)
    383383    {
    384384        ToType output;
    … …  
    395395    struct ConverterExplicit<const char*, ToType>
    396396    {
    397         FORCEINLINE static bool convert(ToType* output, const char* input)
     397        ORX_FORCEINLINE static bool convert(ToType* output, const char* input)
    398398        {
    399399            return convertValue<std::string, ToType>(output, input);
    … …  
    405405    struct ConverterExplicit<char, std::string>
    406406    {
    407         FORCEINLINE static bool convert(std::string* output, const char input)
     407        ORX_FORCEINLINE static bool convert(std::string* output, const char input)
    408408        {
    409409            *output = input;
    … …  
    415415    struct ConverterExplicit<unsigned char, std::string>
    416416    {
    417         FORCEINLINE static bool convert(std::string* output, const unsigned char input)
     417        ORX_FORCEINLINE static bool convert(std::string* output, const unsigned char input)
    418418        {
    419419            *output = input;
    … …  
    425425    struct ConverterExplicit<std::string, char>
    426426    {
    427         FORCEINLINE static bool convert(char* output, const std::string& input)
     427        ORX_FORCEINLINE static bool convert(char* output, const std::string& input)
    428428        {
    429429            if (!input.empty())
    … …  
    438438    struct ConverterExplicit<std::string, unsigned char>
    439439    {
    440         FORCEINLINE static bool convert(unsigned char* output, const std::string& input)
     440        ORX_FORCEINLINE static bool convert(unsigned char* output, const std::string& input)
    441441        {
    442442            if (!input.empty())
    … …  
    453453    struct ConverterExplicit<bool, std::string>
    454454    {
    455         FORCEINLINE static bool convert(std::string* output, const bool& input)
     455        ORX_FORCEINLINE static bool convert(std::string* output, const bool& input)
    456456        {
    457457            if (input)

  • code/trunk/src/libraries/util/Exception.cc

    r7401 r8351  
    3535#include "Exception.h"
    3636
     37#include <cstddef>
    3738#include <CEGUIExceptions.h>
    3839#include "Debug.h"
    … …  
    9596            throw;
    9697        }
     98        catch (const CEGUI::Exception& ex)
     99        {
     100            return GeneralException(ex.getMessage().c_str(), ex.getLine(),
     101                ex.getFileName().c_str(), ex.getName().c_str()).getDescription();
     102        }
    97103        catch (const std::exception& ex)
    98104        {
    99105            return ex.what();
    100         }
    101         catch (const CEGUI::Exception& ex)
    102         {
    103 #if CEGUI_VERSION_MAJOR == 0 && CEGUI_VERSION_MINOR < 6
    104             return GeneralException(ex.getMessage().c_str()).getDescription();
    105 #else
    106             return GeneralException(ex.getMessage().c_str(), ex.getLine(),
    107                 ex.getFileName().c_str(), ex.getName().c_str()).getDescription();
    108 #endif
    109106        }
    110107        catch (...)

  • code/trunk/src/libraries/util/ExprParser.cc

    r7184 r8351  
    5252    {
    5353        this->failed_ = false;
    54         this->variables_["pi"] = math::pi_d;
    55         this->variables_["e"] = math::e_d;
    56     }
    57 
    58     void ExprParser::setVariable(const std::string& varname, double value)
     54        this->variables_["pi"] = math::pi;
     55        this->variables_["e"] = math::e;
     56    }
     57
     58    void ExprParser::setVariable(const std::string& varname, float value)
    5959    {
    6060        this->variables_[varname] = value;
    … …  
    7878    //Private functions:
    7979    /******************/
    80     double ExprParser::parse_argument()
    81     {
    82         double value = parse_expr_8();
     80    float ExprParser::parse_argument()
     81    {
     82        float value = parse_expr_8();
    8383        if (*reading_stream == ',')
    8484        {
    … …  
    9393    }
    9494
    95     double ExprParser::parse_last_argument()
    96     {
    97         double value = parse_expr_8();
     95    float ExprParser::parse_last_argument()
     96    {
     97        float value = parse_expr_8();
    9898        if (*reading_stream == ')')
    9999        {
    … …  
    108108    }
    109109
    110     double ExprParser::parse_expr_8()
    111     {
    112         double value = parse_expr_7();
     110    float ExprParser::parse_expr_8()
     111    {
     112        float value = parse_expr_7();
    113113        for(;;)
    114114        {
    … …  
    124124
    125125
    126     double ExprParser::parse_expr_7()
    127     {
    128         double value = parse_expr_6();
     126    float ExprParser::parse_expr_7()
     127    {
     128        float value = parse_expr_6();
    129129        for(;;)
    130130        {
    … …  
    139139    }
    140140
    141     double ExprParser::parse_expr_6()
    142     {
    143         double value = parse_expr_5();
     141    float ExprParser::parse_expr_6()
     142    {
     143        float value = parse_expr_5();
    144144        for(;;)
    145145        {
    … …  
    158158    }
    159159
    160     double ExprParser::parse_expr_5()
    161     {
    162         double value = parse_expr_4();
     160    float ExprParser::parse_expr_5()
     161    {
     162        float value = parse_expr_4();
    163163        for(;;)
    164164        {
    … …  
    183183    }
    184184
    185     double ExprParser::parse_expr_4()
    186     {
    187         double value = parse_expr_3();
     185    float ExprParser::parse_expr_4()
     186    {
     187        float value = parse_expr_3();
    188188        for(;;)
    189189        {
    … …  
    202202    }
    203203
    204     double ExprParser::parse_expr_3()
    205     {
    206         double value = parse_expr_2();
     204    float ExprParser::parse_expr_3()
     205    {
     206        float value = parse_expr_2();
    207207        for(;;)
    208208        {
    … …  
    217217            case modulo:
    218218                {
    219                     double temp = parse_expr_2();
     219                    float temp = parse_expr_2();
    220220                    value = value - floor(value/temp)*temp;
    221221                    break;
    … …  
    227227    }
    228228
    229     double ExprParser::parse_expr_2()
    230     {
    231         double value = parse_expr_1();
     229    float ExprParser::parse_expr_2()
     230    {
     231        float value = parse_expr_1();
    232232        while (*reading_stream != '\0')
    233233        {
    … …  
    246246    }
    247247
    248     double ExprParser::parse_expr_1()
     248    float ExprParser::parse_expr_1()
    249249    {
    250250        PARSE_BLANKS;
    251         double value;
     251        float value;
    252252
    253253        unary_operator op = parse_unary_operator();
    … …  
    262262        else if ((*reading_stream > 47 && *reading_stream < 59) || *reading_stream == 46)
    263263        {  // number
    264             value = strtod(reading_stream, const_cast<char**>(&reading_stream));
     264            value = (float)strtod(reading_stream, const_cast<char**>(&reading_stream));
    265265        }
    266266        else if ((*reading_stream > 64 && *reading_stream < 91) || (*reading_stream > 96 && *reading_stream < 123) || *reading_stream == 46)
    … …  
    306306                {
    307307                    value = parse_last_argument();
    308                     value = 0.5*log((value + 1)/(value - 1));
     308                    value = 0.5f*log((value + 1.0f)/(value - 1.0f));
    309309                }
    310310                CASE("int")
    … …  
    325325                {
    326326                    value = parse_last_argument();
    327                     value = (value>0 ? 1 : (value<0 ? -1 : 0));
     327                    value = (value>0.0f ? 1.0f : (value<0.0f ? -1.0f : 0.0f));
    328328                }
    329329                CASE("sqrt")
    330330                    value = sqrt(parse_last_argument());
    331331                CASE("degrees")
    332                     value = parse_last_argument()*180/math::pi_d;
     332                    value = parse_last_argument()*180.0f/math::pi;
    333333                CASE("radians")
    334                     value = parse_last_argument()*math::pi_d/180;
     334                    value = parse_last_argument()*math::pi/180.0f;
    335335                CASE("mod")
    336336                {
    337337                    value = parse_argument();
    338                     double value2 = parse_last_argument();
     338                    float value2 = parse_last_argument();
    339339                    value = value - floor(value/value2)*value2;
    340340                }
    … …  
    356356            else
    357357            {
    358                 std::map<std::string, double>::const_iterator it = this->variables_.find(word);
     358                std::map<std::string, float>::const_iterator it = this->variables_.find(word);
    359359                if (it != this->variables_.end())
    360360                    value = it->second;

  • code/trunk/src/libraries/util/ExprParser.h

    r7401 r8351  
    5757                COUT(2) << "Warning: Expression could not be parsed to the end! Remains: '" << expr.getRemains() << '\'' << std::endl;
    5858            }
    59             double result = expr.getResult();
     59            float result = expr.getResult();
    6060        }
    6161        else
    … …  
    125125        void parse(const std::string& str);
    126126        const std::string& getRemains() { return  this->remains_; }
    127         double             getResult()  { return  this->result_; }
     127        float              getResult()  { return  this->result_; }
    128128        bool               getSuccess() { return !this->failed_; }
    129129
    130         void setVariable(const std::string& varname, double value);
     130        void setVariable(const std::string& varname, float value);
    131131
    132132    private:
    133         double parse_expr_1();
    134         double parse_expr_2();
    135         double parse_expr_3();
    136         double parse_expr_4();
    137         double parse_expr_5();
    138         double parse_expr_6();
    139         double parse_expr_7();
    140         double parse_expr_8();
     133        float parse_expr_1();
     134        float parse_expr_2();
     135        float parse_expr_3();
     136        float parse_expr_4();
     137        float parse_expr_5();
     138        float parse_expr_6();
     139        float parse_expr_7();
     140        float parse_expr_8();
    141141        char* parse_word(char* str);
    142142        binary_operator parse_binary_operator();
    143143        unary_operator parse_unary_operator();
    144144
    145         double parse_argument();
    146         double parse_last_argument();
     145        float parse_argument();
     146        float parse_last_argument();
    147147
    148148        binary_operator op;
    149149        const char* reading_stream;
    150150        bool failed_;
    151         double result_;
     151        float result_;
    152152        std::string remains_;
    153         std::map<std::string, double> variables_;
     153        std::map<std::string, float> variables_;
    154154    };
    155155
    156156    //Endzeichen für float expression: ')', '}', ']', ',', ';'
    157     _UtilExport bool parse_float(char* const, char**, double*);
     157    _UtilExport bool parse_float(char* const, char**, float*);
    158158    //Endzeichen angegeben
    159     _UtilExport bool parse_float(char* const, char**, char, double*);
     159    _UtilExport bool parse_float(char* const, char**, char, float*);
    160160    //Letzter Teil-float eines Vektors parsen (keine Vergleichs- und Logikoperationen)
    161     _UtilExport bool parse_vector_float(char* const, char**, bool, double*);
     161    _UtilExport bool parse_vector_float(char* const, char**, bool, float*);
    162162}
    163163

  • code/trunk/src/libraries/util/Math.h

    r7427 r8351  
    6666namespace orxonox
    6767{
    68     // C++ doesn't define any constants for pi, e, etc.
     68    /** Often used numerical constants because C++ doesn't define any.
     69    @note
     70        The values here are decimal representations of the approximate floating
     71        point value as it is stored according to the IEEE 754 standard.
     72    */
    6973    namespace math
    7074    {
    71         const float pi      = 3.14159265f;      ///< PI
    72         const float pi_2    = 1.57079633f;      ///< PI / 2
    73         const float pi_4    = 7.85398163e-1f;   ///< PI / 4
    74         const float e       = 2.71828183f;      ///< e
    75         const float sqrt2   = 1.41421356f;      ///< sqrt(2)
    76         const float sqrt2_2 = 7.07106781e-1f;   ///< sqrt(2) / 2
    77 
    78         const double pi_d      = 3.14159265358979324;       ///< PI (double)
    79         const double pi_2_d    = 1.57079632679489662;       ///< PI / 2 (double)
    80         const double pi_4_d    = 7.85398163397448310e-1;    ///< PI / 4 (double)
    81         const double e_d       = 2.71828182845904524;       ///< e (double)
    82         const double sqrt2_d   = 1.41421356237309505;       ///< sqrt(2) (double)
    83         const double sqrt2_2_d = 7.07106781186547524e-1;    ///< sqrt(2) / 2 (double)
     75        const float twoPi   = 6.283185482025146484375f;     ///< PI * 2
     76        const float pi      = 3.1415927410125732421875f;    ///< PI
     77        const float pi_2    = 1.57079637050628662109375f;   ///< PI / 2
     78        const float pi_4    = 0.785398185253143310546875f;  ///< PI / 4
     79        const float e       = 2.718281269073486328125f;     ///< e
     80        const float sqrt2   = 1.41421353816986083984375f;   ///< sqrt(2)
     81        const float sqrt2_2 = 0.707106769084930419921875f;  ///< sqrt(2) / 2
    8482    }
    8583

  • code/trunk/src/libraries/util/MathConvert.h

    r7401 r8351  
    5151    struct ConverterExplicit<orxonox::Vector2, std::string>
    5252    {
    53         FORCEINLINE static bool convert(std::string* output, const orxonox::Vector2& input)
     53        ORX_FORCEINLINE static bool convert(std::string* output, const orxonox::Vector2& input)
    5454        {
    5555            std::ostringstream ostream;
    … …  
    6767    struct ConverterExplicit<orxonox::Vector3, std::string>
    6868    {
    69         FORCEINLINE static bool convert(std::string* output, const orxonox::Vector3& input)
     69        ORX_FORCEINLINE static bool convert(std::string* output, const orxonox::Vector3& input)
    7070        {
    7171            std::ostringstream ostream;
    … …  
    8383    struct ConverterExplicit<orxonox::Vector4, std::string>
    8484    {
    85         FORCEINLINE static bool convert(std::string* output, const orxonox::Vector4& input)
     85        ORX_FORCEINLINE static bool convert(std::string* output, const orxonox::Vector4& input)
    8686        {
    8787            std::ostringstream ostream;
    … …  
    9999    struct ConverterExplicit<orxonox::Quaternion, std::string>
    100100    {
    101         FORCEINLINE static bool convert(std::string* output, const orxonox::Quaternion& input)
     101        ORX_FORCEINLINE static bool convert(std::string* output, const orxonox::Quaternion& input)
    102102        {
    103103            std::ostringstream ostream;
    … …  
    115115    struct ConverterExplicit<orxonox::ColourValue, std::string>
    116116    {
    117         FORCEINLINE static bool convert(std::string* output, const orxonox::ColourValue& input)
     117        ORX_FORCEINLINE static bool convert(std::string* output, const orxonox::ColourValue& input)
    118118        {
    119119            std::ostringstream ostream;
    … …  
    157157    struct ConverterFallback<orxonox::Radian, ToType>
    158158    {
    159         FORCEINLINE static bool convert(ToType* output, const orxonox::Radian& input)
     159        ORX_FORCEINLINE static bool convert(ToType* output, const orxonox::Radian& input)
    160160        {
    161161            return convertValue<Ogre::Real, ToType>(output, input.valueRadians());
    … …  
    167167    struct ConverterFallback<orxonox::Degree, ToType>
    168168    {
    169         FORCEINLINE static bool convert(ToType* output, const orxonox::Degree& input)
     169        ORX_FORCEINLINE static bool convert(ToType* output, const orxonox::Degree& input)
    170170        {
    171171            return convertValue<Ogre::Real, ToType>(output, input.valueDegrees());
    … …  
    177177    struct ConverterFallback<FromType, orxonox::Radian>
    178178    {
    179         FORCEINLINE static bool convert(orxonox::Radian* output, const FromType& input)
     179        ORX_FORCEINLINE static bool convert(orxonox::Radian* output, const FromType& input)
    180180        {
    181181            float temp;
    … …  
    194194    struct ConverterFallback<FromType, orxonox::Degree>
    195195    {
    196         FORCEINLINE static bool convert(orxonox::Degree* output, const FromType& input)
     196        ORX_FORCEINLINE static bool convert(orxonox::Degree* output, const FromType& input)
    197197        {
    198198            float temp;

  • code/trunk/src/libraries/util/SharedPtr.h

    r7401 r8351  
    163163            public:
    164164                SharedCounter() : count_(1) {}
     165                virtual ~SharedCounter() {}
    165166                virtual void destroy() = 0;
    166167
    … …  
    186187        _UtilExport SmallObjectAllocator& createSharedCounterPool();
    187188
    188         FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
     189        ORX_FORCEINLINE SmallObjectAllocator& getSharedCounterPool()
    189190        {
    190191            static SmallObjectAllocator& instance = createSharedCounterPool();

  • code/trunk/src/libraries/util/SignalHandler.cc

    r7801 r8351  
    3737#include <cstdlib>
    3838#include <cstring>
     39#include <cstdio>
    3940
    4041#include "Debug.h"

  • code/trunk/src/libraries/util/SignalHandler.h

    r7457 r8351  
    7070
    7171    /// The SignalHandler is used to catch signals like SIGSEGV and write a backtrace to the logfile.
    72     class SignalHandler : public Singleton<SignalHandler>
     72    class _UtilExport SignalHandler : public Singleton<SignalHandler>
    7373    {
    7474        friend class Singleton<SignalHandler>;

  • code/trunk/src/libraries/util/UtilPrereqs.h

    r6417 r8351  
    5252#    endif
    5353#  endif
    54 #elif defined ( ORXONOX_GCC_VISIBILITY )
     54#  define _UtilPrivate
     55#elif defined (ORXONOX_GCC_VISIBILITY)
    5556#  define _UtilExport  __attribute__ ((visibility("default")))
     57#  define _UtilPrivate __attribute__ ((visibility("hidden")))
    5658#else
    5759#  define _UtilExport
     60#  define _UtilPrivate
    5861#endif
    5962
Note: See TracChangeset for help on using the changeset viewer.