// Copyright (C) 2002-2003 Gideon May (gideon@computer.org)
//
// Permission to copy, use, sell and distribute this software is granted
// provided this copyright notice appears in all copies.
// Permission to modify the code and to distribute modified code is granted
// provided this copyright notice appears in all copies, and a notice
// that the code was modified is included with the copyright notice.
//
// This software is provided "as is" without express or implied warranty,
// and with no claim as to its suitability for any purpose.
#include <osg/Version>
#if (OSG_VERSION_MAJOR>=1)
#include <boost/python/module.hpp>
#include <boost/python/def.hpp>
#include <boost/python/class.hpp>
#include <boost/python/enum.hpp>
#include <boost/python/call_method.hpp>
#include <boost/python/object.hpp>
#include <boost/python/extract.hpp>
#include <boost/python/return_value_policy.hpp>
#include <boost/python/return_by_value.hpp>
#include <boost/python/copy_const_reference.hpp>
#include <boost/ref.hpp>

#include <osg/CameraNode>

#include <string>
#include <iostream>

#include "Transform.hpp"
#include "held_ptr.hpp"

using namespace boost::python;

namespace
{
   DEFINE_TRANSFORM_CAST(CameraNode)
}

namespace PyOSG
{
   void init_CameraNode()
   {
      REGISTER_TRANSFORM_CAST(CameraNode)

      class_<osg::CameraNode, osg::ref_ptr<osg::CameraNode>, bases<osg::Transform>, boost::noncopyable> cameraNode("CameraNode", no_init);

      cameraNode.def(init<>());

      cameraNode.def("setClearColor",
                     &osg::CameraNode::setClearColor);
      cameraNode.def("getClearColor",
                     &osg::CameraNode::getClearColor,
                     return_value_policy<copy_const_reference>());

      cameraNode.def("setClearMask",
                     &osg::CameraNode::setClearMask);
      cameraNode.def("getClearMask",
                     &osg::CameraNode::getClearMask);

      cameraNode.def("setColorMask",
                     (void (osg::CameraNode::*)(osg::ColorMask*)) &osg::CameraNode::setColorMask);
      cameraNode.def("setColorMask",
                     (void (osg::CameraNode::*)(bool, bool, bool, bool)) &osg::CameraNode::setColorMask);
      cameraNode.def("getColorMask",
                     (const osg::ColorMask* (osg::CameraNode::*)() const) &osg::CameraNode::getColorMask,
                     return_value_policy<manage_osg_object>());

      cameraNode.def("setViewport",
                     (void (osg::CameraNode::*)(osg::Viewport*)) &osg::CameraNode::setViewport);
      cameraNode.def("setViewport",
                     (void (osg::CameraNode::*)(int, int, int, int)) &osg::CameraNode::setViewport);
      cameraNode.def("getViewport",
                     (const osg::Viewport* (osg::CameraNode::*)() const) &osg::CameraNode::getViewport,
                     return_value_policy<manage_osg_object>());

      cameraNode.def("setTransformOrder",
                     &osg::CameraNode::setTransformOrder);
      cameraNode.def("getTransformOrder",
                     &osg::CameraNode::getTransformOrder);

#ifdef OSG_USE_DOUBLE_MATRICES
      cameraNode.def("setProjectionMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixd& matrix)) &osg::CameraNode::setProjectionMatrix);
#else
      cameraNode.def("setProjectionMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixf& matrix)) &osg::CameraNode::setProjectionMatrix);
#endif /* OSG_USE_DOUBLE_MATRICES */

      cameraNode.def("setProjectionMatrixAsOrtho",
                     &osg::CameraNode::setProjectionMatrixAsOrtho);

      cameraNode.def("setProjectionMatrixAsOrtho2D",
                     &osg::CameraNode::setProjectionMatrixAsOrtho2D);

      cameraNode.def("setProjectionMatrixAsFrustum",
                     &osg::CameraNode::setProjectionMatrixAsFrustum);

      cameraNode.def("setProjectionMatrixAsPerspective",
                     &osg::CameraNode::setProjectionMatrixAsPerspective);

#ifdef OSG_USE_DOUBLE_MATRICES
      cameraNode.def("getProjectionMatrix",
                     (osg::Matrixd& (osg::CameraNode::*)()) &osg::CameraNode::getProjectionMatrix,
                     return_internal_reference<>());
#else
      cameraNode.def("getProjectionMatrix",
                     (osg::Matrixf& (osg::CameraNode::*)()) &osg::CameraNode::getProjectionMatrix,
                     return_internal_reference<>());
#endif /* OSG_USE_DOUBLE_MATRICES */

      cameraNode.def("getProjectionMatrixAsOrtho",
                     &osg::CameraNode::getProjectionMatrixAsOrtho);


      cameraNode.def("getProjectionMatrixAsFrustum",
                     &osg::CameraNode::getProjectionMatrixAsFrustum);


      cameraNode.def("getProjectionMatrixAsPerspective",
                     &osg::CameraNode::getProjectionMatrixAsPerspective);

#ifdef OSG_USE_DOUBLE_MATRICES
      cameraNode.def("setViewMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixd &)) &osg::CameraNode::setViewMatrix);
#else
      cameraNode.def("setViewMatrix",
                     (void (osg::CameraNode::*)(const osg::Matrixf &)) &osg::CameraNode::setViewMatrix);
#endif /* OSG_USE_DOUBLE_MATRICES */

      cameraNode.def("setViewMatrixAsLookAt",
                     &osg::CameraNode::setViewMatrixAsLookAt);


      cameraNode.def("getViewMatrix",
                     (const osg::Matrixd & (osg::CameraNode::*)() const) &osg::CameraNode::getViewMatrix,
                     return_value_policy<copy_const_reference>());

      cameraNode.def("getViewMatrixAsLookAt",
                     &osg::CameraNode::getViewMatrixAsLookAt);

      cameraNode.def("getInverseViewMatrix",
                     &osg::CameraNode::getInverseViewMatrix);

      cameraNode.def("setRenderOrder",
                     &osg::CameraNode::setRenderOrder);
      cameraNode.def("getRenderOrder",
                     &osg::CameraNode::getRenderOrder);

      cameraNode.def("setRenderTargetImplementation",
                    (void (osg::CameraNode::*)(osg::CameraNode::RenderTargetImplementation impl))
                     &osg::CameraNode::setRenderTargetImplementation);
      cameraNode.def("getRenderTargetImplementation",
                     &osg::CameraNode::getRenderTargetImplementation);

      cameraNode.def("setDrawBuffer",
                     &osg::CameraNode::setDrawBuffer);
      cameraNode.def("getDrawBuffer",
                     &osg::CameraNode::getDrawBuffer);

// Deprecated
//      cameraNode.def("getRenderBufferList",
//                     (const osg::CameraNode::RenderBufferList &(osg::CameraNode::*)() const) &osg::CameraNode::getRenderBufferList,
//                     return_value_policy<copy_const_reference>());

      cameraNode.def("setReadBuffer",
                     &osg::CameraNode::setReadBuffer);

      cameraNode.def("getReadBuffer",
                     &osg::CameraNode::getReadBuffer);

      cameraNode.def("attach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent, GLenum)) &osg::CameraNode::attach);

      cameraNode.def("attach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent,
                                                osg::Texture *,
                                                unsigned int,
                                                unsigned int,
                                                bool)) &osg::CameraNode::attach);

      cameraNode.def("attach",
                     (void (osg::CameraNode::*)(osg::CameraNode::BufferComponent, osg::Image*)) &osg::CameraNode::attach);

      cameraNode.def("detach",
                     &osg::CameraNode::detach);

#   define OSG_ENUM_MODE(VALUE) \
    (renderorder.value(#VALUE, osg::CameraNode::VALUE), \
    cameraNode.def(#VALUE, object(osg::CameraNode::VALUE)))
    enum_<osg::CameraNode::RenderOrder> renderorder("RenderOrder");

    OSG_ENUM_MODE(PRE_RENDER);
    OSG_ENUM_MODE(NESTED_RENDER);
    OSG_ENUM_MODE(POST_RENDER);


   }
}

#endif // (OSG_VERSION_MAJOR>=1)