00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #include "api.h"
00026 #include "context.h"
00027 #include "paramset.h"
00028 #include "error.h"
00029
00030 #include <boost/date_time/posix_time/posix_time.hpp>
00031 #include <vector>
00032 #include <cstdarg>
00033
00034 using namespace lux;
00035
00036 #define EXTRACT_PARAMETERS(_start) \
00037 va_list pArgs; \
00038 va_start( pArgs, _start ); \
00039 \
00040 std::vector<LuxToken> aTokens; \
00041 std::vector<LuxPointer> aValues; \
00042 int count = buildParameterList( pArgs, aTokens, aValues );
00043
00044 #define PASS_PARAMETERS \
00045 count, aTokens.size()>0?&aTokens[0]:0, aValues.size()>0?&aValues[0]:0
00046
00047 namespace lux
00048 {
00049
00050
00051
00052
00053
00054
00055 int buildParameterList( va_list pArgs, std::vector<LuxToken>& aTokens, std::vector<LuxPointer>& aValues )
00056 {
00057 int count = 0;
00058 LuxToken pToken = va_arg( pArgs, LuxToken );
00059 LuxPointer pValue;
00060 aTokens.clear();
00061 aValues.clear();
00062 while ( pToken != 0 && pToken != LUX_NULL )
00063 {
00064 aTokens.push_back( pToken );
00065 pValue = va_arg( pArgs, LuxPointer );
00066 aValues.push_back( pValue );
00067 pToken = va_arg( pArgs, LuxToken );
00068 count++;
00069 }
00070 return ( count );
00071 }
00072
00073 }
00074
00075 static bool initialized = false;
00076
00077
00078
00079
00080 extern "C" void luxAddServer(const char * name)
00081 {
00082 Context::luxAddServer(std::string(name));
00083 }
00084
00085 extern "C" void luxRemoveServer(const char * name)
00086 {
00087 Context::luxRemoveServer(std::string(name));
00088 }
00089
00090 extern "C" int luxGetServerCount()
00091 {
00092 return Context::luxGetServerCount();
00093 }
00094
00095 extern "C" int luxGetRenderingServersStatus(RenderingServerInfo *info, int maxInfoCount) {
00096 return Context::luxGetRenderingServersStatus(info, maxInfoCount);
00097 }
00098
00099 extern "C" void luxCleanup()
00100 {
00101
00102
00103 if (initialized == true)
00104 Context::luxCleanup();
00105 else
00106 luxError(LUX_NOTSTARTED, LUX_ERROR, "luxCleanup() called without luxInit().");
00107 }
00108
00109 extern "C" void luxIdentity()
00110 {
00111 Context::luxIdentity();
00112 }
00113 extern "C" void luxTranslate(float dx, float dy, float dz)
00114 {
00115 Context::luxTranslate(dx,dy,dz);
00116 }
00117 extern "C" void luxTransform(float tr[16])
00118 {
00119 Context::luxTransform(tr);
00120 }
00121 extern "C" void luxConcatTransform(float tr[16]) {
00122 Context::luxConcatTransform(tr);
00123 }
00124 extern "C" void luxRotate(float angle, float dx, float dy, float dz)
00125 {
00126 Context::luxRotate(angle,dx,dy,dz);
00127 }
00128 extern "C" void luxScale(float sx, float sy, float sz)
00129 {
00130 Context::luxScale(sx,sy,sz);
00131 }
00132 extern "C" void luxLookAt(float ex, float ey, float ez, float lx, float ly, float lz,
00133 float ux, float uy, float uz)
00134 {
00135 Context::luxLookAt(ex, ey, ez, lx, ly, lz, ux, uy, uz);
00136 }
00137 extern "C" void luxCoordinateSystem(const char *name)
00138 {
00139 Context::luxCoordinateSystem(std::string(name));
00140 }
00141 extern "C" void luxCoordSysTransform(const char *name)
00142 {
00143 Context::luxCoordSysTransform(std::string(name));
00144 }
00145 extern "C" void luxPixelFilter(const char *name, ...)
00146 {
00147 EXTRACT_PARAMETERS( name )
00148 luxPixelFilterV( name, PASS_PARAMETERS );
00149 }
00150
00151 extern "C" void luxPixelFilterV (const char *name, int n, LuxToken tokens[], LuxPointer params[])
00152 {
00153
00154
00155 Context::luxPixelFilter(name,ParamSet(n,name,tokens,params));
00156 }
00157
00158
00159
00160
00161
00162
00163 extern "C" void luxFilm(const char *name, ...)
00164 {
00165 EXTRACT_PARAMETERS( name )
00166 luxFilmV( name, PASS_PARAMETERS );
00167 }
00168
00169 extern "C" void luxFilmV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00170 {
00171 Context::luxFilm(name,ParamSet(n,name,tokens,params));
00172 }
00173
00174
00175
00176
00177
00178
00179
00180
00181 extern "C" void luxSampler(const char *name, ...)
00182 {
00183 EXTRACT_PARAMETERS( name )
00184 luxSamplerV( name, PASS_PARAMETERS );
00185 }
00186
00187 extern "C" void luxSamplerV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00188 {
00189 Context::luxSampler(name,ParamSet(n,name,tokens,params));
00190 }
00191
00192
00193
00194
00195
00196
00197 extern "C" void luxAccelerator(const char *name, ...)
00198 {
00199 EXTRACT_PARAMETERS( name )
00200 luxAcceleratorV( name, PASS_PARAMETERS );
00201 }
00202
00203 extern "C" void luxAcceleratorV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00204 {
00205 Context::luxAccelerator(name,ParamSet(n,name,tokens,params));
00206 }
00207
00208
00209
00210
00211
00212 extern "C" void luxSurfaceIntegrator(const char *name, ...)
00213 {
00214 EXTRACT_PARAMETERS( name )
00215 luxSurfaceIntegratorV( name, PASS_PARAMETERS );
00216 }
00217
00218 extern "C" void luxSurfaceIntegratorV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00219 {
00220 Context::luxSurfaceIntegrator(name,ParamSet(n,name,tokens,params));
00221 }
00222
00223
00224
00225
00226
00227
00228
00229 extern "C" void luxVolumeIntegrator(const char *name, ...)
00230 {
00231 EXTRACT_PARAMETERS( name )
00232 luxVolumeIntegratorV( name, PASS_PARAMETERS );
00233 }
00234
00235 extern "C" void luxVolumeIntegratorV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00236 {
00237 Context::luxVolumeIntegrator(name,ParamSet(n,name,tokens,params));
00238 }
00239
00240
00241
00242
00243
00244
00245
00246 extern "C" void luxCamera(const char *name, ...)
00247 {
00248 EXTRACT_PARAMETERS( name )
00249 luxCameraV( name, PASS_PARAMETERS );
00250 }
00251
00252 extern "C" void luxCameraV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00253 {
00254 Context::luxCamera(name,ParamSet(n,name,tokens,params));
00255 }
00256
00257 extern "C" void luxWorldBegin()
00258 {
00259 Context::luxWorldBegin();
00260 }
00261 extern "C" void luxAttributeBegin()
00262 {
00263 Context::luxAttributeBegin();
00264 }
00265 extern "C" void luxAttributeEnd()
00266 {
00267 Context::luxAttributeEnd();
00268 }
00269 extern "C" void luxTransformBegin()
00270 {
00271 Context::luxTransformBegin();
00272 }
00273 extern "C" void luxTransformEnd()
00274 {
00275 Context::luxTransformEnd();
00276 }
00277
00278
00279
00280
00281
00282
00283 extern "C" void luxTexture(const char *name, const char *type, const char *texname, ...)
00284 {
00285 EXTRACT_PARAMETERS( texname )
00286 luxTextureV( name, type, texname, PASS_PARAMETERS );
00287 }
00288
00289 extern "C" void luxTextureV(const char *name, const char *type, const char *texname, int n, LuxToken tokens[], LuxPointer params[])
00290 {
00291 Context::luxTexture(name,type,texname,ParamSet(n,name,tokens,params));
00292 }
00293
00294
00295
00296
00297
00298 extern "C" void luxMaterial(const char *name, ...)
00299 {
00300 EXTRACT_PARAMETERS( name )
00301 luxMaterialV( name, PASS_PARAMETERS );
00302 }
00303
00304 extern "C" void luxMaterialV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00305 {
00306 Context::luxMaterial(name,ParamSet(n,name,tokens,params));
00307 }
00308
00309 extern "C" void luxMakeNamedMaterial(const char *name, ...)
00310 {
00311 EXTRACT_PARAMETERS( name )
00312 luxMakeNamedMaterialV( name, PASS_PARAMETERS );
00313 }
00314
00315 extern "C" void luxMakeNamedMaterialV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00316 {
00317 Context::luxMakeNamedMaterial(name,ParamSet(n,name,tokens,params));
00318 }
00319
00320 extern "C" void luxNamedMaterial(const char *name, ...)
00321 {
00322 EXTRACT_PARAMETERS( name )
00323 luxNamedMaterialV( name, PASS_PARAMETERS );
00324 }
00325
00326 extern "C" void luxNamedMaterialV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00327 {
00328 Context::luxNamedMaterial(name,ParamSet(n,name,tokens,params));
00329 }
00330
00331
00332
00333
00334
00335 extern "C" void luxLightSource(const char *name, ...)
00336 {
00337 EXTRACT_PARAMETERS( name )
00338 luxLightSourceV( name, PASS_PARAMETERS );
00339 }
00340
00341 extern "C" void luxLightSourceV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00342 {
00343 Context::luxLightSource(name,ParamSet(n,name,tokens,params));
00344 }
00345
00346
00347
00348
00349
00350 extern "C" void luxAreaLightSource(const char *name, ...)
00351 {
00352 EXTRACT_PARAMETERS( name )
00353 luxAreaLightSourceV( name, PASS_PARAMETERS );
00354 }
00355
00356 extern "C" void luxAreaLightSourceV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00357 {
00358 Context::luxAreaLightSource(name,ParamSet(n,name,tokens,params));
00359 }
00360
00361
00362
00363
00364
00365 extern "C" void luxPortalShape(const char *name, ...)
00366 {
00367 EXTRACT_PARAMETERS( name )
00368 luxPortalShapeV( name, PASS_PARAMETERS );
00369 }
00370
00371 extern "C" void luxPortalShapeV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00372 {
00373 Context::luxPortalShape(name,ParamSet(n,name,tokens,params));
00374 }
00375
00376
00377
00378
00379
00380 extern "C" void luxShape(const char *name, ...)
00381 {
00382 EXTRACT_PARAMETERS( name )
00383 luxShapeV( name, PASS_PARAMETERS );
00384 }
00385
00386 extern "C" void luxShapeV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00387 {
00388 Context::luxShape(name,ParamSet(n,name,tokens,params));
00389 }
00390
00391 extern "C" void luxReverseOrientation() {
00392 Context::luxReverseOrientation();
00393 }
00394
00395
00396
00397
00398 extern "C" void luxVolume(const char *name, ...)
00399 {
00400 EXTRACT_PARAMETERS( name )
00401 luxVolumeV( name, PASS_PARAMETERS );
00402 }
00403
00404 extern "C" void luxVolumeV(const char *name, int n, LuxToken tokens[], LuxPointer params[])
00405 {
00406 Context::luxVolume(name,ParamSet(n,name,tokens,params));
00407 }
00408
00409 extern "C" void luxObjectBegin(const char *name) {
00410 Context::luxObjectBegin(std::string(name));
00411 }
00412 extern "C" void luxObjectEnd() {
00413 Context::luxObjectEnd();
00414 }
00415 extern "C" void luxObjectInstance(const char *name) {
00416 Context::luxObjectInstance(std::string(name));
00417 }
00418 extern "C" void luxMotionInstance(const char *name, float startTime, float endTime, const char *toTransform) {
00419 Context::luxMotionInstance(std::string(name), startTime, endTime, std::string(toTransform));
00420 }
00421 extern "C" void luxWorldEnd() {
00422 Context::luxWorldEnd();
00423 }
00424
00425
00426 extern "C" void luxInit() {
00427
00428
00429
00430
00431
00432
00433 #ifdef FAST_INT
00434 #if defined(__linux__) && defined(__i386__)
00435 int cword = _FPU_MASK_DM | _FPU_MASK_ZM | _FPU_MASK_OM | _FPU_MASK_PM |
00436 _FPU_MASK_UM | _FPU_MASK_IM | _FPU_DOUBLE | _FPU_RC_NEAREST;
00437 _FPU_SETCW(cword);
00438 #endif
00439 #if defined(WIN32)
00440 _control87(_PC_53, MCW_PC);
00441 #endif
00442 #endif // FAST_INT
00443
00444
00445
00446 if (initialized)
00447 luxError(LUX_ILLSTATE,LUX_ERROR,"luxInit() has already been called.");
00448 else
00449 Context::setActive(new Context());
00450
00451 initialized=true;
00452 }
00453
00454
00455 extern "C" void luxLoadFLM(const char* name) {
00456 Context::luxLoadFLM( string( name ) );
00457 }
00458 extern "C" void luxSaveFLM(const char* name) {
00459 Context::luxSaveFLM( string( name ) );
00460 }
00461
00462 extern "C" void luxOverrideResumeFLM(const char *name) {
00463 Context::luxOverrideResumeFLM( string(name) );
00464 }
00465
00466
00467
00468
00469
00470
00471 extern "C" void luxStart() {
00472 Context::luxStart();
00473 }
00474
00475 extern "C" void luxPause() {
00476 Context::luxPause();
00477 }
00478
00479 extern "C" void luxExit() {
00480 Context::luxExit();
00481 }
00482
00483 extern "C" void luxWait() {
00484 Context::luxWait();
00485 }
00486
00487 extern "C" void luxSetHaltSamplePerPixel(int haltspp, bool haveEnoughSamplePerPixel,
00488 bool suspendThreadsWhenDone) {
00489 Context::luxSetHaltSamplePerPixel(haltspp, haveEnoughSamplePerPixel, suspendThreadsWhenDone);
00490 }
00491
00492 extern "C" int luxAddThread() {
00493 return Context::luxAddThread();
00494 }
00495
00496 extern "C" void luxRemoveThread() {
00497 Context::luxRemoveThread();
00498 }
00499
00500 extern "C" int luxGetRenderingThreadsStatus(RenderingThreadInfo *info, int maxInfoCount) {
00501 return Context::luxGetRenderingThreadsStatus(info, maxInfoCount);
00502 }
00503
00504
00505 extern "C" void luxUpdateFramebuffer() {
00506 Context::luxUpdateFramebuffer();
00507 }
00508
00509 extern "C" unsigned char* luxFramebuffer() {
00510 return Context::luxFramebuffer();
00511 }
00512
00513
00514 extern "C" void luxGetHistogramImage(unsigned char *outPixels, int width, int height, int options) {
00515 Context::luxGetHistogramImage(outPixels, width, height, options);
00516 }
00517
00518
00519 extern "C" void luxSetParameterValue(luxComponent comp, luxComponentParameters param, double value, int index) {
00520 return Context::luxSetParameterValue(comp, param, value, index);
00521 }
00522 extern "C" double luxGetParameterValue(luxComponent comp, luxComponentParameters param, int index) {
00523 return Context::luxGetParameterValue(comp, param, index);
00524 }
00525 extern "C" double luxGetDefaultParameterValue(luxComponent comp, luxComponentParameters param, int index) {
00526 return Context::luxGetDefaultParameterValue(comp, param, index);
00527 }
00528
00529 extern "C" void luxSetStringParameterValue(luxComponent comp, luxComponentParameters param, const char* value, int index) {
00530 return Context::luxSetStringParameterValue(comp, param, value, index);
00531 }
00532 extern "C" int luxGetStringParameterValue(luxComponent comp, luxComponentParameters param, char* dst, int dstlen, int index) {
00533 const string str = Context::luxGetStringParameterValue(comp, param, index);
00534 int nToCopy = int(str.length()) < dstlen - 1 ? int(str.length()) : dstlen - 1;
00535 strncpy(dst, str.c_str(), nToCopy);
00536 dst[nToCopy] = '\0';
00537 return str.length();
00538 }
00539 extern "C" int luxGetDefaultStringParameterValue(luxComponent comp, luxComponentParameters param, char* dst, int dstlen, int index) {
00540 const string str = Context::luxGetDefaultStringParameterValue(comp, param, index);
00541 int nToCopy = int(str.length()) < dstlen - 1 ? int(str.length()) : dstlen - 1;
00542 strncpy(dst, str.c_str(), nToCopy);
00543 dst[nToCopy] = '\0';
00544 return str.length();
00545 }
00546
00547 extern "C" double luxStatistics(const char *statName) {
00548 if(initialized) return Context::luxStatistics(statName);
00549 else
00550 {
00551 luxError(LUX_NOTSTARTED,LUX_SEVERE,"luxInit() must be called before calling 'luxStatistics'. Ignoring.");
00552 return 0;
00553 }
00554 }
00555
00556 extern "C" void luxEnableDebugMode() {
00557 Context::luxEnableDebugMode();
00558 }
00559
00560 extern "C" void luxDisableRandomMode() {
00561 Context::luxDisableRandomMode();
00562 }
00563
00564 extern "C" void luxUpdateFilmFromNetwork() {
00565
00566 Context::luxUpdateFilmFromNetwork();
00567 }
00568
00569 extern "C" void luxSetNetworkServerUpdateInterval(int updateInterval) {
00570
00571 Context::luxSetNetworkServerUpdateInterval(updateInterval);
00572 }
00573
00574 extern "C" int luxGetNetworkServerUpdateInterval() {
00575
00576 return Context::luxGetNetworkServerUpdateInterval();
00577 }
00578
00579
00580 static LuxErrorHandler luxErrorDelegate=luxErrorPrint;
00581 int luxLastError=LUX_NOERROR;
00582 int luxLogFilter = -99;
00583
00584 void luxErrorFilter(int code, int severity, const char *message) {
00585 if (severity >= luxLogFilter) {
00586 luxErrorDelegate(code, severity, message);
00587 }
00588 }
00589
00590
00591
00592 LuxErrorHandler luxError=luxErrorFilter;
00593
00594 extern "C" void luxErrorHandler(LuxErrorHandler handler) {
00595 luxErrorDelegate=handler;
00596 }
00597
00598 extern "C" void luxErrorAbort(int code, int severity, const char *message) {
00599 luxErrorPrint(code, severity, message);
00600 if (severity!=LUX_INFO)
00601 exit(code);
00602 }
00603
00604 extern "C" void luxErrorIgnore(int code, int severity, const char *message) {
00605 luxLastError=code;
00606 }
00607
00608 extern "C" void luxErrorPrintFilter(int code, int severity, const char *message) {
00609 if (severity >= luxLogFilter) {
00610 luxErrorPrint(code, severity, message);
00611 }
00612 }
00613
00614
00615 extern "C" void luxErrorPrint(int code, int severity, const char *message) {
00616 luxLastError=code;
00617 std::cerr<<"[";
00618 #ifndef WIN32 //windows does not support ANSI escape codes
00619
00620 switch (severity) {
00621 case LUX_DEBUG:
00622 std::cerr<<"\033[0;34m";
00623 break;
00624 case LUX_INFO:
00625 std::cerr<<"\033[0;32m";
00626 break;
00627 case LUX_WARNING:
00628 std::cerr<<"\033[0;33m";
00629 break;
00630 case LUX_ERROR:
00631 std::cerr<<"\033[0;31m";
00632 break;
00633 case LUX_SEVERE:
00634 std::cerr<<"\033[0;31m";
00635 break;
00636 }
00637 #endif
00638 std::cerr<<"Lux ";
00639 std::cerr<<boost::posix_time::second_clock::local_time()<<' ';
00640 switch (severity) {
00641 case LUX_DEBUG:
00642 std::cerr<<"DEBUG";
00643 break;
00644 case LUX_INFO:
00645 std::cerr<<"INFO";
00646 break;
00647 case LUX_WARNING:
00648 std::cerr<<"WARNING";
00649 break;
00650 case LUX_ERROR:
00651 std::cerr<<"ERROR";
00652 break;
00653 case LUX_SEVERE:
00654 std::cerr<<"SEVERE ERROR";
00655 break;
00656 }
00657 std::cerr<<" : "<<code;
00658 #ifndef WIN32 //windows does not support ANSI escape codes
00659 std::cerr<<"\033[0m";
00660 #endif
00661 std::cerr<<"] "<<message<<std::endl;
00662 }
00663
00664 extern "C" void luxSetEpsilon(const float minValue, const float maxValue) {
00665 Context::luxSetEpsilon(minValue, maxValue);
00666 }