Free Electron
SurfaceAccessorGeo.h
Go to the documentation of this file.
1 /* Copyright (C) 2003-2021 Free Electron Organization
2  Any use of this software requires a license. If a valid license
3  was not distributed with this file, visit freeelectron.org. */
4 
5 /** @file */
6 
7 #ifndef __json_SurfaceAccessorGeo_h__
8 #define __json_SurfaceAccessorGeo_h__
9 
10 namespace fe
11 {
12 namespace ext
13 {
14 
15 /**************************************************************************//**
16  @brief Common Functionality for Accessor Surface
17 
18  @ingroup json
19 *//***************************************************************************/
20 class FE_DL_EXPORT SurfaceAccessorGeo:
21  public SurfaceAccessorBase,
22  public fe::CastableAs<SurfaceAccessorGeo>
23 {
24  public:
25  SurfaceAccessorGeo(void):
26  m_pElementValues(NULL),
27  m_pVertexValues(NULL)
28  { setName("SurfaceAccessorGeo"); }
29 virtual ~SurfaceAccessorGeo(void) {}
30 
31  using SurfaceAccessorBase::set;
32  using SurfaceAccessorBase::append;
33  using SurfaceAccessorBase::spatialVector;
34 
35  //* as SurfaceAccessorI
36  BWORD bind(SurfaceAccessibleI::Element a_element,
37  SurfaceAccessibleI::Attribute a_attribute)
38  {
39  m_attribute=a_attribute;
40 
41  String name;
42  switch(a_attribute)
43  {
44  case SurfaceAccessibleI::e_generic:
45  case SurfaceAccessibleI::e_position:
46  name="P";
47  break;
48  case SurfaceAccessibleI::e_normal:
49  name="N";
50  break;
51  case SurfaceAccessibleI::e_uv:
52  name="uv";
53  break;
54  case SurfaceAccessibleI::e_color:
55  name="Cd";
56  break;
57  case SurfaceAccessibleI::e_vertices:
58  m_attrName="vertices";
59  FEASSERT(a_element==
60  SurfaceAccessibleI::e_primitive);
61  break;
62  case SurfaceAccessibleI::e_properties:
63  m_attrName="properties";
64  FEASSERT(a_element==
65  SurfaceAccessibleI::e_primitive);
66  break;
67  }
68  return bindInternal(a_element,name);
69  }
70  BWORD bind(SurfaceAccessibleI::Element a_element,
71  const String& a_name)
72  {
73  m_attribute=SurfaceAccessibleI::e_generic;
74  return bindInternal(a_element,a_name);
75  }
76 virtual U32 count(void) const
77  {
78  if(m_attribute!=SurfaceAccessibleI::e_generic &&
79  m_attribute!=
80  SurfaceAccessibleI::e_vertices &&
81  m_attribute!=
82  SurfaceAccessibleI::e_properties &&
83  !isBound())
84  {
85  return 0;
86  }
87 
88  return elementCount(m_element);
89  }
90 virtual U32 subCount(U32 a_index) const
91  {
92  if(m_attribute!=SurfaceAccessibleI::e_generic &&
93  m_attribute!=
94  SurfaceAccessibleI::e_vertices &&
95  m_attribute!=
96  SurfaceAccessibleI::e_properties &&
97  !isBound())
98  {
99  return 0;
100  }
101 
102  if(m_attribute==SurfaceAccessibleI::e_vertices)
103  {
104  FEASSERT(m_element==
105  SurfaceAccessibleI::e_primitive);
106 
107  Json::Value* pVertexArray=
108  findVertices(a_index);
109 
110  FEASSERT(pVertexArray);
111  return pVertexArray->size();
112  }
113 
114  return 1;
115  }
116 
117 virtual void set(U32 a_index,U32 a_subIndex,String a_string)
118  {
119  if(m_element!=SurfaceAccessibleI::e_pointGroup &&
120  m_element!=
121  SurfaceAccessibleI::e_primitiveGroup &&
122  m_attribute!=
123  SurfaceAccessibleI::e_vertices &&
124  !isBound())
125  {
126  addString();
127  }
128 
129  if(!isBound())
130  {
131  return;
132  }
133 
134  Json::Value& rElementValue=
135  (*m_pStringValues)[(int)a_index];
136 
137  rElementValue=a_string.c_str();
138  }
139 
140 virtual String string(U32 a_index,U32 a_subIndex=0)
141  {
142  if(!isBound())
143  {
144  return 0;
145  }
146 
147  if(m_element==
148  SurfaceAccessibleI::e_primitiveGroup ||
149  m_attribute==SurfaceAccessibleI::e_vertices)
150  {
151  FEASSERT(m_element==
152  SurfaceAccessibleI::e_primitiveGroup
153  || m_element==
154  SurfaceAccessibleI::e_primitive);
155 
156  return pointByVertex(a_index,a_subIndex);
157  }
158 
159  const Json::Value& rElementValue=
160  (*m_pStringValues)[(int)a_index];
161 
162  return rElementValue.asString().c_str();
163  }
164 
165 virtual void set(U32 a_index,U32 a_subIndex,I32 a_integer)
166  {
167  if(m_element!=SurfaceAccessibleI::e_pointGroup &&
168  m_element!=
169  SurfaceAccessibleI::e_primitiveGroup &&
170  m_attribute!=
171  SurfaceAccessibleI::e_vertices &&
172  !isBound())
173  {
174  addInteger();
175  }
176 
177  if(!isBound())
178  {
179  return;
180  }
181 
182  Json::Value& rElementValue=
183  (*m_pElementValues)[(int)a_index];
184 
185  rElementValue[0]=a_integer;
186  }
187 
188 virtual I32 integer(U32 a_index,U32 a_subIndex=0)
189  {
190  if(!isBound())
191  {
192  return 0;
193  }
194 
195  if(m_element==
196  SurfaceAccessibleI::e_primitiveGroup ||
197  m_attribute==SurfaceAccessibleI::e_vertices)
198  {
199  FEASSERT(m_element==
200  SurfaceAccessibleI::e_primitiveGroup
201  || m_element==
202  SurfaceAccessibleI::e_primitive);
203 
204  return pointByVertex(a_index,a_subIndex);
205  }
206 
207  const Json::Value& rElementValue=
208  (*m_pElementValues)[(int)a_index];
209 
210  return rElementValue[0].asInt();
211  }
212 
213 virtual I32 append(SurfaceAccessibleI::Form a_form)
214  {
215  if(m_element==SurfaceAccessibleI::e_point)
216  {
217  const I32 index=
218  m_spJsonRoot->value()[5].asInt();
219 
220  m_spJsonRoot->value()[5]=index+1;
221 
222  return index;
223  }
224 
225  if(m_element==SurfaceAccessibleI::e_primitive)
226  {
227  const I32 index=
228  m_spJsonRoot->value()[9].asInt();
229 
230  m_spJsonRoot->value()[9]=index+1;
231 
232  return index;
233  }
234 
235  //* TODO otherwise
236 
237  return -1;
238  }
239 
240 virtual void append(U32 a_index,I32 a_integer)
241  {
242  if(m_element==
243  SurfaceAccessibleI::e_primitiveGroup ||
244  m_attribute==SurfaceAccessibleI::e_vertices)
245  {
246  FEASSERT(m_element==
247  SurfaceAccessibleI::e_primitiveGroup
248  || m_element==
249  SurfaceAccessibleI::e_primitive);
250 
251  Json::Value* pVertexMap=
252  &m_spJsonRoot->value()[13][1][1];
253  FEASSERT(pVertexMap);
254 
255  Json::Value* pVertexArray=
256  findVertices(a_index);
257  FEASSERT(pVertexArray);
258 
259  const int newPointIndex=
260  pVertexArray->size();
261  const int newVertexIndex=
262  pVertexMap->size();
263 
264  (*pVertexArray)[newPointIndex]=
265  newVertexIndex;
266  (*pVertexMap)[newVertexIndex]=a_integer;
267  }
268 
269  //* TODO otherwise
270  }
271 
272 virtual void set(U32 a_index,U32 a_subIndex,Real a_real)
273  {
274  if(m_element!=SurfaceAccessibleI::e_pointGroup &&
275  m_element!=
276  SurfaceAccessibleI::e_primitiveGroup &&
277  m_attribute!=
278  SurfaceAccessibleI::e_vertices &&
279  !isBound())
280  {
281  addReal();
282  }
283 
284  if(!isBound())
285  {
286  return;
287  }
288 
289  Json::Value& rElementValue=
290  (*m_pElementValues)[(int)a_index];
291 
292  rElementValue[0]=a_real;
293  }
294 
295 virtual Real real(U32 a_index,U32 a_subIndex=0)
296  {
297  if(!isBound())
298  {
299  return 0;
300  }
301 
302  if(m_element==
303  SurfaceAccessibleI::e_primitiveGroup ||
304  m_attribute==SurfaceAccessibleI::e_vertices)
305  {
306  FEASSERT(m_element==
307  SurfaceAccessibleI::e_primitiveGroup
308  || m_element==
309  SurfaceAccessibleI::e_primitive);
310 
311  return pointByVertex(a_index,a_subIndex);
312  }
313 
314  const Json::Value& rElementValue=
315  (*m_pElementValues)[(int)a_index];
316 
317  return rElementValue[0].asFloat();
318  }
319 
320 virtual void set(U32 a_index,U32 a_subIndex,
321  const SpatialVector& a_vector)
322  {
323  if(m_element!=SurfaceAccessibleI::e_pointGroup &&
324  m_element!=
325  SurfaceAccessibleI::e_primitiveGroup &&
326  m_attribute!=
327  SurfaceAccessibleI::e_vertices &&
328  !isBound())
329  {
330  addSpatialVector();
331  }
332 
333  if(!isBound())
334  {
335  return;
336  }
337 
338  Json::Value& rElementValue=
339  (*m_pElementValues)[(int)a_index];
340 
341  rElementValue[0]=a_vector[0];
342  rElementValue[1]=a_vector[1];
343  rElementValue[2]=a_vector[2];
344  rElementValue[3]=0.0;
345  }
346 virtual SpatialVector spatialVector(U32 a_index,U32 a_subIndex=0)
347  {
348  if(!isBound())
349  {
350  return SpatialVector(0.0,0.0,0.0);
351  }
352 
353  U32 pointIndex=a_index;
354 
355  if(m_element==
356  SurfaceAccessibleI::e_primitiveGroup ||
357  m_attribute==SurfaceAccessibleI::e_vertices)
358  {
359  FEASSERT(m_element==
360  SurfaceAccessibleI::e_primitiveGroup
361  || m_element==
362  SurfaceAccessibleI::e_primitive);
363 
364  pointIndex=pointByVertex(a_index,a_subIndex);
365  }
366 
367  const Json::Value& rElementValue=
368  (*m_pElementValues)[(int)pointIndex];
369 
370  return SpatialVector(
371  rElementValue[0].asFloat(),
372  rElementValue[1].asFloat(),
373  rElementValue[2].asFloat());
374  }
375 
376  //* JSON specific
377  void setJsonRoot(sp<JsonValue> a_spJsonRoot)
378  { m_spJsonRoot=a_spJsonRoot; }
379 
380  sp<JsonValue> jsonRoot(void) { return m_spJsonRoot; }
381 
382 static Json::Value* accessAttributes(sp<JsonValue> a_spJsonRoot,
383  SurfaceAccessibleI::Element a_element,
384  BWORD a_create);
385 
386  private:
387 
388 virtual BWORD bindInternal(SurfaceAccessibleI::Element a_element,
389  const String& a_name);
390 
391  void addAttribute(String a_type,String a_typeValue,
392  String a_storage,U32 a_components);
393  void addString(void);
394  void addInteger(void);
395  void addReal(void);
396  void addSpatialVector(void);
397 
398 static Json::Value* findKey(Json::Value* a_pParent,String a_key);
399 static Json::Value* accessPointAttributes(sp<JsonValue> a_spJsonRoot,
400  BWORD a_create);
401 static Json::Value* accessVertexAttributes(sp<JsonValue> a_spJsonRoot,
402  BWORD a_create);
403 static Json::Value* accessPrimitiveAttributes(sp<JsonValue> a_spJsonRoot,
404  BWORD a_create);
405 static Json::Value* accessDetailAttributes(sp<JsonValue> a_spJsonRoot,
406  BWORD a_create);
407 
408  I32 elementCount(
409  SurfaceAccessibleI::Element a_element) const;
410 
411  BWORD isBound(void) const
412  { return (m_pElementValues!=NULL); }
413 
414  Json::Value* findVertices(U32 a_index) const
415  { return &(*m_pVertexValues)[(int)a_index][0]; }
416 
417  U32 pointByVertex(U32 a_index,U32 a_subIndex)
418  {
419  Json::Value* pVertexArray=findVertices(a_index);
420 
421  FEASSERT(pVertexArray);
422  const Json::Value& rVertexValue=
423  (*pVertexArray)[(int)a_subIndex];
424 
425  const U32 vertexIndex=rVertexValue.asInt();
426 
427  const Json::Value& rPointValue=
428  (*m_pVertexMap)[(int)vertexIndex];
429 
430  return rPointValue.asInt();
431  }
432 
433  sp<JsonValue> m_spJsonRoot;
434  Json::Value* m_pElementValues;
435  Json::Value* m_pStringValues;
436  Json::Value* m_pVertexMap;
437  Json::Value* m_pVertexValues;
438 };
439 
440 } /* namespace ext */
441 } /* namespace fe */
442 
443 #endif /* __json_SurfaceAccessorGeo_h__ */
fe
kernel
Definition: namespace.dox:3
Json::Value
Represents a JSON value.
Definition: value.h:194
fe::ext::SurfaceAccessorBase
Common Functionality for Accessor Surface.
Definition: SurfaceAccessorBase.h:20
fe::String
Automatically reference-counted string container.
Definition: String.h:128
Json::Value::size
ArrayIndex size() const
Number of values in array or object.
Json::Value::asString
String asString() const
Embedded zeroes are possible.
fe::ext::SurfaceAccessorGeo
Common Functionality for Accessor Surface.
Definition: SurfaceAccessorGeo.h:20
fe::sp
Intrusive Smart Pointer.
Definition: src/core/ptr.h:53
fe::CastableAs
Per-class participation non-RTTI fallback dynamic casting mechanism.
Definition: Castable.h:192
Generated by   doxygen 1.8.13