LCOV - code coverage report
Current view: top level - seq - viewData.cpp (source / functions) Hit Total Coverage
Test: Equalizer Lines: 44 114 38.6 %
Date: 2017-12-16 05:07:20 Functions: 10 18 55.6 %

          Line data    Source code
       1             : 
       2             : /* Copyright (c) 2011-2017, Stefan Eilemann <eile@eyescale.ch>
       3             :  *                          Daniel Nachbaur <danielnachbaur@gmail.com>
       4             :  *                          Petros Kataras <petroskataras@gmail.com>
       5             :  *
       6             :  * This library is free software; you can redistribute it and/or modify it under
       7             :  * the terms of the GNU Lesser General Public License version 2.1 as published
       8             :  * by the Free Software Foundation.
       9             :  *
      10             :  * This library is distributed in the hope that it will be useful, but WITHOUT
      11             :  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
      12             :  * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
      13             :  * details.
      14             :  *
      15             :  * You should have received a copy of the GNU Lesser General Public License
      16             :  * along with this library; if not, write to the Free Software Foundation, Inc.,
      17             :  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
      18             :  */
      19             : 
      20             : #include "viewData.h"
      21             : 
      22             : #include <co/dataIStream.h>
      23             : #include <co/dataOStream.h>
      24             : #include <eq/eventICommand.h>
      25             : #include <eq/fabric/axisEvent.h>
      26             : #include <eq/fabric/keyEvent.h>
      27             : #include <eq/fabric/pointerEvent.h>
      28             : #include <eq/view.h>
      29             : 
      30             : namespace seq
      31             : {
      32           8 : ViewData::ViewData(View& view)
      33             :     : _view(view)
      34             :     , _spinX(5)
      35             :     , _spinY(5)
      36             :     , _advance(0)
      37             :     , _statistics(false)
      38           8 :     , _ortho(false)
      39             : {
      40           8 :     moveModel(0.f, 0.f, -2.f);
      41           8 : }
      42             : 
      43          16 : ViewData::~ViewData()
      44             : {
      45          16 : }
      46             : 
      47          10 : void ViewData::serialize(co::DataOStream& os, const uint64_t dirtyBits)
      48             : {
      49          10 :     if (dirtyBits & DIRTY_MODELMATRIX)
      50          10 :         os << _modelMatrix;
      51          10 :     if (dirtyBits & DIRTY_STATISTICS)
      52           8 :         os << _statistics;
      53          10 :     if (dirtyBits & DIRTY_ORTHO)
      54           8 :         os << _ortho;
      55          10 : }
      56             : 
      57           2 : void ViewData::deserialize(co::DataIStream& is, const uint64_t dirtyBits)
      58             : {
      59           2 :     if (dirtyBits & DIRTY_MODELMATRIX)
      60           2 :         is >> _modelMatrix;
      61           2 :     if (dirtyBits & DIRTY_STATISTICS)
      62           1 :         is >> _statistics;
      63           2 :     if (dirtyBits & DIRTY_ORTHO)
      64           1 :         is >> _ortho;
      65           2 : }
      66             : 
      67           0 : bool ViewData::handleEvent(const eq::EventType, const SizeEvent&)
      68             : {
      69           0 :     return true;
      70             : }
      71             : 
      72           0 : bool ViewData::handleEvent(const eq::EventType type, const PointerEvent& event)
      73             : {
      74           0 :     switch (type)
      75             :     {
      76             :     case EVENT_CHANNEL_POINTER_BUTTON_RELEASE:
      77           0 :         if (event.buttons == eq::PTR_BUTTON_NONE)
      78             :         {
      79           0 :             if (event.button == eq::PTR_BUTTON1)
      80             :             {
      81           0 :                 _spinX = event.dy;
      82           0 :                 _spinY = event.dx;
      83           0 :                 return true;
      84             :             }
      85           0 :             if (event.button == eq::PTR_BUTTON2)
      86             :             {
      87           0 :                 _advance = -event.dy;
      88           0 :                 return true;
      89             :             }
      90             :         }
      91           0 :         return false;
      92             : 
      93             :     case EVENT_CHANNEL_POINTER_MOTION:
      94           0 :         switch (event.buttons)
      95             :         {
      96             :         case eq::PTR_BUTTON1:
      97           0 :             _spinX = 0;
      98           0 :             _spinY = 0;
      99           0 :             spinModel(-0.005f * event.dy, -0.005f * event.dx, 0.f);
     100           0 :             return true;
     101             : 
     102             :         case eq::PTR_BUTTON2:
     103           0 :             _advance = -event.dy;
     104           0 :             moveModel(0.f, 0.f, .005f * _advance);
     105           0 :             return true;
     106             : 
     107             :         case eq::PTR_BUTTON3:
     108           0 :             moveModel(.0005f * event.dx, -.0005f * event.dy, 0.f);
     109           0 :             return true;
     110             : 
     111             :         default:
     112           0 :             return false;
     113             :         }
     114             : 
     115             :     case EVENT_CHANNEL_POINTER_WHEEL:
     116           0 :         moveModel(-0.05f * event.xAxis, 0.f, 0.05f * event.yAxis);
     117           0 :         return true;
     118             : 
     119             :     default:
     120           0 :         return false;
     121             :     }
     122             : }
     123             : 
     124           0 : bool ViewData::handleEvent(const eq::EventType type, const KeyEvent& event)
     125             : {
     126           0 :     switch (type)
     127             :     {
     128             :     case EVENT_KEY_PRESS:
     129           0 :         switch (event.key)
     130             :         {
     131             :         case 's':
     132           0 :             showStatistics(!getStatistics());
     133           0 :             return true;
     134             :         case 'o':
     135           0 :             setOrtho(!useOrtho());
     136           0 :             return true;
     137             :         case ' ':
     138           0 :             _spinX = 0;
     139           0 :             _spinY = 0;
     140           0 :             _advance = 0;
     141           0 :             _modelMatrix = eq::Matrix4f();
     142           0 :             moveModel(0.f, 0.f, -2.f);
     143           0 :             return true;
     144             :         }
     145           0 :         return false;
     146             : 
     147             :     default:
     148           0 :         return false;
     149             :     }
     150             : }
     151             : 
     152           0 : bool ViewData::handleEvent(const AxisEvent& event)
     153             : {
     154           0 :     _spinX = 0;
     155           0 :     _spinY = 0;
     156           0 :     _advance = 0;
     157           0 :     spinModel(0.0001f * event.zRotation, -0.0001f * event.xRotation,
     158           0 :               -0.0001f * event.yRotation);
     159           0 :     moveModel(0.0001f * event.xAxis, -0.0001f * event.zAxis,
     160           0 :               0.0001f * event.yAxis);
     161           0 :     return true;
     162             : }
     163             : 
     164           0 : bool ViewData::handleEvent(const ButtonEvent&)
     165             : {
     166           0 :     return false;
     167             : }
     168             : 
     169           1 : void ViewData::spinModel(const float x, const float y, const float z)
     170             : {
     171           1 :     if (x == 0.f && y == 0.f && z == 0.f)
     172           0 :         return;
     173             : 
     174           1 :     const Vector3f translation = _modelMatrix.getTranslation();
     175           1 :     _modelMatrix.setTranslation(Vector3f());
     176           1 :     _modelMatrix.pre_rotate_x(x);
     177           1 :     _modelMatrix.pre_rotate_y(y);
     178           1 :     _modelMatrix.pre_rotate_z(z);
     179           1 :     _modelMatrix.setTranslation(translation);
     180           1 :     setDirty(DIRTY_MODELMATRIX);
     181             : }
     182             : 
     183           9 : void ViewData::moveModel(const float x, const float y, const float z)
     184             : {
     185           9 :     if (x == 0.f && y == 0.f && z == 0.f)
     186           1 :         return;
     187             : 
     188           8 :     const float unit = _view.getModelUnit();
     189          16 :     _modelMatrix.setTranslation(_modelMatrix.getTranslation() +
     190          24 :                                 Vector3f(x * unit, y * unit, z * unit));
     191           8 :     setDirty(DIRTY_MODELMATRIX);
     192             : }
     193             : 
     194           0 : void ViewData::showStatistics(const bool on)
     195             : {
     196           0 :     if (_statistics == on)
     197           0 :         return;
     198             : 
     199           0 :     _statistics = on;
     200           0 :     setDirty(DIRTY_STATISTICS);
     201             : }
     202             : 
     203           0 : void ViewData::setOrtho(const bool on)
     204             : {
     205           0 :     if (_ortho == on)
     206           0 :         return;
     207             : 
     208           0 :     _ortho = on;
     209           0 :     setDirty(DIRTY_ORTHO);
     210             : }
     211             : 
     212           0 : void ViewData::setModelMatrix(const Matrix4f& matrix)
     213             : {
     214           0 :     if (_modelMatrix == matrix)
     215           0 :         return;
     216             : 
     217           0 :     _modelMatrix = matrix;
     218           0 :     setDirty(DIRTY_MODELMATRIX);
     219             : }
     220             : 
     221           1 : bool ViewData::update()
     222             : {
     223           1 :     if (_spinX == 0 && _spinY == 0 && _advance == 0)
     224           0 :         return false;
     225             : 
     226           1 :     spinModel(-0.001f * _spinX, -0.001f * _spinY, 0.f);
     227           1 :     moveModel(0.0f, 0.0f, 0.001f * _advance);
     228           1 :     return true;
     229             : }
     230          30 : }

Generated by: LCOV version 1.11