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

[DEBUG] correct the VBO FULL implement

Browse Source
This commit is contained in:
Edouard DUPIN 2016-11-08 22:17:47 +01:00
parent 95bff828d8
commit 6b859a45a1
16 changed files with 363 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

55
ewol/compositing/Area.cpp
View File

@ -8,9 +8,10 @@
#include <ewol/compositing/Area.hpp>
// VBO table property:
#define EWOL_COMPOSITING_VBO_COORDINATE (0)
#define EWOL_COMPOSITING_VBO_COLOR (1)
#define EWOL_COMPOSITING_VBO_TEXTURE (2)
const int32_t ewol::compositing::Area::m_vboIdCoord(0);
const int32_t ewol::compositing::Area::m_vboIdCoordText(1);
const int32_t ewol::compositing::Area::m_vboIdColor(2);
#define NB_VBO (3)
ewol::compositing::Area::Area(const ivec2& _size) :
m_position(0.0, 0.0, 0.0),
@ -26,7 +27,7 @@ ewol::compositing::Area::Area(const ivec2& _size) :
m_resource->setImageSize(_size);
m_resource->flush();
// Create the VBO:
m_VBO = gale::resource::VirtualBufferObject::create(3);
m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
if (m_VBO == nullptr) {
EWOL_ERROR("can not instanciate VBO ...");
return;
@ -54,7 +55,7 @@ void ewol::compositing::Area::loadProgram() {
}
void ewol::compositing::Area::draw(bool _disableDepthTest) {
if (m_VBO->bufferSize(EWOL_COMPOSITING_VBO_COORDINATE) <= 0) {
if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -73,13 +74,13 @@ void ewol::compositing::Area::draw(bool _disableDepthTest) {
// TextureID
m_GLprogram->setTexture0(m_GLtexID, m_resource->getRendererId());
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_COMPOSITING_VBO_COORDINATE);
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
// Texture:
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, EWOL_COMPOSITING_VBO_COLOR);
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdColor);
// color:
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, EWOL_COMPOSITING_VBO_TEXTURE);
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdCoordText);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(EWOL_COMPOSITING_VBO_COORDINATE));
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
}
@ -97,41 +98,41 @@ void ewol::compositing::Area::print(const ivec2& _size) {
vec2 tex(0,1);
point.setX(m_position.x());
point.setY(m_position.y());
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
tex.setValue(1,1);
point.setX(m_position.x() + _size.x());
point.setY(m_position.y());
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
tex.setValue(1,0);
point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y());
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
tex.setValue(0,0);
point.setX(m_position.x());
point.setY(m_position.y() + _size.y());
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
tex.setValue(0,1);
point.setX(m_position.x());
point.setY(m_position.y());
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdCoordText, tex);
m_VBO->flush();
}

4
ewol/compositing/Area.hpp
View File

@ -28,6 +28,10 @@ namespace ewol {
int32_t m_GLtexID; //!< openGL id on the element (texture ID)
private:
ememory::SharedPtr<ewol::resource::Texture> m_resource; //!< texture resources
protected:
static const int32_t m_vboIdCoord;
static const int32_t m_vboIdCoordText;
static const int32_t m_vboIdColor;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
private:
/**

42
ewol/compositing/Drawing.cpp
View File

@ -7,6 +7,10 @@
#include <ewol/debug.hpp>
#include <ewol/compositing/Drawing.hpp>
// VBO table property:
const int32_t ewol::compositing::Drawing::m_vboIdCoord(0);
const int32_t ewol::compositing::Drawing::m_vboIdColor(1);
#define NB_VBO (2)
#if 0
@ -234,6 +238,14 @@ ewol::compositing::Drawing::Drawing() :
m_triangle[iii] = m_position;
m_tricolor[iii] = m_color;
}
// Create the VBO:
m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
if (m_VBO == nullptr) {
EWOL_ERROR("can not instanciate VBO ...");
return;
}
// TO facilitate some debugs we add a name of the VBO:
m_VBO->setName("[VBO] of ewol::compositing::Area");
}
ewol::compositing::Drawing::~Drawing() {
@ -243,12 +255,12 @@ ewol::compositing::Drawing::~Drawing() {
void ewol::compositing::Drawing::generateTriangle() {
m_triElement = 0;
m_coord.push_back(m_triangle[0]);
m_coordColor.push_back(m_tricolor[0]);
m_coord.push_back(m_triangle[1]);
m_coordColor.push_back(m_tricolor[1]);
m_coord.push_back(m_triangle[2]);
m_coordColor.push_back(m_tricolor[2]);
m_VBO->pushOnBuffer(m_vboIdCoord, m_triangle[0]);
m_VBO->pushOnBuffer(m_vboIdColor, m_tricolor[0]);
m_VBO->pushOnBuffer(m_vboIdCoord, m_triangle[1]);
m_VBO->pushOnBuffer(m_vboIdColor, m_tricolor[1]);
m_VBO->pushOnBuffer(m_vboIdCoord, m_triangle[2]);
m_VBO->pushOnBuffer(m_vboIdColor, m_tricolor[2]);
}
void ewol::compositing::Drawing::internalSetColor(const etk::Color<>& _color) {
@ -269,6 +281,7 @@ void ewol::compositing::Drawing::setPoint(const vec3& _point) {
if (m_triElement >= 3) {
generateTriangle();
}
m_VBO->flush();
}
void ewol::compositing::Drawing::resetCount() {
@ -294,8 +307,8 @@ void ewol::compositing::Drawing::loadProgram() {
}
void ewol::compositing::Drawing::draw(bool _disableDepthTest) {
if (m_coord.size() <= 0) {
// TODO : a remÚtre ...
if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
// TODO : set it back ...
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -309,12 +322,12 @@ void ewol::compositing::Drawing::draw(bool _disableDepthTest) {
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
mat4 tmpMatrix2;
m_GLprogram->uniformMatrix(m_GLMatrixPosition, tmpMatrix2);
// position :
m_GLprogram->sendAttribute(m_GLPosition, m_coord);
// color :
m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
// color:
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
}
@ -322,8 +335,7 @@ void ewol::compositing::Drawing::clear() {
// call upper class
ewol::Compositing::clear();
// reset Buffer :
m_coord.clear();
m_coordColor.clear();
m_VBO->clear();
// reset temporal variables :
m_position = vec3(0.0, 0.0, 0.0);

9
ewol/compositing/Drawing.hpp
View File

@ -29,9 +29,10 @@ namespace ewol {
int32_t m_GLMatrix; //!< openGL id on the element (transformation matrix)
int32_t m_GLMatrixPosition; //!< position matrix
int32_t m_GLColor; //!< openGL id on the element (color buffer)
public: // Background Color (display only when needed)
std::vector<vec3 > m_coord; //!< internal position for the text display
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the background
protected:
static const int32_t m_vboIdCoord;
static const int32_t m_vboIdColor;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
public:
/**
* @brief Basic constructor
@ -53,7 +54,7 @@ namespace ewol {
float m_thickness; //!< when drawing line and other things
int32_t m_triElement; //!< special counter of the single dot generated
vec3 m_triangle[3]; //!< Register every system with a combinaison of tiangle
etk::Color<float> m_tricolor[3]; //!< Register every the associated color foreground
etk::Color<float,4> m_tricolor[3]; //!< Register every the associated color foreground
// internal API for the generation abstraction of triangles
/**
* @brief Lunch the generation of triangle

120
ewol/compositing/Image.cpp
View File

@ -9,6 +9,12 @@
const int32_t ewol::compositing::Image::sizeAuto(0);
// VBO table property:
const int32_t ewol::compositing::Image::m_vboIdCoord(0);
const int32_t ewol::compositing::Image::m_vboIdCoordTex(1);
const int32_t ewol::compositing::Image::m_vboIdColor(2);
#define NB_VBO (3)
ewol::compositing::Image::Image(const std::string& _imageName,
bool _df,
int32_t _size) :
@ -29,6 +35,14 @@ ewol::compositing::Image::Image(const std::string& _imageName,
m_distanceFieldMode(_df),
m_resource(nullptr),
m_resourceDF(nullptr) {
// Create the VBO:
m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
if (m_VBO == nullptr) {
EWOL_ERROR("can not instanciate VBO ...");
return;
}
// TO facilitate some debugs we add a name of the VBO:
m_VBO->setName("[VBO] of ewol::compositing::Image");
setSource(_imageName, _size);
loadProgram();
}
@ -56,7 +70,7 @@ void ewol::compositing::Image::loadProgram() {
}
void ewol::compositing::Image::draw(bool _disableDepthTest) {
if (m_coord.size() <= 0) {
if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -69,6 +83,7 @@ void ewol::compositing::Image::draw(bool _disableDepthTest) {
EWOL_ERROR("No shader ...");
return;
}
//EWOL_WARNING("Display image : " << m_VBO->bufferSize(m_vboIdCoord));
if (_disableDepthTest == true) {
gale::openGL::disable(gale::openGL::flag_depthTest);
} else {
@ -76,7 +91,7 @@ void ewol::compositing::Image::draw(bool _disableDepthTest) {
}
// set Matrix : translation/positionMatrix
mat4 tmpMatrix = gale::openGL::getMatrix()*m_matrixApply;
m_GLprogram->use();
m_GLprogram->use();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// TextureID
if (m_resource != nullptr) {
@ -90,14 +105,14 @@ void ewol::compositing::Image::draw(bool _disableDepthTest) {
}
m_GLprogram->setTexture0(m_GLtexID, m_resourceDF->getRendererId());
}
// position :
m_GLprogram->sendAttribute(m_GLPosition, m_coord);
// Texture :
m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
// color :
m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
// Texture:
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordTex);
// color:
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
// Request the draw of the elements:
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
}
@ -105,9 +120,7 @@ void ewol::compositing::Image::clear() {
// call upper class
ewol::Compositing::clear();
// reset Buffer :
m_coord.clear();
m_coordTex.clear();
m_coordColor.clear();
m_VBO->clear();
// reset temporal variables :
m_position = vec3(0.0, 0.0, 0.0);
m_clippingPosStart = vec3(0.0, 0.0, 0.0);
@ -154,47 +167,46 @@ void ewol::compositing::Image::print(const vec2& _size) {
void ewol::compositing::Image::printPart(const vec2& _size,
const vec2& _sourcePosStart,
const vec2& _sourcePosStop) {
//EWOL_ERROR("Debug image " << m_filename << " ==> " << m_position << " " << _size << " " << _sourcePosStart << " " << _sourcePosStop);
if (m_angle == 0.0f) {
vec3 point = m_position;
vec2 tex(_sourcePosStart.x(),_sourcePosStop.y());
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
point.setX(m_position.x() + _size.x());
point.setY(m_position.y());
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y());
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
point.setX(m_position.x());
point.setY(m_position.y() + _size.y());
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
point.setX(m_position.x());
point.setY(m_position.y());
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->flush();
return;
}
vec3 center = m_position + vec3(_size.x(),_size.y(),0)/2.0f;
@ -205,43 +217,43 @@ void ewol::compositing::Image::printPart(const vec2& _size,
point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStop.y());
point.setValue(limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStop.x(),_sourcePosStart.y());
point.setValue(limitedSize.x(), limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStart.y());
point.setValue(-limitedSize.x(), limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
tex.setValue(_sourcePosStart.x(),_sourcePosStop.y());
point.setValue(-limitedSize.x(), -limitedSize.y(), 0);
point = point.rotate(vec3(0,0,1), m_angle) + center;
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdCoord, point);
m_VBO->pushOnBuffer(m_vboIdCoordTex, tex);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->flush();
}
void ewol::compositing::Image::setSource(const std::string& _newFile, const vec2& _size) {

9
ewol/compositing/Image.hpp
View File

@ -24,7 +24,7 @@ namespace ewol {
vec3 m_clippingPosStop; //!< Clipping stop position
bool m_clippingEnable; //!< true if the clipping must be activated
private:
etk::Color<> m_color; //!< The text foreground color
etk::Color<float,4> m_color; //!< The text foreground color
float m_angle; //!< Angle to set at the axes
private:
ememory::SharedPtr<gale::resource::Program> m_GLprogram; //!< pointer on the opengl display program
@ -37,9 +37,10 @@ namespace ewol {
bool m_distanceFieldMode; //!< select distance field mode
ememory::SharedPtr<ewol::resource::TextureFile> m_resource; //!< texture resources
ememory::SharedPtr<ewol::resource::ImageDF> m_resourceDF; //!< texture resources
std::vector<vec3 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
static const int32_t m_vboIdCoord;
static const int32_t m_vboIdCoordTex;
static const int32_t m_vboIdColor;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
private:
/**
* @brief load the openGL program and get all the ID needed

106
ewol/compositing/Shaper.cpp
View File

@ -9,8 +9,9 @@
#include <ewol/compositing/Shaper.hpp>
// VBO table property:
#define EWOL_COMPOSITING_SHAPER_VBO_COORDINATE (0)
#define EWOL_COMPOSITING_SHAPER_VBO_POS (1)
const int32_t ewol::compositing::Shaper::m_vboIdCoord(0);
const int32_t ewol::compositing::Shaper::m_vboIdPos(1);
#define NB_VBO (2)
ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
m_name(_shaperName),
@ -45,7 +46,7 @@ ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
m_confIdPaddingIn[iii] = -1;
}
// Create the VBO:
m_VBO = gale::resource::VirtualBufferObject::create(3);
m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
if (m_VBO == nullptr) {
EWOL_ERROR("can not instanciate VBO ...");
return;
@ -180,7 +181,7 @@ void ewol::compositing::Shaper::draw(bool _disableDepthTest) {
EWOL_ERROR("No shader ...");
return;
}
if (m_VBO->bufferSize(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE) <= 0) {
if (m_VBO->bufferSize(m_vboIdCoord) <= 0) {
return;
}
//glScalef(m_scaling.x, m_scaling.y, 1.0);
@ -189,9 +190,9 @@ void ewol::compositing::Shaper::draw(bool _disableDepthTest) {
mat4 tmpMatrix = gale::openGL::getMatrix();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_COMPOSITING_SHAPER_VBO_COORDINATE);
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
// property
m_GLprogram->sendAttributePointer(m_GLPropertyPos, m_VBO, EWOL_COMPOSITING_SHAPER_VBO_POS);
m_GLprogram->sendAttributePointer(m_GLPropertyPos, m_VBO, m_vboIdPos);
// all entry parameters :
m_GLprogram->uniform1i(m_GLStateActivate, m_stateActivate);
m_GLprogram->uniform1i(m_GLStateOld, m_stateOld);
@ -297,104 +298,104 @@ void ewol::compositing::Shaper::addVertexLine(float _yTop,
bool _displayOutside) {
if (m_nbVertexToDisplay != 0) {
// change line ...
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE,
m_VBO->getOnBufferVec2(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, m_nbVertexToDisplay-1));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS,
m_VBO->getOnBufferVec2(EWOL_COMPOSITING_SHAPER_VBO_POS, m_nbVertexToDisplay-1));
m_VBO->pushOnBuffer(m_vboIdCoord,
m_VBO->getOnBufferVec2(m_vboIdCoord, m_nbVertexToDisplay-1));
m_VBO->pushOnBuffer(m_vboIdPos,
m_VBO->getOnBufferVec2(m_vboIdPos, m_nbVertexToDisplay-1));
m_nbVertexToDisplay++;
if (_displayOutside == true) {
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x1, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[0],_yValButtom));
m_nbVertexToDisplay++;
} else {
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++;
}
}
if (_displayOutside == true) {
// A
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x1, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[0],_yValButtom));
m_nbVertexToDisplay++;
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x1, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[0],_yValTop));
m_nbVertexToDisplay++;
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++;
// B
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[1],_yValTop));
m_nbVertexToDisplay++;
// C
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x3, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[2],_yValButtom));
m_nbVertexToDisplay++;
} else {
// C
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++;
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x2, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[1],_yValTop));
m_nbVertexToDisplay++;
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x3, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[2],_yValButtom));
m_nbVertexToDisplay++;
}
// D
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x3, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[2],_yValTop));
m_nbVertexToDisplay++;
// E
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[3],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x4, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[3],_yValButtom));
m_nbVertexToDisplay++;
// F
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[3],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x4, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[3],_yValTop));
m_nbVertexToDisplay++;
// G
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[4],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x5, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[4],_yValButtom));
m_nbVertexToDisplay++;
// H
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[4],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x5, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[4],_yValTop));
m_nbVertexToDisplay++;
// I
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[5],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x6, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[5],_yValButtom));
m_nbVertexToDisplay++;
// J
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[5],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x6, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[5],_yValTop));
m_nbVertexToDisplay++;
// K
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[6],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x7, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[6],_yValButtom));
m_nbVertexToDisplay++;
// L
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[6],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x7, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[6],_yValTop));
m_nbVertexToDisplay++;
if (_displayOutside == true) {
// M
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[7],_yValButtom));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x8, _yButtom));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[7],_yValButtom));
m_nbVertexToDisplay++;
// N
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[7],_yValTop));
m_VBO->pushOnBuffer(m_vboIdCoord, vec2(_x8, _yTop));
m_VBO->pushOnBuffer(m_vboIdPos, vec2(_table[7],_yValTop));
m_nbVertexToDisplay++;
}
}
@ -446,6 +447,7 @@ const float modeDisplay[][8] = {
};
void ewol::compositing::Shaper::setShape(const vec2& _origin, const vec2& _size, const vec2& _insidePos, const vec2& _insideSize) {
m_VBO->clear();
ewol::Padding borderTmp = getBorder();
ewol::Padding paddingIn = getPaddingIn();
ewol::Padding paddingOut = getPaddingOut();

3
ewol/compositing/Shaper.hpp
View File

@ -76,6 +76,9 @@ namespace ewol {
// color management theme:
ememory::SharedPtr<ewol::resource::ColorFile> m_colorProperty; //!< input resource for color management
std::vector<ivec2> m_listAssiciatedId; //!< Corellation ID between ColorProperty (Y) and OpenGL Program (X)
protected:
static const int32_t m_vboIdCoord;
static const int32_t m_vboIdPos;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
private:
/**

79
ewol/compositing/Text.cpp
View File

@ -23,8 +23,9 @@ void ewol::compositing::Text::drawMT(const mat4& _transformationMatrix, bool _en
// draw BG in any case:
m_vectorialDraw.draw();
if (m_coord.size() <= 0 || m_font == nullptr) {
// TODO : a remĂtre ...
if ( m_VBO->bufferSize(m_vboIdCoord) <= 0
|| m_font == nullptr) {
// TODO : set it back ...
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -45,18 +46,18 @@ void ewol::compositing::Text::drawMT(const mat4& _transformationMatrix, bool _en
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->use();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// Texture :
// Texture:
m_GLprogram->setTexture0(m_GLtexID, m_font->getRendererId());
m_GLprogram->uniform1i(m_GLtextWidth, m_font->getOpenGlSize().x());
m_GLprogram->uniform1i(m_GLtextHeight, m_font->getOpenGlSize().x());
// position :
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &m_coord[0]);
// Texture :
m_GLprogram->sendAttribute(m_GLtexture, 2/*u,v*/, &m_coordTex[0]);
// color :
m_GLprogram->sendAttribute(m_GLColor, 4/*r,g,b,a*/, &m_coordColor[0]);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
// Texture:
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
// color:
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
// Request the draw od the elements:
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
if (_enableDepthTest == true) {
gale::openGL::disable(gale::openGL::flag_depthTest);
@ -67,7 +68,8 @@ void ewol::compositing::Text::drawD(bool _disableDepthTest) {
// draw BG in any case:
m_vectorialDraw.draw(_disableDepthTest);
if (m_coord.size() <= 0 || m_font == nullptr) {
if ( m_VBO->bufferSize(m_vboIdCoord) <= 0
|| m_font == nullptr) {
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -87,14 +89,14 @@ void ewol::compositing::Text::drawD(bool _disableDepthTest) {
m_GLprogram->setTexture0(m_GLtexID, m_font->getRendererId());
m_GLprogram->uniform1i(m_GLtextWidth, m_font->getOpenGlSize().x());
m_GLprogram->uniform1i(m_GLtextHeight, m_font->getOpenGlSize().x());
// position :
m_GLprogram->sendAttribute(m_GLPosition, m_coord);
// Texture :
m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
// color :
m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
// Texture:
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
// color:
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
}
@ -180,7 +182,7 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
// get the kerning ofset :
float kerningOffset = 0;
if (true == m_kerning) {
if (m_kerning == true) {
kerningOffset = myGlyph->kerningGet(m_previousCharcode);
if (kerningOffset != 0) {
//EWOL_DEBUG("Kerning between : '" << m_previousCharcode << "'&'" << myGlyph->m_UVal << "' value : " << kerningOffset);
@ -292,17 +294,17 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
*
*/
// set texture coordonates :
m_coordTex.push_back(texturePos[0]);
m_coordTex.push_back(texturePos[1]);
m_coordTex.push_back(texturePos[2]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[1]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
// set display positions :
m_coord.push_back(bitmapDrawPos[0]);
m_coord.push_back(bitmapDrawPos[1]);
m_coord.push_back(bitmapDrawPos[2]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[1]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
// set the color
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
/* Step 2 :
*
* **
@ -311,17 +313,17 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
* ********
*/
// set texture coordonates :
m_coordTex.push_back(texturePos[0]);
m_coordTex.push_back(texturePos[2]);
m_coordTex.push_back(texturePos[3]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[3]);
// set display positions :
m_coord.push_back(bitmapDrawPos[0]);
m_coord.push_back(bitmapDrawPos[2]);
m_coord.push_back(bitmapDrawPos[3]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[3]);
// set the color
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
}
}
}
@ -332,6 +334,7 @@ void ewol::compositing::Text::printChar(const char32_t& _charcode) {
//EWOL_DEBUG(" 6 print '" << charcode << "' : start=" << m_sizeDisplayStart << " stop=" << m_sizeDisplayStop << " pos=" << m_position);
// Register the previous character
m_previousCharcode = _charcode;
m_VBO->flush();
return;
}

25
ewol/compositing/TextBase.cpp
View File

@ -9,6 +9,13 @@
#include <ewol/context/Context.hpp>
#include <etk/types.hpp>
const int32_t ewol::compositing::TextBase::m_vboIdCoord(0);
const int32_t ewol::compositing::TextBase::m_vboIdCoordText(1);
const int32_t ewol::compositing::TextBase::m_vboIdColor(2);
const int32_t ewol::compositing::TextBase::m_vboIdGlyphLevel(3);
#define NB_VBO (4)
ewol::compositing::TextBase::TextBase(const std::string& _shaderName, bool _loadProgram) :
m_position(0.0, 0.0, 0.0),
m_clippingPosStart(0.0, 0.0, 0.0),
@ -37,6 +44,14 @@ ewol::compositing::TextBase::TextBase(const std::string& _shaderName, bool _load
if (_loadProgram == true) {
loadProgram(_shaderName);
}
// Create the VBO:
m_VBO = gale::resource::VirtualBufferObject::create(NB_VBO);
if (m_VBO == nullptr) {
EWOL_ERROR("can not instanciate VBO ...");
return;
}
// TO facilitate some debugs we add a name of the VBO:
m_VBO->setName("[VBO] of ewol::compositing::TextBase");
}
@ -45,7 +60,7 @@ ewol::compositing::TextBase::~TextBase() {
}
void ewol::compositing::TextBase::loadProgram(const std::string& _shaderName) {
// get the shader resource :
// get the shader resource:
m_GLPosition = 0;
ememory::SharedPtr<gale::resource::Program> old = m_GLprogram;
m_GLprogram = gale::resource::Program::create(_shaderName);
@ -84,11 +99,9 @@ void ewol::compositing::TextBase::clear() {
ewol::Compositing::clear();
// remove sub draw system
m_vectorialDraw.clear();
// reset Buffer :
m_coord.clear();
m_coordTex.clear();
m_coordColor.clear();
// reset temporal variables :
// reset Buffer:
m_VBO->clear();
// reset temporal variables:
reset();
}

24
ewol/compositing/TextBase.hpp
View File

@ -22,8 +22,8 @@ namespace ewol {
*/
class TextDecoration {
public:
etk::Color<> m_colorBg; //!< display background color
etk::Color<> m_colorFg; //!< display foreground color
etk::Color<float,4> m_colorBg; //!< display background color
etk::Color<float,4> m_colorFg; //!< display foreground color
enum ewol::font::mode m_mode; //!< display mode Regular/Bold/Italic/BoldItalic
TextDecoration() {
m_colorBg = etk::color::blue;
@ -57,13 +57,13 @@ namespace ewol {
vec3 m_clippingPosStop; //!< Clipping stop position
bool m_clippingEnable; //!< true if the clipping must be activated
protected:
etk::Color<> m_defaultColorFg; //!< The text foreground color
etk::Color<> m_defaultColorBg; //!< The text background color
etk::Color<float,4> m_defaultColorFg; //!< The text foreground color
etk::Color<float,4> m_defaultColorBg; //!< The text background color
protected:
etk::Color<> m_color; //!< The text foreground color
etk::Color<> m_colorBg; //!< The text background color
etk::Color<> m_colorCursor; //!< The text cursor color
etk::Color<> m_colorSelection; //!< The text Selection color
etk::Color<float,4> m_color; //!< The text foreground color
etk::Color<float,4> m_colorBg; //!< The text background color
etk::Color<float,4> m_colorCursor; //!< The text cursor color
etk::Color<float,4> m_colorSelection; //!< The text Selection color
protected:
enum ewol::font::mode m_mode; //!< font display property : Regular/Bold/Italic/BoldItalic
bool m_kerning; //!< Kerning enable or disable on the next elements displayed
@ -85,9 +85,11 @@ namespace ewol {
int32_t m_selectionStartPos; //!< start position of the Selection (if == m_cursorPos ==> no selection)
int32_t m_cursorPos; //!< Cursor position (default no cursor == > -100)
protected: // Text
std::vector<vec3 > m_coord; //!< internal coord of the object
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
static const int32_t m_vboIdCoord;
static const int32_t m_vboIdCoordText;
static const int32_t m_vboIdColor;
static const int32_t m_vboIdGlyphLevel;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
public:
/**
* @brief load the openGL program and get all the ID needed

97
ewol/compositing/TextDF.cpp
View File

@ -30,11 +30,10 @@ void ewol::compositing::TextDF::updateSizeToRender(const vec2& _size) {
}
void ewol::compositing::TextDF::drawMT(const mat4& _transformationMatrix, bool _enableDepthTest) {
// draw BG in any case:
m_vectorialDraw.draw();
if (m_coord.size() <= 0 || m_fontDF == nullptr) {
if ( m_VBO->bufferSize(m_vboIdCoord) <= 0
|| m_fontDF == nullptr) {
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -49,22 +48,22 @@ void ewol::compositing::TextDF::drawMT(const mat4& _transformationMatrix, bool _
if (_enableDepthTest == true) {
gale::openGL::enable(gale::openGL::flag_depthTest);
}
// set Matrix : translation/positionMatrix
// set Matrix: translation/positionMatrix
mat4 projMatrix = gale::openGL::getMatrix();
mat4 camMatrix = gale::openGL::getCameraMatrix();
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->use();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// Texture :
// Texture:
m_GLprogram->setTexture0(m_GLtexID, m_fontDF->getRendererId());
m_GLprogram->uniform1i(m_GLtextWidth, m_fontDF->getOpenGlSize().x());
m_GLprogram->uniform1i(m_GLtextHeight, m_fontDF->getOpenGlSize().x());
m_GLprogram->sendAttribute(m_GLPosition, m_coord);
m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
m_GLprogram->sendAttribute(m_GLglyphLevel, m_glyphLevel);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
m_GLprogram->sendAttributePointer(m_GLglyphLevel, m_VBO, m_vboIdGlyphLevel);
// Request the draw od the elements:
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
if (_enableDepthTest == true) {
gale::openGL::disable(gale::openGL::flag_depthTest);
@ -76,8 +75,9 @@ void ewol::compositing::TextDF::drawD(bool _disableDepthTest) {
// draw BG in any case:
m_vectorialDraw.draw();
if (m_coord.size() <= 0 || m_fontDF == nullptr) {
// TODO : a remètre ...
if ( m_VBO->bufferSize(m_vboIdCoord) <= 0
|| m_fontDF == nullptr) {
// TODO : Set it back
//EWOL_WARNING("Nothink to draw...");
return;
}
@ -89,27 +89,23 @@ void ewol::compositing::TextDF::drawD(bool _disableDepthTest) {
EWOL_ERROR("No shader ...");
return;
}
// set Matrix : translation/positionMatrix
// set Matrix: translation/positionMatrix
mat4 tmpMatrix = gale::openGL::getMatrix()*m_matrixApply;
m_GLprogram->use();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// Texture :
// Texture:
m_GLprogram->setTexture0(m_GLtexID, m_fontDF->getRendererId());
m_GLprogram->uniform1i(m_GLtextWidth, m_fontDF->getOpenGlSize().x());
m_GLprogram->uniform1i(m_GLtextHeight, m_fontDF->getOpenGlSize().x());
m_GLprogram->sendAttribute(m_GLPosition, m_coord);
m_GLprogram->sendAttribute(m_GLtexture, m_coordTex);
m_GLprogram->sendAttribute(m_GLColor, m_coordColor);
m_GLprogram->sendAttribute(m_GLglyphLevel, m_glyphLevel);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, m_vboIdCoord);
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, m_vboIdCoordText);
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, m_vboIdColor);
m_GLprogram->sendAttributePointer(m_GLglyphLevel, m_VBO, m_vboIdGlyphLevel);
// Request the draw od the elements:
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(m_vboIdCoord));
m_GLprogram->unUse();
}
void ewol::compositing::TextDF::clear() {
ewol::compositing::TextBase::clear();
m_glyphLevel.clear();
}
void ewol::compositing::TextDF::loadProgram(const std::string& _shaderName) {
ewol::compositing::TextBase::loadProgram(_shaderName);
if (m_GLprogram != nullptr) {
@ -334,20 +330,21 @@ void ewol::compositing::TextDF::printChar(const char32_t& _charcode) {
*
*/
// set texture coordonates :
m_coordTex.push_back(texturePos[0]);
m_coordTex.push_back(texturePos[1]);
m_coordTex.push_back(texturePos[2]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[1]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
// set display positions :
m_coord.push_back(bitmapDrawPos[0]);
m_coord.push_back(bitmapDrawPos[1]);
m_coord.push_back(bitmapDrawPos[2]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[1]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
// set the color
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_glyphLevel.push_back(glyphLevel);
m_glyphLevel.push_back(glyphLevel);
m_glyphLevel.push_back(glyphLevel);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
// set the bliph level
m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
/* Step 2 :
*
* **
@ -356,20 +353,21 @@ void ewol::compositing::TextDF::printChar(const char32_t& _charcode) {
* ********
*/
// set texture coordonates :
m_coordTex.push_back(texturePos[0]);
m_coordTex.push_back(texturePos[2]);
m_coordTex.push_back(texturePos[3]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[0]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[2]);
m_VBO->pushOnBuffer(m_vboIdCoordText, texturePos[3]);
// set display positions :
m_coord.push_back(bitmapDrawPos[0]);
m_coord.push_back(bitmapDrawPos[2]);
m_coord.push_back(bitmapDrawPos[3]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[0]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[2]);
m_VBO->pushOnBuffer(m_vboIdCoord, bitmapDrawPos[3]);
// set the color
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_coordColor.push_back(m_color);
m_glyphLevel.push_back(glyphLevel);
m_glyphLevel.push_back(glyphLevel);
m_glyphLevel.push_back(glyphLevel);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
m_VBO->pushOnBuffer(m_vboIdColor, m_color);
// set the bliph level
m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
m_VBO->pushOnBuffer(m_vboIdGlyphLevel, glyphLevel);
}
}
}
@ -380,6 +378,7 @@ void ewol::compositing::TextDF::printChar(const char32_t& _charcode) {
//EWOL_DEBUG(" 6 print '" << charcode << "' : start=" << m_sizeDisplayStart << " stop=" << m_sizeDisplayStop << " pos=" << m_position);
// Register the previous character
m_previousCharcode = _charcode;
m_VBO->flush();
return;
}

2
ewol/compositing/TextDF.hpp
View File

@ -20,7 +20,6 @@ namespace ewol {
class TextDF : public ewol::compositing::TextBase {
protected:
ememory::SharedPtr<ewol::resource::DistanceFieldFont> m_fontDF; //!< Font resources
std::vector<float> m_glyphLevel; //!< Level of display of the glyph (notmal : 0.50, bold : 0.40, super bold : 0.30 ...)
protected:
int32_t m_GLglyphLevel; //!< openGL Id on the glyph level display
public:
@ -42,7 +41,6 @@ namespace ewol {
*/
void updateSizeToRender(const vec2& _size);
public:
virtual void clear();
virtual void drawD(bool _disableDepthTest);
virtual void drawMT(const mat4& _transformationMatrix, bool _enableDepthTest);
protected:

65
ewol/resource/Colored3DObject.cpp
View File

@ -4,6 +4,8 @@
* @license APACHE v2.0 (see license file)
*/
#ifndef __TARGET_OS__Web
#include <ewol/debug.hpp>
#include <ewol/resource/Colored3DObject.hpp>
#include <gale/resource/Manager.hpp>
@ -25,11 +27,6 @@ void ewol::resource::Colored3DObject::init() {
m_GLColor = m_GLprogram->getUniform("EW_color");
m_GLMatrix = m_GLprogram->getUniform("EW_MatrixTransformation");
}
m_VBO = gale::resource::VirtualBufferObject::create(3);
if (m_VBO == nullptr) {
EWOL_ERROR("can not instanciate VBO ...");
return;
}
}
ewol::resource::Colored3DObject::~Colored3DObject() {
@ -37,17 +34,18 @@ ewol::resource::Colored3DObject::~Colored3DObject() {
}
void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
bool _updateDepthBuffer,
bool _depthtest) {
if (m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID) <= 0) {
if (_vertices.size() <= 0) {
return;
}
if (m_GLprogram == nullptr) {
EWOL_ERROR("No shader ...");
return;
}
if (_depthtest == true) {
if (true == _depthtest) {
gale::openGL::enable(gale::openGL::flag_depthTest);
if (false == _updateDepthBuffer) {
glDepthMask(GL_FALSE);
@ -61,11 +59,11 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
mat4 tmpMatrix = projMatrix * camMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position :
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z,unused*/, &_vertices[0], 4*sizeof(float));
// color :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID));
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, _vertices.size());
m_GLprogram->unUse();
// Request the draw od the elements :
//glDrawArrays(GL_LINES, 0, vertices.size());
@ -78,11 +76,12 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
}
}
void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer,
bool _depthtest) {
if (m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID) <= 0) {
if (_vertices.size() <= 0) {
return;
}
if (m_GLprogram == nullptr) {
@ -103,11 +102,11 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position :
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &_vertices[0], 4*sizeof(float));
// color :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID));
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, _vertices.size());
m_GLprogram->unUse();
if (true == _depthtest) {
if (false == _updateDepthBuffer) {
@ -117,11 +116,12 @@ void ewol::resource::Colored3DObject::draw(const etk::Color<float>& _color,
}
}
void ewol::resource::Colored3DObject::drawLine(const etk::Color<float>& _color,
void ewol::resource::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer,
bool _depthtest) {
if (m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID) <= 0) {
if (_vertices.size() <= 0) {
return;
}
if (m_GLprogram == nullptr) {
@ -142,11 +142,11 @@ void ewol::resource::Colored3DObject::drawLine(const etk::Color<float>& _color,
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position :
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &_vertices[0], 4*sizeof(float));
// color :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::line, 0, m_VBO->bufferSize(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID));
gale::openGL::drawArrays(gale::openGL::renderMode::line, 0, _vertices.size());
m_GLprogram->unUse();
if (true == _depthtest) {
if (false == _updateDepthBuffer) {
@ -163,7 +163,7 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
mat4& _transformationMatrix,
const etk::Color<float>& _tmpColor) {
int i, j;
m_VBO->clear();
std::vector<vec3> EwolVertices;
for(i = 0; i <= _lats; i++) {
btScalar lat0 = SIMD_PI * (-btScalar(0.5) + (btScalar) (i - 1) / _lats);
btScalar z0 = _radius*sin(lat0);
@ -187,22 +187,22 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
vec3 v2 = vec3(x * zr1, y * zr1, z1);
vec3 v3 = vec3(x * zr0, y * zr0, z0);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v1);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v2);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
EwolVertices.push_back(v1);
EwolVertices.push_back(v2);
EwolVertices.push_back(v3);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v1);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v4);
EwolVertices.push_back(v1);
EwolVertices.push_back(v3);
EwolVertices.push_back(v4);
}
}
draw(_tmpColor, _transformationMatrix);
draw(EwolVertices, _tmpColor, _transformationMatrix);
}
void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
mat4& _transformationMatrix,
const etk::Color<float>& _tmpColor){
m_VBO->clear();
std::vector<vec3> tmpVertices;
static int indices[36] = { 0,1,2, 3,2,1, 4,0,6,
6,0,2, 5,1,4, 4,1,0,
7,3,1, 7,1,5, 5,4,7,
@ -215,15 +215,16 @@ void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
vec3(-_size[0],_size[1],-_size[2]),
vec3(_size[0],-_size[1],-_size[2]),
vec3(-_size[0],-_size[1],-_size[2])};
tmpVertices.clear();
for (int32_t iii=0 ; iii<36 ; iii+=3) {
// normal calculation :
//btVector3 normal = (vertices[indices[iii+2]]-vertices[indices[iii]]).cross(vertices[indices[iii+1]]-vertices[indices[iii]]);
//normal.normalize ();
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii]]);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii+1]]);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii+2]]);
tmpVertices.push_back(vertices[indices[iii]]);
tmpVertices.push_back(vertices[indices[iii+1]]);
tmpVertices.push_back(vertices[indices[iii+2]]);
}
draw(_tmpColor, _transformationMatrix);
draw(tmpVertices, _tmpColor, _transformationMatrix);
}
namespace etk {
template<> std::string to_string(ewol::resource::Colored3DObject const&) {
@ -236,3 +237,5 @@ namespace etk {
ESIGNAL_DECLARE_SIGNAL(ewol::resource::Colored3DObject);
ESIGNAL_DECLARE_SIGNAL(ememory::SharedPtr<ewol::resource::Colored3DObject>);
#endif

18
ewol/resource/Colored3DObject.hpp
View File

@ -5,22 +5,24 @@
*/
#pragma once
#ifndef __TARGET_OS__Web
#include <etk/types.hpp>
#include <gale/resource/Resource.hpp>
#include <ewol/resource/Image.hpp>
#include <gale/resource/Program.hpp>
#define EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID 0
namespace ewol {
namespace resource {
/**
* @brief simple display of Colored3DObject ==> for DEBUG only Not availlable on ALL platform (like webGL)
*/
class Colored3DObject : public gale::Resource {
protected:
ememory::SharedPtr<gale::resource::Program> m_GLprogram;
int32_t m_GLPosition;
int32_t m_GLMatrix;
int32_t m_GLColor;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
protected:
Colored3DObject();
void init();
@ -28,14 +30,17 @@ namespace ewol {
DECLARE_RESOURCE_FACTORY(Colored3DObject);
virtual ~Colored3DObject();
public:
virtual void draw(const etk::Color<float>& _color,
virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
bool _updateDepthBuffer=true,
bool _depthtest=true);
virtual void draw(const etk::Color<float>& _color,
virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer=true,
bool _depthtest=true);
virtual void drawLine(const etk::Color<float>& _color,
virtual void drawLine(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer=true,
bool _depthtest=true);
@ -52,3 +57,4 @@ namespace ewol {
};
};
#endif

8
tools/visual_test/appl/MainWindows.cpp
View File

@ -124,8 +124,8 @@ void appl::MainWindows::onCallbackWidgetChange(int32_t _increment) {
std::string tmpConstruct;
switch(m_idWidget) {
case 0:
tmpConstruct = "<spin/>\n";
tmpDescription = "Test ewol::widget::Spin";
tmpConstruct = "<image src='DATA:sphere.png'/>\n";
tmpDescription = "Test ewol::widget::Image";
break;
case 1:
tmpConstruct = std::string()
@ -147,8 +147,8 @@ void appl::MainWindows::onCallbackWidgetChange(int32_t _increment) {
tmpDescription = "Test ewol::widget::Label";
break;
case 4:
tmpConstruct = "<image src='DATA:sphere.png'/>\n";
tmpDescription = "Test ewol::widget::Image";
tmpConstruct = "<spin/>\n";
tmpDescription = "Test ewol::widget::Spin";
break;
case 5:
tmpConstruct = "<checkbox><label>Simple string</label></checkbox>\n";