public static DrawableElement Circle(double x, double y, double r, string name = null, string comment = null, string color = "Undefined")
{
var settings = new VisualSettings(name, color: color);
return new DrawableElement
{
Type = DrawableType.Circle,
Comment = new List<string>() { comment },
reper = new List<ReperPoint> { new ReperPoint(x, y), new ReperPoint(x + r, y) },
Settings = settings
};
}
public static DrawableElement Ellipse(double ax, double ay, double bx, double by, double l, string name = null, string comment = null, string color = "Undefined")
{
var settings = new VisualSettings(name, color: color);
return new DrawableElement
{
Type = DrawableType.Ellipse,
Comment = new List<string>() { comment },
reper = new List<ReperPoint> { new ReperPoint(ax, ay), new ReperPoint(bx, by), new ReperPoint(ax + l, ay) },
Settings = settings
};
}
public void RenderPoint(bool picking)
{
ViewPlaneHandler vph = (Application.OpenForms[0] as Form1).vph;
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
List <object> SelectedDots = (Application.OpenForms[0] as Form1).SelectedDots;
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, Settings.HighlightPointborderColor.A);
}
else
{
Gl.glColor4f(Settings.PointborderColor.R / 255f, Settings.PointborderColor.G / 255f, Settings.PointborderColor.B / 255f, Settings.PointborderColor.A);
}
vph.draw2DVertice(Pos);
Gl.glEnd();
if (vph.mode == ViewPlaneHandler.PLANE_MODES.XZ)
{
Gl.glPushMatrix();
Gl.glTranslatef(PositionX, PositionZ, 0);
Gl.glRotatef(-RotationY, 0, 0, 1);
Gl.glBegin(Gl.GL_LINES);
Gl.glVertex2f(0, 0);
Gl.glVertex2f(0, 150);
Gl.glEnd();
Gl.glPopMatrix();
}
Gl.glPointSize(Settings.PointSize);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
}
else
{
Gl.glColor4f(Settings.JugemColor.R / 255f, Settings.JugemColor.G / 255f, Settings.JugemColor.B / 255f, Settings.JugemColor.A);
}
vph.draw2DVertice(Pos);
Gl.glEnd();
}
private void load(SessionStatics sessionStatics)
{
muteWarningShownOnce = sessionStatics.GetBindable <bool>(Static.MutedAudioNotificationShownOnce);
batteryWarningShownOnce = sessionStatics.GetBindable <bool>(Static.LowBatteryNotificationShownOnce);
InternalChild = (content = new LogoTrackingContainer
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
}).WithChildren(new Drawable[]
{
MetadataInfo = new BeatmapMetadataDisplay(Beatmap.Value, Mods, content.LogoFacade)
{
Alpha = 0,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
},
PlayerSettings = new FillFlowContainer <PlayerSettingsGroup>
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Vertical,
Spacing = new Vector2(0, 20),
Margin = new MarginPadding(25),
Children = new PlayerSettingsGroup[]
{
VisualSettings = new VisualSettings(),
new InputSettings()
}
},
idleTracker = new IdleTracker(750)
});
if (Beatmap.Value.BeatmapInfo.EpilepsyWarning)
{
AddInternal(epilepsyWarning = new EpilepsyWarning
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
});
}
}
public void RenderPoint()
{
ViewPlaneHandler vph = (Application.OpenForms[0] as Form1).vph;
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
List <object> SelectedDots = (Application.OpenForms[0] as Form1).SelectedDots;
float PointScale = 50f * Scale;
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, Settings.HighlightPointborderColor.A);
}
else
{
Gl.glColor4f(Settings.PointborderColor.R / 255f, Settings.PointborderColor.G / 255f, Settings.PointborderColor.B / 255f, Settings.PointborderColor.A);
}
vph.draw2DVertice(Pos);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
}
else
{
Gl.glColor4f(Settings.GliderColor.R / 255f, Settings.GliderColor.G / 255f, Settings.GliderColor.B / 255f, Settings.GliderColor.A);
}
vph.draw2DVertice(Pos);
Gl.glEnd();
Gl.glLineWidth(Settings.LineWidth);
if (SelectedDots.Contains(this))
{
DrawFilledCircle(vph.getViewCoord(Pos, 0), vph.getViewCoord(Pos, 1), PointScale, 24, Settings.HighlightPointborderColor, Settings.HighlightPointColor);
}
else
{
DrawFilledCircle(vph.getViewCoord(Pos, 0), vph.getViewCoord(Pos, 1), PointScale, 24, Settings.GliderColor, Settings.GliderColor);
}
}
public void SavedValuesAreAppliedDuringConstruction()
{
// Arrange
var visual = new VisualConfig
{
AccentColor = "blue",
FontSize = 13,
HashtagColor = "red",
InlineMedia = true,
LinkColor = "green",
MentionColor = "red",
PrimaryColor = "yellow",
UseDarkTheme = true
};
var cfg = new Mock <IConfig>();
cfg.SetupGet(c => c.Visual).Returns(visual);
var colors = new Mock <IColorProvider>();
var colorList = new[]
{ CreateSwatch("blue"), CreateSwatch("red"), CreateSwatch("green"), CreateSwatch("yellow") };
colors.SetupGet(c => c.AvailableAccentColors).Returns(colorList);
colors.SetupGet(c => c.AvailablePrimaryColors).Returns(colorList);
var lng = new Mock <ILanguageProvider>();
lng.SetupGet(l => l.CurrentCulture).Returns(CultureInfo.CreateSpecificCulture("en-US"));
// Act
var vm = new VisualSettings(cfg.Object, colors.Object, lng.Object);
// Assert
Assert.AreEqual(visual.AccentColor, vm.SelectedAccentColor.Name);
Assert.AreEqual(visual.FontSize, vm.SelectedFontSize.Size);
Assert.AreEqual(visual.HashtagColor, vm.SelectedHashtagColor.Name);
Assert.AreEqual(visual.InlineMedia, vm.InlineMedias);
Assert.AreEqual(visual.LinkColor, vm.SelectedLinkColor.Name);
Assert.AreEqual(visual.MentionColor, vm.SelectedMentionColor.Name);
Assert.AreEqual(visual.PrimaryColor, vm.SelectedPrimaryColor.Name);
Assert.AreEqual(visual.UseDarkTheme, vm.UseDarkTheme);
}
public AssociationSettingsPersistable ToPersistable()
{
return(new AssociationSettingsPersistable
{
SpecializationTypeId = this.Id,
SpecializationType = this.Name,
SourceEnd = new AssociationEndSettingsPersistable
{
SpecializationTypeId = this.SourceEnd.Id,
SpecializationType = this.SourceEnd.Name,
DisplayFunction = this.SourceEnd.GetSettings().DisplayTextFunction(),
Icon = this.SourceEnd.GetSettings().Icon().ToPersistable(),
TypeReferenceSetting = new TypeReferenceSettingPersistable()
{
TargetTypes = this.SourceEnd.GetSettings().TargetTypes().Select(t => t.Name).ToArray(),
IsCollectionDefault = this.SourceEnd.GetSettings().IsCollectionDefault(),
AllowIsCollection = this.SourceEnd.GetSettings().IsCollectionEnabled(),
IsNavigableDefault = this.SourceEnd.GetSettings().IsNavigableDefault(),
AllowIsNavigable = this.SourceEnd.GetSettings().IsNavigableEnabled(),
IsNullableDefault = this.SourceEnd.GetSettings().IsNullableDefault(),
AllowIsNullable = this.SourceEnd.GetSettings().IsNullableEnabled()
}
},
TargetEnd = new AssociationEndSettingsPersistable
{
SpecializationTypeId = this.TargetEnd.Id,
SpecializationType = this.TargetEnd.Name,
DisplayFunction = this.TargetEnd.GetSettings().DisplayTextFunction(),
Icon = this.TargetEnd.GetSettings().Icon().ToPersistable(),
TypeReferenceSetting = new TypeReferenceSettingPersistable()
{
TargetTypes = this.TargetEnd.GetSettings().TargetTypes().Select(t => t.Name).ToArray(),
IsCollectionDefault = this.TargetEnd.GetSettings().IsCollectionDefault(),
AllowIsCollection = this.TargetEnd.GetSettings().IsCollectionEnabled(),
IsNavigableDefault = this.TargetEnd.GetSettings().IsNavigableDefault(),
AllowIsNavigable = this.TargetEnd.GetSettings().IsNavigableEnabled(),
IsNullableDefault = this.TargetEnd.GetSettings().IsNullableDefault(),
AllowIsNullable = this.TargetEnd.GetSettings().IsNullableEnabled()
}
},
VisualSettings = VisualSettings?.ToPersistable()
});
}
public void PropertyChangedIsImplementedCorrectly()
{
// Arrange
var cfg = new Mock <IConfig>();
cfg.SetupGet(c => c.Visual).Returns(new VisualConfig());
var colors = new Mock <IColorProvider>();
var lang = new Mock <ILanguageProvider>();
var vm = new VisualSettings(cfg.Object, colors.Object, lang.Object);
var tester = new PropertyChangedTester(vm);
// Act
tester.Test();
// Assert
tester.Verify();
}
public MainMenuLayer(BuildingDescriptionDatabase buildingDescriptionDatabase, ColorCollectionFile colorCollectionFile, LanguageSettings languageSettings)
{
var colorCollection = new ColorCollection(colorCollectionFile);
HelpButton = new HexButton("Help", 150, colorCollection);
//OptionsButton = new HexButton("Options", 150, colorCollection);
StartGameButton = new HexButton("Start", 150, colorCollection);
BuildingDescriptionDatabase = buildingDescriptionDatabase;
ColorCollectionFile = colorCollectionFile;
LanguageSettings = languageSettings;
VisualSettings = new VisualSettings(colorCollectionFile);
StartGameButton.Touched += StartGameButton_Clicked;
HelpButton.Touched += HelpButton_Clicked;
//OptionsButton.Touched += OptionsButton_Clicked;
AddEventListener(new CCEventListenerTouchOneByOne {
OnTouchBegan = TouchDown, OnTouchCancelled = OnTouchCancelled, OnTouchEnded = OnTouchUp, OnTouchMoved = OnTouchMoved
});
}
public void RenderPicking(int group_id, int entry_id)
{
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
Color pickingColorL = SectionPicking.GetColor(Sections.CheckPoints, group_id, entry_id, PointID.Left);
Color pickingColorR = SectionPicking.GetColor(Sections.CheckPoints, group_id, entry_id, PointID.Right);
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
Gl.glColor4f(pickingColorR.R / 255f, pickingColorR.G / 255f, pickingColorR.B / 255f, 1f);
Gl.glVertex2f(RightPointX, RightPointZ);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
Gl.glColor4f(pickingColorL.R / 255f, pickingColorL.G / 255f, pickingColorL.B / 255f, 1f);
Gl.glVertex2f(LeftPointX, LeftPointZ);
Gl.glEnd();
}
public void Render()
{
if (!Visible)
{
return;
}
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
if (Settings.LinkPoints)
{
for (int i = 0; i < Entries.Count - 1; i++)
{
Gl.glBegin(Gl.GL_LINES);
Entries[i].RenderLeftLine(Settings);
Entries[i + 1].RenderLeftLine(Settings);
Gl.glEnd();
Gl.glBegin(Gl.GL_LINES);
Entries[i].RenderRightLine(Settings);
Entries[i + 1].RenderRightLine(Settings);
Gl.glEnd();
if (!IsConvex(Entries[i], Entries[i + 1]))
{
Gl.glBegin(Gl.GL_TRIANGLE_FAN);
Gl.glColor4f(1f, 0f, 0f, 0.75f);
Gl.glVertex2f(Entries[i].LeftPointX, Entries[i].LeftPointZ);
Gl.glVertex2f(Entries[i].RightPointX, Entries[i].RightPointZ);
Gl.glVertex2f(Entries[i + 1].RightPointX, Entries[i + 1].RightPointZ);
Gl.glVertex2f(Entries[i + 1].LeftPointX, Entries[i + 1].LeftPointZ);
Gl.glEnd();
}
}
}
foreach (var entry in Entries)
{
entry.RenderSegment();
}
}
public void RenderPoint(bool picking)
{
Vector3 pos = new Vector3(PositionX, PositionY, PositionZ);
ViewPlaneHandler vph = (Application.OpenForms[0] as Form1).vph;
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
List<object> SelectedDots = (Application.OpenForms[0] as Form1).SelectedDots;
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this)) Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, Settings.HighlightPointborderColor.A);
else Gl.glColor4f(Settings.PointborderColor.R / 255f, Settings.PointborderColor.G / 255f, Settings.PointborderColor.B / 255f, Settings.PointborderColor.A);
vph.draw2DVertice(pos);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this)) Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
else Gl.glColor4f(Settings.KtptColor.R / 255f, Settings.KtptColor.G / 255f, Settings.KtptColor.B / 255f, Settings.KtptColor.A);
vph.draw2DVertice(pos);
Gl.glEnd();
}
void Awake()
{
visualSettings = FindObjectOfType <VisualSettings>();
}
public void SettingsAreCorrectlySaved()
{
// Arrange
var colorList = new[]
{ CreateSwatch("blue"), CreateSwatch("red"), CreateSwatch("green"), CreateSwatch("yellow") };
var cfg = new Mock <IConfig>();
cfg.SetupGet(c => c.Visual).Returns(new VisualConfig());
var colors = new Mock <IColorProvider>();
colors.SetupGet(c => c.AvailableAccentColors).Returns(colorList);
colors.SetupGet(c => c.AvailablePrimaryColors).Returns(colorList);
colors.Setup(c => c.SetDarkTheme(true)).Verifiable();
colors.Setup(c => c.SetFontSize(16)).Verifiable();
colors.Setup(c => c.SetHashtagColor("yellow")).Verifiable();
colors.Setup(c => c.SetLinkColor("red")).Verifiable();
colors.Setup(c => c.SetMentionColor("blue")).Verifiable();
colors.Setup(c => c.SetAccentColor("green")).Verifiable();
colors.Setup(c => c.SetPrimaryColor("blue")).Verifiable();
var lang = new Mock <ILanguageProvider>();
var vm = new VisualSettings(cfg.Object, colors.Object, lang.Object);
vm.SelectedAccentColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "green");
vm.SelectedPrimaryColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "blue");
vm.SelectedHashtagColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "yellow");
vm.SelectedLinkColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "red");
vm.SelectedMentionColor = vm.AvailableAccentColors.FirstOrDefault(c => c.Name == "blue");
vm.InlineMedias = true;
vm.SelectedFontSize = vm.AvailableFontSizes.FirstOrDefault(f => f.Size == 16);
vm.UseDarkTheme = true;
var saved = new Mock <IConfig>();
var visual = new VisualConfig();
saved.SetupGet(s => s.Visual).Returns(visual);
// Act
vm.SaveTo(saved.Object);
// Assert
Assert.AreEqual(vm.SelectedAccentColor.Name, visual.AccentColor);
Assert.AreEqual(vm.SelectedFontSize.Size, visual.FontSize);
Assert.AreEqual(vm.SelectedHashtagColor.Name, visual.HashtagColor);
Assert.AreEqual(vm.SelectedLinkColor.Name, visual.LinkColor);
Assert.AreEqual(vm.SelectedMentionColor.Name, visual.MentionColor);
Assert.AreEqual(vm.SelectedPrimaryColor.Name, visual.PrimaryColor);
Assert.AreEqual(vm.InlineMedias, visual.InlineMedia);
Assert.AreEqual(vm.UseDarkTheme, visual.UseDarkTheme);
colors.Verify(c => c.SetDarkTheme(true), Times.Once());
colors.Verify(c => c.SetFontSize(16), Times.Once());
colors.Verify(c => c.SetHashtagColor("yellow"), Times.Once());
colors.Verify(c => c.SetLinkColor("red"), Times.Once());
colors.Verify(c => c.SetMentionColor("blue"), Times.Once());
colors.Verify(c => c.SetAccentColor("green"), Times.Once());
colors.Verify(c => c.SetPrimaryColor("blue"), Times.Once());
}
public void RenderPoint()
{
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
List <object> SelectedDots = (Application.OpenForms[0] as Form1).SelectedDots;
float PointScale = 50f * Scale;
Color newcolor = decideColor(this);
ViewPlaneHandler vph = (Application.OpenForms[0] as Form1).vph;
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, Settings.HighlightPointborderColor.A);
}
else
{
Gl.glColor4f(1 - Settings.PointborderColor.R / 255f, 1 - Settings.PointborderColor.G / 255f, 1 - Settings.PointborderColor.B / 255f, Settings.PointborderColor.A);
}
vph.draw2DVertice(Pos);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
}
else
{
Gl.glColor4f(newcolor.R / 255f, newcolor.G / 255f, newcolor.B / 255f, newcolor.A);
}
vph.draw2DVertice(Pos);
Gl.glEnd();
Gl.glLineWidth(Settings.LineWidth);
if (SelectedDots.Contains(this))
{
DrawFilledCircle(vph.getViewCoord(Pos, 0), vph.getViewCoord(Pos, 1), PointScale, 24, Settings.HighlightPointborderColor, Settings.HighlightPointColor);
}
else
{
DrawFilledCircle(vph.getViewCoord(Pos, 0), vph.getViewCoord(Pos, 1), PointScale, 24, newcolor, newcolor);
}
if (SelectedDots.Contains(this) && MaxSearchYOffsetVal != 0 && (vph.mode == ViewPlaneHandler.PLANE_MODES.XY || vph.mode == ViewPlaneHandler.PLANE_MODES.ZY))
{
int toDraw = MaxSearchYOffsetVal;
if (toDraw == -1)
{
toDraw = 75;
}
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
Gl.glPushAttrib(Gl.GL_ENABLE_BIT);
Gl.glLineStipple(3, 0xAAAA);
Gl.glEnable(Gl.GL_LINE_STIPPLE);
Gl.glBegin(Gl.GL_LINES);
vph.draw2DVertice(new Vector3(100000, Pos.Y + toDraw, 100000));
vph.draw2DVertice(new Vector3(-100000, Pos.Y + toDraw, -100000));
Gl.glEnd();
Gl.glBegin(Gl.GL_LINES);
vph.draw2DVertice(new Vector3(100000, Pos.Y - toDraw, 100000));
vph.draw2DVertice(new Vector3(-100000, Pos.Y - toDraw, -100000));
Gl.glEnd();
Gl.glPopAttrib();
}
}
public Port(VisualSettings settings)
{
charts = new List<Chart>();
this.settings = settings;
}
public void RenderRightLine(VisualSettings Settings)
{
judgeColor(Settings, false);
Gl.glVertex2f(RightPointX, RightPointZ);
}
public void RenderLeftLine(VisualSettings Settings)
{
judgeColor(Settings, true);
Gl.glVertex2f(LeftPointX, LeftPointZ);
}
public HelpScene(CCWindow window, VisualSettings visualSettings, LanguageSettings languageSettings) : base(window)
{
AddChild(new HelpLayer(visualSettings, languageSettings));
}
public void Render(bool picking)
{
if (!Visible || (Application.OpenForms[0] as Form1).vph.mode != ViewPlaneHandler.PLANE_MODES.XZ)
{
return;
}
if (picking)
{
for (int i = 0; i < Entries.Count; i++)
{
Entries[i].RenderPicking(i);
}
return;
}
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
Gl.glLineWidth(Settings.LineWidth);
foreach (var group in Entries)
{
if (Settings.LinkPoints && Settings.LinkPaths && group.Visible)
{
Gl.glColor4f(Settings.RouteLinkColor.R / 255f, Settings.RouteLinkColor.G / 255f, Settings.RouteLinkColor.B / 255f, Settings.RouteLinkColor.A);
try
{
foreach (var next in group.Next)
{
if (next != -1 && Entries[next].Visible)
{
CheckpointGroup.CheckpointEntry prevC = group.Entries[group.Entries.Count - 1];
CheckpointGroup.CheckpointEntry nextC = Entries[next].Entries[0];
Gl.glBegin(Gl.GL_LINES);
prevC.RenderLeftLine(Settings);
nextC.RenderLeftLine(Settings);
Gl.glEnd();
Gl.glBegin(Gl.GL_LINES);
prevC.RenderRightLine(Settings);
nextC.RenderRightLine(Settings);
Gl.glEnd();
if (!CheckpointGroup.IsConvex(prevC, nextC))
{
Gl.glBegin(Gl.GL_TRIANGLE_FAN);
Gl.glColor4f(1f, 0f, 0f, 0.75f);
Gl.glVertex2f(prevC.LeftPointX, prevC.LeftPointZ);
Gl.glVertex2f(prevC.RightPointX, prevC.RightPointZ);
Gl.glVertex2f(nextC.RightPointX, nextC.RightPointZ);
Gl.glVertex2f(nextC.LeftPointX, nextC.LeftPointZ);
Gl.glEnd();
}
}
}
}
catch
{
Gl.glEnd();
}
}
group.Render();
}
}
public static DrawableElement Polyline(List<double> coords, string name = null, string comment = null, string color = "Undefined")
{
var settings = new VisualSettings(name, color: color);
List<ReperPoint> points = new List<ReperPoint>();
for (int i = 0; 2 * i + 1 < coords.Count; i++)
{
points.Add(new ReperPoint(coords[2 * i], coords[2 * i + 1]));
}
return new DrawableElement()
{
Type = DrawableType.Polyline,
Comment = new List<string>() { comment },
reper = points,
Settings = settings
};
}
public void RenderSegment()
{
VisualSettings Settings = (Application.OpenForms[0] as Form1).Settings;
List <object> SelectedDots = (Application.OpenForms[0] as Form1).SelectedDots;
Gl.glBegin(Gl.GL_LINES);
judgeColor(Settings, false);
Gl.glVertex2f(RightPointX, RightPointZ);
judgeColor(Settings, true);
Gl.glVertex2f(LeftPointX, LeftPointZ);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, Settings.HighlightPointborderColor.A);
}
else
{
Gl.glColor4f(Settings.PointborderColor.R / 255f, Settings.PointborderColor.G / 255f, Settings.PointborderColor.B / 255f, Settings.PointborderColor.A);
}
Gl.glVertex2f(RightPointX, RightPointZ);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
}
else
{
judgeColor(Settings, false);
}
Gl.glVertex2f(RightPointX, RightPointZ);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize + 2f);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, Settings.HighlightPointborderColor.A);
}
else
{
Gl.glColor4f(Settings.PointborderColor.R / 255f, Settings.PointborderColor.G / 255f, Settings.PointborderColor.B / 255f, Settings.PointborderColor.A);
}
Gl.glVertex2f(LeftPointX, LeftPointZ);
Gl.glEnd();
Gl.glPointSize(Settings.PointSize);
Gl.glBegin(Gl.GL_POINTS);
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, Settings.HighlightPointColor.A);
}
else
{
judgeColor(Settings, true);
}
Gl.glVertex2f(LeftPointX, LeftPointZ);
Gl.glEnd();
}
public static DrawableElement Segment(double x0, double y0, double x1, double y1, string name = null, string comment = null, string color = "Undefined")
{
var settings = new VisualSettings(name, color: color);
return new DrawableElement
{
Type = DrawableType.Segment,
Comment = new List<string>() { comment },
reper = new List<ReperPoint> { new ReperPoint(x0, y0), new ReperPoint(x1, y1) },
Settings = settings
};
}
public static DrawableElement Text(int x, int y, params string[] strings)
{
var settings = new VisualSettings(null, color: "Black");
return new DrawableElement
{
Type = DrawableType.Text,
Comment = new List<string>(strings),
Settings = settings,
reper = new List<ReperPoint> { new ReperPoint(x, y) }
};
}
public static DrawableElement Vector(double px, double py, double vx, double vy, string name = null, string comment = null, string color = "Undefined")
{
var settings = new VisualSettings(name, color: color);
var l = Math.Sqrt(vx * vx + vy * vy);
return new DrawableElement
{
Type = DrawableType.Vector,
Comment = new List<string>() { comment },
reper = new List<ReperPoint> {
new ReperPoint ( px, py ),
new ReperPoint ( px + l, py ),
// here's new points to form vector head
new ReperPoint ( px + 5 * l / 6, py + l / 12),
new ReperPoint ( px + 11 * l / 12, py ),
new ReperPoint ( px + 5 * l / 6, py - l / 12 ),
new ReperPoint ( px + vx, py + vy ) // this point[5] is to remember angle and should be replaced later
},
Settings = settings
};
}
private void load(SessionStatics sessionStatics, AudioManager audio)
{
muteWarningShownOnce = sessionStatics.GetBindable <bool>(Static.MutedAudioNotificationShownOnce);
batteryWarningShownOnce = sessionStatics.GetBindable <bool>(Static.LowBatteryNotificationShownOnce);
const float padding = 25;
InternalChildren = new Drawable[]
{
(content = new LogoTrackingContainer
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
RelativeSizeAxes = Axes.Both,
}).WithChildren(new Drawable[]
{
MetadataInfo = new BeatmapMetadataDisplay(Beatmap.Value, Mods, content.LogoFacade)
{
Alpha = 0,
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
},
new OsuScrollContainer
{
Anchor = Anchor.TopRight,
Origin = Anchor.TopRight,
RelativeSizeAxes = Axes.Y,
Width = SettingsToolboxGroup.CONTAINER_WIDTH + padding * 2,
Padding = new MarginPadding {
Vertical = padding
},
Masking = false,
Child = PlayerSettings = new FillFlowContainer <PlayerSettingsGroup>
{
AutoSizeAxes = Axes.Both,
Direction = FillDirection.Vertical,
Spacing = new Vector2(0, 20),
Padding = new MarginPadding {
Horizontal = padding
},
Children = new PlayerSettingsGroup[]
{
VisualSettings = new VisualSettings(),
AudioSettings = new AudioSettings(),
new InputSettings()
}
},
},
idleTracker = new IdleTracker(750),
}),
lowPassFilter = new AudioFilter(audio.TrackMixer),
highPassFilter = new AudioFilter(audio.TrackMixer, BQFType.HighPass)
};
if (Beatmap.Value.BeatmapInfo.EpilepsyWarning)
{
AddInternal(epilepsyWarning = new EpilepsyWarning
{
Anchor = Anchor.Centre,
Origin = Anchor.Centre,
});
}
}
public void RenderZone(List <object> SelectedDots, VisualSettings Settings, int type)
{
float sizeX = 500f * ScaleX;
float sizeY = 500f * ScaleZ;
if (type == 0)
{
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointColor.R / 255f, Settings.HighlightPointColor.G / 255f, Settings.HighlightPointColor.B / 255f, 0.25f);
}
else
{
Gl.glColor4f(Settings.AreaColor.R / 255f, Settings.AreaColor.G / 255f, Settings.AreaColor.B / 255f, 0.25f);
}
Gl.glPushMatrix();
Gl.glTranslatef(PositionX, PositionZ, 0);
Gl.glRotatef(-RotationY, 0, 0, 1);
Gl.glBegin(Gl.GL_QUADS);
Gl.glVertex2f(-sizeX, -sizeY);
Gl.glVertex2f(sizeX, -sizeY);
Gl.glVertex2f(sizeX, sizeY);
Gl.glVertex2f(-sizeX, sizeY);
Gl.glEnd();
if (SelectedDots.Contains(this))
{
Gl.glColor4f(Settings.HighlightPointborderColor.R / 255f, Settings.HighlightPointborderColor.G / 255f, Settings.HighlightPointborderColor.B / 255f, 1f);
}
else
{
Gl.glColor4f(Settings.AreaColor.R / 255f, Settings.AreaColor.G / 255f, Settings.AreaColor.B / 255f, 1f);
}
Gl.glLineWidth(Settings.LineWidth);
Gl.glBegin(Gl.GL_LINES);
Gl.glVertex2f(-sizeX, sizeY);
Gl.glVertex2f(sizeX, sizeY);
Gl.glVertex2f(sizeX, sizeY);
Gl.glVertex2f(sizeX, -sizeY);
Gl.glVertex2f(sizeX, -sizeY);
Gl.glVertex2f(-sizeX, -sizeY);
Gl.glVertex2f(-sizeX, -sizeY);
Gl.glVertex2f(-sizeX, sizeY);
Gl.glEnd();
Gl.glPopMatrix();
}
else if (type == 1)
{
Gl.glPushMatrix();
Gl.glTranslatef(PositionX, PositionZ, 0);
Gl.glRotatef(-RotationY, 0, 0, 1);
Gl.glLineWidth(Settings.LineWidth);
if (SelectedDots.Contains(this))
{
DrawFilledCircle(0, 0, sizeX, sizeY, 24, Settings.HighlightPointborderColor, Settings.HighlightPointColor);
}
else
{
DrawFilledCircle(0, 0, sizeX, sizeY, 24, Settings.AreaColor, Settings.AreaColor);
}
Gl.glPopMatrix();
}
}
