OgreCommon.h
Go to the documentation of this file.
1 /*
2 -----------------------------------------------------------------------------
3 This source file is part of OGRE
4  (Object-oriented Graphics Rendering Engine)
5 For the latest info, see http://www.ogre3d.org/
6 
7 Copyright (c) 2000-2013 Torus Knot Software Ltd
8 
9 Permission is hereby granted, free of charge, to any person obtaining a copy
10 of this software and associated documentation files (the "Software"), to deal
11 in the Software without restriction, including without limitation the rights
12 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
13 copies of the Software, and to permit persons to whom the Software is
14 furnished to do so, subject to the following conditions:
15 
16 The above copyright notice and this permission notice shall be included in
17 all copies or substantial portions of the Software.
18 
19 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
20 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
21 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
22 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
23 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
24 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
25 THE SOFTWARE.
26 -----------------------------------------------------------------------------
27 */
28 #ifndef __Common_H__
29 #define __Common_H__
30 // Common stuff
31 
32 #include "OgreString.h"
33 
34 #if defined ( OGRE_GCC_VISIBILITY )
35 # pragma GCC visibility push(default)
36 #endif
37 
38 #if defined ( OGRE_GCC_VISIBILITY )
39 # pragma GCC visibility pop
40 #endif
41 
42 #include "OgreHeaderPrefix.h"
43 
44 namespace Ogre {
52  uint32 _OgreExport FastHash (const char * data, int len, uint32 hashSoFar = 0);
55  template <typename T>
56  uint32 HashCombine (uint32 hashSoFar, const T& data)
57  {
58  return FastHash((const char*)&data, sizeof(T), hashSoFar);
59  }
60 
61 
65  {
74  };
75 
79  {
88  };
89 
91  {
98  };
101  {
110  };
111 
114  {
118  };
119 
121  enum FogMode
122  {
131  };
132 
136  {
143  };
144 
151  {
158  };
159 
162  {
176  };
177 
180  {
187  };
188 
191  {
209 
230 
240 
273  };
274 
278  TVC_NONE = 0x0,
279  TVC_AMBIENT = 0x1,
280  TVC_DIFFUSE = 0x2,
283  };
284 
286  enum SortMode
287  {
292  };
293 
296  FBT_COLOUR = 0x1,
297  FBT_DEPTH = 0x2,
299  };
300 
303  {
307  IM_USE16BIT = 0x0001,
308 
311  IM_VTFBESTFIT = 0x0002,
312 
316 
318 
320  IM_USEONEWEIGHT = 0x0010,
321 
324 
326  };
327 
328 
331  template <typename T>
333  {
334  public:
335  typedef std::vector<T, STLAllocator<T, GeneralAllocPolicy> > VectorImpl;
336  protected:
338  mutable uint32 mListHash;
339  mutable bool mListHashDirty;
340 
341  void addToHash(const T& newPtr) const
342  {
343  mListHash = FastHash((const char*)&newPtr, sizeof(T), mListHash);
344  }
345  void recalcHash() const
346  {
347  mListHash = 0;
348  for (const_iterator i = mList.begin(); i != mList.end(); ++i)
349  addToHash(*i);
350  mListHashDirty = false;
351 
352  }
353 
354  public:
355  typedef typename VectorImpl::value_type value_type;
356  typedef typename VectorImpl::pointer pointer;
357  typedef typename VectorImpl::reference reference;
358  typedef typename VectorImpl::const_reference const_reference;
359  typedef typename VectorImpl::size_type size_type;
360  typedef typename VectorImpl::difference_type difference_type;
361  typedef typename VectorImpl::iterator iterator;
362  typedef typename VectorImpl::const_iterator const_iterator;
363  typedef typename VectorImpl::reverse_iterator reverse_iterator;
364  typedef typename VectorImpl::const_reverse_iterator const_reverse_iterator;
365 
366  void dirtyHash()
367  {
368  mListHashDirty = true;
369  }
370  bool isHashDirty() const
371  {
372  return mListHashDirty;
373  }
374 
376  {
377  // we have to assume that hash needs recalculating on non-const
378  dirtyHash();
379  return mList.begin();
380  }
381  iterator end() { return mList.end(); }
382  const_iterator begin() const { return mList.begin(); }
383  const_iterator end() const { return mList.end(); }
385  {
386  // we have to assume that hash needs recalculating on non-const
387  dirtyHash();
388  return mList.rbegin();
389  }
390  reverse_iterator rend() { return mList.rend(); }
391  const_reverse_iterator rbegin() const { return mList.rbegin(); }
392  const_reverse_iterator rend() const { return mList.rend(); }
393  size_type size() const { return mList.size(); }
394  size_type max_size() const { return mList.max_size(); }
395  size_type capacity() const { return mList.capacity(); }
396  bool empty() const { return mList.empty(); }
398  {
399  // we have to assume that hash needs recalculating on non-const
400  dirtyHash();
401  return mList[n];
402  }
403  const_reference operator[](size_type n) const { return mList[n]; }
405  {
406  // we have to assume that hash needs recalculating on non-const
407  dirtyHash();
408  return mList.const_iterator(n);
409  }
410  const_reference at(size_type n) const { return mList.at(n); }
413  HashedVector(size_type n, const T& t) : mList(n, t), mListHash(0), mListHashDirty(n > 0) {}
416 
417  template <class InputIterator>
418  HashedVector(InputIterator a, InputIterator b)
419  : mList(a, b), mListHashDirty(false)
420  {
421  dirtyHash();
422  }
423 
426  {
427  mList = rhs.mList;
428  mListHash = rhs.mListHash;
430  return *this;
431  }
432 
433  void reserve(size_t t) { mList.reserve(t); }
435  {
436  // we have to assume that hash needs recalculating on non-const
437  dirtyHash();
438  return mList.front();
439  }
440  const_reference front() const { return mList.front(); }
442  {
443  // we have to assume that hash needs recalculating on non-const
444  dirtyHash();
445  return mList.back();
446  }
447  const_reference back() const { return mList.back(); }
448  void push_back(const T& t)
449  {
450  mList.push_back(t);
451  // Quick progressive hash add
452  if (!isHashDirty())
453  addToHash(t);
454  }
455  void pop_back()
456  {
457  mList.pop_back();
458  dirtyHash();
459  }
461  {
462  mList.swap(rhs.mList);
463  dirtyHash();
464  }
465  iterator insert(iterator pos, const T& t)
466  {
467  bool recalc = (pos != end());
468  iterator ret = mList.insert(pos, t);
469  if (recalc)
470  dirtyHash();
471  else
472  addToHash(t);
473  return ret;
474  }
475 
476  template <class InputIterator>
477  void insert(iterator pos,
478  InputIterator f, InputIterator l)
479  {
480  mList.insert(pos, f, l);
481  dirtyHash();
482  }
483 
484  void insert(iterator pos, size_type n, const T& x)
485  {
486  mList.insert(pos, n, x);
487  dirtyHash();
488  }
489 
491  {
492  iterator ret = mList.erase(pos);
493  dirtyHash();
494  return ret;
495  }
497  {
498  iterator ret = mList.erase(first, last);
499  dirtyHash();
500  return ret;
501  }
502  void clear()
503  {
504  mList.clear();
505  mListHash = 0;
506  mListHashDirty = false;
507  }
508 
509  void resize(size_type n, const T& t = T())
510  {
511  bool recalc = false;
512  if (n != size())
513  recalc = true;
514 
515  mList.resize(n, t);
516  if (recalc)
517  dirtyHash();
518  }
519 
521  { return mListHash == b.mListHash; }
522 
523  bool operator<(const HashedVector<T>& b)
524  { return mListHash < b.mListHash; }
525 
526 
528  uint32 getHash() const
529  {
530  if (isHashDirty())
531  recalcHash();
532 
533  return mListHash;
534  }
535  public:
536 
537 
538 
539  };
540 
541  class Light;
543 
544 
545 
548 
551 
554 
555  template< typename T > struct TRect
556  {
558  TRect() : left(0), top(0), right(0), bottom(0) {}
559  TRect( T const & l, T const & t, T const & r, T const & b )
560  : left( l ), top( t ), right( r ), bottom( b )
561  {
562  }
563  TRect( TRect const & o )
564  : left( o.left ), top( o.top ), right( o.right ), bottom( o.bottom )
565  {
566  }
567  TRect & operator=( TRect const & o )
568  {
569  left = o.left;
570  top = o.top;
571  right = o.right;
572  bottom = o.bottom;
573  return *this;
574  }
575  T width() const
576  {
577  return right - left;
578  }
579  T height() const
580  {
581  return bottom - top;
582  }
583  bool isNull() const
584  {
585  return width() == 0 || height() == 0;
586  }
587  void setNull()
588  {
589  left = right = top = bottom = 0;
590  }
591  TRect & merge(const TRect& rhs)
592  {
593  if (isNull())
594  {
595  *this = rhs;
596  }
597  else if (!rhs.isNull())
598  {
599  left = std::min(left, rhs.left);
600  right = std::max(right, rhs.right);
601  top = std::min(top, rhs.top);
602  bottom = std::max(bottom, rhs.bottom);
603  }
604 
605  return *this;
606 
607  }
608  TRect intersect(const TRect& rhs) const
609  {
610  TRect ret;
611  if (isNull() || rhs.isNull())
612  {
613  // empty
614  return ret;
615  }
616  else
617  {
618  ret.left = std::max(left, rhs.left);
619  ret.right = std::min(right, rhs.right);
620  ret.top = std::max(top, rhs.top);
621  ret.bottom = std::min(bottom, rhs.bottom);
622  }
623 
624  if (ret.left > ret.right || ret.top > ret.bottom)
625  {
626  // no intersection, return empty
627  ret.left = ret.top = ret.right = ret.bottom = 0;
628  }
629 
630  return ret;
631 
632  }
633 
634  };
635  template<typename T>
636  std::ostream& operator<<(std::ostream& o, const TRect<T>& r)
637  {
638  o << "TRect<>(l:" << r.left << ", t:" << r.top << ", r:" << r.right << ", b:" << r.bottom << ")";
639  return o;
640  }
641 
645 
650 
654 
659  struct Box
660  {
663  Box()
664  : left(0), top(0), right(1), bottom(1), front(0), back(1)
665  {
666  }
676  Box( uint32 l, uint32 t, uint32 r, uint32 b ):
677  left(l),
678  top(t),
679  right(r),
680  bottom(b),
681  front(0),
682  back(1)
683  {
684  assert(right >= left && bottom >= top && back >= front);
685  }
697  Box( uint32 l, uint32 t, uint32 ff, uint32 r, uint32 b, uint32 bb ):
698  left(l),
699  top(t),
700  right(r),
701  bottom(b),
702  front(ff),
703  back(bb)
704  {
705  assert(right >= left && bottom >= top && back >= front);
706  }
707 
709  bool contains(const Box &def) const
710  {
711  return (def.left >= left && def.top >= top && def.front >= front &&
712  def.right <= right && def.bottom <= bottom && def.back <= back);
713  }
714 
716  uint32 getWidth() const { return right-left; }
718  uint32 getHeight() const { return bottom-top; }
720  uint32 getDepth() const { return back-front; }
721  };
722 
723 
724 
736  int _OgreExport findCommandLineOpts(int numargs, char** argv, UnaryOptionList& unaryOptList,
737  BinaryOptionList& binOptList);
738 
741  {
748  };
749 
752  {
754  unsigned int width;
755  unsigned int height;
758  };
759 
762 
765 
768 }
769 
770 #include "OgreHeaderSuffix.h"
771 
772 #endif

Copyright © 2012 Torus Knot Software Ltd
Creative Commons License
This work is licensed under a Creative Commons Attribution-ShareAlike 3.0 Unported License.
Last modified Wed Oct 23 2013 06:57:23