1648 lines
48 KiB
ActionScript
1648 lines
48 KiB
ActionScript
/*
|
|
Copyright (c) 2013 yvt
|
|
|
|
This file is part of OpenSpades.
|
|
|
|
OpenSpades is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
OpenSpades 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with OpenSpades. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
#include "DropDownList.as"
|
|
|
|
namespace spades {
|
|
|
|
|
|
class StartupScreenUI {
|
|
private Renderer@ renderer;
|
|
private AudioDevice@ audioDevice;
|
|
Font@ font;
|
|
StartupScreenHelper@ helper;
|
|
|
|
spades::ui::UIManager@ manager;
|
|
|
|
StartupScreenMainMenu@ mainMenu;
|
|
|
|
|
|
bool shouldExit = false;
|
|
StartupScreenUI(Renderer@ renderer, AudioDevice@ audioDevice, Font@ font, StartupScreenHelper@ helper) {
|
|
@this.renderer = renderer;
|
|
@this.audioDevice = audioDevice;
|
|
@this.font = font;
|
|
@this.helper = helper;
|
|
|
|
SetupRenderer();
|
|
|
|
@manager = spades::ui::UIManager(renderer, audioDevice);
|
|
@manager.RootElement.Font = font;
|
|
|
|
@mainMenu = StartupScreenMainMenu(this);
|
|
mainMenu.Bounds = manager.RootElement.Bounds;
|
|
manager.RootElement.AddChild(mainMenu);
|
|
|
|
}
|
|
|
|
void SetupRenderer() {
|
|
if(manager !is null)
|
|
manager.KeyPanic();
|
|
}
|
|
|
|
void MouseEvent(float x, float y) {
|
|
manager.MouseEvent(x, y);
|
|
}
|
|
|
|
void WheelEvent(float x, float y) {
|
|
manager.WheelEvent(x, y);
|
|
}
|
|
|
|
void KeyEvent(string key, bool down) {
|
|
manager.KeyEvent(key, down);
|
|
}
|
|
|
|
void TextInputEvent(string text) {
|
|
manager.TextInputEvent(text);
|
|
}
|
|
|
|
void TextEditingEvent(string text, int start, int len) {
|
|
manager.TextEditingEvent(text, start, len);
|
|
}
|
|
|
|
bool AcceptsTextInput() {
|
|
return manager.AcceptsTextInput;
|
|
}
|
|
|
|
AABB2 GetTextInputRect() {
|
|
return manager.TextInputRect;
|
|
}
|
|
|
|
void RunFrame(float dt) {
|
|
renderer.ColorNP = Vector4(0.f, 0.f, 0.f, 1.f);
|
|
renderer.DrawImage(renderer.RegisterImage("Gfx/White.tga"),
|
|
AABB2(0.f, 0.f, renderer.ScreenWidth, renderer.ScreenHeight));
|
|
|
|
// draw title logo
|
|
Image@ img = renderer.RegisterImage("Gfx/Title/LogoSmall.png");
|
|
renderer.ColorNP = Vector4(1.f, 1.f, 1.f, 1.f);
|
|
renderer.DrawImage(img, AABB2(10.f, 10.f, img.Width, img.Height));
|
|
|
|
manager.RunFrame(dt);
|
|
manager.Render();
|
|
|
|
renderer.FrameDone();
|
|
renderer.Flip();
|
|
}
|
|
|
|
void Closing() {
|
|
shouldExit = true;
|
|
}
|
|
|
|
bool WantsToBeClosed() {
|
|
return shouldExit;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
class StartupScreenMainMenu: spades::ui::UIElement {
|
|
|
|
StartupScreenUI@ ui;
|
|
StartupScreenHelper@ helper;
|
|
|
|
spades::ui::ListView@ serverList;
|
|
spades::ui::CheckBox@ bypassStartupWindowCheck;
|
|
|
|
StartupScreenGraphicsTab@ graphicsTab;
|
|
StartupScreenAudioTab@ audioTab;
|
|
StartupScreenAdvancedTab@ advancedTab;
|
|
|
|
private ConfigItem cl_showStartupWindow("cl_showStartupWindow", "-1");
|
|
private bool advancedTabVisible = false;
|
|
|
|
StartupScreenMainMenu(StartupScreenUI@ ui) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@this.helper = ui.helper;
|
|
|
|
@this.Font = ui.font;
|
|
|
|
float width = Manager.Renderer.ScreenWidth;
|
|
float height = Manager.Renderer.ScreenHeight;
|
|
{
|
|
spades::ui::Button button(Manager);
|
|
button.Caption = _Tr("StartupScreen", "Start");
|
|
button.Bounds = AABB2(width - 170.f, 20.f, 150.f, 30.f);
|
|
button.Activated = EventHandler(this.OnStartPressed);
|
|
AddChild(button);
|
|
}
|
|
{
|
|
spades::ui::CheckBox button(Manager);
|
|
button.Caption = _Tr("StartupScreen", "Skip this screen next time");
|
|
button.Bounds = AABB2(360.f, 62.f, width - 380.f, 20.f);
|
|
AddChild(button);
|
|
@bypassStartupWindowCheck = button;
|
|
button.Activated = EventHandler(this.OnBypassStartupWindowCheckChanged);
|
|
}
|
|
|
|
AABB2 clientArea(10.f, 100.f, width - 20.f, height - 110.f);
|
|
StartupScreenGraphicsTab graphicsTab(ui, clientArea.max - clientArea.min);
|
|
StartupScreenAudioTab audioTab(ui, clientArea.max - clientArea.min);
|
|
StartupScreenSystemInfoTab profileTab(ui, clientArea.max - clientArea.min);
|
|
StartupScreenAdvancedTab advancedTab(ui, clientArea.max - clientArea.min);
|
|
graphicsTab.Bounds = clientArea;
|
|
audioTab.Bounds = clientArea;
|
|
profileTab.Bounds = clientArea;
|
|
advancedTab.Bounds = clientArea;
|
|
AddChild(graphicsTab);
|
|
AddChild(audioTab);
|
|
AddChild(profileTab);
|
|
AddChild(advancedTab);
|
|
audioTab.Visible = false;
|
|
profileTab.Visible = false;
|
|
advancedTab.Visible = false;
|
|
|
|
@this.graphicsTab = graphicsTab;
|
|
@this.audioTab = audioTab;
|
|
@this.advancedTab = advancedTab;
|
|
|
|
{
|
|
spades::ui::SimpleTabStrip tabStrip(Manager);
|
|
AddChild(tabStrip);
|
|
tabStrip.Bounds = AABB2(10.f, 70.f, width - 20.f, 24.f);
|
|
tabStrip.AddItem(_Tr("StartupScreen", "Graphics"), graphicsTab);
|
|
tabStrip.AddItem(_Tr("StartupScreen", "Audio"), audioTab);
|
|
tabStrip.AddItem(_Tr("StartupScreen", "System Info"), profileTab);
|
|
tabStrip.AddItem(_Tr("StartupScreen", "Advanced"), advancedTab);
|
|
@tabStrip.Changed = EventHandler(this.OnTabChanged);
|
|
}
|
|
|
|
LoadConfig();
|
|
}
|
|
|
|
private void OnTabChanged(spades::ui::UIElement@) {
|
|
bool v = advancedTab.Visible;
|
|
if(advancedTabVisible and not v) {
|
|
LoadConfig();
|
|
}
|
|
advancedTabVisible = v;
|
|
}
|
|
|
|
void LoadConfig() {
|
|
switch(cl_showStartupWindow.IntValue) {
|
|
case -1:
|
|
bypassStartupWindowCheck.Toggled = false;
|
|
break;
|
|
case 0:
|
|
bypassStartupWindowCheck.Toggled = true;
|
|
break;
|
|
default:
|
|
bypassStartupWindowCheck.Toggled = false;
|
|
break;
|
|
}
|
|
|
|
this.graphicsTab.LoadConfig();
|
|
this.audioTab.LoadConfig();
|
|
this.advancedTab.LoadConfig();
|
|
}
|
|
|
|
private void OnBypassStartupWindowCheckChanged(spades::ui::UIElement@ sender) {
|
|
cl_showStartupWindow.IntValue = (bypassStartupWindowCheck.Toggled ? 0 : 1);
|
|
}
|
|
|
|
|
|
private void OnQuitPressed(spades::ui::UIElement@ sender) {
|
|
ui.shouldExit = true;
|
|
}
|
|
|
|
private void OnSetupPressed(spades::ui::UIElement@ sender) {
|
|
PreferenceView al(this, PreferenceViewOptions());
|
|
al.Run();
|
|
}
|
|
|
|
private void Start() {
|
|
helper.Start();
|
|
ui.shouldExit = true; // we have to exit from the startup screen to start the game
|
|
}
|
|
|
|
private void OnStartPressed(spades::ui::UIElement@ sender) {
|
|
Start();
|
|
}
|
|
|
|
void HotKey(string key) {
|
|
if(IsEnabled and key == "Enter") {
|
|
Start();
|
|
} else if(IsEnabled and key == "Escape") {
|
|
ui.shouldExit = true;
|
|
} else {
|
|
UIElement::HotKey(key);
|
|
}
|
|
}
|
|
|
|
void Render() {
|
|
UIElement::Render();
|
|
|
|
}
|
|
}
|
|
|
|
funcdef void HelpTextHandler(string text);
|
|
class ChainedEventHandler {
|
|
EventHandler@ h;
|
|
EventHandler@ h2;
|
|
ChainedEventHandler(EventHandler@ h, EventHandler@ h2) {
|
|
@this.h = h;
|
|
@this.h2 = h2;
|
|
}
|
|
void Handler(spades::ui::UIElement@ e) {
|
|
h(e); h2(e);
|
|
}
|
|
}
|
|
class HelpHandler {
|
|
private HelpTextHandler@ handler;
|
|
private spades::ui::TextViewer@ helpView;
|
|
private string text;
|
|
HelpHandler(spades::ui::TextViewer@ helpView, string text) {
|
|
this.text = text;
|
|
@this.helpView = helpView;
|
|
}
|
|
HelpHandler(HelpTextHandler@ handler, string text) {
|
|
this.text = text;
|
|
@this.handler = handler;
|
|
}
|
|
private void OnMouseHover(spades::ui::UIElement@ elm) {
|
|
if(helpView !is null) {
|
|
helpView.Text = text;
|
|
}
|
|
if(handler !is null) {
|
|
handler(text);
|
|
}
|
|
}
|
|
void Watch(spades::ui::UIElement@ elm) {
|
|
@elm.MouseEntered = EventHandler(this.OnMouseHover);
|
|
}
|
|
void WatchDeep(spades::ui::UIElement@ elm) {
|
|
if(elm.MouseEntered !is null) {
|
|
ChainedEventHandler chain(elm.MouseEntered, EventHandler(this.OnMouseHover));
|
|
@elm.MouseEntered = EventHandler(chain.Handler);
|
|
}else{
|
|
Watch(elm);
|
|
}
|
|
spades::ui::UIElementIterator it(elm);
|
|
while(it.MoveNext()) {
|
|
WatchDeep(it.Current);
|
|
}
|
|
}
|
|
}
|
|
|
|
mixin class LabelAddable {
|
|
|
|
private void AddLabel(float x, float y, float h, string text) {
|
|
spades::ui::Label label(Manager);
|
|
Font@ font = ui.font;
|
|
Vector2 siz = font.Measure(text);
|
|
label.Text = text;
|
|
label.Alignment = Vector2(0.f, 0.5f);
|
|
label.Bounds = AABB2(x, y, siz.x, h);
|
|
AddChild(label);
|
|
}
|
|
|
|
}
|
|
|
|
class StartupScreenConfigViewModel: spades::ui::ListViewModel {
|
|
spades::ui::UIElement@[] items;
|
|
spades::ui::UIElement@[]@ items2;
|
|
StartupScreenConfigViewModel() {
|
|
}
|
|
int NumRows {
|
|
get {
|
|
if(items2 !is null)
|
|
return int(items2.length);
|
|
return int(items.length);
|
|
}
|
|
}
|
|
|
|
void Filter(string text) {
|
|
if(text.length == 0) {
|
|
@items2 = null;
|
|
return;
|
|
}
|
|
spades::ui::UIElement@[] newItems;
|
|
for(uint i = 0, count = items.length; i < count; i++) {
|
|
StartupScreenConfigItemEditor@ editor =
|
|
cast<StartupScreenConfigItemEditor>(items[i]);
|
|
if(editor is null) continue;
|
|
string label = editor.GetLabel();
|
|
if(StringContainsCaseInsensitive(label, text)) {
|
|
newItems.insertLast(items[i]);
|
|
}
|
|
}
|
|
@items2 = newItems;
|
|
}
|
|
spades::ui::UIElement@ CreateElement(int row) {
|
|
if(items2 !is null)
|
|
return items2[row];
|
|
return items[row];
|
|
}
|
|
void RecycleElement(spades::ui::UIElement@ elem) {
|
|
}
|
|
}
|
|
|
|
interface StartupScreenGenericConfig {
|
|
string GetValue();
|
|
void SetValue(string);
|
|
/** Returns an empty string when there's no problem. */
|
|
string CheckValueCapability(string);
|
|
}
|
|
|
|
class StartupScreenConfig: StartupScreenGenericConfig {
|
|
private StartupScreenUI@ ui;
|
|
private ConfigItem@ cfg;
|
|
private string cfgName;
|
|
StartupScreenConfig(StartupScreenUI@ ui, string cfg) {
|
|
@this.ui = ui;
|
|
@this.cfg = ConfigItem(cfg);
|
|
cfgName = cfg;
|
|
}
|
|
string GetValue() {
|
|
return cfg.StringValue;
|
|
}
|
|
void SetValue(string v) {
|
|
cfg.StringValue = v;
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
return ui.helper.CheckConfigCapability(cfgName, v);
|
|
}
|
|
}
|
|
|
|
class StartupScreenConfigSetter {
|
|
StartupScreenGenericConfig@ c;
|
|
string value;
|
|
StartupScreenConfigSetter(StartupScreenGenericConfig@ c, string value) {
|
|
@this.c = c;
|
|
this.value = value;
|
|
}
|
|
void Set(spades::ui::UIElement@) {
|
|
c.SetValue(this.value);
|
|
}
|
|
}
|
|
|
|
interface StartupScreenConfigItemEditor {
|
|
void LoadConfig();
|
|
StartupScreenGenericConfig@ GetConfig();
|
|
void SetHelpTextHandler(HelpTextHandler@);
|
|
string GetLabel();
|
|
}
|
|
|
|
|
|
class StartupScreenConfigSelectItemEditor: spades::ui::UIElement, LabelAddable, StartupScreenConfigItemEditor, StartupScreenConfigItemEditor {
|
|
|
|
private StartupScreenUI@ ui;
|
|
private string[]@ descs;
|
|
private string[]@ values;
|
|
private StartupScreenGenericConfig@ config;
|
|
private spades::ui::RadioButton@[] buttons;
|
|
private string label;
|
|
|
|
StartupScreenConfigSelectItemEditor(StartupScreenUI@ ui,
|
|
StartupScreenGenericConfig@ cfg,
|
|
string values, string descs) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@this.descs = descs.split("|");
|
|
@config = cfg;
|
|
@this.values = values.split("|");
|
|
|
|
{
|
|
string desc = this.descs[0];
|
|
int idx = desc.findFirst(":");
|
|
if(idx >= 0) {
|
|
desc = desc.substr(0, idx);
|
|
}
|
|
AddLabel(0, 0, 24.f, desc);
|
|
this.label = desc;
|
|
}
|
|
|
|
|
|
for(uint i = 0; i < this.values.length; i++) {
|
|
spades::ui::RadioButton b(Manager);
|
|
string desc = this.descs[i + 1];
|
|
int idx = desc.findFirst(":");
|
|
if(idx >= 0) {
|
|
desc = desc.substr(0, idx);
|
|
}
|
|
b.Caption = desc;
|
|
|
|
b.GroupName = "hoge";
|
|
StartupScreenConfigSetter setter(config, this.values[i]);
|
|
@b.Activated = EventHandler(setter.Set);
|
|
buttons.insertLast(b);
|
|
this.AddChild(b);
|
|
}
|
|
}
|
|
|
|
string GetLabel() {
|
|
return label;
|
|
}
|
|
|
|
void LoadConfig() {
|
|
string val = config.GetValue();
|
|
for(uint i = 0, count = values.length; i < count; i++) {
|
|
buttons[i].Toggled = (values[i] == val);
|
|
buttons[i].Enable = CheckValueCapability(values[i]).length == 0;
|
|
}
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
return config.CheckValueCapability(v);
|
|
}
|
|
StartupScreenGenericConfig@ GetConfig() {
|
|
return config;
|
|
}
|
|
void SetHelpTextHandler(HelpTextHandler@ handler) {
|
|
for(uint i = 0, count = values.length; i < count; i++) {
|
|
string desc = descs[i + 1];
|
|
int idx = desc.findFirst(":");
|
|
if(idx < 0) {
|
|
desc = descs[0];
|
|
idx = desc.findFirst(":");
|
|
}
|
|
desc = desc.substr(uint(idx + 1));
|
|
HelpHandler(handler, desc).Watch(buttons[i]);
|
|
}
|
|
}
|
|
|
|
void set_Bounds(AABB2 v) {
|
|
UIElement::set_Bounds(v);
|
|
Vector2 size = this.Size;
|
|
float h = 24.f;
|
|
float x = size.x;
|
|
for(uint i = buttons.length; i > 0; i--) {
|
|
spades::ui::RadioButton@ b = buttons[i - 1];
|
|
float w = ui.font.Measure(b.Caption).x + 26.f;
|
|
x -= w + 2.f;
|
|
b.Bounds = AABB2(x, 0.f, w, h);
|
|
}
|
|
}
|
|
}
|
|
|
|
class StartupScreenConfigCheckItemEditor: spades::ui::UIElement, StartupScreenConfigItemEditor {
|
|
|
|
private StartupScreenUI@ ui;
|
|
private string desc;
|
|
private string valueOff;
|
|
private string valueOn;
|
|
private StartupScreenGenericConfig@ config;
|
|
private spades::ui::CheckBox@ button;
|
|
private string label;
|
|
|
|
StartupScreenConfigCheckItemEditor(StartupScreenUI@ ui,
|
|
StartupScreenGenericConfig@ cfg,
|
|
string valueOff, string valueOn, string label, string desc) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@config = cfg;
|
|
this.valueOff = valueOff;
|
|
this.valueOn = valueOn;
|
|
this.desc = desc;
|
|
|
|
spades::ui::CheckBox b(Manager);
|
|
b.Caption = label;
|
|
this.label = label;
|
|
@b.Activated = EventHandler(this.StateChanged);
|
|
@button = b;
|
|
this.AddChild(b);
|
|
}
|
|
|
|
string GetLabel() {
|
|
return label;
|
|
}
|
|
|
|
void LoadConfig() {
|
|
string val = config.GetValue();
|
|
button.Toggled = (val != valueOff);
|
|
button.Enable = CheckValueCapability(valueOn).length == 0;
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
return config.CheckValueCapability(v);
|
|
}
|
|
StartupScreenGenericConfig@ GetConfig() {
|
|
return config;
|
|
}
|
|
private void StateChanged(spades::ui::UIElement@) {
|
|
config.SetValue(button.Toggled ? valueOn : valueOff);
|
|
}
|
|
void SetHelpTextHandler(HelpTextHandler@ handler) {
|
|
HelpHandler(handler, desc).Watch(button);
|
|
}
|
|
|
|
void set_Bounds(AABB2 v) {
|
|
UIElement::set_Bounds(v);
|
|
Vector2 size = this.Size;
|
|
float h = 24.f;
|
|
button.Bounds = AABB2(0.f, 0.f, size.x, h);
|
|
}
|
|
}
|
|
|
|
class StartupScreenConfigSliderItemEditor: spades::ui::UIElement, StartupScreenConfigItemEditor, LabelAddable {
|
|
|
|
private StartupScreenUI@ ui;
|
|
private string desc;
|
|
private double stepSize;
|
|
private StartupScreenGenericConfig@ config;
|
|
private spades::ui::Slider@ slider;
|
|
private spades::ui::Label@ valueLabel;
|
|
private ConfigNumberFormatter@ formatter;
|
|
private string label;
|
|
|
|
StartupScreenConfigSliderItemEditor(StartupScreenUI@ ui,
|
|
StartupScreenGenericConfig@ cfg,
|
|
double minValue, double maxValue, double stepSize, string label, string desc,
|
|
ConfigNumberFormatter@ formatter) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@config = cfg;
|
|
this.desc = desc;
|
|
this.stepSize = stepSize;
|
|
this.label = label;
|
|
|
|
AddLabel(0, 0, 24.f, label);
|
|
|
|
spades::ui::Slider b(Manager);
|
|
b.MinValue = minValue;
|
|
b.MaxValue = maxValue;
|
|
|
|
// compute large change
|
|
int steps = int((maxValue - minValue) / stepSize);
|
|
steps = (steps + 9) / 10;
|
|
b.LargeChange = float(steps) * stepSize;
|
|
b.SmallChange = stepSize;
|
|
|
|
@b.Changed = EventHandler(this.StateChanged);
|
|
@slider = b;
|
|
this.AddChild(b);
|
|
|
|
spades::ui::Label l(Manager);
|
|
@valueLabel = l;
|
|
l.Alignment = Vector2(1.f, 0.5f);
|
|
this.AddChild(l);
|
|
|
|
@this.formatter = formatter;
|
|
}
|
|
|
|
private void UpdateLabel() {
|
|
double v = slider.Value;
|
|
string s = formatter.Format(v);
|
|
valueLabel.Text = s;
|
|
}
|
|
|
|
string GetLabel() {
|
|
return label;
|
|
}
|
|
|
|
void LoadConfig() {
|
|
string val = config.GetValue();
|
|
double v = ParseDouble(val);
|
|
// don't use `ScrollTo` here; this calls `Changed` so
|
|
// out-of-range value will be clamped and saved back
|
|
slider.Value = Clamp(v, slider.MinValue, slider.MaxValue);
|
|
// FIXME: button.Enable = CheckValueCapability(valueOn).length == 0;
|
|
UpdateLabel();
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
return ""; //FIXME: config.CheckValueCapability(v);
|
|
}
|
|
StartupScreenGenericConfig@ GetConfig() {
|
|
return config;
|
|
}
|
|
|
|
void DoRounding() {
|
|
double v = double(slider.Value - slider.MinValue);
|
|
v = floor((v / stepSize) + 0.5) * stepSize;
|
|
v += double(slider.MinValue);
|
|
slider.Value = v;
|
|
}
|
|
private void StateChanged(spades::ui::UIElement@) {
|
|
DoRounding();
|
|
config.SetValue(ToString(slider.Value));
|
|
UpdateLabel();
|
|
}
|
|
void SetHelpTextHandler(HelpTextHandler@ handler) {
|
|
HelpHandler(handler, desc).WatchDeep(slider);
|
|
}
|
|
|
|
void set_Bounds(AABB2 v) {
|
|
UIElement::set_Bounds(v);
|
|
Vector2 size = this.Size;
|
|
float h = 24.f;
|
|
slider.Bounds = AABB2(100.f, 2.f, size.x - 180.f, h - 4.f);
|
|
valueLabel.Bounds = AABB2(size.x - 80.f, 0.f, 80.f, h);
|
|
}
|
|
}
|
|
|
|
|
|
class StartupScreenConfigFieldItemEditor: spades::ui::UIElement, StartupScreenConfigItemEditor, LabelAddable {
|
|
|
|
private StartupScreenUI@ ui;
|
|
private string desc;
|
|
private double stepSize;
|
|
private StartupScreenGenericConfig@ config;
|
|
private spades::ui::Field@ field;
|
|
private string label;
|
|
|
|
StartupScreenConfigFieldItemEditor(StartupScreenUI@ ui,
|
|
StartupScreenGenericConfig@ cfg,
|
|
string label, string desc) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@config = cfg;
|
|
this.desc = desc;
|
|
this.label = label;
|
|
|
|
AddLabel(0, 0, 24.f, label);
|
|
|
|
spades::ui::Field b(Manager);
|
|
|
|
@b.Changed = EventHandler(this.StateChanged);
|
|
@field = b;
|
|
this.AddChild(b);
|
|
|
|
}
|
|
|
|
string GetLabel() {
|
|
return label;
|
|
}
|
|
|
|
void LoadConfig() {
|
|
string val = config.GetValue();
|
|
field.Text = val;
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
return config.CheckValueCapability(v);
|
|
}
|
|
StartupScreenGenericConfig@ GetConfig() {
|
|
return config;
|
|
}
|
|
|
|
private void StateChanged(spades::ui::UIElement@) {
|
|
config.SetValue(field.Text);
|
|
}
|
|
void SetHelpTextHandler(HelpTextHandler@ handler) {
|
|
HelpHandler(handler, desc).WatchDeep(field);
|
|
}
|
|
|
|
void set_Bounds(AABB2 v) {
|
|
UIElement::set_Bounds(v);
|
|
Vector2 size = this.Size;
|
|
float h = 24.f;
|
|
field.Bounds = AABB2(240.f, 0.f, size.x - 240.f, h);
|
|
}
|
|
}
|
|
|
|
// Maps multiple configs to {"0", "1", ...} or "custom"
|
|
class StartupScreenComplexConfig: StartupScreenGenericConfig {
|
|
StartupScreenConfigItemEditor@[] editors;
|
|
StartupScreenComplexConfigPreset@[] presets;
|
|
|
|
void AddEditor(StartupScreenConfigItemEditor@ editor) {
|
|
Assert(presets.length == 0);
|
|
editors.insertLast(editor);
|
|
}
|
|
void AddPreset(StartupScreenComplexConfigPreset@ preset) {
|
|
Assert(preset.Values.length == editors.length);
|
|
presets.insertLast(preset);
|
|
}
|
|
|
|
string GetValue() {
|
|
string[] values;
|
|
|
|
for(uint i = 0; i < editors.length; i++) {
|
|
values.insertLast(editors[i].GetConfig().GetValue());
|
|
}
|
|
for(uint i = 0; i < presets.length; i++) {
|
|
string[]@ pval = presets[i].Values;
|
|
uint j = 0;
|
|
uint jc = pval.length;
|
|
for(; j < jc; j++) {
|
|
if(values[j] != pval[j]) {
|
|
break;
|
|
}
|
|
}
|
|
if(j == jc) {
|
|
return ToString(int(i));
|
|
}
|
|
}
|
|
return "custom";
|
|
}
|
|
void SetValue(string v) {
|
|
if(v == "custom") {
|
|
return;
|
|
}
|
|
uint pId = uint(ParseInt(v));
|
|
string[]@ pval = presets[pId].Values;
|
|
for(uint i = 0; i < pval.length; i++) {
|
|
editors[i].GetConfig().SetValue(pval[i]);
|
|
}
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
if(v == "custom") {
|
|
return "";
|
|
}
|
|
uint pId = uint(ParseInt(v));
|
|
string[]@ pval = presets[pId].Values;
|
|
string ret = "";
|
|
for(uint i = 0; i < pval.length; i++) {
|
|
ret += editors[i].GetConfig().CheckValueCapability(pval[i]);
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
// used for StartupScreenConfigSelectItemEditor's ctor param
|
|
string GetValuesString() {
|
|
string[] lst;
|
|
for(uint i = 0; i < presets.length; i++) {
|
|
lst.insertLast(ToString(int(i)));
|
|
}
|
|
lst.insertLast("custom");
|
|
return join(lst, "|");
|
|
}
|
|
// used for StartupScreenConfigSelectItemEditor's ctor param
|
|
string GetDescriptionsString() {
|
|
string[] lst;
|
|
for(uint i = 0; i < presets.length; i++) {
|
|
lst.insertLast(presets[i].Name);
|
|
}
|
|
lst.insertLast(_Tr("StartupScreen", "Custom"));
|
|
return join(lst, "|");
|
|
}
|
|
}
|
|
|
|
class StartupScreenComplexConfigPreset {
|
|
string Name;
|
|
string[] Values;
|
|
StartupScreenComplexConfigPreset(string name, string values) {
|
|
Name = name;
|
|
Values = values.split("|");
|
|
}
|
|
}
|
|
|
|
class StartupScreenConfigComplexItemEditor: StartupScreenConfigSelectItemEditor {
|
|
private string dlgTitle;
|
|
|
|
StartupScreenConfigComplexItemEditor(StartupScreenUI@ ui,
|
|
StartupScreenComplexConfig@ cfg,
|
|
string label, string desc) {
|
|
super(ui, cfg, cfg.GetValuesString(),
|
|
label + ":" + desc + "|" + cfg.GetDescriptionsString());
|
|
dlgTitle = label;
|
|
@buttons[buttons.length - 1].Activated = EventHandler(this.CustomClicked);
|
|
}
|
|
|
|
private void CustomClicked(spades::ui::UIElement@) {
|
|
RunDialog();
|
|
}
|
|
|
|
private void DialogDone(spades::ui::UIElement@) {
|
|
LoadConfig();
|
|
}
|
|
|
|
private void RunDialog() {
|
|
StartupScreenComplexConfigDialog dlg(ui.manager, cast<StartupScreenComplexConfig>(config));
|
|
dlg.DialogDone = EventHandler(this.DialogDone);
|
|
dlg.Title = dlgTitle;
|
|
dlg.RunDialog();
|
|
}
|
|
}
|
|
|
|
class StartupScreenConfigView: spades::ui::ListViewBase {
|
|
private StartupScreenConfigViewModel vmodel;
|
|
|
|
StartupScreenConfigView(spades::ui::UIManager@ manager) {
|
|
super(manager);
|
|
this.RowHeight = 30.f;
|
|
}
|
|
void Finalize() {
|
|
@this.Model = vmodel;
|
|
}
|
|
void AddRow(spades::ui::UIElement@ elm) {
|
|
vmodel.items.insertLast(elm);
|
|
}
|
|
|
|
void Filter(string text) {
|
|
vmodel.Filter(text);
|
|
Reload();
|
|
}
|
|
|
|
void SetHelpTextHandler(HelpTextHandler@ handler) {
|
|
spades::ui::UIElement@[]@ elms = vmodel.items;
|
|
for(uint i = 0; i < elms.length; i++) {
|
|
StartupScreenConfigItemEditor@ item = cast<StartupScreenConfigItemEditor>(elms[i]);
|
|
if(item !is null) {
|
|
item.SetHelpTextHandler(handler);
|
|
}
|
|
}
|
|
}
|
|
void LoadConfig() {
|
|
spades::ui::UIElement@[]@ elms = vmodel.items;
|
|
for(uint i = 0; i < elms.length; i++) {
|
|
StartupScreenConfigItemEditor@ item = cast<StartupScreenConfigItemEditor>(elms[i]);
|
|
if(item !is null) {
|
|
item.LoadConfig();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
class StartupScreenComplexConfigDialog: spades::ui::UIElement {
|
|
StartupScreenComplexConfig@ config;
|
|
float ContentsTop = 50.f;
|
|
float ContentsHeight;
|
|
string Title;
|
|
|
|
spades::ui::TextViewer@ helpView;
|
|
StartupScreenConfigView@ configView;
|
|
|
|
spades::ui::EventHandler@ DialogDone;
|
|
|
|
private spades::ui::UIElement@ oldRoot;
|
|
|
|
StartupScreenComplexConfigDialog(spades::ui::UIManager@ manager,
|
|
StartupScreenComplexConfig@ config) {
|
|
super(manager);
|
|
@this.config = config;
|
|
Vector2 size = manager.RootElement.Size;
|
|
ContentsHeight = size.y - ContentsTop * 2.f;
|
|
|
|
float mainWidth = size.x - 250.f;
|
|
{
|
|
spades::ui::TextViewer e(Manager);
|
|
e.Bounds = AABB2(mainWidth, ContentsTop + 30.f, size.x - mainWidth - 10.f, ContentsHeight - 60.f);
|
|
AddChild(e);
|
|
@helpView = e;
|
|
}
|
|
|
|
{
|
|
StartupScreenConfigView cfg(Manager);
|
|
|
|
StartupScreenConfigItemEditor@[]@ editors = config.editors;
|
|
|
|
for(uint i = 0; i < editors.length; i++)
|
|
cfg.AddRow(cast<spades::ui::UIElement>(editors[i]));
|
|
|
|
cfg.Finalize();
|
|
cfg.SetHelpTextHandler(HelpTextHandler(this.HandleHelpText));
|
|
cfg.Bounds = AABB2(10.f, ContentsTop + 30.f, mainWidth - 20.f, ContentsHeight - 60.f);
|
|
AddChild(cfg);
|
|
@configView = cfg;
|
|
}
|
|
|
|
{
|
|
spades::ui::Button button(Manager);
|
|
button.Caption = _Tr("StartupScreen", "Close");
|
|
button.Bounds = AABB2(size.x - 160.f, ContentsTop + ContentsHeight - 30.f, 150.f, 30.f);
|
|
button.Activated = EventHandler(this.CloseActivated);
|
|
AddChild(button);
|
|
}
|
|
|
|
}
|
|
|
|
private void CloseActivated(spades::ui::UIElement@) {
|
|
if(oldRoot !is null) {
|
|
oldRoot.Enable = true;
|
|
@oldRoot = null;
|
|
}
|
|
@this.Parent = null;
|
|
DialogDone(this);
|
|
}
|
|
|
|
private void HandleHelpText(string s) {
|
|
helpView.Text = s;
|
|
}
|
|
|
|
void RunDialog() {
|
|
spades::ui::UIElement@ root = Manager.RootElement;
|
|
|
|
spades::ui::UIElementIterator iterator(root);
|
|
while(iterator.MoveNext()) {
|
|
spades::ui::UIElement@ e = iterator.Current;
|
|
if(e.Enable and e.Visible) {
|
|
@oldRoot = e;
|
|
e.Enable = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.Bounds = root.Bounds;
|
|
root.AddChild(this);
|
|
|
|
configView.LoadConfig();
|
|
}
|
|
|
|
void Render() {
|
|
Vector2 pos = ScreenPosition;
|
|
Vector2 size = Size;
|
|
Renderer@ r = Manager.Renderer;
|
|
Image@ img = r.RegisterImage("Gfx/White.tga");
|
|
|
|
r.ColorNP = Vector4(0, 0, 0, 0.8f);
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, pos.y, size.x, ContentsTop - 15.f));
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, ContentsTop + ContentsHeight + 15.f, size.x, ContentsTop - 15.f));
|
|
|
|
r.ColorNP = Vector4(0, 0, 0, 0.95f);
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, ContentsTop - 15.f, size.x, ContentsHeight + 30.f));
|
|
|
|
r.ColorNP = Vector4(1, 1, 1, 0.08f);
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, pos.y + ContentsTop - 15.f, size.x, 1.f));
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, pos.y + ContentsTop + ContentsHeight + 15.f, size.x, 1.f));
|
|
r.ColorNP = Vector4(1, 1, 1, 0.2f);
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, pos.y + ContentsTop - 14.f, size.x, 1.f));
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, pos.y + ContentsTop + ContentsHeight + 14.f, size.x, 1.f));
|
|
|
|
Font@ font = Font;
|
|
r.ColorNP = Vector4(0.8f, 0.8f, 0.8f, 1.f);
|
|
r.DrawImage(img,
|
|
AABB2(pos.x, pos.y + ContentsTop, size.x, 20.f));
|
|
font.Draw(Title, Vector2(pos.x + 10.f, pos.y + ContentsTop), 1.f, Vector4(0.f, 0.f, 0.f, 1.f));
|
|
|
|
UIElement::Render();
|
|
}
|
|
|
|
}
|
|
|
|
class StartupScreenGraphicsTab: spades::ui::UIElement, LabelAddable {
|
|
StartupScreenUI@ ui;
|
|
StartupScreenHelper@ helper;
|
|
|
|
StartupScreenGraphicsDisplayResolutionEditor@ resEdit;
|
|
|
|
spades::ui::CheckBox@ fullscreenCheck;
|
|
spades::ui::RadioButton@ driverOpenGL;
|
|
spades::ui::RadioButton@ driverSoftware;
|
|
|
|
spades::ui::TextViewer@ helpView;
|
|
StartupScreenConfigView@ configViewGL;
|
|
StartupScreenConfigView@ configViewSoftware;
|
|
|
|
private ConfigItem r_renderer("r_renderer");
|
|
private ConfigItem r_fullscreen("r_fullscreen");
|
|
|
|
StartupScreenGraphicsTab(StartupScreenUI@ ui, Vector2 size) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@helper = ui.helper;
|
|
|
|
float mainWidth = size.x - 250.f;
|
|
|
|
{
|
|
spades::ui::TextViewer e(Manager);
|
|
e.Bounds = AABB2(mainWidth + 10.f, 0.f, size.x - mainWidth - 10.f, size.y);
|
|
@e.Font = ui.font;
|
|
e.Text = _Tr("StartupScreen", "Graphics Settings");
|
|
AddChild(e);
|
|
@helpView = e;
|
|
}
|
|
|
|
AddLabel(0.f, 0.f, 24.f, _Tr("StartupScreen", "Resolution"));
|
|
{
|
|
StartupScreenGraphicsDisplayResolutionEditor e(ui);
|
|
e.Bounds = AABB2(100.f, 0.f, 124.f, 24.f);
|
|
AddChild(e);
|
|
@resEdit = e;
|
|
}
|
|
|
|
{
|
|
spades::ui::CheckBox e(Manager);
|
|
e.Caption = _Tr("StartupScreen", "Fullscreen Mode");
|
|
e.Bounds = AABB2(230.f, 0.f, 200.f, 24.f);
|
|
HelpHandler(helpView,
|
|
_Tr("StartupScreen", "By running in fullscreen mode OpenSpades occupies the "
|
|
"screen, making it easier for you to concentrate on playing the game.")).Watch(e);
|
|
@e.Activated = EventHandler(this.OnFullscreenCheck);
|
|
AddChild(e);
|
|
@fullscreenCheck = e;
|
|
}
|
|
|
|
AddLabel(0.f, 30.f, 24.f, _Tr("StartupScreen", "Backend"));
|
|
{
|
|
spades::ui::RadioButton e(Manager);
|
|
e.Caption = _Tr("StartupScreen", "OpenGL");
|
|
e.Bounds = AABB2(100.f, 30.f, 140.f, 24.f);
|
|
e.GroupName = "driver";
|
|
HelpHandler(helpView,
|
|
_Tr("StartupScreen", "OpenGL renderer uses your computer's graphics "
|
|
"accelerator to generate the game screen.")).Watch(e);
|
|
@e.Activated = EventHandler(this.OnDriverOpenGL);
|
|
AddChild(e);
|
|
@driverOpenGL = e;
|
|
}
|
|
{
|
|
spades::ui::RadioButton e(Manager);
|
|
e.Caption = _Tr("StartupScreen", "Software");
|
|
e.Bounds = AABB2(250.f, 30.f, 140.f, 24.f);
|
|
e.GroupName = "driver";
|
|
HelpHandler(helpView,
|
|
_Tr("StartupScreen", "Software renderer uses CPU to generate the game "
|
|
"screen. Its quality and performance might be inferior to OpenGL "
|
|
"renderer, but it works even with an unsupported GPU.")).Watch(e);
|
|
@e.Activated = EventHandler(this.OnDriverSoftware);
|
|
AddChild(e);
|
|
@driverSoftware = e;
|
|
}
|
|
|
|
{
|
|
StartupScreenConfigView cfg(Manager);
|
|
|
|
cfg.AddRow(StartupScreenConfigSelectItemEditor(ui,
|
|
StartupScreenGraphicsAntialiasConfig(ui), "0|2|4|fxaa",
|
|
_Tr("StartupScreen",
|
|
"Antialias:Enables a technique to improve the appearance of high-constrast edges.\n\n"
|
|
"MSAA: Performs antialiasing by generating an intermediate high-resolution image. "
|
|
"Looks best, but doesn't cope with some settings.\n\n"
|
|
"FXAA: Performs antialiasing by smoothing artifacts out as a post-process.|"
|
|
"Off|MSAA 2x|4x|FXAA")));
|
|
|
|
cfg.AddRow(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_radiosity"), "0", "1", _Tr("StartupScreen", "Global Illumination"),
|
|
_Tr("StartupScreen",
|
|
"Enables a physically based simulation of light path for more realistic lighting.")));
|
|
|
|
{
|
|
StartupScreenComplexConfig cplx;
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_cameraBlur"), "0", "1", _Tr("StartupScreen", "Camera Blur"),
|
|
_Tr("StartupScreen", "Blurs the screen when you turns quickly.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_lens"), "0", "1", _Tr("StartupScreen", "Lens Effect"),
|
|
_Tr("StartupScreen", "Simulates distortion caused by a real camera lens.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_bloom"), "0", "1", _Tr("StartupScreen", "Lens Scattering Filter"),
|
|
_Tr("StartupScreen", "Simulates light being scattered by dust on the camera lens.")));
|
|
// r_lens is currently no-op
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_lensFlare"), "0", "1", _Tr("StartupScreen", "Lens Flare"),
|
|
_Tr("StartupScreen", "The Sun causes lens flare.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_lensFlareDynamic"), "0", "1", _Tr("StartupScreen", "Flares for Dynamic Lights"),
|
|
_Tr("StartupScreen", "Enables lens flare for light sources other than the Sun.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_colorCorrection"), "0", "1", _Tr("StartupScreen", "Color Correction"),
|
|
_Tr("StartupScreen", "Applies cinematic color correction to make the image look better.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_depthOfField"), "0", "1", _Tr("StartupScreen", "Depth of Field"),
|
|
_Tr("StartupScreen", "Blurs out-of-focus objects.")));
|
|
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Low"), "0|0|0|0|0|0|0"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Medium"), "1|0|0|1|0|1|0"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "High"), "1|0|1|1|1|1|1"));
|
|
|
|
cfg.AddRow(StartupScreenConfigComplexItemEditor(ui, cplx,
|
|
_Tr("StartupScreen", "Post-process"),
|
|
_Tr("StartupScreen", "Post-process modifies the image to make it look better and "
|
|
"more realistic.")));
|
|
}
|
|
|
|
cfg.AddRow(StartupScreenConfigSelectItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_softParticles"), "0|1|2",
|
|
_Tr("StartupScreen",
|
|
"Particles|"
|
|
"Low:Artifact occurs when a particle intersects other objects.|"
|
|
"Medium:Particle intersects objects smoothly.|"
|
|
"High:Particle intersects objects smoothly, and some objects casts "
|
|
"their shadow to particles.")));
|
|
|
|
{
|
|
StartupScreenComplexConfig cplx;
|
|
// r_mapSoftShadow is currently no-op
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_dlights"), "0", "1", _Tr("StartupScreen", "Dynamic Lights"),
|
|
_Tr("StartupScreen",
|
|
"Gives some objects an ability to emit light to give them "
|
|
"an energy-emitting impression.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_modelShadows"), "0", "1", _Tr("StartupScreen", "Shadows"),
|
|
_Tr("StartupScreen", "Non-static object casts a shadow.")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_fogShadow"), "0", "1", _Tr("StartupScreen", "Volumetric Fog"),
|
|
_Tr("StartupScreen", "Simulates shadow being casted to the fog particles using a "
|
|
"super highly computationally demanding algorithm. ")));
|
|
cplx.AddEditor(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_physicalLighting"), "0", "1", _Tr("StartupScreen", "Physically Based Lighting"),
|
|
_Tr("StartupScreen", "Uses more accurate approximation techniques to decide the brightness of objects.")));
|
|
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Low"), "1|0|0|0"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Medium"), "1|1|0|0"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "High"), "1|1|0|1"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Ultra"), "1|1|1|1"));
|
|
|
|
cfg.AddRow(StartupScreenConfigComplexItemEditor(ui, cplx,
|
|
_Tr("StartupScreen", "Direct Lights"),
|
|
_Tr("StartupScreen", "Controls how light encounting a material and atmosphere directly "
|
|
"affects its appearance.")));
|
|
}
|
|
|
|
{
|
|
StartupScreenComplexConfig cplx;
|
|
|
|
cplx.AddEditor(StartupScreenConfigSelectItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_water"), "0|1|2",
|
|
_Tr("StartupScreen",
|
|
"Water Shader|"
|
|
"None:Water is rendered in the same way that normal blocks are done.|"
|
|
"Level 1:Refraction and the reflected Sun are simulated.|"
|
|
"Level 2:Waving water is simulated as well as reflection and refraction.")));
|
|
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Low"), "0"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "Medium"), "1"));
|
|
cplx.AddPreset(StartupScreenComplexConfigPreset(_Tr("StartupScreen", "High"), "2"));
|
|
|
|
cfg.AddRow(StartupScreenConfigComplexItemEditor(ui, cplx,
|
|
_Tr("StartupScreen", "Shader Effects"), _Tr("StartupScreen", "Special effects.")));
|
|
}
|
|
|
|
|
|
cfg.Finalize();
|
|
cfg.SetHelpTextHandler(HelpTextHandler(this.HandleHelpText));
|
|
cfg.Bounds = AABB2(0.f, 60.f, mainWidth, size.y - 60.f);
|
|
AddChild(cfg);
|
|
@configViewGL = cfg;
|
|
}
|
|
|
|
{
|
|
StartupScreenConfigView cfg(Manager);
|
|
|
|
cfg.AddRow(StartupScreenConfigSelectItemEditor(ui,
|
|
StartupScreenConfig(ui, "r_swUndersampling"), "0|1|2",
|
|
_Tr("StartupScreen",
|
|
"Fast Mode:Reduces the image resolution to make the rendering faster.|"
|
|
"Off|2x|4x")));
|
|
|
|
|
|
cfg.Finalize();
|
|
cfg.SetHelpTextHandler(HelpTextHandler(this.HandleHelpText));
|
|
cfg.Bounds = AABB2(0.f, 60.f, mainWidth, size.y - 60.f);
|
|
AddChild(cfg);
|
|
@configViewSoftware = cfg;
|
|
}
|
|
|
|
}
|
|
|
|
private void HandleHelpText(string text) {
|
|
helpView.Text = text;
|
|
}
|
|
|
|
private void OnDriverOpenGL(spades::ui::UIElement@){ r_renderer.StringValue = "gl"; LoadConfig(); }
|
|
private void OnDriverSoftware(spades::ui::UIElement@){ r_renderer.StringValue = "sw"; LoadConfig(); }
|
|
|
|
private void OnFullscreenCheck(spades::ui::UIElement@)
|
|
{ r_fullscreen.IntValue = fullscreenCheck.Toggled ? 1 : 0; }
|
|
|
|
void LoadConfig() {
|
|
resEdit.LoadConfig();
|
|
if(r_renderer.StringValue == "sw") {
|
|
driverSoftware.Check();
|
|
configViewGL.Visible = false;
|
|
configViewSoftware.Visible = true;
|
|
}else{
|
|
driverOpenGL.Check();
|
|
configViewGL.Visible = true;
|
|
configViewSoftware.Visible = false;
|
|
}
|
|
fullscreenCheck.Toggled = r_fullscreen.IntValue != 0;
|
|
driverOpenGL.Enable = ui.helper.CheckConfigCapability("r_renderer", "gl").length == 0;
|
|
driverSoftware.Enable = ui.helper.CheckConfigCapability("r_renderer", "sw").length == 0;
|
|
configViewGL.LoadConfig();
|
|
configViewSoftware.LoadConfig();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
class StartupScreenGraphicsDisplayResolutionEditorDropdownButton: spades::ui::SimpleButton {
|
|
StartupScreenGraphicsDisplayResolutionEditorDropdownButton(spades::ui::UIManager@ manager) {
|
|
super(manager);
|
|
}
|
|
void Render() {
|
|
SimpleButton::Render();
|
|
|
|
Renderer@ renderer = Manager.Renderer;
|
|
Image@ image = renderer.RegisterImage("Gfx/UI/ScrollArrow.png");
|
|
AABB2 bnd = ScreenBounds;
|
|
Vector2 p = (bnd.min + bnd.max) * 0.5f + Vector2(-8.f, 8.f);
|
|
renderer.DrawImage(image, AABB2(p.x, p.y, 16.f, -16.f));
|
|
}
|
|
}
|
|
|
|
class StartupScreenGraphicsDisplayResolutionEditor: spades::ui::UIElement {
|
|
spades::ui::Field@ widthField;
|
|
spades::ui::Field@ heightField;
|
|
spades::ui::Button@ dropdownButton;
|
|
private ConfigItem r_videoWidth("r_videoWidth");
|
|
private ConfigItem r_videoHeight("r_videoHeight");
|
|
StartupScreenHelper@ helper;
|
|
|
|
StartupScreenGraphicsDisplayResolutionEditor(StartupScreenUI@ ui) {
|
|
super(ui.manager);
|
|
@helper = ui.helper;
|
|
{
|
|
spades::ui::Field e(manager);
|
|
AddChild(e);
|
|
e.Bounds = AABB2(0, 0, 45.f, 24.f);
|
|
e.DenyNonAscii = true;
|
|
e.Changed = EventHandler(this.ValueEditHandler);
|
|
@widthField = e;
|
|
}
|
|
{
|
|
spades::ui::Field e(manager);
|
|
AddChild(e);
|
|
e.Bounds = AABB2(53, 0, 45.f, 24.f);
|
|
e.DenyNonAscii = true;
|
|
e.Changed = EventHandler(this.ValueEditHandler);
|
|
@heightField = e;
|
|
}
|
|
{
|
|
StartupScreenGraphicsDisplayResolutionEditorDropdownButton e(manager);
|
|
AddChild(e);
|
|
e.Bounds = AABB2(100, 0, 24.f, 24.f);
|
|
@e.Activated = EventHandler(this.ShowDropdown);
|
|
@dropdownButton = e;
|
|
}
|
|
}
|
|
|
|
void LoadConfig() {
|
|
widthField.Text = ToString(r_videoWidth.IntValue);
|
|
heightField.Text = ToString(r_videoHeight.IntValue);
|
|
}
|
|
|
|
void SaveConfig() {
|
|
int w = ParseInt(widthField.Text);
|
|
int h = ParseInt(heightField.Text);
|
|
if(w < 640 or h < 480 or w > 8192 or h > 8192) return;
|
|
r_videoWidth.IntValue = w;
|
|
r_videoHeight.IntValue = h;
|
|
}
|
|
|
|
private void ValueEditHandler(spades::ui::UIElement@) {
|
|
SaveConfig();
|
|
}
|
|
|
|
private void DropdownHandler(int index) {
|
|
if(index >= 0) {
|
|
widthField.Text = ToString(helper.GetVideoModeWidth(index));
|
|
heightField.Text = ToString(helper.GetVideoModeHeight(index));
|
|
|
|
SaveConfig();
|
|
}
|
|
}
|
|
|
|
private void ShowDropdown(spades::ui::UIElement@) {
|
|
string[] items = {};
|
|
int cnt = helper.GetNumVideoModes();
|
|
for(int i = 0; i < cnt; i++) {
|
|
int w = helper.GetVideoModeWidth(i);
|
|
int h = helper.GetVideoModeHeight(i);
|
|
string s = ToString(w) + "x" + ToString(h);
|
|
items.insertLast(s);
|
|
}
|
|
spades::ui::ShowDropDownList(this, items, DropDownListHandler(this.DropdownHandler));
|
|
}
|
|
void Render() {
|
|
Font@ font = this.Font;
|
|
font.Draw("x", Vector2(45.f, 0.f) + ScreenPosition, 1.f, Vector4(1.f, 1.f, 1.f, 1.f));
|
|
UIElement::Render();
|
|
}
|
|
}
|
|
|
|
class StartupScreenGraphicsAntialiasConfig: StartupScreenGenericConfig {
|
|
private StartupScreenUI@ ui;
|
|
private ConfigItem@ msaaConfig;
|
|
private ConfigItem@ fxaaConfig;
|
|
StartupScreenGraphicsAntialiasConfig(StartupScreenUI@ ui) {
|
|
@this.ui = ui;
|
|
@msaaConfig = ConfigItem("r_multisamples");
|
|
@fxaaConfig = ConfigItem("r_fxaa");
|
|
}
|
|
string GetValue() {
|
|
if(fxaaConfig.IntValue != 0) {
|
|
return "fxaa";
|
|
}else{
|
|
int v = msaaConfig.IntValue;
|
|
if(v < 2) return "0";
|
|
else return msaaConfig.StringValue;
|
|
}
|
|
}
|
|
void SetValue(string v) {
|
|
if(v == "fxaa") {
|
|
msaaConfig.StringValue = "0";
|
|
fxaaConfig.StringValue = "1";
|
|
} else if (v == "0" || v == "1") {
|
|
msaaConfig.StringValue = "0";
|
|
fxaaConfig.StringValue = "0";
|
|
} else {
|
|
msaaConfig.StringValue = v;
|
|
fxaaConfig.StringValue = "0";
|
|
}
|
|
}
|
|
string CheckValueCapability(string v) {
|
|
if(v == "fxaa") {
|
|
return ui.helper.CheckConfigCapability("r_multisamples", "0") +
|
|
ui.helper.CheckConfigCapability("r_fxaa", "1");
|
|
} else if (v == "0" || v == "1") {
|
|
return ui.helper.CheckConfigCapability("r_multisamples", "0") +
|
|
ui.helper.CheckConfigCapability("r_fxaa", "0");
|
|
} else {
|
|
return ui.helper.CheckConfigCapability("r_multisamples", v) +
|
|
ui.helper.CheckConfigCapability("r_fxaa", "0");
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
class StartupScreenAudioTab: spades::ui::UIElement, LabelAddable {
|
|
StartupScreenUI@ ui;
|
|
StartupScreenHelper@ helper;
|
|
|
|
spades::ui::RadioButton@ driverOpenAL;
|
|
spades::ui::RadioButton@ driverYSR;
|
|
spades::ui::RadioButton@ driverNull;
|
|
|
|
spades::ui::TextViewer@ helpView;
|
|
StartupScreenConfigView@ configViewOpenAL;
|
|
StartupScreenConfigView@ configViewYSR;
|
|
|
|
private ConfigItem s_audioDriver("s_audioDriver");
|
|
private ConfigItem s_eax("s_eax");
|
|
|
|
StartupScreenAudioTab(StartupScreenUI@ ui, Vector2 size) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@helper = ui.helper;
|
|
|
|
float mainWidth = size.x - 250.f;
|
|
|
|
{
|
|
spades::ui::TextViewer e(Manager);
|
|
e.Bounds = AABB2(mainWidth + 10.f, 0.f, size.x - mainWidth - 10.f, size.y);
|
|
@e.Font = ui.font;
|
|
e.Text = _Tr("StartupScreen", "Audio Settings");
|
|
AddChild(e);
|
|
@helpView = e;
|
|
}
|
|
|
|
|
|
AddLabel(0.f, 0.f, 24.f, _Tr("StartupScreen", "Backend"));
|
|
{
|
|
spades::ui::RadioButton e(Manager);
|
|
e.Caption = _Tr("StartupScreen", "OpenAL");
|
|
e.Bounds = AABB2(100.f, 0.f, 100.f, 24.f);
|
|
e.GroupName = "driver";
|
|
HelpHandler(helpView,
|
|
_Tr("StartupScreen", "Uses an OpenAL-capable sound card to process sound. "
|
|
"In most cases where there isn't such a sound card, software emulation is "
|
|
"used.")).Watch(e);
|
|
@e.Activated = EventHandler(this.OnDriverOpenAL);
|
|
AddChild(e);
|
|
@driverOpenAL = e;
|
|
}
|
|
{
|
|
spades::ui::RadioButton e(Manager);
|
|
e.Caption = _Tr("StartupScreen", "YSR");
|
|
e.Bounds = AABB2(210.f, 0.f, 100.f, 24.f);
|
|
e.GroupName = "driver";
|
|
HelpHandler(helpView,
|
|
_Tr("StartupScreen", "YSR is an experimental 3D HDR sound engine optimized "
|
|
"for OpenSpades. It features several enhanced features including "
|
|
"automatic load control, dynamics compressor, HRTF-based "
|
|
"3D audio, and high quality reverb.")).Watch(e);
|
|
@e.Activated = EventHandler(this.OnDriverYSR);
|
|
AddChild(e);
|
|
@driverYSR = e;
|
|
}
|
|
{
|
|
spades::ui::RadioButton e(Manager);
|
|
e.Caption = _Tr("StartupScreen", "Null");
|
|
e.Bounds = AABB2(320.f, 0.f, 100.f, 24.f);
|
|
e.GroupName = "driver";
|
|
HelpHandler(helpView,
|
|
_Tr("StartupScreen", "Disables audio output.")).Watch(e);
|
|
@e.Activated = EventHandler(this.OnDriverNull);
|
|
AddChild(e);
|
|
@driverNull = e;
|
|
}
|
|
|
|
{
|
|
StartupScreenConfigView cfg(Manager);
|
|
|
|
cfg.AddRow(StartupScreenConfigSliderItemEditor(ui,
|
|
StartupScreenConfig(ui, "s_maxPolyphonics"), 16.0, 256.0, 8.0,
|
|
_Tr("StartupScreen", "Polyphonics"), _Tr("StartupScreen",
|
|
"Specifies how many sounds can be played simultaneously. "
|
|
"Higher value needs more processing power, so setting this too high might "
|
|
"cause an overload (especially with a software emulation)."),
|
|
ConfigNumberFormatter(0, " poly")));
|
|
|
|
cfg.AddRow(StartupScreenConfigCheckItemEditor(ui,
|
|
StartupScreenConfig(ui, "s_eax"), "0", "1",
|
|
_Tr("StartupScreen", "EAX"), _Tr("StartupScreen",
|
|
"Enables extended features provided by the OpenAL driver to create "
|
|
"more ambience.")));
|
|
|
|
cfg.Finalize();
|
|
cfg.SetHelpTextHandler(HelpTextHandler(this.HandleHelpText));
|
|
cfg.Bounds = AABB2(0.f, 30.f, mainWidth, size.y - 30.f);
|
|
AddChild(cfg);
|
|
@configViewOpenAL = cfg;
|
|
}
|
|
|
|
{
|
|
StartupScreenConfigView cfg(Manager);
|
|
|
|
cfg.AddRow(StartupScreenConfigSliderItemEditor(ui,
|
|
StartupScreenConfig(ui, "s_maxPolyphonics"), 16.0, 256.0, 8.0,
|
|
_Tr("StartupScreen", "Polyphonics"), _Tr("StartupScreen",
|
|
"Specifies how many sounds can be played simultaneously. "
|
|
"No matter what value is set, YSR might reduce the number of sounds "
|
|
"when an overload is detected."),
|
|
ConfigNumberFormatter(0, " poly")));
|
|
|
|
|
|
cfg.Finalize();
|
|
cfg.SetHelpTextHandler(HelpTextHandler(this.HandleHelpText));
|
|
cfg.Bounds = AABB2(0.f, 30.f, mainWidth, size.y - 30.f);
|
|
AddChild(cfg);
|
|
@configViewYSR = cfg;
|
|
}
|
|
|
|
}
|
|
|
|
private void HandleHelpText(string text) {
|
|
helpView.Text = text;
|
|
}
|
|
|
|
private void OnDriverOpenAL(spades::ui::UIElement@){ s_audioDriver.StringValue = "openal"; LoadConfig(); }
|
|
private void OnDriverYSR(spades::ui::UIElement@){ s_audioDriver.StringValue = "ysr"; LoadConfig(); }
|
|
private void OnDriverNull(spades::ui::UIElement@){ s_audioDriver.StringValue = "null"; LoadConfig(); }
|
|
|
|
void LoadConfig() {
|
|
if(s_audioDriver.StringValue == "ysr") {
|
|
driverYSR.Check();
|
|
configViewOpenAL.Visible = false;
|
|
configViewYSR.Visible = true;
|
|
}else if(s_audioDriver.StringValue == "openal"){
|
|
driverOpenAL.Check();
|
|
configViewOpenAL.Visible = true;
|
|
configViewYSR.Visible = false;
|
|
}else if(s_audioDriver.StringValue == "null"){
|
|
driverNull.Check();
|
|
configViewOpenAL.Visible = false;
|
|
configViewYSR.Visible = false;
|
|
}
|
|
driverOpenAL.Enable = ui.helper.CheckConfigCapability("s_audioDriver", "openal").length == 0;
|
|
driverYSR.Enable = ui.helper.CheckConfigCapability("s_audioDriver", "ysr").length == 0;
|
|
driverNull.Enable = ui.helper.CheckConfigCapability("s_audioDriver", "null").length == 0;
|
|
configViewOpenAL.LoadConfig();
|
|
configViewYSR.LoadConfig();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
class StartupScreenSystemInfoTab: spades::ui::UIElement, LabelAddable {
|
|
StartupScreenUI@ ui;
|
|
StartupScreenHelper@ helper;
|
|
|
|
spades::ui::TextViewer@ helpView;
|
|
|
|
StartupScreenSystemInfoTab(StartupScreenUI@ ui, Vector2 size) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@helper = ui.helper;
|
|
|
|
{
|
|
spades::ui::TextViewer e(Manager);
|
|
e.Bounds = AABB2(0.f, 0.f, size.x, size.y - 30.f);
|
|
@e.Font = ui.font;
|
|
AddChild(e);
|
|
for(int i = 0, count = helper.GetNumReportLines(); i < count; i++) {
|
|
string text = helper.GetReportLineText(i);
|
|
Vector4 col = helper.GetReportLineColor(i);
|
|
e.AddLine(text, true, col);
|
|
}
|
|
@helpView = e;
|
|
}
|
|
|
|
{
|
|
spades::ui::Button button(Manager);
|
|
button.Caption = _Tr("StartupScreen", "Copy to Clipboard");
|
|
button.Bounds = AABB2(size.x - 180.f, size.y - 30.f, 180.f, 30.f);
|
|
button.Activated = EventHandler(this.OnCopyReport);
|
|
AddChild(button);
|
|
}
|
|
|
|
}
|
|
private void OnCopyReport(spades::ui::UIElement@){
|
|
Manager.Copy(helper.GetReport());
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
class StartupScreenAdvancedTab: spades::ui::UIElement, LabelAddable {
|
|
StartupScreenUI@ ui;
|
|
StartupScreenHelper@ helper;
|
|
|
|
spades::ui::Field@ filter;
|
|
|
|
spades::ui::TextViewer@ helpView;
|
|
StartupScreenConfigView@ configView;
|
|
|
|
StartupScreenAdvancedTab(StartupScreenUI@ ui, Vector2 size) {
|
|
super(ui.manager);
|
|
@this.ui = ui;
|
|
@helper = ui.helper;
|
|
|
|
float mainWidth = size.x - 250.f;
|
|
|
|
{
|
|
spades::ui::TextViewer e(Manager);
|
|
e.Bounds = AABB2(mainWidth + 10.f, 0.f, size.x - mainWidth - 10.f, size.y);
|
|
@e.Font = ui.font;
|
|
e.Text = _Tr("StartupScreen", "Advanced Settings");
|
|
e.Visible = false;
|
|
AddChild(e);
|
|
@helpView = e;
|
|
}
|
|
|
|
|
|
{
|
|
spades::ui::Field e(Manager);
|
|
e.Placeholder = _Tr("StartupScreen", "Filter");
|
|
e.Bounds = AABB2(0.f, 0.f, size.x, 24.f);
|
|
@e.Changed = EventHandler(this.OnFilterChanged);
|
|
AddChild(e);
|
|
@filter = e;
|
|
}
|
|
|
|
{
|
|
StartupScreenConfigView cfg(Manager);
|
|
|
|
string[]@ names = GetAllConfigNames();
|
|
|
|
for(uint i = 0, count = names.length; i < count; i++) {
|
|
|
|
cfg.AddRow(StartupScreenConfigFieldItemEditor(ui,
|
|
StartupScreenConfig(ui, names[i]), names[i], ""));
|
|
}
|
|
|
|
cfg.Finalize();
|
|
cfg.SetHelpTextHandler(HelpTextHandler(this.HandleHelpText));
|
|
cfg.Bounds = AABB2(0.f, 30.f, size.x, size.y - 30.f);
|
|
AddChild(cfg);
|
|
@configView = cfg;
|
|
}
|
|
}
|
|
|
|
private void HandleHelpText(string text) {
|
|
helpView.Text = text;
|
|
}
|
|
|
|
private void OnFilterChanged(spades::ui::UIElement@){
|
|
configView.Filter(filter.Text);
|
|
}
|
|
|
|
void LoadConfig() {
|
|
configView.LoadConfig();
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
StartupScreenUI@ CreateStartupScreenUI(Renderer@ renderer, AudioDevice@ audioDevice,
|
|
Font@ font, StartupScreenHelper@ helper) {
|
|
return StartupScreenUI(renderer, audioDevice, font, helper);
|
|
}
|
|
}
|