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

vsg 1.1.13 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(const Input& output) = delete;
49 Input& operator=(const Input& rhs) = delete;
50
52 virtual bool matchPropertyName(const char* propertyName) = 0;
53
54 // read value(s)
55 virtual void read(size_t num, int8_t* value) = 0;
56 virtual void read(size_t num, uint8_t* value) = 0;
57 virtual void read(size_t num, int16_t* value) = 0;
58 virtual void read(size_t num, uint16_t* value) = 0;
59 virtual void read(size_t num, int32_t* value) = 0;
60 virtual void read(size_t num, uint32_t* value) = 0;
61 virtual void read(size_t num, int64_t* value) = 0;
62 virtual void read(size_t num, uint64_t* value) = 0;
63 virtual void read(size_t num, float* value) = 0;
64 virtual void read(size_t num, double* value) = 0;
65 virtual void read(size_t num, long double* value) = 0;
66 virtual void read(size_t num, std::string* value) = 0;
67 virtual void read(size_t num, std::wstring* value) = 0;
68 virtual void read(size_t num, Path* value) = 0;
69
70 // read object
71 virtual ref_ptr<Object> read() = 0;
72
73 // map char to int8_t
74 void read(size_t num, char* value) { read(num, reinterpret_cast<int8_t*>(value)); }
75 void read(size_t num, bool* value) { read(num, reinterpret_cast<int8_t*>(value)); }
76
77 // vec/mat versions of read methods
78 void read(size_t num, vec2* value) { read(num * value->size(), value->data()); }
79 void read(size_t num, vec3* value) { read(num * value->size(), value->data()); }
80 void read(size_t num, vec4* value) { read(num * value->size(), value->data()); }
81 void read(size_t num, dvec2* value) { read(num * value->size(), value->data()); }
82 void read(size_t num, dvec3* value) { read(num * value->size(), value->data()); }
83 void read(size_t num, ldvec4* value) { read(num * value->size(), value->data()); }
84 void read(size_t num, ldvec2* value) { read(num * value->size(), value->data()); }
85 void read(size_t num, ldvec3* value) { read(num * value->size(), value->data()); }
86 void read(size_t num, dvec4* value) { read(num * value->size(), value->data()); }
87 void read(size_t num, bvec2* value) { read(num * value->size(), value->data()); }
88 void read(size_t num, bvec3* value) { read(num * value->size(), value->data()); }
89 void read(size_t num, bvec4* value) { read(num * value->size(), value->data()); }
90 void read(size_t num, ubvec2* value) { read(num * value->size(), value->data()); }
91 void read(size_t num, ubvec3* value) { read(num * value->size(), value->data()); }
92 void read(size_t num, ubvec4* value) { read(num * value->size(), value->data()); }
93 void read(size_t num, svec2* value) { read(num * value->size(), value->data()); }
94 void read(size_t num, svec3* value) { read(num * value->size(), value->data()); }
95 void read(size_t num, svec4* value) { read(num * value->size(), value->data()); }
96 void read(size_t num, usvec2* value) { read(num * value->size(), value->data()); }
97 void read(size_t num, usvec3* value) { read(num * value->size(), value->data()); }
98 void read(size_t num, usvec4* value) { read(num * value->size(), value->data()); }
99 void read(size_t num, ivec2* value) { read(num * value->size(), value->data()); }
100 void read(size_t num, ivec3* value) { read(num * value->size(), value->data()); }
101 void read(size_t num, ivec4* value) { read(num * value->size(), value->data()); }
102 void read(size_t num, uivec2* value) { read(num * value->size(), value->data()); }
103 void read(size_t num, uivec3* value) { read(num * value->size(), value->data()); }
104 void read(size_t num, uivec4* value) { read(num * value->size(), value->data()); }
105 void read(size_t num, quat* value) { read(num * value->size(), value->data()); }
106 void read(size_t num, dquat* value) { read(num * value->size(), value->data()); }
107 void read(size_t num, mat3* value) { read(num * value->size(), value->data()); }
108 void read(size_t num, dmat3* value) { read(num * value->size(), value->data()); }
109 void read(size_t num, mat4* value) { read(num * value->size(), value->data()); }
110 void read(size_t num, dmat4* value) { read(num * value->size(), value->data()); }
111 void read(size_t num, sphere* value) { read(num * value->size(), value->data()); }
112 void read(size_t num, dsphere* value) { read(num * value->size(), value->data()); }
113 void read(size_t num, box* value) { read(num * value->size(), value->data()); }
114 void read(size_t num, dbox* value) { read(num * value->size(), value->data()); }
115 void read(size_t num, plane* value) { read(num * value->size(), value->data()); }
116 void read(size_t num, dplane* value) { read(num * value->size(), value->data()); }
117
119 template<typename T>
120 void read(size_t num, T* value)
121 {
122 if constexpr (has_read_write<T>())
123 {
124 for (size_t i = 0; i < num; ++i) value[i].read(*this);
125 }
126 else
127 {
128 read(num * sizeof(T), reinterpret_cast<uint8_t*>(value));
129 }
130 }
131
132 template<typename T>
133 void read(const char* propertyName, ref_ptr<T>& arg)
134 {
135 if (!matchPropertyName(propertyName)) return;
136 arg = read().cast<T>();
137 }
138
139 template<typename T>
140 void readObjects(const char* propertyName, T& values)
141 {
142 if (!matchPropertyName(propertyName)) return;
143
144 uint32_t numElements = 0;
145 read(1, &numElements);
146 values.resize(numElements);
147
148 using element_type = typename T::value_type::element_type;
149 const char* element_name = type_name<element_type>();
150
151 for (uint32_t i = 0; i < numElements; ++i)
152 {
153 read(element_name, values[i]);
154 }
155 }
156
157 template<typename T>
158 void readValues(const char* propertyName, std::vector<T>& values)
159 {
160 if (!matchPropertyName(propertyName)) return;
161
162 uint32_t numElements = 0;
163 read(1, &numElements);
164 values.resize(numElements);
165
166 for (uint32_t i = 0; i < numElements; ++i)
167 {
168 read("element", values[i]);
169 }
170 }
171
172 template<typename T>
173 void readValues(const char* propertyName, std::set<T>& values)
174 {
175 if (!matchPropertyName(propertyName)) return;
176
177 uint32_t numElements = 0;
178 read(1, &numElements);
179
180 for (uint32_t i = 0; i < numElements; ++i)
181 {
182 T v;
183 read("element", v);
184 values.insert(v);
185 }
186 }
187
189 template<typename... Args>
190 void read(const char* propertyName, Args&... args)
191 {
192 if (!matchPropertyName(propertyName)) return;
193
194 // use fold expression to expand arguments and map to appropriate read method
195 (read(1, &(args)), ...);
196 }
197
199 ref_ptr<Object> readObject(const char* propertyName)
200 {
201 if (!matchPropertyName(propertyName)) return ref_ptr<Object>();
202
203 return read();
204 }
205
207 template<class T>
208 ref_ptr<T> readObject(const char* propertyName)
209 {
210 if (!matchPropertyName(propertyName)) return ref_ptr<T>();
211
212 ref_ptr<Object> object = read();
213 return ref_ptr<T>(dynamic_cast<T*>(object.get()));
214 }
215
217 template<class T>
218 void readObject(const char* propertyName, ref_ptr<T>& arg)
219 {
220 if (!matchPropertyName(propertyName)) return;
221
222 arg = read().cast<T>();
223 }
224
226 template<typename T>
227 T readValue(const char* propertyName)
228 {
229 T v{};
230 read(propertyName, v);
231 return v;
232 }
233
235 template<typename W, typename T>
236 void readValue(const char* propertyName, T& value)
237 {
238 W read_value{};
239 read(propertyName, read_value);
240 value = static_cast<T>(read_value);
241 }
242
243 using ObjectID = uint32_t;
244 using ObjectIDMap = std::map<ObjectID, ref_ptr<Object>>;
245
246 ObjectIDMap objectIDMap;
247 ref_ptr<ObjectFactory> objectFactory;
248 ref_ptr<const Options> options;
249 Path filename;
250
251 VsgVersion version;
252
253 virtual bool version_less(uint32_t major, uint32_t minor, uint32_t patch, uint32_t soversion = 0) const;
254 virtual bool version_greater_equal(uint32_t major, uint32_t minor, uint32_t patch, uint32_t soversion = 0) const;
255
256 protected:
257 virtual ~Input();
258 };
259
260 template<>
261 inline void Input::readObject(const char* propertyName, ref_ptr<Object>& arg)
262 {
263 if (!matchPropertyName(propertyName)) return;
264
265 arg = read();
266 }
267
268} // 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:218
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:236
vsg::Input::readValue
T readValue(const char *propertyName)
read a value of particular type
Definition Input.h:227
vsg::Input::readObject
ref_ptr< Object > readObject(const char *propertyName)
read object of a particular type
Definition Input.h:199
vsg::Input::readObject
ref_ptr< T > readObject(const char *propertyName)
read object of a particular type
Definition Input.h:208
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:190
vsg::Input::read
void read(size_t num, T *value)
treat non standard type as raw data
Definition Input.h:120
vsg::Options
Class for passing IO related options to vsg::read/write calls.
Definition Options.h:37
vsg::Path
Definition Path.h:34
vsg::ref_ptr
Definition ref_ptr.h:22