diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 86eb1877450a061c0572c8f6f8a14f9c655c92b6..3f0ec8c5b67de4f89ed077b42dd4f27e31beb638 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -87,6 +87,7 @@ SET(VITE_HDRS
render/Geometry.hpp
render/Hook_event.hpp
render/Render_opengl.hpp
+ render/Render_alternate.hpp
render/Render_svg.hpp
render/render_stats.hpp
render/render_stats_opengl.hpp
@@ -166,6 +167,7 @@ SET(VITE_SRCS
render/Hook_event.cpp
render/Render.hpp
render/Render_opengl.cpp
+ render/Render_alternate.cpp
render/Render_svg.cpp
render/render_stats_opengl.cpp
render/render_stats_svg.cpp
diff --git a/src/common/info.cpp b/src/common/info.cpp
index 3bf559051cc3bf3c1636bf1b0f044d3e0de7ae44..33fd91fd9e9d79fb7c8e516c61ac55a844df93c5 100644
--- a/src/common/info.cpp
+++ b/src/common/info.cpp
@@ -47,32 +47,6 @@
#include "common/common.hpp"
#include "common/info.hpp"
-// void (Interface_console:: *Info::Core::launch_action)(int, void*) = NULL;
-// const int Info::Core::_STATE_UNKNOWN = -1;
-// const int Info::Core::_STATE_DISPLAY_HELP = 0;
-// const int Info::Core::_STATE_IN_AN_INTERVAL = 1; // 2^0
-// const int Info::Core::_STATE_OPEN_FILE = 2; // 2^1
-// const int Info::Core::_STATE_OPEN_FILE_IN_AN_INTERVAL = 3;
-// const int Info::Core::_STATE_EXPORT_FILE = 4; // 2^2
-// const int Info::Core::_STATE_EXPORT_FILE_IN_INTERVAL = 5;
-// const int Info::Core::_STATE_RELEASE_RENDER_AREA = 6;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_TRANSLATE = 7;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_SCALE = 8;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_CONTAINER_SCALE = 9;
-// const int Info::Core::_DRAW_OPENGL = 10;
-// const int Info::Core::_DRAW_SVG = 11;
-// const int Info::Core::_STATE_LAUNCH_GRAPHICAL_INTERFACE = 12;
-// const int Info::Core::_STATE_RENDER_AREA_REPLACE_SCALE = 13;
-// const int Info::Core::_STATE_RENDER_AREA_REPLACE_TRANSLATE = 14;
-// const int Info::Core::_STATE_RENDER_AREA_REPLACE_TRANSLATE_Y = 15;
-// const int Info::Core::_STATE_RENDER_AREA_REGISTERED_TRANSLATE = 16;
-// const int Info::Core::_STATE_RENDER_AREA_CHANGE_SCALE_Y = 17;
-// const int Info::Core::_STATE_AJUST_SCROLL_BARS = 18;
-// const int Info::Core::_STATE_REFRESH_SCROLL_BARS = 19;
-// const int Info::Core::_STATE_ZOOM_BOX_VALUE = 20;
-// const int Info::Core::_STATE_RENDER_DISPLAY_INFORMATION = 21;
-// const int Info::Core::_STATE_RENDER_UPDATE = 22;
-
unsigned int Info::Screen::width = 800;
unsigned int Info::Screen::height = 600;
@@ -101,5 +75,5 @@ Element_pos Info::Render::_info_accurate = 0.0;
bool Info::Render::_no_arrows = false;
bool Info::Render::_no_events = false;
-QLabel* Info::Render::_ui_render_min_value = NULL;
-QLabel* Info::Render::_ui_render_max_value = NULL;
+//QLabel* Info::Render::_ui_render_min_value = NULL;
+//QLabel* Info::Render::_ui_render_max_value = NULL;
diff --git a/src/common/info.hpp b/src/common/info.hpp
index 80abd64bb3f4ee59258914609eb958153cf4472d..5199c88d796a81b4934b90f87a07e499b15cb4b5 100644
--- a/src/common/info.hpp
+++ b/src/common/info.hpp
@@ -48,7 +48,7 @@
#define INFO_HPP
class Interface_console;
-class QLabel;
+//class QLabel;
/*!
* \brief Class used to store informations.
@@ -253,13 +253,13 @@ public:
* \brief This attribute is used to update the label which indicates
* the minimum visible trace value.
*/
- static QLabel* _ui_render_min_value;
+ //static QLabel* _ui_render_min_value;
/*!
* \brief This attribute is used to update the label which indicates
* the maximum visible trace value.
*/
- static QLabel* _ui_render_max_value;
+ //static QLabel* _ui_render_max_value;
};
diff --git a/src/core/Core.cpp b/src/core/Core.cpp
index c962507a129924165b65ab8ae90d7579314240aa..727a5cc19ffe03e318009492c2527e518403d2a3 100644
--- a/src/core/Core.cpp
+++ b/src/core/Core.cpp
@@ -45,8 +45,6 @@
*\brief This is the console interface C source code.
*/
-//#define WITH_OTF
-
#include <queue>
#include <string>
@@ -66,12 +64,9 @@
/* -- */
-
-#include "render/Render_opengl.hpp"
//#include "render/render.hpp"
#include "render/Render_svg.hpp"
#include "render/Render.hpp"
-//#include "render/Render_opengl_dl.hpp"
/* -- */
#include "trace/values/Values.hpp"
#include "trace/tree/Interval.hpp"
@@ -101,6 +96,13 @@
#include "core/Core.hpp"
#include "interface/parsing_thread.hpp"
/* -- */
+#ifdef WITH_VBO
+#include "render/Render_alternate.hpp"
+#else
+#include "render/Render_opengl.hpp"
+#endif
+
+
using namespace std;
#define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
@@ -211,13 +213,19 @@ bool Core::draw_trace(const string & filename, const int format){
Parser *parser;
DrawTrace drawing_ogl;
+
+#ifdef WITH_VBO
+ Render<Render_alternate> render(_render_opengl);
+#else
Render<Render_opengl> render(_render_opengl);
+#endif
+
QTime time_elapsed;
ostringstream buf_txt;
int time_buf;
time_buf = 0;
-
+
// Get the parser in function of the extension of the file
const unsigned int position_of_dot = filename.find_last_of('.');
@@ -254,6 +262,13 @@ bool Core::draw_trace(const string & filename, const int format){
if (NULL == _trace) { /* no trace is loaded, parse the file */
+
+ /* Init data */
+ Info::Entity::x_min = 0;
+ Info::Entity::x_max = 0;
+ Info::Render::_x_min_visible = 0;
+ Info::Render::_x_max_visible = 0;
+
_trace = new Trace();
// Init of the thread
@@ -633,12 +648,16 @@ void Core::launch_action(int state, void* arg) {
if ( _STATE_OPEN_FILE == state)
message << QObject::tr("Opening the file: ").toStdString ()+_file_opened << Message::endi;
-
+
_main_window = new Interface_graphic (this);/* launch the window interface */
Message::set_interface (_main_window);/* define which interface will receive messages */
// format.setOverlay(true);
+#ifdef WITH_VBO
+ _render_opengl = new Render_alternate (this, _main_window, format);
+#else
_render_opengl = new Render_opengl (this, _main_window, format);
+#endif
if ( NULL == _render_opengl){
message << QObject::tr("Cannot allocate memory for an OpengGL instance").toStdString () << Message::ende;
diff --git a/src/core/Core.hpp b/src/core/Core.hpp
index 3f524f6c4c1d0e00d032b2aad3e69728e7f04d91..8d32ffa43c40ae3b00d96dc31c5274afca92542f 100644
--- a/src/core/Core.hpp
+++ b/src/core/Core.hpp
@@ -47,9 +47,18 @@
#ifndef CORE_HPP
#define CORE_HPP
+
+//#define WITH_VBO
+
class Core;
class Interface_graphic;
+
+#ifdef WITH_VBO
+class Render_alternate;
+#else
class Render_opengl;
+#endif
+
class Render_svg;
class Trace;
#include "render/Render.hpp"
@@ -256,7 +265,11 @@ protected:
* \brief Contains the OpenGL render instance.
*/
/* MOD */
- Render_opengl* _render_opengl;
+#ifdef WITH_VBO
+ Render_alternate* _render_opengl;
+#else
+ Render_opengl* _render_opengl;
+#endif
//Render<Render_opengl>* _render_opengl;
/*!
diff --git a/src/interface/Interface_graphic.cpp b/src/interface/Interface_graphic.cpp
index 198264bf819d330dcf78c4524ea0c16909a72e61..05221b41ce17f619d085e2aa17e50619cac6b7a1 100644
--- a/src/interface/Interface_graphic.cpp
+++ b/src/interface/Interface_graphic.cpp
@@ -195,8 +195,8 @@ void Interface_graphic::load_windows(){
CKFP(_ui_zoom_box = qFindChild<QComboBox*>(this, "zoom_box"), "Cannot find the zoom box in the .ui file");
- CKFP(Info::Render::_ui_render_min_value = qFindChild<QLabel*>(this, "render_min_value"), "Cannot find the render_min_value label in the .ui file");
- CKFP(Info::Render::_ui_render_max_value = qFindChild<QLabel*>(this, "render_max_value"), "Cannot find the render_max_value label in the .ui file");
+ // CKFP(Info::Render::_ui_render_min_value = qFindChild<QLabel*>(this, "render_min_value"), "Cannot find the render_min_value label in the .ui file");
+ // CKFP(Info::Render::_ui_render_max_value = qFindChild<QLabel*>(this, "render_max_value"), "Cannot find the render_max_value label in the .ui file");
/* Export window */
CKFP(_ui_export_ok_button = qFindChild<QPushButton*>(_ui_time_selection_export, "option_export_ok"), "Cannot find the ok push button in the export dialog .ui file");
diff --git a/src/interface/main_window.ui b/src/interface/main_window.ui
index fb3400176a1fbcc1fd4ea7dfee75abd23865ec54..992022ded20ac7f4a0e4ff2af70fdf3ae70a42bd 100644
--- a/src/interface/main_window.ui
+++ b/src/interface/main_window.ui
@@ -28,55 +28,6 @@
</property>
<widget class="QWidget" name="centralwidget">
<layout class="QVBoxLayout" name="verticalLayout_2">
- <item>
- <layout class="QHBoxLayout" name="horizontalLayout">
- <item>
- <widget class="QLabel" name="render_min_value">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="text">
- <string/>
- </property>
- <property name="textFormat">
- <enum>Qt::RichText</enum>
- </property>
- </widget>
- </item>
- <item>
- <spacer name="horizontalSpacer">
- <property name="orientation">
- <enum>Qt::Horizontal</enum>
- </property>
- <property name="sizeHint" stdset="0">
- <size>
- <width>40</width>
- <height>20</height>
- </size>
- </property>
- </spacer>
- </item>
- <item>
- <widget class="QLabel" name="render_max_value">
- <property name="sizePolicy">
- <sizepolicy hsizetype="Preferred" vsizetype="Fixed">
- <horstretch>0</horstretch>
- <verstretch>0</verstretch>
- </sizepolicy>
- </property>
- <property name="text">
- <string/>
- </property>
- <property name="textFormat">
- <enum>Qt::RichText</enum>
- </property>
- </widget>
- </item>
- </layout>
- </item>
<item>
<layout class="QHBoxLayout" name="horizontalLayout_2">
<item>
@@ -235,7 +186,7 @@
<x>0</x>
<y>0</y>
<width>1060</width>
- <height>27</height>
+ <height>25</height>
</rect>
</property>
<widget class="QMenu" name="menuHelp">
diff --git a/src/render/Hook_event.cpp b/src/render/Hook_event.cpp
index 1eb0b26edb8e1c8149fba60dca4dd270e7703917..9a61d15ae6fd5ead4ddcf6b590621712dd2e3ba5 100644
--- a/src/render/Hook_event.cpp
+++ b/src/render/Hook_event.cpp
@@ -253,7 +253,7 @@ void Hook_event::mouseDoubleClickEvent ( QMouseEvent * event ){
void Hook_event::mouseMoveEvent(QMouseEvent * event){
- // if (!_mouse_pressed) return;
+ if (!_mouse_pressed) return;
_new_mouse_x = event->x();
_new_mouse_y = event->y();
diff --git a/src/render/Render.hpp b/src/render/Render.hpp
index 04eef9420f71368ac548e1cebf8ddac5850bc8d6..10e3bd1d5b614c17e0769912840ddf9f2c98e910 100755
--- a/src/render/Render.hpp
+++ b/src/render/Render.hpp
@@ -52,6 +52,7 @@
#include "render/Ruler.hpp"
#include "common/info.hpp"
+#include <GL/glut.h>
/*!
* \brief Structure used to store container information.
@@ -242,16 +243,20 @@ public:
}
drawing_instance->end_draw_containers();
+
}
+ static int bb;
+
/*!
* \brief Creates and opens the display list for state draws.
*/
inline void start_draw_states(){
drawing_instance->start_draw_states();
-
}
+
+
/*!
* \brief Draw a state of the trace.
* \param start the beginning time of the state.
@@ -262,18 +267,17 @@ public:
* \param g the green color rate of the state.
* \param b the blue color rate of the state.
*/
- inline void draw_state(const Element_pos start, const Element_pos end, const Element_pos base, const Element_pos height, const Element_col r, const Element_col g, const Element_col b) {
- // std::cout << __FILE__ << " " << __LINE__ << " -* " << trace_to_render_x(start) << " " << coeff_trace_render_x() << std::endl;
+ inline void draw_state(const Element_pos start, const Element_pos end, const Element_pos base, const Element_pos height, const Element_col r, const Element_col g, const Element_col b) {
+
drawing_instance->set_color(r, g, b);
- // drawing_instance->draw_quad(start, base, _z_state, end-start, height);
+
drawing_instance->draw_quad(trace_to_render_x(start - Info::Render::_x_min_visible),
trace_to_render_y(base),
_z_state,
(end-start)*coeff_trace_render_x(),
height*coeff_trace_render_y());
-
}
/*!
@@ -449,7 +453,6 @@ public:
*/
inline void end_draw(){
// std::cerr << __FILE__ << __LINE__ << " " << Info::Render::_x_min_visible << " " << Info::Render::_x_max_visible << std::endl;
-
/* Now, draw ruler */
Element_pos graduation_diff;
Element_pos coeff_prefix;
diff --git a/src/render/Render_alternate.cpp b/src/render/Render_alternate.cpp
new file mode 100755
index 0000000000000000000000000000000000000000..479780a7161afb58dbfbc40fe68170a705219385
--- /dev/null
+++ b/src/render/Render_alternate.cpp
@@ -0,0 +1,932 @@
+/*
+** This file is part of the ViTE project.
+**
+** This software is governed by the CeCILL-A license under French law
+** and abiding by the rules of distribution of free software. You can
+** use, modify and/or redistribute the software under the terms of the
+** CeCILL-A license as circulated by CEA, CNRS and INRIA at the following
+** URL: "http://www.cecill.info".
+**
+** As a counterpart to the access to the source code and rights to copy,
+** modify and redistribute granted by the license, users are provided
+** only with a limited warranty and the software's author, the holder of
+** the economic rights, and the successive licensors have only limited
+** liability.
+**
+** In this respect, the user's attention is drawn to the risks associated
+** with loading, using, modifying and/or developing or reproducing the
+** software by the user in light of its specific status of free software,
+** that may mean that it is complicated to manipulate, and that also
+** therefore means that it is reserved for developers and experienced
+** professionals having in-depth computer knowledge. Users are therefore
+** encouraged to load and test the software's suitability as regards
+** their requirements in conditions enabling the security of their
+** systems and/or data to be ensured and, more generally, to use and
+** operate it in the same conditions as regards security.
+**
+** The fact that you are presently reading this means that you have had
+** knowledge of the CeCILL-A license and that you accept its terms.
+**
+**
+** ViTE developers are (for version 0.* to 1.0):
+**
+** - COULOMB Kevin
+** - FAVERGE Mathieu
+** - JAZEIX Johnny
+** - LAGRASSE Olivier
+** - MARCOUEILLE Jule
+** - NOISETTE Pascal
+** - REDONDY Arthur
+** - VUCHENER Clément
+**
+*/
+/*!
+ *\file Render_alternate.cpp
+ */
+
+
+#include "common/common.hpp"
+#include "common/info.hpp"
+/* -- */
+//#include "render/render.hpp"
+
+#include <GL/glew.h>
+#include "render/Hook_event.hpp"
+
+#include "render/Render_alternate.hpp"
+/* -- */
+
+#include "interface/resource.hpp"
+//#include "interface/interface.hpp"
+#include "render/Render.hpp"
+#include "core/Core.hpp"
+/* -- */
+
+#include "vbo.hpp"
+
+
+using namespace std;
+
+
+#define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
+
+static bool _draw_container;
+static bool _draw_ruler;
+static bool _draw_arrow;
+static bool _draw_event;
+const int Render_alternate::DRAWING_TIMER_DEFAULT = 10;
+
+/***********************************
+ *
+ *
+ *
+ * Constructor and destructor.
+ *
+ *
+ *
+ **********************************/
+
+Render_alternate::Render_alternate(Core* core, QWidget *parent, const QGLFormat& format)
+ : Hook_event((Render_opengl*)this, core, parent, format){
+
+ _arrows.clear();
+ _circles.clear();
+ _texts.clear();
+ _vbos.clear();
+
+
+
+ setAutoFillBackground(false);
+}
+
+
+Render_alternate::~Render_alternate(){
+}
+
+/***********************************
+ *
+ *
+ *
+ * Default QGLWidget functions.
+ *
+ *
+ *
+ **********************************/
+
+void Render_alternate::initializeGL() {
+ glClearColor(0.5f, 0.5f, 0.55f, 1.0f);
+
+ glEnable(GL_DEPTH_TEST);
+
+ glClearStencil(0);
+}
+
+void Render_alternate::resizeGL(int width, int height) {
+ glViewport(0, 0, width, height);
+
+ /* update informations about widget size */
+ Info::Screen::width = width;
+ Info::Screen::height = height;
+
+ glMatrixMode(GL_PROJECTION);
+ glLoadIdentity();
+
+
+
+ if(DRAWING_STATE_WAITING == _state){// A wait is drawn
+ glOrtho(-50, 50, -50, 50, 0, 1000);
+ }else if (DRAWING_STATE_DRAWING == _state){// A trace is drawn
+ glOrtho(0, Info::Render::width, 0, Info::Render::height, 0, -1000);
+ }else{
+ message << tr("Undefined value for the drawing state attribute - Render area").toStdString() << Message::ende;
+ }
+
+
+ glMatrixMode(GL_MODELVIEW);
+}
+
+
+void Render_alternate::paintGL(){
+
+ resizeGL(Render_alternate::QGLWidget::width(), Render_alternate::QGLWidget::height());
+ Render_alternate::QGLWidget::setFocus(Qt::ActiveWindowFocusReason);/* give the focus to the render area for mouse and keyboard events */
+
+
+ glClearDepth(1.0);
+ glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+ glLoadIdentity();
+
+
+ if(DRAWING_STATE_WAITING == _state){/* A wait is drawn */
+
+ /* turn around y axis */
+ _wait_angle+=0.1f;
+ if (_wait_angle>=360) _wait_angle=0.0f;
+
+ glPushMatrix();
+
+ glScalef(15, 15, 0);
+
+ glRotatef(-_wait_angle,0, 1, 0);
+ glRotatef(_wait_angle_y, 1, 0, 0);
+
+
+ glPopMatrix();
+
+
+ }else if (DRAWING_STATE_DRAWING == _state){/* A trace is drawn */
+ glMatrixMode(GL_MODELVIEW);
+ glLoadIdentity();
+
+ glPushMatrix();
+ {
+ glTranslated(0.0, Info::Render::height, 100.0);
+ glRotated(180.0, 1.0, 0.0, 0.0);
+
+
+ glPushMatrix();
+ {
+
+ glTranslated(_default_entity_x_translate - _x_state_translate, _ruler_y + _ruler_height - _y_state_translate, 0.0);
+ glScalef(_x_state_scale, _y_state_scale, 1.0);
+
+ for (unsigned int i=0 ;
+ i<_vbos.size() ;
+ i++){
+ _vbos[i]->display();
+ }
+ }
+ glPopMatrix();
+
+ call_ruler();
+
+
+ if (false == Info::Render::_no_arrows)/* display arrows */
+ draw_stored_arrows();
+
+ if (false == Info::Render::_no_events)/* display events */
+ draw_stored_circles();
+
+ }
+ glPopMatrix();
+
+ glPushMatrix();
+ {
+ glTranslated(0.0, 0.0, 100.0);/* not accurate */
+
+ if (_mouse_pressed){
+
+
+ glTranslated(0.0, 0.0, _z_container_under);
+
+ Element_pos old_x, old_y, new_x, new_y;
+
+
+
+ old_x = _mouse_x*(Info::Render::width/Info::Screen::width);
+ old_y = Info::Render::height - _mouse_y*(Info::Render::height/Info::Screen::height);
+ new_x = _new_mouse_x*(Info::Render::width/Info::Screen::width);
+ new_y = Info::Render::height - _new_mouse_y*(Info::Render::height/Info::Screen::height);
+
+#ifdef DEBUG_MODE_RENDER_OPENGL
+
+ cerr << __FILE__ << " l." << __LINE__ << ":" << endl;
+ cerr << "Selection rectangle position: (" << old_x << ", " << old_y << ") - (" << new_x << ", " << new_y << ")" << endl;
+#endif
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ /* Square for selection */
+ glBegin(GL_QUADS);
+ {
+ glColor4d(0.9, 1.0, 0.9, _selection_rectangle_alpha);glVertex2d(old_x, old_y);
+ glColor4d(0.9, 0.9, 0.9, _selection_rectangle_alpha);glVertex2d(old_x, new_y);
+ glColor4d(0.9, 0.9, 0.9, _selection_rectangle_alpha);glVertex2d(new_x, new_y);
+ glColor4d(0.9, 0.9, 0.9, _selection_rectangle_alpha);glVertex2d(new_x, old_y);
+ }
+ glEnd();
+
+ glDisable(GL_BLEND);
+
+ }/* end if (true==_mouse_pressed) */
+ }
+ glPopMatrix();
+
+
+
+ }else{
+ message << tr("Undefined value for the drawing state attribute - Render area").toStdString() << Message::ende;
+ }
+
+ glFlush();
+
+
+ /* Check the errors */
+ GLenum glerror;
+ glerror = glGetError();
+ if(glerror != GL_NO_ERROR)
+ message << tr("Render area : the following OpengGL error occured: ").toStdString() << (char *)gluErrorString(glerror) << Message::endw;
+
+
+
+ if(DRAWING_STATE_WAITING == _state)/* A wait is drawn, do not take car about the ruler drawing */
+ return;
+
+ QFont arial_font = QFont("Arial", 10);
+ qglColor(Qt::white);//QColor(0, 0, 0));
+
+
+ /* Draw container text */
+ const unsigned int texts_size = _texts.size();
+ for (unsigned int i=0 ; i<texts_size ; i++){
+ const QFontMetrics metric(arial_font);
+ const QString text_elided = metric.elidedText(_texts[i].value.c_str(), Qt::ElideRight, _x_scale_container_state*Info::Screen::width/3.);
+ renderText ( render_to_screen_x(_texts[i].x * _x_scale_container_state/0.20),
+ render_to_screen_y( trace_to_render_y(_texts[i].y) + 0.5),
+ text_elided,
+ arial_font);
+ }
+
+ /* Draw ruler text */
+ std::ostringstream buf_txt;
+ Element_pos graduation_diff;
+ Element_pos coeff_prefix;
+ graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+ coeff_prefix = Ruler::get_coeff_for_common_prefix(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+
+ // painter.setFont(QFont("Arial", 14));
+
+ arial_font.setPointSize(14);
+
+ buf_txt.str("");/* flush the buffer */
+ buf_txt << "min: " << (double)Info::Render::_x_min_visible;
+
+ renderText (render_to_screen_x(trace_to_render_x(Info::Render::_x_min_visible)),
+ render_to_screen_y(3),
+ buf_txt.str().c_str(),
+ arial_font);
+
+ buf_txt.str("");/* flush the buffer */
+ buf_txt << "max: " << (double)Info::Render::_x_max_visible;
+
+ renderText (render_to_screen_x(trace_to_render_x(Info::Render::_x_max_visible))-130,
+ render_to_screen_y(3),
+ buf_txt.str().c_str(),
+ arial_font);
+
+ buf_txt.str("");
+ buf_txt << Ruler::get_common_part_string(Info::Render::_x_min_visible, coeff_prefix) << "--";
+
+ renderText (render_to_screen_x(
+ trace_to_render_x(
+ (Info::Render::_x_min_visible +
+ Info::Render::_x_max_visible) / 2)),
+ render_to_screen_y(3),
+ buf_txt.str().c_str(),
+ arial_font);
+
+ arial_font.setPointSize(10);
+
+ for (Element_pos i = Info::Render::_x_min_visible ;
+ i < Info::Render::_x_max_visible ;
+ i+=graduation_diff){
+
+ buf_txt.str("");/* flush the buffer */
+ buf_txt << Ruler::get_variable_part(i, coeff_prefix, 2);
+
+ renderText (render_to_screen_x(trace_to_render_x(i)+1),
+ render_to_screen_y(8),
+ buf_txt.str().c_str(),
+ arial_font);
+ }
+}
+
+
+
+
+
+/***********************************
+ *
+ *
+ *
+ * Building functions.
+ *
+ *
+ *
+ **********************************/
+
+
+
+bool Render_alternate::build(){
+
+ _state = DRAWING_STATE_DRAWING;/* change the drawing state */
+
+ /* disable some OpenGL features to enhance the rendering */
+ glDisable(GL_TEXTURE_2D);
+ glDisable(GL_BLEND);
+
+ replace_scale(1);/* for states scaling */
+ _x_state_translate = 0;/* for states translation */
+ _y_state_scale = 1;/* for states scaling */
+ _y_state_translate = 0;/* for states translation */
+ _x_scroll_pos = 0;/* horizontal bar placed on 0 */
+ _y_scroll_pos = 0;/* vertical bar placed on 0 */
+
+ if (NULL == _render_instance)
+ return true;
+
+ return true;
+}
+
+
+
+bool Render_alternate::unbuild(){
+
+ /**********************
+ *
+ * Init OpenGL features
+ *
+ **********************/
+
+ /* enable some OpenGL features*/
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+ glEnable(GL_TEXTURE_2D);
+
+ glEnable(GL_BLEND);/* enable blending for the alpha color */
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+ glColor3d(1.0, 1.0, 1.0);/* init color to white */
+
+
+ /*****************************
+ *
+ * Init render area attributes
+ *
+ *****************************/
+
+ _state = DRAWING_STATE_WAITING;/* change the drawing state */
+
+ _wait_angle=0.0f;/* begin with 0 rad angle */
+ _wait_angle_y=0.0f;/* begin with 0 rad angle */
+
+ /* init measurement attributes */
+ Info::Container::x_max = 0;
+ Info::Container::y_max = 0;
+ Info::Container::x_min = 0;
+ Info::Container::y_min = 0;
+
+ // Info::Render::_ui_render_min_value->setText("");
+ // Info::Render::_ui_render_max_value->setText("");
+
+ Info::Entity::x_max = 0;
+ Info::Entity::x_min = 0;
+ // _state_x_max = 0;
+ _state_y_max = 0;
+ // _state_x_min = 0;
+ _state_y_min = 0;
+
+ /* clear lists to store container texts */
+ _text_pos.clear();
+ _text_value.clear();
+
+ _arrows.clear();
+ _circles.clear();
+ _texts.clear();
+
+ for (unsigned int i=0 ;
+ i<_vbos.size() ;
+ i++){
+ delete _vbos[i];
+ }
+ _vbos.clear();
+
+ /* clear the event vector */
+ // _events.clear();
+
+ /* clear the arrow vector */
+ // _arrows.clear();
+
+ /* empty the selection stack */
+ while(false == _previous_selection.empty())
+ _previous_selection.pop();
+
+ if (NULL == _render_instance)
+ return true;
+
+ /* Now, timer is set */
+ if (_wait_timer == NULL){
+ _wait_angle = 0.0f;
+
+ /* _wait_timer = new QTimer(this);
+ connect(_wait_timer, SIGNAL(timeout()), _render_instance, SLOT(updateGL()));
+ _wait_timer->start(_wait_spf);*/
+ }
+
+
+ return true;//_render_instance->display_unbuild();
+}
+
+
+
+
+
+/***********************************
+ *
+ *
+ *
+ * Drawing function for the wait screen.
+ *
+ *
+ *
+ **********************************/
+
+
+
+GLuint Render_alternate::draw_wait() {
+ GLuint object;
+ GLuint texture;
+
+ glGenTextures(1, &texture);/* create the texture and link it with the list previously created */
+
+ QFile texture_file(QString(":/img/img/logo") + QDate::currentDate().toString("MMdd") + QString(".png"));
+
+ if (true == texture_file.exists())/* The texture exists */
+ texture = bindTexture(QPixmap(texture_file.fileName()), GL_TEXTURE_2D);
+ else/* use the default picture */
+ texture = bindTexture(QPixmap(":/img/img/logo.png"), GL_TEXTURE_2D);
+
+
+ /* apply some parameters on the texture */
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+ glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+
+ glEnable(GL_TEXTURE_2D);
+
+ glEnable(GL_BLEND);/* enable blending for the alpha color */
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+
+ /* Now, timer is set */
+ if (_wait_timer == NULL){
+ _wait_angle = 0.0f;
+ /*
+ _wait_timer = new QTimer(this);
+ connect(_wait_timer, SIGNAL(timeout()), _render_instance, SLOT(updateGL()));
+ _wait_timer->start(_wait_spf);*/
+ }
+
+ return object;
+}
+
+
+
+
+
+void Render_alternate::call_ruler(){
+ Element_pos graduation_diff;
+ Element_pos coeff_prefix;
+ const Element_pos offset_x = _default_entity_x_translate;
+ const Element_pos offset_y = _ruler_y + _ruler_height+3.5;
+
+ update_visible_interval_value();
+
+ graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+ coeff_prefix = Ruler::get_coeff_for_common_prefix(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+
+ set_color(1.0, 1.0, 1.0);
+
+ for (Element_pos i = Info::Render::_x_min_visible ; i < Info::Render::_x_max_visible ; i+=graduation_diff){
+ const Element_pos grad_div_by_5 = graduation_diff/5;
+ for (Element_pos j = (i+grad_div_by_5) ; j<(i+graduation_diff) ; j+= grad_div_by_5){
+ draw_line( trace_to_render_x(j) + offset_x, offset_y ,
+ trace_to_render_x(j) + offset_x, 2+offset_y, _z_ruler);
+ }
+
+ draw_line( trace_to_render_x(i) + offset_x, offset_y-1 ,
+ trace_to_render_x(i) + offset_x, 4+offset_y, _z_ruler);
+ }
+
+ glBegin(GL_QUADS);
+ {
+ glColor4d(0.0, 0.0, 1.0, 0.8);
+ glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 0, _z_ruler_under );
+ glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 8, _z_ruler_under );
+ glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 8, _z_ruler_under );
+ glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 0, _z_ruler_under );
+ }
+ glEnd();
+
+ glBegin(GL_QUADS);
+ {
+ glColor4d(0.0, 0.0, 0.0, 1.0);
+ glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 0, _z_ruler_over );
+ glVertex3d(trace_to_render_x(Info::Render::_x_min_visible) , 3, _z_ruler_over );
+ glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 3, _z_ruler_over );
+ glVertex3d(trace_to_render_x(Info::Render::_x_max_visible) , 0, _z_ruler_over );
+ }
+ glEnd();
+
+ return;
+}
+
+
+
+void Render_alternate::set_color(float r, float g, float b){
+ _red = r;
+ _green = g;
+ _blue = b;
+}
+
+void Render_alternate::draw_text(const Element_pos x, const Element_pos y, const Element_pos, const std::string s){
+ if (_draw_ruler) return;/* do not draw text for ruler */
+
+ Container_text_ buf;
+
+ buf.x = x;
+ buf.y = render_to_trace_y(y);/* Cancel previous transformation. */
+ buf.value = s;
+
+ _texts.push_back(buf);
+}
+
+
+void Render_alternate::draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h){
+ int state;
+ Element_pos data[8];
+
+ Element_pos offset_x;
+ const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+ offset_x = 0;
+
+ if (!_draw_container)
+ offset_x = -_default_entity_x_translate;
+
+ data[0] = x + offset_x;
+ data[1] = y + offset_y;
+ data[2] = x + offset_x;
+ data[3] = y + h + offset_y;
+ data[4] = x + w + offset_x;
+ data[5] = y + h + offset_y;
+ data[6] = x + w + offset_x;
+ data[7] = y + offset_y;
+
+ state = Vbo::VBO_OK;
+
+ if(NULL != _current_vbo)
+ state = _current_vbo->add(8, data);
+
+ if (Vbo::VBO_OUT_OF_MEMORY == state){
+ /* Store the current vbo */
+ _vbos.push_back(_current_vbo);
+
+ /* Create a new vbo */
+ _current_vbo = NULL;/* DO NOT DEALLOCATE BEFORE! */
+ _current_vbo = new Vbo(100000, _current_vbo->QUADS);
+
+ if (NULL == _current_vbo)
+ message << tr("Cannot create a Vbo for states.").toStdString() << Message::ende;
+ }
+
+ /*
+ glBegin(GL_QUADS);
+ {
+ glColor3d(_red, _green, _blue);
+ glVertex3d(x + offset_x , y + offset_y , z );
+ glVertex3d(x + offset_x , y + h + offset_y, z );
+ glColor3d(_red/1.5 , _green/1.5 , _blue/1.5);
+ glVertex3d(x + w + offset_x, y + h + offset_y, z );
+ glVertex3d(x + w + offset_x, y + offset_y , z );
+ }
+ glEnd();*/
+}
+
+void Render_alternate::draw_triangle(Element_pos , Element_pos ,
+ Element_pos , Element_pos ){
+}
+
+void Render_alternate::draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z){
+ if (_draw_ruler || _draw_arrow || _draw_event) return;/* do not draw line for ruler or for arrow or for event */
+
+
+ const Element_pos offset_x = -_default_entity_x_translate;
+ const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+ glBegin(GL_LINES);
+ {
+ glColor3d(_red, _green, _blue);
+ glVertex3d(x1 + offset_x, y1 + offset_y, z);
+ glVertex3d(x2 + offset_x, y2 + offset_y, z);
+ }
+ glEnd();
+}
+
+void Render_alternate::draw_circle(Element_pos /*x*/, Element_pos /*y*/, Element_pos /*z*/, Element_pos /*r*/){
+}
+
+
+void Render_alternate::start_draw(){
+ /* Init GLEW */
+ glewInit();
+ _draw_ruler = false;
+ _draw_container = false;
+ _draw_arrow = false;
+ _draw_event = false;
+
+ _current_vbo = NULL;
+
+}
+
+void Render_alternate::start_draw_containers(){
+ _list_containers = glGenLists(1);/* create the list */
+ if (_list_containers == 0) {
+ *Message::get_instance() << tr("Error when creating list.").toStdString() << Message::endw;
+ }
+
+ glNewList(_list_containers, GL_COMPILE);/* open the list */
+ _draw_container = true;
+}
+
+void Render_alternate::draw_container(const Element_pos , const Element_pos , const Element_pos , const Element_pos ){
+
+}
+
+void Render_alternate::draw_container_text(const Element_pos , const Element_pos , const std::string ){
+}
+
+void Render_alternate::end_draw_containers(){
+ _draw_container = false;
+ glEndList();/* close the list */
+}
+
+void Render_alternate::start_draw_states(){
+ _current_vbo = NULL;
+ _current_vbo = new Vbo((1<<20), _current_vbo->QUADS);/* Allocate 1 MiB */
+
+ if (NULL == _current_vbo)
+ message << tr("Cannot create a Vbo for states.").toStdString() << Message::ende;
+}
+
+void Render_alternate::draw_state(const Element_pos , const Element_pos , const Element_pos , const Element_pos , const Element_col , const Element_col , const Element_col ){
+}
+
+void Render_alternate::end_draw_states(){
+
+ _vbos.push_back(_current_vbo);
+}
+
+void Render_alternate::start_draw_arrows(){
+ _draw_arrow = true;
+
+}
+
+void Render_alternate::draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height, const Element_col red, const Element_col green, const Element_col blue){
+
+ Arrow_ buf;
+ const Element_pos offset_x = -_default_entity_x_translate;
+ const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+ buf.start_time = start_time + offset_x;
+ buf.end_time = end_time + offset_x;
+ buf.start_height = start_height + offset_y;
+ buf.end_height = end_height + offset_y;
+ buf.red = red;
+ buf.green = green;
+ buf.blue = blue;
+
+ _arrows.push_back(buf);
+}
+
+void Render_alternate::end_draw_arrows(){
+ _draw_arrow = false;
+}
+
+void Render_alternate::start_draw_events(){
+ _draw_event = true;
+}
+
+void Render_alternate::draw_event(const Element_pos time, const Element_pos height, const Element_pos container_height){
+ Event_ buf;
+ const Element_pos offset_x = -_default_entity_x_translate;
+ const Element_pos offset_y = -_ruler_y - _ruler_height;
+
+ buf.time = time + offset_x;
+ buf.height = height + offset_y;
+ buf.container_height = container_height + offset_y;
+ buf.red = _red;
+ buf.green = _green;
+ buf.blue = _blue;
+
+ _circles.push_back(buf);
+}
+
+
+void Render_alternate::end_draw_events(){
+ _draw_event = false;
+}
+
+void Render_alternate::start_draw_counter(){
+}
+
+void Render_alternate::draw_counter(const Element_pos , const Element_pos ){
+}
+
+void Render_alternate::end_draw_counter(){
+}
+
+void Render_alternate::start_ruler(){
+ _draw_ruler = true;
+}
+
+void Render_alternate::end_ruler(){
+ _draw_ruler = false;
+}
+
+void Render_alternate::end_draw(){
+}
+
+
+void Render_alternate::draw_stored_texts(){
+}
+
+void Render_alternate::draw_stored_arrows(){
+
+ /* Only draw triangle. Lines are already in a display list */
+ const Element_pos coeff = 180.0f/M_PI;
+ Element_pos angle;
+ Element_pos start_time, end_time, start_height, end_height;
+ Element_pos scaled_start_time, scaled_end_time, scaled_start_height, scaled_end_height;
+
+
+
+ const unsigned int arrow_size = _arrows.size();
+ for (unsigned int i=0 ; i<arrow_size ; i++){
+
+ start_time = _arrows[i].start_time;// + _x_state_scale*_x_state_translate;
+ end_time = _arrows[i].end_time;// + _x_state_scale*_x_state_translate;
+ start_height = _arrows[i].start_height;
+ end_height = _arrows[i].end_height;
+
+ set_color(_arrows[i].red, _arrows[i].green, _arrows[i].blue);
+
+ scaled_start_time = start_time * _x_state_scale;
+ scaled_end_time = end_time * _x_state_scale;
+ scaled_start_height = start_height * _y_state_scale;
+ scaled_end_height = end_height * _y_state_scale;
+
+ glPushMatrix();
+ {
+
+ glTranslated(_default_entity_x_translate + _x_state_scale*end_time - _x_state_translate,
+ _ruler_y + _ruler_height + _y_state_scale*end_height - _y_state_translate,
+ _z_arrow);
+
+ if (start_time != end_time){
+ angle = atan2((scaled_end_height - scaled_start_height), (scaled_end_time - scaled_start_time))*coeff;/* arc tangent */
+ glRotatef(angle, 0, 0, 1);
+ }
+ else
+ glRotatef(90, 0, 0, 1);/* vertical alignment */
+
+ glBegin(GL_TRIANGLES);
+ {
+ // glColor3d(_red, _green, _blue);
+ glVertex2d(0.0, 0.0);
+ glVertex2d(-1.2, -0.4);
+ glVertex2d(-1.2, 0.4);
+ }
+ glEnd();
+
+ }
+ glPopMatrix();
+
+ glPushMatrix();
+ {
+
+ glTranslated(_default_entity_x_translate - _x_state_translate,
+ _ruler_y + _ruler_height - _y_state_translate,
+ _z_arrow);
+ glScalef(_x_state_scale, _y_state_scale, 1.0);
+
+ glBegin(GL_LINES);
+ {
+ glVertex2d(start_time, start_height);
+ glVertex2d(end_time , end_height );
+ }
+ glEnd();
+ }
+ glPopMatrix();
+ }
+}
+
+void Render_alternate::draw_stored_circles(){
+ const int step = 20;/* 20 polygons for the circle */
+ const float angle = M_PI/2.0f;
+ const float delta_angle = 2*M_PI/step;
+ const float radius = .5f;
+
+ const unsigned int size = _circles.size();
+
+ for (unsigned int i=0 ; i<size ; i++){
+
+ glPushMatrix();
+ {
+
+ set_color(1.0 - _circles[i].red, 1.0 - _circles[i].green, 1.0 - _circles[i].blue);
+
+ glTranslated(_default_entity_x_translate - _x_state_translate,
+ _ruler_y + _ruler_height - _y_state_translate,
+ _z_arrow);
+
+ glScalef(_x_state_scale, _y_state_scale, 1.0);
+
+ /* Draw the circle */
+
+ glBegin(GL_POLYGON);
+ {
+ for(int j = 0 ; j < step ; j ++){
+ glVertex2d(_circles[i].time + cos(angle+delta_angle*j)*radius/_x_state_scale,
+ _circles[i].height + sin(angle+delta_angle*j)*(radius/_y_state_scale)*Info::Screen::width/Info::Screen::height);
+ }
+ }
+ glEnd();
+
+
+ set_color(_circles[i].red, _circles[i].green, _circles[i].blue);
+
+ /* Draw the sub-circle */
+ glBegin(GL_POLYGON);
+ {
+ for(int j = 0 ; j < step ; j ++){
+ glVertex3d(_circles[i].time + cos(angle+delta_angle*j)*radius/(1.2*_x_state_scale) ,
+ _circles[i].height + sin(angle+delta_angle*j)*radius/(1.2*_y_state_scale)*Info::Screen::width/Info::Screen::height ,
+ 0.1);
+ }
+ }
+ glEnd();
+
+
+ glLineWidth( 3.0 );
+ /* Draw the line */
+ glBegin(GL_LINES);
+ {
+ glVertex2d(_circles[i].time, _circles[i].height);
+ glVertex2d(_circles[i].time, _circles[i].height+_circles[i].container_height);
+ }
+ glEnd();
+
+ glLineWidth( 1.0 );
+
+
+ }
+ glPopMatrix();
+ }
+
+ set_color(1.0, 1.0, 1.0);
+
+}
+
diff --git a/src/render/Render_alternate.hpp b/src/render/Render_alternate.hpp
new file mode 100755
index 0000000000000000000000000000000000000000..68f083903cb0e524cdeb8bf0963abb54e47892e2
--- /dev/null
+++ b/src/render/Render_alternate.hpp
@@ -0,0 +1,567 @@
+/*
+** This file is part of the ViTE project.
+**
+** This software is governed by the CeCILL-A license under French law
+** and abiding by the rules of distribution of free software. You can
+** use, modify and/or redistribute the software under the terms of the
+** CeCILL-A license as circulated by CEA, CNRS and INRIA at the following
+** URL: "http://www.cecill.info".
+**
+** As a counterpart to the access to the source code and rights to copy,
+** modify and redistribute granted by the license, users are provided
+** only with a limited warranty and the software's author, the holder of
+** the economic rights, and the successive licensors have only limited
+** liability.
+**
+** In this respect, the user's attention is drawn to the risks associated
+** with loading, using, modifying and/or developing or reproducing the
+** software by the user in light of its specific status of free software,
+** that may mean that it is complicated to manipulate, and that also
+** therefore means that it is reserved for developers and experienced
+** professionals having in-depth computer knowledge. Users are therefore
+** encouraged to load and test the software's suitability as regards
+** their requirements in conditions enabling the security of their
+** systems and/or data to be ensured and, more generally, to use and
+** operate it in the same conditions as regards security.
+**
+** The fact that you are presently reading this means that you have had
+** knowledge of the CeCILL-A license and that you accept its terms.
+**
+**
+** ViTE developers are (for version 0.* to 1.0):
+**
+** - COULOMB Kevin
+** - FAVERGE Mathieu
+** - JAZEIX Johnny
+** - LAGRASSE Olivier
+** - MARCOUEILLE Jule
+** - NOISETTE Pascal
+** - REDONDY Arthur
+** - VUCHENER Clément
+**
+*/
+/*!
+ *\file Render_alternate.hpp
+ */
+
+#ifndef RENDER_OPENGL_HPP
+#define RENDER_OPENGL_HPP
+
+#include <QGLWidget>
+
+#include "core/Core.hpp"
+#include "render/Hook_event.hpp"
+#include "render/Render_template.hpp"
+
+class Render_alternate;
+class Interface_console;
+struct Container_text_;
+class Vbo;
+
+/*!
+ * \brief Structure used to store arrow information.
+ */
+struct Arrow_{
+ /*!
+ * \brief Coordinates.
+ */
+ Element_pos start_time, end_time, start_height, end_height;
+ /*!
+ * \brief Colors.
+ */
+ Element_col red, green, blue;
+};
+
+/*!
+ * \brief Structure used to store event information.
+ */
+struct Event_{
+ /*!
+ * \brief Coordinates and radius.
+ */
+ Element_pos time, height, container_height;
+ /*!
+ * \brief Colors.
+ */
+ Element_col red, green, blue;
+};
+
+
+/*!
+ * \brief This class redefined the OpenGL widget - QGLWidget - to display the trace.
+ */
+class Render_alternate : /*public QGLWidget,*/ public Hook_event, public Render_template
+{
+ Q_OBJECT
+
+protected:
+
+ /*!
+ * \brief Contains the parent instance.
+ */
+ Core* _core;
+
+ /*!
+ * \brief The waiting screen display list.
+ */
+ GLuint _wait_list;
+
+
+ /*!
+ * \brief The container GLu list.
+ */
+ GLuint _list_containers;
+
+ /*!
+ * \brief The state GLu list.
+ */
+ GLuint _list_states;
+
+ /*!
+ * \brief The counter GLu list.
+ */
+ GLuint _list_counters;
+
+
+ /*!
+ * \brief The wait GLu list.
+ */
+ // GLuint _wait_list;
+
+ float _red, _green, _blue;
+
+ std::vector<Container_text_> _texts;
+ std::vector<Arrow_> _arrows;
+ std::vector<Event_> _circles;
+
+
+ /***********************************
+ *
+ * The wait screen drawing.
+ *
+ **********************************/
+
+ /***********************************
+ * The wait list Attributes.
+ **********************************/
+
+
+ /*!
+ * \brief Rotation angle for the wait.
+ */
+ float _wait_angle;
+
+ /*!
+ * \brief Y rotation angle for the wait.
+ */
+ float _wait_angle_y;
+
+ /*!
+ * \brief Time in ms between two frames for the waiting screen.
+ */
+ static const int DRAWING_TIMER_DEFAULT;
+
+ /*!
+ * \brief Wait animation seconds per frame.
+ */
+ int _wait_spf;
+
+
+ Vbo* _current_vbo;
+ std::vector<Vbo*> _vbos;
+
+ /*!
+ * \brief Timer to animate the wait.
+ */
+ QTimer* _wait_timer;
+
+public:
+
+ /***********************************
+ *
+ * Constructor and destructor.
+ *
+ **********************************/
+
+ /*!
+ * \brief The default constructor
+ */
+ Render_alternate(Core* core, QWidget *parent, const QGLFormat& format);
+
+ /*!
+ * \brief The destructor
+ */
+ virtual ~Render_alternate();
+
+ /*!
+ * \brief Set Statistics and Informations about input trace
+ */
+ void set_total_width(Element_pos){}
+
+ /*!
+ * \brief Set Statistics and Informations about input trace
+ */
+ void set_total_time(Times){}
+
+ /*!
+ * \brief display the scale
+ */
+ void display_time_scale(){}
+
+
+ /***********************************
+ *
+ * Default QGLWidget functions.
+ *
+ **********************************/
+
+ /*!
+ * \brief Call by the system to initialize the OpenGL render area.
+ */
+ void initializeGL();
+
+ /*!
+ * \brief Call by the system when the render area was resized (occurs during a window resizement).
+ * \param width : the new width of the render area.
+ * \param height : the new height of the render area.
+ */
+ void resizeGL(int width, int height);
+
+ /*!
+ * \brief Call by the system each time the render area need to be updated.
+ */
+ void paintGL();
+
+ //void paintEvent(QPaintEvent *event);
+
+ /* void initializeOverlayGL();
+ void resizeOverlayGL(int width, int height);
+ void paintOverlayGL();*/
+
+
+ /***********************************
+ *
+ * Building functions.
+ *
+ **********************************/
+
+ /*!
+ * \brief This function constructs the trace.
+ */
+ // bool display_build() ;
+
+ /*!
+ * \brief This function releases the trace.
+ */
+ // bool display_unbuild() ;
+
+ /*!
+ * \brief Proceeds with the initialization of the OpenGL draw functions.
+ */
+ void start_draw();
+
+ /*!
+ * \brief Creates and opens the display list for container draws.
+ */
+ void start_draw_containers();
+
+ /*!
+ * \brief Draw a container according to the parameters
+ * \param x the x position of the container
+ * \param y the y position of the container
+ * \param w the width of the container
+ * \param h the height of the container
+ */
+ void draw_container(const Element_pos x, const Element_pos y, const Element_pos w, const Element_pos h);
+
+ /*!
+ * \brief Draw the text of a container.
+ * \param x the x position of the text.
+ * \param y the y position of the text.
+ * \param value the string value of the text.
+ *
+ * This function stores text in a list. This list will be display each time the render area need to be updated.
+ */
+ void draw_container_text(const Element_pos x, const Element_pos y, const std::string value);
+
+ /*!
+ * \brief Closes the container display list.
+ */
+ void end_draw_containers();
+
+ /*!
+ * \brief Creates and opens the display list for stater draws.
+ */
+ void start_draw_states();
+
+ /*!
+ * \brief Draw a state of the trace.
+ * \param start the beginning time of the state.
+ * \param end the ending time of the state.
+ * \param base vertical position of the state.
+ * \param height the state height.
+ * \param r the red color rate of the state.
+ * \param g the green color rate of the state.
+ * \param b the blue color rate of the state.
+ */
+ void draw_state(const Element_pos start , const Element_pos end, const Element_pos base, const Element_pos height, const Element_col r, const Element_col g, const Element_col b);
+
+ /*!
+ * \brief Closes the state display list.
+ */
+ void end_draw_states();
+
+ /*!
+ * \brief Open the arrow display list.
+ */
+ void start_draw_arrows();
+
+ /*!
+ * \brief Draw an arrow.
+ * \param start_time the beginning time of the arrow.
+ * \param end_time the ending time of the arrow.
+ * \param start_height vertical position of the begining time of the arrow.
+ * \param end_height vertical position of the ending time of the arrow.
+ *
+ * This function stores all the information of the arrow to display it each time the render area need to be updated.
+ */
+ void draw_arrow(const Element_pos start_time, const Element_pos end_time, const Element_pos start_height, const Element_pos end_height,const Element_col red, const Element_col green, const Element_col blue);
+
+ /*!
+ * \brief Closes the arrow display list.
+ */
+ void end_draw_arrows();
+
+ /*!
+ * \brief Draw arrows contained in the Arrow_ vector
+ * \param arrows An arrow vector.
+ */
+ // void draw_stored_arrows(std::vector<Arrow_> &arrows);
+
+ void start_draw_events();
+
+ /*!
+ * \brief Draw an event.
+ * \param time time when the event occurs.
+ * \param height vertical position of the event.
+ * \param container_height information to draw event. It corresponds to the container height when they are drawn horizontally.
+ *
+ *
+ * \brief Creates and opens the display list for container draws.
+ *
+ * This function stores all the information of the event to display it each time the render area need to be updated.
+ */
+ void draw_event(const Element_pos time, const Element_pos height, const Element_pos container_height);
+
+ void end_draw_events();
+
+
+ /*!
+ * \brief Draw events contained in the Event_ vector
+ * \param events An event vector.
+ */
+ // void draw_stored_events(std::vector<Event_> &events);
+
+ /*!
+ * \brief Creates and opens the display list for counter draws.
+ */
+ void start_draw_counter();
+
+ /*!
+ * \brief Draw a point of the counter.
+ * \param x x position of the point.
+ * \param y y position of the point.
+ *
+ * Each time counter is increased, this function is called with the coordinates of the new point.
+ */
+ void draw_counter(const Element_pos x, const Element_pos y);
+
+ /*!
+ * \brief Closes the counter display list.
+ */
+ void end_draw_counter();
+
+ /*!
+ * \brief Called before ruler drawing.
+ */
+ void start_ruler();
+
+ /*!
+ * \brief Called after ruler drawing.
+ */
+ void end_ruler();
+
+
+ /*!
+ * \brief Do nothing (it is present for compatibility of the Render class).
+ */
+ void end_draw();
+
+
+
+ /***********************************
+ *
+ * Render OpenGL drawing functions.
+ *
+ **********************************/
+
+ /*!
+ * \brief Display a wait on the screen if there is no file opened.
+ * \return Asset value of the wait.
+ */
+ GLuint draw_wait();
+
+ /*!
+ * \brief Draw the ruler display list.
+ */
+ void call_ruler();
+
+
+
+ /***********************************
+ *
+ * Building functions.
+ *
+ **********************************/
+
+ /*!
+ * \brief This function draws the trace.
+ */
+ bool build();
+
+ /*!
+ * \brief This function releases the trace.
+ */
+ bool unbuild();
+
+ /***********************************
+ *
+ * Displaying functions.
+ *
+ **********************************/
+
+ // /*!
+// * \brief Display on screen containers between container_begin and container_end.
+// * \param container_begin integer value : id of the first container.
+// * \param container_end integer value : id of the last container.
+// */
+// void display_container(Element_count container_begin, Element_count container_end) =0;
+
+// /*!
+// * \brief Display on screen states between timer_begin and time_end,
+// * container_begin and container_end and with timer width between depth_begin and depth_end.
+// * \param time_begin floating point value : time of the first state.
+// * \param time_end floating point value : time of the last state.
+// * \param container_begin integer value : id of the first container.
+// * \param container_end integer value : id of the last container.
+// * \param depth_begin floating point value : width of the narrowest state.
+// * \param depth_end floating point value : width of the widest state.
+// */
+// void display_state(Element_pos time_begin, Element_pos time_end,
+// Element_count container_begin, Element_count container_end,
+// Element_pos depth_begin, Element_pos depth_end) =0;
+
+// /*!
+// * \brief Display on screen arrows between timer_begin and time_end,
+// * container_begin and container_end and with timer width between depth_begin and depth_end.
+// * \param time_begin floating point value : time of the smallest arrow time value.
+// * \param time_end floating point value : time of the higher arrow time value.
+// * \param container_begin integer value : id of the first container.
+// * \param container_end integer value : id of the last container.
+// * \param depth_begin floating point value : the narrowest difference between
+// * the beginning time and the ending time of the arrow.
+// * \param depth_end floating point value : width of the widest difference between
+// * the beginning time and the ending time of the arrow.
+// */
+// virtual void display_arrow(Element_pos time_begin, Element_pos time_end,
+// Element_count container_begin, Element_count container_end,
+// Element_pos depth_begin, Element_pos depth_end) =0;
+
+// /*!
+// * \brief Display on screen events between timer_begin and time_end,
+// * container_begin and container_end.
+// * \param time_begin floating point value : time of the first event.
+// * \param time_end floating point value : time of the last event.
+// * \param container_begin integer value : id of the first container.
+// * \param container_end integer value : id of the last container.
+// */
+// virtual void display_event(Element_pos time_begin, Element_pos time_end,
+// Element_count container_begin, Element_count container_end) =0;
+
+// /*!
+// * \brief Display on screen counters between timer_begin and time_end,
+// * container_begin and container_end.
+// * \param time_begin floating point value : time of the smallest counter time value.
+// * \param time_end floating point value : time of the higher counter time value.
+// * \param container_begin integer value : id of the first container.
+// * \param container_end integer value : id of the last container.
+// */
+// virtual void display_counter(Element_pos time_begin, Element_pos time_end,
+// Element_count container_begin, Element_count container_end) =0;
+
+ /*!
+ * \brief Set the color for the further drawings.
+ * \param r the red value. Within [0 ; 1].
+ * \param g the green value. Within [0 ; 1].
+ * \param b the blue value. Within [0 ; 1].
+ */
+ void set_color(float r, float g, float b);
+
+ /*!
+ * \brief Draw a text.
+ * \param x the horizontal position of the left bottom corner of the text.
+ * \param y the vertical position of the left bottom corner of the text.
+ * \param z the deep position of the text.
+ * \param s the text.
+ */
+ virtual void draw_text(const Element_pos x, const Element_pos y, const Element_pos z, const std::string s);
+
+ /*!
+ * \brief Draw a quad.
+ * \param x the horizontal position of the left bottom corner of the quad.
+ * \param y the vertical position of the left bottom corner of the quad.
+ * \param z the deep position of the quad.
+ * \param w the width of the quad.
+ * \param h the height of the quad.
+ */
+ void draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h);
+
+ /*!
+ * \brief Draw a triangle.
+ * \param x the horizontal position of the triangle center.
+ * \param y the vertical position of the triangle center.
+ * \param size the edge size.
+ * \param r the rotation of triangle. (clockwise and in degree)
+ */
+ void draw_triangle(Element_pos x, Element_pos y,
+ Element_pos size, Element_pos r);
+
+ /*!
+ * \brief Draw a line.
+ * \param x1 the horizontal position of the first point.
+ * \param y1 the vertical position of the firt point.
+ * \param x2 the horizontal position of the second point.
+ * \param y2 the vertical position of the second point.
+ * \param z the deep position of the triangle.
+ */
+ void draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z);
+
+ /*!
+ * \brief Draw a circle.
+ * \param x the horizontal position of the circle center.
+ * \param y the vertical position of the circle center.
+ * \param z the deep position of the circle.
+ * \param r the circle radius.
+ */
+ void draw_circle(Element_pos x, Element_pos y, Element_pos z, Element_pos r);
+
+ /* Temporary methods. Use to draw stored arrows and circles. It is to prevent scaling */
+ void draw_stored_arrows();
+ void draw_stored_circles();
+
+ void draw_stored_texts();
+};
+
+
+
+#endif
diff --git a/src/render/Render_opengl.cpp b/src/render/Render_opengl.cpp
index 7629099d2941ae32561b34ef589857d3ca9cac39..1f3578c46e7f26370570e172f3f40eaf15e6aa63 100644
--- a/src/render/Render_opengl.cpp
+++ b/src/render/Render_opengl.cpp
@@ -63,10 +63,6 @@ using namespace std;
#define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
-static bool _draw_container;
-static bool _draw_ruler;
-static bool _draw_arrow;
-static bool _draw_event;
const int Render_opengl::DRAWING_TIMER_DEFAULT = 10;
/***********************************
@@ -204,76 +200,47 @@ void Render_opengl::paintGL(){
glTranslated(0.0, Info::Render::height, 100.0);
glRotated(180.0, 1.0, 0.0, 0.0);
-
-
- // display_container(0, 0);
glPushMatrix();
- {
-
- /* Translate containers and entities of the ruler height */
- // glTranslated(0.0, _ruler_height, 0.0);
- // glTranslated(- _x_state_translate, -_y_state_translate, 0.0);
-
+ {
glTranslatef(0.0f, _ruler_y + _ruler_height -_y_state_translate, 0.0);
- // glScalef( (Info::Render::width/Info::Container::x_max)*_x_scale_container_state, _y_state_scale*(Info::Render::height-_ruler_height)/Info::Container::y_max, 0.0f);
-
glScalef(_x_scale_container_state/0.20, _y_state_scale, 1.0);
-
if (glIsList(_list_containers) == GL_FALSE)
*Message::get_instance() << tr("ERROR LIST not exist for containers.").toStdString() << Message::ende;
else
glCallList(_list_containers);
-
-
}
glPopMatrix();
-
glPushMatrix();
{
-
- glTranslated(_default_entity_x_translate - _x_state_translate, _ruler_y + _ruler_height - _y_state_translate, 0.0);
-
-
- glScalef(_x_state_scale, _y_state_scale, 1.0);
+ glTranslated(_default_entity_x_translate - _x_state_translate, _ruler_y + _ruler_height - _y_state_translate, _z_state);
+ glScalef(_x_state_scale, _y_state_scale, 1);
- if (glIsList(_list_states) == GL_FALSE)
+ if (glIsList(_list_states) == GL_FALSE)
*Message::get_instance() << tr("ERROR LIST not exist for states.").toStdString() << Message::ende;
- else
+ else{
glCallList(_list_states);
+ glCallList(_list_counters);
+ }
}
glPopMatrix();
+ if (false == Info::Render::_no_arrows)/* display arrows */
+ draw_stored_arrows();
- // draw_stored_texts();
- call_ruler();
-
-
-// display_state(0, 0, 0, 0, 0, 0);
-
- if (false == Info::Render::_no_arrows)/* display arrows */
- draw_stored_arrows();
-// display_arrow(0, 0, 0, 0, 0, 0);
-
- if (false == Info::Render::_no_events)/* display events */
- draw_stored_circles();
-// display_event(0, 0, 0, 0);
-
-// display_counter(0, 0, 0, 0);
-
+ if (false == Info::Render::_no_events)/* display events */
+ draw_stored_circles();
/* Untranslate ruler */
- /* glTranslated(0.0, -_ruler_height, 0.0);
-
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
call_ruler();
- glDisable(GL_BLEND);*/
+ glDisable(GL_BLEND);
}
glPopMatrix();
-
+
glPushMatrix();
{
glTranslated(0.0, 0.0, 100.0);/* not accurate */
@@ -334,6 +301,11 @@ void Render_opengl::paintGL(){
+
+ if(DRAWING_STATE_WAITING == _state)/* A wait is drawn, do not take car about the ruler drawing */
+ return;
+
+
QFont arial_font = QFont("Arial", 10);
qglColor(Qt::white);//QColor(0, 0, 0));
@@ -486,8 +458,8 @@ bool Render_opengl::unbuild(){
Info::Container::x_min = 0;
Info::Container::y_min = 0;
- Info::Render::_ui_render_min_value->setText("");
- Info::Render::_ui_render_max_value->setText("");
+ // Info::Render::_ui_render_min_value->setText("");
+ // Info::Render::_ui_render_max_value->setText("");
Info::Entity::x_max = 0;
Info::Entity::x_min = 0;
@@ -619,6 +591,7 @@ void Render_opengl::call_ruler(){
graduation_diff = Ruler::get_graduation_diff(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
coeff_prefix = Ruler::get_coeff_for_common_prefix(Info::Render::_x_min_visible, Info::Render::_x_max_visible);
+ set_color(1.0, 1.0, 1.0);
for (Element_pos i = Info::Render::_x_min_visible ; i < Info::Render::_x_max_visible ; i+=graduation_diff){
const Element_pos grad_div_by_5 = graduation_diff/5;
@@ -660,12 +633,11 @@ void Render_opengl::set_color(float r, float g, float b){
_red = r;
_green = g;
_blue = b;
-
- glColor3d(_red, _green, _blue);
}
void Render_opengl::draw_text(const Element_pos x, const Element_pos y, const Element_pos, const std::string s){
if (_draw_ruler) return;/* do not draw text for ruler */
+ if (_draw_state) message << "Fatal error! Cannot put text in state lists!" << Message::ende;
Container_text_ buf;
@@ -677,23 +649,23 @@ void Render_opengl::draw_text(const Element_pos x, const Element_pos y, const El
}
-void Render_opengl::draw_quad(Element_pos x, Element_pos y, Element_pos z, Element_pos w, Element_pos h){
+void Render_opengl::draw_quad(Element_pos x, Element_pos y, Element_pos /*z*/, Element_pos w, Element_pos h){
Element_pos offset_x;
- const Element_pos offset_y = -_ruler_y - _ruler_height;
+ Element_pos offset_y = -_ruler_y - _ruler_height;
offset_x = 0;
if (!_draw_container)
offset_x = -_default_entity_x_translate;
-
- glBegin(GL_QUADS);
+
+ glBegin(GL_QUADS);
{
glColor3d(_red, _green, _blue);
- glVertex3d(x + offset_x , y + offset_y , z );
- glVertex3d(x + offset_x , y + h + offset_y, z );
- glColor3d(_red/1.5 , _green/1.5 , _blue/1.5);
- glVertex3d(x + w + offset_x, y + h + offset_y, z );
- glVertex3d(x + w + offset_x, y + offset_y , z );
+ glVertex2d(x + offset_x , y + offset_y);
+ glVertex2d(x + offset_x , y + h + offset_y);
+ glColor3d(_red/1.5 , _green/1.5 , _blue/1.5);
+ glVertex2d(x + w + offset_x, y + h + offset_y);
+ glVertex2d(x + w + offset_x, y + offset_y);
}
glEnd();
}
@@ -704,7 +676,7 @@ void Render_opengl::draw_triangle(Element_pos , Element_pos ,
void Render_opengl::draw_line(Element_pos x1, Element_pos y1, Element_pos x2, Element_pos y2, Element_pos z){
if (_draw_ruler || _draw_arrow || _draw_event) return;/* do not draw line for ruler or for arrow or for event */
-
+ if (_draw_state) message << "Fatal error! Cannot put line in state lists!" << Message::ende;
const Element_pos offset_x = -_default_entity_x_translate;
const Element_pos offset_y = -_ruler_y - _ruler_height;
@@ -724,10 +696,11 @@ void Render_opengl::draw_circle(Element_pos /*x*/, Element_pos /*y*/, Element_po
void Render_opengl::start_draw(){
- _draw_ruler = false;
_draw_container = false;
- _draw_arrow = false;
- _draw_event = false;
+ _draw_state = false;
+ _draw_ruler = false;
+ _draw_arrow = false;
+ _draw_event = false;
}
@@ -736,9 +709,9 @@ void Render_opengl::start_draw_containers(){
if (_list_containers == 0) {
*Message::get_instance() << tr("Error when creating list.").toStdString() << Message::endw;
}
-
+
+ _draw_container = true;
glNewList(_list_containers, GL_COMPILE);/* open the list */
- _draw_container = true;
}
void Render_opengl::draw_container(const Element_pos , const Element_pos , const Element_pos , const Element_pos ){
@@ -758,7 +731,8 @@ void Render_opengl::start_draw_states(){
if (_list_states == 0) {
*Message::get_instance() << tr("Error when creating list.").toStdString() << Message::endw;
}
-
+
+ _draw_state = true;
glNewList(_list_states, GL_COMPILE);/* open the list */
}
@@ -766,7 +740,8 @@ void Render_opengl::draw_state(const Element_pos , const Element_pos , const Ele
}
void Render_opengl::end_draw_states(){
-
+ glEndList();/* close the states list */
+ _draw_state = false;
}
void Render_opengl::start_draw_arrows(){
@@ -819,12 +794,19 @@ void Render_opengl::end_draw_events(){
}
void Render_opengl::start_draw_counter(){
+ _list_counters = glGenLists(1);/* create the list */
+ if (_list_counters == 0) {
+ *Message::get_instance() << tr("Error when creating list").toStdString() << Message::ende;
+ }
+
+ glNewList(_list_counters, GL_COMPILE);/* open the list */
}
void Render_opengl::draw_counter(const Element_pos , const Element_pos ){
}
void Render_opengl::end_draw_counter(){
+ glEndList();/* close the list */
}
void Render_opengl::start_ruler(){
@@ -836,7 +818,6 @@ void Render_opengl::end_ruler(){
}
void Render_opengl::end_draw(){
- glEndList();/* close the states list */
}
@@ -861,7 +842,7 @@ void Render_opengl::draw_stored_arrows(){
start_height = _arrows[i].start_height;
end_height = _arrows[i].end_height;
- set_color(_arrows[i].red, _arrows[i].green, _arrows[i].blue);
+ glColor3d(_arrows[i].red, _arrows[i].green, _arrows[i].blue);
scaled_start_time = start_time * _x_state_scale;
scaled_end_time = end_time * _x_state_scale;
@@ -926,7 +907,7 @@ void Render_opengl::draw_stored_circles(){
glPushMatrix();
{
- set_color(1.0 - _circles[i].red, 1.0 - _circles[i].green, 1.0 - _circles[i].blue);
+ glColor3d(1.0 - _circles[i].red, 1.0 - _circles[i].green, 1.0 - _circles[i].blue);
glTranslated(_default_entity_x_translate - _x_state_translate,
_ruler_y + _ruler_height - _y_state_translate,
@@ -946,7 +927,7 @@ void Render_opengl::draw_stored_circles(){
glEnd();
- set_color(_circles[i].red, _circles[i].green, _circles[i].blue);
+ glColor3d(_circles[i].red, _circles[i].green, _circles[i].blue);
/* Draw the sub-circle */
glBegin(GL_POLYGON);
@@ -975,8 +956,5 @@ void Render_opengl::draw_stored_circles(){
}
glPopMatrix();
}
-
- set_color(1.0, 1.0, 1.0);
-
}
diff --git a/src/render/Render_opengl.hpp b/src/render/Render_opengl.hpp
index 308eb79d75ca1fbc60c0d9cadca7c21a1468eb4b..330271b2b8db63723bbf8ccf67734893ab22a023 100644
--- a/src/render/Render_opengl.hpp
+++ b/src/render/Render_opengl.hpp
@@ -94,6 +94,15 @@ class Render_opengl : /*public QGLWidget,*/ public Hook_event, public Render_te
{
Q_OBJECT
+
+ private:
+
+ bool _draw_container;
+ bool _draw_state;
+ bool _draw_ruler;
+ bool _draw_arrow;
+ bool _draw_event;
+
protected:
/*!
@@ -166,6 +175,8 @@ protected:
*/
int _wait_spf;
+
+
/*!
* \brief Timer to animate the wait.
*/
diff --git a/src/render/vbo.cpp b/src/render/vbo.cpp
index becd421293f34eb2cc6bb2e16e649134608485f4..9d7853e8bf9738e06d64e90c5e4cc6e7b2c50c06 100644
--- a/src/render/vbo.cpp
+++ b/src/render/vbo.cpp
@@ -43,14 +43,15 @@
/*!
*\file vbo.cpp
*/
-
-#include "common/common.hpp"
-/* -- */
-#include "render/vbo.hpp"
-/* -- */
-using namespace std;
+ #include <GL/glew.h>
+#include <stdlib.h>
+#include <iostream>
+#include "vbo.hpp"
-#define message *Message::get_instance() << "(" << __FILE__ << " l." << __LINE__ << "): "
+
+#define ERROR(m) printf("%s", m);
+
+using namespace std;
const int Vbo::VBO_OK = 0;
const int Vbo::VBO_OUT_OF_MEMORY = 1;
@@ -70,7 +71,7 @@ Vbo::Vbo(){
}
-Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum client_state){
+Vbo::Vbo(int nb_object, Type object_type){
/* init class attributes */
@@ -79,13 +80,25 @@ Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum c
_id = 0;
_nb_object = nb_object;
- _nb_verteces_per_object = nb_verteces_per_object;
+
+ switch (object_type){
+ case TRIANGLES:
+ _nb_verteces_per_object = 3;
+ _object_type = GL_TRIANGLES;
+ break;
+ case QUADS:
+ _nb_verteces_per_object = 4;
+ _object_type = GL_QUADS;
+ break;
+ case LINES:
+ _nb_verteces_per_object = 2;
+ _object_type = GL_LINES;
+ }
/* There is _nb_object*(number_of_vertices_per_object) elements. */
- _size = _nb_coordinates_per_vertex*nb_verteces_per_object*_nb_object;
+ _size = _nb_coordinates_per_vertex*_nb_verteces_per_object*_nb_object;
- _object_type = object_type;
- _client_state = client_state;
+ _client_state = GL_VERTEX_ARRAY;
/* init OpenGL */
@@ -94,7 +107,7 @@ Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum c
glBindBuffer(GL_ARRAY_BUFFER, _id);/* select our vbo */
- glBufferData(GL_ARRAY_BUFFER, _size*sizeof(Element_pos), NULL, GL_STREAM_DRAW);/* allocate memory space inside graphic card */
+ glBufferData(GL_ARRAY_BUFFER, _size*sizeof(Data_type), NULL, GL_STREAM_DRAW);/* allocate memory space inside graphic card */
glBindBuffer(GL_ARRAY_BUFFER, 0);/* deselect our vbo */
@@ -102,7 +115,7 @@ Vbo::Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum c
Vbo::~Vbo(){
- glDeleteBuffers(1, &_id);/* release the buffer and free its memory inside graphic card */
+ glDeleteBuffers(1, &_id);/* release the buffer and free its memory inside the graphic card */
_id = 0;
}
@@ -119,7 +132,7 @@ Vbo::~Vbo(){
*
**********************************/
-int Vbo::fill_buffer(const unsigned int data_size, const Element_pos* const data){
+int Vbo::add(const unsigned int data_size, const Data_type* const data){
glBindBuffer(GL_ARRAY_BUFFER, _id);/* select our vbo */
@@ -132,7 +145,7 @@ int Vbo::fill_buffer(const unsigned int data_size, const Element_pos* const dat
if ( (_cur+data_size) <= _size){
- glBufferSubData(GL_ARRAY_BUFFER, _cur*sizeof(Element_pos), data_size*sizeof(Element_pos), data);
+ glBufferSubData(GL_ARRAY_BUFFER, _cur*sizeof(Data_type), data_size*sizeof(Data_type), data);
_cur += data_size;
}else{
@@ -148,7 +161,7 @@ int Vbo::fill_buffer(const unsigned int data_size, const Element_pos* const dat
int Vbo::get_remaining_size() const{
- return (_size-_cur);
+ return (_size-_cur)/(_nb_verteces_per_object*_nb_coordinates_per_vertex);
}
@@ -164,7 +177,7 @@ int Vbo::get_remaining_size() const{
*
**********************************/
-void Vbo::display_buffer() const{
+void Vbo::display() const{
glBindBuffer(GL_ARRAY_BUFFER, _id);/* select our vbo */
@@ -212,48 +225,5 @@ void Vbo::display_buffer() const{
void Vbo::display_info(){
GLvoid* _read_buf = NULL;
-
- message << "*** Display VBO info ***" << Message::endi;
-
- message << "Id: " << _id << Message::endi;
-
- message << "Current position inside vbo: " << _cur << Message::endi;
-
- message << "Coordinates per vertex: " << _nb_coordinates_per_vertex << Message::endi;
-
- message << "Verteces per object: " << _nb_verteces_per_object << Message::endi;
-
- message << "Max objects per vertex buffer: " << _nb_object << Message::endi;
-
- message << "Max size of the vbo (verteces_per_object * nb_object * sizeof(Element_pos)) in Bytes: " << _size*sizeof(Element_pos) << Message::endi;
-
- message << "Object type: " << _object_type << Message::endi;
-
- message << "Client state: " << _client_state << Message::endi;
-
-
- /* Now, read the video memory */
- message << Message::endi << Message::endi << "Display memory data: " << Message::endi;
-
- glBindBuffer(GL_ARRAY_BUFFER, _id);
-
- _read_buf = glMapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
- if (NULL == _read_buf){
- message << "Cannot access data" << Message::endi;
- }
- else{
- for (unsigned int i = 0 ; i< _cur ; i++)
- message << ((Element_pos*)_read_buf)[i] << Message::endi;
-
- message << "End display memory data" << Message::endi;
- if (GL_FALSE == glUnmapBuffer(GL_ARRAY_BUFFER)){
- message << "Cannot unmap the vbo" << Message::ende;
- }
- else{
- _read_buf = NULL;
- }
- }
-
- glBindBuffer(GL_ARRAY_BUFFER, 0);
-
+
}
diff --git a/src/render/vbo.hpp b/src/render/vbo.hpp
index f85e0e67384360bf37963742d662bd3795fea954..28fac022e13235d16fa65e49b3eb0377ef5becbe 100644
--- a/src/render/vbo.hpp
+++ b/src/render/vbo.hpp
@@ -47,6 +47,12 @@
#ifndef VBO_HPP
#define VBO_HPP
+
+typedef double Data_type;
+
+
+
+
/*!
\def VBO_BUFFER_OFFSET(a)
OpenGL special macro
@@ -116,6 +122,13 @@ private:
public:
+ enum Type{
+ TRIANGLES,
+ QUADS,
+ LINES
+ };
+
+
/***********************************
*
* Constructor and destructor.
@@ -129,7 +142,7 @@ public:
* \param object_type Defines how kind of OpenGL primitive object is made.
* \param client_state Define how kind of OpenGL buffer object belongs to.
*/
- Vbo(int nb_verteces_per_object, int nb_object, GLenum object_type, GLenum client_state);
+ Vbo(int nb_object, Type object_type);
/*!
* \brief The destructor.
@@ -173,7 +186,7 @@ public:
* <li><b>VBO_UNDEFINED_ERROR</b>: an error occurs but has not been identified.
* </ul>
*/
- int fill_buffer(const unsigned int data_size, const Element_pos* const data);
+ int add(const unsigned int data_size, const Data_type* const data);
/*!
@@ -194,7 +207,7 @@ public:
/*!
* \brief Display the VBO list inside the OpenGL area.
*/
- void display_buffer() const;
+ void display() const;
@@ -209,6 +222,12 @@ public:
*/
void display_info();
+
+ void *operator new(size_t s){
+ std::cout << "Vbo: allocation de "<< s << " octets." << std::endl;
+ return malloc(s*sizeof(Vbo));
+ }
+
};
@@ -222,23 +241,23 @@ public:
*
****************/
-struct Vbo_container : public Vbo{
+// struct Vbo_container : public Vbo{
-public:
+// public:
- /*!
- * \brief The default constructor.
- */
- Vbo_container():Vbo(4, 8000, GL_QUADS, GL_VERTEX_ARRAY){
- }
+// /*!
+// * \brief The default constructor.
+// */
+// Vbo_container():Vbo(4, 8000, GL_QUADS, GL_VERTEX_ARRAY){
+// }
- /*!
- * \brief The destructor.
- */
- virtual ~Vbo_container(){
- }
+// /*!
+// * \brief The destructor.
+// */
+// virtual ~Vbo_container(){
+// }
-};
+// };
@@ -252,47 +271,47 @@ public:
****************/
-/*!
- * \brief VBO uses for triangle arrows.
- */
-struct Vbo_arrow_triangle : public Vbo{
+// /*!
+// * \brief VBO uses for triangle arrows.
+// */
+// struct Vbo_arrow_triangle : public Vbo{
-public:
+// public:
- /*!
- * \brief The default constructor.
- */
- Vbo_arrow_triangle():Vbo(3, 2000, GL_TRIANGLES, GL_VERTEX_ARRAY){
- }
+// /*!
+// * \brief The default constructor.
+// */
+// Vbo_arrow_triangle():Vbo(3, 2000, GL_TRIANGLES, GL_VERTEX_ARRAY){
+// }
- /*!
- * \brief The destructor.
- */
- virtual ~Vbo_arrow_triangle(){
- }
-};
+// /*!
+// * \brief The destructor.
+// */
+// virtual ~Vbo_arrow_triangle(){
+// }
+// };
-/*!
- * \brief VBO uses for line arrows.
- */
-struct Vbo_arrow_line : public Vbo{
+// /*!
+// * \brief VBO uses for line arrows.
+// */
+// struct Vbo_arrow_line : public Vbo{
-public:
+// public:
- /*!
- * \brief The default constructor.
- */
- Vbo_arrow_line():Vbo(2, 8000, GL_LINES, GL_VERTEX_ARRAY){
- }
+// /*!
+// * \brief The default constructor.
+// */
+// Vbo_arrow_line():Vbo(2, 8000, GL_LINES, GL_VERTEX_ARRAY){
+// }
- /*!
- * \brief The destructor.
- */
- virtual ~Vbo_arrow_line(){
- }
-};
+// /*!
+// * \brief The destructor.
+// */
+// virtual ~Vbo_arrow_line(){
+// }
+// };
#endif
diff --git a/src/src.pro b/src/src.pro
index 787bd2a56f79b17febe3748d8445518b8bdcf6cd..f209dfc2629d373c44a2a393c9eb287b0070e059 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -64,6 +64,8 @@ LIBS += general/otf/otflib/.libs/libotf.a -Lgeneral/otf/otflib/.libs
# LIBS += -lglut
#}
+LIBS += -lGLEW
+
macx {
QMAKESPEC = macx-g++
# QMAKE_LFLAGS += -F/System/Library/Frameworks/GLUT
@@ -97,7 +99,8 @@ HEADERS += common/common.hpp \
render/render_stats.hpp \
render/render_stats_opengl.hpp \
render/render_stats_svg.hpp \
-# render/vbo.hpp \
+ render/Render_alternate.hpp \
+ render/vbo.hpp \
# Parser headers
parser/Definition.hpp \
parser/Line.hpp \
@@ -202,7 +205,8 @@ SOURCES += common/Message.cpp \
render/Render_svg.cpp \
render/render_stats_opengl.cpp \
render/render_stats_svg.cpp \
-# render/vbo.cpp \
+ render/Render_alternate.cpp \
+ render/vbo.cpp \
# Statistics code files
statistics/Stats_window.cpp \
statistics/Statistic.cpp \