steamvr_lh: properly handle other properties · matrixfurry.com/monado@2ed83e8

+79 -11

src/xrt/drivers/steamvr_lh/device.cpp

··· 208 208 } 209 209 } // namespace 210 210 211 + Property::Property(vr::PropertyTypeTag_t tag, void *buffer, uint32_t bufferSize) 212 + { 213 + this->tag = tag; 214 + this->buffer.resize(bufferSize); 215 + std::memcpy(this->buffer.data(), buffer, bufferSize); 216 + } 217 + 211 218 HmdDevice::HmdDevice(const DeviceBuilder &builder) : Device(builder) 212 219 { 213 220 this->name = XRT_DEVICE_GENERIC_HMD; ··· 789 796 m_relation_history_push(relation_hist, &relation, ts); 790 797 } 791 798 792 - void 799 + vr::ETrackedPropertyError 793 800 Device::handle_properties(const vr::PropertyWrite_t *batch, uint32_t count) 794 801 { 795 802 for (uint32_t i = 0; i < count; ++i) { 796 - handle_property_write(batch[i]); 803 + vr::ETrackedPropertyError err = handle_property_write(batch[i]); 804 + if (err != vr::ETrackedPropertyError::TrackedProp_Success) { 805 + return err; 806 + } 797 807 } 808 + return vr::ETrackedPropertyError::TrackedProp_Success; 809 + } 810 + 811 + vr::ETrackedPropertyError 812 + Device::handle_read_properties(vr::PropertyRead_t *batch, uint32_t count) 813 + { 814 + for (uint32_t i = 0; i < count; ++i) { 815 + vr::ETrackedPropertyError err = handle_generic_property_read(batch[i]); 816 + if (err != vr::ETrackedPropertyError::TrackedProp_Success) { 817 + return err; 818 + } 819 + } 820 + return vr::ETrackedPropertyError::TrackedProp_Success; 798 821 } 799 822 800 823 void ··· 829 852 } 830 853 } // namespace 831 854 832 - void 855 + vr::ETrackedPropertyError 856 + Device::handle_generic_property_write(const vr::PropertyWrite_t &prop) 857 + { 858 + switch (prop.writeType) { 859 + case vr::EPropertyWriteType::PropertyWrite_Set: 860 + if (properties.count(prop.prop) > 0) { 861 + Property &p = properties.at(prop.prop); 862 + if (p.tag != prop.unTag) { 863 + return vr::ETrackedPropertyError::TrackedProp_WrongDataType; 864 + } 865 + p.buffer.resize(prop.unBufferSize); 866 + std::memcpy(p.buffer.data(), prop.pvBuffer, prop.unBufferSize); 867 + return vr::ETrackedPropertyError::TrackedProp_Success; 868 + } else { 869 + properties.emplace(std::piecewise_construct, std::forward_as_tuple(prop.prop), 870 + std::forward_as_tuple(prop.unTag, prop.pvBuffer, prop.unBufferSize)); 871 + } 872 + break; 873 + case vr::EPropertyWriteType::PropertyWrite_Erase: properties.erase(prop.prop); break; 874 + case vr::EPropertyWriteType::PropertyWrite_SetError: 875 + DEV_DEBUG("Property write type SetError not supported! (property %d)", prop.prop); 876 + break; 877 + } 878 + return vr::ETrackedPropertyError::TrackedProp_Success; 879 + } 880 + 881 + vr::ETrackedPropertyError 882 + Device::handle_generic_property_read(vr::PropertyRead_t &prop) 883 + { 884 + if (properties.count(prop.prop) == 0) { 885 + // not verified if this is the correct error 886 + return vr::ETrackedPropertyError::TrackedProp_UnknownProperty; 887 + } 888 + Property &p = properties.at(prop.prop); 889 + prop.unTag = p.tag; 890 + prop.unRequiredBufferSize = p.buffer.size(); 891 + if (prop.pvBuffer == nullptr || prop.unBufferSize < p.buffer.size()) { 892 + prop.eError = vr::ETrackedPropertyError::TrackedProp_BufferTooSmall; 893 + return prop.eError; 894 + } 895 + std::memcpy(prop.pvBuffer, p.buffer.data(), p.buffer.size()); 896 + prop.eError = vr::ETrackedPropertyError::TrackedProp_Success; 897 + return prop.eError; 898 + } 899 + 900 + vr::ETrackedPropertyError 833 901 Device::handle_property_write(const vr::PropertyWrite_t &prop) 834 902 { 835 903 switch (prop.prop) { ··· 854 922 break; 855 923 } 856 924 } 925 + return handle_generic_property_write(prop); 857 926 } 858 927 859 - void 928 + vr::ETrackedPropertyError 860 929 HmdDevice::handle_property_write(const vr::PropertyWrite_t &prop) 861 930 { 862 931 switch (prop.prop) { ··· 907 976 break; 908 977 } 909 978 default: { 910 - Device::handle_property_write(prop); 911 - break; 979 + return Device::handle_property_write(prop); 912 980 } 913 981 } 982 + return handle_generic_property_write(prop); 914 983 } 915 984 916 - void 985 + vr::ETrackedPropertyError 917 986 ControllerDevice::handle_property_write(const vr::PropertyWrite_t &prop) 918 987 { 919 988 switch (prop.prop) { ··· 943 1012 (this->manufacturer.size() != name.size()); 944 1013 fixedProp.unBufferSize = name.end() - (char *)fixedProp.pvBuffer; 945 1014 } 946 - Device::handle_property_write(fixedProp); 947 - break; 1015 + return Device::handle_property_write(fixedProp); 948 1016 } 949 1017 case vr::Prop_ControllerRoleHint_Int32: { 950 1018 vr::ETrackedControllerRole role = *static_cast<vr::ETrackedControllerRole *>(prop.pvBuffer); ··· 1037 1105 break; 1038 1106 } 1039 1107 default: { 1040 - Device::handle_property_write(prop); 1041 - break; 1108 + return Device::handle_property_write(prop); 1042 1109 } 1043 1110 } 1111 + return handle_generic_property_write(prop); 1044 1112 }

+22 -4

src/xrt/drivers/steamvr_lh/device.hpp

··· 44 44 operator=(const DeviceBuilder &) = delete; 45 45 }; 46 46 47 + class Property 48 + { 49 + public: 50 + Property(vr::PropertyTypeTag_t tag, void *buffer, uint32_t bufferSize); 51 + 52 + vr::PropertyTypeTag_t tag; 53 + std::vector<uint8_t> buffer; 54 + }; 55 + 47 56 class Device : public xrt_device 48 57 { 49 58 ··· 65 74 void 66 75 get_pose(uint64_t at_timestamp_ns, xrt_space_relation *out_relation); 67 76 68 - void 77 + vr::ETrackedPropertyError 69 78 handle_properties(const vr::PropertyWrite_t *batch, uint32_t count); 70 79 80 + vr::ETrackedPropertyError 81 + handle_read_properties(vr::PropertyRead_t *batch, uint32_t count); 82 + 71 83 //! Maps to @ref xrt_device::get_tracked_pose. 72 84 virtual xrt_result_t 73 85 get_tracked_pose(xrt_input_name name, uint64_t at_timestamp_ns, xrt_space_relation *out_relation) = 0; ··· 79 91 Device(const DeviceBuilder &builder); 80 92 std::shared_ptr<Context> ctx; 81 93 vr::PropertyContainerHandle_t container_handle{0}; 94 + std::unordered_map<vr::ETrackedDeviceProperty, Property> properties; 82 95 std::unordered_map<std::string_view, xrt_input *> inputs_map; 83 96 std::vector<xrt_input> inputs_vec; 84 97 inline static xrt_pose chaperone = XRT_POSE_IDENTITY; ··· 90 103 bool charging{false}; 91 104 float charge{1.0F}; 92 105 93 - virtual void 106 + vr::ETrackedPropertyError 107 + handle_generic_property_write(const vr::PropertyWrite_t &prop); 108 + vr::ETrackedPropertyError 109 + handle_generic_property_read(vr::PropertyRead_t &prop); 110 + 111 + virtual vr::ETrackedPropertyError 94 112 handle_property_write(const vr::PropertyWrite_t &prop); 95 113 96 114 private: ··· 158 176 private: 159 177 std::unique_ptr<Parts> hmd_parts{nullptr}; 160 178 161 - void 179 + vr::ETrackedPropertyError 162 180 handle_property_write(const vr::PropertyWrite_t &prop) override; 163 181 164 182 void ··· 214 232 void 215 233 set_hand_tracking_hand(xrt_input_name name); 216 234 217 - void 235 + vr::ETrackedPropertyError 218 236 handle_property_write(const vr::PropertyWrite_t &prop) override; 219 237 };

+7 -3

src/xrt/drivers/steamvr_lh/steamvr_lh.cpp

··· 667 667 vr::PropertyRead_t *pBatch, 668 668 uint32_t unBatchEntryCount) 669 669 { 670 - return vr::TrackedProp_Success; 670 + Device *device = prop_container_to_device(ulContainerHandle); 671 + if (!device) 672 + return vr::TrackedProp_InvalidContainer; 673 + if (!pBatch) 674 + return vr::TrackedProp_InvalidOperation; // not verified vs steamvr 675 + return device->handle_read_properties(pBatch, unBatchEntryCount); 671 676 } 672 677 673 678 vr::ETrackedPropertyError ··· 680 685 return vr::TrackedProp_InvalidContainer; 681 686 if (!pBatch) 682 687 return vr::TrackedProp_InvalidOperation; // not verified vs steamvr 683 - device->handle_properties(pBatch, unBatchEntryCount); 684 - return vr::TrackedProp_Success; 688 + return device->handle_properties(pBatch, unBatchEntryCount); 685 689 } 686 690 687 691 const char *