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

[DEV] update gale

Browse Source
This commit is contained in:
Edouard DUPIN 2015-08-23 21:42:48 +02:00
parent 9055235cf7
commit 835c7f5134
24 changed files with 137 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ege/Environement.cpp
View File

@ -11,7 +11,7 @@
#include <ege/elements/Element.h>
#include <ewol/object/Manager.h>
#include <ewol/openGL/openGL.h>
#include <gale/renderer/openGL/openGL.h>
#include <etk/math/Matrix4.h>
#include <BulletDynamics/Dynamics/btRigidBody.h>
#include <LinearMath/btDefaultMotionState.h>

4
ege/Light.cpp
View File

@ -27,7 +27,7 @@ ege::Light::~Light() {
}
void ege::Light::link(const std::shared_ptr<ewol::resource::Program>& _prog, const std::string& _baseName) {
void ege::Light::link(const std::shared_ptr<gale::resource::Program>& _prog, const std::string& _baseName) {
if (nullptr == _prog) {
return;
}
@ -38,7 +38,7 @@ void ege::Light::link(const std::shared_ptr<ewol::resource::Program>& _prog, con
m_GL_specularColor = _prog->getUniform(_baseName+".specularColor");
}
void ege::Light::draw(const std::shared_ptr<ewol::resource::Program>& _prog) {
void ege::Light::draw(const std::shared_ptr<gale::resource::Program>& _prog) {
_prog->uniform3(m_GL_direction, m_direction);
_prog->uniform3(m_GL_halfplane, m_halfplane);
_prog->uniform4(m_GL_ambientColor, m_ambientColor);

6
ege/Light.h
View File

@ -12,7 +12,7 @@
#include <etk/types.h>
#include <etk/math/Vector3D.h>
#include <etk/math/Vector4D.h>
#include <ewol/resource/Program.h>
#include <gale/resource/Program.h>
namespace ege {
class Light {
@ -33,8 +33,8 @@ namespace ege {
public:
Light();
~Light();
void link(const std::shared_ptr<ewol::resource::Program>& _prog, const std::string& _baseName);
void draw(const std::shared_ptr<ewol::resource::Program>& _prog);
void link(const std::shared_ptr<gale::resource::Program>& _prog, const std::string& _baseName);
void draw(const std::shared_ptr<gale::resource::Program>& _prog);
void setDirection(const vec3& val) {
m_direction = val;
}

48
ege/Material.cpp
View File

@ -6,7 +6,7 @@
* @license BSD v3 (see license file)
*/
#include <ewol/resource/Manager.h>
#include <gale/resource/Manager.h>
#include <ege/Material.h>
#include <ege/debug.h>
@ -19,7 +19,7 @@ ege::MaterialGlId::MaterialGlId() :
// nothing to do else ...
}
void ege::MaterialGlId::link(const std::shared_ptr<ewol::resource::Program>& _prog, const std::string& _baseName) {
void ege::MaterialGlId::link(const std::shared_ptr<gale::resource::Program>& _prog, const std::string& _baseName) {
if (nullptr == _prog) {
return;
}
@ -35,7 +35,7 @@ ege::Material::Material() :
m_diffuseFactor(0,0,0,1),
m_specularFactor(0,0,0,1),
m_shininess(1),
m_renderMode(ewol::openGL::renderTriangle),
m_renderMode(gale::openGL::render_triangle),
m_texture0(nullptr) {
// nothing to do else ...
}
@ -44,7 +44,7 @@ ege::Material::~Material() {
}
void ege::Material::draw(const std::shared_ptr<ewol::resource::Program>& _prog, const MaterialGlId& _glID) {
void ege::Material::draw(const std::shared_ptr<gale::resource::Program>& _prog, const MaterialGlId& _glID) {
_prog->uniform4(_glID.m_GL_ambientFactor, m_ambientFactor);
_prog->uniform4(_glID.m_GL_diffuseFactor, m_diffuseFactor);
_prog->uniform4(_glID.m_GL_specularFactor, m_specularFactor);
@ -100,45 +100,45 @@ void ege::Material::setTexture0Magic(const ivec2& _size) {
}
}
int32_t ege::Material::getRenderModeOpenGl() {
return static_cast<int32_t>(m_renderMode);
enum gale::openGL::renderMode ege::Material::getRenderModeOpenGl() {
return m_renderMode;
}
void ege::Material::setRenderMode(enum ewol::openGL::renderMode _val) {
void ege::Material::setRenderMode(enum gale::openGL::renderMode _val) {
switch (_val) {
case ewol::openGL::renderPoint:
case gale::openGL::render_point:
break;
case ewol::openGL::renderLine:
case gale::openGL::render_line:
break;
case ewol::openGL::renderLineStrip:
case gale::openGL::render_lineStrip:
EGE_INFO("Does not support " << _val << " auto convert it in 'LINE'");
_val = ewol::openGL::renderLine;
_val = gale::openGL::render_line;
break;
case ewol::openGL::renderLineLoop:
case gale::openGL::render_lineLoop:
EGE_INFO("Does not support " << _val << " auto convert it in 'LINE'");
_val = ewol::openGL::renderLine;
_val = gale::openGL::render_line;
break;
case ewol::openGL::renderTriangle:
case gale::openGL::render_triangle:
break;
case ewol::openGL::renderTriangleStrip:
case gale::openGL::render_triangleStrip:
EGE_INFO("Does not support " << _val << " auto convert it in 'TRIANGLE'");
_val = ewol::openGL::renderTriangle;
_val = gale::openGL::render_triangle;
break;
case ewol::openGL::renderTriangleFan:
case gale::openGL::render_triangleFan:
EGE_INFO("Does not support " << _val << " auto convert it in 'TRIANGLE'");
_val = ewol::openGL::renderTriangle;
_val = gale::openGL::render_triangle;
break;
case ewol::openGL::renderQuad:
case gale::openGL::render_quad:
EGE_INFO("Does not support " << _val << " auto convert it in 'TRIANGLE'");
_val = ewol::openGL::renderTriangle;
_val = gale::openGL::render_triangle;
break;
case ewol::openGL::renderQuadStrip:
case gale::openGL::render_quadStrip:
EGE_INFO("Does not support " << _val << " auto convert it in 'TRIANGLE'");
_val = ewol::openGL::renderTriangle;
_val = gale::openGL::render_triangle;
break;
case ewol::openGL::renderPolygon:
case gale::openGL::render_polygon:
EGE_ERROR("Does not support " << _val << " try convert it in 'TRIANGLE'");
_val = ewol::openGL::renderTriangle;
_val = gale::openGL::render_triangle;
break;
}
m_renderMode = _val;

14
ege/Material.h
View File

@ -12,7 +12,7 @@
#include <etk/types.h>
#include <etk/math/Vector3D.h>
#include <etk/math/Vector4D.h>
#include <ewol/resource/Program.h>
#include <gale/resource/Program.h>
#include <ewol/resource/Image.h>
namespace ege {
@ -28,7 +28,7 @@ namespace ege {
int32_t m_GL_shininess;
int32_t m_GL_texture0;
MaterialGlId();
void link(const std::shared_ptr<ewol::resource::Program>& _prog, const std::string& _baseName);
void link(const std::shared_ptr<gale::resource::Program>& _prog, const std::string& _baseName);
};
@ -39,14 +39,14 @@ namespace ege {
vec4 m_diffuseFactor;
vec4 m_specularFactor;
float m_shininess;
enum ewol::openGL::renderMode m_renderMode; // Select Render mode (triangle/Line/point ...)
enum gale::openGL::renderMode m_renderMode; // Select Render mode (triangle/Line/point ...)
std::shared_ptr<ewol::resource::Texture> m_texture0;
public:
std::vector<uint32_t> m_listIndexFaces;
public:
Material();
~Material();
void draw(const std::shared_ptr<ewol::resource::Program>& _prog, const ege::MaterialGlId& _glID);
void draw(const std::shared_ptr<gale::resource::Program>& _prog, const ege::MaterialGlId& _glID);
void setAmbientFactor(const vec4& _val) {
m_ambientFactor = _val;
}
@ -59,9 +59,9 @@ namespace ege {
void setShininess(float _val) {
m_shininess = _val;
}
void setRenderMode(enum ewol::openGL::renderMode _val);
int32_t getRenderModeOpenGl();
enum ewol::openGL::renderMode getRenderMode() {
void setRenderMode(enum gale::openGL::renderMode _val);
enum gale::openGL::renderMode getRenderModeOpenGl();
enum gale::openGL::renderMode getRenderMode() {
return m_renderMode;
}
void setTexture0(const std::string& _filename);

6
ege/camera/Camera.cpp
View File

@ -10,7 +10,7 @@
#include <ege/camera/Camera.h>
#include <ege/debug.h>
#include <ewol/openGL/openGL.h>
#include <gale/renderer/openGL/openGL.h>
#undef __class__
#define __class__ "Camera"
@ -62,8 +62,8 @@ void ege::Camera::updateProjectionMatrix() {
}
void ege::Camera::configureOpenGL() {
ewol::openGL::setCameraMatrix(getMatrixCamera());
ewol::openGL::setMatrix(getMatrixProjection());
gale::openGL::setCameraMatrix(getMatrixCamera());
gale::openGL::setMatrix(getMatrixProjection());
}

2
ege/elements/Element.h
View File

@ -15,7 +15,7 @@
#include <vector>
#include <ewol/debug.h>
#include <ewol/widget/Widget.h>
#include <ewol/openGL/openGL.h>
#include <gale/renderer/openGL/openGL.h>
#include <ewol/resource/Colored3DObject.h>
#include <ege/resource/Mesh.h>
#include <ege/camera/Camera.h>

2
ege/elements/ElementPhysic.h
View File

@ -15,7 +15,7 @@
#include <vector>
#include <ewol/debug.h>
#include <ewol/widget/Widget.h>
#include <ewol/openGL/openGL.h>
#include <gale/renderer/openGL/openGL.h>
#include <ewol/resource/Colored3DObject.h>
#include <ege/resource/Mesh.h>
#include <ege/camera/Camera.h>

2
ege/physics/Engine.cpp
View File

@ -10,7 +10,7 @@
#include <ege/debug.h>
#include <ewol/openGL/openGL.h>
#include <gale/renderer/openGL/openGL.h>
#include <etk/math/Matrix4.h>
#include <BulletDynamics/Dynamics/btRigidBody.h>
#include <LinearMath/btDefaultMotionState.h>

6
ege/physics/Engine.h
View File

@ -21,9 +21,9 @@ namespace ege {
#include <ewol/debug.h>
#include <ege/camera/Camera.h>
#include <ewol/widget/Widget.h>
#include <ewol/openGL/openGL.h>
#include <ewol/resource/Manager.h>
#include <ewol/Dimension.h>
#include <gale/renderer/openGL/openGL.h>
#include <gale/resource/Manager.h>
#include <gale/Dimension.h>
class btBroadphaseInterface;

98
ege/resource/Mesh.cpp
View File

@ -8,7 +8,8 @@
#include <ege/debug.h>
#include <ege/resource/Mesh.h>
#include <ewol/resource/Manager.h>
#include <gale/resource/Manager.h>
#include <gale/renderer/openGL/openGL-include.h>
#include <etk/os/FSNode.h>
#include <ege/resource/tools/viewBox.h>
#include <ege/resource/tools/isoSphere.h>
@ -30,12 +31,11 @@ ege::resource::Mesh::Mesh() :
m_numberOfElments(-1),
m_pointerShape(nullptr),
m_functionFreeShape(nullptr) {
addObjectType("ege::resource::Mesh");
addResourceType("ege::resource::Mesh");
}
void ege::resource::Mesh::init(const std::string& _fileName, const std::string& _shaderName) {
ewol::Resource::init(_fileName);
addObjectType("ege::resource::Mesh");
gale::Resource::init(_fileName);
EGE_VERBOSE("Load a new mesh : '" << _fileName << "'");
// get the shader resource :
m_GLPosition = 0;
@ -47,7 +47,7 @@ void ege::resource::Mesh::init(const std::string& _fileName, const std::string&
m_light.setSpecularColor(vec4(0.0f,0.0f,0.0f,1.0f));
//EGE_DEBUG(m_name << " " << m_light);
m_GLprogram = ewol::resource::Program::create(_shaderName);
m_GLprogram = gale::resource::Program::create(_shaderName);
if (m_GLprogram != nullptr) {
m_GLPosition = m_GLprogram->getAttribute("EW_coord3d");
m_GLtexture = m_GLprogram->getAttribute("EW_texture2d");
@ -60,7 +60,7 @@ void ege::resource::Mesh::init(const std::string& _fileName, const std::string&
m_light.link(m_GLprogram, "EW_directionalLight");
}
// this is the properties of the buffer requested : "r"/"w" + "-" + buffer type "f"=flaot "i"=integer
m_verticesVBO = ewol::resource::VirtualBufferObject::create(5);
m_verticesVBO = gale::resource::VirtualBufferObject::create(5);
if (m_verticesVBO == nullptr) {
EGE_ERROR("can not instanciate VBO ...");
return;
@ -118,18 +118,18 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
}
//EGE_DEBUG(m_name << " " << m_light);
if (_enableDepthTest == true) {
ewol::openGL::enable(ewol::openGL::FLAG_DEPTH_TEST);
gale::openGL::enable(gale::openGL::flag_depthTest);
if (false == _enableDepthUpdate) {
glDepthMask(GL_FALSE);
}
} else {
ewol::openGL::disable(ewol::openGL::FLAG_DEPTH_TEST);
gale::openGL::disable(gale::openGL::flag_depthTest);
}
//EGE_DEBUG(" display " << m_coord.size() << " elements" );
m_GLprogram->use();
// set Matrix : translation/positionMatrix
mat4 projMatrix = ewol::openGL::getMatrix();
mat4 camMatrix = ewol::openGL::getCameraMatrix();
mat4 projMatrix = gale::openGL::getMatrix();
mat4 camMatrix = gale::openGL::getCameraMatrix();
mat4 tmpMatrix = projMatrix * camMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
m_GLprogram->uniformMatrix(m_GLMatrixPosition, _positionMatrix);
@ -165,7 +165,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
}
m_materials[m_listFaces.getKey(kkk)]->draw(m_GLprogram, m_GLMaterial);
if (m_checkNormal == false) {
ewol::openGL::drawElements(m_materials[m_listFaces.getKey(kkk)]->getRenderModeOpenGl(), m_listFaces.getValue(kkk).m_index);
gale::openGL::drawElements(m_materials[m_listFaces.getKey(kkk)]->getRenderModeOpenGl(), m_listFaces.getValue(kkk).m_index);
#ifdef DISPLAY_NB_VERTEX_DISPLAYED
nbElementDraw += m_listFaces.getValue(kkk).m_index.size();
nbElementDrawTheoric += m_listFaces.getValue(kkk).m_index.size();
@ -211,7 +211,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
}
break;
}
ewol::openGL::drawElements(m_materials[m_listFaces.getKey(kkk)]->getRenderModeOpenGl(), tmpIndexResult);
gale::openGL::drawElements(m_materials[m_listFaces.getKey(kkk)]->getRenderModeOpenGl(), tmpIndexResult);
#ifdef DISPLAY_NB_VERTEX_DISPLAYED
nbElementDraw += tmpIndexResult.size();
nbElementDrawTheoric += m_listFaces.getValue(kkk).m_index.size();
@ -235,7 +235,7 @@ void ege::resource::Mesh::draw(mat4& _positionMatrix,
if (false == _enableDepthUpdate) {
glDepthMask(GL_TRUE);
}
ewol::openGL::disable(ewol::openGL::FLAG_DEPTH_TEST);
gale::openGL::disable(gale::openGL::flag_depthTest);
}
// TODO : UNDERSTAND why ... it is needed
glBindBuffer(GL_ARRAY_BUFFER,0);
@ -247,11 +247,11 @@ void ege::resource::Mesh::calculateNormaleFace(const std::string& _materialName)
m_listFacesNormal.clear();
if (m_normalMode == ege::resource::Mesh::normalModeFace) {
EGE_INFO("calculateNormaleFace(" << _materialName << ")");
ewol::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode();
if ( tmpRenderMode == ewol::openGL::renderPoint
|| tmpRenderMode == ewol::openGL::renderLine
|| tmpRenderMode == ewol::openGL::renderLineStrip
|| tmpRenderMode == ewol::openGL::renderLineLoop) {
gale::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode();
if ( tmpRenderMode == gale::openGL::render_point
|| tmpRenderMode == gale::openGL::render_line
|| tmpRenderMode == gale::openGL::render_lineStrip
|| tmpRenderMode == gale::openGL::render_lineLoop) {
EGE_ERROR("calculateNormaleFace(" << _materialName << ") : can not calculate normal on lines ...");
m_normalMode = ege::resource::Mesh::normalModeNone;
return;
@ -269,11 +269,11 @@ void ege::resource::Mesh::calculateNormaleEdge(const std::string& _materialName)
m_listVertexNormal.clear();
if (m_normalMode == ege::resource::Mesh::normalModeVertex) {
EGE_INFO("calculateNormaleEdge(" << _materialName << ")");
ewol::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode();
if ( tmpRenderMode == ewol::openGL::renderPoint
|| tmpRenderMode == ewol::openGL::renderLine
|| tmpRenderMode == ewol::openGL::renderLineStrip
|| tmpRenderMode == ewol::openGL::renderLineLoop) {
gale::openGL::renderMode tmpRenderMode = m_materials[_materialName]->getRenderMode();
if ( tmpRenderMode == gale::openGL::render_point
|| tmpRenderMode == gale::openGL::render_line
|| tmpRenderMode == gale::openGL::render_lineStrip
|| tmpRenderMode == gale::openGL::render_lineLoop) {
EGE_ERROR("calculateNormaleEdge(" << _materialName << ") : can not calculate normal on lines ...");
m_normalMode = ege::resource::Mesh::normalModeNone;
return;
@ -319,24 +319,24 @@ void ege::resource::Mesh::generateVBO() {
m_listFaces.getValue(kkk).m_index.clear();
int32_t nbIndicInFace = 3;
switch (m_materials[m_listFaces.getKey(kkk)]->getRenderMode()) {
case ewol::openGL::renderTriangle:
case ewol::openGL::renderTriangleStrip:
case ewol::openGL::renderTriangleFan:
case gale::openGL::render_triangle:
case gale::openGL::render_triangleStrip:
case gale::openGL::render_triangleFan:
nbIndicInFace = 3;
break;
case ewol::openGL::renderLine:
case ewol::openGL::renderLineStrip:
case ewol::openGL::renderLineLoop:
case gale::openGL::render_line:
case gale::openGL::render_lineStrip:
case gale::openGL::render_lineLoop:
nbIndicInFace = 2;
break;
case ewol::openGL::renderPoint:
case gale::openGL::render_point:
nbIndicInFace = 1;
break;
case ewol::openGL::renderQuad:
case ewol::openGL::renderQuadStrip:
case gale::openGL::render_quad:
case gale::openGL::render_quadStrip:
nbIndicInFace = 4;
break;
case ewol::openGL::renderPolygon:
case gale::openGL::render_polygon:
nbIndicInFace = 3;
break;
}
@ -493,8 +493,8 @@ void ege::resource::Mesh::addPoint(const std::string& _layerName, const vec3& _p
EGE_ERROR("Mesh layer : " << _layerName << " does not exist in list faces=" << m_listFaces.exist(_layerName) << " materials=" << m_listFaces.exist(_layerName) << " ...");
return;
}
ewol::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if (tmpRenderMode != ewol::openGL::renderPoint) {
gale::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if (tmpRenderMode != gale::openGL::render_point) {
EGE_ERROR("try to add Point in a mesh material section that not support Point");
return;
}
@ -514,10 +514,10 @@ void ege::resource::Mesh::addLine(const std::string& _layerName, const vec3& _po
EGE_ERROR("Mesh layer : " << _layerName << " does not exist in list faces=" << m_listFaces.exist(_layerName) << " materials=" << m_listFaces.exist(_layerName) << " ...");
return;
}
ewol::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if ( tmpRenderMode != ewol::openGL::renderLine
&& tmpRenderMode != ewol::openGL::renderLineStrip
&& tmpRenderMode != ewol::openGL::renderLineLoop) {
gale::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if ( tmpRenderMode != gale::openGL::render_line
&& tmpRenderMode != gale::openGL::render_lineStrip
&& tmpRenderMode != gale::openGL::render_lineLoop) {
EGE_ERROR("try to add Line in a mesh material section that not support Line");
return;
}
@ -559,10 +559,10 @@ void ege::resource::Mesh::addTriangle(const std::string& _layerName,
EGE_ERROR("Mesh layer : " << _layerName << " does not exist in list faces=" << m_listFaces.exist(_layerName) << " materials=" << m_listFaces.exist(_layerName) << " ...");
return;
}
ewol::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if ( tmpRenderMode != ewol::openGL::renderTriangle
&& tmpRenderMode != ewol::openGL::renderTriangleStrip
&& tmpRenderMode != ewol::openGL::renderTriangleFan) {
gale::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if ( tmpRenderMode != gale::openGL::render_triangle
&& tmpRenderMode != gale::openGL::render_triangleStrip
&& tmpRenderMode != gale::openGL::render_triangleFan) {
EGE_ERROR("try to add Line in a mesh material section that not support Line");
return;
}
@ -592,13 +592,13 @@ void ege::resource::Mesh::addTriangle(const std::string& _layerName, const vec3&
EGE_ERROR("Mesh layer : " << _layerName << " does not exist in list faces=" << m_listFaces.exist(_layerName) << " materials=" << m_listFaces.exist(_layerName) << " ...");
return;
}
ewol::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if ( tmpRenderMode == ewol::openGL::renderQuad
|| tmpRenderMode == ewol::openGL::renderQuadStrip) {
gale::openGL::renderMode tmpRenderMode = m_materials[_layerName]->getRenderMode();
if ( tmpRenderMode == gale::openGL::render_quad
|| tmpRenderMode == gale::openGL::render_quadStrip) {
EGE_TODO("Create quad interface ...");
} else if ( tmpRenderMode == ewol::openGL::renderTriangle
|| tmpRenderMode == ewol::openGL::renderLineStrip
|| tmpRenderMode == ewol::openGL::renderTriangleFan) {
} else if ( tmpRenderMode == gale::openGL::render_triangle
|| tmpRenderMode == gale::openGL::render_lineStrip
|| tmpRenderMode == gale::openGL::render_triangleFan) {
// try to find position:
int32_t pos1 = findPositionInList(_pos1);

14
ege/resource/Mesh.h
View File

@ -11,11 +11,11 @@
#include <etk/types.h>
#include <etk/Hash.h>
#include <ewol/resource/Resource.h>
#include <gale/resource/Resource.h>
#include <ewol/resource/Image.h>
#include <ewol/resource/Shader.h>
#include <ewol/resource/Program.h>
#include <ewol/resource/VirtualBufferObject.h>
#include <gale/resource/Shader.h>
#include <gale/resource/Program.h>
#include <gale/resource/VirtualBufferObject.h>
#include <ege/Light.h>
#include <ege/Material.h>
#include <ege/resource/tools/Face.h>
@ -31,7 +31,7 @@
namespace ege {
namespace resource {
class Mesh : public ewol::Resource {
class Mesh : public gale::Resource {
public:
static std::shared_ptr<ege::resource::Mesh> createGrid(int32_t _lineCount, const vec3& _position=vec3(0,0,0), float _size=1.0f, const std::string& _materialName="basics");
static std::shared_ptr<ege::resource::Mesh> createCube(float _size=1.0f, const std::string& _materialName="basics", const etk::Color<float>& _color=etk::color::white);
@ -48,7 +48,7 @@ namespace ege {
enum normalMode m_normalMode; // select the normal mode of display
bool m_checkNormal; //!< when enable, this check the normal of the mesh before sending it at the 3d card
protected:
std::shared_ptr<ewol::resource::Program> m_GLprogram;
std::shared_ptr<gale::resource::Program> m_GLprogram;
int32_t m_GLPosition;
int32_t m_GLMatrix;
int32_t m_GLMatrixPosition;
@ -70,7 +70,7 @@ namespace ege {
std::vector<std::shared_ptr<ege::PhysicsShape>> m_physics; //!< collision shape module ... (independent of bullet lib)
void clean();
protected:
std::shared_ptr<ewol::resource::VirtualBufferObject> m_verticesVBO;
std::shared_ptr<gale::resource::VirtualBufferObject> m_verticesVBO;
protected:
Mesh();
void init(const std::string& _fileName="---", const std::string& _shaderName="DATA:textured3D2.prog");

2
ege/resource/MeshCube.cpp
View File

@ -19,7 +19,7 @@ std::shared_ptr<ege::resource::Mesh> ege::resource::Mesh::createCube(float _size
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
material->setShininess(1);
material->setRenderMode(ewol::openGL::renderTriangle);
material->setRenderMode(gale::openGL::render_triangle);
out->addMaterial(_materialName, material);
out->addFaceIndexing(_materialName);

2
ege/resource/MeshEmf.cpp
View File

@ -483,7 +483,7 @@ bool ege::resource::Mesh::loadEMF(const std::string& _fileName) {
material->setTexture0(fileName.getRelativeFolder() + &inputDataLine[7]);
EGE_VERBOSE(" Texture " << &inputDataLine[7]);
} else if(0 == strncmp(inputDataLine,"renderMode ",11)) {
ewol::openGL::renderMode mode;
gale::openGL::renderMode mode;
etk::from_string(mode, &inputDataLine[11]);
material->setRenderMode(mode);
EGE_VERBOSE(" Texture " << mode);

4
ege/resource/MeshGird.cpp
View File

@ -18,8 +18,8 @@ std::shared_ptr<ege::resource::Mesh> ege::resource::Mesh::createGrid(int32_t _li
material->setDiffuseFactor(vec4(0,0,0,1));
material->setSpecularFactor(vec4(0,0,0,1));
material->setShininess(1);
material->setRenderMode(ewol::openGL::renderLine);
//material->setRenderMode(ewol::openGL::renderPoint);
material->setRenderMode(gale::openGL::render_line);
//material->setRenderMode(gale::openGL::render_point);
out->addMaterial(_materialName, material);
out->addFaceIndexing(_materialName);

19
ege/resource/ParticuleMesh.cpp
View File

@ -8,10 +8,11 @@
#include <ege/debug.h>
#include <ege/resource/ParticuleMesh.h>
#include <ewol/resource/Manager.h>
#include <gale/resource/Manager.h>
#include <gale/renderer/openGL/openGL-include.h>
ege::resource::ParticuleMesh::ParticuleMesh() {
addObjectType("ege::resource::ParticuleMesh");
addResourceType("ege::resource::ParticuleMesh");
}
void ege::resource::ParticuleMesh::init(const std::string& _fileName, const std::string& _shaderName) {
@ -36,18 +37,18 @@ void ege::resource::ParticuleMesh::draw(mat4& _positionMatrix,
}
//EGE_DEBUG(m_name << " " << m_light);
if (_enableDepthTest == true) {
ewol::openGL::enable(ewol::openGL::FLAG_DEPTH_TEST);
gale::openGL::enable(gale::openGL::flag_depthTest);
if (false == _enableDepthUpdate) {
glDepthMask(GL_FALSE);
}
} else {
ewol::openGL::disable(ewol::openGL::FLAG_DEPTH_TEST);
gale::openGL::disable(gale::openGL::flag_depthTest);
}
//EGE_DEBUG(" display " << m_coord.size() << " elements" );
m_GLprogram->use();
// set Matrix : translation/positionMatrix
mat4 projMatrix = ewol::openGL::getMatrix();
mat4 camMatrix = ewol::openGL::getCameraMatrix();
mat4 projMatrix = gale::openGL::getMatrix();
mat4 camMatrix = gale::openGL::getCameraMatrix();
mat4 tmpMatrix = projMatrix * camMatrix;
m_GLprogram->uniformMatrix(m_GLMatrix, tmpMatrix);
m_GLprogram->uniformMatrix(m_GLMatrixPosition, _positionMatrix);
@ -72,7 +73,7 @@ void ege::resource::ParticuleMesh::draw(mat4& _positionMatrix,
}
m_materials[m_listFaces.getKey(kkk)]->draw(m_GLprogram, m_GLMaterial);
if (m_checkNormal == false) {
ewol::openGL::drawElements(GL_TRIANGLES, m_listFaces.getValue(kkk).m_index);
gale::openGL::drawElements(gale::openGL::render_triangle, m_listFaces.getValue(kkk).m_index);
#ifdef DISPLAY_NB_VERTEX_DISPLAYED
nbElementDraw += m_listFaces.getValue(kkk).m_index.size();
nbElementDrawTheoric += m_listFaces.getValue(kkk).m_index.size();
@ -108,7 +109,7 @@ void ege::resource::ParticuleMesh::draw(mat4& _positionMatrix,
}
}
}
ewol::openGL::drawElements(GL_TRIANGLES, tmpIndexResult);
gale::openGL::drawElements(gale::openGL::render_triangle, tmpIndexResult);
#ifdef DISPLAY_NB_VERTEX_DISPLAYED
nbElementDraw += tmpIndexResult.size();
nbElementDrawTheoric += m_listFaces.getValue(kkk).m_index.size();
@ -123,7 +124,7 @@ void ege::resource::ParticuleMesh::draw(mat4& _positionMatrix,
if (false == _enableDepthUpdate) {
glDepthMask(GL_TRUE);
}
ewol::openGL::disable(ewol::openGL::FLAG_DEPTH_TEST);
gale::openGL::disable(gale::openGL::flag_depthTest);
}
glBindBuffer(GL_ARRAY_BUFFER,0);
}

19
ege/widget/Mesh.cpp
View File

@ -8,7 +8,7 @@
#include <ege/widget/Mesh.h>
#include <ewol/widget/Manager.h>
#include <ewol/resource/Manager.h>
#include <gale/resource/Manager.h>
#include <ege/debug.h>
#undef __class__
@ -54,22 +54,19 @@ void ege::widget::Mesh::onDraw() {
}
void ege::widget::Mesh::systemDraw(const ewol::DrawProperty& _displayProp) {
ewol::openGL::push();
gale::openGL::push();
// here we invert the reference of the standard openGl view because the reference in the common display is Top left and not buttom left
glViewport( m_origin.x(),
m_origin.y(),
m_size.x(),
m_size.y());
gale::openGL::setViewPort(m_origin, m_size);
float ratio = m_size.x() / m_size.y();
//EGE_INFO("ratio : " << ratio);
mat4 tmpProjection = etk::matPerspective(M_PI/3.0, ratio, 0.5, 100);
//mat4 tmpMat = tmpProjection * m_camera.getMatrix();
// set internal matrix system :
//ewol::openGL::setMatrix(tmpMat);
ewol::openGL::setMatrix(tmpProjection);
gale::openGL::setMatrix(tmpProjection);
onDraw();
ewol::openGL::pop();
gale::openGL::pop();
}
void ege::widget::Mesh::onRegenerateDisplay() {
@ -85,8 +82,8 @@ void ege::widget::Mesh::periodicCall(const ewol::event::Time& _event) {
bool ege::widget::Mesh::onEventInput(const ewol::event::Input& _event) {
//EGE_DEBUG("Event on BT ...");
if (1 == _event.getId()) {
if(ewol::key::statusSingle == _event.getStatus()) {
if (_event.getId() == 1) {
if(_event.getStatus() == gale::key::status_single) {
signalPressed.emit();
return true;
}
@ -95,7 +92,7 @@ bool ege::widget::Mesh::onEventInput(const ewol::event::Input& _event) {
}
void ege::widget::Mesh::setFile(const std::string& _filename) {
if( _filename!=""
if( _filename != ""
&& m_meshName != _filename ) {
m_meshName = _filename;
m_object = ege::resource::Mesh::create(m_meshName);

13
ege/widget/Scene.cpp
View File

@ -12,7 +12,7 @@
#include <math.h>
#include <ege/debug.h>
#include <ewol/ewol.h>
#include <ewol/openGL/openGL.h>
#include <gale/renderer/openGL/openGL.h>
#include <etk/math/Matrix4.h>
#include <BulletDynamics/Dynamics/btRigidBody.h>
#include <LinearMath/btDefaultMotionState.h>
@ -168,20 +168,17 @@ void ege::widget::Scene::systemDraw(const ewol::DrawProperty& _displayProp) {
#ifdef SCENE_BRUT_PERFO_TEST
int64_t tmp___startTime0 = ewol::getTime();
#endif
glBindBuffer(GL_ARRAY_BUFFER,0);
ewol::openGL::push();
gale::openGL::bindBuffer(0);
gale::openGL::push();
// here we invert the reference of the standard openGl view because the reference in the common display is Top left and not buttom left
glViewport( m_origin.x(),
m_origin.y(),
m_size.x(),
m_size.y());
gale::openGL::setViewPort(m_origin, m_size);
// configure render with the camera...
std::shared_ptr<ege::Camera> camera = m_env->getCamera(m_cameraName);
if (camera != nullptr) {
camera->configureOpenGL();
}
onDraw();
ewol::openGL::pop();
gale::openGL::pop();
#ifdef SCENE_BRUT_PERFO_TEST
float tmp___localTime1 = (float)(ewol::getTime() - tmp___startTime0) / 1000.0f;
EWOL_DEBUG(" SCENE render : " << tmp___localTime1 << "ms ");

6
ege/widget/Scene.h
View File

@ -16,10 +16,10 @@
#include <ewol/debug.h>
#include <ege/camera/Camera.h>
#include <ewol/widget/Widget.h>
#include <ewol/openGL/openGL.h>
#include <ewol/resource/Manager.h>
#include <gale/renderer/openGL/openGL.h>
#include <gale/resource/Manager.h>
#include <ege/elements/Element.h>
#include <ewol/Dimension.h>
#include <gale/Dimension.h>
class btBroadphaseInterface;
class btCollisionShape;

2
sample/CameraPosition/appl/main.cpp
View File

@ -9,7 +9,7 @@
#include <etk/types.h>
#include <ewol/ewol.h>
#include <ewol/context/commandLine.h>
#include <gale/context/commandLine.h>
#include <appl/debug.h>
#include <appl/Windows.h>

2
sample/Collision/appl/main.cpp
View File

@ -9,7 +9,7 @@
#include <etk/types.h>
#include <ewol/ewol.h>
#include <ewol/context/commandLine.h>
#include <gale/context/commandLine.h>
#include <appl/debug.h>
#include <appl/Windows.h>

2
sample/DoubleView/appl/main.cpp
View File

@ -9,7 +9,7 @@
#include <etk/types.h>
#include <ewol/ewol.h>
#include <ewol/context/commandLine.h>
#include <gale/context/commandLine.h>
#include <appl/debug.h>
#include <appl/Windows.h>

2
sample/MeshCreator/appl/main.cpp
View File

@ -9,7 +9,7 @@
#include <etk/types.h>
#include <ewol/ewol.h>
#include <ewol/context/commandLine.h>
#include <gale/context/commandLine.h>
#include <appl/debug.h>
#include <appl/Windows.h>

2
sample/RayTest/appl/main.cpp
View File

@ -9,7 +9,7 @@
#include <etk/types.h>
#include <ewol/ewol.h>
#include <ewol/context/commandLine.h>
#include <gale/context/commandLine.h>
#include <appl/debug.h>
#include <appl/Windows.h>