TransitionImpl.hxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*************************************************************************
 *
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * Copyright 2008 by Sun Microsystems, Inc.
 *
 * OpenOffice.org - a multi-platform office productivity suite
 *
 * This file is part of OpenOffice.org.
 *
 * OpenOffice.org is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License version 3
 * only, as published by the Free Software Foundation.
 *
 * OpenOffice.org 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 version 3 for more details
 * (a copy is included in the LICENSE file that accompanied this code).
 *
 * You should have received a copy of the GNU Lesser General Public License
 * version 3 along with OpenOffice.org.  If not, see
 * <http://www.openoffice.org/license.html>
 * for a copy of the LGPLv3 License.
 *
 ************************************************************************/
#ifndef INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
#define INCLUDED_OGLTRANS_TRANSITIONIMPL_HXX_
 
#include <config_lgpl.h>
#include <epoxy/gl.h>
#include <glm/gtc/type_ptr.hpp>
 
#include <o3tl/safeint.hxx>
#include <sal/types.h>
 
#include <limits>
#include <memory>
#include <vector>
 
class Primitive;
class OpenGLContext;
class Operation;
class SceneObject;
class TransitionData;
 
struct TransitionSettings
{
    TransitionSettings() :
        mbUseMipMapLeaving( true ),
        mbUseMipMapEntering( true ),
        mnRequiredGLVersion( 3.0f )
    {
    }
 
    bool mbUseMipMapLeaving;
    bool mbUseMipMapEntering;
 
    float mnRequiredGLVersion;
};
 
typedef std::vector<Primitive> Primitives_t;
typedef std::vector<std::shared_ptr<SceneObject> > SceneObjects_t;
typedef std::vector<std::shared_ptr<Operation> > Operations_t;
 
class TransitionScene
{
public:
    inline TransitionScene(
            Primitives_t&& rLeavingSlidePrimitives,
            Primitives_t&& rEnteringSlidePrimitives,
            Operations_t&& rOverallOperations = Operations_t(),
            SceneObjects_t&& rSceneObjects = SceneObjects_t()
    );
 
    inline ~TransitionScene();
 
    TransitionScene(TransitionScene const& rOther);
    TransitionScene& operator=(const TransitionScene& rOther);
 
    void swap(TransitionScene& rOther);
 
    const Primitives_t& getLeavingSlide() const
    {
        return maLeavingSlidePrimitives;
    }
 
    const Primitives_t& getEnteringSlide() const
    {
        return maEnteringSlidePrimitives;
    }
 
    const Operations_t& getOperations() const
    {
        return maOverallOperations;
    }
 
    const SceneObjects_t& getSceneObjects() const
    {
        return maSceneObjects;
    }
 
private:
    Primitives_t maLeavingSlidePrimitives;
 
    Primitives_t maEnteringSlidePrimitives;
 
    Operations_t maOverallOperations;
 
    SceneObjects_t maSceneObjects;
};
 
class OGLTransitionImpl
{
public:
    virtual ~OGLTransitionImpl();
 
    OGLTransitionImpl(const OGLTransitionImpl&) = delete;
    OGLTransitionImpl& operator=(const OGLTransitionImpl&) = delete;
 
    bool prepare( sal_Int32 glLeavingSlideTex, sal_Int32 glEnteringSlideTex, OpenGLContext *pContext );
    void display( double nTime, sal_Int32 glLeavingSlideTex, sal_Int32 glEnteringSlideTex, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight, OpenGLContext *pContext );
    void finish();
 
    TransitionSettings const& getSettings() const
    {
        return maSettings;
    }
 
protected:
    OGLTransitionImpl(const TransitionScene& rScene, const TransitionSettings& rSettings)
        : maScene(rScene)
        , maSettings(rSettings)
    {}
 
    TransitionScene const& getScene() const
    {
        return maScene;
    }
 
    void displaySlide( double nTime, sal_Int32 glSlideTex, const Primitives_t& primitives, double SlideWidthScale, double SlideHeightScale );
    void displayUnbufferedSlide( double nTime, sal_Int32 glSlideTex, const Primitives_t& primitives, double SlideWidthScale, double SlideHeightScale );
    void displayScene( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight);
    void applyOverallOperations( double nTime, double SlideWidthScale, double SlideHeightScale );
 
private:
    virtual void prepare( double SlideWidth, double SlideHeight );
 
    virtual void cleanup();
 
    virtual void prepareTransition( sal_Int32 glLeavingSlideTex, sal_Int32 glEnteringSlideTex, OpenGLContext *pContext );
 
    virtual void finishTransition();
 
    virtual void displaySlides_( double nTime, sal_Int32 glLeavingSlideTex, sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale, OpenGLContext *pContext );
 
    virtual GLuint makeShader() const = 0;
 
private:
    const TransitionScene maScene;
    const TransitionSettings maSettings;
 
    void uploadModelViewProjectionMatrices();
 
    GLint m_nPrimitiveTransformLocation = -1;
    GLint m_nSceneTransformLocation = -1;
    GLint m_nOperationsTransformLocation = -1;
 
    GLint m_nPositionLocation = -1;
    GLint m_nNormalLocation = -1;
    GLint m_nTexCoordLocation = -1;
 
    GLuint m_nVertexArrayObject = 0u;
 
    std::vector<int> m_nFirstIndices;
 
protected:
    GLuint m_nProgramObject = 0u;
 
    GLuint m_nVertexBufferObject = 0u;
 
    GLint m_nTimeLocation = -1;
};
 
 
// "Constructors" of available transitions
std::shared_ptr<OGLTransitionImpl> makeOutsideCubeFaceToLeft();
std::shared_ptr<OGLTransitionImpl> makeInsideCubeFaceToLeft();
std::shared_ptr<OGLTransitionImpl> makeNByMTileFlip( sal_uInt16 n, sal_uInt16 m );
std::shared_ptr<OGLTransitionImpl> makeRevolvingCircles( sal_uInt16 nCircles , sal_uInt16 nPointsOnCircles );
std::shared_ptr<OGLTransitionImpl> makeHelix( sal_uInt16 nRows );
std::shared_ptr<OGLTransitionImpl> makeFallLeaving();
std::shared_ptr<OGLTransitionImpl> makeTurnAround();
std::shared_ptr<OGLTransitionImpl> makeTurnDown();
std::shared_ptr<OGLTransitionImpl> makeIris();
std::shared_ptr<OGLTransitionImpl> makeRochade();
std::shared_ptr<OGLTransitionImpl> makeVenetianBlinds( bool vertical, int parts );
std::shared_ptr<OGLTransitionImpl> makeStatic();
std::shared_ptr<OGLTransitionImpl> makeDissolve();
std::shared_ptr<OGLTransitionImpl> makeVortex();
std::shared_ptr<OGLTransitionImpl> makeRipple();
std::shared_ptr<OGLTransitionImpl> makeGlitter();
std::shared_ptr<OGLTransitionImpl> makeHoneycomb();
std::shared_ptr<OGLTransitionImpl> makeNewsflash();
 
std::shared_ptr<OGLTransitionImpl> makeDiamond();
std::shared_ptr<OGLTransitionImpl> makeFadeSmoothly();
// fade through black or white
std::shared_ptr<OGLTransitionImpl> makeFadeThroughColor( bool white = false );
 
class SceneObject
{
public:
    SceneObject();
    virtual ~SceneObject();
    SceneObject(const SceneObject&) = delete;
    SceneObject& operator=(const SceneObject&) = delete;
 
    virtual void prepare(GLuint /* program */) {}
    virtual void display(GLint sceneTransformLocation, GLint primitiveTransformLocation, double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight ) const;
    virtual void finish() {}
 
    void pushPrimitive (const Primitive &p);
 
protected:
    Primitives_t maPrimitives;
    std::vector<int> maFirstIndices;
};
 
struct Vertex
{
    glm::vec3 position;
    glm::vec3 normal;
    glm::vec2 texcoord;
};
static_assert(sizeof(Vertex) == (3 + 3 + 2) * 4, "Vertex struct has wrong size/alignment");
 
class Primitive
{
public:
    Primitive() {}
    // making copy constructor explicit makes the class un-suitable for use with stl containers
    Primitive(const Primitive& rvalue);
    Primitive& operator=(const Primitive& rvalue);
 
    void swap(Primitive& rOther);
 
    void applyOperations(glm::mat4& matrix, double nTime, double SlideWidthScale, double SlideHeightScale) const;
    void display(GLint primitiveTransformLocation, double nTime, double WidthScale, double HeightScale) const;
    void display(GLint primitiveTransformLocation, double nTime, double WidthScale, double HeightScale, int first) const;
 
    void pushTriangle(const glm::vec2& SlideLocation0,const glm::vec2& SlideLocation1,const glm::vec2& SlideLocation2);
 
    const glm::vec3& getVertex(int n) const {return Vertices[n].position;}
 
    int getVerticesCount() const
    {
        assert(Vertices.size() < o3tl::make_unsigned(std::numeric_limits<int>::max()));
        return int(unsigned(Vertices.size()));
    }
 
    int getVerticesByteSize() const {return Vertices.size() * sizeof(Vertex);}
 
    int writeVertices(Vertex *location) const {
        std::copy(Vertices.begin(), Vertices.end(), location);
        return Vertices.size();
    }
 
    Operations_t Operations;
 
private:
    std::vector<Vertex> Vertices;
};
 
TransitionScene::TransitionScene(
        Primitives_t&& rLeavingSlidePrimitives,
        Primitives_t&& rEnteringSlidePrimitives,
        Operations_t&& rOverallOperations,
        SceneObjects_t&& rSceneObjects
)
    : maLeavingSlidePrimitives(std::move(rLeavingSlidePrimitives))
    , maEnteringSlidePrimitives(std::move(rEnteringSlidePrimitives))
    , maOverallOperations(std::move(rOverallOperations))
    , maSceneObjects(std::move(rSceneObjects))
{
}
 
TransitionScene::~TransitionScene() = default;
 
#endif // INCLUDED_SLIDESHOW_TRANSITION_HXX_
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */