Changeset 13468

Show
Ignore:
Timestamp:
12/19/14 16:43:31 (3 days ago)
Author:
robert
Message:

Release OpenSceneGraph-3.3.3

Location:
OpenSceneGraph/trunk
Files:
3 modified

Legend:

Unmodified
Added
Removed
  • OpenSceneGraph/trunk/include/osg/Texture

    r13397 r13468  
    2222#include <osg/Vec4> 
    2323#include <osg/Vec4d> 
     24#include <osg/Vec4i> 
    2425#include <osg/buffered_value> 
    2526#include <osg/GL2Extensions> 
     
    3233#ifndef GL_TEXTURE_MAX_ANISOTROPY_EXT 
    3334    #define GL_TEXTURE_MAX_ANISOTROPY_EXT 0x84FE 
     35#endif 
     36 
     37// If not defined, use the definition found in: 
     38// http://www.opengl.org/registry/specs/ARB/texture_swizzle.txt 
     39#ifndef GL_TEXTURE_SWIZZLE_RGBA 
     40    #define GL_TEXTURE_SWIZZLE_RGBA 0x8E46 
    3441#endif 
    3542 
     
    482489        }; 
    483490 
    484  
    485491        /** Sets the texture filter mode. */ 
    486492        void setFilter(FilterParameter which, FilterMode filter); 
     
    498504        /** Gets the maximum anisotropy value. */ 
    499505        inline float getMaxAnisotropy() const { return _maxAnisotropy; } 
     506 
     507        /** Configure the source of texture swizzling for all channels */ 
     508        inline void setSwizzle(const Vec4i& swizzle) { _swizzle = swizzle; dirtyTextureParameters(); }; 
     509 
     510        /** Gets the source of texture swizzling for all channels */ 
     511        inline const Vec4i& getSwizzle() const { return _swizzle; } 
    500512 
    501513        /** Sets the hardware mipmap generation hint. If enabled, it will 
     
    765777                bool isTextureFilterAnisotropicSupported() const { return _isTextureFilterAnisotropicSupported; } 
    766778 
     779                void setTextureSwizzleSupported(bool flag) { _isTextureSwizzleSupported=flag; } 
     780                bool isTextureSwizzleSupported() const { return _isTextureSwizzleSupported; } 
     781 
    767782                void setTextureCompressionARBSupported(bool flag) { _isTextureCompressionARBSupported=flag; } 
    768783                bool isTextureCompressionARBSupported() const { return _isTextureCompressionARBSupported; } 
     
    896911                bool    _isMultiTexturingSupported; 
    897912                bool    _isTextureFilterAnisotropicSupported; 
     913                bool    _isTextureSwizzleSupported; 
    898914                bool    _isTextureCompressionARBSupported; 
    899915                bool    _isTextureCompressionS3TCSupported; 
     
    10181034        FilterMode      _mag_filter; 
    10191035        float           _maxAnisotropy; 
     1036        Vec4i           _swizzle; 
    10201037        bool            _useHardwareMipMapGeneration; 
    10211038        bool            _unrefImageDataAfterApply; 
  • OpenSceneGraph/trunk/src/osg/Texture.cpp

    r13311 r13468  
    10761076            _mag_filter(LINEAR), 
    10771077            _maxAnisotropy(1.0f), 
     1078            _swizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA),  
    10781079            _useHardwareMipMapGeneration(true), 
    10791080            _unrefImageDataAfterApply(false), 
     
    11021103            _mag_filter(text._mag_filter), 
    11031104            _maxAnisotropy(text._maxAnisotropy), 
     1105            _swizzle(text._swizzle),  
    11041106            _useHardwareMipMapGeneration(text._useHardwareMipMapGeneration), 
    11051107            _unrefImageDataAfterApply(text._unrefImageDataAfterApply), 
     
    11341136    COMPARE_StateAttribute_Parameter(_mag_filter) 
    11351137    COMPARE_StateAttribute_Parameter(_maxAnisotropy) 
     1138    COMPARE_StateAttribute_Parameter(_swizzle) 
    11361139    COMPARE_StateAttribute_Parameter(_useHardwareMipMapGeneration) 
    11371140    COMPARE_StateAttribute_Parameter(_internalFormatMode) 
     
    17051708    } 
    17061709 
     1710    if (extensions->isTextureSwizzleSupported()) 
     1711    { 
     1712        // note, GL_TEXTURE_SWIZZLE_RGBA will either be defined 
     1713        // by gl.h (or via glext.h) or by include/osg/Texture. 
     1714        glTexParameteriv(target, GL_TEXTURE_SWIZZLE_RGBA, _swizzle.ptr()); 
     1715    } 
     1716 
    17071717    if (extensions->isTextureBorderClampSupported()) 
    17081718    { 
     
    25072517    _isTextureFilterAnisotropicSupported = isGLExtensionSupported(contextID,"GL_EXT_texture_filter_anisotropic"); 
    25082518 
     2519    _isTextureSwizzleSupported = isGLExtensionSupported(contextID,"GL_ARB_texture_swizzle"); 
     2520 
    25092521    _isTextureCompressionARBSupported = builtInSupport || isGLExtensionOrVersionSupported(contextID,"GL_ARB_texture_compression", 1.3f); 
    25102522 
  • OpenSceneGraph/trunk/src/osgWrappers/serializers/osg/Texture.cpp

    r13311 r13468  
    9292    os << attachment.unit << attachment.level << attachment.layered 
    9393       << attachment.layer << attachment.access << attachment.format << std::endl; 
     94    return true; 
     95} 
     96 
     97// _swizzle 
     98static bool checkSwizzle( const osg::Texture& attr ) 
     99{ 
     100    return true; 
     101} 
     102 
     103static unsigned char swizzleToCharacter(GLint swizzle, unsigned char defaultCharacter) 
     104{ 
     105    switch (swizzle) 
     106    { 
     107    case GL_RED: 
     108        return 'R'; 
     109    case GL_GREEN: 
     110        return 'G'; 
     111    case GL_BLUE: 
     112        return 'B'; 
     113    case GL_ALPHA: 
     114        return 'A'; 
     115    case GL_ZERO: 
     116        return '0'; 
     117    case GL_ONE: 
     118        return '1'; 
     119    default: 
     120        break; 
     121    } 
     122 
     123    return defaultCharacter; 
     124} 
     125 
     126static GLint characterToSwizzle(unsigned char character, GLint defaultSwizzle) 
     127{ 
     128    switch (character) 
     129    { 
     130    case 'R': 
     131        return GL_RED; 
     132    case 'G': 
     133        return GL_GREEN; 
     134    case 'B': 
     135        return GL_BLUE; 
     136    case 'A': 
     137        return GL_ALPHA; 
     138    case '0': 
     139        return GL_ZERO; 
     140    case '1': 
     141        return GL_ONE; 
     142    default: 
     143        break; 
     144    } 
     145 
     146    return defaultSwizzle; 
     147} 
     148 
     149static std::string swizzleToString(const osg::Vec4i& swizzle) 
     150{ 
     151    std::string result; 
     152 
     153    result.push_back(swizzleToCharacter(swizzle.r(), 'R')); 
     154    result.push_back(swizzleToCharacter(swizzle.g(), 'G')); 
     155    result.push_back(swizzleToCharacter(swizzle.b(), 'B')); 
     156    result.push_back(swizzleToCharacter(swizzle.a(), 'A')); 
     157 
     158    return result; 
     159} 
     160 
     161static osg::Vec4i stringToSwizzle(const std::string& swizzleString) 
     162{ 
     163    osg::Vec4i swizzle; 
     164 
     165    swizzle.r() = characterToSwizzle(swizzleString[0], GL_RED); 
     166    swizzle.g() = characterToSwizzle(swizzleString[1], GL_GREEN); 
     167    swizzle.b() = characterToSwizzle(swizzleString[2], GL_BLUE); 
     168    swizzle.a() = characterToSwizzle(swizzleString[3], GL_ALPHA); 
     169 
     170    return swizzle; 
     171} 
     172 
     173static bool readSwizzle( osgDB::InputStream& is, osg::Texture& attr ) 
     174{ 
     175    std::string swizzleString; 
     176    is >> swizzleString; 
     177    attr.setSwizzle(stringToSwizzle(swizzleString)); 
     178 
     179    return true; 
     180} 
     181 
     182static bool writeSwizzle( osgDB::OutputStream& os, const osg::Texture& attr ) 
     183{ 
     184    os << swizzleToString(attr.getSwizzle()) << std::endl; 
     185 
    94186    return true; 
    95187} 
     
    157249        ADD_USER_SERIALIZER( ImageAttachment );  // _imageAttachment 
    158250    } 
    159 } 
     251 
     252    {  
     253        UPDATE_TO_VERSION_SCOPED( 98 )  
     254        ADD_USER_SERIALIZER( Swizzle );  // _swizzle 
     255    } 
     256}