vsg: include/vsg/io/Input.h Source File

vsg 1.1.8 VulkanSceneGraph library

Loading...
Searching...
No Matches
Input.h
1#pragma once
2
3/* <editor-fold desc="MIT License">
4
5Copyright(c) 2018 Robert Osfield
6
7Permission 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:
8
9The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
10
11THE 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.
12
13</editor-fold> */
14
15#include <vsg/core/Data.h>
16#include <vsg/core/Object.h>
17#include <vsg/core/Version.h>
18
19#include <vsg/maths/box.h>
20#include <vsg/maths/mat3.h>
21#include <vsg/maths/mat4.h>
22#include <vsg/maths/plane.h>
23#include <vsg/maths/quat.h>
24#include <vsg/maths/sphere.h>
25#include <vsg/maths/vec2.h>
26#include <vsg/maths/vec3.h>
27#include <vsg/maths/vec4.h>
28
29#include <vsg/io/FileSystem.h>
30#include <vsg/io/ObjectFactory.h>
31
32#include <set>
33#include <unordered_map>
34
35namespace vsg
36{
37
38 // forward declare
39 class Options;
40
43 class VSG_DECLSPEC Input
44 {
45 public:
46 Input(ref_ptr<ObjectFactory> in_objectFactory, ref_ptr<const Options> in_options = {});
47
48 Input& operator=(const Input& rhs) = delete;
49
51 virtual bool matchPropertyName(const char* propertyName) = 0;
52
53 // read value(s)
54 virtual void read(size_t num, int8_t* value) = 0;
55 virtual void read(size_t num, uint8_t* value) = 0;
56 virtual void read(size_t num, int16_t* value) = 0;
57 virtual void read(size_t num, uint16_t* value) = 0;
58 virtual void read(size_t num, int32_t* value) = 0;
59 virtual void read(size_t num, uint32_t* value) = 0;
60 virtual void read(size_t num, int64_t* value) = 0;
61 virtual void read(size_t num, uint64_t* value) = 0;
62 virtual void read(size_t num, float* value) = 0;
63 virtual void read(size_t num, double* value) = 0;
64 virtual void read(size_t num, std::string* value) = 0;
65 virtual void read(size_t num, std::wstring* value) = 0;
66 virtual void read(size_t num, Path* value) = 0;
67
68 // read object
69 virtual ref_ptr<Object> read() = 0;
70
71 // map char to int8_t
72 void read(size_t num, char* value) { read(num, reinterpret_cast<int8_t*>(value)); }
73 void read(size_t num, bool* value) { read(num, reinterpret_cast<int8_t*>(value)); }
74
75 // vec/mat versions of read methods
76 void read(size_t num, vec2* value) { read(num * value->size(), value->data()); }
77 void read(size_t num, vec3* value) { read(num * value->size(), value->data()); }
78 void read(size_t num, vec4* value) { read(num * value->size(), value->data()); }
79 void read(size_t num, dvec2* value) { read(num * value->size(), value->data()); }
80 void read(size_t num, dvec3* value) { read(num * value->size(), value->data()); }
81 void read(size_t num, dvec4* value) { read(num * value->size(), value->data()); }
82 void read(size_t num, bvec2* value) { read(num * value->size(), value->data()); }
83 void read(size_t num, bvec3* value) { read(num * value->size(), value->data()); }
84 void read(size_t num, bvec4* value) { read(num * value->size(), value->data()); }
85 void read(size_t num, ubvec2* value) { read(num * value->size(), value->data()); }
86 void read(size_t num, ubvec3* value) { read(num * value->size(), value->data()); }
87 void read(size_t num, ubvec4* value) { read(num * value->size(), value->data()); }
88 void read(size_t num, svec2* value) { read(num * value->size(), value->data()); }
89 void read(size_t num, svec3* value) { read(num * value->size(), value->data()); }
90 void read(size_t num, svec4* value) { read(num * value->size(), value->data()); }
91 void read(size_t num, usvec2* value) { read(num * value->size(), value->data()); }
92 void read(size_t num, usvec3* value) { read(num * value->size(), value->data()); }
93 void read(size_t num, usvec4* value) { read(num * value->size(), value->data()); }
94 void read(size_t num, ivec2* value) { read(num * value->size(), value->data()); }
95 void read(size_t num, ivec3* value) { read(num * value->size(), value->data()); }
96 void read(size_t num, ivec4* value) { read(num * value->size(), value->data()); }
97 void read(size_t num, uivec2* value) { read(num * value->size(), value->data()); }
98 void read(size_t num, uivec3* value) { read(num * value->size(), value->data()); }
99 void read(size_t num, uivec4* value) { read(num * value->size(), value->data()); }
100 void read(size_t num, quat* value) { read(num * value->size(), value->data()); }
101 void read(size_t num, dquat* value) { read(num * value->size(), value->data()); }
102 void read(size_t num, mat3* value) { read(num * value->size(), value->data()); }
103 void read(size_t num, dmat3* value) { read(num * value->size(), value->data()); }
104 void read(size_t num, mat4* value) { read(num * value->size(), value->data()); }
105 void read(size_t num, dmat4* value) { read(num * value->size(), value->data()); }
106 void read(size_t num, sphere* value) { read(num * value->size(), value->data()); }
107 void read(size_t num, dsphere* value) { read(num * value->size(), value->data()); }
108 void read(size_t num, box* value) { read(num * value->size(), value->data()); }
109 void read(size_t num, dbox* value) { read(num * value->size(), value->data()); }
110 void read(size_t num, plane* value) { read(num * value->size(), value->data()); }
111 void read(size_t num, dplane* value) { read(num * value->size(), value->data()); }
112
114 template<typename T>
115 void read(size_t num, T* value)
116 {
117 if constexpr (has_read_write<T>())
118 {
119 for (size_t i = 0; i < num; ++i) value[i].read(*this);
120 }
121 else
122 {
123 read(num * sizeof(T), reinterpret_cast<uint8_t*>(value));
124 }
125 }
126
127 template<typename T>
128 void read(const char* propertyName, ref_ptr<T>& arg)
129 {
130 if (!matchPropertyName(propertyName)) return;
131 arg = read().cast<T>();
132 }
133
134 template<typename T>
135 void readObjects(const char* propertyName, T& values)
136 {
137 if (!matchPropertyName(propertyName)) return;
138
139 uint32_t numElements = 0;
140 read(1, &numElements);
141 values.resize(numElements);
142
143 using element_type = typename T::value_type::element_type;
144 const char* element_name = type_name<element_type>();
145
146 for (uint32_t i = 0; i < numElements; ++i)
147 {
148 read(element_name, values[i]);
149 }
150 }
151
152 template<typename T>
153 void readValues(const char* propertyName, std::vector<T>& values)
154 {
155 if (!matchPropertyName(propertyName)) return;
156
157 uint32_t numElements = 0;
158 read(1, &numElements);
159 values.resize(numElements);
160
161 for (uint32_t i = 0; i < numElements; ++i)
162 {
163 read("element", values[i]);
164 }
165 }
166
167 template<typename T>
168 void readValues(const char* propertyName, std::set<T>& values)
169 {
170 if (!matchPropertyName(propertyName)) return;
171
172 uint32_t numElements = 0;
173 read(1, &numElements);
174
175 for (uint32_t i = 0; i < numElements; ++i)
176 {
177 T v;
178 read("element", v);
179 values.insert(v);
180 }
181 }
182
184 template<typename... Args>
185 void read(const char* propertyName, Args&... args)
186 {
187 if (!matchPropertyName(propertyName)) return;
188
189 // use fold expression to expand arguments and map to appropriate read method
190 (read(1, &(args)), ...);
191 }
192
194 ref_ptr<Object> readObject(const char* propertyName)
195 {
196 if (!matchPropertyName(propertyName)) return ref_ptr<Object>();
197
198 return read();
199 }
200
202 template<class T>
203 ref_ptr<T> readObject(const char* propertyName)
204 {
205 if (!matchPropertyName(propertyName)) return ref_ptr<T>();
206
207 ref_ptr<Object> object = read();
208 return ref_ptr<T>(dynamic_cast<T*>(object.get()));
209 }
210
212 template<class T>
213 void readObject(const char* propertyName, ref_ptr<T>& arg)
214 {
215 if (!matchPropertyName(propertyName)) return;
216
217 arg = read().cast<T>();
218 }
219
221 template<typename T>
222 T readValue(const char* propertyName)
223 {
224 T v{};
225 read(propertyName, v);
226 return v;
227 }
228
230 template<typename W, typename T>
231 void readValue(const char* propertyName, T& value)
232 {
233 W read_value{};
234 read(propertyName, read_value);
235 value = static_cast<T>(read_value);
236 }
237
238 using ObjectID = uint32_t;
239 using ObjectIDMap = std::map<ObjectID, ref_ptr<Object>>;
240
241 ObjectIDMap objectIDMap;
242 ref_ptr<ObjectFactory> objectFactory;
243 ref_ptr<const Options> options;
244 Path filename;
245
246 VsgVersion version;
247
248 virtual bool version_less(uint32_t major, uint32_t minor, uint32_t patch, uint32_t soversion = 0) const;
249 virtual bool version_greater_equal(uint32_t major, uint32_t minor, uint32_t patch, uint32_t soversion = 0) const;
250
251 protected:
252 virtual ~Input();
253 };
254
255 template<>
256 inline void Input::readObject(const char* propertyName, ref_ptr<Object>& arg)
257 {
258 if (!matchPropertyName(propertyName)) return;
259
260 arg = read();
261 }
262
263} // namespace vsg
vsg::Input
Definition Input.h:44
vsg::Input::readObject
void readObject(const char *propertyName, ref_ptr< T > &arg)
read object of a particular type
Definition Input.h:213
vsg::Input::readValue
void readValue(const char *propertyName, T &value)
read a value as a type, then cast it to another type
Definition Input.h:231
vsg::Input::readValue
T readValue(const char *propertyName)
read a value of particular type
Definition Input.h:222
vsg::Input::readObject
ref_ptr< Object > readObject(const char *propertyName)
read object of a particular type
Definition Input.h:194
vsg::Input::readObject
ref_ptr< T > readObject(const char *propertyName)
read object of a particular type
Definition Input.h:203
vsg::Input::matchPropertyName
virtual bool matchPropertyName(const char *propertyName)=0
return true if property name matches the next token in the stream, or if property names are not requi...
vsg::Input::read
void read(const char *propertyName, Args &... args)
match property name and read value(s)
Definition Input.h:185
vsg::Input::read
void read(size_t num, T *value)
treat non standard type as raw data
Definition Input.h:115
vsg::Path
Definition Path.h:34
vsg::ref_ptr
Definition ref_ptr.h:22