BVB Source Codes

CRYENGINE Show CoverSurface.h Source code

Return Download CRYENGINE: download CoverSurface.h Source code - Download CRYENGINE Source code - Type:.h
  1. // Copyright 2001-2016 Crytek GmbH / Crytek Group. All rights reserved.
  2.  
  3. #ifndef __CoverSurface_h__
  4. #define __CoverSurface_h__
  5. #pragma once
  6.  
  7. #include "Cover.h"
  8. #include "CoverPath.h"
  9.  
  10. class CoverSurface
  11. {
  12.         typedef ICoverSampler::Sample Sample;
  13. public:
  14.         CoverSurface();
  15.         CoverSurface(const ICoverSystem::SurfaceInfo& surfaceInfo);
  16.  
  17.         static void FreeStaticData()
  18.         {
  19.                 stl::free_container(s_simplifiedPoints);
  20.         }
  21.  
  22.         struct Segment
  23.         {
  24. #if defined(__clang__)
  25.         #pragma clang diagnostic push
  26.         #pragma clang diagnostic ignored "-Wconstant-conversion"
  27. #endif
  28.  
  29. #if defined(__GNUC__)
  30.         #if __GNUC__ >= 4 && __GNUC__MINOR__ < 7
  31.                 #pragma GCC diagnostic ignored "-Woverflow"
  32.         #else
  33.                 #pragma GCC diagnostic push
  34.                 #pragma GCC diagnostic ignored "-Woverflow"
  35.         #endif
  36. #endif
  37.                 Segment()
  38.                 {
  39.                         normal = ZERO;
  40.                         leftIdx = std::numeric_limits<uint16>::max();
  41.                         rightIdx = std::numeric_limits<uint16>::max();
  42.                         flags = 0;
  43.                         length = 0;
  44.                 }
  45. #if defined(__clang__)
  46.         #pragma clang diagnostic pop
  47. #endif
  48. #if defined(__GNUC__)
  49.         #if __GNUC__ >= 4 && __GNUC__MINOR__ < 7
  50.                 #pragma GCC diagnostic error "-Woverflow"
  51.         #else
  52.                 #pragma GCC diagnostic pop
  53.         #endif
  54. #endif
  55.  
  56.                 Segment(const Vec3& n, float len, uint16 left, uint16 right, uint16 _flags)
  57.                         : normal(n)
  58.                         , length(len)
  59.                         , leftIdx(left)
  60.                         , rightIdx(right)
  61.                         , flags(_flags)
  62.                 {
  63.                 }
  64.  
  65.                 enum Flags
  66.                 {
  67.                         Dynamic  = 1 << 0,
  68.                         Disabled = 1 << 1,
  69.                 };
  70.  
  71.                 Vec3   normal;
  72.                 float  length;
  73.  
  74.                 uint16 leftIdx  : 14;
  75.                 uint16 rightIdx : 14;
  76.                 uint16 flags    : 4;
  77.         };
  78.  
  79.         bool           IsValid() const;
  80.         void           Clear();
  81.         void           Swap(CoverSurface& other);
  82.  
  83.         uint32         GetSampleCount() const;
  84.         bool           GetSurfaceInfo(ICoverSystem::SurfaceInfo* surfaceInfo) const;
  85.  
  86.         uint32         GetSegmentCount() const;
  87.  
  88.         Segment&       GetSegment(uint16 segmentIdx);
  89.         const Segment& GetSegment(uint16 segmentIdx) const;
  90.  
  91.         const AABB&    GetAABB() const;
  92.         const uint32   GetFlags() const;
  93.  
  94.         void           ReserveSamples(uint32 sampleCount);
  95.         void           AddSample(const Sample& sample);
  96.         void           Generate();
  97.         void           GenerateLocations();
  98.  
  99.         uint32         GetLocationCount() const;
  100.         Vec3           GetLocation(uint16 location, float offset = 0.0f, float* height = 0, Vec3* normal = 0) const;
  101.  
  102.         bool           IsPointInCover(const Vec3& eye, const Vec3& point) const;
  103.         bool           IsCircleInCover(const Vec3& eye, const Vec3& center, float radius) const;
  104.         bool           CalculatePathCoverage(const Vec3& eye, const CoverPath& coverPath, CoverInterval* interval) const;
  105.         bool           GetCoverOcclusionAt(const Vec3& eye, const Vec3& point, float* heightSq) const;
  106.         bool           GetCoverOcclusionAt(const Vec3& eye, const Vec3& center, float radius, float* heightSq) const;
  107.  
  108.         bool           GenerateCoverPath(float distanceToCover, CoverPath* path, bool skipSimplify = false) const;
  109.  
  110.         void           DebugDraw() const;
  111.  
  112. private:
  113.         typedef std::vector<Vec3> Points;
  114.         void SimplifyCoverPath(Points& points) const;
  115.  
  116.         static Points s_simplifiedPoints;
  117.  
  118.         bool ILINE IsPointBehindSegment(const Vec3& eye, const Vec3& point, const Segment& segment) const
  119.         {
  120.                 const Sample& left = m_samples[segment.leftIdx];
  121.                 const Sample& right = m_samples[segment.rightIdx];
  122.  
  123.                 Lineseg ray(eye, point);
  124.                 Lineseg seg(left.position, right.position);
  125.  
  126.                 if (!Overlap::Lineseg_Lineseg2D(ray, seg))
  127.                         return false;
  128.  
  129.                 const float BottomGuard = 2.0f;
  130.  
  131.                 Vec3 leftBottom = left.position;
  132.                 leftBottom.z -= BottomGuard;
  133.                 Vec3 rightBottom = right.position;
  134.                 rightBottom.z -= BottomGuard;
  135.  
  136.                 Vec3 leftTop = left.position;
  137.                 leftTop.z += static_cast<float>(left.GetHeightInteger()) * Sample::GetHeightToFloatConverter();
  138.  
  139.                 Vec3 hit;
  140.  
  141.                 if (!Intersect::Lineseg_Triangle(ray, rightBottom, leftTop, leftBottom, hit))
  142.                 {
  143.                         Vec3 rightTop = right.position;
  144.                         rightTop.z += static_cast<float>(right.GetHeightInteger()) * Sample::GetHeightToFloatConverter();
  145.  
  146.                         if (!Intersect::Lineseg_Triangle(ray, rightBottom, rightTop, leftTop, hit))
  147.                                 return false;
  148.                 }
  149.  
  150.                 return true;
  151.         }
  152.  
  153.         bool ILINE GetOcclusionBehindSegment(const Vec3& eye, const Vec3& point, const Segment& segment, float* heightSq) const
  154.         {
  155.                 FUNCTION_PROFILER(gEnv->pSystem, PROFILE_AI);
  156.  
  157.                 const Sample& left = m_samples[segment.leftIdx];
  158.                 const Sample& right = m_samples[segment.rightIdx];
  159.  
  160.                 Lineseg ray(eye, point);
  161.                 Lineseg seg(left.position, right.position);
  162.  
  163.                 float a;
  164.                 float b;
  165.  
  166.                 if (!Intersect::Lineseg_Lineseg2D(ray, seg, a, b))
  167.                         return false;
  168.  
  169.                 const float BottomGuard = 2.0f;
  170.  
  171.                 Vec3 leftBottom = left.position;
  172.                 leftBottom.z -= BottomGuard;
  173.                 Vec3 rightBottom = right.position;
  174.                 rightBottom.z -= BottomGuard;
  175.  
  176.                 Vec3 leftTop = left.position;
  177.  
  178.                 float leftHeight = static_cast<float>(left.GetHeightInteger()) * Sample::GetHeightToFloatConverter();
  179.                 float rightHeight = static_cast<float>(right.GetHeightInteger()) * Sample::GetHeightToFloatConverter();
  180.                 leftTop.z += leftHeight;
  181.  
  182.                 Vec3 hit;
  183.  
  184.                 if (!Intersect::Lineseg_Triangle(ray, rightBottom, leftTop, leftBottom, hit))
  185.                 {
  186.                         Vec3 rightTop = right.position;
  187.                         rightTop.z += rightHeight;
  188.  
  189.                         if (!Intersect::Lineseg_Triangle(ray, rightBottom, rightTop, leftTop, hit))
  190.                                 return false;
  191.                 }
  192.  
  193.                 float h = leftHeight + b * (rightHeight - leftHeight);
  194.  
  195.                 Vec3 top = left.position + b * (right.position - left.position);
  196.                 top.z += h;
  197.  
  198.                 Vec3 dir = (top - eye) * 9999.0f;
  199.  
  200.                 float t;
  201.                 *heightSq = Distance::Point_LinesegSq(point, Lineseg(eye, eye + dir), t);
  202.  
  203.                 return true;
  204.         }
  205.  
  206.         bool IntersectCoverPlane(const Vec3& origin, const Vec3& length, const Plane& plane, Vec3* point, float* t) const;
  207.         void FindCoverPlanes(const Vec3& eye, Plane& left, Plane& right) const;
  208.  
  209.         typedef std::vector<Sample> Samples;
  210.         Samples m_samples;
  211.  
  212.         typedef std::vector<Segment> Segments;
  213.         Segments m_segments;
  214.  
  215.         struct Location
  216.         {
  217.                 enum
  218.                 {
  219.                         IntegerPartBitCount = 12,
  220.                 };
  221.  
  222.                 enum Flags
  223.                 {
  224.                         LeftEdge  = 1 << 0,
  225.                         RightEdge = 1 << 1,
  226.                 };
  227.  
  228.                 uint16 segmentIdx;
  229.                 uint16 offset;
  230.                 uint16 height;
  231.                 uint16 flags;
  232.  
  233.                 Location()
  234.                 {
  235.                 }
  236.  
  237.                 Location(const uint16 _segmentIdx, float _offset, float _height)
  238.                         : segmentIdx(_segmentIdx)
  239.                 {
  240.                         SetOffset(_offset);
  241.                         SetHeight(_height);
  242.                 }
  243.  
  244.                 ILINE void SetOffset(float _offset)
  245.                 {
  246.                         assert((0.0f <= _offset) && (_offset <= 1.0f));
  247.                         offset = (uint16)(_offset * (float)0xffff);
  248.                 }
  249.  
  250.                 ILINE float GetOffset() const
  251.                 {
  252.                         return offset * (1.0f / (float)0xffff);
  253.                 }
  254.  
  255.                 ILINE void SetHeight(float _height)
  256.                 {
  257.                         height = (uint16)(_height * ((1 << IntegerPartBitCount) - 1));
  258.                 }
  259.  
  260.                 ILINE float GetHeight() const
  261.                 {
  262.                         return height * (1.0f / (float)((1 << IntegerPartBitCount) - 1));
  263.                 }
  264.         };
  265.  
  266.         typedef std::vector<Location> Locations;
  267.         Locations m_locations;
  268.  
  269.         AABB      m_aabb;
  270.         uint32    m_flags;
  271. };
  272.  
  273. #endif //__CoverSurface_h__
  274.  
downloadCoverSurface.h Source code - Download CRYENGINE Source code
Related Source Codes/Software:
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
angular-starter - 2017-06-10

 Back to top