361 lines
12 KiB
C++
Executable File
361 lines
12 KiB
C++
Executable File
// ======================================================================== //
|
|
// 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. //
|
|
// ======================================================================== //
|
|
|
|
#include "common/default.h"
|
|
#include "scene.h"
|
|
|
|
namespace embree
|
|
{
|
|
#define size_t int // FIXME: workaround of ISPC bug
|
|
|
|
#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"); \
|
|
}
|
|
|
|
#define TRACE(x) //std::cout << #x << std::endl;
|
|
|
|
extern "C" void ispcInit(const char* cfg) {
|
|
rtcInit(cfg);
|
|
}
|
|
|
|
extern "C" void ispcExit() {
|
|
rtcExit();
|
|
}
|
|
|
|
extern "C" RTCError ispcGetError() {
|
|
return rtcGetError();
|
|
}
|
|
|
|
extern "C" void ispcSetErrorFunction(void* f) {
|
|
return rtcSetErrorFunction((RTC_ERROR_FUNCTION)f);
|
|
}
|
|
|
|
extern "C" void ispcDebug() {
|
|
rtcDebug();
|
|
}
|
|
|
|
extern "C" RTCScene ispcNewScene (RTCSceneFlags flags, RTCAlgorithmFlags aflags)
|
|
{
|
|
if (!isCoherent(flags) && !isIncoherent(flags)) flags = RTCSceneFlags(flags | RTC_SCENE_COHERENT);
|
|
return rtcNewScene(flags,aflags);
|
|
}
|
|
|
|
extern "C" void ispcCommitScene (RTCScene scene) {
|
|
return rtcCommit(scene);
|
|
}
|
|
|
|
extern "C" void ispcCommitSceneThread (RTCScene scene, unsigned int threadID, unsigned int numThreads) {
|
|
return rtcCommitThread(scene,threadID,numThreads);
|
|
}
|
|
|
|
extern "C" void ispcIntersect1 (RTCScene scene, RTCRay& ray) {
|
|
rtcIntersect(scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcIntersect4 (const void* valid, RTCScene scene, RTCRay4& ray) {
|
|
rtcIntersect4(valid,scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcIntersect8 (const void* valid, RTCScene scene, RTCRay8& ray) {
|
|
rtcIntersect8(valid,scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcIntersect16 (const void* valid, RTCScene scene, RTCRay16& ray) {
|
|
rtcIntersect16(valid,scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcOccluded1 (RTCScene scene, RTCRay& ray) {
|
|
rtcOccluded(scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcOccluded4 (const void* valid, RTCScene scene, RTCRay4& ray) {
|
|
rtcOccluded4(valid,scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcOccluded8 (const void* valid, RTCScene scene, RTCRay8& ray) {
|
|
rtcOccluded8(valid,scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcOccluded16 (const void* valid, RTCScene scene, RTCRay16& ray) {
|
|
rtcOccluded16(valid,scene,ray);
|
|
}
|
|
|
|
extern "C" void ispcDeleteScene (RTCScene scene) {
|
|
rtcDeleteScene(scene);
|
|
}
|
|
|
|
extern "C" unsigned ispcNewInstance (RTCScene target, RTCScene source) {
|
|
return rtcNewInstance(target,source);
|
|
}
|
|
|
|
extern "C" void ispcSetTransform (RTCScene scene, unsigned geomID, RTCMatrixType layout, const float* xfm) {
|
|
return rtcSetTransform(scene,geomID,layout,xfm);
|
|
}
|
|
|
|
extern "C" unsigned ispcNewUserGeometry (RTCScene scene, size_t numItems) {
|
|
return rtcNewUserGeometry(scene,numItems);
|
|
}
|
|
|
|
extern "C" unsigned ispcNewTriangleMesh (RTCScene scene, RTCGeometryFlags flags, size_t numTriangles, size_t numVertices, size_t numTimeSteps) {
|
|
return rtcNewTriangleMesh((RTCScene)scene,flags,numTriangles,numVertices,numTimeSteps);
|
|
}
|
|
|
|
extern "C" unsigned ispcNewBezierCurves (RTCScene scene, RTCGeometryFlags flags, size_t numCurves, size_t numVertices, size_t numTimeSteps) {
|
|
return rtcNewHairGeometry(scene,flags,numCurves,numVertices,numTimeSteps);
|
|
}
|
|
|
|
extern "C" void ispcSetRayMask (RTCScene scene, unsigned geomID, int mask) {
|
|
rtcSetMask(scene,geomID,mask);
|
|
}
|
|
|
|
extern "C" void* ispcMapBuffer(RTCScene scene, unsigned geomID, RTCBufferType type) {
|
|
return rtcMapBuffer(scene,geomID,type);
|
|
}
|
|
|
|
extern "C" void ispcUnmapBuffer(RTCScene scene, unsigned geomID, RTCBufferType type) {
|
|
rtcUnmapBuffer(scene,geomID,type);
|
|
}
|
|
|
|
extern "C" void ispcSetBuffer(RTCScene scene, unsigned geomID, RTCBufferType type, void* ptr, size_t offset, size_t stride) {
|
|
rtcSetBuffer(scene,geomID,type,ptr,offset,stride);
|
|
}
|
|
|
|
extern "C" void ispcEnable (RTCScene scene, unsigned geomID) {
|
|
rtcEnable(scene,geomID);
|
|
}
|
|
|
|
extern "C" void ispcUpdate (RTCScene scene, unsigned geomID) {
|
|
rtcUpdate(scene,geomID);
|
|
}
|
|
|
|
extern "C" void ispcUpdateBuffer (RTCScene scene, unsigned geomID, RTCBufferType type) {
|
|
rtcUpdateBuffer(scene,geomID,type);
|
|
}
|
|
|
|
extern "C" void ispcDisable (RTCScene scene, unsigned geomID) {
|
|
rtcDisable(scene,geomID);
|
|
}
|
|
|
|
extern "C" void ispcDeleteGeometry (RTCScene scene, unsigned geomID) {
|
|
rtcDeleteGeometry(scene,geomID);
|
|
}
|
|
|
|
extern "C" void ispcSetUserData (RTCScene scene, unsigned geomID, void* ptr)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetUserData);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setUserData(ptr,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetBoundsFunction (RTCScene scene, unsigned geomID, RTCBoundsFunc bounds) {
|
|
rtcSetBoundsFunction(scene,geomID,bounds);
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectFunction1 (RTCScene scene, unsigned geomID, RTCIntersectFunc intersect)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectFunction1);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectFunction(intersect,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectFunction4 (RTCScene scene, unsigned geomID, RTCIntersectFunc4 intersect)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectFunction4);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectFunction4(intersect,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectFunction8 (RTCScene scene, unsigned geomID, RTCIntersectFunc8 intersect)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectFunction8);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectFunction8(intersect,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectFunction16 (RTCScene scene, unsigned geomID, RTCIntersectFunc16 intersect)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectFunction16);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectFunction16(intersect,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOccludedFunction1 (RTCScene scene, unsigned geomID, RTCOccludedFunc occluded)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOccludedFunction1);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOccludedFunction(occluded,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOccludedFunction4 (RTCScene scene, unsigned geomID, RTCOccludedFunc4 occluded)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOccludedFunction4);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOccludedFunction4(occluded,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOccludedFunction8 (RTCScene scene, unsigned geomID, RTCOccludedFunc8 occluded)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOccludedFunction8);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOccludedFunction8(occluded,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOccludedFunction16 (RTCScene scene, unsigned geomID, RTCOccludedFunc16 occluded)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOccludedFunction16);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOccludedFunction16(occluded,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectionFilterFunction1 (RTCScene scene, unsigned geomID, RTCFilterFunc filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectionFilterFunction1);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectionFilterFunction(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectionFilterFunction4 (RTCScene scene, unsigned geomID, RTCFilterFunc4 filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectionFilterFunction4);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectionFilterFunction4(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectionFilterFunction8 (RTCScene scene, unsigned geomID, RTCFilterFunc8 filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectionFilterFunction8);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectionFilterFunction8(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetIntersectionFilterFunction16 (RTCScene scene, unsigned geomID, RTCFilterFunc16 filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetIntersectionFilterFunction16);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setIntersectionFilterFunction16(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOcclusionFilterFunction1 (RTCScene scene, unsigned geomID, RTCFilterFunc filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOcclusionFilterFunction1);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOcclusionFilterFunction(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOcclusionFilterFunction4 (RTCScene scene, unsigned geomID, RTCFilterFunc4 filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOcclusionFilterFunction4);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOcclusionFilterFunction4(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOcclusionFilterFunction8 (RTCScene scene, unsigned geomID, RTCFilterFunc8 filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOcclusionFilterFunction8);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOcclusionFilterFunction8(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" void ispcSetOcclusionFilterFunction16 (RTCScene scene, unsigned geomID, RTCFilterFunc16 filter)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetOcclusionFilterFunction16);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setOcclusionFilterFunction16(filter,true);
|
|
CATCH_END;
|
|
}
|
|
|
|
extern "C" unsigned ispcNewSubdivisionMesh (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) {
|
|
return rtcNewSubdivisionMesh((RTCScene)scene,flags,numFaces,numEdges,numVertices,numEdgeCreases,numVertexCreases,numHoles,numTimeSteps);
|
|
}
|
|
|
|
extern "C" void ispcSetDisplacementFunction (RTCScene scene, unsigned int geomID, void* func, RTCBounds* bounds)
|
|
{
|
|
CATCH_BEGIN;
|
|
TRACE(rtcSetDisplacementFunction);
|
|
VERIFY_HANDLE(scene);
|
|
VERIFY_GEOMID(geomID);
|
|
((Scene*)scene)->get(geomID)->setDisplacementFunction((RTCDisplacementFunc)func,bounds);
|
|
CATCH_END;
|
|
}
|
|
|
|
}
|