Applies general transformation to an intersectable. More...
#include <TransformedIntersectable.h>
Public Member Functions | |
| TransformedIntersectable () | |
| TransformedIntersectable (const Intersectable *intersectable, const math::Transform *localToWorld, const math::Transform *worldToLocal) | |
| bool | isIntersecting (const Ray &ray, HitProbe &probe) const override |
| Determine whether a given ray hits the object. | |
| bool | reintersect (const Ray &ray, HitProbe &probe, const Ray &srcRay, HitProbe &srcProbe) const override |
| Intersect the intersected object again with a different ray. | |
| void | calcHitDetail (const Ray &ray, HitProbe &probe, HitDetail *const out_detail) const override |
| Calculates properties of a hit, such as coordinates and normal. | |
| bool | isOccluding (const Ray &ray) const override |
| Determines whether this object blocks the ray. | |
| bool | mayOverlapVolume (const math::AABB3D &aabb) const override |
| Conservatively checks whether this object overlaps a volume. | |
| math::AABB3D | calcAABB () const override |
| Calculates Axis-Aligned Bounding Box (AABB) of itself. | |
 Public Member Functions inherited from ph::Intersectable | |
| virtual | ~Intersectable ()=default |
Protected Attributes | |
| const Intersectable * | m_intersectable |
| const math::Transform * | m_localToWorld |
| const math::Transform * | m_worldToLocal |
Detailed Description
Applies general transformation to an intersectable.
Constructor & Destructor Documentation
◆ TransformedIntersectable() [1/2]
| ph::TransformedIntersectable::TransformedIntersectable | ( | ) |
◆ TransformedIntersectable() [2/2]
| ph::TransformedIntersectable::TransformedIntersectable | ( | const Intersectable * | intersectable, |
| const math::Transform * | localToWorld, | ||
| const math::Transform * | worldToLocal ) |
Member Function Documentation
◆ calcAABB()
|
overridevirtual |
Calculates Axis-Aligned Bounding Box (AABB) of itself.
Implements ph::Intersectable.
◆ calcHitDetail()
|
inlineoverridevirtual |
Calculates properties of a hit, such as coordinates and normal.
This method calculates a detailed description of a hit from the ray and probe involved in a hit event. For example, the ray and probe used for calling isIntersecting() can be the inputs of this method (if an intersection is found). The process of calculating intersection detail will destroy the input probe.
- Parameters
-
ray The ray from a hit event. probe The probe from a hit event. The process of detail calculation will destroy the probe. out_detail Stores the calculated details. This method calculates the essential details only. Some information such as coordinate bases will only be available if specifically requested afterwards (for an example, see HitDetail::computeBases()).
- Note
- See
Primitivefor more methods that can generate a hit event.
- Warning
- This method will destroy the probe.
Implements ph::Intersectable.
◆ isIntersecting()
|
inlineoverridevirtual |
Determine whether a given ray hits the object.
Checks whether the specified ray intersects this intersectable. If there is an intersection, true is returned and a brief hit report is stored inside the probe. If there is no intersection, false is returned and the state of the probe is undefined. ray and probe can be used for obtaining hit detail if an intersection is found.
- Note
- Generates hit event (with
rayandprobe).
Implements ph::Intersectable.
◆ isOccluding()
|
inlineoverridevirtual |
Determines whether this object blocks the ray.
If greater performance is desired, you can override the default implementation which simply calls isIntersecting(const Ray&, HitProbe&) const to do the job. The test generally considers the underlying shape as hollow (for closed shape), e.g., a sphere is not occluding a line segment inside the sphere.
This method does not provide any means to retrieve HitDetail. Focusing on testing occlusion can improve performance for some cases.
Reimplemented from ph::Intersectable.
◆ mayOverlapVolume()
|
overridevirtual |
Conservatively checks whether this object overlaps a volume.
By conservative, it means true can be returned even though the object does not overlap the volume; but if it actually does, true must be returned. The default implementation performs conservative intersecting test using the AABB calculated by calcAABB(). Although false-positives are allowed for this method, providing an implementation with higher accuracy is benefitial for many algorithms used by the renderer. The test generally considers the underlying shape as hollow (for closed shape), while the volume is solid.
Reimplemented from ph::Intersectable.
◆ reintersect()
|
inlineoverridevirtual |
Intersect the intersected object again with a different ray.
This method is different to isIntersecting(const Ray, HitProbe&) const. Given srcRay and srcProbe, this method performs an intersection test against the chain of intersectables recorded in srcProbe (so it is impossible to "discover" new intersectables with this method). Taking BVH as an example, the implementation may only record the intersected object in the probe so this method can bypass the entire BVH traversal.
- Parameters
-
ray The ray to test for intersection. probe The probe to record the intersection. srcRay The ray from a previous hit event. srcProbe The probe from a hit event. The process of re-intersect will destroy the probe.
- Returns
- Whether
rayintersects the object.
- Note
- Generates hit event (with
rayandprobe).
- Warning
- This method will destroy
srcProbe.
Implements ph::Intersectable.
Member Data Documentation
◆ m_intersectable
|
protected |
◆ m_localToWorld
|
protected |
◆ m_worldToLocal
|
protected |
The documentation for this class was generated from the following files:
- Source/Core/Intersection/TransformedIntersectable.h
- Source/Core/Intersection/TransformedIntersectable.cpp
