eq/types.h

/* Copyright (c) 2007-2016, Stefan Eilemann <eile@equalizergraphics.com>
 *                          Daniel Nachbaur <danielnachbaur@gmail.com>
 *                          Cedric Stalder <cedric.stalder@gmail.com>
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License version 2.1 as published
 * by the Free Software Foundation.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this library; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#ifndef EQ_TYPES_H
#define EQ_TYPES_H

#include <eq/defines.h>
#include <eq/fabric/commands.h>
#include <eq/fabric/eventType.h>
#include <eq/fabric/focusMode.h>
#include <eq/fabric/types.h>
#include <eq/util/types.h>
#include <lunchbox/atomic.h>
#include <lunchbox/compiler.h>

#include <map>
#include <vector>

namespace eq
{
class Canvas;
class Channel;
class Client;
class CommandQueue;
class Config;
class EventICommand;
class Frame;
class FrameData;
class Image;
class Layout;
class MessagePump;
class Node;
class NodeFactory;
class NotifierInterface;
class Observer;
class Pipe;
class ResultImageListener;
class Segment;
class Server;
class SystemPipe;
class SystemWindow;
class View;
class Window;
class WindowSettings;
class WindowSystem;
struct ImageOp;
struct PixelData;

using namespace fabric::eventEnums;
using namespace fabric::eventTypes;

using fabric::ANAGLYPH;
using fabric::ASYNC;
using fabric::AUTO;
using fabric::DRAW_SYNC;
using fabric::FASTEST;
using fabric::FBO;
using fabric::HORIZONTAL;
using fabric::LOCAL_SYNC;
using fabric::NICEST;
using fabric::OFF;
using fabric::ON;
using fabric::QUAD;
using fabric::RGBA16F;
using fabric::RGBA32F;
using fabric::UNDEFINED;
using fabric::VERTICAL;
using fabric::WINDOW;

using fabric::AxisEvent;
using fabric::ButtonEvent;
using fabric::ColorMask;
using fabric::DrawableConfig;
using fabric::Errors;
using fabric::Event;
using fabric::Frustum;
using fabric::Frustumf;
using fabric::GPUInfo;
using fabric::IAttribute;
using fabric::KeyEvent;
using fabric::Pixel;
using fabric::PixelViewport;
using fabric::PointerEvent;
using fabric::Projection;
using fabric::Range;
using fabric::RenderContext;
using fabric::SizeEvent;
using fabric::Statistic;
using fabric::SubPixel;
using fabric::Tile;
using fabric::Viewport;
using fabric::Wall;
using fabric::Zoom;

typedef fabric::LeafVisitor<Segment> SegmentVisitor;

typedef fabric::LeafVisitor<View> ViewVisitor;

typedef fabric::LeafVisitor<Observer> ObserverVisitor;

typedef fabric::LeafVisitor<Channel> ChannelVisitor;

typedef fabric::ElementVisitor<Canvas, SegmentVisitor> CanvasVisitor;

typedef fabric::ElementVisitor<Window, ChannelVisitor> WindowVisitor;

typedef fabric::ElementVisitor<Pipe, WindowVisitor> PipeVisitor;

typedef fabric::ElementVisitor<Node, PipeVisitor> NodeVisitor;

typedef fabric::ElementVisitor<Layout, ViewVisitor> LayoutVisitor;

typedef fabric::ConfigVisitor<Config, ObserverVisitor, LayoutVisitor,
                              // cppcheck-suppress unnecessaryForwardDeclaration
                              CanvasVisitor, NodeVisitor>
    ConfigVisitor;

typedef fabric::ElementVisitor<Server, ConfigVisitor> ServerVisitor;

//----- Vectors
typedef std::vector<Config*> Configs;
typedef std::vector<Server*> Servers;
typedef std::vector<Node*> Nodes;
typedef std::vector<Pipe*> Pipes;
typedef std::vector<Window*> Windows;
typedef std::vector<Channel*> Channels;
typedef std::vector<Frame*> Frames;
typedef std::vector<Image*> Images;
typedef std::vector<Observer*> Observers;
typedef std::vector<Canvas*> Canvases;
typedef std::vector<Layout*> Layouts;
typedef std::vector<Segment*> Segments;
typedef std::vector<View*> Views;
typedef std::vector<PixelViewport> PixelViewports;
typedef std::vector<ImageOp> ImageOps;

typedef Configs::const_iterator ConfigsCIter;
typedef Servers::const_iterator ServersCIter;
typedef Nodes::const_iterator NodesCIter;
typedef Pipes::const_iterator PipesCIter;
typedef Windows::const_iterator WindowsCIter;
typedef Channels::const_iterator ChannelsCIter;
typedef Frames::iterator FramesIter;
typedef Frames::const_iterator FramesCIter;
typedef Images::const_iterator ImagesCIter;
typedef Observers::const_iterator ObserversCIter;
typedef Canvases::const_iterator CanvasesCIter;
typedef Layouts::const_iterator LayoutsCIter;
typedef Segments::const_iterator SegmentsCIter;
typedef Views::const_iterator ViewsCIter;
typedef PixelViewports::const_iterator PixelViewportsCIter;

typedef lunchbox::RefPtr<Client> ClientPtr;
typedef lunchbox::RefPtr<const Client> ConstClientPtr;
typedef lunchbox::RefPtr<Server> ServerPtr;
typedef lunchbox::RefPtr<FrameData> FrameDataPtr;
typedef lunchbox::RefPtr<const FrameData> ConstFrameDataPtr;

using fabric::Matrix3d;    
using fabric::Matrix4d;    
using fabric::Matrix3f;    
using fabric::Matrix4f;    
using fabric::Vector2i;    
using fabric::Vector3i;    
using fabric::Vector4i;    
using fabric::Vector3d;    
using fabric::Vector4d;    
using fabric::Vector2f;    
using fabric::Vector3f;    
using fabric::Vector4f;    
using fabric::Vector3ub;   
using fabric::Frustumf;    
using fabric::Quaternionf; // !< A float quaternion

using fabric::EventOCommand;
using fabric::EventType;
using fabric::FocusMode;
using fabric::FOCUSMODE_FIXED;
using fabric::FOCUSMODE_RELATIVE_TO_ORIGIN;
using fabric::FOCUSMODE_RELATIVE_TO_OBSERVER;
using fabric::CMD_CONFIG_EVENT;

using fabric::Statistics;   
using fabric::Strings;      
using fabric::StringsCIter; 
using fabric::Viewports;    

using vmml::FrustumCullerf;

typedef std::vector<uint8_t> Vectorub;
typedef std::vector<uint16_t> Vectorus;

using co::f_bool_t;

using lunchbox::a_int32_t;
using lunchbox::backtrace;
using lunchbox::uint128_t;

typedef co::WorkerThread<CommandQueue> Worker; // instantiated in worker.cpp

namespace detail
{
class InitVisitor;  
class ExitVisitor;  
class FrameVisitor; 
}

namespace deflect
{
class Proxy;
}
}

// GLEW
struct GLEWContextStruct;
struct WGLEWContextStruct;
struct GLXEWContextStruct;
typedef struct GLEWContextStruct GLEWContext;
typedef struct WGLEWContextStruct WGLEWContext;
typedef struct GLXEWContextStruct GLXEWContext;
namespace GLStats
{
class Data;
}
class QThread;
#endif // EQ_TYPES_H