SO3Engine/SO3Utils/SO3ConversionTools.cpp

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com

Copyright (c) 2010 I-maginer

This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.

This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#include "SO3ConversionTools.h"

namespace SO3
{

ConversionTools::ConversionTools()
{
  // Forbiden (private). Use static functions instead.
}

int ConversionTools::OgreToScolColorRGBA(Ogre::ColourValue ogreColor)
{
  // ATTENTION! RGB and RGBA values are encoded in a different way!
  // RGBA colour are encoded by scol as "RR GG BB 0A << 1" in memory ("see SCOLParticle.cpp" of the ZooEngine (!)).
  int a = static_cast<int>(ogreColor.a * CONST_COLOR_ALPHA);
  int b = static_cast<int>(ogreColor.b * CONST_COLOR);
  int g = static_cast<int>(ogreColor.g * CONST_COLOR);
        int r = static_cast<int>(ogreColor.r * CONST_COLOR);
        return 0x0 + ((a & 0x0000007E) + ((b & 0x000000ff) << 7) + ((g & 0x000000ff) << 15) + ((r & 0x000000ff) << 23));
}

Ogre::ColourValue ConversionTools::ScolToOgreColorRGBA(int scolColor)
{
  // ATTENTION! RGB and RGBA values are encoded in a different way!
  // RGBA colour are encoded by scol as "RR GG BB 0A << 1" in memory ("see SCOLParticle.cpp" of the ZooEngine (!)).
  float r = ((scolColor>>23) & 0x000000ff) / CONST_COLOR;
        float g = ((scolColor>>15) & 0x000000ff) / CONST_COLOR;
        float b = ((scolColor>>7 ) & 0x000000ff) / CONST_COLOR;
        float a = ((scolColor    ) & 0x0000007E) / CONST_COLOR_ALPHA;
        return Ogre::ColourValue(r, g, b, a);
}

int ConversionTools::OgreToScolColorRGB(Ogre::ColourValue ogreColor)
{
  // ATTENTION! RGB and RGBA values are encoded in a different way!
  // RGB colour are encoded by scol as "00 BB GG RR" in memory (see make_rgb bind, "CSTmakeRGB" in "utils.c" of the scol VM).
  int b = static_cast<int>(ogreColor.b * CONST_COLOR);
  int g = static_cast<int>(ogreColor.g * CONST_COLOR);
        int r = static_cast<int>(ogreColor.r * CONST_COLOR);
        return 0x0 + (r & 0x000000ff) + ((g & 0x000000ff) << 8) + ((b & 0x000000ff) << 16);
}

Ogre::ColourValue ConversionTools::ScolToOgreColorRGB(int scolColor)
{
  // ATTENTION! RGB and RGBA values are encoded in a different way!
  // RGB colour are encoded by scol as "00 BB GG RR" in memory (see make_rgb bind, "CSTmakeRGB" in "utils.c" of the scol VM).
  float b = ((scolColor>>16) & 0x000000ff) / CONST_COLOR;
        float g = ((scolColor>>8)  & 0x000000ff) / CONST_COLOR;
        float r = ((scolColor)     & 0x000000ff) / CONST_COLOR;
        return Ogre::ColourValue(r, g, b, 1.0f);
}

void ConversionTools::ScolBitmapGetRGB(PtrObjBitmap scolBitmap, unsigned char* buff)
{
  if ((scolBitmap == 0) || (buff == 0))
    return;

  //Scol bitmap are 32bits aligned
  int sbpl = scolBitmap->BPL;
  int dbpl = scolBitmap->TailleW * 3;

  if (sbpl == dbpl)
    memcpy(buff, scolBitmap->bits, scolBitmap->TailleW * scolBitmap->TailleH * scolBitmap->BytesPP);
  else
    for (long y=0; y<scolBitmap->TailleH; y++)
    {
      for (long x=0; x<scolBitmap->TailleW; x++)
      {
        unsigned long srcByte = (x * scolBitmap->BytesPP) + (sbpl * y);
        unsigned long destByte = (x * 3) + (dbpl * y);

        buff[destByte] = scolBitmap->bits[srcByte];
        buff[destByte + 1] = scolBitmap->bits[srcByte + 1];
        buff[destByte + 2] = scolBitmap->bits[srcByte + 2];
      }
    }
}

void ConversionTools::ScolBitmapGetRGBA(PtrObjBitmap scolBitmap, PtrObjBitmap alphaBitmap, Ogre::uint32* buff)
{
  if ((scolBitmap == 0) || (buff == 0))
    return;
  
  //Scol bitmap are 32bits aligned
  int sbpl = scolBitmap->BPL;
  int abpl = (alphaBitmap != 0) ? alphaBitmap->BPL : scolBitmap->TailleW;
  int dbpl = scolBitmap->TailleW;

  for (long y=0; y<scolBitmap->TailleH; y++)
  {
    for (long x=0; x<scolBitmap->TailleW; x++)
    {
      unsigned long srcByte = (x * scolBitmap->BytesPP) + (sbpl * y);
      unsigned long srcByteA = (x * ((alphaBitmap != 0) ? alphaBitmap->BytesPP : 1)) + (abpl * y);
      unsigned long destByte = x + (dbpl * y);
      Ogre::uint32 color = static_cast<Ogre::uint32>(((alphaBitmap != 0) ? alphaBitmap->bits[srcByteA] : 0xff) + (scolBitmap->bits[srcByte] << 8) + (scolBitmap->bits[srcByte + 1] << 16) + (scolBitmap->bits[srcByte + 2] << 24));
      *(buff + destByte) = color;
    }
  }
}

}

---