phynexis-deps/igl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
3c1e35d568b815038eae2d94de1ba128932873fd
igl/external/embree/kernels/common/rtcore.cpp
T

1145 lines
37 KiB
C++
Executable File
Raw Blame History

// ======================================================================== //
// Copyright 2009-2014 Intel Corporation //
// //
// Licensed under the Apache License, Version 2.0 (the "License"); //
// you may not use this file except in compliance with the License. //
// You may obtain a copy of the License at //
// //
// http://www.apache.org/licenses/LICENSE-2.0 //
// //
// Unless required by applicable law or agreed to in writing, software //
// distributed under the License is distributed on an "AS IS" BASIS, //
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. //
// See the License for the specific language governing permissions and //
// limitations under the License. //
// ======================================================================== //
#ifdef _WIN32
# define RTCORE_API extern "C" __declspec(dllexport)
#else
# define RTCORE_API extern "C" __attribute__ ((visibility ("default")))
#endif
#include "common/default.h"
#include "common/alloc.h"
#include "embree2/rtcore.h"
#include "common/scene.h"
#include "sys/taskscheduler.h"
#include "sys/thread.h"
#include "raystream_log.h"
#define TRACE(x) //std::cout << #x << std::endl;
namespace embree
{
#define CATCH_BEGIN try {
#define CATCH_END \
} catch (std::bad_alloc&) { \
process_error(RTC_OUT_OF_MEMORY,"out of memory"); \
} catch (std::exception& e) { \
process_error(RTC_UNKNOWN_ERROR,e.what()); \
} catch (...) { \
process_error(RTC_UNKNOWN_ERROR,"unknown exception caught"); \
}
#define VERIFY_HANDLE(handle) \
if (handle == NULL) { \
process_error(RTC_INVALID_ARGUMENT,"invalid argument"); \
}
#define VERIFY_GEOMID(id) \
if (id == -1) { \
process_error(RTC_INVALID_ARGUMENT,"invalid argument"); \
}
/* functions to initialize global state */
void init_globals();
/* register functions for accels */
void BVH4Register();
void BVH8Register();
#if defined(__MIC__)
void BVH4iRegister();
void BVH4MBRegister();
void BVH4HairRegister();
#endif
/*! intersector registration functions */
DECLARE_SYMBOL(RTCBoundsFunc,InstanceBoundsFunc);
DECLARE_SYMBOL(AccelSet::Intersector1,InstanceIntersector1);
DECLARE_SYMBOL(AccelSet::Intersector4,InstanceIntersector4);
DECLARE_SYMBOL(AccelSet::Intersector8,InstanceIntersector8);
DECLARE_SYMBOL(AccelSet::Intersector16,InstanceIntersector16);
/* global settings */
std::string g_tri_accel = "default"; //!< acceleration structure to use for triangles
std::string g_tri_builder = "default"; //!< builder to use for triangles
std::string g_tri_traverser = "default"; //!< traverser to use for triangles
double g_tri_builder_replication_factor = 2.0f; //!< maximally factor*N many primitives in accel
std::string g_tri_accel_mb = "default"; //!< acceleration structure to use for motion blur triangles
std::string g_tri_builder_mb = "default"; //!< builder to use for motion blur triangles
std::string g_tri_traverser_mb = "default"; //!< traverser to use for triangles
std::string g_hair_accel = "default"; //!< hair acceleration structure to use
std::string g_hair_builder = "default"; //!< builder to use for hair
std::string g_hair_traverser = "default"; //!< traverser to use for hair
double g_hair_builder_replication_factor = 3.0f; //!< maximally factor*N many primitives in accel
float g_memory_preallocation_factor = 1.0f;
std::string g_subdiv_accel = "default"; //!< acceleration structure to use for subdivision surfaces
int g_scene_flags = -1; //!< scene flags to use
size_t g_verbose = 0; //!< verbosity of output
size_t g_numThreads = 0; //!< number of threads to use in builders
size_t g_benchmark = 0;
size_t g_regression_testing = 0; //!< enables regression tests at startup
void initSettings()
{
g_tri_accel = "default";
g_tri_builder = "default";
g_tri_traverser = "default";
g_tri_builder_replication_factor = 2.0f;
g_tri_accel_mb = "default";
g_tri_builder_mb = "default";
g_tri_traverser_mb = "default";
g_hair_accel = "default";
g_hair_builder = "default";
g_hair_traverser = "default";
g_hair_builder_replication_factor = 3.0f;
g_memory_preallocation_factor = 1.0f;
g_subdiv_accel = "default";
g_scene_flags = -1;
g_verbose = 0;
g_numThreads = 0;
g_benchmark = 0;
}
void printSettings()
{
std::cout << "general:" << std::endl;
std::cout << " build threads = " << g_numThreads << std::endl;
std::cout << " verbosity = " << g_verbose << std::endl;
std::cout << "triangles:" << std::endl;
std::cout << " accel = " << g_tri_accel << std::endl;
std::cout << " builder = " << g_tri_builder << std::endl;
std::cout << " traverser = " << g_tri_traverser << std::endl;
std::cout << " replications = " << g_tri_builder_replication_factor << std::endl;
std::cout << "motion blur triangles:" << std::endl;
std::cout << " accel = " << g_tri_accel_mb << std::endl;
std::cout << " builder = " << g_tri_builder_mb << std::endl;
std::cout << " traverser = " << g_tri_traverser_mb << std::endl;
std::cout << "hair:" << std::endl;
std::cout << " accel = " << g_hair_accel << std::endl;
std::cout << " builder = " << g_hair_builder << std::endl;
std::cout << " traverser = " << g_hair_traverser << std::endl;
std::cout << " replications = " << g_hair_builder_replication_factor << std::endl;
std::cout << "subdivision surfaces:" << std::endl;
std::cout << " accel = " << g_subdiv_accel << std::endl;
#if defined(__MIC__)
std::cout << "memory allocation:" << std::endl;
std::cout << " preallocation_factor = " << g_memory_preallocation_factor << std::endl;
#endif
}
/* error flag */
static tls_t g_error = NULL;
static std::vector<RTCError*> g_errors;
static MutexSys g_errors_mutex;
static RTC_ERROR_FUNCTION g_error_function = NULL;
/* mutex to make API thread safe */
static MutexSys g_mutex;
/* set if embree got initialized */
static bool g_initialized = false;
void skipSpace(const char* str, size_t& pos) {
while (str[pos] == ' ') pos++;
}
int parseInt(const char* str, size_t& pos)
{
skipSpace(str,pos);
size_t begin = pos;
while (isdigit(str[pos])) pos++;
return atoi(str+begin);
}
float parseFloat(const char* str, size_t& pos)
{
skipSpace(str,pos);
size_t begin = pos;
while (isdigit(str[pos]) || str[pos] == '.') pos++;
return atof(str+begin);
}
std::string parseIdentifier(const char* str, size_t& pos)
{
skipSpace(str,pos);
size_t begin = pos;
while (isalnum(str[pos]) || str[pos] == '_' || str[pos] == '.') pos++;
return std::string(str+begin,str+pos);
}
bool parseSymbol(const char* str, char c, size_t& pos)
{
skipSpace(str,pos);
if (str[pos] == c) { pos++; return true; }
return false;
}
bool findNext(const char* str, char c, size_t& pos)
{
while (str[pos] && str[pos] != c) pos++;
if (str[pos] == c) { pos++; return true; }
else return false;
}
void InstanceIntersectorsRegister ()
{
int features = getCPUFeatures();
#if defined(__MIC__)
SELECT_SYMBOL_KNC(features,InstanceBoundsFunc);
SELECT_SYMBOL_KNC(features,InstanceIntersector1);
SELECT_SYMBOL_KNC(features,InstanceIntersector16);
#else
SELECT_SYMBOL_DEFAULT_AVX_AVX2(features,InstanceBoundsFunc);
SELECT_SYMBOL_DEFAULT_AVX_AVX2(features,InstanceIntersector1);
SELECT_SYMBOL_DEFAULT_AVX_AVX2(features,InstanceIntersector4);
SELECT_SYMBOL_AVX_AVX2(features,InstanceIntersector8);
#endif
}
LockStepTaskScheduler regression_task_scheduler;
void task_regression_testing(void* This, size_t threadIndex, size_t threadCount, size_t taskIndex, size_t taskCount, TaskScheduler::Event* taskGroup)
{
if (regression_tests == NULL) return;
LockStepTaskScheduler::setInstance(&regression_task_scheduler);
LockStepTaskScheduler::Init init(threadIndex,threadCount,&regression_task_scheduler);
if (threadIndex != 0) return;
for (size_t i=0; i<regression_tests->size(); i++)
(*(*regression_tests)[i])();
}
RTCORE_API void rtcInit(const char* cfg)
{
Lock<MutexSys> lock(g_mutex);
TRACE(rtcInit);
CATCH_BEGIN;
if (g_initialized) {
g_mutex.unlock();
process_error(RTC_INVALID_OPERATION,"already initialized");
g_mutex.lock();
return;
}
g_initialized = true;
/* reset global state */
initSettings();
if (cfg != NULL)
{
size_t pos = 0;
do {
std::string tok = parseIdentifier (cfg,pos);
if (tok == "threads" && parseSymbol(cfg,'=',pos))
{
g_numThreads = parseInt(cfg,pos);
#if defined(__MIC__)
if (!(g_numThreads == 1 || (g_numThreads % 4) == 0)) {
g_mutex.unlock();
process_error(RTC_INVALID_OPERATION,"Xeon Phi supports only number of threads % 4 == 0, or threads == 1");
g_mutex.lock();
return;
}
#endif
}
else if (tok == "isa" && parseSymbol (cfg,'=',pos))
{
std::string isa = parseIdentifier (cfg,pos);
if (isa == "sse" ) cpu_features = SSE;
else if (isa == "sse2") cpu_features = SSE2;
else if (isa == "sse3") cpu_features = SSE3;
else if (isa == "ssse3") cpu_features = SSSE3;
else if (isa == "sse41") cpu_features = SSE41;
else if (isa == "sse4.1") cpu_features = SSE41;
else if (isa == "sse42") cpu_features = SSE42;
else if (isa == "sse4.2") cpu_features = SSE42;
else if (isa == "avx") cpu_features = AVX;
else if (isa == "avxi") cpu_features = AVXI;
else if (isa == "avx2") cpu_features = AVX2;
}
else if ((tok == "tri_accel" || tok == "accel") && parseSymbol (cfg,'=',pos))
g_tri_accel = parseIdentifier (cfg,pos);
else if ((tok == "tri_builder" || tok == "builder") && parseSymbol (cfg,'=',pos))
g_tri_builder = parseIdentifier (cfg,pos);
else if ((tok == "tri_traverser" || tok == "traverser") && parseSymbol (cfg,'=',pos))
g_tri_traverser = parseIdentifier (cfg,pos);
else if (tok == "tri_builder_replication_factor" && parseSymbol (cfg,'=',pos))
g_tri_builder_replication_factor = parseInt (cfg,pos);
else if ((tok == "tri_accel_mb" || tok == "accel_mb") && parseSymbol (cfg,'=',pos))
g_tri_accel = parseIdentifier (cfg,pos);
else if ((tok == "tri_builder_mb" || tok == "builder_mb") && parseSymbol (cfg,'=',pos))
g_tri_builder = parseIdentifier (cfg,pos);
else if ((tok == "tri_traverser_mb" || tok == "traverser_mb") && parseSymbol (cfg,'=',pos))
g_tri_traverser = parseIdentifier (cfg,pos);
else if (tok == "hair_accel" && parseSymbol (cfg,'=',pos))
g_hair_accel = parseIdentifier (cfg,pos);
else if (tok == "hair_builder" && parseSymbol (cfg,'=',pos))
g_hair_builder = parseIdentifier (cfg,pos);
else if (tok == "hair_traverser" && parseSymbol (cfg,'=',pos))
g_hair_traverser = parseIdentifier (cfg,pos);
else if (tok == "hair_builder_replication_factor" && parseSymbol (cfg,'=',pos))
g_hair_builder_replication_factor = parseInt (cfg,pos);
else if (tok == "subdiv_accel" && parseSymbol (cfg,'=',pos))
g_subdiv_accel = parseIdentifier (cfg,pos);
else if (tok == "verbose" && parseSymbol (cfg,'=',pos))
g_verbose = parseInt (cfg,pos);
else if (tok == "benchmark" && parseSymbol (cfg,'=',pos))
g_benchmark = parseInt (cfg,pos);
else if (tok == "flags") {
g_scene_flags = 0;
if (parseSymbol (cfg,'=',pos)) {
do {
std::string flag = parseIdentifier (cfg,pos);
if (flag == "static" ) g_scene_flags |= RTC_SCENE_STATIC;
else if (flag == "dynamic") g_scene_flags |= RTC_SCENE_DYNAMIC;
else if (flag == "compact") g_scene_flags |= RTC_SCENE_COMPACT;
else if (flag == "coherent") g_scene_flags |= RTC_SCENE_COHERENT;
else if (flag == "incoherent") g_scene_flags |= RTC_SCENE_INCOHERENT;
else if (flag == "high_quality") g_scene_flags |= RTC_SCENE_HIGH_QUALITY;
else if (flag == "robust") g_scene_flags |= RTC_SCENE_ROBUST;
} while (parseSymbol (cfg,',',pos));
}
}
else if (tok == "memory_preallocation_factor" && parseSymbol (cfg,'=',pos))
{
g_memory_preallocation_factor = parseFloat (cfg,pos);
DBG_PRINT( g_memory_preallocation_factor );
}
else if (tok == "regression" && parseSymbol (cfg,'=',pos)) {
g_regression_testing = parseInt (cfg,pos);
}
} while (findNext (cfg,',',pos));
}
if (g_verbose >= 1)
{
std::cout << "Embree Ray Tracing Kernels " << __EMBREE_VERSION__ << " (" << __DATE__ << ")" << std::endl;
std::cout << " Compiler : " << getCompilerName() << std::endl;
std::cout << " Platform : " << getPlatformName() << std::endl;
std::cout << " CPU : " << stringOfCPUFeatures(getCPUFeatures()) << std::endl;
std::cout << " Features : ";
#if defined(RTCORE_RAY_MASK)
std::cout << "raymasks ";
#endif
#if defined (RTCORE_BACKFACE_CULLING)
std::cout << "backfaceculling ";
#endif
#if defined(RTCORE_INTERSECTION_FILTER)
std::cout << "intersection_filter ";
#endif
#if defined(RTCORE_BUFFER_STRIDE)
std::cout << "bufferstride ";
#endif
std::cout << std::endl;
#if defined (__MIC__)
#if defined(RTCORE_BUFFER_STRIDE)
std::cout << " WARNING: enabled 'bufferstride' support will lower BVH build performance" << std::endl;
#endif
#endif
}
/* CPU has to support at least SSE2 */
#if !defined (__MIC__)
if (!has_feature(SSE2)) {
g_mutex.unlock();
process_error(RTC_UNSUPPORTED_CPU,"CPU does not support SSE2");
g_mutex.lock();
return;
}
#endif
g_error = createTls();
g_error_function = NULL;
init_globals();
#if !defined(__MIC__)
BVH4Register();
#else
BVH4iRegister();
BVH4MBRegister();
BVH4HairRegister();
#endif
#if defined(__TARGET_AVX__)
if (has_feature(AVX)) {
BVH8Register();
}
#endif
InstanceIntersectorsRegister();
if (g_verbose >= 2)
printSettings();
TaskScheduler::create(g_numThreads);
/* execute regression tests */
if (g_regression_testing)
{
TaskScheduler::EventSync event;
TaskScheduler::Task task(&event,task_regression_testing,NULL,TaskScheduler::getNumThreads(),NULL,NULL,"regression_testing");
TaskScheduler::addTask(-1,TaskScheduler::GLOBAL_FRONT,&task);
event.sync();
}
CATCH_END;
}
RTCORE_API void rtcExit()
{
Lock<MutexSys> lock(g_mutex);
TRACE(rtcExit);
CATCH_BEGIN;
if (!g_initialized) {
return;
}
TaskScheduler::destroy();
{
Lock<MutexSys> lock(g_errors_mutex);
for (size_t i=0; i<g_errors.size(); i++)
delete g_errors[i];
destroyTls(g_error);
g_errors.clear();
}
Alloc::global.clear();
g_error_function = NULL;
g_initialized = false;
CATCH_END;
}
RTCError* getThreadError()
{
RTCError* stored_error = (RTCError*) getTls(g_error);
if (stored_error == NULL) {
Lock<MutexSys> lock(g_errors_mutex);
stored_error = new RTCError(RTC_NO_ERROR);
g_errors.push_back(stored_error);
setTls(g_error,stored_error);
}
return stored_error;
}
void process_error(RTCError error, const char* str)
{
/* print error when in verbose mode */
if (g_verbose)
{
switch (error) {
case RTC_NO_ERROR : std::cerr << "Embree: No error"; break;
case RTC_UNKNOWN_ERROR : std::cerr << "Embree: Unknown error"; break;
case RTC_INVALID_ARGUMENT : std::cerr << "Embree: Invalid argument"; break;
case RTC_INVALID_OPERATION: std::cerr << "Embree: Invalid operation"; break;
case RTC_OUT_OF_MEMORY : std::cerr << "Embree: Out of memory"; break;
case RTC_UNSUPPORTED_CPU : std::cerr << "Embree: Unsupported CPU"; break;
default : std::cerr << "Embree: Invalid error code"; break;
};
if (str) std::cerr << ", (" << str << ")";
std::cerr << std::endl;
}
/* call user specified error callback */
if (g_error_function)
g_error_function(error,str);
/* record error code */
RTCError* stored_error = getThreadError();
if (*stored_error == RTC_NO_ERROR)
*stored_error = error;
}
RTCORE_API RTCError rtcGetError()
{
TRACE(rtcGetError);
RTCError* stored_error = getThreadError();
RTCError error = *stored_error;
*stored_error = RTC_NO_ERROR;
return error;
}
RTCORE_API void rtcSetErrorFunction(RTC_ERROR_FUNCTION func) {
g_error_function = func;
}
RTCORE_API void rtcDebug()
{
Lock<MutexSys> lock(g_mutex);
TRACE(rtcDebug);
#if defined(RTCORE_STAT_COUNTERS)
Stat::print(std::cout);
Stat::clear();
#endif
#if defined(DEBUG) && 0
extern void printTessCacheStats();
printTessCacheStats();
#endif
}
RTCORE_API RTCScene rtcNewScene (RTCSceneFlags flags, RTCAlgorithmFlags aflags)
{
CATCH_BEGIN;
TRACE(rtcNewScene);
if (!isCoherent(flags) && !isIncoherent(flags)) flags = RTCSceneFlags(flags | RTC_SCENE_INCOHERENT);
return (RTCScene) new Scene(flags,aflags);
CATCH_END;
return NULL;
}
RTCORE_API void rtcCommit (RTCScene scene)
{
CATCH_BEGIN;
TRACE(rtcCommit);
VERIFY_HANDLE(scene);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.dumpGeometry(scene);
#endif
((Scene*)scene)->build(0,0);
CATCH_END;
}
RTCORE_API void rtcCommitThread(RTCScene scene, unsigned int threadID, unsigned int numThreads)
{
CATCH_BEGIN;
TRACE(rtcCommitMT);
VERIFY_HANDLE(scene);
if (unlikely(numThreads == 0))
process_error(RTC_INVALID_OPERATION,"invalid number of threads specified");
#if defined(__MIC__)
if (unlikely(numThreads % 4 != 0 && numThreads != 1))
FATAL("MIC requires numThreads % 4 == 0 in rtcCommitThread");
#endif
((Scene*)scene)->build(threadID,numThreads);
CATCH_END;
}
RTCORE_API void rtcIntersect (RTCScene scene, RTCRay& ray)
{
TRACE(rtcIntersect);
STAT3(normal.travs,1,1,1);
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)&ray) & 0x0F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 16 bytes");
#endif
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay old_ray = ray;
#endif
((Scene*)scene)->intersect(ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay1Intersect(scene,old_ray,ray);
#endif
}
RTCORE_API void rtcIntersect4 (const void* valid, RTCScene scene, RTCRay4& ray)
{
TRACE(rtcIntersect4);
#if !defined(__TARGET_SIMD4__)
process_error(RTC_INVALID_OPERATION,"rtcIntersect4 not supported");
#else
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)valid) & 0x0F) process_error(RTC_INVALID_ARGUMENT,"mask not aligned to 16 bytes");
if (((size_t)&ray ) & 0x0F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 16 bytes");
#endif
STAT(size_t cnt=0; for (size_t i=0; i<4; i++) cnt += ((int*)valid)[i] == -1;);
STAT3(normal.travs,1,cnt,4);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay4 old_ray = ray;
#endif
((Scene*)scene)->intersect4(valid,ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay4Intersect(valid,scene,old_ray,ray);
#endif
#endif
}
RTCORE_API void rtcIntersect8 (const void* valid, RTCScene scene, RTCRay8& ray)
{
TRACE(rtcIntersect8);
#if !defined(__TARGET_SIMD8__)
process_error(RTC_INVALID_OPERATION,"rtcIntersect8 not supported");
#else
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)valid) & 0x1F) process_error(RTC_INVALID_ARGUMENT,"mask not aligned to 32 bytes");
if (((size_t)&ray ) & 0x1F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 32 bytes");
#endif
STAT(size_t cnt=0; for (size_t i=0; i<8; i++) cnt += ((int*)valid)[i] == -1;);
STAT3(normal.travs,1,cnt,8);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay8 old_ray = ray;
#endif
((Scene*)scene)->intersect8(valid,ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay8Intersect(valid,scene,old_ray,ray);
#endif
#endif
}
RTCORE_API void rtcIntersect16 (const void* valid, RTCScene scene, RTCRay16& ray)
{
TRACE(rtcIntersect16);
#if !defined(__TARGET_SIMD16__)
process_error(RTC_INVALID_OPERATION,"rtcIntersect16 not supported");
#else
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)valid) & 0x3F) process_error(RTC_INVALID_ARGUMENT,"mask not aligned to 64 bytes");
if (((size_t)&ray ) & 0x3F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 64 bytes");
#endif
STAT(size_t cnt=0; for (size_t i=0; i<16; i++) cnt += ((int*)valid)[i] == -1;);
STAT3(normal.travs,1,cnt,16);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay16 old_ray = ray;
#endif
((Scene*)scene)->intersect16(valid,ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay16Intersect(valid,scene,old_ray,ray);
#endif
#endif
}
RTCORE_API void rtcOccluded (RTCScene scene, RTCRay& ray)
{
TRACE(rtcOccluded);
STAT3(shadow.travs,1,1,1);
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)&ray) & 0x0F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 16 bytes");
#endif
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay old_ray = ray;
#endif
((Scene*)scene)->occluded(ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay1Occluded(scene,old_ray,ray);
#endif
}
RTCORE_API void rtcOccluded4 (const void* valid, RTCScene scene, RTCRay4& ray)
{
TRACE(rtcOccluded4);
#if !defined(__TARGET_SIMD4__)
process_error(RTC_INVALID_OPERATION,"rtcOccluded4 not supported");
#else
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)valid) & 0x0F) process_error(RTC_INVALID_ARGUMENT,"mask not aligned to 16 bytes");
if (((size_t)&ray ) & 0x0F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 16 bytes");
#endif
STAT(size_t cnt=0; for (size_t i=0; i<4; i++) cnt += ((int*)valid)[i] == -1;);
STAT3(shadow.travs,1,cnt,4);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay4 old_ray = ray;
#endif
((Scene*)scene)->occluded4(valid,ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay4Occluded(valid,scene,old_ray,ray);
#endif
#endif
}
RTCORE_API void rtcOccluded8 (const void* valid, RTCScene scene, RTCRay8& ray)
{
TRACE(rtcOccluded8);
#if !defined(__TARGET_SIMD8__)
process_error(RTC_INVALID_OPERATION,"rtcOccluded8 not supported");
#else
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)valid) & 0x1F) process_error(RTC_INVALID_ARGUMENT,"mask not aligned to 32 bytes");
if (((size_t)&ray ) & 0x1F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 32 bytes");
#endif
STAT(size_t cnt=0; for (size_t i=0; i<8; i++) cnt += ((int*)valid)[i] == -1;);
STAT3(shadow.travs,1,cnt,8);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay8 old_ray = ray;
#endif
((Scene*)scene)->occluded8(valid,ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay8Occluded(valid,scene,old_ray,ray);
#endif
#endif
}
RTCORE_API void rtcOccluded16 (const void* valid, RTCScene scene, RTCRay16& ray)
{
TRACE(rtcOccluded16);
#if !defined(__TARGET_SIMD16__)
process_error(RTC_INVALID_OPERATION,"rtcOccluded16 not supported");
#else
#if defined(DEBUG)
if (!((Scene*)scene)->is_build) process_error(RTC_INVALID_OPERATION,"scene got not committed");
if (((size_t)valid) & 0x3F) process_error(RTC_INVALID_ARGUMENT,"mask not aligned to 64 bytes");
if (((size_t)&ray ) & 0x3F) process_error(RTC_INVALID_ARGUMENT,"ray not aligned to 64 bytes");
#endif
STAT(size_t cnt=0; for (size_t i=0; i<16; i++) cnt += ((int*)valid)[i] == -1;);
STAT3(shadow.travs,1,cnt,16);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RTCRay16 old_ray = ray;
#endif
((Scene*)scene)->occluded16(valid,ray);
#if defined(RTCORE_ENABLE_RAYSTREAM_LOGGER)
RayStreamLogger::rayStreamLogger.logRay16Occluded(valid,scene,old_ray,ray);
#endif
#endif
}
RTCORE_API void rtcDeleteScene (RTCScene scene)
{
CATCH_BEGIN;
TRACE(rtcDeleteScene);
VERIFY_HANDLE(scene);
delete (Scene*) scene;
CATCH_END;
}
RTCORE_API unsigned rtcNewInstance (RTCScene target, RTCScene source)
{
CATCH_BEGIN;
TRACE(rtcNewInstance);
VERIFY_HANDLE(target);
VERIFY_HANDLE(source);
return ((Scene*) target)->newInstance((Scene*) source);
CATCH_END;
return -1;
}
RTCORE_API void rtcSetTransform (RTCScene scene, unsigned geomID, RTCMatrixType layout, const float* xfm)
{
CATCH_BEGIN;
TRACE(rtcSetTransform);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
VERIFY_HANDLE(xfm);
AffineSpace3fa transform = one;
switch (layout)
{
case RTC_MATRIX_ROW_MAJOR:
transform = AffineSpace3fa(Vec3fa(xfm[ 0],xfm[ 4],xfm[ 8]),
Vec3fa(xfm[ 1],xfm[ 5],xfm[ 9]),
Vec3fa(xfm[ 2],xfm[ 6],xfm[10]),
Vec3fa(xfm[ 3],xfm[ 7],xfm[11]));
break;
case RTC_MATRIX_COLUMN_MAJOR:
transform = AffineSpace3fa(Vec3fa(xfm[ 0],xfm[ 1],xfm[ 2]),
Vec3fa(xfm[ 3],xfm[ 4],xfm[ 5]),
Vec3fa(xfm[ 6],xfm[ 7],xfm[ 8]),
Vec3fa(xfm[ 9],xfm[10],xfm[11]));
break;
case RTC_MATRIX_COLUMN_MAJOR_ALIGNED16:
transform = AffineSpace3fa(Vec3fa(xfm[ 0],xfm[ 1],xfm[ 2]),
Vec3fa(xfm[ 4],xfm[ 5],xfm[ 6]),
Vec3fa(xfm[ 8],xfm[ 9],xfm[10]),
Vec3fa(xfm[12],xfm[13],xfm[14]));
break;
default:
process_error(RTC_INVALID_OPERATION,"Unknown matrix type");
break;
}
((Scene*) scene)->get_locked(geomID)->setTransform(transform);
CATCH_END;
}
RTCORE_API unsigned rtcNewUserGeometry (RTCScene scene, size_t numItems)
{
CATCH_BEGIN;
TRACE(rtcNewUserGeometry);
VERIFY_HANDLE(scene);
return ((Scene*)scene)->newUserGeometry(numItems);
CATCH_END;
return -1;
}
RTCORE_API unsigned rtcNewTriangleMesh (RTCScene scene, RTCGeometryFlags flags, size_t numTriangles, size_t numVertices, size_t numTimeSteps)
{
CATCH_BEGIN;
TRACE(rtcNewTriangleMesh);
VERIFY_HANDLE(scene);
return ((Scene*)scene)->newTriangleMesh(flags,numTriangles,numVertices,numTimeSteps);
CATCH_END;
return -1;
}
RTCORE_API unsigned rtcNewHairGeometry (RTCScene scene, RTCGeometryFlags flags, size_t numCurves, size_t numVertices, size_t numTimeSteps)
{
CATCH_BEGIN;
TRACE(rtcNewHairGeometry);
VERIFY_HANDLE(scene);
return ((Scene*)scene)->newBezierCurves(flags,numCurves,numVertices,numTimeSteps);
CATCH_END;
return -1;
}
RTCORE_API void rtcSetMask (RTCScene scene, unsigned geomID, int mask)
{
CATCH_BEGIN;
TRACE(rtcSetMask);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setMask(mask);
CATCH_END;
}
RTCORE_API void* rtcMapBuffer(RTCScene scene, unsigned geomID, RTCBufferType type)
{
CATCH_BEGIN;
TRACE(rtcMapBuffer);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
return ((Scene*)scene)->get_locked(geomID)->map(type);
CATCH_END;
return NULL;
}
RTCORE_API void rtcUnmapBuffer(RTCScene scene, unsigned geomID, RTCBufferType type)
{
CATCH_BEGIN;
TRACE(rtcUnmapBuffer);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->unmap(type);
CATCH_END;
}
RTCORE_API void rtcSetBuffer(RTCScene scene, unsigned geomID, RTCBufferType type, void* ptr, size_t offset, size_t stride)
{
CATCH_BEGIN;
TRACE(rtcSetBuffer);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setBuffer(type,ptr,offset,stride);
CATCH_END;
}
RTCORE_API void rtcEnable (RTCScene scene, unsigned geomID)
{
CATCH_BEGIN;
TRACE(rtcEnable);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->enable();
CATCH_END;
}
RTCORE_API void rtcUpdate (RTCScene scene, unsigned geomID)
{
CATCH_BEGIN;
TRACE(rtcUpdate);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->update();
CATCH_END;
}
RTCORE_API void rtcUpdateBuffer (RTCScene scene, unsigned geomID, RTCBufferType type)
{
CATCH_BEGIN;
TRACE(rtcUpdateBuffer);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->updateBuffer(type);
CATCH_END;
}
RTCORE_API void rtcDisable (RTCScene scene, unsigned geomID)
{
CATCH_BEGIN;
TRACE(rtcDisable);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->disable();
CATCH_END;
}
RTCORE_API void rtcDeleteGeometry (RTCScene scene, unsigned geomID)
{
CATCH_BEGIN;
TRACE(rtcDeleteGeometry);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->erase();
CATCH_END;
}
RTCORE_API void rtcSetUserData (RTCScene scene, unsigned geomID, void* ptr)
{
CATCH_BEGIN;
TRACE(rtcSetUserData);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setUserData(ptr);
CATCH_END;
}
RTCORE_API void rtcSetBoundsFunction (RTCScene scene, unsigned geomID, RTCBoundsFunc bounds)
{
CATCH_BEGIN;
TRACE(rtcSetBoundsFunction);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setBoundsFunction(bounds);
CATCH_END;
}
RTCORE_API void rtcSetDisplacementFunction (RTCScene scene, unsigned geomID, RTCDisplacementFunc func, RTCBounds* bounds)
{
CATCH_BEGIN;
TRACE(rtcSetDisplacementFunction);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setDisplacementFunction(func,bounds);
CATCH_END;
}
RTCORE_API void rtcSetIntersectFunction (RTCScene scene, unsigned geomID, RTCIntersectFunc intersect)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectFunction);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectFunction(intersect);
CATCH_END;
}
RTCORE_API void rtcSetIntersectFunction4 (RTCScene scene, unsigned geomID, RTCIntersectFunc4 intersect4)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectFunction4);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectFunction4(intersect4);
CATCH_END;
}
RTCORE_API void rtcSetIntersectFunction8 (RTCScene scene, unsigned geomID, RTCIntersectFunc8 intersect8)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectFunction8);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectFunction8(intersect8);
CATCH_END;
}
RTCORE_API void rtcSetIntersectFunction16 (RTCScene scene, unsigned geomID, RTCIntersectFunc16 intersect16)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectFunction16(intersect16);
CATCH_END;
}
RTCORE_API void rtcSetOccludedFunction (RTCScene scene, unsigned geomID, RTCOccludedFunc occluded)
{
CATCH_BEGIN;
TRACE(rtcSetOccludedFunction);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOccludedFunction(occluded);
CATCH_END;
}
RTCORE_API void rtcSetOccludedFunction4 (RTCScene scene, unsigned geomID, RTCOccludedFunc4 occluded4)
{
CATCH_BEGIN;
TRACE(rtcSetOccludedFunction4);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOccludedFunction4(occluded4);
CATCH_END;
}
RTCORE_API void rtcSetOccludedFunction8 (RTCScene scene, unsigned geomID, RTCOccludedFunc8 occluded8)
{
CATCH_BEGIN;
TRACE(rtcSetOccludedFunction8);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOccludedFunction8(occluded8);
CATCH_END;
}
RTCORE_API void rtcSetOccludedFunction16 (RTCScene scene, unsigned geomID, RTCOccludedFunc16 occluded16)
{
CATCH_BEGIN;
TRACE(rtcSetOccludedFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOccludedFunction16(occluded16);
CATCH_END;
}
RTCORE_API void rtcSetIntersectionFilterFunction (RTCScene scene, unsigned geomID, RTCFilterFunc intersect)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectionFilterFunction);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectionFilterFunction(intersect);
CATCH_END;
}
RTCORE_API void rtcSetIntersectionFilterFunction4 (RTCScene scene, unsigned geomID, RTCFilterFunc4 filter4)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectionFilterFunction4);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectionFilterFunction4(filter4);
CATCH_END;
}
RTCORE_API void rtcSetIntersectionFilterFunction8 (RTCScene scene, unsigned geomID, RTCFilterFunc8 filter8)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectionFilterFunction8);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectionFilterFunction8(filter8);
CATCH_END;
}
RTCORE_API void rtcSetIntersectionFilterFunction16 (RTCScene scene, unsigned geomID, RTCFilterFunc16 filter16)
{
CATCH_BEGIN;
TRACE(rtcSetIntersectionFilterFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setIntersectionFilterFunction16(filter16);
CATCH_END;
}
RTCORE_API void rtcSetOcclusionFilterFunction (RTCScene scene, unsigned geomID, RTCFilterFunc intersect)
{
CATCH_BEGIN;
TRACE(rtcSetOcclusionFilterFunction);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOcclusionFilterFunction(intersect);
CATCH_END;
}
RTCORE_API void rtcSetOcclusionFilterFunction4 (RTCScene scene, unsigned geomID, RTCFilterFunc4 filter4)
{
CATCH_BEGIN;
TRACE(rtcSetOcclusionFilterFunction4);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOcclusionFilterFunction4(filter4);
CATCH_END;
}
RTCORE_API void rtcSetOcclusionFilterFunction8 (RTCScene scene, unsigned geomID, RTCFilterFunc8 filter8)
{
CATCH_BEGIN;
TRACE(rtcSetOcclusionFilterFunction8);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOcclusionFilterFunction8(filter8);
CATCH_END;
}
RTCORE_API void rtcSetOcclusionFilterFunction16 (RTCScene scene, unsigned geomID, RTCFilterFunc16 filter16)
{
CATCH_BEGIN;
TRACE(rtcSetOcclusionFilterFunction16);
VERIFY_HANDLE(scene);
VERIFY_GEOMID(geomID);
((Scene*)scene)->get_locked(geomID)->setOcclusionFilterFunction16(filter16);
CATCH_END;
}
/* new support for subdivision surfaces */
RTCORE_API unsigned rtcNewSubdivisionMesh (RTCScene scene, RTCGeometryFlags flags, size_t numFaces, size_t numEdges, size_t numVertices,
size_t numEdgeCreases, size_t numVertexCreases, size_t numHoles, size_t numTimeSteps)
{
CATCH_BEGIN;
TRACE(rtcNewSubdivisionMesh);
VERIFY_HANDLE(scene);
return ((Scene*)scene)->newSubdivisionMesh(flags,numFaces,numEdges,numVertices,numEdgeCreases,numVertexCreases,numHoles,numTimeSteps);
CATCH_END;
return -1;
}
}
Reference in New Issue View Git Blame Copy Permalink