From Aurelien Albert, Added support for texture swizzle.

src/osg/Texture.cpp

@@ -1075,6 +1075,7 @@ Texture::Texture():
             _min_filter(LINEAR_MIPMAP_LINEAR), // trilinear
             _mag_filter(LINEAR),
             _maxAnisotropy(1.0f),
+            _swizzle(GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA), 
             _useHardwareMipMapGeneration(true),
             _unrefImageDataAfterApply(false),
             _clientStorageHint(false),
@@ -1101,6 +1102,7 @@ Texture::Texture(const Texture& text,const CopyOp& copyop):
             _min_filter(text._min_filter),
             _mag_filter(text._mag_filter),
             _maxAnisotropy(text._maxAnisotropy),
+            _swizzle(text._swizzle), 
             _useHardwareMipMapGeneration(text._useHardwareMipMapGeneration),
             _unrefImageDataAfterApply(text._unrefImageDataAfterApply),
             _clientStorageHint(text._clientStorageHint),
@@ -1133,6 +1135,7 @@ int Texture::compareTexture(const Texture& rhs) const
     COMPARE_StateAttribute_Parameter(_min_filter)
     COMPARE_StateAttribute_Parameter(_mag_filter)
     COMPARE_StateAttribute_Parameter(_maxAnisotropy)
+    COMPARE_StateAttribute_Parameter(_swizzle)
     COMPARE_StateAttribute_Parameter(_useHardwareMipMapGeneration)
     COMPARE_StateAttribute_Parameter(_internalFormatMode)
 
@@ -1704,6 +1707,13 @@ void Texture::applyTexParameters(GLenum target, State& state) const
         glTexParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, _maxAnisotropy);
     }
 
+    if (extensions->isTextureSwizzleSupported())
+    {
+        // note, GL_TEXTURE_SWIZZLE_RGBA will either be defined
+        // by gl.h (or via glext.h) or by include/osg/Texture.
+        glTexParameteriv(target, GL_TEXTURE_SWIZZLE_RGBA, _swizzle.ptr());
+    }
+
     if (extensions->isTextureBorderClampSupported())
     {
 
@@ -2506,6 +2516,8 @@ Texture::Extensions::Extensions(unsigned int contextID)
 
     _isTextureFilterAnisotropicSupported = isGLExtensionSupported(contextID,"GL_EXT_texture_filter_anisotropic");
 
+    _isTextureSwizzleSupported = isGLExtensionSupported(contextID,"GL_ARB_texture_swizzle");
+
     _isTextureCompressionARBSupported = builtInSupport || isGLExtensionOrVersionSupported(contextID,"GL_ARB_texture_compression", 1.3f);
 
     _isTextureCompressionS3TCSupported = isGLExtensionSupported(contextID,"GL_EXT_texture_compression_s3tc");

src/osgWrappers/serializers/osg/Texture.cpp

@@ -94,6 +94,98 @@ static bool writeImageAttachment( osgDB::OutputStream& os, const osg::Texture& a
     return true;
 }
 
+// _swizzle
+static bool checkSwizzle( const osg::Texture& attr )
+{
+    return true;
+}
+
+static unsigned char swizzleToCharacter(GLint swizzle, unsigned char defaultCharacter)
+{
+    switch (swizzle)
+    {
+    case GL_RED:
+        return 'R';
+    case GL_GREEN:
+        return 'G';
+    case GL_BLUE:
+        return 'B';
+    case GL_ALPHA:
+        return 'A';
+    case GL_ZERO:
+        return '0';
+    case GL_ONE:
+        return '1';
+    default:
+        break;
+    }
+
+    return defaultCharacter;
+}
+
+static GLint characterToSwizzle(unsigned char character, GLint defaultSwizzle)
+{
+    switch (character)
+    {
+    case 'R':
+        return GL_RED;
+    case 'G':
+        return GL_GREEN;
+    case 'B':
+        return GL_BLUE;
+    case 'A':
+        return GL_ALPHA;
+    case '0':
+        return GL_ZERO;
+    case '1':
+        return GL_ONE;
+    default:
+        break;
+    }
+
+    return defaultSwizzle;
+}
+
+static std::string swizzleToString(const osg::Vec4i& swizzle)
+{
+    std::string result;
+
+    result.push_back(swizzleToCharacter(swizzle.r(), 'R'));
+    result.push_back(swizzleToCharacter(swizzle.g(), 'G'));
+    result.push_back(swizzleToCharacter(swizzle.b(), 'B'));
+    result.push_back(swizzleToCharacter(swizzle.a(), 'A'));
+
+    return result;
+}
+
+static osg::Vec4i stringToSwizzle(const std::string& swizzleString)
+{
+    osg::Vec4i swizzle;
+
+    swizzle.r() = characterToSwizzle(swizzleString[0], GL_RED);
+    swizzle.g() = characterToSwizzle(swizzleString[1], GL_GREEN);
+    swizzle.b() = characterToSwizzle(swizzleString[2], GL_BLUE);
+    swizzle.a() = characterToSwizzle(swizzleString[3], GL_ALPHA);
+
+    return swizzle;
+}
+
+static bool readSwizzle( osgDB::InputStream& is, osg::Texture& attr )
+{
+    std::string swizzleString;
+    is >> swizzleString;
+    attr.setSwizzle(stringToSwizzle(swizzleString));
+
+    return true;
+}
+
+static bool writeSwizzle( osgDB::OutputStream& os, const osg::Texture& attr )
+{
+    os << swizzleToString(attr.getSwizzle()) << std::endl;
+
+    return true;
+}
+
 REGISTER_OBJECT_WRAPPER( Texture,
                          /*new osg::Texture*/NULL,
                          osg::Texture,
@@ -156,4 +248,9 @@ REGISTER_OBJECT_WRAPPER( Texture,
         UPDATE_TO_VERSION_SCOPED( 95 )
         ADD_USER_SERIALIZER( ImageAttachment );  // _imageAttachment
     }
+
+    { 
+        UPDATE_TO_VERSION_SCOPED( 98 ) 
+        ADD_USER_SERIALIZER( Swizzle );  // _swizzle
+    }
 }