You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
620 lines
23 KiB
620 lines
23 KiB
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,
|
|
};
|
|
|
|
public struct PackedSensorSettings {
|
|
// Load cell thresholds:
|
|
public Byte loadCellLowThreshold;
|
|
public Byte loadCellHighThreshold;
|
|
|
|
// FSR thresholds (16-bit):
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public UInt16[] fsrLowThreshold;
|
|
|
|
[MarshalAs(UnmanagedType.ByValArray, SizeConst = 4)]
|
|
public UInt16[] fsrHighThreshold;
|
|
|
|
// This must be left unchanged.
|
|
public UInt16 reserved;
|
|
};
|
|
|
|
[StructLayout(LayoutKind.Sequential, Pack=1)]
|
|
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 = 13)]
|
|
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;
|
|
}
|
|
|
|
// 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 UInt16[4];
|
|
result.panelSettings[panel].fsrHighThreshold = new UInt16[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_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 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);
|
|
}
|
|
}
|
|
}
|
|
|