mirrors/rawaccel
1
0
Fork 0
mirror of https://github.com/RawAccelOfficial/rawaccel.git synced 2025-05-11 10:26:58 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions

rename driver_settings

Browse source 
found a better one

refactor driver/DeviceSetup
This commit is contained in:
a1xd 2021-09-08 04:43:15 -04:00
parent 864ef4d74b
commit 427a94bc40
5 changed files with 68 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

16
common/rawaccel-io.hpp
View file

@ -47,19 +47,19 @@ namespace rawaccel {
size_t size = sizeof(base_data); size_t size = sizeof(base_data);
if (base_data.driver_data_size == 0) { if (base_data.modifier_data_size == 0) {
// driver has no data, but it's more useful to return something, // driver has no data, but it's more useful to return something,
// so return a default driver_settings object along with base data // so return a default modifier_settings object along with base data
size += sizeof(driver_settings); size += sizeof(modifier_settings);
base_data.driver_data_size = 1; base_data.modifier_data_size = 1;
auto bytes = std::make_unique<std::byte[]>(size); auto bytes = std::make_unique<std::byte[]>(size);
*reinterpret_cast<io_base*>(bytes.get()) = base_data; *reinterpret_cast<io_base*>(bytes.get()) = base_data;
*reinterpret_cast<driver_settings*>(bytes.get() + sizeof(io_base)) = {}; *reinterpret_cast<modifier_settings*>(bytes.get() + sizeof(io_base)) = {};
return bytes; return bytes;
} }
else { else {
size += sizeof(driver_settings) * base_data.driver_data_size; size += sizeof(modifier_settings) * base_data.modifier_data_size;
size += sizeof(device_settings) * base_data.device_data_size; size += sizeof(device_settings) * base_data.device_data_size;
auto bytes = std::make_unique<std::byte[]>(size); auto bytes = std::make_unique<std::byte[]>(size);
io_control(READ, NULL, 0, bytes.get(), DWORD(size)); io_control(READ, NULL, 0, bytes.get(), DWORD(size));
@ -74,7 +74,7 @@ namespace rawaccel {
auto* base_ptr = static_cast<const io_base*>(buffer); auto* base_ptr = static_cast<const io_base*>(buffer);
auto size = sizeof(io_base); auto size = sizeof(io_base);
size += base_ptr->driver_data_size * sizeof(driver_settings); size += base_ptr->modifier_data_size * sizeof(modifier_settings);
size += base_ptr->device_data_size * sizeof(device_settings); size += base_ptr->device_data_size * sizeof(device_settings);
if (size > DWORD(-1)) throw io_error("write buffer is too large"); if (size > DWORD(-1)) throw io_error("write buffer is too large");
@ -85,7 +85,7 @@ namespace rawaccel {
inline void reset() inline void reset()
{ {
io_base base_data{}; io_base base_data{};
// all driver/device data is cleared when a default io_base is passed // all modifier/device data is cleared when a default io_base is passed
io_control(WRITE, &base_data, sizeof(io_base), NULL, 0); io_control(WRITE, &base_data, sizeof(io_base), NULL, 0);
} }

12
common/rawaccel.hpp
View file

@ -24,7 +24,7 @@ namespace rawaccel {
device_config config; device_config config;
}; };
struct driver_settings { struct modifier_settings {
profile prof; profile prof;
struct data_t { struct data_t {
@ -34,7 +34,7 @@ namespace rawaccel {
} data = {}; } data = {};
}; };
inline void init_data(driver_settings& settings) inline void init_data(modifier_settings& settings)
{ {
auto set_accel = [](accel_union& u, const accel_args& args) { auto set_accel = [](accel_union& u, const accel_args& args) {
u.visit([&](auto& impl) { u.visit([&](auto& impl) {
@ -50,18 +50,18 @@ namespace rawaccel {
struct io_base { struct io_base {
device_config default_dev_cfg; device_config default_dev_cfg;
unsigned driver_data_size = 0; unsigned modifier_data_size = 0;
unsigned device_data_size = 0; unsigned device_data_size = 0;
}; };
static_assert(alignof(io_base) == alignof(driver_settings) && alignof(driver_settings) == alignof(device_settings)); static_assert(alignof(io_base) == alignof(modifier_settings) && alignof(modifier_settings) == alignof(device_settings));
class modifier { class modifier {
public: public:
#ifdef _KERNEL_MODE #ifdef _KERNEL_MODE
__forceinline __forceinline
#endif #endif
void modify(vec2d& in, const driver_settings& settings, double dpi_factor, milliseconds time) const void modify(vec2d& in, const modifier_settings& settings, double dpi_factor, milliseconds time) const
{ {
auto& args = settings.prof; auto& args = settings.prof;
auto& data = settings.data; auto& data = settings.data;
@ -147,7 +147,7 @@ namespace rawaccel {
} }
} }
modifier(driver_settings& settings) modifier(modifier_settings& settings)
{ {
auto& args = settings.prof; auto& args = settings.prof;

64
driver/driver.cpp
View file

@ -24,7 +24,7 @@ struct {
WDFCOLLECTION device_collection; WDFCOLLECTION device_collection;
WDFWAITLOCK collection_lock; WDFWAITLOCK collection_lock;
ra::io_base base_data; ra::io_base base_data;
ra::driver_settings* driver_data; ra::modifier_settings* modifier_data;
ra::device_settings* device_data; ra::device_settings* device_data;
milliseconds tick_interval; milliseconds tick_interval;
} global = {}; } global = {};
@ -98,7 +98,7 @@ Arguments:
static_cast<double>(it->LastY) static_cast<double>(it->LastY)
}; };
devExt->mod.modify(input, devExt->drv_settings, devExt->dpi_factor, time); devExt->mod.modify(input, devExt->mod_settings, devExt->dpi_factor, time);
double carried_result_x = input.x + devExt->carry.x; double carried_result_x = input.x + devExt->carry.x;
double carried_result_y = input.y + devExt->carry.y; double carried_result_y = input.y + devExt->carry.y;
@ -191,9 +191,9 @@ Return Value:
else { else {
*static_cast<ra::io_base*>(buffer) = global.base_data; *static_cast<ra::io_base*>(buffer) = global.base_data;
size_t driver_bytes = global.base_data.driver_data_size * sizeof(ra::driver_settings); size_t modifier_bytes = global.base_data.modifier_data_size * sizeof(ra::modifier_settings);
size_t device_bytes = global.base_data.device_data_size * sizeof(ra::device_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; size_t total_bytes = SIZEOF_BASE + modifier_bytes + device_bytes;
if (buffer_length < total_bytes) { if (buffer_length < total_bytes) {
bytes_out = SIZEOF_BASE; bytes_out = SIZEOF_BASE;
@ -201,8 +201,8 @@ Return Value:
else { else {
BYTE* output_ptr = static_cast<BYTE*>(buffer) + SIZEOF_BASE; BYTE* output_ptr = static_cast<BYTE*>(buffer) + SIZEOF_BASE;
if (global.driver_data) RtlCopyMemory(output_ptr, global.driver_data, driver_bytes); if (global.modifier_data) RtlCopyMemory(output_ptr, global.modifier_data, modifier_bytes);
output_ptr += driver_bytes; output_ptr += modifier_bytes;
if (global.device_data) RtlCopyMemory(output_ptr, global.device_data, device_bytes); if (global.device_data) RtlCopyMemory(output_ptr, global.device_data, device_bytes);
bytes_out = total_bytes; bytes_out = total_bytes;
} }
@ -223,26 +223,26 @@ Return Value:
ra::io_base& input = *static_cast<ra::io_base*>(buffer); ra::io_base& input = *static_cast<ra::io_base*>(buffer);
auto driver_bytes = size_t(input.driver_data_size) * sizeof(ra::driver_settings); auto modifier_bytes = size_t(input.modifier_data_size) * sizeof(ra::modifier_settings);
auto device_bytes = size_t(input.device_data_size) * sizeof(ra::device_settings); auto device_bytes = size_t(input.device_data_size) * sizeof(ra::device_settings);
auto alloc_size = driver_bytes + device_bytes; auto alloc_size = modifier_bytes + device_bytes;
auto total_size = alloc_size + SIZEOF_BASE; auto total_size = alloc_size + SIZEOF_BASE;
auto max_u32 = unsigned(-1); auto max_u32 = unsigned(-1);
if (driver_bytes > max_u32 || device_bytes > max_u32 || total_size > max_u32) { if (modifier_bytes > max_u32 || device_bytes > max_u32 || total_size > max_u32) {
status = STATUS_CANCELLED; status = STATUS_CANCELLED;
break; break;
} }
if (input.driver_data_size == 0) { if (input.modifier_data_size == 0) {
// clear data and disable all devices // clear data and disable all devices
WdfWaitLockAcquire(global.collection_lock, NULL); WdfWaitLockAcquire(global.collection_lock, NULL);
global.base_data = {}; global.base_data = {};
if (global.driver_data) { if (global.modifier_data) {
ExFreePoolWithTag(global.driver_data, 'g'); ExFreePoolWithTag(global.modifier_data, 'g');
global.driver_data = NULL; global.modifier_data = NULL;
global.device_data = NULL; global.device_data = NULL;
} }
@ -265,15 +265,15 @@ Return Value:
WdfWaitLockAcquire(global.collection_lock, NULL); WdfWaitLockAcquire(global.collection_lock, NULL);
if (global.driver_data) { if (global.modifier_data) {
ExFreePoolWithTag(global.driver_data, 'g'); ExFreePoolWithTag(global.modifier_data, 'g');
} }
void* dev_data = static_cast<BYTE*>(pool) + driver_bytes; void* dev_data = static_cast<BYTE*>(pool) + modifier_bytes;
global.device_data = input.device_data_size > 0 ? global.device_data = input.device_data_size > 0 ?
static_cast<ra::device_settings*>(dev_data) : static_cast<ra::device_settings*>(dev_data) :
NULL; NULL;
global.driver_data = static_cast<ra::driver_settings*>(pool); global.modifier_data = static_cast<ra::modifier_settings*>(pool);
global.base_data = input; global.base_data = input;
auto count = WdfCollectionGetCount(global.device_collection); auto count = WdfCollectionGetCount(global.device_collection);
@ -373,15 +373,27 @@ DeviceSetup(WDFOBJECT hDevice)
} }
}; };
if (!global.driver_data) { auto set_mod_if_found = [devExt](auto* prof_name) {
for (auto i = 0u; i < global.base_data.modifier_data_size; i++) {
auto& profile = global.modifier_data[i].prof;
if (wcsncmp(prof_name, profile.name, ra::MAX_NAME_LEN) == 0) {
devExt->mod_settings = global.modifier_data[i];
devExt->mod = { devExt->mod_settings };
return;
}
}
};
if (!global.modifier_data) {
devExt->enable = false; devExt->enable = false;
devExt->mod = {}; devExt->mod = {};
return; return;
} }
set_ext_from_cfg(global.base_data.default_dev_cfg); set_ext_from_cfg(global.base_data.default_dev_cfg);
devExt->drv_settings = *global.driver_data; devExt->mod_settings = *global.modifier_data;
devExt->mod = { devExt->drv_settings }; devExt->mod = { devExt->mod_settings };
for (auto i = 0u; i < global.base_data.device_data_size; i++) { for (auto i = 0u; i < global.base_data.device_data_size; i++) {
auto& dev_settings = global.device_data[i]; auto& dev_settings = global.device_data[i];
@ -390,18 +402,10 @@ DeviceSetup(WDFOBJECT hDevice)
set_ext_from_cfg(dev_settings.config); set_ext_from_cfg(dev_settings.config);
if (dev_settings.profile[0] != L'\0') { if (dev_settings.profile[0] != L'\0') {
for (auto j = 0u; j < global.base_data.driver_data_size; j++) { set_mod_if_found(dev_settings.profile);
auto& profile = global.driver_data[j].prof;
if (wcsncmp(dev_settings.profile, profile.name, ra::MAX_NAME_LEN) == 0) {
devExt->drv_settings = global.driver_data[j];
devExt->mod = { devExt->drv_settings };
return;
}
}
} }
return; break;
} }
} }
} }

2
driver/driver.h
View file

@ -28,7 +28,7 @@ typedef struct _DEVICE_EXTENSION {
ra::modifier mod; ra::modifier mod;
vec2d carry; vec2d carry;
CONNECT_DATA UpperConnectData; CONNECT_DATA UpperConnectData;
ra::driver_settings drv_settings; ra::modifier_settings mod_settings;
WCHAR dev_id[ra::MAX_DEV_ID_LEN]; WCHAR dev_id[ra::MAX_DEV_ID_LEN];
} DEVICE_EXTENSION, *PDEVICE_EXTENSION; } DEVICE_EXTENSION, *PDEVICE_EXTENSION;

38
wrapper/wrapper.cpp
View file

@ -15,7 +15,7 @@ using namespace Newtonsoft::Json::Linq;
namespace ra = rawaccel; namespace ra = rawaccel;
ra::driver_settings default_driver_settings; ra::modifier_settings default_modifier_settings;
ra::device_settings default_device_settings; ra::device_settings default_device_settings;
public ref struct VersionHelper public ref struct VersionHelper
@ -147,7 +147,7 @@ public ref struct Profile
} }
Profile() : Profile() :
Profile(default_driver_settings.prof) {} Profile(default_modifier_settings.prof) {}
}; };
[JsonObject(ItemRequired = Required::Always)] [JsonObject(ItemRequired = Required::Always)]
@ -395,11 +395,11 @@ public:
struct accel_instance_t { struct accel_instance_t {
ra::modifier mod; ra::modifier mod;
ra::driver_settings settings; ra::modifier_settings settings;
accel_instance_t() = default; accel_instance_t() = default;
accel_instance_t(ra::driver_settings& args) : accel_instance_t(ra::modifier_settings& args) :
settings(args), settings(args),
mod(args) {} mod(args) {}
@ -418,7 +418,7 @@ public:
ManagedAccel() {} ManagedAccel() {}
ManagedAccel(ra::driver_settings& settings) : ManagedAccel(ra::modifier_settings& settings) :
instance(new accel_instance_t(settings)) {} instance(new accel_instance_t(settings)) {}
ManagedAccel(Profile^ settings) ManagedAccel(Profile^ settings)
@ -462,7 +462,7 @@ public:
} }
ra::driver_settings NativeSettings() ra::modifier_settings NativeSettings()
{ {
return instance->settings; return instance->settings;
} }
@ -495,11 +495,11 @@ public:
std::byte* buffer; std::byte* buffer;
auto driver_data_bytes = accels->Count * sizeof(ra::driver_settings); auto modifier_data_bytes = accels->Count * sizeof(ra::modifier_settings);
auto device_data_bytes = devices->Count * sizeof(ra::device_settings); auto device_data_bytes = devices->Count * sizeof(ra::device_settings);
try { try {
buffer = new std::byte[sizeof(ra::io_base) + driver_data_bytes + device_data_bytes]; buffer = new std::byte[sizeof(ra::io_base) + modifier_data_bytes + device_data_bytes];
} }
catch (const std::exception& e) { catch (const std::exception& e) {
throw gcnew InteropException(e); throw gcnew InteropException(e);
@ -514,18 +514,18 @@ public:
base_data->default_dev_cfg.polling_rate = defaultDeviceConfig.pollingRate; base_data->default_dev_cfg.polling_rate = defaultDeviceConfig.pollingRate;
base_data->default_dev_cfg.clamp.min = defaultDeviceConfig.minimumTime; base_data->default_dev_cfg.clamp.min = defaultDeviceConfig.minimumTime;
base_data->default_dev_cfg.clamp.max = defaultDeviceConfig.maximumTime; base_data->default_dev_cfg.clamp.max = defaultDeviceConfig.maximumTime;
base_data->driver_data_size = accels->Count; base_data->modifier_data_size = accels->Count;
base_data->device_data_size = devices->Count; base_data->device_data_size = devices->Count;
byte_ptr += sizeof(ra::io_base); byte_ptr += sizeof(ra::io_base);
auto* driver_data = reinterpret_cast<ra::driver_settings*>(byte_ptr); auto* modifier_data = reinterpret_cast<ra::modifier_settings*>(byte_ptr);
for (auto i = 0; i < accels->Count; i++) { for (auto i = 0; i < accels->Count; i++) {
auto& drv_settings = driver_data[i]; auto& mod_settings = modifier_data[i];
drv_settings = accels[i]->NativeSettings(); mod_settings = accels[i]->NativeSettings();
} }
byte_ptr += driver_data_bytes; byte_ptr += modifier_data_bytes;
auto* device_data = reinterpret_cast<ra::device_settings*>(byte_ptr); auto* device_data = reinterpret_cast<ra::device_settings*>(byte_ptr);
for (auto i = 0; i < devices->Count; i++) { for (auto i = 0; i < devices->Count; i++) {
@ -683,14 +683,14 @@ public:
byte_ptr += sizeof(ra::io_base); byte_ptr += sizeof(ra::io_base);
ra::driver_settings* driver_data = reinterpret_cast<ra::driver_settings*>(byte_ptr); ra::modifier_settings* modifier_data = reinterpret_cast<ra::modifier_settings*>(byte_ptr);
for (auto i = 0u; i < base_data->driver_data_size; i++) { for (auto i = 0u; i < base_data->modifier_data_size; i++) {
auto& drv_settings = driver_data[i]; auto& mod_settings = modifier_data[i];
cfg->profiles->Add(gcnew Profile(drv_settings.prof)); cfg->profiles->Add(gcnew Profile(mod_settings.prof));
cfg->accels->Add(gcnew ManagedAccel(drv_settings)); cfg->accels->Add(gcnew ManagedAccel(mod_settings));
} }
byte_ptr += base_data->driver_data_size * sizeof(ra::driver_settings); byte_ptr += base_data->modifier_data_size * sizeof(ra::modifier_settings);
ra::device_settings* device_data = reinterpret_cast<ra::device_settings*>(byte_ptr); ra::device_settings* device_data = reinterpret_cast<ra::device_settings*>(byte_ptr);
for (auto i = 0u; i < base_data->device_data_size; i++) { for (auto i = 0u; i < base_data->device_data_size; i++) {