RenderTypes.hh

Go to the documentation of this file.

/*
 * Copyright (C) 2015 Open Source Robotics Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 */
#ifndef GZ_RENDERING_RENDERTYPES_HH_
#define GZ_RENDERING_RENDERTYPES_HH_
 
#include <memory>
#include <gz/rendering/config.hh>
 
 
#define GZ_VISIBILITY_ALL             0x0FFFFFFF
 
#define GZ_VISIBILITY_SELECTION       0x10000000
 
#define GZ_VISIBILITY_GUI             0x00000001
 
#define GZ_VISIBILITY_SELECTABLE      0x00000002
 
namespace gz
{
  namespace rendering
  {
    inline namespace GZ_RENDERING_VERSION_NAMESPACE {
    //
    template <class T>
    using shared_ptr = std::shared_ptr<T>;
 
    class ArrowVisual;
    class AxisVisual;
    class BoundingBoxCamera;
    class Camera;
    class Capsule;
    class CiVctCascade;
    class COMVisual;
    class DepthCamera;
    class DirectionalLight;
    class DistortionPass;
    class GaussianNoisePass;
    class Geometry;
    class GizmoVisual;
    class GlobalIlluminationBase;
    class GlobalIlluminationCiVct;
    class GlobalIlluminationVct;
    class GpuRays;
    class Grid;
    class Heightmap;
    class Image;
    class InertiaVisual;
    class LensFlarePass;
    class Light;
    class LightVisual;
    class JointVisual;
    class LidarVisual;
    class FrustumVisual;
    class Light;
    class Marker;
    class Material;
    class Mesh;
    class NativeWindow;
    class Node;
    class Object;
    class ObjectFactory;
    class ParticleEmitter;
    class PointLight;
    class Projector;
    class RayQuery;
    class RenderEngine;
    class RenderPass;
    class RenderPassSystem;
    class RenderTarget;
    class RenderTexture;
    class RenderWindow;
    class Scene;
    class SegmentationCamera;
    class Sensor;
    class ShaderParams;
    class SpotLight;
    class SubMesh;
    class Text;
    class ThermalCamera;
    class Visual;
    class WideAngleCamera;
    class WireBox;
 
    typedef shared_ptr<ArrowVisual> ArrowVisualPtr;
 
    typedef shared_ptr<AxisVisual> AxisVisualPtr;
 
    typedef shared_ptr<Camera> CameraPtr;
 
    typedef std::shared_ptr<CiVctCascade> CiVctCascadePtr;
 
    typedef shared_ptr<DepthCamera> DepthCameraPtr;
 
    typedef shared_ptr<ThermalCamera> ThermalCameraPtr;
 
    typedef shared_ptr<BoundingBoxCamera> BoundingBoxCameraPtr;
 
    typedef shared_ptr<SegmentationCamera> SegmentationCameraPtr;
 
    typedef shared_ptr<WideAngleCamera> WideAngleCameraPtr;
 
    typedef shared_ptr<GpuRays> GpuRaysPtr;
 
    typedef shared_ptr<DirectionalLight> DirectionalLightPtr;
 
    typedef shared_ptr<DistortionPass> DistortionPassPtr;
 
    typedef shared_ptr<GaussianNoisePass> GaussianNoisePassPtr;
 
    typedef shared_ptr<Geometry> GeometryPtr;
 
    typedef shared_ptr<GizmoVisual> GizmoVisualPtr;
 
    typedef shared_ptr<Capsule> CapsulePtr;
 
    typedef shared_ptr<Grid> GridPtr;
 
    typedef shared_ptr<JointVisual> JointVisualPtr;
 
    typedef shared_ptr<Heightmap> HeightmapPtr;
 
    typedef shared_ptr<Image> ImagePtr;
 
    typedef shared_ptr<InertiaVisual> InertiaVisualPtr;
 
    typedef shared_ptr<LensFlarePass> LensFlarePassPtr;
 
    typedef shared_ptr<Light> LightPtr;
 
    typedef shared_ptr<COMVisual> COMVisualPtr;
 
    typedef shared_ptr<LightVisual> LightVisualPtr;
 
    typedef shared_ptr<LidarVisual> LidarVisualPtr;
 
    typedef shared_ptr<FrustumVisual> FrustumVisualPtr;
 
    typedef shared_ptr<Material> MaterialPtr;
 
    typedef shared_ptr<Marker> MarkerPtr;
 
    typedef shared_ptr<Mesh> MeshPtr;
 
    typedef shared_ptr<NativeWindow> NativeWindowPtr;
 
    typedef shared_ptr<Node> NodePtr;
 
    typedef shared_ptr<Object> ObjectPtr;
 
    typedef shared_ptr<ObjectFactory> ObjectFactoryPtr;
 
    typedef shared_ptr<ParticleEmitter> ParticleEmitterPtr;
 
    typedef shared_ptr<GlobalIlluminationBase> GlobalIlluminationBasePtr;
 
    typedef shared_ptr<GlobalIlluminationCiVct> GlobalIlluminationCiVctPtr;
 
    typedef shared_ptr<GlobalIlluminationVct> GlobalIlluminationVctPtr;
 
    typedef shared_ptr<PointLight> PointLightPtr;
 
    typedef shared_ptr<Projector> ProjectorPtr;
 
    typedef shared_ptr<RayQuery> RayQueryPtr;
 
    typedef shared_ptr<RenderPass> RenderPassPtr;
 
    typedef shared_ptr<RenderPassSystem> RenderPassSystemPtr;
 
    typedef shared_ptr<RenderTarget> RenderTargetPtr;
 
    typedef shared_ptr<RenderTexture> RenderTexturePtr;
 
    typedef shared_ptr<RenderWindow> RenderWindowPtr;
    typedef shared_ptr<Scene> ScenePtr;
 
    typedef shared_ptr<Sensor> SensorPtr;
 
    typedef shared_ptr<ShaderParams> ShaderParamsPtr;
 
    typedef shared_ptr<SpotLight> SpotLightPtr;
 
    typedef shared_ptr<SubMesh> SubMeshPtr;
 
    typedef shared_ptr<Text> TextPtr;
 
    typedef shared_ptr<Visual> VisualPtr;
 
    typedef shared_ptr<WireBox> WireBoxPtr;
 
    typedef shared_ptr<const ArrowVisual> ConstArrowVisualPtr;
 
    typedef shared_ptr<const AxisVisual> ConstAxisVisualPtr;
 
    typedef shared_ptr<const Camera> ConstCameraPtr;
 
    typedef shared_ptr<const DepthCamera> ConstDepthCameraPtr;
 
    typedef shared_ptr<const ThermalCamera> ConstThermalCameraPtr;
 
    typedef shared_ptr<const BoundingBoxCamera> ConstBoundingBoxCameraPtr;
 
    typedef shared_ptr<const SegmentationCamera> ConstSegmentationCameraPtr;
 
    typedef shared_ptr<const WideAngleCamera> ConstWideAngleCameraPtr;
 
    typedef shared_ptr<const GpuRays> ConstGpuRaysPtr;
 
    typedef shared_ptr<const DirectionalLight> ConstDirectionalLightPtr;
 
    typedef shared_ptr<const GaussianNoisePass> ConstGaussianNoisePass;
 
    typedef shared_ptr<const Geometry> ConstGeometryPtr;
 
    typedef shared_ptr<const GizmoVisual> ConstGizmoVisualPtr;
 
    typedef shared_ptr<const JointVisual> ConstJointVisualPtr;
 
    typedef shared_ptr<const Heightmap> ConstHeightmapPtr;
 
    typedef shared_ptr<const Image> ConstImagePtr;
 
    typedef shared_ptr<const Light> ConstLightPtr;
 
    typedef shared_ptr<const LidarVisual> ConstLidarVisualPtr;
 
    typedef shared_ptr<const FrustumVisual> ConstFrustumVisualPtr;
 
    typedef shared_ptr<const Material> ConstMaterialPtr;
 
    typedef shared_ptr<const Mesh> ConstMeshPtr;
 
    typedef shared_ptr<const Node> ConstNodePtr;
 
    typedef shared_ptr<const Object> ConstObjectPtr;
 
    typedef shared_ptr<const ObjectFactory> ConstObjectFactoryPtr;
 
    typedef shared_ptr<const ParticleEmitter> ConstParticleEmitterPtr;
 
    typedef shared_ptr<const PointLight> ConstPointLightPtr;
 
    typedef shared_ptr<const Projector> ConstProjectorPtr;
 
    typedef shared_ptr<const RayQuery> ConstRayQueryPtr;
 
    typedef shared_ptr<const RenderPass> ConstRenderPassPtr;
 
    typedef shared_ptr<const RenderPassSystem> ConstRenderPassSystemPtr;
 
    typedef shared_ptr<const RenderTarget> ConstRenderTargetPtr;
 
    typedef shared_ptr<const RenderTexture> ConstRenderTexturePtr;
 
    typedef shared_ptr<const RenderWindow> ConstRenderWindowPtr;
 
    typedef shared_ptr<const Scene> ConstScenePtr;
 
    typedef shared_ptr<const Sensor> ConstSensorPtr;
 
    typedef shared_ptr<const ShaderParams> ConstShaderParamsPtr;
 
    typedef shared_ptr<const SpotLight> ConstSpotLightPtr;
 
    typedef shared_ptr<const SubMesh> ConstSubMeshPtr;
 
    typedef shared_ptr<const Text> ConstTextPtr;
 
    typedef shared_ptr<const Visual> ConstVisualPtr;
    }
  }
}
#endif