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/util/types.h>
#include <eq/fabric/commands.h>
#include <eq/fabric/focusMode.h>
#include <eq/fabric/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 ComputeContext;
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 ConfigEvent; 
struct ImageOp;
struct PixelData;

using namespace fabric::eventEnums;

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::PBUFFER;
using fabric::QUAD;
using fabric::RGBA16F;
using fabric::RGBA32F;
using fabric::UNDEFINED;
using fabric::VERTICAL;
using fabric::WINDOW;

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::Projection;
using fabric::PointerEvent;
using fabric::Range;
using fabric::RenderContext;
using fabric::ResizeEvent;
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::EventOCommand;
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