Compare commits
No commits in common. '7ea04b949990d516fe4afc8c7285329373821651' and '5979eddc21a09ae71b7b3ddb31fd14078f2a7c2c' have entirely different histories.
7ea04b9499
...
5979eddc21
@ -0,0 +1,8 @@ |
||||
root=true |
||||
|
||||
[*] |
||||
indent_style = space |
||||
|
||||
[*.{cpp,cs,h}] |
||||
indent_size = 4 |
||||
|
||||
@ -1,63 +0,0 @@ |
||||
############################################################################### |
||||
# Set default behavior to automatically normalize line endings. |
||||
############################################################################### |
||||
* text=auto |
||||
|
||||
############################################################################### |
||||
# Set default behavior for command prompt diff. |
||||
# |
||||
# This is need for earlier builds of msysgit that does not have it on by |
||||
# default for csharp files. |
||||
# Note: This is only used by command line |
||||
############################################################################### |
||||
#*.cs diff=csharp |
||||
|
||||
############################################################################### |
||||
# Set the merge driver for project and solution files |
||||
# |
||||
# Merging from the command prompt will add diff markers to the files if there |
||||
# are conflicts (Merging from VS is not affected by the settings below, in VS |
||||
# the diff markers are never inserted). Diff markers may cause the following |
||||
# file extensions to fail to load in VS. An alternative would be to treat |
||||
# these files as binary and thus will always conflict and require user |
||||
# intervention with every merge. To do so, just uncomment the entries below |
||||
############################################################################### |
||||
#*.sln merge=binary |
||||
#*.csproj merge=binary |
||||
#*.vbproj merge=binary |
||||
#*.vcxproj merge=binary |
||||
#*.vcproj merge=binary |
||||
#*.dbproj merge=binary |
||||
#*.fsproj merge=binary |
||||
#*.lsproj merge=binary |
||||
#*.wixproj merge=binary |
||||
#*.modelproj merge=binary |
||||
#*.sqlproj merge=binary |
||||
#*.wwaproj merge=binary |
||||
|
||||
############################################################################### |
||||
# behavior for image files |
||||
# |
||||
# image files are treated as binary by default. |
||||
############################################################################### |
||||
#*.jpg binary |
||||
#*.png binary |
||||
#*.gif binary |
||||
|
||||
############################################################################### |
||||
# diff behavior for common document formats |
||||
# |
||||
# Convert binary document formats to text before diffing them. This feature |
||||
# is only available from the command line. Turn it on by uncommenting the |
||||
# entries below. |
||||
############################################################################### |
||||
#*.doc diff=astextplain |
||||
#*.DOC diff=astextplain |
||||
#*.docx diff=astextplain |
||||
#*.DOCX diff=astextplain |
||||
#*.dot diff=astextplain |
||||
#*.DOT diff=astextplain |
||||
#*.pdf diff=astextplain |
||||
#*.PDF diff=astextplain |
||||
#*.rtf diff=astextplain |
||||
#*.RTF diff=astextplain |
||||
@ -1,363 +1,5 @@ |
||||
## Ignore Visual Studio temporary files, build results, and |
||||
## files generated by popular Visual Studio add-ons. |
||||
## |
||||
## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore |
||||
|
||||
# User-specific files |
||||
*.rsuser |
||||
*.suo |
||||
.vs |
||||
*.user |
||||
*.userosscache |
||||
*.sln.docstates |
||||
|
||||
# User-specific files (MonoDevelop/Xamarin Studio) |
||||
*.userprefs |
||||
|
||||
# Mono auto generated files |
||||
mono_crash.* |
||||
|
||||
# Build results |
||||
[Dd]ebug/ |
||||
[Dd]ebugPublic/ |
||||
[Rr]elease/ |
||||
[Rr]eleases/ |
||||
x64/ |
||||
x86/ |
||||
[Ww][Ii][Nn]32/ |
||||
[Aa][Rr][Mm]/ |
||||
[Aa][Rr][Mm]64/ |
||||
bld/ |
||||
[Bb]in/ |
||||
[Oo]bj/ |
||||
[Oo]ut/ |
||||
[Ll]og/ |
||||
[Ll]ogs/ |
||||
|
||||
# Visual Studio 2015/2017 cache/options directory |
||||
.vs/ |
||||
# Uncomment if you have tasks that create the project's static files in wwwroot |
||||
#wwwroot/ |
||||
|
||||
# Visual Studio 2017 auto generated files |
||||
Generated\ Files/ |
||||
|
||||
# MSTest test Results |
||||
[Tt]est[Rr]esult*/ |
||||
[Bb]uild[Ll]og.* |
||||
|
||||
# NUnit |
||||
*.VisualState.xml |
||||
TestResult.xml |
||||
nunit-*.xml |
||||
|
||||
# Build Results of an ATL Project |
||||
[Dd]ebugPS/ |
||||
[Rr]eleasePS/ |
||||
dlldata.c |
||||
|
||||
# Benchmark Results |
||||
BenchmarkDotNet.Artifacts/ |
||||
|
||||
# .NET Core |
||||
project.lock.json |
||||
project.fragment.lock.json |
||||
artifacts/ |
||||
|
||||
# ASP.NET Scaffolding |
||||
ScaffoldingReadMe.txt |
||||
|
||||
# StyleCop |
||||
StyleCopReport.xml |
||||
|
||||
# Files built by Visual Studio |
||||
*_i.c |
||||
*_p.c |
||||
*_h.h |
||||
*.ilk |
||||
*.meta |
||||
*.obj |
||||
*.iobj |
||||
*.pch |
||||
*.pdb |
||||
*.ipdb |
||||
*.pgc |
||||
*.pgd |
||||
*.rsp |
||||
*.sbr |
||||
*.tlb |
||||
*.tli |
||||
*.tlh |
||||
*.tmp |
||||
*.tmp_proj |
||||
*_wpftmp.csproj |
||||
*.log |
||||
*.vspscc |
||||
*.vssscc |
||||
.builds |
||||
*.pidb |
||||
*.svclog |
||||
*.scc |
||||
|
||||
# Chutzpah Test files |
||||
_Chutzpah* |
||||
|
||||
# Visual C++ cache files |
||||
ipch/ |
||||
*.aps |
||||
*.ncb |
||||
*.opendb |
||||
*.opensdf |
||||
*.sdf |
||||
*.cachefile |
||||
*.VC.db |
||||
*.VC.VC.opendb |
||||
|
||||
# Visual Studio profiler |
||||
*.psess |
||||
*.vsp |
||||
*.vspx |
||||
*.sap |
||||
|
||||
# Visual Studio Trace Files |
||||
*.e2e |
||||
|
||||
# TFS 2012 Local Workspace |
||||
$tf/ |
||||
|
||||
# Guidance Automation Toolkit |
||||
*.gpState |
||||
|
||||
# ReSharper is a .NET coding add-in |
||||
_ReSharper*/ |
||||
*.[Rr]e[Ss]harper |
||||
*.DotSettings.user |
||||
|
||||
# TeamCity is a build add-in |
||||
_TeamCity* |
||||
|
||||
# DotCover is a Code Coverage Tool |
||||
*.dotCover |
||||
|
||||
# AxoCover is a Code Coverage Tool |
||||
.axoCover/* |
||||
!.axoCover/settings.json |
||||
|
||||
# Coverlet is a free, cross platform Code Coverage Tool |
||||
coverage*.json |
||||
coverage*.xml |
||||
coverage*.info |
||||
|
||||
# Visual Studio code coverage results |
||||
*.coverage |
||||
*.coveragexml |
||||
|
||||
# NCrunch |
||||
_NCrunch_* |
||||
.*crunch*.local.xml |
||||
nCrunchTemp_* |
||||
|
||||
# MightyMoose |
||||
*.mm.* |
||||
AutoTest.Net/ |
||||
|
||||
# Web workbench (sass) |
||||
.sass-cache/ |
||||
|
||||
# Installshield output folder |
||||
[Ee]xpress/ |
||||
|
||||
# DocProject is a documentation generator add-in |
||||
DocProject/buildhelp/ |
||||
DocProject/Help/*.HxT |
||||
DocProject/Help/*.HxC |
||||
DocProject/Help/*.hhc |
||||
DocProject/Help/*.hhk |
||||
DocProject/Help/*.hhp |
||||
DocProject/Help/Html2 |
||||
DocProject/Help/html |
||||
|
||||
# Click-Once directory |
||||
publish/ |
||||
|
||||
# Publish Web Output |
||||
*.[Pp]ublish.xml |
||||
*.azurePubxml |
||||
# Note: Comment the next line if you want to checkin your web deploy settings, |
||||
# but database connection strings (with potential passwords) will be unencrypted |
||||
*.pubxml |
||||
*.publishproj |
||||
|
||||
# Microsoft Azure Web App publish settings. Comment the next line if you want to |
||||
# checkin your Azure Web App publish settings, but sensitive information contained |
||||
# in these scripts will be unencrypted |
||||
PublishScripts/ |
||||
|
||||
# NuGet Packages |
||||
*.nupkg |
||||
# NuGet Symbol Packages |
||||
*.snupkg |
||||
# The packages folder can be ignored because of Package Restore |
||||
**/[Pp]ackages/* |
||||
# except build/, which is used as an MSBuild target. |
||||
!**/[Pp]ackages/build/ |
||||
# Uncomment if necessary however generally it will be regenerated when needed |
||||
#!**/[Pp]ackages/repositories.config |
||||
# NuGet v3's project.json files produces more ignorable files |
||||
*.nuget.props |
||||
*.nuget.targets |
||||
|
||||
# Microsoft Azure Build Output |
||||
csx/ |
||||
*.build.csdef |
||||
|
||||
# Microsoft Azure Emulator |
||||
ecf/ |
||||
rcf/ |
||||
|
||||
# Windows Store app package directories and files |
||||
AppPackages/ |
||||
BundleArtifacts/ |
||||
Package.StoreAssociation.xml |
||||
_pkginfo.txt |
||||
*.appx |
||||
*.appxbundle |
||||
*.appxupload |
||||
|
||||
# Visual Studio cache files |
||||
# files ending in .cache can be ignored |
||||
*.[Cc]ache |
||||
# but keep track of directories ending in .cache |
||||
!?*.[Cc]ache/ |
||||
|
||||
# Others |
||||
ClientBin/ |
||||
~$* |
||||
*~ |
||||
*.dbmdl |
||||
*.dbproj.schemaview |
||||
*.jfm |
||||
*.pfx |
||||
*.publishsettings |
||||
orleans.codegen.cs |
||||
|
||||
# Including strong name files can present a security risk |
||||
# (https://github.com/github/gitignore/pull/2483#issue-259490424) |
||||
#*.snk |
||||
|
||||
# Since there are multiple workflows, uncomment next line to ignore bower_components |
||||
# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) |
||||
#bower_components/ |
||||
|
||||
# RIA/Silverlight projects |
||||
Generated_Code/ |
||||
|
||||
# Backup & report files from converting an old project file |
||||
# to a newer Visual Studio version. Backup files are not needed, |
||||
# because we have git ;-) |
||||
_UpgradeReport_Files/ |
||||
Backup*/ |
||||
UpgradeLog*.XML |
||||
UpgradeLog*.htm |
||||
ServiceFabricBackup/ |
||||
*.rptproj.bak |
||||
|
||||
# SQL Server files |
||||
*.mdf |
||||
*.ldf |
||||
*.ndf |
||||
|
||||
# Business Intelligence projects |
||||
*.rdl.data |
||||
*.bim.layout |
||||
*.bim_*.settings |
||||
*.rptproj.rsuser |
||||
*- [Bb]ackup.rdl |
||||
*- [Bb]ackup ([0-9]).rdl |
||||
*- [Bb]ackup ([0-9][0-9]).rdl |
||||
|
||||
# Microsoft Fakes |
||||
FakesAssemblies/ |
||||
|
||||
# GhostDoc plugin setting file |
||||
*.GhostDoc.xml |
||||
|
||||
# Node.js Tools for Visual Studio |
||||
.ntvs_analysis.dat |
||||
node_modules/ |
||||
|
||||
# Visual Studio 6 build log |
||||
*.plg |
||||
|
||||
# Visual Studio 6 workspace options file |
||||
*.opt |
||||
|
||||
# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) |
||||
*.vbw |
||||
|
||||
# Visual Studio LightSwitch build output |
||||
**/*.HTMLClient/GeneratedArtifacts |
||||
**/*.DesktopClient/GeneratedArtifacts |
||||
**/*.DesktopClient/ModelManifest.xml |
||||
**/*.Server/GeneratedArtifacts |
||||
**/*.Server/ModelManifest.xml |
||||
_Pvt_Extensions |
||||
|
||||
# Paket dependency manager |
||||
.paket/paket.exe |
||||
paket-files/ |
||||
|
||||
# FAKE - F# Make |
||||
.fake/ |
||||
|
||||
# CodeRush personal settings |
||||
.cr/personal |
||||
|
||||
# Python Tools for Visual Studio (PTVS) |
||||
__pycache__/ |
||||
*.pyc |
||||
|
||||
# Cake - Uncomment if you are using it |
||||
# tools/** |
||||
# !tools/packages.config |
||||
|
||||
# Tabs Studio |
||||
*.tss |
||||
|
||||
# Telerik's JustMock configuration file |
||||
*.jmconfig |
||||
|
||||
# BizTalk build output |
||||
*.btp.cs |
||||
*.btm.cs |
||||
*.odx.cs |
||||
*.xsd.cs |
||||
|
||||
# OpenCover UI analysis results |
||||
OpenCover/ |
||||
|
||||
# Azure Stream Analytics local run output |
||||
ASALocalRun/ |
||||
|
||||
# MSBuild Binary and Structured Log |
||||
*.binlog |
||||
|
||||
# NVidia Nsight GPU debugger configuration file |
||||
*.nvuser |
||||
|
||||
# MFractors (Xamarin productivity tool) working folder |
||||
.mfractor/ |
||||
|
||||
# Local History for Visual Studio |
||||
.localhistory/ |
||||
|
||||
# BeatPulse healthcheck temp database |
||||
healthchecksdb |
||||
|
||||
# Backup folder for Package Reference Convert tool in Visual Studio 2017 |
||||
MigrationBackup/ |
||||
|
||||
# Ionide (cross platform F# VS Code tools) working folder |
||||
.ionide/ |
||||
|
||||
# Fody - auto-generated XML schema |
||||
FodyWeavers.xsd |
||||
build |
||||
obj |
||||
out |
||||
|
||||
@ -0,0 +1,22 @@ |
||||
The MIT License (MIT) |
||||
|
||||
Copyright (c) 2017 Step Revolution LLC |
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy |
||||
of this software and associated documentation files (the "Software"), to deal |
||||
in the Software without restriction, including without limitation the rights |
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
||||
copies of the Software, and to permit persons to whom the Software is |
||||
furnished to do so, subject to the following conditions: |
||||
|
||||
The above copyright notice and this permission notice shall be included in all |
||||
copies or substantial portions of the Software. |
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
||||
SOFTWARE. |
||||
|
||||
@ -0,0 +1,7 @@ |
||||
This is the SDK for StepManiaX platform development. |
||||
|
||||
See [the StepManiaX website](https://stepmaniax.com) and the [documentation](https://steprevolution.github.io/stepmaniax-sdk/) |
||||
for info. |
||||
|
||||
SDK support: [sdk@stepmaniax.com](mailto:sdk@stepmaniax.com) |
||||
|
||||
@ -1,37 +0,0 @@ |
||||
#define OLC_PGE_APPLICATION |
||||
#include "olcPixelGameEngine.h" |
||||
|
||||
class Example : public olc::PixelGameEngine |
||||
{ |
||||
public: |
||||
Example() |
||||
{ |
||||
sAppName = "Example"; |
||||
} |
||||
|
||||
public: |
||||
bool OnUserCreate() override |
||||
{ |
||||
// Called once at the start, so create things here
|
||||
return true; |
||||
} |
||||
|
||||
bool OnUserUpdate(float fElapsedTime) override |
||||
{ |
||||
// called once per frame
|
||||
for (int x = 0; x < ScreenWidth(); x++) |
||||
for (int y = 0; y < ScreenHeight(); y++) |
||||
Draw(x, y, olc::Pixel(rand() % 255, rand() % 255, rand()% 255));
|
||||
return true; |
||||
} |
||||
}; |
||||
|
||||
|
||||
int main() |
||||
{ |
||||
Example demo; |
||||
if (demo.Construct(256, 240, 4, 4)) |
||||
demo.Start(); |
||||
|
||||
return 0; |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
|
After Width: | Height: | Size: 25 KiB |
@ -0,0 +1,183 @@ |
||||
<html> |
||||
<link rel=stylesheet href=style.css> |
||||
<link rel="icon" href="icon.png" type="image/png"> |
||||
|
||||
<img src=logo.png style="width: 80%; display: block; margin-left: auto; margin-right: auto;"> |
||||
|
||||
<h2>Introduction to the StepManiaX SDK</h2> |
||||
|
||||
The StepManiaX SDK supports C++ development for the <a href=https://stepmaniax.com/>StepManiaX dance platform</a>. |
||||
<p> |
||||
SDK support: <a href=mailto:sdk@stepmaniax.com>sdk@stepmaniax.com</a> |
||||
|
||||
<h2>Usage</h2> |
||||
|
||||
You can either build the solution and link the resulting SMX.dll to your application, |
||||
or import the source project and add it to your Visual Studio solution. The SDK |
||||
interface is <code>SMX.h</code>. |
||||
<p> |
||||
See <code>SMXSample</code> for a sample application. |
||||
<p> |
||||
Up to two controllers are supported. <code>SMX_GetInfo</code> can be used to check which |
||||
controllers are connected. Each <code>pad</code> argument to API calls can be 0 for the |
||||
player 1 pad, or 1 for the player 2 pad. |
||||
|
||||
<h2>HID support</h2> |
||||
|
||||
The platform can be used as a regular USB HID input device, which works in any game |
||||
that supports input remapping. |
||||
<p> |
||||
However, applications using this SDK to control the panels directly should ignore the |
||||
HID interface, and instead use <code>SMX_GetInputState</code> to retrieve the input state. |
||||
|
||||
<h2>Platform lights</h2> |
||||
|
||||
The platform can have up to nine panels. Each panel has a grid of 4x4 RGB LEDs, which can |
||||
be individually controlled at up to 30 FPS. |
||||
<p> |
||||
See <code>SMX_SetLights2</code>. |
||||
|
||||
<h2>Update notes</h2> |
||||
|
||||
2019-07-18-01: Added SMX_SetLights2. This is the same as SMX_SetLights, with an added |
||||
parameter to specify the size of the buffer. This must be used to control the Gen4 |
||||
pads which have additional LEDs. |
||||
|
||||
<h2>Platform configuration</h2> |
||||
|
||||
The platform configuration can be read and modified using SMX_GetConfig and SMX_SetConfig. |
||||
Most of the platform configuration doesn't need to be accessed by applications, since |
||||
users can use the SMXConfig application to manage their platform. |
||||
<p> |
||||
<ul> |
||||
<li> |
||||
<b>enabledSensors</b> |
||||
<p> |
||||
Each platform can have up to nine panels in any configuration, but most devices have |
||||
a smaller number of panels installed. If an application wants to adapt its UI to the |
||||
user's panel configuration, see enabledSensors to detect which sensors are enabled. |
||||
<p> |
||||
Each panel has four sensors, and if a panel is disabled, all four of its sensors will be |
||||
disabled. Disabling individual sensors is possible, but removing individual sensors |
||||
reduces the performance of the pad and isn't recommended. |
||||
<p> |
||||
Note that this indicates which panels the player is using for input. Other panels may |
||||
still have lights support, and the application should always send lights data for all |
||||
possible panels even if it's not being used for input. |
||||
</li> |
||||
</ul> |
||||
|
||||
<h2>Reference</h2> |
||||
|
||||
<h3 class=ref>void SMX_Start(SMXUpdateCallback UpdateCallback, void *pUser);</h3> |
||||
|
||||
Initialize, and start searching for devices. |
||||
<p> |
||||
UpdateCallback will be called when something happens: connection or disconnection, inputs |
||||
changed, configuration updated, test data updated, etc. It doesn't specify what's changed, |
||||
and the user should check all state that it's interested in. |
||||
<p> |
||||
This is called asynchronously from a helper thread, so the receiver must be thread-safe. |
||||
|
||||
<h3 class=ref>void SMX_Stop();</h3> |
||||
|
||||
Shut down and disconnect from all devices. This will wait for any user callbacks to complete, |
||||
and no user callbacks will be called after this returns. |
||||
|
||||
<h3 class=ref>void SMX_SetLogCallback(SMXLogCallback callback);</h3> |
||||
|
||||
Set a function to receive diagnostic logs. By default, logs are written to stdout. |
||||
This can be called before SMX_Start, so it affects any logs sent during initialization. |
||||
|
||||
<h3 class=ref>void SMX_GetInfo(int pad, SMXInfo *info);</h3> |
||||
|
||||
Get info about a pad. Use this to detect which pads are currently connected. |
||||
|
||||
<h3 class=ref>uint16_t SMX_GetInputState(int pad);</h3> |
||||
|
||||
Get a mask of the currently pressed panels. |
||||
|
||||
<h3 class=ref>void SMX_SetLights(const char lightsData[864]);</h3> |
||||
|
||||
(deprecated) |
||||
<p> |
||||
Equivalent to SMX_SetLights2(lightsData, 864). SMX_SetLights2 should be used instead. |
||||
|
||||
<h3 class=ref>void SMX_SetLights2(const char *lightsData, int lightDataSize);</h3> |
||||
Update the lights. Both pads are always updated together. lightsData is a list of 8-bit RGB |
||||
colors, one for each LED. |
||||
<p> |
||||
lightDataSize is the number of bytes in lightsData. This should be 1350 (2 pads * 9 panels * |
||||
25 lights * 3 RGB colors). For backwards-compatibility, this can also be 864. |
||||
<p> |
||||
25-LED panels have lights in the following order: |
||||
<p> |
||||
<pre> |
||||
00 01 02 03 |
||||
16 17 18 |
||||
04 05 06 07 |
||||
19 20 21 |
||||
08 09 10 11 |
||||
22 23 24 |
||||
12 13 14 15 |
||||
</pre> |
||||
<p> |
||||
|
||||
16-LED panels have the same layout, ignoring LEDs 16 and up. |
||||
<p> |
||||
Panels are in the following order: |
||||
<p> |
||||
<pre> |
||||
012 9AB |
||||
345 CDE |
||||
678 F01 |
||||
</pre> |
||||
|
||||
Lights will update at up to 30 FPS. If lights data is sent more quickly, a best effort will be |
||||
made to send the most recent lights data available, but the panels won't update more quickly. |
||||
<p> |
||||
The panels will return to automatic lighting if no lights are received for a while, so applications |
||||
controlling lights should send light updates continually, even if the lights aren't changing. |
||||
<p> |
||||
For backwards compatibility, if lightDataSize is 864, the old 4x4-only order is used, |
||||
which simply omits lights 16-24. |
||||
|
||||
<h3 class=ref>void SMX_ReenableAutoLights();</h3> |
||||
|
||||
By default, the panels light automatically when stepped on. If a lights command is sent by |
||||
the application, this stops happening to allow the application to fully control lighting. |
||||
If no lights update is received for a few seconds, automatic lighting is reenabled by the |
||||
panels. |
||||
<p> |
||||
<code>SMX_ReenableAutoLights</code> can be called to immediately reenable auto-lighting, without waiting |
||||
for the timeout period to elapse. Games don't need to call this, since the panels will return |
||||
to auto-lighting mode automatically after a brief period of no updates. |
||||
|
||||
<h3 class=ref>void SMX_GetConfig(int pad, SMXConfig *config);</h3> |
||||
|
||||
Get the current controller's configuration. |
||||
|
||||
<h3 class=ref>void SMX_SetConfig(int pad, const SMXConfig *config);</h3> |
||||
|
||||
Update the current controller's configuration. This doesn't block, and the new configuration will |
||||
be sent in the background. SMX_GetConfig will return the new configuration as soon as this call |
||||
returns, without waiting for it to actually be sent to the controller. |
||||
|
||||
<h3 class=ref>void SMX_FactoryReset(int pad);</h3> |
||||
|
||||
Reset a pad to its original configuration. |
||||
|
||||
<h3 class=ref>void SMX_ForceRecalibration(int pad);</h3> |
||||
|
||||
Request an immediate panel recalibration. This is normally not necessary, but can be helpful |
||||
for diagnostics. |
||||
|
||||
<h3 class=ref> |
||||
void SMX_SetTestMode(int pad, SensorTestMode mode); |
||||
<br> |
||||
bool SMX_GetTestData(int pad, SMXSensorTestModeData *data); |
||||
</h3> |
||||
|
||||
Set a panel test mode and request test data. This is used by the configuration tool. |
||||
|
||||
|
||||
|
After Width: | Height: | Size: 416 KiB |
@ -0,0 +1,26 @@ |
||||
body { |
||||
padding: 1em; |
||||
max-width: 1000px; |
||||
font-family: "Segoe UI",Helvetica,Arial,sans-serif; |
||||
margin-left: auto; |
||||
margin-right: auto; |
||||
line-height: 1.5; |
||||
} |
||||
|
||||
h1 { |
||||
font-size: 2em; |
||||
} |
||||
h1, h2 { |
||||
border-bottom: 1px solid #eeeeee; |
||||
padding-bottom: .3em; |
||||
} |
||||
|
||||
h3.ref { |
||||
display: block; |
||||
font-family: monospace; |
||||
background-color: #008080; |
||||
color: #FFFFFF; |
||||
padding: .5em; |
||||
|
||||
|
||||
} |
||||
@ -0,0 +1,57 @@ |
||||
#include "SMX.h" |
||||
#define OLC_PGE_APPLICATION |
||||
#include "olcPixelGameEngine.h" |
||||
using namespace olc; |
||||
|
||||
class SMX_PGE : public olc::PixelGameEngine |
||||
{ |
||||
public: |
||||
SMX_PGE() |
||||
{ |
||||
sAppName = "Example"; |
||||
} |
||||
|
||||
static void SMXStateChangedCallback(int pad, SMXUpdateCallbackReason reason, void *pUser) |
||||
{ |
||||
SMX_PGE *pSelf = (SMX_PGE*) pUser; |
||||
pSelf->SMXStateChanged( pad, reason ); |
||||
} |
||||
|
||||
static void SMXLogCallback(const char *log) |
||||
{ |
||||
printf("-> %s\n", log); |
||||
} |
||||
|
||||
void SMXStateChanged(int pad, SMXUpdateCallbackReason reason) |
||||
{ |
||||
printf("Device %i state changed: %04x\n", pad, SMX_GetInputState(pad)); |
||||
|
||||
} |
||||
|
||||
public: |
||||
bool OnUserCreate() override |
||||
{ |
||||
SMX_Start( SMXStateChangedCallback, this ); |
||||
// Called once at the start, so create things here
|
||||
return true; |
||||
} |
||||
|
||||
bool OnUserUpdate(float fElapsedTime) override |
||||
{ |
||||
// called once per frame
|
||||
for (int x = 0; x < ScreenWidth(); x++) |
||||
for (int y = 0; y < ScreenHeight(); y++) |
||||
Draw(x, y, olc::Pixel(rand() % 255, rand() % 255, rand()% 255));
|
||||
return true; |
||||
} |
||||
}; |
||||
|
||||
|
||||
int main() |
||||
{ |
||||
SMX_PGE demo; |
||||
if (demo.Construct(256, 240, 4, 4)) |
||||
demo.Start(); |
||||
|
||||
return 0; |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,319 @@ |
||||
#ifndef SMX_H |
||||
#define SMX_H |
||||
|
||||
#include <stdint.h> |
||||
#include <stddef.h> // for offsetof |
||||
|
||||
#ifdef SMX_EXPORTS |
||||
#define SMX_API extern "C" __declspec(dllexport) |
||||
#else |
||||
#define SMX_API extern "C" __declspec(dllimport) |
||||
#endif |
||||
|
||||
struct SMXInfo; |
||||
struct SMXConfig; |
||||
enum SensorTestMode; |
||||
enum PanelTestMode; |
||||
enum SMXUpdateCallbackReason; |
||||
struct SMXSensorTestModeData; |
||||
|
||||
// All functions are nonblocking. Getters will return the most recent state. Setters will
|
||||
// return immediately and do their work in the background. No functions return errors, and
|
||||
// setting data on a pad which isn't connected will have no effect.
|
||||
|
||||
// Initialize, and start searching for devices.
|
||||
//
|
||||
// UpdateCallback will be called when something happens: connection or disconnection, inputs
|
||||
// changed, configuration updated, test data updated, etc. It doesn't specify what's changed,
|
||||
// and the user should check all state that it's interested in.
|
||||
//
|
||||
// This is called asynchronously from a helper thread, so the receiver must be thread-safe.
|
||||
typedef void SMXUpdateCallback(int pad, SMXUpdateCallbackReason reason, void *pUser); |
||||
SMX_API void SMX_Start(SMXUpdateCallback UpdateCallback, void *pUser); |
||||
|
||||
// Shut down and disconnect from all devices. This will wait for any user callbacks to complete,
|
||||
// and no user callbacks will be called after this returns. This must not be called from within
|
||||
// the update callback.
|
||||
SMX_API void SMX_Stop(); |
||||
|
||||
// Set a function to receive diagnostic logs. By default, logs are written to stdout.
|
||||
// This can be called before SMX_Start, so it affects any logs sent during initialization.
|
||||
typedef void SMXLogCallback(const char *log); |
||||
SMX_API void SMX_SetLogCallback(SMXLogCallback callback); |
||||
|
||||
// Get info about a pad. Use this to detect which pads are currently connected.
|
||||
SMX_API void SMX_GetInfo(int pad, SMXInfo *info); |
||||
|
||||
// Get a mask of the currently pressed panels.
|
||||
SMX_API uint16_t SMX_GetInputState(int pad); |
||||
|
||||
// (deprecated) Equivalent to SMX_SetLights2(lightsData, 864).
|
||||
SMX_API void SMX_SetLights(const char lightData[864]); |
||||
|
||||
// Update the lights. Both pads are always updated together. lightData is a list of 8-bit RGB
|
||||
// colors, one for each LED.
|
||||
//
|
||||
// lightDataSize is the number of bytes in lightsData. This should be 1350 (2 pads * 9 panels *
|
||||
// 25 lights * 3 RGB colors). For backwards-compatibility, this can also be 864.
|
||||
//
|
||||
// Each panel has lights in the following order:
|
||||
//
|
||||
// 00 01 02 03
|
||||
// 16 17 18
|
||||
// 04 05 06 07
|
||||
// 19 20 21
|
||||
// 08 09 10 11
|
||||
// 22 23 24
|
||||
// 12 13 14 15
|
||||
//
|
||||
// Panels are in the following order:
|
||||
//
|
||||
// 012 9AB
|
||||
// 345 CDE
|
||||
// 678 F01
|
||||
//
|
||||
// With 18 panels, 25 LEDs per panel and 3 bytes per LED, each light update has 1350 bytes of data.
|
||||
//
|
||||
// Lights will update at up to 30 FPS. If lights data is sent more quickly, a best effort will be
|
||||
// made to send the most recent lights data available, but the panels won't update more quickly.
|
||||
//
|
||||
// The panels will return to automatic lighting if no lights are received for a while, so applications
|
||||
// controlling lights should send light updates continually, even if the lights aren't changing.
|
||||
//
|
||||
// For backwards compatibility, if lightDataSize is 864, the old 4x4-only order is used,
|
||||
// which simply omits lights 16-24.
|
||||
SMX_API void SMX_SetLights2(const char *lightData, int lightDataSize); |
||||
|
||||
// By default, the panels light automatically when stepped on. If a lights command is sent by
|
||||
// the application, this stops happening to allow the application to fully control lighting.
|
||||
// If no lights update is received for a few seconds, automatic lighting is reenabled by the
|
||||
// panels.
|
||||
//
|
||||
// SMX_ReenableAutoLights can be called to immediately reenable auto-lighting, without waiting
|
||||
// for the timeout period to elapse. Games don't need to call this, since the panels will return
|
||||
// to auto-lighting mode automatically after a brief period of no updates.
|
||||
SMX_API void SMX_ReenableAutoLights(); |
||||
|
||||
// Get the current controller's configuration.
|
||||
//
|
||||
// Return true if a configuration is available. If false is returned, no panel is connected
|
||||
// and no data will be set.
|
||||
SMX_API bool SMX_GetConfig(int pad, SMXConfig *config); |
||||
|
||||
// Update the current controller's configuration. This doesn't block, and the new configuration will
|
||||
// be sent in the background. SMX_GetConfig will return the new configuration as soon as this call
|
||||
// returns, without waiting for it to actually be sent to the controller.
|
||||
SMX_API void SMX_SetConfig(int pad, const SMXConfig *config); |
||||
|
||||
// Reset a pad to its original configuration.
|
||||
SMX_API void SMX_FactoryReset(int pad); |
||||
|
||||
// Request an immediate panel recalibration. This is normally not necessary, but can be helpful
|
||||
// for diagnostics.
|
||||
SMX_API void SMX_ForceRecalibration(int pad); |
||||
|
||||
// Set a sensor test mode and request test data. This is used by the configuration tool.
|
||||
SMX_API void SMX_SetTestMode(int pad, SensorTestMode mode); |
||||
SMX_API bool SMX_GetTestData(int pad, SMXSensorTestModeData *data); |
||||
|
||||
// Set a panel test mode. These only appear as debug lighting on the panel and don't
|
||||
// return data to us. Lights can't be updated while a panel test mode is active.
|
||||
// This applies to all connected pads.
|
||||
SMX_API void SMX_SetPanelTestMode(PanelTestMode mode); |
||||
|
||||
// Return the build version of the DLL, which is based on the git tag at build time. This
|
||||
// is only intended for diagnostic logging, and it's also the version we show in SMXConfig.
|
||||
SMX_API const char *SMX_Version(); |
||||
|
||||
// General info about a connected controller. This can be retrieved with SMX_GetInfo.
|
||||
struct SMXInfo |
||||
{ |
||||
// True if we're fully connected to this controller. If this is false, the other
|
||||
// fields won't be set.
|
||||
bool m_bConnected = false; |
||||
|
||||
// This device's serial number. This can be used to distinguish devices from each
|
||||
// other if more than one is connected. This is a null-terminated string instead
|
||||
// of a C++ string for C# marshalling.
|
||||
char m_Serial[33]; |
||||
|
||||
// This device's firmware version.
|
||||
uint16_t m_iFirmwareVersion; |
||||
}; |
||||
|
||||
enum SMXUpdateCallbackReason { |
||||
// This is called when a generic state change happens: connection or disconnection, inputs changed,
|
||||
// test data updated, etc. It doesn't specify what's changed. We simply check the whole state.
|
||||
SMXUpdateCallback_Updated, |
||||
|
||||
// This is called when SMX_FactoryReset completes, indicating that SMX_GetConfig will now return
|
||||
// the reset configuration.
|
||||
SMXUpdateCallback_FactoryResetCommandComplete |
||||
}; |
||||
|
||||
// Bits for SMXConfig::flags.
|
||||
enum SMXConfigFlags { |
||||
// If set, panels will use the pressed animation when pressed, and stepColor
|
||||
// is ignored. If unset, panels will be lit solid using stepColor.
|
||||
// masterVersion >= 4. Previous versions always use stepColor.
|
||||
PlatformFlags_AutoLightingUsePressedAnimations = 1 << 0, |
||||
|
||||
// If set, panels are using FSRs, otherwise load cells.
|
||||
PlatformFlags_FSR = 1 << 1, |
||||
}; |
||||
#pragma pack(push, 1) |
||||
|
||||
struct packed_sensor_settings_t { |
||||
// Load cell thresholds:
|
||||
uint8_t loadCellLowThreshold; |
||||
uint8_t loadCellHighThreshold; |
||||
|
||||
// FSR thresholds:
|
||||
uint8_t fsrLowThreshold[4]; |
||||
uint8_t fsrHighThreshold[4]; |
||||
|
||||
uint16_t combinedLowThreshold; |
||||
uint16_t combinedHighThreshold; |
||||
|
||||
// This must be left unchanged.
|
||||
uint16_t reserved; |
||||
}; |
||||
|
||||
static_assert(sizeof(packed_sensor_settings_t) == 16, "Incorrect packed_sensor_settings_t size"); |
||||
|
||||
// The configuration for a connected controller. This can be retrieved with SMX_GetConfig
|
||||
// and modified with SMX_SetConfig.
|
||||
//
|
||||
// The order and packing of this struct corresponds to the configuration packet sent to
|
||||
// the master controller, so it must not be changed.
|
||||
struct SMXConfig |
||||
{ |
||||
// The firmware version of the master controller. Where supported (version 2 and up), this
|
||||
// will always read back the firmware version. This will default to 0xFF on version 1, and
|
||||
// we'll always write 0xFF here so it doesn't change on that firmware version.
|
||||
//
|
||||
// We don't need this since we can read the "I" command which also reports the version, but
|
||||
// this allows panels to also know the master version.
|
||||
uint8_t masterVersion = 0xFF; |
||||
|
||||
// The version of this config packet. This can be used by the firmware to know which values
|
||||
// have been filled in. Any values not filled in will always be 0xFF, which can be tested
|
||||
// for, but that doesn't work for values where 0xFF is a valid value. This value is unrelated
|
||||
// to the firmware version, and just indicates which fields in this packet have been set.
|
||||
// Note that we don't need to increase this any time we add a field, only when it's important
|
||||
// that we be able to tell if a field is set or not.
|
||||
//
|
||||
// Versions:
|
||||
// - 0xFF: This is a config packet from before configVersion was added.
|
||||
// - 0x00: configVersion added
|
||||
// - 0x02: panelThreshold0Low through panelThreshold8High added
|
||||
// - 0x03: debounceDelayMs added
|
||||
uint8_t configVersion = 0x05; |
||||
|
||||
// Packed flags (masterVersion >= 4).
|
||||
uint8_t flags = 0; |
||||
|
||||
// Panel thresholds are labelled by their numpad position, eg. Panel8 is up.
|
||||
// If m_iFirmwareVersion is 1, Panel7 corresponds to all of up, down, left and
|
||||
// right, and Panel2 corresponds to UpLeft, UpRight, DownLeft and DownRight. For
|
||||
// later firmware versions, each panel is configured independently.
|
||||
//
|
||||
// Setting a value to 0xFF disables that threshold.
|
||||
|
||||
// These are internal tunables and should be left unchanged.
|
||||
uint16_t debounceNodelayMilliseconds = 0; |
||||
uint16_t debounceDelayMilliseconds = 0; |
||||
uint16_t panelDebounceMicroseconds = 4000; |
||||
uint8_t autoCalibrationMaxDeviation = 100; |
||||
uint8_t badSensorMinimumDelaySeconds = 15; |
||||
uint16_t autoCalibrationAveragesPerUpdate = 60; |
||||
uint16_t autoCalibrationSamplesPerAverage = 500; |
||||
|
||||
// The maximum tare value to calibrate to (except on startup).
|
||||
uint16_t autoCalibrationMaxTare = 0xFFFF; |
||||
|
||||
// Which sensors on each panel to enable. This can be used to disable sensors that
|
||||
// we know aren't populated. This is packed, with four sensors on two pads per byte:
|
||||
// enabledSensors[0] & 1 is the first sensor on the first pad, and so on.
|
||||
uint8_t enabledSensors[5]; |
||||
|
||||
// How long the master controller will wait for a lights command before assuming the
|
||||
// game has gone away and resume auto-lights. This is in 128ms units.
|
||||
uint8_t autoLightsTimeout = 1000/128; // 1 second
|
||||
|
||||
// The color to use for each panel when auto-lighting in master mode. This doesn't
|
||||
// apply when the pads are in autonomous lighting mode (no master), since they don't
|
||||
// store any configuration by themselves. These colors should be scaled to the 0-170
|
||||
// range.
|
||||
uint8_t stepColor[3*9]; |
||||
|
||||
// The default color to set the platform LED strip to.
|
||||
uint8_t platformStripColor[3]; |
||||
|
||||
// Which panels to enable auto-lighting for. Disabled panels will be unlit.
|
||||
// 0x01 = panel 0, 0x02 = panel 1, 0x04 = panel 2, etc. This only affects
|
||||
// the master controller's built-in auto lighting and not lights data send
|
||||
// from the SDK.
|
||||
uint16_t autoLightPanelMask = 0xFFFF; |
||||
|
||||
// The rotation of the panel, where 0 is the standard rotation, 1 means the panel is
|
||||
// rotated right 90 degrees, 2 is rotated 180 degrees, and 3 is rotated 270 degrees.
|
||||
// This value is unused.
|
||||
uint8_t panelRotation; |
||||
|
||||
// Per-panel sensor settings:
|
||||
packed_sensor_settings_t panelSettings[9]; |
||||
|
||||
// These are internal tunables and should be left unchanged.
|
||||
uint8_t preDetailsDelayMilliseconds = 5; |
||||
|
||||
// Pad the struct to 250 bytes. This keeps this struct size from changing
|
||||
// as we add fields, so the ABI doesn't change. Applications should leave
|
||||
// any data in here unchanged when calling SMX_SetConfig.
|
||||
uint8_t padding[49]; |
||||
}; |
||||
#pragma pack(pop) |
||||
|
||||
static_assert(offsetof(SMXConfig, padding) == 201, "Incorrect padding alignment"); |
||||
static_assert(sizeof(SMXConfig) == 250, "Expected 250 bytes"); |
||||
|
||||
// The values (except for Off) correspond with the protocol and must not be changed.
|
||||
enum SensorTestMode { |
||||
SensorTestMode_Off = 0, |
||||
// Return the raw, uncalibrated value of each sensor.
|
||||
SensorTestMode_UncalibratedValues = '0', |
||||
|
||||
// Return the calibrated value of each sensor.
|
||||
SensorTestMode_CalibratedValues = '1', |
||||
|
||||
// Return the sensor noise value.
|
||||
SensorTestMode_Noise = '2', |
||||
|
||||
// Return the sensor tare value.
|
||||
SensorTestMode_Tare = '3', |
||||
}; |
||||
|
||||
// Data for the current SensorTestMode. The interpretation of sensorLevel depends on the mode.
|
||||
struct SMXSensorTestModeData |
||||
{ |
||||
// If false, sensorLevel[n][*] is zero because we didn't receive a response from that panel.
|
||||
bool bHaveDataFromPanel[9]; |
||||
|
||||
int16_t sensorLevel[9][4]; |
||||
bool bBadSensorInput[9][4]; |
||||
|
||||
// The DIP switch settings on each panel. This is used for diagnostics displays.
|
||||
int iDIPSwitchPerPanel[9]; |
||||
|
||||
// Bad sensor selection jumper indication for each panel.
|
||||
bool iBadJumper[9][4]; |
||||
}; |
||||
|
||||
// The values also correspond with the protocol and must not be changed.
|
||||
// These are panel-side diagnostics modes.
|
||||
enum PanelTestMode { |
||||
PanelTestMode_Off = '0', |
||||
PanelTestMode_PressureTest = '1', |
||||
}; |
||||
|
||||
#endif |
||||
@ -0,0 +1,3 @@ |
||||
# Ignore updates to the auto-generated build version. |
||||
SMXBuildVersion.h |
||||
|
||||
@ -0,0 +1,336 @@ |
||||
#include "Helpers.h" |
||||
#include <windows.h> |
||||
#include <algorithm> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
namespace { |
||||
function<void(const string &log)> g_LogCallback = [](const string &log) { |
||||
printf("%6.3f: %s\n", GetMonotonicTime(), log.c_str()); |
||||
}; |
||||
}; |
||||
|
||||
void SMX::Log(string s) |
||||
{ |
||||
g_LogCallback(s); |
||||
} |
||||
|
||||
void SMX::Log(wstring s) |
||||
{ |
||||
Log(WideStringToUTF8(s)); |
||||
} |
||||
|
||||
void SMX::SetLogCallback(function<void(const string &log)> callback) |
||||
{ |
||||
g_LogCallback = callback; |
||||
} |
||||
|
||||
const DWORD MS_VC_EXCEPTION = 0x406D1388;
|
||||
#pragma pack(push,8) |
||||
typedef struct tagTHREADNAME_INFO
|
||||
{
|
||||
DWORD dwType; // Must be 0x1000.
|
||||
LPCSTR szName; // Pointer to name (in user addr space).
|
||||
DWORD dwThreadID; // Thread ID (-1=caller thread).
|
||||
DWORD dwFlags; // Reserved for future use, must be zero.
|
||||
} THREADNAME_INFO;
|
||||
|
||||
#pragma pack(pop) |
||||
void SMX::SetThreadName(DWORD iThreadId, const string &name) |
||||
{ |
||||
|
||||
THREADNAME_INFO info;
|
||||
info.dwType = 0x1000;
|
||||
info.szName = name.c_str();
|
||||
info.dwThreadID = iThreadId; |
||||
info.dwFlags = 0;
|
||||
#pragma warning(push) |
||||
#pragma warning(disable: 6320 6322) |
||||
__try{
|
||||
RaiseException(MS_VC_EXCEPTION, 0, sizeof(info) / sizeof(ULONG_PTR), (ULONG_PTR*)&info);
|
||||
}
|
||||
__except (EXCEPTION_EXECUTE_HANDLER) { |
||||
}
|
||||
#pragma warning(pop) |
||||
}
|
||||
|
||||
void SMX::StripCrnl(wstring &s) |
||||
{ |
||||
while(s.size() && (s[s.size()-1] == '\r' || s[s.size()-1] == '\n')) |
||||
s.erase(s.size()-1); |
||||
} |
||||
|
||||
wstring SMX::GetErrorString(int err) |
||||
{ |
||||
wchar_t buf[1024] = L""; |
||||
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, 0, err, 0, buf, sizeof(buf), NULL); |
||||
|
||||
// Fix badly formatted strings returned by FORMAT_MESSAGE_FROM_SYSTEM.
|
||||
wstring sResult = buf; |
||||
StripCrnl(sResult); |
||||
return sResult; |
||||
} |
||||
|
||||
string SMX::vssprintf(const char *szFormat, va_list argList) |
||||
{ |
||||
int iChars = vsnprintf(NULL, 0, szFormat, argList); |
||||
if(iChars == -1) |
||||
return string("Error formatting string: ") + szFormat; |
||||
|
||||
string sStr; |
||||
sStr.resize(iChars+1); |
||||
vsnprintf((char *) sStr.data(), iChars+1, szFormat, argList); |
||||
sStr.resize(iChars); |
||||
|
||||
return sStr; |
||||
} |
||||
|
||||
string SMX::ssprintf(const char *fmt, ...) |
||||
{ |
||||
va_list va; |
||||
va_start(va, fmt); |
||||
return vssprintf(fmt, va); |
||||
} |
||||
|
||||
wstring SMX::wvssprintf(const wchar_t *szFormat, va_list argList) |
||||
{ |
||||
int iChars = _vsnwprintf(NULL, 0, szFormat, argList); |
||||
if(iChars == -1) |
||||
return wstring(L"Error formatting string: ") + szFormat; |
||||
|
||||
wstring sStr; |
||||
sStr.resize(iChars+1); |
||||
_vsnwprintf((wchar_t *) sStr.data(), iChars+1, szFormat, argList); |
||||
sStr.resize(iChars); |
||||
|
||||
return sStr; |
||||
} |
||||
|
||||
wstring SMX::wssprintf(const wchar_t *fmt, ...) |
||||
{ |
||||
va_list va; |
||||
va_start(va, fmt); |
||||
return wvssprintf(fmt, va); |
||||
} |
||||
|
||||
string SMX::BinaryToHex(const void *pData_, int iNumBytes) |
||||
{ |
||||
const unsigned char *pData = (const unsigned char *) pData_; |
||||
string s; |
||||
for(int i=0; i<iNumBytes; i++) |
||||
{ |
||||
unsigned val = pData[i]; |
||||
s += ssprintf("%02x", val); |
||||
} |
||||
return s; |
||||
} |
||||
|
||||
string SMX::BinaryToHex(const string &sString) |
||||
{ |
||||
return BinaryToHex(sString.data(), sString.size()); |
||||
} |
||||
|
||||
bool SMX::GetRandomBytes(void *pData, int iBytes) |
||||
{ |
||||
HCRYPTPROV hCryptProvider = 0; |
||||
if (!CryptAcquireContext(&hCryptProvider, NULL, MS_DEF_PROV, PROV_RSA_FULL, (CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET)) &&
|
||||
!CryptAcquireContext(&hCryptProvider, NULL, MS_DEF_PROV, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT | CRYPT_MACHINE_KEYSET | CRYPT_NEWKEYSET)) |
||||
return 0; |
||||
|
||||
bool bSuccess = !!CryptGenRandom(hCryptProvider, iBytes, (uint8_t *) pData); |
||||
CryptReleaseContext(hCryptProvider, 0); |
||||
return bSuccess; |
||||
} |
||||
|
||||
// Monotonic timer code from https://stackoverflow.com/questions/24330496.
|
||||
// Why is this hard?
|
||||
//
|
||||
// This code has backwards compatibility to XP, but we only officially support and
|
||||
// test back to Windows 7, so that code path isn't tested.
|
||||
typedef struct _KSYSTEM_TIME { |
||||
ULONG LowPart; |
||||
LONG High1Time; |
||||
LONG High2Time; |
||||
} KSYSTEM_TIME; |
||||
#define KUSER_SHARED_DATA 0x7ffe0000 |
||||
#define InterruptTime ((KSYSTEM_TIME volatile*)(KUSER_SHARED_DATA + 0x08)) |
||||
#define InterruptTimeBias ((ULONGLONG volatile*)(KUSER_SHARED_DATA + 0x3b0)) |
||||
|
||||
namespace { |
||||
LONGLONG ReadInterruptTime() |
||||
{ |
||||
// Reading the InterruptTime from KUSER_SHARED_DATA is much better than
|
||||
// using GetTickCount() because it doesn't wrap, and is even a little quicker.
|
||||
// This works on all Windows NT versions (NT4 and up).
|
||||
LONG timeHigh; |
||||
ULONG timeLow; |
||||
do { |
||||
timeHigh = InterruptTime->High1Time; |
||||
timeLow = InterruptTime->LowPart; |
||||
} while (timeHigh != InterruptTime->High2Time); |
||||
LONGLONG now = ((LONGLONG)timeHigh << 32) + timeLow; |
||||
static LONGLONG d = now; |
||||
return now - d; |
||||
} |
||||
|
||||
LONGLONG ScaleQpc(LONGLONG qpc) |
||||
{ |
||||
// We do the actual scaling in fixed-point rather than floating, to make sure
|
||||
// that we don't violate monotonicity due to rounding errors. There's no
|
||||
// need to cache QueryPerformanceFrequency().
|
||||
LARGE_INTEGER frequency; |
||||
QueryPerformanceFrequency(&frequency); |
||||
double fraction = 10000000/double(frequency.QuadPart); |
||||
LONGLONG denom = 1024; |
||||
LONGLONG numer = max(1LL, (LONGLONG)(fraction*denom + 0.5)); |
||||
return qpc * numer / denom; |
||||
} |
||||
|
||||
ULONGLONG ReadUnbiasedQpc() |
||||
{ |
||||
// We remove the suspend bias added to QueryPerformanceCounter results by
|
||||
// subtracting the interrupt time bias, which is not strictly speaking legal,
|
||||
// but the units are correct and I think it's impossible for the resulting
|
||||
// "unbiased QPC" value to go backwards.
|
||||
LONGLONG interruptTimeBias, qpc; |
||||
do { |
||||
interruptTimeBias = *InterruptTimeBias; |
||||
LARGE_INTEGER counter; |
||||
QueryPerformanceCounter(&counter); |
||||
qpc = counter.QuadPart; |
||||
} while (interruptTimeBias != *InterruptTimeBias); |
||||
static std::pair<LONGLONG,LONGLONG> d(qpc, interruptTimeBias); |
||||
return ScaleQpc(qpc - d.first) - (interruptTimeBias - d.second); |
||||
} |
||||
|
||||
bool Win7OrLater() |
||||
{ |
||||
static int iWin7OrLater = -1; |
||||
if(iWin7OrLater != -1) |
||||
return bool(iWin7OrLater); |
||||
|
||||
OSVERSIONINFOW ver = { sizeof(OSVERSIONINFOW), }; |
||||
GetVersionEx(&ver); |
||||
iWin7OrLater = (ver.dwMajorVersion > 6 || (ver.dwMajorVersion == 6 && ver.dwMinorVersion >= 1)); |
||||
return bool(iWin7OrLater); |
||||
} |
||||
} |
||||
|
||||
/// getMonotonicTime() returns the time elapsed since the application's first
|
||||
/// call to getMonotonicTime(), in 100ns units. The values returned are
|
||||
/// guaranteed to be monotonic. The time ticks in 15ms resolution and advances
|
||||
/// during suspend on XP and Vista, but we manage to avoid this on Windows 7
|
||||
/// and 8, which also use a high-precision timer. The time does not wrap after
|
||||
/// 49 days.
|
||||
double SMX::GetMonotonicTime() |
||||
{ |
||||
// On Windows XP and earlier, QueryPerformanceCounter is not monotonic so we
|
||||
// steer well clear of it; on Vista, it's just a bit slow.
|
||||
uint64_t iTime = Win7OrLater()? ReadUnbiasedQpc() : ReadInterruptTime(); |
||||
return iTime / 10000000.0; |
||||
} |
||||
|
||||
void SMX::GenerateRandom(void *pOut, int iSize) |
||||
{ |
||||
// These calls shouldn't fail.
|
||||
HCRYPTPROV cryptProv; |
||||
if(!CryptAcquireContext(&cryptProv, nullptr, |
||||
L"Microsoft Base Cryptographic Provider v1.0", |
||||
PROV_RSA_FULL, CRYPT_VERIFYCONTEXT)) |
||||
throw exception("CryptAcquireContext error"); |
||||
|
||||
if(!CryptGenRandom(cryptProv, iSize, (BYTE *) pOut))
|
||||
throw exception("CryptGenRandom error"); |
||||
|
||||
if(!CryptReleaseContext(cryptProv, 0)) |
||||
throw exception("CryptReleaseContext error"); |
||||
} |
||||
|
||||
string SMX::WideStringToUTF8(wstring s) |
||||
{ |
||||
if(s.empty()) |
||||
return ""; |
||||
|
||||
int iBytes = WideCharToMultiByte( CP_ACP, 0, s.data(), s.size(), NULL, 0, NULL, FALSE ); |
||||
|
||||
string ret; |
||||
ret.resize(iBytes); |
||||
WideCharToMultiByte( CP_ACP, 0, s.data(), s.size(), (char *) ret.data(), iBytes, NULL, FALSE ); |
||||
|
||||
return ret; |
||||
} |
||||
|
||||
const char *SMX::CreateError(string error) |
||||
{ |
||||
// Store the string in a static so it doesn't get deallocated.
|
||||
static string buf; |
||||
buf = error; |
||||
return buf.c_str(); |
||||
} |
||||
|
||||
SMX::AutoCloseHandle::AutoCloseHandle(HANDLE h) |
||||
{ |
||||
handle = h; |
||||
} |
||||
|
||||
SMX::AutoCloseHandle::~AutoCloseHandle() |
||||
{ |
||||
if(handle != INVALID_HANDLE_VALUE) |
||||
CloseHandle(handle); |
||||
} |
||||
|
||||
SMX::Mutex::Mutex() |
||||
{ |
||||
m_hLock = CreateMutex(NULL, false, NULL); |
||||
} |
||||
|
||||
SMX::Mutex::~Mutex() |
||||
{ |
||||
CloseHandle(m_hLock); |
||||
} |
||||
|
||||
void SMX::Mutex::Lock() |
||||
{ |
||||
WaitForSingleObject(m_hLock, INFINITE); |
||||
m_iLockedByThread = GetCurrentThreadId(); |
||||
} |
||||
|
||||
void SMX::Mutex::Unlock() |
||||
{ |
||||
m_iLockedByThread = 0; |
||||
ReleaseMutex(m_hLock); |
||||
} |
||||
|
||||
void SMX::Mutex::AssertNotLockedByCurrentThread() |
||||
{ |
||||
if(m_iLockedByThread == GetCurrentThreadId()) |
||||
throw exception("Expected to not be locked"); |
||||
} |
||||
|
||||
void SMX::Mutex::AssertLockedByCurrentThread() |
||||
{ |
||||
if(m_iLockedByThread != GetCurrentThreadId()) |
||||
throw exception("Expected to be locked"); |
||||
} |
||||
|
||||
SMX::LockMutex::LockMutex(SMX::Mutex &mutex): |
||||
m_Mutex(mutex) |
||||
{ |
||||
m_Mutex.AssertNotLockedByCurrentThread(); |
||||
m_Mutex.Lock(); |
||||
} |
||||
|
||||
SMX::LockMutex::~LockMutex() |
||||
{ |
||||
m_Mutex.AssertLockedByCurrentThread(); |
||||
m_Mutex.Unlock(); |
||||
} |
||||
|
||||
// This is a helper to let the config tool open a window, which has no freopen.
|
||||
// This isn't exposed in SMX.h.
|
||||
extern "C" __declspec(dllexport) void SMX_Internal_OpenConsole() |
||||
{ |
||||
AllocConsole(); |
||||
freopen("CONOUT$","wb", stdout); |
||||
freopen("CONOUT$","wb", stderr); |
||||
} |
||||
@ -0,0 +1,152 @@ |
||||
#ifndef HELPERS_H |
||||
#define HELPERS_H |
||||
|
||||
#include <string> |
||||
#include <stdarg.h> |
||||
#include <windows.h> |
||||
#include <functional> |
||||
#include <memory> |
||||
#include <vector> |
||||
using namespace std; |
||||
|
||||
namespace SMX |
||||
{ |
||||
void Log(string s); |
||||
void Log(wstring s); |
||||
|
||||
// Set a function to receive logs written by SMX::Log. By default, logs are written
|
||||
// to stdout.
|
||||
void SetLogCallback(function<void(const string &log)> callback); |
||||
|
||||
void SetThreadName(DWORD iThreadId, const string &name); |
||||
void StripCrnl(wstring &s); |
||||
wstring GetErrorString(int err); |
||||
string vssprintf(const char *szFormat, va_list argList); |
||||
string ssprintf(const char *fmt, ...); |
||||
wstring wvssprintf(const wchar_t *szFormat, va_list argList); |
||||
wstring wssprintf(const wchar_t *fmt, ...); |
||||
string BinaryToHex(const void *pData_, int iNumBytes); |
||||
string BinaryToHex(const string &sString); |
||||
bool GetRandomBytes(void *pData, int iBytes); |
||||
double GetMonotonicTime(); |
||||
void GenerateRandom(void *pOut, int iSize); |
||||
string WideStringToUTF8(wstring s); |
||||
|
||||
// Create a char* string that will be valid until the next call to CreateError.
|
||||
// This is used to return error messages to the caller.
|
||||
const char *CreateError(string error); |
||||
|
||||
#define arraylen(a) (sizeof(a) / sizeof((a)[0])) |
||||
|
||||
// In order to be able to use smart pointers to fully manage an object, we need to get
|
||||
// a shared_ptr to pass around, but also store a weak_ptr in the object itself. This
|
||||
// lets the object create shared_ptrs for itself as needed, without keeping itself from
|
||||
// being deallocated.
|
||||
//
|
||||
// This helper allows this pattern:
|
||||
//
|
||||
// struct Class
|
||||
// {
|
||||
// Class(shared_ptr<Class> &pSelf): m_pSelf(GetPointers(pSelf, this)) { }
|
||||
// const weak_ptr<Class> m_pSelf;
|
||||
// };
|
||||
//
|
||||
// shared_ptr<Class> obj;
|
||||
// new Class(obj);
|
||||
//
|
||||
// For a more convenient way to invoke this, see CreateObj() below.
|
||||
|
||||
template<typename T> |
||||
weak_ptr<T> GetPointers(shared_ptr<T> &pSharedPtr, T *pObj) |
||||
{ |
||||
pSharedPtr.reset(pObj); |
||||
return pSharedPtr; |
||||
} |
||||
|
||||
// Create a class that retains a weak reference to itself, returning a shared_ptr.
|
||||
template<typename T, class... Args> |
||||
shared_ptr<T> CreateObj(Args&&... args) |
||||
{ |
||||
shared_ptr<typename T> pResult; |
||||
new T(pResult, std::forward<Args>(args)...); |
||||
return dynamic_pointer_cast<T>(pResult); |
||||
} |
||||
|
||||
class AutoCloseHandle |
||||
{ |
||||
public: |
||||
AutoCloseHandle(HANDLE h); |
||||
~AutoCloseHandle(); |
||||
HANDLE value() const { return handle; } |
||||
|
||||
private: |
||||
AutoCloseHandle(const AutoCloseHandle &rhs); |
||||
AutoCloseHandle &operator=(const AutoCloseHandle &rhs); |
||||
HANDLE handle; |
||||
}; |
||||
|
||||
class Mutex |
||||
{ |
||||
public: |
||||
Mutex(); |
||||
~Mutex(); |
||||
void Lock(); |
||||
void Unlock(); |
||||
|
||||
void AssertNotLockedByCurrentThread(); |
||||
void AssertLockedByCurrentThread(); |
||||
|
||||
private: |
||||
HANDLE m_hLock = INVALID_HANDLE_VALUE; |
||||
DWORD m_iLockedByThread = 0; |
||||
}; |
||||
|
||||
// A local lock helper for Mutex.
|
||||
class LockMutex |
||||
{ |
||||
public: |
||||
LockMutex(Mutex &mutex); |
||||
~LockMutex(); |
||||
|
||||
private: |
||||
Mutex &m_Mutex; |
||||
}; |
||||
|
||||
|
||||
class Event |
||||
{ |
||||
public: |
||||
Event(Mutex &lock): |
||||
m_Lock(lock) |
||||
{ |
||||
m_hEvent = make_shared<AutoCloseHandle>(CreateEvent(NULL, false, false, NULL)); |
||||
} |
||||
|
||||
void Set() |
||||
{ |
||||
SetEvent(m_hEvent->value()); |
||||
} |
||||
|
||||
// Unlock m_Lock, wait up to iDelayMilliseconds for the event to be set,
|
||||
// then lock m_Lock. If iDelayMilliseconds is -1, wait forever.
|
||||
void Wait(int iDelayMilliseconds) |
||||
{ |
||||
if(iDelayMilliseconds == -1) |
||||
iDelayMilliseconds = INFINITE; |
||||
|
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
m_Lock.Unlock(); |
||||
vector<HANDLE> aHandles = { m_hEvent->value() }; |
||||
WaitForSingleObjectEx(m_hEvent->value(), iDelayMilliseconds, true); |
||||
m_Lock.Lock(); |
||||
} |
||||
|
||||
private: |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
Mutex &m_Lock; |
||||
}; |
||||
|
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,124 @@ |
||||
// This implements the public API.
|
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
|
||||
#include "../SMX.h" |
||||
#include "SMXManager.h" |
||||
#include "SMXDevice.h" |
||||
#include "SMXBuildVersion.h" |
||||
#include "SMXPanelAnimation.h" // for SMX_LightsAnimation_SetAuto |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
BOOL APIENTRY DllMain(HMODULE hModule, DWORD ul_reason_for_call, LPVOID lpReserved) |
||||
{ |
||||
switch(ul_reason_for_call) |
||||
{ |
||||
case DLL_PROCESS_ATTACH: |
||||
case DLL_THREAD_ATTACH: |
||||
case DLL_THREAD_DETACH: |
||||
case DLL_PROCESS_DETACH: |
||||
break; |
||||
} |
||||
return TRUE; |
||||
} |
||||
|
||||
// DLL interface:
|
||||
SMX_API void SMX_Start(SMXUpdateCallback callback, void *pUser) |
||||
{ |
||||
if(SMXManager::g_pSMX != NULL) |
||||
return; |
||||
|
||||
// The C++ interface takes a std::function, which doesn't need a user pointer. We add
|
||||
// one for the C interface for convenience.
|
||||
auto UpdateCallback = [callback, pUser](int pad, SMXUpdateCallbackReason reason) { |
||||
callback(pad, reason, pUser); |
||||
}; |
||||
|
||||
// Log(ssprintf("Struct sizes (native): %i %i %i\n", sizeof(SMXConfig), sizeof(SMXInfo), sizeof(SMXSensorTestModeData)));
|
||||
SMXManager::g_pSMX = make_shared<SMXManager>(UpdateCallback); |
||||
} |
||||
|
||||
SMX_API void SMX_Stop() |
||||
{ |
||||
// If lights animation is running, shut it down first.
|
||||
SMX_LightsAnimation_SetAuto(false); |
||||
|
||||
SMXManager::g_pSMX.reset(); |
||||
} |
||||
|
||||
SMX_API void SMX_SetLogCallback(SMXLogCallback callback) |
||||
{ |
||||
// Wrap the C callback with a C++ one.
|
||||
SMX::SetLogCallback([callback](const string &log) { |
||||
callback(log.c_str()); |
||||
}); |
||||
} |
||||
|
||||
SMX_API bool SMX_GetConfig(int pad, SMXConfig *config) { return SMXManager::g_pSMX->GetDevice(pad)->GetConfig(*config); } |
||||
SMX_API void SMX_SetConfig(int pad, const SMXConfig *config) { SMXManager::g_pSMX->GetDevice(pad)->SetConfig(*config); } |
||||
SMX_API void SMX_GetInfo(int pad, SMXInfo *info) { SMXManager::g_pSMX->GetDevice(pad)->GetInfo(*info); } |
||||
SMX_API uint16_t SMX_GetInputState(int pad) { return SMXManager::g_pSMX->GetDevice(pad)->GetInputState(); } |
||||
SMX_API void SMX_FactoryReset(int pad) { SMXManager::g_pSMX->GetDevice(pad)->FactoryReset(); } |
||||
SMX_API void SMX_ForceRecalibration(int pad) { SMXManager::g_pSMX->GetDevice(pad)->ForceRecalibration(); } |
||||
SMX_API void SMX_SetTestMode(int pad, SensorTestMode mode) { SMXManager::g_pSMX->GetDevice(pad)->SetSensorTestMode(mode); } |
||||
SMX_API bool SMX_GetTestData(int pad, SMXSensorTestModeData *data) { return SMXManager::g_pSMX->GetDevice(pad)->GetTestData(*data); } |
||||
SMX_API void SMX_SetPanelTestMode(PanelTestMode mode) { SMXManager::g_pSMX->SetPanelTestMode(mode); } |
||||
|
||||
SMX_API void SMX_SetLights(const char lightData[864]) |
||||
{ |
||||
SMX_SetLights2(lightData, 864); |
||||
} |
||||
SMX_API void SMX_SetLights2(const char *lightData, int lightDataSize) |
||||
{ |
||||
// The lightData into data per pad depending on whether we've been
|
||||
// given 16 or 25 lights of data.
|
||||
string lights[2]; |
||||
const int BytesPerPad16 = 9*16*3; |
||||
const int BytesPerPad25 = 9*25*3; |
||||
if(lightDataSize == 2*BytesPerPad16) |
||||
{ |
||||
lights[0] = string(lightData, BytesPerPad16); |
||||
lights[1] = string(lightData + BytesPerPad16, BytesPerPad16); |
||||
} |
||||
else if(lightDataSize == 2*BytesPerPad25) |
||||
{ |
||||
lights[0] = string(lightData, BytesPerPad25); |
||||
lights[1] = string(lightData + BytesPerPad25, BytesPerPad25); |
||||
} |
||||
else |
||||
{ |
||||
Log(ssprintf("SMX_SetLights2: lightDataSize is invalid (must be %i or %i)\n", |
||||
2*BytesPerPad16, 2*BytesPerPad25)); |
||||
return; |
||||
} |
||||
|
||||
SMXManager::g_pSMX->SetLights(lights); |
||||
|
||||
// If we're running auto animations, stop them when we get an API call to set lights.
|
||||
SMXAutoPanelAnimations::TemporaryStopAnimating(); |
||||
} |
||||
|
||||
// This is internal for SMXConfig. These lights aren't meant to be animated.
|
||||
SMX_API void SMX_SetPlatformLights(const char lightData[88*3], int lightDataSize) |
||||
{ |
||||
if(lightDataSize != 88*3) |
||||
{ |
||||
Log(ssprintf("SMX_SetPlatformLights: lightDataSize is invalid (must be %i)\n", |
||||
88*3)); |
||||
return; |
||||
} |
||||
|
||||
string lights[2]; |
||||
lights[0] = string(lightData, 44*3); |
||||
lights[1] = string(lightData + 44*3, 44*3); |
||||
SMXManager::g_pSMX->SetPlatformLights(lights); |
||||
} |
||||
|
||||
SMX_API void SMX_ReenableAutoLights() { SMXManager::g_pSMX->ReenableAutoLights(); } |
||||
SMX_API const char *SMX_Version() { return SMX_BUILD_VERSION; } |
||||
|
||||
// These aren't exposed in the public API, since they're only used internally.
|
||||
SMX_API void SMX_SetOnlySendLightsOnChange(bool value) { SMXManager::g_pSMX->SetOnlySendLightsOnChange(value); } |
||||
SMX_API void SMX_SetSerialNumbers() { SMXManager::g_pSMX->SetSerialNumbers(); } |
||||
@ -0,0 +1,169 @@ |
||||
#include "SMXConfigPacket.h" |
||||
#include <stdint.h> |
||||
#include <stddef.h> |
||||
|
||||
// The config packet format changed in version 5. This handles compatibility with
|
||||
// the old configuration packet. The config packet in SMX.h matches the new format.
|
||||
//
|
||||
|
||||
|
||||
#pragma pack(push, 1) |
||||
struct OldSMXConfig |
||||
{ |
||||
uint8_t unused1 = 0xFF, unused2 = 0xFF; |
||||
uint8_t unused3 = 0xFF, unused4 = 0xFF; |
||||
uint8_t unused5 = 0xFF, unused6 = 0xFF; |
||||
|
||||
uint16_t masterDebounceMilliseconds = 0; |
||||
uint8_t panelThreshold7Low = 0xFF, panelThreshold7High = 0xFF; // was "cardinal"
|
||||
uint8_t panelThreshold4Low = 0xFF, panelThreshold4High = 0xFF; // was "center"
|
||||
uint8_t panelThreshold2Low = 0xFF, panelThreshold2High = 0xFF; // was "corner"
|
||||
|
||||
uint16_t panelDebounceMicroseconds = 4000; |
||||
uint16_t autoCalibrationPeriodMilliseconds = 1000; |
||||
uint8_t autoCalibrationMaxDeviation = 100; |
||||
uint8_t badSensorMinimumDelaySeconds = 15; |
||||
uint16_t autoCalibrationAveragesPerUpdate = 60; |
||||
|
||||
uint8_t unused7 = 0xFF, unused8 = 0xFF; |
||||
|
||||
uint8_t panelThreshold1Low = 0xFF, panelThreshold1High = 0xFF; // was "up"
|
||||
|
||||
uint8_t enabledSensors[5]; |
||||
|
||||
uint8_t autoLightsTimeout = 1000/128; // 1 second
|
||||
|
||||
uint8_t stepColor[3*9]; |
||||
|
||||
uint8_t panelRotation; |
||||
|
||||
uint16_t autoCalibrationSamplesPerAverage = 500; |
||||
|
||||
uint8_t masterVersion = 0xFF; |
||||
uint8_t configVersion = 0x03; |
||||
|
||||
uint8_t unused9[10]; |
||||
uint8_t panelThreshold0Low, panelThreshold0High; |
||||
uint8_t panelThreshold3Low, panelThreshold3High; |
||||
uint8_t panelThreshold5Low, panelThreshold5High; |
||||
uint8_t panelThreshold6Low, panelThreshold6High; |
||||
uint8_t panelThreshold8Low, panelThreshold8High; |
||||
|
||||
uint16_t debounceDelayMilliseconds = 0; |
||||
|
||||
uint8_t padding[164]; |
||||
}; |
||||
#pragma pack(pop) |
||||
static_assert(offsetof(OldSMXConfig, padding) == 86, "Incorrect padding alignment"); |
||||
static_assert(sizeof(OldSMXConfig) == 250, "Expected 250 bytes"); |
||||
|
||||
void ConvertToNewConfig(const vector<uint8_t> &oldConfigData, SMXConfig &newConfig) |
||||
{ |
||||
// Copy data in its order within OldSMXConfig. This lets us easily stop at each
|
||||
// known packet version. Any fields that aren't present in oldConfigData will be
|
||||
// left at their default values in SMXConfig.
|
||||
const OldSMXConfig &oldConfig = (OldSMXConfig &) *oldConfigData.data(); |
||||
|
||||
newConfig.debounceNodelayMilliseconds = oldConfig.masterDebounceMilliseconds; |
||||
|
||||
newConfig.panelSettings[7].loadCellLowThreshold = oldConfig.panelThreshold7Low; |
||||
newConfig.panelSettings[4].loadCellLowThreshold = oldConfig.panelThreshold4Low; |
||||
newConfig.panelSettings[2].loadCellLowThreshold = oldConfig.panelThreshold2Low; |
||||
|
||||
newConfig.panelSettings[7].loadCellHighThreshold = oldConfig.panelThreshold7High; |
||||
newConfig.panelSettings[4].loadCellHighThreshold = oldConfig.panelThreshold4High; |
||||
newConfig.panelSettings[2].loadCellHighThreshold = oldConfig.panelThreshold2High; |
||||
|
||||
newConfig.panelDebounceMicroseconds = oldConfig.panelDebounceMicroseconds; |
||||
newConfig.autoCalibrationMaxDeviation = oldConfig.autoCalibrationMaxDeviation; |
||||
newConfig.badSensorMinimumDelaySeconds = oldConfig.badSensorMinimumDelaySeconds; |
||||
newConfig.autoCalibrationAveragesPerUpdate = oldConfig.autoCalibrationAveragesPerUpdate; |
||||
|
||||
newConfig.panelSettings[1].loadCellLowThreshold = oldConfig.panelThreshold1Low; |
||||
newConfig.panelSettings[1].loadCellHighThreshold = oldConfig.panelThreshold1High; |
||||
|
||||
memcpy(newConfig.enabledSensors, oldConfig.enabledSensors, sizeof(newConfig.enabledSensors)); |
||||
newConfig.autoLightsTimeout = oldConfig.autoLightsTimeout; |
||||
memcpy(newConfig.stepColor, oldConfig.stepColor, sizeof(newConfig.stepColor)); |
||||
newConfig.panelRotation = oldConfig.panelRotation; |
||||
newConfig.autoCalibrationSamplesPerAverage = oldConfig.autoCalibrationSamplesPerAverage; |
||||
|
||||
if(oldConfig.configVersion == 0xFF) |
||||
return; |
||||
|
||||
newConfig.masterVersion = oldConfig.masterVersion; |
||||
newConfig.configVersion = oldConfig.configVersion; |
||||
|
||||
if(oldConfig.configVersion < 2) |
||||
return; |
||||
|
||||
newConfig.panelSettings[0].loadCellLowThreshold = oldConfig.panelThreshold0Low; |
||||
newConfig.panelSettings[3].loadCellLowThreshold = oldConfig.panelThreshold3Low; |
||||
newConfig.panelSettings[5].loadCellLowThreshold = oldConfig.panelThreshold5Low; |
||||
newConfig.panelSettings[6].loadCellLowThreshold = oldConfig.panelThreshold6Low; |
||||
newConfig.panelSettings[8].loadCellLowThreshold = oldConfig.panelThreshold8Low; |
||||
|
||||
newConfig.panelSettings[0].loadCellHighThreshold = oldConfig.panelThreshold0High; |
||||
newConfig.panelSettings[3].loadCellHighThreshold = oldConfig.panelThreshold3High; |
||||
newConfig.panelSettings[5].loadCellHighThreshold = oldConfig.panelThreshold5High; |
||||
newConfig.panelSettings[6].loadCellHighThreshold = oldConfig.panelThreshold6High; |
||||
newConfig.panelSettings[8].loadCellHighThreshold = oldConfig.panelThreshold8High; |
||||
|
||||
if(oldConfig.configVersion < 3) |
||||
return; |
||||
|
||||
newConfig.debounceDelayMilliseconds = oldConfig.debounceDelayMilliseconds; |
||||
} |
||||
|
||||
// oldConfigData contains the data we're replacing. Any fields that exist in the old
|
||||
// config format and not the new one will be left unchanged.
|
||||
void ConvertToOldConfig(const SMXConfig &newConfig, vector<uint8_t> &oldConfigData) |
||||
{ |
||||
OldSMXConfig &oldConfig = (OldSMXConfig &) *oldConfigData.data(); |
||||
|
||||
// We don't need to check configVersion here. It's safe to set all fields in
|
||||
// the output config packet. If oldConfigData isn't 128 bytes, extend it.
|
||||
if(oldConfigData.size() < 128) |
||||
oldConfigData.resize(128, 0xFF); |
||||
|
||||
oldConfig.masterDebounceMilliseconds = newConfig.debounceNodelayMilliseconds; |
||||
|
||||
oldConfig.panelThreshold7Low = newConfig.panelSettings[7].loadCellLowThreshold; |
||||
oldConfig.panelThreshold4Low = newConfig.panelSettings[4].loadCellLowThreshold; |
||||
oldConfig.panelThreshold2Low = newConfig.panelSettings[2].loadCellLowThreshold; |
||||
|
||||
oldConfig.panelThreshold7High = newConfig.panelSettings[7].loadCellHighThreshold; |
||||
oldConfig.panelThreshold4High = newConfig.panelSettings[4].loadCellHighThreshold; |
||||
oldConfig.panelThreshold2High = newConfig.panelSettings[2].loadCellHighThreshold; |
||||
|
||||
oldConfig.panelDebounceMicroseconds = newConfig.panelDebounceMicroseconds; |
||||
oldConfig.autoCalibrationMaxDeviation = newConfig.autoCalibrationMaxDeviation; |
||||
oldConfig.badSensorMinimumDelaySeconds = newConfig.badSensorMinimumDelaySeconds; |
||||
oldConfig.autoCalibrationAveragesPerUpdate = newConfig.autoCalibrationAveragesPerUpdate; |
||||
|
||||
oldConfig.panelThreshold1Low = newConfig.panelSettings[1].loadCellLowThreshold; |
||||
oldConfig.panelThreshold1High = newConfig.panelSettings[1].loadCellHighThreshold; |
||||
|
||||
memcpy(oldConfig.enabledSensors, newConfig.enabledSensors, sizeof(newConfig.enabledSensors)); |
||||
oldConfig.autoLightsTimeout = newConfig.autoLightsTimeout; |
||||
memcpy(oldConfig.stepColor, newConfig.stepColor, sizeof(newConfig.stepColor)); |
||||
oldConfig.panelRotation = newConfig.panelRotation; |
||||
oldConfig.autoCalibrationSamplesPerAverage = newConfig.autoCalibrationSamplesPerAverage; |
||||
|
||||
oldConfig.masterVersion = newConfig.masterVersion; |
||||
oldConfig.configVersion= newConfig.configVersion; |
||||
|
||||
oldConfig.panelThreshold0Low = newConfig.panelSettings[0].loadCellLowThreshold; |
||||
oldConfig.panelThreshold3Low = newConfig.panelSettings[3].loadCellLowThreshold; |
||||
oldConfig.panelThreshold5Low = newConfig.panelSettings[5].loadCellLowThreshold; |
||||
oldConfig.panelThreshold6Low = newConfig.panelSettings[6].loadCellLowThreshold; |
||||
oldConfig.panelThreshold8Low = newConfig.panelSettings[8].loadCellLowThreshold; |
||||
|
||||
oldConfig.panelThreshold0High = newConfig.panelSettings[0].loadCellHighThreshold; |
||||
oldConfig.panelThreshold3High = newConfig.panelSettings[3].loadCellHighThreshold; |
||||
oldConfig.panelThreshold5High = newConfig.panelSettings[5].loadCellHighThreshold; |
||||
oldConfig.panelThreshold6High = newConfig.panelSettings[6].loadCellHighThreshold; |
||||
oldConfig.panelThreshold8High = newConfig.panelSettings[8].loadCellHighThreshold; |
||||
|
||||
oldConfig.debounceDelayMilliseconds = newConfig.debounceDelayMilliseconds; |
||||
} |
||||
@ -0,0 +1,12 @@ |
||||
#ifndef SMXConfigPacket_h |
||||
#define SMXConfigPacket_h |
||||
|
||||
#include <vector> |
||||
using namespace std; |
||||
|
||||
#include "../SMX.h" |
||||
|
||||
void ConvertToNewConfig(const vector<uint8_t> &oldConfig, SMXConfig &newConfig); |
||||
void ConvertToOldConfig(const SMXConfig &newConfig, vector<uint8_t> &oldConfigData); |
||||
|
||||
#endif |
||||
@ -0,0 +1,607 @@ |
||||
#include "SMXDevice.h" |
||||
|
||||
#include "../SMX.h" |
||||
#include "Helpers.h" |
||||
#include "SMXDeviceConnection.h" |
||||
#include "SMXDeviceSearch.h" |
||||
#include "SMXConfigPacket.h" |
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <vector> |
||||
#include <map> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
// Extract test data for panel iPanel.
|
||||
static void ReadDataForPanel(const vector<uint16_t> &data, int iPanel, void *pOut, int iOutSize) |
||||
{ |
||||
int m_iBit = 0; |
||||
|
||||
uint8_t *p = (uint8_t *) pOut; |
||||
|
||||
// Read each byte.
|
||||
for(int i = 0; i < iOutSize; ++i) |
||||
{ |
||||
// Read each bit in this byte.
|
||||
uint8_t result = 0; |
||||
for(int j = 0; j < 8; ++j) |
||||
{ |
||||
bool bit = false; |
||||
|
||||
if(m_iBit < data.size()) |
||||
{ |
||||
bit = data[m_iBit] & (1 << iPanel); |
||||
m_iBit++; |
||||
} |
||||
|
||||
result |= bit << j; |
||||
} |
||||
|
||||
*p++ = result; |
||||
} |
||||
} |
||||
|
||||
|
||||
shared_ptr<SMXDevice> SMX::SMXDevice::Create(shared_ptr<AutoCloseHandle> hEvent, Mutex &lock) |
||||
{ |
||||
return CreateObj<SMXDevice>(hEvent, lock); |
||||
} |
||||
|
||||
SMX::SMXDevice::SMXDevice(shared_ptr<SMXDevice> &pSelf, shared_ptr<AutoCloseHandle> hEvent, Mutex &lock): |
||||
m_pSelf(GetPointers(pSelf, this)), |
||||
m_hEvent(hEvent), |
||||
m_Lock(lock) |
||||
{ |
||||
m_pConnection = SMXDeviceConnection::Create(); |
||||
} |
||||
|
||||
SMX::SMXDevice::~SMXDevice() |
||||
{ |
||||
} |
||||
|
||||
bool SMX::SMXDevice::OpenDeviceHandle(shared_ptr<AutoCloseHandle> pHandle, wstring &sError) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
return m_pConnection->Open(pHandle, sError); |
||||
} |
||||
|
||||
void SMX::SMXDevice::CloseDevice() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
m_pConnection->Close(); |
||||
m_bHaveConfig = false; |
||||
m_bSendConfig = false; |
||||
m_bSendingConfig = false; |
||||
m_bWaitingForConfigResponse = false; |
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
} |
||||
|
||||
shared_ptr<AutoCloseHandle> SMX::SMXDevice::GetDeviceHandle() const |
||||
{ |
||||
return m_pConnection->GetDeviceHandle(); |
||||
} |
||||
|
||||
void SMX::SMXDevice::SetUpdateCallback(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
m_pUpdateCallback = pCallback; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::IsConnected() const |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Don't expose the device as connected until we've read the current configuration.
|
||||
LockMutex Lock(m_Lock); |
||||
return IsConnectedLocked(); |
||||
} |
||||
|
||||
bool SMX::SMXDevice::IsConnectedLocked() const |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
return m_pConnection->IsConnectedWithDeviceInfo() && m_bHaveConfig; |
||||
} |
||||
|
||||
void SMX::SMXDevice::SendCommand(string cmd, function<void(string response)> pComplete) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
SendCommandLocked(cmd, pComplete); |
||||
} |
||||
|
||||
void SMX::SMXDevice::SendCommandLocked(string cmd, function<void(string response)> pComplete) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pConnection->IsConnected()) |
||||
{ |
||||
// If we're not connected, just call pComplete.
|
||||
if(pComplete) |
||||
pComplete(""); |
||||
return; |
||||
} |
||||
|
||||
// This call is nonblocking, so it's safe to do this in the UI thread.
|
||||
m_pConnection->SendCommand(cmd, pComplete); |
||||
|
||||
// Wake up the communications thread to send the message.
|
||||
if(m_hEvent) |
||||
SetEvent(m_hEvent->value()); |
||||
} |
||||
|
||||
void SMX::SMXDevice::GetInfo(SMXInfo &info) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
GetInfoLocked(info); |
||||
} |
||||
|
||||
void SMX::SMXDevice::GetInfoLocked(SMXInfo &info) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
info = SMXInfo(); |
||||
info.m_bConnected = IsConnectedLocked(); |
||||
if(!info.m_bConnected) |
||||
return; |
||||
|
||||
// Copy fields from the low-level device info to the high-level struct.
|
||||
// These are kept separate because the interface depends on the format
|
||||
// of SMXInfo, but it doesn't care about anything inside SMXDeviceConnection.
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
memcpy(info.m_Serial, deviceInfo.m_Serial, sizeof(info.m_Serial)); |
||||
info.m_iFirmwareVersion = deviceInfo.m_iFirmwareVersion; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::IsPlayer2Locked() const |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
if(!IsConnectedLocked()) |
||||
return false; |
||||
|
||||
return m_pConnection->GetDeviceInfo().m_bP2; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::GetConfig(SMXConfig &configOut) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
return GetConfigLocked(configOut); |
||||
} |
||||
|
||||
bool SMX::SMXDevice::GetConfigLocked(SMXConfig &configOut) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// If SetConfig was called to write a new configuration but we haven't sent it
|
||||
// yet, return it instead of the configuration we read alst, so GetConfig
|
||||
// immediately after SetConfig returns the value the caller expects set.
|
||||
if(m_bSendConfig) |
||||
configOut = wanted_config; |
||||
else |
||||
configOut = config; |
||||
|
||||
return m_bHaveConfig; |
||||
} |
||||
|
||||
void SMX::SMXDevice::SetConfig(const SMXConfig &newConfig) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
wanted_config = newConfig; |
||||
m_bSendConfig = true; |
||||
} |
||||
|
||||
uint16_t SMX::SMXDevice::GetInputState() const |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
return m_pConnection->GetInputState(); |
||||
} |
||||
|
||||
void SMX::SMXDevice::FactoryReset() |
||||
{ |
||||
// Send a factory reset command, and then read the new configuration.
|
||||
LockMutex Lock(m_Lock); |
||||
SendCommandLocked("f\n"); |
||||
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
|
||||
SendCommandLocked(deviceInfo.m_iFirmwareVersion >= 5? "G":"g\n", |
||||
[&](string response) { |
||||
// We now have the new configuration.
|
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(deviceInfo.m_iFirmwareVersion >= 5) |
||||
{ |
||||
// Factory reset resets the platform strip color saved to the configuration, but doesn't
|
||||
// apply it to the lights. Do that now.
|
||||
string sLightCommand; |
||||
sLightCommand.push_back('L'); |
||||
sLightCommand.push_back(0); // LED strip index (always 0)
|
||||
sLightCommand.push_back(44); // number of LEDs to set
|
||||
|
||||
config.platformStripColor[0]; |
||||
for(int i = 0; i < 44; ++i) |
||||
{ |
||||
sLightCommand += config.platformStripColor[0]; |
||||
sLightCommand += config.platformStripColor[1]; |
||||
sLightCommand += config.platformStripColor[2]; |
||||
} |
||||
|
||||
SendCommandLocked(sLightCommand); |
||||
} |
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_FactoryResetCommandComplete); |
||||
}); |
||||
} |
||||
|
||||
void SMX::SMXDevice::ForceRecalibration() |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
SendCommandLocked("C\n"); |
||||
} |
||||
|
||||
void SMX::SMXDevice::SetSensorTestMode(SensorTestMode mode) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
m_SensorTestMode = mode; |
||||
} |
||||
|
||||
bool SMX::SMXDevice::GetTestData(SMXSensorTestModeData &data) |
||||
{ |
||||
LockMutex Lock(m_Lock); |
||||
|
||||
// Stop if we haven't read test mode data yet.
|
||||
if(!m_HaveSensorTestModeData) |
||||
return false; |
||||
|
||||
data = m_SensorTestData; |
||||
return true; |
||||
} |
||||
|
||||
void SMX::SMXDevice::CallUpdateCallback(SMXUpdateCallbackReason reason) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pUpdateCallback) |
||||
return; |
||||
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
m_pUpdateCallback(deviceInfo.m_bP2? 1:0, reason); |
||||
} |
||||
|
||||
void SMX::SMXDevice::HandlePackets() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
while(1) |
||||
{ |
||||
string buf; |
||||
if(!m_pConnection->ReadPacket(buf)) |
||||
break; |
||||
if(buf.empty()) |
||||
continue; |
||||
|
||||
switch(buf[0]) |
||||
{ |
||||
case 'y': |
||||
HandleSensorTestDataResponse(buf); |
||||
break; |
||||
|
||||
// 'g' is sent by firmware versions 1-4. Version 5 and newer send 'G', to ensure
|
||||
// older code doesn't misinterpret the modified config packet format.
|
||||
case 'g': |
||||
case 'G': |
||||
{ |
||||
// This command reads back the configuration we wrote with 'w', or the defaults if
|
||||
// we haven't written any.
|
||||
if(buf.size() < 2) |
||||
{ |
||||
Log("Communication error: invalid configuration packet"); |
||||
continue; |
||||
} |
||||
uint8_t iSize = buf[1]; |
||||
if(buf.size() < iSize+2) |
||||
{ |
||||
Log("Communication error: invalid configuration packet"); |
||||
continue; |
||||
} |
||||
|
||||
// Store the raw config data in rawConfig. For V1-4 firmwares, this is the
|
||||
// old config format.
|
||||
rawConfig.resize(iSize); |
||||
memcpy(rawConfig.data(), buf.data()+2, min(iSize, sizeof(config))); |
||||
|
||||
if(buf[0] == 'g') |
||||
{ |
||||
// Convert the old config format to the new one, so the rest of the SDK and
|
||||
// user code doesn't need to deal with multiple formats.
|
||||
ConvertToNewConfig(rawConfig, config); |
||||
} |
||||
else |
||||
{ |
||||
// This is the new config format. Copy it directly into config.
|
||||
memcpy(&config, buf.data()+2, min(iSize, sizeof(config))); |
||||
} |
||||
|
||||
m_bHaveConfig = true; |
||||
buf.erase(buf.begin(), buf.begin()+iSize+2); |
||||
|
||||
// Log(ssprintf("Read back configuration: %i bytes, first byte %i", iSize, buf[2]));
|
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
// If m_bSendConfig is true, send the configuration to the pad. Note that while the game
|
||||
// always sends its configuration, so the pad is configured according to the game's configuration,
|
||||
// we only change the configuration if the user changes something so we don't overwrite
|
||||
// his configuration.
|
||||
void SMX::SMXDevice::SendConfig() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pConnection->IsConnected() || !m_bSendConfig || m_bSendingConfig) |
||||
return; |
||||
|
||||
// We can't update the configuration until we've received the device's previous
|
||||
// configuration.
|
||||
if(!m_bHaveConfig) |
||||
return; |
||||
|
||||
// If we're still waiting for a previous configuration to read back, don't send
|
||||
// another yet.
|
||||
if(m_bWaitingForConfigResponse) |
||||
return; |
||||
|
||||
// Rate limit updating the configuration, to prevent excess EEPROM wear. This is just
|
||||
// a safeguard in case applications try to change the configuration in realtime. If we've
|
||||
// written the configuration recently, stop. We'll write the most recent configuration
|
||||
// once enough time has passed. This is hidden to the application, since GetConfig returns
|
||||
// wanted_config if it's set.
|
||||
const float fTimeBetweenConfigUpdates = 1.0f; |
||||
double fNow = SMX::GetMonotonicTime(); |
||||
if(m_fDelayConfigUpdatesUntil > fNow) |
||||
return; |
||||
m_fDelayConfigUpdatesUntil = fNow + 1.0f; |
||||
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
|
||||
// Write configuration command. This is "w" in versions 1-4, and "W" in versions 5
|
||||
// and newer.
|
||||
string sData = ssprintf(deviceInfo.m_iFirmwareVersion >= 5? "W":"w"); |
||||
|
||||
// Append the config packet.
|
||||
if(deviceInfo.m_iFirmwareVersion < 5) |
||||
{ |
||||
// Convert wanted_config to the old configuration format.
|
||||
vector<uint8_t> outputConfig = rawConfig; |
||||
ConvertToOldConfig(wanted_config, outputConfig); |
||||
|
||||
uint8_t iSize = (uint8_t) outputConfig.size(); |
||||
sData.append((char *) &iSize, sizeof(iSize)); |
||||
sData.append((char *) outputConfig.data(), outputConfig.size()); |
||||
} |
||||
else |
||||
{ |
||||
int8_t iSize = sizeof(SMXConfig); |
||||
sData.append((char *) &iSize, sizeof(iSize)); |
||||
sData.append((char *) &wanted_config, sizeof(wanted_config)); |
||||
} |
||||
|
||||
// Don't send another config packet until this one finishes, so if we get a bunch of
|
||||
// SetConfig calls quickly we won't spam the device, which can get slow.
|
||||
m_bSendingConfig = true; |
||||
SendCommandLocked(sData, [&](string response) { |
||||
m_bSendingConfig = false; |
||||
}); |
||||
m_bSendConfig = false; |
||||
|
||||
// Assume the configuration is what we just sent, so calls to GetConfig will
|
||||
// continue to return it. Otherwise, they'd return the old values until the
|
||||
// command below completes.
|
||||
config = wanted_config; |
||||
|
||||
// Don't send another configuration packet until we receive the response to the above
|
||||
// command. If we're sending updates quickly (eg. dragging the color slider), we can
|
||||
// send multiple updates before we get a response.
|
||||
m_bWaitingForConfigResponse = true; |
||||
|
||||
// After we write the configuration, read back the updated configuration to
|
||||
// verify it. This command is "g" in versions 1-4, and "G" in versions 5 and
|
||||
// newer.
|
||||
SendCommandLocked( |
||||
deviceInfo.m_iFirmwareVersion >= 5? "G":"g\n", [this](string response) { |
||||
m_bWaitingForConfigResponse = false; |
||||
}); |
||||
} |
||||
|
||||
void SMX::SMXDevice::Update(wstring &sError) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(!m_pConnection->IsConnected()) |
||||
return; |
||||
|
||||
CheckActive(); |
||||
SendConfig(); |
||||
UpdateSensorTestMode(); |
||||
|
||||
{ |
||||
uint16_t iOldState = m_pConnection->GetInputState(); |
||||
|
||||
// Process any received packets, and start sending any waiting packets.
|
||||
m_pConnection->Update(sError); |
||||
if(!sError.empty()) |
||||
return; |
||||
|
||||
// If the inputs changed from packets we just processed, call the update callback.
|
||||
if(iOldState != m_pConnection->GetInputState()) |
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
} |
||||
|
||||
HandlePackets(); |
||||
} |
||||
|
||||
void SMX::SMXDevice::CheckActive() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// If there's no connected device, or we've already activated it, we have nothing to do.
|
||||
if(!m_pConnection->IsConnectedWithDeviceInfo() || m_pConnection->GetActive()) |
||||
return; |
||||
|
||||
m_pConnection->SetActive(true); |
||||
|
||||
SMXDeviceInfo deviceInfo = m_pConnection->GetDeviceInfo(); |
||||
|
||||
// Read the current configuration. The device will return a "g" or "G" response
|
||||
// containing its current SMXConfig.
|
||||
SendCommandLocked(deviceInfo.m_iFirmwareVersion >= 5? "G":"g\n"); |
||||
} |
||||
|
||||
// Check if we need to request test mode data.
|
||||
void SMX::SMXDevice::UpdateSensorTestMode() |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
if(m_SensorTestMode == SensorTestMode_Off) |
||||
return; |
||||
|
||||
// Request sensor data from the master. Don't send this if we have a request outstanding
|
||||
// already.
|
||||
uint32_t now = GetTickCount(); |
||||
if(m_WaitingForSensorTestModeResponse != SensorTestMode_Off) |
||||
{ |
||||
// This request should be quick. If we haven't received a response in a long
|
||||
// time, assume the request wasn't received.
|
||||
if(now - m_SentSensorTestModeRequestAtTicks < 2000) |
||||
return; |
||||
} |
||||
|
||||
|
||||
// Send the request.
|
||||
m_WaitingForSensorTestModeResponse = m_SensorTestMode; |
||||
m_SentSensorTestModeRequestAtTicks = now; |
||||
|
||||
SendCommandLocked(ssprintf("y%c\n", m_SensorTestMode)); |
||||
} |
||||
|
||||
// Handle a response to UpdateTestMode.
|
||||
void SMX::SMXDevice::HandleSensorTestDataResponse(const string &sReadBuffer) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// "y" is a response to our "y" query. This is binary data, with the format:
|
||||
// yAB......
|
||||
// where A is our original query mode (currently '0' or '1'), and B is the number
|
||||
// of bits from each panel in the response. Each bit is encoded as a 16-bit int,
|
||||
// with each int having the response bits from each panel.
|
||||
if(sReadBuffer.size() < 3) |
||||
return; |
||||
|
||||
// If we don't have the whole packet yet, wait.
|
||||
uint8_t iSize = sReadBuffer[2] * 2; |
||||
if(sReadBuffer.size() < iSize + 3) |
||||
return; |
||||
|
||||
SensorTestMode iMode = (SensorTestMode) sReadBuffer[1]; |
||||
|
||||
// Copy off the data and remove it from the serial buffer.
|
||||
vector<uint16_t> data; |
||||
for(int i = 3; i < iSize + 3; i += 2) |
||||
{ |
||||
uint16_t iValue = |
||||
(uint8_t(sReadBuffer[i+1]) << 8) | |
||||
(uint8_t(sReadBuffer[i+0]) << 0); |
||||
data.push_back(iValue); |
||||
} |
||||
|
||||
if(m_WaitingForSensorTestModeResponse == SensorTestMode_Off) |
||||
{ |
||||
Log("Ignoring unexpected sensor data request. It may have been sent by another application."); |
||||
return; |
||||
} |
||||
|
||||
if(iMode != m_WaitingForSensorTestModeResponse) |
||||
{ |
||||
Log(ssprintf("Ignoring unexpected sensor data request (got %i, expected %i)", iMode, m_WaitingForSensorTestModeResponse)); |
||||
return; |
||||
} |
||||
|
||||
m_WaitingForSensorTestModeResponse = SensorTestMode_Off; |
||||
|
||||
// We match m_WaitingForSensorTestModeResponse, which is the sensor request we most
|
||||
// recently sent. If we don't match g_SensorTestMode, then the sensor mode was changed
|
||||
// while a request was in the air. Just ignore the response.
|
||||
if(iMode != m_SensorTestMode) |
||||
return; |
||||
|
||||
#pragma pack(push,1) |
||||
struct detail_data { |
||||
uint8_t sig1:1; // always 0
|
||||
uint8_t sig2:1; // always 1
|
||||
uint8_t sig3:1; // always 0
|
||||
uint8_t bad_sensor_0:1; |
||||
uint8_t bad_sensor_1:1; |
||||
uint8_t bad_sensor_2:1; |
||||
uint8_t bad_sensor_3:1; |
||||
uint8_t dummy:1; |
||||
|
||||
int16_t sensors[4]; |
||||
|
||||
uint8_t dip:4; |
||||
uint8_t bad_sensor_dip_0:1; |
||||
uint8_t bad_sensor_dip_1:1; |
||||
uint8_t bad_sensor_dip_2:1; |
||||
uint8_t bad_sensor_dip_3:1; |
||||
}; |
||||
#pragma pack(pop) |
||||
|
||||
m_HaveSensorTestModeData = true; |
||||
SMXSensorTestModeData &output = m_SensorTestData; |
||||
|
||||
bool bLastHaveDataFromPanel[9]; |
||||
memcpy(bLastHaveDataFromPanel, output.bHaveDataFromPanel, sizeof(output.bHaveDataFromPanel)); |
||||
memset(output.bHaveDataFromPanel, 0, sizeof(output.bHaveDataFromPanel)); |
||||
|
||||
memset(output.sensorLevel, 0, sizeof(output.sensorLevel)); |
||||
memset(output.bBadSensorInput, 0, sizeof(output.bBadSensorInput)); |
||||
memset(output.iDIPSwitchPerPanel, 0, sizeof(output.iDIPSwitchPerPanel)); |
||||
memset(output.iBadJumper, 0, sizeof(output.iBadJumper)); |
||||
|
||||
for(int iPanel = 0; iPanel < 9; ++iPanel) |
||||
{ |
||||
// Decode the response from this panel.
|
||||
detail_data pad_data; |
||||
ReadDataForPanel(data, iPanel, &pad_data, sizeof(pad_data)); |
||||
|
||||
// Check the header. This is always 0 1 0, to identify it as a response, and not as random
|
||||
// steps from the player.
|
||||
if(pad_data.sig1 != 0 || pad_data.sig2 != 1 || pad_data.sig3 != 0) |
||||
{ |
||||
if(bLastHaveDataFromPanel[iPanel]) |
||||
Log(ssprintf("No data from panel %i (%02x %02x %02x)", iPanel, pad_data.sig1, pad_data.sig2, pad_data.sig3)); |
||||
output.bHaveDataFromPanel[iPanel] = false; |
||||
continue; |
||||
} |
||||
output.bHaveDataFromPanel[iPanel] = true; |
||||
|
||||
// These bits are true if that sensor's most recent reading is invalid.
|
||||
output.bBadSensorInput[iPanel][0] = pad_data.bad_sensor_0; |
||||
output.bBadSensorInput[iPanel][1] = pad_data.bad_sensor_1; |
||||
output.bBadSensorInput[iPanel][2] = pad_data.bad_sensor_2; |
||||
output.bBadSensorInput[iPanel][3] = pad_data.bad_sensor_3; |
||||
output.iDIPSwitchPerPanel[iPanel] = pad_data.dip; |
||||
output.iBadJumper[iPanel][0] = pad_data.bad_sensor_dip_0; |
||||
output.iBadJumper[iPanel][1] = pad_data.bad_sensor_dip_1; |
||||
output.iBadJumper[iPanel][2] = pad_data.bad_sensor_dip_2; |
||||
output.iBadJumper[iPanel][3] = pad_data.bad_sensor_dip_3; |
||||
|
||||
for(int iSensor = 0; iSensor < 4; ++iSensor) |
||||
output.sensorLevel[iPanel][iSensor] = pad_data.sensors[iSensor]; |
||||
} |
||||
|
||||
CallUpdateCallback(SMXUpdateCallback_Updated); |
||||
} |
||||
@ -0,0 +1,136 @@ |
||||
#ifndef SMXDevice_h |
||||
#define SMXDevice_h |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <functional> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
#include "../SMX.h" |
||||
|
||||
namespace SMX |
||||
{ |
||||
class SMXDeviceConnection; |
||||
|
||||
// The high-level interface to a single controller. This is managed by SMXManager, and uses SMXDeviceConnection
|
||||
// for low-level USB communication.
|
||||
class SMXDevice |
||||
{ |
||||
public: |
||||
// Create an SMXDevice.
|
||||
//
|
||||
// lock is our serialization mutex. This is shared across SMXManager and all SMXDevices.
|
||||
//
|
||||
// hEvent is signalled when we have new packets to be sent, to wake the communications thread. The
|
||||
// device handle opened with OpenPort must also be monitored, to check when packets have been received
|
||||
// (or successfully sent).
|
||||
static shared_ptr<SMXDevice> Create(shared_ptr<SMX::AutoCloseHandle> hEvent, SMX::Mutex &lock); |
||||
SMXDevice(shared_ptr<SMXDevice> &pSelf, shared_ptr<SMX::AutoCloseHandle> hEvent, SMX::Mutex &lock); |
||||
~SMXDevice(); |
||||
|
||||
bool OpenDeviceHandle(shared_ptr<SMX::AutoCloseHandle> pHandle, wstring &sError); |
||||
void CloseDevice(); |
||||
shared_ptr<SMX::AutoCloseHandle> GetDeviceHandle() const; |
||||
|
||||
// Set a function to be called when something changes on the device. This allows efficiently
|
||||
// detecting when a panel is pressed or other changes happen on the device.
|
||||
void SetUpdateCallback(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback); |
||||
|
||||
// Return true if we're connected.
|
||||
bool IsConnected() const; |
||||
|
||||
// Send a raw command.
|
||||
void SendCommand(string sCmd, function<void(string response)> pComplete=nullptr); |
||||
void SendCommandLocked(string sCmd, function<void(string response)> pComplete=nullptr); |
||||
|
||||
// Get basic info about the device.
|
||||
void GetInfo(SMXInfo &info); |
||||
void GetInfoLocked(SMXInfo &info); // used by SMXManager
|
||||
|
||||
// Return true if this device is configured as player 2.
|
||||
bool IsPlayer2Locked() const; // used by SMXManager
|
||||
|
||||
// Get the configuration of the connected device (or the most recently read configuration if
|
||||
// we're not connected).
|
||||
bool GetConfig(SMXConfig &configOut); |
||||
bool GetConfigLocked(SMXConfig &configOut); |
||||
|
||||
// Set the configuration of the connected device.
|
||||
//
|
||||
// This is asynchronous and returns immediately.
|
||||
void SetConfig(const SMXConfig &newConfig); |
||||
|
||||
// Return a mask of the panels currently pressed.
|
||||
uint16_t GetInputState() const; |
||||
|
||||
// Reset the configuration data to what the device used when it was first flashed.
|
||||
// GetConfig() will continue to return the previous configuration until this command
|
||||
// completes, which is signalled by a SMXUpdateCallback_FactoryResetCommandComplete callback.
|
||||
void FactoryReset(); |
||||
|
||||
// Force immediate fast recalibration. This is the same calibration that happens at
|
||||
// boot. This is only used for diagnostics, and the panels will normally auto-calibrate
|
||||
// on their own.
|
||||
void ForceRecalibration(); |
||||
|
||||
// Set the test mode of the connected device.
|
||||
//
|
||||
// This is asynchronous and returns immediately.
|
||||
void SetSensorTestMode(SensorTestMode mode); |
||||
|
||||
// Return the most recent test data we've received from the pad. Return false if we haven't
|
||||
// received test data since changing the test mode (or if we're not in a test mode).
|
||||
bool GetTestData(SMXSensorTestModeData &data); |
||||
|
||||
// Internal:
|
||||
|
||||
// Update this device, processing received packets and sending any outbound packets.
|
||||
// m_Lock must be held.
|
||||
//
|
||||
// sError will be set on a communications error. The owner must close the device.
|
||||
void Update(wstring &sError); |
||||
|
||||
private: |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
SMX::Mutex &m_Lock; |
||||
|
||||
function<void(int PadNumber, SMXUpdateCallbackReason reason)> m_pUpdateCallback; |
||||
weak_ptr<SMXDevice> m_pSelf; |
||||
|
||||
shared_ptr<SMXDeviceConnection> m_pConnection; |
||||
|
||||
// The configuration we've read from the device. m_bHaveConfig is true if we've received
|
||||
// a configuration from the device since we've connected to it.
|
||||
SMXConfig config; |
||||
vector<uint8_t> rawConfig; |
||||
bool m_bHaveConfig = false; |
||||
double m_fDelayConfigUpdatesUntil = 0; |
||||
|
||||
// This is the configuration the user has set, if he's changed anything. We send this to
|
||||
// the device if m_bSendConfig is true. Once we send it once, m_bSendConfig is cleared, and
|
||||
// if we see a different configuration from the device again we won't re-send this.
|
||||
SMXConfig wanted_config; |
||||
bool m_bSendConfig = false; |
||||
bool m_bSendingConfig = false; |
||||
bool m_bWaitingForConfigResponse = false; |
||||
|
||||
void CallUpdateCallback(SMXUpdateCallbackReason reason); |
||||
void HandlePackets(); |
||||
|
||||
void SendConfig(); |
||||
void CheckActive(); |
||||
bool IsConnectedLocked() const; |
||||
|
||||
// Test/diagnostics mode handling.
|
||||
void UpdateSensorTestMode(); |
||||
void HandleSensorTestDataResponse(const string &sReadBuffer); |
||||
SensorTestMode m_WaitingForSensorTestModeResponse = SensorTestMode_Off; |
||||
SensorTestMode m_SensorTestMode = SensorTestMode_Off; |
||||
bool m_HaveSensorTestModeData = false; |
||||
SMXSensorTestModeData m_SensorTestData; |
||||
uint32_t m_SentSensorTestModeRequestAtTicks = 0; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,437 @@ |
||||
#include "SMXDeviceConnection.h" |
||||
#include "Helpers.h" |
||||
|
||||
#include <string> |
||||
#include <memory> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
#include <hidsdi.h> |
||||
#include <SetupAPI.h> |
||||
|
||||
SMX::SMXDeviceConnection::PendingCommandPacket::PendingCommandPacket() |
||||
{ |
||||
} |
||||
|
||||
SMXDeviceConnection::PendingCommand::PendingCommand() |
||||
{ |
||||
memset(&m_Overlapped, 0, sizeof(m_Overlapped)); |
||||
} |
||||
|
||||
shared_ptr<SMX::SMXDeviceConnection> SMXDeviceConnection::Create() |
||||
{ |
||||
return CreateObj<SMXDeviceConnection>(); |
||||
} |
||||
|
||||
SMX::SMXDeviceConnection::SMXDeviceConnection(shared_ptr<SMXDeviceConnection> &pSelf): |
||||
m_pSelf(GetPointers(pSelf, this)) |
||||
{ |
||||
memset(&overlapped_read, 0, sizeof(overlapped_read)); |
||||
} |
||||
|
||||
SMX::SMXDeviceConnection::~SMXDeviceConnection() |
||||
{ |
||||
Close(); |
||||
} |
||||
|
||||
bool SMX::SMXDeviceConnection::Open(shared_ptr<AutoCloseHandle> DeviceHandle, wstring &sError) |
||||
{ |
||||
m_hDevice = DeviceHandle; |
||||
|
||||
if(!HidD_SetNumInputBuffers(DeviceHandle->value(), 512)) |
||||
Log(ssprintf("Error: HidD_SetNumInputBuffers: %ls", GetErrorString(GetLastError()).c_str())); |
||||
|
||||
// Begin the first async read.
|
||||
BeginAsyncRead(sError); |
||||
|
||||
// Request device info.
|
||||
RequestDeviceInfo([&](string response) { |
||||
Log(ssprintf("Received device info. Master version: %i, P%i", m_DeviceInfo.m_iFirmwareVersion, m_DeviceInfo.m_bP2+1)); |
||||
m_bGotInfo = true; |
||||
}); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::Close() |
||||
{ |
||||
Log("Closing device"); |
||||
|
||||
if(m_hDevice) |
||||
CancelIo(m_hDevice->value()); |
||||
|
||||
// If we're being closed while a command was in progress, call its completion
|
||||
// callback, so it's guaranteed to always be called.
|
||||
if(m_pCurrentCommand && m_pCurrentCommand->m_pComplete) |
||||
m_pCurrentCommand->m_pComplete(""); |
||||
|
||||
// If any commands were queued with completion callbacks, call their completion
|
||||
// callbacks.
|
||||
for(auto &pendingCommand: m_aPendingCommands) |
||||
{ |
||||
if(pendingCommand->m_pComplete) |
||||
pendingCommand->m_pComplete(""); |
||||
} |
||||
|
||||
m_hDevice.reset(); |
||||
m_sReadBuffers.clear(); |
||||
m_aPendingCommands.clear(); |
||||
memset(&overlapped_read, 0, sizeof(overlapped_read)); |
||||
m_bActive = false; |
||||
m_bGotInfo = false; |
||||
m_pCurrentCommand = nullptr; |
||||
m_iInputState = 0; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::SetActive(bool bActive) |
||||
{ |
||||
if(m_bActive == bActive) |
||||
return; |
||||
|
||||
m_bActive = bActive; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::Update(wstring &sError) |
||||
{ |
||||
if(!sError.empty()) |
||||
return; |
||||
|
||||
if(m_hDevice == nullptr) |
||||
{ |
||||
sError = L"Device not open"; |
||||
return; |
||||
} |
||||
|
||||
// A read packet can allow us to initiate a write, so check reads before writes.
|
||||
CheckReads(sError); |
||||
CheckWrites(sError); |
||||
} |
||||
|
||||
bool SMX::SMXDeviceConnection::ReadPacket(string &out) |
||||
{ |
||||
if(m_sReadBuffers.empty()) |
||||
return false; |
||||
out = m_sReadBuffers.front(); |
||||
m_sReadBuffers.pop_front(); |
||||
return true; |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::CheckReads(wstring &error) |
||||
{ |
||||
if(m_pCurrentCommand) |
||||
{ |
||||
// See if this command timed out. This doesn't happen often, so this is
|
||||
// mostly just a failsafe. The controller takes a moment to initialize on
|
||||
// startup, so we use a large enough timeout that this doesn't trigger on
|
||||
// every connection.
|
||||
double fSecondsAgo = SMX::GetMonotonicTime() - m_pCurrentCommand->m_fSentAt; |
||||
if(fSecondsAgo > 2.0f) |
||||
{ |
||||
// If we didn't get a response in this long, we're not going to. Retry the
|
||||
// command by cancelling its I/O and moving it back to the command queue.
|
||||
//
|
||||
// if we were delayed and the response is in the queue, we'll get out of sync
|
||||
Log("Command timed out. Retrying..."); |
||||
CancelIoEx(m_hDevice->value(), &m_pCurrentCommand->m_Overlapped); |
||||
|
||||
// Block until the cancellation completes. This should happen quickly.
|
||||
DWORD unused; |
||||
GetOverlappedResult(m_hDevice->value(), &m_pCurrentCommand->m_Overlapped, &unused, true); |
||||
|
||||
m_aPendingCommands.push_front(m_pCurrentCommand); |
||||
m_pCurrentCommand = nullptr; |
||||
Log("Command requeued"); |
||||
} |
||||
} |
||||
|
||||
DWORD bytes; |
||||
int result = GetOverlappedResult(m_hDevice->value(), &overlapped_read, &bytes, FALSE); |
||||
if(result == 0) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
error = wstring(L"Error reading device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
|
||||
HandleUsbPacket(string(overlapped_read_buffer, bytes)); |
||||
|
||||
// Start the next read.
|
||||
BeginAsyncRead(error); |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::HandleUsbPacket(const string &buf) |
||||
{ |
||||
if(buf.empty()) |
||||
return; |
||||
// Log(ssprintf("Read: %s", BinaryToHex(buf).c_str()));
|
||||
|
||||
int iReportId = buf[0]; |
||||
switch(iReportId) |
||||
{ |
||||
case 3: |
||||
// Input state. We could also read this as a normal HID button change.
|
||||
m_iInputState = ((buf[2] & 0xFF) << 8) | |
||||
((buf[1] & 0xFF) << 0); |
||||
|
||||
// Log(ssprintf("Input state: %x (%x %x)\n", m_iInputState, buf[2], buf[1]));
|
||||
break; |
||||
|
||||
case 6: |
||||
// A HID serial packet.
|
||||
if(buf.size() < 3) |
||||
return; |
||||
|
||||
int cmd = buf[1]; |
||||
|
||||
#define PACKET_FLAG_START_OF_COMMAND 0x04 |
||||
#define PACKET_FLAG_END_OF_COMMAND 0x01 |
||||
#define PACKET_FLAG_HOST_CMD_FINISHED 0x02 |
||||
#define PACKET_FLAG_DEVICE_INFO 0x80 |
||||
|
||||
int bytes = buf[2]; |
||||
if(3 + bytes > buf.size()) |
||||
{ |
||||
Log("Communication error: oversized packet (ignored)"); |
||||
return; |
||||
} |
||||
|
||||
string sPacket( buf.begin()+3, buf.begin()+3+bytes ); |
||||
|
||||
if(cmd & PACKET_FLAG_DEVICE_INFO) |
||||
{ |
||||
// This is a response to RequestDeviceInfo. Since any application can send this,
|
||||
// we ignore the packet if we didn't request it, since it might be requested for
|
||||
// a different program.
|
||||
if(m_pCurrentCommand == nullptr || !m_pCurrentCommand->m_bIsDeviceInfoCommand) |
||||
break; |
||||
|
||||
// We're little endian and the device is too, so we can just match the struct.
|
||||
// We're depending on correct padding.
|
||||
struct data_info_packet |
||||
{ |
||||
char cmd; // always 'I'
|
||||
uint8_t packet_size; // not used
|
||||
char player; // '0' for P1, '1' for P2:
|
||||
char unused2; |
||||
uint8_t serial[16]; |
||||
uint16_t firmware_version; |
||||
char unused3; // always '\n'
|
||||
}; |
||||
|
||||
// The packet contains data_info_packet. The packet is actually one byte smaller
|
||||
// due to a padding byte added (it contains 23 bytes of data but the struct is
|
||||
// 24 bytes). Resize to be sure.
|
||||
sPacket.resize(sizeof(data_info_packet)); |
||||
|
||||
// Convert the info packet from the wire protocol to our friendlier API.
|
||||
const data_info_packet *packet = (data_info_packet *) sPacket.data(); |
||||
m_DeviceInfo.m_bP2 = packet->player == '1'; |
||||
m_DeviceInfo.m_iFirmwareVersion = packet->firmware_version; |
||||
|
||||
// The serial is binary in this packet. Hex format it, which is the same thing
|
||||
// we'll get if we read the USB serial number (eg. HidD_GetSerialNumberString).
|
||||
string sHexSerial = BinaryToHex(packet->serial, 16); |
||||
memcpy(m_DeviceInfo.m_Serial, sHexSerial.c_str(), 33); |
||||
|
||||
if(m_pCurrentCommand->m_pComplete) |
||||
m_pCurrentCommand->m_pComplete(sPacket); |
||||
m_pCurrentCommand = nullptr; |
||||
|
||||
break; |
||||
} |
||||
|
||||
// If we're not active, ignore all packets other than device info. This is always false
|
||||
// while we're in Open() waiting for the device info response.
|
||||
if(!m_bActive) |
||||
break; |
||||
|
||||
if(cmd & PACKET_FLAG_START_OF_COMMAND && !m_sCurrentReadBuffer.empty()) |
||||
{ |
||||
// When we get a start packet, the read buffer should already be empty. If
|
||||
// it isn't, we got a command that didn't end with an END_OF_COMMAND packet,
|
||||
// and something is wrong. This shouldn't happen, so warn about it and recover
|
||||
// by clearing the junk in the buffer.
|
||||
Log(ssprintf("Got PACKET_FLAG_START_OF_COMMAND, but we had %i bytes in the read buffer", |
||||
m_sCurrentReadBuffer.size())); |
||||
|
||||
m_sCurrentReadBuffer.clear(); |
||||
} |
||||
|
||||
m_sCurrentReadBuffer.append(sPacket); |
||||
|
||||
// Note that if PACKET_FLAG_HOST_CMD_FINISHED is set, PACKET_FLAG_END_OF_COMMAND
|
||||
// will always also be set.
|
||||
if(cmd & PACKET_FLAG_HOST_CMD_FINISHED) |
||||
{ |
||||
// This tells us that a command we wrote to the device has finished executing, and
|
||||
// it's safe to start writing another.
|
||||
if(m_pCurrentCommand && m_pCurrentCommand->m_pComplete) |
||||
m_pCurrentCommand->m_pComplete(m_sCurrentReadBuffer); |
||||
m_pCurrentCommand = nullptr; |
||||
} |
||||
|
||||
if(cmd & PACKET_FLAG_END_OF_COMMAND) |
||||
{ |
||||
if(!m_sCurrentReadBuffer.empty()) |
||||
m_sReadBuffers.push_back(m_sCurrentReadBuffer); |
||||
m_sCurrentReadBuffer.clear(); |
||||
} |
||||
|
||||
break; |
||||
} |
||||
|
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::BeginAsyncRead(wstring &error) |
||||
{ |
||||
while(1) |
||||
{ |
||||
// Our read buffer is 64 bytes. The HID input packet is much smaller than that,
|
||||
// but Windows pads packets to the maximum size of any HID report, and the HID
|
||||
// serial packet is 64 bytes, so we'll get 64 bytes even for 3-byte input packets.
|
||||
// If this didn't happen, we'd have to be smarter about pulling data out of the
|
||||
// read buffer.
|
||||
DWORD bytes; |
||||
memset(overlapped_read_buffer, sizeof(overlapped_read_buffer), 0); |
||||
if(!ReadFile(m_hDevice->value(), overlapped_read_buffer, sizeof(overlapped_read_buffer), &bytes, &overlapped_read)) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
error = wstring(L"Error reading device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
|
||||
// The async read finished synchronously. This just means that there was already data waiting.
|
||||
// Handle the result, and loop to try to start the next async read again.
|
||||
HandleUsbPacket(string(overlapped_read_buffer, bytes)); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::CheckWrites(wstring &error) |
||||
{ |
||||
if(m_pCurrentCommand) |
||||
{ |
||||
// A command is in progress. See if its writes have completed.
|
||||
if(m_pCurrentCommand->m_bWriting) |
||||
{ |
||||
DWORD bytes; |
||||
int iResult = GetOverlappedResult(m_hDevice->value(), &m_pCurrentCommand->m_Overlapped, &bytes, FALSE); |
||||
if(iResult == 0) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
error = wstring(L"Error writing to device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
|
||||
m_pCurrentCommand->m_bWriting = false; |
||||
} |
||||
|
||||
// Don't clear m_pCurrentCommand here. It'll stay set until we get a PACKET_FLAG_HOST_CMD_FINISHED
|
||||
// packet from the device, which tells us it's ready to receive another command.
|
||||
//
|
||||
// Don't send packets if there's a command in progress.
|
||||
return; |
||||
} |
||||
|
||||
// Stop if we have nothing to do.
|
||||
if(m_aPendingCommands.empty()) |
||||
return; |
||||
|
||||
// Send the next command.
|
||||
shared_ptr<PendingCommand> pPendingCommand = m_aPendingCommands.front(); |
||||
|
||||
// Record the time. We can use this for timeouts.
|
||||
pPendingCommand->m_fSentAt = SMX::GetMonotonicTime(); |
||||
|
||||
for(shared_ptr<PendingCommandPacket> &pPacket: pPendingCommand->m_Packets) |
||||
{ |
||||
// In theory the API allows this to return success if the write completed successfully without needing to
|
||||
// be async, like reads can. However, this can't really happen (the write always needs to go to the device
|
||||
// first, unlike reads which might already be buffered), and there's no way to test it if we implement that,
|
||||
// so this assumes all writes are async.
|
||||
DWORD unused; |
||||
// Log(ssprintf("Write: %s", BinaryToHex(pPacket->sData).c_str()));
|
||||
if(!WriteFile(m_hDevice->value(), pPacket->sData.data(), pPacket->sData.size(), &unused, &pPendingCommand->m_Overlapped)) |
||||
{ |
||||
int windows_error = GetLastError(); |
||||
if(windows_error != ERROR_IO_PENDING && windows_error != ERROR_IO_INCOMPLETE) |
||||
{ |
||||
error = wstring(L"Error writing to device: ") + GetErrorString(windows_error).c_str(); |
||||
return; |
||||
} |
||||
} |
||||
} |
||||
|
||||
pPendingCommand->m_bWriting = true; |
||||
|
||||
// Remove this command and store it in m_pCurrentCommand, and we'll stop sending data until the command finishes.
|
||||
m_pCurrentCommand = pPendingCommand; |
||||
m_aPendingCommands.pop_front(); |
||||
} |
||||
|
||||
// Request device info. This is the same as sending an 'i' command, but we can send it safely
|
||||
// at any time, even if another application is talking to the device, so we can do this during
|
||||
// enumeration.
|
||||
void SMX::SMXDeviceConnection::RequestDeviceInfo(function<void(string response)> pComplete) |
||||
{ |
||||
shared_ptr<PendingCommand> pPendingCommand = make_shared<PendingCommand>(); |
||||
pPendingCommand->m_pComplete = pComplete; |
||||
pPendingCommand->m_bIsDeviceInfoCommand = true; |
||||
|
||||
shared_ptr<PendingCommandPacket> pCommandPacket = make_shared<PendingCommandPacket>(); |
||||
|
||||
string sPacket({ |
||||
5, // report ID
|
||||
(char) (uint8_t) PACKET_FLAG_DEVICE_INFO, // flags
|
||||
(char) 0, // bytes in packet
|
||||
}); |
||||
sPacket.resize(64, 0); |
||||
pCommandPacket->sData = sPacket; |
||||
|
||||
pPendingCommand->m_Packets.push_back(pCommandPacket); |
||||
|
||||
m_aPendingCommands.push_back(pPendingCommand); |
||||
} |
||||
|
||||
void SMX::SMXDeviceConnection::SendCommand(const string &cmd, function<void(string response)> pComplete) |
||||
{ |
||||
shared_ptr<PendingCommand> pPendingCommand = make_shared<PendingCommand>(); |
||||
pPendingCommand->m_pComplete = pComplete; |
||||
|
||||
// Send the command in packets. We allow sending zero-length packets here
|
||||
// for testing purposes.
|
||||
int i = 0; |
||||
do { |
||||
shared_ptr<PendingCommandPacket> pCommandPacket = make_shared<PendingCommandPacket>(); |
||||
|
||||
int iFlags = 0; |
||||
int iPacketSize = min(cmd.size() - i, 61); |
||||
|
||||
bool bFirstPacket = (i == 0); |
||||
if(bFirstPacket) |
||||
iFlags |= PACKET_FLAG_START_OF_COMMAND; |
||||
|
||||
bool bLastPacket = (i + iPacketSize == cmd.size()); |
||||
if(bLastPacket) |
||||
iFlags |= PACKET_FLAG_END_OF_COMMAND; |
||||
|
||||
string sPacket({ |
||||
5, // report ID
|
||||
(char) iFlags, |
||||
(char) iPacketSize, // bytes in packet
|
||||
}); |
||||
|
||||
sPacket.append(cmd.begin() + i, cmd.begin() + i + iPacketSize); |
||||
sPacket.resize(64, 0); |
||||
pCommandPacket->sData = sPacket; |
||||
|
||||
pPendingCommand->m_Packets.push_back(pCommandPacket); |
||||
|
||||
i += iPacketSize; |
||||
} |
||||
while(i < cmd.size()); |
||||
|
||||
m_aPendingCommands.push_back(pPendingCommand); |
||||
} |
||||
@ -0,0 +1,131 @@ |
||||
#ifndef SMXDevice_H |
||||
#define SMXDevice_H |
||||
|
||||
#include <windows.h> |
||||
#include <vector> |
||||
#include <memory> |
||||
#include <string> |
||||
#include <list> |
||||
#include <functional> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
|
||||
namespace SMX |
||||
{ |
||||
|
||||
struct SMXDeviceInfo |
||||
{ |
||||
// If true, this controller is set to player 2.
|
||||
bool m_bP2 = false; |
||||
|
||||
// This device's serial number.
|
||||
char m_Serial[33]; |
||||
|
||||
// This device's firmware version (normally 1).
|
||||
uint16_t m_iFirmwareVersion; |
||||
}; |
||||
|
||||
// Low-level SMX device handling.
|
||||
class SMXDeviceConnection |
||||
{ |
||||
public: |
||||
static shared_ptr<SMXDeviceConnection> Create(); |
||||
SMXDeviceConnection(shared_ptr<SMXDeviceConnection> &pSelf); |
||||
~SMXDeviceConnection(); |
||||
|
||||
bool Open(shared_ptr<AutoCloseHandle> DeviceHandle, wstring &error); |
||||
|
||||
void Close(); |
||||
|
||||
// Get the device handle opened by Open(), or NULL if we're not open.
|
||||
shared_ptr<AutoCloseHandle> GetDeviceHandle() const { return m_hDevice; } |
||||
|
||||
void Update(wstring &sError); |
||||
|
||||
// Devices are inactive by default, and will just read device info and then idle. We'll
|
||||
// process input state packets, but we won't send any commands to the device or process
|
||||
// any commands from it. It's safe to have a device open but inactive if it's being used
|
||||
// by another application.
|
||||
void SetActive(bool bActive); |
||||
bool GetActive() const { return m_bActive; } |
||||
|
||||
bool IsConnected() const { return m_hDevice != nullptr; } |
||||
bool IsConnectedWithDeviceInfo() const { return m_hDevice != nullptr && m_bGotInfo; } |
||||
SMXDeviceInfo GetDeviceInfo() const { return m_DeviceInfo; } |
||||
|
||||
// Read from the read buffer. This only returns data that we've already read, so there aren't
|
||||
// any errors to report here.
|
||||
bool ReadPacket(string &out); |
||||
|
||||
// Send a command. This must be a single complete command: partial writes and multiple
|
||||
// commands in a call aren't allowed.
|
||||
void SendCommand(const string &cmd, function<void(string response)> pComplete=nullptr); |
||||
|
||||
uint16_t GetInputState() const { return m_iInputState; } |
||||
|
||||
private: |
||||
void RequestDeviceInfo(function<void(string response)> pComplete = nullptr); |
||||
|
||||
void CheckReads(wstring &error); |
||||
void BeginAsyncRead(wstring &error); |
||||
void CheckWrites(wstring &error); |
||||
void HandleUsbPacket(const string &buf); |
||||
|
||||
weak_ptr<SMXDeviceConnection> m_pSelf; |
||||
shared_ptr<AutoCloseHandle> m_hDevice; |
||||
|
||||
bool m_bActive = false; |
||||
|
||||
// After we open a device, we request basic info. Once we get it, this is set to true.
|
||||
bool m_bGotInfo = false; |
||||
|
||||
list<string> m_sReadBuffers; |
||||
string m_sCurrentReadBuffer; |
||||
|
||||
struct PendingCommandPacket { |
||||
PendingCommandPacket(); |
||||
|
||||
string sData; |
||||
}; |
||||
|
||||
// Commands that are waiting to be sent:
|
||||
struct PendingCommand { |
||||
PendingCommand(); |
||||
|
||||
list<shared_ptr<PendingCommandPacket>> m_Packets; |
||||
|
||||
// The overlapped struct for writing this command's packets. m_bWriting is true
|
||||
// if we're waiting for the write to complete.
|
||||
OVERLAPPED m_Overlapped; |
||||
bool m_bWriting = false; |
||||
|
||||
// This is only called if m_bWaitForResponse if true. Otherwise, we send the command
|
||||
// and forget about it. If the command has a response, it'll be in buf.
|
||||
function<void(string response)> m_pComplete; |
||||
|
||||
// If true, once we send this command we won't send any other commands until we get
|
||||
// a response.
|
||||
bool m_bIsDeviceInfoCommand = false; |
||||
|
||||
// The SMX::GetMonotonicTime when we started sending this command.
|
||||
double m_fSentAt = 0; |
||||
}; |
||||
list<shared_ptr<PendingCommand>> m_aPendingCommands; |
||||
|
||||
// If set, we've sent a command out of m_aPendingCommands and we're waiting for a response. We
|
||||
// can't send another command until the previous one has completed.
|
||||
shared_ptr<PendingCommand> m_pCurrentCommand = nullptr; |
||||
|
||||
// We always have a read in progress.
|
||||
OVERLAPPED overlapped_read; |
||||
char overlapped_read_buffer[64]; |
||||
|
||||
uint16_t m_iInputState = 0; |
||||
|
||||
// The current device info. We retrieve this when we connect.
|
||||
SMXDeviceInfo m_DeviceInfo; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,174 @@ |
||||
#include "SMXDeviceSearch.h" |
||||
|
||||
#include "SMXDeviceConnection.h" |
||||
#include "Helpers.h" |
||||
|
||||
#include <string> |
||||
#include <memory> |
||||
#include <set> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
#include <hidsdi.h> |
||||
#include <SetupAPI.h> |
||||
|
||||
// Return all USB HID device paths. This doesn't open the device to filter just our devices.
|
||||
static set<wstring> GetAllHIDDevicePaths(wstring &error) |
||||
{ |
||||
HDEVINFO DeviceInfoSet = NULL; |
||||
|
||||
GUID HidGuid; |
||||
HidD_GetHidGuid(&HidGuid); |
||||
DeviceInfoSet = SetupDiGetClassDevs(&HidGuid, NULL, NULL, DIGCF_DEVICEINTERFACE | DIGCF_PRESENT); |
||||
if(DeviceInfoSet == NULL) |
||||
return {}; |
||||
|
||||
set<wstring> paths; |
||||
SP_DEVICE_INTERFACE_DATA DeviceInterfaceData; |
||||
DeviceInterfaceData.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); |
||||
for(DWORD iIndex = 0; |
||||
SetupDiEnumDeviceInterfaces(DeviceInfoSet, NULL, &HidGuid, iIndex, &DeviceInterfaceData); |
||||
iIndex++) |
||||
{ |
||||
DWORD iSize; |
||||
if(!SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, &DeviceInterfaceData, NULL, 0, &iSize, NULL)) |
||||
{ |
||||
// This call normally fails with ERROR_INSUFFICIENT_BUFFER.
|
||||
int iError = GetLastError(); |
||||
if(iError != ERROR_INSUFFICIENT_BUFFER) |
||||
{ |
||||
Log(wssprintf(L"SetupDiGetDeviceInterfaceDetail failed: %ls", GetErrorString(iError).c_str())); |
||||
continue; |
||||
} |
||||
} |
||||
|
||||
PSP_DEVICE_INTERFACE_DETAIL_DATA DeviceInterfaceDetailData = (PSP_DEVICE_INTERFACE_DETAIL_DATA) alloca(iSize); |
||||
DeviceInterfaceDetailData->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); |
||||
|
||||
SP_DEVINFO_DATA DeviceInfoData; |
||||
ZeroMemory(&DeviceInfoData, sizeof(SP_DEVINFO_DATA)); |
||||
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); |
||||
if(!SetupDiGetDeviceInterfaceDetail(DeviceInfoSet, &DeviceInterfaceData, DeviceInterfaceDetailData, iSize, NULL, &DeviceInfoData)) |
||||
{ |
||||
Log(wssprintf(L"SetupDiGetDeviceInterfaceDetail failed: %ls", GetErrorString(GetLastError()).c_str())); |
||||
continue; |
||||
} |
||||
|
||||
paths.insert(DeviceInterfaceDetailData->DevicePath); |
||||
} |
||||
|
||||
SetupDiDestroyDeviceInfoList(DeviceInfoSet); |
||||
|
||||
return paths; |
||||
} |
||||
|
||||
static shared_ptr<AutoCloseHandle> OpenUSBDevice(LPCTSTR DevicePath, wstring &error) |
||||
{ |
||||
// Log(ssprintf("Opening device: %ls", DevicePath));
|
||||
HANDLE OpenDevice = CreateFile( |
||||
DevicePath, |
||||
GENERIC_READ | GENERIC_WRITE, |
||||
FILE_SHARE_READ | FILE_SHARE_WRITE, |
||||
NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL |
||||
); |
||||
|
||||
if(OpenDevice == INVALID_HANDLE_VALUE) |
||||
{ |
||||
// Many unrelated devices will fail to open, so don't return this as an error.
|
||||
Log(wssprintf(L"Error opening device %ls: %ls", DevicePath, GetErrorString(GetLastError()).c_str())); |
||||
return nullptr; |
||||
} |
||||
|
||||
auto result = make_shared<AutoCloseHandle>(OpenDevice); |
||||
|
||||
// Get the HID attributes to check the IDs.
|
||||
HIDD_ATTRIBUTES HidAttributes; |
||||
HidAttributes.Size = sizeof(HidAttributes); |
||||
if(!HidD_GetAttributes(result->value(), &HidAttributes)) |
||||
{ |
||||
Log(ssprintf("Error opening device %ls: HidD_GetAttributes failed", DevicePath)); |
||||
error = L"HidD_GetAttributes failed"; |
||||
return nullptr; |
||||
} |
||||
|
||||
if(HidAttributes.VendorID != 0x2341 || HidAttributes.ProductID != 0x8037) |
||||
{ |
||||
Log(ssprintf("Device %ls: not our device (ID %04x:%04x)", DevicePath, HidAttributes.VendorID, HidAttributes.ProductID)); |
||||
return nullptr; |
||||
} |
||||
|
||||
// Since we're using the default Arduino IDs, check the product name to make sure
|
||||
// this isn't some other Arduino device.
|
||||
WCHAR ProductName[255]; |
||||
ZeroMemory(ProductName, sizeof(ProductName)); |
||||
if(!HidD_GetProductString(result->value(), ProductName, 255)) |
||||
{ |
||||
Log(ssprintf("Error opening device %ls: HidD_GetProductString failed", DevicePath)); |
||||
return nullptr; |
||||
} |
||||
|
||||
if(wstring(ProductName) != L"StepManiaX") |
||||
{ |
||||
Log(ssprintf("Device %ls: not our device (%ls)", DevicePath, ProductName)); |
||||
return nullptr; |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> SMX::SMXDeviceSearch::GetDevices(wstring &error) |
||||
{ |
||||
set<wstring> aDevicePaths = GetAllHIDDevicePaths(error); |
||||
|
||||
// Remove any entries in m_Devices that are no longer in the list.
|
||||
for(wstring sPath: m_setLastDevicePaths) |
||||
{ |
||||
if(aDevicePaths.find(sPath) != aDevicePaths.end()) |
||||
continue; |
||||
|
||||
Log(ssprintf("Device removed: %ls", sPath.c_str())); |
||||
m_Devices.erase(sPath); |
||||
} |
||||
|
||||
// Check for new entries.
|
||||
for(wstring sPath: aDevicePaths) |
||||
{ |
||||
// Only look at devices that weren't in the list last time. OpenUSBDevice has
|
||||
// to open the device and causes requests to be sent to it.
|
||||
if(m_setLastDevicePaths.find(sPath) != m_setLastDevicePaths.end()) |
||||
continue; |
||||
|
||||
// This will return NULL if this isn't our device.
|
||||
shared_ptr<AutoCloseHandle> hDevice = OpenUSBDevice(sPath.c_str(), error); |
||||
if(hDevice == nullptr) |
||||
continue; |
||||
|
||||
Log(ssprintf("Device added: %ls", sPath.c_str())); |
||||
m_Devices[sPath] = hDevice; |
||||
} |
||||
|
||||
m_setLastDevicePaths = aDevicePaths; |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> aDevices; |
||||
for(auto it: m_Devices) |
||||
aDevices.push_back(it.second); |
||||
|
||||
return aDevices; |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearch::DeviceWasClosed(shared_ptr<AutoCloseHandle> pDevice) |
||||
{ |
||||
map<wstring, shared_ptr<AutoCloseHandle>> aDevices; |
||||
for(auto it: m_Devices) |
||||
{ |
||||
if(it.second == pDevice) |
||||
{ |
||||
m_setLastDevicePaths.erase(it.first); |
||||
} |
||||
else |
||||
{ |
||||
aDevices[it.first] = it.second; |
||||
} |
||||
} |
||||
m_Devices = aDevices; |
||||
} |
||||
@ -0,0 +1,33 @@ |
||||
#ifndef SMXDeviceSearch_h |
||||
#define SMXDeviceSearch_h |
||||
|
||||
#include <memory> |
||||
#include <string> |
||||
#include <vector> |
||||
#include <set> |
||||
#include <map> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
|
||||
namespace SMX { |
||||
|
||||
class SMXDeviceSearch |
||||
{ |
||||
public: |
||||
// Return a list of connected devices. If the same device stays connected and this
|
||||
// is called multiple times, the same handle will be returned.
|
||||
vector<shared_ptr<AutoCloseHandle>> GetDevices(wstring &error); |
||||
|
||||
// After a device is opened and then closed, tell this class that the device was closed.
|
||||
// We'll discard our record of it, so we'll notice a new device plugged in on the same
|
||||
// path.
|
||||
void DeviceWasClosed(shared_ptr<AutoCloseHandle> pDevice); |
||||
|
||||
private: |
||||
set<wstring> m_setLastDevicePaths; |
||||
map<wstring, shared_ptr<AutoCloseHandle>> m_Devices; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,97 @@ |
||||
#include "SMXDeviceSearchThreaded.h" |
||||
#include "SMXDeviceSearch.h" |
||||
#include "SMXDeviceConnection.h" |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
SMX::SMXDeviceSearchThreaded::SMXDeviceSearchThreaded() |
||||
{ |
||||
m_hEvent = make_shared<AutoCloseHandle>(CreateEvent(NULL, false, false, NULL)); |
||||
m_pDeviceList = make_shared<SMXDeviceSearch>(); |
||||
|
||||
// Start the thread.
|
||||
DWORD id; |
||||
m_hThread = CreateThread(NULL, 0, ThreadMainStart, this, 0, &id); |
||||
SMX::SetThreadName(id, "SMXDeviceSearch"); |
||||
} |
||||
|
||||
SMX::SMXDeviceSearchThreaded::~SMXDeviceSearchThreaded() |
||||
{ |
||||
// Shut down the thread, if it's still running.
|
||||
Shutdown(); |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::Shutdown() |
||||
{ |
||||
if(m_hThread == INVALID_HANDLE_VALUE) |
||||
return; |
||||
|
||||
// Tell the thread to shut down, and wait for it before returning.
|
||||
m_bShutdown = true; |
||||
SetEvent(m_hEvent->value()); |
||||
|
||||
WaitForSingleObject(m_hThread, INFINITE); |
||||
m_hThread = INVALID_HANDLE_VALUE; |
||||
} |
||||
|
||||
DWORD WINAPI SMX::SMXDeviceSearchThreaded::ThreadMainStart(void *self_) |
||||
{ |
||||
SMXDeviceSearchThreaded *self = (SMXDeviceSearchThreaded *) self_; |
||||
self->ThreadMain(); |
||||
return 0; |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::UpdateDeviceList() |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Tell m_pDeviceList about closed devices, so it knows that any device on the
|
||||
// same path is new.
|
||||
m_Lock.Lock(); |
||||
for(auto pDevice: m_apClosedDevices) |
||||
m_pDeviceList->DeviceWasClosed(pDevice); |
||||
m_apClosedDevices.clear(); |
||||
m_Lock.Unlock(); |
||||
|
||||
// Get the current device list.
|
||||
wstring sError; |
||||
vector<shared_ptr<AutoCloseHandle>> apDevices = m_pDeviceList->GetDevices(sError); |
||||
if(!sError.empty()) |
||||
{ |
||||
Log(ssprintf("Error listing USB devices: %ls", sError.c_str())); |
||||
return; |
||||
} |
||||
|
||||
// Update the device list returned by GetDevices.
|
||||
m_Lock.Lock(); |
||||
m_apDevices = apDevices; |
||||
m_Lock.Unlock(); |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::ThreadMain() |
||||
{ |
||||
while(!m_bShutdown) |
||||
{ |
||||
UpdateDeviceList(); |
||||
WaitForSingleObjectEx(m_hEvent->value(), 250, true); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXDeviceSearchThreaded::DeviceWasClosed(shared_ptr<AutoCloseHandle> pDevice) |
||||
{ |
||||
// Add pDevice to the list of closed devices. We'll call m_pDeviceList->DeviceWasClosed
|
||||
// on these from the scanning thread.
|
||||
m_apClosedDevices.push_back(pDevice); |
||||
} |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> SMX::SMXDeviceSearchThreaded::GetDevices() |
||||
{ |
||||
// Lock to make a copy of the device list.
|
||||
m_Lock.Lock(); |
||||
vector<shared_ptr<AutoCloseHandle>> apResult = m_apDevices; |
||||
m_Lock.Unlock(); |
||||
return apResult; |
||||
} |
||||
@ -0,0 +1,46 @@ |
||||
#ifndef SMXDeviceSearchThreaded_h |
||||
#define SMXDeviceSearchThreaded_h |
||||
|
||||
#include "Helpers.h" |
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <vector> |
||||
using namespace std; |
||||
|
||||
namespace SMX { |
||||
|
||||
class SMXDeviceSearch; |
||||
|
||||
// This is a wrapper around SMXDeviceSearch which performs USB scanning in a thread.
|
||||
// It's free on Win10, but takes a while on Windows 7 (about 8ms), so running it on
|
||||
// a separate thread prevents random timing errors when reading HID updates.
|
||||
class SMXDeviceSearchThreaded |
||||
{ |
||||
public: |
||||
SMXDeviceSearchThreaded(); |
||||
~SMXDeviceSearchThreaded(); |
||||
|
||||
// The same interface as SMXDeviceSearch:
|
||||
vector<shared_ptr<SMX::AutoCloseHandle>> GetDevices(); |
||||
void DeviceWasClosed(shared_ptr<SMX::AutoCloseHandle> pDevice); |
||||
|
||||
// Synchronously shut down the thread.
|
||||
void Shutdown(); |
||||
|
||||
private: |
||||
void UpdateDeviceList(); |
||||
|
||||
static DWORD WINAPI ThreadMainStart(void *self_); |
||||
void ThreadMain(); |
||||
|
||||
SMX::Mutex m_Lock; |
||||
shared_ptr<SMXDeviceSearch> m_pDeviceList; |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
vector<shared_ptr<SMX::AutoCloseHandle>> m_apDevices; |
||||
vector<shared_ptr<SMX::AutoCloseHandle>> m_apClosedDevices; |
||||
bool m_bShutdown = false; |
||||
HANDLE m_hThread = INVALID_HANDLE_VALUE; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,545 @@ |
||||
#include "SMXGif.h" |
||||
#include <stdint.h> |
||||
#include <string> |
||||
#include <vector> |
||||
using namespace std; |
||||
|
||||
// This is a simple animated GIF decoder. It always decodes to RGBA color,
|
||||
// discarding palettes, and decodes the whole file at once.
|
||||
|
||||
class GIFError: public exception { }; |
||||
|
||||
struct Palette |
||||
{ |
||||
SMXGif::Color color[256]; |
||||
}; |
||||
|
||||
void SMXGif::GIFImage::Init(int width_, int height_) |
||||
{ |
||||
width = width_; |
||||
height = height_; |
||||
image.resize(width * height); |
||||
} |
||||
|
||||
void SMXGif::GIFImage::Clear(const Color &color) |
||||
{ |
||||
for(int y = 0; y < height; ++y) |
||||
for(int x = 0; x < width; ++x) |
||||
get(x,y) = color; |
||||
} |
||||
|
||||
void SMXGif::GIFImage::CropImage(SMXGif::GIFImage &dst, int crop_left, int crop_top, int crop_width, int crop_height) const |
||||
{ |
||||
dst.Init(crop_width, crop_height); |
||||
|
||||
for(int y = 0; y < crop_height; ++y) |
||||
{ |
||||
for(int x = 0; x < crop_width; ++x) |
||||
dst.get(x,y) = get(x + crop_left, y + crop_top); |
||||
} |
||||
} |
||||
|
||||
void SMXGif::GIFImage::Blit(SMXGif::GIFImage &src, int dst_left, int dst_top, int dst_width, int dst_height) |
||||
{ |
||||
for(int y = 0; y < dst_height; ++y) |
||||
{ |
||||
for(int x = 0; x < dst_width; ++x) |
||||
get(x + dst_left, y + dst_top) = src.get(x, y); |
||||
} |
||||
} |
||||
bool SMXGif::GIFImage::operator==(const GIFImage &rhs) const |
||||
{ |
||||
return |
||||
width == rhs.width && |
||||
height == rhs.height && |
||||
image == rhs.image; |
||||
} |
||||
|
||||
class DataStream |
||||
{ |
||||
public: |
||||
DataStream(const string &data_): |
||||
data(data_) |
||||
{ |
||||
} |
||||
|
||||
uint8_t ReadByte() |
||||
{ |
||||
if(pos >= data.size()) |
||||
throw GIFError(); |
||||
|
||||
uint8_t result = data[pos]; |
||||
pos++; |
||||
return result; |
||||
} |
||||
|
||||
uint16_t ReadLE16() |
||||
{ |
||||
uint8_t byte1 = ReadByte(); |
||||
uint8_t byte2 = ReadByte(); |
||||
return byte1 | (byte2 << 8); |
||||
} |
||||
|
||||
void ReadBytes(string &s, int count) |
||||
{ |
||||
s.clear(); |
||||
while(count--) |
||||
s.push_back(ReadByte()); |
||||
} |
||||
|
||||
void skip(int bytes) |
||||
{ |
||||
pos += bytes; |
||||
} |
||||
|
||||
private: |
||||
const string &data; |
||||
uint32_t pos = 0; |
||||
}; |
||||
|
||||
class LWZStream |
||||
{ |
||||
public: |
||||
LWZStream(DataStream &stream_): |
||||
stream(stream_) |
||||
{ |
||||
} |
||||
|
||||
// Read one LZW code from the input data.
|
||||
uint32_t ReadLZWCode(uint32_t bit_count) |
||||
{ |
||||
while(bits_in_buffer < bit_count) |
||||
{ |
||||
if(bytes_remaining == 0) |
||||
{ |
||||
// Read the next block's byte count.
|
||||
bytes_remaining = stream.ReadByte(); |
||||
if(bytes_remaining == 0) |
||||
throw GIFError(); |
||||
} |
||||
|
||||
// Shift in another 8 bits into the end of self.bits.
|
||||
bits |= stream.ReadByte() << bits_in_buffer; |
||||
bits_in_buffer += 8; |
||||
bytes_remaining -= 1; |
||||
} |
||||
|
||||
// Shift out bit_count worth of data from the end.
|
||||
uint32_t result = bits & ((1 << bit_count) - 1); |
||||
bits >>= bit_count; |
||||
bits_in_buffer -= bit_count; |
||||
|
||||
return result; |
||||
} |
||||
|
||||
// Skip the rest of the LZW data.
|
||||
void Flush() |
||||
{ |
||||
stream.skip(bytes_remaining); |
||||
bytes_remaining = 0; |
||||
|
||||
// If there are any blocks past the end of data, skip them.
|
||||
while(1) |
||||
{ |
||||
uint8_t blocksize = stream.ReadByte(); |
||||
stream.skip(blocksize); |
||||
if(bytes_remaining == 0) |
||||
break; |
||||
} |
||||
} |
||||
|
||||
private: |
||||
DataStream &stream; |
||||
uint32_t bits = 0; |
||||
int bytes_remaining = 0; |
||||
int bits_in_buffer = 0; |
||||
}; |
||||
|
||||
struct LWZDecoder |
||||
{ |
||||
LWZDecoder(DataStream &stream): |
||||
lzw_stream(LWZStream(stream)) |
||||
{ |
||||
// Each frame has a single bits field.
|
||||
code_bits = stream.ReadByte(); |
||||
} |
||||
|
||||
string DecodeImage(); |
||||
|
||||
private: |
||||
uint16_t code_bits; |
||||
LWZStream lzw_stream; |
||||
}; |
||||
|
||||
|
||||
static const int GIFBITS = 12; |
||||
|
||||
string LWZDecoder::DecodeImage() |
||||
{ |
||||
uint32_t dictionary_bits = code_bits + 1; |
||||
int prev_code1 = -1; |
||||
int prev_code2 = -1; |
||||
|
||||
uint32_t clear = 1 << code_bits; |
||||
uint32_t end = clear + 1; |
||||
uint32_t next_free_slot = clear + 2; |
||||
|
||||
vector<pair<int,int>> dictionary; |
||||
dictionary.resize(1 << GIFBITS); |
||||
|
||||
// We append to this buffer as we decode data, then append the data in reverse
|
||||
// order.
|
||||
string append_buffer; |
||||
|
||||
string result; |
||||
while(1) |
||||
{ |
||||
// Flush append_buffer.
|
||||
for(int i = append_buffer.size() - 1; i >= 0; --i) |
||||
result.push_back(append_buffer[i]); |
||||
append_buffer.clear(); |
||||
|
||||
int code1 = lzw_stream.ReadLZWCode(dictionary_bits); |
||||
// printf("%02x");
|
||||
if(code1 == end) |
||||
break; |
||||
|
||||
if(code1 == clear) |
||||
{ |
||||
// Clear the dictionary and reset.
|
||||
dictionary_bits = code_bits + 1; |
||||
next_free_slot = clear + 2; |
||||
prev_code1 = -1; |
||||
prev_code2 = -1; |
||||
continue; |
||||
} |
||||
|
||||
int code2; |
||||
if(code1 < next_free_slot) |
||||
code2 = code1; |
||||
else if(code1 == next_free_slot && prev_code2 != -1) |
||||
{ |
||||
append_buffer.push_back(prev_code2); |
||||
code2 = prev_code1; |
||||
} |
||||
else |
||||
throw GIFError(); |
||||
|
||||
// Walk through the linked list of codes in the dictionary and append.
|
||||
while(code2 >= clear + 2) |
||||
{ |
||||
uint8_t append_char = dictionary[code2].first; |
||||
code2 = dictionary[code2].second; |
||||
append_buffer.push_back(append_char); |
||||
} |
||||
append_buffer.push_back(code2); |
||||
|
||||
// If we're already at the last free slot, the dictionary is full and can't be expanded.
|
||||
if(next_free_slot < (1 << dictionary_bits)) |
||||
{ |
||||
// If we have any free dictionary slots, save.
|
||||
if(prev_code1 != -1) |
||||
{ |
||||
dictionary[next_free_slot] = make_pair(code2, prev_code1); |
||||
next_free_slot += 1; |
||||
} |
||||
// If we've just filled the last dictionary slot, expand the dictionary size if possible.
|
||||
if(next_free_slot >= (1 << dictionary_bits) && dictionary_bits < GIFBITS) |
||||
dictionary_bits += 1; |
||||
} |
||||
|
||||
prev_code1 = code1; |
||||
prev_code2 = code2; |
||||
} |
||||
|
||||
// Skip any remaining data in this block.
|
||||
lzw_stream.Flush(); |
||||
|
||||
return result; |
||||
} |
||||
|
||||
struct GlobalGIFData |
||||
{ |
||||
int width = 0, height = 0; |
||||
int background_index = -1; |
||||
bool use_transparency = false; |
||||
int transparency_index = -1; |
||||
int duration = 0; |
||||
int disposal_method = 0; |
||||
bool have_global_palette = false; |
||||
Palette palette; |
||||
}; |
||||
|
||||
class GIFDecoder |
||||
{ |
||||
public: |
||||
GIFDecoder(DataStream &stream_): |
||||
stream(stream_) |
||||
{ |
||||
} |
||||
|
||||
void ReadAllFrames(vector<SMXGif::SMXGifFrame> &frames); |
||||
|
||||
private: |
||||
bool ReadPacket(string &packet); |
||||
Palette ReadPalette(int palette_size); |
||||
void DecodeImage(GlobalGIFData global_data, SMXGif::GIFImage &out); |
||||
|
||||
DataStream &stream; |
||||
SMXGif::GIFImage image; |
||||
int frame; |
||||
}; |
||||
|
||||
// Read a palette with size colors.
|
||||
//
|
||||
// This is a simple string, with 4 RGBA bytes per color.
|
||||
Palette GIFDecoder::ReadPalette(int palette_size) |
||||
{ |
||||
Palette result; |
||||
for(int i = 0; i < palette_size; ++i) |
||||
{ |
||||
result.color[i].color[0] = stream.ReadByte(); // R
|
||||
result.color[i].color[1] = stream.ReadByte(); // G
|
||||
result.color[i].color[2] = stream.ReadByte(); // B
|
||||
result.color[i].color[3] = 0xFF; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
bool GIFDecoder::ReadPacket(string &packet) |
||||
{ |
||||
uint8_t packet_size = stream.ReadByte(); |
||||
if(packet_size == 0) |
||||
return false; |
||||
|
||||
stream.ReadBytes(packet, packet_size); |
||||
return true; |
||||
} |
||||
|
||||
void GIFDecoder::ReadAllFrames(vector<SMXGif::SMXGifFrame> &frames) |
||||
{ |
||||
string header; |
||||
stream.ReadBytes(header, 6); |
||||
|
||||
if(header != "GIF87a" && header != "GIF89a") |
||||
throw GIFError(); |
||||
|
||||
GlobalGIFData global_data; |
||||
|
||||
global_data.width = stream.ReadLE16(); |
||||
global_data.height = stream.ReadLE16(); |
||||
image.Init(global_data.width, global_data.height); |
||||
|
||||
// Ignore the aspect ratio field. (Supporting pixel aspect ratios in a format
|
||||
// this rudimentary was almost ambitious of them...)
|
||||
uint8_t global_flags = stream.ReadByte(); |
||||
global_data.background_index = stream.ReadByte(); |
||||
|
||||
// Ignore the aspect ratio field. (Supporting pixel aspect ratios in a format
|
||||
// this rudimentary was almost ambitious of them...)
|
||||
stream.ReadByte(); |
||||
|
||||
// Decode global_flags.
|
||||
uint8_t global_palette_size = global_flags & 0x7; |
||||
|
||||
global_data.have_global_palette = (global_flags >> 7) & 0x1; |
||||
|
||||
|
||||
// If there's no global palette, leave it empty.
|
||||
if(global_data.have_global_palette) |
||||
global_data.palette = ReadPalette(1 << (global_palette_size + 1)); |
||||
|
||||
frame = 0; |
||||
|
||||
// Save a copy of global data, so we can restore it after each frame.
|
||||
GlobalGIFData saved_global_data = global_data; |
||||
|
||||
// Decode all packets.
|
||||
while(1) |
||||
{ |
||||
uint8_t packet_type = stream.ReadByte(); |
||||
if(packet_type == 0x21) |
||||
{ |
||||
// Extension packet
|
||||
uint8_t extension_type = stream.ReadByte(); |
||||
|
||||
if(extension_type == 0xF9) |
||||
{ |
||||
string packet; |
||||
if(!ReadPacket(packet)) |
||||
throw GIFError(); |
||||
|
||||
DataStream packet_buf(packet); |
||||
|
||||
// Graphics control extension
|
||||
uint8_t gce_flags = packet_buf.ReadByte(); |
||||
global_data.duration = packet_buf.ReadLE16(); |
||||
global_data.transparency_index = packet_buf.ReadByte(); |
||||
|
||||
global_data.use_transparency = bool(gce_flags & 1); |
||||
global_data.disposal_method = (gce_flags >> 2) & 0xF; |
||||
if(!global_data.use_transparency) |
||||
global_data.transparency_index = -1; |
||||
} |
||||
|
||||
// Read any remaining packets in this extension packet.
|
||||
while(1) |
||||
{ |
||||
string packet; |
||||
if(!ReadPacket(packet)) |
||||
break; |
||||
} |
||||
} |
||||
else if(packet_type == 0x2C) |
||||
{ |
||||
// Image data
|
||||
SMXGif::GIFImage frame_image; |
||||
DecodeImage(global_data, frame_image); |
||||
|
||||
SMXGif::SMXGifFrame gif_frame; |
||||
gif_frame.width = global_data.width; |
||||
gif_frame.height = global_data.height; |
||||
gif_frame.milliseconds = global_data.duration * 10; |
||||
gif_frame.frame = frame_image; |
||||
|
||||
// If this frame is identical to the previous one, just extend the previous frame.
|
||||
if(!frames.empty() && gif_frame.frame == frames.back().frame) |
||||
{ |
||||
frames.back().milliseconds += gif_frame.milliseconds; |
||||
continue; |
||||
} |
||||
|
||||
frames.push_back(gif_frame); |
||||
|
||||
frame++; |
||||
|
||||
// Reset GCE (frame-specific) data.
|
||||
global_data = saved_global_data; |
||||
} |
||||
else if(packet_type == 0x3B) |
||||
{ |
||||
// EOF
|
||||
return; |
||||
} |
||||
else |
||||
throw GIFError(); |
||||
} |
||||
} |
||||
|
||||
// Decode a single GIF image into out, leaving this->image ready for
|
||||
// the next frame (with this frame's dispose applied).
|
||||
void GIFDecoder::DecodeImage(GlobalGIFData global_data, SMXGif::GIFImage &out) |
||||
{ |
||||
uint16_t block_left = stream.ReadLE16(); |
||||
uint16_t block_top = stream.ReadLE16(); |
||||
uint16_t block_width = stream.ReadLE16(); |
||||
uint16_t block_height = stream.ReadLE16(); |
||||
uint8_t local_flags = stream.ReadByte(); |
||||
|
||||
// area = (block_left, block_top, block_left + block_width, block_top + block_height)
|
||||
// Extract flags:
|
||||
uint8_t have_local_palette = (local_flags >> 7) & 1; |
||||
// bool interlaced = (local_flags >> 6) & 1;
|
||||
uint8_t local_palette_size = (local_flags >> 0) & 0x7; |
||||
// print 'Interlaced:', interlaced
|
||||
|
||||
// We don't support interlaced GIFs right now.
|
||||
// assert interlaced == 0
|
||||
|
||||
// If this frame has a local palette, use it. Otherwise, use the global palette.
|
||||
Palette active_palette = global_data.palette; |
||||
if(have_local_palette) |
||||
active_palette = ReadPalette(1 << (local_palette_size + 1)); |
||||
|
||||
if(!global_data.have_global_palette && !have_local_palette) |
||||
{ |
||||
// We have no palette. This is an invalid file.
|
||||
throw GIFError(); |
||||
} |
||||
|
||||
if(frame == 0) |
||||
{ |
||||
// On the first frame, clear the buffer. If we have a transparency index,
|
||||
// clear to transparent. Otherwise, clear to the background color.
|
||||
if(global_data.transparency_index != -1) |
||||
image.Clear(SMXGif::Color(0,0,0,0)); |
||||
else |
||||
image.Clear(active_palette.color[global_data.background_index]); |
||||
} |
||||
|
||||
// Decode the compressed image data.
|
||||
LWZDecoder decoder(stream); |
||||
string decompressed_data = decoder.DecodeImage(); |
||||
|
||||
if(decompressed_data.size() < block_width*block_height) |
||||
throw GIFError(); |
||||
|
||||
// Save the region to restore after decoding.
|
||||
SMXGif::GIFImage dispose; |
||||
if(global_data.disposal_method <= 1) |
||||
{ |
||||
// No disposal.
|
||||
} |
||||
else if(global_data.disposal_method == 2) |
||||
{ |
||||
// Clear the region to a background color afterwards.
|
||||
dispose.Init(block_width, block_height); |
||||
|
||||
if(global_data.transparency_index != -1) |
||||
dispose.Clear(SMXGif::Color(0,0,0,0)); |
||||
else |
||||
{ |
||||
uint8_t palette_idx = global_data.background_index; |
||||
dispose.Clear(active_palette.color[palette_idx]); |
||||
} |
||||
|
||||
} |
||||
else if(global_data.disposal_method == 3) |
||||
{ |
||||
// Restore the previous frame afterwards.
|
||||
image.CropImage(dispose, block_left, block_top, block_width, block_height); |
||||
} |
||||
else |
||||
{ |
||||
// Unknown disposal method
|
||||
} |
||||
|
||||
int pos = 0; |
||||
for(int y = block_top; y < block_top + block_height; ++y) |
||||
{ |
||||
for(int x = block_left; x < block_left + block_width; ++x) |
||||
{ |
||||
uint8_t palette_idx = decompressed_data[pos]; |
||||
pos++; |
||||
|
||||
if(palette_idx == global_data.transparency_index) |
||||
{ |
||||
// If this pixel is transparent, leave the existing color in place.
|
||||
} |
||||
else |
||||
{ |
||||
image.get(x,y) = active_palette.color[palette_idx]; |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Copy the image before we run dispose.
|
||||
out = image; |
||||
|
||||
// Restore the dispose area.
|
||||
if(dispose.width != 0) |
||||
image.Blit(dispose, block_left, block_top, block_width, block_height); |
||||
} |
||||
|
||||
bool SMXGif::DecodeGIF(string buf, vector<SMXGif::SMXGifFrame> &frames) |
||||
{ |
||||
DataStream stream(buf); |
||||
GIFDecoder gif(stream); |
||||
try { |
||||
gif.ReadAllFrames(frames); |
||||
} catch(GIFError &) { |
||||
// We don't return error strings for this, just success or failure.
|
||||
return false; |
||||
} |
||||
return true; |
||||
} |
||||
@ -0,0 +1,72 @@ |
||||
#ifndef SMXGif_h |
||||
#define SMXGif_h |
||||
|
||||
#include <stdint.h> |
||||
#include <string> |
||||
#include <vector> |
||||
|
||||
// This is a simple internal GIF decoder. It's only meant to be used by
|
||||
// SMXConfig.
|
||||
namespace SMXGif |
||||
{ |
||||
struct Color |
||||
{ |
||||
uint8_t color[4]; |
||||
Color() |
||||
{ |
||||
memset(color, 0, sizeof(color)); |
||||
} |
||||
|
||||
Color(uint8_t r, uint8_t g, uint8_t b, uint8_t a) |
||||
{ |
||||
color[0] = r; |
||||
color[1] = g; |
||||
color[2] = b; |
||||
color[3] = a; |
||||
} |
||||
bool operator==(const Color &rhs) const |
||||
{ |
||||
return !memcmp(color, rhs.color, sizeof(color)); |
||||
} |
||||
}; |
||||
|
||||
struct GIFImage |
||||
{ |
||||
int width = 0, height = 0; |
||||
void Init(int width, int height); |
||||
|
||||
Color get(int x, int y) const { return image[y*width+x]; } |
||||
Color &get(int x, int y) { return image[y*width+x]; } |
||||
|
||||
// Clear to a solid color.
|
||||
void Clear(const Color &color); |
||||
|
||||
// Copy a rectangle from this image into dst.
|
||||
void CropImage(GIFImage &dst, int crop_left, int crop_top, int crop_width, int crop_height) const; |
||||
|
||||
// Copy src into a rectangle in this image.
|
||||
void Blit(GIFImage &src, int dst_left, int dst_top, int dst_width, int dst_height); |
||||
|
||||
bool operator==(const GIFImage &rhs) const; |
||||
|
||||
private: |
||||
std::vector<Color> image; |
||||
}; |
||||
|
||||
struct SMXGifFrame |
||||
{ |
||||
int width = 0, height = 0; |
||||
|
||||
// GIF images have a delay in 10ms units. We use 1ms for clarity.
|
||||
int milliseconds = 0; |
||||
|
||||
GIFImage frame; |
||||
}; |
||||
|
||||
// Decode a GIF into a list of frames.
|
||||
bool DecodeGIF(std::string buf, std::vector<SMXGifFrame> &frames); |
||||
} |
||||
|
||||
void gif_test(); |
||||
|
||||
#endif |
||||
@ -0,0 +1,42 @@ |
||||
#include "SMXHelperThread.h" |
||||
using namespace SMX; |
||||
|
||||
SMX::SMXHelperThread::SMXHelperThread(const string &sThreadName): |
||||
SMXThread(m_Lock) |
||||
{ |
||||
Start(sThreadName); |
||||
} |
||||
|
||||
void SMX::SMXHelperThread::ThreadMain() |
||||
{ |
||||
m_Lock.Lock(); |
||||
while(true) |
||||
{ |
||||
vector<function<void()>> funcs; |
||||
swap(m_FunctionsToCall, funcs); |
||||
|
||||
// If we're shutting down and have no more functions to call, stop.
|
||||
if(funcs.empty() && m_bShutdown) |
||||
break; |
||||
|
||||
// Unlock while we call the queued functions.
|
||||
m_Lock.Unlock(); |
||||
for(auto &func: funcs) |
||||
func(); |
||||
m_Lock.Lock(); |
||||
|
||||
m_Event.Wait(250); |
||||
} |
||||
m_Lock.Unlock(); |
||||
} |
||||
|
||||
void SMX::SMXHelperThread::RunInThread(function<void()> func) |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Add func to the list, and poke the event to wake up the thread if needed.
|
||||
m_Lock.Lock(); |
||||
m_FunctionsToCall.push_back(func); |
||||
m_Event.Set(); |
||||
m_Lock.Unlock(); |
||||
} |
||||
@ -0,0 +1,31 @@ |
||||
#ifndef SMXHelperThread_h |
||||
#define SMXHelperThread_h |
||||
|
||||
#include "Helpers.h" |
||||
#include "SMXThread.h" |
||||
|
||||
#include <functional> |
||||
#include <vector> |
||||
#include <memory> |
||||
using namespace std; |
||||
|
||||
namespace SMX |
||||
{ |
||||
class SMXHelperThread: public SMXThread |
||||
{ |
||||
public: |
||||
SMXHelperThread(const string &sThreadName); |
||||
|
||||
// Call func asynchronously from the helper thread.
|
||||
void RunInThread(function<void()> func); |
||||
|
||||
private: |
||||
void ThreadMain(); |
||||
|
||||
// Helper threads use their independent lock.
|
||||
SMX::Mutex m_Lock; |
||||
vector<function<void()>> m_FunctionsToCall; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,704 @@ |
||||
#include "SMXManager.h" |
||||
#include "SMXDevice.h" |
||||
#include "SMXDeviceConnection.h" |
||||
#include "SMXDeviceSearchThreaded.h" |
||||
#include "Helpers.h" |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <stdexcept> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
namespace { |
||||
Mutex g_Lock; |
||||
} |
||||
|
||||
shared_ptr<SMXManager> SMXManager::g_pSMX; |
||||
|
||||
SMX::SMXManager::SMXManager(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback): |
||||
m_UserCallbackThread("SMXUserCallbackThread") |
||||
{ |
||||
// Raise the priority of the user callback thread, since we don't want input
|
||||
// events to be preempted by other things and reduce timing accuracy.
|
||||
m_UserCallbackThread.SetHighPriority(true); |
||||
m_hEvent = make_shared<AutoCloseHandle>(CreateEvent(NULL, false, false, NULL)); |
||||
m_pSMXDeviceSearchThreaded = make_shared<SMXDeviceSearchThreaded>(); |
||||
|
||||
// Create the SMXDevices. We don't create these as we connect, we just reuse the same
|
||||
// ones.
|
||||
for(int i = 0; i < 2; ++i) |
||||
{ |
||||
shared_ptr<SMXDevice> pDevice = SMXDevice::Create(m_hEvent, g_Lock); |
||||
m_pDevices.push_back(pDevice); |
||||
} |
||||
|
||||
// The callback we send to SMXDeviceConnection will be called from our thread. Wrap
|
||||
// it so it's called from UserCallbackThread instead.
|
||||
auto pCallbackInThread = [this, pCallback](int PadNumber, SMXUpdateCallbackReason reason) { |
||||
m_UserCallbackThread.RunInThread([pCallback, PadNumber, reason]() { |
||||
pCallback(PadNumber, reason); |
||||
}); |
||||
}; |
||||
|
||||
// Set the update callbacks. Do this before starting the thread, to avoid race conditions.
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
m_pDevices[pad]->SetUpdateCallback(pCallbackInThread); |
||||
|
||||
// Start the thread.
|
||||
DWORD id; |
||||
m_hThread = CreateThread(NULL, 0, ThreadMainStart, this, 0, &id); |
||||
SMX::SetThreadName(id, "SMXManager"); |
||||
|
||||
// Raise the priority of the I/O thread, since we don't want input
|
||||
// events to be preempted by other things and reduce timing accuracy.
|
||||
SetThreadPriority( m_hThread, THREAD_PRIORITY_HIGHEST ); |
||||
} |
||||
|
||||
SMX::SMXManager::~SMXManager() |
||||
{ |
||||
// Shut down the thread, if it's still running.
|
||||
Shutdown(); |
||||
} |
||||
|
||||
shared_ptr<SMXDevice> SMX::SMXManager::GetDevice(int pad) |
||||
{ |
||||
return m_pDevices[pad]; |
||||
} |
||||
|
||||
void SMX::SMXManager::Shutdown() |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Make sure we're not being called from within m_UserCallbackThread, since that'll
|
||||
// deadlock when we shut down m_UserCallbackThread.
|
||||
if(m_UserCallbackThread.IsCurrentThread()) |
||||
throw runtime_error("SMX::SMXManager::Shutdown must not be called from an SMX callback"); |
||||
|
||||
// Shut down the thread we make user callbacks from.
|
||||
m_UserCallbackThread.Shutdown(); |
||||
|
||||
// Shut down the device search thread.
|
||||
m_pSMXDeviceSearchThreaded->Shutdown(); |
||||
|
||||
if(m_hThread == INVALID_HANDLE_VALUE) |
||||
return; |
||||
|
||||
// Tell the thread to shut down, and wait for it before returning.
|
||||
m_bShutdown = true; |
||||
SetEvent(m_hEvent->value()); |
||||
|
||||
WaitForSingleObject(m_hThread, INFINITE); |
||||
m_hThread = INVALID_HANDLE_VALUE; |
||||
} |
||||
|
||||
DWORD WINAPI SMX::SMXManager::ThreadMainStart(void *self_) |
||||
{ |
||||
SMXManager *self = (SMXManager *) self_; |
||||
self->ThreadMain(); |
||||
return 0; |
||||
} |
||||
|
||||
// When we connect to a device, we don't know whether it's P1 or P2, since we get that
|
||||
// info from the device after we connect to it. If we have a P2 device in SMX_PadNumber_1
|
||||
// or a P1 device in SMX_PadNumber_2, swap the two.
|
||||
void SMX::SMXManager::CorrectDeviceOrder() |
||||
{ |
||||
// We're still holding the lock from when we updated the devices, so the application
|
||||
// won't see the devices out of order before we do this.
|
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
SMXInfo info[2]; |
||||
m_pDevices[0]->GetInfoLocked(info[0]); |
||||
m_pDevices[1]->GetInfoLocked(info[1]); |
||||
|
||||
// If we have two P1s or two P2s, the pads are misconfigured and we'll just leave the order alone.
|
||||
bool Player2[2] = { |
||||
m_pDevices[0]->IsPlayer2Locked(), |
||||
m_pDevices[1]->IsPlayer2Locked(), |
||||
}; |
||||
if(info[0].m_bConnected && info[1].m_bConnected && Player2[0] == Player2[1]) |
||||
return; |
||||
|
||||
bool bP1NeedsSwap = info[0].m_bConnected && Player2[0]; |
||||
bool bP2NeedsSwap = info[1].m_bConnected && !Player2[1]; |
||||
if(bP1NeedsSwap || bP2NeedsSwap) |
||||
swap(m_pDevices[0], m_pDevices[1]); |
||||
} |
||||
|
||||
void SMX::SMXManager::ThreadMain() |
||||
{ |
||||
g_Lock.Lock(); |
||||
|
||||
while(!m_bShutdown) |
||||
{ |
||||
// If there are any lights commands to be sent, send them now. Do this before callig Update(),
|
||||
// since this actually just queues commands, which are actually handled in Update.
|
||||
SendLightUpdates(); |
||||
|
||||
// Send panel test mode commands if needed.
|
||||
UpdatePanelTestMode(); |
||||
|
||||
// See if there are any new devices.
|
||||
AttemptConnections(); |
||||
|
||||
// Update all connected devices.
|
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
wstring sError; |
||||
pDevice->Update(sError); |
||||
|
||||
if(!sError.empty()) |
||||
{ |
||||
Log(ssprintf("Device error: %ls", sError.c_str())); |
||||
|
||||
// Tell m_pDeviceList that the device was closed, so it'll discard the device
|
||||
// and notice if a new device shows up on the same path.
|
||||
m_pSMXDeviceSearchThreaded->DeviceWasClosed(pDevice->GetDeviceHandle()); |
||||
pDevice->CloseDevice(); |
||||
} |
||||
} |
||||
|
||||
// Devices may have finished initializing, so see if we need to update the ordering.
|
||||
CorrectDeviceOrder(); |
||||
|
||||
// Make a list of handles for WaitForMultipleObjectsEx.
|
||||
vector<HANDLE> aHandles = { m_hEvent->value() }; |
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
shared_ptr<AutoCloseHandle> pHandle = pDevice->GetDeviceHandle(); |
||||
if(pHandle) |
||||
aHandles.push_back(pHandle->value()); |
||||
} |
||||
|
||||
// See how long we should block waiting for I/O. If we have any scheduled lights commands,
|
||||
// wait until the next command should be sent, otherwise wait for a second.
|
||||
int iDelayMS = 1000; |
||||
if(!m_aPendingLightsCommands.empty()) |
||||
{ |
||||
double fSendIn = m_aPendingLightsCommands[0].fTimeToSend - GetMonotonicTime(); |
||||
|
||||
// Add 1ms to the delay time. We're using a high resolution timer, but
|
||||
// WaitForMultipleObjectsEx only has 1ms resolution, so this keeps us from
|
||||
// repeatedly waking up slightly too early.
|
||||
iDelayMS = int(fSendIn * 1000) + 1; |
||||
iDelayMS = max(0, iDelayMS); |
||||
} |
||||
|
||||
// Wait until there's something to do for a connected device, or delay briefly if we're
|
||||
// not connected to anything. Unlock while we block. Devices are only ever opened or
|
||||
// closed from within this thread, so the handles won't go away while we're waiting on
|
||||
// them.
|
||||
g_Lock.Unlock(); |
||||
WaitForMultipleObjectsEx(aHandles.size(), aHandles.data(), false, iDelayMS, true); |
||||
g_Lock.Lock(); |
||||
} |
||||
g_Lock.Unlock(); |
||||
} |
||||
|
||||
// Lights are updated with two commands. The top two rows of LEDs in each panel are
|
||||
// updated by the first command, and the bottom two rows are updated by the second
|
||||
// command. We need to send the two commands in order. The panel won't update lights
|
||||
// until both commands have been received, so we don't flicker the partial top update
|
||||
// before the bottom update is received.
|
||||
//
|
||||
// A complete update can be performed at up to 30 FPS, but we actually update at 60
|
||||
// FPS, alternating between updating the top and bottom half.
|
||||
//
|
||||
// This interlacing is performed to reduce the amount of work the panels and master
|
||||
// controller need to do on each update. This improves timing accuracy, since less
|
||||
// time is taken by each update.
|
||||
//
|
||||
// The order of lights is:
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// with panels left-to-right, top-to-bottom. The first packet sends all 0123 and 4567
|
||||
// lights, and the second packet sends 78AB and CDEF.
|
||||
//
|
||||
// We hide these details from the API to simplify things for the user:
|
||||
//
|
||||
// - The user sends us a complete lights set. This should be sent at (up to) 30Hz.
|
||||
// If we get lights data too quickly, we'll always complete the one we started before
|
||||
// sending the next.
|
||||
// - We don't limit to exactly 30Hz to prevent phase issues where a 60 FPS game is
|
||||
// coming in and out of phase with our timer. To avoid this, we limit to 40Hz.
|
||||
// - When we have new lights data to send, we send the first half right away, wait
|
||||
// 16ms (60Hz), then send the second half, which is the pacing the device expects.
|
||||
// - If we get a new lights update in between the two lights commands, we won't split
|
||||
// the lights. The two lights commands will always come from the same update, so
|
||||
// we don't get weird interlacing effects.
|
||||
// - If SMX_ReenableAutoLights is called between the two commands, we need to guarantee
|
||||
// that we don't send the second lights commands, since that may re-disable auto lights.
|
||||
// - If we have two pads, the lights update is for both pads and we'll send both commands
|
||||
// for both pads at the same time, so both pads update lights simultaneously.
|
||||
void SMX::SMXManager::SetLights(const string sPanelLights[2]) |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
// Don't send lights when a panel test mode is active.
|
||||
if(m_PanelTestMode != PanelTestMode_Off) |
||||
return; |
||||
|
||||
// If m_bOnlySendLightsOnChange is true, only send lights commands if the lights have
|
||||
// actually changed. This is only used for internal testing, and the controllers normally
|
||||
// expect to receive regular lights updates, even if the lights aren't actually changing.
|
||||
if(m_bOnlySendLightsOnChange) |
||||
{ |
||||
static string sLastPanelLights[2]; |
||||
if(sPanelLights[0] == sLastPanelLights[0] && sPanelLights[1] == sLastPanelLights[1]) |
||||
{ |
||||
Log("no change"); |
||||
return; |
||||
} |
||||
|
||||
sLastPanelLights[0] = sPanelLights[0]; |
||||
sLastPanelLights[1] = sPanelLights[1]; |
||||
} |
||||
|
||||
// Separate top and bottom lights commands.
|
||||
//
|
||||
// sPanelLights[iPad] is
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// 0123 0123 0123
|
||||
// 4567 4567 4567
|
||||
// 89AB 89AB 89AB
|
||||
// CDEF CDEF CDEF
|
||||
//
|
||||
// If we're on a 25-light device, we have an additional grid of 3x3 LEDs:
|
||||
//
|
||||
//
|
||||
// x x x x
|
||||
// 0 1 2
|
||||
// x x x x
|
||||
// 3 4 5
|
||||
// x x x x
|
||||
// 6 7 8
|
||||
// x x x x
|
||||
//
|
||||
// Set sLightsCommand[iPad][0] to include 0123 4567, [1] to 89AB CDEF,
|
||||
// and [2] to the 3x3 grid.
|
||||
string sLightCommands[3][2]; // sLightCommands[command][pad]
|
||||
|
||||
// Read the linearly arranged color data we've been given and split it into top and
|
||||
// bottom commands for each pad.
|
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
// If there's no data for this pad, leave the command empty.
|
||||
string sLightsDataForPad = sPanelLights[iPad]; |
||||
if(sLightsDataForPad.empty()) |
||||
continue; |
||||
|
||||
// Sanity check the lights data. For 4x4 lights, it should have 9*4*4*3 bytes of
|
||||
// data: RGB for each of 4x4 LEDs on 9 panels. For 25-light panels there should
|
||||
// be 4x4+3x3 (25) lights of data.
|
||||
int LightSize4x4 = 9*4*4*3; |
||||
int LightSize25 = 9*5*5*3; |
||||
if(sLightsDataForPad.size() != LightSize4x4 && sLightsDataForPad.size() != LightSize25) |
||||
{ |
||||
Log(ssprintf("SetLights: Lights data should be %i or %i bytes, received %i", |
||||
LightSize4x4, LightSize25, sLightsDataForPad.size())); |
||||
continue; |
||||
} |
||||
|
||||
// If we've been given 16 lights, pad to 25.
|
||||
if(sLightsDataForPad.size() == LightSize4x4) |
||||
sLightsDataForPad.append(LightSize25 - LightSize4x4, '\0'); |
||||
|
||||
// Lights are sent in three commands:
|
||||
//
|
||||
// 4: the 3x3 inner grid
|
||||
// 2: the top 4x2 lights
|
||||
// 3: the bottom 4x2 lights
|
||||
//
|
||||
// Command 4 is only used by firmware version 4+.
|
||||
//
|
||||
// Always send all three commands if the firmware expects it, even if we've
|
||||
// been given 4x4 data.
|
||||
sLightCommands[0][iPad] = "4"; |
||||
sLightCommands[1][iPad] = "2"; |
||||
sLightCommands[2][iPad] = "3"; |
||||
int iNextInputByte = 0; |
||||
auto scaleLight = [](uint8_t iColor) { |
||||
// Apply color scaling. Values over about 170 don't make the LEDs any brighter, so this
|
||||
// gives better contrast and draws less power.
|
||||
return uint8_t(iColor * 0.6666f); |
||||
}; |
||||
for(int iPanel = 0; iPanel < 9; ++iPanel) |
||||
{ |
||||
// Create the 2 and 3 commands.
|
||||
for(int iByte = 0; iByte < 4*4*3; ++iByte) |
||||
{ |
||||
uint8_t iColor = sLightsDataForPad[iNextInputByte++]; |
||||
iColor = scaleLight(iColor); |
||||
|
||||
int iCommandIndex = iByte < 4*2*3? 1:2; |
||||
sLightCommands[iCommandIndex][iPad].append(1, iColor); |
||||
} |
||||
|
||||
// Create the 4 command.
|
||||
for(int iByte = 0; iByte < 3*3*3; ++iByte) |
||||
{ |
||||
uint8_t iColor = sLightsDataForPad[iNextInputByte++]; |
||||
iColor = scaleLight(iColor); |
||||
sLightCommands[0][iPad].append(1, iColor); |
||||
} |
||||
} |
||||
|
||||
sLightCommands[0][iPad].push_back('\n'); |
||||
sLightCommands[1][iPad].push_back('\n'); |
||||
sLightCommands[2][iPad].push_back('\n'); |
||||
} |
||||
|
||||
// Each update adds one entry to m_aPendingLightsCommands for each lights command.
|
||||
//
|
||||
// If there are at least as many entries in m_aPendingLightsCommands as there are
|
||||
// commands to send, then lights updates are happening faster than they can be sent
|
||||
// to the pad. If that happens, replace the existing commands rather than adding
|
||||
// new ones.
|
||||
//
|
||||
// Make sure we always finish a lights update once we start it, so if we receive lights
|
||||
// updates very quickly we won't just keep sending the first half and never finish one.
|
||||
// Otherwise, we'll update with the newest data we have available.
|
||||
//
|
||||
// Note that m_aPendingLightsCommands contains the update for both pads, to guarantee
|
||||
// we always send light updates for both pads together and they never end up out of
|
||||
// phase.
|
||||
if(m_aPendingLightsCommands.size() < 3) |
||||
{ |
||||
// There's a subtle but important difference between command timing in
|
||||
// firmware version 4 compared to earlier versions:
|
||||
//
|
||||
// Earlier firmwares would process host commands as soon as they're received.
|
||||
// Because of this, we have to wait before sending the '3' command to give
|
||||
// the master controller time to finish sending the '2' command to panels.
|
||||
// If we don't do this everything will still work, but the master will block
|
||||
// while processing the second command waiting for panel data to finish sending
|
||||
// since the TX queue will be full. If this happens it isn't processing HID
|
||||
// data, which reduces input timing accuracy.
|
||||
//
|
||||
// Firmware version 4 won't process a host command if there's data still being
|
||||
// sent to the panels. It'll wait until the data is flushed. This means that
|
||||
// we can queue all three lights commands at once, and just send them as fast
|
||||
// as the host acknowledges them. The second command will sit around on the
|
||||
// master controller's buffer until it finishes sending the first command to
|
||||
// the panels, then the third command will do the same.
|
||||
//
|
||||
// This change is only needed due to the larger amount of data sent in 25-light
|
||||
// mode. Since we're spending more time sending data from the master to the
|
||||
// panels, the timing requirements are tighter. Doing it in the same manual-delay
|
||||
// fashion causes too much latency and makes it harder to maintain 30 FPS.
|
||||
//
|
||||
// If two controllers are connected, they should either both be 4+ or not. We
|
||||
// don't handle the case where they're different and both timings are needed.
|
||||
double fNow = GetMonotonicTime(); |
||||
double fSendCommandAt = max(fNow, m_fDelayLightCommandsUntil); |
||||
double fCommandTimes[3] = { fNow, fNow, fNow }; |
||||
|
||||
bool masterIsV4 = false; |
||||
bool anyMasterConnected = false; |
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
SMXConfig config; |
||||
if(!m_pDevices[iPad]->GetConfigLocked(config)) |
||||
continue; |
||||
|
||||
anyMasterConnected = true; |
||||
if(config.masterVersion >= 4) |
||||
masterIsV4 = true; |
||||
} |
||||
|
||||
// If we don't have the config yet, the master is in the process of connecting, so don't
|
||||
// queue lights.
|
||||
if(!anyMasterConnected) |
||||
return; |
||||
|
||||
// If we're on master firmware < 4, set delay times. For 4+, just queue commands.
|
||||
// We don't need to set fCommandTimes[0] since the '4' packet won't be sent.
|
||||
if(!masterIsV4) |
||||
{ |
||||
const double fDelayBetweenLightsCommands = 1/60.0; |
||||
fCommandTimes[1] = fSendCommandAt; |
||||
fCommandTimes[2] = fCommandTimes[1] + fDelayBetweenLightsCommands; |
||||
} |
||||
|
||||
// Update m_fDelayLightCommandsUntil, so we know when the next
|
||||
// lights command can be sent.
|
||||
m_fDelayLightCommandsUntil = fSendCommandAt + 1/30.0f; |
||||
|
||||
// Add three commands to the list, scheduled at fFirstCommandTime and fSecondCommandTime.
|
||||
m_aPendingLightsCommands.push_back(PendingCommand(fCommandTimes[0])); |
||||
m_aPendingLightsCommands.push_back(PendingCommand(fCommandTimes[1])); |
||||
m_aPendingLightsCommands.push_back(PendingCommand(fCommandTimes[2])); |
||||
} |
||||
|
||||
// Set the pad commands.
|
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
// If the command for this pad is empty, leave any existing pad command alone.
|
||||
if(sLightCommands[0][iPad].empty()) |
||||
continue; |
||||
|
||||
SMXConfig config; |
||||
if(!m_pDevices[iPad]->GetConfigLocked(config)) |
||||
continue; |
||||
|
||||
// If this pad is firmware version 4, send the 4 command. Otherwise, leave the 4 command
|
||||
// empty and no command will be sent.
|
||||
PendingCommand *pPending4Commands = &m_aPendingLightsCommands[m_aPendingLightsCommands.size()-3]; // 3
|
||||
if(config.masterVersion >= 4) |
||||
pPending4Commands->sPadCommand[iPad] = sLightCommands[0][iPad]; |
||||
else |
||||
pPending4Commands->sPadCommand[iPad] = ""; |
||||
|
||||
PendingCommand *pPending2Commands = &m_aPendingLightsCommands[m_aPendingLightsCommands.size()-2]; // 2
|
||||
pPending2Commands->sPadCommand[iPad] = sLightCommands[1][iPad]; |
||||
|
||||
PendingCommand *pPending3Commands = &m_aPendingLightsCommands[m_aPendingLightsCommands.size()-1]; // 3
|
||||
pPending3Commands->sPadCommand[iPad] = sLightCommands[2][iPad]; |
||||
} |
||||
|
||||
// Wake up the I/O thread if it's blocking on WaitForMultipleObjectsEx.
|
||||
SetEvent(m_hEvent->value()); |
||||
} |
||||
|
||||
void SMX::SMXManager::SetPlatformLights(const string sPanelLights[2]) |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
// Read the linearly arranged color data we've been given and split it into top and
|
||||
// bottom commands for each pad.
|
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
// If there's no data for this pad, skip it.
|
||||
string sLightsDataForPad = sPanelLights[iPad]; |
||||
if(sLightsDataForPad.empty()) |
||||
continue; |
||||
|
||||
if(sLightsDataForPad.size() != 44*3) |
||||
{ |
||||
Log(ssprintf("SetPlatformLights: Platform lights data should be %i bytes, received %i", |
||||
44*3, sLightsDataForPad.size())); |
||||
continue; |
||||
} |
||||
|
||||
// If this master doesn't support this, skip it.
|
||||
SMXConfig config; |
||||
if(!m_pDevices[iPad]->GetConfigLocked(config)) |
||||
continue; |
||||
if(config.masterVersion < 4) |
||||
continue; |
||||
|
||||
string sLightCommand; |
||||
sLightCommand.push_back('L'); |
||||
sLightCommand.push_back(0); // LED strip index (always 0)
|
||||
sLightCommand.push_back(44); // number of LEDs to set
|
||||
sLightCommand += sLightsDataForPad; |
||||
|
||||
m_pDevices[iPad]->SendCommandLocked(sLightCommand); |
||||
} |
||||
|
||||
// Wake up the I/O thread if it's blocking on WaitForMultipleObjectsEx.
|
||||
SetEvent(m_hEvent->value()); |
||||
} |
||||
|
||||
void SMX::SMXManager::ReenableAutoLights() |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
// Clear any pending lights commands, so we don't re-disable auto-lighting by sending a
|
||||
// lights command after we enable it. If we've sent the first half of a lights update
|
||||
// and this causes us to not send the second half, the controller will just discard it.
|
||||
m_aPendingLightsCommands.clear(); |
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
m_pDevices[iPad]->SendCommandLocked(string("S 1\n", 4)); |
||||
} |
||||
|
||||
// Check to see if we should send any commands in m_aPendingLightsCommands.
|
||||
void SMX::SMXManager::SendLightUpdates() |
||||
{ |
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// If previous lights commands are being sent, wait for them to complete before
|
||||
// queueing more.
|
||||
if(m_iLightsCommandsInProgress > 0) |
||||
return; |
||||
|
||||
// If we have more than one command queued, we can queue several of them if we're
|
||||
// before fTimeToSend. For the V4 pads that require more commands, this lets us queue
|
||||
// the whole lights update at once. V3 pads require us to time commands, so we can't
|
||||
// spam both lights commands at once, which is handled by fTimeToSend.
|
||||
while( !m_aPendingLightsCommands.empty() ) |
||||
{ |
||||
// Send the lights command for each pad. If either pad isn't connected, this won't do
|
||||
// anything.
|
||||
const PendingCommand &command = m_aPendingLightsCommands[0]; |
||||
|
||||
// See if it's time to send this command.
|
||||
if(command.fTimeToSend > GetMonotonicTime()) |
||||
break; |
||||
|
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
if(!command.sPadCommand[iPad].empty()) |
||||
{ |
||||
// Count the number of commands we've queued. We won't send any more until
|
||||
// this reaches 0 and all queued commands were sent.
|
||||
m_iLightsCommandsInProgress++; |
||||
|
||||
// The completion callback is guaranteed to always be called, even if the controller
|
||||
// disconnects and the command wasn't sent.
|
||||
m_pDevices[iPad]->SendCommandLocked(command.sPadCommand[iPad], [this, iPad](string response) { |
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
m_iLightsCommandsInProgress--; |
||||
}); |
||||
} |
||||
} |
||||
|
||||
// Remove the command we've sent.
|
||||
m_aPendingLightsCommands.erase(m_aPendingLightsCommands.begin(), m_aPendingLightsCommands.begin()+1); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXManager::SetPanelTestMode(PanelTestMode mode) |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex Lock(g_Lock); |
||||
m_PanelTestMode = mode; |
||||
} |
||||
|
||||
void SMX::SMXManager::UpdatePanelTestMode() |
||||
{ |
||||
// If the test mode has changed, send the new test mode.
|
||||
//
|
||||
// When the test mode is enabled, send the test mode again periodically, or it'll time
|
||||
// out on the master and be turned off. Don't repeat the PanelTestMode_Off command.
|
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
uint32_t now = GetTickCount(); |
||||
if(m_PanelTestMode == m_LastSentPanelTestMode &&
|
||||
(m_PanelTestMode == PanelTestMode_Off || now - m_SentPanelTestModeAtTicks < 1000)) |
||||
return; |
||||
|
||||
// When we first send the test mode command (not for repeats), turn off lights.
|
||||
if(m_LastSentPanelTestMode == PanelTestMode_Off) |
||||
{ |
||||
// The 'l' command used to set lights, but it's now only used to turn lights off
|
||||
// for cases like this.
|
||||
string sData = "l"; |
||||
sData.append(108, 0); |
||||
sData += "\n"; |
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
m_pDevices[iPad]->SendCommandLocked(sData); |
||||
} |
||||
|
||||
m_SentPanelTestModeAtTicks = now; |
||||
m_LastSentPanelTestMode = m_PanelTestMode; |
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
m_pDevices[iPad]->SendCommandLocked(ssprintf("t %c\n", m_PanelTestMode)); |
||||
} |
||||
|
||||
// Assign a serial number to master controllers if one isn't already assigned. This
|
||||
// will have no effect if a serial is already set.
|
||||
//
|
||||
// We just assign a random number. The serial number will be used as the USB serial
|
||||
// number, and can be queried in SMXInfo.
|
||||
void SMX::SMXManager::SetSerialNumbers() |
||||
{ |
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
m_aPendingLightsCommands.clear(); |
||||
for(int iPad = 0; iPad < 2; ++iPad) |
||||
{ |
||||
string sData = "s"; |
||||
uint8_t serial[16]; |
||||
SMX::GenerateRandom(serial, sizeof(serial)); |
||||
sData.append((char *) serial, sizeof(serial)); |
||||
sData.append(1, '\n'); |
||||
|
||||
m_pDevices[iPad]->SendCommandLocked(sData); |
||||
} |
||||
} |
||||
|
||||
void SMX::SMXManager::RunInHelperThread(function<void()> func) |
||||
{ |
||||
m_UserCallbackThread.RunInThread(func); |
||||
} |
||||
|
||||
// See if there are any new devices to connect to.
|
||||
void SMX::SMXManager::AttemptConnections() |
||||
{ |
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
vector<shared_ptr<AutoCloseHandle>> apDevices = m_pSMXDeviceSearchThreaded->GetDevices(); |
||||
|
||||
// Check each device that we've found. This will include ones we already have open.
|
||||
for(shared_ptr<AutoCloseHandle> pHandle: apDevices) |
||||
{ |
||||
// See if this device is already open. If it is, we don't need to do anything with it.
|
||||
bool bAlreadyOpen = false; |
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
if(pDevice->GetDeviceHandle() == pHandle) |
||||
bAlreadyOpen = true; |
||||
} |
||||
if(bAlreadyOpen) |
||||
continue; |
||||
|
||||
// Find an open device slot.
|
||||
shared_ptr<SMXDevice> pDeviceToOpen; |
||||
for(shared_ptr<SMXDevice> pDevice: m_pDevices) |
||||
{ |
||||
// Note that we check whether the device has a handle rather than calling IsConnected, since
|
||||
// devices aren't actually considered connected until they've read the configuration.
|
||||
if(pDevice->GetDeviceHandle() == NULL) |
||||
{ |
||||
pDeviceToOpen = pDevice; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
if(pDeviceToOpen == nullptr) |
||||
{ |
||||
// All device slots are used. Are there more than two devices plugged in?
|
||||
Log("Error: No available slots for device. Are more than two devices connected?"); |
||||
break; |
||||
} |
||||
|
||||
// Open the device in this slot.
|
||||
Log("Opening SMX device"); |
||||
wstring sError; |
||||
pDeviceToOpen->OpenDeviceHandle(pHandle, sError); |
||||
if(!sError.empty()) |
||||
Log(ssprintf("Error opening device: %ls", sError.c_str())); |
||||
} |
||||
} |
||||
|
||||
|
||||
|
||||
@ -0,0 +1,96 @@ |
||||
#ifndef SMXManager_h |
||||
#define SMXManager_h |
||||
|
||||
#include <windows.h> |
||||
#include <memory> |
||||
#include <vector> |
||||
#include <functional> |
||||
using namespace std; |
||||
|
||||
#include "Helpers.h" |
||||
#include "../SMX.h" |
||||
#include "SMXHelperThread.h" |
||||
|
||||
namespace SMX { |
||||
class SMXDevice; |
||||
class SMXDeviceSearchThreaded; |
||||
|
||||
struct SMXControllerState |
||||
{ |
||||
// True
|
||||
bool m_bConnected[2]; |
||||
|
||||
// Pressed panels for player 1 and player 2:
|
||||
uint16_t m_Inputs[2]; |
||||
}; |
||||
|
||||
// This implements the main thread that controller communication and device searching
|
||||
// happens in, finding and opening devices, and running device updates.
|
||||
//
|
||||
// Connected controllers can be accessed with GetDevice(),
|
||||
// This also abstracts controller numbers. GetDevice(SMX_PadNumber_1) will return the
|
||||
// first device that connected,
|
||||
class SMXManager |
||||
{ |
||||
public: |
||||
// Our singleton:
|
||||
static shared_ptr<SMXManager> g_pSMX; |
||||
|
||||
// pCallback is a function to be called when something changes on any device. This allows
|
||||
// efficiently detecting when a panel is pressed or other changes happen.
|
||||
SMXManager(function<void(int PadNumber, SMXUpdateCallbackReason reason)> pCallback); |
||||
~SMXManager(); |
||||
|
||||
void Shutdown(); |
||||
shared_ptr<SMXDevice> GetDevice(int pad); |
||||
void SetLights(const string sLights[2]); |
||||
void SetPlatformLights(const string sLights[2]); |
||||
void ReenableAutoLights(); |
||||
void SetPanelTestMode(PanelTestMode mode); |
||||
void SetSerialNumbers(); |
||||
void SetOnlySendLightsOnChange(bool value) { m_bOnlySendLightsOnChange = value; } |
||||
|
||||
// Run a function in the user callback thread.
|
||||
void RunInHelperThread(function<void()> func); |
||||
|
||||
private: |
||||
static DWORD WINAPI ThreadMainStart(void *self_); |
||||
void ThreadMain(); |
||||
void AttemptConnections(); |
||||
void CorrectDeviceOrder(); |
||||
void SendLightUpdates(); |
||||
|
||||
HANDLE m_hThread = INVALID_HANDLE_VALUE; |
||||
shared_ptr<SMX::AutoCloseHandle> m_hEvent; |
||||
shared_ptr<SMXDeviceSearchThreaded> m_pSMXDeviceSearchThreaded; |
||||
bool m_bShutdown = false; |
||||
vector<shared_ptr<SMXDevice>> m_pDevices; |
||||
|
||||
// We make user callbacks asynchronously in this thread, to avoid any locking or timing
|
||||
// issues that could occur by calling them in our I/O thread.
|
||||
SMXHelperThread m_UserCallbackThread; |
||||
|
||||
// A list of queued lights commands to send to the controllers. This is always sorted
|
||||
// by iTimeToSend.
|
||||
struct PendingCommand |
||||
{ |
||||
PendingCommand(float fTime): fTimeToSend(fTime) { } |
||||
double fTimeToSend = 0; |
||||
string sPadCommand[2]; |
||||
}; |
||||
vector<PendingCommand> m_aPendingLightsCommands; |
||||
int m_iLightsCommandsInProgress = 0; |
||||
double m_fDelayLightCommandsUntil = 0; |
||||
|
||||
// Panel test mode. This is separate from the sensor test mode (pressure display),
|
||||
// which is handled in SMXDevice.
|
||||
void UpdatePanelTestMode(); |
||||
uint32_t m_SentPanelTestModeAtTicks = 0; |
||||
PanelTestMode m_PanelTestMode = PanelTestMode_Off; |
||||
PanelTestMode m_LastSentPanelTestMode = PanelTestMode_Off; |
||||
|
||||
bool m_bOnlySendLightsOnChange = false; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,519 @@ |
||||
// Handle playing GIF animations from inside SMXConfig.
|
||||
//
|
||||
// This can load two GIF animations, one for when panels are released
|
||||
// and one for when they're pressed, and play them automatically on the
|
||||
// pad in the background. Applications that control lights can do more
|
||||
// sophisticated things with the lights, but this gives an easy way for
|
||||
// people to create simple animations.
|
||||
//
|
||||
// If you're implementing the SDK in a game, you don't need this and should
|
||||
// use SMX.h instead.
|
||||
//
|
||||
// An animation is a single GIF with animations for all panels, in the
|
||||
// following layout:
|
||||
//
|
||||
// 0000|1111|2222
|
||||
// 0000|1111|2222
|
||||
// 0000|1111|2222
|
||||
// 0000|1111|2222
|
||||
// --------------
|
||||
// 3333|4444|5555
|
||||
// 3333|4444|5555
|
||||
// 3333|4444|5555
|
||||
// 3333|4444|5555
|
||||
// --------------
|
||||
// 6666|7777|8888
|
||||
// 6666|7777|8888
|
||||
// 6666|7777|8888
|
||||
// 6666|7777|8888
|
||||
// x-------------
|
||||
//
|
||||
// The - | regions are ignored and are only there to space out the animation
|
||||
// to make it easier to view.
|
||||
//
|
||||
// The extra bottom row is a flag row and should normally be black. The first
|
||||
// pixel (bottom-left) optionally marks a loop frame. By default, the animation
|
||||
// plays all the way through and then loops back to the beginning. If the loop
|
||||
// frame pixel is white, it marks a frame to loop to instead of the beginning.
|
||||
// This allows pressed animations to have a separate lead-in and loop.
|
||||
//
|
||||
// Each animation is for a single pad. You can load the same animation for both
|
||||
// pads or use different ones.
|
||||
|
||||
#include "SMXPanelAnimation.h" |
||||
#include "SMXManager.h" |
||||
#include "SMXDevice.h" |
||||
#include "SMXThread.h" |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
namespace { |
||||
Mutex g_Lock; |
||||
} |
||||
|
||||
#define LIGHTS_PER_PANEL 25 |
||||
|
||||
// XXX: go to sleep if there are no pads connected
|
||||
|
||||
struct AnimationState |
||||
{ |
||||
SMXPanelAnimation animation; |
||||
|
||||
// Seconds into the animation:
|
||||
float fTime = 0; |
||||
|
||||
// The currently displayed frame:
|
||||
int iCurrentFrame = 0; |
||||
|
||||
bool bPlaying = false; |
||||
|
||||
double m_fLastUpdateTime = -1; |
||||
|
||||
// Return the current animation frame.
|
||||
const vector<SMXGif::Color> &GetAnimationFrame() const |
||||
{ |
||||
// If we're not playing, return an empty array. As a sanity check, do this
|
||||
// if the frame is out of bounds too.
|
||||
if(!bPlaying || iCurrentFrame >= animation.m_aPanelGraphics.size()) |
||||
{ |
||||
static vector<SMXGif::Color> dummy; |
||||
return dummy; |
||||
} |
||||
|
||||
return animation.m_aPanelGraphics[iCurrentFrame]; |
||||
} |
||||
|
||||
// Start the animation if it's not playing.
|
||||
void Play() |
||||
{ |
||||
bPlaying = true; |
||||
} |
||||
|
||||
// Stop and disable the animation.
|
||||
void Stop() |
||||
{ |
||||
bPlaying = false; |
||||
Rewind(); |
||||
} |
||||
|
||||
// Reset to the first frame.
|
||||
void Rewind() |
||||
{ |
||||
fTime = 0; |
||||
iCurrentFrame = 0; |
||||
} |
||||
|
||||
// Advance the animation by fSeconds.
|
||||
void Update() |
||||
{ |
||||
// fSeconds is the time since the last update:
|
||||
double fNow = SMX::GetMonotonicTime(); |
||||
double fSeconds = m_fLastUpdateTime == -1? 0: (fNow - m_fLastUpdateTime); |
||||
m_fLastUpdateTime = fNow; |
||||
|
||||
if(!bPlaying || animation.m_aPanelGraphics.empty()) |
||||
return; |
||||
|
||||
// If the current frame is past the end, a new animation was probably
|
||||
// loaded.
|
||||
if(iCurrentFrame >= animation.m_aPanelGraphics.size()) |
||||
Rewind(); |
||||
|
||||
// Advance time.
|
||||
fTime += fSeconds; |
||||
|
||||
// If we're still on this frame, we're done.
|
||||
float fFrameDuration = animation.m_iFrameDurations[iCurrentFrame]; |
||||
if(fTime - 0.00001f < fFrameDuration) |
||||
return; |
||||
|
||||
// If we've passed the end of the frame, move to the next frame. Don't
|
||||
// skip frames if we're updating too quickly.
|
||||
fTime -= fFrameDuration; |
||||
if(fTime > 0) |
||||
fTime = 0; |
||||
|
||||
// Advance the frame.
|
||||
iCurrentFrame++; |
||||
|
||||
// If we're at the end of the frame, rewind to the loop frame.
|
||||
if(iCurrentFrame == animation.m_aPanelGraphics.size()) |
||||
iCurrentFrame = animation.m_iLoopFrame; |
||||
} |
||||
}; |
||||
|
||||
struct AnimationStateForPad |
||||
{ |
||||
// asLightsData is an array of lights data to send to the pad and graphic
|
||||
// is an animation graphic. Overlay graphic on top of the lights.
|
||||
void OverlayLights(char *asLightsData, const vector<SMXGif::Color> &graphic) const |
||||
{ |
||||
// Stop if this graphic isn't loaded or is paused.
|
||||
if(graphic.empty()) |
||||
return; |
||||
|
||||
for(int i = 0; i < graphic.size(); ++i) |
||||
{ |
||||
if(i >= LIGHTS_PER_PANEL) |
||||
return; |
||||
|
||||
// If this color is transparent, leave the released animation alone.
|
||||
if(graphic[i].color[3] == 0) |
||||
continue; |
||||
|
||||
asLightsData[i*3+0] = graphic[i].color[0]; |
||||
asLightsData[i*3+1] = graphic[i].color[1]; |
||||
asLightsData[i*3+2] = graphic[i].color[2]; |
||||
} |
||||
} |
||||
|
||||
// Return the command to set the current animation state as pad lights.
|
||||
string GetLightsCommand(int iPadState, const SMXConfig &config) const |
||||
{ |
||||
g_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// If AutoLightingUsePressedAnimations is set, use lights animations.
|
||||
// If it's not (the config tool is set to step color), mimic the built-in
|
||||
// step color behavior instead of using pressed animations. Any released
|
||||
// animation will always be used.
|
||||
bool bUsePressedAnimations = config.flags & PlatformFlags_AutoLightingUsePressedAnimations; |
||||
|
||||
const int iBytesPerPanel = LIGHTS_PER_PANEL*3; |
||||
const int iTotalLights = 9*iBytesPerPanel; |
||||
string result(iTotalLights, 0); |
||||
|
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
// The portion of lights data for this panel:
|
||||
char *out = &result[panel*iBytesPerPanel]; |
||||
|
||||
// Skip this panel if it's not in autoLightPanelMask.
|
||||
if(!(config.autoLightPanelMask & (1 << panel))) |
||||
continue; |
||||
|
||||
// Add the released animation, then overlay the pressed animation if we're pressed.
|
||||
OverlayLights(out, animations[SMX_LightsType_Released][panel].GetAnimationFrame()); |
||||
bool bPressed = bool(iPadState & (1 << panel)); |
||||
if(bPressed && bUsePressedAnimations) |
||||
OverlayLights(out, animations[SMX_LightsType_Pressed][panel].GetAnimationFrame()); |
||||
else if(bPressed && !bUsePressedAnimations) |
||||
{ |
||||
// Light all LEDs on this panel using stepColor.
|
||||
double LightsScaleFactor = 0.666666f; |
||||
const uint8_t *color = &config.stepColor[panel*3]; |
||||
|
||||
for(int light = 0; light < LIGHTS_PER_PANEL; ++light) |
||||
{ |
||||
for(int i = 0; i < 3; ++i) |
||||
{ |
||||
// stepColor is scaled to the 0-170 range. Scale it back to the 0-255 range.
|
||||
// User applications don't need to worry about this since they normally don't
|
||||
// need to care about stepColor.
|
||||
uint8_t c = color[i]; |
||||
c = (uint8_t) lrintf(min(255.0f, c / LightsScaleFactor)); |
||||
out[light*3+i] = c; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
// State for both animations on each panel:
|
||||
AnimationState animations[NUM_SMX_LightsType][9]; |
||||
}; |
||||
|
||||
namespace |
||||
{ |
||||
// Animations and animation states for both pads.
|
||||
AnimationStateForPad pad_states[2]; |
||||
} |
||||
|
||||
namespace { |
||||
// The X,Y positions of each possible panel.
|
||||
vector<pair<int,int>> graphic_positions = { |
||||
{ 0,0 }, |
||||
{ 1,0 }, |
||||
{ 2,0 }, |
||||
{ 0,1 }, |
||||
{ 1,1 }, |
||||
{ 2,1 }, |
||||
{ 0,2 }, |
||||
{ 1,2 }, |
||||
{ 2,2 }, |
||||
}; |
||||
|
||||
// Given a 14x15 graphic frame and a panel number, return an array of 16 colors, containing
|
||||
// each light in the order it's sent to the master controller.
|
||||
void ConvertToPanelGraphic16(const SMXGif::GIFImage &src, vector<SMXGif::Color> &dst, int panel) |
||||
{ |
||||
dst.clear(); |
||||
|
||||
// The top-left corner for this panel:
|
||||
int x = graphic_positions[panel].first * 5; |
||||
int y = graphic_positions[panel].second * 5; |
||||
|
||||
// Add the 4x4 grid.
|
||||
for(int dy = 0; dy < 4; ++dy) |
||||
for(int dx = 0; dx < 4; ++dx) |
||||
dst.push_back(src.get(x+dx, y+dy)); |
||||
|
||||
// These animations have no data for the 3x3 grid, so just set them to transparent.
|
||||
for(int dy = 0; dy < 3; ++dy) |
||||
for(int dx = 0; dx < 3; ++dx) |
||||
dst.push_back(SMXGif::Color(0,0,0,0)); |
||||
} |
||||
|
||||
// Given a 23x24 graphic frame and a panel number, return an array of 25 colors, containing
|
||||
// each light in the order it's sent to the master controller.
|
||||
void ConvertToPanelGraphic25(const SMXGif::GIFImage &src, vector<SMXGif::Color> &dst, int panel) |
||||
{ |
||||
dst.clear(); |
||||
|
||||
// The top-left corner for this panel:
|
||||
int x = graphic_positions[panel].first * 8; |
||||
int y = graphic_positions[panel].second * 8; |
||||
|
||||
// Add the 4x4 grid first.
|
||||
for(int dy = 0; dy < 4; ++dy) |
||||
for(int dx = 0; dx < 4; ++dx) |
||||
dst.push_back(src.get(x+dx*2, y+dy*2)); |
||||
|
||||
// Add the 3x3 grid.
|
||||
for(int dy = 0; dy < 3; ++dy) |
||||
for(int dx = 0; dx < 3; ++dx) |
||||
dst.push_back(src.get(x+dx*2+1, y+dy*2+1)); |
||||
} |
||||
} |
||||
|
||||
// Load an array of animation frames as a panel animation. Each frame must
|
||||
// be 14x15 or 23x24.
|
||||
void SMXPanelAnimation::Load(const vector<SMXGif::SMXGifFrame> &frames, int panel) |
||||
{ |
||||
m_aPanelGraphics.clear(); |
||||
m_iFrameDurations.clear(); |
||||
m_iLoopFrame = -1; |
||||
|
||||
for(int frame_no = 0; frame_no < frames.size(); ++frame_no) |
||||
{ |
||||
const SMXGif::SMXGifFrame &gif_frame = frames[frame_no]; |
||||
|
||||
// If the bottom-left pixel is white, this is the loop frame, which marks the
|
||||
// frame the animation should start at after a loop. This is global to the
|
||||
// animation, not specific to each panel.
|
||||
SMXGif::Color marker = gif_frame.frame.get(0, gif_frame.frame.height-1); |
||||
if(marker.color[3] == 0xFF && marker.color[0] >= 0x80) |
||||
{ |
||||
// We shouldn't see more than one of these. If we do, use the first.
|
||||
if(m_iLoopFrame == -1) |
||||
m_iLoopFrame = frame_no; |
||||
} |
||||
|
||||
// Extract this frame. If the graphic is 14x15 it's a 4x4 animation,
|
||||
// and if it's 23x24 it's 25-light.
|
||||
vector<SMXGif::Color> panel_graphic; |
||||
if(frames[0].width == 14) |
||||
ConvertToPanelGraphic16(gif_frame.frame, panel_graphic, panel); |
||||
else |
||||
ConvertToPanelGraphic25(gif_frame.frame, panel_graphic, panel); |
||||
|
||||
// GIFs have a very low-resolution duration field, with 10ms units.
|
||||
// The panels run at 30 FPS internally, or 33 1/3 ms, but GIF can only
|
||||
// represent 30ms or 40ms. Most applications will probably output 30,
|
||||
// but snap both 30ms and 40ms to exactly 30 FPS to make sure animations
|
||||
// that are meant to run at native framerate do.
|
||||
float seconds; |
||||
if(gif_frame.milliseconds == 30 || gif_frame.milliseconds == 40) |
||||
seconds = 1 / 30.0f; |
||||
else |
||||
seconds = gif_frame.milliseconds / 1000.0; |
||||
|
||||
m_aPanelGraphics.push_back(panel_graphic); |
||||
m_iFrameDurations.push_back(seconds); |
||||
} |
||||
|
||||
// By default, loop back to the first frame.
|
||||
if(m_iLoopFrame == -1) |
||||
m_iLoopFrame = 0; |
||||
} |
||||
|
||||
#include "SMXPanelAnimationUpload.h" |
||||
|
||||
// Load a GIF into SMXLoadedPanelAnimations::animations.
|
||||
bool SMX_LightsAnimation_Load(const char *gif, int size, int pad, SMX_LightsType type, const char **error) |
||||
{ |
||||
// Parse the GIF.
|
||||
string buf(gif, size); |
||||
vector<SMXGif::SMXGifFrame> frames; |
||||
if(!SMXGif::DecodeGIF(buf, frames) || frames.empty()) |
||||
{ |
||||
*error = "The GIF couldn't be read."; |
||||
return false; |
||||
} |
||||
|
||||
// Check the dimensions of the image. We only need to check the first, the
|
||||
// others will always have the same size.
|
||||
if((frames[0].width != 14 || frames[0].height != 15) && (frames[0].width != 23 || frames[0].height != 24)) |
||||
{ |
||||
*error = "The GIF must be 14x15 or 23x24."; |
||||
return false; |
||||
} |
||||
|
||||
// Load the graphics into SMXPanelAnimations.
|
||||
SMXPanelAnimation animations[9]; |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
animations[panel].Load(frames, panel); |
||||
|
||||
// Set up the upload for this graphic.
|
||||
if(!SMX_LightsUpload_PrepareUpload(pad, type, animations, error)) |
||||
return false; |
||||
|
||||
// Lock while we access pad_states.
|
||||
g_Lock.AssertNotLockedByCurrentThread(); |
||||
LockMutex L(g_Lock); |
||||
|
||||
// Commit the animation to pad_states now that we know there are no errors.
|
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
SMXPanelAnimation &animation = pad_states[pad].animations[type][panel].animation; |
||||
animation = animations[panel]; |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
namespace |
||||
{ |
||||
double g_fStopAnimatingUntil = -1; |
||||
} |
||||
|
||||
void SMXAutoPanelAnimations::TemporaryStopAnimating() |
||||
{ |
||||
// Stop animating for 100ms.
|
||||
double fStopForSeconds = 1/10.0f; |
||||
g_fStopAnimatingUntil = SMX::GetMonotonicTime() + fStopForSeconds; |
||||
} |
||||
|
||||
// A thread to handle setting light animations. We do this in a separate
|
||||
// thread rather than in the SMXManager thread so this can be treated as
|
||||
// if it's external application thread, and it's making normal threaded
|
||||
// calls to SetLights.
|
||||
class PanelAnimationThread: public SMXThread |
||||
{ |
||||
public: |
||||
static shared_ptr<PanelAnimationThread> g_pSingleton; |
||||
PanelAnimationThread(): |
||||
SMXThread(g_Lock) |
||||
{ |
||||
Start("SMX light animations"); |
||||
} |
||||
|
||||
private: |
||||
void ThreadMain() |
||||
{ |
||||
m_Lock.Lock(); |
||||
|
||||
// Update lights at 30 FPS.
|
||||
const int iDelayMS = 33; |
||||
|
||||
while(!m_bShutdown) |
||||
{ |
||||
// Check if we've temporarily stopped updating lights.
|
||||
bool bSkipUpdate = g_fStopAnimatingUntil > SMX::GetMonotonicTime(); |
||||
|
||||
// Run a single panel lights update.
|
||||
if(!bSkipUpdate) |
||||
UpdateLights(); |
||||
|
||||
// Wait up to 30 FPS, or until we're signalled. We can only be signalled
|
||||
// if we're shutting down, so we don't need to worry about partial frame
|
||||
// delays.
|
||||
m_Event.Wait(iDelayMS); |
||||
} |
||||
|
||||
m_Lock.Unlock(); |
||||
} |
||||
|
||||
// Return lights for the given pad and pad state, using the loaded panel animations.
|
||||
bool GetCurrentLights(string &asLightsDataOut, int pad, int iPadState) |
||||
{ |
||||
m_Lock.AssertLockedByCurrentThread(); |
||||
|
||||
// Get this pad's configuration.
|
||||
SMXConfig config; |
||||
if(!SMXManager::g_pSMX->GetDevice(pad)->GetConfig(config)) |
||||
return false; |
||||
|
||||
// If this controller handles animation itself, don't handle it here too. It can
|
||||
// lead to confusing situations if SMXConfig's animations don't match the ones stored
|
||||
// on the pad.
|
||||
if(config.masterVersion >= 4) |
||||
return false; |
||||
|
||||
AnimationStateForPad &pad_state = pad_states[pad]; |
||||
|
||||
// Make sure the correct animations are playing.
|
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
// The released animation is always playing.
|
||||
pad_state.animations[SMX_LightsType_Released][panel].Play(); |
||||
|
||||
// The pressed animation only plays while the button is pressed,
|
||||
// and rewind when it's released.
|
||||
bool bPressed = iPadState & (1 << panel); |
||||
if(bPressed) |
||||
pad_state.animations[SMX_LightsType_Pressed][panel].Play(); |
||||
else |
||||
pad_state.animations[SMX_LightsType_Pressed][panel].Stop(); |
||||
} |
||||
|
||||
// Set the current state.
|
||||
asLightsDataOut = pad_state.GetLightsCommand(iPadState, config); |
||||
|
||||
// Advance animations.
|
||||
for(int type = 0; type < NUM_SMX_LightsType; ++type) |
||||
{ |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
pad_state.animations[type][panel].Update(); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
// Run a single light animation update.
|
||||
void UpdateLights() |
||||
{ |
||||
string asLightsData[2]; |
||||
bool bHaveLights = false; |
||||
for(int pad = 0; pad < 2; pad++) |
||||
{ |
||||
int iPadState = SMXManager::g_pSMX->GetDevice(pad)->GetInputState(); |
||||
if(GetCurrentLights(asLightsData[pad], pad, iPadState)) |
||||
bHaveLights = true; |
||||
} |
||||
|
||||
// Update lights.
|
||||
if(bHaveLights) |
||||
SMXManager::g_pSMX->SetLights(asLightsData); |
||||
} |
||||
}; |
||||
|
||||
void SMX_LightsAnimation_SetAuto(bool enable) |
||||
{ |
||||
if(!enable) |
||||
{ |
||||
// If we're turning off, shut down the thread if it's running.
|
||||
if(PanelAnimationThread::g_pSingleton) |
||||
PanelAnimationThread::g_pSingleton->Shutdown(); |
||||
PanelAnimationThread::g_pSingleton.reset(); |
||||
return; |
||||
} |
||||
|
||||
// Create the animation thread if it's not already running.
|
||||
if(PanelAnimationThread::g_pSingleton) |
||||
return; |
||||
PanelAnimationThread::g_pSingleton.reset(new PanelAnimationThread()); |
||||
} |
||||
|
||||
shared_ptr<PanelAnimationThread> PanelAnimationThread::g_pSingleton; |
||||
@ -0,0 +1,57 @@ |
||||
#ifndef SMXPanelAnimation_h |
||||
#define SMXPanelAnimation_h |
||||
|
||||
#include <vector> |
||||
#include "SMXGif.h" |
||||
|
||||
enum SMX_LightsType |
||||
{ |
||||
SMX_LightsType_Released, // animation while panels are released
|
||||
SMX_LightsType_Pressed, // animation while panel is pressed
|
||||
NUM_SMX_LightsType, |
||||
}; |
||||
|
||||
// SMXPanelAnimation holds an animation, with graphics for a single panel.
|
||||
class SMXPanelAnimation |
||||
{ |
||||
public: |
||||
void Load(const std::vector<SMXGif::SMXGifFrame> &frames, int panel); |
||||
|
||||
// The high-level animated GIF frames:
|
||||
std::vector<std::vector<SMXGif::Color>> m_aPanelGraphics; |
||||
|
||||
// The animation starts on frame 0. When it reaches the end, it loops
|
||||
// back to this frame.
|
||||
int m_iLoopFrame = 0; |
||||
|
||||
// The duration of each frame in seconds.
|
||||
std::vector<float> m_iFrameDurations; |
||||
}; |
||||
|
||||
namespace SMXAutoPanelAnimations |
||||
{ |
||||
// If SMX_LightsAnimation_SetAuto is active, stop sending animations briefly. This is
|
||||
// called when lights are set directly, so they don't compete with the animation.
|
||||
void TemporaryStopAnimating(); |
||||
} |
||||
|
||||
// For SMX_API:
|
||||
#include "../SMX.h" |
||||
|
||||
// High-level interface for C# bindings:
|
||||
//
|
||||
// Load an animated GIF as a panel animation. pad is the pad this animation is for (0 or 1),
|
||||
// and type is which animation this is for. Any previously loaded animation will be replaced.
|
||||
// On error, false is returned and error is set to a plain-text error message which is valid
|
||||
// until the next call. On success, the animation can be uploaded to the pad if supported using
|
||||
// SMX_LightsUpload_BeginUpload, or used directly with SMX_LightsAnimation_SetAuto.
|
||||
SMX_API bool SMX_LightsAnimation_Load(const char *gif, int size, int pad, SMX_LightsType type, const char **error); |
||||
|
||||
// Enable or disable automatically handling lights animations. If enabled, any animations
|
||||
// loaded with SMX_LightsAnimation_Load will run automatically as long as the SDK is loaded.
|
||||
// This only has an effect if the platform doesn't handle animations directly. On newer firmware,
|
||||
// this has no effect (upload the animation to the panel instead).
|
||||
// XXX: should we automatically disable SMX_SetLights when this is enabled?
|
||||
SMX_API void SMX_LightsAnimation_SetAuto(bool enable); |
||||
|
||||
#endif |
||||
@ -0,0 +1,484 @@ |
||||
#include "SMXPanelAnimationUpload.h" |
||||
#include "SMXPanelAnimation.h" |
||||
#include "SMXGif.h" |
||||
#include "SMXManager.h" |
||||
#include "SMXDevice.h" |
||||
#include "Helpers.h" |
||||
#include <string> |
||||
#include <vector> |
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
// This handles setting up commands to upload panel animations to the
|
||||
// controller.
|
||||
//
|
||||
// This is only meant to be used by configuration tools to allow setting
|
||||
// up animations that work while the pad isn't being controlled by the
|
||||
// SDK. If you want to control lights for your game, this isn't what
|
||||
// you want. Use SMX_SetLights instead.
|
||||
//
|
||||
// Panel animations are sent to the master controller one panel at a time, and
|
||||
// each animation can take several commands to upload to fit in the protocol packet
|
||||
// size. These commands are stateful.
|
||||
namespace |
||||
{ |
||||
// Panel names for error messages.
|
||||
static const char *panel_names[] = { |
||||
"up-left", "up", "up-right", |
||||
"left", "center", "right", |
||||
"down-left", "down", "down-right", |
||||
}; |
||||
} |
||||
|
||||
// These structs are the protocol we use to send offline graphics to the pad.
|
||||
// This isn't related to realtime lighting.
|
||||
namespace PanelLightGraphic |
||||
{ |
||||
// One 24-bit RGB color:
|
||||
struct color_t { |
||||
uint8_t rgb[3]; |
||||
}; |
||||
|
||||
// 4-bit palette, 15 colors. Our graphics are 4-bit. Color 0xF is transparent,
|
||||
// so we don't have a palette entry for it.
|
||||
struct palette_t { |
||||
color_t colors[15]; |
||||
}; |
||||
|
||||
// A single 4-bit paletted graphic.
|
||||
struct graphic_t { |
||||
uint8_t data[13]; |
||||
}; |
||||
|
||||
struct panel_animation_data_t |
||||
{ |
||||
// Our graphics and palettes. We can apply either palette to any graphic. Note that
|
||||
// each graphic is 13 bytes and each palette is 45 bytes.
|
||||
graphic_t graphics[64]; |
||||
palette_t palettes[2]; |
||||
}; |
||||
|
||||
struct animation_timing_t |
||||
{ |
||||
// An index into frames[]:
|
||||
uint8_t loop_animation_frame; |
||||
|
||||
// A list of graphic frames to display, and how long to display them in
|
||||
// 30 FPS frames. A frame index of 0xFF (or reaching the end) loops.
|
||||
uint8_t frames[64]; |
||||
uint8_t delay[64]; |
||||
}; |
||||
|
||||
// Commands to upload data:
|
||||
#pragma pack(push, 1) |
||||
struct upload_packet |
||||
{ |
||||
// 'm' to upload master animation data.
|
||||
uint8_t cmd = 'm'; |
||||
|
||||
// The panel this data is for. If this is 0xFF, it's for the master.
|
||||
uint8_t panel = 0; |
||||
|
||||
// For master uploads, the animation number to modify. Panels ignore this field.
|
||||
uint8_t animation_idx = 0; |
||||
|
||||
// True if this is the last upload packet. This lets the firmware know that
|
||||
// this part of the upload is finished and it can update anything that might
|
||||
// be affected by it, like resetting lights animations.
|
||||
bool final_packet = false; |
||||
|
||||
uint16_t offset = 0; |
||||
uint8_t size = 0; |
||||
uint8_t data[240]; |
||||
}; |
||||
#pragma pack(pop) |
||||
|
||||
#pragma pack(push, 1) |
||||
struct delay_packet |
||||
{ |
||||
// 'd' to ask the master to delay.
|
||||
uint8_t cmd = 'd'; |
||||
|
||||
// How long to delay:
|
||||
uint16_t milliseconds = 0; |
||||
}; |
||||
#pragma pack(pop) |
||||
|
||||
// Make sure the packet fits in a command packet.
|
||||
static_assert(sizeof(upload_packet) <= 0xFF, ""); |
||||
} |
||||
|
||||
// The GIFs can use variable framerates. The panels update at 30 FPS.
|
||||
#define FPS 30 |
||||
|
||||
// Helpers for converting PanelGraphics to the packed sprite representation
|
||||
// we give to the pad.
|
||||
namespace ProtocolHelpers |
||||
{ |
||||
// Return a color's index in palette. If the color isn't found, return 0xFF.
|
||||
// We can use a dumb linear search here since the graphics are so small.
|
||||
uint8_t GetColorIndex(const PanelLightGraphic::palette_t &palette, const SMXGif::Color &color) |
||||
{ |
||||
// Transparency is always palette index 15.
|
||||
if(color.color[3] == 0) |
||||
return 15; |
||||
|
||||
for(int idx = 0; idx < 15; ++idx) |
||||
{ |
||||
PanelLightGraphic::color_t pad_color = palette.colors[idx]; |
||||
if(pad_color.rgb[0] == color.color[0] && |
||||
pad_color.rgb[1] == color.color[1] && |
||||
pad_color.rgb[2] == color.color[2]) |
||||
return idx; |
||||
} |
||||
return 0xFF; |
||||
} |
||||
|
||||
// Create a palette for an animation.
|
||||
//
|
||||
// We're loading from paletted GIFs, but we create a separate small palette
|
||||
// for each panel's animation, so we don't use the GIF's palette.
|
||||
bool CreatePalette(const SMXPanelAnimation &animation, PanelLightGraphic::palette_t &palette) |
||||
{ |
||||
int next_color = 0; |
||||
for(const auto &panel_graphic: animation.m_aPanelGraphics) |
||||
{ |
||||
for(const SMXGif::Color &color: panel_graphic) |
||||
{ |
||||
// If this color is transparent, leave it out of the palette.
|
||||
if(color.color[3] == 0) |
||||
continue; |
||||
|
||||
// Check if this color is already in the palette.
|
||||
uint8_t existing_idx = GetColorIndex(palette, color); |
||||
if(existing_idx != 0xFF) |
||||
continue; |
||||
|
||||
// Return false if we're using too many colors.
|
||||
if(next_color == 15) |
||||
return false; |
||||
|
||||
// Add this color.
|
||||
PanelLightGraphic::color_t pad_color; |
||||
pad_color.rgb[0] = color.color[0]; |
||||
pad_color.rgb[1] = color.color[1]; |
||||
pad_color.rgb[2] = color.color[2]; |
||||
palette.colors[next_color] = pad_color; |
||||
next_color++; |
||||
} |
||||
} |
||||
return true; |
||||
} |
||||
|
||||
// Return packed paletted graphics for each frame, using a palette created
|
||||
// with CreatePalette. The palette must have fewer than 16 colors.
|
||||
void CreatePackedGraphic(const vector<SMXGif::Color> &image, const PanelLightGraphic::palette_t &palette, |
||||
PanelLightGraphic::graphic_t &out) |
||||
{ |
||||
int position = 0; |
||||
memset(out.data, 0, sizeof(out.data)); |
||||
for(auto color: image) |
||||
{ |
||||
// Transparency is always palette index 15.
|
||||
uint8_t palette_idx = GetColorIndex(palette, color); |
||||
if(palette_idx == 0xFF) |
||||
palette_idx = 0; |
||||
|
||||
// If this is an odd index, put the palette index in the low 4
|
||||
// bits. Otherwise, put it in the high 4 bits.
|
||||
if(position & 1) |
||||
out.data[position/2] |= (palette_idx & 0x0F) << 0; |
||||
else |
||||
out.data[position/2] |= (palette_idx & 0x0F) << 4; |
||||
position++; |
||||
} |
||||
} |
||||
|
||||
vector<uint8_t> get_frame_delays(const SMXPanelAnimation &animation) |
||||
{ |
||||
vector<uint8_t> result; |
||||
int current_frame = 0; |
||||
|
||||
float time_left_in_frame = animation.m_iFrameDurations[0]; |
||||
result.push_back(0); |
||||
while(1) |
||||
{ |
||||
// Advance time by 1/FPS seconds.
|
||||
time_left_in_frame -= 1.0f / FPS; |
||||
result.back()++; |
||||
|
||||
if(time_left_in_frame <= 0.00001f) |
||||
{ |
||||
// We've displayed this frame long enough, so advance to the next frame.
|
||||
if(current_frame + 1 == animation.m_iFrameDurations.size()) |
||||
break; |
||||
|
||||
current_frame += 1; |
||||
result.push_back(0); |
||||
time_left_in_frame += animation.m_iFrameDurations[current_frame]; |
||||
|
||||
// If time_left_in_frame is still negative, the animation is too fast.
|
||||
if(time_left_in_frame < 0.00001) |
||||
time_left_in_frame = 0; |
||||
} |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
// Create the master data. This just has timing information.
|
||||
bool CreateMasterAnimationData(SMX_LightsType type, |
||||
const SMXPanelAnimation &animation, |
||||
PanelLightGraphic::animation_timing_t &animation_timing, const char **error) |
||||
{ |
||||
// Released (idle) animations use frames 0-31, and pressed animations use 32-63.
|
||||
int first_graphic = type == SMX_LightsType_Released? 0:32; |
||||
|
||||
// Check that we don't have more frames than we can fit in animation_timing.
|
||||
// This is currently the same as the "too many frames" error below, but if
|
||||
// we support longer delays (staying on the same graphic for multiple animation_timings)
|
||||
// or deduping they'd be different.
|
||||
if(animation.m_aPanelGraphics.size() > arraylen(animation_timing.frames)) |
||||
{ |
||||
*error = "The animation is too long."; |
||||
return false; |
||||
} |
||||
|
||||
memset(&animation_timing.frames[0], 0xFF, sizeof(animation_timing.frames)); |
||||
for(int i = 0; i < animation.m_aPanelGraphics.size(); ++i) |
||||
animation_timing.frames[i] = i + first_graphic; |
||||
|
||||
// Set frame delays.
|
||||
memset(&animation_timing.delay[0], 0, sizeof(animation_timing.delay)); |
||||
vector<uint8_t> delays = get_frame_delays(animation); |
||||
for(int i = 0; i < delays.size() && i < 64; ++i) |
||||
animation_timing.delay[i] = delays[i]; |
||||
|
||||
// These frame numbers are relative to the animation, so don't add first_graphic.
|
||||
animation_timing.loop_animation_frame = animation.m_iLoopFrame; |
||||
|
||||
return true; |
||||
} |
||||
|
||||
// Pack panel graphics.
|
||||
bool CreatePanelAnimationData(PanelLightGraphic::panel_animation_data_t &panel_data, |
||||
int pad, SMX_LightsType type, int panel, const SMXPanelAnimation &animation, const char **error) |
||||
{ |
||||
// We have a single buffer of animation frames for each panel, which we pack
|
||||
// both the pressed and released frames into. This is the index of the next
|
||||
// frame.
|
||||
int next_graphic_idx = type == SMX_LightsType_Released? 0:32; |
||||
|
||||
// Create this animation's 4-bit palette.
|
||||
if(!ProtocolHelpers::CreatePalette(animation, panel_data.palettes[type])) |
||||
{ |
||||
*error = SMX::CreateError(SMX::ssprintf("The %s panel uses too many colors.", panel_names[panel])); |
||||
return false; |
||||
} |
||||
|
||||
// Create a small 4-bit paletted graphic with the 4-bit palette we created.
|
||||
// These are the graphics we'll send to the controller.
|
||||
for(const auto &panel_graphic: animation.m_aPanelGraphics) |
||||
{ |
||||
if(next_graphic_idx > arraylen(panel_data.graphics)) |
||||
{ |
||||
*error = "The animation has too many frames."; |
||||
return false; |
||||
} |
||||
|
||||
ProtocolHelpers::CreatePackedGraphic(panel_graphic, panel_data.palettes[type], panel_data.graphics[next_graphic_idx]); |
||||
next_graphic_idx++; |
||||
} |
||||
|
||||
// Apply color scaling to the palette, in the same way SMXManager::SetLights does.
|
||||
// Do this after we've finished creating the graphic, so this is only applied to
|
||||
// the final result and doesn't affect palettization.
|
||||
for(PanelLightGraphic::color_t &color: panel_data.palettes[type].colors) |
||||
{ |
||||
for(int i = 0; i < 3; ++i) |
||||
color.rgb[i] = uint8_t(color.rgb[i] * 0.6666f); |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
// Create upload packets to upload a block of data.
|
||||
void CreateUploadPackets(vector<PanelLightGraphic::upload_packet> &packets, |
||||
const void *data_block, int start, int size, |
||||
uint8_t panel, int animation_idx) |
||||
{ |
||||
const uint8_t *buf = (const uint8_t *) data_block; |
||||
for(int offset = 0; offset < size; ) |
||||
{ |
||||
PanelLightGraphic::upload_packet packet; |
||||
packet.panel = panel; |
||||
packet.animation_idx = animation_idx; |
||||
packet.offset = start + offset; |
||||
|
||||
int bytes_left = size - offset; |
||||
packet.size = min(sizeof(PanelLightGraphic::upload_packet::data), bytes_left); |
||||
memcpy(packet.data, buf, packet.size); |
||||
packets.push_back(packet); |
||||
|
||||
offset += packet.size; |
||||
buf += packet.size; |
||||
} |
||||
} |
||||
} |
||||
|
||||
namespace LightsUploadData |
||||
{ |
||||
vector<string> commands[2]; |
||||
} |
||||
|
||||
// Prepare the loaded graphics for upload.
|
||||
bool SMX_LightsUpload_PrepareUpload(int pad, SMX_LightsType type, const SMXPanelAnimation animations[9], const char **error) |
||||
{ |
||||
// Create master animation data.
|
||||
PanelLightGraphic::animation_timing_t master_animation_data; |
||||
memset(&master_animation_data, 0xFF, sizeof(master_animation_data)); |
||||
|
||||
// All animations of each type have the same timing for all panels, since
|
||||
// they come from the same GIF, so just use the first frame to generate the
|
||||
// master data.
|
||||
if(!ProtocolHelpers::CreateMasterAnimationData(type, animations[0], master_animation_data, error)) |
||||
return false; |
||||
|
||||
// Create panel animation data.
|
||||
PanelLightGraphic::panel_animation_data_t all_panel_data[9]; |
||||
memset(&all_panel_data, 0xFF, sizeof(all_panel_data)); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
if(!ProtocolHelpers::CreatePanelAnimationData(all_panel_data[panel], pad, type, panel, animations[panel], error)) |
||||
return false; |
||||
} |
||||
|
||||
// We successfully created the data, so there's nothing else that can fail from
|
||||
// here on.
|
||||
//
|
||||
// A list of the final commands we'll send:
|
||||
vector<string> &pad_commands = LightsUploadData::commands[pad]; |
||||
pad_commands.clear(); |
||||
|
||||
// Add an upload packet to pad_commands:
|
||||
auto add_packet_command = [&pad_commands](const PanelLightGraphic::upload_packet &packet) { |
||||
string command((char *) &packet, sizeof(packet)); |
||||
pad_commands.push_back(command); |
||||
}; |
||||
|
||||
// Add a command to briefly delay the master, to give panels a chance to finish writing to EEPROM.
|
||||
auto add_delay = [&pad_commands](int milliseconds) { |
||||
PanelLightGraphic::delay_packet packet; |
||||
packet.milliseconds = milliseconds; |
||||
|
||||
string command((char *) &packet, sizeof(packet)); |
||||
pad_commands.push_back(command); |
||||
}; |
||||
|
||||
// Create the packets we'll send, grouped by panel.
|
||||
vector<PanelLightGraphic::upload_packet> packetsPerPanel[9]; |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
// Only upload the panel graphic data and the palette we're changing. If type
|
||||
// is 0 (SMX_LightsType_Released), we're uploading the first 32 graphics and palette
|
||||
// 0. If it's 1 (SMX_LightsType_Pressed), we're uploading the second 32 graphics
|
||||
// and palette 1.
|
||||
const auto &panel_data_block = all_panel_data[panel]; |
||||
{ |
||||
int first_graphic = type == SMX_LightsType_Released? 0:32; |
||||
const PanelLightGraphic::graphic_t *graphics = &panel_data_block.graphics[first_graphic]; |
||||
int offset = offsetof(PanelLightGraphic::panel_animation_data_t, graphics[first_graphic]); |
||||
ProtocolHelpers::CreateUploadPackets(packetsPerPanel[panel], graphics, offset, sizeof(PanelLightGraphic::graphic_t) * 32, panel, type); |
||||
} |
||||
|
||||
{ |
||||
const PanelLightGraphic::palette_t *palette = &panel_data_block.palettes[type]; |
||||
int offset = offsetof(PanelLightGraphic::panel_animation_data_t, palettes[type]); |
||||
ProtocolHelpers::CreateUploadPackets(packetsPerPanel[panel], palette, offset, sizeof(PanelLightGraphic::palette_t), panel, type); |
||||
} |
||||
} |
||||
|
||||
// It takes 3.4ms per byte to write to EEPROM, and we need to avoid writing data
|
||||
// to any single panel faster than that or data won't be written. However, we're
|
||||
// writing each data separately to each panel, so we can write data to panel 1, then
|
||||
// immediately write to panel 2 while panel 1 is busy doing the write. Taking advantage
|
||||
// of this makes the upload go much faster. Panels will miss commands while they're
|
||||
// writing data, but we don't care if panel 1 misses a command that's writing to panel
|
||||
// 2 that it would ignore anyway.
|
||||
//
|
||||
// We write the first set of packets for each panel, then explicitly delay long enough
|
||||
// for them to finish before writing the next set of packets.
|
||||
|
||||
while(1) |
||||
{ |
||||
bool added_any_packets = false; |
||||
int max_size = 0; |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
// Pull this panel's next packet. It doesn't actually matter what order we
|
||||
// send the packets in.
|
||||
// Add the next packet for each panel.
|
||||
vector<PanelLightGraphic::upload_packet> &packets = packetsPerPanel[panel]; |
||||
if(packets.empty()) |
||||
continue; |
||||
|
||||
PanelLightGraphic::upload_packet packet = packets.back(); |
||||
packets.pop_back(); |
||||
add_packet_command(packet); |
||||
max_size = max(max_size, packet.size); |
||||
added_any_packets = true; |
||||
} |
||||
|
||||
// Delay long enough for the biggest write in this burst to finish. We do this
|
||||
// by sending a command to the master to tell it to delay synchronously by the
|
||||
// right amount.
|
||||
int millisecondsToDelay = lrintf(max_size * 3.4); |
||||
add_delay(millisecondsToDelay); |
||||
|
||||
// Stop if there were no more packets to add.
|
||||
if(!added_any_packets) |
||||
break; |
||||
} |
||||
|
||||
// Add the master data.
|
||||
vector<PanelLightGraphic::upload_packet> masterPackets; |
||||
ProtocolHelpers::CreateUploadPackets(masterPackets, &master_animation_data, 0, sizeof(master_animation_data), 0xFF, type); |
||||
masterPackets.back().final_packet = true; |
||||
for(const auto &packet: masterPackets) |
||||
add_packet_command(packet); |
||||
|
||||
return true; |
||||
} |
||||
|
||||
// Start sending a prepared upload.
|
||||
//
|
||||
// The commands to send to upload the data are in LightsUploadData::commands[pad].
|
||||
void SMX_LightsUpload_BeginUpload(int pad, SMX_LightsUploadCallback pCallback, void *pUser) |
||||
{ |
||||
shared_ptr<SMXDevice> pDevice = SMXManager::g_pSMX->GetDevice(pad); |
||||
vector<string> asCommands = LightsUploadData::commands[pad]; |
||||
int iTotalCommands = asCommands.size(); |
||||
|
||||
// Queue all commands at once. As each command finishes, our callback
|
||||
// will be called.
|
||||
for(int i = 0; i < asCommands.size(); ++i) |
||||
{ |
||||
const string &sCommand = asCommands[i]; |
||||
pDevice->SendCommand(sCommand, [i, iTotalCommands, pCallback, pUser](string response) { |
||||
// Command #i has finished being sent.
|
||||
//
|
||||
// If this isn't the last command, make sure progress isn't 100.
|
||||
// Once we send 100%, the callback is no longer valid.
|
||||
int progress; |
||||
if(i != iTotalCommands-1) |
||||
progress = min((i*100) / (iTotalCommands - 1), 99); |
||||
else |
||||
progress = 100; |
||||
|
||||
// We're currently in the SMXManager thread. Call the user thread from
|
||||
// the user callback thread.
|
||||
SMXManager::g_pSMX->RunInHelperThread([pCallback, pUser, progress]() { |
||||
pCallback(progress, pUser); |
||||
}); |
||||
}); |
||||
} |
||||
} |
||||
@ -0,0 +1,39 @@ |
||||
#ifndef SMXPanelAnimationUpload_h |
||||
#define SMXPanelAnimationUpload_h |
||||
|
||||
#include "SMXPanelAnimation.h" |
||||
|
||||
// For SMX_API:
|
||||
#include "../SMX.h" |
||||
|
||||
// This is used to upload panel animations to the firmware. This is
|
||||
// only needed for offline animations. For live animations, either
|
||||
// use SMX_LightsAnimation_SetAuto, or to control lights directly
|
||||
// (recommended), use SMX_SetLights. animations[] contains the animations
|
||||
// to load.
|
||||
//
|
||||
// Prepare the currently loaded animations to be stored on the pad.
|
||||
// Return false with an error message on error.
|
||||
//
|
||||
// All LightTypes must be loaded before beginning the upload.
|
||||
//
|
||||
// If a lights upload is already in progress, returns an error.
|
||||
SMX_API bool SMX_LightsUpload_PrepareUpload(int pad, SMX_LightsType type, const SMXPanelAnimation animations[9], const char **error); |
||||
|
||||
typedef void SMX_LightsUploadCallback(int progress, void *pUser); |
||||
|
||||
// After a successful call to SMX_LightsUpload_PrepareUpload, begin uploading data
|
||||
// to the master controller for the given pad and animation type.
|
||||
//
|
||||
// The callback will be called as the upload progresses, with progress values
|
||||
// from 0-100.
|
||||
//
|
||||
// callback will always be called exactly once with a progress value of 100.
|
||||
// Once the 100% progress is called, the callback won't be accessed, so the
|
||||
// caller can safely clean up. This will happen even if the pad disconnects
|
||||
// partway through the upload.
|
||||
//
|
||||
// The callback will be called from the user callback helper thread.
|
||||
SMX_API void SMX_LightsUpload_BeginUpload(int pad, SMX_LightsUploadCallback callback, void *pUser); |
||||
|
||||
#endif |
||||
@ -0,0 +1,49 @@ |
||||
#include "SMXThread.h" |
||||
|
||||
using namespace std; |
||||
using namespace SMX; |
||||
|
||||
SMXThread::SMXThread(Mutex &lock): |
||||
m_Lock(lock), |
||||
m_Event(lock) |
||||
{ |
||||
} |
||||
|
||||
void SMX::SMXThread::SetHighPriority(bool bHighPriority) |
||||
{ |
||||
if(m_hThread == INVALID_HANDLE_VALUE) |
||||
throw exception("SetHighPriority called while the thread isn't running"); |
||||
|
||||
SetThreadPriority(m_hThread, THREAD_PRIORITY_HIGHEST); |
||||
} |
||||
|
||||
bool SMX::SMXThread::IsCurrentThread() const |
||||
{ |
||||
return GetCurrentThreadId() == m_iThreadId; |
||||
} |
||||
|
||||
void SMXThread::Start(string name) |
||||
{ |
||||
// Start the thread.
|
||||
m_hThread = CreateThread(NULL, 0, ThreadMainStart, this, 0, &m_iThreadId); |
||||
SMX::SetThreadName(m_iThreadId, name); |
||||
} |
||||
|
||||
void SMXThread::Shutdown() |
||||
{ |
||||
m_Lock.AssertNotLockedByCurrentThread(); |
||||
|
||||
// Shut down the thread and wait for it to exit.
|
||||
m_bShutdown = true; |
||||
m_Event.Set(); |
||||
|
||||
WaitForSingleObject(m_hThread, INFINITE); |
||||
m_hThread = INVALID_HANDLE_VALUE; |
||||
} |
||||
|
||||
DWORD WINAPI SMXThread::ThreadMainStart(void *self_) |
||||
{ |
||||
SMXThread *self = (SMXThread *) self_; |
||||
self->ThreadMain(); |
||||
return 0; |
||||
} |
||||
@ -0,0 +1,45 @@ |
||||
#ifndef SMXThread_h |
||||
#define SMXThread_h |
||||
|
||||
// A base class for a thread.
|
||||
#include "Helpers.h" |
||||
#include <string> |
||||
|
||||
namespace SMX |
||||
{ |
||||
|
||||
class SMXThread |
||||
{ |
||||
public: |
||||
SMXThread(SMX::Mutex &lock); |
||||
|
||||
// Raise the priority of the thread.
|
||||
void SetHighPriority(bool bHighPriority); |
||||
|
||||
// Start the thread, giving it a name for debugging.
|
||||
void Start(std::string name); |
||||
|
||||
// Shut down the thread. This function won't return until the thread
|
||||
// has been stopped.
|
||||
void Shutdown(); |
||||
|
||||
// Return true if this is the calling thread.
|
||||
bool IsCurrentThread() const; |
||||
|
||||
// The derived class implements this.
|
||||
virtual void ThreadMain() = 0; |
||||
|
||||
protected: |
||||
static DWORD WINAPI ThreadMainStart(void *self); |
||||
|
||||
SMX::Mutex &m_Lock; |
||||
SMX::Event m_Event; |
||||
bool m_bShutdown = false; |
||||
|
||||
private: |
||||
HANDLE m_hThread = INVALID_HANDLE_VALUE; |
||||
DWORD m_iThreadId = 0; |
||||
}; |
||||
} |
||||
|
||||
#endif |
||||
@ -0,0 +1,43 @@ |
||||
@echo off |
||||
setlocal ENABLEDELAYEDEXPANSION |
||||
|
||||
rem A good old 80s batch file, because it's guaranteed to always be available. |
||||
rem This assumes git is in the path. |
||||
|
||||
for /F %%I in ('git describe --always --dirty') do set GITVER=%%I |
||||
if "%GITVER%" == "" goto git_error |
||||
|
||||
rem Replace -dirty with -devel, to indicate builds with uncommitted changes. |
||||
set GITVER=%GITVER:-dirty=-devel% |
||||
|
||||
goto continue |
||||
|
||||
:git_error |
||||
rem If calling git fails for some reason, put a message in the version instead of |
||||
rem letting it be blank. |
||||
set GITVER=git failed |
||||
|
||||
:continue |
||||
|
||||
rem Output the current version to a temp file. |
||||
set TEMP_FILE=%TEMP%\temp-SMXBuildVersion.h |
||||
set OUTPUT_FILE=SMXBuildVersion.h |
||||
|
||||
echo // This file is auto-generated by update-build-version.bat. > %TEMP_FILE% |
||||
echo. >> %TEMP_FILE% |
||||
echo #ifndef SMXBuildVersion_h >> %TEMP_FILE% |
||||
echo #define SMXBuildVersion_h >> %TEMP_FILE% |
||||
echo. >> %TEMP_FILE% |
||||
echo #define SMX_BUILD_VERSION "%GITVER%" >> %TEMP_FILE% |
||||
echo. >> %TEMP_FILE% |
||||
echo #endif >> %TEMP_FILE% |
||||
|
||||
rem Compare the temp file to any existing file. Only copy the new file over the old |
||||
rem one if it's different, so we don't trigger dependency rebuilds every time. |
||||
fc %TEMP_FILE% %OUTPUT_FILE% > nul |
||||
if %errorlevel% == 0 goto end |
||||
|
||||
echo Updated to version %GITVER% |
||||
copy %TEMP_FILE% %OUTPUT_FILE% > nul |
||||
|
||||
:end |
||||
@ -0,0 +1 @@ |
||||
bin |
||||
@ -0,0 +1,8 @@ |
||||
<Application x:Class="smx_config.App" |
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" |
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
||||
xmlns:local="clr-namespace:smx_config"> |
||||
<Application.Resources> |
||||
|
||||
</Application.Resources> |
||||
</Application> |
||||
@ -0,0 +1,250 @@ |
||||
using System; |
||||
using System.Windows; |
||||
using System.Runtime.InteropServices; |
||||
using System.IO; |
||||
using System.Threading; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public partial class App: Application |
||||
{ |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_Internal_OpenConsole(); |
||||
|
||||
private System.Windows.Forms.NotifyIcon trayIcon; |
||||
private MainWindow window; |
||||
|
||||
App() |
||||
{ |
||||
AppDomain.CurrentDomain.UnhandledException += UnhandledExceptionEventHandler; |
||||
} |
||||
|
||||
protected override void OnStartup(StartupEventArgs e) |
||||
{ |
||||
base.OnStartup(e); |
||||
|
||||
// If an instance is already running, foreground it and exit. |
||||
if(ForegroundExistingInstance()) |
||||
{ |
||||
Shutdown(); |
||||
return; |
||||
} |
||||
|
||||
// This is used by the installer to close a running instance automatically when updating. |
||||
ListenForShutdownRequest(); |
||||
|
||||
// If we're being launched on startup, but the LaunchOnStartup setting is false, |
||||
// then the user turned off auto-launching but we're still being launched for some |
||||
// reason (eg. a renamed launch shortcut that we couldn't find to remove). As |
||||
// a safety so we don't launch when the user doesn't want us to, just exit in this |
||||
// case. |
||||
if(Helpers.LaunchedOnStartup() && !LaunchOnStartup.Enable) |
||||
{ |
||||
Shutdown(); |
||||
return; |
||||
} |
||||
|
||||
LaunchOnStartup.Enable = true; |
||||
if(!SMX.SMX.DLLExists()) |
||||
{ |
||||
MessageBox.Show("SMXConfig encountered an unexpected error.\n\nSMX.dll couldn't be found:\n\n" + Helpers.GetLastWin32ErrorString(), "SMXConfig"); |
||||
Current.Shutdown(); |
||||
return; |
||||
} |
||||
|
||||
if(!SMX.SMX.DLLAvailable()) |
||||
{ |
||||
MessageBox.Show("SMXConfig encountered an unexpected error.\n\nSMX.dll failed to load:\n\n" + Helpers.GetLastWin32ErrorString(), "SMXConfig"); |
||||
Current.Shutdown(); |
||||
return; |
||||
} |
||||
|
||||
if(Helpers.GetDebug()) |
||||
SMX_Internal_OpenConsole(); |
||||
|
||||
CurrentSMXDevice.singleton = new CurrentSMXDevice(); |
||||
|
||||
// Load animations. |
||||
Helpers.LoadSavedPanelAnimations(); |
||||
|
||||
CreateTrayIcon(); |
||||
|
||||
// Create the main window. |
||||
if(!Helpers.LaunchedOnStartup()) |
||||
ToggleMainWindow(); |
||||
} |
||||
|
||||
// Open or close the main window. |
||||
// |
||||
// We don't create our UI until the first time it's opened, so we use |
||||
// less memory when we're launched on startup. However, when we're minimized |
||||
// back to the tray, we don't destroy the main window. WPF is just too |
||||
// leaky to recreate the main window each time it's called due to internal |
||||
// circular references. Instead, we just focus on minimizing CPU overhead. |
||||
void ToggleMainWindow() |
||||
{ |
||||
if(window == null) |
||||
{ |
||||
window = new MainWindow(); |
||||
window.Closed += MainWindowClosed; |
||||
window.Show(); |
||||
} |
||||
else if(IsMinimizedToTray()) |
||||
{ |
||||
window.Visibility = Visibility.Visible; |
||||
window.Activate(); |
||||
} |
||||
else |
||||
{ |
||||
MinimizeToTray(); |
||||
} |
||||
} |
||||
|
||||
public bool IsMinimizedToTray() |
||||
{ |
||||
return window.Visibility == Visibility.Collapsed; |
||||
} |
||||
|
||||
public void MinimizeToTray() |
||||
{ |
||||
// Just hide the window. Don't actually set the window to minimized, since it |
||||
// won't do anything and it causes problems when restoring the window. |
||||
window.Visibility = Visibility.Collapsed; |
||||
} |
||||
|
||||
public void BringToForeground() |
||||
{ |
||||
// Restore or create the window. Don't minimize if we're already restored. |
||||
if(window == null || IsMinimizedToTray()) |
||||
ToggleMainWindow(); |
||||
|
||||
// Focus the window. |
||||
window.WindowState = WindowState.Normal; |
||||
window.Activate(); |
||||
} |
||||
|
||||
private void MainWindowClosed(object sender, EventArgs e) |
||||
{ |
||||
window = null; |
||||
} |
||||
|
||||
private void UnhandledExceptionEventHandler(object sender, UnhandledExceptionEventArgs e) |
||||
{ |
||||
string message = e.ExceptionObject.ToString(); |
||||
MessageBox.Show("SMXConfig encountered an unexpected error:\n\n" + message, "SMXConfig"); |
||||
} |
||||
|
||||
protected override void OnExit(ExitEventArgs e) |
||||
{ |
||||
base.OnExit(e); |
||||
|
||||
Console.WriteLine("Application exiting"); |
||||
|
||||
// Remove the tray icon. |
||||
if(trayIcon != null) |
||||
{ |
||||
trayIcon.Visible = false; |
||||
trayIcon = null; |
||||
} |
||||
|
||||
// Shut down cleanly, to make sure we don't run any threaded callbacks during shutdown. |
||||
if(CurrentSMXDevice.singleton != null) |
||||
{ |
||||
CurrentSMXDevice.singleton.Shutdown(); |
||||
CurrentSMXDevice.singleton = null; |
||||
} |
||||
} |
||||
|
||||
// If another instance other than this one is running, send it WM_USER to tell it to |
||||
// foreground itself. Return true if another instance was found. |
||||
private bool ForegroundExistingInstance() |
||||
{ |
||||
bool createdNew = false; |
||||
EventWaitHandle SMXConfigEvent = new EventWaitHandle(false, EventResetMode.AutoReset, "SMXConfigEvent", out createdNew); |
||||
if(!createdNew) |
||||
{ |
||||
// Signal the event to foreground the existing instance. |
||||
SMXConfigEvent.Set(); |
||||
return true; |
||||
} |
||||
|
||||
ThreadPool.RegisterWaitForSingleObject(SMXConfigEvent, ForegroundApplicationCallback, this, Timeout.Infinite, false); |
||||
|
||||
return false; |
||||
} |
||||
|
||||
private static void ForegroundApplicationCallback(Object self, Boolean timedOut) |
||||
{ |
||||
// This is called when another instance sends us a message over SMXConfigEvent. |
||||
Application.Current.Dispatcher.Invoke(new Action(() => { |
||||
App application = (App) Application.Current; |
||||
application.BringToForeground(); |
||||
})); |
||||
} |
||||
|
||||
private void ListenForShutdownRequest() |
||||
{ |
||||
// We've already checked that we're the only instance when we get here, so this event shouldn't |
||||
// exist. If it already exists for some reason, we'll listen to it anyway. |
||||
EventWaitHandle SMXConfigShutdown = new EventWaitHandle(false, EventResetMode.AutoReset, "SMXConfigShutdown"); |
||||
ThreadPool.RegisterWaitForSingleObject(SMXConfigShutdown, ShutdownApplicationCallback, this, Timeout.Infinite, false); |
||||
} |
||||
|
||||
private static void ShutdownApplicationCallback(Object self, Boolean timedOut) |
||||
{ |
||||
// This is called when another instance sends us a message over SMXConfigShutdown. |
||||
Application.Current.Dispatcher.Invoke(new Action(() => { |
||||
App application = (App) Application.Current; |
||||
application.Shutdown(); |
||||
})); |
||||
} |
||||
|
||||
// Create a tray icon. For some reason there's no WPF interface for this, |
||||
// so we have to use Forms. |
||||
void CreateTrayIcon() |
||||
{ |
||||
Stream iconStream = GetResourceStream(new Uri( "pack://application:,,,/Resources/window%20icon%20grey.ico")).Stream; |
||||
System.Drawing.Icon icon = new System.Drawing.Icon(iconStream); |
||||
|
||||
trayIcon = new System.Windows.Forms.NotifyIcon(); |
||||
trayIcon.Text = "StepManiaX"; |
||||
trayIcon.Visible = true; |
||||
|
||||
// Show or hide the application window on click. |
||||
trayIcon.Click += delegate (object sender, EventArgs e) { ToggleMainWindow(); }; |
||||
trayIcon.DoubleClick += delegate (object sender, EventArgs e) { ToggleMainWindow(); }; |
||||
|
||||
CurrentSMXDevice.singleton.ConfigurationChanged += delegate(LoadFromConfigDelegateArgs args) { |
||||
RefreshTrayIcon(args); |
||||
}; |
||||
|
||||
// Do the initial refresh. |
||||
RefreshTrayIcon(CurrentSMXDevice.singleton.GetState(), true); |
||||
} |
||||
|
||||
// Refresh the tray icon when we're connected or disconnected. |
||||
bool wasConnected; |
||||
void RefreshTrayIcon(LoadFromConfigDelegateArgs args, bool force=false) |
||||
{ |
||||
if(trayIcon == null) |
||||
return; |
||||
|
||||
bool EitherControllerConnected = false; |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
if(args.controller[pad].info.connected) |
||||
EitherControllerConnected = true; |
||||
|
||||
// Skip the refresh if the connected state didn't change. |
||||
if(wasConnected == EitherControllerConnected && !force) |
||||
return; |
||||
wasConnected = EitherControllerConnected; |
||||
|
||||
trayIcon.Text = EitherControllerConnected? "StepManiaX (connected)":"StepManiaX (disconnected)"; |
||||
|
||||
// Set the tray icon. |
||||
string filename = EitherControllerConnected? "window%20icon.ico":"window%20icon%20grey.ico"; |
||||
Stream iconStream = GetResourceStream(new Uri( "pack://application:,,,/Resources/" + filename)).Stream; |
||||
trayIcon.Icon = new System.Drawing.Icon(iconStream); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,159 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
class ConfigPresets |
||||
{ |
||||
static private string[] Presets = { "low", "normal", "high" }; |
||||
|
||||
static public string GetPreset(SMX.SMXConfig config) |
||||
{ |
||||
// If the config we're comparing against is a V1 config, that means the per-panel thresholds |
||||
// weren't set and those fields are ignored (or not supported by) by the firmware. Sync those |
||||
// thresholds to the unified thresholds before comparing. That way, we'll correctly match up |
||||
// each preset regardless of what happens to be in the unused per-panel threshold fields. |
||||
// If we don't do this, we won't recognize that the default preset is active because unused |
||||
// fields won't match up. |
||||
if(config.configVersion == 0xFF || config.configVersion < 2) |
||||
SyncUnifiedThresholds(ref config); |
||||
|
||||
foreach(string Preset in Presets) |
||||
{ |
||||
SMX.SMXConfig PresetConfig = SMX.SMXConfig.Create(); |
||||
SetPreset(Preset, ref PresetConfig); |
||||
if(SamePreset(config, PresetConfig)) |
||||
return Preset; |
||||
} |
||||
return ""; |
||||
} |
||||
|
||||
// Return true if the config matches, only comparing values that we set in presets. |
||||
static private bool SamePreset(SMX.SMXConfig config1, SMX.SMXConfig config2) |
||||
{ |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
if(config1.panelSettings[panel].loadCellLowThreshold != config2.panelSettings[panel].loadCellLowThreshold || |
||||
config1.panelSettings[panel].loadCellHighThreshold != config2.panelSettings[panel].loadCellHighThreshold) |
||||
return false; |
||||
|
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
if(config1.panelSettings[panel].fsrLowThreshold[sensor] != config2.panelSettings[panel].fsrLowThreshold[sensor] || |
||||
config1.panelSettings[panel].fsrHighThreshold[sensor] != config2.panelSettings[panel].fsrHighThreshold[sensor]) |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
return true; |
||||
} |
||||
|
||||
static public void SetPreset(string name, ref SMX.SMXConfig config) |
||||
{ |
||||
switch(name) |
||||
{ |
||||
case "low": SetLowPreset(ref config); return; |
||||
case "normal": SetNormalPreset(ref config); return; |
||||
case "high": SetHighPreset(ref config); return; |
||||
} |
||||
} |
||||
|
||||
static private void SetPreset(ref SMX.SMXConfig config, |
||||
byte loadCellLow, byte loadCellHigh, byte loadCellLowCenter, byte loadCellHighCenter, |
||||
byte fsrLow, byte fsrHigh, byte fsrLowCenter, byte fsrHighCenter) |
||||
{ |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
config.panelSettings[panel].loadCellLowThreshold = loadCellLow; |
||||
config.panelSettings[panel].loadCellHighThreshold = loadCellHigh; |
||||
} |
||||
|
||||
// Center: |
||||
config.panelSettings[4].loadCellLowThreshold = loadCellLowCenter; |
||||
config.panelSettings[4].loadCellHighThreshold = loadCellHighCenter; |
||||
|
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
config.panelSettings[panel].fsrLowThreshold[sensor] = fsrLow; |
||||
config.panelSettings[panel].fsrHighThreshold[sensor] = fsrHigh; |
||||
} |
||||
} |
||||
|
||||
// Center: |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
config.panelSettings[4].fsrLowThreshold[sensor] = fsrLowCenter; |
||||
config.panelSettings[4].fsrHighThreshold[sensor] = fsrHighCenter; |
||||
} |
||||
} |
||||
|
||||
static private void SetHighPreset(ref SMX.SMXConfig config) |
||||
{ |
||||
SetPreset(ref config, |
||||
20, 25, 20, 30, |
||||
148, 150, 145, 160); |
||||
} |
||||
|
||||
static private void SetNormalPreset(ref SMX.SMXConfig config) |
||||
{ |
||||
SetPreset(ref config, |
||||
33, 42, 35, 60, |
||||
162, 175, 202, 225); |
||||
} |
||||
|
||||
static private void SetLowPreset(ref SMX.SMXConfig config) |
||||
{ |
||||
SetPreset(ref config, |
||||
70, 80, 100, 120, |
||||
200, 219, 212, 225); |
||||
} |
||||
|
||||
// Return the extra panels that the given panel's sensitivities control when |
||||
// advanced threshold mode is off. |
||||
static public List<int> GetPanelsToSyncUnifiedThresholds(int fromPanel) |
||||
{ |
||||
List<int> result = new List<int>(); |
||||
switch(fromPanel) |
||||
{ |
||||
case 7: // down (cardinal) |
||||
result.Add(3); // left |
||||
result.Add(5); // right |
||||
break; |
||||
case 2: // up-right (corners) |
||||
result.Add(0); // up-left |
||||
result.Add(6); // down-left |
||||
result.Add(8); // down-right |
||||
break; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
// The simplified configuration scheme sets thresholds for up, center, cardinal directions |
||||
// and corners. Rev1 firmware uses those only. Copy cardinal directions (down) to the |
||||
// other cardinal directions (except for up, which already had its own setting) and corners |
||||
// to the other corners. |
||||
static private void SyncUnifiedThresholds(ref SMX.SMXConfig config) |
||||
{ |
||||
for(int fromPanel = 0; fromPanel < 9; ++fromPanel) |
||||
{ |
||||
foreach(int toPanel in GetPanelsToSyncUnifiedThresholds(fromPanel)) |
||||
{ |
||||
config.panelSettings[toPanel].loadCellLowThreshold = config.panelSettings[fromPanel].loadCellLowThreshold; |
||||
config.panelSettings[toPanel].loadCellHighThreshold = config.panelSettings[fromPanel].loadCellHighThreshold; |
||||
|
||||
// Do the same for FSR thresholds. |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
config.panelSettings[toPanel].fsrLowThreshold[sensor] = config.panelSettings[fromPanel].fsrLowThreshold[sensor]; |
||||
config.panelSettings[toPanel].fsrHighThreshold[sensor] = config.panelSettings[fromPanel].fsrHighThreshold[sensor]; |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,283 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Windows; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
using System.Windows.Threading; |
||||
using System.Windows.Controls; |
||||
using System.ComponentModel; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
// The state and configuration of a pad. |
||||
public struct LoadFromConfigDelegateArgsPerController |
||||
{ |
||||
public SMX.SMXInfo info; |
||||
public SMX.SMXConfig config; |
||||
public SMX.SMXSensorTestModeData test_data; |
||||
|
||||
// The panels that are activated. Note that to receive notifications from OnConfigChange |
||||
// when inputs change state, set RefreshOnInputChange to true. Otherwise, this field will |
||||
// be filled in but notifications won't be sent due to only inputs changing. |
||||
public bool[] inputs; |
||||
} |
||||
|
||||
public struct LoadFromConfigDelegateArgs |
||||
{ |
||||
// This indicates which fields changed since the last call. |
||||
public bool ConnectionsChanged, ConfigurationChanged, InputChanged, TestDataChanged; |
||||
|
||||
// Data for each of two controllers: |
||||
public LoadFromConfigDelegateArgsPerController[] controller; |
||||
|
||||
// If we have more than one connected controller, we expect them to be the same version. |
||||
// Return the newest firmware version that's connected. |
||||
public int firmwareVersion() |
||||
{ |
||||
int result = 1; |
||||
foreach(var data in controller) |
||||
{ |
||||
if(data.info.connected && data.info.m_iFirmwareVersion > result) |
||||
result = data.info.m_iFirmwareVersion; |
||||
|
||||
} |
||||
return result; |
||||
} |
||||
|
||||
// The control that changed the configuration (passed to FireConfigurationChanged). |
||||
public object source; |
||||
}; |
||||
|
||||
// This class tracks the device we're currently configuring, and runs a callback when |
||||
// it changes. |
||||
class CurrentSMXDevice |
||||
{ |
||||
public static CurrentSMXDevice singleton; |
||||
|
||||
// This is fired when FireConfigurationChanged is called, and when the current device |
||||
// changes. |
||||
public delegate void ConfigurationChangedDelegate(LoadFromConfigDelegateArgs args); |
||||
public event ConfigurationChangedDelegate ConfigurationChanged; |
||||
|
||||
private bool[] WasConnected = new bool[2] { false, false }; |
||||
private bool[][] LastInputs = new bool[2][]; |
||||
private SMX.SMXSensorTestModeData[] LastTestData = new SMX.SMXSensorTestModeData[2]; |
||||
private Dispatcher MainDispatcher; |
||||
|
||||
public CurrentSMXDevice() |
||||
{ |
||||
// Grab the main thread's dispatcher, so we can invoke into it. |
||||
MainDispatcher = Dispatcher.CurrentDispatcher; |
||||
|
||||
// Set our update callback. This will be called when something happens: connection or disconnection, |
||||
// inputs changed, configuration updated, test data updated, etc. It doesn't specify what's changed, |
||||
// we simply check the whole state. |
||||
SMX.SMX.Start(delegate(int PadNumber, SMX.SMX.SMXUpdateCallbackReason reason) { |
||||
// Console.WriteLine("... " + reason); |
||||
// This is called from a thread, with SMX's internal mutex locked. We must not call into SMX |
||||
// or do anything with the UI from here. Just queue an update back into the UI thread. |
||||
MainDispatcher.InvokeAsync(delegate() { |
||||
switch(reason) |
||||
{ |
||||
case SMX.SMX.SMXUpdateCallbackReason.Updated: |
||||
CheckForChanges(); |
||||
break; |
||||
case SMX.SMX.SMXUpdateCallbackReason.FactoryResetCommandComplete: |
||||
Console.WriteLine("SMX_FactoryResetCommandComplete"); |
||||
FireConfigurationChanged(null); |
||||
break; |
||||
} |
||||
}); |
||||
}); |
||||
} |
||||
|
||||
public void Shutdown() |
||||
{ |
||||
SMX.SMX.Stop(); |
||||
} |
||||
|
||||
private void CheckForChanges() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = GetState(); |
||||
|
||||
// Mark which parts have changed. |
||||
// |
||||
// For configuration, we only check for connection state changes. Actual configuration |
||||
// changes are fired by controls via FireConfigurationChanged. |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
LoadFromConfigDelegateArgsPerController controller = args.controller[pad]; |
||||
if(WasConnected[pad] != controller.info.connected) |
||||
{ |
||||
args.ConfigurationChanged = true; |
||||
args.ConnectionsChanged = true; |
||||
WasConnected[pad] = controller.info.connected; |
||||
} |
||||
|
||||
if(LastInputs[pad] == null || !Enumerable.SequenceEqual(controller.inputs, LastInputs[pad])) |
||||
{ |
||||
args.InputChanged = true; |
||||
LastInputs[pad] = controller.inputs; |
||||
} |
||||
|
||||
if(!controller.test_data.Equals(LastTestData[pad])) |
||||
{ |
||||
args.TestDataChanged = true; |
||||
LastTestData[pad] = controller.test_data; |
||||
} |
||||
} |
||||
|
||||
// Only fire the delegate if something has actually changed. |
||||
if(args.ConfigurationChanged || args.InputChanged || args.TestDataChanged) |
||||
ConfigurationChanged?.Invoke(args); |
||||
} |
||||
|
||||
public void FireConfigurationChanged(object source) |
||||
{ |
||||
LoadFromConfigDelegateArgs args = GetState(); |
||||
args.ConfigurationChanged = true; |
||||
args.source = source; |
||||
ConfigurationChanged?.Invoke(args); |
||||
} |
||||
|
||||
public LoadFromConfigDelegateArgs GetState() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = new LoadFromConfigDelegateArgs(); |
||||
args.controller = new LoadFromConfigDelegateArgsPerController[2]; |
||||
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
LoadFromConfigDelegateArgsPerController controller; |
||||
controller.test_data = new SMX.SMXSensorTestModeData(); |
||||
|
||||
// Expand the inputs mask to an array. |
||||
UInt16 Inputs = SMX.SMX.GetInputState(pad); |
||||
controller.inputs = new bool[9]; |
||||
for(int i = 0; i < 9; ++i) |
||||
controller.inputs[i] = (Inputs & (1 << i)) != 0; |
||||
SMX.SMX.GetInfo(pad, out controller.info); |
||||
SMX.SMX.GetConfig(pad, out controller.config); |
||||
SMX.SMX.GetTestData(pad, out controller.test_data); |
||||
args.controller[pad] = controller; |
||||
} |
||||
|
||||
return args; |
||||
} |
||||
|
||||
} |
||||
|
||||
// Call a delegate on configuration change. Configuration changes are notified by calling |
||||
// FireConfigurationChanged. Listeners won't receive notifications for changes that they |
||||
// fired themselves. |
||||
public class OnConfigChange |
||||
{ |
||||
public delegate void LoadFromConfigDelegate(LoadFromConfigDelegateArgs args); |
||||
private readonly Control Owner; |
||||
private readonly LoadFromConfigDelegate Callback; |
||||
private bool _RefreshOnInputChange = false; |
||||
|
||||
// If set to true, the callback will be invoked on input changes in addition to configuration |
||||
// changes. This can cause the callback to be run at any time, such as while the user is |
||||
// interacting with the control. |
||||
public bool RefreshOnInputChange { |
||||
get { return _RefreshOnInputChange; } |
||||
set {_RefreshOnInputChange = value; } |
||||
} |
||||
|
||||
private bool _RefreshOnTestDataChange = false; |
||||
|
||||
// Like RefreshOnInputChange, but enables callbacks when test data changes. |
||||
public bool RefreshOnTestDataChange { |
||||
get { return _RefreshOnTestDataChange; } |
||||
set { _RefreshOnTestDataChange = value; } |
||||
} |
||||
|
||||
// Owner is the Control that we're calling. This callback will be disable when the |
||||
// control is unloaded, and we won't call it if it's the same control that fired |
||||
// the change via FireConfigurationChanged. |
||||
// |
||||
// In addition, the callback is called when the control is Loaded, to load the initial |
||||
// state. |
||||
public OnConfigChange(Control owner, LoadFromConfigDelegate callback) |
||||
{ |
||||
Owner = owner; |
||||
Callback = callback; |
||||
|
||||
Owner.Loaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
CurrentSMXDevice.singleton.ConfigurationChanged += ConfigurationChanged; |
||||
Refresh(); |
||||
}; |
||||
|
||||
Owner.Unloaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
CurrentSMXDevice.singleton.ConfigurationChanged -= ConfigurationChanged; |
||||
}; |
||||
} |
||||
|
||||
private void ConfigurationChanged(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
if(args.ConfigurationChanged || |
||||
(RefreshOnInputChange && args.InputChanged) || |
||||
(RefreshOnTestDataChange && args.TestDataChanged)) |
||||
{ |
||||
Callback(args); |
||||
} |
||||
} |
||||
|
||||
private void Refresh() |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
Callback(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
}; |
||||
|
||||
|
||||
public class OnInputChange |
||||
{ |
||||
public delegate void LoadFromConfigDelegate(LoadFromConfigDelegateArgs args); |
||||
private readonly Control Owner; |
||||
private readonly LoadFromConfigDelegate Callback; |
||||
|
||||
// Owner is the Control that we're calling. This callback will be disable when the |
||||
// control is unloaded, and we won't call it if it's the same control that fired |
||||
// the change via FireConfigurationChanged. |
||||
// |
||||
// In addition, the callback is called when the control is Loaded, to load the initial |
||||
// state. |
||||
public OnInputChange(Control owner, LoadFromConfigDelegate callback) |
||||
{ |
||||
Owner = owner; |
||||
Callback = callback; |
||||
|
||||
// This is available when the application is running, but will be null in the XAML designer. |
||||
if(CurrentSMXDevice.singleton == null) |
||||
return; |
||||
|
||||
Owner.Loaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
CurrentSMXDevice.singleton.ConfigurationChanged += ConfigurationChanged; |
||||
Refresh(); |
||||
}; |
||||
|
||||
Owner.Unloaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
CurrentSMXDevice.singleton.ConfigurationChanged -= ConfigurationChanged; |
||||
}; |
||||
} |
||||
|
||||
private void ConfigurationChanged(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
Callback(args); |
||||
} |
||||
|
||||
private void Refresh() |
||||
{ |
||||
if(CurrentSMXDevice.singleton != null) |
||||
Callback(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
}; |
||||
} |
||||
@ -0,0 +1,403 @@ |
||||
using System; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Media; |
||||
using System.Windows.Shapes; |
||||
using System.Windows.Input; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public class DiagnosticsPanelButton: PanelSelectButton |
||||
{ |
||||
public static readonly DependencyProperty PanelProperty = DependencyProperty.RegisterAttached("Panel", |
||||
typeof(int), typeof(PanelSelectButton), new FrameworkPropertyMetadata(0)); |
||||
|
||||
public int Panel { |
||||
get { return (int) this.GetValue(PanelProperty); } |
||||
set { this.SetValue(PanelProperty, value); } |
||||
} |
||||
// Which panel is currently selected. |
||||
public static readonly DependencyProperty SelectedPanelProperty = DependencyProperty.RegisterAttached("SelectedPanel", |
||||
typeof(int), typeof(PanelSelectButton), new FrameworkPropertyMetadata(0)); |
||||
|
||||
public int SelectedPanel { |
||||
get { return (int) this.GetValue(SelectedPanelProperty); } |
||||
set { this.SetValue(SelectedPanelProperty, value); } |
||||
} |
||||
|
||||
// True if this panel is being pressed. |
||||
public static readonly DependencyProperty PressedProperty = DependencyProperty.Register("Pressed", |
||||
typeof(bool), typeof(DiagnosticsPanelButton), new FrameworkPropertyMetadata(false)); |
||||
|
||||
public bool Pressed { |
||||
get { return (bool) GetValue(PressedProperty); } |
||||
set { SetValue(PressedProperty, value); } |
||||
} |
||||
|
||||
// True if a warning icon should be displayed for this panel. |
||||
public static readonly DependencyProperty WarningProperty = DependencyProperty.Register("Warning", |
||||
typeof(bool), typeof(DiagnosticsPanelButton), new FrameworkPropertyMetadata(false)); |
||||
|
||||
public bool Warning { |
||||
get { return (bool) GetValue(WarningProperty); } |
||||
set { SetValue(WarningProperty, value); } |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
OnConfigChange onConfigChange; |
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) { |
||||
int SelectedPad = Panel < 9? 0:1; |
||||
int PanelIndex = Panel % 9; |
||||
Pressed = args.controller[SelectedPad].inputs[PanelIndex]; |
||||
|
||||
Warning = !args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex] || |
||||
args.controller[SelectedPad].test_data.AnySensorsOnPanelNotResponding(PanelIndex) || |
||||
args.controller[SelectedPad].test_data.AnyBadJumpersOnPanel(PanelIndex); |
||||
|
||||
// Only show this panel button if the panel's input is enabled. |
||||
SMX.SMXConfig config = ActivePad.GetFirstActivePadConfig(args); |
||||
Visibility = ShouldBeDisplayed(config)? Visibility.Visible:Visibility.Collapsed; |
||||
}); |
||||
onConfigChange.RefreshOnInputChange = true; |
||||
onConfigChange.RefreshOnTestDataChange = true; |
||||
} |
||||
|
||||
protected override void OnClick() |
||||
{ |
||||
base.OnClick(); |
||||
|
||||
// Select this panel. |
||||
SelectedPanel = Panel; |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(this); |
||||
} |
||||
|
||||
// Return true if this button should be displayed. |
||||
private bool ShouldBeDisplayed(SMX.SMXConfig config) |
||||
{ |
||||
bool[] enabledPanels = config.GetEnabledPanels(); |
||||
int PanelIndex = Panel % 9; |
||||
return enabledPanels[PanelIndex]; |
||||
} |
||||
} |
||||
|
||||
public class LevelBar: Control |
||||
{ |
||||
public static readonly DependencyProperty ValueProperty = DependencyProperty.Register("Value", |
||||
typeof(double), typeof(LevelBar), new FrameworkPropertyMetadata(0.5, ValueChangedCallback)); |
||||
|
||||
public double Value { |
||||
get { return (double) GetValue(ValueProperty); } |
||||
set { SetValue(ValueProperty, value); } |
||||
} |
||||
|
||||
public static readonly DependencyProperty ErrorProperty = DependencyProperty.Register("Error", |
||||
typeof(bool), typeof(LevelBar), new FrameworkPropertyMetadata(false, ValueChangedCallback)); |
||||
|
||||
public bool Error { |
||||
get { return (bool) GetValue(ErrorProperty); } |
||||
set { SetValue(ErrorProperty, value); } |
||||
} |
||||
|
||||
private Rectangle Fill, Back; |
||||
|
||||
private static void ValueChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args) |
||||
{ |
||||
LevelBar self = target as LevelBar; |
||||
self.Refresh(); |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
Fill = Template.FindName("Fill", this) as Rectangle; |
||||
Back = Template.FindName("Back", this) as Rectangle; |
||||
Refresh(); |
||||
} |
||||
|
||||
private void Refresh() |
||||
{ |
||||
// If Error is true, fill the bar red. |
||||
double FillHeight = Error? 1:Value; |
||||
Fill.Height = Math.Round(Math.Max(FillHeight, 0) * (Back.Height - 2)); |
||||
|
||||
if(Error) |
||||
{ |
||||
Fill.Fill = new SolidColorBrush(Color.FromRgb(255,0,0)); |
||||
} |
||||
else |
||||
{ |
||||
// Scale from green (#FF0000) to yellow (#FFFF00) as we go from 0 to .4. |
||||
double ColorValue = Value / 0.4; |
||||
Byte Yellow = (Byte) (Math.Max(0, Math.Min(255, ColorValue * 255)) ); |
||||
Fill.Fill = new SolidColorBrush(Color.FromRgb(255,Yellow,0)); |
||||
} |
||||
} |
||||
} |
||||
|
||||
public class DiagnosticsControl: Control |
||||
{ |
||||
// Which panel is currently selected: |
||||
public static readonly DependencyProperty SelectedPanelProperty = DependencyProperty.Register("SelectedPanel", |
||||
typeof(int), typeof(DiagnosticsControl), new FrameworkPropertyMetadata(0)); |
||||
|
||||
public int SelectedPanel { |
||||
get { return (int) this.GetValue(SelectedPanelProperty); } |
||||
set { this.SetValue(SelectedPanelProperty, value); } |
||||
} |
||||
|
||||
private LevelBar[] LevelBars; |
||||
private Label[] LevelBarText; |
||||
private ComboBox DiagnosticMode; |
||||
private Panel CurrentDIPGroup; |
||||
private FrameImage CurrentDIP; |
||||
private FrameImage ExpectedDIP; |
||||
private FrameworkElement NoResponseFromPanel; |
||||
private FrameworkElement NoResponseFromSensors; |
||||
private FrameworkElement BadSensorDIPSwitches; |
||||
private FrameworkElement P1Diagnostics, P2Diagnostics; |
||||
private FrameworkElement DIPLabelLeft, DIPLabelRight; |
||||
|
||||
public delegate void ShowAllLightsEvent(bool on); |
||||
public event ShowAllLightsEvent SetShowAllLights; |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
LevelBars = new LevelBar[4]; |
||||
LevelBars[0] = Template.FindName("SensorBar1", this) as LevelBar; |
||||
LevelBars[1] = Template.FindName("SensorBar2", this) as LevelBar; |
||||
LevelBars[2] = Template.FindName("SensorBar3", this) as LevelBar; |
||||
LevelBars[3] = Template.FindName("SensorBar4", this) as LevelBar; |
||||
|
||||
LevelBarText = new Label[4]; |
||||
LevelBarText[0] = Template.FindName("SensorBarLevel1", this) as Label; |
||||
LevelBarText[1] = Template.FindName("SensorBarLevel2", this) as Label; |
||||
LevelBarText[2] = Template.FindName("SensorBarLevel3", this) as Label; |
||||
LevelBarText[3] = Template.FindName("SensorBarLevel4", this) as Label; |
||||
|
||||
DiagnosticMode = Template.FindName("DiagnosticMode", this) as ComboBox; |
||||
CurrentDIPGroup = Template.FindName("CurrentDIPGroup", this) as Panel; |
||||
CurrentDIP = Template.FindName("CurrentDIP", this) as FrameImage; |
||||
ExpectedDIP = Template.FindName("ExpectedDIP", this) as FrameImage; |
||||
NoResponseFromPanel = Template.FindName("NoResponseFromPanel", this) as FrameworkElement; |
||||
NoResponseFromSensors = Template.FindName("NoResponseFromSensors", this) as FrameworkElement; |
||||
BadSensorDIPSwitches = Template.FindName("BadSensorDIPSwitches", this) as FrameworkElement; |
||||
P1Diagnostics = Template.FindName("P1Diagnostics", this) as FrameworkElement; |
||||
P2Diagnostics = Template.FindName("P2Diagnostics", this) as FrameworkElement; |
||||
|
||||
DIPLabelRight = Template.FindName("DIPLabelRight", this) as FrameworkElement; |
||||
DIPLabelLeft = Template.FindName("DIPLabelLeft", this) as FrameworkElement; |
||||
|
||||
Button Recalibrate = Template.FindName("Recalibrate", this) as Button; |
||||
Recalibrate.Click += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.ForceRecalibration(pad); |
||||
}; |
||||
|
||||
// Note that we won't get a MouseUp if the display is hidden due to a controller |
||||
// disconnection while the mouse is held. We handle this in Refresh(). |
||||
Button LightAll = Template.FindName("LightAll", this) as Button; |
||||
LightAll.PreviewMouseDown += delegate(object sender, MouseButtonEventArgs e) |
||||
{ |
||||
SetShowAllLights?.Invoke(true); |
||||
}; |
||||
LightAll.PreviewMouseUp += delegate(object sender, MouseButtonEventArgs e) |
||||
{ |
||||
SetShowAllLights?.Invoke(false); |
||||
}; |
||||
|
||||
// Update the test mode when the dropdown is changed. |
||||
DiagnosticMode.AddHandler(ComboBox.SelectionChangedEvent, new RoutedEventHandler(delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.SetSensorTestMode(pad, GetTestMode()); |
||||
})); |
||||
|
||||
OnConfigChange onConfigChange; |
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) { |
||||
Refresh(args); |
||||
}); |
||||
onConfigChange.RefreshOnTestDataChange = true; |
||||
|
||||
Loaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.SetSensorTestMode(pad, GetTestMode()); |
||||
}; |
||||
|
||||
Unloaded += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
SMX.SMX.SetSensorTestMode(pad, SMX.SMX.SensorTestMode.Off); |
||||
}; |
||||
} |
||||
|
||||
private SMX.SMX.SensorTestMode GetTestMode() |
||||
{ |
||||
switch(DiagnosticMode.SelectedIndex) |
||||
{ |
||||
case 0: return SMX.SMX.SensorTestMode.CalibratedValues; |
||||
case 1: return SMX.SMX.SensorTestMode.UncalibratedValues; |
||||
case 2: return SMX.SMX.SensorTestMode.Noise; |
||||
case 3: |
||||
default: return SMX.SMX.SensorTestMode.Tare; |
||||
} |
||||
} |
||||
|
||||
private void Refresh(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
// First, make sure a valid panel is selected. |
||||
SMX.SMXConfig config = ActivePad.GetFirstActivePadConfig(args); |
||||
SelectValidPanel(config); |
||||
|
||||
RefreshSelectedPanel(); |
||||
|
||||
// Make sure SetShowAllLights is disabled if the controller is disconnected, since |
||||
// we can miss mouse up events. |
||||
bool EitherControllerConnected = args.controller[0].info.connected || args.controller[1].info.connected; |
||||
if(!EitherControllerConnected) |
||||
SetShowAllLights?.Invoke(false); |
||||
|
||||
P1Diagnostics.Visibility = args.controller[0].info.connected? Visibility.Visible:Visibility.Collapsed; |
||||
P2Diagnostics.Visibility = args.controller[1].info.connected? Visibility.Visible:Visibility.Collapsed; |
||||
|
||||
// Update the displayed DIP switch icons. |
||||
int SelectedPad = SelectedPanel < 9? 0:1; |
||||
int PanelIndex = SelectedPanel % 9; |
||||
int dip = args.controller[SelectedPad].test_data.iDIPSwitchPerPanel[PanelIndex]; |
||||
CurrentDIP.Frame = dip; |
||||
ExpectedDIP.Frame = PanelIndex; |
||||
|
||||
// Show or hide the sensor error text. |
||||
bool AnySensorsNotResponding = false, HaveIncorrectSensorDIP = false; |
||||
if(args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex]) |
||||
{ |
||||
AnySensorsNotResponding = args.controller[SelectedPad].test_data.AnySensorsOnPanelNotResponding(PanelIndex); |
||||
|
||||
// Don't show both warnings. |
||||
HaveIncorrectSensorDIP = !AnySensorsNotResponding && args.controller[SelectedPad].test_data.AnyBadJumpersOnPanel(PanelIndex); |
||||
} |
||||
NoResponseFromSensors.Visibility = AnySensorsNotResponding? Visibility.Visible:Visibility.Collapsed; |
||||
BadSensorDIPSwitches.Visibility = HaveIncorrectSensorDIP? Visibility.Visible:Visibility.Collapsed; |
||||
|
||||
// Adjust the DIP labels to match the PCB. |
||||
bool DIPLabelsOnLeft = config.masterVersion < 4; |
||||
DIPLabelRight.Visibility = DIPLabelsOnLeft? Visibility.Collapsed:Visibility.Visible; |
||||
DIPLabelLeft.Visibility = DIPLabelsOnLeft? Visibility.Visible:Visibility.Collapsed; |
||||
|
||||
// Update the level bar from the test mode data for the selected panel. |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
var controllerData = args.controller[SelectedPad]; |
||||
Int16 value = controllerData.test_data.sensorLevel[PanelIndex*4+sensor]; |
||||
|
||||
if(GetTestMode() == SMX.SMX.SensorTestMode.Noise) |
||||
{ |
||||
// In noise mode, we receive standard deviation values squared. Display the square |
||||
// root, since the panels don't do this for us. This makes the numbers different |
||||
// than the configured value (square it to convert back), but without this we display |
||||
// a bunch of 4 and 5-digit numbers that are too hard to read. |
||||
value = (Int16) Math.Sqrt(value); |
||||
} |
||||
|
||||
LevelBarText[sensor].Visibility = Visibility.Visible; |
||||
if(!args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex]) |
||||
{ |
||||
LevelBars[sensor].Value = 0; |
||||
LevelBarText[sensor].Visibility = Visibility.Hidden; |
||||
LevelBarText[sensor].Content = "-"; |
||||
LevelBars[sensor].Error = false; |
||||
} |
||||
else if(args.controller[SelectedPad].test_data.bBadSensorInput[PanelIndex*4+sensor]) |
||||
{ |
||||
LevelBars[sensor].Value = 0; |
||||
LevelBarText[sensor].Content = "!"; |
||||
LevelBars[sensor].Error = true; |
||||
} |
||||
else |
||||
{ |
||||
// Very slightly negative values happen due to noise. They don't indicate a |
||||
// problem, but they're confusing in the UI, so clamp them away. |
||||
if(value < 0 && value >= -10) |
||||
value = 0; |
||||
|
||||
// Scale differently depending on if this is an FSR panel or a load cell panel. |
||||
bool isFSR = controllerData.config.masterVersion >= 4 && (controllerData.config.configFlags & SMX.SMXConfigFlags.PlatformFlags_FSR) != 0; |
||||
if(isFSR) |
||||
value >>= 2; |
||||
float maxValue = isFSR? 250:500; |
||||
LevelBars[sensor].Value = value / maxValue; |
||||
LevelBarText[sensor].Content = value; |
||||
LevelBars[sensor].Error = false; |
||||
} |
||||
} |
||||
|
||||
NoResponseFromPanel.Visibility = Visibility.Collapsed; |
||||
CurrentDIPGroup.Visibility = Visibility.Visible; |
||||
if(!args.controller[SelectedPad].test_data.bHaveDataFromPanel[PanelIndex]) |
||||
{ |
||||
NoResponseFromPanel.Visibility = Visibility.Visible; |
||||
NoResponseFromSensors.Visibility = Visibility.Collapsed; |
||||
CurrentDIPGroup.Visibility = Visibility.Hidden; |
||||
return; |
||||
} |
||||
|
||||
} |
||||
|
||||
// If the selected panel isn't enabled for input, select another one. |
||||
private void SelectValidPanel(SMX.SMXConfig config) |
||||
{ |
||||
bool[] enabledPanels = config.GetEnabledPanels(); |
||||
int SelectedPanelIndex = SelectedPanel % 9; |
||||
|
||||
// If we're not selected, or this button is visible, we don't need to do anything. |
||||
if(!enabledPanels[SelectedPanelIndex]) |
||||
SelectedPanel = config.GetFirstEnabledPanel(); |
||||
} |
||||
|
||||
// Update the selected diagnostics button based on the value of selectedButton. |
||||
private void RefreshSelectedPanel() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = CurrentSMXDevice.singleton.GetState(); |
||||
|
||||
DiagnosticsPanelButton[] buttons = getPanelSelectionButtons(); |
||||
|
||||
// Tell the buttons which one is selected. |
||||
foreach(DiagnosticsPanelButton button in buttons) |
||||
button.IsSelected = button.Panel == SelectedPanel; |
||||
} |
||||
|
||||
// Return all panel selection buttons. |
||||
DiagnosticsPanelButton[] getPanelSelectionButtons() |
||||
{ |
||||
DiagnosticsPanelButton[] result = new DiagnosticsPanelButton[18]; |
||||
for(int i = 0; i < 18; ++i) |
||||
{ |
||||
result[i] = Template.FindName("Panel" + i, this) as DiagnosticsPanelButton; |
||||
} |
||||
return result; |
||||
} |
||||
} |
||||
|
||||
public class PanelTestModeCheckbox: CheckBox |
||||
{ |
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
} |
||||
|
||||
protected override void OnClick() |
||||
{ |
||||
base.OnClick(); |
||||
|
||||
SMX.SMX.SetPanelTestMode((bool) IsChecked? SMX.SMX.PanelTestMode.PressureTest:SMX.SMX.PanelTestMode.Off); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,222 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.ComponentModel; |
||||
using System.Linq; |
||||
using System.Text; |
||||
using System.Threading.Tasks; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Controls.Primitives; |
||||
using System.Windows.Input; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
// A slider with two handles, and a handle connecting them. Dragging the handle drags both |
||||
// of the sliders. |
||||
class DoubleSlider: Control |
||||
{ |
||||
public delegate void ValueChangedDelegate(DoubleSlider slider); |
||||
public event ValueChangedDelegate ValueChanged; |
||||
|
||||
// The minimum value for either knob. |
||||
public static readonly DependencyProperty MinimumProperty = DependencyProperty.Register("Minimum", |
||||
typeof(double), typeof(DoubleSlider), new FrameworkPropertyMetadata(0.0)); |
||||
|
||||
public double Minimum { |
||||
get { return (double) GetValue(MinimumProperty); } |
||||
set { SetValue(MinimumProperty, value); } |
||||
} |
||||
|
||||
// The maximum value for either knob. |
||||
public static readonly DependencyProperty MaximumProperty = DependencyProperty.Register("Maximum", |
||||
typeof(double), typeof(DoubleSlider), new FrameworkPropertyMetadata(20.0)); |
||||
|
||||
public double Maximum { |
||||
get { return (double) GetValue(MaximumProperty); } |
||||
set { SetValue(MaximumProperty, value); } |
||||
} |
||||
|
||||
// The minimum distance between the two values. |
||||
public static readonly DependencyProperty MinimumDistanceProperty = DependencyProperty.Register("MinimumDistance", |
||||
typeof(double), typeof(DoubleSlider), new FrameworkPropertyMetadata(0.0)); |
||||
|
||||
public double MinimumDistance { |
||||
get { return (double) GetValue(MinimumDistanceProperty); } |
||||
set { SetValue(MinimumDistanceProperty, value); } |
||||
} |
||||
|
||||
// Clamp value between minimum and maximum. |
||||
private double CoerceValueToLimits(double value) |
||||
{ |
||||
return Math.Min(Math.Max(value, Minimum), Maximum); |
||||
} |
||||
|
||||
// Note that we only clamp LowerValue and UpperValue to the min/max values. We don't |
||||
// clamp them to each other or to MinimumDistance here, since that complicates setting |
||||
// properties a lot. We only clamp to those when the user manipulates the control, not |
||||
// when we set values directly. |
||||
private static object LowerValueCoerceValueCallback(DependencyObject target, object valueObject) |
||||
{ |
||||
DoubleSlider slider = target as DoubleSlider; |
||||
double value = (double)valueObject; |
||||
value = slider.CoerceValueToLimits(value); |
||||
return value; |
||||
} |
||||
|
||||
private static object UpperValueCoerceValueCallback(DependencyObject target, object valueObject) |
||||
{ |
||||
DoubleSlider slider = target as DoubleSlider; |
||||
double value = (double)valueObject; |
||||
value = slider.CoerceValueToLimits(value); |
||||
return value; |
||||
} |
||||
|
||||
private static void SliderValueChangedCallback(DependencyObject target, DependencyPropertyChangedEventArgs args) |
||||
{ |
||||
DoubleSlider slider = target as DoubleSlider; |
||||
if(slider.ValueChanged != null) |
||||
slider.ValueChanged.Invoke(slider); |
||||
} |
||||
|
||||
public static readonly DependencyProperty LowerValueProperty = DependencyProperty.Register("LowerValue", |
||||
typeof(double), typeof(DoubleSlider), |
||||
new FrameworkPropertyMetadata(10.0, FrameworkPropertyMetadataOptions.AffectsArrange, SliderValueChangedCallback, LowerValueCoerceValueCallback)); |
||||
|
||||
public double LowerValue { |
||||
get { return (double) GetValue(LowerValueProperty); } |
||||
set { SetValue(LowerValueProperty, value); } |
||||
} |
||||
|
||||
public static readonly DependencyProperty UpperValueProperty = DependencyProperty.Register("UpperValue", |
||||
typeof(double), typeof(DoubleSlider), |
||||
new FrameworkPropertyMetadata(15.0, FrameworkPropertyMetadataOptions.AffectsArrange, SliderValueChangedCallback, UpperValueCoerceValueCallback)); |
||||
|
||||
public double UpperValue { |
||||
get { return (double) GetValue(UpperValueProperty); } |
||||
set { SetValue(UpperValueProperty, value); } |
||||
} |
||||
|
||||
private Thumb Middle; |
||||
|
||||
Thumb UpperThumb; |
||||
Thumb LowerThumb; |
||||
|
||||
private RepeatButton DecreaseButton; |
||||
private RepeatButton IncreaseButton; |
||||
|
||||
protected override Size ArrangeOverride(Size arrangeSize) |
||||
{ |
||||
arrangeSize = base.ArrangeOverride(arrangeSize); |
||||
|
||||
// Figure out the X position of the upper and lower thumbs. Note that we have to provide |
||||
// our width to GetValueToSize, since ActualWidth isn't available yet. |
||||
double valueToSize = GetValueToSize(arrangeSize.Width); |
||||
double UpperPointX = (UpperValue-Minimum) * valueToSize; |
||||
double LowerPointX = (LowerValue-Minimum) * valueToSize; |
||||
|
||||
// Move the upper and lower handles out by this much, and extend this middle. This |
||||
// makes the middle handle bigger. |
||||
double OffsetOutwards = 5; |
||||
Middle.Arrange(new Rect(LowerPointX-OffsetOutwards-1, 0, |
||||
Math.Max(1, UpperPointX-LowerPointX+OffsetOutwards*2+2), arrangeSize.Height)); |
||||
|
||||
// Right-align the lower thumb and left-align the upper thumb. |
||||
LowerThumb.Arrange(new Rect(LowerPointX-LowerThumb.Width-OffsetOutwards, 0, LowerThumb.Width, arrangeSize.Height)); |
||||
UpperThumb.Arrange(new Rect(UpperPointX +OffsetOutwards, 0, UpperThumb.Width, arrangeSize.Height)); |
||||
|
||||
DecreaseButton.Arrange(new Rect(0, 0, Math.Max(1, LowerPointX), Math.Max(1, arrangeSize.Height))); |
||||
IncreaseButton.Arrange(new Rect(UpperPointX, 0, Math.Max(1, arrangeSize.Width - UpperPointX), arrangeSize.Height)); |
||||
return arrangeSize; |
||||
} |
||||
|
||||
private void MoveValue(double delta) |
||||
{ |
||||
if(delta > 0) |
||||
{ |
||||
// If this increase will be clamped when changing the upper value, reduce it |
||||
// so it clamps the lower value too. This way, the distance between the upper |
||||
// and lower value stays the same. |
||||
delta = Math.Min(delta, Maximum - UpperValue); |
||||
UpperValue += delta; |
||||
LowerValue += delta; |
||||
} |
||||
else |
||||
{ |
||||
delta *= -1; |
||||
delta = Math.Min(delta, LowerValue - Minimum); |
||||
LowerValue -= delta; |
||||
UpperValue -= delta; |
||||
} |
||||
} |
||||
|
||||
private double GetValueToSize() |
||||
{ |
||||
return GetValueToSize(this.ActualWidth); |
||||
} |
||||
|
||||
private double GetValueToSize(double width) |
||||
{ |
||||
double Range = Maximum - Minimum; |
||||
return Math.Max(0.0, (width - UpperThumb.RenderSize.Width) / Range); |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
LowerThumb = GetTemplateChild("PART_LowerThumb") as Thumb; |
||||
UpperThumb = GetTemplateChild("PART_UpperThumb") as Thumb; |
||||
Middle = GetTemplateChild("PART_Middle") as Thumb; |
||||
DecreaseButton = GetTemplateChild("PART_DecreaseButton") as RepeatButton; |
||||
IncreaseButton = GetTemplateChild("PART_IncreaseButton") as RepeatButton; |
||||
DecreaseButton.Click += delegate(object sender, RoutedEventArgs e) { MoveValue(-1); }; |
||||
IncreaseButton.Click += delegate(object sender, RoutedEventArgs e) { MoveValue(+1); }; |
||||
|
||||
LowerThumb.DragDelta += delegate(object sender, DragDeltaEventArgs e) |
||||
{ |
||||
double sizeToValue = 1 / GetValueToSize(); |
||||
|
||||
double NewValue = LowerValue + e.HorizontalChange * sizeToValue; |
||||
NewValue = Math.Min(NewValue, UpperValue - MinimumDistance); |
||||
LowerValue = NewValue; |
||||
}; |
||||
|
||||
UpperThumb.DragDelta += delegate(object sender, DragDeltaEventArgs e) |
||||
{ |
||||
double sizeToValue = 1 / GetValueToSize(); |
||||
double NewValue = UpperValue + e.HorizontalChange * sizeToValue; |
||||
NewValue = Math.Max(NewValue, LowerValue + MinimumDistance); |
||||
UpperValue = NewValue; |
||||
}; |
||||
|
||||
Middle.DragDelta += delegate(object sender, DragDeltaEventArgs e) |
||||
{ |
||||
// Convert the pixel delta to a value change. |
||||
double sizeToValue = 1 / GetValueToSize(); |
||||
Console.WriteLine("drag: " + e.HorizontalChange + ", " + sizeToValue + ", " + e.HorizontalChange * sizeToValue); |
||||
MoveValue(e.HorizontalChange * sizeToValue); |
||||
}; |
||||
|
||||
InvalidateArrange(); |
||||
} |
||||
} |
||||
|
||||
class DoubleSliderThumb: Thumb |
||||
{ |
||||
public static readonly DependencyProperty ShowUpArrowProperty = DependencyProperty.Register("ShowUpArrow", |
||||
typeof(bool), typeof(DoubleSliderThumb)); |
||||
|
||||
public bool ShowUpArrow { |
||||
get { return (bool) this.GetValue(ShowUpArrowProperty); } |
||||
set { this.SetValue(ShowUpArrowProperty, value); } |
||||
} |
||||
|
||||
public static readonly DependencyProperty ShowDownArrowProperty = DependencyProperty.Register("ShowDownArrow", |
||||
typeof(bool), typeof(DoubleSliderThumb)); |
||||
|
||||
public bool ShowDownArrow { |
||||
get { return (bool) this.GetValue(ShowDownArrowProperty); } |
||||
set { this.SetValue(ShowDownArrowProperty, value); } |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,984 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.IO; |
||||
using System.Linq; |
||||
using System.Runtime.InteropServices; |
||||
using System.Runtime.Serialization.Formatters.Binary; |
||||
using System.Windows; |
||||
using System.Windows.Media; |
||||
using System.Windows.Resources; |
||||
using System.Windows.Threading; |
||||
using SMXJSON; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
// Track whether we're configuring one pad or both at once. |
||||
static class ActivePad |
||||
{ |
||||
public enum SelectedPad { |
||||
P1, |
||||
P2, |
||||
Both, |
||||
}; |
||||
|
||||
// The actual pad selection. This defaults to both, and doesn't change if |
||||
// only one pad is selected. We don't actually show "both" in the dropdown |
||||
// unless two pads are connected, but the underlying setting remains. |
||||
public static SelectedPad selectedPad = SelectedPad.Both; |
||||
|
||||
// A shortcut for when a LoadFromConfigDelegateArgs isn't available: |
||||
public static IEnumerable<Tuple<int, SMX.SMXConfig>> ActivePads() |
||||
{ |
||||
// In case we're called in design mode, just return an empty list. |
||||
if(CurrentSMXDevice.singleton == null) |
||||
return new List<Tuple<int, SMX.SMXConfig>>(); |
||||
|
||||
return ActivePads(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
|
||||
// Yield each connected pad which is currently active for configuration. |
||||
public static IEnumerable<Tuple<int, SMX.SMXConfig>> ActivePads(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
bool Pad1Connected = args.controller[0].info.connected; |
||||
bool Pad2Connected = args.controller[1].info.connected; |
||||
|
||||
// If both pads are connected and a single pad is selected, ignore the deselected pad. |
||||
if(Pad1Connected && Pad2Connected) |
||||
{ |
||||
if(selectedPad == SelectedPad.P1) |
||||
Pad2Connected = false; |
||||
if(selectedPad == SelectedPad.P2) |
||||
Pad1Connected = false; |
||||
} |
||||
|
||||
if(Pad1Connected) |
||||
yield return Tuple.Create(0, args.controller[0].config); |
||||
if(Pad2Connected) |
||||
yield return Tuple.Create(1, args.controller[1].config); |
||||
} |
||||
|
||||
// We know the selected pads are synced if there are two active, and when refreshing a |
||||
// UI we just want one of them to set the UI to. For convenience, return the first one. |
||||
public static SMX.SMXConfig GetFirstActivePadConfig(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePads(args)) |
||||
return activePad.Item2; |
||||
|
||||
// There aren't any pads connected. Just return a dummy config, since the UI |
||||
// isn't visible. |
||||
return SMX.SMXConfig.Create(); |
||||
} |
||||
|
||||
public static SMX.SMXConfig GetFirstActivePadConfig() |
||||
{ |
||||
return GetFirstActivePadConfig(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
} |
||||
|
||||
static class Helpers |
||||
{ |
||||
// Return true if arg is in the commandline. |
||||
public static bool HasCommandlineArgument(string arg) |
||||
{ |
||||
foreach(string s in Environment.GetCommandLineArgs()) |
||||
{ |
||||
if(s == arg) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
// Return true if we're in debug mode. |
||||
public static bool GetDebug() |
||||
{ |
||||
return HasCommandlineArgument("-d"); |
||||
} |
||||
|
||||
// Return true if we were launched on startup. |
||||
public static bool LaunchedOnStartup() |
||||
{ |
||||
return HasCommandlineArgument("-s"); |
||||
} |
||||
|
||||
// Return the last Win32 error as a string. |
||||
public static string GetLastWin32ErrorString() |
||||
{ |
||||
int error = Marshal.GetLastWin32Error(); |
||||
if(error == 0) |
||||
return ""; |
||||
return new System.ComponentModel.Win32Exception(error).Message; |
||||
} |
||||
|
||||
// https://stackoverflow.com/a/129395/136829 |
||||
public static T DeepClone<T>(T obj) |
||||
{ |
||||
using (var ms = new MemoryStream()) |
||||
{ |
||||
var formatter = new BinaryFormatter(); |
||||
formatter.Serialize(ms, obj); |
||||
ms.Position = 0; |
||||
|
||||
return (T) formatter.Deserialize(ms); |
||||
} |
||||
} |
||||
|
||||
// Work around Enumerable.SequenceEqual not checking if the arrays are null. |
||||
public static bool SequenceEqual<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second) |
||||
{ |
||||
if(first == second) |
||||
return true; |
||||
if(first == null || second == null) |
||||
return false; |
||||
return Enumerable.SequenceEqual(first, second); |
||||
} |
||||
|
||||
public static Color ColorFromFloatRGB(double r, double g, double b) |
||||
{ |
||||
byte R = (byte) Math.Max(0, Math.Min(255, r * 255)); |
||||
byte G = (byte) Math.Max(0, Math.Min(255, g * 255)); |
||||
byte B = (byte) Math.Max(0, Math.Min(255, b * 255)); |
||||
return Color.FromRgb(R, G, B); |
||||
} |
||||
|
||||
// Return a Color as an HTML color code. |
||||
public static string ColorToString(Color color) |
||||
{ |
||||
// WPF's Color.ToString() returns #AARRGGBB, which is just wrong. Alpha is always |
||||
// last in HTML color codes. We don't need alpha, so just strip it off. |
||||
return "#" + color.ToString().Substring(3); |
||||
} |
||||
|
||||
// Parse #RRGGBB and return a Color, or white if the string isn't in the correct format. |
||||
public static Color ParseColorString(string s) |
||||
{ |
||||
// We only expect "#RRGGBB". |
||||
if(s.Length != 7 || !s.StartsWith("#")) |
||||
return Color.FromRgb(255,255,255); |
||||
|
||||
try { |
||||
return (Color) ColorConverter.ConvertFromString(s); |
||||
} |
||||
catch(System.FormatException) |
||||
{ |
||||
return Color.FromRgb(255,255,255); |
||||
} |
||||
} |
||||
|
||||
// Light values are actually in the range 0-170 and not 0-255, since higher values aren't |
||||
// any brighter and just draw more power. The auto-lighting colors that we're configuring |
||||
// need to be scaled to this range too, but show full range colors in the UI. |
||||
readonly static double LightsScaleFactor = 0.666666f; |
||||
static public Byte ScaleColor(Byte c) |
||||
{ |
||||
return (Byte) Math.Round(c * LightsScaleFactor); |
||||
} |
||||
static public Byte UnscaleColor(Byte c) |
||||
{ |
||||
Byte result = (Byte) Math.Round(Math.Min(255, c / LightsScaleFactor)); |
||||
|
||||
// The color values we output are quantized, since we're scaling an 8-bit value. |
||||
// This doesn't have any real effect, but it causes #FFFFFF in the settings export |
||||
// file to be written out as #FDFDFD (which has the same value in hardware). Just |
||||
// so the common value of white is clean, snap these values to 0xFF. The end result |
||||
// will be the same. |
||||
if(result >= 0xFD) |
||||
return 0xFF; |
||||
return result; |
||||
} |
||||
|
||||
static public Color ScaleColor(Color c) |
||||
{ |
||||
return Color.FromRgb(ScaleColor(c.R), ScaleColor(c.G), ScaleColor(c.B)); |
||||
} |
||||
|
||||
static public Color UnscaleColor(Color c) |
||||
{ |
||||
return Color.FromRgb(UnscaleColor(c.R), UnscaleColor(c.G), UnscaleColor(c.B)); |
||||
} |
||||
|
||||
public static Color FromHSV(double H, double S, double V) |
||||
{ |
||||
H = H % 360; |
||||
S = Math.Max(0, Math.Min(1, S)); |
||||
V = Math.Max(0, Math.Min(1, V)); |
||||
if(H < 0) |
||||
H += 360; |
||||
H /= 60; |
||||
|
||||
if( S < 0.0001f ) |
||||
return ColorFromFloatRGB(V, V, V); |
||||
|
||||
double C = V * S; |
||||
double X = C * (1 - Math.Abs((H % 2) - 1)); |
||||
|
||||
Color ret; |
||||
switch( (int) Math.Round(Math.Floor(H)) ) |
||||
{ |
||||
case 0: ret = ColorFromFloatRGB(C, X, 0); break; |
||||
case 1: ret = ColorFromFloatRGB(X, C, 0); break; |
||||
case 2: ret = ColorFromFloatRGB(0, C, X); break; |
||||
case 3: ret = ColorFromFloatRGB(0, X, C); break; |
||||
case 4: ret = ColorFromFloatRGB(X, 0, C); break; |
||||
default: ret = ColorFromFloatRGB(C, 0, X); break; |
||||
} |
||||
|
||||
ret -= ColorFromFloatRGB(C-V, C-V, C-V); |
||||
return ret; |
||||
} |
||||
|
||||
public static void ToHSV(Color c, out double h, out double s, out double v) |
||||
{ |
||||
h = s = v = 0; |
||||
if( c.R == 0 && c.G == 0 && c.B == 0 ) |
||||
return; |
||||
|
||||
double r = c.R / 255.0; |
||||
double g = c.G / 255.0; |
||||
double b = c.B / 255.0; |
||||
|
||||
double m = Math.Min(Math.Min(r, g), b); |
||||
double M = Math.Max(Math.Max(r, g), b); |
||||
double C = M - m; |
||||
if( Math.Abs(r-g) < 0.0001f && Math.Abs(g-b) < 0.0001f ) // grey |
||||
h = 0; |
||||
else if( Math.Abs(r-M) < 0.0001f ) // M == R |
||||
h = ((g - b)/C) % 6; |
||||
else if( Math.Abs(g-M) < 0.0001f ) // M == G |
||||
h = (b - r)/C + 2; |
||||
else // M == B |
||||
h = (r - g)/C + 4; |
||||
|
||||
h *= 60; |
||||
if( h < 0 ) |
||||
h += 360; |
||||
|
||||
s = C / M; |
||||
v = M; |
||||
} |
||||
|
||||
// Return our settings directory, creating it if it doesn't exist. |
||||
public static string GetSettingsDirectory() |
||||
{ |
||||
string result = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "/StepManiaX/"; |
||||
System.IO.Directory.CreateDirectory(result); |
||||
return result; |
||||
} |
||||
|
||||
public static byte[] ReadFileFromSettings(string filename) |
||||
{ |
||||
string outputFilename = GetSettingsDirectory() + filename; |
||||
try { |
||||
return System.IO.File.ReadAllBytes(outputFilename); |
||||
} catch { |
||||
// If the file doesn't exist or can't be read for some other reason, just |
||||
// return null. |
||||
return null; |
||||
} |
||||
} |
||||
|
||||
public static void SaveFileToSettings(string filename, byte[] data) |
||||
{ |
||||
string outputFilename = GetSettingsDirectory() + filename; |
||||
string directory = System.IO.Path.GetDirectoryName(outputFilename); |
||||
System.IO.Directory.CreateDirectory(directory); |
||||
System.IO.File.WriteAllBytes(outputFilename, data); |
||||
} |
||||
|
||||
// Read path. If an error is encountered, return "". |
||||
public static string ReadFile(string path) |
||||
{ |
||||
try { |
||||
return System.IO.File.ReadAllText(path); |
||||
} |
||||
catch(System.IO.IOException) |
||||
{ |
||||
return ""; |
||||
} |
||||
} |
||||
|
||||
// Read path. If an error is encountered, return null. |
||||
public static byte[] ReadBinaryFile(string path) |
||||
{ |
||||
try { |
||||
return System.IO.File.ReadAllBytes(path); |
||||
} |
||||
catch(System.IO.IOException) |
||||
{ |
||||
return null; |
||||
} |
||||
} |
||||
|
||||
public static Dictionary<SMX.SMX.LightsType, string> LightsTypeNames = new Dictionary<SMX.SMX.LightsType, string>() |
||||
{ |
||||
{ SMX.SMX.LightsType.LightsType_Pressed, "pressed" }, |
||||
{ SMX.SMX.LightsType.LightsType_Released, "released" }, |
||||
}; |
||||
|
||||
// Load any saved animations from disk. |
||||
public static void LoadSavedPanelAnimations() |
||||
{ |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
foreach(var it in LightsTypeNames) |
||||
LoadSavedAnimationType(pad, it.Key); |
||||
} |
||||
} |
||||
|
||||
public static void SaveAnimationToDisk(int pad, SMX.SMX.LightsType type, byte[] data) |
||||
{ |
||||
string filename = LightsTypeNames[type] + ".gif"; |
||||
string path = "Animations/Pad" + (pad+1) + "/" + filename; |
||||
Helpers.SaveFileToSettings(path, data); |
||||
} |
||||
|
||||
// Read a saved PanelAnimation. |
||||
// |
||||
// Data will always be returned. If the user hasn't saved anything, we'll return |
||||
// our default animation. |
||||
private static byte[] ReadSavedAnimationType(int pad, SMX.SMX.LightsType type) |
||||
{ |
||||
string filename = LightsTypeNames[type] + ".gif"; |
||||
string path = "Animations/Pad" + (pad+1) + "/" + filename; |
||||
byte[] gif = Helpers.ReadFileFromSettings(path); |
||||
if(gif == null) |
||||
{ |
||||
// If the user has never loaded a file, load our default. |
||||
Uri url = new Uri("pack://application:,,,/Resources/" + filename); |
||||
StreamResourceInfo info = Application.GetResourceStream(url); |
||||
gif = new byte[info.Stream.Length]; |
||||
info.Stream.Read(gif, 0, gif.Length); |
||||
} |
||||
return gif; |
||||
} |
||||
|
||||
// Load a PanelAnimation from disk. |
||||
private static void LoadSavedAnimationType(int pad, SMX.SMX.LightsType type) |
||||
{ |
||||
byte[] gif = ReadSavedAnimationType(pad, type); |
||||
string error; |
||||
SMX.SMX.LightsAnimation_Load(gif, pad, type, out error); |
||||
} |
||||
|
||||
// Some broken antivirus software locks files when they're read. This is horrifying and |
||||
// breaks lots of software, including WPF's settings class. This is a race condition, |
||||
// so try to work around this by trying repeatedly. There's not much else we can do about |
||||
// it other than asking users to use a better antivirus. |
||||
public static void SaveApplicationSettings() |
||||
{ |
||||
for(int i = 0; i < 10; ++i) |
||||
{ |
||||
try { |
||||
Properties.Settings.Default.Save(); |
||||
return; |
||||
} catch(IOException e) |
||||
{ |
||||
Console.WriteLine("Error writing settings. Trying again: " + e); |
||||
} |
||||
} |
||||
|
||||
MessageBox.Show("Settings couldn't be saved.\n\nThis is usually caused by faulty antivirus software.", |
||||
"Error", MessageBoxButton.OK, MessageBoxImage.Warning); |
||||
} |
||||
|
||||
// Create a .lnk. |
||||
public static void CreateShortcut(string outputFile, string targetPath, string arguments) |
||||
{ |
||||
Type shellType = Type.GetTypeFromProgID("WScript.Shell"); |
||||
dynamic shell = Activator.CreateInstance(shellType); |
||||
dynamic shortcut = shell.CreateShortcut(outputFile); |
||||
|
||||
shortcut.TargetPath = targetPath; |
||||
shortcut.Arguments = arguments; |
||||
shortcut.WindowStyle = 0; |
||||
shortcut.Save(); |
||||
} |
||||
|
||||
[DllImport("user32.dll", CharSet = CharSet.Auto)] |
||||
public static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, IntPtr wParam, IntPtr lParam); |
||||
} |
||||
|
||||
// The threshold sliders in the advanced tab affect different panels and sensors depending |
||||
// on the user's settings. This handles managing which sensors each slider controls. |
||||
static public class ThresholdSettings |
||||
{ |
||||
[Serializable] |
||||
public struct PanelAndSensor |
||||
{ |
||||
public PanelAndSensor(int panel, int sensor) |
||||
{ |
||||
this.panel = panel; |
||||
this.sensor = sensor; |
||||
} |
||||
public int panel; |
||||
public int sensor; |
||||
}; |
||||
|
||||
public static List<string> thresholdSliderNames = new List<string>() |
||||
{ |
||||
"up-left", "up", "up-right", |
||||
"left", "center", "right", |
||||
"down-left", "down", "down-right", |
||||
"cardinal", "corner", |
||||
"inner-sensors", |
||||
"outer-sensors", |
||||
"custom-sensors", |
||||
}; |
||||
|
||||
// These correspond with ThresholdSlider.Type. |
||||
static Dictionary<string, int> panelNameToIndex = new Dictionary<string, int>() { |
||||
{ "up-left", 0 }, |
||||
{ "up", 1 }, |
||||
{ "up-right", 2 }, |
||||
{ "left", 3 }, |
||||
{ "center", 4 }, |
||||
{ "right", 5 }, |
||||
{ "down-left", 6 }, |
||||
{ "down", 7 }, |
||||
{ "down-right", 8 }, |
||||
|
||||
// The cardinal and corner sliders write to the down and up-right panels, and |
||||
// are then synced to the other panels. |
||||
{ "cardinal", 7 }, |
||||
{ "corner", 2 }, |
||||
}; |
||||
|
||||
// Save and load the list of custom threshold sensors to settings. These aren't saved to the pad, we |
||||
// just keep them in application settings. |
||||
static List<PanelAndSensor> cachedCustomSensors; |
||||
static public void SetCustomSensors(List<PanelAndSensor> panelAndSensors) |
||||
{ |
||||
List<object> result = new List<object>(); |
||||
foreach(PanelAndSensor panelAndSensor in panelAndSensors) |
||||
{ |
||||
List<int> panelAndSensorArray = new List<int>() { panelAndSensor.panel, panelAndSensor.sensor }; |
||||
result.Add(panelAndSensorArray); |
||||
} |
||||
|
||||
SetCustomSensorsJSON(result); |
||||
} |
||||
|
||||
// Set CustomSensors from a [[1,1],[2,2]] array. This is what we save to settings and |
||||
// export to JSON. |
||||
static public void SetCustomSensorsJSON(List<object> panelAndSensors) |
||||
{ |
||||
Properties.Settings.Default.CustomSensors = SerializeJSON.Serialize(panelAndSensors); |
||||
Helpers.SaveApplicationSettings(); |
||||
|
||||
// Clear the cache. Set it to null instead of assigning panelAndSensors to it to force |
||||
// it to re-parse at least once, to catch problems early. |
||||
cachedCustomSensors = null; |
||||
} |
||||
|
||||
// Return the sensors that are controlled by the custom-sensors slider. The other |
||||
// threshold sliders will leave these alone. |
||||
static public List<PanelAndSensor> GetCustomSensors() |
||||
{ |
||||
// Properties.Settings.Default.CustomSensors = "[[0,0], [1,0]]"; |
||||
// This is only ever changed with calls to SetCustomSensors. |
||||
if(cachedCustomSensors != null) |
||||
return Helpers.DeepClone(cachedCustomSensors); |
||||
|
||||
List<PanelAndSensor> result = new List<PanelAndSensor>(); |
||||
if(Properties.Settings.Default.CustomSensors == "") |
||||
return result; |
||||
|
||||
try { |
||||
// This is a list of [panel,sensor] arrays: |
||||
// [[0,0], [0,1], [1,0]] |
||||
List<object> sensors = GetCustomSensorsJSON(); |
||||
foreach(object panelAndSensorObj in sensors) |
||||
{ |
||||
List<object> panelAndSensor = (List<object>) panelAndSensorObj; |
||||
int panel = panelAndSensor.Get(0, -1); |
||||
int sensor = panelAndSensor.Get(1, -1); |
||||
if(panel == -1 || sensor == -1) |
||||
continue; |
||||
|
||||
result.Add(new PanelAndSensor(panel, sensor)); |
||||
} |
||||
} catch(ParseError) { |
||||
return result; |
||||
} |
||||
|
||||
cachedCustomSensors = result; |
||||
|
||||
return Helpers.DeepClone(cachedCustomSensors); |
||||
} |
||||
|
||||
static public List<object> GetCustomSensorsJSON() |
||||
{ |
||||
try { |
||||
return SMXJSON.ParseJSON.Parse<List<object>>(Properties.Settings.Default.CustomSensors); |
||||
} catch(ParseError) { |
||||
// CustomSensors is empty by default. We could test if it's empty, but as a more general |
||||
// safety, just catch any JSON errors in case something invalid is saved to it. |
||||
return new List<object>(); |
||||
} |
||||
} |
||||
|
||||
const int SensorLeft = 0; |
||||
const int SensorRight = 1; |
||||
const int SensorUp = 2; |
||||
const int SensorDown = 3; |
||||
static public List<PanelAndSensor> GetInnerSensors() |
||||
{ |
||||
return new List<PanelAndSensor>() |
||||
{ |
||||
new PanelAndSensor(1,SensorDown), // up panel, bottom sensor |
||||
new PanelAndSensor(3,SensorRight), // left panel, right sensor |
||||
new PanelAndSensor(5,SensorLeft), // right panel, left sensor |
||||
new PanelAndSensor(7,SensorUp), // down panel, top sensor |
||||
}; |
||||
} |
||||
|
||||
static public List<PanelAndSensor> GetOuterSensors() |
||||
{ |
||||
return new List<PanelAndSensor>() |
||||
{ |
||||
new PanelAndSensor(1,SensorUp), // up panel, top sensor |
||||
new PanelAndSensor(3,SensorLeft), // left panel, left sensor |
||||
new PanelAndSensor(5,SensorRight), // right panel, right sensor |
||||
new PanelAndSensor(7,SensorDown), // down panel, bottom sensor |
||||
}; |
||||
} |
||||
// Return the sensors controlled by the given slider. Most of the work is done |
||||
// in GetControlledSensorsForSliderTypeInternal. This just handles removing overlapping |
||||
// sensors. If inner-sensors is enabled, the inner sensors are removed from the normal |
||||
// thresholds. |
||||
// |
||||
// This is really inefficient: it calls GetControlledSensorsForSliderTypeInternal a lot, |
||||
// and the filtering is a linear search, but it doesn't matter. |
||||
// |
||||
// If includeOverridden is true, include sensors that would be controlled by this slider |
||||
// by default, but which have been overridden by a higher priority slider, or which are |
||||
// disabled by checkboxes. This is used for the UI. |
||||
static public List<PanelAndSensor> GetControlledSensorsForSliderType(string Type, bool advancedMode, bool includeOverridden) |
||||
{ |
||||
List<PanelAndSensor> result = GetControlledSensorsForSliderTypeInternal(Type, advancedMode, includeOverridden); |
||||
|
||||
if(!includeOverridden) |
||||
{ |
||||
// inner-sensors, outer-sensors and custom thresholds overlap each other and the standard |
||||
// sliders. inner-sensors and outer-sensors take over the equivalent sensors in the standard |
||||
// sliders, and custom thresholds take priority over everything else. |
||||
// |
||||
// We always pass false to includeOverridden here, since we need to know the real state of the |
||||
// sliders we're removing. |
||||
if(Type == "inner-sensors" || Type == "outer-sensors") |
||||
{ |
||||
// Remove any sensors controlled by the custom threshold. |
||||
RemoveFromSensorList(result, GetControlledSensorsForSliderTypeInternal("custom-sensors", advancedMode, false)); |
||||
} |
||||
else if(Type != "custom-sensors") |
||||
{ |
||||
// This is a regular slider. Remove any sensors controlled by inner-sensors, outer-sensors |
||||
// or custom-sensors. |
||||
RemoveFromSensorList(result, GetControlledSensorsForSliderTypeInternal("inner-sensors", advancedMode, false)); |
||||
RemoveFromSensorList(result, GetControlledSensorsForSliderTypeInternal("outer-sensors", advancedMode, false)); |
||||
RemoveFromSensorList(result, GetControlledSensorsForSliderTypeInternal("custom-sensors", advancedMode, false)); |
||||
} |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
static private void RemoveFromSensorList(List<PanelAndSensor> target, List<PanelAndSensor> sensorsToRemove) |
||||
{ |
||||
foreach(PanelAndSensor panelAndSensor in sensorsToRemove) |
||||
target.Remove(panelAndSensor); |
||||
} |
||||
|
||||
static private List<PanelAndSensor> GetControlledSensorsForSliderTypeInternal(string Type, bool advancedMode, bool includeOverridden) |
||||
{ |
||||
// inner-sensors and outer-sensors do nothing if their checkbox is disabled. We do this here because we |
||||
// need to skip this for the RemoveFromSensorList logic above. |
||||
if(!includeOverridden) |
||||
{ |
||||
if(Type == "inner-sensors" && !Properties.Settings.Default.UseInnerSensorThresholds) |
||||
return new List<PanelAndSensor>(); |
||||
if(Type == "outer-sensors" && !Properties.Settings.Default.UseOuterSensorThresholds) |
||||
return new List<PanelAndSensor>(); |
||||
} |
||||
|
||||
// Special sliders: |
||||
if(Type == "custom-sensors") return GetCustomSensors(); |
||||
if(Type == "inner-sensors") return GetInnerSensors(); |
||||
if(Type == "outer-sensors") return GetOuterSensors(); |
||||
|
||||
List<PanelAndSensor> result = new List<PanelAndSensor>(); |
||||
|
||||
// Check if this slider is shown in this mode. |
||||
if(advancedMode) |
||||
{ |
||||
// Hide the combo sliders in advanced mode. |
||||
if(Type == "cardinal" || Type == "corner") |
||||
return result; |
||||
} |
||||
|
||||
if(!advancedMode) |
||||
{ |
||||
// Only these sliders are shown in normal mode. |
||||
if(Type != "up" && Type != "center" && Type != "cardinal" && Type != "corner") |
||||
return result; |
||||
} |
||||
|
||||
// If advanced mode is disabled, save to all panels this slider affects. The down arrow controls |
||||
// all four cardinal panels. (If advanced mode is enabled we'll never be a different cardinal |
||||
// direction, since those widgets won't exist.) If it's disabled, just write to our own panel. |
||||
List<int> saveToPanels = new List<int>(); |
||||
int ourPanelIdx = panelNameToIndex[Type]; |
||||
saveToPanels.Add(ourPanelIdx); |
||||
if(!advancedMode) |
||||
saveToPanels.AddRange(ConfigPresets.GetPanelsToSyncUnifiedThresholds(ourPanelIdx)); |
||||
|
||||
foreach(int panelIdx in saveToPanels) |
||||
{ |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
result.Add(new PanelAndSensor(panelIdx, sensor)); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
// If the user disables inner-sensors after setting a value and control of those thresholds |
||||
// goes back to other sliders, the old inner-sensors thresholds will still be set in config |
||||
// until the user changes them, which is confusing. Make sure the value of each slider is |
||||
// actually set to config, even if the user doesn't change them. |
||||
// |
||||
// This isn't perfect. If the user assigns the first up sensor to custom and then removes it, |
||||
// so that sensor goes back to the normal up slider, this will sync the custom value to up. |
||||
// That's because we don't know which thresholds were actually being controlled by the up slider |
||||
// before it was changed. This is tricky to fix and not a big problem. |
||||
private static void SyncSliderThresholdsForConfig(ref SMX.SMXConfig config) |
||||
{ |
||||
if(!config.fsr()) |
||||
return; |
||||
|
||||
bool AdvancedModeEnabled = Properties.Settings.Default.AdvancedMode; |
||||
foreach(string sliderName in thresholdSliderNames) |
||||
{ |
||||
List<PanelAndSensor> controlledSensors = GetControlledSensorsForSliderType(sliderName, AdvancedModeEnabled, false); |
||||
if(controlledSensors.Count == 0) |
||||
continue; |
||||
PanelAndSensor firstSensor = controlledSensors[0]; |
||||
|
||||
foreach(PanelAndSensor panelAndSensor in controlledSensors) |
||||
{ |
||||
config.panelSettings[panelAndSensor.panel].fsrLowThreshold[panelAndSensor.sensor] = |
||||
config.panelSettings[firstSensor.panel].fsrLowThreshold[firstSensor.sensor]; |
||||
config.panelSettings[panelAndSensor.panel].fsrHighThreshold[panelAndSensor.sensor] = |
||||
config.panelSettings[firstSensor.panel].fsrHighThreshold[firstSensor.sensor]; |
||||
} |
||||
} |
||||
} |
||||
|
||||
public static void SyncSliderThresholds() |
||||
{ |
||||
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
SyncSliderThresholdsForConfig(ref config); |
||||
SMX.SMX.SetConfig(activePad.Item1, config); |
||||
} |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
public static bool IsAdvancedModeRequired() |
||||
{ |
||||
return false; |
||||
} |
||||
} |
||||
|
||||
// This class just makes it easier to assemble binary command packets. |
||||
public class CommandBuffer |
||||
{ |
||||
public void Write(string s) |
||||
{ |
||||
char[] buf = s.ToCharArray(); |
||||
byte[] data = new byte[buf.Length]; |
||||
for(int i = 0; i < buf.Length; ++i) |
||||
data[i] = (byte) buf[i]; |
||||
Write(data); |
||||
} |
||||
public void Write(byte[] s) { parts.AddLast(s); } |
||||
public void Write(byte b) { Write(new byte[] { b }); } |
||||
public void Write(char b) { Write((byte) b); } |
||||
|
||||
public byte[] Get() |
||||
{ |
||||
int length = 0; |
||||
foreach(byte[] part in parts) |
||||
length += part.Length; |
||||
|
||||
byte[] result = new byte[length]; |
||||
int next = 0; |
||||
foreach(byte[] part in parts) |
||||
{ |
||||
Buffer.BlockCopy(part, 0, result, next, part.Length); |
||||
next += part.Length; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
private LinkedList<byte[]> parts = new LinkedList<byte[]>(); |
||||
}; |
||||
|
||||
// Manage launching on startup. |
||||
static class LaunchOnStartup |
||||
{ |
||||
public static string GetLaunchShortcutFilename() |
||||
{ |
||||
string startupFolder = Environment.GetFolderPath(Environment.SpecialFolder.Startup); |
||||
return startupFolder + "/StepManiaX.lnk"; |
||||
} |
||||
|
||||
// Enable or disable launching on startup. |
||||
public static bool Enable |
||||
{ |
||||
get { |
||||
return Properties.Settings.Default.LaunchOnStartup; |
||||
} |
||||
|
||||
set { |
||||
if(Properties.Settings.Default.LaunchOnStartup == value) |
||||
return; |
||||
|
||||
// Remember whether we want to be launched on startup. This is used as a sanity |
||||
// check in case we're not able to remove our launch shortcut. |
||||
Properties.Settings.Default.LaunchOnStartup = value; |
||||
Helpers.SaveApplicationSettings(); |
||||
|
||||
string shortcutFilename = GetLaunchShortcutFilename(); |
||||
if(value) |
||||
{ |
||||
string filename = System.Diagnostics.Process.GetCurrentProcess().MainModule.FileName; |
||||
Helpers.CreateShortcut(shortcutFilename, filename, "-s"); |
||||
} else { |
||||
|
||||
try { |
||||
System.IO.File.Delete(shortcutFilename); |
||||
} catch { |
||||
// If there's an error deleting the shortcut (most likely it doesn't exist), |
||||
// don't do anything. |
||||
} |
||||
} |
||||
} |
||||
} |
||||
}; |
||||
|
||||
// When enabled, periodically set all lights to the current auto-lighting color. This |
||||
// is enabled while manipulating the step color slider. |
||||
class ShowAutoLightsColor |
||||
{ |
||||
private DispatcherTimer LightsTimer; |
||||
|
||||
public ShowAutoLightsColor() |
||||
{ |
||||
LightsTimer = new DispatcherTimer(); |
||||
|
||||
// Run at 30fps. |
||||
LightsTimer.Interval = new TimeSpan(0,0,0,0, 1000 / 33); |
||||
|
||||
LightsTimer.Tick += delegate(object sender, EventArgs e) |
||||
{ |
||||
if(!LightsTimer.IsEnabled) |
||||
return; |
||||
|
||||
AutoLightsColorRefreshColor(); |
||||
}; |
||||
} |
||||
|
||||
public void Start() |
||||
{ |
||||
// To show the current color, send a lights command periodically. If we stop sending |
||||
// this for a while the controller will return to auto-lights, which we won't want to |
||||
// happen until AutoLightsColorEnd is called. |
||||
if(LightsTimer.IsEnabled) |
||||
return; |
||||
|
||||
// Don't wait for an interval to send the first update. |
||||
//AutoLightsColorRefreshColor(); |
||||
|
||||
LightsTimer.Start(); |
||||
} |
||||
|
||||
public void Stop() |
||||
{ |
||||
LightsTimer.Stop(); |
||||
|
||||
// Reenable pad auto-lighting. If we're running animations in SMXPanelAnimation, |
||||
// this will be overridden by it once it sends lights. |
||||
SMX.SMX.ReenableAutoLights(); |
||||
} |
||||
|
||||
private void AutoLightsColorRefreshColor() |
||||
{ |
||||
CommandBuffer cmd = new CommandBuffer(); |
||||
|
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
// Use this panel's color. If a panel isn't connected, we still need to run the |
||||
// loop below to insert data for the panel. |
||||
byte[] color = new byte[9*3]; |
||||
SMX.SMXConfig config; |
||||
if(SMX.SMX.GetConfig(pad, out config)) |
||||
color = config.stepColor; |
||||
for( int iPanel = 0; iPanel < 9; ++iPanel ) |
||||
{ |
||||
for( int i = 0; i < 25; ++i ) |
||||
{ |
||||
// Auto-lights colors in the config packet are scaled so the firmware |
||||
// doesn't have to do it, but here we're setting the panel color to |
||||
// the auto-light color directly to preview the color. SetLights |
||||
// will apply the scaling, so we need to remove it. |
||||
cmd.Write( Helpers.UnscaleColor(color[iPanel*3+0]) ); |
||||
cmd.Write( Helpers.UnscaleColor(color[iPanel*3+1]) ); |
||||
cmd.Write( Helpers.UnscaleColor(color[iPanel*3+2]) ); |
||||
} |
||||
} |
||||
} |
||||
|
||||
SMX.SMX.SetLights2(cmd.Get()); |
||||
} |
||||
}; |
||||
|
||||
static class SMXHelpers |
||||
{ |
||||
// Export configurable values in SMXConfig to a JSON string. |
||||
public static string ExportSettingsToJSON(SMX.SMXConfig config) |
||||
{ |
||||
// The user only uses one of low or high thresholds. Only export the |
||||
// settings the user is actually using. |
||||
Dictionary<string, Object> dict = new Dictionary<string, Object>(); |
||||
if(config.fsr()) |
||||
{ |
||||
List<int> fsrLowThresholds = new List<int>(); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
fsrLowThresholds.Add(config.panelSettings[panel].fsrLowThreshold[0]); |
||||
dict.Add("fsrLowThresholds", fsrLowThresholds); |
||||
|
||||
List<int> fsrHighThresholds = new List<int>(); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
fsrHighThresholds.Add(config.panelSettings[panel].fsrHighThreshold[0]); |
||||
dict.Add("fsrHighThresholds", fsrHighThresholds); |
||||
} |
||||
else |
||||
{ |
||||
List<int> panelLowThresholds = new List<int>(); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
panelLowThresholds.Add(config.panelSettings[panel].loadCellLowThreshold); |
||||
dict.Add("panelLowThresholds", panelLowThresholds); |
||||
|
||||
List<int> panelHighThresholds = new List<int>(); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
panelHighThresholds.Add(config.panelSettings[panel].loadCellHighThreshold); |
||||
dict.Add("panelHighThresholds", panelHighThresholds); |
||||
} |
||||
|
||||
// Store the enabled panel mask as a simple list of which panels are selected. |
||||
bool[] enabledPanels = config.GetEnabledPanels(); |
||||
List<int> enabledPanelList = new List<int>(); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
if(enabledPanels[panel]) |
||||
enabledPanelList.Add(panel); |
||||
} |
||||
dict.Add("enabledPanels", enabledPanelList); |
||||
|
||||
// Store panel colors. |
||||
List<string> panelColors = new List<string>(); |
||||
for(int PanelIndex = 0; PanelIndex < 9; ++PanelIndex) |
||||
{ |
||||
// Scale colors from the hardware value back to the 0-255 value we use in the UI. |
||||
Color color = Color.FromRgb(config.stepColor[PanelIndex*3+0], config.stepColor[PanelIndex*3+1], config.stepColor[PanelIndex*3+2]); |
||||
color = Helpers.UnscaleColor(color); |
||||
panelColors.Add(Helpers.ColorToString(color)); |
||||
} |
||||
dict.Add("panelColors", panelColors); |
||||
|
||||
dict.Add("advancedMode", Properties.Settings.Default.AdvancedMode); |
||||
dict.Add("useOuterSensorThresholds", Properties.Settings.Default.UseOuterSensorThresholds); |
||||
dict.Add("useInnerSensorThresholds", Properties.Settings.Default.UseInnerSensorThresholds); |
||||
dict.Add("customSensors", ThresholdSettings.GetCustomSensorsJSON()); |
||||
|
||||
return SMXJSON.SerializeJSON.Serialize(dict); |
||||
} |
||||
|
||||
// Import a saved JSON configuration to an SMXConfig. |
||||
public static void ImportSettingsFromJSON(string json, ref SMX.SMXConfig config) |
||||
{ |
||||
Dictionary<string, Object> dict; |
||||
try { |
||||
dict = SMXJSON.ParseJSON.Parse<Dictionary<string, Object>>(json); |
||||
} catch(ParseError e) { |
||||
MessageBox.Show(e.Message, "Error importing configuration", MessageBoxButton.OK, MessageBoxImage.Warning); |
||||
return; |
||||
} |
||||
|
||||
// Read the thresholds. If any values are missing, we'll leave the value in config alone. |
||||
if(config.fsr()) |
||||
{ |
||||
List<Object> newPanelLowThresholds = dict.Get("fsrLowThresholds", new List<Object>()); |
||||
List<Object> newPanelHighThresholds = dict.Get("fsrHighThresholds", new List<Object>()); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
config.panelSettings[panel].fsrLowThreshold[sensor] = (byte) newPanelLowThresholds.Get(panel, (int) config.panelSettings[panel].fsrLowThreshold[sensor]); |
||||
config.panelSettings[panel].fsrHighThreshold[sensor] = (byte) newPanelHighThresholds.Get(panel, (int) config.panelSettings[panel].fsrHighThreshold[sensor]); |
||||
} |
||||
} |
||||
} |
||||
else |
||||
{ |
||||
List<Object> newPanelLowThresholds = dict.Get("panelLowThresholds", new List<Object>()); |
||||
List<Object> newPanelHighThresholds = dict.Get("panelHighThresholds", new List<Object>()); |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
config.panelSettings[panel].loadCellLowThreshold = newPanelLowThresholds.Get(panel, config.panelSettings[panel].loadCellLowThreshold); |
||||
config.panelSettings[panel].loadCellHighThreshold = newPanelHighThresholds.Get(panel, config.panelSettings[panel].loadCellHighThreshold); |
||||
} |
||||
} |
||||
|
||||
List<Object> enabledPanelList = dict.Get<List<Object>>("enabledPanels", null); |
||||
if(enabledPanelList != null) |
||||
{ |
||||
bool[] enabledPanels = new bool[9]; |
||||
for(int i = 0; i < enabledPanelList.Count; ++i) |
||||
{ |
||||
int panel = enabledPanelList.Get(i, 0); |
||||
|
||||
// Sanity check: |
||||
if(panel < 0 || panel >= 9) |
||||
continue; |
||||
enabledPanels[panel] = true; |
||||
} |
||||
config.SetEnabledPanels(enabledPanels); |
||||
} |
||||
|
||||
List<Object> panelColors = dict.Get<List<Object>>("panelColors", null); |
||||
if(panelColors != null) |
||||
{ |
||||
for(int PanelIndex = 0; PanelIndex < 9 && PanelIndex < panelColors.Count; ++PanelIndex) |
||||
{ |
||||
string colorString = panelColors.Get(PanelIndex, "#FFFFFF"); |
||||
Color color = Helpers.ParseColorString(colorString); |
||||
color = Helpers.ScaleColor(color); |
||||
|
||||
config.stepColor[PanelIndex*3+0] = color.R; |
||||
config.stepColor[PanelIndex*3+1] = color.G; |
||||
config.stepColor[PanelIndex*3+2] = color.B; |
||||
} |
||||
} |
||||
|
||||
// Older exported settings don't have advancedMode. Set it to true if it's missing. |
||||
Properties.Settings.Default.AdvancedMode = dict.Get<bool>("advancedMode", true); |
||||
Properties.Settings.Default.UseOuterSensorThresholds = dict.Get<bool>("useOuterSensorThresholds", false); |
||||
Properties.Settings.Default.UseInnerSensorThresholds = dict.Get<bool>("useInnerSensorThresholds", false); |
||||
List<object> customSensors = dict.Get<List<object>>("customSensors", null); |
||||
if(customSensors != null) |
||||
ThresholdSettings.SetCustomSensorsJSON(customSensors); |
||||
} |
||||
}; |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,668 @@ |
||||
using System; |
||||
using System.Linq; |
||||
using System.Collections.Generic; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Media; |
||||
using System.Windows.Interop; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public partial class MainWindow: Window |
||||
{ |
||||
OnConfigChange onConfigChange; |
||||
ShowAutoLightsColor showAutoLightsColor = new ShowAutoLightsColor(); |
||||
|
||||
public MainWindow() |
||||
{ |
||||
InitializeComponent(); |
||||
|
||||
onConfigChange = new OnConfigChange(this, delegate (LoadFromConfigDelegateArgs args) |
||||
{ |
||||
LoadUIFromConfig(args); |
||||
}); |
||||
|
||||
// If we're controlling GIF animations and the firmware doesn't support |
||||
// doing animations internally, confirm exiting, since you can minimize |
||||
// to tray to keep playing animations. If we're not controlling animations, |
||||
// or the firmware supports doing them automatically, don't bug the user |
||||
// with a prompt. |
||||
Closing += delegate (object sender, System.ComponentModel.CancelEventArgs e) |
||||
{ |
||||
LoadFromConfigDelegateArgs args = CurrentSMXDevice.singleton.GetState(); |
||||
|
||||
// Don't use ActivePads here. Even if P1 is selected for configuration, |
||||
// we can still be controlling animations for P2, so check both connected |
||||
// pads. |
||||
bool shouldConfirmExit = false; |
||||
for(int pad = 0; pad < 2; ++pad) |
||||
{ |
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
// If the firmware is version 4 or higher, it supports animations directly. |
||||
// The user can upload GIF animations and doesn't need to leave us running |
||||
// for them to work. You can still use this tool to drive animations, but |
||||
// don't confirm exiting. |
||||
if(config.masterVersion >= 4) |
||||
continue; |
||||
|
||||
// If AutoLightingUsePressedAnimations isn't set, the panel is using step |
||||
// coloring instead of pressed animations. All firmwares support this. |
||||
// Don't confirm exiting for this mode. |
||||
if((config.configFlags & SMX.SMXConfigFlags.AutoLightingUsePressedAnimations) == 0) |
||||
continue; |
||||
|
||||
shouldConfirmExit = true; |
||||
} |
||||
|
||||
if(!shouldConfirmExit) |
||||
return; |
||||
|
||||
MessageBoxResult result = MessageBox.Show( |
||||
"Close StepManiaX configuration?\n\n" + |
||||
"GIF animations will keep playing if the application is minimized.", |
||||
"StepManiaX", System.Windows.MessageBoxButton.YesNo); |
||||
if(result == MessageBoxResult.No) |
||||
e.Cancel = true; |
||||
}; |
||||
} |
||||
|
||||
bool IsThresholdSliderShown(string type) |
||||
{ |
||||
bool AdvancedModeEnabled = Properties.Settings.Default.AdvancedMode; |
||||
SMX.SMXConfig config = ActivePad.GetFirstActivePadConfig(); |
||||
bool[] enabledPanels = config.GetEnabledPanels(); |
||||
|
||||
// Check the list of sensors this slider controls. If the list is empty, don't show it. |
||||
// For example, if the user adds all four sensors on the up panel to custom-sensors, the |
||||
// up button has nothing left to control, so we'll hide it. |
||||
// |
||||
// Don't do this for custom, inner-sensors or outer-sensors. Those are always shown in |
||||
// advanced mode. |
||||
List<ThresholdSettings.PanelAndSensor> panelAndSensors = ThresholdSettings.GetControlledSensorsForSliderType(type, AdvancedModeEnabled, false); |
||||
if(type == "custom-sensors" || type == "inner-sensors" || type == "outer-sensors") |
||||
{ |
||||
if(!AdvancedModeEnabled || !config.fsr()) |
||||
return false; |
||||
} |
||||
else |
||||
{ |
||||
if(panelAndSensors.Count == 0) |
||||
return false; |
||||
} |
||||
|
||||
// Hide thresholds that only affect panels that are disabled, so we don't show |
||||
// corner panel sliders in advanced mode if the corner panels are disabled. We |
||||
// don't handle this in GetControlledSensorsForSliderType, since we do want cardinal |
||||
// and corner to write thresholds to disabled panels, so they're in sync if they're |
||||
// turned back on. |
||||
switch(type) |
||||
{ |
||||
case "up-left": return enabledPanels[0]; |
||||
case "up": return enabledPanels[1]; |
||||
case "up-right": return enabledPanels[2]; |
||||
case "left": return enabledPanels[3]; |
||||
case "center": return enabledPanels[4]; |
||||
case "right": return enabledPanels[5]; |
||||
case "down-left": return enabledPanels[6]; |
||||
case "down": return enabledPanels[7]; |
||||
case "down-right": return enabledPanels[8]; |
||||
|
||||
// Show cardinal and corner if at least one panel they affect is enabled. |
||||
case "cardinal": return enabledPanels[3] || enabledPanels[5] || enabledPanels[8]; |
||||
case "corner": return enabledPanels[0] || enabledPanels[2] || enabledPanels[6] || enabledPanels[8]; |
||||
default: return true; |
||||
} |
||||
} |
||||
|
||||
ThresholdSlider CreateThresholdSlider(string type) |
||||
{ |
||||
ThresholdSlider slider = new ThresholdSlider(); |
||||
slider.Type = type; |
||||
return slider; |
||||
} |
||||
|
||||
void CreateThresholdSliders() |
||||
{ |
||||
// Remove and recreate threshold sliders. |
||||
ThresholdSliderContainer.Children.Clear(); |
||||
foreach(string sliderName in ThresholdSettings.thresholdSliderNames) |
||||
{ |
||||
if(!IsThresholdSliderShown(sliderName)) |
||||
continue; |
||||
|
||||
ThresholdSlider slider = CreateThresholdSlider(sliderName); |
||||
DockPanel.SetDock(slider, Dock.Top); |
||||
slider.Margin = new Thickness(0, 8, 0, 0); |
||||
ThresholdSliderContainer.Children.Add(slider); |
||||
} |
||||
|
||||
ThresholdSettings.SyncSliderThresholds(); |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
// Add our WndProc hook. |
||||
HwndSource source = (HwndSource)PresentationSource.FromVisual(this); |
||||
source.AddHook(new HwndSourceHook(WndProcHook)); |
||||
|
||||
Version1.Content = "SMXConfig version " + SMX.SMX.Version(); |
||||
Version2.Content = "SMXConfig version " + SMX.SMX.Version(); |
||||
|
||||
AutoLightsColor.StartedDragging += delegate () { showAutoLightsColor.Start(); }; |
||||
AutoLightsColor.StoppedDragging += delegate () { showAutoLightsColor.Stop(); }; |
||||
AutoLightsColor.StoppedDragging += delegate () { showAutoLightsColor.Stop(); }; |
||||
|
||||
CreateThresholdSliders(); |
||||
|
||||
// This doesn't happen at the same time AutoLightsColor is used, since they're on different tabs. |
||||
Diagnostics.SetShowAllLights += delegate (bool on) |
||||
{ |
||||
if(on) |
||||
showAutoLightsColor.Start(); |
||||
else |
||||
showAutoLightsColor.Stop(); |
||||
}; |
||||
|
||||
SetAllPanelsToCurrentColor.Click += delegate (object sender, RoutedEventArgs e) |
||||
{ |
||||
// Get the color of the selected color button, and apply it to all other buttons. |
||||
Color color = selectedButton.getColor(); |
||||
|
||||
ColorButton[] colorButtons = getColorPickerButtons(); |
||||
foreach(ColorButton button in colorButtons) |
||||
{ |
||||
// Only apply this to panel colors, not the floor color. |
||||
if((button as PanelColorButton) == null) |
||||
continue; |
||||
|
||||
button.setColor(color); |
||||
} |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
}; |
||||
|
||||
// Listen to clicks on the panel color buttons. |
||||
ColorButton[] buttons = getColorPickerButtons(); |
||||
foreach(ColorButton button in buttons) |
||||
{ |
||||
button.Click += delegate (object sender, RoutedEventArgs e) |
||||
{ |
||||
ColorButton clickedButton = sender as ColorButton; |
||||
selectedButton = clickedButton; |
||||
|
||||
RefreshSelectedColorPicker(); |
||||
}; |
||||
} |
||||
} |
||||
|
||||
// We have two main modes: color mode and GIF animation mode. These behave differently |
||||
// on gen1-3 pads and gen4 pads. |
||||
// |
||||
// On gen4 pads, this determines whether we show animations on press, or show a solid color. |
||||
// This makes it easy to pick a solid color if that's all you want to change, instead of having |
||||
// to make a GIF with the color. We always show animations on release in both modes. |
||||
// |
||||
// On gen1-3 pads, panels are black in color mode, so they behave the same as they did originally. |
||||
// Animations are only shown in GIF animation mode. These animations are enabled with |
||||
// LightsAnimation_SetAuto. |
||||
// |
||||
// The gen1-3 firmware ignores the AutoLightingUsePressedAnimations flag, but we still use it to |
||||
// store which mode the user has selected. |
||||
private void PressedColorModeButton(object sender, RoutedEventArgs e) |
||||
{ |
||||
// The user pressed either the "panel colors" or "GIF animations" button. |
||||
bool pressedPanelColors = sender == PanelColorsButton; |
||||
|
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
|
||||
// If we're in panel colors mode, clear the AutoLightingUsePressedAnimations flag. |
||||
// Otherwise, set it. |
||||
if(pressedPanelColors) |
||||
config.configFlags &= ~SMX.SMXConfigFlags.AutoLightingUsePressedAnimations; |
||||
else |
||||
config.configFlags |= SMX.SMXConfigFlags.AutoLightingUsePressedAnimations; |
||||
SMX.SMX.SetConfig(activePad.Item1, config); |
||||
} |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
private void LoadUIFromConfig(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
// Refresh whether LightsAnimation_SetAuto should be enabled. |
||||
SMX.SMXConfig firstConfig = ActivePad.GetFirstActivePadConfig(); |
||||
bool usePressedAnimationsEnabled = (firstConfig.configFlags & SMX.SMXConfigFlags.AutoLightingUsePressedAnimations) != 0; |
||||
SMX.SMX.LightsAnimation_SetAuto(usePressedAnimationsEnabled); |
||||
|
||||
bool EitherControllerConnected = args.controller[0].info.connected || args.controller[1].info.connected; |
||||
Main.Visibility = EitherControllerConnected ? Visibility.Visible : Visibility.Hidden; |
||||
Searching.Visibility = EitherControllerConnected ? Visibility.Hidden : Visibility.Visible; |
||||
ConnectedPads.Visibility = EitherControllerConnected ? Visibility.Visible : Visibility.Hidden; |
||||
PanelColorP1.Visibility = args.controller[0].info.connected ? Visibility.Visible : Visibility.Collapsed; |
||||
PanelColorP2.Visibility = args.controller[1].info.connected ? Visibility.Visible : Visibility.Collapsed; |
||||
EnableCenterTopSensorCheckbox.Visibility = |
||||
P1_Floor.Visibility = |
||||
P2_Floor.Visibility = |
||||
args.firmwareVersion() >= 5 ? Visibility.Visible : Visibility.Collapsed; |
||||
|
||||
// Show the color slider or GIF UI depending on which one is set in flags. |
||||
// If both pads are turned on, just use the first one. |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
|
||||
// If SMXConfigFlags_AutoLightingUsePressedAnimations is set, show the GIF UI. |
||||
// If it's not set, show the color slider UI. |
||||
SMX.SMXConfigFlags flags = config.configFlags; |
||||
bool usePressedAnimations = (flags & SMX.SMXConfigFlags.AutoLightingUsePressedAnimations) != 0; |
||||
ColorPickerGroup.Visibility = usePressedAnimations ? Visibility.Collapsed : Visibility.Visible; |
||||
GIFGroup.Visibility = usePressedAnimations ? Visibility.Visible : Visibility.Collapsed; |
||||
|
||||
// Tell the color mode buttons which one is selected, to set the button highlight. |
||||
PanelColorsButton.Selected = !usePressedAnimations; |
||||
GIFAnimationsButton.Selected = usePressedAnimations; |
||||
|
||||
break; |
||||
} |
||||
|
||||
RefreshConnectedPadList(args); |
||||
RefreshUploadPadText(args); |
||||
RefreshSelectedColorPicker(); |
||||
|
||||
// If a device has connected or disconnected, refresh the displayed threshold |
||||
// sliders. Don't do this otherwise, or we'll do this when the sliders are |
||||
// dragged. |
||||
if(args.ConnectionsChanged) |
||||
CreateThresholdSliders(); |
||||
|
||||
// Show the threshold warning explanation if any panels are showing the threshold warning icon. |
||||
bool ShowThresholdWarningText = false; |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
for(int panelIdx = 0; panelIdx < 9; ++panelIdx) |
||||
{ |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
if(config.ShowThresholdWarning(panelIdx, sensor)) |
||||
ShowThresholdWarningText = true; |
||||
} |
||||
} |
||||
} |
||||
ThresholdWarningText.Visibility = ShowThresholdWarningText ? Visibility.Visible : Visibility.Hidden; |
||||
|
||||
// If a second controller has connected and we're on Both, see if we need to prompt |
||||
// to sync configs. We only actually need to do this if a controller just connected. |
||||
if(args.ConfigurationChanged) |
||||
CheckConfiguringBothPads(args); |
||||
} |
||||
|
||||
ColorButton selectedButton; |
||||
|
||||
// Return all color picker buttons. |
||||
ColorButton[] getColorPickerButtons() |
||||
{ |
||||
return new ColorButton[] { |
||||
P1_0, P1_1, P1_2, |
||||
P1_3, P1_4, P1_5, |
||||
P1_6, P1_7, P1_8, |
||||
P1_Floor, |
||||
|
||||
P2_0, P2_1, P2_2, |
||||
P2_3, P2_4, P2_5, |
||||
P2_6, P2_7, P2_8, |
||||
P2_Floor, |
||||
}; |
||||
} |
||||
|
||||
// Update the selected color picker based on the value of selectedButton. |
||||
private void RefreshSelectedColorPicker() |
||||
{ |
||||
LoadFromConfigDelegateArgs args = CurrentSMXDevice.singleton.GetState(); |
||||
|
||||
ColorButton[] buttons = getColorPickerButtons(); |
||||
|
||||
// If our selected button isn't enabled (or no button is selected), try to select a |
||||
// different one. |
||||
if(selectedButton == null || !selectedButton.isEnabled(args)) |
||||
{ |
||||
foreach(ColorButton button in buttons) |
||||
{ |
||||
if(button.isEnabled(args)) |
||||
{ |
||||
selectedButton = button; |
||||
break; |
||||
} |
||||
} |
||||
} |
||||
|
||||
// Tell the buttons which one is selected. |
||||
foreach(ColorButton button in buttons) |
||||
button.IsSelected = button == selectedButton; |
||||
|
||||
// Tell the color slider which button is selected. |
||||
AutoLightsColor.colorButton = selectedButton; |
||||
} |
||||
|
||||
// Update which of the "Leave this application running", etc. blocks to display. |
||||
private void RefreshUploadPadText(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
|
||||
bool uploadsSupported = config.masterVersion >= 4; |
||||
LeaveRunning.Visibility = uploadsSupported ? Visibility.Collapsed : Visibility.Visible; |
||||
break; |
||||
} |
||||
} |
||||
|
||||
private void ConnectedPadList_SelectionChanged(object sender, SelectionChangedEventArgs e) |
||||
{ |
||||
ComboBoxItem selection = ConnectedPadList.SelectedItem as ComboBoxItem; |
||||
ActivePad.SelectedPad newSelection; |
||||
if(selection == ConnectedPadList_P1) |
||||
newSelection = ActivePad.SelectedPad.P1; |
||||
else if(selection == ConnectedPadList_P2) |
||||
newSelection = ActivePad.SelectedPad.P2; |
||||
else |
||||
newSelection = ActivePad.SelectedPad.Both; |
||||
if(ActivePad.selectedPad == newSelection) |
||||
return; |
||||
|
||||
ActivePad.selectedPad = newSelection; |
||||
|
||||
// Before firing and updating UI, run CheckConfiguringBothPads to see if we should |
||||
// sync the config and/or change the selection again. |
||||
CheckConfiguringBothPads(CurrentSMXDevice.singleton.GetState()); |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
// If the user selects "Both", or connects a second pad while on "Both", both pads need |
||||
// to have the same configuration, since we're configuring them together. Check if the |
||||
// configuration is out of sync, and ask the user before syncing them up so we don't |
||||
// clobber P2's configuration if this wasn't intended. |
||||
// |
||||
// If the user cancels, change the pad selection to P1 so we don't clobber P2. |
||||
private void CheckConfiguringBothPads(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
// Check if we're actually in "Both" mode with two controllers connected. If not, |
||||
// we don't have to do anything. |
||||
bool Pad1Connected = args.controller[0].info.connected; |
||||
bool Pad2Connected = args.controller[1].info.connected; |
||||
if(ActivePad.selectedPad != ActivePad.SelectedPad.Both || !Pad1Connected || !Pad2Connected) |
||||
return; |
||||
|
||||
// If the two pads have the same configuration, there's nothing to do. |
||||
SMX.SMXConfig config1 = args.controller[0].config; |
||||
SMX.SMXConfig config2 = args.controller[1].config; |
||||
if(ConfigurationsSynced(config1, config2)) |
||||
return; |
||||
|
||||
string messageBoxText = "The two pads have different settings. Do you want to " + |
||||
"match P2 settings to P1 and configure both pads together? (This won't affect panel colors.)"; |
||||
MessageBoxResult result = MessageBox.Show(messageBoxText, "StepManiaX", MessageBoxButton.YesNo, MessageBoxImage.None); |
||||
if(result == MessageBoxResult.Yes) |
||||
{ |
||||
SyncP2FromP1(config1, config2); |
||||
return; |
||||
} |
||||
else |
||||
{ |
||||
// Switch to P1. |
||||
ActivePad.selectedPad = ActivePad.SelectedPad.P1; |
||||
RefreshConnectedPadList(CurrentSMXDevice.singleton.GetState()); |
||||
} |
||||
|
||||
} |
||||
|
||||
// Return true if the two pads have the same configuration, so we can configure them together |
||||
// without clobbering separate configurations. |
||||
bool ConfigurationsSynced(SMX.SMXConfig config1, SMX.SMXConfig config2) |
||||
{ |
||||
if(!Enumerable.SequenceEqual(config1.GetLowThresholds(), config2.GetLowThresholds())) |
||||
return false; |
||||
if(!Enumerable.SequenceEqual(config1.GetHighThresholds(), config2.GetHighThresholds())) |
||||
return false; |
||||
if(!Enumerable.SequenceEqual(config1.enabledSensors, config2.enabledSensors)) |
||||
return false; |
||||
return true; |
||||
} |
||||
|
||||
// Copy the P2 pad configuration to P1. |
||||
// |
||||
// This only copies settings that we actually configure, and it doesn't copy pad |
||||
// colors, which is separate from pad selection. |
||||
void SyncP2FromP1(SMX.SMXConfig config1, SMX.SMXConfig config2) |
||||
{ |
||||
// Copy P1's configuration to P2. |
||||
Array.Copy(config1.enabledSensors, config2.enabledSensors, config1.enabledSensors.Count()); |
||||
config2.SetLowThresholds(config1.GetLowThresholds()); |
||||
config2.SetHighThresholds(config1.GetHighThresholds()); |
||||
SMX.SMX.SetConfig(1, config2); |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
// Refresh which items are visible in the connected pads list, and which item is displayed as selected. |
||||
private void RefreshConnectedPadList(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
bool TwoControllersConnected = args.controller[0].info.connected && args.controller[1].info.connected; |
||||
|
||||
// Only show the dropdown if two controllers are connected. |
||||
ConnectedPadList.Visibility = TwoControllersConnected ? Visibility.Visible : Visibility.Collapsed; |
||||
|
||||
// Only show the P1/P2 text if only one controller is connected, since it takes the place |
||||
// of the dropdown. |
||||
P1Connected.Visibility = (!TwoControllersConnected && args.controller[0].info.connected) ? Visibility.Visible : Visibility.Collapsed; |
||||
P2Connected.Visibility = (!TwoControllersConnected && args.controller[1].info.connected) ? Visibility.Visible : Visibility.Collapsed; |
||||
|
||||
if(!TwoControllersConnected) |
||||
return; |
||||
|
||||
// Set the current selection. |
||||
ActivePad.SelectedPad selectedPad = ActivePad.selectedPad; |
||||
switch(ActivePad.selectedPad) |
||||
{ |
||||
case ActivePad.SelectedPad.P1: ConnectedPadList.SelectedItem = ConnectedPadList_P1; break; |
||||
case ActivePad.SelectedPad.P2: ConnectedPadList.SelectedItem = ConnectedPadList_P2; break; |
||||
case ActivePad.SelectedPad.Both: ConnectedPadList.SelectedItem = ConnectedPadList_Both; break; |
||||
} |
||||
} |
||||
|
||||
|
||||
private void FactoryReset_Click(object sender, RoutedEventArgs e) |
||||
{ |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
int pad = activePad.Item1; |
||||
SMX.SMX.FactoryReset(pad); |
||||
} |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
private void AdvancedModeEnabledCheckbox_Changed(object sender, RoutedEventArgs e) |
||||
{ |
||||
CreateThresholdSliders(); |
||||
} |
||||
|
||||
private void ExportSettings(object sender, RoutedEventArgs e) |
||||
{ |
||||
// Save the current thresholds on the first available pad as a preset. |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
int pad = activePad.Item1; |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
string json = SMXHelpers.ExportSettingsToJSON(config); |
||||
|
||||
Microsoft.Win32.SaveFileDialog dialog = new Microsoft.Win32.SaveFileDialog(); |
||||
dialog.FileName = "StepManiaX settings"; |
||||
dialog.DefaultExt = ".smxcfg"; |
||||
dialog.Filter = "StepManiaX settings (.smxcfg)|*.smxcfg"; |
||||
bool? result = dialog.ShowDialog(); |
||||
if(result == null || !(bool)result) |
||||
return; |
||||
|
||||
System.IO.File.WriteAllText(dialog.FileName, json); |
||||
return; |
||||
} |
||||
} |
||||
|
||||
private void ImportSettings(object sender, RoutedEventArgs e) |
||||
{ |
||||
// Prompt for a file to read. |
||||
Microsoft.Win32.OpenFileDialog dialog = new Microsoft.Win32.OpenFileDialog(); |
||||
dialog.FileName = "StepManiaX settings"; |
||||
dialog.DefaultExt = ".smxcfg"; |
||||
dialog.Filter = "StepManiaX settings (.smxcfg)|*.smxcfg"; |
||||
bool? result = dialog.ShowDialog(); |
||||
if(result == null || !(bool)result) |
||||
return; |
||||
|
||||
string json = Helpers.ReadFile(dialog.FileName); |
||||
|
||||
// Apply settings from the file to all active pads. |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
int pad = activePad.Item1; |
||||
SMX.SMXConfig config = activePad.Item2; |
||||
|
||||
SMXHelpers.ImportSettingsFromJSON(json, ref config); |
||||
SMX.SMX.SetConfig(pad, config); |
||||
} |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
private void LoadGIF(object sender, RoutedEventArgs e) |
||||
{ |
||||
// If the "load idle GIF" button was pressed, load the released animation. |
||||
// Otherwise, load the pressed animation. |
||||
bool pressed = sender == this.LoadPressed; |
||||
|
||||
// Prompt for a file to read. |
||||
Microsoft.Win32.OpenFileDialog dialog = new Microsoft.Win32.OpenFileDialog(); |
||||
dialog.FileName = "Select an animated GIF"; |
||||
dialog.DefaultExt = ".gif"; |
||||
dialog.Filter = "Animated GIF (.gif)|*.gif"; |
||||
bool? result = dialog.ShowDialog(); |
||||
if(result == null || !(bool)result) |
||||
return; |
||||
|
||||
byte[] buf = Helpers.ReadBinaryFile(dialog.FileName); |
||||
SMX.SMX.LightsType type = pressed ? SMX.SMX.LightsType.LightsType_Pressed : SMX.SMX.LightsType.LightsType_Released; |
||||
|
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
int pad = activePad.Item1; |
||||
|
||||
// Load the animation. |
||||
string error; |
||||
if(!SMX.SMX.LightsAnimation_Load(buf, pad, type, out error)) |
||||
{ |
||||
// Any errors here are problems with the GIF, so there's no point trying |
||||
// to load it for the second pad if the first returns an error. Just show the |
||||
// error and stop. |
||||
MessageBox.Show(error, "Error", MessageBoxButton.OK, MessageBoxImage.Warning); |
||||
|
||||
// Return without saving to settings on error. |
||||
return; |
||||
} |
||||
|
||||
// Save the GIF to disk so we can load it quickly later. |
||||
Helpers.SaveAnimationToDisk(pad, type, buf); |
||||
|
||||
// Refresh after loading a GIF to update the "Leave this application running" text. |
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(null); |
||||
} |
||||
|
||||
// For firmwares that support it, upload the animation to the pad now. Otherwise, |
||||
// we'll run the animation directly. |
||||
foreach(Tuple<int, SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
int pad = activePad.Item1; |
||||
|
||||
SMX.SMXConfig config; |
||||
if(!SMX.SMX.GetConfig(pad, out config)) |
||||
continue; |
||||
|
||||
if(config.masterVersion >= 4) |
||||
UploadLatestGIF(); |
||||
|
||||
break; |
||||
} |
||||
} |
||||
|
||||
private void UploadLatestGIF() |
||||
{ |
||||
// Create a progress window. Center it on top of the main window. |
||||
ProgressWindow dialog = new ProgressWindow(); |
||||
dialog.Left = (Left + Width/2) - (dialog.Width/2); |
||||
dialog.Top = (Top + Height/2) - (dialog.Height/2); |
||||
dialog.Title = "Storing animations on pad..."; |
||||
|
||||
int[] CurrentProgress = new int[] { 0, 0 }; |
||||
|
||||
// Upload graphics for all connected pads. If two pads are connected |
||||
// we can start both of these simultaneously, and they'll be sent in |
||||
// parallel. |
||||
int total = 0; |
||||
foreach(Tuple<int,SMX.SMXConfig> activePad in ActivePad.ActivePads()) |
||||
{ |
||||
int pad = activePad.Item1; |
||||
SMX.SMX.LightsUpload_BeginUpload(pad, delegate(int progress) { |
||||
// This is called from a thread, so dispatch back to the main thread. |
||||
Dispatcher.Invoke(delegate() { |
||||
// Store progress, so we can sum both pads. |
||||
CurrentProgress[pad] = progress; |
||||
|
||||
dialog.SetProgress(CurrentProgress[0] + CurrentProgress[1]); |
||||
if(progress == 100) |
||||
dialog.Close(); |
||||
}); |
||||
}); |
||||
|
||||
// Each pad that we start uploading to is 100 units of progress. |
||||
total += 100; |
||||
dialog.SetTotal(total); |
||||
} |
||||
|
||||
// Show the progress window as a modal dialog. This function won't return |
||||
// until we call dialog.Close above. |
||||
dialog.ShowDialog(); |
||||
} |
||||
|
||||
const int WM_SYSCOMMAND = 0x0112; |
||||
const int SC_MINIMIZE = 0xF020; |
||||
private IntPtr WndProcHook(IntPtr hwnd, int msg, IntPtr wparam, IntPtr lparam, ref bool handled) |
||||
{ |
||||
App application = (App) Application.Current; |
||||
|
||||
if(msg == WM_SYSCOMMAND && ((int)wparam & 0xFFF0) == SC_MINIMIZE) |
||||
{ |
||||
// Cancel minimize, and call MinimizeToTray instead. |
||||
handled = true; |
||||
application.MinimizeToTray(); |
||||
} |
||||
|
||||
return IntPtr.Zero; |
||||
} |
||||
|
||||
private void MainTab_Selected(object sender, RoutedEventArgs e) |
||||
{ |
||||
if(Main.SelectedItem == SensitivityTab) |
||||
{ |
||||
// Refresh the threshold sliders, in case the enabled panels were changed |
||||
// on the advanced tab. |
||||
CreateThresholdSliders(); |
||||
} |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,15 @@ |
||||
<Window x:Class="smx_config.ProgressWindow" |
||||
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" |
||||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
||||
xmlns:d="http://schemas.microsoft.com/expression/blend/2008" |
||||
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" |
||||
mc:Ignorable="d" |
||||
Icon="Resources/window icon.png" |
||||
Background="#DDD" |
||||
Height="100" Width="325" ResizeMode="NoResize"> |
||||
<ProgressBar Name="ProgressBar" |
||||
Width="300" Height="50" |
||||
Value="0" |
||||
Maximum="100" |
||||
/> |
||||
</Window> |
||||
@ -0,0 +1,45 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Runtime.InteropServices; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Interop; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public partial class ProgressWindow: Window |
||||
{ |
||||
private const int GWL_STYLE = -16; |
||||
private const int WS_SYSMENU = 0x80000; |
||||
[DllImport("user32.dll", SetLastError = true)] |
||||
private static extern int GetWindowLong(IntPtr hWnd, int nIndex); |
||||
[DllImport("user32.dll")] |
||||
private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong); |
||||
|
||||
public ProgressWindow() |
||||
{ |
||||
InitializeComponent(); |
||||
|
||||
// Hide the window close button, since we can't easily cancel. |
||||
Loaded += delegate(object sender, RoutedEventArgs e) { |
||||
var hwnd = new WindowInteropHelper(this).Handle; |
||||
SetWindowLong(hwnd, GWL_STYLE, GetWindowLong(hwnd, GWL_STYLE) & ~WS_SYSMENU); |
||||
}; |
||||
} |
||||
|
||||
public void SetTotal(int total) |
||||
{ |
||||
ProgressBar.Maximum = total; |
||||
} |
||||
|
||||
public void SetProgress(int progress) |
||||
{ |
||||
ProgressBar.Value = progress; |
||||
} |
||||
|
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
} |
||||
} |
||||
} |
||||
|
After Width: | Height: | Size: 3.5 KiB |
|
After Width: | Height: | Size: 17 KiB |
|
After Width: | Height: | Size: 108 B |
|
After Width: | Height: | Size: 141 B |
|
After Width: | Height: | Size: 2.4 KiB |
|
After Width: | Height: | Size: 2.3 KiB |
|
After Width: | Height: | Size: 2.4 KiB |
|
After Width: | Height: | Size: 2.4 KiB |
|
After Width: | Height: | Size: 2.5 KiB |
|
After Width: | Height: | Size: 37 KiB |
|
After Width: | Height: | Size: 11 KiB |
|
After Width: | Height: | Size: 37 KiB |
|
After Width: | Height: | Size: 25 KiB |
@ -0,0 +1,652 @@ |
||||
using System; |
||||
using System.Runtime.InteropServices; |
||||
using smx_config; |
||||
|
||||
// This is a binding to the native SMX.dll. |
||||
namespace SMX |
||||
{ |
||||
[StructLayout(LayoutKind.Sequential, Pack=1)] |
||||
public struct SMXInfo { |
||||
[MarshalAs(UnmanagedType.I1)] // work around C# bug: marshals bool as int |
||||
public bool connected; |
||||
|
||||
// The 32-byte hex serial number of the device, followed by '\0'. |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 33)] |
||||
public byte[] m_Serial; |
||||
|
||||
public Int16 m_iFirmwareVersion; |
||||
|
||||
// Padding to make this the same size as native, where MSVC adds padding even though |
||||
// we tell it not to: |
||||
private Byte dummy; |
||||
}; |
||||
|
||||
// Bits for SMXConfig::flags. |
||||
public enum SMXConfigFlags { |
||||
AutoLightingUsePressedAnimations = 1 << 0, |
||||
PlatformFlags_FSR = 1 << 1, |
||||
}; |
||||
|
||||
[Serializable] |
||||
public struct PackedSensorSettings { |
||||
// Load cell thresholds: |
||||
public Byte loadCellLowThreshold; |
||||
public Byte loadCellHighThreshold; |
||||
|
||||
// FSR thresholds (16-bit): |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] |
||||
public Byte[] fsrLowThreshold; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)] |
||||
public Byte[] fsrHighThreshold; |
||||
|
||||
public UInt16 combinedLowThreshold; |
||||
public UInt16 combinedHighThreshold; |
||||
|
||||
// This must be left unchanged. |
||||
public UInt16 reserved; |
||||
}; |
||||
|
||||
[StructLayout(LayoutKind.Sequential, Pack=1)] |
||||
[Serializable] |
||||
public struct SMXConfig { |
||||
public Byte masterVersion; |
||||
public Byte configVersion; |
||||
|
||||
// Packed flags (SMXConfigFlags). |
||||
public Byte flags; |
||||
|
||||
public UInt16 debounceNodelayMilliseconds; |
||||
public UInt16 debounceDelayMs; |
||||
public UInt16 panelDebounceMicroseconds; |
||||
public Byte autoCalibrationMaxDeviation; |
||||
public Byte badSensorMinimumDelaySeconds; |
||||
public UInt16 autoCalibrationAveragesPerUpdate; |
||||
public UInt16 autoCalibrationSamplesPerAverage; |
||||
public UInt16 autoCalibrationMaxTare; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 5)] |
||||
public Byte[] enabledSensors; |
||||
|
||||
public Byte autoLightsTimeout; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3*9)] |
||||
public Byte[] stepColor; |
||||
|
||||
// The default color to set the platform LED strip to. |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 3)] |
||||
public Byte[] platformStripColor; |
||||
|
||||
// Which panels to enable auto-lighting for. Disabled panels will be unlit. |
||||
// 0x01 = panel 0, 0x02 = panel 1, 0x04 = panel 2, etc. This only affects |
||||
// the master controller's built-in auto lighting and not lights data send |
||||
// from the SDK. |
||||
public UInt16 autoLightPanelMask; |
||||
|
||||
public Byte panelRotation; |
||||
|
||||
// Per-panel sensor settings: |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)] |
||||
public PackedSensorSettings[] panelSettings; |
||||
|
||||
// These are internal tunables and should be left unchanged. |
||||
public Byte preDetailsDelayMilliseconds; |
||||
|
||||
// Pad this struct to exactly 250 bytes. |
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 49)] |
||||
public Byte[] padding; |
||||
|
||||
// It would be simpler to set flags to [MarshalAs(UnmanagedType.U8)], but |
||||
// that doesn't work. |
||||
public SMXConfigFlags configFlags { |
||||
get { |
||||
return (SMXConfigFlags) flags; |
||||
} |
||||
|
||||
set { |
||||
flags = (Byte) value; |
||||
} |
||||
} |
||||
|
||||
// Return true if the platform is using FSRs, or false for load cells. |
||||
public bool fsr() |
||||
{ |
||||
return masterVersion >= 4 && (configFlags & SMXConfigFlags.PlatformFlags_FSR) != 0; |
||||
} |
||||
|
||||
// Return true if the low threshold is set too low. |
||||
// |
||||
// Higher low threshold values make the panel respond to the panel being released more |
||||
// quickly. It shouldn't be set too low. |
||||
public bool ShowThresholdWarning(int panel, int sensor) |
||||
{ |
||||
if(!fsr()) |
||||
return false; |
||||
|
||||
// Don't show warnings for disabled panels. |
||||
if(!GetEnabledPanels()[panel]) |
||||
return false; |
||||
|
||||
int lower = panelSettings[panel].fsrLowThreshold[sensor]; |
||||
int MinimumRecommendedLowThreshold = 140; |
||||
return lower < MinimumRecommendedLowThreshold; |
||||
} |
||||
|
||||
// enabledSensors is a mask of which panels are enabled. Return this as an array |
||||
// for convenience. |
||||
public bool[] GetEnabledPanels() |
||||
{ |
||||
return new bool[] { |
||||
(enabledSensors[0] & 0xF0) != 0, |
||||
(enabledSensors[0] & 0x0F) != 0, |
||||
(enabledSensors[1] & 0xF0) != 0, |
||||
(enabledSensors[1] & 0x0F) != 0, |
||||
(enabledSensors[2] & 0xF0) != 0, |
||||
(enabledSensors[2] & 0x0F) != 0, |
||||
(enabledSensors[3] & 0xF0) != 0, |
||||
(enabledSensors[3] & 0x0F) != 0, |
||||
(enabledSensors[4] & 0xF0) != 0, |
||||
}; |
||||
} |
||||
|
||||
// Set enabledSensors from an array returned from GetEnabledPanels. |
||||
public void SetEnabledPanels(bool[] panels) |
||||
{ |
||||
for(int i = 0; i < 5; ++i) |
||||
enabledSensors[i] = 0; |
||||
|
||||
if(panels[0]) enabledSensors[0] |= 0xF0; |
||||
if(panels[1]) enabledSensors[0] |= 0x0F; |
||||
if(panels[2]) enabledSensors[1] |= 0xF0; |
||||
if(panels[3]) enabledSensors[1] |= 0x0F; |
||||
if(panels[4]) enabledSensors[2] |= 0xF0; |
||||
if(panels[5]) enabledSensors[2] |= 0x0F; |
||||
if(panels[6]) enabledSensors[3] |= 0xF0; |
||||
if(panels[7]) enabledSensors[3] |= 0x0F; |
||||
if(panels[8]) enabledSensors[4] |= 0xF0; |
||||
} |
||||
|
||||
// Return the index of the first enabled panel, or 1 (up) if no panels |
||||
// are enabled. |
||||
public int GetFirstEnabledPanel() |
||||
{ |
||||
bool[] enabledPanels = GetEnabledPanels(); |
||||
for(int i = 0; i < 9; ++i) |
||||
{ |
||||
if(enabledPanels[i]) |
||||
return i; |
||||
} |
||||
|
||||
return 0; |
||||
} |
||||
|
||||
// The layout of this structure (and the underlying C struct) matches the firmware configuration |
||||
// data. This is a bit inconvenient for the panel thresholds which aren't contiguous, so these |
||||
// helpers just convert them to and from arrays. |
||||
// XXX: used? |
||||
public Byte[] GetLowThresholds() |
||||
{ |
||||
return new Byte[] { |
||||
panelSettings[0].loadCellLowThreshold, |
||||
panelSettings[1].loadCellLowThreshold, |
||||
panelSettings[2].loadCellLowThreshold, |
||||
panelSettings[3].loadCellLowThreshold, |
||||
panelSettings[4].loadCellLowThreshold, |
||||
panelSettings[5].loadCellLowThreshold, |
||||
panelSettings[6].loadCellLowThreshold, |
||||
panelSettings[7].loadCellLowThreshold, |
||||
panelSettings[8].loadCellLowThreshold, |
||||
}; |
||||
} |
||||
|
||||
public Byte[] GetHighThresholds() |
||||
{ |
||||
return new Byte[] { |
||||
panelSettings[0].loadCellHighThreshold, |
||||
panelSettings[1].loadCellHighThreshold, |
||||
panelSettings[2].loadCellHighThreshold, |
||||
panelSettings[3].loadCellHighThreshold, |
||||
panelSettings[4].loadCellHighThreshold, |
||||
panelSettings[5].loadCellHighThreshold, |
||||
panelSettings[6].loadCellHighThreshold, |
||||
panelSettings[7].loadCellHighThreshold, |
||||
panelSettings[8].loadCellHighThreshold, |
||||
}; |
||||
} |
||||
|
||||
public void SetLowThresholds(Byte[] values) |
||||
{ |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
panelSettings[panel].loadCellLowThreshold = values[panel]; |
||||
} |
||||
|
||||
public void SetHighThresholds(Byte[] values) |
||||
{ |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
panelSettings[panel].loadCellHighThreshold = values[panel]; |
||||
} |
||||
|
||||
// Create an empty SMXConfig. |
||||
static public SMXConfig Create() |
||||
{ |
||||
SMXConfig result = new SMXConfig(); |
||||
result.enabledSensors = new Byte[5]; |
||||
result.stepColor = new Byte[3*9]; |
||||
result.panelSettings = new PackedSensorSettings[9]; |
||||
result.platformStripColor = new Byte[3]; |
||||
for(int panel = 0; panel < 9; ++panel) |
||||
{ |
||||
result.panelSettings[panel].fsrLowThreshold = new Byte[4]; |
||||
result.panelSettings[panel].fsrHighThreshold = new Byte[4]; |
||||
} |
||||
return result; |
||||
} |
||||
|
||||
// autoLightPanelMask controls which lights the master controller will light. Only the |
||||
// first 9 bits (0x1ff) are meaningful for our 9 panels. As a special case, we use 0xFFFF |
||||
// to indicate that "light all panels" was checked. The controller doesn't care about this |
||||
// since it only looks at the first 9 bits. |
||||
public bool getLightAllPanelsMode() { return autoLightPanelMask == 0xFFFF; } |
||||
|
||||
public void setLightAllPanelsMode(bool enable) |
||||
{ |
||||
if(enable) |
||||
autoLightPanelMask = 0xFFFF; |
||||
else |
||||
refreshAutoLightPanelMask(false); |
||||
} |
||||
|
||||
// If we're not in light all panels mode, set autoLightPanelMask to the currently |
||||
// enabled panels. This should be called if enabledSensors is changed. |
||||
public void refreshAutoLightPanelMask(bool onlyIfEnabled=true) |
||||
{ |
||||
if(onlyIfEnabled && getLightAllPanelsMode()) |
||||
return; |
||||
|
||||
// Set autoLightPanelMask to just the enabled panels. |
||||
autoLightPanelMask = 0; |
||||
bool[] enabledPanels = GetEnabledPanels(); |
||||
for(int i = 0; i < 9; ++i) |
||||
if(enabledPanels[i]) |
||||
autoLightPanelMask |= (UInt16) (1 << i); |
||||
} |
||||
}; |
||||
|
||||
public struct SMXSensorTestModeData |
||||
{ |
||||
// If false, sensorLevel[n][*] is zero because we didn't receive a response from that panel. |
||||
[MarshalAs(UnmanagedType.ByValArray, ArraySubType=UnmanagedType.I1, SizeConst = 9)] |
||||
public bool[] bHaveDataFromPanel; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9*4)] |
||||
public Int16[] sensorLevel; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, ArraySubType=UnmanagedType.I1, SizeConst = 9*4)] |
||||
public bool[] bBadSensorInput; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 9)] |
||||
public int[] iDIPSwitchPerPanel; |
||||
|
||||
[MarshalAs(UnmanagedType.ByValArray, ArraySubType=UnmanagedType.I1, SizeConst = 9*4)] |
||||
public bool[] iWrongSensorJumper; |
||||
|
||||
public override bool Equals(object obj) |
||||
{ |
||||
SMXSensorTestModeData other = (SMXSensorTestModeData) obj; |
||||
return |
||||
Helpers.SequenceEqual(bHaveDataFromPanel, other.bHaveDataFromPanel) && |
||||
Helpers.SequenceEqual(sensorLevel, other.sensorLevel) && |
||||
Helpers.SequenceEqual(bBadSensorInput, other.bBadSensorInput) && |
||||
Helpers.SequenceEqual(iDIPSwitchPerPanel, other.iDIPSwitchPerPanel) && |
||||
Helpers.SequenceEqual(iWrongSensorJumper, other.iWrongSensorJumper); |
||||
} |
||||
|
||||
// Dummy override to silence a bad warning. We don't use these in containers that need |
||||
// a hash code implementation. |
||||
public override int GetHashCode() { return base.GetHashCode(); } |
||||
|
||||
|
||||
public bool AnySensorsOnPanelNotResponding(int panel) |
||||
{ |
||||
if(!bHaveDataFromPanel[panel]) |
||||
return false; |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
if(bBadSensorInput[panel*4+sensor]) |
||||
return true; |
||||
|
||||
return false; |
||||
} |
||||
|
||||
public bool AnyBadJumpersOnPanel(int panel) |
||||
{ |
||||
if(!bHaveDataFromPanel[panel]) |
||||
return false; |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
if(iWrongSensorJumper[panel*4+sensor]) |
||||
return true; |
||||
|
||||
return false; |
||||
} |
||||
}; |
||||
|
||||
public static class SMX |
||||
{ |
||||
[System.Flags] |
||||
enum LoadLibraryFlags : uint |
||||
{ |
||||
None = 0, |
||||
DONT_RESOLVE_DLL_REFERENCES = 0x00000001, |
||||
LOAD_IGNORE_CODE_AUTHZ_LEVEL = 0x00000010, |
||||
LOAD_LIBRARY_AS_DATAFILE = 0x00000002, |
||||
LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE = 0x00000040, |
||||
LOAD_LIBRARY_AS_IMAGE_RESOURCE = 0x00000020, |
||||
LOAD_LIBRARY_SEARCH_APPLICATION_DIR = 0x00000200, |
||||
LOAD_LIBRARY_SEARCH_DEFAULT_DIRS = 0x00001000, |
||||
LOAD_LIBRARY_SEARCH_DLL_LOAD_DIR = 0x00000100, |
||||
LOAD_LIBRARY_SEARCH_SYSTEM32 = 0x00000800, |
||||
LOAD_LIBRARY_SEARCH_USER_DIRS = 0x00000400, |
||||
LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008 |
||||
} |
||||
|
||||
[DllImport("kernel32", SetLastError=true)] |
||||
static extern IntPtr LoadLibrary(string lpFileName); |
||||
[DllImport("kernel32.dll", SetLastError = true)] |
||||
static extern IntPtr LoadLibraryEx(string lpFileName, IntPtr hReservedNull, LoadLibraryFlags dwFlags); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_Start( |
||||
[MarshalAs(UnmanagedType.FunctionPtr)] InternalUpdateCallback callback, |
||||
IntPtr user); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_Stop(); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_GetInfo(int pad, out SMXInfo info); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern UInt16 SMX_GetInputState(int pad); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
[return:MarshalAs(UnmanagedType.I1)] |
||||
private static extern bool SMX_GetConfig(int pad, out SMXConfig config); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_SetConfig(int pad, ref SMXConfig config); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_FactoryReset(int pad); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_ForceRecalibration(int pad); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_SetTestMode(int pad, int mode); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_GetTestData(int pad, out SMXSensorTestModeData data); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern void SMX_SetPanelTestMode(int mode); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_SetLights2(byte[] buf, int lightDataSize); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_SetPlatformLights(byte[] buf, int lightDataSize); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl)] |
||||
private static extern bool SMX_ReenableAutoLights(); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] |
||||
private static extern IntPtr SMX_Version(); |
||||
|
||||
public enum LightsType |
||||
{ |
||||
LightsType_Released, // animation while panels are released |
||||
LightsType_Pressed, // animation while panel is pressed |
||||
}; |
||||
|
||||
public static string Version() |
||||
{ |
||||
if(!DLLAvailable()) return ""; |
||||
|
||||
// I can't find any way to marshal a simple null-terminated string. Marshalling |
||||
// UnmanagedType.LPStr tries to deallocate the string, which crashes since it's |
||||
// a static string. |
||||
unsafe { |
||||
sbyte *p = (sbyte *) SMX_Version(); |
||||
int length = 0; |
||||
while(p[length] != 0) |
||||
++length; |
||||
return new string(p, 0, length); |
||||
} |
||||
} |
||||
|
||||
// Check if the native DLL is available. This is mostly to avoid exceptions in the designer. |
||||
// This returns false if the DLL doesn't load. |
||||
public static bool DLLAvailable() |
||||
{ |
||||
return LoadLibrary("SMX.dll") != IntPtr.Zero; |
||||
} |
||||
|
||||
// Check if the native DLL exists. This will return false if SMX.dll is missing entirely, |
||||
// but not if it fails to load for another reason like runtime dependencies. This just lets |
||||
// us print a more specific error message. |
||||
public static bool DLLExists() |
||||
{ |
||||
return LoadLibraryEx("SMX.dll", (IntPtr)0, LoadLibraryFlags.LOAD_LIBRARY_AS_DATAFILE_EXCLUSIVE) != IntPtr.Zero; |
||||
} |
||||
|
||||
public delegate void UpdateCallback(int PadNumber, SMXUpdateCallbackReason reason); |
||||
|
||||
// The C API allows a user pointer, but we don't use that here. |
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] |
||||
public delegate void InternalUpdateCallback(int PadNumber, int reason, IntPtr user); |
||||
private static InternalUpdateCallback CurrentUpdateCallback; |
||||
|
||||
public static void Start(UpdateCallback callback) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
// Sanity check SMXConfig, which should be 250 bytes. If this is incorrect, |
||||
// check the padding array. |
||||
{ |
||||
SMXConfig config = new SMXConfig(); |
||||
int bytes = Marshal.SizeOf(config); |
||||
if(bytes != 250) |
||||
throw new Exception("SMXConfig is " + bytes + " bytes, but should be 250 bytes"); |
||||
} |
||||
|
||||
// Make a wrapper to convert from the native enum to SMXUpdateCallbackReason. |
||||
InternalUpdateCallback NewCallback = delegate(int PadNumber, int reason, IntPtr user) { |
||||
SMXUpdateCallbackReason ReasonEnum = (SMXUpdateCallbackReason) Enum.ToObject(typeof(SMXUpdateCallbackReason), reason); |
||||
callback(PadNumber, ReasonEnum); |
||||
}; |
||||
if(callback == null) |
||||
NewCallback = null; |
||||
|
||||
SMX_Start(NewCallback, IntPtr.Zero); |
||||
|
||||
// Keep a reference to the delegate, so it isn't garbage collected. Do this last. Once |
||||
// we do this the old callback may be collected, so we want to be sure that native code |
||||
// has already updated the callback. |
||||
CurrentUpdateCallback = NewCallback; |
||||
|
||||
Console.WriteLine("Struct sizes (C#): " + |
||||
Marshal.SizeOf(typeof(SMXConfig)) + " " + |
||||
Marshal.SizeOf(typeof(SMXInfo)) + " " + |
||||
Marshal.SizeOf(typeof(SMXSensorTestModeData))); |
||||
} |
||||
|
||||
public static void Stop() |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_Stop(); |
||||
} |
||||
|
||||
public enum SMXUpdateCallbackReason { |
||||
Updated, |
||||
FactoryResetCommandComplete |
||||
}; |
||||
|
||||
public static void GetInfo(int pad, out SMXInfo info) |
||||
{ |
||||
if(!DLLAvailable()) { |
||||
info = new SMXInfo(); |
||||
return; |
||||
} |
||||
SMX_GetInfo(pad, out info); |
||||
} |
||||
|
||||
public static UInt16 GetInputState(int pad) |
||||
{ |
||||
if(!DLLAvailable()) |
||||
return 0; |
||||
|
||||
return SMX_GetInputState(pad); |
||||
} |
||||
|
||||
public static bool GetConfig(int pad, out SMXConfig config) |
||||
{ |
||||
if(!DLLAvailable()) { |
||||
config = SMXConfig.Create(); |
||||
return false; |
||||
} |
||||
|
||||
return SMX_GetConfig(pad, out config); |
||||
} |
||||
|
||||
public static void SetConfig(int pad, SMXConfig config) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
// Always bump the configVersion to the version we support on write. |
||||
config.configVersion = 2; |
||||
|
||||
SMX_SetConfig(pad, ref config); |
||||
} |
||||
|
||||
public enum SensorTestMode { |
||||
Off = 0, |
||||
UncalibratedValues = '0', |
||||
CalibratedValues = '1', |
||||
Noise = '2', |
||||
Tare = '3', |
||||
}; |
||||
|
||||
public static void SetSensorTestMode(int pad, SensorTestMode mode) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_SetTestMode(pad, (int) mode); |
||||
} |
||||
|
||||
public static bool GetTestData(int pad, out SMXSensorTestModeData data) |
||||
{ |
||||
if(!DLLAvailable()) { |
||||
data = new SMXSensorTestModeData(); |
||||
return false; |
||||
} |
||||
|
||||
return SMX_GetTestData(pad, out data); |
||||
} |
||||
|
||||
public enum PanelTestMode { |
||||
Off = '0', |
||||
PressureTest = '1', |
||||
}; |
||||
|
||||
public static void SetPanelTestMode(PanelTestMode mode) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_SetPanelTestMode((int) mode); |
||||
} |
||||
|
||||
public static void FactoryReset(int pad) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_FactoryReset(pad); |
||||
} |
||||
|
||||
|
||||
public static void ForceRecalibration(int pad) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_ForceRecalibration(pad); |
||||
} |
||||
|
||||
public static void SetLights2(byte[] buf) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
SMX_SetLights2(buf, buf.Length); |
||||
} |
||||
|
||||
public static void SMX_SetPlatformLights(byte[] buf) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
SMX_SetPlatformLights(buf, buf.Length); |
||||
} |
||||
|
||||
public static void ReenableAutoLights() |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
|
||||
SMX_ReenableAutoLights(); |
||||
} |
||||
|
||||
// SMXPanelAnimation |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] |
||||
[return:MarshalAs(UnmanagedType.I1)] |
||||
private static extern bool SMX_LightsAnimation_Load(byte[] buf, int size, int pad, int type, out IntPtr error); |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] |
||||
private static extern void SMX_LightsAnimation_SetAuto(bool enable); |
||||
|
||||
public static bool LightsAnimation_Load(byte[] buf, int pad, LightsType type, out string error) |
||||
{ |
||||
if(!DLLAvailable()) |
||||
{ |
||||
error = "SMX.DLL not available"; |
||||
return false; |
||||
} |
||||
|
||||
error = ""; |
||||
IntPtr error_pointer; |
||||
bool result = SMX_LightsAnimation_Load(buf, buf.Length, pad, (int) type, out error_pointer); |
||||
if(!result) |
||||
{ |
||||
// SMX_LightsAnimation_Load takes a char **error, which is set to the error |
||||
// string. |
||||
error = Marshal.PtrToStringAnsi(error_pointer); |
||||
} |
||||
|
||||
return result; |
||||
} |
||||
|
||||
public static void LightsAnimation_SetAuto(bool enable) |
||||
{ |
||||
if(!DLLAvailable()) return; |
||||
SMX_LightsAnimation_SetAuto(enable); |
||||
} |
||||
|
||||
// SMXPanelAnimationUpload |
||||
[DllImport("SMX.dll", CallingConvention = CallingConvention.Cdecl, CharSet = CharSet.Ansi)] |
||||
private static extern void SMX_LightsUpload_BeginUpload(int pad, |
||||
[MarshalAs(UnmanagedType.FunctionPtr)] InternalLightsUploadCallback callback, |
||||
IntPtr user); |
||||
|
||||
public delegate void LightsUploadCallback(int progress); |
||||
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] |
||||
private delegate void InternalLightsUploadCallback(int reason, IntPtr user); |
||||
public static void LightsUpload_BeginUpload(int pad, LightsUploadCallback callback) |
||||
{ |
||||
if(!DLLAvailable()) |
||||
return; |
||||
|
||||
GCHandle handle = new GCHandle(); |
||||
InternalLightsUploadCallback wrapper = delegate(int progress, IntPtr user) |
||||
{ |
||||
try { |
||||
callback(progress); |
||||
} finally { |
||||
// When progress = 100, this is the final call and we can release this |
||||
// object to GC. |
||||
if(progress == 100) |
||||
handle.Free(); |
||||
} |
||||
}; |
||||
|
||||
// Pin the callback until we get the last call. |
||||
handle = GCHandle.Alloc(wrapper); |
||||
|
||||
SMX_LightsUpload_BeginUpload(pad, wrapper, IntPtr.Zero); |
||||
} |
||||
} |
||||
} |
||||
@ -0,0 +1,102 @@ |
||||
using System; |
||||
using System.Collections.Generic; |
||||
using System.Windows; |
||||
using System.Windows.Controls; |
||||
using System.Windows.Controls.Primitives; |
||||
|
||||
namespace smx_config |
||||
{ |
||||
public class SensorSelectionButton: ToggleButton |
||||
{ |
||||
} |
||||
|
||||
// A control with one button for each of four sensors: |
||||
class SensorSelector: Control |
||||
{ |
||||
// The panel we're editing (0-8). |
||||
public static readonly DependencyProperty PanelProperty = DependencyProperty.RegisterAttached("Panel", |
||||
typeof(int), typeof(SensorSelector), new FrameworkPropertyMetadata(0)); |
||||
|
||||
public int Panel { |
||||
get { return (int) this.GetValue(PanelProperty); } |
||||
set { this.SetValue(PanelProperty, value); } |
||||
} |
||||
|
||||
ToggleButton[] SensorSelectionButtons = new ToggleButton[4]; |
||||
public override void OnApplyTemplate() |
||||
{ |
||||
base.OnApplyTemplate(); |
||||
|
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
{ |
||||
int ThisSensor = sensor; // bind |
||||
SensorSelectionButtons[sensor] = GetTemplateChild("Sensor" + sensor) as ToggleButton; |
||||
SensorSelectionButtons[sensor].Click += delegate(object sender, RoutedEventArgs e) |
||||
{ |
||||
ClickedSensorButton(ThisSensor); |
||||
}; |
||||
} |
||||
|
||||
// These settings are stored in the application settings, not on the pad. However, |
||||
// we treat changes to this as config changes, so we can use the same OnConfigChange |
||||
// method for updating. |
||||
OnConfigChange onConfigChange; |
||||
onConfigChange = new OnConfigChange(this, delegate(LoadFromConfigDelegateArgs args) { |
||||
LoadUIFromConfig(args); |
||||
}); |
||||
} |
||||
|
||||
private void ClickedSensorButton(int sensor) |
||||
{ |
||||
// Toggle the clicked sensor. |
||||
Console.WriteLine("Clicked sensor " + sensor); |
||||
List<ThresholdSettings.PanelAndSensor> customSensors = ThresholdSettings.GetCustomSensors(); |
||||
bool enabled = !IsSensorEnabled(customSensors, sensor); |
||||
|
||||
if(enabled) |
||||
customSensors.Add(new ThresholdSettings.PanelAndSensor(Panel, sensor)); |
||||
else |
||||
customSensors.Remove(new ThresholdSettings.PanelAndSensor(Panel, sensor)); |
||||
ThresholdSettings.SetCustomSensors(customSensors); |
||||
|
||||
// Sync thresholds after changing custom sensors. |
||||
ThresholdSettings.SyncSliderThresholds(); |
||||
|
||||
CurrentSMXDevice.singleton.FireConfigurationChanged(this); |
||||
} |
||||
|
||||
// Return true if the given sensor is included in custom-sensors. |
||||
bool IsSensorEnabled(List<ThresholdSettings.PanelAndSensor> customSensors, int sensor) |
||||
{ |
||||
foreach(ThresholdSettings.PanelAndSensor panelAndSensor in customSensors) |
||||
{ |
||||
if(panelAndSensor.panel == Panel && panelAndSensor.sensor == sensor) |
||||
return true; |
||||
} |
||||
return false; |
||||
} |
||||
|
||||
private void LoadUIFromConfig(LoadFromConfigDelegateArgs args) |
||||
{ |
||||
// Check the selected custom-sensors. |
||||
List<ThresholdSettings.PanelAndSensor> customSensors = ThresholdSettings.GetCustomSensors(); |
||||
for(int sensor = 0; sensor < 4; ++sensor) |
||||
SensorSelectionButtons[sensor].IsChecked = IsSensorEnabled(customSensors, sensor); |
||||
} |
||||
} |
||||
|
||||
// This dialog sets which sensors are controlled by custom-sensors. The actual work is done |
||||
// by SensorSelector above. |
||||
public partial class SetCustomSensors: Window |
||||
{ |
||||
public SetCustomSensors() |
||||
{ |
||||
InitializeComponent(); |
||||
} |
||||
|
||||
private void OK_Click(object sender, RoutedEventArgs e) |
||||
{ |
||||
Close(); |
||||
} |
||||
} |
||||
} |
||||
File diff suppressed because it is too large
Load Diff
@ -0,0 +1 @@ |
||||
InstallSMXConfig.exe |
||||
@ -0,0 +1,168 @@ |
||||
!include "MUI2.nsh" |
||||
|
||||
Name "StepManiaX Platform" |
||||
OutFile "SMXConfigInstaller.exe" |
||||
|
||||
!define MUI_ICON "..\window icon.ico" |
||||
|
||||
InstallDir "$PROGRAMFILES32\SMXConfig" |
||||
!insertmacro MUI_UNPAGE_CONFIRM |
||||
!insertmacro MUI_UNPAGE_INSTFILES |
||||
;!insertmacro MUI_PAGE_DIRECTORY |
||||
|
||||
Function InstallNetRuntime |
||||
# Check if .NET 4.5.2 is installed. https://msdn.microsoft.com/en-us/library/hh925568(v=vs.110).aspx |
||||
Var /Global Net4Version |
||||
ReadRegDWORD $Net4Version HKLM "SOFTWARE\Microsoft\NET Framework Setup\NDP\v4\Full" "Release" |
||||
IntCmp $Net4Version 379893 already_installed do_install already_installed |
||||
|
||||
already_installed: |
||||
DetailPrint ".NET runtime 4.5.2 already installed." |
||||
return |
||||
|
||||
do_install: |
||||
|
||||
# Download the runtime. |
||||
NSISdl::download "https://go.microsoft.com/fwlink/?LinkId=397708" "$TEMP\NET452Installer.exe" |
||||
Var /GLOBAL download_result |
||||
Pop $download_result |
||||
DetailPrint "$download_result" |
||||
StrCmp $download_result success download_successful |
||||
|
||||
MessageBox MB_OK|MB_ICONEXCLAMATION "The .NET 4.5.2 runtime couldn't be downloaded." |
||||
return |
||||
|
||||
download_successful: |
||||
|
||||
# Run the installer. |
||||
# We can run this without opening the install dialog like this, but this runtime can take a |
||||
# while to install and it makes it look like the installation has stalled. |
||||
# ExecWait '"$TEMP\NET452Installer.exe" /q /norestart /c:"install /q"' |
||||
ExecWait '"$TEMP\NET452Installer.exe" /passive /norestart /c:"install"' |
||||
FunctionEnd |
||||
|
||||
Function InstallMSVCRuntime |
||||
# Check if the runtime is already installed. |
||||
Var /Global MSVCVersion1 |
||||
Var /Global MSVCVersion2 |
||||
GetDLLVersion "$sysdir\MSVCP140.dll" $MSVCVersion1 $MSVCVersion2 |
||||
StrCmp $MSVCVersion1 "" do_install |
||||
|
||||
DetailPrint "MSVC runtime already installed." |
||||
return |
||||
|
||||
do_install: |
||||
|
||||
DetailPrint "Installing MSVC runtime" |
||||
|
||||
# Download the runtime. |
||||
NSISdl::download "https://go.microsoft.com/fwlink/?LinkId=615459" "$TEMP\vcredist_x86.exe" |
||||
Var /GLOBAL download_result_2 |
||||
Pop $download_result_2 |
||||
DetailPrint "$download_result_2" |
||||
StrCmp $download_result_2 success download_successful |
||||
|
||||
MessageBox MB_OK|MB_ICONEXCLAMATION "The MSVC runtime couldn't be downloaded." |
||||
return |
||||
|
||||
download_successful: |
||||
|
||||
# Run the installer. |
||||
ExecWait '"$TEMP\vcredist_x86.exe" /passive /norestart' |
||||
FunctionEnd |
||||
|
||||
# Global variables and lots of gotos. That's all NSIS can do. I feel like I'm 8 again, writing in BASIC. |
||||
# Also, we need to use some macro nastiness to convince NSIS to include this in both the installer and uninstaller. |
||||
Var /Global "ShutdownRetries" |
||||
!macro myfunc un |
||||
Function ${un}CheckRunning |
||||
# Reset ShutdownRetries. |
||||
StrCpy $ShutdownRetries "0" |
||||
|
||||
retry: |
||||
# Check if SMXConfig is running. For now we use SMXConfigEvent for this, which is used to foreground |
||||
# the application, since it's been around for a while. SMXConfigShutdown is only available in newer |
||||
# versions. |
||||
System::Call 'kernel32::OpenEventW(i 0x00100000, b 0, w "SMXConfigEvent") i .R0' |
||||
IntCmp $R0 0 done |
||||
System::Call 'kernel32::CloseHandle(i $R0)' |
||||
|
||||
try_to_shut_down: |
||||
IntOp $ShutdownRetries $ShutdownRetries + 1 |
||||
IntCmp $ShutdownRetries 10 failed_to_shut_down |
||||
|
||||
# SMXConfig is running. See if SMXConfigShutdown is available, to let us exit it automatically. |
||||
System::Call 'kernel32::OpenEventW(i 0x00100000|0x0002, b 0, w "SMXConfigShutdown") i .R0' |
||||
IntCmp $R0 0 CantShutdownAutomatically |
||||
|
||||
# We have the shutdown handle. Signal it to tell SMXConfig to exit. |
||||
System::Call 'kernel32::SetEvent(i $R0) i .R0' |
||||
System::Call 'kernel32::CloseHandle(i $R0)' |
||||
|
||||
# Wait briefly to give it a chance to shut down, then loop and check that it's shut down. If it isn't, |
||||
# we'll retry a few times. |
||||
Sleep 100 |
||||
goto retry |
||||
# goto done |
||||
|
||||
# System::Call "Kernel32::GetLastError() i() .r1" |
||||
|
||||
failed_to_shut_down: |
||||
StrCpy $ShutdownRetries "0" |
||||
MessageBox MB_RETRYCANCEL|MB_ICONEXCLAMATION "Please close SMXConfig before updating." /SD IDCANCEL IDRETRY retry IDCANCEL cancel |
||||
Quit |
||||
|
||||
CantShutdownAutomatically: |
||||
# SMXConfig is running, but it's an older version that doesn't have a shutdown signal. Ask the |
||||
# user to shut it down. Retry will restart and check if it's not running. |
||||
MessageBox MB_RETRYCANCEL|MB_ICONEXCLAMATION "Please close SMXConfig." /SD IDCANCEL IDRETRY retry IDCANCEL cancel |
||||
Quit |
||||
|
||||
cancel: |
||||
Quit |
||||
done: |
||||
FunctionEnd |
||||
!macroend |
||||
|
||||
!insertmacro myfunc "" |
||||
!insertmacro myfunc "un." |
||||
|
||||
Page custom CheckRunning |
||||
Page directory |
||||
Page instfiles |
||||
|
||||
Section |
||||
Call InstallNetRuntime |
||||
Call InstallMSVCRuntime |
||||
|
||||
SetOutPath $INSTDIR |
||||
File "..\..\out\SMX.dll" |
||||
File "..\..\out\SMXConfig.exe" |
||||
|
||||
CreateShortCut "$SMPROGRAMS\StepManiaX Platform.lnk" "$INSTDIR\SMXConfig.exe" |
||||
WriteUninstaller $INSTDIR\uninstall.exe |
||||
|
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"DisplayName" "StepManiaX Platform" |
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"Publisher" "Step Revolution" |
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"DisplayIcon" "$INSTDIR\SMXConfig.exe" |
||||
WriteRegStr HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" \ |
||||
"UninstallString" "$\"$INSTDIR\uninstall.exe$\"" |
||||
SectionEnd |
||||
|
||||
#Section "un.CheckRunning" |
||||
#SectionEnd |
||||
|
||||
Section "Uninstall" |
||||
# Make sure SMXConfig isn't running. |
||||
Call un.CheckRunning |
||||
Delete $INSTDIR\SMX.dll |
||||
Delete $INSTDIR\SMXConfig.exe |
||||
Delete $INSTDIR\uninstall.exe |
||||
rmdir $INSTDIR |
||||
Delete "$SMPROGRAMS\StepManiaX Platform.lnk" |
||||
DeleteRegKey HKLM "Software\Microsoft\Windows\CurrentVersion\Uninstall\StepManiaX Platform" |
||||
SectionEnd |
||||
|
||||
@ -0,0 +1,3 @@ |
||||
@echo off |
||||
"C:\Program Files (x86)\NSIS\makensis.exe" SMX.nsi |
||||
pause |
||||
|
After Width: | Height: | Size: 37 KiB |
Loading…
Reference in new issue