Quelle  ximp3dscene.cxx   Sprache: C

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you 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 .
 */

#include <sax/tools/converter.hxx>
#include <sal/log.hxx>

#include "ximp3dscene.hxx"
#include <xmloff/xmluconv.hxx>
#include <xexptran.hxx>
#include <xmloff/xmltoken.hxx>
#include <xmloff/xmlnamespace.hxx>
#include <com/sun/star/beans/XPropertySet.hpp>
#include <com/sun/star/drawing/Direction3D.hpp>
#include <com/sun/star/drawing/CameraGeometry.hpp>
#include "eventimp.hxx"
#include "descriptionimp.hxx"

using namespace ::com::sun::star;
using namespace ::xmloff::token;

// dr3d:3dlight context

SdXML3DLightContext::SdXML3DLightContext(
    SvXMLImport& rImport,
    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
:   SvXMLImportContext( rImport ),
    maDiffuseColor(0x00000000),
    maDirection(0.0, 0.0, 1.0),
    mbEnabled(false),
    mbSpecular(false)
{
    // read attributes for the 3DScene
    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
    {
        switch(aIter.getToken())
        {
            case XML_ELEMENT(DR3D, XML_DIFFUSE_COLOR):
            {
                ::sax::Converter::convertColor(maDiffuseColor, aIter.toView());
                break;
            }
            case XML_ELEMENT(DR3D, XML_DIRECTION):
            {
                ::basegfx::B3DVector aVal;
                SvXMLUnitConverter::convertB3DVector(aVal, aIter.toView());
                if (!std::isnan(aVal.getX()) && !std::isnan(aVal.getY()) && !std::isnan(aVal.getZ()))
                {
                    maDirection = aVal;
                }
                else
                {
                    SAL_WARN("xmloff", "NaNs found in light direction: " << aIter.toString());
                }
                break;
            }
            case XML_ELEMENT(DR3D, XML_ENABLED):
            {
                (void)::sax::Converter::convertBool(mbEnabled, aIter.toView());
                break;
            }
            case XML_ELEMENT(DR3D, XML_SPECULAR):
            {
                (void)::sax::Converter::convertBool(mbSpecular, aIter.toView());
                break;
            }
            default:
                XMLOFF_WARN_UNKNOWN("xmloff", aIter);
        }
    }
}

SdXML3DLightContext::~SdXML3DLightContext()
{
}


SdXML3DSceneShapeContext::SdXML3DSceneShapeContext(
    SvXMLImport& rImport,
    const css::uno::Reference< css::xml::sax::XFastAttributeList>& xAttrList,
    uno::Reference< drawing::XShapes > const & rShapes,
    bool bTemporaryShapes)
:   SdXMLShapeContext( rImport, xAttrList, rShapes, bTemporaryShapes ), SdXML3DSceneAttributesHelper( rImport )
{
}

SdXML3DSceneShapeContext::~SdXML3DSceneShapeContext()
{
}

void SdXML3DSceneShapeContext::startFastElement(
    sal_Int32 nElement,
    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
{
    // create new 3DScene shape and add it to rShapes, use it
    // as base for the new 3DScene import
    AddShape( u"com.sun.star.drawing.Shape3DSceneObject"_ustr );
    if( mxShape.is() )
    {
        SetStyle();

        mxChildren.set( mxShape, uno::UNO_QUERY );
        if( mxChildren.is() )
            GetImport().GetShapeImport()->pushGroupForPostProcessing( mxChildren );

        SetLayer();

        // set pos, size, shear and rotate
        SetTransformation();
    }

    // read attributes for the 3DScene
    for( auto& aIter : sax_fastparser::castToFastAttributeList(xAttrList) )
        processSceneAttribute( aIter );

    // #91047# call parent function is missing here, added it
    if(mxShape.is())
    {
        // call parent
        SdXMLShapeContext::startFastElement(nElement, xAttrList);
    }
}

void SdXML3DSceneShapeContext::endFastElement(sal_Int32 nElement)
{
    if(!mxShape.is())
        return;

    uno::Reference< beans::XPropertySet > xPropSet(mxShape, uno::UNO_QUERY);
    if(xPropSet.is())
    {
        setSceneAttributes( xPropSet );
    }

    if( mxChildren.is() )
        GetImport().GetShapeImport()->popGroupAndPostProcess();

    // call parent
    SdXMLShapeContext::endFastElement(nElement);
}

css::uno::Reference< css::xml::sax::XFastContextHandler > SdXML3DSceneShapeContext::createFastChildContext(
    sal_Int32 nElement,
    const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList )
{
    SvXMLImportContextRef xContext;
    switch (nElement)
    {
        // #i68101#
        case XML_ELEMENT(SVG, XML_TITLE):
        case XML_ELEMENT(SVG_COMPAT, XML_TITLE):
        case XML_ELEMENT(SVG, XML_DESC):
        case XML_ELEMENT(SVG_COMPAT, XML_DESC):
            xContext = new SdXMLDescriptionContext( GetImport(), nElement, mxShape );
            break;
        case XML_ELEMENT(OFFICE, XML_EVENT_LISTENERS):
            xContext = new SdXMLEventsContext( GetImport(), mxShape );
            break;
        // look for local light context first
        case XML_ELEMENT(DR3D, XML_LIGHT):
            // dr3d:light inside dr3d:scene context
            xContext = create3DLightContext( xAttrList );
            break;
        default:
            // call GroupChildContext function at common ShapeImport
            return XMLShapeImportHelper::Create3DSceneChildContext(
                GetImport(), nElement, xAttrList, mxChildren);
    }
    return xContext;
}

SdXML3DSceneAttributesHelper::SdXML3DSceneAttributesHelper( SvXMLImport& rImporter )
:   mrImport( rImporter ),
    mbSetTransform( false ),
    mxPrjMode(drawing::ProjectionMode_PERSPECTIVE),
    mnDistance(1000),
    mnFocalLength(1000),
    mnShadowSlant(0),
    mxShadeMode(drawing::ShadeMode_SMOOTH),
    maAmbientColor(0x00666666),
    mbLightingMode(false),
    maVRP(0.0, 0.0, 1.0),
    maVPN(0.0, 0.0, 1.0),
    maVUP(0.0, 1.0, 0.0),
    mbVRPUsed(false)
{
}

/** creates a 3d light context and adds it to the internal list for later processing */
SvXMLImportContext * SdXML3DSceneAttributesHelper::create3DLightContext( const css::uno::Reference< css::xml::sax::XFastAttributeList >& xAttrList)
{
    const rtl::Reference<SdXML3DLightContext> xContext{new SdXML3DLightContext(mrImport, xAttrList)};

    // remember SdXML3DLightContext for later evaluation
    maList.push_back(xContext);

    return xContext.get();
}

/** this should be called for each scene attribute */
void SdXML3DSceneAttributesHelper::processSceneAttribute( const sax_fastparser::FastAttributeList::FastAttributeIter & aIter )
{
    auto nAttributeToken = aIter.getToken();
    if( !IsTokenInNamespace(nAttributeToken, XML_NAMESPACE_DR3D) )
        return;

    switch(nAttributeToken & TOKEN_MASK)
    {
        case XML_TRANSFORM:
        {
            SdXMLImExTransform3D aTransform(aIter.toString(), mrImport.GetMM100UnitConverter());
            if(aTransform.NeedsAction())
                mbSetTransform = aTransform.GetFullHomogenTransform(mxHomMat);
            return;
        }
        case XML_VRP:
        {
            ::basegfx::B3DVector aNewVec;
            SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());

            if(aNewVec != maVRP)
            {
                maVRP = aNewVec;
                mbVRPUsed = true;
            }
            return;
        }
        case XML_VPN:
        {
            ::basegfx::B3DVector aNewVec;
            SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());

            if(aNewVec != maVPN)
            {
                maVPN = aNewVec;
            }
            return;
        }
        case XML_VUP:
        {
            ::basegfx::B3DVector aNewVec;
            SvXMLUnitConverter::convertB3DVector(aNewVec, aIter.toView());

            if(aNewVec != maVUP)
            {
                maVUP = aNewVec;
            }
            return;
        }
        case XML_PROJECTION:
        {
            if( IsXMLToken( aIter, XML_PARALLEL ) )
                mxPrjMode = drawing::ProjectionMode_PARALLEL;
            else
                mxPrjMode = drawing::ProjectionMode_PERSPECTIVE;
            return;
        }
        case XML_DISTANCE:
        {
            mrImport.GetMM100UnitConverter().convertMeasureToCore(mnDistance,
                    aIter.toView());
            return;
        }
        case XML_FOCAL_LENGTH:
        {
            mrImport.GetMM100UnitConverter().convertMeasureToCore(mnFocalLength,
                    aIter.toView());
            return;
        }
        case XML_SHADOW_SLANT:
        {
            double fAngle = 0.0;
            if (::sax::Converter::convertAngle(fAngle, aIter.toView()))
                mnShadowSlant = static_cast<sal_Int32>(basegfx::fround(fAngle));
            else
                mnShadowSlant = 0;
            return;
        }
        case XML_SHADE_MODE:
        {
            if( IsXMLToken( aIter, XML_FLAT ) )
                mxShadeMode = drawing::ShadeMode_FLAT;
            else if( IsXMLToken( aIter, XML_PHONG ) )
                mxShadeMode = drawing::ShadeMode_PHONG;
            else if( IsXMLToken( aIter, XML_GOURAUD ) )
                mxShadeMode = drawing::ShadeMode_SMOOTH;
            else
                mxShadeMode = drawing::ShadeMode_DRAFT;
            return;
        }
        case XML_AMBIENT_COLOR:
        {
            ::sax::Converter::convertColor(maAmbientColor, aIter.toView());
            return;
        }
        case XML_LIGHTING_MODE:
        {
            (void)::sax::Converter::convertBool(mbLightingMode, aIter.toView());
            return;
        }
        default:
            XMLOFF_WARN_UNKNOWN("xmloff", aIter);
    }
}

/** this sets the scene attributes at this propertyset */
void SdXML3DSceneAttributesHelper::setSceneAttributes( const css::uno::Reference< css::beans::XPropertySet >& xPropSet )
{
    uno::Any aAny;

    // world transformation
    if(mbSetTransform)
    {
        xPropSet->setPropertyValue(u"D3DTransformMatrix"_ustr, uno::Any(mxHomMat));
    }

    // distance
    xPropSet->setPropertyValue(u"D3DSceneDistance"_ustr, uno::Any(mnDistance));
    // focalLength
    xPropSet->setPropertyValue(u"D3DSceneFocalLength"_ustr, uno::Any(mnFocalLength));
    // shadowSlant
    xPropSet->setPropertyValue(u"D3DSceneShadowSlant"_ustr, uno::Any(static_cast<sal_Int16>(mnShadowSlant)));
    // shadeMode
    xPropSet->setPropertyValue(u"D3DSceneShadeMode"_ustr, uno::Any(mxShadeMode));
    // ambientColor
    xPropSet->setPropertyValue(u"D3DSceneAmbientColor"_ustr, uno::Any(maAmbientColor));
    // lightingMode
    xPropSet->setPropertyValue(u"D3DSceneTwoSidedLighting"_ustr, uno::Any(mbLightingMode));

    if( !maList.empty() )
    {
        uno::Any aAny2;
        uno::Any aAny3;

        // set lights
        for( size_t a = 0; a < maList.size(); a++)
        {
            SdXML3DLightContext* pCtx = maList[ a ].get();

            // set anys
            aAny <<= pCtx->GetDiffuseColor();
            drawing::Direction3D aLightDir;
            aLightDir.DirectionX = pCtx->GetDirection().getX();
            aLightDir.DirectionY = pCtx->GetDirection().getY();
            aLightDir.DirectionZ = pCtx->GetDirection().getZ();
            aAny2 <<= aLightDir;
            aAny3 <<= pCtx->GetEnabled();

            switch(a)
            {
                case 0:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor1"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection1"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn1"_ustr, aAny3);
                    break;
                }
                case 1:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor2"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection2"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn2"_ustr, aAny3);
                    break;
                }
                case 2:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor3"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection3"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn3"_ustr, aAny3);
                    break;
                }
                case 3:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor4"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection4"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn4"_ustr, aAny3);
                    break;
                }
                case 4:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor5"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection5"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn5"_ustr, aAny3);
                    break;
                }
                case 5:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor6"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection6"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn6"_ustr, aAny3);
                    break;
                }
                case 6:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor7"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection7"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn7"_ustr, aAny3);
                    break;
                }
                case 7:
                {
                    xPropSet->setPropertyValue(u"D3DSceneLightColor8"_ustr, aAny);
                    xPropSet->setPropertyValue(u"D3DSceneLightDirection8"_ustr, aAny2);
                    xPropSet->setPropertyValue(u"D3DSceneLightOn8"_ustr, aAny3);
                    break;
                }
            }
        }
    }

    // CameraGeometry and camera settings
    drawing::CameraGeometry aCamGeo;
    aCamGeo.vrp.PositionX = maVRP.getX();
    aCamGeo.vrp.PositionY = maVRP.getY();
    aCamGeo.vrp.PositionZ = maVRP.getZ();
    aCamGeo.vpn.DirectionX = maVPN.getX();
    aCamGeo.vpn.DirectionY = maVPN.getY();
    aCamGeo.vpn.DirectionZ = maVPN.getZ();
    aCamGeo.vup.DirectionX = maVUP.getX();
    aCamGeo.vup.DirectionY = maVUP.getY();
    aCamGeo.vup.DirectionZ = maVUP.getZ();
    xPropSet->setPropertyValue(u"D3DCameraGeometry"_ustr, uno::Any(aCamGeo));

    // #91047# set drawing::ProjectionMode AFTER camera geometry is set
    // projection "D3DScenePerspective" drawing::ProjectionMode
    xPropSet->setPropertyValue(u"D3DScenePerspective"_ustr, uno::Any(mxPrjMode));
}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */