text stringlengths 1 24.5M |
|---|
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../../common/sys/platform.h"
#include "../../common/sys/sysinfo.h"
#include "../../common/sys/thread.h"
#include "../../common/sys/alloc.h"
#include "../../common/sys/ref.h"
#include "../../common/sys/intrinsics.h"
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "device.h"
#include "../../common/tasking/taskscheduler.h"
#include "../hash.h"
#include "scene_triangle_mesh.h"
#include "scene_user_geometry.h"
#include "scene_instance.h"
#include "scene_curves.h"
#include "scene_subdiv_mesh.... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "state.h"
#include "accel.h"
namespace embree
{
class BVH4Factory;
class BVH8Factory;
struct TaskArena;
class Device : public State, public MemoryMonitorInterface
{
ALIGNED_CLASS_... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "geometry.h"
#include "scene.h"
namespace embree
{
const char* Geometry::gtype_names[Geometry::GTY_END] =
{
"flat_linear_curve",
"round_linear_curve",
"oriented_linear_curve",
"",
"flat_bezier_curve",
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "device.h"
#include "buffer.h"
#include "../common/point_query.h"
#include "../builders/priminfo.h"
#include "../builders/priminfo_mb.h"
namespace embree
{
class Scene;
class Geometry;
st... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "ray.h"
#include "instance_stack.h"
namespace embree
{
/* Hit structure for K hits */
template<int K>
struct HitK
{
/* Default construction does nothing */
__forceinline HitK()... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "rtcore.h"
namespace embree {
namespace instance_id_stack {
static_assert(RTC_MAX_INSTANCE_LEVEL_COUNT > 0,
"RTC_MAX_INSTANCE_LEVEL_COUNT must be greater than 0.");
/********************************... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../../common/sys/platform.h"
#include "../../common/sys/sysinfo.h"
namespace embree
{
#define DEFINE_SYMBOL2(type,name) \
typedef type (*name##Func)(); \
name##Func name;
#defin... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../../common/math/affinespace.h"
#include "../../common/math/interval.h"
#include <functional>
namespace embree {
#define MOTION_DERIVATIVE_ROOT_EPSILON 1e-4f
static void motion_derivative_coefficients(const flo... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
namespace embree
{
/* Point query structure for closest point query */
template<int K>
struct RTC_ALIGN(16) PointQueryK
{
/* Default construction does nothing */
__forceinline PointQuery... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
namespace embree
{
/*! helper structure for the implementation of the profile functions below */
struct ProfileTimer
{
static const size_t N = 20;
ProfileTimer () {}
ProfileTimer ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "instance_stack.h"
// FIXME: if ray gets separated into ray* and hit, uload4 needs to be adjusted
namespace embree
{
/* Ray structure for K rays */
template<int K>
struct RayK
{
/* ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#define RTC_EXPORT_API
#include "default.h"
#include "device.h"
#include "scene.h"
#include "context.h"
#include "../geometry/filter.h"
#include "../../include/embree4/rtcore_ray.h"
using namespace embree;
RTC_NAMESPACE_BEGIN;
#define R... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../../include/embree4/rtcore.h"
RTC_NAMESPACE_USE
namespace embree
{
/*! decoding of intersection flags */
__forceinline bool isCoherent (RTCRayQueryFlags flags) { return (flags & RTC_RAY_QUERY_FLAG_COHERENT... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#define RTC_EXPORT_API
#include "default.h"
#include "device.h"
#include "scene.h"
#include "context.h"
#include "alloc.h"
#include "../builders/bvh_builder_sah.h"
#include "../builders/bvh_builder_morton.h"
namespace embree
{
namesp... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "scene.h"
#include "../../common/tasking/taskscheduler.h"
#include "../bvh/bvh4_factory.h"
#include "../bvh/bvh8_factory.h"
#include "../../common/algorithms/parallel_reduce.h"
#if defined(EMBREE_SYCL_SUPPORT)
# include "../s... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "device.h"
#include "builder.h"
#include "scene_triangle_mesh.h"
#include "scene_quad_mesh.h"
#include "scene_user_geometry.h"
#include "scene_instance.h"
#include "scene_instance_array.h"
#incl... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "geometry.h"
#include "buffer.h"
#include "../subdiv/bezier_curve.h"
#include "../subdiv/hermite_curve.h"
#include "../subdiv/bspline_curve.h"
#include "../subdiv/catmullrom_curve.h"
#include ".... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "buffer.h"
namespace embree
{
/*! Grid Mesh */
struct GridMesh : public Geometry
{
/*! type of this geometry */
static const Geometry::GTypeMask geom_type = Geometry::MTY_GRID_MES... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "accel.h"
namespace embree
{
struct MotionDerivativeCoefficients;
/*! Instanced acceleration structure */
struct Instance : public Geometry
{
static const Geometry::GTypeMask geom_... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "accel.h"
namespace embree
{
struct MotionDerivativeCoefficients;
/*! Instanced acceleration structure */
struct InstanceArray : public Geometry
{
static const Geometry::GTypeMask ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
#include "geometry.h"
#include "buffer.h"
namespace embree
{
/*! represents an array of line segments */
struct LineSegments : public Geometry
{
/*! type of this geometry */
static const Ge... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "buffer.h"
#include "default.h"
#include "geometry.h"
namespace embree
{
/*! represents an array of points */
struct Points : public Geometry
{
/*! type of this geometry */
static const Geometry::GType... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "buffer.h"
namespace embree
{
/*! Quad Mesh */
struct QuadMesh : public Geometry
{
/*! type of this geometry */
static const Geometry::GTypeMask geom_type = Geometry::MTY_QUAD_MES... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "buffer.h"
#include "../subdiv/half_edge.h"
#include "../subdiv/tessellation_cache.h"
#include "../subdiv/catmullclark_coefficients.h"
#include "../subdiv/patch.h"
namespace embree
{
struct H... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "scene_triangle_mesh.h"
#include "scene.h"
namespace embree
{
#if defined(EMBREE_LOWEST_ISA)
TriangleMesh::TriangleMesh (Device* device)
: Geometry(device,GTY_TRIANGLE_MESH,0,1)
{
vertices.resize(numTimeSteps);
}
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "geometry.h"
#include "buffer.h"
namespace embree
{
/*! Triangle Mesh */
struct TriangleMesh : public Geometry
{
/*! type of this geometry */
static const Geometry::GTypeMask geom_type = Geometry::MTY_... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "accelset.h"
namespace embree
{
/*! User geometry with user defined intersection functions */
struct UserGeometry : public AccelSet
{
/*! type of this geometry */
static const Geometry::GTypeMask geom_... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "scene.h"
#include "../../common/algorithms/parallel_any_of.h"
namespace embree
{
void Scene::checkIfModifiedAndSet ()
{
if (isModified ()) return;
auto geometryIsModified = [this](size_t geomID)->bool {
return isGeome... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
namespace embree
{
/*! An item on the stack holds the node ID and distance of that node. */
template<typename T>
struct __aligned(16) StackItemT
{
/*! assert that the xchg function works */
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "stat.h"
namespace embree
{
Stat Stat::instance;
Stat::Stat () {
}
Stat::~Stat ()
{
#ifdef EMBREE_STAT_COUNTERS
Stat::print(std::cout);
#endif
}
void Stat::print(embree_ostream cout)
{
Counters& cnt... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
/* Macros to gather statistics */
#ifdef EMBREE_STAT_COUNTERS
# define STAT(x) x
# define STAT3(s,x,y,z) \
STAT(Stat::get().code .s+=x); \
STAT(Stat::get().active.s+=y); ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "state.h"
#include "../../common/lexers/streamfilters.h"
namespace embree
{
MutexSys g_printMutex;
State::ErrorHandler State::g_errorHandler;
State::ErrorHandler::ErrorHandler()
: thread_error(createTls()) {}
State... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "default.h"
namespace embree
{
/* mutex to make printing to cout thread safe */
extern MutexSys g_printMutex;
struct RTCErrorMessage
{
RTCErrorMessage(RTCError error, std::string const& msg)
: erro... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "default.h"
namespace embree
{
/*! invokes the memory monitor callback */
struct MemoryMonitorInterface {
virtual void memoryMonitor(ssize_t bytes, bool post) = 0;
};
/*! allocator that performs aligned monitored all... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
namespace embree
{
namespace isa
{
struct Cone
{
const Vec3fa p0; //!< start position of cone
const Vec3fa p1; //!< end position of cone
const float r0; //!< start ra... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "coneline_intersector.h"
#include "intersector_epilog.h"
namespace embree
{
namespace isa
{
template<int M, bool filter>
struct ConeCurveMiIntersector1
{
typedef LineMi<M> Primitive;
type... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
namespace isa
{
namespace __coneline_internal
{
template<int M, typename Epilog, typename ray_tfar_func>
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
template<int M>
struct CurveNi
{
struct Type : public PrimitiveType {
const char* name() const;
size_t sizeActi... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "curveNi.h"
#include "roundline_intersector.h"
#include "coneline_intersector.h"
#include "curve_intersector_ribbon.h"
#include "curve_intersector_oriented.h"
#include "curve_intersector_sweep.h"
namespace embree
{... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
template<int M>
struct CurveNiMB
{
struct Type : public PrimitiveType {
const char* name() const;
size_t sizeAc... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "curveNi_mb.h"
#include "../subdiv/linear_bezier_patch.h"
#include "roundline_intersector.h"
#include "coneline_intersector.h"
#include "curve_intersector_ribbon.h"
#include "curve_intersector_oriented.h"
#include "... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "curveNi.h"
namespace embree
{
template<int M>
struct CurveNv : public CurveNi<M>
{
using CurveNi<M>::N;
struct Type : public PrimitiveType {
const char* name() const;
size_t sizeA... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "curveNv.h"
#include "curveNi_intersector.h"
namespace embree
{
namespace isa
{
template<int M>
struct CurveNvIntersector1 : public CurveNiIntersector1<M>
{
typedef CurveNv<M> Primitive;
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "../subdiv/bezier_curve.h"
#include "../common/primref.h"
#include "bezier_hair_intersector.h"
#include "bezier_ribbon_intersector.h"
#include "bezier_curve_intersector.h"
#include "oriented_cu... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
namespace isa
{
template<typename NativeCurve3fa, int M>
struct DistanceCurveHit
{
__forceinline DistanceCurv... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "curve_intersector_precalculations.h"
#include "curve_intersector_sweep.h"
#include "../subdiv/linear_bezier_patch.h"
#define DBG(x)
namespace embree
{
namespace isa
{
template<ty... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/geometry.h"
namespace embree
{
namespace isa
{
struct CurvePrecalculations1
{
float depth_scale;
LinearSpace3fa ray_space;
__forceinlin... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "quad_intersector.h"
#include "curve_intersector_precalculations.h"
#define Bezier1Intersector1 RibbonCurve1Intersector1
#define Bezier1IntersectorK RibbonCurve1IntersectorK
namespace emb... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "cylinder.h"
#include "plane.h"
#include "line_intersector.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
namespace isa
{
static const size_t numJacobianItera... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "../subdiv/bezier_curve.h"
#include "../builders/primref.h"
#include "curve_intersector_precalculations.h"
#include "../bvh/node_intersector1.h"
#include "../bvh/node_intersector_packet.h"
#in... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
namespace embree
{
namespace isa
{
struct Cylinder
{
const Vec3fa p0; //!< start location
const Vec3fa p1; //!< end position
const float rr; //!< squared radius of... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "disc_intersector.h"
#include "intersector_epilog.h"
#include "pointi.h"
namespace embree
{
namespace isa
{
template<int M, bool filter>
struct DiscMiIntersector1
{
typedef PointMi<M> Primitive... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/scene_points.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
namespace isa
{
template<int M>
struct DiscIntersectorHitM
{
__forceinlin... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/geometry.h"
#include "../common/ray.h"
#include "../common/hit.h"
#include "../common/context.h"
namespace embree
{
namespace isa
{
__forceinline bool runIntersectionFilter1Helper(RTCFilterFunctio... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/geometry.h"
#include "../common/ray.h"
#include "../common/hit.h"
#include "../common/context.h"
namespace embree
{
__forceinline bool runIntersectionFilter1Helper(RTCFilterFunctionNArguments* args, int... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "grid_soa.h"
#include "grid_soa_intersector1.h"
#include "grid_soa_intersector_packet.h"
#include "../common/ray.h"
namespace embree
{
namespace isa
{
template<typename T>
class SubdivPatch1Precalculat... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/scene_subdiv_mesh.h"
#include "../bvh/bvh.h"
#include "../subdiv/tessellation.h"
#include "../subdiv/tessellation_cache.h"
#include "subdivpatch1.h"
namespace embree
{
namespa... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "grid_soa.h"
#include "../common/ray.h"
#include "triangle_intersector_pluecker.h"
namespace embree
{
namespace isa
{
class GridSOAIntersector1
{
public:
typedef void Primitive;
cl... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "grid_soa.h"
#include "../common/ray.h"
#include "triangle_intersector_pluecker.h"
namespace embree
{
namespace isa
{
template<int K>
struct MapUV0
{
const float* const grid_uv;
size_t ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "../common/scene_instance.h"
namespace embree
{
struct InstancePrimitive
{
struct Type : public PrimitiveType
{
const char* name() const;
size_t sizeActive(const char*... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "../common/scene_instance_array.h"
namespace embree
{
//template<int M>
struct InstanceArrayPrimitive
{
struct Type : public PrimitiveType
{
const char* name() const;
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "instance_array.h"
#include "../common/ray.h"
#include "../common/point_query.h"
#include "../common/scene.h"
namespace embree
{
namespace isa
{
struct InstanceArrayIntersector1
{
typedef InstanceA... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "instance.h"
#include "../common/ray.h"
#include "../common/point_query.h"
namespace embree
{
namespace isa
{
struct InstanceIntersector1
{
typedef InstancePrimitive Primitive;
struct Precal... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/context.h"
#include "filter.h"
namespace embree
{
namespace isa
{
template<int M>
struct UVIdentity {
__forceinline void operator() (vfloat<M>& u, vfloat<M>& v... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/context.h"
#include "filter_sycl.h"
namespace embree
{
template<typename Ray>
struct Intersect1Epilog1_HWIF;
template<>
struct Intersect1Epilog1_HWIF<RayHit>
{
Ra... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/scene.h"
#include "../common/ray.h"
#include "../common/point_query.h"
#include "../bvh/node_intersector1.h"
#include "../bvh/node_intersector_packet.h"
namespace embree
{
namespace isa
{
template... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
template<int M>
struct LineMi
{
/* Virtual interface to query information about the line segment type */
struct Type : public PrimitiveType
{
const char* name... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "linei.h"
#include "line_intersector.h"
#include "intersector_epilog.h"
namespace embree
{
namespace isa
{
template<int M, bool filter>
struct FlatLinearCurveMiIntersector1
{
typedef LineMi<M> ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
namespace isa
{
template<int M>
struct LineIntersectorHitM
{
__forceinline LineIntersectorHitM() {}
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
struct Object
{
struct Type : public PrimitiveType
{
const char* name() const;
size_t sizeActive(const char* This) const;
size_t sizeTotal(const char* ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "object.h"
#include "../common/ray.h"
namespace embree
{
namespace isa
{
template<bool mblur>
struct ObjectIntersector1
{
typedef Object Primitive;
static const bool validIntersecto... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
namespace embree
{
namespace isa
{
struct HalfPlane
{
const Vec3fa P; //!< plane origin
const Vec3fa N; //!< plane normal
__forceinline HalfPlane(const Vec3fa& P, c... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
template<int M>
struct PointMi
{
/* Virtual interface to query information about the line segment type */
struct Type : public PrimitiveType
{
const char* nam... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/default.h"
#include "../common/scene.h"
#include "../../common/simd/simd.h"
#include "../builders/primref.h"
#include "../builders/primref_mb.h"
namespace embree
{
struct PrimitiveType
{
/*! retur... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#include "primitive.h"
#include "curveNv.h"
#include "curveNi.h"
#include "curveNi_mb.h"
#include "linei.h"
#include "triangle.h"
#include "trianglev.h"
#include "trianglev_mb.h"
#include "trianglei.h"
#include "quadv.h"
#include "quadi.h"... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "../common/scene.h"
namespace embree
{
/* Stores M quads from an indexed face set */
template <int M>
struct QuadMi
{
/* Virtual interface to query information about the quad type ... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "quadi.h"
#include "quad_intersector_moeller.h"
#include "quad_intersector_pluecker.h"
namespace embree
{
namespace isa
{
/*! Intersects M quads with 1 ray */
template<int M, bool filter>
struct Quad... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
/* Stores the vertices of M quads in struct of array layout */
template <int M>
struct QuadMv
{
public:
struct Type : public PrimitiveType
{
const char* nam... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "quadv.h"
#include "quad_intersector_moeller.h"
#include "quad_intersector_pluecker.h"
namespace embree
{
namespace isa
{
/*! Intersects M quads with 1 ray */
template<int M, bool filter>
struct Quad... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
namespace embree
{
namespace isa
{
/*! Intersects a ray with a quad with backface culling
* enabled. The quad v0,v1,v2,v3 is split into two triangles
* v0,v1,v3 and v2,v3,v1. The edge v1,v2 decides which o... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "quadv.h"
#include "triangle_intersector_moeller.h"
namespace embree
{
namespace isa
{
template<int M>
struct QuadHitM
{
__forceinline QuadHitM() {}
__forceinline QuadHitM(const vbool<M>... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "quad_intersector_moeller.h"
/*! Modified Pluecker ray/triangle intersector. The test first shifts
* the ray origin into the origin of the coordinate system and then
* uses Pluecker coordinates for the intersect... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "roundline_intersector.h"
#include "intersector_epilog.h"
namespace embree
{
namespace isa
{
template<int M, bool filter>
struct RoundLinearCurveMiIntersector1
{
typedef LineMi<M> Primitive;
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "curve_intersector_precalculations.h"
/*
This file implements the intersection of a ray with a round linear
curve segment. We define the geometry of such a round linear curve
seg... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "intersector_epilog.h"
#include "pointi.h"
#include "sphere_intersector.h"
namespace embree
{
namespace isa
{
template<int M, bool filter>
struct SphereMiIntersector1
{
typedef PointMi<M> Primi... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/scene_points.h"
#include "curve_intersector_precalculations.h"
namespace embree
{
namespace isa
{
template<int M>
struct SphereIntersectorHitM
{
__forceinl... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../geometry/primitive.h"
#include "../subdiv/subdivpatch1base.h"
namespace embree
{
struct __aligned(64) SubdivPatch1 : public SubdivPatch1Base
{
struct Type : public PrimitiveType
{
const char*... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "subdivpatch1.h"
#include "grid_soa.h"
#include "grid_soa_intersector1.h"
#include "grid_soa_intersector_packet.h"
#include "../common/ray.h"
namespace embree
{
namespace isa
{
template<typename T>
cla... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "../common/ray.h"
#include "../common/scene_grid_mesh.h"
#include "../bvh/bvh.h"
namespace embree
{
/* Stores M quads from an indexed face set */
struct SubGrid
{
/* Virtual interface to quer... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "subgrid.h"
#include "subgrid_intersector_moeller.h"
#include "subgrid_intersector_pluecker.h"
namespace embree
{
namespace isa
{
// =========================================================================... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "subgrid.h"
#include "quad_intersector_moeller.h"
namespace embree
{
namespace isa
{
/* ----------------------------- */
/* -- single ray intersectors -- */
/* ----------------------------- */
... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "subgrid.h"
#include "quad_intersector_moeller.h"
#include "quad_intersector_pluecker.h"
namespace embree
{
namespace isa
{
template<int M>
__forceinline void interpolateUV(PlueckerHitM<M,UVIdentity<M>>... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "subgrid_intersector.h"
namespace embree
{
namespace isa
{
template<int N, bool filter>
struct SubGridMBIntersector1Pluecker
{
typedef SubGridMBQBVHN<N> Primitive;
typedef SubGridQuadMInt... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
/* Precalculated representation for M triangles. Stores for each
triangle a base vertex, two edges, and the geometry normal to
speed up intersection calculations */
tem... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
#include "../common/scene.h"
namespace embree
{
/* Stores M triangles from an indexed face set */
template <int M>
struct TriangleMi
{
/* Virtual interface to query information about the tr... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "trianglei.h"
#include "triangle_intersector_moeller.h"
#include "triangle_intersector_pluecker.h"
namespace embree
{
namespace isa
{
/*! Intersects M triangles with 1 ray */
template<int M, bool filter>... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
/* Stores the vertices of M triangles in struct of array layout */
template <int M>
struct TriangleMv
{
public:
struct Type : public PrimitiveType
{
const c... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "triangle.h"
#include "triangle_intersector_pluecker.h"
#include "triangle_intersector_moeller.h"
#include "triangle_intersector_woop.h"
namespace embree
{
namespace isa
{
/*! Intersects M triangles with 1 r... |
// Copyright 2009-2021 Intel Corporation
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include "primitive.h"
namespace embree
{
/* Stores the vertices of M triangles in struct of array layout */
template<int M>
struct TriangleMvMB
{
public:
struct Type : public PrimitiveType
{
const c... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.