void GameRules::SetFromStrings(const std::map<std::string, std::string>& names_values) {
CheckPendingGameRules();
DebugLogger() << "Setting Rules from Strings:";
for (const auto& entry : names_values)
DebugLogger() << " " << entry.first << " : " << entry.second;
ResetToDefaults();
for (auto& entry : names_values) {
auto rule_it = m_game_rules.find(entry.first);
if (rule_it == m_game_rules.end()) {
InfoLogger() << "GameRules::serialize received unrecognized rule: " << entry.first;
continue;
}
try {
rule_it->second.SetFromString(entry.second);
} catch (const boost::bad_lexical_cast& e) {
ErrorLogger() << "Unable to set rule: " << entry.first << " to value: " << entry.second << " - couldn't cast string to allowed value for this option";
} catch (...) {
ErrorLogger() << "Unable to set rule: " << entry.first << " to value: " << entry.second;
}
}
DebugLogger() << "After Setting Rules:";
for (const auto& entry : m_game_rules)
DebugLogger() << " " << entry.first << " : " << entry.second.ValueToString();
}
Settings::Settings()
:
fMessage(kMsgNetworkTimeSettings)
{
ResetToDefaults();
Load();
}
Material::Material(Context* context) :
Resource(context),
auxViewFrameNumber_(0),
occlusion_(true),
specular_(false)
{
SetNumTechniques(1);
ResetToDefaults();
}
bool Material::BeginLoad(Deserializer& source)
{
// In headless mode, do not actually load the material, just return success
Graphics* graphics = GetSubsystem<Graphics>();
if (!graphics)
return true;
loadXMLFile_ = new XMLFile(context_);
if (loadXMLFile_->Load(source))
{
// If async loading, scan the XML content beforehand for technique & texture resources
// and request them to also be loaded. Can not do anything else at this point
if (GetAsyncLoadState() == ASYNC_LOADING)
{
ResourceCache* cache = GetSubsystem<ResourceCache>();
XMLElement rootElem = loadXMLFile_->GetRoot();
XMLElement techniqueElem = rootElem.GetChild("technique");
while (techniqueElem)
{
cache->BackgroundLoadResource<Technique>(techniqueElem.GetAttribute("name"), true, this);
techniqueElem = techniqueElem.GetNext("technique");
}
XMLElement textureElem = rootElem.GetChild("texture");
while (textureElem)
{
String name = textureElem.GetAttribute("name");
// Detect cube maps by file extension: they are defined by an XML file
/// \todo Differentiate with 3D textures by actually reading the XML content
if (GetExtension(name) == ".xml")
{
#ifdef DESKTOP_GRAPHICS
TextureUnit unit = TU_DIFFUSE;
if (textureElem.HasAttribute("unit"))
unit = ParseTextureUnitName(textureElem.GetAttribute("unit"));
if (unit == TU_VOLUMEMAP)
cache->BackgroundLoadResource<Texture3D>(name, true, this);
else
#endif
cache->BackgroundLoadResource<TextureCube>(name, true, this);
}
else
cache->BackgroundLoadResource<Texture2D>(name, true, this);
textureElem = textureElem.GetNext("texture");
}
}
return true;
}
else
{
ResetToDefaults();
loadXMLFile_.Reset();
return false;
}
}
PrefEdit::PrefEdit ()
{
setupUi (this);
storyTextSize->setMinimum(DRSSConfig::minTextFactor);
storyTextSize->setMaximum(DRSSConfig::maxTextFactor);
hide();
connect (okButton,SIGNAL(clicked()),this,SLOT(DoOk()));
connect (cancelButton,SIGNAL(clicked()),this,SLOT(DoCancel()));
connect (defaultsButton,SIGNAL(clicked()),this,SLOT(ResetToDefaults()));
running = false;
}
Material::Material(Context* context) :
Resource(context),
auxViewFrameNumber_(0),
shaderParameterHash_(0),
occlusion_(true),
specular_(false),
subscribed_(false),
batchedParameterUpdate_(false)
{
ResetToDefaults();
}
bool Material::Load(const XMLElement& source)
{
ResetToDefaults();
if (source.IsNull())
{
LOGERROR("Can not load material from null XML element");
return false;
}
ResourceCache* cache = GetSubsystem<ResourceCache>();
XMLElement techniqueElem = source.GetChild("technique");
techniques_.Clear();
while (techniqueElem)
{
Technique* tech = cache->GetResource<Technique>(techniqueElem.GetAttribute("name"));
if (tech)
{
TechniqueEntry newTechnique;
newTechnique.technique_ = tech;
if (techniqueElem.HasAttribute("quality"))
newTechnique.qualityLevel_ = techniqueElem.GetInt("quality");
if (techniqueElem.HasAttribute("loddistance"))
newTechnique.lodDistance_ = techniqueElem.GetFloat("loddistance");
techniques_.Push(newTechnique);
}
techniqueElem = techniqueElem.GetNext("technique");
}
SortTechniques();
XMLElement textureElem = source.GetChild("texture");
while (textureElem)
{
TextureUnit unit = TU_DIFFUSE;
if (textureElem.HasAttribute("unit"))
{
String unitName = textureElem.GetAttributeLower("unit");
if (unitName.Length() > 1)
{
unit = ParseTextureUnitName(unitName);
if (unit >= MAX_MATERIAL_TEXTURE_UNITS)
LOGERROR("Unknown or illegal texture unit " + unitName);
}
else
unit = (TextureUnit)Clamp(ToInt(unitName), 0, MAX_MATERIAL_TEXTURE_UNITS - 1);
}
if (unit != MAX_MATERIAL_TEXTURE_UNITS)
{
String name = textureElem.GetAttribute("name");
// Detect cube maps by file extension: they are defined by an XML file
if (GetExtension(name) == ".xml")
SetTexture(unit, cache->GetResource<TextureCube>(name));
else
SetTexture(unit, cache->GetResource<Texture2D>(name));
}
textureElem = textureElem.GetNext("texture");
}
XMLElement parameterElem = source.GetChild("parameter");
while (parameterElem)
{
String name = parameterElem.GetAttribute("name");
SetShaderParameter(name, ParseShaderParameterValue(parameterElem.GetAttribute("value")));
parameterElem = parameterElem.GetNext("parameter");
}
XMLElement cullElem = source.GetChild("cull");
if (cullElem)
SetCullMode((CullMode)GetStringListIndex(cullElem.GetAttribute("value").CString(), cullModeNames, CULL_CCW));
XMLElement shadowCullElem = source.GetChild("shadowcull");
if (shadowCullElem)
SetShadowCullMode((CullMode)GetStringListIndex(shadowCullElem.GetAttribute("value").CString(), cullModeNames, CULL_CCW));
XMLElement depthBiasElem = source.GetChild("depthbias");
if (depthBiasElem)
SetDepthBias(BiasParameters(depthBiasElem.GetFloat("constant"), depthBiasElem.GetFloat("slopescaled")));
// Calculate memory use
unsigned memoryUse = sizeof(Material);
memoryUse += techniques_.Size() * sizeof(TechniqueEntry);
memoryUse += MAX_MATERIAL_TEXTURE_UNITS * sizeof(SharedPtr<Texture>);
memoryUse += shaderParameters_.Size() * sizeof(MaterialShaderParameter);
SetMemoryUse(memoryUse);
CheckOcclusion();
return true;
}
/* virtual */
void CreatureMotionSys::Activate()
{
ResetToDefaults();
}
bool Material::Load(const XMLElement& source)
{
ResetToDefaults();
if (source.IsNull())
{
LOGERROR("Can not load material from null XML element");
return false;
}
ResourceCache* cache = GetSubsystem<ResourceCache>();
XMLElement techniqueElem = source.GetChild("technique");
techniques_.Clear();
while (techniqueElem)
{
Technique* tech = cache->GetResource<Technique>(techniqueElem.GetAttribute("name"));
if (tech)
{
TechniqueEntry newTechnique;
newTechnique.technique_ = tech;
if (techniqueElem.HasAttribute("quality"))
newTechnique.qualityLevel_ = techniqueElem.GetInt("quality");
if (techniqueElem.HasAttribute("loddistance"))
newTechnique.lodDistance_ = techniqueElem.GetFloat("loddistance");
techniques_.Push(newTechnique);
}
techniqueElem = techniqueElem.GetNext("technique");
}
SortTechniques();
XMLElement textureElem = source.GetChild("texture");
while (textureElem)
{
TextureUnit unit = TU_DIFFUSE;
if (textureElem.HasAttribute("unit"))
unit = ParseTextureUnitName(textureElem.GetAttribute("unit"));
if (unit < MAX_TEXTURE_UNITS)
{
String name = textureElem.GetAttribute("name");
// Detect cube maps by file extension: they are defined by an XML file
/// \todo Differentiate with 3D textures by actually reading the XML content
if (GetExtension(name) == ".xml")
{
#ifdef DESKTOP_GRAPHICS
if (unit == TU_VOLUMEMAP)
SetTexture(unit, cache->GetResource<Texture3D>(name));
else
#endif
SetTexture(unit, cache->GetResource<TextureCube>(name));
}
else
SetTexture(unit, cache->GetResource<Texture2D>(name));
}
textureElem = textureElem.GetNext("texture");
}
batchedParameterUpdate_ = true;
XMLElement parameterElem = source.GetChild("parameter");
while (parameterElem)
{
String name = parameterElem.GetAttribute("name");
SetShaderParameter(name, ParseShaderParameterValue(parameterElem.GetAttribute("value")));
parameterElem = parameterElem.GetNext("parameter");
}
batchedParameterUpdate_ = false;
XMLElement parameterAnimationElem = source.GetChild("parameteranimation");
while (parameterAnimationElem)
{
String name = parameterAnimationElem.GetAttribute("name");
SharedPtr<ValueAnimation> animation(new ValueAnimation(context_));
if (!animation->LoadXML(parameterAnimationElem))
{
LOGERROR("Could not load parameter animation");
return false;
}
String wrapModeString = parameterAnimationElem.GetAttribute("wrapmode");
WrapMode wrapMode = WM_LOOP;
for (int i = 0; i <= WM_CLAMP; ++i)
{
if (wrapModeString == wrapModeNames[i])
{
wrapMode = (WrapMode)i;
break;
}
}
float speed = parameterAnimationElem.GetFloat("speed");
SetShaderParameterAnimation(name, animation, wrapMode, speed);
parameterAnimationElem = parameterAnimationElem.GetNext("parameteranimation");
}
XMLElement cullElem = source.GetChild("cull");
if (cullElem)
SetCullMode((CullMode)GetStringListIndex(cullElem.GetAttribute("value").CString(), cullModeNames, CULL_CCW));
XMLElement shadowCullElem = source.GetChild("shadowcull");
if (shadowCullElem)
SetShadowCullMode((CullMode)GetStringListIndex(shadowCullElem.GetAttribute("value").CString(), cullModeNames, CULL_CCW));
XMLElement fillElem = source.GetChild("fill");
if (fillElem)
SetFillMode((FillMode)GetStringListIndex(fillElem.GetAttribute("value").CString(), fillModeNames, FILL_SOLID));
XMLElement depthBiasElem = source.GetChild("depthbias");
if (depthBiasElem)
SetDepthBias(BiasParameters(depthBiasElem.GetFloat("constant"), depthBiasElem.GetFloat("slopescaled")));
RefreshShaderParameterHash();
RefreshMemoryUse();
CheckOcclusion();
return true;
}
bool Material::Load(Deserializer& source)
{
PROFILE(LoadMaterial);
// In headless mode, do not actually load the material, just return success
Graphics* graphics = GetSubsystem<Graphics>();
if (!graphics)
return true;
ResetToDefaults();
ResourceCache* cache = GetSubsystem<ResourceCache>();
SharedPtr<XMLFile> xml(new XMLFile(context_));
if (!xml->Load(source))
return false;
XMLElement rootElem = xml->GetRoot();
XMLElement techniqueElem = rootElem.GetChild("technique");
techniques_.Clear();
while (techniqueElem)
{
Technique* tech = cache->GetResource<Technique>(techniqueElem.GetAttribute("name"));
if (tech)
{
TechniqueEntry newTechnique;
newTechnique.technique_ = tech;
if (techniqueElem.HasAttribute("quality"))
newTechnique.qualityLevel_ = techniqueElem.GetInt("quality");
if (techniqueElem.HasAttribute("loddistance"))
newTechnique.lodDistance_ = techniqueElem.GetFloat("loddistance");
techniques_.Push(newTechnique);
}
techniqueElem = techniqueElem.GetNext("technique");
}
XMLElement textureElem = rootElem.GetChild("texture");
while (textureElem)
{
TextureUnit unit = TU_DIFFUSE;
if (textureElem.HasAttribute("unit"))
{
String unitName = textureElem.GetAttributeLower("unit");
if (unitName.Length() > 1)
{
unit = ParseTextureUnitName(unitName);
if (unit >= MAX_MATERIAL_TEXTURE_UNITS)
LOGERROR("Unknown or illegal texture unit " + unitName);
}
else
unit = (TextureUnit)Clamp(ToInt(unitName), 0, MAX_MATERIAL_TEXTURE_UNITS - 1);
}
if (unit != MAX_MATERIAL_TEXTURE_UNITS)
{
String name = textureElem.GetAttribute("name");
// Detect cube maps by file extension: they are defined by an XML file
if (GetExtension(name) == ".xml")
SetTexture(unit, cache->GetResource<TextureCube>(name));
else
SetTexture(unit, cache->GetResource<Texture2D>(name));
}
textureElem = textureElem.GetNext("texture");
}
XMLElement parameterElem = rootElem.GetChild("parameter");
while (parameterElem)
{
String name = parameterElem.GetAttribute("name");
Variant value = parameterElem.GetVectorVariant("value");
SetShaderParameter(name, value);
parameterElem = parameterElem.GetNext("parameter");
}
XMLElement cullElem = rootElem.GetChild("cull");
if (cullElem)
SetCullMode((CullMode)GetStringListIndex(cullElem.GetAttribute("value").CString(), cullModeNames, CULL_CCW));
XMLElement shadowCullElem = rootElem.GetChild("shadowcull");
if (shadowCullElem)
SetShadowCullMode((CullMode)GetStringListIndex(shadowCullElem.GetAttribute("value").CString(), cullModeNames, CULL_CCW));
XMLElement depthBiasElem = rootElem.GetChild("depthbias");
if (depthBiasElem)
SetDepthBias(BiasParameters(depthBiasElem.GetFloat("constant"), depthBiasElem.GetFloat("slopescaled")));
// Calculate memory use
unsigned memoryUse = sizeof(Material);
memoryUse += techniques_.Size() * sizeof(TechniqueEntry);
memoryUse += MAX_MATERIAL_TEXTURE_UNITS * sizeof(SharedPtr<Texture>);
memoryUse += shaderParameters_.Size() * sizeof(MaterialShaderParameter);
SetMemoryUse(memoryUse);
CheckOcclusion();
return true;
}
MsgFilterData::MsgFilterData() {
ResetToDefaults();
}
void PrefsWindow::MessageReceived(BMessage* message)
{
switch(message->what)
{
case PrefsConstants::K_PREFS_VIEW_RESET_COLOUR_DEFAULTS:
{
ResetToDefaults(PrefsConstants::K_RESET_COLOUR_PREFS);
}
break;
case PrefsConstants::K_PREFS_VIEW_RESET_COMMAND_DEFAULTS:
{
ResetToDefaults(PrefsConstants::K_RESET_COMMAND_PREFS);
}
break;
case PrefsConstants::K_PREFS_VIEW_RESET_TOOLBAR_DEFAULTS:
{
ResetToDefaults(PrefsConstants::K_RESET_TOOLBAR_PREFS);
}
break;
case PrefsConstants::K_PREFS_VIEW_RESET_GENERAL_DEFAULTS:
{
ResetToDefaults(PrefsConstants::K_RESET_GENERAL_PREFS);
}
break;
case PrefsConstants::K_PREFS_UPDATE:
{
//update the preferences message, from view values
BString prefsID;
if (message->FindString(K_PREFS_ID, &prefsID) == B_OK)
{
BView *changedView = m_parent->FindView(prefsID.String());
prefsLock.Lock();
//different view have different kinds of values
if (is_instance_of(changedView, BTextControl))
{
//a textcontrol value was changed, update preferences with new text
BTextControl *textControl = dynamic_cast<BTextControl*>(changedView);
preferences.ReplaceString(prefsID.String(), textControl->Text());
}
else if (is_instance_of(changedView, BCheckBox))
{
//a checkbox value was changed, update preferences with new bool value(on/off)
BCheckBox *checkBox = dynamic_cast<BCheckBox*>(changedView);
preferences.ReplaceBool(prefsID.String(), checkBox->Value());
}
else if (is_instance_of(changedView, BSlider))
{
//a slider value was changed, update preferences with new slider value
BSlider *slider = dynamic_cast<BSlider*>(changedView);
preferences.ReplaceInt32(prefsID.String(), slider->Value());
}
else if (is_instance_of(changedView, ColourButton))
{
//a colourcontrol value was changed, update preferences with new colour
ColourButton *colourControl = dynamic_cast<ColourButton*>(changedView);
preferences.ReplaceData(prefsID.String(),B_RGB_COLOR_TYPE, &colourControl->Value(), sizeof(rgb_color));
}
prefsLock.Unlock();
}
}
break;
case PrefsConstants::K_LOAD_PREFERENCES:
{
//set preferences view values to values of the preferences message
BString prefsID;
if (message->FindString(K_PREFS_ID, &prefsID) == B_OK)
{
//find out which view value has to be updated
BView *changedView = m_parent->FindView(prefsID.String());
prefsLock.Lock();
char *name;
uint32 type;
int32 count;
for (int32 i = 0; preferences.GetInfo(B_ANY_TYPE, i, &name, &type, &count) == B_OK; i++)
{
//find out what kind of field we are using
switch (type)
{
case B_INT32_TYPE:
{
int32 value;
preferences.FindInt32(name, &value);
if (is_instance_of(changedView, BSlider))
{
BSlider *slider = dynamic_cast<BSlider*>(changedView);
slider->SetValue(value);
}
}
break;
case B_BOOL_TYPE:
{
bool value;
preferences.FindBool(name, &value);
if (is_instance_of(changedView, BCheckBox))
{
BCheckBox *checkBox = dynamic_cast<BCheckBox*>(changedView);
checkBox->SetValue(value);
}
}
break;
case B_RGB_COLOR_TYPE:
{
rgb_color *colour;
ssize_t size;
preferences.FindData(name, B_RGB_COLOR_TYPE, (const void**)&colour, &size);
if (is_instance_of(changedView, ColourButton))
{
ColourButton *colourControl = dynamic_cast<ColourButton*>(changedView);
colourControl->SetValue(*colour);
}
}
break;
case B_STRING_TYPE:
{
BString string;
preferences.FindString(name, &string);
if (is_instance_of(changedView, ColourButton))
{
BTextControl *textControl = dynamic_cast<BTextControl*>(changedView);
textControl->SetText(string.String());
}
}
break;
}
}
prefsLock.Unlock();
//make sure the new view values are drawn!
changedView->Invalidate();
}
}
break;
default:
BWindow::MessageReceived(message);
break;
}
}
