Update to bsnes v014 release.

This version adds speed regulation, greatly improves PPU rendering, and increases speed by ~30% over the previous version.
Changelog:
    - Rewrote offset-per-tile mode emulation, should be correct now. Fixes Chrono Trigger, Contra III, Tetris Attack, etc.
    - Fixed a bug with HDMA occuring during interrupts. Fixes Tales of Phantasia souond test screen
    - Updated compiler to Visual Studio 2005, and enabled profile guided optimizations
    - Added conditional compilation of debugging functions (faster without them)
    - Added conditional compilation of core classes as pointers (allowing polymorphism) or objects (allowing inlining). The latter results in a speed increase
    - Small fixes to BG and OAM rendering routines
    - Corrected sprite tile bounds wrapping
    - Corrected sprite rendering in hires video modes
    - Rewrote color add/sub routines, should be correct now. Fixes Illusion of Gaia menu, etc.
    - Optimized video blitting routines, will temporarilly break mixed video mode screenshots
    - Prevented selecting menu options via return key from being recognized as keypresses by the emulator
    - Added system speed regulation (60hz/NTSC or 50hz/PAL)! Many thanks to kode54, GIGO, and Richard Bannister for their assistance
I disabled the debugger and polymorphism, and enabled profile guided optimizations for this build, to maximize speed. The debugger and polymorphism can be re-enabled via uncommenting the respective #defines in src/base.h and recompiling, or bsnes v0.013 can be used. I may start releasing two separate builds in the future... not sure yet.

.github/workflows/build.yml

@@ -1,170 +0,0 @@
-name: Build
-on:
-  push:
-    branches: [ master ]
-    tags: [ 'v*' ]
-  pull_request:
-    branches: [ master ]
-jobs:
-  build:
-    strategy:
-      matrix:
-        program:
-        - ares
-        os:
-        - name: windows
-          version: latest
-        - name: macos
-          version: latest
-        - name: ubuntu
-          version: latest
-    runs-on: ${{ matrix.os.name }}-${{ matrix.os.version }}
-    steps:
-    - uses: actions/checkout@v2
-    - name: Install Dependencies
-      if: matrix.os.name == 'ubuntu'
-      run: |
-        sudo apt-get update -y -qq
-        sudo apt-get install libsdl2-dev libgtksourceview2.0-dev libgtk2.0-dev libao-dev libopenal-dev   
-    - name: Make
-      run: make -j4 -C desktop-ui build=optimized local=false lto=true
-    - name: Upload
-      uses: actions/upload-artifact@v2
-      with:
-        name: ${{ matrix.program }}-${{ matrix.os.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' }
-

LICENSE

@@ -1,15 +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.

README.md

@@ -1,18 +0,0 @@
-# ares
-
-[![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-emulator.github.io).
-
-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,98 +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),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/ares/ares.cpp

@@ -1,11 +0,0 @@
-#include <ares/ares.hpp>
-#include <ares/debug/debug.cpp>
-#include <ares/node/node.cpp>
-#include <ares/resource/resource.cpp>
-
-namespace ares {
-
-Platform* platform = nullptr;
-bool _runAhead = false;
-
-}

ares/ares/ares.hpp

@@ -1,80 +0,0 @@
-#pragma once
-
-#include <libco/libco.h>
-
-#include <nall/platform.hpp>
-#include <nall/adaptive-array.hpp>
-#include <nall/any.hpp>
-#include <nall/array.hpp>
-#include <nall/bump-allocator.hpp>
-#include <nall/chrono.hpp>
-#include <nall/directory.hpp>
-#include <nall/dl.hpp>
-#include <nall/endian.hpp>
-#include <nall/image.hpp>
-#include <nall/literals.hpp>
-#include <nall/priority-queue.hpp>
-#include <nall/queue.hpp>
-#include <nall/random.hpp>
-#include <nall/serializer.hpp>
-#include <nall/set.hpp>
-#include <nall/shared-pointer.hpp>
-#include <nall/string.hpp>
-#include <nall/terminal.hpp>
-#include <nall/thread.hpp>
-#include <nall/traits.hpp>
-#include <nall/unique-pointer.hpp>
-#include <nall/variant.hpp>
-#include <nall/vector.hpp>
-#include <nall/vfs.hpp>
-#include <nall/cd.hpp>
-#include <nall/dsp/iir/one-pole.hpp>
-#include <nall/dsp/iir/biquad.hpp>
-#include <nall/dsp/resampler/cubic.hpp>
-#include <nall/hash/crc32.hpp>
-#include <nall/hash/sha256.hpp>
-using namespace nall;
-
-namespace ares {
-  static const string Name       = "ares";
-  static const string Version    = "124";
-  static const string Copyright  = "ares team, Near";
-  static const string License    = "ISC";
-  static const string LicenseURI = "https://opensource.org/licenses/ISC";
-  static const string Website    = "ares-emulator.github.io";
-  static const string WebsiteURI = "https://ares-emulator.github.io";
-
-  //incremented only when serialization format changes
-  static const u32    SerializerSignature = 0x31545342;  //"BST1" (little-endian)
-  static const string SerializerVersion   = "123.1";
-
-  namespace VFS {
-    using Pak = shared_pointer<vfs::directory>;
-    using File = shared_pointer<vfs::file>;
-  }
-
-  namespace Video {
-    static constexpr bool Threaded = true;
-  }
-
-  namespace Constants {
-    namespace Colorburst {
-      static constexpr f64 NTSC = 315.0 / 88.0 * 1'000'000.0;
-      static constexpr f64 PAL  = 283.75 * 15'625.0 + 25.0;
-    }
-  }
-
-  extern bool _runAhead;
-  inline auto runAhead() -> bool { return _runAhead; }
-  inline auto setRunAhead(bool runAhead) -> void { _runAhead = runAhead; }
-}
-
-#include <ares/types.hpp>
-#include <ares/random.hpp>
-#include <ares/debug/debug.hpp>
-#include <ares/node/node.hpp>
-#include <ares/platform.hpp>
-#include <ares/memory/fixed-allocator.hpp>
-#include <ares/memory/readable.hpp>
-#include <ares/memory/writable.hpp>
-#include <ares/resource/resource.hpp>

ares/ares/debug/debug.cpp

@@ -1,45 +0,0 @@
-namespace ares {
-
-Debug _debug;
-
-auto Debug::reset() -> void {
-  _totalNotices = 0;
-  _unhandledNotices.reset();
-  _unimplementedNotices.reset();
-  _unusualNotices.reset();
-  _unverifiedNotices.reset();
-}
-
-auto Debug::_unhandled(const string& text) -> void {
-  if(_unhandledNotices.find(text)) return;
-  if(_totalNotices++ > 256) return;
-  _unhandledNotices.append(text);
-
-  print(terminal::color::yellow("[unhandled] "), text, "\n");
-}
-
-auto Debug::_unimplemented(const string& text) -> void {
-  if(_unimplementedNotices.find(text)) return;
-  if(_totalNotices++ > 256) return;
-  _unimplementedNotices.append(text);
-
-  print(terminal::color::magenta("[unimplemented] "), text, "\n");
-}
-
-auto Debug::_unusual(const string& text) -> void {
-  if(_unusualNotices.find(text)) return;
-  if(_totalNotices++ > 256) return;
-  _unusualNotices.append(text);
-
-  print(terminal::color::cyan("[unusual] "), text, "\n");
-}
-
-auto Debug::_unverified(const string& text) -> void {
-  if(_unverifiedNotices.find(text)) return;
-  if(_totalNotices++ > 256) return;
-  _unverifiedNotices.append(text);
-
-  print(terminal::color::gray("[unverified] "), text, "\n");
-}
-
-}

ares/ares/debug/debug.hpp

@@ -1,39 +0,0 @@
-namespace ares {
-
-struct Debug {
-  auto reset() -> void;
-
-  template<typename... P> auto unhandled(P&&... p) -> void {
-    return _unhandled({forward<P>(p)...});
-  }
-
-  template<typename... P> auto unimplemented(P&&... p) -> void {
-    return _unimplemented({forward<P>(p)...});
-  }
-
-  template<typename... P> auto unusual(P&&... p) -> void {
-    return _unusual({forward<P>(p)...});
-  }
-
-  template<typename... P> auto unverified(P&&... p) -> void {
-    return _unverified({forward<P>(p)...});
-  }
-
-private:
-  auto _unhandled(const string&) -> void;
-  auto _unimplemented(const string&) -> void;
-  auto _unusual(const string&) -> void;
-  auto _unverified(const string&) -> void;
-
-  u64 _totalNotices = 0;
-  vector<string> _unhandledNotices;
-  vector<string> _unimplementedNotices;
-  vector<string> _unusualNotices;
-  vector<string> _unverifiedNotices;
-};
-
-extern Debug _debug;
-
-}
-
-#define debug(function, ...) if constexpr(1) ares::_debug.function(__VA_ARGS__)

ares/ares/inline.hpp

@@ -1,4 +0,0 @@
-#include <ares/scheduler/thread.hpp>
-#include <ares/scheduler/scheduler.hpp>
-#include <ares/scheduler/thread.cpp>
-#include <ares/scheduler/scheduler.cpp>

ares/ares/memory/fixed-allocator.cpp

@@ -1,16 +0,0 @@
-#include <ares/ares.hpp>
-
-namespace ares::Memory {
-
-alignas(4096) u8 fixedBuffer[1_GiB];
-
-FixedAllocator::FixedAllocator() {
-  _allocator.resize(sizeof(fixedBuffer), 0, fixedBuffer);
-}
-
-auto FixedAllocator::get() -> bump_allocator& {
-  static FixedAllocator allocator;
-  return allocator._allocator;
-}
-
-}

ares/ares/memory/fixed-allocator.hpp

@@ -1,14 +0,0 @@
-#pragma once
-
-namespace ares::Memory {
-
-struct FixedAllocator {
-  static auto get() -> bump_allocator&;
-
-private:
-  FixedAllocator();
-
-  bump_allocator _allocator;
-};
-
-}

ares/ares/memory/memory.hpp

@@ -1,30 +0,0 @@
-#pragma once
-
-namespace ares::Memory {
-
-inline auto mirror(u32 address, u32 size) -> u32 {
-  if(size == 0) return 0;
-  u32 base = 0;
-  u32 mask = 1 << 31;
-  while(address >= size) {
-    while(!(address & mask)) mask >>= 1;
-    address -= mask;
-    if(size > mask) {
-      size -= mask;
-      base += mask;
-    }
-    mask >>= 1;
-  }
-  return base + address;
-}
-
-inline auto reduce(u32 address, u32 mask) -> u32 {
-  while(mask) {
-    u32 bits = (mask & -mask) - 1;
-    address = address >> 1 & ~bits | address & bits;
-    mask = (mask & mask - 1) >> 1;
-  }
-  return address;
-}
-
-}

ares/ares/memory/readable.hpp

@@ -1,73 +0,0 @@
-#pragma once
-
-#include <ares/memory/memory.hpp>
-
-namespace ares::Memory {
-
-template<typename T>
-struct Readable {
-  ~Readable() { reset(); }
-
-  auto reset() -> void {
-    delete[] self.data;
-    self.data = nullptr;
-    self.size = 0;
-    self.mask = 0;
-  }
-
-  auto allocate(u32 size, T fill = (T)~0ull) -> void {
-    if(!size) return reset();
-    delete[] self.data;
-    self.size = size;
-    self.mask = bit::round(self.size) - 1;
-    self.data = new T[self.mask + 1];
-    memory::fill<T>(self.data, self.mask + 1, fill);
-  }
-
-  auto fill(T fill = ~0ull) -> void {
-    for(u32 address : range(self.size)) {
-      self.data[address] = fill;
-    }
-  }
-
-  auto load(VFS::File fp) -> void {
-    if(!self.size) allocate(fp->size());
-    fp->read({self.data, min(fp->size(), self.size * sizeof(T))});
-    for(u32 address = self.size; address <= self.mask; address++) {
-      self.data[address] = self.data[mirror(address, self.size)];
-    }
-  }
-
-  auto save(VFS::File fp) -> void {
-    fp->write({self.data, min(fp->size(), self.size * sizeof(T))});
-  }
-
-  explicit operator bool() const { return (bool)self.data; }
-  auto data() const -> const T* { return self.data; }
-  auto size() const -> u32 { return self.size; }
-  auto mask() const -> u32 { return self.mask; }
-
-  auto operator[](u32 address) const -> T { return self.data[address & self.mask]; }
-  auto read(u32 address) const -> T { return self.data[address & self.mask]; }
-  auto write(u32 address, T data) const -> void {}
-  auto program(u32 address, T data) const -> void { self.data[address & self.mask] = data; }
-
-  auto begin() -> T* { return &self.data[0]; }
-  auto end() -> T* { return &self.data[self.size]; }
-
-  auto begin() const -> const T* { return &self.data[0]; }
-  auto end() const -> const T* { return &self.data[self.size]; }
-
-  auto serialize(serializer& s) -> void {
-    s(array_span<T>{self.data, self.size});
-  }
-
-//private:
-  struct {
-    T* data = nullptr;
-    u32 size = 0;
-    u32 mask = 0;
-  } self;
-};
-
-}

ares/ares/memory/writable.hpp

@@ -1,75 +0,0 @@
-#pragma once
-
-#include <ares/memory/memory.hpp>
-
-namespace ares::Memory {
-
-template<typename T>
-struct Writable {
-  ~Writable() { reset(); }
-
-  auto reset() -> void {
-    delete[] self.data;
-    self.data = nullptr;
-    self.size = 0;
-    self.mask = 0;
-  }
-
-  auto allocate(u32 size, T fill = (T)~0ull) -> void {
-    if(!size) return reset();
-    delete[] self.data;
-    self.size = size;
-    self.mask = bit::round(self.size) - 1;
-    self.data = new T[self.mask + 1];
-    memory::fill<T>(self.data, self.mask + 1, fill);
-  }
-
-  auto fill(T fill = ~0ull) -> void {
-    for(u32 address : range(self.size)) {
-      self.data[address] = fill;
-    }
-  }
-
-  auto load(VFS::File fp) -> void {
-    if(!self.size) allocate(fp->size());
-    fp->read({self.data, min(fp->size(), self.size * sizeof(T))});
-    for(u32 address = self.size; address <= self.mask; address++) {
-      self.data[address] = self.data[mirror(address, self.size)];
-    }
-  }
-
-  auto save(VFS::File fp) -> void {
-    fp->write({self.data, min(fp->size(), self.size * sizeof(T))});
-  }
-
-  explicit operator bool() const { return (bool)self.data; }
-  auto data() -> T* { return self.data; }
-  auto data() const -> const T* { return self.data; }
-  auto size() const -> u32 { return self.size; }
-  auto mask() const -> u32 { return self.mask; }
-
-  auto operator[](u32 address) -> T& { return self.data[address & self.mask]; }
-  auto operator[](u32 address) const -> T { return self.data[address & self.mask]; }
-  auto read(u32 address) const -> T { return self.data[address & self.mask]; }
-  auto write(u32 address, T data) -> void { self.data[address & self.mask] = data; }
-  auto program(u32 address, T data) -> void { self.data[address & self.mask] = data; }
-
-  auto begin() -> T* { return &self.data[0]; }
-  auto end() -> T* { return &self.data[self.size]; }
-
-  auto begin() const -> const T* { return &self.data[0]; }
-  auto end() const -> const T* { return &self.data[self.size]; }
-
-  auto serialize(serializer& s) -> void {
-    s(array_span<T>{self.data, self.size});
-  }
-
-private:
-  struct {
-    T* data = nullptr;
-    u32 size = 0;
-    u32 mask = 0;
-  } self;
-};
-
-}

ares/ares/node/attribute.hpp

@@ -1,8 +0,0 @@
-struct Attribute {
-  Attribute(const string& name, const any& value = {}) : name(name), value(value) {}
-  auto operator==(const Attribute& source) const -> bool { return name == source.name; }
-  auto operator< (const Attribute& source) const -> bool { return name <  source.name; }
-
-  string name;
-  any value;
-};

ares/ares/node/audio/audio.hpp

@@ -1,4 +0,0 @@
-struct Audio : Object {
-  DeclareClass(Audio, "audio")
-  using Object::Object;
-};

ares/ares/node/audio/stream.cpp

@@ -1,131 +0,0 @@
-auto Stream::setChannels(u32 channels) -> void {
-  _channels.reset();
-  _channels.resize(channels);
-}
-
-auto Stream::setFrequency(f64 frequency) -> void {
-  _frequency = frequency;
-  setResamplerFrequency(_resamplerFrequency);
-}
-
-auto Stream::setResamplerFrequency(f64 resamplerFrequency) -> void {
-  _resamplerFrequency = resamplerFrequency;
-
-  for(auto& channel : _channels) {
-    channel.nyquist.reset();
-    channel.resampler.reset(_frequency, _resamplerFrequency);
-  }
-
-  if(_frequency >= _resamplerFrequency * 2) {
-    //add a low-pass filter to prevent aliasing during resampling
-    f64 cutoffFrequency = min(25000.0, _resamplerFrequency / 2.0 - 2000.0);
-    for(auto& channel : _channels) {
-      u32 passes = 3;
-      for(u32 pass : range(passes)) {
-        DSP::IIR::Biquad filter;
-        f64 q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
-        filter.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, _frequency, q);
-        channel.nyquist.append(filter);
-      }
-    }
-  }
-}
-
-auto Stream::setMuted(bool muted) -> void {
-  _muted = muted;
-}
-
-auto Stream::resetFilters() -> void {
-  for(auto& channel : _channels) {
-    channel.filters.reset();
-  }
-}
-
-auto Stream::addLowPassFilter(f64 cutoffFrequency, u32 order, u32 passes) -> void {
-  for(auto& channel : _channels) {
-    for(u32 pass : range(passes)) {
-      if(order == 1) {
-        Filter filter{Filter::Mode::OnePole, Filter::Type::LowPass, Filter::Order::First};
-        filter.onePole.reset(DSP::IIR::OnePole::Type::LowPass, cutoffFrequency, _frequency);
-        channel.filters.append(filter);
-      }
-      if(order == 2) {
-        Filter filter{Filter::Mode::Biquad, Filter::Type::LowPass, Filter::Order::Second};
-        f64 q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
-        filter.biquad.reset(DSP::IIR::Biquad::Type::LowPass, cutoffFrequency, _frequency, q);
-        channel.filters.append(filter);
-      }
-    }
-  }
-}
-
-auto Stream::addHighPassFilter(f64 cutoffFrequency, u32 order, u32 passes) -> void {
-  for(auto& channel : _channels) {
-    for(u32 pass : range(passes)) {
-      if(order == 1) {
-        Filter filter{Filter::Mode::OnePole, Filter::Type::HighPass, Filter::Order::First};
-        filter.onePole.reset(DSP::IIR::OnePole::Type::HighPass, cutoffFrequency, _frequency);
-        channel.filters.append(filter);
-      }
-      if(order == 2) {
-        Filter filter{Filter::Mode::Biquad, Filter::Type::HighPass, Filter::Order::Second};
-        f64 q = DSP::IIR::Biquad::butterworth(passes * 2, pass);
-        filter.biquad.reset(DSP::IIR::Biquad::Type::HighPass, cutoffFrequency, _frequency, q);
-        channel.filters.append(filter);
-      }
-    }
-  }
-}
-
-auto Stream::addLowShelfFilter(f64 cutoffFrequency, u32 order, f64 gain, f64 slope) -> void {
-  for(auto& channel : _channels) {
-    if(order == 2) {
-      Filter filter{Filter::Mode::Biquad, Filter::Type::LowShelf, Filter::Order::Second};
-      f64 q = DSP::IIR::Biquad::shelf(gain, slope);
-      filter.biquad.reset(DSP::IIR::Biquad::Type::LowShelf, cutoffFrequency, _frequency, q);
-      channel.filters.append(filter);
-    }
-  }
-}
-
-auto Stream::addHighShelfFilter(f64 cutoffFrequency, u32 order, f64 gain, f64 slope) -> void {
-  for(auto& channel : _channels) {
-    if(order == 2) {
-      Filter filter{Filter::Mode::Biquad, Filter::Type::HighShelf, Filter::Order::Second};
-      f64 q = DSP::IIR::Biquad::shelf(gain, slope);
-      filter.biquad.reset(DSP::IIR::Biquad::Type::HighShelf, cutoffFrequency, _frequency, q);
-      channel.filters.append(filter);
-    }
-  }
-}
-
-auto Stream::pending() const -> bool {
-  return _channels && _channels[0].resampler.pending();
-}
-
-auto Stream::read(f64 samples[]) -> u32 {
-  for(u32 c : range(_channels.size())) {
-    samples[c] = _channels[c].resampler.read() * !muted();
-  }
-  return _channels.size();
-}
-
-auto Stream::write(const f64 samples[]) -> void {
-  for(u32 c : range(_channels.size())) {
-    f64 sample = samples[c] + 1e-25;  //constant offset used to suppress denormals
-    for(auto& filter : _channels[c].filters) {
-      switch(filter.mode) {
-      case Filter::Mode::OnePole: sample = filter.onePole.process(sample); break;
-      case Filter::Mode::Biquad: sample = filter.biquad.process(sample); break;
-      }
-    }
-    for(auto& filter : _channels[c].nyquist) {
-      sample = filter.process(sample);
-    }
-    _channels[c].resampler.write(sample);
-  }
-
-  //if there are samples pending, then alert the frontend to possibly process them.
-  //this will generally happen when every audio stream has pending samples to be mixed.
-  if(pending()) platform->audio(shared());
-}

ares/ares/node/audio/stream.hpp

@@ -1,49 +0,0 @@
-struct Stream : Audio {
-  DeclareClass(Stream, "audio.stream")
-  using Audio::Audio;
-
-  auto channels() const -> u32 { return _channels.size(); }
-  auto frequency() const -> f64 { return _frequency; }
-  auto resamplerFrequency() const -> f64 { return _resamplerFrequency; }
-  auto muted() const -> bool { return _muted; }
-
-  auto setChannels(u32 channels) -> void;
-  auto setFrequency(f64 frequency) -> void;
-  auto setResamplerFrequency(f64 resamplerFrequency) -> void;
-  auto setMuted(bool muted) -> void;
-
-  auto resetFilters() -> void;
-  auto addLowPassFilter(f64 cutoffFrequency, u32 order, u32 passes = 1) -> void;
-  auto addHighPassFilter(f64 cutoffFrequency, u32 order, u32 passes = 1) -> void;
-  auto addLowShelfFilter(f64 cutoffFrequency, u32 order, f64 gain, f64 slope) -> void;
-  auto addHighShelfFilter(f64 cutoffFrequency, u32 order, f64 gain, f64 slope) -> void;
-
-  auto pending() const -> bool;
-  auto read(f64 samples[]) -> u32;
-  auto write(const f64 samples[]) -> void;
-
-  template<typename... P>
-  auto frame(P&&... p) -> void {
-    if(runAhead()) return;
-    f64 samples[sizeof...(p)] = {forward<P>(p)...};
-    write(samples);
-  }
-
-protected:
-  struct Filter {
-    enum class Mode : u32 { OnePole, Biquad } mode;
-    enum class Type : u32 { None, LowPass, HighPass, LowShelf, HighShelf } type;
-    enum class Order : u32 { None, First, Second } order;
-    DSP::IIR::OnePole onePole;
-    DSP::IIR::Biquad biquad;
-  };
-  struct Channel {
-    vector<Filter> filters;
-    vector<DSP::IIR::Biquad> nyquist;
-    DSP::Resampler::Cubic resampler;
-  };
-  vector<Channel> _channels;
-  f64 _frequency = 48000.0;
-  f64 _resamplerFrequency = 48000.0;
-  bool _muted = false;
-};

ares/ares/node/class.hpp

@@ -1,34 +0,0 @@
-//horrible implementation of run-time introspection:
-//allow converting a unique class string to a derived Node type.
-
-struct Class {
-  struct Instance {
-    const string identifier;
-    const function<Node::Object ()> create;
-  };
-
-  static auto classes() -> vector<Instance>& {
-    static vector<Instance> classes;
-    return classes;
-  }
-
-  template<typename T> static auto register() -> void {
-    if(!classes().find([&](auto instance) { return instance.identifier == T::identifier(); })) {
-      classes().append({T::identifier(), &T::create});
-    } else {
-      throw;
-    }
-  }
-
-  static auto create(string identifier) -> Node::Object {
-    if(auto index = classes().find([&](auto instance) { return instance.identifier == identifier; })) {
-      return classes()[*index].create();
-    }
-    if(identifier == "Object") throw;  //should never occur: detects unregistered classes
-    return create("Object");
-  }
-
-  template<typename T> struct Register {
-    Register() { Class::register<T>(); }
-  };
-};

ares/ares/node/component/component.hpp

@@ -1,4 +0,0 @@
-struct Component : Object {
-  DeclareClass(Component, "component");
-  using Object::Object;
-};

ares/ares/node/component/real-time-clock.hpp

@@ -1,30 +0,0 @@
-struct RealTimeClock : Component {
-  DeclareClass(RealTimeClock, "component.real-time-clock")
-  using Component::Component;
-
-  auto update() -> void { if(_update) return _update(); }
-  auto timestamp() const -> u64 { return _timestamp; }
-
-  auto setUpdate(function<void ()> update) -> void { _update = update; }
-  auto setTimestamp(u64 timestamp) -> void { _timestamp = timestamp; }
-
-  auto synchronize(u64 timestamp = 0) -> void {
-    if(!timestamp) timestamp = chrono::timestamp();
-    _timestamp = timestamp;
-    update();
-  }
-
-  auto serialize(string& output, string depth) -> void override {
-    Component::serialize(output, depth);
-    output.append(depth, "  timestamp: ", _timestamp, "\n");
-  }
-
-  auto unserialize(Markup::Node node) -> void override {
-    Component::unserialize(node);
-    _timestamp = node["timestamp"].natural();
-  }
-
-protected:
-  function<void ()> _update;
-  u64 _timestamp;
-};

ares/ares/node/debugger/debugger.hpp

@@ -1,4 +0,0 @@
-struct Debugger : Object {
-  DeclareClass(Debugger, "debugger")
-  using Object::Object;
-};

ares/ares/node/debugger/graphics.hpp

@@ -1,26 +0,0 @@
-struct Graphics : Debugger {
-  DeclareClass(Graphics, "debugger.graphics")
-
-  Graphics(string name = {}) : Debugger(name) {
-  }
-
-  auto width() const -> u32 { return _width; }
-  auto height() const -> u32 { return _height; }
-  auto capture() const -> vector<u32> { if(_capture) return _capture(); return {}; }
-
-  auto setSize(u32 width, u32 height) -> void { _width = width, _height = height; }
-  auto setCapture(function<vector<u32> ()> capture) -> void { _capture = capture; }
-
-  auto serialize(string& output, string depth) -> void override {
-    Debugger::serialize(output, depth);
-  }
-
-  auto unserialize(Markup::Node node) -> void override {
-    Debugger::unserialize(node);
-  }
-
-protected:
-  u32 _width = 0;
-  u32 _height = 0;
-  function<vector<u32> ()> _capture;
-};