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); }