/** * @file llwldaycycle.cpp * @brief Implementation for the LLWLDayCycle class. * * $LicenseInfo:firstyear=2007&license=viewerlgpl$ * Second Life Viewer Source Code * Copyright (C) 2010, Linden Research, Inc. * * This library 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; * version 2.1 of the License only. * * This library 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 library; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA * * Linden Research, Inc., 945 Battery Street, San Francisco, CA 94111 USA * $/LicenseInfo$ */ #include "llviewerprecompiledheaders.h" #include "llwldaycycle.h" #include "llsdserialize.h" #include "llwlparammanager.h" #include "llnotifications.h" #include "llviewerwindow.h" #include <map> LLWLDayCycle::LLWLDayCycle() : mDayRate(120) { } LLWLDayCycle::~LLWLDayCycle() { } void LLWLDayCycle::loadDayCycle(const LLSD& day_data, LLWLParamKey::EScope scope) { #if 0 LL_DEBUGS() << "Loading day cycle (day_data.size() = " << day_data.size() << ", scope = " << scope << ")" << LL_ENDL; mTimeMap.clear(); // add each key frame for(S32 i = 0; i < day_data.size(); ++i) { // make sure it's a two array if(day_data[i].size() != 2) { continue; } // check each param key exists in param manager bool success; LLWLParamSet pset; LLWLParamKey frame = LLWLParamKey(day_data[i][1].asString(), scope); success = LLWLParamManager::getInstance()->getParamSet(frame, pset); if(!success) { // *HACK: If loading region day cycle, try local sky presets as well. // Local presets may be referenced by a region day cycle after // it has been edited but the changes have not been uploaded. if (scope == LLEnvKey::SCOPE_REGION) { frame.scope = LLEnvKey::SCOPE_LOCAL; success = LLWLParamManager::getInstance()->getParamSet(frame, pset); } if (!success) { // alert the user LLSD args; args["SKY"] = day_data[i][1].asString(); LLNotifications::instance().add("WLMissingSky", args, LLSD()); continue; } } // then add the keyframe addKeyframe((F32)day_data[i][0].asReal(), frame); } #endif } void LLWLDayCycle::loadDayCycleFromFile(const std::string & fileName) { loadDayCycle(loadCycleDataFromFile(fileName), LLWLParamKey::SCOPE_LOCAL); } /*static*/ LLSD LLWLDayCycle::loadCycleDataFromFile(const std::string & fileName) { // *FIX: Cannot load user day cycles. std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/days", fileName)); return loadDayCycleFromPath(pathName); } // static LLSD LLWLDayCycle::loadDayCycleFromPath(const std::string& file_path) { LL_DEBUGS("Windlight") << "Loading DayCycle settings from " << file_path << LL_ENDL; llifstream day_cycle_xml(file_path.c_str()); if (day_cycle_xml.is_open()) { // load and parse it LLSD day_data(LLSD::emptyArray()); LLPointer<LLSDParser> parser = new LLSDXMLParser(); parser->parse(day_cycle_xml, day_data, LLSDSerialize::SIZE_UNLIMITED); day_cycle_xml.close(); return day_data; } else { return LLSD(); } } void LLWLDayCycle::saveDayCycle(const std::string & fileName) { std::string pathName(gDirUtilp->getExpandedFilename(LL_PATH_APP_SETTINGS, "windlight/days", fileName)); //LL_INFOS() << "Saving WindLight settings to " << pathName << LL_ENDL; save(pathName); } void LLWLDayCycle::save(const std::string& file_path) { LLSD day_data = asLLSD(); llofstream day_cycle_xml(file_path.c_str()); LLPointer<LLSDFormatter> formatter = new LLSDXMLFormatter(); formatter->format(day_data, day_cycle_xml, LLSDFormatter::OPTIONS_PRETTY); day_cycle_xml.close(); } LLSD LLWLDayCycle::asLLSD() { LLSD day_data(LLSD::emptyArray()); for(std::map<F32, LLWLParamKey>::const_iterator mIt = mTimeMap.begin(); mIt != mTimeMap.end(); ++mIt) { LLSD key(LLSD::emptyArray()); key.append(mIt->first); key.append(mIt->second.name); day_data.append(key); } LL_DEBUGS() << "Dumping day cycle (" << mTimeMap.size() << ") to LLSD: " << day_data << LL_ENDL; return day_data; } // bool LLWLDayCycle::getSkyRefs(std::map<LLWLParamKey, LLWLParamSet>& refs) const // { // bool result = true; // LLWLParamManager& wl_mgr = LLWLParamManager::instance(); // // refs.clear(); // for (std::map<F32, LLWLParamKey>::const_iterator iter = mTimeMap.begin(); iter != mTimeMap.end(); ++iter) // { // const LLWLParamKey& key = iter->second; // if (!wl_mgr.getParamSet(key, refs[key])) // { // LL_WARNS() << "Cannot find sky [" << key.name << "] referenced by a day cycle" << LL_ENDL; // result = false; // } // } // // return result; // } bool LLWLDayCycle::getSkyMap(LLSD& sky_map) const { // std::map<LLWLParamKey, LLWLParamSet> refs; // // if (!getSkyRefs(refs)) // { // return false; // } // // sky_map = LLWLParamManager::createSkyMap(refs); return true; } void LLWLDayCycle::clearKeyframes() { LL_DEBUGS() << "Clearing key frames" << LL_ENDL; mTimeMap.clear(); } bool LLWLDayCycle::addKeyframe(F32 newTime, LLWLParamKey frame) { // no adding negative time if(newTime < 0) { newTime = 0; } // if time not being used, add it and return true if(mTimeMap.find(newTime) == mTimeMap.end()) { mTimeMap.insert(std::pair<F32, LLWLParamKey>(newTime, frame)); LL_DEBUGS() << "Adding key frame (" << newTime << ", " << frame.toLLSD() << ")" << LL_ENDL; return true; } // otherwise, don't add, and return error LL_WARNS() << "Error adding key frame (" << newTime << ", " << frame.toLLSD() << ")" << LL_ENDL; return false; } bool LLWLDayCycle::changeKeyframeTime(F32 oldTime, F32 newTime) { LL_DEBUGS() << "Changing key frame time (" << oldTime << " => " << newTime << ")" << LL_ENDL; // just remove and add back LLWLParamKey frame = mTimeMap[oldTime]; bool stat = removeKeyframe(oldTime); if(stat == false) { LL_DEBUGS() << "Failed to change key frame time (" << oldTime << " => " << newTime << ")" << LL_ENDL; return stat; } return addKeyframe(newTime, frame); } // bool LLWLDayCycle::changeKeyframeParam(F32 time, LLWLParamKey key) // { // LL_DEBUGS() << "Changing key frame param (" << time << ", " << key.toLLSD() << ")" << LL_ENDL; // // // just remove and add back // // make sure param exists // LLWLParamSet tmp; // bool stat = LLWLParamManager::getInstance()->getParamSet(key, tmp); // if(stat == false) // { // LL_DEBUGS() << "Failed to change key frame param (" << time << ", " << key.toLLSD() << ")" << LL_ENDL; // return stat; // } // // mTimeMap[time] = key; // return true; // } bool LLWLDayCycle::removeKeyframe(F32 time) { LL_DEBUGS() << "Removing key frame (" << time << ")" << LL_ENDL; // look for the time. If there, erase it std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time); if(mIt != mTimeMap.end()) { mTimeMap.erase(mIt); return true; } return false; } bool LLWLDayCycle::getKeytime(LLWLParamKey frame, F32& key_time) const { // scroll through till we find the correct value in the map std::map<F32, LLWLParamKey>::const_iterator mIt = mTimeMap.begin(); for(; mIt != mTimeMap.end(); ++mIt) { if(frame == mIt->second) { key_time = mIt->first; return true; } } return false; } // bool LLWLDayCycle::getKeyedParam(F32 time, LLWLParamSet& param) // { // // just scroll on through till you find it // std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time); // if(mIt != mTimeMap.end()) // { // return LLWLParamManager::getInstance()->getParamSet(mIt->second, param); // } // // // return error if not found // LL_DEBUGS() << "Key " << time << " not found" << LL_ENDL; // return false; // } bool LLWLDayCycle::getKeyedParamName(F32 time, std::string & name) { // just scroll on through till you find it std::map<F32, LLWLParamKey>::iterator mIt = mTimeMap.find(time); if(mIt != mTimeMap.end()) { name = mTimeMap[time].name; return true; } // return error if not found LL_DEBUGS() << "Key " << time << " not found" << LL_ENDL; return false; } bool LLWLDayCycle::hasReferencesTo(const LLWLParamKey& keyframe) const { F32 dummy; return getKeytime(keyframe, dummy); } void LLWLDayCycle::removeReferencesTo(const LLWLParamKey& keyframe) { LL_DEBUGS() << "Removing references to key frame " << keyframe.toLLSD() << LL_ENDL; F32 keytime; bool might_exist; do { // look for it might_exist = getKeytime(keyframe, keytime); if(!might_exist) { return; } might_exist = removeKeyframe(keytime); } while(might_exist); // might be another one }