Update to bsnes v033 release.

This release adds SPC7110 emulation, without the need for graphics packs!!, and a rewritten S-RTC (real-time clock) emulator.
SPC7110 support means that Far East of Eden Zero, FEoEZ: Shounen Jump Edition, Momotarou Dentetsu Happy and Super Power League 4 are now all fully playable. I will warn you, the emulation is very slow in this version -- while most areas of each game will run at the same speed as other games, there are a few peak moments where speed will drop by up to ~50%. The reason for the slow-down is that I am currently uncertain how to determine the amount of data to decompress in advance, so I default to the maximum amount possible. The reason I am releasing now anyway, is because I beleive in the "release early, release often" paradigm. It will likely take me a few weeks to finish researching this chip, and I didn't want to keep the work I had private during that time. But rest assured, bsnes v034 should feature much faster SPC7110 emulation.
neviksti, Andreas Naive and jolly_codger worked non-stop on the SPC7110 decompression algorithm for the past two weeks. caitsith2 provided valuable data to the effort. I only wish that I could've been of some use, but alas, I had no role in this. In the end, it was neviksti who managed to crack all three(!!) compression modes of this chip, which turned out to be a customized 8-bit QM-coder with a prediction model. You can read more about this here. I would also like to thank Dark Force and John Weidman (aka The Dumper) for their research notes on the SPC7110 register interface.
For those who don't understand the hoopla about figuring out this compression algorithm when we already had graphics pack simulation, I should note that we have since found a few errors in these packs. Not to mention, you no longer need ~4-16MB packs for each game you wish to run. They work like any other game now. Better still, the chip can now be used to compress new graphics, eg for any future translation efforts on these titles.
The real-time clocks in both Far East of Eden Zero and Dai Kaijuu Monogatari 2 will now save a ".rtc" file in your save folder, which contains the clock as set by the video game, as well as a timestamp from your computer when the time was last updated. It uses the difference between the saved timestamp and current time to update the time. This allows you to specify any time you like, whereas previously bsnes would just use your computer's current time, ignoring the time you set in-game. It also allows the "round clock by 30 seconds" option in both games to work. I avoided this before because this method makes supporting daylight savings time and such impractical, although I should note that the original hardware did not support DST, either. This method was required to pass the SPC7110 tests, and is overall much more faithful to how the original chips worked.
Once again, I'd really like to personally thank neviksti for his tireless efforts. Eliminating graphics packs from SNES emulation was one of my primary reasons for getting involved in the SNES emulation scene. That neviksti managed to crack this algorithm means a lot to me. Thank you so much, neviksti. This release is dedicated to you, now go get some sleep Wink

.github/workflows/build.yml

@@ -1,194 +0,0 @@
-name: Build
-on:
-  push:
-    branches: [ master ]
-    tags: [ 'v*' ]
-  pull_request:
-    branches: [ master ]
-jobs:
-  build:
-    strategy:
-      matrix:
-        program:
-        - ares
-        platform:
-        - name: windows
-          os: windows-latest
-          compiler: g++
-          shell: 'msys2 {0}'
-          msystem: mingw64
-          msys-env: x86_64
-        - name: windows-clang
-          os: windows-latest
-          compiler: clang++
-          shell: 'msys2 {0}'
-          msystem: clang64
-          msys-env: clang-x86_64
-        - name: macos
-          os: macos-latest
-          compiler: clang++
-          shell: sh
-        - name: ubuntu
-          os: ubuntu-latest
-          compiler: g++
-          shell: sh
-    name: ${{ matrix.program }}-${{ matrix.platform.name }}
-    runs-on: ${{ matrix.platform.os }}
-    defaults:
-      run:
-        shell: ${{ matrix.platform.shell }}
-    steps:
-    - name: Install MSYS2 Dependencies
-      if: matrix.platform.shell == 'msys2 {0}'
-      uses: msys2/setup-msys2@v2
-      with:
-        msystem: ${{ matrix.platform.msystem }}
-        install: make mingw-w64-${{ matrix.platform.msys-env }}-toolchain
-    - name: Install Linux Dependencies
-      if: runner.os == 'Linux'
-      run: |
-        sudo apt-get update -y -qq
-        sudo apt-get install libsdl2-dev libgtksourceview2.0-dev libgtk2.0-dev libao-dev libopenal-dev   
-    - uses: actions/checkout@v2
-    - name: Make
-      run: make -j4 -C desktop-ui build=optimized local=false lto=true compiler=${{ matrix.platform.compiler }}
-    - name: Upload
-      uses: actions/upload-artifact@v2
-      with:
-        name: ${{ matrix.program }}-${{ matrix.platform.name }}
-        path: desktop-ui/out/*
-
-     
-  release:
-    if: github.ref == 'refs/heads/master' || startsWith(github.ref, 'refs/tags/')
-    runs-on: ubuntu-latest
-    needs:
-    - build
-    steps:
-    - uses: actions/checkout@v2
-      with:
-        path: 'src'
-    - name: Download Artifacts
-      uses: actions/download-artifact@v2
-      with:
-        path: 'bin'
-    - name: Package Artifacts
-      run: |
-        set -eu
-        case ${GITHUB_REF} in
-          refs/tags/*) suffix="-${GITHUB_REF#refs/tags/}" ;;
-          refs/heads/master) suffix="-nightly" ;;
-          *) suffix="" ;;
-        esac
-
-        srcdir="${GITHUB_WORKSPACE}/src"
-        bindir="${GITHUB_WORKSPACE}/bin"
-
-        # Hack: Workaround for GitHub artifacts losing attributes.
-        chmod +x ${bindir}/ares-macos/ares.app/Contents/MacOS/ares
-
-        for os in windows macos
-        do
-          mkdir "${os}"
-          cd "${os}"
-
-          # Package ares.
-          outdir=ares${suffix}
-          mkdir ${outdir}
-          cp -ar ${bindir}/ares-${os}/* ${outdir}
-          zip -r ../ares-${os}.zip ${outdir}
-
-          cd -
-        done
-    - name: Create Release
-      id: release
-      env:
-        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-      run: |
-        set -eu
-        github_rest()
-        {
-          local method="${1}"
-          local url="https://api.github.com${2}"
-          shift 2
-          >&2 echo "${method} ${url}"
-          curl \
-            --fail \
-            -H "Accept: application/vnd.github.v3+json" \
-            -H "Authorization: token ${GITHUB_TOKEN}" \
-            -X "${method}" \
-            "${url}" \
-            "$@"
-        }
-        github_get_release_id_for_tag()
-        {
-          payload=$(github_rest GET "/repos/${GITHUB_REPOSITORY}/releases/tags/${1}") || return
-          echo "${payload}" | jq .id
-        }
-        github_delete_release_by_id()
-        {
-          github_rest DELETE "/repos/${GITHUB_REPOSITORY}/releases/${1}"
-        }
-        github_create_release()
-        {
-          local payload="{
-            \"tag_name\": \"${1}\",
-            \"target_commitish\": \"${2}\",
-            \"name\": \"${3}\",
-            \"body\": \"${4}\",
-            \"draft\": ${5},
-            \"prerelease\": ${6}
-          }"
-          github_rest POST "/repos/${GITHUB_REPOSITORY}/releases" -d "${payload}"
-        }
-        make_nightly_release()
-        {
-          github_create_release \
-            nightly \
-            "${GITHUB_SHA}" \
-            "ares nightly $(date +"%Y-%m-%d")" \
-            "Auto-generated nightly release on $(date -u +"%Y-%m-%d %T %Z")" \
-            false \
-            true
-        }
-        make_version_release()
-        {
-          github_create_release \
-            "${1}" \
-            "${GITHUB_SHA}" \
-            "ares ${1}" \
-            "This is ares ${1}, released on $(date +"%Y-%m-%d")." \
-            false \
-            false
-        }
-        case ${GITHUB_REF} in
-          refs/tags/*)
-            # Create a new version release using the current revision.
-            echo "UPLOAD_URL=$(make_version_release ${GITHUB_REF#refs/tags/} | jq -r .upload_url)" >> $GITHUB_ENV
-            ;;
-          refs/heads/master)
-            # Check for an existing nightly release.
-            { release_id=$(github_get_release_id_for_tag nightly); status=$?; } || true
-            # Delete existing nightly release if it exists.
-            case ${status} in
-              0) github_delete_release_by_id "${release_id}" ;;
-              22) >&2 echo "No current nightly release; skipping tag deletion." ;;
-              *) >&2 echo "API call failed unexpectedly." && exit 1 ;;
-            esac
-            # Create a new nightly release using the current revision.
-            echo "UPLOAD_URL=$(make_nightly_release | jq -r .upload_url)" >> $GITHUB_ENV
-            ;;
-        esac
-    - name: Upload ares-windows
-      uses: actions/upload-release-asset@v1
-      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-windows.zip', asset_name: 'ares-windows.zip', asset_content_type: 'application/zip' }
-    - name: Upload ares-macos
-      uses: actions/upload-release-asset@v1
-      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-macos.zip', asset_name: 'ares-macos.zip', asset_content_type: 'application/zip' }
-#  - name: Upload ares-ubuntu
-#      uses: actions/upload-release-asset@v1
-#      env: { GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}' }
-#      with: { upload_url: '${{ env.UPLOAD_URL }}', asset_path: 'ares-ubuntu.zip', asset_name: 'ares-ubuntu.zip', asset_content_type: 'application/zip' }
-

.github/workflows/split-subtrees.yml

@@ -1,30 +0,0 @@
-name: 'Split Subtrees'
-on:
-    push:
-        branches:
-            - master
-        tags:
-            - '*'
-env:
-    GITHUB_TOKEN: ${{ secrets.ACCESS_TOKEN }}
-jobs:
-    packages_split:
-        runs-on: ubuntu-latest
-        strategy:
-            fail-fast: false
-            matrix:
-                package: 
-                  - nall
-                  - hiro
-                  - ruby
-                  - libco
-        steps:
-            -   uses: actions/checkout@v2
-            -   if: "!startsWith(github.ref, 'refs/tags/')"
-                uses: "symplify/[email protected]"
-                with:
-                    package_directory: '${{ matrix.package }}'
-                    repository_organization: 'ares-emulator'
-                    repository_name: '${{ matrix.package }}'
-                    user_name: "Luke Usher"
-                    user_email: "[email protected]"

.gitignore

@@ -1,2 +0,0 @@
-obj/
-out/

GNUmakefile

@@ -1,6 +0,0 @@
-all: desktop
-
-desktop:
-	$(MAKE) -C desktop-ui
-
-.PHONY: all desktop

LICENSE

@@ -1,148 +0,0 @@
-----------------------------------------------------------------------
-ares
-
-Copyright (c) 2004-2021 ares team, Near et al
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
-----------------------------------------------------------------------
-
-----------------------------------------------------------------------
-Stack-less Just-In-Time compiler
-
-Copyright Zoltan Herczeg ([email protected]). All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS
-``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
-NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
-USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------
-
-----------------------------------------------------------------------
-MAME
-Copyright (c) 1997-2021 MAMEdev and contributors
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its
-   contributors may be used to endorse or promote products derived from
-   this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
-IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
-TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
-PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT
-HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
-TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-----------------------------------------------------------------------
-
-----------------------------------------------------------------------
-libchdr
-
-Copyright Romain Tisserand
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright
-      notice, this list of conditions and the following disclaimer in the
-      documentation and/or other materials provided with the distribution.
-    * Neither the name of the <organization> nor the
-      names of its contributors may be used to endorse or promote products
-      derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
-DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
-ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-----------------------------------------------------------------------
-
-----------------------------------------------------------------------
-LZMA SDK is placed in the public domain.
-
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute
-the original LZMA SDK code, either in source code form or as a compiled binary,
-for any purpose, commercial or non-commercial, and by any means.
-----------------------------------------------------------------------
-
-----------------------------------------------------------------------
-zlib
-
- (C) 1995-2017 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  [email protected]          [email protected]
-
-If you use the zlib library in a product, we would appreciate *not* receiving
-lengthy legal documents to sign.  The sources are provided for free but without
-warranty of any kind.  The library has been entirely written by Jean-loup
-Gailly and Mark Adler; it does not include third-party code.
-
-If you redistribute modified sources, we would appreciate that you include in
-the file ChangeLog history information documenting your changes.  Please read
-the FAQ for more information on the distribution of modified source versions.
-----------------------------------------------------------------------

README.md

@@ -1,18 +0,0 @@
-![ares logo](https://ares-emulator.github.io/images/logo.png)
-
-[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://github.com/higan-emu/ares/blob/master/LICENSE)
-
-**ares** is a multi-system emulator that began development on October 14th, 2004.
-It is a descendent of [higan](https://github.com/higan-emu/higan) and [bsnes](https://github.com/bsnes-emu/bsnes/), and focuses on accuracy and preservation.
-
-Official Releases
------------------
-
-Official releases are available from
-[the ares website](https://ares-emu.net).
-
-Nightly Builds
---------------
-
-Automated, untested builds of ares are available for Windows and macOS as a [pre-release](https://github.com/higan-emu/ares/releases/tag/nightly). 
-Only the latest nightly build is kept.

ares/GNUmakefile

@@ -1,102 +0,0 @@
-ifeq ($(platform),windows)
-  options += -luuid -lkernel32 -luser32 -lgdi32 -lcomctl32 -lcomdlg32 -lshell32
-  options += -Wl,-enable-auto-import
-  options += -Wl,-enable-runtime-pseudo-reloc
-else ifeq ($(platform),macos)
-else ifneq ($(filter $(platform),linux bsd),)
-  options += -Wl,-export-dynamic
-  options += -lX11 -lXext
-else
-  $(error "ares is a library and cannot be built directly.")
-endif
-
-ares.objects := ares ares-fixed-allocator
-
-$(object.path)/ares.o: $(ares.path)/ares/ares.cpp
-$(object.path)/ares-fixed-allocator.o: $(ares.path)/ares/memory/fixed-allocator.cpp
-
-ifeq ($(vulkan),true)
-  flags += -DVULKAN
-endif
-
-ifeq ($(profile),accuracy)
-  flags += -DPROFILE_ACCURACY
-endif
-
-ifeq ($(profile),performance)
-  flags += -DPROFILE_PERFORMANCE
-endif
-
-ifneq ($(filter $(cores),a26),)
-  include $(ares.path)/a26/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),fc),)
-  include $(ares.path)/fc/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),sfc),)
-  include $(ares.path)/sfc/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),n64),)
-  include $(ares.path)/n64/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),sg),)
-  include $(ares.path)/sg/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ms),)
-  include $(ares.path)/ms/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),md),)
-  include $(ares.path)/md/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),saturn),)
-  include $(ares.path)/saturn/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ps1),)
-  include $(ares.path)/ps1/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),pce),)
-  include $(ares.path)/pce/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),msx),)
-  include $(ares.path)/msx/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),cv),)
-  include $(ares.path)/cv/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),gb),)
-  include $(ares.path)/gb/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),gba),)
-  include $(ares.path)/gba/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ws),)
-  include $(ares.path)/ws/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ng),)
-  include $(ares.path)/ng/GNUmakefile
-endif
-
-ifneq ($(filter $(cores),ngp),)
-  include $(ares.path)/ngp/GNUmakefile
-endif
-
-include $(ares.path)/component/GNUmakefile
-
-flags += $(foreach c,$(call strupper,$(cores)),-DCORE_$c)
-
-ares.objects := $(ares.objects:%=$(object.path)/%.o)

ares/Shaders/AANN.shader/AANN.fs

@@ -1,81 +0,0 @@
-#version 150
-
-//anti-aliased nearest-neighbor
-
-precision highp float;
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform vec4 targetSize[];
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-vec4 vpow(vec4 n, float e) {
-  return vec4(pow(n.x, e), pow(n.y, e), pow(n.z, e), pow(n.w, e));
-}
-
-vec4 toLQV(vec3 c) {
-  return vec4(c.r, c.g, c.b, c.r * 0.2989 + c.g * 0.5870 + c.b * 0.1140);
-}
-
-vec3 fromLQV(vec4 c) {
-  float f = c.w / (c.r * 0.2989 + c.g * 0.5870 + c.b * 0.1140);
-  return vec3(c.rgb) * f;
-}
-
-vec3 percent(float ssize, float tsize, float coord) {
-  float minfull  = (coord * tsize - 0.5) / tsize * ssize;
-  float maxfull  = (coord * tsize + 0.5) / tsize * ssize;
-  float realfull = floor(maxfull);
-
-  if(minfull > realfull) {
-    return vec3(
-      1,
-      (realfull + 0.5) / ssize,
-      (realfull + 0.5) / ssize
-    );
-  }
-
-  return vec3(
-    (maxfull - realfull) / (maxfull - minfull),
-    (realfull - 0.5) / ssize,
-    (realfull + 0.5) / ssize
-  );
-}
-
-void main() {
-  float srgb  = 2.1;
-  float gamma = 3.0;
-
-  vec3 x = percent(sourceSize[0].x, targetSize[0].x, texCoord.x);
-  vec3 y = percent(sourceSize[0].y, targetSize[0].y, texCoord.y);
-
-  //get points to interpolate across in linear RGB
-  vec4 a = toLQV(vpow(texture(source[0], vec2(x[1], y[1])), srgb).rgb);
-  vec4 b = toLQV(vpow(texture(source[0], vec2(x[2], y[1])), srgb).rgb);
-  vec4 c = toLQV(vpow(texture(source[0], vec2(x[1], y[2])), srgb).rgb);
-  vec4 d = toLQV(vpow(texture(source[0], vec2(x[2], y[2])), srgb).rgb);
-
-  //use perceptual gamma for luminance component
-  a.w = pow(a.w, 1 / gamma);
-  b.w = pow(b.w, 1 / gamma);
-  c.w = pow(c.w, 1 / gamma);
-  d.w = pow(d.w, 1 / gamma);
-
-  //interpolate
-  vec4 gammaLQV =
-    (1.0 - x[0]) * (1.0 - y[0]) * a +
-    (0.0 + x[0]) * (1.0 - y[0]) * b +
-    (1.0 - x[0]) * (0.0 + y[0]) * c +
-    (0.0 + x[0]) * (0.0 + y[0]) * d;
-
-  //convert luminance gamma back to linear
-  gammaLQV.w = pow(gammaLQV.w, gamma);
-
-  //convert color back to sRGB
-  fragColor = vpow(vec4(fromLQV(gammaLQV), 1), 1 / srgb);
-}

ares/Shaders/AANN.shader/manifest.bml

@@ -1,8 +0,0 @@
-input
-  filter: nearest
-
-program
-  fragment: AANN.fs
-
-output
-  filter: nearest

ares/Shaders/CRT-Lottes.shader/manifest.bml

@@ -1,10 +0,0 @@
-input
-  filter: nearest
-
-program
-  filter: nearest
-  wrap: border
-  fragment: shadertoy.fs
-
-output
-  filter: nearest

ares/Shaders/CRT-Lottes.shader/shadertoy.fs

@@ -1,145 +0,0 @@
-//
-// PUBLIC DOMAIN CRT STYLED SCAN-LINE SHADER
-//
-//   by Timothy Lottes
-//
-// This is more along the style of a really good CGA arcade monitor.
-// With RGB inputs instead of NTSC.
-// The shadow mask example has the mask rotated 90 degrees for less chromatic aberration.
-//
-// Left it unoptimized to show the theory behind the algorithm.
-//
-// It is an example what I personally would want as a display option for pixel art games.
-// Please take and use, change, or whatever.
-//
-
-#version 150
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform int phase;
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-// Emulated input resolution.
-  vec2 res=sourceSize[0].xy;
-
-// Hardness of scanline.
-//  -8.0 = soft
-// -16.0 = medium
-float hardScan=-8.0;
-
-// Hardness of pixels in scanline.
-// -2.0 = soft
-// -4.0 = hard
-float hardPix=-3.0;
-
-// Display warp.
-// 0.0 = none
-// 1.0/8.0 = extreme
-vec2 warp=vec2(1.0/32.0,1.0/24.0); 
-
-// Amount of shadow mask.
-float maskDark=0.5;
-float maskLight=1.5;
-
-//------------------------------------------------------------------------
-
-// sRGB to Linear.
-// Assuing using sRGB typed textures this should not be needed.
-float ToLinear1(float c){return(c<=0.04045)?c/12.92:pow((c+0.055)/1.055,2.4);}
-vec3 ToLinear(vec3 c){return vec3(ToLinear1(c.r),ToLinear1(c.g),ToLinear1(c.b));}
-
-// Linear to sRGB.
-// Assuing using sRGB typed textures this should not be needed.
-float ToSrgb1(float c){return(c<0.0031308?c*12.92:1.055*pow(c,0.41666)-0.055);}
-vec3 ToSrgb(vec3 c){return vec3(ToSrgb1(c.r),ToSrgb1(c.g),ToSrgb1(c.b));}
-
-// Nearest emulated sample given floating point position and texel offset.
-// Also zero's off screen.
-vec3 Fetch(vec2 pos,vec2 off){
-  pos=(floor(pos*res+off)+vec2(0.5,0.5))/res;
-  return ToLinear(1.2 * texture(source[0],pos.xy,-16.0).rgb);}
-
-// Distance in emulated pixels to nearest texel.
-vec2 Dist(vec2 pos){pos=pos*res;return -((pos-floor(pos))-vec2(0.5));}
-    
-// 1D Gaussian.
-float Gaus(float pos,float scale){return exp2(scale*pos*pos);}
-
-// 3-tap Gaussian filter along horz line.
-vec3 Horz3(vec2 pos,float off){
-  vec3 b=Fetch(pos,vec2(-1.0,off));
-  vec3 c=Fetch(pos,vec2( 0.0,off));
-  vec3 d=Fetch(pos,vec2( 1.0,off));
-  float dst=Dist(pos).x;
-  // Convert distance to weight.
-  float scale=hardPix;
-  float wb=Gaus(dst-1.0,scale);
-  float wc=Gaus(dst+0.0,scale);
-  float wd=Gaus(dst+1.0,scale);
-  // Return filtered sample.
-  return (b*wb+c*wc+d*wd)/(wb+wc+wd);}
-
-// 5-tap Gaussian filter along horz line.
-vec3 Horz5(vec2 pos,float off){
-  vec3 a=Fetch(pos,vec2(-2.0,off));
-  vec3 b=Fetch(pos,vec2(-1.0,off));
-  vec3 c=Fetch(pos,vec2( 0.0,off));
-  vec3 d=Fetch(pos,vec2( 1.0,off));
-  vec3 e=Fetch(pos,vec2( 2.0,off));
-  float dst=Dist(pos).x;
-  // Convert distance to weight.
-  float scale=hardPix;
-  float wa=Gaus(dst-2.0,scale);
-  float wb=Gaus(dst-1.0,scale);
-  float wc=Gaus(dst+0.0,scale);
-  float wd=Gaus(dst+1.0,scale);
-  float we=Gaus(dst+2.0,scale);
-  // Return filtered sample.
-  return (a*wa+b*wb+c*wc+d*wd+e*we)/(wa+wb+wc+wd+we);}
-
-// Return scanline weight.
-float Scan(vec2 pos,float off){
-  float dst=Dist(pos).y;
-  return Gaus(dst+off,hardScan);}
-
-// Allow nearest three lines to effect pixel.
-vec3 Tri(vec2 pos){
-  vec3 a=Horz3(pos,-1.0);
-  vec3 b=Horz5(pos, 0.0);
-  vec3 c=Horz3(pos, 1.0);
-  float wa=Scan(pos,-1.0);
-  float wb=Scan(pos, 0.0);
-  float wc=Scan(pos, 1.0);
-  return a*wa+b*wb+c*wc;}
-
-// Distortion of scanlines, and end of screen alpha.
-vec2 Warp(vec2 pos){
-  pos=pos*2.0-1.0;    
-  pos*=vec2(1.0+(pos.y*pos.y)*warp.x,1.0+(pos.x*pos.x)*warp.y);
-  return pos*0.5+0.5;}
-
-// Shadow mask.
-vec3 Mask(vec2 pos){
-  pos.x+=pos.y*3.0;
-  vec3 mask=vec3(maskDark,maskDark,maskDark);
-  pos.x=fract(pos.x/6.0);
-  if(pos.x<0.333)mask.r=maskLight;
-  else if(pos.x<0.666)mask.g=maskLight;
-  else mask.b=maskLight;
-  return mask;}    
-
-void main() {
-    vec2 pos = texCoord.xy * 1.0001;
-      hardScan=-12.0;
-//      maskDark=maskLight;
-      pos=Warp(pos.xy);
-    fragColor.rgb=Tri(pos)*Mask(gl_FragCoord.xy);    
-  fragColor.a=1.0;
-  fragColor = vec4(ToSrgb(fragColor.rgb), fragColor.a);
-}

ares/Shaders/CRT-Lottes2.shader/lottes.fs

@@ -1,609 +0,0 @@
-#version 150
-
-//_____________________________/\_______________________________
-//==============================================================
-//
-//
-//      [CRTS] PUBLIC DOMAIN CRT-STYLED SCALAR - 20180120b
-//
-//                      by Timothy Lottes
-//             https://www.shadertoy.com/view/MtSfRK
-//              adapted for quark syntax by hunterk
-//
-//
-//==============================================================
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-//_____________________________/\_______________________________
-//==============================================================
-//
-//                         WHAT'S NEW
-//
-//--------------------------------------------------------------
-// Evolution of prior shadertoy example
-//--------------------------------------------------------------
-// This one is semi-optimized
-//  - Less texture fetches
-//  - Didn't get to instruction level optimization
-//  - Could likely use texture fetch to generate phosphor mask
-//--------------------------------------------------------------
-// Added options to disable unused features
-//--------------------------------------------------------------
-// Added in exposure matching
-//  - Given scan-line effect and mask always darkens image
-//  - Uses generalized tonemapper to boost mid-level
-//  - Note this can compress highlights
-//  - And won't get back peak brightness
-//  - But best option if one doesn't want as much darkening
-//--------------------------------------------------------------
-// Includes option saturation and contrast controls
-//--------------------------------------------------------------
-// Added in subtractive aperture grille
-//  - This is a bit brighter than prior
-//--------------------------------------------------------------
-// Make sure input to this filter is already low-resolution
-//  - This is not designed to work on titles doing the following
-//     - Rendering to hi-res with nearest sampling
-//--------------------------------------------------------------
-// Added a fast and more pixely option for 2 tap/pixel
-//--------------------------------------------------------------
-// Improved the vignette when WARP is enabled
-//--------------------------------------------------------------
-// Didn't test HLSL or CPU options
-//  - Will incorportate patches if they are broken
-//  - But out of time to try them myself
-//==============================================================
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-//_____________________________/\_______________________________
-//==============================================================
-//
-//          LICENSE = UNLICENSE (aka PUBLIC DOMAIN)
-//
-//--------------------------------------------------------------
-// This is free and unencumbered software released into the 
-// public domain.
-//--------------------------------------------------------------
-// Anyone is free to copy, modify, publish, use, compile, sell, 
-// or distribute this software, either in source code form or as
-// a compiled binary, for any purpose, commercial or 
-// non-commercial, and by any means.
-//--------------------------------------------------------------
-// In jurisdictions that recognize copyright laws, the author or
-// authors of this software dedicate any and all copyright 
-// interest in the software to the public domain. We make this
-// dedication for the benefit of the public at large and to the
-// detriment of our heirs and successors. We intend this 
-// dedication to be an overt act of relinquishment in perpetuity
-// of all present and future rights to this software under 
-// copyright law.
-//--------------------------------------------------------------
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY
-// KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE 
-// WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR 
-// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE
-// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
-// AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT 
-// OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 
-// DEALINGS IN THE SOFTWARE.
-//--------------------------------------------------------------
-// For more information, please refer to 
-// <http://unlicense.org/>
-//==============================================================
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-
-#define MASK 1.0
-#define MASK_INTENSITY 0.5
-#define SCANLINE_THINNESS 0.5
-#define SCAN_BLUR 2.5
-#define CURVATURE 0.02
-#define TRINITRON_CURVE 0.0
-#define CORNER 3.0
-#define CRT_GAMMA 2.4
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform vec4 outputSize;
-
-in Vertex {
-   vec2 vTexCoord;
-};
-
-out vec4 FragColor;
-
-//_____________________________/\_______________________________
-//==============================================================
-//
-//                       GAMMA FUNCTIONS
-//
-//--------------------------------------------------------------
-//--------------------------------------------------------------
-// Since shadertoy doesn't have sRGB textures
-// And we need linear input into shader
-// Don't do this in your code
-	float FromSrgb1(float c){
-		return (c<=0.04045)?c*(1.0/12.92):
-			pow(c*(1.0/1.055)+(0.055/1.055),CRT_GAMMA);}
-//--------------------------------------------------------------
-vec3 FromSrgb(vec3 c){return vec3(
- FromSrgb1(c.r),FromSrgb1(c.g),FromSrgb1(c.b));}
- 
-// Convert from linear to sRGB
-// Since shader toy output is not linear
-float ToSrgb1(float c){
- return(c<0.0031308?c*12.92:1.055*pow(c,0.41666)-0.055);}
-//--------------------------------------------------------------
-vec3 ToSrgb(vec3 c){return vec3(
- ToSrgb1(c.r),ToSrgb1(c.g),ToSrgb1(c.b));}
-//--------------------------------------------------------------
-
-//_____________________________/\_______________________________
-//==============================================================
-//
-//                           DEFINES
-//
-//--------------------------------------------------------------
-// CRTS_CPU - CPU code
-// CRTS_GPU - GPU code
-//--------------------------------------------------------------
-// CRTS_GLSL - GLSL
-// CRTS_HLSL - HLSL (not tested yet)
-//--------------------------------------------------------------
-// CRTS_DEBUG - Define to see on/off split screen
-//--------------------------------------------------------------
-// CRTS_WARP - Apply screen warp
-//--------------------------------------------------------------
-// CRTS_2_TAP - Faster very pixely 2-tap filter (off is 8)
-//--------------------------------------------------------------
-// CRTS_MASK_GRILLE      - Aperture grille (aka Trinitron)
-// CRTS_MASK_GRILLE_LITE - Brighter (subtractive channels)
-// CRTS_MASK_NONE        - No mask
-// CRTS_MASK_SHADOW      - Horizontally stretched shadow mask
-//--------------------------------------------------------------
-// CRTS_TONE       - Normalize mid-level and process color
-// CRTS_CONTRAST   - Process color - enable contrast control
-// CRTS_SATURATION - Process color - enable saturation control
-//--------------------------------------------------------------
-#define CRTS_STATIC
-#define CrtsPow
-#define CRTS_RESTRICT
-//==============================================================
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-
-//==============================================================
-//                      SETUP FOR CRTS
-//--------------------------------------------------------------
-//==============================================================
-//#define CRTS_DEBUG 1
-#define CRTS_GPU 1
-#define CRTS_GLSL 1
-//--------------------------------------------------------------
-//#define CRTS_2_TAP 1
-//--------------------------------------------------------------
-#define CRTS_TONE 1
-#define CRTS_CONTRAST 0
-#define CRTS_SATURATION 0
-//--------------------------------------------------------------
-#define CRTS_WARP 1
-//--------------------------------------------------------------
-// Try different masks -> moved to runtime parameters
-//#define CRTS_MASK_GRILLE 1
-//#define CRTS_MASK_GRILLE_LITE 1
-//#define CRTS_MASK_NONE 1
-//#define CRTS_MASK_SHADOW 1
-//--------------------------------------------------------------
-// Scanline thinness
-//  0.50 = fused scanlines
-//  0.70 = recommended default
-//  1.00 = thinner scanlines (too thin)
-#define INPUT_THIN (0.5 + (0.5 * SCANLINE_THINNESS))
-//--------------------------------------------------------------
-// Horizonal scan blur
-//  -3.0 = pixely
-//  -2.5 = default
-//  -2.0 = smooth
-//  -1.0 = too blurry
-#define INPUT_BLUR (-1.0 * SCAN_BLUR)
-//--------------------------------------------------------------
-// Shadow mask effect, ranges from,
-//  0.25 = large amount of mask (not recommended, too dark)
-//  0.50 = recommended default
-//  1.00 = no shadow mask
-#define INPUT_MASK (1.0 - MASK_INTENSITY)
-//--------------------------------------------------------------
-#define INPUT_X sourceSize[0].x
-#define INPUT_Y sourceSize[0].y
-//--------------------------------------------------------------
-// Setup the function which returns input image color
-vec3 CrtsFetch(vec2 uv){
- // For shadertoy, scale to get native texels in the image
- uv*=vec2(INPUT_X,INPUT_Y)/sourceSize[0].xy;
- // Move towards intersting parts
-// uv+=vec2(0.5,0.5);
- // Non-shadertoy case would not have the color conversion
- return FromSrgb(texture(source[0],uv.xy,-16.0).rgb);}
- 
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////////
-//_____________________________/\_______________________________
-//==============================================================
-//
-//                          GPU CODE
-//
-//==============================================================
-#ifdef CRTS_GPU
-//_____________________________/\_______________________________
-//==============================================================
-//                         PORTABILITY
-//==============================================================
- #ifdef CRTS_GLSL
-  #define CrtsF1 float
-  #define CrtsF2 vec2
-  #define CrtsF3 vec3
-  #define CrtsF4 vec4
-  #define CrtsFractF1 fract
-  #define CrtsRcpF1(x) (1.0/(x))
-  #define CrtsSatF1(x) clamp((x),0.0,1.0)
-//--------------------------------------------------------------
-  CrtsF1 CrtsMax3F1(CrtsF1 a,CrtsF1 b,CrtsF1 c){
-   return max(a,max(b,c));}
- #endif
-//==============================================================
- #ifdef CRTS_HLSL
-  #define CrtsF1 float
-  #define CrtsF2 float2
-  #define CrtsF3 float3
-  #define CrtsF4 float4
-  #define CrtsFractF1 frac
-  #define CrtsRcpF1(x) (1.0/(x))
-  #define CrtsSatF1(x) saturate(x)
-//--------------------------------------------------------------
-  CrtsF1 CrtsMax3F1(CrtsF1 a,CrtsF1 b,CrtsF1 c){
-   return max(a,max(b,c));}
- #endif
-//_____________________________/\_______________________________
-//==============================================================
-//              TONAL CONTROL CONSTANT GENERATION
-//--------------------------------------------------------------
-// This is in here for rapid prototyping
-// Please use the CPU code and pass in as constants
-//==============================================================
- CrtsF4 CrtsTone(
- CrtsF1 contrast,
- CrtsF1 saturation,
- CrtsF1 thin,
- CrtsF1 mask){
-//--------------------------------------------------------------
-  if(MASK == 0.0) mask=1.0;
-//--------------------------------------------------------------
-  if(MASK == 1.0){
-   // Normal R mask is {1.0,mask,mask}
-   // LITE   R mask is {mask,1.0,1.0}
-   mask=0.5+mask*0.5;
-   }
-//--------------------------------------------------------------
-  CrtsF4 ret;
-  CrtsF1 midOut=0.18/((1.5-thin)*(0.5*mask+0.5));
-  CrtsF1 pMidIn=pow(0.18,contrast);
-  ret.x=contrast;
-  ret.y=((-pMidIn)+midOut)/((1.0-pMidIn)*midOut);
-  ret.z=((-pMidIn)*midOut+pMidIn)/(midOut*(-pMidIn)+midOut);
-  ret.w=contrast+saturation;
-  return ret;}
-//_____________________________/\_______________________________
-//==============================================================
-//                            MASK
-//--------------------------------------------------------------
-// Letting LCD/OLED pixel elements function like CRT phosphors
-// So "phosphor" resolution scales with display resolution
-//--------------------------------------------------------------
-// Not applying any warp to the mask (want high frequency)
-// Real aperture grille has a mask which gets wider on ends
-// Not attempting to be "real" but instead look the best
-//--------------------------------------------------------------
-// Shadow mask is stretched horizontally
-//  RRGGBB
-//  GBBRRG
-//  RRGGBB
-// This tends to look better on LCDs than vertical
-// Also 2 pixel width is required to get triad centered
-//--------------------------------------------------------------
-// The LITE version of the Aperture Grille is brighter
-// Uses {dark,1.0,1.0} for R channel
-// Non LITE version uses {1.0,dark,dark}
-//--------------------------------------------------------------
-// 'pos' - This is 'fragCoord.xy'
-//         Pixel {0,0} should be {0.5,0.5}
-//         Pixel {1,1} should be {1.5,1.5} 
-//--------------------------------------------------------------
-// 'dark' - Exposure of of masked channel
-//          0.0=fully off, 1.0=no effect
-//==============================================================
- CrtsF3 CrtsMask(CrtsF2 pos,CrtsF1 dark){
-  if(MASK == 2.0){
-   CrtsF3 m=CrtsF3(dark,dark,dark);
-   CrtsF1 x=CrtsFractF1(pos.x*(1.0/3.0));
-   if(x<(1.0/3.0))m.r=1.0;
-   else if(x<(2.0/3.0))m.g=1.0;
-   else m.b=1.0;
-   return m;
-  }
-//--------------------------------------------------------------
-  if(MASK == 1.0){
-   CrtsF3 m=CrtsF3(1.0,1.0,1.0);
-   CrtsF1 x=CrtsFractF1(pos.x*(1.0/3.0));
-   if(x<(1.0/3.0))m.r=dark;
-   else if(x<(2.0/3.0))m.g=dark;
-   else m.b=dark;
-   return m;
-  }
-//--------------------------------------------------------------
-  if(MASK == 0.0){
-   return CrtsF3(1.0,1.0,1.0);
-  }
-//--------------------------------------------------------------
-  if(MASK == 3.0){
-   pos.x+=pos.y*2.9999;
-   CrtsF3 m=CrtsF3(dark,dark,dark);
-   CrtsF1 x=CrtsFractF1(pos.x*(1.0/6.0));
-   if(x<(1.0/3.0))m.r=1.0;
-   else if(x<(2.0/3.0))m.g=1.0;
-   else m.b=1.0;
-   return m;
-  }
- }
-//_____________________________/\_______________________________
-//==============================================================
-//                        FILTER ENTRY
-//--------------------------------------------------------------
-// Input must be linear
-// Output color is linear
-//--------------------------------------------------------------
-// Must have fetch function setup: CrtsF3 CrtsFetch(CrtsF2 uv)
-//  - The 'uv' range is {0.0 to 1.0} for input texture
-//  - Output of this must be linear color
-//--------------------------------------------------------------
-// SCANLINE MATH & AUTO-EXPOSURE NOTES
-// ===================================
-// Each output line has contribution from at most 2 scanlines
-// Scanlines are shaped by a windowed cosine function
-// This shape blends together well with only 2 lines of overlap
-//--------------------------------------------------------------
-// Base scanline intensity is as follows
-// which leaves output intensity range from {0 to 1.0}
-// --------
-// thin := range {thick 0.5 to thin 1.0}
-// off  := range {0.0 to <1.0}, 
-//         sub-pixel offset between two scanlines
-//  --------
-//  a0=cos(min(0.5,     off *thin)*2pi)*0.5+0.5;
-//  a1=cos(min(0.5,(1.0-off)*thin)*2pi)*0.5+0.5;
-//--------------------------------------------------------------
-// This leads to a image darkening factor of roughly: 
-//  {(1.5-thin)/1.0}
-// This is further reduced by the mask: 
-//  {1.0/2.0+mask*1.0/2.0}
-// Reciprocal of combined effect is used for auto-exposure
-//  to scale up the mid-level in the tonemapper
-//==============================================================
- CrtsF3 CrtsFilter(
-//--------------------------------------------------------------
-  // SV_POSITION, fragCoord.xy
-  CrtsF2 ipos,
-//--------------------------------------------------------------
-  // inputSize / outputSize (in pixels)
-  CrtsF2 inputSizeDivOutputSize,     
-//--------------------------------------------------------------
-  // 0.5 * inputSize (in pixels)
-  CrtsF2 halfInputSize,
-//--------------------------------------------------------------
-  // 1.0 / inputSize (in pixels)
-  CrtsF2 rcpInputSize,
-//--------------------------------------------------------------
-  // 1.0 / outputSize (in pixels)
-  CrtsF2 rcpOutputSize,
-//--------------------------------------------------------------
-  // 2.0 / outputSize (in pixels)
-  CrtsF2 twoDivOutputSize,   
-//--------------------------------------------------------------
-  // inputSize.y
-  CrtsF1 inputHeight,
-//--------------------------------------------------------------
-  // Warp scanlines but not phosphor mask
-  //  0.0 = no warp
-  //  1.0/64.0 = light warping
-  //  1.0/32.0 = more warping
-  // Want x and y warping to be different (based on aspect)
-  CrtsF2 warp,
-//--------------------------------------------------------------
-  // Scanline thinness
-  //  0.50 = fused scanlines
-  //  0.70 = recommended default
-  //  1.00 = thinner scanlines (too thin)
-  // Shared with CrtsTone() function
-  CrtsF1 thin,
-//--------------------------------------------------------------
-  // Horizonal scan blur
-  //  -3.0 = pixely
-  //  -2.5 = default
-  //  -2.0 = smooth
-  //  -1.0 = too blurry
-  CrtsF1 blur,
-//--------------------------------------------------------------
-  // Shadow mask effect, ranges from,
-  //  0.25 = large amount of mask (not recommended, too dark)
-  //  0.50 = recommended default
-  //  1.00 = no shadow mask
-  // Shared with CrtsTone() function
-  CrtsF1 mask,
-//--------------------------------------------------------------
-  // Tonal curve parameters generated by CrtsTone()
-  CrtsF4 tone
-//--------------------------------------------------------------
- ){
-//--------------------------------------------------------------
-  #ifdef CRTS_DEBUG
-   CrtsF2 uv=ipos*rcpOutputSize;
-   // Show second half processed, and first half un-processed
-   if(uv.x<0.5){
-    // Force nearest to get squares
-    uv*=1.0/rcpInputSize;
-    uv=floor(uv)+CrtsF2(0.5,0.5);
-    uv*=rcpInputSize;
-    CrtsF3 color=CrtsFetch(uv);
-    return color;}
-  #endif
-//--------------------------------------------------------------
-  // Optional apply warp
-  CrtsF2 pos;
-  #ifdef CRTS_WARP
-   // Convert to {-1 to 1} range
-   pos=ipos*twoDivOutputSize-CrtsF2(1.0,1.0);
-   // Distort pushes image outside {-1 to 1} range
-   pos*=CrtsF2(
-    1.0+(pos.y*pos.y)*warp.x,
-    1.0+(pos.x*pos.x)*warp.y);
-   // TODO: Vignette needs optimization
-   CrtsF1 vin=(1.0-(
-    (1.0-CrtsSatF1(pos.x*pos.x))*(1.0-CrtsSatF1(pos.y*pos.y)))) * (0.998 + (0.001 * CORNER));
-   vin=CrtsSatF1((-vin)*inputHeight+inputHeight);
-   // Leave in {0 to inputSize}
-   pos=pos*halfInputSize+halfInputSize;     
-  #else
-   pos=ipos*inputSizeDivOutputSize;
-  #endif
-//--------------------------------------------------------------
-  // Snap to center of first scanline
-  CrtsF1 y0=floor(pos.y-0.5)+0.5;
-  #ifdef CRTS_2_TAP
-   // Using Inigo's "Improved Texture Interpolation"
-   // http://iquilezles.org/www/articles/texture/texture.htm
-   pos.x+=0.5;
-   CrtsF1 xi=floor(pos.x);
-   CrtsF1 xf=pos.x-xi;
-   xf=xf*xf*xf*(xf*(xf*6.0-15.0)+10.0);  
-   CrtsF1 x0=xi+xf-0.5;
-   CrtsF2 p=CrtsF2(x0*rcpInputSize.x,y0*rcpInputSize.y);     
-   // Coordinate adjusted bilinear fetch from 2 nearest scanlines
-   CrtsF3 colA=CrtsFetch(p);
-   p.y+=rcpInputSize.y;
-   CrtsF3 colB=CrtsFetch(p);
-  #else
-   // Snap to center of one of four pixels
-   CrtsF1 x0=floor(pos.x-1.5)+0.5;
-   // Inital UV position
-   CrtsF2 p=CrtsF2(x0*rcpInputSize.x,y0*rcpInputSize.y);     
-   // Fetch 4 nearest texels from 2 nearest scanlines
-   CrtsF3 colA0=CrtsFetch(p);
-   p.x+=rcpInputSize.x;
-   CrtsF3 colA1=CrtsFetch(p);
-   p.x+=rcpInputSize.x;
-   CrtsF3 colA2=CrtsFetch(p);
-   p.x+=rcpInputSize.x;
-   CrtsF3 colA3=CrtsFetch(p);
-   p.y+=rcpInputSize.y;
-   CrtsF3 colB3=CrtsFetch(p);
-   p.x-=rcpInputSize.x;
-   CrtsF3 colB2=CrtsFetch(p);
-   p.x-=rcpInputSize.x;
-   CrtsF3 colB1=CrtsFetch(p);
-   p.x-=rcpInputSize.x;
-   CrtsF3 colB0=CrtsFetch(p);
-  #endif
-//--------------------------------------------------------------
-  // Vertical filter
-  // Scanline intensity is using sine wave
-  // Easy filter window and integral used later in exposure
-  CrtsF1 off=pos.y-y0;
-  CrtsF1 pi2=6.28318530717958;
-  CrtsF1 hlf=0.5;
-  CrtsF1 scanA=cos(min(0.5,  off *thin     )*pi2)*hlf+hlf;
-  CrtsF1 scanB=cos(min(0.5,(-off)*thin+thin)*pi2)*hlf+hlf;
-//--------------------------------------------------------------
-  #ifdef CRTS_2_TAP
-   #ifdef CRTS_WARP
-    // Get rid of wrong pixels on edge
-    scanA*=vin;
-    scanB*=vin;
-   #endif
-   // Apply vertical filter
-   CrtsF3 color=(colA*scanA)+(colB*scanB);
-  #else
-   // Horizontal kernel is simple gaussian filter
-   CrtsF1 off0=pos.x-x0;
-   CrtsF1 off1=off0-1.0;
-   CrtsF1 off2=off0-2.0;
-   CrtsF1 off3=off0-3.0;
-   CrtsF1 pix0=exp2(blur*off0*off0);
-   CrtsF1 pix1=exp2(blur*off1*off1);
-   CrtsF1 pix2=exp2(blur*off2*off2);
-   CrtsF1 pix3=exp2(blur*off3*off3);
-   CrtsF1 pixT=CrtsRcpF1(pix0+pix1+pix2+pix3);
-   #ifdef CRTS_WARP
-    // Get rid of wrong pixels on edge
-    pixT*=vin;
-   #endif
-   scanA*=pixT;
-   scanB*=pixT;
-   // Apply horizontal and vertical filters
-   CrtsF3 color=
-    (colA0*pix0+colA1*pix1+colA2*pix2+colA3*pix3)*scanA +
-    (colB0*pix0+colB1*pix1+colB2*pix2+colB3*pix3)*scanB;
-  #endif
-//--------------------------------------------------------------
-  // Apply phosphor mask          
-  color*=CrtsMask(ipos,mask);
-//--------------------------------------------------------------
-  // Optional color processing
-  #ifdef CRTS_TONE
-   // Tonal control, start by protecting from /0
-   CrtsF1 peak=max(1.0/(256.0*65536.0),
-    CrtsMax3F1(color.r,color.g,color.b));
-   // Compute the ratios of {R,G,B}
-   CrtsF3 ratio=color*CrtsRcpF1(peak);
-   // Apply tonal curve to peak value
-   #ifdef CRTS_CONTRAST
-    peak=pow(peak,tone.x);
-   #endif
-   peak=peak*CrtsRcpF1(peak*tone.y+tone.z);
-   // Apply saturation
-   #ifdef CRTS_SATURATION
-    ratio=pow(ratio,CrtsF3(tone.w,tone.w,tone.w));
-   #endif
-   // Reconstruct color
-   return ratio*peak;
- #else
-  return color;
- #endif
-//--------------------------------------------------------------
- }
-#endif
-
-void main() {
-   vec2 warp_factor;
-   warp_factor.x = CURVATURE;
-   warp_factor.y = (3.0 / 4.0) * warp_factor.x; // assume 4:3 aspect
-   warp_factor.x *= (1.0 - TRINITRON_CURVE);
-   FragColor.rgb = CrtsFilter(vTexCoord.xy * outputSize.xy,
-   sourceSize[0].xy * outputSize.zw,
-   sourceSize[0].xy * vec2(0.5,0.5),
-   sourceSize[0].zw,
-   outputSize.zw,
-   2.0 * outputSize.zw,
-   sourceSize[0].y,
-   warp_factor,
-   INPUT_THIN,
-   INPUT_BLUR,
-   INPUT_MASK,
-   CrtsTone(1.0,0.0,INPUT_THIN,INPUT_MASK));
-	
-   // Shadertoy outputs non-linear color
-   FragColor.rgb = ToSrgb(FragColor.rgb);
-}

ares/Shaders/CRT-Lottes2.shader/lottes.vs

@@ -1,16 +0,0 @@
-#version 150
-
-in vec4 position;
-in vec2 texCoord;
-
-out Vertex {
-   vec2 vTexCoord;
-};
-
-uniform vec4 targetSize;
-uniform vec4 sourceSize[];
-
-void main() {
-   gl_Position = position;
-   vTexCoord = texCoord;
-}

ares/Shaders/CRT-Lottes2.shader/manifest.bml

@@ -1,12 +0,0 @@
-input
-  filter: nearest
-
-program
-  filter: nearest
-  vertex: lottes.vs
-  fragment: lottes.fs
-  
-output
-  height: 0
-  width: 0
-  filter: linear

ares/Shaders/Curvature.shader/curvature.fs

@@ -1,21 +0,0 @@
-#version 150
-#define distortion 0.2
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-vec2 radialDistortion(vec2 coord) {
-  vec2 cc = coord - vec2(0.5);
-  float dist = dot(cc, cc) * distortion;
-  return coord + cc * (1.0 - dist) * dist;
-}
-
-void main() {
-  fragColor = texture(source[0], radialDistortion(texCoord));
-}

ares/Shaders/Curvature.shader/manifest.bml

@@ -1,4 +0,0 @@
-program
-  filter: linear
-  wrap: border
-  fragment: curvature.fs

ares/Shaders/Edge Detection.shader/edge-detection.fs

@@ -1,25 +0,0 @@
-#version 150
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-vec3 grayscale(vec3 color) {
-  return vec3(dot(color, vec3(0.3, 0.59, 0.11)));
-}
-
-void main() {
-  vec2 offset = fract(texCoord * sourceSize[0].xy) - 0.5;
-  offset /= sourceSize[0].xy;
-
-  vec3 cx = texture(source[0], texCoord - offset).xyz;
-  vec3 cy = texture(source[0], texCoord).xyz;
-  vec3 cz = vec3(5.0 * grayscale(abs(cx - cy)));
-
-  fragColor = vec4(clamp(cz, 0.0, 1.0), 1.0);
-}

ares/Shaders/Edge Detection.shader/manifest.bml

@@ -1,4 +0,0 @@
-program
-  filter: linear
-  wrap: edge
-  fragment: edge-detection.fs

ares/Shaders/GritsScanlines.shader/GritsScanlines.fs

@@ -1,99 +0,0 @@
-#version 150
-
-// GritsScanlines by torridgristle
-// license: public domain (https://forums.libretro.com/t/lightweight-lut-based-scanline-glow-concept-prototype-glsl/18336/7)
-
-/* Runtime parameters
-#in LuminanceDawnbringer
-#in LuminanceLUT
-#in ScanlinesOpacity
-#in GammaCorrection
-#in TrinitronColors
-*/
-
-// static parameters
-//#define LuminanceDawnbringer
-#define LuminanceLUT
-//#define TrinitronColors
-#define ScanlinesOpacity 0.9
-//#define GammaCorrection 1.2
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform vec4 targetSize;
-uniform sampler2D pixmap[];
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-#ifdef LuminanceLUT
-#define LUT_SizeLum 16.0
-
-	// Code taken from RetroArch's LUT shader
-float luminancelut(vec4 org)
-{
-	vec4 imgColorLum = org;
-	float redLum = ( imgColorLum.r * (LUT_SizeLum - 1.0) + 0.4999 ) / (LUT_SizeLum * LUT_SizeLum);
-	float greenLum = ( imgColorLum.g * (LUT_SizeLum - 1.0) + 0.4999 ) / LUT_SizeLum;
-	float blue1Lum = (floor( imgColorLum.b  * (LUT_SizeLum - 1.0) ) / LUT_SizeLum) + redLum;
-	float blue2Lum = (ceil( imgColorLum.b  * (LUT_SizeLum - 1.0) ) / LUT_SizeLum) + redLum;
-	float mixerLum = clamp(max((imgColorLum.b - blue1Lum) / (blue2Lum - blue1Lum), 0.0), 0.0, 32.0);
-	float color1Lum = texture(pixmap[1], vec2( blue1Lum, greenLum )).x;
-	float color2Lum = texture(pixmap[1], vec2( blue2Lum, greenLum )).x;
-	return mix(color1Lum, color2Lum, mixerLum);
-}
-#endif
-
-#ifdef TrinitronColors
-#define LUT_SizeTrinitron 32.0
-
-vec4 TrinitronD50(vec4 org)
-{
-	vec4 imgColorTrinitron = org;
-	float redTrinitron = ( imgColorTrinitron.r * (LUT_SizeTrinitron - 1.0) + 0.4999 ) / (LUT_SizeTrinitron * LUT_SizeTrinitron);
-	float greenTrinitron = ( imgColorTrinitron.g * (LUT_SizeTrinitron - 1.0) + 0.4999 ) / LUT_SizeTrinitron;
-	float blue1Trinitron = (floor( imgColorTrinitron.b  * (LUT_SizeTrinitron - 1.0) ) / LUT_SizeTrinitron) + redTrinitron;
-	float blue2Trinitron = (ceil( imgColorTrinitron.b  * (LUT_SizeTrinitron - 1.0) ) / LUT_SizeTrinitron) + redTrinitron;
-	float mixerTrinitron = clamp(max((imgColorTrinitron.b - blue1Trinitron) / (blue2Trinitron - blue1Trinitron), 0.0), 0.0, 32.0);
-	vec4 color1Trinitron = texture(pixmap[2], vec2( blue1Trinitron, greenTrinitron ));
-	vec4 color2Trinitron = texture(pixmap[2], vec2( blue2Trinitron, greenTrinitron ));
-	vec4 fragColorTrinitron = mix(color1Trinitron, color2Trinitron, mixerTrinitron);
-	return vec4(pow(fragColorTrinitron.rgb,vec3(GammaCorrection,GammaCorrection,GammaCorrection)),1.0);
-} 
-#endif
-
-void main() {
-
-//Source Image
-	vec4 org = texture(source[0], texCoord);
-   
-#ifdef LuminanceLUT
-// Use a 3DLUT instead of an equation so that it can use any arbitrary mess you can come up with.
-	float luminance = luminancelut(org);
-#elif defined LuminanceDawnbringer
-// Dawnbringer's brightness equation from Dawnbringer's Toolbox scripts for Grafx2
-	float luminance = sqrt(org.r*org.r*0.0676 + org.g*org.g*0.3025 + org.b*org.b*0.0361) * 1.5690256395005606;
-#else
-// Plain, standard, fine; slightly faster
-	float luminance = ((0.299*org.r) + (0.587*org.g) + (0.114*org.b));
-#endif
-
-// Don't let it exceed 1.0
-	luminance = clamp(luminance, 0.0, 1.0);
-
-// Scanline Mapping, based on the Phosphor LUT shader's method of tiling a texture over the screen
-	vec2 LUTeffectiveCoord = vec2(luminance,fract((texCoord.y*targetSize.y)/4.0));
-
-// Scanline Layer
-	vec4 screen = texture(pixmap[0], LUTeffectiveCoord);
-
-// Output multiplying the scanlines into the original image, with control over opacity
-#ifdef TrinitronColors
-	org = TrinitronD50(org);
-#endif
-	fragColor = ((screen*ScanlinesOpacity)+(1.0 - ScanlinesOpacity)) * (org);
-}
-

ares/Shaders/GritsScanlines.shader/manifest.bml

@@ -1,35 +0,0 @@
-settings
-  LuminanceDawnbringer
-    active: false
-  LuminanceLUT
-    active: false
-  TrinitronColors
-    active: true
-  ScanlinesOpacity: 0.9
-    min: 0.0
-    max: 1.0
-    step: 0.05
-  GammaCorrection: 1.2
-    min: 0.5
-    max: 2.0
-    step: 0.1
-
-
-program
-  filter: nearest
-  wrap: edge
-  width: 100%
-  height: 400%
-  fragment: GritsScanlines.fs
-  pixmap: Scanline-LUT-4px.png
-    filter: linear
-    wrap: edge
-  pixmap: Fake-Self-Illumination.png
-    filter: linear
-    wrap: edge
-  pixmap: Trinitron D50 Absolute Colorimetric - LUT.png
-    filter: linear
-    wrap: edge
-
-output1
-  filter: linear

ares/Shaders/Interlacing.shader/interlace.fs

@@ -1,39 +0,0 @@
-#version 150
-
-/*
-   Interlacing
-   Author: hunterk
-   License: Public domain
-   
-   Note: This shader is designed to work with the typical interlaced output from an emulator, which displays both even and odd fields twice.
-   This shader will un-weave the image, resulting in a standard, alternating-field interlacing.
-*/
-
-uniform sampler2D source[];
-uniform vec2 targetSize;
-uniform vec4 sourceSize[];
-uniform int phase;
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-// This controls how bright the intermediate lines are; 0.0 = totally black
-#define percent 0.0
-
-void main()
-{
-vec4 res = texture(source[0], texCoord);
-   float y = 0.0;
-
-   // assume anything with a vertical resolution greater than 400 lines is interlaced
-   if (sourceSize[0].y > 400.0) y = sourceSize[0].y * texCoord.y + phase;
-   else
-      y = 2.00001 * sourceSize[0].y * texCoord.y;
-
-   if (mod(y, 2.0) > 0.99999) fragColor = res;
-   else
-      fragColor = vec4(percent) * res;
-}

ares/Shaders/Interlacing.shader/manifest.bml

@@ -1,6 +0,0 @@
-input
-  filter: nearest
-
-program
-  fragment: interlace.fs
-  modulo: 2

ares/Shaders/PAL-r57shell.shader/manifest.bml

@@ -1,11 +0,0 @@
-input
-  filter: nearest
-
-program
-  filter: nearest
-  height: 100%
-  fragment: pal-r57shell.fs
-  
-output
-  height: 0
-  filter: linear

ares/Shaders/PAL-r57shell.shader/pal-r57shell.fs

@@ -1,368 +0,0 @@
-#version 150
-
-// NES PAL composite signal simulation for RetroArch
-// shader by r57shell
-// thanks to feos & HardWareMan & NewRisingSun
-
-// also TV subpixels and scanlines
-
-// LICENSE: PUBLIC DOMAIN
-
-// NOTE: for nice TV subpixels and scanlines I recommend to
-// disable this features here and apply CRT-specialized shader.
-
-// Quality considerations
-
-// there are three main options:
-// USE_RAW (R), USE_DELAY_LINE (D), USE_COLORIMETRY (C)
-// here is table of quality in decreasing order:
-// RDC, RD, RC, DC, D, C
-
-// compatibility macros
-#define float2 vec2
-#define float3 vec3
-#define float4 vec4
-#define frac(c) fract(c)
-#define saturate(c) clamp(c, 0.0, 1.0)
-#define fmod(x,y) mod(x,y)
-#define mul(x,y) (y*x)
-#define float2x2 mat2
-#define float3x3 mat3
-#define float4x4 mat4
-#define bool2 bvec2
-#define bool3 bvec3
-#define bool4 bvec4
-#define static 
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform vec4 outputSize;
-uniform int phase;
-
-in Vertex {
-   vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-// TWEAKS start
-
-// use delay line technique
-// without delay line technique, color would interleave
-// to avoid this, set HueRotation to zero.
-#define USE_DELAY_LINE
-
-// use this if you need to swap even/odd V sign.
-// sign of V changes each scanline
-// so if some scanline is positive, then next is negative
-// and if you want to match picture
-// to actual running PAL NES on TV
-// you may want to have this option, to change signs
-// if they don't match
-//#define SWAP_VSIGN
-
-// rough simulation of scanlines
-// better if you use additional shader instead
-// if you still use it, make sure that SizeY
-// is at least twice lower than output height
-#define USE_SCANLINES // FIXME: scanlines are broken and I'm too lazy to fix it right now
-
-// to change gamma of virtual TV from 2.2 to something else
-#define USE_GAMMA
-
-// use sampled version. it's much more slower version of shader.
-// because it is computing x4 more values. NOT RECOMMENDED.
-//#define USE_SAMPLED
-
-#ifndef PARAMETER_UNIFORM
-// NTSC standard gamma = 2.2
-// PAL standard gamma = 2.8
-// according to many sources, very unlikely gamma of TV is 2.8
-// most likely gamma of PAL TV is in range 2.4-2.5
-const float Gamma_static = 2.8; // gamma of virtual TV
-
-const float Brightness_static = 0.25;
-const float Contrast_static = 1.1;
-const float Saturation_static = 1.1;
-
-const int
-	Ywidth_static = 12,
-	Uwidth_static = 23,
-	Vwidth_static = 23;
-   
-#define Brightness Brightness_static
-#define Gamma Gamma_static
-
-#define Ywidth Ywidth_static
-#define Uwidth Uwidth_static
-#define Vwidth Vwidth_static
-
-#define SCANLINE_MUL (sw.x*dark_scanline+sw.y)
-
-int Mwidth = int(max(float(Ywidth), max(float(Uwidth), float(Vwidth))));
-
-// correct one is -2.5
-// works only with USE_RAW
-const float HueShift = -2.5;
-
-// rotation of hue due to luma level.
-const float HueRotation = 2.;
-
-// touch this only if you know what you doing
-const float Phase_Y = 2.; // fmod(341*10,12)
-const float Phase_One = 0.; // alternating phases.
-const float Phase_Two = 8.;
-
-// screen size, scanlines = y*2; y one field, and y other field.
-const int SizeX = 256;
-const int SizeY = 240;
-
-// count of pixels of virtual TV.
-// value close to 1000 produce small artifacts
-const int TV_Pixels = 400;
-
-const float dark_scanline = 0.5; // half
-#endif
-
-// this is using following matrixes.
-// it provides more scientific approach
-// by conversion into linear XYZ space
-// and back to sRGB.
-// it's using Gamma setting too.
-// define USE_GAMMA is not required.
-#define USE_COLORIMETRY
-
-const float3x3 RGB_to_XYZ =
-mat3(
-	0.4306190, 0.3415419, 0.1783091,
-	0.2220379, 0.7066384, 0.0713236,
-	0.0201853, 0.1295504, 0.9390944
-);
-
-const float3x3 XYZ_to_sRGB =
-mat3(
-	 3.2406, -1.5372, -0.4986,
-	-0.9689,  1.8758,  0.0415,
-	 0.0557, -0.2040,  1.0570
-);
-
-// TWEAKS end
-
-const float YUV_u = 0.492;
-const float YUV_v = 0.877;
-
-const mat3 RGB_to_YUV =
-mat3(
-	float3( 0.299, 0.587, 0.114), //Y
-	float3(-0.299,-0.587, 0.886)*YUV_u, //B-Y
-	float3( 0.701,-0.587,-0.114)*YUV_v //R-Y
-);
-
-#ifdef USE_DELAY_LINE
-const float comb_line = 1.;
-#else
-const float comb_line = 2.;
-#endif
-
-static const float Voltage_0 = 0.518;
-static const float Voltage_1 = 1.962;
-static const float DeltaV = (Voltage_1-Voltage_0);
-
-float RGB_y = Contrast_static/Ywidth_static/DeltaV;
-float RGB_u = comb_line*Contrast_static*Saturation_static/YUV_u/Uwidth_static/DeltaV;
-float RGB_v = comb_line*Contrast_static*Saturation_static/YUV_v/Vwidth_static/DeltaV;
-
-mat3 YUV_to_RGB =
-mat3(
-	float3(1., 1., 1.)*RGB_y,
-	float3(0., -0.114/0.587, 1.)*RGB_u,
-	float3(1., -0.299/0.587, 0.)*RGB_v
-);
-
-const float pi = 3.1415926535897932384626433832795;
-
-float sinn(float x)
-{
-	return sin(/*fmod(x,24)*/x*(pi*2./24.));
-}
-
-float coss(float x)
-{
-	return cos(/*fmod(x,24)*/x*(pi*2./24.));
-}
-
-float3 monitor(sampler2D tex, float2 p)
-{
-   float2 size = sourceSize[0].xy;//float2(SizeX,SizeY);
-	// align vertical coord to center of texel
-	float2 uv = float2(
-
-		p.x,
-
-		(floor(p.y*sourceSize[0].y)+0.5)/sourceSize[0].y);
-#ifdef USE_DELAY_LINE
-	float2 sh = (sourceSize[0].xy/sourceSize[0].xy/size)*float2(14./10.,-1.0);
-#endif
-	float2 pc = uv*sourceSize[0].xy/sourceSize[0].xy*size*float2(10.,1.);
-	float alpha = dot(floor(float2(pc.x,pc.y)),float2(2.,Phase_Y*2.));
-	alpha += Phase_One*2.;
-
-	// 1/size.x of screen in uv coords = sourceSize[0].x/sourceSize[0].x/size.x;
-	// then 1/10*size.x of screen:
-	float ustep = sourceSize[0].x/sourceSize[0].x/size.x/10.;
-
-	float border = sourceSize[0].x/sourceSize[0].x;
-	float ss = 2.0;
-#ifdef SWAP_VSIGN
-#define PAL_SWITCH(A) A < 1.
-#else
-#define PAL_SWITCH(A) A > 1.
-#endif
-	if (PAL_SWITCH(fmod(uv.y*sourceSize[0].y/sourceSize[0].y*size.y,2.0)))
-	{
-		// cos(pi-alpha) = -cos(alpha)
-		// sin(pi-alpha) = sin(alpha)
-		// pi - alpha
-		alpha = -alpha+12012.0;
-		ss = -2.0;
-	}
-   
-	float ysum = 0., usum = 0., vsum = 0.;
-	for (int i=0; i<Mwidth; ++i)
-	{
-		float4 res = texture(tex, uv);
-      float3 yuv = mul(RGB_to_YUV, res.xyz);
-		float a1 = alpha+(HueShift+2.5)*2.-yuv.x*ss*HueRotation;
-		float sig = yuv.x+dot(yuv.yz,sign(float2(sinn(a1),coss(a1))));
-#ifdef USE_DELAY_LINE
-		float4 res1 = texture(tex, uv+sh);
-		float3 yuv1 = mul(RGB_to_YUV, res1.xyz);
-		float a2 = (HueShift+2.5)*2.+12012.0-alpha+yuv.x*ss*HueRotation;
-		float sig1 = yuv1.x+dot(yuv1.yz,sign(float2(sinn(a2),coss(a2))));
-#endif
-		if (i < Ywidth)
-			ysum += sig;
-
-#ifdef USE_DELAY_LINE
-		if (i < Uwidth)
-			usum += (sig+sig1)*sinn(alpha);
-		if (i < Vwidth)
-			vsum += (sig-sig1)*coss(alpha);
-#else
-		if (i < Uwidth)
-			usum += sig*sinn(alpha);
-		if (i < Vwidth)
-			vsum += sig*coss(alpha);
-#endif
-		alpha -= ss;
-		uv.x -= ustep;
-	}
-   
-	float3 rgb = mul(float3(ysum+Brightness*Ywidth_static,usum,vsum), YUV_to_RGB);
-#if defined(USE_GAMMA) && !defined(USE_COLORIMETRY)
-	float3 rgb1 = saturate(rgb);
-	rgb = pow(rgb1, Gamma/2.2);
-#endif
-
-#ifdef USE_COLORIMETRY
-	float3 rgb1 = saturate(rgb);
-	rgb = pow(rgb1, float3(Gamma, Gamma, Gamma));
-#endif
-
-#if (defined(USE_SCANLINES))
-	float2 q = (p*sourceSize[0].xy/sourceSize[0].xy)*float2(TV_Pixels*3.,size.y*2.);
-#endif
-
-#ifdef USE_SCANLINES
-	float scanlines = size.y * outputSize.z;
-	float top = fmod(q.y-0.5*scanlines*2.,2.);
-	float bottom = top+frac(scanlines)*2.;
-	float2 sw = saturate(min(float2(1.,2.),float2(bottom, bottom))
-		-max(float2(0.,1.),float2(top)))
-		+saturate(min(float2(3.,4.),float2(bottom, bottom))
-		-max(float2(2.,3.),float2(top)))
-		+floor(scanlines);
-
-	rgb = rgb*SCANLINE_MUL/(sw.x+sw.y);
-   
-   /*
-	//old stupid method
-	float z =
-#ifdef ANIMATE_SCANLINE
-	fmod(phase,2.0)+
-#endif
-		0.5;
-
-	if (abs(fmod(q.y+0.5,2)-z)<0.5)
-		rgb *= dark_scanline;
-*/
-#endif
-
-	// size of pixel screen in texture coords:
-	//float output_pixel_size = sourceSize[0].x/(outputSize.x*sourceSize[0].x);
-
-	// correctness check
-	//if (fmod(p.x*output_pixel_size,2.0) < 1.0)
-	//	rgb = float3(0.,0.,0.);
-
-#ifdef USE_COLORIMETRY
-	float3 xyz1 = mul(RGB_to_XYZ,rgb);
-	float3 srgb = saturate(mul(XYZ_to_sRGB,xyz1));
-	float3 a1 = 12.92*srgb;
-	float3 a2 = 1.055*pow(srgb,float3(1./2.4))-0.055;
-	float3 ssrgb;
-   ssrgb.x = (srgb.x<0.0031308?a1.x:a2.x);
-   ssrgb.y = (srgb.y<0.0031308?a1.y:a2.y);
-   ssrgb.z = (srgb.z<0.0031308?a1.z:a2.z);
-	return ssrgb;
-#else
-	return rgb;
-#endif
-}
-
-// pos (left corner, sample size)
-float4 monitor_sample(sampler2D tex, float2 p, float2 sample_)
-{
-	// linear interpolation was...
-	// now other thing.
-	// http://imgur.com/m8Z8trV
-	// AT LAST IT WORKS!!!!
-	// going to check in retroarch...
-	float2 size = sourceSize[0].xy;
-	float2 next = float2(.25,1.)/size;
-	float2 f = frac(float2(4.,1.)*size*p);
-	sample_ *= float2(4.,1.)*size;
-	float2 l;
-	float2 r;
-	if (f.x+sample_.x < 1.)
-	{
-		l.x = f.x+sample_.x;
-		r.x = 0.;
-	}
-	else
-	{
-		l.x = 1.-f.x;
-		r.x = min(1.,f.x+sample_.x-1.);
-	}
-	if (f.y+sample_.y < 1.)
-	{
-		l.y = f.y+sample_.y;
-		r.y = 0.;
-	}
-	else
-	{
-		l.y = 1.-f.y;
-		r.y = min(1.,f.y+sample_.y-1.);
-	}
-	float3 top = mix(monitor(tex, p), monitor(tex, p+float2(next.x,0.)), r.x/(l.x+r.x));
-	float3 bottom = mix(monitor(tex, p+float2(0.,next.y)), monitor(tex, p+next), r.x/(l.x+r.x));
-	return float4(mix(top,bottom, r.y/(l.y+r.y)),1.0);
-}
-
-void main() {
-#ifdef USE_SAMPLED
-	fragColor = vec4(monitor_sample(source[0], texCoord, outputSize.zw).rgb, 1.0);
-#else
-	fragColor = float4(monitor(source[0], texCoord), 1.);
-#endif
-}

ares/Shaders/Phosphorish.shader/manifest.bml

@@ -1,2 +0,0 @@
-program
-  fragment: phosphorish.fs

ares/Shaders/Phosphorish.shader/phosphorish.fs

@@ -1,56 +0,0 @@
-/*    Phosphorish
-
-    Copyright (C) 2011 Themaister
-
-    This program is licensed in the public domain
-*/
-
-#version 150
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform vec4 targetSize;
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-      vec3 to_focus(float pixel)
-      {
-         pixel = mod(pixel + 3.0, 3.0);
-         if (pixel >= 2.0) // Blue
-            return vec3(pixel - 2.0, 0.0, 3.0 - pixel);
-         else if (pixel >= 1.0) // Green
-            return vec3(0.0, 2.0 - pixel, pixel - 1.0);
-         else // Red
-            return vec3(1.0 - pixel, pixel, 0.0);
-      }
-
-      void main()
-      {
-         float y = mod(texCoord.y * sourceSize[0].y, 1.0);
-         float intensity = exp(-0.2 * y);
-
-         vec2 one_x = vec2(1.0 / (3.0 * sourceSize[0].x), 0.0);
-
-         vec3 color = texture(source[0], texCoord.xy - 0.0 * one_x).rgb;
-         vec3 color_prev = texture(source[0], texCoord.xy - 1.0 * one_x).rgb;
-         vec3 color_prev_prev = texture(source[0], texCoord.xy - 2.0 * one_x).rgb;
-
-         float pixel_x = 3.0 * texCoord.x * sourceSize[0].x;
-
-         vec3 focus = to_focus(pixel_x - 0.0);
-         vec3 focus_prev = to_focus(pixel_x - 1.0);
-         vec3 focus_prev_prev = to_focus(pixel_x - 2.0);
-
-         vec3 result =
-            0.8 * color * focus +
-            0.6 * color_prev * focus_prev +
-            0.3 * color_prev_prev * focus_prev_prev;
-
-         result = 2.3 * pow(result, vec3(1.4));
-
-         fragColor = vec4(intensity * result, 1.0);
-      }

ares/Shaders/Scanline.shader/manifest.bml

@@ -1,4 +0,0 @@
-program
-  filter: linear
-  wrap: border
-  fragment: scanline.fs

ares/Shaders/Scanline.shader/scanline.fs

@@ -1,20 +0,0 @@
-#version 150
-
-uniform sampler2D source[];
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-void main() {
-  vec4 rgba = texture(source[0], texCoord);
-  vec4 intensity;
-  if(fract(gl_FragCoord.y * (0.5 * 4.0 / 3.0)) > 0.5) {
-    intensity = vec4(0);
-  } else {
-    intensity = smoothstep(0.2, 0.8, rgba) + normalize(rgba);
-  }
-  fragColor = intensity * -0.25 + rgba * 1.1;
-}

ares/Shaders/Sharp-Bilinear.shader/manifest.bml

@@ -1,8 +0,0 @@
-input
-  filter: linear
-
-program
-  fragment: sharp-bilinear.fs
-  
-output
-  filter: linear

ares/Shaders/Sharp-Bilinear.shader/sharp-bilinear.fs

@@ -1,33 +0,0 @@
-#version 150
-
-// Sharp Bilinear
-// Author: Themaister
-// License: Public Domain
-
-uniform sampler2D source[];
-uniform vec4 sourceSize[];
-uniform vec4 targetSize;
-
-in Vertex {
-  vec2 texCoord;
-};
-
-out vec4 fragColor;
-
-void main() {
-float prescale = floor(targetSize.y / sourceSize[0].y);
-   vec2 texel = texCoord.xy * sourceSize[0].xy;
-   vec2 texel_floored = floor(texel);
-   vec2 s = fract(texel);
-   float region_range = 0.5 - 0.5 / prescale;
-
-   // Figure out where in the texel to sample to get correct pre-scaled bilinear.
-   // Uses the hardware bilinear interpolator to avoid having to sample 4 times manually.
-
-   vec2 center_dist = s - 0.5;
-   vec2 f = (center_dist - clamp(center_dist, -region_range, region_range)) * prescale + 0.5;
-
-   vec2 mod_texel = texel_floored + f;
-    
-   fragColor = texture(source[0], mod_texel / sourceSize[0].xy);;
-}

ares/System/MSX/Keyboard/Japanese/layout.bml

@@ -1,122 +0,0 @@
-layout
-  name: Japanese
-
-  //row 0
-  key: 0 わ を
-  key: 1 ! ぬ
-  key: 2 " ふ
-  key: 3 # あ ぁ
-  key: 4 $ う ぅ
-  key: 5 % え ぇ
-  key: 6 & お ぉ
-  key: 7 ’ や ゃ
-
-  //row 1
-  key: 8 ( ゆ ゅ
-  key: 9 ) よ ょ
-  key: - = ほ
-  key: ^ ~ へ
-  key: ¥ | ー
-  key: @ ‘ "
-  key: [ { 。
-  key: ; + れ
-
-  //row 2
-  key: : * け
-  key: ] } む
-  key: , < ね `
-  key: . > る 。
-  key: / ? め .
-  key: - ろ
-  key: A ち
-  key: B こ
-
-  //row 3
-  key: C そ
-  key: D し
-  key: E い ぃ
-  key: F は
-  key: G き
-  key: H く
-  key: I に
-  key: J ま
-
-  //row 4
-  key: K の
-  key: L り
-  key: M も
-  key: N み
-  key: O ら
-  key: P せ
-  key: Q た
-  key: R す
-
-  //row 5
-  key: S と
-  key: T か
-  key: U な
-  key: V ひ
-  key: W て
-  key: X さ
-  key: Y ん
-  key: Z つ っ
-
-  //row 6
-  key: SHIFT
-  key: CTRL
-  key: GRAPH
-  key: CAPS
-  key: かな
-  key: F1 F6
-  key: F2 F7
-  key: F3 F8
-
-  //row 7
-  key: F4 F9
-  key: F5 F10
-  key: ESC
-  key: TAB
-  key: STOP
-  key: BS
-  key: SELECT
-  key: RETURN
-
-  //row 8
-  key: SPACE
-  key: CLS/HOME
-  key: INS
-  key: DEL
-  key: ←
-  key: ↑
-  key: ↓
-  key: →
-
-  //row 9
-  key: *
-  key: +
-  key: /
-  key: 0
-  key: 1
-  key: 2
-  key: 3
-  key: 4
-
-  //row 10
-  key: 5
-  key: 6
-  key: 7
-  key: 8
-  key: 9
-  key: -
-  key: ,
-  key: .
-
-  //row 11
-  key:
-  key: 実行
-  key:
-  key: 取消
-  key:
-  key:
-  key:
-  key:

ares/System/MSX2/Keyboard/Japanese/layout.bml

@@ -1,122 +0,0 @@
-layout
-  name: Japanese
-
-  //row 0
-  key: 0 わ を
-  key: 1 ! ぬ
-  key: 2 " ふ
-  key: 3 # あ ぁ
-  key: 4 $ う ぅ
-  key: 5 % え ぇ
-  key: 6 & お ぉ
-  key: 7 ’ や ゃ
-
-  //row 1
-  key: 8 ( ゆ ゅ
-  key: 9 ) よ ょ
-  key: - = ほ
-  key: ^ ~ へ
-  key: ¥ | ー
-  key: @ ‘ "
-  key: [ { 。
-  key: ; + れ
-
-  //row 2
-  key: : * け
-  key: ] } む
-  key: , < ね `
-  key: . > る 。
-  key: / ? め .
-  key: - ろ
-  key: A ち
-  key: B こ
-
-  //row 3
-  key: C そ
-  key: D し
-  key: E い ぃ
-  key: F は
-  key: G き
-  key: H く
-  key: I に
-  key: J ま
-
-  //row 4
-  key: K の
-  key: L り
-  key: M も
-  key: N み
-  key: O ら
-  key: P せ
-  key: Q た
-  key: R す
-
-  //row 5
-  key: S と
-  key: T か
-  key: U な
-  key: V ひ
-  key: W て
-  key: X さ
-  key: Y ん
-  key: Z つ っ
-
-  //row 6
-  key: SHIFT
-  key: CTRL
-  key: GRAPH
-  key: CAPS
-  key: かな
-  key: F1 F6
-  key: F2 F7
-  key: F3 F8
-
-  //row 7
-  key: F4 F9
-  key: F5 F10
-  key: ESC
-  key: TAB
-  key: STOP
-  key: BS
-  key: SELECT
-  key: RETURN
-
-  //row 8
-  key: SPACE
-  key: CLS/HOME
-  key: INS
-  key: DEL
-  key: ←
-  key: ↑
-  key: ↓
-  key: →
-
-  //row 9
-  key: *
-  key: +
-  key: /
-  key: 0
-  key: 1
-  key: 2
-  key: 3
-  key: 4
-
-  //row 10
-  key: 5
-  key: 6
-  key: 7
-  key: 8
-  key: 9
-  key: -
-  key: ,
-  key: .
-
-  //row 11
-  key:
-  key: 実行
-  key:
-  key: 取消
-  key:
-  key:
-  key:
-  key:

ares/System/Super Famicom/boards.bml

@@ -1,970 +0,0 @@
-database
-  revision: 2020-11-09
-
-//Boards (Production)
-
-database
-  revision: 2020-01-21
-
-board: BANDAI-PT-923
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  slot type=SufamiTurbo
-    rom
-      map address=20-3f,a0-bf:8000-ffff mask=0x8000
-    ram
-      map address=60-6f,e0-ef:0000-ffff
-  slot type=SufamiTurbo
-    rom
-      map address=40-5f,c0-df:0000-ffff mask=0x8000
-    ram
-      map address=70-7d,f0-ff:0000-ffff
-
-board: BSC-1A5B9P-01
-  memory type=RAM content=Save
-    map address=10-17:5000-5fff mask=0xf000
-  processor identifier=MCC
-    map address=00-0f:5000-5fff
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=40-7d,c0-ff:0000-ffff
-      map address=20-3f,a0-bf:6000-7fff
-      memory type=ROM content=Program
-      memory type=RAM content=Download
-      slot type=BSMemory
-
-board: BSC-1A5M-02
-  memory type=ROM content=Program
-    map address=00-1f:8000-ffff mask=0xe08000 base=0x000000
-    map address=20-3f:8000-ffff mask=0xe08000 base=0x100000
-    map address=80-9f:8000-ffff mask=0xe08000 base=0x200000
-    map address=a0-bf:8000-ffff mask=0xe08000 base=0x100000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-  slot type=BSMemory
-    map address=c0-ef:0000-ffff
-
-board: BSC-1A7M-(01,10)
-  memory type=ROM content=Program
-    map address=00-1f:8000-ffff mask=0xe08000 base=0x000000
-    map address=20-3f:8000-ffff mask=0xe08000 base=0x100000
-    map address=80-9f:8000-ffff mask=0xe08000 base=0x200000
-    map address=a0-bf:8000-ffff mask=0xe08000 base=0x100000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-  slot type=BSMemory
-    map address=c0-ef:0000-ffff
-
-board: BSC-1J3M-01
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff
-    map address=40-5f,c0-df:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  slot type=BSMemory
-    map address=20-3f,a0-bf:8000-ffff
-    map address=60-7d,e0-ff:0000-ffff
-
-board: BSC-1J5M-01
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff
-    map address=40-5f,c0-df:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  slot type=BSMemory
-    map address=20-3f,a0-bf:8000-ffff
-    map address=60-7d,e0-ff:0000-ffff
-
-board: BSC-1L3B-01
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-      slot type=BSMemory
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: BSC-1L5B-01
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-      slot type=BSMemory
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: SGB-R-10
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-  processor identifier=ICD revision=2
-    map address=00-3f,80-bf:6000-67ff,7000-7fff
-    memory type=ROM content=Boot architecture=SM83
-    slot type=GameBoy
-
-board: SHVC-1A0N-(01,02,10,20,30)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-
-board: SHVC-1A1B-(04,05,06)
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff
-
-board: SHVC-1A1M-(01,10,11,20)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-1A3B-(11,12,13)
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff
-
-board: SHVC-1A3B-20
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-1A3M-(10,20,21,30)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-1A5B-(02,04)
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff
-
-board: SHVC-1A5M-(01,11,20)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-1B0N-(02,03,10)
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  processor architecture=uPD7725
-    map address=30-3f,b0-bf:8000-ffff mask=0x3fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: SHVC-1B5B-02
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff
-  processor architecture=uPD7725
-    map address=20-3f,a0-bf:8000-ffff mask=0x3fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: SHVC-1C0N
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-1f,80-9f:8000-ffff mask=0x8000
-    memory type=RAM content=Save
-      map address=60-7d,e0-ff:0000-ffff
-
-board: SHVC-1C0N5S-01
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-1f,80-9f:8000-ffff mask=0x8000
-    memory type=RAM content=Save
-      map address=60-7d,e0-ff:0000-ffff
-
-board: SHVC-1CA0N5S-01
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-      map address=40-5f,c0-df:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71,f0-f1:0000-ffff
-
-board: SHVC-1CA0N6S-01
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-      map address=40-5f,c0-df:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71,f0-f1:0000-ffff
-
-board: SHVC-1CA6B-01
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-      map address=40-5f,c0-df:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71,f0-f1:0000-ffff
-
-board: SHVC-1CB0N7S-01
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f:8000-ffff mask=0x8000
-      map address=40-5f:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71:0000-ffff
-
-board: SHVC-1CB5B-(01,20)
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f:8000-ffff mask=0x8000
-      map address=40-5f:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71:0000-ffff
-
-board: SHVC-1CB7B-01
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f:8000-ffff mask=0x8000
-      map address=40-5f:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71:0000-ffff
-
-board: SHVC-1DC0N-01
-  processor architecture=HG51BS169
-    map address=00-3f,80-bf:6c00-6fff,7c00-7fff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-    memory type=RAM content=Save
-      map address=70-77:0000-7fff
-    memory type=ROM content=Data architecture=HG51BS169
-    memory type=RAM content=Data architecture=HG51BS169
-      map address=00-3f,80-bf:6000-6bff,7000-7bff mask=0xf000
-    oscillator
-
-board: SHVC-1DS0B-20
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  processor architecture=uPD96050
-    map address=60-67,e0-e7:0000-3fff
-    memory type=ROM content=Program architecture=uPD96050
-    memory type=ROM content=Data architecture=uPD96050
-    memory type=RAM content=Data architecture=uPD96050
-      map address=68-6f,e8-ef:0000-7fff mask=0x8000
-    oscillator
-
-board: SHVC-1J0N-(01,10,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-
-board: SHVC-1J1M-(11,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: SHVC-1J3B-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: SHVC-1J3M-(01,11,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: SHVC-1J5M-(01,11,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: SHVC-1K0N-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  processor architecture=uPD7725
-    map address=00-1f,80-9f:6000-7fff mask=0xfff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: SHVC-1K1B-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  processor architecture=uPD7725
-    map address=00-1f,80-9f:6000-7fff mask=0xfff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: SHVC-1K1X-10
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  processor architecture=uPD7725
-    map address=00-1f,80-9f:6000-7fff mask=0xfff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: SHVC-1L0N3S-01
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: SHVC-1L3B-(02,11)
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: SHVC-1L5B-(11,20)
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: SHVC-1N0N-(01,10)
-  processor identifier=SDD1
-    map address=00-3f,80-bf:4800-480f
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-
-board: SHVC-2A0N-01#A
-  memory type=ROM content=Program
-    map address=00-2f,80-af:8000-ffff mask=0x8000
-    map address=40-6f,c0-ef:0000-ffff mask=0x8000
-
-board: SHVC-2A0N-(01,10,11,20)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-
-board: SHVC-2A1M-01
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-2A3B-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-2A3M-01#A
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-2A3M-(01,11,20)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-2A5M-01
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-2B3B-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-  processor architecture=uPD7725
-    map address=60-6f,e0-ef:0000-7fff mask=0x3fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: SHVC-2DC0N-01
-  processor architecture=HG51BS169
-    map address=00-3f,80-bf:6c00-6fff,7c00-7fff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-    memory type=RAM content=Save
-      map address=70-77:0000-7fff
-    memory type=ROM content=Data architecture=HG51BS169
-    memory type=RAM content=Data architecture=HG51BS169
-      map address=00-3f,80-bf:6000-6bff,7000-7bff mask=0xf000
-    oscillator
-
-board: SHVC-2E3M-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  processor identifier=OBC1
-    map address=00-3f,80-bf:6000-7fff mask=0xe000
-    map address=70-71,f0-f1:6000-7fff,e000-ffff mask=0xe000
-    memory type=RAM content=Save
-
-board: SHVC-2J0N-(01,10,11,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-
-board: SHVC-2J3M-(01,11,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=10-1f,30-3f,90-9f,b0-bf:6000-7fff mask=0xe000
-
-board: SHVC-2J5M-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=10-1f,30-3f,90-9f,b0-bf:6000-7fff mask=0xe000
-
-board: SHVC-3J0N-01
-  memory type=ROM content=Program
-    map address=00-2f,80-af:8000-ffff
-    map address=40-6f,c0-ef:0000-ffff
-
-board: SHVC-BA0N-(01,10)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-
-board: SHVC-BA1M-01
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-BA3M-(01,10)
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: SHVC-BJ0N-(01,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-
-board: SHVC-BJ1M-(10,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: SHVC-BJ3M-(10,20)
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: SHVC-LDH3C-01
-  processor identifier=SPC7110
-    map address=00-3f,80-bf:4800-483f
-    map address=50,58:0000-ffff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x800000
-      map address=c0-ff:0000-ffff mask=0xc00000
-      memory type=ROM content=Program
-      memory type=ROM content=Data
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff mask=0xe000
-  rtc manufacturer=Epson
-    map address=00-3f,80-bf:4840-4842
-    memory type=RTC content=Time manufacturer=Epson
-
-board: SHVC-LJ3M-01
-  memory type=ROM content=Program
-    map address=00-3f:8000-ffff base=0x400000
-    map address=40-7d:0000-ffff base=0x400000
-    map address=80-bf:8000-ffff mask=0xc00000
-    map address=c0-ff:0000-ffff mask=0xc00000
-  memory type=RAM content=Save
-    map address=80-bf:6000-7fff mask=0xe000
-
-board: SHVC-LN3B-01
-  memory type=RAM content=Save
-    map address=00-3f,80-bf:6000-7fff mask=0xe000
-    map address=70-73:0000-ffff
-  processor identifier=SDD1
-    map address=00-3f,80-bf:4800-480f
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-
-board: SHVC-SGB2-01
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-  processor identifier=ICD revision=2
-    map address=00-3f,80-bf:6000-67ff,7000-7fff
-    memory type=ROM content=Boot architecture=SM83
-    oscillator
-    slot type=GameBoy
-
-board: SHVC-YA0N-01
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-
-board: SHVC-YJ0N-01
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-
-//Boards (Generic)
-
-database
-  revision: 2020-11-09
-
-board: ARM-LOROM-RAM
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-6f,c0-ef:0000-7fff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff
-  processor architecture=ARM6
-    map address=00-3f,80-bf:3800-38ff
-    memory type=ROM content=Program architecture=ARM6
-    memory type=ROM content=Data architecture=ARM6
-    memory type=RAM content=Data architecture=ARM6
-    oscillator
-
-board: BS-HIROM-RAM
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff
-    map address=40-5f,c0-df:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  slot type=BSMemory
-    map address=20-3f,a0-bf:8000-ffff
-    map address=60-7d,e0-ff:0000-ffff
-
-board: BS-LOROM-RAM
-  memory type=ROM content=Program
-    map address=00-1f:8000-ffff mask=0xe08000 base=0x000000
-    map address=20-3f:8000-ffff mask=0xe08000 base=0x100000
-    map address=80-9f:8000-ffff mask=0xe08000 base=0x200000
-    map address=a0-bf:8000-ffff mask=0xe08000 base=0x100000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-  slot type=BSMemory
-    map address=c0-ef:0000-ffff
-
-board: BS-MCC-RAM
-  memory type=RAM content=Save
-    map address=10-17:5000-5fff mask=0xf000
-  processor identifier=MCC
-    map address=00-0f:5000-5fff
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=40-7d,c0-ff:0000-ffff
-      map address=20-3f,a0-bf:6000-7fff
-      memory type=ROM content=Program
-      memory type=RAM content=Download
-      slot type=BSMemory
-
-board: BS-SA1-RAM
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-      slot type=BSMemory
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: EVENT-CC92
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-  processor manufacturer=NEC architecture=uPD78214
-    identifier: Campus Challenge '92
-    map address=c0,e0:0000
-    mcu
-      map address=00-1f,80-9f:8000-ffff
-      memory type=ROM content=Program
-      memory type=ROM content=Level-1
-      memory type=ROM content=Level-2
-      memory type=ROM content=Level-3
-    dip
-  processor manufacturer=NEC architecture=uPD7725
-    map address=20-3f,a0-bf:8000-ffff mask=0x7fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: EVENT-PF94
-  memory type=RAM content=Save
-    map address=30-3f,b0-bf:6000-7fff mask=0xe000
-  processor manufacturer=NEC architecture=uPD78214
-    identifier: PowerFest '94
-    map address=10,20:6000
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-      memory type=ROM content=Level-1
-      memory type=ROM content=Level-2
-      memory type=ROM content=Level-3
-    dip
-  processor manufacturer=NEC architecture=uPD7725
-    map address=00-0f,80-8f:6000-7fff mask=0xfff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: EXHIROM
-  memory type=ROM content=Program
-    map address=00-3f:8000-ffff base=0x400000
-    map address=40-7d:0000-ffff base=0x400000
-    map address=80-bf:8000-ffff mask=0xc00000
-    map address=c0-ff:0000-ffff mask=0xc00000
-
-board: EXHIROM-RAM
-  memory type=ROM content=Program
-    map address=00-3f:8000-ffff base=0x400000
-    map address=40-7d:0000-ffff base=0x400000
-    map address=80-bf:8000-ffff mask=0xc00000
-    map address=c0-ff:0000-ffff mask=0xc00000
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: EXHIROM-RAM-SHARPRTC
-  memory type=ROM content=Program
-    map address=00-3f:8000-ffff base=0x400000
-    map address=40-7d:0000-ffff base=0x400000
-    map address=80-bf:8000-ffff mask=0xc00000
-    map address=c0-ff:0000-ffff mask=0xc00000
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  rtc manufacturer=Sharp
-    map address=00-3f,80-bf:2800-2801
-    memory type=RTC content=Time manufacturer=Sharp
-
-board: EXLOROM
-  memory type=ROM content=Program
-    map address=00-7d:8000-ffff mask=0x808000 base=0x400000
-    map address=80-ff:8000-ffff mask=0x808000 base=0x000000
-
-board: EXLOROM-RAM
-  memory type=ROM content=Program
-    map address=00-7d:8000-ffff mask=0x808000 base=0x400000
-    map address=80-ff:8000-ffff mask=0x808000 base=0x000000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: EXNEC-LOROM
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  processor architecture=uPD96050
-    map address=60-67,e0-e7:0000-3fff
-    memory type=ROM content=Program architecture=uPD96050
-    memory type=ROM content=Data architecture=uPD96050
-    memory type=RAM content=Data architecture=uPD96050
-      map address=68-6f,e8-ef:0000-7fff mask=0x8000
-    oscillator
-
-board: EXSPC7110-RAM-EPSONRTC
-  memory type=ROM content=Expansion
-    map address=40-4f:0000-ffff
-  processor identifier=SPC7110
-    map address=00-3f,80-bf:4800-483f
-    map address=50,58:0000-ffff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x800000
-      map address=c0-ff:0000-ffff mask=0xc00000
-      memory type=ROM content=Program
-      memory type=ROM content=Data
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff mask=0xe000
-  rtc manufacturer=Epson
-    map address=00-3f,80-bf:4840-4842
-    memory type=RTC content=Time manufacturer=Epson
-
-board: GB-LOROM
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-    map address=40-7d,c0-ff:0000-7fff mask=0x8000
-  processor identifier=ICD revision=2
-    map address=00-3f,80-bf:6000-67ff,7000-7fff
-    memory type=ROM content=Boot architecture=SM83
-    oscillator
-    slot type=GameBoy
-
-board: GSU-RAM
-  processor architecture=GSU
-    map address=00-3f,80-bf:3000-34ff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-      map address=40-5f,c0-df:0000-ffff
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=70-71,f0-f1:0000-ffff
-
-board: HIROM
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-
-board: HIROM-RAM
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-
-board: HITACHI-LOROM
-  processor architecture=HG51BS169
-    map address=00-3f,80-bf:6c00-6fff,7c00-7fff
-    memory type=ROM content=Program
-      map address=00-3f,80-bf:8000-ffff mask=0x8000
-    memory type=RAM content=Save
-      map address=70-77:0000-7fff
-    memory type=ROM content=Data architecture=HG51BS169
-    memory type=RAM content=Data architecture=HG51BS169
-      map address=00-3f,80-bf:6000-6bff,7000-7bff mask=0xf000
-    oscillator
-
-board: LOROM
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-
-board: LOROM-RAM
-  memory type=ROM content=Program
-    map address=00-7d,80-ff:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-
-board: LOROM-RAM#A
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff mask=0x8000
-
-board: NEC-HIROM
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  processor architecture=uPD7725
-    map address=00-1f,80-9f:6000-7fff mask=0xfff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: NEC-HIROM-RAM
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff
-    map address=40-7d,c0-ff:0000-ffff
-  memory type=RAM content=Save
-    map address=20-3f,a0-bf:6000-7fff mask=0xe000
-  processor architecture=uPD7725
-    map address=00-1f,80-9f:6000-7fff mask=0xfff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: NEC-LOROM
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  processor architecture=uPD7725
-    map address=30-3f,b0-bf:8000-ffff mask=0x3fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: NEC-LOROM-RAM
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-7fff mask=0x8000
-  processor architecture=uPD7725
-    map address=60-6f,e0-ef:0000-7fff mask=0x3fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: NEC-LOROM-RAM#A
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  memory type=RAM content=Save
-    map address=70-7d,f0-ff:0000-ffff
-  processor architecture=uPD7725
-    map address=20-3f,a0-bf:8000-ffff mask=0x3fff
-    memory type=ROM content=Program architecture=uPD7725
-    memory type=ROM content=Data architecture=uPD7725
-    memory type=RAM content=Data architecture=uPD7725
-    oscillator
-
-board: OBC1-LOROM-RAM
-  memory type=ROM content=Program
-    map address=00-3f,80-bf:8000-ffff mask=0x8000
-  processor identifier=OBC1
-    map address=00-3f,80-bf:6000-7fff mask=0xe000
-    map address=70-71,f0-f1:6000-7fff,e000-ffff mask=0xe000
-    memory type=RAM content=Save
-
-board: SA1
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: SA1-RAM
-  processor architecture=W65C816S
-    map address=00-3f,80-bf:2200-23ff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x408000
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff size=0x2000
-      map address=40-4f:0000-ffff
-    memory type=RAM content=Internal
-      map address=00-3f,80-bf:3000-37ff size=0x800
-
-board: SDD1
-  processor identifier=SDD1
-    map address=00-3f,80-bf:4800-480f
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-
-board: SDD1-RAM
-  memory type=RAM content=Save
-    map address=00-3f,80-bf:6000-7fff mask=0xe000
-    map address=70-73:0000-ffff mask=0x8000
-  processor identifier=SDD1
-    map address=00-3f,80-bf:4800-480f
-    mcu
-      map address=00-3f,80-bf:8000-ffff
-      map address=c0-ff:0000-ffff
-      memory type=ROM content=Program
-
-board: SPC7110-RAM
-  processor identifier=SPC7110
-    map address=00-3f,80-bf:4800-483f
-    map address=50,58:0000-ffff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x800000
-      map address=c0-ff:0000-ffff mask=0xc00000
-      memory type=ROM content=Program
-      memory type=ROM content=Data
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff mask=0xe000
-
-board: SPC7110-RAM-EPSONRTC
-  processor identifier=SPC7110
-    map address=00-3f,80-bf:4800-483f
-    map address=50,58:0000-ffff
-    mcu
-      map address=00-3f,80-bf:8000-ffff mask=0x800000
-      map address=c0-ff:0000-ffff mask=0xc00000
-      memory type=ROM content=Program
-      memory type=ROM content=Data
-    memory type=RAM content=Save
-      map address=00-3f,80-bf:6000-7fff mask=0xe000
-  rtc manufacturer=Epson
-    map address=00-3f,80-bf:4840-4842
-    memory type=RTC content=Time manufacturer=Epson
-
-board: ST-LOROM
-  memory type=ROM content=Program
-    map address=00-1f,80-9f:8000-ffff mask=0x8000
-  slot type=SufamiTurbo
-    rom
-      map address=20-3f,a0-bf:8000-ffff mask=0x8000
-    ram
-      map address=60-6f,e0-ef:0000-ffff
-  slot type=SufamiTurbo
-    rom
-      map address=40-5f,c0-df:0000-ffff mask=0x8000
-    ram
-      map address=70-7d,f0-ff:0000-ffff
-

ares/a26/GNUmakefile

@@ -1,15 +0,0 @@
-ares.components += mos6502
-
-ares.objects += ares-a26-system
-ares.objects += ares-a26-controller
-ares.objects += ares-a26-cartridge
-ares.objects += ares-a26-cpu
-ares.objects += ares-a26-tia
-ares.objects += ares-a26-riot
-
-$(object.path)/ares-a26-system.o:     	$(ares.path)/a26/system/system.cpp
-$(object.path)/ares-a26-controller.o: 	$(ares.path)/a26/controller/controller.cpp
-$(object.path)/ares-a26-cartridge.o:  	$(ares.path)/a26/cartridge/cartridge.cpp
-$(object.path)/ares-a26-cpu.o:     		$(ares.path)/a26/cpu/cpu.cpp
-$(object.path)/ares-a26-tia.o:     		$(ares.path)/a26/tia/tia.cpp
-$(object.path)/ares-a26-riot.o:     	$(ares.path)/a26/riot/riot.cpp

ares/a26/a26.hpp

@@ -1,25 +0,0 @@
-#pragma once
-
-#include <ares/ares.hpp>
-
-#include <component/processor/mos6502/mos6502.hpp>
-
-namespace ares::Atari2600 {
-  #include <ares/inline.hpp>
-  auto enumerate() -> vector<string>;
-  auto load(Node::System& node, string name) -> bool;
-
-  struct Region {
-    static inline auto NTSC() -> bool;
-    static inline auto PAL() -> bool;
-    static inline auto SECAM() -> bool;
-  };
-
-  #include <a26/controller/controller.hpp>
-  #include <a26/system/system.hpp>
-  #include <a26/cartridge/cartridge.hpp>
-  #include <a26/cpu/cpu.hpp>
-  #include <a26/tia/tia.hpp>
-  #include <a26/riot/riot.hpp>
-}
-

ares/a26/cartridge/board/atari16k.cpp

@@ -1,58 +0,0 @@
-struct Atari16k : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  Memory::Writable<n8> ram;
-  n2 bank;
-  bool hasRam;
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    if(address == 0x1ff6) bank = 0;
-    if(address == 0x1ff7) bank = 1;
-    if(address == 0x1ff8) bank = 2;
-    if(address == 0x1ff9) bank = 3;
-
-    if(address.bit(12)) {
-      if(hasRam && address >= 0x1080 && address <= 0x10ff) return ram.read(address & 0x7f);
-      return rom.read((bank * 0x1000) + (address & 0xfff));
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    if(address == 0x1ff6) bank = 0;
-    if(address == 0x1ff7) bank = 1;
-    if(address == 0x1ff8) bank = 2;
-    if(address == 0x1ff9) bank = 3;
-
-    if(address >= 0x1000 && address <= 0x107f) {
-      hasRam = true;
-      ram.write(address & 0x7f, data);
-      return true;
-    }
-
-    return false;
-  }
-
-  auto power() -> void override {
-    bank = 0;
-    hasRam = 0;
-    ram.allocate(128);
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(bank);
-    s(hasRam);
-    s(ram);
-  }
-};

ares/a26/cartridge/board/atari32k.cpp

@@ -1,66 +0,0 @@
-struct Atari32k : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  Memory::Writable<n8> ram;
-  n3 bank;
-  bool hasRam;
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    if(address == 0x1ff4) bank = 0;
-    if(address == 0x1ff5) bank = 1;
-    if(address == 0x1ff6) bank = 2;
-    if(address == 0x1ff7) bank = 3;
-    if(address == 0x1ff8) bank = 4;
-    if(address == 0x1ff9) bank = 5;
-    if(address == 0x1ffa) bank = 6;
-    if(address == 0x1ffb) bank = 7;
-
-    if(address.bit(12)) {
-      if(hasRam && address >= 0x1080 && address <= 0x10ff) return ram.read(address & 0x7f);
-      return rom.read((bank * 0x1000) + (address & 0xfff));
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    if(address == 0x1ff4) bank = 0;
-    if(address == 0x1ff5) bank = 1;
-    if(address == 0x1ff6) bank = 2;
-    if(address == 0x1ff7) bank = 3;
-    if(address == 0x1ff8) bank = 4;
-    if(address == 0x1ff9) bank = 5;
-    if(address == 0x1ffa) bank = 6;
-    if(address == 0x1ffb) bank = 7;
-
-    if(address >= 0x1000 && address <= 0x107f) {
-      hasRam = true;
-      ram.write(address & 0x7f, data);
-      return true;
-    }
-
-    return false;
-  }
-
-  auto power() -> void override {
-    bank = 0;
-    hasRam = 0;
-    ram.allocate(128);
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(bank);
-    s(hasRam);
-    s(ram);
-  }
-};

ares/a26/cartridge/board/atari8k.cpp

@@ -1,54 +0,0 @@
-struct Atari8k : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  Memory::Writable<n8> ram;
-  n1 bank;
-  bool hasRam;
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    if(address == 0x1ff8) bank = 0;
-    if(address == 0x1ff9) bank = 1;
-
-    if(address.bit(12)) {
-      if(hasRam && address >= 0x1080 && address <= 0x10ff) return ram.read(address & 0x7f);
-      return rom.read((bank * 0x1000) + (address & 0xfff));
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    if(address == 0x1ff8) bank = 0;
-    if(address == 0x1ff9) bank = 1;
-
-    if(address >= 0x1000 && address <= 0x107f) {
-      hasRam = true;
-      ram.write(address & 0x7f, data);
-      return true;
-    }
-
-    return false;
-  }
-
-  auto power() -> void override {
-    bank = 0;
-    hasRam = 0;
-    ram.allocate(128);
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(bank);
-    s(hasRam);
-    s(ram);
-  }
-};

ares/a26/cartridge/board/board.cpp

@@ -1,37 +0,0 @@
-namespace Board {
-
-#include "linear.cpp"
-#include "atari8k.cpp"
-#include "atari16k.cpp"
-#include "atari32k.cpp"
-#include "commavid.cpp"
-#include "parker-bros.cpp"
-#include "tigervision.cpp"
-
-auto Interface::load(Memory::Readable<n8>& memory, string name) -> bool {
-  if(auto fp = pak->read(name)) {
-    memory.allocate(fp->size());
-    memory.load(fp);
-    return true;
-  }
-  return false;
-}
-
-auto Interface::load(Memory::Writable<n8>& memory, string name) -> bool {
-  if(auto fp = pak->read(name)) {
-    memory.allocate(fp->size());
-    memory.load(fp);
-    return true;
-  }
-  return false;
-}
-
-auto Interface::save(Memory::Writable<n8>& memory, string name) -> bool {
-  if(auto fp = pak->write(name)) {
-    memory.save(fp);
-    return true;
-  }
-  return false;
-}
-
-}

ares/a26/cartridge/board/board.hpp

@@ -1,23 +0,0 @@
-namespace Board {
-
-struct Interface {
-  VFS::Pak pak;
-
-  Interface(Cartridge& cartridge) : cartridge(cartridge) {}
-  virtual ~Interface() = default;
-  virtual auto load() -> void {}
-  virtual auto save() -> void {}
-  virtual auto unload() -> void {}
-  virtual auto read(n16 address) -> n8 { return 0xff; }
-  virtual auto write(n16 address, n8 data) -> bool { return false; }
-  virtual auto power() -> void {}
-  virtual auto serialize(serializer&) -> void {}
-
-  auto load(Memory::Readable<n8>&, string name) -> bool;
-  auto load(Memory::Writable<n8>&, string name) -> bool;
-  auto save(Memory::Writable<n8>&, string name) -> bool;
-
-  Cartridge& cartridge;
-};
-
-}

ares/a26/cartridge/board/commavid.cpp

@@ -1,41 +0,0 @@
-struct Commavid : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  Memory::Writable<n8> ram;
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    if(address.bit(12)) {
-      if(address >= 0x1000 && address <= 0x13ff) return ram.read(address & 0x3ff);
-      return rom.read(address & 0xfff);
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    if(address >= 0x1400 && address <= 0x17ff) {
-      ram.write(address & 0x3ff, data);
-      return true;
-    }
-
-    return false;
-  }
-
-  auto power() -> void override {
-    ram.allocate(1_KiB);
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(ram);
-  }
-};

ares/a26/cartridge/board/linear.cpp

@@ -1,45 +0,0 @@
-struct Linear : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  Memory::Writable<n8> ram;
-  bool hasRam;
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    if(address.bit(12)) {
-      if(hasRam && address >= 0x1080 && address <= 0x10ff) return ram.read(address & 0x7f);
-      return rom.read(address & 0xfff);
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    if(address >= 0x1000 && address <= 0x107f) {
-      hasRam = true;
-      ram.write(address & 0x7f, data);
-      return true;
-    }
-
-    return false;
-  }
-
-  auto power() -> void override {
-    hasRam = 0;
-    ram.allocate(128);
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(hasRam);
-    s(ram);
-  }
-};

ares/a26/cartridge/board/parker-bros.cpp

@@ -1,51 +0,0 @@
-struct ParkerBros : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  n3 banks[3];
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    bankswitch(address);
-
-    if(address.bit(12)) {
-      if(address >= 0x1000 && address <= 0x13ff) return rom.read((banks[0] * 0x400) + (address & 0x3ff));
-      if(address >= 0x1400 && address <= 0x17ff) return rom.read((banks[1] * 0x400) + (address & 0x3ff));
-      if(address >= 0x1800 && address <= 0x1bff) return rom.read((banks[2] * 0x400) + (address & 0x3ff));
-      if(address >= 0x1c00 && address <= 0x1fff) return rom.read((      7  * 0x400) + (address & 0x3ff));
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    bankswitch(address);
-    return false;
-  }
-
-  auto bankswitch(n16 address) -> void {
-    if(address >= 0x1fe0 && address <= 0x1fe7) banks[0] = address - 0x1fe0;
-    if(address >= 0x1fe8 && address <= 0x1fef) banks[1] = address - 0x1fe8;
-    if(address >= 0x1ff0 && address <= 0x1ff7) banks[2] = address - 0x1ff0;
-  }
-
-  auto power() -> void override {
-    banks[0] = 0;
-    banks[1] = 1;
-    banks[2] = 2;
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(banks[0]);
-    s(banks[1]);
-    s(banks[2]);
-  }
-};

ares/a26/cartridge/board/tigervision.cpp

@@ -1,42 +0,0 @@
-struct Tigervision : Interface {
-  using Interface::Interface;
-  Memory::Readable<n8> rom;
-  n8 bank;
-  n8 nextBank;
-
-  auto load() -> void override {
-    Interface::load(rom, "program.rom");
-  }
-
-  auto save() -> void override {
-  }
-
-  auto unload() -> void override {
-  }
-
-  auto read(n16 address) -> n8 override {
-    if(address.bit(12)) {
-      if(bank != nextBank) bank = nextBank;
-      if(address <= 0x17ff) return rom.read((bank * 0x800) + (address & 0x7ff));
-      return rom.read((rom.size() - 0x800) + (address & 0x7ff));
-    }
-
-    return 0xff;
-  }
-   
-  auto write(n16 address, n8 data) -> bool override {
-    if(address.bit(12) && bank != nextBank) bank = nextBank;
-    if(address <= 0x3f) nextBank = data;
-    return false;
-  }
-
-  auto power() -> void override {
-    bank = 0;
-    nextBank = 0;
-  }
-
-  auto serialize(serializer& s) -> void override {
-    s(bank);
-    s(nextBank);
-  }
-};

ares/a26/cartridge/cartridge.cpp

@@ -1,66 +0,0 @@
-#include <a26/a26.hpp>
-
-namespace ares::Atari2600 {
-
-Cartridge& cartridge = cartridgeSlot.cartridge;
-#include "board/board.cpp"
-#include "slot.cpp"
-#include "serialization.cpp"
-
-auto Cartridge::allocate(Node::Port parent) -> Node::Peripheral {
-  return node = parent->append<Node::Peripheral>(string{system.name(), " Cartridge"});
-}
-
-auto Cartridge::connect() -> void {
-  if(!node->setPak(pak = platform->pak(node))) return;
-
-  information = {};
-  information.title  = pak->attribute("title");
-  information.region = pak->attribute("region");
-  information.board  = pak->attribute("board");
-
-  if(information.board == "Linear") board = new Board::Linear{*this};
-  if(information.board == "Atari8k") board = new Board::Atari8k{*this};
-  if(information.board == "Atari16k") board = new Board::Atari16k{*this};
-  if(information.board == "Atari32k") board = new Board::Atari32k{*this};
-  if(information.board == "Commavid") board = new Board::Commavid{*this};
-  if(information.board == "ParkerBros8k") board = new Board::ParkerBros{*this};
-  if(information.board == "Tigervision") board = new Board::Tigervision{*this};
-
-  if(!board) board = new Board::Interface{*this};
-  board->pak = pak;
-  board->load();
-  power();
-}
-
-auto Cartridge::disconnect() -> void {
-  if(!node || !board) return;
-  board->unload();
-  board->pak.reset();
-  board.reset();
-  node.reset();
-}
-
-auto Cartridge::save() -> void {
-  if(!node) return;
-  if(board) board->save();
-}
-
-auto Cartridge::power() -> void {
-  if(board) board->power();
-}
-
-auto Cartridge::read(n16 address) -> n8 {
-  if(!node) return 0xff;
-  if(board) return board->read(address);
-
-  return 0xff;
-}
-
-auto Cartridge::write(n16 address, n8 data) -> bool {
-  if(!node) return false;
-  if(board) return board->write(address, data);
-  return false;
-}
-
-}

ares/a26/cartridge/cartridge.hpp

@@ -1,36 +0,0 @@
-struct Cartridge;
-#include "board/board.hpp"
-
-struct Cartridge {
-  Node::Peripheral node;
-  VFS::Pak pak;
-
-  auto title() const -> string { return information.title; }
-  auto region() const -> string { return information.region; }
-
-  //cartridge.cpp
-  auto allocate(Node::Port) -> Node::Peripheral;
-  auto connect() -> void;
-  auto disconnect() -> void;
-
-  auto save() -> void;
-  auto power() -> void;
-
-  auto read(n16 address) -> n8;
-  auto write(n16 address, n8 data) -> bool;
-
-  //serialization.cpp
-  auto serialize(serializer&) -> void;
-
-  unique_pointer<Board::Interface> board;
-
-//private:
-  struct Information {
-    string title;
-    string region;
-    string board;
-  } information;
-};
-
-#include "slot.hpp"
-extern Cartridge& cartridge;

ares/a26/cartridge/serialization.cpp

@@ -1,3 +0,0 @@
-auto Cartridge::serialize(serializer& s) -> void {
-  if(board) s(*board);
-}

ares/a26/cartridge/slot.cpp

@@ -1,18 +0,0 @@
-CartridgeSlot cartridgeSlot{"Cartridge Slot"};
-
-CartridgeSlot::CartridgeSlot(string name) : name(name) {
-}
-
-auto CartridgeSlot::load(Node::Object parent) -> void {
-  port = parent->append<Node::Port>(name);
-  port->setFamily(system.name());
-  port->setType("Cartridge");
-  port->setAllocate([&](auto name) { return cartridge.allocate(port); });
-  port->setConnect([&] { return cartridge.connect(); });
-  port->setDisconnect([&] { return cartridge.disconnect(); });
-}
-
-auto CartridgeSlot::unload() -> void {
-  cartridge.disconnect();
-  port = {};
-}