Adding support for sub and mul blending types.

QGearsMain/include/core/Background2D.h

@@ -122,6 +122,18 @@ private:
     unsigned int                          m_AddMaxVertexCount;
     Ogre::MaterialPtr                     m_AddMaterial;
 
+    // subtract blended
+    Ogre::RenderOperation                 m_SubtractRenderOp;
+    Ogre::HardwareVertexBufferSharedPtr   m_SubtractVertexBuffer;
+    unsigned int                          m_SubtractMaxVertexCount;
+    Ogre::MaterialPtr                     m_SubtractMaterial;
+
+    // multiply blended
+    Ogre::RenderOperation                 m_MultiplyRenderOp;
+    Ogre::HardwareVertexBufferSharedPtr   m_MultiplyVertexBuffer;
+    unsigned int                          m_MultiplyMaxVertexCount;
+    Ogre::MaterialPtr                     m_MultiplyMaterial;
+
     Entity*                               m_ScrollEntity;
     Ogre::Vector2                         m_ScrollPositionStart;
     Ogre::Vector2                         m_ScrollPositionEnd;

QGearsMain/include/map/QGearsBackground2DFileXMLSerializer.h

@@ -52,6 +52,8 @@ namespace QGears
 
         static const String BLENDING_ALPHA;
         static const String BLENDING_ADD;
+        static const String BLENDING_SUBTRACT;
+        static const String BLENDING_MULTIPLY;
 
         template<typename ValueType> void
         readVector( TiXmlNode &node, const String &tag, std::vector<ValueType> &pDest )

QGearsMain/include/map/QGearsTile.h

@@ -12,6 +12,8 @@ namespace QGears
     {
         B_ALPHA
        ,B_ADD
+       ,B_SUBTRACT
+       ,B_MULTIPLY
     };
 
     struct KeyFrame

QGearsMain/src/core/Background2D.cpp

@@ -21,6 +21,8 @@ ConfigVar cv_background2d_manual( "background2d_manual", "Manual scrolling for 2
 Background2D::Background2D():
     m_AlphaMaxVertexCount( 0 ),
     m_AddMaxVertexCount( 0 ),
+    m_SubtractMaxVertexCount( 0 ),
+    m_MultiplyMaxVertexCount( 0 ),
 
     m_ScrollEntity( NULL ),
     m_ScrollPositionStart( Ogre::Vector2::ZERO ),
@@ -70,6 +72,36 @@ Background2D::Background2D():
     tex->setNumMipmaps( -1 );
     tex->setTextureFiltering( Ogre::TFO_NONE );
 
+    m_SubtractMaterial = Ogre::MaterialManager::getSingleton().create( "Background2DSubtract", "General" );
+    pass = m_SubtractMaterial->getTechnique( 0 )->getPass( 0 );
+    pass->setVertexColourTracking( Ogre::TVC_AMBIENT );
+    pass->setCullingMode( Ogre::CULL_NONE );
+    pass->setDepthCheckEnabled( true );
+    pass->setDepthWriteEnabled( true );
+    pass->setLightingEnabled( false );
+    pass->setSceneBlending( Ogre::SBF_ONE, Ogre::SBF_ONE_MINUS_SOURCE_COLOUR ); // FIXME: SUBTRACT
+    pass->setAlphaRejectFunction( Ogre::CMPF_LESS );
+    pass->setAlphaRejectValue( 0 );
+    tex = pass->createTextureUnitState();
+    tex->setTextureName( "system/blank.png" );
+    tex->setNumMipmaps( -1 );
+    tex->setTextureFiltering( Ogre::TFO_NONE );
+
+    m_MultiplyMaterial = Ogre::MaterialManager::getSingleton().create( "Background2DMultiply", "General" );
+    pass = m_MultiplyMaterial->getTechnique( 0 )->getPass( 0 );
+    pass->setVertexColourTracking( Ogre::TVC_AMBIENT );
+    pass->setCullingMode( Ogre::CULL_NONE );
+    pass->setDepthCheckEnabled( true );
+    pass->setDepthWriteEnabled( true );
+    pass->setLightingEnabled( false );
+    pass->setSceneBlending( Ogre::SBT_ADD ); // FIXME: MULTIPLY
+    pass->setAlphaRejectFunction( Ogre::CMPF_GREATER );
+    pass->setAlphaRejectValue( 0 );
+    tex = pass->createTextureUnitState();
+    tex->setTextureName( "system/blank.png" );
+    tex->setNumMipmaps( -1 );
+    tex->setTextureFiltering( Ogre::TFO_NONE );
+
     m_SceneManager->addRenderQueueListener( this );
 }
 
@@ -256,6 +288,14 @@ Background2D::OnResize()
         {
             vertex_buffer = m_AddVertexBuffer;
         }
+        else if( m_Tiles[ i ].blending == QGears::B_SUBTRACT )
+        {
+            vertex_buffer = m_SubtractVertexBuffer;
+        }
+        else if( m_Tiles[ i ].blending == QGears::B_MULTIPLY )
+        {
+            vertex_buffer = m_MultiplyVertexBuffer;
+        }
 
         float* writeIterator = ( float* )vertex_buffer->lock( Ogre::HardwareBuffer::HBL_NORMAL );
 
@@ -494,6 +534,12 @@ Background2D::SetImage( const Ogre::String& image )
     pass = m_AddMaterial->getTechnique( 0 )->getPass( 0 );
     tex = pass->getTextureUnitState( 0 );
     tex->setTextureName( image );
+    pass = m_SubtractMaterial->getTechnique( 0 )->getPass( 0 );
+    tex = pass->getTextureUnitState( 0 );
+    tex->setTextureName( image );
+    pass = m_MultiplyMaterial->getTechnique( 0 )->getPass( 0 );
+    tex = pass->getTextureUnitState( 0 );
+    tex->setTextureName( image );
 }
 
 //------------------------------------------------------------------------------
@@ -584,6 +630,18 @@ Background2D::AddTile( const int x, const int y, const int width, const int heig
         vertex_buffer = m_AddVertexBuffer;
         max_vertex_count = m_AddMaxVertexCount;
     }
+    else if( blending == QGears::B_SUBTRACT )
+    {
+        render_op = m_SubtractRenderOp;
+        vertex_buffer = m_SubtractVertexBuffer;
+        max_vertex_count = m_SubtractMaxVertexCount;
+    }
+    else if( blending == QGears::B_MULTIPLY )
+    {
+        render_op = m_MultiplyRenderOp;
+        vertex_buffer = m_MultiplyVertexBuffer;
+        max_vertex_count = m_MultiplyMaxVertexCount;
+    }
     else
     {
         LOG_ERROR( "Unknown blending type." );
@@ -716,6 +774,14 @@ Background2D::UpdateTileUV( const unsigned int tile_id, const float u1, const fl
     {
         vertex_buffer = m_AddVertexBuffer;
     }
+    else if( m_Tiles[ tile_id ].blending == QGears::B_SUBTRACT )
+    {
+        vertex_buffer = m_SubtractVertexBuffer;
+    }
+    else if( m_Tiles[ tile_id ].blending == QGears::B_MULTIPLY )
+    {
+        vertex_buffer = m_MultiplyVertexBuffer;
+    }
 
     float* writeIterator = ( float* )vertex_buffer->lock( Ogre::HardwareBuffer::HBL_NORMAL );
 
@@ -852,6 +918,18 @@ Background2D::renderQueueEnded( Ogre::uint8 queueGroupId, const Ogre::String& in
             m_SceneManager->_setPass( m_AddMaterial->getTechnique( 0 )->getPass( 0 ), true, false );
             m_RenderSystem->_render( m_AddRenderOp );
         }
+
+        if( m_SubtractRenderOp.vertexData->vertexCount != 0 )
+        {
+            m_SceneManager->_setPass( m_SubtractMaterial->getTechnique( 0 )->getPass( 0 ), true, false );
+            m_RenderSystem->_render( m_SubtractRenderOp );
+        }
+
+        if( m_MultiplyRenderOp.vertexData->vertexCount != 0 )
+        {
+            m_SceneManager->_setPass( m_MultiplyMaterial->getTechnique( 0 )->getPass( 0 ), true, false );
+            m_RenderSystem->_render( m_MultiplyRenderOp );
+        }
     }
 }
 
@@ -898,6 +976,48 @@ Background2D::CreateVertexBuffers()
     m_AddRenderOp.vertexData->vertexBufferBinding->setBinding( 0, m_AddVertexBuffer );
     m_AddRenderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
     m_AddRenderOp.useIndexes = false;
+
+
+
+    m_SubtractMaxVertexCount = 256 * TILE_VERTEX_COUNT; // FIXME: 256?
+    m_SubtractRenderOp.vertexData = new Ogre::VertexData;
+    m_SubtractRenderOp.vertexData->vertexStart = 0;
+
+    vDecl = m_SubtractRenderOp.vertexData->vertexDeclaration;
+
+    offset = 0;
+    vDecl->addElement( 0, 0, Ogre::VET_FLOAT3, Ogre::VES_POSITION );
+    offset += Ogre::VertexElement::getTypeSize( Ogre::VET_FLOAT3 );
+    vDecl->addElement( 0, offset, Ogre::VET_FLOAT4, Ogre::VES_DIFFUSE );
+    offset += Ogre::VertexElement::getTypeSize( Ogre::VET_FLOAT4 );
+    vDecl->addElement( 0, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES );
+
+    m_SubtractVertexBuffer = Ogre::HardwareBufferManager::getSingletonPtr()->createVertexBuffer( vDecl->getVertexSize( 0 ), m_SubtractMaxVertexCount, Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY, false );
+
+    m_SubtractRenderOp.vertexData->vertexBufferBinding->setBinding( 0, m_SubtractVertexBuffer );
+    m_SubtractRenderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
+    m_SubtractRenderOp.useIndexes = false;
+
+
+
+    m_MultiplyMaxVertexCount = 256 * TILE_VERTEX_COUNT; // FIXME: 256?
+    m_MultiplyRenderOp.vertexData = new Ogre::VertexData;
+    m_MultiplyRenderOp.vertexData->vertexStart = 0;
+
+    vDecl = m_MultiplyRenderOp.vertexData->vertexDeclaration;
+
+    offset = 0;
+    vDecl->addElement( 0, 0, Ogre::VET_FLOAT3, Ogre::VES_POSITION );
+    offset += Ogre::VertexElement::getTypeSize( Ogre::VET_FLOAT3 );
+    vDecl->addElement( 0, offset, Ogre::VET_FLOAT4, Ogre::VES_DIFFUSE );
+    offset += Ogre::VertexElement::getTypeSize( Ogre::VET_FLOAT4 );
+    vDecl->addElement( 0, offset, Ogre::VET_FLOAT2, Ogre::VES_TEXTURE_COORDINATES );
+
+    m_MultiplyVertexBuffer = Ogre::HardwareBufferManager::getSingletonPtr()->createVertexBuffer( vDecl->getVertexSize( 0 ), m_MultiplyMaxVertexCount, Ogre::HardwareBuffer::HBU_DYNAMIC_WRITE_ONLY, false );
+
+    m_MultiplyRenderOp.vertexData->vertexBufferBinding->setBinding( 0, m_AMultiplyVertexBuffer );
+    m_MultiplyRenderOp.operationType = Ogre::RenderOperation::OT_TRIANGLE_LIST;
+    m_MultiplyRenderOp.useIndexes = false;
 }
 
 //------------------------------------------------------------------------------
@@ -913,6 +1033,16 @@ Background2D::DestroyVertexBuffers()
     m_AddRenderOp.vertexData = 0;
     m_AddVertexBuffer.setNull();
     m_AddMaxVertexCount = 0;
+
+    delete m_SubtractRenderOp.vertexData;
+    m_SubtractRenderOp.vertexData = 0;
+    m_SubtractVertexBuffer.setNull();
+    m_SubtractMaxVertexCount = 0;
+
+    delete m_MultiplyRenderOp.vertexData;
+    m_MultiplyRenderOp.vertexData = 0;
+    m_MultiplyVertexBuffer.setNull();
+    m_MultiplyMaxVertexCount = 0;
 }
 
 //------------------------------------------------------------------------------

QGearsMain/src/core/XmlBackground2DFile.cpp

@@ -63,7 +63,23 @@ XmlBackground2DFile::Load()
                 float depth = GetFloat( node, "depth", 0 );
                 Ogre::String blending_str = GetString( node, "blending", "alpha" );
 
-                QGears::Blending blending = ( blending_str == "add" ) ? QGears::B_ADD : QGears::B_ALPHA;
+                QGears::Blending blending;
+                if ( blending_str == "add" )
+                {
+                    blending = QGears::B_ADD;
+                }
+                else if ( blending_str == "subtract" )
+                {
+                    blending = QGears::B_SUBTRACT;
+                }
+                else if ( blending_str == "multiply" )
+                {
+                    blending = QGears::B_MULTIPLY;
+                }
+                else
+                {
+                    blending = QGears::B_ALPHA;
+                }
 
                 Ogre::Vector4 distance = Ogre::Vector4( 0, 0, -depth, 1 );
                 Ogre::Vector4 res = CameraManager::getSingleton().GetCurrentCamera()->getProjectionMatrixWithRSDepth() * distance;

QGearsMain/src/map/QGearsBackground2DFileXMLSerializer.cpp

@@ -31,8 +31,10 @@ THE SOFTWARE.
 namespace QGears
 {
     //---------------------------------------------------------------------
-    const String Background2DFileXMLSerializer::BLENDING_ALPHA( "alpha" );
-    const String Background2DFileXMLSerializer::BLENDING_ADD  ( "add"   );
+    const String Background2DFileXMLSerializer::BLENDING_ALPHA   ( "alpha"    );
+    const String Background2DFileXMLSerializer::BLENDING_ADD     ( "add"      );
+    const String Background2DFileXMLSerializer::BLENDING_SUBTRACT( "subtract" );
+    const String Background2DFileXMLSerializer::BLENDING_MULTIPLY( "multiply" );
 
     //---------------------------------------------------------------------
     Background2DFileXMLSerializer::Background2DFileXMLSerializer() :
@@ -77,6 +79,16 @@ namespace QGears
             pDest = B_ALPHA;
             return true;
         }
+        if( *value == BLENDING_SUBTRACT )
+        {
+            pDest = B_SUBTRACT;
+            return true;
+        }
+        if( *value == BLENDING_MULTIPLY )
+        {
+            pDest = B_MULTIPLY;
+            return true;
+        }
         pDest = pDefault;
         return false;
     }

utilities/ffvii_field_dat_dumper/src/DatFile.cpp

@@ -3338,6 +3338,14 @@ DatFile::AddTile( const Tile& tile, MimFile& mim, Logger* export_text )
     {
         blending_str = "add";
     }
+    else if( tile.blending == 2 )
+    {
+        blending_str = "subtract";
+    }
+    else if( tile.blending == 3 )
+    {
+        blending_str = "multiply";
+    }
     else
     {
         LOGGER->Log( "Tile blending with type \"" + Ogre::StringConverter::toString( tile.blending ) + "\" not supported." );