Render_alternate.hpp 17.3 KB
Newer Older
1
/*
2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
 ** 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
 **
 */
43 44 45 46 47 48 49
/*!
 *\file Render_alternate.hpp
 */

#ifndef RENDER_OPENGL_HPP
#define RENDER_OPENGL_HPP

50 51 52 53 54 55 56 57
#include <stack>
#include <cmath>
#include <sstream>
/* -- */
#include <QObject>
#include <QGLWidget>
#include <QLabel>
#include <QPainter>
58 59 60 61
#define GLM_FORCE_RADIANS
#include <glm/glm.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/gtc/type_ptr.hpp>
62 63 64 65 66 67 68 69 70 71
/* -- */
#include "common/common.hpp"
#include "common/Info.hpp"
/* -- */
#include "render/Geometry.hpp"
#include "render/Hook_event.hpp"
#include "render/Render.hpp"
#include "render/Minimap.hpp"
#include "render/Ruler.hpp"
#include "render/GanttDiagram.hpp"
72 73
#include "render/vbo.hpp"
#include "render/Shader.hpp"
74

75 76
class Render_alternate;
class Interface_console;
77
class StateType;
78
struct Container_text_;
Thibault Soucarre's avatar
Thibault Soucarre committed
79 80 81 82 83 84 85
/*!
 * \brief Structure used to store text for variables.
 */
struct Variable_text_{
    Element_pos y;
    Element_pos value;
};
86

87 88 89 90 91 92 93
/*!
 * \def _DRAWING_CONTAINER_HEIGHT_DEFAULT
 * \brief The default height for basic containers.
 */

#define _DRAWING_CONTAINER_HEIGHT_DEFAULT 1.2f

94 95 96
/*!
 * \brief This class redefined the OpenGL widget - QGLWidget - to display the trace.
 */
97

98
class Render_alternate :  /*public QGLWidget,*/ public Hook_event, public Render
99 100
{
    Q_OBJECT
101
private:
102 103
    int _glsl; //version of OpenGL Shading Language
    Shader* _shader;
Thibault Soucarre's avatar
Thibault Soucarre committed
104
    Shader* _wait_shader;
105
    Element_pos _container_height;
106 107 108 109
    Element_col _r;
    Element_col _g;
    Element_col _b;
    std::vector<Element_pos> _links;
110
    //std::vector<Element_pos> _events;
111
    std::vector<Container_text_> _texts;
Thibault Soucarre's avatar
Thibault Soucarre committed
112
    std::map<long int, Variable_text_> _variable_texts;
113
    glm::mat4 _modelview;
114
    glm::mat4 _projection;
115
    Vbo _containers;
116
    //Vbo _states;
117 118
    Vbo _events;
    Vbo _events2;
119
    Vbo _arrows;
120
    Vbo _arrows2;
121
    Vbo _arrows3;
122 123
    Vbo _counters;
    Vbo _ruler;
Thibault Soucarre's avatar
Thibault Soucarre committed
124
    Vbo _wait;
125
    Vbo *_current;
126 127
    std::map<EntityValue*, Vbo*> _states;
    std::map<EntityValue*, Shader*> _states_shaders;
128
    std::map<EntityValue*, bool> _states_visible;
Thibault Soucarre's avatar
Thibault Soucarre committed
129
    GLuint _textureID;
Thibault Soucarre's avatar
Thibault Soucarre committed
130 131 132 133
    /*!
     * \brief Offset of the vertical helper line
     */
    Element_pos vertical_line;
134 135
public:

136 137 138 139 140
/***********************************
 *
 * Constructor and destructor.
 *
 **********************************/
141

142 143 144 145
/*!
 * \brief The default constructor
 */
Render_alternate(Core* core, QWidget *parent, const QGLFormat& format);
146

147 148 149 150
/*!
 * \brief The destructor
 */
virtual ~Render_alternate();
151

152 153 154 155
/*!
 * \brief Set Statistics and Informations about input trace
 */
void set_total_width(Element_pos){}
156

157 158 159 160
/*!
 * \brief Set Statistics and Informations about input trace
 */
void set_total_time(Times){}
161

162 163 164 165
/*!
 * \brief display the scale
 */
void display_time_scale(){}
166 167


168 169 170 171 172
/***********************************
 *
 * Default QGLWidget functions.
 *
 **********************************/
Thibault Soucarre's avatar
Thibault Soucarre committed
173

174 175 176 177
/*!
 * \brief Call by the system to initialize the OpenGL render area.
 */
void initializeGL();
Thibault Soucarre's avatar
Thibault Soucarre committed
178

179 180 181 182 183 184
/*!
 * \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);
Thibault Soucarre's avatar
Thibault Soucarre committed
185

186 187 188 189
/*!
 * \brief Call by the system each time the render area need to be updated.
 */
void paintGL();
Thibault Soucarre's avatar
Thibault Soucarre committed
190

191
//void paintEvent(QPaintEvent *event);
192

193 194 195
/* void initializeOverlayGL();
 void resizeOverlayGL(int width, int height);
 void paintOverlayGL();*/
Thibault Soucarre's avatar
Thibault Soucarre committed
196

197

198 199 200 201 202
/***********************************
 *
 * Building functions.
 *
 **********************************/
203

204 205 206 207
/*!
 * \brief This function constructs the trace.
 */
//  bool display_build() ;
208

209 210 211 212
/*!
 * \brief This function releases the trace.
 */
//   bool display_unbuild() ;
213

214 215 216 217
/*!
 * \brief Proceeds with the initialization of the OpenGL draw functions.
 */
void start_draw();
218

219 220 221 222
/*!
 * \brief Creates and opens the display list for container draws.
 */
void start_draw_containers();
223

224 225 226 227 228 229 230 231
/*!
 * \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);
232

233 234 235 236 237 238 239 240 241
/*!
 * \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);
242

243 244 245 246
/*!
 * \brief Closes the container display list.
 */
void end_draw_containers();
Thibault Soucarre's avatar
Thibault Soucarre committed
247

248 249 250 251
/*!
 * \brief Creates and opens the display list for stater draws.
 */
void start_draw_states();
252

253 254 255 256 257 258 259 260 261 262
/*!
 * \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.
 */
263
void draw_state(const Element_pos start , const Element_pos end, const Element_pos base, const Element_pos height, const Element_pos r, EntityValue* type);
264

265 266 267 268
/*!
 * \brief Closes the state display list.
 */
void end_draw_states();
269

270 271 272 273
/*!
 * \brief Open the arrow display list.
 */
void start_draw_arrows();
274

275 276 277 278 279 280 281 282 283 284
/*!
 * \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);
285

286 287 288 289
/*!
 * \brief Closes the arrow display list.
 */
void end_draw_arrows();
290

291 292 293 294
/*!
 * \brief Draw arrows contained in the Arrow_ vector
 * \param arrows An arrow vector.
 */
295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
    // 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();
Thibault Soucarre's avatar
Thibault Soucarre committed
325

326 327 328 329 330 331 332 333
    /*!
     * \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);
Thibault Soucarre's avatar
Thibault Soucarre committed
334

335 336 337 338 339 340 341 342 343
    /*!
     * \brief Closes the counter display list.
     */
    void end_draw_counter();

    /*!
     * \brief Called before ruler drawing.
     */
    void start_ruler();
Thibault Soucarre's avatar
Thibault Soucarre committed
344

345 346 347 348
    /*!
     * \brief Called after ruler drawing.
     */
    void end_ruler();
Thibault Soucarre's avatar
Thibault Soucarre committed
349

350 351 352 353 354 355

    /*!
     * \brief Do nothing (it is present for compatibility of the Render class).
     */
    void end_draw();

Thibault Soucarre's avatar
Thibault Soucarre committed
356

357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398

    /***********************************
     *
     * 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.
     *
     **********************************/

399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
    //    /*!
    //      * \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;
Thibault Soucarre's avatar
Thibault Soucarre committed
457

458 459 460 461
    /*!
     * \brief Set the color for the further drawings.
     * \param r the red value. Within [0 ; 1].
     * \param g the green value. Within [0 ; 1].
Thibault Soucarre's avatar
Thibault Soucarre committed
462
     * \param b the blue value. Within [0 ; 1].
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493
     */
    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);
Thibault Soucarre's avatar
Thibault Soucarre committed
494

495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
    /*!
     * \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();
519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
    void release();
    void draw_text_value(long int id,double text, double y);
    void show_minimap();

    /*!
     * \brief draws the vertical helper line
     */

    void draw_vertical_line();

    /*!
     * \brief set the vertical line offset
     * \param l the line offset.
     */
    void set_vertical_line(Element_pos l);
534 535


Thibault Soucarre's avatar
Thibault Soucarre committed
536 537 538 539 540 541
    /*!
     * \brief returns the offset of the vertical helper line
     */
    Element_pos get_vertical_line();

public slots:
542
    /*!
Thibault Soucarre's avatar
Thibault Soucarre committed
543 544 545 546
     * \brief slot connected to the simple click event
     */
    void update_vertical_line();

547 548 549
    /*!
     * \brief Function that only delete the text of the screen
     */
550 551
    void clear_text ();

552 553 554 555 556 557
    /*!
     * \brief Change the color corresponding to an EntityValue
     */

    void change_color(std::string entity, Element_col r, Element_col g, Element_col b);

558 559
    void change_visible(std::string entity, bool visible);

560 561 562 563 564
    /*!
     * \brief reload state color from trace file
     */
    void reload_states();

Thibault Soucarre's avatar
Thibault Soucarre committed
565 566
};

567 568

#endif