atria-soft/ewol
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Add texture loader of the SVG files

Browse Source
This commit is contained in:
Edouard Dupin 2012-03-28 18:13:49 +02:00
parent dcd2bdb833
commit 9282ee6915
25 changed files with 904 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
Sources/libewol/ewol/FontBitmap.cpp
View File

@ -119,7 +119,7 @@ namespace ewol
etk::UString bitmapRealFile = m_filename.GetFolder() + "/" + m_bitmapName; etk::UString bitmapRealFile = m_filename.GetFolder() + "/" + m_bitmapName;
EWOL_INFO("load text font image : \"" << bitmapRealFile << "\""); EWOL_INFO("load text font image : \"" << bitmapRealFile << "\"");
etk::File tmpFile(bitmapRealFile, m_filename.GetTypeAccess()); etk::File tmpFile(bitmapRealFile, m_filename.GetTypeAccess());
m_textureId = ewol::LoadTexture(tmpFile); m_textureId = ewol::texture::Load(tmpFile);
m_textureLoaded = true; m_textureLoaded = true;
m_loadedOK = true; m_loadedOK = true;
}; };
@ -127,7 +127,7 @@ namespace ewol
~EbtFont(void) ~EbtFont(void)
{ {
if (true == m_textureLoaded) { if (true == m_textureLoaded) {
ewol::UnLoadTexture(m_textureId); ewol::Texture::UnLoad(m_textureId);
} }
}; };
bool loadedOK(void) bool loadedOK(void)
@ -204,7 +204,7 @@ namespace ewol
}; };
uint32_t GetOglId(void) uint32_t GetOglId(void)
{ {
return GetTextureGLID(m_textureId); return ewol::Texture::GetGLID(m_textureId);
}; };
int32_t GetHeight(void) int32_t GetHeight(void)
{ {

2
Sources/libewol/ewol/FontFreeType.cpp
View File

@ -359,7 +359,7 @@ class FTFontInternal
EWOL_DEBUG("End generation of the Fond bitmap, start adding texture"); EWOL_DEBUG("End generation of the Fond bitmap, start adding texture");
// use the texture manager to have the texture availlable every restart of the screen // use the texture manager to have the texture availlable every restart of the screen
//textureId = LoadTexture(GL_TEXTURE_2D, 0, GL_ALPHA8, textureWidth, textureHeight, 0, GL_ALPHA, GL_UNSIGNED_BYTE, expanded_data, byfferDataSize * sizeof(GLubyte), "---FreeFont---" ); //textureId = LoadTexture(GL_TEXTURE_2D, 0, GL_ALPHA8, textureWidth, textureHeight, 0, GL_ALPHA, GL_UNSIGNED_BYTE, expanded_data, byfferDataSize * sizeof(GLubyte), "---FreeFont---" );
textureId = ewol::LoadTexture(GL_TEXTURE_2D, 0, GL_ALPHA, textureWidth, textureHeight, 0, GL_ALPHA, GL_UNSIGNED_BYTE, expanded_data, byfferDataSize * sizeof(GLubyte), "---FreeFont---" ); textureId = ewol::texture::Load(GL_TEXTURE_2D, 0, GL_ALPHA, textureWidth, textureHeight, 0, GL_ALPHA, GL_UNSIGNED_BYTE, expanded_data, byfferDataSize * sizeof(GLubyte), "---FreeFont---" );
EWOL_DEBUG("end load texture font"); EWOL_DEBUG("end load texture font");
// With The Texture Created, We Don't Need The Expanded Data Anymore. // With The Texture Created, We Don't Need The Expanded Data Anymore.

2
Sources/libewol/ewol/OObject/2DText.cpp
View File

@ -65,7 +65,7 @@ void ewol::OObject2DText::Draw(void)
} }
glColor4f(m_textColorFg.red, m_textColorFg.green, m_textColorFg.blue, m_textColorFg.alpha); glColor4f(m_textColorFg.red, m_textColorFg.green, m_textColorFg.blue, m_textColorFg.alpha);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, ewol::GetTextureGLID(m_FontTextureId)); glBindTexture(GL_TEXTURE_2D, ewol::texture::GetGLID(m_FontTextureId));
glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays
glVertexPointer( 2, oglTypeFloat_t, 0, &m_coord[0] ); glVertexPointer( 2, oglTypeFloat_t, 0, &m_coord[0] );

2
Sources/libewol/ewol/OObject/2DTextColored.cpp
View File

@ -86,7 +86,7 @@ void ewol::OObject2DTextColored::Draw(void)
return; return;
} }
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, ewol::GetTextureGLID(m_FontTextureId)); glBindTexture(GL_TEXTURE_2D, ewol::texture::GetGLID(m_FontTextureId));
glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays
glEnableClientState( GL_COLOR_ARRAY ); // Enable Color Arrays glEnableClientState( GL_COLOR_ARRAY ); // Enable Color Arrays

18
Sources/libewol/ewol/OObject/2DTextured.cpp
View File

@ -34,12 +34,18 @@
ewol::OObject2DTextured::OObject2DTextured(etk::File textureName) ewol::OObject2DTextured::OObject2DTextured(etk::File textureName)
{ {
EWOL_DEBUG("Create OObject textured : \"" << textureName << "\""); EWOL_DEBUG("Create OObject textured : \"" << textureName << "\"");
m_textureId = ewol::LoadTexture(textureName); m_textureId = ewol::texture::Load(textureName);
} }
ewol::OObject2DTextured::OObject2DTextured(etk::File textureName, etkFloat_t sizeX, etkFloat_t sizeY)
{
EWOL_DEBUG("Create OObject textured : \"" << textureName << "\"");
m_textureId = ewol::texture::Load(textureName, sizeX);
}
ewol::OObject2DTextured::~OObject2DTextured(void) ewol::OObject2DTextured::~OObject2DTextured(void)
{ {
ewol::UnLoadTexture(m_textureId); ewol::texture::UnLoad(m_textureId);
} }
void ewol::OObject2DTextured::Draw(void) void ewol::OObject2DTextured::Draw(void)
@ -48,10 +54,14 @@ void ewol::OObject2DTextured::Draw(void)
EWOL_WARNING("Nothink to draw..."); EWOL_WARNING("Nothink to draw...");
return; return;
} }
if (m_textureId == -1) {
EWOL_WARNING("Texture does not exist ...");
return;
}
glColor4f(1.0, 1.0, 1.0, 1.0); glColor4f(1.0, 1.0, 1.0, 1.0);
glEnable(GL_TEXTURE_2D); glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, ewol::GetTextureGLID(m_textureId)); //EWOL_WARNING("Draw with texture : " << m_textureId << " ==> ogl=" << ewol::texture::GetGLID(m_textureId));
glBindTexture(GL_TEXTURE_2D, ewol::texture::GetGLID(m_textureId));
glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays glEnableClientState( GL_VERTEX_ARRAY ); // Enable Vertex Arrays
glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays glEnableClientState( GL_TEXTURE_COORD_ARRAY ); // Enable Texture Coord Arrays
glVertexPointer( 2, oglTypeFloat_t, 0, &m_coord[0] ); glVertexPointer( 2, oglTypeFloat_t, 0, &m_coord[0] );

1
Sources/libewol/ewol/OObject/2DTextured.h
View File

@ -32,6 +32,7 @@ namespace ewol {
{ {
public: public:
OObject2DTextured(etk::File textureName); OObject2DTextured(etk::File textureName);
OObject2DTextured(etk::File textureName, etkFloat_t sizeX, etkFloat_t sizeY);
virtual ~OObject2DTextured(void); virtual ~OObject2DTextured(void);
public: public:
virtual void Draw(void); virtual void Draw(void);

590
Sources/libewol/ewol/Texture.cpp
View File

@ -27,287 +27,11 @@
#include <ewol/Texture.h> #include <ewol/Texture.h>
#include <ewol/importgl.h> #include <ewol/importgl.h>
#include <ewol/ewol.h> #include <ewol/ewol.h>
#include <pthread.h> #include <ewol/Texture/TextureBMP.h>
#include <ewol/Texture/TextureSVG.h>
extern "C" #include <ewol/Texture/TexturePNG.h>
{
#pragma pack(push,1)
typedef struct
{
int16_t bfType;
int32_t bfSize;
int32_t bfReserved;
int32_t bfOffBits;
} bitmapFileHeader_ts;
typedef struct
{
int32_t biSize;
int32_t biWidth;
int32_t biHeight;
int16_t biPlanes;
int16_t biBitCount;
int32_t biCompression;
int32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
int32_t biClrUsed;
int32_t biClrImportant;
} bitmapInfoHeader_ts;
#pragma pack(pop)
typedef enum {
BITS_16_R5G6B5,
BITS_16_X1R5G5B5,
BITS_24_R8G8B8,
BITS_32_X8R8G8B8,
BITS_32_A8R8G8B8
} modeBitmap_te;
};
#undef __class__
#define __class__ "ewol::Bitmap"
class Bitmap
{
private:
modeBitmap_te m_dataMode;
int32_t m_width;
int32_t m_height;
int32_t m_size;
uint8_t * m_data;
uint8_t * m_dataGenerate;
bitmapFileHeader_ts m_FileHeader;
bitmapInfoHeader_ts m_InfoHeader;
public:
Bitmap(etk::File & fileName) : m_data(NULL), m_dataGenerate(NULL)
{
m_dataMode = BITS_16_R5G6B5;
m_width = 0;
m_height = 0;
m_size = 0;
// Get the fileSize ...
/*if (fileName.Size() < (int32_t)(sizeof(bitmapFileHeader_ts) + sizeof(bitmapInfoHeader_ts) ) ) {
EWOL_ERROR("not enought data in the file named=\"" << fileName << "\"");
return;
}*/
if(false == fileName.fOpenRead() ) {
EWOL_ERROR("Can not find the file name=\"" << fileName << "\"");
return;
}
// get the data :
if (fileName.fRead(&m_FileHeader,sizeof(bitmapFileHeader_ts),1) != 1) {
EWOL_ERROR("error loading file header");
fileName.fClose();
return;
}
if (fileName.fRead(&m_InfoHeader,sizeof(bitmapInfoHeader_ts),1) != 1) {
EWOL_ERROR("error loading file header");
fileName.fClose();
return;
}
if(false == fileName.fSeek(m_FileHeader.bfOffBits, SEEK_SET)) {
EWOL_ERROR("error with the 'bfOffBits' in the file named=\"" << fileName << "\"");
fileName.fClose();
return;
}
// Check the header error :
if (m_FileHeader.bfType != 0x4D42) {
EWOL_ERROR("the file=\"" << fileName << "\" is not a bitmap file ...");
fileName.fClose();
return;
}
if (m_FileHeader.bfReserved != 0x00000000) {
EWOL_ERROR("the bfReserved feald is not at 0 ==> not supported format ...");
fileName.fClose();
return;
}
if( m_InfoHeader.biBitCount == 16
&& m_InfoHeader.biCompression == 0)
{
m_dataMode = BITS_16_X1R5G5B5;
} else if( m_InfoHeader.biBitCount == 16
&& m_InfoHeader.biCompression == 3)
{
m_dataMode = BITS_16_R5G6B5;
} else if( m_InfoHeader.biBitCount == 24
&& m_InfoHeader.biCompression == 0)
{
m_dataMode = BITS_24_R8G8B8;
} else if( m_InfoHeader.biBitCount == 32
&& m_InfoHeader.biCompression == 3)
{
m_dataMode = BITS_32_X8R8G8B8;
} else if( m_InfoHeader.biBitCount == 32
&& m_InfoHeader.biCompression == 0)
{
m_dataMode = BITS_32_A8R8G8B8;
} else {
EWOL_ERROR("the biBitCount & biCompression fealds are unknow ==> not supported format ...");
fileName.fClose();;
return;
}
m_width = m_InfoHeader.biWidth;
m_height = m_InfoHeader.biHeight;
if(0 != m_InfoHeader.biSizeImage)
{
m_data=new uint8_t[m_InfoHeader.biSizeImage];
if (fileName.fRead(m_data,m_InfoHeader.biSizeImage,1) != 1){
EWOL_CRITICAL("Can not read the file with the good size...");
}
// allocate the destination data ...
m_dataGenerate=new uint8_t[m_width*m_height*4];
}
fileName.fClose();
// need now to generate RGBA data ...
switch(m_dataMode)
{
case BITS_16_R5G6B5:
{
uint16_t * pointer = (uint16_t*)m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = (int8_t)((*pointer & 0xF800) >> 8);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = (int8_t)((*pointer & 0x07E0) >> 3);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = (int8_t)(*pointer << 3);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
pointer++;
}
}
}
break;
case BITS_16_X1R5G5B5:
{
uint16_t * pointer = (uint16_t*)m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = (int8_t)((*pointer & 0x7C00) >> 7);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = (int8_t)((*pointer & 0x03E0) >> 2);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = (int8_t)(*pointer << 3);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
pointer++;
}
}
}
break;
case BITS_24_R8G8B8:
{
uint8_t * pointer = m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
}
}
}
break;
case BITS_32_X8R8G8B8:
{
uint8_t * pointer = m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
}
}
}
break;
case BITS_32_A8R8G8B8:
{
uint8_t * pointer = m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = *pointer++;
}
}
}
break;
default:
EWOL_DEBUG(" mode = ERROR");
break;
}
}
~Bitmap(void)
{
if (NULL != m_data) {
delete(m_data);
}
if (NULL != m_dataGenerate) {
delete(m_dataGenerate);
}
}
bool LoadOK(void) { if (NULL != m_dataGenerate) { return true; } else { return false; } };
int32_t Width(void) { return m_width; };
int32_t Height(void) { return m_height; };
uint8_t * Data(void) { return m_dataGenerate; };
void Display(void)
{
if (NULL == m_data) {
EWOL_ERROR("Might loading error of this Bitmap ...");
return;
}
EWOL_DEBUG(" -----------------------------------------------------------");
if (false) {
EWOL_DEBUG("Display caracteristic of the bitmap : ");
EWOL_DEBUG(" Header of file :");
EWOL_DEBUG(" bfType =" << m_FileHeader.bfType << " 19778 : must always be set to 'BM' to declare that this is a .bmp-file.");
EWOL_DEBUG(" bfSize =" << m_FileHeader.bfSize << " specifies the size of the file in bytes.");
EWOL_DEBUG(" bfReserved=" << m_FileHeader.bfReserved << " must always be set to zero.");
EWOL_DEBUG(" bfOffBits =" << m_FileHeader.bfOffBits << " 1078 : specifies the offset from the beginning of the file to the bitmap data.");
EWOL_DEBUG(" info header of file :");
EWOL_DEBUG(" biSize =" << m_InfoHeader.biSize << " specifies the size of the BITMAPINFOHEADER structure, in bytes.");
EWOL_DEBUG(" biWidth =" << m_InfoHeader.biWidth << " specifies the width of the image, in pixels.");
EWOL_DEBUG(" biHeight =" << m_InfoHeader.biHeight << " specifies the height of the image, in pixels.");
EWOL_DEBUG(" biPlanes =" << m_InfoHeader.biPlanes << " specifies the number of planes of the target device, must be set to zero.");
EWOL_DEBUG(" biBitCount =" << m_InfoHeader.biBitCount << " specifies the number of bits per pixel.");
EWOL_DEBUG(" biCompression =" << m_InfoHeader.biCompression << " Specifies the type of compression, usually set to zero (no compression).");
EWOL_DEBUG(" biSizeImage =" << m_InfoHeader.biSizeImage << " specifies the size of the image data, in bytes. If there is no compression, it is valid to set this member to zero.");
EWOL_DEBUG(" biXPelsPerMeter=" << m_InfoHeader.biXPelsPerMeter << " specifies the the horizontal pixels per meter on the designated targer device, usually set to zero.");
EWOL_DEBUG(" biYPelsPerMeter=" << m_InfoHeader.biYPelsPerMeter << " specifies the the vertical pixels per meter on the designated targer device, usually set to zero.");
EWOL_DEBUG(" biClrUsed =" << m_InfoHeader.biClrUsed << " speglTexImage2Dcifies the number of colors used in the bitmap, if set to zero the number of colors is calculated using the biBitCount member.");
EWOL_DEBUG(" biClrImportant =" << m_InfoHeader.biClrImportant << " specifies the number of color that are 'important' for the bitmap, if set to zero, all colors are important.");
}
EWOL_DEBUG("Bitmap : " << m_width << "x" << m_height);
switch(m_dataMode)
{
case BITS_16_R5G6B5:
EWOL_DEBUG(" mode = 16 bits R5G6B5");
break;
case BITS_16_X1R5G5B5:
EWOL_DEBUG(" mode = 16 bits X1R5G5B5");
break;
case BITS_24_R8G8B8:
EWOL_DEBUG(" mode = 24 bits R8G8B8");
break;
case BITS_32_X8R8G8B8:
EWOL_DEBUG(" mode = 32 bits X8R8G8B8");
break;
case BITS_32_A8R8G8B8:
EWOL_DEBUG(" mode = 32 bits A8R8G8B8");
break;
default:
EWOL_DEBUG(" mode = ERROR");
break;
}
}
};
//! One Texture element
class LoadedTexture class LoadedTexture
{ {
public: public:
@ -328,19 +52,18 @@ class LoadedTexture
bool m_loaded; bool m_loaded;
bool m_destroy; bool m_destroy;
}; };
//! List of all Texture loaded ...
etk::VectorType<LoadedTexture*> l_listLoadedTexture;
etk::VectorType<LoadedTexture*> listLoadedTexture;
#undef __class__ #undef __class__
#define __class__ "ewol::texture" #define __class__ "texture"
static pthread_mutex_t localMutex; static pthread_mutex_t localMutex;
/**
* @brief Initialise the texture namespace (init a mutex)
* @param ---
* @return ---
*/
void ewol::texture::Init(void) void ewol::texture::Init(void)
{ {
EWOL_DEBUG("==> Init Texture-Manager"); EWOL_DEBUG("==> Init Texture-Manager");
@ -349,92 +72,112 @@ void ewol::texture::Init(void)
EWOL_ASSERT(ret == 0, "Error creating Mutex ..."); EWOL_ASSERT(ret == 0, "Error creating Mutex ...");
} }
/**
* @brief Un-Initialise the Texture namespace (Remove all loaded texture and temporary data and remove Mutex)
* @param ---
* @return ---
*/
void ewol::texture::UnInit(void) void ewol::texture::UnInit(void)
{ {
pthread_mutex_lock(&localMutex);
EWOL_DEBUG("==> Un-Init Texture-Manager"); EWOL_DEBUG("==> Un-Init Texture-Manager");
for (int32_t iii=0; iii<listLoadedTexture.Size(); iii++) { for (int32_t iii=0; iii<l_listLoadedTexture.Size(); iii++) {
if (listLoadedTexture[iii] != NULL) { if (l_listLoadedTexture[iii] != NULL) {
delete(listLoadedTexture[iii]); delete(l_listLoadedTexture[iii]);
} }
listLoadedTexture[iii] = NULL; l_listLoadedTexture[iii] = NULL;
} }
listLoadedTexture.Clear(); l_listLoadedTexture.Clear();
pthread_mutex_unlock(&localMutex);
int ret = pthread_mutex_destroy(&localMutex); int ret = pthread_mutex_destroy(&localMutex);
EWOL_ASSERT(ret == 0, "Error destroying Mutex ..."); EWOL_ASSERT(ret == 0, "Error destroying Mutex ...");
} }
#undef __class__ /**
#define __class__ "ewol" * @brief Specific for Android, some configuration restart openGl context when the screen is rotate, then,
* Android inform us that the openGl context has been destroy. We mark all the texture like not loaded
void ewol::UpdateTextureContextIsDestroy(void) * To load it again when a new context will be enable (@ref UpdateContext)
* @param ---
* @return ---
*/
void ewol::texture::UpdateContextIsDestroy(void)
{ {
pthread_mutex_lock(&localMutex); pthread_mutex_lock(&localMutex);
for (int32_t iii=0; iii < listLoadedTexture.Size(); iii++) { for (int32_t iii=0; iii < l_listLoadedTexture.Size(); iii++) {
if( NULL != listLoadedTexture[iii] if( NULL != l_listLoadedTexture[iii]
&& NULL != listLoadedTexture[iii]->m_data) && NULL != l_listLoadedTexture[iii]->m_data)
{ {
listLoadedTexture[iii]->m_loaded = false; l_listLoadedTexture[iii]->m_loaded = false;
EWOL_INFO("TEXTURE: Disable [" << iii << "]=(" << listLoadedTexture[iii]->m_width << "px," << EWOL_INFO("TEXTURE: Disable [" << iii << "]=(" << l_listLoadedTexture[iii]->m_width << "px," <<
listLoadedTexture[iii]->m_height << "px) in file:" << l_listLoadedTexture[iii]->m_height << "px) in file:" <<
listLoadedTexture[iii]->m_filename << " OGl_Id=" <<listLoadedTexture[iii]->m_openGlTextureID); l_listLoadedTexture[iii]->m_filename << " OGl_Id=" <<l_listLoadedTexture[iii]->m_openGlTextureID);
//glDeleteTextures(1, &listLoadedTexture[iii]->m_openGlTextureID); // note : the context might be destroy... we can not remove the textures ...
//glDeleteTextures(1, &l_listLoadedTexture[iii]->m_openGlTextureID);
} }
} }
pthread_mutex_unlock(&localMutex); pthread_mutex_unlock(&localMutex);
} }
void ewol::UpdateTextureContext(void)
/**
* @brief Check all texture and load/Remove/Reload all texture that has been Add/Remove/Change from the previous display cycle
* @param ---
* @return ---
*/
// TODO : The reload might be writen ...
void ewol::texture::UpdateContext(void)
{ {
bool needRedraw = false; bool needRedraw = false;
pthread_mutex_lock(&localMutex); pthread_mutex_lock(&localMutex);
for (int32_t iii=0; iii < listLoadedTexture.Size(); iii++) { for (int32_t iii=0; iii < l_listLoadedTexture.Size(); iii++) {
if( NULL != listLoadedTexture[iii] if( NULL != l_listLoadedTexture[iii]
&& NULL != listLoadedTexture[iii]->m_data) && NULL != l_listLoadedTexture[iii]->m_data)
{ {
if( false == listLoadedTexture[iii]->m_destroy if( false == l_listLoadedTexture[iii]->m_destroy
&& false == listLoadedTexture[iii]->m_loaded) && false == l_listLoadedTexture[iii]->m_loaded)
{ {
GLuint textureid; GLuint textureid;
glGenTextures(1, &textureid); glGenTextures(1, &textureid);
glBindTexture(listLoadedTexture[iii]->m_target, textureid); glBindTexture(l_listLoadedTexture[iii]->m_target, textureid);
//glTexParameteri(tmpTex->m_target, GL_TEXTURE_WRAP_S, GL_REPEAT); //glTexParameteri(tmpTex->m_target, GL_TEXTURE_WRAP_S, GL_REPEAT);
//glTexParameteri(tmpTex->m_target, GL_TEXTURE_WRAP_T, GL_REPEAT); //glTexParameteri(tmpTex->m_target, GL_TEXTURE_WRAP_T, GL_REPEAT);
//--- mode nearest //--- mode nearest
//glTexParameteri(tmpTex->m_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST); //glTexParameteri(tmpTex->m_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//glTexParameteri(tmpTex->m_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST); //glTexParameteri(tmpTex->m_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
//--- Mode linear //--- Mode linear
glTexParameteri(listLoadedTexture[iii]->m_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(l_listLoadedTexture[iii]->m_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(listLoadedTexture[iii]->m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(l_listLoadedTexture[iii]->m_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
EWOL_INFO("TEXTURE: Add [" << iii << "]=(" << listLoadedTexture[iii]->m_width << "px," << EWOL_INFO("TEXTURE: Add [" << iii << "]=(" << l_listLoadedTexture[iii]->m_width << "px," <<
listLoadedTexture[iii]->m_height << "px) in file:" << l_listLoadedTexture[iii]->m_height << "px) in file:" <<
listLoadedTexture[iii]->m_filename << " OGl_Id=" <<textureid); l_listLoadedTexture[iii]->m_filename << " OGl_Id=" <<textureid);
glTexImage2D(listLoadedTexture[iii]->m_target, glTexImage2D(l_listLoadedTexture[iii]->m_target,
listLoadedTexture[iii]->m_level, l_listLoadedTexture[iii]->m_level,
listLoadedTexture[iii]->m_internalFormat, l_listLoadedTexture[iii]->m_internalFormat,
listLoadedTexture[iii]->m_width, l_listLoadedTexture[iii]->m_width,
listLoadedTexture[iii]->m_height, l_listLoadedTexture[iii]->m_height,
listLoadedTexture[iii]->m_border, l_listLoadedTexture[iii]->m_border,
listLoadedTexture[iii]->m_format, l_listLoadedTexture[iii]->m_format,
listLoadedTexture[iii]->m_type, l_listLoadedTexture[iii]->m_type,
listLoadedTexture[iii]->m_data); l_listLoadedTexture[iii]->m_data);
listLoadedTexture[iii]->m_openGlTextureID = textureid; l_listLoadedTexture[iii]->m_openGlTextureID = textureid;
listLoadedTexture[iii]->m_loaded = true; l_listLoadedTexture[iii]->m_loaded = true;
needRedraw = true; needRedraw = true;
} else if ( true == listLoadedTexture[iii]->m_destroy } else if ( true == l_listLoadedTexture[iii]->m_destroy
&& true == listLoadedTexture[iii]->m_loaded) && true == l_listLoadedTexture[iii]->m_loaded)
{ {
// Request remove texture ... // Request remove texture ...
EWOL_DEBUG("TEXTURE: Rm [" << iii << "] file:" << listLoadedTexture[iii]->m_filename); EWOL_INFO("TEXTURE: Rm [" << iii << "] file:" << l_listLoadedTexture[iii]->m_filename);
glDeleteTextures(1, &listLoadedTexture[iii]->m_openGlTextureID); glDeleteTextures(1, &l_listLoadedTexture[iii]->m_openGlTextureID);
listLoadedTexture[iii]->m_loaded = false; l_listLoadedTexture[iii]->m_loaded = false;
listLoadedTexture[iii]->m_openGlTextureID = -1; l_listLoadedTexture[iii]->m_openGlTextureID = -1;
if (NULL != listLoadedTexture[iii]->m_data) { if (NULL != l_listLoadedTexture[iii]->m_data) {
delete[] listLoadedTexture[iii]->m_data; delete[] l_listLoadedTexture[iii]->m_data;
listLoadedTexture[iii]->m_data = NULL; l_listLoadedTexture[iii]->m_data = NULL;
} }
delete(listLoadedTexture[iii]); delete(l_listLoadedTexture[iii]);
listLoadedTexture[iii] = NULL; l_listLoadedTexture[iii] = NULL;
} }
} }
} }
@ -444,17 +187,25 @@ void ewol::UpdateTextureContext(void)
} }
} }
int32_t ewol::LoadTexture(int32_t target,
int32_t level, /**
int32_t internalFormat, * @brief Register a texture in the automatic system to load and reload
int32_t width, * @param[in] target Standard element of OpenGL target
int32_t height, * @param[in] level Standard element of OpenGL level
int32_t border, * @param[in] internalFormat Standard element of OpenGL internalFormat
int32_t format, * @param[in] width Standard element of OpenGL width
int32_t type, * @param[in] height Standard element of OpenGL height
const void* data, * @param[in] border Standard element of OpenGL border
int32_t nbBytes, * @param[in] format Standard element of OpenGL format
etk::UString filename) * @param[in] type Standard element of OpenGL type
* @param[in] data Pointer on the buffer where are contain the data (a copy is done automaticly)
* @param[in] nbBytes Number of byte in the buffer
* @param[in] filename File Name of the texture or "---" if it is an internal loaded texture
* @return The Internal ID of the texture, or -1 if an error occured ...
*/
int32_t ewol::texture::Load(int32_t target, int32_t level, int32_t internalFormat, int32_t width, int32_t height,
int32_t border, int32_t format, int32_t type,
const void* data, int32_t nbBytes, etk::UString filename)
{ {
LoadedTexture *tmpTex = new LoadedTexture(); LoadedTexture *tmpTex = new LoadedTexture();
@ -463,6 +214,10 @@ int32_t ewol::LoadTexture(int32_t target,
EWOL_ERROR("Texture : Allocation ERROR... " << filename); EWOL_ERROR("Texture : Allocation ERROR... " << filename);
return -1; return -1;
} }
if (NULL == data){
EWOL_ERROR("Texture : Input pointer of the data texture =NULL... " << filename);
return -1;
}
tmpTex->m_filename = filename; tmpTex->m_filename = filename;
tmpTex->m_nbTimeLoaded = 1; tmpTex->m_nbTimeLoaded = 1;
@ -486,80 +241,155 @@ int32_t ewol::LoadTexture(int32_t target,
memcpy(tmpTex->m_data, data, sizeof(char) * tmpTex->m_nbBytes); memcpy(tmpTex->m_data, data, sizeof(char) * tmpTex->m_nbBytes);
pthread_mutex_lock(&localMutex); pthread_mutex_lock(&localMutex);
listLoadedTexture.PushBack(tmpTex); l_listLoadedTexture.PushBack(tmpTex);
outTextureID = listLoadedTexture.Size()-1; outTextureID = l_listLoadedTexture.Size()-1;
pthread_mutex_unlock(&localMutex); pthread_mutex_unlock(&localMutex);
return outTextureID; return outTextureID;
} }
int32_t ewol::LoadTexture(etk::File fileName) /**
* @brief get the next power 2 if the input
* @param[in] value Value that we want the next power of 2
* @return result value
*/
static int32_t nextP2(int32_t value)
{
int32_t val=1;
for (int32_t iii=1; iii<31; iii++) {
if (value <= val) {
return val;
}
val *=2;
}
EWOL_CRITICAL("impossible CASE....");
return val;
}
/**
* @brief Load a specific file texture
* @note : dimention must be a power of 2, otherwise, the display can be wrong... For the SVG, the texture automaticly generate the power of 2 dimention ...
* @param[in] fileName File that might be open
* @param[in] requestedWidth Requested size of the file we desire (if we can not resize it, we load it whit his normal size)
* @return The Internal ID of the texture, or -1 if an error occured ...
*/
// TODO : Load non square texture ...
// TODO : Check the size to regenerate the texture if the size change
int32_t ewol::texture::Load(etk::File fileName, int32_t requestedWidth)
{ {
int32_t outTextureID = -1; int32_t outTextureID = -1;
if (listLoadedTexture.Size()!=0) { if (l_listLoadedTexture.Size()!=0) {
for (int32_t iii=0; iii<listLoadedTexture.Size(); iii++) { for (int32_t iii=0; iii<l_listLoadedTexture.Size(); iii++) {
if (NULL != listLoadedTexture[iii]) { if (NULL != l_listLoadedTexture[iii]) {
if (listLoadedTexture[iii]->m_filename == fileName.GetCompleateName()) { if (l_listLoadedTexture[iii]->m_filename == fileName.GetCompleateName()) {
listLoadedTexture[iii]->m_nbTimeLoaded++; l_listLoadedTexture[iii]->m_nbTimeLoaded++;
return iii; return iii;
} }
} }
} }
} }
etk::UString fileExtention = fileName.GetExtention();
if (fileExtention == "bmp") {
if (false == fileName.Exist()) { if (false == fileName.Exist()) {
EWOL_ERROR("File does not Exist ... " << fileName); EWOL_ERROR("File does not Exist ... " << fileName);
} else { } else {
Bitmap * myBitmap = new Bitmap(fileName); etk::UString fileExtention = fileName.GetExtention();
if (fileExtention == "bmp") {
// create the bitmap texture
ewol::texture::TextureBMP * myBitmap = new ewol::texture::TextureBMP(fileName);
// draw bitmap properties
myBitmap->Display(); myBitmap->Display();
// check if all is OK
if (myBitmap->LoadOK() == true) { if (myBitmap->LoadOK() == true) {
if (myBitmap->Width()!= myBitmap->Height()) { if (myBitmap->Width() != nextP2(myBitmap->Width()) ) {
EWOL_ERROR("Texture has not the good dimention power of 2 : Width=" << myBitmap->Width() << "px ==> maybe not drawable ...");
}
if (myBitmap->Width() != myBitmap->Height()) {
EWOL_ERROR("Texture can not have Width=" << myBitmap->Width() << "px different of height=" << myBitmap->Height() << "px in file:" << fileName); EWOL_ERROR("Texture can not have Width=" << myBitmap->Width() << "px different of height=" << myBitmap->Height() << "px in file:" << fileName);
return -1; return -1;
} }
outTextureID = LoadTexture(GL_TEXTURE_2D, 0, GL_RGBA, myBitmap->Width(), myBitmap->Height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, myBitmap->Data(), myBitmap->Width()*myBitmap->Height()*4, fileName.GetCompleateName()); outTextureID = ewol::texture::Load(GL_TEXTURE_2D, 0, GL_RGBA, myBitmap->Width(), myBitmap->Height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, myBitmap->Data(), myBitmap->DataSize(), fileName.GetCompleateName());
} }
// removet the bitmap handle
delete (myBitmap); delete (myBitmap);
} else if (fileExtention == "svg") {
// get the upper paw2 ot the size requested...
requestedWidth = nextP2(requestedWidth);
/*if (requestedWidth < 32) {
requestedWidth = 32;
}*/
// create the bitmap texture
ewol::texture::TextureSVG * mySvg = new ewol::texture::TextureSVG(fileName, requestedWidth, requestedWidth);
// draw bitmap properties
mySvg->Display();
// check if all is OK
if (mySvg->LoadOK() == true) {
if (mySvg->Width() != mySvg->Height()) {
EWOL_ERROR("Texture can not have Width=" << mySvg->Width() << "px different of height=" << mySvg->Height() << "px in file:" << fileName);
return -1;
} }
outTextureID = ewol::texture::Load(GL_TEXTURE_2D, 0, GL_RGBA, mySvg->Width(), mySvg->Height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, mySvg->Data(), mySvg->DataSize(), fileName.GetCompleateName());
}
// removet the bitmap handle
delete (mySvg);
} else if (fileExtention == "png") {
EWOL_ERROR("Extention not supported now, but soon " << fileName );
} else { } else {
EWOL_ERROR("Extention not managed " << fileName << " Sopported extention : .bmp"); EWOL_ERROR("Extention not managed " << fileName << " Sopported extention : .bmp / .svg / .png");
}
} }
return outTextureID; return outTextureID;
} }
void ewol::UnLoadTexture(uint32_t textureID)
/**
* @brief Remove a specific texture ID from the system
* @note A texture can be loaded as many time we want, the texture will be destroy only when nobody want the texture anymore
* @param[in] textureID The internal texture ID that might be remove
* @return ---
*/
void ewol::texture::UnLoad(uint32_t textureID)
{ {
EWOL_INFO("Unload a specific tecture ID=" << textureID); EWOL_INFO("Unload a specific tecture ID=" << textureID);
if (textureID>=0 && (int32_t)textureID<listLoadedTexture.Size()) { if (textureID>=0 && (int32_t)textureID<l_listLoadedTexture.Size()) {
if (NULL == listLoadedTexture[textureID]) { if (NULL == l_listLoadedTexture[textureID]) {
EWOL_ERROR("Texture : " << textureID << " does not existe anymore..."); EWOL_ERROR("Texture : " << textureID << " does not existe anymore...");
return; return;
} }
listLoadedTexture[textureID]->m_nbTimeLoaded--; l_listLoadedTexture[textureID]->m_nbTimeLoaded--;
if (0 == listLoadedTexture[textureID]->m_nbTimeLoaded) { if (0 == l_listLoadedTexture[textureID]->m_nbTimeLoaded) {
EWOL_DEBUG("Remove openGL texture ID=" << textureID << " file:" << listLoadedTexture[textureID]->m_filename); EWOL_DEBUG("Remove openGL texture ID=" << textureID << " file:" << l_listLoadedTexture[textureID]->m_filename);
listLoadedTexture[textureID]->m_destroy = true; l_listLoadedTexture[textureID]->m_destroy = true;
} }
return; return;
} }
EWOL_CRITICAL("Can not find TextureId=" << (int)textureID << " in the list of texture loaded...==> to remove it ..."); EWOL_CRITICAL("Can not find TextureId=" << (int)textureID << " in the list of texture loaded...==> to remove it ...");
} }
uint32_t ewol::GetTextureGLID(uint32_t textureID)
/**
* @brief Get the openGL texture ID whith the internal ID
* @param textureID the internal texture ID
* @return the OpenGl texture ID (or 0 if an error occured...)
*/
uint32_t ewol::texture::GetGLID(uint32_t textureID)
{ {
if (textureID>=0 && (int32_t)textureID<listLoadedTexture.Size()) { if (textureID>=0 && (int32_t)textureID<l_listLoadedTexture.Size()) {
return listLoadedTexture[textureID]->m_openGlTextureID; return l_listLoadedTexture[textureID]->m_openGlTextureID;
} }
return -1; return 0;
} }
int32_t ewol::GetTextureSize(uint32_t textureID) /**
* @brief Get the size of the specific texture
* @param[in] textureID the internal texture ID
* @return the width of the texture
*/
int32_t ewol::texture::GetSize(uint32_t textureID)
{ {
for (int32_t iii=0; iii<listLoadedTexture.Size(); iii++) { for (int32_t iii=0; iii<l_listLoadedTexture.Size(); iii++) {
if (listLoadedTexture[iii]->m_openGlTextureID == textureID) { if (l_listLoadedTexture[iii]->m_openGlTextureID == textureID) {
return listLoadedTexture[iii]->m_width; return l_listLoadedTexture[iii]->m_width;
} }
} }
EWOL_ERROR("Can not find TextureId=" << textureID << " in the list of texture loaded..."); EWOL_ERROR("Can not find TextureId=" << textureID << " in the list of texture loaded...");

24
Sources/libewol/ewol/Texture.h
View File

@ -31,26 +31,18 @@
namespace ewol namespace ewol
{ {
// TODO : Create a subNameSpace:
/*
namespace texture {
int32_t Load(etk::File fileName);
void UnLoad(uint32_t textureID);
int32_t GetSize(uint32_t textureID);
};
*/
namespace texture { namespace texture {
void Init(void); void Init(void);
void UnInit(void); void UnInit(void);
int32_t Load(etk::File fileName, int32_t requestedWidth=-1);
int32_t Load(int32_t target, int32_t level, int32_t internalFormat, int32_t width, int32_t height, int32_t border, int32_t format, int32_t type, const void* data, int32_t nbBytes, etk::UString filename);
void UnLoad(uint32_t textureID);
int32_t GetSize(uint32_t textureID);
uint32_t GetGLID(uint32_t textureID);
void UpdateContext(void);
void UpdateContextIsDestroy(void);
void OGLContext(bool enable);
}; };
int32_t LoadTexture(etk::File fileName);
int32_t LoadTexture(int32_t target, int32_t level, int32_t internalFormat, int32_t width, int32_t height, int32_t border, int32_t format, int32_t type, const void* data, int32_t nbBytes, etk::UString filename);
void UnLoadTexture(uint32_t textureID);
int32_t GetTextureSize(uint32_t textureID);
uint32_t GetTextureGLID(uint32_t textureID);
void UpdateTextureContext(void);
void UpdateTextureContextIsDestroy(void);
void TextureOGLContext(bool enable);
}; };
#endif #endif

282
Sources/libewol/ewol/Texture/TextureBMP.cpp Normal file
View File

@ -0,0 +1,282 @@
/**
*******************************************************************************
* @file ewol/Texture/TextureBMP.cpp
* @brief ewol Texture Bitmap abstraction (sources)
* @author Edouard DUPIN
* @date 28/03/2012
* @par Project
* ewol
*
* @par Copyright
* Copyright 2011 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
*
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#include <ewol/Texture/TextureBMP.h>
#undef __class__
#define __class__ "texture::TextureBMP"
ewol::texture::TextureBMP::TextureBMP(etk::File & fileName) : m_data(NULL), m_dataGenerate(NULL)
{
m_dataMode = BITS_16_R5G6B5;
m_width = 0;
m_height = 0;
m_size = 0;
// Get the fileSize ...
/*if (fileName.Size() < (int32_t)(sizeof(bitmapFileHeader_ts) + sizeof(bitmapInfoHeader_ts) ) ) {
EWOL_ERROR("not enought data in the file named=\"" << fileName << "\"");
return;
}*/
if(false == fileName.fOpenRead() ) {
EWOL_ERROR("Can not find the file name=\"" << fileName << "\"");
return;
}
// get the data :
if (fileName.fRead(&m_FileHeader,sizeof(bitmapFileHeader_ts),1) != 1) {
EWOL_ERROR("error loading file header");
fileName.fClose();
return;
}
if (fileName.fRead(&m_InfoHeader,sizeof(bitmapInfoHeader_ts),1) != 1) {
EWOL_ERROR("error loading file header");
fileName.fClose();
return;
}
if(false == fileName.fSeek(m_FileHeader.bfOffBits, SEEK_SET)) {
EWOL_ERROR("error with the 'bfOffBits' in the file named=\"" << fileName << "\"");
fileName.fClose();
return;
}
// Check the header error :
if (m_FileHeader.bfType != 0x4D42) {
EWOL_ERROR("the file=\"" << fileName << "\" is not a bitmap file ...");
fileName.fClose();
return;
}
if (m_FileHeader.bfReserved != 0x00000000) {
EWOL_ERROR("the bfReserved feald is not at 0 ==> not supported format ...");
fileName.fClose();
return;
}
if( m_InfoHeader.biBitCount == 16
&& m_InfoHeader.biCompression == 0)
{
m_dataMode = BITS_16_X1R5G5B5;
} else if( m_InfoHeader.biBitCount == 16
&& m_InfoHeader.biCompression == 3)
{
m_dataMode = BITS_16_R5G6B5;
} else if( m_InfoHeader.biBitCount == 24
&& m_InfoHeader.biCompression == 0)
{
m_dataMode = BITS_24_R8G8B8;
} else if( m_InfoHeader.biBitCount == 32
&& m_InfoHeader.biCompression == 3)
{
m_dataMode = BITS_32_X8R8G8B8;
} else if( m_InfoHeader.biBitCount == 32
&& m_InfoHeader.biCompression == 0)
{
m_dataMode = BITS_32_A8R8G8B8;
} else {
EWOL_ERROR("the biBitCount & biCompression fealds are unknow ==> not supported format ...");
fileName.fClose();;
return;
}
m_width = m_InfoHeader.biWidth;
m_height = m_InfoHeader.biHeight;
if(0 != m_InfoHeader.biSizeImage)
{
m_data=new uint8_t[m_InfoHeader.biSizeImage];
if (fileName.fRead(m_data,m_InfoHeader.biSizeImage,1) != 1){
EWOL_CRITICAL("Can not read the file with the good size...");
}
// allocate the destination data ...
m_dataGenerate=new uint8_t[m_width*m_height*4];
}
fileName.fClose();
// need now to generate RGBA data ...
switch(m_dataMode)
{
case BITS_16_R5G6B5:
{
uint16_t * pointer = (uint16_t*)m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = (int8_t)((*pointer & 0xF800) >> 8);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = (int8_t)((*pointer & 0x07E0) >> 3);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = (int8_t)(*pointer << 3);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
pointer++;
}
}
}
break;
case BITS_16_X1R5G5B5:
{
uint16_t * pointer = (uint16_t*)m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = (int8_t)((*pointer & 0x7C00) >> 7);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = (int8_t)((*pointer & 0x03E0) >> 2);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = (int8_t)(*pointer << 3);
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
pointer++;
}
}
}
break;
case BITS_24_R8G8B8:
{
uint8_t * pointer = m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
}
}
}
break;
case BITS_32_X8R8G8B8:
{
uint8_t * pointer = m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = 0xFF;
}
}
}
break;
case BITS_32_A8R8G8B8:
{
uint8_t * pointer = m_data;
for(int32_t yyy=0; yyy<m_height; yyy++) {
for(int32_t xxx=0; xxx<m_width; xxx++) {
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 0] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 1] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 2] = *pointer++;
m_dataGenerate[4*((m_height-yyy-1) * m_width + xxx ) + 3] = *pointer++;
}
}
}
break;
default:
EWOL_DEBUG(" mode = ERROR");
break;
}
}
ewol::texture::TextureBMP::~TextureBMP(void)
{
if (NULL != m_data) {
delete(m_data);
}
if (NULL != m_dataGenerate) {
delete(m_dataGenerate);
}
}
bool ewol::texture::TextureBMP::LoadOK(void)
{
if (NULL != m_dataGenerate) {
return true;
} else {
return false;
}
};
int32_t ewol::texture::TextureBMP::Width(void)
{
return m_width;
}
int32_t ewol::texture::TextureBMP::Height(void)
{
return m_height;
}
uint8_t * ewol::texture::TextureBMP::Data(void)
{
return m_dataGenerate;
};
uint32_t ewol::texture::TextureBMP::DataSize(void)
{
if (NULL == m_dataGenerate) {
return 0;
}
return m_width*m_height*4;
}
void ewol::texture::TextureBMP::Display(void)
{
if (NULL == m_data) {
EWOL_ERROR("Might loading error of this Bitmap ...");
return;
}
EWOL_DEBUG(" -----------------------------------------------------------");
if (false) {
EWOL_DEBUG("Display caracteristic of the bitmap : ");
EWOL_DEBUG(" Header of file :");
EWOL_DEBUG(" bfType =" << m_FileHeader.bfType << " 19778 : must always be set to 'BM' to declare that this is a .bmp-file.");
EWOL_DEBUG(" bfSize =" << m_FileHeader.bfSize << " specifies the size of the file in bytes.");
EWOL_DEBUG(" bfReserved=" << m_FileHeader.bfReserved << " must always be set to zero.");
EWOL_DEBUG(" bfOffBits =" << m_FileHeader.bfOffBits << " 1078 : specifies the offset from the beginning of the file to the bitmap data.");
EWOL_DEBUG(" info header of file :");
EWOL_DEBUG(" biSize =" << m_InfoHeader.biSize << " specifies the size of the BITMAPINFOHEADER structure, in bytes.");
EWOL_DEBUG(" biWidth =" << m_InfoHeader.biWidth << " specifies the width of the image, in pixels.");
EWOL_DEBUG(" biHeight =" << m_InfoHeader.biHeight << " specifies the height of the image, in pixels.");
EWOL_DEBUG(" biPlanes =" << m_InfoHeader.biPlanes << " specifies the number of planes of the target device, must be set to zero.");
EWOL_DEBUG(" biBitCount =" << m_InfoHeader.biBitCount << " specifies the number of bits per pixel.");
EWOL_DEBUG(" biCompression =" << m_InfoHeader.biCompression << " Specifies the type of compression, usually set to zero (no compression).");
EWOL_DEBUG(" biSizeImage =" << m_InfoHeader.biSizeImage << " specifies the size of the image data, in bytes. If there is no compression, it is valid to set this member to zero.");
EWOL_DEBUG(" biXPelsPerMeter=" << m_InfoHeader.biXPelsPerMeter << " specifies the the horizontal pixels per meter on the designated targer device, usually set to zero.");
EWOL_DEBUG(" biYPelsPerMeter=" << m_InfoHeader.biYPelsPerMeter << " specifies the the vertical pixels per meter on the designated targer device, usually set to zero.");
EWOL_DEBUG(" biClrUsed =" << m_InfoHeader.biClrUsed << " speglTexImage2Dcifies the number of colors used in the bitmap, if set to zero the number of colors is calculated using the biBitCount member.");
EWOL_DEBUG(" biClrImportant =" << m_InfoHeader.biClrImportant << " specifies the number of color that are 'important' for the bitmap, if set to zero, all colors are important.");
}
EWOL_DEBUG("Bitmap : " << m_width << "x" << m_height);
switch(m_dataMode)
{
case BITS_16_R5G6B5:
EWOL_DEBUG(" mode = 16 bits R5G6B5");
break;
case BITS_16_X1R5G5B5:
EWOL_DEBUG(" mode = 16 bits X1R5G5B5");
break;
case BITS_24_R8G8B8:
EWOL_DEBUG(" mode = 24 bits R8G8B8");
break;
case BITS_32_X8R8G8B8:
EWOL_DEBUG(" mode = 32 bits X8R8G8B8");
break;
case BITS_32_A8R8G8B8:
EWOL_DEBUG(" mode = 32 bits A8R8G8B8");
break;
default:
EWOL_DEBUG(" mode = ERROR");
break;
}
}

93
Sources/libewol/ewol/Texture/TextureBMP.h Normal file
View File

@ -0,0 +1,93 @@
/**
*******************************************************************************
* @file ewol/Texture/TextureBMP.h
* @brief ewol Texture Bitmap abstraction (header)
* @author Edouard DUPIN
* @date 28/03/2012
* @par Project
* ewol
*
* @par Copyright
* Copyright 2011 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
*
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#ifndef __EWOL_TEXTURE_BITMAP_H__
#define __EWOL_TEXTURE_BITMAP_H__
#include <etk/Types.h>
#include <ewol/Debug.h>
#include <etk/File.h>
namespace ewol
{
namespace texture {
#pragma pack(push,1)
typedef struct
{
int16_t bfType;
int32_t bfSize;
int32_t bfReserved;
int32_t bfOffBits;
} bitmapFileHeader_ts;
typedef struct
{
int32_t biSize;
int32_t biWidth;
int32_t biHeight;
int16_t biPlanes;
int16_t biBitCount;
int32_t biCompression;
int32_t biSizeImage;
int32_t biXPelsPerMeter;
int32_t biYPelsPerMeter;
int32_t biClrUsed;
int32_t biClrImportant;
} bitmapInfoHeader_ts;
#pragma pack(pop)
typedef enum {
BITS_16_R5G6B5,
BITS_16_X1R5G5B5,
BITS_24_R8G8B8,
BITS_32_X8R8G8B8,
BITS_32_A8R8G8B8
} modeBitmap_te;
class TextureBMP
{
private:
modeBitmap_te m_dataMode;
int32_t m_width;
int32_t m_height;
int32_t m_size;
uint8_t * m_data;
uint8_t * m_dataGenerate;
bitmapFileHeader_ts m_FileHeader;
bitmapInfoHeader_ts m_InfoHeader;
public:
TextureBMP(etk::File & fileName);
~TextureBMP(void);
bool LoadOK(void);
int32_t Width(void);
int32_t Height(void);
uint8_t * Data(void);
uint32_t DataSize(void);
void Display(void);
};
};
};
#endif

0
Sources/libewol/ewol/Texture/TexturePNG.cpp Normal file
View File

0
Sources/libewol/ewol/Texture/TexturePNG.h Normal file
View File

86
Sources/libewol/ewol/Texture/TextureSVG.cpp Normal file
View File

@ -0,0 +1,86 @@
/**
*******************************************************************************
* @file ewol/Texture/TextureSVG.cpp
* @brief ewol Texture SVG abstraction (Sources)
* @author Edouard DUPIN
* @date 28/03/2012
* @par Project
* ewol
*
* @par Copyright
* Copyright 2011 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
*
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#include <ewol/Texture/TextureSVG.h>
#undef __class__
#define __class__ "texture::TextureSVG"
ewol::texture::TextureSVG::TextureSVG(etk::File & fileName, int32_t width, int32_t height) : m_elementParsed(fileName)
{
m_loadOK = false;
if (false == m_elementParsed.IsLoadOk()) {
EWOL_ERROR("Error To load SVG file " << fileName.GetCompleateName() );
} else {
m_elementParsed.GenerateAnImage(width, height);
m_loadOK = true;
}
if (width == -1) {
coord2D_ts elementSize = m_elementParsed.GetDefinedSize();
m_width = elementSize.x;
m_height = elementSize.y;
} else {
m_width = width;
m_height = height;
}
}
ewol::texture::TextureSVG::~TextureSVG(void)
{
}
bool ewol::texture::TextureSVG::LoadOK(void)
{
return m_loadOK;
}
int32_t ewol::texture::TextureSVG::Width(void)
{
return m_width;
}
int32_t ewol::texture::TextureSVG::Height(void)
{
return m_height;
}
uint8_t * ewol::texture::TextureSVG::Data(void)
{
return m_elementParsed.GetPointerOnData();
}
uint32_t ewol::texture::TextureSVG::DataSize(void)
{
return m_elementParsed.GetSizeOnData();
}
void ewol::texture::TextureSVG::Display(void)
{
EWOL_DEBUG("SVG Texture : (" << m_width << "," << m_height << ") loadedOK=" << m_loadOK);
}

59
Sources/libewol/ewol/Texture/TextureSVG.h Normal file
View File

@ -0,0 +1,59 @@
/**
*******************************************************************************
* @file ewol/Texture/TextureSVG.h
* @brief ewol Texture SVG abstraction (header)
* @author Edouard DUPIN
* @date 28/03/2012
* @par Project
* ewol
*
* @par Copyright
* Copyright 2011 Edouard DUPIN, all right reserved
*
* This software is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY.
*
* Licence summary :
* You can modify and redistribute the sources code and binaries.
* You can send me the bug-fix
*
* Term of the licence in in the file licence.txt.
*
*******************************************************************************
*/
#ifndef __EWOL_TEXTURE_SVG_H__
#define __EWOL_TEXTURE_SVG_H__
#include <etk/Types.h>
#include <ewol/Debug.h>
#include <etk/File.h>
#include <parserSVG/parserSVG.h>
namespace ewol
{
namespace texture {
class TextureSVG
{
private:
svg::Parser m_elementParsed;
int32_t m_width;
int32_t m_height;
int32_t m_size;
uint8_t * m_data;
bool m_loadOK;
public:
TextureSVG(etk::File & fileName, int32_t width, int32_t height);
~TextureSVG(void);
bool LoadOK(void);
int32_t Width(void);
int32_t Height(void);
uint8_t * Data(void);
uint32_t DataSize(void);
void Display(void);
};
};
};
#endif

3
Sources/libewol/ewol/base/gui.cpp
View File

@ -177,6 +177,7 @@ void EWOL_GenericDraw(bool everyTime)
if( true == ewol::widgetManager::GetDoubleBufferNeedDraw() if( true == ewol::widgetManager::GetDoubleBufferNeedDraw()
|| true == everyTime) || true == everyTime)
{ {
ewol::texture::UpdateContext();
nbDisplayTime++; nbDisplayTime++;
gui_uniqueWindows->SysDraw(); gui_uniqueWindows->SysDraw();
//EWOL_WARNING("DRAW..."); //EWOL_WARNING("DRAW...");
@ -195,7 +196,7 @@ void EWOL_GenericDraw(bool everyTime)
void EWOL_NativeGLDestroy(void) void EWOL_NativeGLDestroy(void)
{ {
ewol::UpdateTextureContextIsDestroy(); ewol::texture::UpdateContextIsDestroy();
} }

2
Sources/libewol/ewol/base/guiAndroid.cpp
View File

@ -82,7 +82,7 @@ static etkFloat_t gTriangleVertices5[] = { 200.0f, 200.0f, 100.0f, 200.0f, 200.0
void EWOL_NativeRender(void) void EWOL_NativeRender(void)
{ {
ewol::UpdateTextureContext(); ewol::texture::UpdateContext();
//EWOL_DEBUG("redraw (" << gui_width << "," << gui_height << ")"); //EWOL_DEBUG("redraw (" << gui_width << "," << gui_height << ")");
if(NULL == gui_uniqueWindows) { if(NULL == gui_uniqueWindows) {
// set the size of the open GL system // set the size of the open GL system

2
Sources/libewol/ewol/base/guiX11.cpp
View File

@ -292,7 +292,7 @@ bool CreateOGlContext(void)
void EWOL_NativeRender(void) void EWOL_NativeRender(void)
{ {
ewol::UpdateTextureContext(); ewol::texture::UpdateContext();
//EWOL_DEBUG("redraw (" << gui_width << "," << gui_height << ")"); //EWOL_DEBUG("redraw (" << gui_width << "," << gui_height << ")");
if(NULL == gui_uniqueWindows) { if(NULL == gui_uniqueWindows) {
//EWOL_DEBUG("Has No Windows set..."); //EWOL_DEBUG("Has No Windows set...");

37
Sources/libewol/ewol/widget/Button.cpp
View File

@ -43,7 +43,7 @@ void ewol::Button::Init(void)
AddEventId(ewolEventButtonPressed); AddEventId(ewolEventButtonPressed);
AddEventId(ewolEventButtonEnter); AddEventId(ewolEventButtonEnter);
AddEventId(ewolEventButtonLeave); AddEventId(ewolEventButtonLeave);
m_hasAnImage = false;
m_alignement = ewol::TEXT_ALIGN_CENTER; m_alignement = ewol::TEXT_ALIGN_CENTER;
#ifdef __PLATFORM__Android #ifdef __PLATFORM__Android
@ -84,6 +84,15 @@ ewol::Button::~Button(void)
} }
void ewol::Button::SetImage(etk::UString imageName)
{
if (imageName == "") {
m_hasAnImage = false;
} else {
m_imageSelected.SetCompleateName(imageName, etk::FILE_TYPE_DATA);
m_hasAnImage = true;
}
}
//!< EObject name : //!< EObject name :
extern const char * const ewol::TYPE_EOBJECT_WIDGET_BUTTON = "Button"; extern const char * const ewol::TYPE_EOBJECT_WIDGET_BUTTON = "Button";
@ -135,6 +144,13 @@ bool ewol::Button::CalculateMinSize(void)
int32_t minHeight = ewol::GetHeight(fontId); int32_t minHeight = ewol::GetHeight(fontId);
m_minSize.x = m_padding.x*2 + minWidth; m_minSize.x = m_padding.x*2 + minWidth;
m_minSize.y = m_padding.y*2 + minHeight; m_minSize.y = m_padding.y*2 + minHeight;
// Add the image element ...
if (true == m_hasAnImage) {
//m_minSize.x += -m_padding.x + m_padding.y*2 + minHeight;
//m_minSize.y += m_padding.y*2;
m_minSize.x += m_padding.x + minHeight;
}
MarkToReedraw(); MarkToReedraw();
return true; return true;
} }
@ -202,6 +218,16 @@ void ewol::Button::OnRegenerateDisplay(void)
coord2D_ts textPos; coord2D_ts textPos;
textPos.x = tmpTextOriginX; textPos.x = tmpTextOriginX;
textPos.y = tmpTextOriginY; textPos.y = tmpTextOriginY;
ewol::OObject2DTextured * tmpImage = NULL;
if (true == m_hasAnImage) {
int32_t fontId = GetDefaultFontId();
int32_t fontHeight = ewol::GetHeight(fontId);
tmpImage = new ewol::OObject2DTextured(m_imageSelected, fontHeight, fontHeight);
tmpImage->Rectangle(textPos.x, textPos.y, fontHeight, fontHeight);
// update the text position ...
textPos.x += m_padding.x + fontHeight;
}
clipping_ts drawClipping; clipping_ts drawClipping;
drawClipping.x = m_padding.x; drawClipping.x = m_padding.x;
drawClipping.y = m_padding.y; drawClipping.y = m_padding.y;
@ -216,10 +242,17 @@ void ewol::Button::OnRegenerateDisplay(void)
tmpSizeX += m_padding.x/1; tmpSizeX += m_padding.x/1;
tmpSizeY += m_padding.y/1; tmpSizeY += m_padding.y/1;
tmpOObjects->Rectangle( tmpOriginX, tmpOriginY, tmpSizeX, tmpSizeY); tmpOObjects->Rectangle( tmpOriginX, tmpOriginY, tmpSizeX, tmpSizeY);
// add all needed objects ...
if (NULL != tmpOObjects) {
AddOObject(tmpOObjects); AddOObject(tmpOObjects);
}
if (NULL != tmpImage) {
AddOObject(tmpImage);
}
if (NULL != tmpText) {
AddOObject(tmpText); AddOObject(tmpText);
} }
}
} }
/** /**

3
Sources/libewol/ewol/widget/Button.h
View File

@ -63,11 +63,14 @@ namespace ewol {
virtual bool CalculateMinSize(void); virtual bool CalculateMinSize(void);
void SetLabel(etk::UString newLabel); void SetLabel(etk::UString newLabel);
etk::UString GetLabel(void) {return m_label;}; etk::UString GetLabel(void) {return m_label;};
void SetImage(etk::UString imageName);
void SetValue(bool val); void SetValue(bool val);
bool GetValue(void); bool GetValue(void);
void SetAlignement(textAlignement_te typeAlign); void SetAlignement(textAlignement_te typeAlign);
void SetPadding(coord2D_ts newPadding); void SetPadding(coord2D_ts newPadding);
private: private:
bool m_hasAnImage;
etk::File m_imageSelected;
textAlignement_te m_alignement; textAlignement_te m_alignement;
coord2D_ts m_padding; coord2D_ts m_padding;
etk::UString m_label; etk::UString m_label;

14
Sources/libewol/ewol/widget/Menu.cpp
View File

@ -141,9 +141,13 @@ int32_t ewol::Menu::Add(int32_t parent, etk::UString label, etk::UString image,
myButton = new ewol::Button(label); myButton = new ewol::Button(label);
if (NULL == myButton) { if (NULL == myButton) {
EWOL_ERROR("Allocation button error"); EWOL_ERROR("Allocation button error");
return tmpObject->m_localId;; return tmpObject->m_localId;
} }
// set the image if one is present ...
myButton->SetImage(tmpObject->m_image);
// add it in the widget list
ewol::SizerHori::SubWidgetAdd(myButton); ewol::SizerHori::SubWidgetAdd(myButton);
// keep the specific event ...
myButton->RegisterOnEvent(this, ewolEventButtonPressed, ewolEventButtonPressed); myButton->RegisterOnEvent(this, ewolEventButtonPressed, ewolEventButtonPressed);
tmpObject->m_widgetPointer = myButton; tmpObject->m_widgetPointer = myButton;
} }
@ -229,13 +233,17 @@ void ewol::Menu::OnReceiveMessage(ewol::EObject * CallerObject, const char * eve
myButton = new ewol::Button(m_listElement[jjj]->m_label); myButton = new ewol::Button(m_listElement[jjj]->m_label);
if (NULL == myButton) { if (NULL == myButton) {
EWOL_ERROR("Allocation Error"); EWOL_ERROR("Allocation Error");
} } else {
m_listElement[jjj]->m_widgetPointer = myButton; // set the image if one is present ...
myButton->SetImage(m_listElement[jjj]->m_image);
myButton->RegisterOnEvent(this, ewolEventButtonPressed, ewolEventButtonPressed, ""); myButton->RegisterOnEvent(this, ewolEventButtonPressed, ewolEventButtonPressed, "");
myButton->SetExpendX(true); myButton->SetExpendX(true);
myButton->SetFillX(true); myButton->SetFillX(true);
myButton->SetAlignement(ewol::TEXT_ALIGN_LEFT); myButton->SetAlignement(ewol::TEXT_ALIGN_LEFT);
// add it in the widget list
mySizerVert->SubWidgetAdd(myButton); mySizerVert->SubWidgetAdd(myButton);
m_listElement[jjj]->m_widgetPointer = myButton;
}
} }
} }
ewol::PopUpWidgetPush(m_widgetContextMenu); ewol::PopUpWidgetPush(m_widgetContextMenu);

3
Sources/libewol/file.mk
View File

@ -15,6 +15,9 @@ FILE_LIST = ewol/ewol.cpp \
ewol/OObject/2DTextured.cpp \ ewol/OObject/2DTextured.cpp \
ewol/OObject/e2d.cpp \ ewol/OObject/e2d.cpp \
ewol/Texture.cpp \ ewol/Texture.cpp \
ewol/Texture/TextureBMP.cpp \
ewol/Texture/TexturePNG.cpp \
ewol/Texture/TextureSVG.cpp \
ewol/FontBitmap.cpp \ ewol/FontBitmap.cpp \
ewol/FontFreeType.cpp \ ewol/FontFreeType.cpp \
ewol/Widget.cpp \ ewol/Widget.cpp \

5
Sources/libparsersvg/parserSVG/Renderer.cpp
View File

@ -30,10 +30,12 @@
svg::Renderer::Renderer(uint32_t width, uint32_t height) svg::Renderer::Renderer(uint32_t width, uint32_t height)
{ {
m_allocatedSize = 0;
m_size.x = width; m_size.x = width;
m_size.y = height; m_size.y = height;
int32_t dataSize = ((int32_t)width * (int32_t)height * DATA_ALLOCATION_ELEMENT); int32_t dataSize = ((int32_t)width * (int32_t)height * DATA_ALLOCATION_ELEMENT);
m_allocatedSize = dataSize;
// allocate Data // allocate Data
SVG_DEBUG("Allocate buffer : " << dataSize); SVG_DEBUG("Allocate buffer : " << dataSize);
@ -41,10 +43,11 @@ svg::Renderer::Renderer(uint32_t width, uint32_t height)
ETK_MALLOC(m_buffer, dataSize, uint8_t); ETK_MALLOC(m_buffer, dataSize, uint8_t);
if (NULL == m_buffer) { if (NULL == m_buffer) {
SVG_ERROR("Allocation of the output buffer for SVG drawing error"); SVG_ERROR("Allocation of the output buffer for SVG drawing error");
m_allocatedSize = 0;
return; return;
} }
memset(m_buffer, 0xFF, dataSize * sizeof(uint8_t) ); memset(m_buffer, 0x00, dataSize * sizeof(uint8_t) );
m_renderingBuffer = new agg::rendering_buffer(m_buffer, m_size.x, m_size.y, m_size.x * DATA_ALLOCATION_ELEMENT); m_renderingBuffer = new agg::rendering_buffer(m_buffer, m_size.x, m_size.y, m_size.x * DATA_ALLOCATION_ELEMENT);
if (NULL == m_renderingBuffer) { if (NULL == m_renderingBuffer) {

3
Sources/libparsersvg/parserSVG/Renderer.h
View File

@ -69,6 +69,7 @@ namespace svg
class Renderer { class Renderer {
private: private:
uint8_t * m_buffer; uint8_t * m_buffer;
uint32_t m_allocatedSize;
public: public:
Renderer(uint32_t width, uint32_t height); Renderer(uint32_t width, uint32_t height);
~Renderer(void); ~Renderer(void);
@ -80,6 +81,8 @@ namespace svg
rendererSolid_t * m_renderArea; rendererSolid_t * m_renderArea;
agg::rasterizer_scanline_aa<> m_rasterizer; //!< AGG renderer system agg::rasterizer_scanline_aa<> m_rasterizer; //!< AGG renderer system
agg::scanline_p8 m_scanLine; //!< agg::scanline_p8 m_scanLine; //!<
uint8_t* GetDataPointer(void) { return m_buffer; };
uint32_t GetDataSize(void) { return m_allocatedSize; };
}; };
}; };

74
Sources/libparsersvg/parserSVG/parserSVG.cpp
View File

@ -47,11 +47,11 @@
#include <agg-2.4/agg_color_rgba.h> #include <agg-2.4/agg_color_rgba.h>
#include <agg-2.4/agg_pixfmt_rgba.h> #include <agg-2.4/agg_pixfmt_rgba.h>
svg::Parser::Parser(etk::File fileName) svg::Parser::Parser(etk::File fileName) : m_renderedElement(NULL)
{ {
m_fileName = fileName; m_fileName = fileName;
m_version = "0.0"; m_version = "0.0";
m_loadOK = false; m_loadOK = true;
m_paint.fill.red = 0xFF; m_paint.fill.red = 0xFF;
m_paint.fill.green = 0; m_paint.fill.green = 0;
m_paint.fill.blue = 0; m_paint.fill.blue = 0;
@ -78,21 +78,25 @@ svg::Parser::Parser(etk::File fileName)
TiXmlDocument XmlDocument; TiXmlDocument XmlDocument;
if (false == m_fileName.Exist()) { if (false == m_fileName.Exist()) {
SVG_ERROR("File Does not exist : " << m_fileName); SVG_ERROR("File Does not exist : " << m_fileName);
m_loadOK = false;
return; return;
} }
int32_t fileSize = m_fileName.Size(); int32_t fileSize = m_fileName.Size();
if (0==fileSize) { if (0==fileSize) {
SVG_ERROR("This file is empty : " << m_fileName); SVG_ERROR("This file is empty : " << m_fileName);
m_loadOK = false;
return; return;
} }
if (false == m_fileName.fOpenRead()) { if (false == m_fileName.fOpenRead()) {
SVG_ERROR("Can not open the file : " << m_fileName); SVG_ERROR("Can not open the file : " << m_fileName);
m_loadOK = false;
return; return;
} }
// allocate data // allocate data
char * fileBuffer = new char[fileSize+5]; char * fileBuffer = new char[fileSize+5];
if (NULL == fileBuffer) { if (NULL == fileBuffer) {
SVG_ERROR("Error Memory allocation size=" << fileSize); SVG_ERROR("Error Memory allocation size=" << fileSize);
m_loadOK = false;
return; return;
} }
memset(fileBuffer, 0, (fileSize+5)*sizeof(char)); memset(fileBuffer, 0, (fileSize+5)*sizeof(char));
@ -106,6 +110,7 @@ svg::Parser::Parser(etk::File fileName)
TiXmlElement* root = XmlDocument.FirstChildElement( "svg" ); TiXmlElement* root = XmlDocument.FirstChildElement( "svg" );
if (NULL == root ) { if (NULL == root ) {
SVG_ERROR("(l ?) main node not find: \"svg\" in \"" << m_fileName << "\""); SVG_ERROR("(l ?) main node not find: \"svg\" in \"" << m_fileName << "\"");
m_loadOK = false;
} else { } else {
// get the svg version : // get the svg version :
const char *version = root->ToElement()->Attribute("version"); const char *version = root->ToElement()->Attribute("version");
@ -197,7 +202,10 @@ svg::Parser::Parser(etk::File fileName)
svg::Parser::~Parser(void) svg::Parser::~Parser(void)
{ {
if(NULL != m_renderedElement) {
delete(m_renderedElement);
m_renderedElement = NULL;
}
} }
@ -225,7 +233,6 @@ void svg::Parser::AggDraw(svg::Renderer& myRenderer, agg::trans_affine& basicTra
void svg::Parser::GenerateTestFile(void) void svg::Parser::GenerateTestFile(void)
{ {
float coefmult = 2;
int32_t SizeX = m_size.x; int32_t SizeX = m_size.x;
if (SizeX == 0) { if (SizeX == 0) {
SizeX = 50; SizeX = 50;
@ -234,7 +241,11 @@ void svg::Parser::GenerateTestFile(void)
if (SizeY == 0) { if (SizeY == 0) {
SizeY = 50; SizeY = 50;
} }
svg::Renderer * myRenderer = new svg::Renderer(SizeX, SizeY); if(NULL != m_renderedElement) {
delete(m_renderedElement);
m_renderedElement = NULL;
}
m_renderedElement = new svg::Renderer(SizeX, SizeY);
// create the first element matrix modification ... // create the first element matrix modification ...
agg::trans_affine basicTrans; agg::trans_affine basicTrans;
//basicTrans *= agg::trans_affine_translation(-g_base_dx, -g_base_dy); //basicTrans *= agg::trans_affine_translation(-g_base_dx, -g_base_dy);
@ -245,13 +256,62 @@ void svg::Parser::GenerateTestFile(void)
//basicTrans *= agg::trans_affine_translation(width/3, height/3); //basicTrans *= agg::trans_affine_translation(width/3, height/3);
AggDraw(*myRenderer, basicTrans); AggDraw(*m_renderedElement, basicTrans);
etk::UString tmpFileOut = "yyy_out_"; etk::UString tmpFileOut = "yyy_out_";
tmpFileOut += m_fileName.GetShortFilename(); tmpFileOut += m_fileName.GetShortFilename();
tmpFileOut += ".ppm"; tmpFileOut += ".ppm";
myRenderer->WritePpm(tmpFileOut); m_renderedElement->WritePpm(tmpFileOut);
} }
void svg::Parser::GenerateAnImage(int32_t sizeX, int32_t sizeY)
{
int32_t SizeX = sizeX;
if (SizeX == 0) {
SizeX = 50;
}
int32_t SizeY = sizeY;
if (SizeY == 0) {
SizeY = 50;
}
if(NULL != m_renderedElement) {
delete(m_renderedElement);
m_renderedElement = NULL;
}
m_renderedElement = new svg::Renderer(SizeX, SizeY);
// create the first element matrix modification ...
agg::trans_affine basicTrans;
//basicTrans *= agg::trans_affine_translation(-g_base_dx, -g_base_dy);
basicTrans *= agg::trans_affine_scaling(SizeX/m_size.x, SizeY/m_size.y);
//basicTrans *= agg::trans_affine_rotation(g_angle);// + agg::pi);
//basicTrans *= agg::trans_affine_skewing(2.0, 5.0);
//basicTrans *= agg::trans_affine_translation(width*0.3, height/2);
//basicTrans *= agg::trans_affine_translation(width/3, height/3);
AggDraw(*m_renderedElement, basicTrans);
etk::UString tmpFileOut = "zzz_out_test.ppm";
m_renderedElement->WritePpm(tmpFileOut);
}
uint8_t* svg::Parser::GetPointerOnData(void)
{
if(NULL == m_renderedElement) {
return NULL;
}
return m_renderedElement->GetDataPointer();
}
uint32_t svg::Parser::GetSizeOnData(void)
{
if(NULL == m_renderedElement) {
return 0;
}
return m_renderedElement->GetDataSize();
}

5
Sources/libparsersvg/parserSVG/parserSVG.h
View File

@ -40,6 +40,7 @@ namespace svg
etk::UString m_title; etk::UString m_title;
etk::VectorType<svg::Base *> m_subElementList; etk::VectorType<svg::Base *> m_subElementList;
coord2D_ts m_size; coord2D_ts m_size;
svg::Renderer* m_renderedElement;
public: public:
Parser(etk::File fileName); Parser(etk::File fileName);
@ -47,7 +48,11 @@ namespace svg
bool IsLoadOk(void) { return m_loadOK; }; bool IsLoadOk(void) { return m_loadOK; };
void DisplayDebug(void); void DisplayDebug(void);
void GenerateTestFile(void); void GenerateTestFile(void);
void GenerateAnImage(int32_t sizeX, int32_t sizeY);
virtual void AggDraw(svg::Renderer& myRenderer, agg::trans_affine& basicTrans); virtual void AggDraw(svg::Renderer& myRenderer, agg::trans_affine& basicTrans);
uint8_t* GetPointerOnData(void);
uint32_t GetSizeOnData(void);
coord2D_ts GetDefinedSize(void) { return m_size;};
}; };
}; };