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

[DEV] start rework interface OpenGl ==> all must be called by ewol::openGL namespace

Browse Source
This commit is contained in:
Edouard DUPIN 2014-11-24 22:09:20 +01:00
parent 0d23654379
commit 412cf41cef
11 changed files with 156 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
data/color3.frag
View File

@ -6,5 +6,5 @@ precision mediump int;
varying vec4 f_color;
void main(void) {
gl_FragColor = f_color;
gl_FragColor = f_color;
}

1
data/color3.vert
View File

@ -14,6 +14,5 @@ varying vec4 f_color;
void main(void) {
gl_Position = EW_MatrixTransformation * EW_MatrixPosition * vec4(EW_coord3d, 1.0);
//gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * vec4(EW_coord2d, 0.0, 1.0);
f_color = EW_color;
}

2
external/ege vendored

@ -1 +1 @@
Subproject commit e0f0c1d65b779382b3a3fd793fb074e377c9a5bc
Subproject commit c838fc6e3e6bb6e0419d7e45a8cd15a1794e617c

2
sources/ewol/context/Context.cpp
View File

@ -641,7 +641,7 @@ bool ewol::Context::OS_Draw(bool _displayEveryTime) {
m_FpsFlush.tic();
m_FpsFlush.incrementCounter();
}
glFlush();
ewol::openGL::flush();
//glFinish();
if (m_displayFps == true) {
m_FpsFlush.toc();

71
sources/ewol/openGL/openGL.cpp
View File

@ -12,6 +12,22 @@
#include <etk/stdTools.h>
#include <mutex>
//#define DIRECT_MODE
static void checkGlError(const char* _op, int32_t _localLine) {
bool isPresent = false;
for (GLint error = glGetError(); error; error = glGetError()) {
EWOL_ERROR("after " << _op << "():" << _localLine << " glError(" << error << ")");
isPresent = true;
}
if (isPresent == true) {
EWOL_CRITICAL("plop");
}
}
/**
* @brief get the draw mutex (ewol render).
* @note due ti the fact that the system can be called for multiple instance, for naw we just limit the acces to one process at a time.
@ -112,6 +128,10 @@ void ewol::openGL::finish() {
void ewol::openGL::flush() {
l_programId = -1;
l_textureflags = 0;
glFlush();
EWOL_ERROR("========================" );
EWOL_ERROR("== FLUSH OPEN GL ==" );
EWOL_ERROR("========================");
}
void ewol::openGL::swap() {
@ -415,3 +435,54 @@ void ewol::openGL::useProgram(int32_t _id) {
}
bool ewol::openGL::genBuffers(std::vector<GLuint>& _buffers) {
if (_buffers.size() == 0) {
EWOL_WARNING("try to generate vector buffer with size 0");
return true;
}
EWOL_VERBOSE("Create N=" << _buffers.size() << " Buffer");
glGenBuffers(_buffers.size(), &_buffers[0]);
checkGlError("glGenBuffers", __LINE__);
bool hasError = false;
for (size_t iii=0; iii<_buffers.size(); iii++) {
if (_buffers[iii] == 0) {
EWOL_ERROR("[" << iii << "] error to create a buffer id=" << _buffers[iii]);
hasError = true;
}
}
return hasError;
}
bool ewol::openGL::deleteBuffers(std::vector<GLuint>& _buffers) {
if (_buffers.size() == 0) {
EWOL_WARNING("try to delete vector buffer with size 0");
return true;
}
glDeleteBuffers(_buffers.size(), &_buffers[0]);
checkGlError("glDeleteBuffers", __LINE__);
for (auto &it : _buffers) {
it = 0;
}
return true;
}
bool ewol::openGL::bindBuffer(GLuint _bufferId) {
glBindBuffer(GL_ARRAY_BUFFER, _bufferId);
checkGlError("glBindBuffer", __LINE__);
return true;
}
bool ewol::openGL::bufferData(size_t _size, const void* _data, GLenum _usage) {
glBufferData(GL_ARRAY_BUFFER, _size, _data, _usage);
checkGlError("glBufferData", __LINE__);
return true;
}
bool ewol::openGL::unbindBuffer() {
glBindBuffer(GL_ARRAY_BUFFER, 0);
checkGlError("glBindBuffer(0)", __LINE__);
return true;
}

7
sources/ewol/openGL/openGL.h
View File

@ -191,6 +191,13 @@ namespace ewol {
*/
void useProgram(int32_t _id);
void reset();
bool genBuffers(std::vector<GLuint>& _buffers);
bool deleteBuffers(std::vector<GLuint>& _buffers);
bool bindBuffer(GLuint _bufferId);
bool bufferData(size_t _size, const void* _data, GLenum _usage);
bool unbindBuffer();
};
std::ostream& operator <<(std::ostream& _os, const enum openGL::openGlFlags& _obj);
std::ostream& operator <<(std::ostream& _os, const enum openGL::renderMode& _obj);

50
sources/ewol/resource/Program.cpp
View File

@ -107,9 +107,32 @@ ewol::resource::Program::~Program() {
m_hasTexture1 = false;
}
std::ostream& ewol::resource::operator <<(std::ostream& _os, const ewol::resource::progAttributeElement& _obj) {
_os << "{";
_os << "[" << _obj.m_name << "] ";
_os << _obj.m_elementId << " ";
_os << _obj.m_isLinked;
_os << "}";
return _os;
}
std::ostream& ewol::resource::operator <<(std::ostream& _os, const std::vector<ewol::resource::progAttributeElement>& _obj){
_os << "{";
for (auto &it : _obj) {
_os << it;
}
_os << "}";
return _os;
}
static void checkGlError(const char* _op, int32_t _localLine) {
bool isPresent = false;
for (GLint error = glGetError(); error; error = glGetError()) {
EWOL_INFO("after " << _op << "():" << _localLine << " glError(" << error << ")");
EWOL_ERROR("after " << _op << "():" << _localLine << " glError(" << error << ")");
isPresent = true;
}
if (isPresent == true) {
EWOL_CRITICAL("plop");
}
}
@ -138,8 +161,10 @@ int32_t ewol::resource::Program::getAttribute(std::string _elementName) {
tmp.m_isLinked = true;
if (tmp.m_elementId<0) {
checkGlError("glGetAttribLocation", __LINE__);
EWOL_WARNING("glGetAttribLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
EWOL_WARNING(" [" << m_elementList.size() << "] glGetAttribLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
tmp.m_isLinked = false;
} else {
EWOL_INFO(" [" << m_elementList.size() << "] glGetAttribLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
}
m_elementList.push_back(tmp);
return m_elementList.size()-1;
@ -159,8 +184,10 @@ int32_t ewol::resource::Program::getUniform(std::string _elementName) {
tmp.m_isLinked = true;
if (tmp.m_elementId<0) {
checkGlError("glGetUniformLocation", __LINE__);
EWOL_WARNING("glGetUniformLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
EWOL_WARNING(" [" << m_elementList.size() << "] glGetUniformLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
tmp.m_isLinked = false;
} else {
EWOL_INFO(" [" << m_elementList.size() << "] glGetUniformLocation(\"" << tmp.m_name << "\") = " << tmp.m_elementId);
}
m_elementList.push_back(tmp);
return m_elementList.size()-1;
@ -326,6 +353,7 @@ void ewol::resource::Program::sendAttribute(int32_t _idElem,
if (m_elementList[_idElem].m_isLinked == false) {
return;
}
EWOL_ERROR("[" << m_elementList[_idElem].m_name << "] send " << _nbElement << " element");
glVertexAttribPointer(m_elementList[_idElem].m_elementId, // attribute ID of openGL
_nbElement, // number of elements per vertex, here (r,g,b,a)
GL_FLOAT, // the type of each element
@ -352,16 +380,23 @@ void ewol::resource::Program::sendAttributePointer(int32_t _idElem,
if (false == m_elementList[_idElem].m_isLinked) {
return;
}
EWOL_INFO(m_elementList);
EWOL_ERROR("[" << m_elementList[_idElem].m_name << "] send " << _vbo->getElementSize(_index) << " element on oglID=" << _vbo->getGL_ID(_index) << " VBOindex=" << _index);
glBindBuffer(GL_ARRAY_BUFFER, _vbo->getGL_ID(_index));
checkGlError("glBindBuffer", __LINE__);
EWOL_ERROR(" id=" << m_elementList[_idElem].m_elementId);
EWOL_ERROR(" eleme size=" << _vbo->getElementSize(_index));
EWOL_ERROR(" jump sample=" << _jumpBetweenSample);
EWOL_ERROR(" offset=" << _offset);
glVertexAttribPointer(m_elementList[_idElem].m_elementId, // attribute ID of openGL
_vbo->getElementSize(_index), // number of elements per vertex, here (r,g,b,a)
GL_FLOAT, // the type of each element
GL_FALSE, // take our values as-is
_jumpBetweenSample, // no extra data between each position
(GLvoid *)_offset); // Pointer on the buffer
//checkGlError("glVertexAttribPointer", __LINE__);
checkGlError("glVertexAttribPointer", __LINE__);
glEnableVertexAttribArray(m_elementList[_idElem].m_elementId);
//checkGlError("glEnableVertexAttribArray", __LINE__);
checkGlError("glEnableVertexAttribArray", __LINE__);
}
//////////////////////////////////////////////////////////////////////////////////////////////
@ -377,10 +412,12 @@ void ewol::resource::Program::uniformMatrix(int32_t _idElem, const mat4& _matrix
if (false == m_elementList[_idElem].m_isLinked) {
return;
}
EWOL_ERROR("[" << m_elementList[_idElem].m_name << "] send 1 matrix");
// note : Android des not supported the transposition of the matrix, then we will done it oursef:
if (true == _transpose) {
mat4 tmp = _matrix;
tmp.transpose();
EWOL_ERROR("matrix:" << tmp);
glUniformMatrix4fv(m_elementList[_idElem].m_elementId, 1, GL_FALSE, tmp.m_mat);
} else {
glUniformMatrix4fv(m_elementList[_idElem].m_elementId, 1, GL_FALSE, _matrix.m_mat);
@ -443,6 +480,7 @@ void ewol::resource::Program::uniform4f(int32_t _idElem, float _value1, float _v
if (false == m_elementList[_idElem].m_isLinked) {
return;
}
EWOL_ERROR("[" << m_elementList[_idElem].m_name << "] send 4 values");
glUniform4f(m_elementList[_idElem].m_elementId, _value1, _value2, _value3, _value4);
//checkGlError("glUniform4f", __LINE__);
}
@ -572,6 +610,7 @@ void ewol::resource::Program::uniform3fv(int32_t _idElem, int32_t _nbElement, co
EWOL_ERROR("nullptr Input pointer to send at open GL ...");
return;
}
EWOL_ERROR("[" << m_elementList[_idElem].m_name << "] send " << _nbElement << " vec3");
glUniform3fv(m_elementList[_idElem].m_elementId, _nbElement, _value);
//checkGlError("glUniform3fv", __LINE__);
}
@ -594,6 +633,7 @@ void ewol::resource::Program::uniform4fv(int32_t _idElem, int32_t _nbElement, co
EWOL_ERROR("nullptr Input pointer to send at open GL ...");
return;
}
EWOL_ERROR("[" << m_elementList[_idElem].m_name << "] send " << _nbElement << " vec4");
glUniform4fv(m_elementList[_idElem].m_elementId, _nbElement, _value);
//checkGlError("glUniform4fv", __LINE__);
}

4
sources/ewol/resource/Program.h
View File

@ -33,6 +33,10 @@ namespace ewol {
bool m_isAttribute; //!< true if it was an attribute element, otherwite it was an uniform
bool m_isLinked; //!< if this element does not exist this is false
};
//! @not-in-doc
std::ostream& operator <<(std::ostream& _os, const ewol::resource::progAttributeElement& _obj);
//! @not-in-doc
std::ostream& operator <<(std::ostream& _os, const std::vector<ewol::resource::progAttributeElement>& _obj);
/**
* @brief Program is a compilation of some fragment Shader and vertex Shader. This construct automaticly this assiciation
* The input file must have the form : "myFile.prog"

15
sources/ewol/resource/Shader.cpp
View File

@ -55,7 +55,7 @@ ewol::resource::Shader::~Shader() {
static void checkGlError(const char* _op) {
for (GLint error = glGetError(); error; error = glGetError()) {
EWOL_INFO("after " << _op << "() glError (" << error << ")");
EWOL_ERROR("after " << _op << "() glError (" << error << ")");
}
}
#define LOG_OGL_INTERNAL_BUFFER_LEN (8192)
@ -70,13 +70,15 @@ void ewol::resource::Shader::updateContext() {
m_shader = 0;
return;
}
EWOL_INFO("Create Shader : '" << m_name << "'");
m_shader = glCreateShader(m_type);
if (!m_shader) {
EWOL_ERROR("glCreateShader return error ...");
checkGlError("glCreateShader");
EWOL_CRITICAL(" can not load shader");
return;
} else {
//EWOL_INFO("Creater shader with GLID=" << m_shader);
EWOL_INFO("Compile shader with GLID=" << m_shader);
glShaderSource(m_shader, 1, (const char**)&m_fileData, nullptr);
glCompileShader(m_shader);
GLint compiled = 0;
@ -95,6 +97,7 @@ void ewol::resource::Shader::updateContext() {
for (size_t iii=0 ; iii<lines.size() ; iii++) {
EWOL_ERROR("file " << (iii+1) << "|" << lines[iii]);
}
EWOL_CRITICAL(" can not load shader");
return;
}
}
@ -118,17 +121,17 @@ void ewol::resource::Shader::removeContextToLate() {
void ewol::resource::Shader::reload() {
etk::FSNode file(m_name);
if (false == file.exist()) {
EWOL_ERROR("File does not Exist : '" << file << "' : '" << file.getFileSystemName() << "'");
EWOL_CRITICAL("File does not Exist : '" << file << "' : '" << file.getFileSystemName() << "'");
return;
}
int64_t fileSize = file.fileSize();
if (0 == fileSize) {
EWOL_ERROR("This file is empty : " << file);
EWOL_CRITICAL("This file is empty : " << file);
return;
}
if (false == file.fileOpenRead()) {
EWOL_ERROR("Can not open the file : " << file);
EWOL_CRITICAL("Can not open the file : " << file);
return;
}
// remove previous data ...
@ -139,7 +142,7 @@ void ewol::resource::Shader::reload() {
// allocate data
m_fileData = new char[fileSize+5];
if (nullptr == m_fileData) {
EWOL_ERROR("Error Memory allocation size=" << fileSize);
EWOL_CRITICAL("Error Memory allocation size=" << fileSize);
return;
}
memset(m_fileData, 0, (fileSize+5)*sizeof(char));

34
sources/ewol/resource/VirtualBufferObject.cpp
View File

@ -16,16 +16,15 @@
void ewol::resource::VirtualBufferObject::init(int32_t _number) {
ewol::Resource::init();
m_nbVBO = std::avg(1, _number, NB_VBO_MAX);
for (size_t iii=0; iii<NB_VBO_MAX; iii++) {
m_vbo[iii]=0;
m_vboUsed[iii]=false;
m_vboSizeDataOffset[iii]=-1;
}
m_vbo.resize(_number, 0);
m_vboUsed.resize(_number, false);
m_buffer.resize(_number);
m_vboSizeDataOffset.resize(_number, 0);
EWOL_DEBUG("OGL : load VBO count=\"" << _number << "\"");
}
ewol::resource::VirtualBufferObject::VirtualBufferObject() {
ewol::resource::VirtualBufferObject::VirtualBufferObject() :
m_exist(false) {
addObjectType("ewol::VirtualBufferObject");
m_resourceLevel = 3;
}
@ -41,40 +40,33 @@ void ewol::resource::VirtualBufferObject::retreiveData() {
void ewol::resource::VirtualBufferObject::updateContext() {
if (false == m_exist) {
// Allocate and assign a Vertex Array Object to our handle
glGenBuffers(m_nbVBO, m_vbo);
ewol::openGL::genBuffers(m_vbo);
}
m_exist = true;
for (size_t iii=0; iii<m_nbVBO; iii++) {
for (size_t iii=0; iii<m_vbo.size(); iii++) {
EWOL_INFO("VBO : add [" << getId() << "]=" << m_buffer[iii].size() << "*sizeof(float) OGl_Id=" << m_vbo[iii]);
if (true == m_vboUsed[iii]) {
// select the buffer to set data inside it ...
if (m_buffer[iii].size()>0) {
glBindBuffer(GL_ARRAY_BUFFER, m_vbo[iii]);
glBufferData(GL_ARRAY_BUFFER, sizeof(float)*m_buffer[iii].size(), &((m_buffer[iii])[0]), GL_STATIC_DRAW);
ewol::openGL::bindBuffer(m_vbo[iii]);
ewol::openGL::bufferData(sizeof(float)*m_buffer[iii].size(), &((m_buffer[iii])[0]), GL_STATIC_DRAW);
}
}
}
// un-bind it to permet to have no erreor in the next display ...
glBindBuffer(GL_ARRAY_BUFFER, 0);
ewol::openGL::unbindBuffer();
}
void ewol::resource::VirtualBufferObject::removeContext() {
if (true == m_exist) {
EWOL_INFO("VBO: remove [" << getId() << "] OGl_Id=" << m_vbo[0]
<< "/" << m_vbo[1]
<< "/" << m_vbo[2]
<< "/" << m_vbo[3]);
glDeleteBuffers(m_nbVBO, m_vbo);
ewol::openGL::deleteBuffers(m_vbo);
m_exist = false;
for (size_t iii=0; iii<NB_VBO_MAX; iii++) {
m_vbo[iii] = 0;
}
}
}
void ewol::resource::VirtualBufferObject::removeContextToLate() {
m_exist = false;
for (size_t iii=0; iii<NB_VBO_MAX; iii++) {
for (size_t iii=0; iii<m_vbo.size(); iii++) {
m_vbo[iii] = 0;
}
}

12
sources/ewol/resource/VirtualBufferObject.h
View File

@ -16,9 +16,6 @@
#include <ewol/openGL/openGL.h>
#include <etk/Color.h>
// TODO : Remove this ...
#define NB_VBO_MAX (20)
namespace ewol {
namespace resource {
/**
@ -26,12 +23,11 @@ namespace ewol {
*/
class VirtualBufferObject : public ewol::Resource {
private :
size_t m_nbVBO;
bool m_exist; //!< This data is availlable in the Graphic card
GLuint m_vbo[NB_VBO_MAX]; //!< openGl ID of this VBO
bool m_vboUsed[NB_VBO_MAX]; //!< true if the VBO is allocated or used ...
std::vector<float> m_buffer[NB_VBO_MAX]; //!< data that is availlable in the VBO system ...
int8_t m_vboSizeDataOffset[NB_VBO_MAX]; //!< Internal size of the VBO (dynamicly set)
std::vector<GLuint> m_vbo; //!< openGl ID of this VBO
std::vector<bool> m_vboUsed; //!< true if the VBO is allocated or used ...
std::vector<std::vector<float>> m_buffer; //!< data that is availlable in the VBO system ...
std::vector<int8_t> m_vboSizeDataOffset; //!< Internal size of the VBO (dynamicly set)
protected:
/**
* @brief Constructor of this VBO.