#rendersettings | Explore Tumblr posts and blogs

just4programmers · 7 years ago

Text

A multi-player server-side GameBoy Emulator written in .NET Core and Angular

One of the great joys of sharing and discovering code online is when you stumble upon something so truly epic, so amazing, that you have to dig in. Head over to https://github.com/axle-h/Retro.Net and ask yourself why this GitHub project has only 20 stars?

Alex Haslehurst has created some retro hardware libraries in open source .NET Core with an Angular Front End!

Translation?

A multiplayer server-side Game Boy emulator. Epic.

You can run it in minutes with

docker run -p 2500:2500 alexhaslehurst/server-side-gameboy

Then just browse to http://localhost:2500 and play Tetris on the original GameBoy!

I love this for a number of reasons.

First, I love his perspective:

Please check out my GameBoy emulator written in .NET Core; Retro.Net. Yes, a GameBoy emulator written in .NET Core. Why? Why not. I plan to do a few write-ups about my experience with this project. Firstly: why it was a bad idea.

Emulation on .NET

Emulating the GameBoy CPU on .NET

The biggest issue one has trying to emulate a CPU with a platform like .NET is the lack of reliable high-precision timing. However, he manages a nice from-scratch emulation of the Z80 processor, modeling low level things like registers in very high level C#. I love that public class GameBoyFlagsRegister is a thing. ;) I did similar things when I ported a 15 year old "Tiny CPU" to .NET Core/C#.

Be sure to check out Alex's extremely detailed explanation on how he modeled the Z80 microprocessor.

Luckily the GameBoy CPU, a Sharp LR35902, is derived from the popular and very well documented Zilog Z80 - A microprocessor that is unbelievably still in production today, over 40 years after it’s introduction.

The Z80 is an 8-bit microprocessor, meaning that each operation is natively performed on a single byte. The instruction set does have some 16-bit operations but these are just executed as multiple cycles of 8-bit logic. The Z80 has a 16-bit wide address bus, which logically represents a 64K memory map. Data is transferred to the CPU over an 8-bit wide data bus but this is irrelevant to simulating the system at state machine level. The Z80 and the Intel 8080 that it derives from have 256 I/O ports for accessing external peripherals but the GameBoy CPU has none - favouring memory mapped I/O instead

He didn't just create an emulator - there's lots of those - but uniquely he runs it on the server-side while allowing shared controls in a browser. "In between each unique frame, all connected clients can vote on what the next control input should be. The server will choose the one with the most votes�� most of the time." Massively multi-player online GameBoy! Then he streams out the next frame! "GPU rendering is completed on the server once per unique frame, compressed with LZ4 and streamed out to all connected clients over websockets."

This is a great learning repository because:

it has complex business logic on the server-side but the front end uses Angular and web-sockets and open web technologies.

It's also nice that he has a complete multi-stage Dockerfile that is itself a great example of how to build both .NET Core and Angular apps in Docker.

Extensive (thousands) of Unit Tests with the Shouldly Assertion Framework and Moq Mocking Framework.

Great example usages of Reactive Programming

Unit Testing on both server AND client, using Karma Unit Testing for Angular

Here's a few favorite elegant code snippets in this huge repository.

The Reactive Button Presses:

_joyPadSubscription = _joyPadSubject .Buffer(FrameLength) .Where(x => x.Any()) .Subscribe(presses => { var (button, name) = presses .Where(x => !string.IsNullOrEmpty(x.name)) .GroupBy(x => x.button) .OrderByDescending(grp => grp.Count()) .Select(grp => (button: grp.Key, name: grp.Select(x => x.name).First())) .FirstOrDefault(); joyPad.PressOne(button); Publish(name, $"Pressed {button}"); Thread.Sleep(ButtonPressLength); joyPad.ReleaseAll(); });

The GPU Renderer:

private void Paint() { var renderSettings = new RenderSettings(_gpuRegisters); var backgroundTileMap = _tileRam.ReadBytes(renderSettings.BackgroundTileMapAddress, 0x400); var tileSet = _tileRam.ReadBytes(renderSettings.TileSetAddress, 0x1000); var windowTileMap = renderSettings.WindowEnabled ? _tileRam.ReadBytes(renderSettings.WindowTileMapAddress, 0x400) : new byte[0]; byte[] spriteOam, spriteTileSet; if (renderSettings.SpritesEnabled) { // If the background tiles are read from the sprite pattern table then we can reuse the bytes. spriteTileSet = renderSettings.SpriteAndBackgroundTileSetShared ? tileSet : _tileRam.ReadBytes(0x0, 0x1000); spriteOam = _spriteRam.ReadBytes(0x0, 0xa0); } else { spriteOam = spriteTileSet = new byte[0]; } var renderState = new RenderState(renderSettings, tileSet, backgroundTileMap, windowTileMap, spriteOam, spriteTileSet); var renderStateChange = renderState.GetRenderStateChange(_lastRenderState); if (renderStateChange == RenderStateChange.None) { // No need to render the same frame twice. _frameSkip = 0; _framesRendered++; return; } _lastRenderState = renderState; _tileMapPointer = _tileMapPointer == null ? new TileMapPointer(renderState) : _tileMapPointer.Reset(renderState, renderStateChange); var bitmapPalette = _gpuRegisters.LcdMonochromePaletteRegister.Pallette; for (var y = 0; y < LcdHeight; y++) { for (var x = 0; x < LcdWidth; x++) { _lcdBuffer.SetPixel(x, y, (byte) bitmapPalette[_tileMapPointer.Pixel]); if (x + 1 < LcdWidth) { _tileMapPointer.NextColumn(); } } if (y + 1 < LcdHeight){ _tileMapPointer.NextRow(); } } _renderer.Paint(_lcdBuffer); _frameSkip = 0; _framesRendered++; }

The GameBoy Frames are composed on the server side then compressed and sent to the client over WebSockets. He's got backgrounds and sprites working, and there's still work to be done.

The Raw LCD is an HTML5 canvas:

I love this whole project because it has everything. TypeScript, 2D JavaScript Canvas, retro-gaming, and so much more!

const raw: HTMLCanvasElement = this.rawLcdCanvas.nativeElement; const rawContext: CanvasRenderingContext2D = raw.getContext("2d"); const img = rawContext.createImageData(this.lcdWidth, this.lcdHeight); for (let y = 0; y < this.lcdHeight; y++) { for (let x = 0; x < this.lcdWidth; x++) { const index = y * this.lcdWidth + x; const imgIndex = index * 4; const colourIndex = this.service.frame[index]; if (colourIndex < 0 || colourIndex >= colours.length) { throw new Error("Unknown colour: " + colourIndex); } const colour = colours[colourIndex]; img.data[imgIndex] = colour.red; img.data[imgIndex + 1] = colour.green; img.data[imgIndex + 2] = colour.blue; img.data[imgIndex + 3] = 255; } } rawContext.putImageData(img, 0, 0); context.drawImage(raw, lcdX, lcdY, lcdW, lcdH);

I would encourage you to go STAR and CLONE https://github.com/axle-h/Retro.Net and give it a run with Docker! You can then use Visual Studio Code and .NET Core to compile and run it locally. He's looking for help with GameBoy sound and a Debugger.

Sponsor: Get the latest JetBrains Rider for debugging third-party .NET code, Smart Step Into, more debugger improvements, C# Interactive, new project wizard, and formatting code in columns.

#Scott Hanselman's Blog

0 notes

mobilenamic · 6 years ago

Text

Release 2.18.0: Update to Qt 5.11.1 with QML Compiler and Massive Performance Improvements

V-Play 2.18.0 adds support for Qt 5.11.1, with all features, improvements and fixes. Major changes to the QML compiler pipeline and QML engine boost the performance of your apps and games. The Qt Quick Compiler is now also available with the open source Qt version. This update also adds several improvements and fixes to V-Play app and game components.

Improved QML and JavaScript Performance on iOS, Android and Desktop

Qt now uses a completely new QML compiler pipeline to compile QML and JavaScript into bytecode. Then JIT is used to compile heavy used functions to assembly code on the fly.

Image from www.qt.io

Here are some more details about this great addition:

Lots of cleanups and performance improvement to the way function calls and JavaScript scopes are being handled.

Improved performance of JS property lookups.

A new bytecode format that is very compact, saving memory in many cases.

Significantly faster bytecode interpreter than in earlier versions of Qt, in many cases reaching almost the performance of the old JIT.

A new JIT that works on top of the bytecode interpreter and only compiles hot functions into assembly.

Overall test results show almost a doubling of the JS performance on platforms where JIT can’t be used (iOS and WinRT) compared to 5.10.

With the new JIT, JS performance is usually around 10-40% faster than in older Qt versions (depending on the use case).

Qt Quick Compiler for AOT Compilation of QML and JS

You can now use the Qt Quick Compiler in all your apps and games. This was previously limited to only commercial Qt users, but is now also available with the open source Qt version.

To use the Qt Quick Compiler, just add the following line to your .pro file

CONFIG += qtquickcompiler

and enable the qrc resource system as described in your .pro and main.cpp file. This will compile your QML and JavaScript files AOT to bytecode and embed them with your application.

Note for using the resource system: For the Qt Quick Compiler, it is not sufficient to just add the directory names to the resources.qrc file. Instead add all the files that you want to include.

Use the Qt Quick Compiler for a Faster App Start

Qt compiles and caches QML and JS files while your application is running. This results in significantly faster load times of applications, as the cache files are faster to load. However, the initial creation of cache files can still take time, especially when the application starts for the very first time. To avoid that initial step and provide faster start-up times from the very beginning, you can use the Qt Quick Compiler to generate the cache files ahead-of-time, when compiling your application.

You can find more info about this here.

Improved Performance and Reduced CPU Usage with Qt 3D

The update to Qt 5.11.1 also brings performance improvements and a lot of fixes to the Qt 3D module. This makes it even easier to add 3D content in your apps and games.

import VPlayApps 1.0 import QtQuick 2.9 // 3d imports import QtQuick.Scene3D 2.0 import Qt3D.Core 2.0 import Qt3D.Render 2.0 import Qt3D.Input 2.0 import Qt3D.Extras 2.0 import QtSensors 5.9 App { // Set screen to portrait in live client app (not needed for normal deployment) onInitTheme: nativeUtils.preferredScreenOrientation = NativeUtils.ScreenOrientationPortrait RotationSensor { id: sensor active: true // We copy reading to custom property to use behavior on it property real readingX: reading ? reading.x : 0 property real readingY: reading ? reading.y : 0 // We animate property changes for smoother movement of the cube Behavior on readingX {NumberAnimation{duration: 200}} Behavior on readingY {NumberAnimation{duration: 200}} } NavigationStack { Page { title: "3D Cube on Page" backgroundColor: Theme.secondaryBackgroundColor Column { padding: dp(15) spacing: dp(5) AppText { text: "x-axis " + sensor.readingX.toFixed(2) } AppText { text: "y-axis " + sensor.readingY.toFixed(2) } } // 3d object on top of camera Scene3D { id: scene3d anchors.fill: parent focus: true aspects: ["input", "logic"] cameraAspectRatioMode: Scene3D.AutomaticAspectRatio Entity { // The camera for the 3d world, to view our cube Camera { id: camera3D projectionType: CameraLens.PerspectiveProjection fieldOfView: 45 nearPlane : 0.1 farPlane : 1000.0 position: Qt.vector3d( 0.0, 0.0, 40.0 ) upVector: Qt.vector3d( 0.0, 1.0, 0.0 ) viewCenter: Qt.vector3d( 0.0, 0.0, 0.0 ) } components: [ RenderSettings { activeFrameGraph: ForwardRenderer { camera: camera3D clearColor: "transparent" } }, InputSettings { } ] PhongMaterial { id: material ambient: Theme.tintColor // Also available are diffuse, specular + shininess to control lighting behavior } // The 3d mesh for the cube CuboidMesh { id: cubeMesh xExtent: 8 yExtent: 8 zExtent: 8 } // Transform (rotate) the cube depending on sensor reading Transform { id: cubeTransform // Create the rotation quaternion from the sensor reading rotation: fromAxesAndAngles(Qt.vector3d(1,0,0), sensor.readingX*2, Qt.vector3d(0,1,0), sensor.readingY*2) } // The actuac 3d cube that consist of a mesh, a material and a transform component Entity { id: sphereEntity components: [ cubeMesh, material, cubeTransform ] } } } // Scene3D // Color selection row Row { anchors.horizontalCenter: parent.horizontalCenter anchors.bottom: parent.bottom spacing: dp(5) padding: dp(15) Repeater { model: [Theme.tintColor, "red", "green", "#FFFF9500"] Rectangle { color: modelData width: dp(48) height: dp(48) radius: dp(5) MouseArea { anchors.fill: parent onClicked: { material.ambient = modelData } } } } } } // Page } // NavigationStack } // App

Add Turn-by-Turn Navigation with Qt Location

You can use many new features of Qt Location and Maps. With this release you can start experimenting with turn-by-turn navigation. There are also several brand new features available for the Mapbox plugin.

Fixes for Qt Quick Controls

Many controls of the Qt Quick Controls 2 module received fixes, which are also available with the derived V-Play controls. Examples of improved components are ButtonGroup, CheckBox, Combobox, RangeSlider, ScrollBar, Slider, SpinBox and many more.

Qt for Webassembly and Python

With Qt for Webassembly, Qt is working towards filling the last large gaps in cross-platform development, allowing users to target the web and browsers as a platform. The first version has been released as a technology preview.

In addition, to the above, Qt is actively working on supporting Qt on Python.

Create Augmented Reality Apps and Games with Wikitude

As mentioned already in a previous release, you can now create feature-rich Augmented Reality (AR) apps & games with the Wikitude Plugin. You will read more on this amazing addition in another blog post coming soon. Stay tuned!

More Features, Improvements and Fixes

Here is a compressed list of improvements with this update:

WikitudeArView now properly rotates the camera image to device rotation on iOS.

WikitudeArView now supports live reloading of the HTML/JavaScript files with the V-Play Live Client.

Fixes Desktop Resolution Simulation on Windows when additional UI scaling is applied in display settings.

Fixes a crash in FirebaseAuth, FirebaseDatabase and FirebaseStorage when the FirebaseConfig is invalid.

WikitudeArView no longer gets a stuck camera image when resuming the app from background on iOS.

For a list of additional fixes, please check out the changelog.

How to Update V-Play

Test out these new features by following these steps:

Open the V-Play SDK Maintenance Tool in your V-Play SDK directory.

Choose “Update components” and finish the update process to get this release as described in the V-Play Update Guide.

If you haven’t installed V-Play yet, you can do so now with the latest installer from here. Now you can explore all of the new features included in this release!

For a full list of improvements and fixes to V-Play in this update, please check out the change log!