private static void testClearScreen(IT8951SPIDevice device, DisplayModeEnum mode = DisplayModeEnum.GC16)
{
using (new Operation("testClearScreen"))
{
device.ClearScreen(mode);
}
}
private void UpdateGameStart(KeyboardState kState, GameTime gameTime)
{
if (kState.IsKeyPressed(_oldKeyState, Keys.Enter, Keys.Space, Keys.D0, Keys.D1, Keys.D2, Keys.D3, Keys.D4,
Keys.D5, Keys.D6, Keys.D7, Keys.D8, Keys.D9))
{
_displayMode = DisplayModeEnum.Splash;
string value = Encoding.UTF8.GetString(new[] { (byte)kState.GetPressedKeys()[0] }, 0, 1);
int newRange;
int range = int.TryParse(value, out newRange) ? newRange : Game.Range;
if (OnPlayingStarted != null)
{
OnPlayingStarted(this, new PlayingStartedEventArgs
{
Range = range
});
}
return;
}
_splashInterval = _splashInterval - gameTime.ElapsedGameTime;
if (_splashInterval.Ticks < 0)
{
_displayMode = DisplayModeEnum.Splash;
}
}
internal ColorScreen(DisplayModeEnum displayMode)
{
Width = 400;
Height = 1200;
Model = "TB0407";
Description = $"colorfull display, display controller {Model}, bus width 256 bit";
this._displayMode = displayMode;
}
public object Convert(object value, Type targetType, object parameter, string language)
{
DisplayModeEnum val = (DisplayModeEnum)value;
if (val == DisplayModeEnum.EXECUTE)
{
return(false);
}
return(true);
}
private void Update()
{
bool contextProhibited = DoesContextProhibitMenu();
if (contextProhibited)
{
CloseMenu();
}
else
{
switch (targetMode)
{
case TargetModeEnum.Open:
OpenMenu();
break;
case TargetModeEnum.Closed:
CloseMenu();
break;
}
}
switch (displayMode)
{
case DisplayModeEnum.Closed:
animationTarget.SetActive(false);
break;
case DisplayModeEnum.Open:
animationTarget.SetActive(true);
animationTarget.transform.localScale = Vector3.one;
break;
case DisplayModeEnum.Opening:
animationTarget.SetActive(true);
float timeSinceOpened = Time.time - timeOpened;
animationTarget.transform.localScale = Vector3.one * openCurve.Evaluate(timeSinceOpened);
if (timeSinceOpened > openDuration)
{
displayMode = DisplayModeEnum.Open;
}
break;
case DisplayModeEnum.Closing:
animationTarget.SetActive(true);
float timeSinceClosed = Time.time - timeClosed;
animationTarget.transform.localScale = Vector3.one * closeCurve.Evaluate(timeSinceClosed);
if (timeSinceClosed > closeDuration)
{
displayMode = DisplayModeEnum.Closed;
}
break;
}
}
private void Awake()
{
Keyframe[] keys = openCurve.keys;
openDuration = keys[keys.Length - 1].time;
keys = closeCurve.keys;
closeDuration = keys[keys.Length - 1].time;
animationTarget.gameObject.SetActive(false);
displayMode = DisplayModeEnum.Closed;
}
//PlayerSmallData _Data = new PlayerSmallData();
//---------------------------------------------------------------------------------------
public PlayerSmall(DisplayModeEnum _displayMode = DisplayModeEnum.PlayPause)
{
InitializeComponent();
SetStyle(ControlStyles.SupportsTransparentBackColor, true);
SetStyle(ControlStyles.Opaque, true);
this.BackColor = Color.Transparent;
DisplayMode = _displayMode;
UpdateUI();
}
public object Convert(object value, Type targetType, object parameter, string language)
{
DisplayModeEnum val = (DisplayModeEnum)value;
if (val == DisplayModeEnum.MODELE)
{
return(new SolidColorBrush(Colors.Gray));
}
else if (val == DisplayModeEnum.EXECUTE)
{
return(new SolidColorBrush(Colors.Black));
}
return(new SolidColorBrush(Colors.Gray));
}
public void CloseMenu()
{
switch (displayMode)
{
case DisplayModeEnum.Closed:
case DisplayModeEnum.Closing:
case DisplayModeEnum.Opening:
return;
default:
break;
}
displayMode = DisplayModeEnum.Closing;
timeClosed = Time.time;
}
private void UpdateSplash(KeyboardState kState, GameTime gameTime)
{
if (kState.IsKeyPressed(_oldKeyState, Keys.Enter, Keys.Space, Keys.Escape, Keys.D0, Keys.D1, Keys.D2,
Keys.D3,
Keys.D4, Keys.D5, Keys.D6, Keys.D7))
{
_displayMode = DisplayModeEnum.GameStart;
_splashInterval = new TimeSpan(Game.GameSpeedScaleFactor * 40);
}
_splashInterval = _splashInterval - gameTime.ElapsedGameTime;
if (_splashInterval.Ticks < 0)
{
Game.BackColor = (Game.BackColor == BackColorEnum.White ? BackColorEnum.Black : BackColorEnum.White);
_splashInterval = new TimeSpan(Game.GameSpeedScaleFactor * 20);
}
}
public void OpenMenu()
{
switch (displayMode)
{
case DisplayModeEnum.Open:
case DisplayModeEnum.Opening:
case DisplayModeEnum.Closing:
return;
default:
break;
}
displayMode = DisplayModeEnum.Opening;
timeOpened = Time.time;
ActivatedOnce = true;
}
public static void ClearScreen(this IT8951SPIDevice device, DisplayModeEnum mode = DisplayModeEnum.INIT)
{
switch (mode)
{
case DisplayModeEnum.INIT:
case DisplayModeEnum.GC16:
device.Draw(b =>
{
b.Buffer.Span.Fill(0xff);
}, mode: mode);
break;
case DisplayModeEnum.A2:
device.Draw(b =>
{
b.Buffer.Span.Fill(0xff);
}, bpp: ImagePixelPackEnum.BPP1,
mode: DisplayModeEnum.A2);
break;
default:
throw new ArgumentOutOfRangeException(nameof(mode));
}
}
/// <summary>
/// Partial display image from Image Object
/// </summary>
/// <param name="device">device to present the image</param>
/// <param name="image">Image object</param>
/// <param name="sourceImageArea">the area to be displayed from source image</param>
/// <param name="targetPosition">the top left position to place the image of device screen</param>
/// <param name="bpp">BitsPerPixel mode in pixel transfer. suggest use BPP4 for GC16 and BPP1 for A2</param>
/// <param name="displayMode">Display mode, GC16=16 level greyscale, A2=Balck and White</param>
/// <exception cref="ArgumentOutOfRangeException">display mode cannot be INIT and position X and width must be multiple of 32 in 1bpp mode</exception>
public static void DrawImagePartial(this IT8951SPIDevice device, Image <L8> image, Rectangle sourceImageArea, Point targetPosition, ImagePixelPackEnum bpp = ImagePixelPackEnum.BPP4, DisplayModeEnum displayMode = DisplayModeEnum.GC16)
{
if (displayMode == DisplayModeEnum.INIT)
{
throw new ArgumentOutOfRangeException(nameof(displayMode), "displayMode can't be INIT while drawing image");
}
if (bpp == ImagePixelPackEnum.BPP1)
{
if (sourceImageArea.Width % 32 != 0 || targetPosition.X % 32 != 0)
{
throw new ArgumentOutOfRangeException("position X and width must be multiple of 32 in 1bpp mode");
}
}
var p = new DrawingBuffer(targetPosition.X, targetPosition.Y, sourceImageArea.Width, sourceImageArea.Height, bpp);
Parallel.For(0, sourceImageArea.Height, i =>
{
var rowBytes = image.DangerousGetPixelRowMemory(sourceImageArea.Y + i).Span.Slice(sourceImageArea.X, sourceImageArea.Width);
p.WriteRow(rowBytes, i, getByteFromL8);
});
ushort x = (ushort)targetPosition.X;
ushort y = (ushort)targetPosition.Y;
ushort w = (ushort)sourceImageArea.Width;
ushort h = (ushort)sourceImageArea.Height;
if (bpp == ImagePixelPackEnum.BPP1)
{
//use bpp8 to transfer full bytes data
device.LoadImageArea(ImagePixelPackEnum.BPP8, ImageEndianTypeEnum.BigEndian, ImageRotateEnum.Rotate0, p.Buffer.Span, (ushort)(x / 8), y, (ushort)(w / 8), h);
device.Set1BPPMode(true);
device.RefreshArea(displayMode, x, y, w, h);
device.Set1BPPMode(false);//restore to default display mode
}
else
{
device.LoadImageArea(bpp, ImageEndianTypeEnum.BigEndian, ImageRotateEnum.Rotate0, p.Buffer.Span, x, y, w, h);
device.RefreshArea(displayMode, x, y, w, h);
}
}
private void OnDisable()
{
animationTarget.gameObject.SetActive(false);
displayMode = DisplayModeEnum.Closed;
}
/// <summary>
/// Display a full sreen image from Image Object.
/// </summary>
/// <param name="device">device to present the image</param>
/// <param name="image"> Image object</param>
/// <param name="dither">dither the image for better visual</param>
/// <param name="autoResize">Resize the image if necessary. An exception will thrown if this parameter is false and image size not equal device screen size</param>
/// <param name="bpp">BitsPerPixel mode in pixel transfer. suggest use BPP4 for GC16 and BPP1 for A2 </param>
/// <param name="displayMode">Display mode, GC16=16 level greyscale, A2=Balck and White</param>
public static void DrawImage(this IT8951SPIDevice device, Image <L8> image, bool dither = true, bool autoResize = true, ImagePixelPackEnum bpp = ImagePixelPackEnum.BPP4, DisplayModeEnum displayMode = DisplayModeEnum.GC16)
{
if (displayMode == DisplayModeEnum.INIT)
{
throw new ArgumentOutOfRangeException(nameof(displayMode), "displayMode can't be INIT while drawing image");
}
if (device.DeviceInfo.ScreenSize.Width != image.Width || device.DeviceInfo.ScreenSize.Height != image.Height)
{
if (!autoResize)
{
throw new ArgumentException("image size should be same as device screen size");
}
else
{
var o = new ResizeOptions();
o.Size = new Size(device.DeviceInfo.ScreenSize.Width, device.DeviceInfo.ScreenSize.Height);
o.Mode = ResizeMode.Pad;
image.Mutate(opt =>
{
opt.Resize(o);
});
}
}
var p = new DrawingBuffer(device, bpp);
if (dither)
{
switch (bpp)
{
case ImagePixelPackEnum.BPP2:
image.Mutate(opt =>
{
Color[] palette = new Color[4];
for (int i = 0; i < palette.Length; i++)
{
palette[i] = new Color(new L16((ushort)(i * 16384)));
}
opt.Dither(KnownDitherings.FloydSteinberg, palette);
});
break;
case ImagePixelPackEnum.BPP3:
throw new NotImplementedException();
case ImagePixelPackEnum.BPP4: //maximum grey scale is 16 levels
case ImagePixelPackEnum.BPP8: //BPP8=BPP4, 4 lower bits are ignored
image.Mutate(opt =>
{
Color[] palette = new Color[16];
for (int i = 0; i < palette.Length; i++)
{
palette[i] = new Color(new L16((ushort)(i * 4096)));
}
opt.Dither(KnownDitherings.FloydSteinberg, palette);
});
break;
case ImagePixelPackEnum.BPP1:
image.Mutate(opt =>
{
opt.BinaryDither(KnownDitherings.FloydSteinberg);
});
break;
default:
break;
}
}
Parallel.For(0, image.Height, i =>
{
var rowBytes = image.DangerousGetPixelRowMemory(i).Span;
p.WriteRow(rowBytes, i, getByteFromL8);
});
if (bpp == ImagePixelPackEnum.BPP1)
{
ushort width = (ushort)(image.Width / 8);
ushort height = (ushort)(image.Height);
//use bpp8 to transfer full bytes data
device.LoadImageArea(ImagePixelPackEnum.BPP8, ImageEndianTypeEnum.BigEndian, ImageRotateEnum.Rotate0, p.Buffer.Span, 0, 0, width, height);
device.Set1BPPMode(true);
device.RefreshArea(displayMode, 0, 0, (ushort)image.Width, (ushort)image.Height);
device.Set1BPPMode(false);//restore to default display mode
}
else
{
device.LoadImage(bpp, ImageEndianTypeEnum.BigEndian, ImageRotateEnum.Rotate0, p.Buffer.Span);
device.RefreshScreen(displayMode);
}
}
private static void drawImagePartialTest(IT8951SPIDevice device, string imagePath, Size gridSize, DisplayModeEnum displayMode = DisplayModeEnum.GC16, bool waitEnter = true)
{
Image <L8> image = Image.Load <L8>(imagePath);
var o = new ResizeOptions();
o.Size = new Size(device.DeviceInfo.ScreenSize.Width, device.DeviceInfo.ScreenSize.Height);
o.Mode = ResizeMode.Pad;
image.Mutate(opt =>
{
opt.Resize(o);
if (displayMode == DisplayModeEnum.A2)
{
opt.BinaryDither(KnownDitherings.FloydSteinberg);
}
});
int y = 0;
while (y < image.Height)
{
int h = Math.Min(gridSize.Height, image.Height - y);
int x = 0;
while (x < image.Width)
{
int w = Math.Min(gridSize.Width, image.Width - x);
Console.WriteLine($"x={x},y={y},w={w},h={h}");
device.DrawImagePartial(image, new Rectangle(x, y, w, h), new Point(x, y),
displayMode == DisplayModeEnum.GC16 ? ImagePixelPackEnum.BPP4 : ImagePixelPackEnum.BPP1,
displayMode);
x += w;
}
y += h;
}
if (waitEnter)
{
Console.WriteLine("Partial test completed, press ENTER to continue");
Console.ReadLine();
}
}
private static void testdrawImage(IT8951SPIDevice device, string imagePath, bool waitEnter = false, DisplayModeEnum mode = DisplayModeEnum.GC16)
{
using (new Operation("testdrawImage"))
{
var img = Image.Load <L8>(imagePath);
device.DrawImage(image: img,
bpp: mode == DisplayModeEnum.A2 ? ImagePixelPackEnum.BPP1 : ImagePixelPackEnum.BPP4,
displayMode: mode);
if (waitEnter)
{
Console.WriteLine($"Image {imagePath} Ready, Press ENTER to continue");
Console.ReadLine();
}
else
{
Console.WriteLine($"Image {imagePath} Ready");
}
}
}
public static void RefreshScreen(this IT8951SPIDevice device, DisplayModeEnum mode) => device.DisplayArea(0, 0, (ushort)device.DeviceInfo.ScreenSize.Width, (ushort)device.DeviceInfo.ScreenSize.Height, mode);
private IEnumerator UpdateDisplayMode()
{
// Variables we'll be using
Vector3 targetPosition = inMenuPosition;
Vector3 targetScale = Vector3.one;
Quaternion targetRotation = Quaternion.Euler(inMenuRotation);
Vector3 startPosition = targetPosition;
Vector3 startScale = targetScale;
Quaternion startRotation = targetRotation;
// Reset before starting
displayMode = DisplayModeEnum.InMenu;
DisplayModeEnum lastDisplayMode = displayMode;
brushObjectTransform.localPosition = targetPosition;
brushObjectTransform.localRotation = targetRotation;
while (isActiveAndEnabled)
{
// Wait for displayMode to change
while (displayMode == lastDisplayMode)
{
yield return(null);
}
startPosition = brushObjectTransform.localPosition;
startRotation = brushObjectTransform.localRotation;
startScale = brushObjectTransform.localScale;
lastDisplayMode = displayMode;
switch (displayMode)
{
case DisplayModeEnum.InHand:
targetPosition = inHandPosition;
targetScale = Vector3.one;
targetRotation = Quaternion.Euler(inHandRotation);
brushObjectTransform.gameObject.SetActive(true);
break;
case DisplayModeEnum.InMenu:
targetPosition = inMenuPosition;
targetScale = Vector3.one;
targetRotation = Quaternion.Euler(inMenuRotation);
brushObjectTransform.gameObject.SetActive(true);
break;
case DisplayModeEnum.Hidden:
targetPosition = inMenuPosition;
targetRotation = Quaternion.Euler(inMenuRotation);
targetScale = startScale * 0.01f;
break;
}
// Keep going until we're done transitioning, or until the mode changes, whichever comes first
float startTime = Time.unscaledTime;
while ((Time.unscaledTime < startTime + transitionDuration) && lastDisplayMode == displayMode)
{
float normalizedTime = (Time.unscaledTime - startTime) / transitionDuration;
brushObjectTransform.localPosition = Vector3.Lerp(startPosition, targetPosition, transitionCurve.Evaluate(normalizedTime));
brushObjectTransform.localScale = Vector3.Lerp(startScale, targetScale, transitionCurve.Evaluate(normalizedTime));
brushObjectTransform.localRotation = Quaternion.Lerp(startRotation, targetRotation, transitionCurve.Evaluate(normalizedTime));
yield return(null);
}
brushObjectTransform.localPosition = targetPosition;
brushObjectTransform.localScale = targetScale;
brushObjectTransform.localRotation = targetRotation;
if (displayMode == DisplayModeEnum.Hidden)
{
brushObjectTransform.gameObject.SetActive(false);
}
yield return(null);
}
yield break;
}
private void UpdateSplash(KeyboardState kState, GamePadState gState, GameTime gameTime)
{
if (kState.IsKeyPressed(_oldKeyState, Keys.Enter, Keys.Space, Keys.Escape, Keys.D0, Keys.D1, Keys.D2,
Keys.D3,
Keys.D4, Keys.D5, Keys.D6, Keys.D7) ||
gState.IsButtonPressed(_oldGamePadState, Buttons.Start))
{
_displayMode = DisplayModeEnum.GameStart;
_splashInterval = new TimeSpan(Game.GameSpeedScaleFactor*40);
}
_splashInterval = _splashInterval - gameTime.ElapsedGameTime;
if (_splashInterval.Ticks < 0)
{
_backColor = (_backColor == BackColorEnum.White ? BackColorEnum.Black : BackColorEnum.White);
_splashInterval = new TimeSpan(Game.GameSpeedScaleFactor*20);
}
}
private void UpdateGameStart(KeyboardState kState, GamePadState gState, GameTime gameTime)
{
if (kState.IsKeyPressed(_oldKeyState, Keys.Enter, Keys.Space, Keys.D0, Keys.D1, Keys.D2, Keys.D3, Keys.D4,
Keys.D5, Keys.D6, Keys.D7, Keys.D8, Keys.D9) || gState.IsButtonPressed(_oldGamePadState, Buttons.Start))
{
_displayMode = DisplayModeEnum.Splash;
string value = Encoding.UTF8.GetString(new[] {(byte) kState.GetPressedKeys()[0]}, 0, 1);
int newRange;
int range = int.TryParse(value, out newRange) ? newRange : Game.Range;
if (OnPlayingStarted != null)
{
Game.BackColor = _backColor;
OnPlayingStarted(this, new PlayingStartedEventArgs
{
Range = range
});
}
return;
}
_splashInterval = _splashInterval - gameTime.ElapsedGameTime;
if (_splashInterval.Ticks < 0)
{
_displayMode = DisplayModeEnum.Splash;
}
}
public void DisplayBufferArea(ushort x, ushort y, ushort width, ushort height, DisplayModeEnum mode, int memoryAddress)
{
io.SendCommand(IT8951SPIDeviceIO.DeviceCommand.DPY_BUF_AREA, x, y, width, height, (ushort)mode, (ushort)memoryAddress, (ushort)memoryAddress);
}
public static void Draw(this IT8951SPIDevice device, Action <DrawingBuffer> pixelOperateCallback, ImagePixelPackEnum bpp = ImagePixelPackEnum.BPP4, ImageEndianTypeEnum endian = ImageEndianTypeEnum.BigEndian, ImageRotateEnum rotate = ImageRotateEnum.Rotate0, DisplayModeEnum mode = DisplayModeEnum.GC16)
{
var p = new DrawingBuffer(device, bpp);
pixelOperateCallback(p);
if (bpp == ImagePixelPackEnum.BPP1)
{
device.LoadImageArea(ImagePixelPackEnum.BPP8, endian, rotate, p.Buffer.Span, 0, 0, (ushort)(device.DeviceInfo.ScreenSize.Width / 8), (ushort)device.DeviceInfo.ScreenSize.Height);
device.Set1BPPMode(true);
device.RefreshScreen(DisplayModeEnum.A2);
device.Set1BPPMode(false);
}
else
{
device.LoadImage(bpp, endian, rotate, p.Buffer.Span);
device.RefreshScreen(mode);
}
}
public static void DrawArea(this IT8951SPIDevice device, Action <DrawingBuffer> pixelOperateCallback, ushort x, ushort y, ushort width, ushort height, ImagePixelPackEnum bpp = ImagePixelPackEnum.BPP4, ImageEndianTypeEnum endian = ImageEndianTypeEnum.BigEndian, ImageRotateEnum rotate = ImageRotateEnum.Rotate0, DisplayModeEnum mode = DisplayModeEnum.GC16)
{
var p = new DrawingBuffer(x, y, width, height, bpp);
pixelOperateCallback(p);
device.LoadImageArea(bpp, endian, rotate, p.Buffer.Span, x, y, width, height);
device.RefreshArea(mode, x, y, width, height);
}
public void DisplayArea(ushort x, ushort y, ushort width, ushort height, DisplayModeEnum mode)
{
io.SendCommand(IT8951SPIDeviceIO.DeviceCommand.DPY_AREA, x, y, width, height, (ushort)mode);
}
public static void RefreshArea(this IT8951SPIDevice device, DisplayModeEnum mode, ushort x, ushort y, ushort width, ushort height)
{
device.DisplayArea(x, y, width, height, mode);
}
