source: downloads/ColladaPlugin/src/OgreColladaLight.cpp @ 21

/**
 * This source file is part of OgreColladaPlugin
 * an addon for OGRE (Object-oriented Graphics Rendering Engine)
 * For the latest info, see http://www.ogre3d.org/
 *
 * This program is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option) any later
 * version.

 * This program 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 for more details.

 * You should have received a copy of the GNU Lesser General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place - Suite 330, Boston, MA 02111-1307, USA, or go to
 * http://www.gnu.org/copyleft/lesser.txt.
 *
 * @author      Philipp Hartl
 * @see         README
 */

#include "OgreColladaLight.h"
#include "OgreColladaDocument.h"
#include "OgreColladaScene.h"
#include "OgreColladaSyntax.h"
#include "OgreColladaUtils.h"

#include "OgreSceneManager.h"
#include "OgreStringConverter.h"

namespace Ogre
{
        //-------------------------------------------------------------------------
        ColladaLight::ColladaLight(ColladaDocument *d, xmlNode *n) : ColladaEntity(d, n) { }

        //-------------------------------------------------------------------------
        ColladaLight::~ColladaLight(void) { }

        //-------------------------------------------------------------------------
        MovableObject *ColladaLight::getOgreInstance(void) const
        {
                if (mType == ColladaLightSpecific::AMBIENT)
                {
                        mDoc->getSceneManager()->setAmbientLight(mColour);
                        return NULL;
                }

                // Light *light = new Light(mId);
                Light *light = mDoc->getSceneManager()->createLight(mId);

                light->setDiffuseColour(mColour);
                light->setSpecularColour(mColour);
                light->setDirection(Vector3(0, 0, -1));         // see collada spec

                if (mType == ColladaLightSpecific::DIRECTIONAL) light->setType(Light::LT_DIRECTIONAL);
                else if (mType == ColladaLightSpecific::POINT) light->setType(Light::LT_POINT);
                else if (mType == ColladaLightSpecific::SPOT) light->setType(Light::LT_SPOTLIGHT);

                if (mType == ColladaLightSpecific::POINT || mType == ColladaLightSpecific::SPOT)
                {
                        float constant = (mAttenuation == ColladaLightSpecific::CONSTANT) ? mAttenuationScale : 0;
                        float linear = (mAttenuation == ColladaLightSpecific::LINEAR) ? mAttenuationScale : 0;
                        float quadratic = (mAttenuation == ColladaLightSpecific::QUADRATIC) ? mAttenuationScale : 0;
                
                        float range = 100000;
                        ColladaBoundingBox *scenebox = mDoc->getScene()->getBoundingBox();
                        if (scenebox != NULL) range = scenebox->getRadius() * 2;

                        light->setAttenuation(range, constant, linear, quadratic);
                }

                if (mType == ColladaLightSpecific::SPOT)
                {
                        light->setSpotlightRange(Radian(0), Radian(Math::DegreesToRadians(mAngle)), mFalloffScale);
                }

                return light;
        }

        //-------------------------------------------------------------------------
        bool ColladaLight::doImport(void)
        {
                if (mLoaded) return mStatus;
                else mLoaded = true;

                // get light type
                String lighttype = ColladaUtils::getProperty(mNode, CS_ATR_TYPE);
                mType = ColladaLightSpecific::getType(lighttype);
                if (mType == ColladaLightSpecific::UNKNOWN)
                {
                        LogManager::getSingleton().logMessage("ColladaLight::doImport - light type " + lighttype + " unknown! " + mId);
                        return false;
                }

                // <asset> child
                // xmlNode *asset = ColladaUtils::getChildByTagName(mNode, CS_ELM_ASSET);

                // <param> childs, describes the values that the light contributes
                xmlNodePtrVector params = ColladaUtils::getChildsByTagName(mNode, CS_ELM_PARAM);
                for (xmlNodePtrVector::iterator it = params.begin(); it != params.end(); ++it)
                {
                        String name = ColladaUtils::getProperty(*it, CS_ATR_NAME);
                        String content = ColladaUtils::getContentDirect(*it);

                        /**
                         * if the type attribute value is DIRECTIONAL or SPOT 
                         * then the light's default direction vector in local
                         * coordinates is [0,0,-1], pointing down the -Z axis
                         */

                        // should be in every case
                        if (name == CS_VAL_LIGHT_PARAM_COLOR)
                        {
                                mColour = StringConverter::parseColourValue(content);
                        }
                        // point or spot
                        else if (name == CS_VAL_LIGHT_PARAM_ATTENUATION)
                        {
                                mAttenuation = ColladaLightSpecific::getFunction(content);
                        }
                        else if (name == CS_VAL_LIGHT_PARAM_ATTENUATION_SCALE)
                        {
                                mAttenuationScale = StringConverter::parseReal(content);
                        }
                        // especially for spot light
                        else if (name == CS_VAL_LIGHT_PARAM_ANGLE)
                        {
                                mAngle = StringConverter::parseReal(content);
                        }
                        else if (name == CS_VAL_LIGHT_PARAM_FALLOFF)
                        {
                                mFalloff = ColladaLightSpecific::getFunction(content);
                        }
                        else if (name == CS_VAL_LIGHT_PARAM_FALLOFF_SCALE)
                        {
                                mFalloffScale = StringConverter::parseReal(content);
                        }
                        else
                        {
                                LogManager::getSingleton().logMessage("ColladaLight::doImport - unknown attribute of light param " + name + "! " + mId);
                        }
                }

                mStatus = true;
                return mStatus;
        }

        //-------------------------------------------------------------------------
        namespace ColladaLightSpecific
        {
                Type getType(const String &s)
                {
                        if (s == CS_VAL_LIGHT_TYPE_AMBIENT) return AMBIENT;
                        else if (s == CS_VAL_LIGHT_TYPE_DIRECTIONAL) return DIRECTIONAL;
                        else if (s == CS_VAL_LIGHT_TYPE_POINT) return POINT;
                        else if (s == CS_VAL_LIGHT_TYPE_SPOT) return SPOT;
                        else return UNKNOWN;
                }

                Function getFunction(const String &s)
                {
                        if (s == CS_VAL_LIGHT_FUNCTION_CONSTANT) return CONSTANT;
                        else if (s == CS_VAL_LIGHT_FUNCTION_LINEAR) return LINEAR;
                        else if (s == CS_VAL_LIGHT_FUNCTION_QUADRATIC) return QUADRATIC;
                        else return CONSTANT;
                }
        }
}