// ================================================================================================
// 
// This file is part of the CAMPVis Software Framework.
// 
// If not explicitly stated otherwise: Copyright (C) 2012-2015, all rights reserved,
//      Christian Schulte zu Berge <christian.szb@in.tum.de>
//      Chair for Computer Aided Medical Procedures
//      Technische Universitaet Muenchen
//      Boltzmannstr. 3, 85748 Garching b. Muenchen, Germany
// 
// For a full list of authors and contributors, please refer to the file "AUTHORS.txt".
// 
// 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.
// 
// ================================================================================================

#include "stereorenderdemo.h"

#include "cgt/texturereadertga.h"

#include "core/datastructures/imagedata.h"
#include "core/datastructures/imagerepresentationgl.h"

#include "core/classification/geometry1dtransferfunction.h"
#include "core/classification/tfgeometry1d.h"

#include "core/datastructures/geometrydatafactory.h"

namespace campvis {

    StereoRenderDemo::StereoRenderDemo(DataContainer& dc)
        : AutoEvaluationPipeline(dc, getId())
        , _tcp(&_canvasSize)
        , _lsp()
        , _geometryReader()
        , _lvRendererL(&_canvasSize)
        , _teapotRendererL(&_canvasSize)
        , _compositorL(&_canvasSize)
        , _lvRendererR(&_canvasSize)
        , _teapotRendererR(&_canvasSize)
        , _compositorR(&_canvasSize)
        , _stereoComp(&_canvasSize)
    {
        addEventListenerToBack(&_tcp);

        addProcessor(&_tcp);
        addProcessor(&_stereoCamGenerator);
        addProcessor(&_lsp);
        addProcessor(&_geometryReader);
        addProcessor(&_teapotRendererL);
        addProcessor(&_lvRendererL);
        addProcessor(&_compositorL);
        addProcessor(&_teapotRendererR);
        addProcessor(&_lvRendererR);
        addProcessor(&_compositorR);
        addProcessor(&_stereoComp);
    }

    StereoRenderDemo::~StereoRenderDemo() {
        _geometryReader.s_validated.disconnect(this);
    }

    void StereoRenderDemo::init() {
        AutoEvaluationPipeline::init();

        // load textureData from file
        cgt::TextureReaderTga trt;
        cgt::Texture* campTexture = trt.loadTexture(ShdrMgr.completePath("/modules/vis/sampledata/camplogo.tga"), cgt::Texture::LINEAR);
        ImageData* textureData = new ImageData(2, campTexture->getDimensions(), campTexture->getNumChannels());
        ImageRepresentationGL::create(textureData, campTexture);
        getDataContainer().addData("CampTexture", textureData);

        // connect slots
        _geometryReader.s_validated.connect(this, &StereoRenderDemo::onProcessorValidated);

        // create Teapot
        auto teapot = GeometryDataFactory::createTeapot();
        teapot->applyTransformationToVertices(cgt::mat4::createScale(cgt::vec3(50.f)));
        getDataContainer().addData("teapot", teapot.release());

        // setup pipeline
        _geometryReader.p_url.setValue(ShdrMgr.completePath("/modules/vis/sampledata/left_ventricle_mesh.vtk"));
        _geometryReader.p_targetImageID.setValue("reader.output");

        _lvRendererL.p_geometryID.setValue("reader.output");
        _lvRendererL.p_renderTargetID.setValue("lv.render.left");
        _lvRendererL.p_renderMode.selectById("triangles");
        _lvRendererL.p_camera.setValue("camera.left");
        _lvRendererL.p_solidColor.setValue(cgt::vec4(0.8f, 0.f, 0.f, .9f));

        _lvRendererR.p_geometryID.setValue("reader.output");
        _lvRendererR.p_renderTargetID.setValue("lv.render.right");
        _lvRendererR.p_renderMode.selectById("triangles");
        _lvRendererR.p_camera.setValue("camera.right");
        _lvRendererR.p_solidColor.setValue(cgt::vec4(0.8f, 0.f, 0.f, .9f));

        _teapotRendererL.p_geometryID.setValue("teapot");
        _teapotRendererL.p_renderTargetID.setValue("teapot.render.left");
        _teapotRendererL.p_renderMode.selectById("trianglestrip");
        _teapotRendererL.p_showWireframe.setValue(false);
        _teapotRendererL.p_camera.setValue("camera.left");
        _teapotRendererL.p_solidColor.setValue(cgt::vec4(1.f, 0.5f, 0.f, 1.f));

        _teapotRendererR.p_geometryID.setValue("teapot");
        _teapotRendererR.p_renderTargetID.setValue("teapot.render.right");
        _teapotRendererR.p_renderMode.selectById("trianglestrip");
        _teapotRendererR.p_showWireframe.setValue(false);
        _teapotRendererR.p_camera.setValue("camera.right");
        _teapotRendererR.p_solidColor.setValue(cgt::vec4(1.f, 0.5f, 0.f, 1.f));

        _compositorL.p_firstImageId.setValue("lv.render.left");
        _compositorL.p_secondImageId.setValue("teapot.render.left");
        _compositorL.p_compositingMethod.selectById("depth");
        _compositorL.p_targetImageId.setValue("combine.left");
        _compositorL.p_enableBackground.setValue(false);

        _compositorR.p_firstImageId.setValue("lv.render.right");
        _compositorR.p_secondImageId.setValue("teapot.render.right");
        _compositorR.p_compositingMethod.selectById("depth");
        _compositorR.p_targetImageId.setValue("combine.right");
        _compositorR.p_enableBackground.setValue(false);

        _stereoComp.p_inputLeft.setValue("combine.left");
        _stereoComp.p_inputRight.setValue("combine.right");
        _stereoComp.p_outputImage.setValue("stereocombined");

        // setup the eye viewport size
        _lvRendererL.setViewportSizeProperty(&_stereoComp.p_preferredInputViewports);
        _teapotRendererL.setViewportSizeProperty(&_stereoComp.p_preferredInputViewports);
        _compositorL.setViewportSizeProperty(&_stereoComp.p_preferredInputViewports);
        _lvRendererR.setViewportSizeProperty(&_stereoComp.p_preferredInputViewports);
        _teapotRendererR.setViewportSizeProperty(&_stereoComp.p_preferredInputViewports);
        _compositorR.setViewportSizeProperty(&_stereoComp.p_preferredInputViewports);

        _renderTargetID.setValue("stereocombined");
    }

    void StereoRenderDemo::deinit() {
        _geometryReader.s_validated.disconnect(this);
        AutoEvaluationPipeline::deinit();
    }

    void StereoRenderDemo::onProcessorValidated(AbstractProcessor* processor) {
        if (processor == &_geometryReader) {
            // update camera
            ScopedTypedData<IHasWorldBounds> lv(*_dataContainer, _geometryReader.p_targetImageID.getValue());
            ScopedTypedData<IHasWorldBounds> teapot(*_dataContainer, "teapot");

            if (lv != 0 && teapot != 0) {
                cgt::Bounds unionBounds;
                //unionBounds.addVolume(lv->getWorldBounds());
                unionBounds.addVolume(teapot->getWorldBounds());

                _tcp.reinitializeCamera(unionBounds);
            }
        }
    }


}