public DeviceMode(
string deviceName,
PointL position,
DisplayOrientation orientation,
DisplayFixedOutput fixedOutput,
uint bpp,
uint width,
uint height,
DisplayFlags displayFlags,
uint displayFrequency) : this(
deviceName,
DeviceModeFields.Position |
DeviceModeFields.DisplayOrientation |
DeviceModeFields.DisplayFixedOutput |
DeviceModeFields.BitsPerPixel |
DeviceModeFields.PelsWidth |
DeviceModeFields.PelsHeight |
DeviceModeFields.DisplayFlags |
DeviceModeFields.DisplayFrequency
)
{
Position = position;
DisplayOrientation = orientation;
DisplayFixedOutput = fixedOutput;
BitsPerPixel = bpp;
PixelsWidth = width;
PixelsHeight = height;
DisplayFlags = displayFlags;
DisplayFrequency = displayFrequency;
}
/// <summary>
/// Initializes a new Lcm1602a1 display object.
/// This object will use the board's GPIO pins, or the McpController pins if one is provided.
/// </summary>
/// <param name="mcpController">McpController that is used to provide the pins for the display. Null if we should use board's GPIO pins instead.</param>
/// <param name="registerSelect">The pin that controls the regsiter select.</param>
/// <param name="readWrite">The pin that controls the read and write switch.</param>
/// <param name="enable">The pin that controls the enable switch.</param>
/// <param name="backlight">The pin that controls the backlight of the display.</param>
/// <param name="data">Collection of pins holding the data that will be printed on the screen.</param>
public Lcm1602a1(Mcp23008 mcpController, int registerSelect, int readWrite, int enable, int backlight, int[] data)
{
_rwPin = readWrite;
_rsPin = registerSelect;
_enablePin = enable;
_dataPins = data;
_backlight = backlight;
_rowOffsets = new byte[4];
_displayFunction = DisplayFlags.LCD_1LINE | DisplayFlags.LCD_5x8DOTS;
if (data.Length == 4)
{
_displayFunction |= DisplayFlags.LCD_4BITMODE;
}
else if (data.Length == 8)
{
_displayFunction |= DisplayFlags.LCD_8BITMODE;
}
else
{
throw new ArgumentException($"The length of the array given to parameter {nameof(data)} must be 4 or 8");
}
if (mcpController == null)
{
_controller = (RuntimeInformation.IsOSPlatform(OSPlatform.Linux)) ?
new GpioController(PinNumberingScheme.Logical, new UnixDriver()) :
new GpioController(PinNumberingScheme.Logical, new Windows10Driver());
_usingMcp = false;
}
else
{
_mcpController = mcpController;
_usingMcp = true;
}
OpenPin(_rsPin, PinMode.Input);
if (_rwPin != -1)
{
OpenPin(_rwPin, PinMode.Input);
}
if (_backlight != -1)
{
OpenPin(_backlight, PinMode.Input);
}
OpenPin(_enablePin, PinMode.Input);
foreach (int i in _dataPins)
{
OpenPin(i, PinMode.Input);
}
// By default, initialize the display with one row and 16 characters.
Begin(16, 1);
}
public void Begin(byte cols, byte lines, DisplayFlags dotSize = DisplayFlags.LCD_5x8DOTS)
{
if (lines > 1)
{
_displayFunction |= DisplayFlags.LCD_2LINE;
}
_numLines = lines;
SetRowOffsets(0x00, 0x40, 0x14, 0x54);
// for some 1 line displays you can select a 10 pixel high font
if ((dotSize != DisplayFlags.LCD_5x8DOTS) && (lines == 1))
{
_displayFunction |= DisplayFlags.LCD_5x10DOTS;
}
_displayControl = DisplayFlags.LCD_DISPLAYON | DisplayFlags.LCD_CURSOROFF | DisplayFlags.LCD_BLINKOFF;
_displayMode = DisplayFlags.LCD_ENTRYLEFT | DisplayFlags.LCD_ENTRYSHIFTDECREMENT;
SetPinMode(_rsPin, PinMode.Output);
// we can save 1 pin by not using RW. Indicate by passing null instead of a pin
if (_rwPin != -1)
{
SetPinMode(_rwPin, PinMode.Output);
}
if (_backlight != -1)
{
SetPinMode(_backlight, PinMode.Output);
Write(_backlight, PinValue.High);
}
SetPinMode(_enablePin, PinMode.Output);
// Do this just once, instead of every time a character is drawn (for speed reasons).
for (int i = 0; i < _dataPins.Length; ++i)
{
SetPinMode(_dataPins[i], PinMode.Output);
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
DelayMicroseconds(50000);
// Initialize the display.
Write((byte)0x33);
Write((byte)0x32);
Write((byte)((byte)Commands.LCD_DISPLAYCONTROL | (byte)_displayControl));
Write((byte)((byte)Commands.LCD_FUNCTIONSET | (byte)_displayFunction));
Write((byte)((byte)Commands.LCD_ENTRYMODESET | (byte)_displayMode));
Clear();
}
private bool SectionToggle(DisplayFlags flag, string title, Texture2D icon)
{
bool hasFlag = (displayFlags & flag) == flag;
bool result = SectionGroup(title, icon, hasFlag);
if (result != hasFlag)
{
displayFlags = result ? displayFlags | flag : displayFlags & ~flag;
serializedObject.FindProperty("z_display_flags").intValue = (int)displayFlags;
}
return(hasFlag);
}
internal void Read(Class434 or, DxfVisualStyle.Class486 pr)
{
if (or.Version < DxfVersion.Dxf24)
{
this.displayFlags_0 = (DisplayFlags)pr.vmethod_3();
this.double_0 = (double)pr.vmethod_3();
this.shadowType_0 = (ShadowType)pr.vmethod_3();
}
else
{
this.displayFlags_0 = (DisplayFlags)pr.vmethod_3();
this.double_0 = pr.vmethod_4();
this.shadowType_0 = (ShadowType)pr.vmethod_3();
}
}
public override void OnInspectorGUI()
{
displayFlags = (DisplayFlags)serializedObject.FindProperty("z_display_flags").intValue;
MainContainerBegin("Stat Effect", "Icons/statscog");
if (SectionToggle(DisplayFlags.Behaviour, "Behaviour", BehaviourIcon))
{
SimpleProperty("isDetrimental", "Detrimental");
SimpleProperty("isBenificial", "Benifecial");
SimpleProperty("effectParticles", "Particles");
SimpleProperty("canStack", "Stackable");
SimpleProperty("hasLifeSpan");
if (serializedObject.FindProperty("hasLifeSpan").boolValue)
{
SimpleProperty("lifeInSeconds");
if (!serializedObject.FindProperty("canStack").boolValue)
{
SimpleProperty("resetLifeOnAdd");
}
}
}
if (SectionToggle(DisplayFlags.UI, "UI", UIIcon))
{
SimpleProperty("category");
SimpleProperty("sprite");
SimpleProperty("displayName");
SimpleProperty("description");
SimpleProperty("startedText");
SimpleProperty("endedText");
SimpleProperty("removedText");
SimpleProperty("displayInList");
}
if (SectionToggle(DisplayFlags.Modifiers, "Modifiers", ModifiersIcon))
{
modifiersList.DoLayoutList();
SectionHeader("Cancels Events", "cancelEffects", typeof(StatEffect));
SimpleList("cancelEffects");
SectionHeader("Prevent Events", "preventEffects", typeof(StatEffect));
SimpleList("preventEffects");
}
MainContainerEnd();
}
public ConsoleLogger(TestRunnerOptions opts)
{
if (!opts.SuppressSummary)
{
_flags = DisplayFlags.ShowSummary;
}
if (opts.ShowTestNames)
{
_flags |= DisplayFlags.ShowCaseStart;
}
if (opts.ShowPassExplicitly)
{
_flags |= DisplayFlags.ShowExplicitPasses;
}
_parts = new ConsoleOutputParts(opts);
_renderContext = new RenderContext {
Console = console,
Parts = _parts,
};
}
private void CreateSpawn(GroundSpawn spawn,DisplayFlags flags)
{
Model3DGroup group = Model as Model3DGroup;
Model3DCollection collection = new Model3DCollection();
if (_mapping.ContainsKey(spawn))
{
foreach (Model3D model in _mapping[spawn])
{
group.Children.Remove(model);
}
}
Point3D p = new Point3D(
(spawn.MaxX + spawn.MinX) / 2,
(spawn.MaxY + spawn.MinY) / 2,
spawn.MaxZ);
if (!Clipping.DrawPoint(p)) return;
var xlen = spawn.MaxX - spawn.MinX;
var ylen = spawn.MaxY - spawn.MinY;
xlen = xlen <= 0 ? 4 : xlen;
ylen = ylen <= 0 ? 4 : ylen;
MeshBuilder builder = new MeshBuilder();
builder.AddBox(p, ylen, xlen, 2);
GeometryModel3D box = new GeometryModel3D(builder.ToMesh(), Materials.Gold);
collection.Add(box);
if ( flags != DisplayFlags.None )
{
var scale = 1.25;
builder = new MeshBuilder();
if (flags.HasFlag(DisplayFlags.DarkGrayAura))
{
builder.AddBox(p, ylen * scale, xlen * scale, 1);
box = new GeometryModel3D(builder.ToMesh(), Materials.DarkGray);
collection.Add(box);
}
else if (flags.HasFlag(DisplayFlags.GreenAura))
{
builder.AddBox(p, ylen * scale, xlen * scale, 1);
box = new GeometryModel3D(builder.ToMesh(), Materials.Green);
collection.Add(box);
}
}
_mapping[spawn] = collection;
foreach (Model3D model in collection)
{
group.Children.Add(model);
}
}
// This will 'left justify' text from the cursor
public void NoAutoscroll()
{
_displayMode &= ~DisplayFlags.LCD_ENTRYSHIFTINCREMENT;
Command((byte)Commands.LCD_ENTRYMODESET | (byte)_displayMode);
}
// This is for text that flows Right to Left
public void RightToLeft()
{
_displayMode &= ~DisplayFlags.LCD_ENTRYLEFT;
Command((byte)Commands.LCD_ENTRYMODESET | (byte)_displayMode);
}
private void CreatePoint(ZonePoint zp,DisplayFlags flags)
{
Model3DGroup group = Model as Model3DGroup;
Model3DCollection collection = new Model3DCollection();
if (_mapping.ContainsKey(zp))
{
foreach (Model3D model in _mapping[zp])
{
group.Children.Remove(model);
}
}
double px, py, pz;
px = zp.X == 999999 ? 0 : zp.X;
py = zp.Y == 999999 ? 0 : zp.Y;
pz = zp.Z == 999999 ? 0 : zp.Z;
Point3D p = new Point3D(px,py,pz);
if (!Clipping.DrawPoint(p)) return;
MeshBuilder builder = new MeshBuilder();
builder.AddBox(p, 20, 20, 2);
//connect box to destination
px = zp.TargetX == 999999 ? px : zp.TargetX;
py = zp.TargetY == 999999 ? py : zp.TargetY;
pz = zp.TargetZ == 999999 ? pz : zp.TargetZ;
GeometryModel3D box;
box = new GeometryModel3D(builder.ToMesh(), Materials.Red);
collection.Add(box);
builder = new MeshBuilder();
Point3D destP = new Point3D(px, py, pz);
builder.AddArrow(p, destP, 0.5);
builder.AddBox(destP, 20, 20, 2);
if (zp.X == 999999 || zp.Y == 999999 || zp.Z == 999999 ||
zp.TargetX == 999999 || zp.TargetY == 999999 || zp.TargetZ == 999999)
{
box = new GeometryModel3D(builder.ToMesh(), Materials.Gold);
}
else
{
box = new GeometryModel3D(builder.ToMesh(), Materials.White);
}
collection.Add(box);
if (flags != DisplayFlags.None)
{
builder = new MeshBuilder();
if (flags.HasFlag(DisplayFlags.DarkGrayAura))
{
builder.AddBox(p, 25,25, 1);
builder.AddBox(destP, 25, 25, 1);
box = new GeometryModel3D(builder.ToMesh(), Materials.DarkGray);
collection.Add(box);
}
else if (flags.HasFlag(DisplayFlags.GreenAura))
{
builder.AddBox(p, 25, 25, 1);
builder.AddBox(destP, 25, 25, 1);
box = new GeometryModel3D(builder.ToMesh(), Materials.Green);
collection.Add(box);
}
}
_mapping[zp] = collection;
foreach (Model3D model in collection)
{
group.Children.Add(model);
}
}
public void ShowSpawn(EQEmu.Spawns.Spawn2 spawn,DisplayFlags flags=DisplayFlags.None)
{
if (spawn == null || !_zoneSpawns.Spawns.Contains(spawn))
{
//UpdateAll();
return;
}
else
{
//Model3DGroup group = Model as Model3DGroup;
//group.Children.Clear();
CreateSpawn(spawn,flags);
}
}
// Turn the display on/off (quickly)
public void NoDisplay()
{
_displayControl &= ~DisplayFlags.LCD_DISPLAYON;
Command((byte)Commands.LCD_DISPLAYCONTROL | (byte)_displayControl);
}
public void Begin(byte cols, byte lines, DisplayFlags dotSize = DisplayFlags.LCD_5x8DOTS)
{
if (lines > 1)
{
_displayFunction |= DisplayFlags.LCD_2LINE;
}
_numLines = lines;
SetRowOffsets(0x00, 0x40, (byte)(0x00 + cols), (byte)(0x40 + cols));
// for some 1 line displays you can select a 10 pixel high font
if ((dotSize != DisplayFlags.LCD_5x8DOTS) && (lines == 1))
{
_displayFunction |= DisplayFlags.LCD_5x10DOTS;
}
SetPinMode(_rsPin, PinMode.Output);
// we can save 1 pin by not using RW. Indicate by passing null instead of a pin
if (_rwPin != -1)
{
SetPinMode(_rwPin, PinMode.Output);
}
SetPinMode(_enablePin, PinMode.Output);
// Do this just once, instead of every time a character is drawn (for speed reasons).
for (int i = 0; i < _dataPins.Length; ++i)
{
SetPinMode(_dataPins[i], PinMode.Output);
}
// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
// according to datasheet, we need at least 40ms after power rises above 2.7V
// before sending commands. Arduino can turn on way before 4.5V so we'll wait 50
DelayMicroseconds(50000);
// Now we pull both RS and R/W low to begin commands
Write(_rsPin, PinValue.Low);
Write(_enablePin, PinValue.Low);
if (_rwPin != -1)
{
Write(_rwPin, PinValue.Low);
}
//put the LCD into 4 bit or 8 bit mode
if (_displayFunction.HasFlag(DisplayFlags.LCD_8BITMODE))
{
// this is according to the hitachi HD44780 datasheet
// page 45 figure 23
// Send function set command sequence
Command((byte)Commands.LCD_FUNCTIONSET | (byte)_displayFunction);
DelayMicroseconds(4500); // wait more than 4.1ms
// second try
Command((byte)Commands.LCD_FUNCTIONSET | (byte)_displayFunction);
DelayMicroseconds(150);
// third go
Command((byte)Commands.LCD_FUNCTIONSET | (byte)_displayFunction);
}
else
{
// this is according to the hitachi HD44780 datasheet
// figure 24, pg 46
// we start in 8bit mode, try to set 4 bit mode
Write4bits(0x03);
DelayMicroseconds(4500); // wait min 4.1ms
// second try
Write4bits(0x03);
DelayMicroseconds(4500); // wait min 4.1ms
// third go!
Write4bits(0x03);
DelayMicroseconds(150);
// finally, set to 4-bit interface
Write4bits(0x02);
}
// finally, set # lines, font size, etc.
Command((byte)Commands.LCD_FUNCTIONSET | (byte)_displayFunction);
// turn the display on with no cursor or blinking default
_displayControl = DisplayFlags.LCD_DISPLAYON | DisplayFlags.LCD_CURSOROFF | DisplayFlags.LCD_BLINKOFF;
Display();
// clear it off
Clear();
// Initialize to default text direction (for romance languages)
_displayMode = DisplayFlags.LCD_ENTRYLEFT | DisplayFlags.LCD_ENTRYSHIFTDECREMENT;
// set the entry mode
Command((byte)Commands.LCD_ENTRYMODESET | (byte)_displayMode);
}
public void CopyFrom(DisplayStyle from, CloneContext cloneContext)
{
this.displayFlags_0 = from.displayFlags_0;
this.double_0 = from.double_0;
this.shadowType_0 = from.shadowType_0;
}
public void ShowSpawn(GroundSpawn spawn, DisplayFlags flags=DisplayFlags.None)
{
if (spawn == null) return;
CreateSpawn(spawn,flags);
}
public void Cursor()
{
_displayControl |= DisplayFlags.LCD_CURSORON;
Command((byte)Commands.LCD_DISPLAYCONTROL | (byte)_displayControl);
}
public void Blink()
{
_displayControl |= DisplayFlags.LCD_BLINKON;
Command((byte)Commands.LCD_DISPLAYCONTROL | (byte)_displayControl);
}
private void CreateSpawn(EQEmu.Spawns.Spawn2 spawn,DisplayFlags flags)
{
Model3DGroup group = Model as Model3DGroup;
Model3DCollection collection = new Model3DCollection();
if (_mapping.ContainsKey(spawn))
{
foreach (Model3D model in _mapping[spawn])
{
group.Children.Remove(model);
}
}
MeshBuilder builder = new MeshBuilder();
Point3D p = new Point3D(spawn.X,spawn.Y,spawn.Z);
if( !Clipping.DrawPoint(p) ) return;
builder.AddBox(p,2,2,2);
Transform3D headingRotate = new RotateTransform3D()
{
CenterX = p.X,
CenterY = p.Y,
CenterZ = p.Z,
Rotation = new AxisAngleRotation3D(
new Vector3D(0,0,-1),spawn.HeadingDegrees)
};
GeometryModel3D box;
Material mat = Materials.White;
if (flags == DisplayFlags.None)
{
if (spawn.RoamAreaId > 0)
{
mat = Materials.Red;
}
else if (spawn.GridId > 0)
{
mat = Materials.Yellow;
}
}
else if (flags == DisplayFlags.Green)
{
mat = Materials.Green;
}
else if (flags == DisplayFlags.DarkGray)
{
mat = Materials.DarkGray;
}
else if (flags == DisplayFlags.Rainbow)
{
mat = Materials.Rainbow;
}
else if (flags == DisplayFlags.Blue)
{
mat = Materials.Blue;
}
box = new GeometryModel3D(builder.ToMesh(), mat);
box.Transform = headingRotate;
collection.Add(box);
builder = new MeshBuilder();
float radius = 3.0f;
double hx = spawn.X + Math.Cos((spawn.HeadingDegrees - 90) / 180 * Math.PI) * radius;
double hy = spawn.Y + Math.Sin((spawn.HeadingDegrees + 90) / 180 * Math.PI) * radius;
builder.AddArrow(new Point3D(spawn.X, spawn.Y, spawn.Z), new Point3D(hx, hy, spawn.Z), 0.5, 1);
collection.Add(new GeometryModel3D(builder.ToMesh(), mat));
_mapping[spawn] = collection;
foreach (Model3D model in collection)
{
group.Children.Add(model);
}
}
// This is for text that flows Left to Right
public void LeftToRight()
{
_displayMode |= DisplayFlags.LCD_ENTRYLEFT;
Command((byte)Commands.LCD_ENTRYMODESET | (byte)_displayMode);
}
public void ShowPoint(ZonePoint pt, DisplayFlags flags=DisplayFlags.None)
{
if (pt == null) return;
CreatePoint(pt,flags);
}
public override void OnInspectorGUI()
{
displayFlags = (DisplayFlags)serializedObject.FindProperty("z_display_flags").intValue;
MainContainerBeginSlim();
GUILayout.BeginVertical();
GUILayout.Space(6);
GUILayout.EndVertical();
if (GUILayout.Button("Stats & Effects Editor", GUILayout.MinHeight(32)))
{
StatsWindow.Open();
}
GUILayout.BeginVertical();
GUILayout.Space(6);
GUILayout.EndVertical();
if (Application.isPlaying)
{
if (SectionToggle((int)displayFlags, (int)DisplayFlags.Debug, "Debug", DebugIcon))
{
DrawDebug();
}
}
if (SectionDropToggle((int)displayFlags, (int)DisplayFlags.Stats, "Stats", StatsIcon, "stats", typeof(StatValue)))
{
statSP = SimpleList("stats", statSP, 120, 1);
}
if (SectionToggle((int)displayFlags, (int)DisplayFlags.Effects, "Effects", EffectsIcon))
{
DrawEffects();
}
if (SectionToggle((int)displayFlags, (int)DisplayFlags.Combat, "Combat", CombatIcon))
{
DrawCombat();
}
if (SectionToggle((int)displayFlags, (int)DisplayFlags.DamageDealers, "Damage Dealers", DealersIcon))
{
DamageDealer[] dealers = myTarget.GetComponentsInChildren <DamageDealer>();
foreach (DamageDealer dealer in dealers)
{
EditorGUILayout.ObjectField(dealer, typeof(DamageDealer), true);
}
if (dealers.Length == 0)
{
GUILayout.BeginHorizontal();
GUILayout.Space(24);
GUILayout.Label("{None}", Skin.GetStyle("SubHeader"));
GUILayout.EndHorizontal();
}
Animator anim = myTarget.GetComponentInChildren <Animator>();
if (anim != null && anim.isHuman)
{
SubHeader("Dynamic Creation");
boneIndex1 = EditorGUILayout.Popup("Add to Bone", boneIndex1, bones, GUILayout.ExpandWidth(true));
if (GUILayout.Button("Add"))
{
Transform target = anim.GetBoneTransform((HumanBodyBones)boneIndex1);
if (target == null)
{
EditorUtility.DisplayDialog("Stats Cog", "The requested bone '" + bones[boneIndex1] + "' could not be found on the selected rig.", "OK");
}
else
{
GameObject newDD = new GameObject();
newDD.name = "DamageDealer_" + bones[boneIndex1];
newDD.AddComponent <SphereCollider>().isTrigger = true;
newDD.AddComponent <DamageDealer>();
newDD.transform.SetParent(target);
newDD.transform.localPosition = Vector3.zero;
Selection.activeGameObject = newDD;
}
}
}
}
if (SectionToggle((int)displayFlags, (int)DisplayFlags.DamageReceivers, "Damage Receivers", ReceiversIcon))
{
DamageReceiver[] receivers = myTarget.GetComponentsInChildren <DamageReceiver>();
foreach (DamageReceiver Receiver in receivers)
{
EditorGUILayout.ObjectField(Receiver, typeof(DamageReceiver), true);
}
if (receivers.Length == 0)
{
GUILayout.BeginHorizontal();
GUILayout.Space(24);
GUILayout.Label("{None}", Skin.GetStyle("SubHeader"));
GUILayout.EndHorizontal();
}
Animator anim = myTarget.GetComponentInChildren <Animator>();
if (anim != null && anim.isHuman)
{
SubHeader("Dynamic Creation");
boneIndex2 = EditorGUILayout.Popup("Add to Bone", boneIndex2, bones, GUILayout.ExpandWidth(true));
if (GUILayout.Button("Add"))
{
Transform target = anim.GetBoneTransform((HumanBodyBones)boneIndex2);
if (target == null)
{
EditorUtility.DisplayDialog("Stats Cog", "The requested bone '" + bones[boneIndex2] + "' could not be found on the selected rig.", "OK");
}
else
{
GameObject newDD = new GameObject();
newDD.name = "DamageReceiver_" + bones[boneIndex2];
newDD.AddComponent <CapsuleCollider>().isTrigger = true;
newDD.AddComponent <DamageReceiver>();
newDD.transform.SetParent(target);
newDD.transform.localPosition = Vector3.zero;
Selection.activeGameObject = newDD;
}
}
}
}
if (SectionToggle((int)displayFlags, (int)DisplayFlags.Events, "Events", EventsIcon))
{
DrawEvents();
}
MainContainerEnd();
}
