mirror of
https://github.com/godotengine/godot.git
synced 2025-10-30 21:21:10 +00:00
767e374dce
Since Embree v3.13.0 supports AARCH64, switch back to the official repo instead of using Embree-aarch64. `thirdparty/embree/patches/godot-changes.patch` should now contain an accurate diff of the changes done to the library.
378 lines
10 KiB
C++
378 lines
10 KiB
C++
// Copyright 2009-2021 Intel Corporation
|
|
// SPDX-License-Identifier: Apache-2.0
|
|
|
|
#pragma once
|
|
|
|
#include "rtcore_common.h"
|
|
|
|
RTC_NAMESPACE_BEGIN
|
|
|
|
/* Ray structure for a single ray */
|
|
struct RTC_ALIGN(16) RTCRay
|
|
{
|
|
float org_x; // x coordinate of ray origin
|
|
float org_y; // y coordinate of ray origin
|
|
float org_z; // z coordinate of ray origin
|
|
float tnear; // start of ray segment
|
|
|
|
float dir_x; // x coordinate of ray direction
|
|
float dir_y; // y coordinate of ray direction
|
|
float dir_z; // z coordinate of ray direction
|
|
float time; // time of this ray for motion blur
|
|
|
|
float tfar; // end of ray segment (set to hit distance)
|
|
unsigned int mask; // ray mask
|
|
unsigned int id; // ray ID
|
|
unsigned int flags; // ray flags
|
|
};
|
|
|
|
/* Hit structure for a single ray */
|
|
struct RTC_ALIGN(16) RTCHit
|
|
{
|
|
float Ng_x; // x coordinate of geometry normal
|
|
float Ng_y; // y coordinate of geometry normal
|
|
float Ng_z; // z coordinate of geometry normal
|
|
|
|
float u; // barycentric u coordinate of hit
|
|
float v; // barycentric v coordinate of hit
|
|
|
|
unsigned int primID; // primitive ID
|
|
unsigned int geomID; // geometry ID
|
|
unsigned int instID[RTC_MAX_INSTANCE_LEVEL_COUNT]; // instance ID
|
|
};
|
|
|
|
/* Combined ray/hit structure for a single ray */
|
|
struct RTCRayHit
|
|
{
|
|
struct RTCRay ray;
|
|
struct RTCHit hit;
|
|
};
|
|
|
|
/* Ray structure for a packet of 4 rays */
|
|
struct RTC_ALIGN(16) RTCRay4
|
|
{
|
|
float org_x[4];
|
|
float org_y[4];
|
|
float org_z[4];
|
|
float tnear[4];
|
|
|
|
float dir_x[4];
|
|
float dir_y[4];
|
|
float dir_z[4];
|
|
float time[4];
|
|
|
|
float tfar[4];
|
|
unsigned int mask[4];
|
|
unsigned int id[4];
|
|
unsigned int flags[4];
|
|
};
|
|
|
|
/* Hit structure for a packet of 4 rays */
|
|
struct RTC_ALIGN(16) RTCHit4
|
|
{
|
|
float Ng_x[4];
|
|
float Ng_y[4];
|
|
float Ng_z[4];
|
|
|
|
float u[4];
|
|
float v[4];
|
|
|
|
unsigned int primID[4];
|
|
unsigned int geomID[4];
|
|
unsigned int instID[RTC_MAX_INSTANCE_LEVEL_COUNT][4];
|
|
};
|
|
|
|
/* Combined ray/hit structure for a packet of 4 rays */
|
|
struct RTCRayHit4
|
|
{
|
|
struct RTCRay4 ray;
|
|
struct RTCHit4 hit;
|
|
};
|
|
|
|
/* Ray structure for a packet of 8 rays */
|
|
struct RTC_ALIGN(32) RTCRay8
|
|
{
|
|
float org_x[8];
|
|
float org_y[8];
|
|
float org_z[8];
|
|
float tnear[8];
|
|
|
|
float dir_x[8];
|
|
float dir_y[8];
|
|
float dir_z[8];
|
|
float time[8];
|
|
|
|
float tfar[8];
|
|
unsigned int mask[8];
|
|
unsigned int id[8];
|
|
unsigned int flags[8];
|
|
};
|
|
|
|
/* Hit structure for a packet of 8 rays */
|
|
struct RTC_ALIGN(32) RTCHit8
|
|
{
|
|
float Ng_x[8];
|
|
float Ng_y[8];
|
|
float Ng_z[8];
|
|
|
|
float u[8];
|
|
float v[8];
|
|
|
|
unsigned int primID[8];
|
|
unsigned int geomID[8];
|
|
unsigned int instID[RTC_MAX_INSTANCE_LEVEL_COUNT][8];
|
|
};
|
|
|
|
/* Combined ray/hit structure for a packet of 8 rays */
|
|
struct RTCRayHit8
|
|
{
|
|
struct RTCRay8 ray;
|
|
struct RTCHit8 hit;
|
|
};
|
|
|
|
/* Ray structure for a packet of 16 rays */
|
|
struct RTC_ALIGN(64) RTCRay16
|
|
{
|
|
float org_x[16];
|
|
float org_y[16];
|
|
float org_z[16];
|
|
float tnear[16];
|
|
|
|
float dir_x[16];
|
|
float dir_y[16];
|
|
float dir_z[16];
|
|
float time[16];
|
|
|
|
float tfar[16];
|
|
unsigned int mask[16];
|
|
unsigned int id[16];
|
|
unsigned int flags[16];
|
|
};
|
|
|
|
/* Hit structure for a packet of 16 rays */
|
|
struct RTC_ALIGN(64) RTCHit16
|
|
{
|
|
float Ng_x[16];
|
|
float Ng_y[16];
|
|
float Ng_z[16];
|
|
|
|
float u[16];
|
|
float v[16];
|
|
|
|
unsigned int primID[16];
|
|
unsigned int geomID[16];
|
|
unsigned int instID[RTC_MAX_INSTANCE_LEVEL_COUNT][16];
|
|
};
|
|
|
|
/* Combined ray/hit structure for a packet of 16 rays */
|
|
struct RTCRayHit16
|
|
{
|
|
struct RTCRay16 ray;
|
|
struct RTCHit16 hit;
|
|
};
|
|
|
|
/* Ray structure for a packet/stream of N rays in pointer SOA layout */
|
|
struct RTCRayNp
|
|
{
|
|
float* org_x;
|
|
float* org_y;
|
|
float* org_z;
|
|
float* tnear;
|
|
|
|
float* dir_x;
|
|
float* dir_y;
|
|
float* dir_z;
|
|
float* time;
|
|
|
|
float* tfar;
|
|
unsigned int* mask;
|
|
unsigned int* id;
|
|
unsigned int* flags;
|
|
};
|
|
|
|
/* Hit structure for a packet/stream of N rays in pointer SOA layout */
|
|
struct RTCHitNp
|
|
{
|
|
float* Ng_x;
|
|
float* Ng_y;
|
|
float* Ng_z;
|
|
|
|
float* u;
|
|
float* v;
|
|
|
|
unsigned int* primID;
|
|
unsigned int* geomID;
|
|
unsigned int* instID[RTC_MAX_INSTANCE_LEVEL_COUNT];
|
|
};
|
|
|
|
/* Combined ray/hit structure for a packet/stream of N rays in pointer SOA layout */
|
|
struct RTCRayHitNp
|
|
{
|
|
struct RTCRayNp ray;
|
|
struct RTCHitNp hit;
|
|
};
|
|
|
|
struct RTCRayN;
|
|
struct RTCHitN;
|
|
struct RTCRayHitN;
|
|
|
|
#if defined(__cplusplus)
|
|
|
|
/* Helper functions to access ray packets of runtime size N */
|
|
RTC_FORCEINLINE float& RTCRayN_org_x(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[0*N+i]; }
|
|
RTC_FORCEINLINE float& RTCRayN_org_y(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[1*N+i]; }
|
|
RTC_FORCEINLINE float& RTCRayN_org_z(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[2*N+i]; }
|
|
RTC_FORCEINLINE float& RTCRayN_tnear(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[3*N+i]; }
|
|
|
|
RTC_FORCEINLINE float& RTCRayN_dir_x(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[4*N+i]; }
|
|
RTC_FORCEINLINE float& RTCRayN_dir_y(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[5*N+i]; }
|
|
RTC_FORCEINLINE float& RTCRayN_dir_z(RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[6*N+i]; }
|
|
RTC_FORCEINLINE float& RTCRayN_time (RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[7*N+i]; }
|
|
|
|
RTC_FORCEINLINE float& RTCRayN_tfar (RTCRayN* ray, unsigned int N, unsigned int i) { return ((float*)ray)[8*N+i]; }
|
|
RTC_FORCEINLINE unsigned int& RTCRayN_mask (RTCRayN* ray, unsigned int N, unsigned int i) { return ((unsigned*)ray)[9*N+i]; }
|
|
RTC_FORCEINLINE unsigned int& RTCRayN_id (RTCRayN* ray, unsigned int N, unsigned int i) { return ((unsigned*)ray)[10*N+i]; }
|
|
RTC_FORCEINLINE unsigned int& RTCRayN_flags(RTCRayN* ray, unsigned int N, unsigned int i) { return ((unsigned*)ray)[11*N+i]; }
|
|
|
|
/* Helper functions to access hit packets of runtime size N */
|
|
RTC_FORCEINLINE float& RTCHitN_Ng_x(RTCHitN* hit, unsigned int N, unsigned int i) { return ((float*)hit)[0*N+i]; }
|
|
RTC_FORCEINLINE float& RTCHitN_Ng_y(RTCHitN* hit, unsigned int N, unsigned int i) { return ((float*)hit)[1*N+i]; }
|
|
RTC_FORCEINLINE float& RTCHitN_Ng_z(RTCHitN* hit, unsigned int N, unsigned int i) { return ((float*)hit)[2*N+i]; }
|
|
|
|
RTC_FORCEINLINE float& RTCHitN_u(RTCHitN* hit, unsigned int N, unsigned int i) { return ((float*)hit)[3*N+i]; }
|
|
RTC_FORCEINLINE float& RTCHitN_v(RTCHitN* hit, unsigned int N, unsigned int i) { return ((float*)hit)[4*N+i]; }
|
|
|
|
RTC_FORCEINLINE unsigned int& RTCHitN_primID(RTCHitN* hit, unsigned int N, unsigned int i) { return ((unsigned*)hit)[5*N+i]; }
|
|
RTC_FORCEINLINE unsigned int& RTCHitN_geomID(RTCHitN* hit, unsigned int N, unsigned int i) { return ((unsigned*)hit)[6*N+i]; }
|
|
RTC_FORCEINLINE unsigned int& RTCHitN_instID(RTCHitN* hit, unsigned int N, unsigned int i, unsigned int l) { return ((unsigned*)hit)[7*N+i+N*l]; }
|
|
|
|
/* Helper functions to extract RTCRayN and RTCHitN from RTCRayHitN */
|
|
RTC_FORCEINLINE RTCRayN* RTCRayHitN_RayN(RTCRayHitN* rayhit, unsigned int N) { return (RTCRayN*)&((float*)rayhit)[0*N]; }
|
|
RTC_FORCEINLINE RTCHitN* RTCRayHitN_HitN(RTCRayHitN* rayhit, unsigned int N) { return (RTCHitN*)&((float*)rayhit)[12*N]; }
|
|
|
|
/* Helper structure for a ray packet of compile-time size N */
|
|
template<int N>
|
|
struct RTCRayNt
|
|
{
|
|
float org_x[N];
|
|
float org_y[N];
|
|
float org_z[N];
|
|
float tnear[N];
|
|
|
|
float dir_x[N];
|
|
float dir_y[N];
|
|
float dir_z[N];
|
|
float time[N];
|
|
|
|
float tfar[N];
|
|
unsigned int mask[N];
|
|
unsigned int id[N];
|
|
unsigned int flags[N];
|
|
};
|
|
|
|
/* Helper structure for a hit packet of compile-time size N */
|
|
template<int N>
|
|
struct RTCHitNt
|
|
{
|
|
float Ng_x[N];
|
|
float Ng_y[N];
|
|
float Ng_z[N];
|
|
|
|
float u[N];
|
|
float v[N];
|
|
|
|
unsigned int primID[N];
|
|
unsigned int geomID[N];
|
|
unsigned int instID[RTC_MAX_INSTANCE_LEVEL_COUNT][N];
|
|
};
|
|
|
|
/* Helper structure for a combined ray/hit packet of compile-time size N */
|
|
template<int N>
|
|
struct RTCRayHitNt
|
|
{
|
|
RTCRayNt<N> ray;
|
|
RTCHitNt<N> hit;
|
|
};
|
|
|
|
RTC_FORCEINLINE RTCRay rtcGetRayFromRayN(RTCRayN* rayN, unsigned int N, unsigned int i)
|
|
{
|
|
RTCRay ray;
|
|
ray.org_x = RTCRayN_org_x(rayN,N,i);
|
|
ray.org_y = RTCRayN_org_y(rayN,N,i);
|
|
ray.org_z = RTCRayN_org_z(rayN,N,i);
|
|
ray.tnear = RTCRayN_tnear(rayN,N,i);
|
|
ray.dir_x = RTCRayN_dir_x(rayN,N,i);
|
|
ray.dir_y = RTCRayN_dir_y(rayN,N,i);
|
|
ray.dir_z = RTCRayN_dir_z(rayN,N,i);
|
|
ray.time = RTCRayN_time(rayN,N,i);
|
|
ray.tfar = RTCRayN_tfar(rayN,N,i);
|
|
ray.mask = RTCRayN_mask(rayN,N,i);
|
|
ray.id = RTCRayN_id(rayN,N,i);
|
|
ray.flags = RTCRayN_flags(rayN,N,i);
|
|
return ray;
|
|
}
|
|
|
|
RTC_FORCEINLINE RTCHit rtcGetHitFromHitN(RTCHitN* hitN, unsigned int N, unsigned int i)
|
|
{
|
|
RTCHit hit;
|
|
hit.Ng_x = RTCHitN_Ng_x(hitN,N,i);
|
|
hit.Ng_y = RTCHitN_Ng_y(hitN,N,i);
|
|
hit.Ng_z = RTCHitN_Ng_z(hitN,N,i);
|
|
hit.u = RTCHitN_u(hitN,N,i);
|
|
hit.v = RTCHitN_v(hitN,N,i);
|
|
hit.primID = RTCHitN_primID(hitN,N,i);
|
|
hit.geomID = RTCHitN_geomID(hitN,N,i);
|
|
for (unsigned int l = 0; l < RTC_MAX_INSTANCE_LEVEL_COUNT; l++)
|
|
hit.instID[l] = RTCHitN_instID(hitN,N,i,l);
|
|
return hit;
|
|
}
|
|
|
|
RTC_FORCEINLINE void rtcCopyHitToHitN(RTCHitN* hitN, const RTCHit* hit, unsigned int N, unsigned int i)
|
|
{
|
|
RTCHitN_Ng_x(hitN,N,i) = hit->Ng_x;
|
|
RTCHitN_Ng_y(hitN,N,i) = hit->Ng_y;
|
|
RTCHitN_Ng_z(hitN,N,i) = hit->Ng_z;
|
|
RTCHitN_u(hitN,N,i) = hit->u;
|
|
RTCHitN_v(hitN,N,i) = hit->v;
|
|
RTCHitN_primID(hitN,N,i) = hit->primID;
|
|
RTCHitN_geomID(hitN,N,i) = hit->geomID;
|
|
for (unsigned int l = 0; l < RTC_MAX_INSTANCE_LEVEL_COUNT; l++)
|
|
RTCHitN_instID(hitN,N,i,l) = hit->instID[l];
|
|
}
|
|
|
|
RTC_FORCEINLINE RTCRayHit rtcGetRayHitFromRayHitN(RTCRayHitN* rayhitN, unsigned int N, unsigned int i)
|
|
{
|
|
RTCRayHit rh;
|
|
|
|
RTCRayN* ray = RTCRayHitN_RayN(rayhitN,N);
|
|
rh.ray.org_x = RTCRayN_org_x(ray,N,i);
|
|
rh.ray.org_y = RTCRayN_org_y(ray,N,i);
|
|
rh.ray.org_z = RTCRayN_org_z(ray,N,i);
|
|
rh.ray.tnear = RTCRayN_tnear(ray,N,i);
|
|
rh.ray.dir_x = RTCRayN_dir_x(ray,N,i);
|
|
rh.ray.dir_y = RTCRayN_dir_y(ray,N,i);
|
|
rh.ray.dir_z = RTCRayN_dir_z(ray,N,i);
|
|
rh.ray.time = RTCRayN_time(ray,N,i);
|
|
rh.ray.tfar = RTCRayN_tfar(ray,N,i);
|
|
rh.ray.mask = RTCRayN_mask(ray,N,i);
|
|
rh.ray.id = RTCRayN_id(ray,N,i);
|
|
rh.ray.flags = RTCRayN_flags(ray,N,i);
|
|
|
|
RTCHitN* hit = RTCRayHitN_HitN(rayhitN,N);
|
|
rh.hit.Ng_x = RTCHitN_Ng_x(hit,N,i);
|
|
rh.hit.Ng_y = RTCHitN_Ng_y(hit,N,i);
|
|
rh.hit.Ng_z = RTCHitN_Ng_z(hit,N,i);
|
|
rh.hit.u = RTCHitN_u(hit,N,i);
|
|
rh.hit.v = RTCHitN_v(hit,N,i);
|
|
rh.hit.primID = RTCHitN_primID(hit,N,i);
|
|
rh.hit.geomID = RTCHitN_geomID(hit,N,i);
|
|
for (unsigned int l = 0; l < RTC_MAX_INSTANCE_LEVEL_COUNT; l++)
|
|
rh.hit.instID[l] = RTCHitN_instID(hit,N,i,l);
|
|
|
|
return rh;
|
|
}
|
|
|
|
#endif
|
|
|
|
RTC_NAMESPACE_END
|
|
|