mirror of
https://github.com/RawAccelOfficial/rawaccel.git
synced 2025-05-11 10:26:58 +02:00
make profile count dynamic (unlimited)
This commit is contained in:
a1xd
parent
83545569d9
commit
8680805b26
5 changed files with 209 additions and 138 deletions
|
|
@ -5,6 +5,8 @@
|
|||
#include "rawaccel-error.hpp"
|
||||
#include "rawaccel.hpp"
|
||||
|
||||
#include <memory>
|
||||
|
||||
namespace rawaccel {
|
||||
|
||||
inline void io_control(DWORD code, void* in, DWORD in_size, void* out, DWORD out_size)
|
||||
|
|
@ -37,14 +39,54 @@ namespace rawaccel {
|
|||
}
|
||||
}
|
||||
|
||||
inline void read(io_t& args)
|
||||
inline std::unique_ptr<std::byte[]> read()
|
||||
{
|
||||
io_control(READ, NULL, 0, &args, sizeof(io_t));
|
||||
io_base base_data;
|
||||
|
||||
io_control(READ, NULL, 0, &base_data, sizeof(io_base));
|
||||
|
||||
size_t size = sizeof(base_data);
|
||||
|
||||
if (base_data.driver_data_size == 0) {
|
||||
// driver has no data, but it's more useful to return something,
|
||||
// so return a default driver_settings object along with base data
|
||||
|
||||
size += sizeof(driver_settings);
|
||||
base_data.driver_data_size = 1;
|
||||
auto bytes = std::make_unique<std::byte[]>(size);
|
||||
*reinterpret_cast<io_base*>(bytes.get()) = base_data;
|
||||
*reinterpret_cast<driver_settings*>(bytes.get() + sizeof(io_base)) = {};
|
||||
return bytes;
|
||||
}
|
||||
else {
|
||||
size += sizeof(driver_settings) * base_data.driver_data_size;
|
||||
size += sizeof(device_settings) * base_data.device_data_size;
|
||||
auto bytes = std::make_unique<std::byte[]>(size);
|
||||
io_control(READ, NULL, 0, bytes.get(), DWORD(size));
|
||||
return bytes;
|
||||
}
|
||||
}
|
||||
|
||||
inline void write(const io_t& args)
|
||||
// buffer must point to at least sizeof(io_base) bytes
|
||||
inline void write(const void* buffer)
|
||||
{
|
||||
io_control(WRITE, const_cast<io_t*>(&args), sizeof(io_t), NULL, 0);
|
||||
if (buffer == nullptr) throw io_error("write buffer is null");
|
||||
|
||||
auto* base_ptr = static_cast<const io_base*>(buffer);
|
||||
auto size = sizeof(io_base);
|
||||
size += base_ptr->driver_data_size * sizeof(driver_settings);
|
||||
size += base_ptr->device_data_size * sizeof(device_settings);
|
||||
|
||||
if (size > DWORD(-1)) throw io_error("write buffer is too large");
|
||||
|
||||
io_control(WRITE, const_cast<void*>(buffer), DWORD(size), NULL, 0);
|
||||
}
|
||||
|
||||
inline void reset()
|
||||
{
|
||||
io_base base_data{};
|
||||
// all driver/device data is cleared when a default io_base is passed
|
||||
io_control(WRITE, &base_data, sizeof(io_base), NULL, 0);
|
||||
}
|
||||
|
||||
inline version_t get_version()
|
||||
|
|
|
|||
|
|
@ -48,17 +48,14 @@ namespace rawaccel {
|
|||
settings.data.rot_direction = direction(settings.prof.degrees_rotation);
|
||||
}
|
||||
|
||||
inline constexpr unsigned DRIVER_CAPACITY = POOL_SIZE / sizeof(driver_settings);
|
||||
inline constexpr unsigned DEVICE_CAPACITY = POOL_SIZE / sizeof(device_settings);
|
||||
|
||||
struct io_t {
|
||||
struct io_base {
|
||||
device_config default_dev_cfg;
|
||||
unsigned driver_data_size;
|
||||
unsigned device_data_size;
|
||||
driver_settings driver_data[DRIVER_CAPACITY];
|
||||
device_settings device_data[DEVICE_CAPACITY];
|
||||
unsigned driver_data_size = 0;
|
||||
unsigned device_data_size = 0;
|
||||
};
|
||||
|
||||
static_assert(alignof(io_base) == alignof(driver_settings) && alignof(driver_settings) == alignof(device_settings));
|
||||
|
||||
class modifier {
|
||||
public:
|
||||
#ifdef _KERNEL_MODE
|
||||
|
|
|
|||
|
|
@ -20,24 +20,17 @@
|
|||
using milliseconds = double;
|
||||
|
||||
struct {
|
||||
bool initialized;
|
||||
WDFCOLLECTION device_collection;
|
||||
WDFWAITLOCK collection_lock;
|
||||
ra::device_config default_dev_cfg;
|
||||
unsigned device_data_size;
|
||||
unsigned driver_data_size;
|
||||
ra::device_settings* device_data;
|
||||
ra::io_base base_data;
|
||||
ra::driver_settings* driver_data;
|
||||
ra::device_settings* device_data;
|
||||
milliseconds tick_interval;
|
||||
ra::modifier modifier_data[ra::DRIVER_CAPACITY];
|
||||
} global = {};
|
||||
|
||||
extern "C" PULONG InitSafeBootMode;
|
||||
|
||||
bool init_failed()
|
||||
{
|
||||
return global.driver_data_size == 0;
|
||||
};
|
||||
|
||||
__declspec(guard(ignore))
|
||||
VOID
|
||||
RawaccelCallback(
|
||||
|
|
@ -105,7 +98,7 @@ Arguments:
|
|||
static_cast<double>(it->LastY)
|
||||
};
|
||||
|
||||
devExt->mod_ptr->modify(input, *devExt->drv_ptr, devExt->dpi_factor, time);
|
||||
devExt->mod.modify(input, devExt->drv_settings, devExt->dpi_factor, time);
|
||||
|
||||
double carried_result_x = input.x + devExt->carry.x;
|
||||
double carried_result_y = input.y + devExt->carry.y;
|
||||
|
|
@ -167,7 +160,7 @@ Return Value:
|
|||
{
|
||||
NTSTATUS status;
|
||||
void* buffer;
|
||||
|
||||
size_t buffer_length;
|
||||
size_t bytes_out = 0;
|
||||
|
||||
UNREFERENCED_PARAMETER(Queue);
|
||||
|
|
@ -177,42 +170,50 @@ Return Value:
|
|||
|
||||
DebugPrint(("Ioctl received into filter control object.\n"));
|
||||
|
||||
if (init_failed()) {
|
||||
if (!global.initialized) {
|
||||
WdfRequestCompleteWithInformation(Request, STATUS_CANCELLED, 0);
|
||||
return;
|
||||
}
|
||||
|
||||
const auto SIZEOF_BASE = sizeof(ra::io_base);
|
||||
|
||||
switch (IoControlCode) {
|
||||
case ra::READ:
|
||||
status = WdfRequestRetrieveOutputBuffer(
|
||||
Request,
|
||||
sizeof(ra::io_t),
|
||||
SIZEOF_BASE,
|
||||
&buffer,
|
||||
NULL
|
||||
&buffer_length
|
||||
);
|
||||
if (!NT_SUCCESS(status)) {
|
||||
DebugPrint(("RetrieveOutputBuffer failed: 0x%x\n", status));
|
||||
}
|
||||
else {
|
||||
ra::io_t& output = *static_cast<ra::io_t*>(buffer);
|
||||
*static_cast<ra::io_base*>(buffer) = global.base_data;
|
||||
|
||||
output.default_dev_cfg = global.default_dev_cfg;
|
||||
size_t driver_bytes = global.base_data.driver_data_size * sizeof(ra::driver_settings);
|
||||
size_t device_bytes = global.base_data.device_data_size * sizeof(ra::device_settings);
|
||||
size_t total_bytes = SIZEOF_BASE + driver_bytes + device_bytes;
|
||||
|
||||
output.device_data_size = global.device_data_size;
|
||||
output.driver_data_size = global.driver_data_size;
|
||||
if (buffer_length < total_bytes) {
|
||||
bytes_out = SIZEOF_BASE;
|
||||
}
|
||||
else {
|
||||
BYTE* output_ptr = static_cast<BYTE*>(buffer) + SIZEOF_BASE;
|
||||
|
||||
RtlCopyMemory(output.device_data, global.device_data, sizeof(output.device_data));
|
||||
RtlCopyMemory(output.driver_data, global.driver_data, sizeof(output.driver_data));
|
||||
|
||||
bytes_out = sizeof(ra::io_t);
|
||||
if (global.driver_data) RtlCopyMemory(output_ptr, global.driver_data, driver_bytes);
|
||||
output_ptr += driver_bytes;
|
||||
if (global.device_data) RtlCopyMemory(output_ptr, global.device_data, device_bytes);
|
||||
bytes_out = total_bytes;
|
||||
}
|
||||
}
|
||||
break;
|
||||
case ra::WRITE:
|
||||
status = WdfRequestRetrieveInputBuffer(
|
||||
Request,
|
||||
sizeof(ra::io_t),
|
||||
SIZEOF_BASE,
|
||||
&buffer,
|
||||
NULL
|
||||
&buffer_length
|
||||
);
|
||||
if (!NT_SUCCESS(status)) {
|
||||
DebugPrint(("RetrieveInputBuffer failed: 0x%x\n", status));
|
||||
|
|
@ -220,36 +221,73 @@ Return Value:
|
|||
else {
|
||||
WriteDelay();
|
||||
|
||||
ra::io_t& input = *static_cast<ra::io_t*>(buffer);
|
||||
ra::io_base& input = *static_cast<ra::io_base*>(buffer);
|
||||
|
||||
if (input.driver_data_size == 0) {
|
||||
auto driver_bytes = size_t(input.driver_data_size) * sizeof(ra::driver_settings);
|
||||
auto device_bytes = size_t(input.device_data_size) * sizeof(ra::device_settings);
|
||||
auto alloc_size = driver_bytes + device_bytes;
|
||||
auto total_size = alloc_size + SIZEOF_BASE;
|
||||
|
||||
auto max_u32 = unsigned(-1);
|
||||
if (driver_bytes > max_u32 || device_bytes > max_u32 || total_size > max_u32) {
|
||||
status = STATUS_CANCELLED;
|
||||
break;
|
||||
}
|
||||
|
||||
WdfWaitLockAcquire(global.collection_lock, NULL);
|
||||
if (input.driver_data_size == 0) {
|
||||
// clear data and disable all devices
|
||||
WdfWaitLockAcquire(global.collection_lock, NULL);
|
||||
|
||||
global.default_dev_cfg = input.default_dev_cfg;
|
||||
global.base_data = {};
|
||||
|
||||
global.device_data_size = ra::min(input.device_data_size, ra::DEVICE_CAPACITY);
|
||||
global.driver_data_size = ra::min(input.driver_data_size, ra::DRIVER_CAPACITY);
|
||||
if (global.driver_data) {
|
||||
ExFreePoolWithTag(global.driver_data, 'g');
|
||||
global.driver_data = NULL;
|
||||
global.device_data = NULL;
|
||||
}
|
||||
|
||||
RtlCopyMemory(global.device_data, input.device_data, sizeof(input.device_data));
|
||||
RtlCopyMemory(global.driver_data, input.driver_data, sizeof(input.driver_data));
|
||||
auto count = WdfCollectionGetCount(global.device_collection);
|
||||
|
||||
for (auto i = 0u; i < global.driver_data_size; i++) {
|
||||
global.modifier_data[i] = { global.driver_data[i] };
|
||||
for (auto i = 0u; i < count; i++) {
|
||||
DeviceSetup(WdfCollectionGetItem(global.device_collection, i));
|
||||
}
|
||||
|
||||
WdfWaitLockRelease(global.collection_lock);
|
||||
}
|
||||
else if (buffer_length == total_size) {
|
||||
void* pool = ExAllocatePoolWithTag(PagedPool, alloc_size, 'g');
|
||||
if (!pool) {
|
||||
DebugPrint(("ExAllocatePoolWithTag (PagedPool) failed"));
|
||||
status = STATUS_UNSUCCESSFUL;
|
||||
break;
|
||||
}
|
||||
RtlCopyMemory(pool, static_cast<BYTE*>(buffer) + SIZEOF_BASE, alloc_size);
|
||||
|
||||
auto count = WdfCollectionGetCount(global.device_collection);
|
||||
WdfWaitLockAcquire(global.collection_lock, NULL);
|
||||
|
||||
for (auto i = 0u; i < count; i++) {
|
||||
DeviceSetup(WdfCollectionGetItem(global.device_collection, i));
|
||||
if (global.driver_data) {
|
||||
ExFreePoolWithTag(global.driver_data, 'g');
|
||||
}
|
||||
|
||||
void* dev_data = static_cast<BYTE*>(pool) + driver_bytes;
|
||||
global.device_data = input.device_data_size > 0 ?
|
||||
static_cast<ra::device_settings*>(dev_data) :
|
||||
NULL;
|
||||
global.driver_data = static_cast<ra::driver_settings*>(pool);
|
||||
global.base_data = input;
|
||||
|
||||
auto count = WdfCollectionGetCount(global.device_collection);
|
||||
|
||||
for (auto i = 0u; i < count; i++) {
|
||||
DeviceSetup(WdfCollectionGetItem(global.device_collection, i));
|
||||
}
|
||||
|
||||
WdfWaitLockRelease(global.collection_lock);
|
||||
}
|
||||
else {
|
||||
status = STATUS_CANCELLED;
|
||||
}
|
||||
|
||||
WdfWaitLockRelease(global.collection_lock);
|
||||
}
|
||||
|
||||
break;
|
||||
case ra::GET_VERSION:
|
||||
status = WdfRequestRetrieveOutputBuffer(
|
||||
|
|
@ -310,34 +348,11 @@ RawaccelInit(WDFDRIVER driver)
|
|||
return;
|
||||
}
|
||||
|
||||
void* paged_p = ExAllocatePoolWithTag(PagedPool, ra::POOL_SIZE, 'g');
|
||||
if (paged_p) {
|
||||
RtlZeroMemory(paged_p, ra::POOL_SIZE);
|
||||
global.device_data = static_cast<ra::device_settings*>(paged_p);
|
||||
}
|
||||
else {
|
||||
DebugPrint(("ExAllocatePoolWithTag (PagedPool) failed"));
|
||||
return;
|
||||
}
|
||||
|
||||
void* nonpaged_p = ExAllocatePoolWithTag(NonPagedPool, ra::POOL_SIZE, 'g');
|
||||
if (nonpaged_p) {
|
||||
RtlZeroMemory(nonpaged_p, ra::POOL_SIZE);
|
||||
global.driver_data = static_cast<ra::driver_settings*>(nonpaged_p);
|
||||
global.driver_data->prof.domain_weights = { 1, 1 };
|
||||
global.driver_data->prof.range_weights = { 1, 1 };
|
||||
global.driver_data->prof.sensitivity = 1;
|
||||
global.driver_data->prof.yx_sens_ratio = 1;
|
||||
global.driver_data_size = 1;
|
||||
}
|
||||
else {
|
||||
DebugPrint(("ExAllocatePoolWithTag (NonPagedPool) failed"));
|
||||
return;
|
||||
}
|
||||
|
||||
LARGE_INTEGER freq;
|
||||
KeQueryPerformanceCounter(&freq);
|
||||
global.tick_interval = 1e3 / freq.QuadPart;
|
||||
|
||||
global.initialized = true;
|
||||
}
|
||||
|
||||
VOID
|
||||
|
|
@ -360,25 +375,29 @@ DeviceSetup(WDFOBJECT hDevice)
|
|||
}
|
||||
};
|
||||
|
||||
set_ext_from_cfg(global.default_dev_cfg);
|
||||
devExt->counter = 0;
|
||||
devExt->carry = {};
|
||||
devExt->drv_ptr = global.driver_data;
|
||||
devExt->mod_ptr = global.modifier_data;
|
||||
|
||||
for (auto i = 0u; i < global.device_data_size; i++) {
|
||||
if (!global.driver_data) {
|
||||
devExt->enable = false;
|
||||
devExt->mod = {};
|
||||
return;
|
||||
}
|
||||
|
||||
set_ext_from_cfg(global.base_data.default_dev_cfg);
|
||||
devExt->drv_settings = *global.driver_data;
|
||||
devExt->mod = { devExt->drv_settings };
|
||||
|
||||
for (auto i = 0u; i < global.base_data.device_data_size; i++) {
|
||||
auto& dev_settings = global.device_data[i];
|
||||
|
||||
if (wcsncmp(devExt->dev_id, dev_settings.id, ra::MAX_DEV_ID_LEN) == 0) {
|
||||
set_ext_from_cfg(dev_settings.config);
|
||||
|
||||
if (dev_settings.profile[0] != L'\0') {
|
||||
for (auto j = 0u; j < global.driver_data_size; j++) {
|
||||
for (auto j = 0u; j < global.base_data.driver_data_size; j++) {
|
||||
auto& profile = global.driver_data[j].prof;
|
||||
|
||||
if (wcsncmp(dev_settings.profile, profile.name, ra::MAX_NAME_LEN) == 0) {
|
||||
devExt->drv_ptr = &global.driver_data[j];
|
||||
devExt->mod_ptr = &global.modifier_data[j];
|
||||
devExt->drv_settings = global.driver_data[j];
|
||||
devExt->mod = { devExt->drv_settings };
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
|
@ -624,7 +643,7 @@ Return Value:
|
|||
|
||||
DebugPrint(("Enter FilterEvtDeviceAdd \n"));
|
||||
|
||||
if (init_failed()) {
|
||||
if (!global.initialized) {
|
||||
return STATUS_SUCCESS;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -25,10 +25,10 @@ typedef struct _DEVICE_EXTENSION {
|
|||
double dpi_factor;
|
||||
counter_t counter;
|
||||
ra::time_clamp clamp;
|
||||
ra::driver_settings* drv_ptr;
|
||||
ra::modifier* mod_ptr;
|
||||
ra::modifier mod;
|
||||
vec2d carry;
|
||||
CONNECT_DATA UpperConnectData;
|
||||
ra::driver_settings drv_settings;
|
||||
WCHAR dev_id[ra::MAX_DEV_ID_LEN];
|
||||
} DEVICE_EXTENSION, *PDEVICE_EXTENSION;
|
||||
|
||||
|
|
|
|||
|
|
@ -462,7 +462,7 @@ public:
|
|||
|
||||
}
|
||||
|
||||
ra::driver_settings GetSettings()
|
||||
ra::driver_settings NativeSettings()
|
||||
{
|
||||
return instance->settings;
|
||||
}
|
||||
|
|
@ -474,8 +474,6 @@ public:
|
|||
public ref class DriverConfig {
|
||||
public:
|
||||
literal double WriteDelayMs = ra::WRITE_DELAY;
|
||||
literal int MaxProfiles = ra::DRIVER_CAPACITY;
|
||||
literal int MaxDevices = ra::DEVICE_CAPACITY;
|
||||
literal String^ Key = "Driver settings";
|
||||
|
||||
String^ version = RA_VER_STRING;
|
||||
|
|
@ -491,36 +489,56 @@ public:
|
|||
|
||||
void Activate()
|
||||
{
|
||||
ra::io_t* data = static_cast<ra::io_t*>(malloc(sizeof(ra::io_t)));
|
||||
|
||||
if (!data) throw gcnew Exception("bad alloc");
|
||||
|
||||
data->default_dev_cfg.disable = defaultDeviceConfig.disable;
|
||||
data->default_dev_cfg.set_extra_info = defaultDeviceConfig.setExtraInfo;
|
||||
data->default_dev_cfg.dpi = defaultDeviceConfig.dpi;
|
||||
data->default_dev_cfg.polling_rate = defaultDeviceConfig.pollingRate;
|
||||
data->default_dev_cfg.clamp.min = defaultDeviceConfig.minimumTime;
|
||||
data->default_dev_cfg.clamp.max = defaultDeviceConfig.maximumTime;
|
||||
|
||||
data->driver_data_size = profiles->Count;
|
||||
data->device_data_size = devices->Count;
|
||||
|
||||
for (auto i = 0; i < profiles->Count; i++) {
|
||||
auto& drv_settings = data->driver_data[i];
|
||||
drv_settings = accels[i]->GetSettings();
|
||||
if (accels->Count != profiles->Count) {
|
||||
throw gcnew Exception("Profile count does not match ManagedAccel");
|
||||
}
|
||||
|
||||
std::byte* buffer;
|
||||
|
||||
auto driver_data_bytes = accels->Count * sizeof(ra::driver_settings);
|
||||
auto device_data_bytes = devices->Count * sizeof(ra::device_settings);
|
||||
|
||||
try {
|
||||
buffer = new std::byte[sizeof(ra::io_base) + driver_data_bytes + device_data_bytes];
|
||||
}
|
||||
catch (const std::exception& e) {
|
||||
throw gcnew InteropException(e);
|
||||
}
|
||||
|
||||
auto* byte_ptr = buffer;
|
||||
|
||||
auto* base_data = reinterpret_cast<ra::io_base*>(byte_ptr);
|
||||
base_data->default_dev_cfg.disable = defaultDeviceConfig.disable;
|
||||
base_data->default_dev_cfg.set_extra_info = defaultDeviceConfig.setExtraInfo;
|
||||
base_data->default_dev_cfg.dpi = defaultDeviceConfig.dpi;
|
||||
base_data->default_dev_cfg.polling_rate = defaultDeviceConfig.pollingRate;
|
||||
base_data->default_dev_cfg.clamp.min = defaultDeviceConfig.minimumTime;
|
||||
base_data->default_dev_cfg.clamp.max = defaultDeviceConfig.maximumTime;
|
||||
base_data->driver_data_size = accels->Count;
|
||||
base_data->device_data_size = devices->Count;
|
||||
|
||||
byte_ptr += sizeof(ra::io_base);
|
||||
|
||||
auto* driver_data = reinterpret_cast<ra::driver_settings*>(byte_ptr);
|
||||
for (auto i = 0; i < accels->Count; i++) {
|
||||
auto& drv_settings = driver_data[i];
|
||||
drv_settings = accels[i]->NativeSettings();
|
||||
}
|
||||
|
||||
byte_ptr += driver_data_bytes;
|
||||
|
||||
auto* device_data = reinterpret_cast<ra::device_settings*>(byte_ptr);
|
||||
for (auto i = 0; i < devices->Count; i++) {
|
||||
auto& dev_settings = data->device_data[i];
|
||||
auto& dev_settings = device_data[i];
|
||||
Marshal::StructureToPtr(devices[i], IntPtr(&dev_settings), false);
|
||||
}
|
||||
|
||||
try {
|
||||
ra::write(*data);
|
||||
free(data);
|
||||
ra::write(buffer);
|
||||
delete[] buffer;
|
||||
}
|
||||
catch (const ra::error& e) {
|
||||
free(data);
|
||||
catch (const std::exception& e) {
|
||||
delete[] buffer;
|
||||
throw gcnew InteropException(e);
|
||||
}
|
||||
}
|
||||
|
|
@ -530,14 +548,6 @@ public:
|
|||
{
|
||||
Text::StringBuilder^ sb = gcnew Text::StringBuilder();
|
||||
|
||||
if (profiles->Count > MaxProfiles) {
|
||||
sb->AppendFormat("Number of profiles ({0}) exceeds max ({1})\n", profiles->Count, MaxProfiles);
|
||||
}
|
||||
|
||||
if (devices->Count > MaxDevices) {
|
||||
sb->AppendFormat("Number of devices ({0}) exceeds max ({1})\n", devices->Count, MaxDevices);
|
||||
}
|
||||
|
||||
ProfileErrors^ profErrors = gcnew ProfileErrors(profiles);
|
||||
if (!profErrors->Empty()) {
|
||||
sb->Append(profErrors->ToString());
|
||||
|
|
@ -648,15 +658,11 @@ public:
|
|||
|
||||
static DriverConfig^ GetActive()
|
||||
{
|
||||
ra::io_t* data = static_cast<ra::io_t*>(malloc(sizeof(ra::io_t)));
|
||||
|
||||
if (!data) throw gcnew Exception("io_t alloc failed");
|
||||
|
||||
std::unique_ptr<std::byte[]> bytes;
|
||||
try {
|
||||
ra::read(*data);
|
||||
bytes = ra::read();
|
||||
}
|
||||
catch (const ra::error& e) {
|
||||
free(data);
|
||||
catch (const std::exception& e) {
|
||||
throw gcnew InteropException(e);
|
||||
}
|
||||
|
||||
|
|
@ -665,20 +671,27 @@ public:
|
|||
cfg->accels = gcnew List<ManagedAccel^>();
|
||||
cfg->devices = gcnew List<DeviceSettings^>();
|
||||
|
||||
for (auto i = 0u; i < data->driver_data_size; i++) {
|
||||
auto& drv_settings = data->driver_data[i];
|
||||
auto* byte_ptr = bytes.get();
|
||||
ra::io_base* base_data = reinterpret_cast<ra::io_base*>(byte_ptr);
|
||||
cfg->defaultDeviceConfig.Init(base_data->default_dev_cfg);
|
||||
|
||||
byte_ptr += sizeof(ra::io_base);
|
||||
|
||||
ra::driver_settings* driver_data = reinterpret_cast<ra::driver_settings*>(byte_ptr);
|
||||
for (auto i = 0u; i < base_data->driver_data_size; i++) {
|
||||
auto& drv_settings = driver_data[i];
|
||||
cfg->profiles->Add(gcnew Profile(drv_settings.prof));
|
||||
cfg->accels->Add(gcnew ManagedAccel(drv_settings));
|
||||
}
|
||||
|
||||
for (auto i = 0u; i < data->device_data_size; i++) {
|
||||
auto& dev_settings = data->device_data[i];
|
||||
byte_ptr += base_data->driver_data_size * sizeof(ra::driver_settings);
|
||||
|
||||
ra::device_settings* device_data = reinterpret_cast<ra::device_settings*>(byte_ptr);
|
||||
for (auto i = 0u; i < base_data->device_data_size; i++) {
|
||||
auto& dev_settings = device_data[i];
|
||||
cfg->devices->Add(gcnew DeviceSettings(dev_settings));
|
||||
}
|
||||
|
||||
cfg->defaultDeviceConfig.Init(data->default_dev_cfg);
|
||||
|
||||
free(data);
|
||||
return cfg;
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue