Mirrors/sf2000
2
0
Fork 0
mirror of https://github.com/vonmillhausen/sf2000.git synced 2024-11-08 19:15:12 +01:00
Code Issues Packages Projects Releases Wiki Activity
857b5bccea
sf2000/tools/buttonMappingChanger.htm

564 lines
31 KiB
HTML
Raw Normal View History

Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
<!DOCTYPE html>
<html lang="en">
<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8">
<title>Data Frog SF2000 Button Mapping Tool</title>
<meta name="viewport" content="width=device-width">
Moved tool CSS to shared CSS file Just for future flexibility, moved the CSS from each individual tool to a shared CSS library
2023-06-26 14:19:47 +02:00
<link rel="stylesheet" href="tools.css">
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
</head>
<body>
<h1>Data Frog SF2000 Button Mapping Tool</h1>
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
<p>This tool lets you alter the button mappings for the SF2000 hand-held console; it can generate per-game mappings (NOTE: only possible on firmwares prior to the May 15th firmware), as well as alter the global mappings defined in the device's <code>bisrv.asd</code> BIOS file or in the <code>KeyMapInfo.kmp</code> file used by newer BIOS versions. As the SF2000 supports multiplayer gaming via an optional wireless controller (sold separately), mappings for both Player 1 and Player 2 are possible.</p>
<p> Please note this tool is provided as-is, and no support will be given if this corrupts your device's BIOS or keymap file; make sure you have backups of anything you care about before messing with your device's critical files! 🙂</p>
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
<p>This tool was originally written by nikita.burnashev (email) gmail.com; it was re-written (mostly just re-styled) by myself upon their request.</p>
<hr>
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
<div id="steps">
<section id="fileSection">
<h2>Step 1: Select <code>bisrv.asd</code> or a game ROM</h2>
<p>Select the <code>bisrv.asd</code> (for global device mappings) or game ROM file (for per-game mappings) whose button mappings you want to modify. You can find the <code>bisrv.asd</code> file in the <code>bios</code> folder on your device's microSD card.</p>
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
<div id="fileMessages"></div>
<div class="controlContainer">
<label class="control">Open file: <input id="fileSelector" type="file" onchange="fileLoad(event.target.files[0])"></label>
</div>
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
</section>
</div>
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
<script src="tools.js"></script>
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
<script>
// Global variables...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let mappingTableOffset; // Will contain the offset of the button mappings within the data file
let mappingConsoles; // Will contain a list of the specific game consoles we'll be setting up mappings for
let firmwareVersion; // Will contain the firmware version if the user selects a bisrv.asd file
let mappingData; // Used to store the binary data that will eventually be written to the downloadable file
let fileName; // Will hold the name of the selected file, used for naming ROM .kmp files
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Utility function: getButtonMap(int index)
// =========================================
// This function returns data about how given buttons on the SF2000
// map to controls provided by the device's emulators.
// Thanks to @notv37 :)
// https://discord.com/channels/741895796315914271/1099465777825972347/1104285497804738640
function getButtonMap(index) {
if (mappingConsoles[index] == "Genesis/Mega Drive, Master System")
return { 'A': 8, 'B': 0, 'C': 1, 'X': 10, 'Y': 11, 'Z': 9 };
else if (mappingConsoles[index] == "Arcade") // FIXME
return { 'A': 8, 'B': 0, 'C': 1, 'X': 10, 'Y': 11, 'Z': 9 };
else if (mappingConsoles[index] == "SNES")
return { 'A': 8, 'B': 0, 'X': 10, 'Y': 11, 'L': 9, 'R': 1 };
else // GBA, GB/GBC, NES
return { 'A': 8, 'B': 0, 'L': 10, 'R': 11, 'X': 9, 'Y': 1 };
}
// This function is called whenever a file is selected in Step 1...
function fileLoad(file) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// Create a FileReader object, and read in the selected file's contents
// as an array buffer...
const fr = new FileReader();
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
fr.readAsArrayBuffer(file);
fr.onload = function(event) {
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Clear out any HTML that might already exist after Step 1...
while(document.getElementById("fileSection").nextSibling) {
document.getElementById("fileSection").nextSibling.remove();
}
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Clear any old messages...
document.getElementById("fileMessages").innerHTML = "";
// We'll also reset the firmwareVersion global variable...
firmwareVersion = null;
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// Read the provided file's data from the buffer array into an
// unsigned 8-bit int array...
const data = new Uint8Array(event.target.result);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// We'll do a hash-check against it, even if it's not a bisrv.asd...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const hashResult = getFirmwareHash(data);
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The result could be either a Promise if it had a bisrv.asd-like
// structure and we got a hash, or false otherwise... let's check!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
if (hashResult instanceof Promise) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// We got a Promise! Wait for it to finish so we get our bisrv.asd
// hash...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
hashResult.then(function(dataHash) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// If we have a newer bisrv.asd that stores button mappings in an
// external KeyMapInfo.kmp, we'll need a Step 1b to load that file
// as well...
let step1BRequired = false;
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Check the hash against all the known good ones...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
firmwareVersion = knownHash(dataHash);
switch (firmwareVersion) {
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Mid-March BIOS...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
case "03.15":
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingTableOffset = 0x8DBC0C;
mappingConsoles = ["Arcade", "Game Boy Advance", "SNES", "Genesis/Mega Drive, Master System", "NES, Game Boy, Game Boy Color"];
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("info", "fileMessages", "INFO: Mid-March <code>bisrv.asd</code> detected.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
break;
// April 20th BIOS...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
case "04.20":
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingTableOffset = 0x8DBC9C;
mappingConsoles = ["Arcade", "Game Boy Advance", "Game Boy, Game Boy Color", "SNES", "Genesis/Mega Drive, Master System", "NES"];
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("info", "fileMessages", "INFO: April 20th <code>bisrv.asd</code> detected.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
break;
// May 15th BIOS...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
case "05.15":
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingTableOffset = 0;
mappingConsoles = ["NES", "Genesis/Mega Drive, Master System", "SNES", "Game Boy, Game Boy Color", "Game Boy Advance", "Arcade"];
step1BRequired = true;
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("info", "fileMessages", "INFO: May 15th <code>bisrv.asd</code> detected.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
break;
// May 22nd BIOS...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
case "05.22":
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingTableOffset = 0;
mappingConsoles = ["NES", "SNES", "Genesis/Mega Drive, Master System", "Game Boy, Game Boy Color", "Game Boy Advance", "Arcade"];
step1BRequired = true;
Updated tools to support firmware 1.71 Data Frog released firmware 1.71, a quick bug-fixed version of firmware 1.7, so added support for it to the tools I host
2023-10-19 15:31:40 +02:00
setMessage("info", "fileMessages", "INFO: Version 1.5 <code>bisrv.asd</code> detected.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
break;
Added support for the new "August 3rd" BIOS There's a new BIOS revision floating around (MD5 hash first posted in Discord on August 3rd); no official announcement from Data Frog about it yet, but I've gone ahead and added support for it to the Boot Logo Changer and the Button Mapping Changer tools
2023-08-19 18:45:25 +02:00
// August 3rd BIOS...
case "08.03":
mappingTableOffset = 0;
mappingConsoles = ["NES", "SNES", "Genesis/Mega Drive, Master System", "Game Boy, Game Boy Color", "Game Boy Advance", "Arcade"];
step1BRequired = true;
Updated tools to support firmware 1.71 Data Frog released firmware 1.71, a quick bug-fixed version of firmware 1.7, so added support for it to the tools I host
2023-10-19 15:31:40 +02:00
setMessage("info", "fileMessages", "INFO: Version 1.6 <code>bisrv.asd</code> detected.");
Added support for the new "August 3rd" BIOS There's a new BIOS revision floating around (MD5 hash first posted in Discord on August 3rd); no official announcement from Data Frog about it yet, but I've gone ahead and added support for it to the Boot Logo Changer and the Button Mapping Changer tools
2023-08-19 18:45:25 +02:00
break;
Updated for October 7th/1.7 BIOS version Looks like there's a new official firmware version out, and it's got a critical bug with SNES save states - avoid this one! Updated the tools I host to support the new firmware, complete with warnings about it. Also updated the main Github document with the first details about the firmware, more will come later when my own download of it has completed.
2023-10-12 12:24:01 +02:00
// October 7th BIOS...
case "10.07":
mappingTableOffset = 0;
mappingConsoles = ["NES", "SNES", "Genesis/Mega Drive, Master System", "Game Boy, Game Boy Color", "Game Boy Advance", "Arcade"];
step1BRequired = true;
Updated tools to support firmware 1.71 Data Frog released firmware 1.71, a quick bug-fixed version of firmware 1.7, so added support for it to the tools I host
2023-10-19 15:31:40 +02:00
setMessage("warning", "fileMessages", "WARNING: Version 1.7 <code>bisrv.asd</code> detected; this version has known issues with SNES save states and is not recommended for use.");
break;
// October 13th BIOS...
case "10.13":
mappingTableOffset = 0;
mappingConsoles = ["NES", "SNES", "Genesis/Mega Drive, Master System", "Game Boy, Game Boy Color", "Game Boy Advance", "Arcade"];
step1BRequired = true;
setMessage("info", "fileMessages", "INFO: Version 1.71 <code>bisrv.asd</code> detected.");
Updated for October 7th/1.7 BIOS version Looks like there's a new official firmware version out, and it's got a critical bug with SNES save states - avoid this one! Updated the tools I host to support the new firmware, complete with warnings about it. Also updated the main Github document with the first details about the firmware, more will come later when my own download of it has completed.
2023-10-12 12:24:01 +02:00
break;
Added support for the new "August 3rd" BIOS There's a new BIOS revision floating around (MD5 hash first posted in Discord on August 3rd); no official announcement from Data Frog about it yet, but I've gone ahead and added support for it to the Boot Logo Changer and the Button Mapping Changer tools
2023-08-19 18:45:25 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
default:
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// Huh... wasn't false so had bisrv.asd structure, but didn't
// return a known hash... a new BIOS version? Unknown anyway!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
console.log(dataHash);
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("error", "fileMessages", "ERROR: While the file you've selected does appear to be generally structured like the SF2000's <code>bisrv.asd</code> BIOS file, the specifics of your file don't match any known SF2000 BIOS version. As such, this tool cannot safely modify the selected file.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
return;
break;
}
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// If we're here, then we got some kind bisrv.asd file we're happy
// with; we'll set mappingData to it's full contents...
mappingData = data.slice();
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Keep a record of the input file's name as well...
fileName = file.name;
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// Check if we need a KeyMapInfo.kmp file to be provided as
// well...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
if (step1BRequired) {
// Yup, we're going to need a KeyMapInfo.kmp file as well...
stepOneB();
}
else {
// Nope, we're all good; go ahead call our Step Two function...
stepTwo();
}
});
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
else {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// We got false, so whatever it was, it wasn't a bisrv.asd... let's
// check some other possibilities...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
if (data.length == 288) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// That's the correct length for a KeyMapInfo.kmp file, however we
// must know the host BIOS version before we can correctly process
// those files. Let the user know...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("error", "fileMessages", "ERROR: The file you've provided may be a <code>KeyMapInfo.kmp</code> button map file; however as the internal data structure of these files varies depending on the version of the host BIOS, you must select your device's <code>bisrv.asd</code> file first. You can find this file in the <code>bios</code> folder on your device's microSD card.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
return;
}
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// If we're still checking, next test the file extensions for the
// individual console's ROMs...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
else if (/\.(zfb|zip)$/i.exec(file.name)) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The file's name ends with .zfb or .zip - assume it's an arcade
// ROM!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingConsoles = ["Arcade"];
}
else if (/\.(zgb|gba|agb|gbz)$/i.exec(file.name)) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The file's name ends with .zgb, .gba, .agb or .gbz - assume
// it's a Game Boy Advance ROM!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingConsoles = ["Game Boy Advance"];
}
else if (/\.(gbc|gb|sgb)$/i.exec(file.name)) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The file's name ends with .gbc, .gb or .sgb - assume it's a
// Game Boy or Game Boy Color ROM!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingConsoles = ["Game Boy, Game Boy Color"];
}
else if (/\.(zsf|smc|fig|sfc|gd3|gd7|dx2|bsx|swc)$/i.exec(file.name)) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The file's name ends with .zsf, .smc, .fig, .sfc, .gd3, .gd7,
// .dx2, .bsx or .swc - assume it's a SNES ROM!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingConsoles = ["SNES"];
}
else if (/\.(zmd|bin|md|smd|gen|sms)$/i.exec(file.name)) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The file's name ends with .zmd, .bin, .md, .smd, .gen or .sms,
// assume it's a Genesis/Mega Drive or Master System ROM!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingConsoles = ["Genesis/Mega Drive, Master System"];
}
else if (/\.(zfc|nes|nfc|fds|unf)$/i.exec(file.name)) {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// The file's name ends with .zfc, .nes, .nfc, .fds or .unf,
// assume it's a NES ROM!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingConsoles = ["NES"];
}
else {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// Oh dear, the provided file didn't match any of the above rules!
// Display an error to the user...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("error", "fileMessages", "ERROR: The selected file does not appear to be a known <code>bisrv.asd</code> file, a <code>KeyMapInfo.kmp</code> file, or a game ROM with a known extension!");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
return;
}
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
// If we're here, then we got some kind of non-bisrv.asd file we're
// happy with. If mappingConsoles only contains one entry, then it
// was a ROM file, and we'll want to initialise our mappingData
// array with 48 slots; otherwise, it was a KeyMapInfo.kmp and we'll
// set mappingData to it's full contents instead...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
if (mappingConsoles.length == 1) {
mappingData = new Uint8Array(48);
}
else {
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
mappingData = data.slice();
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
}
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// In both cases, the mapping data begins at the very start of our data stream...
mappingTableOffset = 0;
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Keep a record of the input file's name as well...
fileName = file.name;
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Go ahead call our Step Two function...
stepTwo();
}
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// This function is called if the file selected in Step 1 is a bisrv.asd
// version that relies on an external KeyMapInfo.kmp file - so we also
// need the user to supply that...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
function stepOneB() {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Build our HTML...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let html = "<section id=\"stepOneB\"><h2>Step 1b: Select <code>KeyMapInfo.kmp</code></h2><p>This version of the SF2000 BIOS reads its button mappings from an external file called <code>KeyMapInfo.kmp</code>, stored in the <code>Resources</code> folder on the microSD card. Please select your device's <code>KeyMapInfo.kmp</code> file now.</p><div id=\"stepOneBMessages\"></div><div class=\"controlContainer\"><label class=\"control\">Open <code>KeyMapInfo.kmp</code>: <input id=\"keyMapInfoSelector\" type=\"file\" accept=\".kmp\"></label></div></section>";
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Add a <hr> separator after the last step, and append the new step...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
document.getElementById("steps").insertAdjacentHTML("beforeend", "<hr>");
document.getElementById("steps").insertAdjacentHTML("beforeend", html);
// Attach our event handler to our new file input control...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const keyMapInfoInput = document.getElementById("keyMapInfoSelector");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
keyMapInfoInput.addEventListener("change", function() {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// The user has chosen a new file; it should be a KeyMapInfo.kmp file,
// so let's do our best to check!
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// First, clear out any HTML that might already exist after Step 1b...
while(document.getElementById("stepOneB").nextSibling) {
document.getElementById("stepOneB").nextSibling.remove();
}
// Clear any old messages...
document.getElementById("stepOneBMessages").innerHTML = "";
// Next, read in the contents of the user-provided file...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const frKMI = new FileReader();
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
fileName = event.target.files[0].name;
frKMI.readAsDataURL(event.target.files[0]);
frKMI.onload = function(event) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Get the file's data and data type...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const fileData = event.target.result;
const dataType = fileData.substring(5, fileData.indexOf(";"));
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Check to make sure the data type is binary...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
if (dataType === "application/octet-stream") {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// The user selected a file that appears to contain binary data; it's
// a good candidate! Let's check its length next...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const base64Data = fileData.substring(fileData.indexOf(",") + 1);
const binaryData = atob(base64Data);
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
if (binaryData.length == 288) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// It's the right length - let's assume it's a KeyMapInfo.kmp!
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// We'll assign it to our global mappingData variable, and
// we'll proceed to Step 2...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingData = new Uint8Array(binaryData.length);
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
for (let i = 0; i < binaryData.length; i++) {
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
mappingData[i] = binaryData.charCodeAt(i);
}
stepTwo();
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
}
else {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Wrong length for a KeyMapInfo.kmp file!
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("error", "stepOneBMessages", "ERROR: The selected file does not appear to be a valid <code>KeyMapInfo.kmp</code> file.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
return;
}
}
else {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// The file the user selected doesn't appear to be binary data, so
// highly unlikely to be a KeyMapInfo.kmp file...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
setMessage("error", "stepOneBMessages", "ERROR: The selected file does not appear to be a valid <code>KeyMapInfo.kmp</code> file.");
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
return;
}
}
});
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// This function triggers automatically when the user selects a valid
// file (or files) in Step 1...
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
function stepTwo() {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// We're going to be creating a bunch of HTML here; we want to display
// banks of mapping controls to the user, one bank per console. Each
// bank will have a heading specifying which console it's for, and then
// a section each for Player 1 and Player 2. Each player section will
// have a list of the six SF2000 buttons that are available to be
// mapped, and for each a selection box of the target console's buttons
// for the mapping. There'll also be a checkbox per button, which can
// be checked to enable "autofire" on that button.
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let html = "<section id=\"mappingSection\"><h2>Step 2: Choose your button mappings</h2>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// First, we need to update Step 2's instructions, depending on whether
// or not the user supplied a bisrv.asd file or KeyMapInfo.kmp
// (multiple consoles) or a ROM (one console)...
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
if (mappingConsoles.length > 1) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
// They provided a bisrv.asd or a KeyMapInfo.kmp file!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<p>Below you will see the current global button mappings for the file you provided. Each tile covers the button mappings for a different game console - the physical SF2000 buttons are on the left, and the virtual console buttons are in the middle. On the right are some \"autofire\" checkboxes - if the box for a button is checked, it means holding that button down will trigger multiple repeated button presses in the virtual console automatically. As the SF2000 supports local multiplayer via the use of a second wireless controller, there are <i>two</i> sets of button mappings per console - one for Player 1 and one for Player 2. When you have finished tweaking your button mappings, proceed to Step 3.</p>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
else {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// They provided a ROM file!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<p>Below you will see an empty \"" + mappingConsoles[0] + "\" button mapping table, which will be used to create a unique button mapping profile for \"" + fileName + "\". In the table, the physical SF2000 buttons are on the left, and the virtual console buttons are in the middle. On the right are some \"autofire\" checkboxes - if the box for a button is checked, it means holding that button down will trigger multiple repeated button presses in the virtual console automatically. As the SF2000 supports local multiplayer via the use of a second wireless controller, there are <i>two</i> sets of button mappings per console - one for Player 1 and one for Player 2. When you have finished tweaking your button mappings, proceed to Step 3.</p>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
html += "<div class=\"controlContainer\">";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Next we'll be looping through all of the consoles we'll be setting
// up mappings for...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const presentationButtonOrder = ['A', 'B' ,'X', 'Y', 'L', 'R'];
for (let currentConsole = 0; currentConsole < mappingConsoles.length; currentConsole++) {
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// This console's bank of mapping controls will be stored in a <div>,
// and we'll add a <h3> header for good measure as well...
html += "<div class=\"control\"><h3>" + mappingConsoles[currentConsole] + "</h3>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Get the button mapping for this console...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const buttonMap = getButtonMap(currentConsole);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// We'll add two tables of control mappings to the <div>, one each
// for Player 1 and Player 2...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
for (let player = 0; player < 2; player++) {
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Start creating our table HTML...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<table><caption>Player " + (player + 1) + "</caption>";
html += "<thead><tr><th class=\"alignL\">SF2000</th><th>Console</th><th>Autofire</th></tr></thead>";
html += "<tbody>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Loop through all the SF2000's buttons (well, the ones that can
// be mapped, anyway)...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
for (let button = 0; button < 6; button++) {
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// By default, the SF2000 stores its button maps in XYLABR
// order... except for GBA under newer firmware versions where
// the order is LRXABY for some reason. We specify the order the
// bytes are in here. If they do other weird stuff in the future,
// it'll probably be here that needs to change!
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let buttonByteOrder = ['X', 'Y' ,'L', 'A', 'B', 'R'];
Updated tools to support firmware 1.71 Data Frog released firmware 1.71, a quick bug-fixed version of firmware 1.7, so added support for it to the tools I host
2023-10-19 15:31:40 +02:00
if (mappingConsoles[currentConsole] == "Game Boy Advance" && ["05.15", "05.22", "08.03", "10.07", "10.13"].includes(firmwareVersion)) {
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
buttonByteOrder = ['L', 'R', 'X', 'A', 'B', 'Y'];
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Calculate our offset within our mapping data for the current
// button...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const offset = mappingTableOffset + (currentConsole * 48) + (player * 24) + (buttonByteOrder.indexOf(presentationButtonOrder[button]) * 4);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Start creating the HTML data for this row in the table...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<tr>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// SF2000 Button Name (e.g., "Player 1 X")...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<td>Player " + (player + 1).toString() + " " + presentationButtonOrder[button] + "</td>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Console button selection list...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<td class=\"alignC\">";
html += "<select id=\"sel" + offset.toString(16) + "\">";
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
for (let buttonTable in buttonMap) {
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<option ";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
if (mappingData[offset] == buttonMap[buttonTable]) {
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "selected";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += ">" + buttonTable + "</option>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "</select></td>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Autofire checkbox...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<td class=\"alignC\"><input id=\"cb" + offset.toString(16) + "\" type=\"checkbox\"";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
if (mappingData[offset + 2] == 1) {
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += " checked";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "></td>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// And we're finished with the row...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "</tr>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
// Close off our table body, and add it to the console's <div>...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "</tbody></table>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// Finally, close this console's <div>...
html += "</div>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
// And finally finally, close the mappingControls <div>...
html += "</div>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// OK, we're all done displaying our mapping table HTML; trigger Step 3's setup...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
document.getElementById("steps").insertAdjacentHTML("beforeend", "<hr>");
document.getElementById("steps").insertAdjacentHTML("beforeend", html);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
stepThreeSetup();
}
function stepThreeSetup() {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// More HTML in this function! We'll display the appropriate
// instructions to the user (either how to replace the
// bisrv.asd/KeyMapInfo.kmp file, or where to put the per-rom .kmp
// file), as well as generate a button that (when clicked) will
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
// download the appropriate file to their device...
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// First, let's clear any HTML that might already exist after Step 2...
while(document.getElementById("mappingSection").nextSibling) {
document.getElementById("mappingSection").nextSibling.remove();
}
// Now let's start building our HTML...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let html = "<section id=\"saveSection\"><h2>Step 3: Save your mapping changes</h2>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// First up, instructions! These will depend on whether they provided a
// bisrv.asd, a KeyMapInfo.kmp, or a game ROM...
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
if (mappingConsoles.length > 1) {
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
if (fileName == "bisrv.asd") {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
// They provided a bisrv.asd file!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<p>Click the Download button below to download a new <code>bisrv.asd</code> BIOS file for the SF2000, with your updated global button mappings baked into it. Use it to replace the existing <code>bisrv.asd</code> file in the <code>bios</code> folder on your device's microSD card.</p>";
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
}
else if (fileName == "KeyMapInfo.kmp") {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
// They provided a KeyMapInfo.kmp file!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<p>Click the Download button below to download a new <code>KeyMapInfo.kmp</code> keymap file for the SF2000, with your updated global button mappings baked into it. Use it to replace the existing <code>KeyMapInfo.kmp</code> file in the <code>Resources</code> folder on your device's microSD card.</p>";
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
}
else {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
// They provided a... something!
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<p>Click the Download button below to download an updated version of your file, with your updated global button mappings baked into it. Use it to replace the existing file on your device's microSD card.</p>";
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
}
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
else {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// They provided a ROM file! To make the instructions clearer, let's
// calculate the name of the keymap file we're generating...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const kmpFileName = fileName.replace(/($|\.[^.]*$)/, function(m, p1) {return p1.toUpperCase() + '.kmp';});
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
// Now the instructions themselves...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
html += "<p>Click the Download button below to download \"" + kmpFileName + "\", a game-specific keymap file for \"" + fileName + "\". Once downloaded, place it in the <code>save</code> subfolder of the folder where the ROM itself is stored. So for example, if \"" + fileName + "\" is in the <code>ROMS</code> folder on your SF2000's microSD card, place the \"" + kmpFileName + "\" file in <code>ROMS/save/</code>. If the <code>save</code> subfolder does not already exist, create it yourself first.</p>";
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Add our download button...
html += "<div class=\"controlContainer\"><div class=\"control\"><input id=\"downloadButton\" type=\"button\" value=\"Download\"></div></div>";
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Close our section...
html += "</section>";
// Finally, add a <hr> separator after the last step, and append the
// new step...
Update buttonMappingChanger.htm Substantially re-written in light of the May 22nd firmware, which had a `bisrv.asd` of the same length as the May 15th firmware, but different in operation - the byte order in `KeyMapInfo.kmp` has been flipped for SNES and Genesis. As there's no way to tell from just looking at a `KeyMapInfo.kmp` what the byte order should be, users must now provide both `bisrv.asd` AND `KeyMapInfo.kmp` files - the `bisrv.asd` is now hash-checked against known versions, and that's used to inform which byte order to use for the `KeyMapInfo.kmp`
2023-05-22 20:42:20 +02:00
document.getElementById("steps").insertAdjacentHTML("beforeend", "<hr>");
document.getElementById("steps").insertAdjacentHTML("beforeend", html);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Let's add the event handler for our Download button...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const dButton = document.getElementById("downloadButton");
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
dButton.addEventListener("click", function() {
// Here, we'll construct the file for the user to download (a
// modified bisrv.asd, a modified KeyMapInfo.kmp, or a .kmp keymap
// file), and send it to the user's browser...
// We need to loop through all of the mapping form data, read its
// settings, and use those settings to build the binary data of our
// button mapping. Loop through all of the consoles we're mapping
// for...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const presentationButtonOrder = ['A', 'B' ,'X', 'Y', 'L', 'R'];
for (let currentConsole = 0; currentConsole < mappingConsoles.length; currentConsole ++) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Get the button mapping for this console...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const buttonMap = getButtonMap(currentConsole);
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// For each player...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
for (let player = 0; player < 2; player++) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// ... and for each button...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
for (let button = 0; button < 6; button++) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// By default, the SF2000 stores its button maps in XYLABR
// order... except for GBA under newer firmware versions where
// the order is LRXABY for some reason. We specify the order
// the bytes are in here. If they do other weird stuff in the
// future, it'll probably be here that needs to change!
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let buttonByteOrder = ['X', 'Y' ,'L', 'A', 'B', 'R'];
Updated tools to support firmware 1.71 Data Frog released firmware 1.71, a quick bug-fixed version of firmware 1.7, so added support for it to the tools I host
2023-10-19 15:31:40 +02:00
if (mappingConsoles[currentConsole] == "Game Boy Advance" && ["05.15", "05.22", "08.03", "10.07", "10.13"].includes(firmwareVersion)) {
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
buttonByteOrder = ['L', 'R', 'X', 'A', 'B', 'Y'];
}
// Calculate the offset in our mapping data for the current
// button, read the button settings from the HTML controls, and
// assign the appropriate values to our binary mappingData...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
const offset = mappingTableOffset + (currentConsole * 48) + (player * 24) + (buttonByteOrder.indexOf(presentationButtonOrder[button]) * 4);
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
mappingData[offset] = buttonMap[document.getElementById("sel" + offset.toString(16)).value];
mappingData[offset + 2] = document.getElementById("cb" + offset.toString(16)).checked ? 1 : 0;
Update buttonMappingChanger.htm Updated to support the new May 15th firmware. Also took the opportunity to make a few tweaks, including presenting the button tables in a more standard "ABXYLR" order, regardless of the byte-order in the actual SF2000 data files
2023-05-16 19:13:48 +02:00
}
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Now that we've got our updated data, we'll need to check if it's
// an updated bisrv.asd or not - if it is, we'll need to update some
// CRC32 check-bits in the bisrv.asd data as well...
if (mappingConsoles.length > 1 && fileName == "bisrv.asd") {
// It's a bisrv.asd alright! Let's do the CRC32 update dance...
patchCRC32(mappingData);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// Next, let's determine the name of the file we're going to send to
// the user's browser...
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
let downloadFileName = fileName;
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
if (mappingConsoles.length == 1) {
downloadFileName = downloadFileName.replace(/($|\.[^.]*$)/, function(m, p1) {return p1.toUpperCase() + '.kmp';});
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
// And finally, send the data to the user's browser as a download...
downloadToBrowser(mappingData, "application/octet-stream", downloadFileName);
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
Transitioned to shared Javascript library There was a lot of repeated JS across all my tools (e.g., image conversion, BIOS hash checking, etc.), and so I decided to move all shared code out to its own separate library. This will improve scalability and maintainability at the cost of portability - a fair trade in my opinion. This work also involved large-scale refactoring of all of the tools. There's no actual functional difference (all the tools should behave exactly the same), bar some UI improvements for the oldest tools as a result of moving to the same codebase used by the more recent tools.
2023-06-26 15:11:01 +02:00
});
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
}
</script>
<hr>
Tool updates... This was just supposed to be a new feature for the generic image tool (dithering support), but while working on that things kind of snowballed 😅 * Added dithering support to the generic image tool and the boot logo changer, when converting images to RGB565 format. This uses a Bayer 8x8 matrix, and the overall "strength" of the dither can be controlled - it defaults to what I feel is a sane value. Dithering can help reduce banding effects due to the low colour depth in RGB565. * Made "fix" scaling mode more flexible in the generic image tool - now there's checkboxes beside the width and height dimensions - if you un-check one, the other dimension will be calculated automatically to keep the input's aspect ratio intact * Improved downscaling quality in the generic image tool. While working on the dithering feature, I discovered the previous "gaussian resampling" downscaling method I was using introduced distortion in certain situations. I had a lot of fun playing around with possible replacements (I tried 10 new downscaling functions!), and finally settled on a hybrid function that mixes powers-of-two downscaling (with some custom mipmap style cross-blending) with Hermite interpolation. This new method is reasonably quick, gives clean results with no great distortion, and works well with alpha channels (doesn't introduce any dark fringing) * Generic image tool now shows the dimensions of the output image * Added a max width on the main tool page bodies, so that they don't get so wide on full-screen desktop browsers * Fixed a few edge-case logic bugs here and there (e.g., when upscaling only a single dimensions with the generic image tool, or places where I thought I was copying objects, but was only creating references to them, etc.) * Switched from using "var" declarations across all tool codebases to "let" or "const" instead * Switched out the SVG alert icons to just use emoji instead * Various other nips and tucks (fixed up my arbitrary 80-column comment wrapping on the tools that had previously just been eye-balled, fixed a few comment typos, etc.)
2024-05-14 21:20:57 +02:00
<p><a rel="license" href="https://creativecommons.org/publicdomain/zero/1.0/">CC0</a>: public domain. Version 1.6, 20240514.1</p>
Added my version of osaka's key mapping tool
2023-05-10 16:32:01 +02:00
</body>
</html>
Reference in New Issue Copy Permalink