/****************************************************************************
**
** Copyright (C) 2015 Klaralvdalens Datakonsult AB (KDAB).
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt3D module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include "nodemanagers_p.h"

#include <Qt3DRender/private/managers_p.h>
#include <Qt3DRender/private/scenemanager_p.h>
#include <Qt3DRender/private/buffermanager_p.h>
#include <Qt3DRender/private/gltexturemanager_p.h>
#include <Qt3DRender/private/geometryrenderermanager_p.h>
#include <Qt3DRender/private/techniquemanager_p.h>
#include <Qt3DRender/private/armature_p.h>
#include <Qt3DRender/private/skeleton_p.h>
#include <private/resourceaccessor_p.h>

#include <QOpenGLVertexArrayObject>

QT_BEGIN_NAMESPACE

namespace Qt3DRender {

namespace Render {

NodeManagers::NodeManagers()
    : m_cameraManager(new CameraManager())
    , m_renderNodesManager(new EntityManager())
    , m_materialManager(new MaterialManager())
    , m_worldMatrixManager(new MatrixManager())
    , m_vaoManager(new VAOManager())
    , m_shaderManager(new ShaderManager())
    , m_shaderBuilderManager(new ShaderBuilderManager())
    , m_techniqueManager(new TechniqueManager())
    , m_effectManager(new EffectManager())
    , m_renderPassManager(new RenderPassManager())
    , m_textureManager(new TextureManager())
    , m_textureImageManager(new TextureImageManager())
    , m_glTextureManager(new GLTextureManager())
    , m_layerManager(new LayerManager())
    , m_levelOfDetailManager(new LevelOfDetailManager())
    , m_filterKeyManager(new FilterKeyManager())
    , m_frameGraphManager(new FrameGraphManager())
    , m_transformManager(new TransformManager())
    , m_renderTargetManager(new RenderTargetManager())
    , m_sceneManager(new SceneManager())
    , m_attachmentManager(new AttachmentManager())
    , m_parameterManager(new ParameterManager())
    , m_shaderDataManager(new ShaderDataManager())
    , m_glBufferManager(new GLBufferManager())
    , m_glFenceManager(new GLFenceManager())
    , m_bufferManager(new BufferManager())
    , m_attributeManager(new AttributeManager())
    , m_geometryManager(new GeometryManager())
    , m_geometryRendererManager(new GeometryRendererManager)
    , m_objectPickerManager(new ObjectPickerManager())
    , m_rayCasterManager(new RayCasterManager())
//    , m_boundingVolumeDebugManager(new BoundingVolumeDebugManager())
    , m_lightManager(new LightManager())
    , m_environmentLightManager(new EnvironmentLightManager())
    , m_computeJobManager(new ComputeCommandManager())
    , m_renderStateManager(new RenderStateManager())
    , m_armatureManager(new ArmatureManager())
    , m_skeletonManager(new SkeletonManager())
    , m_jointManager(new JointManager())
    , m_shaderImageManager(new ShaderImageManager())
    , m_resourceAccessor(new ResourceAccessor(this))
{
}

NodeManagers::~NodeManagers()
{
    delete m_cameraManager;
    delete m_materialManager;
    delete m_worldMatrixManager;
    delete m_vaoManager;
    delete m_shaderManager;
    delete m_shaderBuilderManager;
    delete m_techniqueManager;
    delete m_effectManager;
    delete m_renderPassManager;
    delete m_glTextureManager;
    delete m_textureManager;
    delete m_layerManager;
    delete m_levelOfDetailManager;
    delete m_filterKeyManager;
    delete m_transformManager;
    delete m_renderTargetManager;
    delete m_sceneManager;
    delete m_attachmentManager;
    delete m_parameterManager;
    delete m_shaderDataManager;
    delete m_glBufferManager;
    delete m_glFenceManager;
    delete m_textureImageManager;
    delete m_bufferManager;
    delete m_attributeManager;
    delete m_geometryManager;
    delete m_geometryRendererManager;
    delete m_objectPickerManager;
    delete m_rayCasterManager;

    // Delete after m_objectPickerManager as that manager's shutdown needs to access
    // the frame graph manager still.
    delete m_frameGraphManager;
//    delete m_boundingVolumeDebugManager;
    delete m_lightManager;
    delete m_environmentLightManager;
    delete m_computeJobManager;
    delete m_renderStateManager;
    delete m_renderNodesManager;
    delete m_armatureManager;
    delete m_skeletonManager;
    delete m_jointManager;
    delete m_shaderImageManager;
}

QSharedPointer<ResourceAccessor> NodeManagers::resourceAccessor()
{
    return m_resourceAccessor;
}

template<>
CameraManager *NodeManagers::manager<CameraLens>() const noexcept
{
    return m_cameraManager;
}

template<>
EntityManager *NodeManagers::manager<Entity>() const noexcept
{
    return m_renderNodesManager;
}

template<>
MaterialManager *NodeManagers::manager<Material>() const noexcept
{
    return m_materialManager;
}

template<>
MatrixManager *NodeManagers::manager<Matrix4x4>() const noexcept
{
    return m_worldMatrixManager;
}

template<>
VAOManager *NodeManagers::manager<OpenGLVertexArrayObject>() const noexcept
{
    return m_vaoManager;
}

template<>
ShaderManager *NodeManagers::manager<Shader>() const noexcept
{
    return m_shaderManager;
}

template<>
ShaderBuilderManager *NodeManagers::manager<ShaderBuilder>() const noexcept
{
    return m_shaderBuilderManager;
}

template<>
TechniqueManager *NodeManagers::manager<Technique>() const noexcept
{
    return m_techniqueManager;
}

template<>
EffectManager *NodeManagers::manager<Effect>() const noexcept
{
    return m_effectManager;
}

template<>
RenderPassManager *NodeManagers::manager<RenderPass>() const noexcept
{
    return m_renderPassManager;
}

template<>
TextureManager *NodeManagers::manager<Texture>() const noexcept
{
    return m_textureManager;
}

template<>
LayerManager *NodeManagers::manager<Layer>() const noexcept
{
    return m_layerManager;
}

template<>
LevelOfDetailManager *NodeManagers::manager<LevelOfDetail>() const noexcept
{
    return m_levelOfDetailManager;
}

template<>
FilterKeyManager *NodeManagers::manager<FilterKey>() const noexcept
{
    return m_filterKeyManager;
}

template<>
FrameGraphManager *NodeManagers::manager<FrameGraphNode*>() const noexcept
{
    return m_frameGraphManager;
}

template<>
TransformManager *NodeManagers::manager<Transform>() const noexcept
{
    return m_transformManager;
}

template<>
RenderTargetManager *NodeManagers::manager<RenderTarget>() const noexcept
{
    return m_renderTargetManager;
}

template<>
SceneManager *NodeManagers::manager<Scene>() const noexcept
{
    return m_sceneManager;
}

template<>
AttachmentManager *NodeManagers::manager<RenderTargetOutput>() const noexcept
{
    return m_attachmentManager;
}

template<>
ParameterManager *NodeManagers::manager<Parameter>() const noexcept
{
    return m_parameterManager;
}

template<>
ShaderDataManager *NodeManagers::manager<ShaderData>() const noexcept
{
    return m_shaderDataManager;
}

template<>
GLBufferManager *NodeManagers::manager<GLBuffer>() const noexcept
{
    return m_glBufferManager;
}

template<>
TextureImageManager *NodeManagers::manager<TextureImage>() const noexcept
{
    return m_textureImageManager;
}

template<>
BufferManager *NodeManagers::manager<Buffer>() const noexcept
{
    return m_bufferManager;
}

template<>
AttributeManager *NodeManagers::manager<Attribute>() const noexcept
{
    return m_attributeManager;
}

template<>
GeometryManager *NodeManagers::manager<Geometry>() const noexcept
{
    return m_geometryManager;
}

template<>
GeometryRendererManager *NodeManagers::manager<GeometryRenderer>() const noexcept
{
    return m_geometryRendererManager;
}

template<>
ObjectPickerManager *NodeManagers::manager<ObjectPicker>() const noexcept
{
    return m_objectPickerManager;
}

template<>
RayCasterManager *NodeManagers::manager<RayCaster>() const noexcept
{
    return m_rayCasterManager;
}

//template<>
//BoundingVolumeDebugManager *NodeManagers::manager<BoundingVolumeDebug>() const noexcept
//{
//    return m_boundingVolumeDebugManager;
//}

template<>
LightManager *NodeManagers::manager<Light>() const noexcept
{
    return m_lightManager;
}

template<>
EnvironmentLightManager *NodeManagers::manager<EnvironmentLight>() const noexcept
{
    return m_environmentLightManager;
}

template<>
ComputeCommandManager *NodeManagers::manager<ComputeCommand>() const noexcept
{
    return m_computeJobManager;
}

template<>
RenderStateManager *NodeManagers::manager<RenderStateNode>() const noexcept
{
    return m_renderStateManager;
}

template<>
ArmatureManager *NodeManagers::manager<Armature>() const noexcept
{
    return m_armatureManager;
}

template<>
SkeletonManager *NodeManagers::manager<Skeleton>() const noexcept
{
    return m_skeletonManager;
}

template<>
JointManager *NodeManagers::manager<Joint>() const noexcept
{
    return m_jointManager;
}

template<>
ShaderImageManager *NodeManagers::manager<ShaderImage>() const noexcept
{
    return m_shaderImageManager;
}

} // Render

} // Qt3DRender

QT_END_NAMESPACE