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

[DEV] update to Web build mode (not finish)

Browse Source
This commit is contained in:
Edouard DUPIN 2016-11-04 22:54:25 +01:00
parent c7f95a96c7
commit 2ad64a73fb
6 changed files with 134 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

69
ewol/compositing/Area.cpp
View File

@ -7,6 +7,11 @@
#include <ewol/debug.hpp> #include <ewol/debug.hpp>
#include <ewol/compositing/Area.hpp> #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)
ewol::compositing::Area::Area(const ivec2& _size) : ewol::compositing::Area::Area(const ivec2& _size) :
m_position(0.0, 0.0, 0.0), m_position(0.0, 0.0, 0.0),
m_color(etk::color::white), m_color(etk::color::white),
@ -20,6 +25,14 @@ ewol::compositing::Area::Area(const ivec2& _size) :
m_resource = ewol::resource::Texture::create(); m_resource = ewol::resource::Texture::create();
m_resource->setImageSize(_size); m_resource->setImageSize(_size);
m_resource->flush(); m_resource->flush();
// Create the VBO:
m_VBO = gale::resource::VirtualBufferObject::create(3);
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");
loadProgram(); loadProgram();
} }
@ -59,12 +72,12 @@ void ewol::compositing::Area::draw(bool _disableDepthTest) {
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix); m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// TextureID // TextureID
m_GLprogram->setTexture0(m_GLtexID, m_resource->getRendererId()); m_GLprogram->setTexture0(m_GLtexID, m_resource->getRendererId());
// position : // position:
m_GLprogram->sendAttribute(m_GLPosition, m_coord); m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_COMPOSITING_VBO_COORDINATE);
// Texture : // Texture:
m_GLprogram->sendAttribute(m_GLtexture, m_coordTex); m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, EWOL_COMPOSITING_VBO_COLOR);
// color : // color:
m_GLprogram->sendAttribute(m_GLColor, m_coordColor); m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, EWOL_COMPOSITING_VBO_TEXTURE);
// Request the draw od the elements : // 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_coord.size());
m_GLprogram->unUse(); m_GLprogram->unUse();
@ -73,10 +86,8 @@ void ewol::compositing::Area::draw(bool _disableDepthTest) {
void ewol::compositing::Area::clear() { void ewol::compositing::Area::clear() {
// call upper class // call upper class
ewol::Compositing::clear(); ewol::Compositing::clear();
// reset Buffer : // reset all VBOs:
m_coord.clear(); m_VBO.clear();
m_coordTex.clear();
m_coordColor.clear();
// reset temporal variables : // reset temporal variables :
m_position = vec3(0.0, 0.0, 0.0); m_position = vec3(0.0, 0.0, 0.0);
} }
@ -86,41 +97,43 @@ void ewol::compositing::Area::print(const ivec2& _size) {
vec2 tex(0,1); vec2 tex(0,1);
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.push_back(point); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_coordTex.push_back(tex); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_coordColor.push_back(m_color); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(1,1); tex.setValue(1,1);
point.setX(m_position.x() + _size.x()); point.setX(m_position.x() + _size.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.push_back(point); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_coordTex.push_back(tex); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_coordColor.push_back(m_color); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(1,0); tex.setValue(1,0);
point.setX(m_position.x() + _size.x()); point.setX(m_position.x() + _size.x());
point.setY(m_position.y() + _size.y()); point.setY(m_position.y() + _size.y());
m_coord.push_back(point); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_coordTex.push_back(tex); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_coordColor.push_back(m_color); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_coord.push_back(point); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_coordTex.push_back(tex); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_coordColor.push_back(m_color); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(0,0); tex.setValue(0,0);
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y() + _size.y()); point.setY(m_position.y() + _size.y());
m_coord.push_back(point); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_coordTex.push_back(tex); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_coordColor.push_back(m_color); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(0,1); tex.setValue(0,1);
point.setX(m_position.x()); point.setX(m_position.x());
point.setY(m_position.y()); point.setY(m_position.y());
m_coord.push_back(point); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_coordTex.push_back(tex); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_coordColor.push_back(m_color); m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_VBO->flush();
} }

4
ewol/compositing/Area.hpp
View File

@ -28,9 +28,7 @@ namespace ewol {
int32_t m_GLtexID; //!< openGL id on the element (texture ID) int32_t m_GLtexID; //!< openGL id on the element (texture ID)
private: private:
ememory::SharedPtr<ewol::resource::Texture> m_resource; //!< texture resources ememory::SharedPtr<ewol::resource::Texture> m_resource; //!< texture resources
std::vector<vec3 > m_coord; //!< internal coord of the object ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
std::vector<vec2 > m_coordTex; //!< internal texture coordinate for every point
std::vector<etk::Color<float> > m_coordColor; //!< internal color of the different point
private: private:
/** /**
* @brief load the openGL program and get all the ID needed * @brief load the openGL program and get all the ID needed

119
ewol/compositing/Shaper.cpp
View File

@ -8,6 +8,10 @@
#include <ewol/debug.hpp> #include <ewol/debug.hpp>
#include <ewol/compositing/Shaper.hpp> #include <ewol/compositing/Shaper.hpp>
// VBO table property:
#define EWOL_COMPOSITING_SHAPER_VBO_COORDINATE (0)
#define EWOL_COMPOSITING_SHAPER_VBO_POS (1)
ewol::compositing::Shaper::Shaper(const std::string& _shaperName) : ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
m_name(_shaperName), m_name(_shaperName),
m_config(nullptr), m_config(nullptr),
@ -40,10 +44,14 @@ ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
m_confIdBorder[iii] = -1; m_confIdBorder[iii] = -1;
m_confIdPaddingIn[iii] = -1; m_confIdPaddingIn[iii] = -1;
} }
for (size_t iii=0; iii<SHAPER_NB_MAX_VERTEX; ++iii) { // Create the VBO:
m_coord[iii] = vec2(0,0); m_VBO = gale::resource::VirtualBufferObject::create(3);
m_pos[iii] = vec2(0,0); 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::Shaper");
loadProgram(); loadProgram();
} }
@ -61,10 +69,7 @@ void ewol::compositing::Shaper::unLoadProgram() {
m_confIdBorder[iii] = -1; m_confIdBorder[iii] = -1;
m_confIdPaddingIn[iii] = -1; m_confIdPaddingIn[iii] = -1;
} }
for (size_t iii=0; iii<SHAPER_NB_MAX_VERTEX; ++iii) { m_VBO->clear();
m_coord[iii] = vec2(0,0);
m_pos[iii] = vec2(0,0);
}
m_confIdMode = -1; m_confIdMode = -1;
m_confIdDisplayOutside = -1; m_confIdDisplayOutside = -1;
m_nbVertexToDisplay = 0; m_nbVertexToDisplay = 0;
@ -180,10 +185,10 @@ void ewol::compositing::Shaper::draw(bool _disableDepthTest) {
// set Matrix : translation/positionMatrix // set Matrix : translation/positionMatrix
mat4 tmpMatrix = gale::openGL::getMatrix(); mat4 tmpMatrix = gale::openGL::getMatrix();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix); m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position : // position:
m_GLprogram->sendAttribute(m_GLPosition, 2/*x,y*/, m_coord); m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, );
// property // property
m_GLprogram->sendAttribute(m_GLPropertyPos, 2/*x,y*/, m_pos); m_GLprogram->sendAttributePointer(m_GLPropertyPos, m_VBO, );
// all entry parameters : // all entry parameters :
m_GLprogram->uniform1i(m_GLStateActivate, m_stateActivate); m_GLprogram->uniform1i(m_GLStateActivate, m_stateActivate);
m_GLprogram->uniform1i(m_GLStateOld, m_stateOld); m_GLprogram->uniform1i(m_GLStateOld, m_stateOld);
@ -208,7 +213,7 @@ void ewol::compositing::Shaper::clear() {
m_propertyOrigin = vec2(0,0); m_propertyOrigin = vec2(0,0);
m_propertyInsidePosition = vec2(0,0); m_propertyInsidePosition = vec2(0,0);
m_propertyInsideSize = vec2(0,0); m_propertyInsideSize = vec2(0,0);
memset(m_coord, 0, sizeof(m_coord)); m_VBO->clear()
} }
bool ewol::compositing::Shaper::setState(int32_t _newState) { bool ewol::compositing::Shaper::setState(int32_t _newState) {
@ -289,101 +294,104 @@ void ewol::compositing::Shaper::addVertexLine(float _yTop,
bool _displayOutside) { bool _displayOutside) {
if (m_nbVertexToDisplay != 0) { if (m_nbVertexToDisplay != 0) {
// change line ... // change line ...
m_coord[m_nbVertexToDisplay] = m_coord[m_nbVertexToDisplay-1]; m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE,
m_pos[m_nbVertexToDisplay] = m_pos[m_nbVertexToDisplay-1]; 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_nbVertexToDisplay++; m_nbVertexToDisplay++;
if (_displayOutside == true) { if (_displayOutside == true) {
m_coord[m_nbVertexToDisplay].setValue(_x1, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[0],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
} else { } else {
m_coord[m_nbVertexToDisplay].setValue(_x2, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
} }
} }
if (_displayOutside == true) { if (_displayOutside == true) {
// A // A
m_coord[m_nbVertexToDisplay].setValue(_x1, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[0],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x1, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[0],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x2, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// B // B
m_coord[m_nbVertexToDisplay].setValue(_x2, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// C // C
m_coord[m_nbVertexToDisplay].setValue(_x3, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[2],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
} else { } else {
// C // C
m_coord[m_nbVertexToDisplay].setValue(_x2, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x2, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x3, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[2],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
} }
// D // D
m_coord[m_nbVertexToDisplay].setValue(_x3, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[2],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// E // E
m_coord[m_nbVertexToDisplay].setValue(_x4, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[3],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[3],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// F // F
m_coord[m_nbVertexToDisplay].setValue(_x4, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[3],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[3],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// G // G
m_coord[m_nbVertexToDisplay].setValue(_x5, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[4],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[4],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// H // H
m_coord[m_nbVertexToDisplay].setValue(_x5, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[4],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[4],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// I // I
m_coord[m_nbVertexToDisplay].setValue(_x6, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[5],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[5],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// J // J
m_coord[m_nbVertexToDisplay].setValue(_x6, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[5],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[5],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// K // K
m_coord[m_nbVertexToDisplay].setValue(_x7, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[6],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[6],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// L // L
m_coord[m_nbVertexToDisplay].setValue(_x7, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[6],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[6],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
if (_displayOutside == true) { if (_displayOutside == true) {
// M // M
m_coord[m_nbVertexToDisplay].setValue(_x8, _yButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yButtom));
m_pos[m_nbVertexToDisplay].setValue(_table[7],_yValButtom); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[7],_yValButtom));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
// N // N
m_coord[m_nbVertexToDisplay].setValue(_x8, _yTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yTop));
m_pos[m_nbVertexToDisplay].setValue(_table[7],_yValTop); m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[7],_yValTop));
m_nbVertexToDisplay++; m_nbVertexToDisplay++;
} }
} }
@ -571,6 +579,7 @@ void ewol::compositing::Shaper::setShape(const vec2& _origin, const vec2& _size,
modeDisplay[mode], modeDisplay[mode],
displayOutside); displayOutside);
} }
m_VBO->flush();
} }
ewol::Padding ewol::compositing::Shaper::getPadding() { ewol::Padding ewol::compositing::Shaper::getPadding() {

3
ewol/compositing/Shaper.hpp
View File

@ -72,12 +72,11 @@ namespace ewol {
int32_t m_stateOld; //!< previous state int32_t m_stateOld; //!< previous state
int32_t m_stateNew; //!< destination state int32_t m_stateNew; //!< destination state
float m_stateTransition; //!< working state between 2 states float m_stateTransition; //!< working state between 2 states
vec2 m_coord[SHAPER_NB_MAX_VERTEX]; //!< coordonate of the display ...
vec2 m_pos[SHAPER_NB_MAX_VERTEX]; //!< podition to display property
int32_t m_nbVertexToDisplay; int32_t m_nbVertexToDisplay;
// color management theme: // color management theme:
ememory::SharedPtr<ewol::resource::ColorFile> m_colorProperty; //!< input resource for color management 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) std::vector<ivec2> m_listAssiciatedId; //!< Corellation ID between ColorProperty (Y) and OpenGL Program (X)
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
private: private:
/** /**
* @brief load the openGL program and get all the ID needed * @brief load the openGL program and get all the ID needed

37
ewol/resource/Colored3DObject.cpp
View File

@ -25,6 +25,11 @@ void ewol::resource::Colored3DObject::init() {
m_GLColor = m_GLprogram->getUniform("EW_color"); m_GLColor = m_GLprogram->getUniform("EW_color");
m_GLMatrix = m_GLprogram->getUniform("EW_MatrixTransformation"); 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() { ewol::resource::Colored3DObject::~Colored3DObject() {
@ -57,7 +62,7 @@ void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
mat4 tmpMatrix = projMatrix * camMatrix; mat4 tmpMatrix = projMatrix * camMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix); m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position : // position :
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z,unused*/, &_vertices[0], 4*sizeof(float)); m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
// color : // color :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color); m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements : // Request the draw od the elements :
@ -100,7 +105,7 @@ void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix; mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix); m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position : // position :
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &_vertices[0], 4*sizeof(float)); m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
// color : // color :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color); m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements : // Request the draw od the elements :
@ -140,7 +145,7 @@ void ewol::resource::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix; mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix); m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position : // position :
m_GLprogram->sendAttribute(m_GLPosition, 3/*x,y,z*/, &_vertices[0], 4*sizeof(float)); m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID);
// color : // color :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color); m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements : // Request the draw od the elements :
@ -161,7 +166,7 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
mat4& _transformationMatrix, mat4& _transformationMatrix,
const etk::Color<float>& _tmpColor) { const etk::Color<float>& _tmpColor) {
int i, j; int i, j;
std::vector<vec3> EwolVertices; m_VBO.clear();
for(i = 0; i <= _lats; i++) { for(i = 0; i <= _lats; i++) {
btScalar lat0 = SIMD_PI * (-btScalar(0.5) + (btScalar) (i - 1) / _lats); btScalar lat0 = SIMD_PI * (-btScalar(0.5) + (btScalar) (i - 1) / _lats);
btScalar z0 = _radius*sin(lat0); btScalar z0 = _radius*sin(lat0);
@ -185,22 +190,22 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
vec3 v2 = vec3(x * zr1, y * zr1, z1); vec3 v2 = vec3(x * zr1, y * zr1, z1);
vec3 v3 = vec3(x * zr0, y * zr0, z0); vec3 v3 = vec3(x * zr0, y * zr0, z0);
EwolVertices.push_back(v1); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v1);
EwolVertices.push_back(v2); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v2);
EwolVertices.push_back(v3); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
EwolVertices.push_back(v1); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v1);
EwolVertices.push_back(v3); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
EwolVertices.push_back(v4); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v4);
} }
} }
draw(EwolVertices, _tmpColor, _transformationMatrix); draw(_tmpColor, _transformationMatrix);
} }
void ewol::resource::Colored3DObject::drawSquare(const vec3& _size, void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
mat4& _transformationMatrix, mat4& _transformationMatrix,
const etk::Color<float>& _tmpColor){ const etk::Color<float>& _tmpColor){
std::vector<vec3> tmpVertices; m_VBO.clear();
static int indices[36] = { 0,1,2, 3,2,1, 4,0,6, static int indices[36] = { 0,1,2, 3,2,1, 4,0,6,
6,0,2, 5,1,4, 4,1,0, 6,0,2, 5,1,4, 4,1,0,
7,3,1, 7,1,5, 5,4,7, 7,3,1, 7,1,5, 5,4,7,
@ -218,11 +223,11 @@ void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
// normal calculation : // normal calculation :
//btVector3 normal = (vertices[indices[iii+2]]-vertices[indices[iii]]).cross(vertices[indices[iii+1]]-vertices[indices[iii]]); //btVector3 normal = (vertices[indices[iii+2]]-vertices[indices[iii]]).cross(vertices[indices[iii+1]]-vertices[indices[iii]]);
//normal.normalize (); //normal.normalize ();
tmpVertices.push_back(vertices[indices[iii]]); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii]]);
tmpVertices.push_back(vertices[indices[iii+1]]); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii+1]]);
tmpVertices.push_back(vertices[indices[iii+2]]); m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, vertices[indices[iii+2]]);
} }
draw(tmpVertices, _tmpColor, _transformationMatrix); draw(_tmpColor, _transformationMatrix);
} }
namespace etk { namespace etk {
template<> std::string to_string(ewol::resource::Colored3DObject const&) { template<> std::string to_string(ewol::resource::Colored3DObject const&) {

12
ewol/resource/Colored3DObject.hpp
View File

@ -10,6 +10,8 @@
#include <ewol/resource/Image.hpp> #include <ewol/resource/Image.hpp>
#include <gale/resource/Program.hpp> #include <gale/resource/Program.hpp>
#define EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID 0
namespace ewol { namespace ewol {
namespace resource { namespace resource {
class Colored3DObject : public gale::Resource { class Colored3DObject : public gale::Resource {
@ -18,6 +20,7 @@ namespace ewol {
int32_t m_GLPosition; int32_t m_GLPosition;
int32_t m_GLMatrix; int32_t m_GLMatrix;
int32_t m_GLColor; int32_t m_GLColor;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
protected: protected:
Colored3DObject(); Colored3DObject();
void init(); void init();
@ -25,17 +28,14 @@ namespace ewol {
DECLARE_RESOURCE_FACTORY(Colored3DObject); DECLARE_RESOURCE_FACTORY(Colored3DObject);
virtual ~Colored3DObject(); virtual ~Colored3DObject();
public: public:
virtual void draw(std::vector<vec3>& _vertices, virtual void draw(const etk::Color<float>& _color,
const etk::Color<float>& _color,
bool _updateDepthBuffer=true, bool _updateDepthBuffer=true,
bool _depthtest=true); bool _depthtest=true);
virtual void draw(std::vector<vec3>& _vertices, virtual void draw(const etk::Color<float>& _color,
const etk::Color<float>& _color,
mat4& _transformationMatrix, mat4& _transformationMatrix,
bool _updateDepthBuffer=true, bool _updateDepthBuffer=true,
bool _depthtest=true); bool _depthtest=true);
virtual void drawLine(std::vector<vec3>& _vertices, virtual void drawLine(const etk::Color<float>& _color,
const etk::Color<float>& _color,
mat4& _transformationMatrix, mat4& _transformationMatrix,
bool _updateDepthBuffer=true, bool _updateDepthBuffer=true,
bool _depthtest=true); bool _depthtest=true);