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/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) :
m_position(0.0, 0.0, 0.0),
m_color(etk::color::white),
@ -20,6 +25,14 @@ ewol::compositing::Area::Area(const ivec2& _size) :
m_resource = ewol::resource::Texture::create();
m_resource->setImageSize(_size);
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();
}
@ -59,12 +72,12 @@ void ewol::compositing::Area::draw(bool _disableDepthTest) {
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// TextureID
m_GLprogram->setTexture0(m_GLtexID, m_resource->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);
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, EWOL_COMPOSITING_VBO_COORDINATE);
// Texture:
m_GLprogram->sendAttributePointer(m_GLtexture, m_VBO, EWOL_COMPOSITING_VBO_COLOR);
// color:
m_GLprogram->sendAttributePointer(m_GLColor, m_VBO, EWOL_COMPOSITING_VBO_TEXTURE);
// Request the draw od the elements :
gale::openGL::drawArrays(gale::openGL::renderMode::triangle, 0, m_coord.size());
m_GLprogram->unUse();
@ -73,10 +86,8 @@ void ewol::compositing::Area::draw(bool _disableDepthTest) {
void ewol::compositing::Area::clear() {
// call upper class
ewol::Compositing::clear();
// reset Buffer :
m_coord.clear();
m_coordTex.clear();
m_coordColor.clear();
// reset all VBOs:
m_VBO.clear();
// reset temporal variables :
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);
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(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(1,1);
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(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(1,0);
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(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
m_coord.push_back(point);
m_coordTex.push_back(tex);
m_coordColor.push_back(m_color);
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);
tex.setValue(0,0);
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(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, m_color);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_TEXTURE, tex);
tex.setValue(0,1);
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(EWOL_COMPOSITING_VBO_COORDINATE, point);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_VBO_COLOR, 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)
private:
ememory::SharedPtr<ewol::resource::Texture> m_resource; //!< 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
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
private:
/**
* @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/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) :
m_name(_shaperName),
m_config(nullptr),
@ -40,10 +44,14 @@ ewol::compositing::Shaper::Shaper(const std::string& _shaperName) :
m_confIdBorder[iii] = -1;
m_confIdPaddingIn[iii] = -1;
}
for (size_t iii=0; iii<SHAPER_NB_MAX_VERTEX; ++iii) {
m_coord[iii] = vec2(0,0);
m_pos[iii] = vec2(0,0);
// 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::Shaper");
loadProgram();
}
@ -61,10 +69,7 @@ void ewol::compositing::Shaper::unLoadProgram() {
m_confIdBorder[iii] = -1;
m_confIdPaddingIn[iii] = -1;
}
for (size_t iii=0; iii<SHAPER_NB_MAX_VERTEX; ++iii) {
m_coord[iii] = vec2(0,0);
m_pos[iii] = vec2(0,0);
}
m_VBO->clear();
m_confIdMode = -1;
m_confIdDisplayOutside = -1;
m_nbVertexToDisplay = 0;
@ -180,10 +185,10 @@ void ewol::compositing::Shaper::draw(bool _disableDepthTest) {
// set Matrix : translation/positionMatrix
mat4 tmpMatrix = gale::openGL::getMatrix();
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// position :
m_GLprogram->sendAttribute(m_GLPosition, 2/*x,y*/, m_coord);
// position:
m_GLprogram->sendAttributePointer(m_GLPosition, m_VBO, );
// property
m_GLprogram->sendAttribute(m_GLPropertyPos, 2/*x,y*/, m_pos);
m_GLprogram->sendAttributePointer(m_GLPropertyPos, m_VBO, );
// all entry parameters :
m_GLprogram->uniform1i(m_GLStateActivate, m_stateActivate);
m_GLprogram->uniform1i(m_GLStateOld, m_stateOld);
@ -208,7 +213,7 @@ void ewol::compositing::Shaper::clear() {
m_propertyOrigin = vec2(0,0);
m_propertyInsidePosition = 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) {
@ -289,101 +294,104 @@ void ewol::compositing::Shaper::addVertexLine(float _yTop,
bool _displayOutside) {
if (m_nbVertexToDisplay != 0) {
// change line ...
m_coord[m_nbVertexToDisplay] = m_coord[m_nbVertexToDisplay-1];
m_pos[m_nbVertexToDisplay] = m_pos[m_nbVertexToDisplay-1];
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_nbVertexToDisplay++;
if (_displayOutside == true) {
m_coord[m_nbVertexToDisplay].setValue(_x1, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[0],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValButtom));
m_nbVertexToDisplay++;
} else {
m_coord[m_nbVertexToDisplay].setValue(_x2, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++;
}
}
if (_displayOutside == true) {
// A
m_coord[m_nbVertexToDisplay].setValue(_x1, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[0],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValButtom));
m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x1, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[0],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x1, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[0],_yValTop));
m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x2, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++;
// B
m_coord[m_nbVertexToDisplay].setValue(_x2, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValTop));
m_nbVertexToDisplay++;
// C
m_coord[m_nbVertexToDisplay].setValue(_x3, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[2],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValButtom));
m_nbVertexToDisplay++;
} else {
// C
m_coord[m_nbVertexToDisplay].setValue(_x2, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValButtom));
m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x2, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[1],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x2, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[1],_yValTop));
m_nbVertexToDisplay++;
m_coord[m_nbVertexToDisplay].setValue(_x3, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[2],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValButtom));
m_nbVertexToDisplay++;
}
// D
m_coord[m_nbVertexToDisplay].setValue(_x3, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[2],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x3, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[2],_yValTop));
m_nbVertexToDisplay++;
// E
m_coord[m_nbVertexToDisplay].setValue(_x4, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[3],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[3],_yValButtom));
m_nbVertexToDisplay++;
// F
m_coord[m_nbVertexToDisplay].setValue(_x4, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[3],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x4, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[3],_yValTop));
m_nbVertexToDisplay++;
// G
m_coord[m_nbVertexToDisplay].setValue(_x5, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[4],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[4],_yValButtom));
m_nbVertexToDisplay++;
// H
m_coord[m_nbVertexToDisplay].setValue(_x5, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[4],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x5, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[4],_yValTop));
m_nbVertexToDisplay++;
// I
m_coord[m_nbVertexToDisplay].setValue(_x6, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[5],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[5],_yValButtom));
m_nbVertexToDisplay++;
// J
m_coord[m_nbVertexToDisplay].setValue(_x6, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[5],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x6, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[5],_yValTop));
m_nbVertexToDisplay++;
// K
m_coord[m_nbVertexToDisplay].setValue(_x7, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[6],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[6],_yValButtom));
m_nbVertexToDisplay++;
// L
m_coord[m_nbVertexToDisplay].setValue(_x7, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[6],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x7, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[6],_yValTop));
m_nbVertexToDisplay++;
if (_displayOutside == true) {
// M
m_coord[m_nbVertexToDisplay].setValue(_x8, _yButtom);
m_pos[m_nbVertexToDisplay].setValue(_table[7],_yValButtom);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yButtom));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[7],_yValButtom));
m_nbVertexToDisplay++;
// N
m_coord[m_nbVertexToDisplay].setValue(_x8, _yTop);
m_pos[m_nbVertexToDisplay].setValue(_table[7],_yValTop);
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_COORDINATE, vec2(_x8, _yTop));
m_VBO->pushOnBuffer(EWOL_COMPOSITING_SHAPER_VBO_POS, vec2(_table[7],_yValTop));
m_nbVertexToDisplay++;
}
}
@ -571,6 +579,7 @@ void ewol::compositing::Shaper::setShape(const vec2& _origin, const vec2& _size,
modeDisplay[mode],
displayOutside);
}
m_VBO->flush();
}
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_stateNew; //!< destination state
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;
// 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)
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
private:
/**
* @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_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() {
@ -57,7 +62,7 @@ void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
mat4 tmpMatrix = projMatrix * camMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// 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 :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements :
@ -100,7 +105,7 @@ void ewol::resource::Colored3DObject::draw(std::vector<vec3>& _vertices,
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// 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 :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements :
@ -140,7 +145,7 @@ void ewol::resource::Colored3DObject::drawLine(std::vector<vec3>& _vertices,
mat4 tmpMatrix = projMatrix * camMatrix * _transformationMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
// 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 :
m_GLprogram->uniform4fv(m_GLColor, 1/*r,g,b,a*/, (float*)&_color);
// Request the draw od the elements :
@ -161,7 +166,7 @@ void ewol::resource::Colored3DObject::drawSphere(float _radius,
mat4& _transformationMatrix,
const etk::Color<float>& _tmpColor) {
int i, j;
std::vector<vec3> EwolVertices;
m_VBO.clear();
for(i = 0; i <= _lats; i++) {
btScalar lat0 = SIMD_PI * (-btScalar(0.5) + (btScalar) (i - 1) / _lats);
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 v3 = vec3(x * zr0, y * zr0, z0);
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, v2);
m_VBO->pushOnBuffer(EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID, v3);
EwolVertices.push_back(v1);
EwolVertices.push_back(v3);
EwolVertices.push_back(v4);
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);
}
}
draw(EwolVertices, _tmpColor, _transformationMatrix);
draw(_tmpColor, _transformationMatrix);
}
void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
mat4& _transformationMatrix,
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,
6,0,2, 5,1,4, 4,1,0,
7,3,1, 7,1,5, 5,4,7,
@ -218,11 +223,11 @@ void ewol::resource::Colored3DObject::drawSquare(const vec3& _size,
// normal calculation :
//btVector3 normal = (vertices[indices[iii+2]]-vertices[indices[iii]]).cross(vertices[indices[iii+1]]-vertices[indices[iii]]);
//normal.normalize ();
tmpVertices.push_back(vertices[indices[iii]]);
tmpVertices.push_back(vertices[indices[iii+1]]);
tmpVertices.push_back(vertices[indices[iii+2]]);
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]]);
}
draw(tmpVertices, _tmpColor, _transformationMatrix);
draw(_tmpColor, _transformationMatrix);
}
namespace etk {
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 <gale/resource/Program.hpp>
#define EWOL_RESOURCE_COLORED3DOBJECT_VBO_VERTEX_ID 0
namespace ewol {
namespace resource {
class Colored3DObject : public gale::Resource {
@ -18,6 +20,7 @@ namespace ewol {
int32_t m_GLPosition;
int32_t m_GLMatrix;
int32_t m_GLColor;
ememory::SharedPtr<gale::resource::VirtualBufferObject> m_VBO;
protected:
Colored3DObject();
void init();
@ -25,17 +28,14 @@ namespace ewol {
DECLARE_RESOURCE_FACTORY(Colored3DObject);
virtual ~Colored3DObject();
public:
virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
virtual void draw(const etk::Color<float>& _color,
bool _updateDepthBuffer=true,
bool _depthtest=true);
virtual void draw(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
virtual void draw(const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer=true,
bool _depthtest=true);
virtual void drawLine(std::vector<vec3>& _vertices,
const etk::Color<float>& _color,
virtual void drawLine(const etk::Color<float>& _color,
mat4& _transformationMatrix,
bool _updateDepthBuffer=true,
bool _depthtest=true);