Date: Sunday, July 29, 2018 @ 15:15:59 Author: heftig Revision: 364831
1.6-17: python 3.7 Added: luxrender/trunk/no-lib64.diff luxrender/trunk/py3.7.diff Modified: luxrender/trunk/PKGBUILD ---------------+ PKGBUILD | 21 + no-lib64.diff | 11 py3.7.diff | 618 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 641 insertions(+), 9 deletions(-) Modified: PKGBUILD =================================================================== --- PKGBUILD 2018-07-29 15:08:56 UTC (rev 364830) +++ PKGBUILD 2018-07-29 15:15:59 UTC (rev 364831) @@ -5,7 +5,7 @@ pkgname=luxrender pkgver=1.6 _pkgver=b3f85cf7742f -pkgrel=16 +pkgrel=17 pkgdesc="Rendering system for physically correct, unbiased image synthesis" arch=('x86_64') url="http://www.luxrender.net/" @@ -15,11 +15,13 @@ 'python: pylux Python interface') makedepends=('cmake' 'boost' 'mesa' 'qt4' "luxrays=$pkgver" 'python' 'opencl-headers') source=($pkgname-$pkgver.tar.bz2::https://bitbucket.org/luxrender/lux/get/v${pkgver/./}.tar.bz2 \ - force_python3.diff luxrender-gcc7.patch fix_deprecated_native.diff) + force_python3.diff luxrender-gcc7.patch fix_deprecated_native.diff no-lib64.diff py3.7.diff) sha256sums=('29144f657087644086928a66421df5d25fc4dccd05970200932f5693650ddecf' '916a45aec1326e6990c1ff9f141080c17a33ed793c44d1af9a2dacb9b21c19d2' 'e51e33ac85c247696a0cab7751b5e91a23df5dac45af05b9ee68299e4a37dc6d' - '0a35caff0cb72fb57c13ba932403849b9280f56506676d0144eceaf13e470209') + '0a35caff0cb72fb57c13ba932403849b9280f56506676d0144eceaf13e470209' + '6172c8dc1616dd5e396f1c9dc538f74a62959a818690839ea700db19745c13dc' + 'e1b86f3d678f765ff22001db388c6e12cdd342d1771dc5247d061590164d8a9f') prepare() { cd "$srcdir"/luxrender-lux-$_pkgver @@ -29,6 +31,10 @@ patch -Np1 < ../luxrender-gcc7.patch # fix build with boost 1.66 (the deprecated native() method was removed) patch -Np1 < ../fix_deprecated_native.diff + # fix library path on x86_64 + patch -Np1 < ../no-lib64.diff + # fix for python 3.7 + patch -Np1 < ../py3.7.diff } build() { @@ -39,8 +45,8 @@ -DCMAKE_INSTALL_PREFIX=/usr \ -DLUXRAYS_DISABLE_OPENCL=OFF \ -DPYTHON_CUSTOM=ON \ - -DPYTHON_LIBRARIES=/usr/lib/libpython3.6m.so \ - -DPYTHON_INCLUDE_PATH=/usr/include/python3.6m/ \ + -DPYTHON_LIBRARIES=/usr/lib/libpython3.7m.so \ + -DPYTHON_INCLUDE_PATH=/usr/include/python3.7m/ \ -DCMAKE_EXE_LINKER_FLAGS=-lpthread make } @@ -49,11 +55,8 @@ cd "$srcdir"/luxrender-lux-$_pkgver make DESTDIR="$pkgdir" install - # fix library path on x86_64 - [ "$CARCH" = "x86_64" ] && mv "$pkgdir"/usr/lib64 "$pkgdir"/usr/lib - # install pylux - install -D -m644 pylux.so "$pkgdir"/usr/lib/python3.6/pylux.so + install -D -m644 pylux.so "$pkgdir"/usr/lib/python3.7/site-packages/pylux.so } # vim:set ts=2 sw=2 et: Added: no-lib64.diff =================================================================== --- no-lib64.diff (rev 0) +++ no-lib64.diff 2018-07-29 15:15:59 UTC (rev 364831) @@ -0,0 +1,11 @@ +diff -u -r luxrender-lux-b3f85cf7742f/CMakeLists.txt luxrender-lux-b3f85cf7742f-lib/CMakeLists.txt +--- luxrender-lux-b3f85cf7742f/CMakeLists.txt 2016-05-09 23:21:17.000000000 +0200 ++++ luxrender-lux-b3f85cf7742f-lib/CMakeLists.txt 2018-07-29 16:09:18.682728166 +0200 +@@ -224,7 +224,6 @@ + STRING(REGEX MATCH "(x86_64-*)|(X86_64-*)|(AMD64-*)|(amd64-*)" _mach_x86_64 ${MACHINE}) + IF (_mach_x86_64) + SET(ARCH_X86_64 1) +- SET(LIB_SUFFIX 64) + #jromang - Hack to avoid boost bug on x64 Ubuntu 8.10 and Fedora 10 (http://www.luxrender.net/mantis/view.php?id=433) + ADD_DEFINITIONS(-DBOOST_NO_INTRINSIC_INT64_T) + ENDIF (_mach_x86_64) Added: py3.7.diff =================================================================== --- py3.7.diff (rev 0) +++ py3.7.diff 2018-07-29 15:15:59 UTC (rev 364831) @@ -0,0 +1,618 @@ +diff -u -r luxrender-lux-b3f85cf7742f/python/binding.cpp luxrender-lux-b3f85cf7742f-py3.7/python/binding.cpp +--- luxrender-lux-b3f85cf7742f/python/binding.cpp 2016-05-09 23:21:17.000000000 +0200 ++++ luxrender-lux-b3f85cf7742f-py3.7/python/binding.cpp 2018-07-29 17:01:42.325353797 +0200 +@@ -193,7 +193,7 @@ + + + // Add definitions given in other header files +- export_PyContext(); ++ export_PyLuxContext(); + export_PyDynload(); + export_PyFlexImageFilm(); + // export_PyRenderer(); +diff -u -r luxrender-lux-b3f85cf7742f/python/pycontext.h luxrender-lux-b3f85cf7742f-py3.7/python/pycontext.h +--- luxrender-lux-b3f85cf7742f/python/pycontext.h 2016-05-09 23:21:17.000000000 +0200 ++++ luxrender-lux-b3f85cf7742f-py3.7/python/pycontext.h 2018-07-29 17:03:05.042267372 +0200 +@@ -359,13 +359,13 @@ + } + + /* +- * PyContext class ++ * PyLuxContext class + */ + +-class PyContext ++class PyLuxContext + { + public: +- PyContext(std::string _name) ++ PyLuxContext(std::string _name) + { + //System wide init + boost::call_once(&luxInit, luxInitFlag); +@@ -376,7 +376,7 @@ + // LOG(LUX_INFO,LUX_NOERROR)<<"Created new context : '"<<name<<"'"; + } + +- ~PyContext() ++ ~PyLuxContext() + { + //destroy threads + BOOST_FOREACH(boost::thread *t,pyLuxWorldEndThreads) +@@ -802,7 +802,7 @@ + void worldEnd() //launch luxWorldEnd() into a thread + { + checkActiveContext(); +- pyLuxWorldEndThreads.push_back(new boost::thread( boost::bind(&PyContext::pyWorldEnd, this) )); ++ pyLuxWorldEndThreads.push_back(new boost::thread( boost::bind(&PyLuxContext::pyWorldEnd, this) )); + } + + void loadFLM(const char* name) +@@ -1363,472 +1363,472 @@ + fb_type->tp_as_sequence = &float_buffer_as_sequence; + } + +-// Add PyContext class to pylux module definition +-void export_PyContext() ++// Add PyLuxContext class to pylux module definition ++void export_PyLuxContext() + { + using namespace boost::python; + using namespace lux; + + export_float_buffer(); + +- class_<PyContext>( ++ class_<PyLuxContext>( + "Context", + ds_pylux_Context, + init<std::string>(args("Context", "name"), ds_pylux_Context_init) + ) + .def_readonly("name", +- &PyContext::name ++ &PyLuxContext::name + ) + .def("__repr__", +- &PyContext::repr, ++ &PyLuxContext::repr, + args("Context") + ) + .def("accelerator", +- &PyContext::accelerator, ++ &PyLuxContext::accelerator, + args("Context", "type", "ParamSet"), + ds_pylux_Context_accelerator + ) + .def("addServer", +- &PyContext::addServer, ++ &PyLuxContext::addServer, + args("Context", "address"), + ds_pylux_Context_addServer + ) + .def("addThread", +- &PyContext::addThread, ++ &PyLuxContext::addThread, + args("Context"), + ds_pylux_Context_addThread + ) + .def("areaLightSource", +- &PyContext::areaLightSource, ++ &PyLuxContext::areaLightSource, + args("Context", "type", "ParamSet"), + ds_pylux_Context_areaLightSource + ) + .def("attributeBegin", +- &PyContext::attributeBegin, ++ &PyLuxContext::attributeBegin, + args("Context"), + ds_pylux_Context_attributeBegin + ) + .def("attributeEnd", +- &PyContext::attributeEnd, ++ &PyLuxContext::attributeEnd, + args("Context"), + ds_pylux_Context_attributeEnd + ) + .def("blenderCombinedDepthBuffers", +- &PyContext::blenderCombinedDepthBuffers, ++ &PyLuxContext::blenderCombinedDepthBuffers, + args("Context"), + "Blender framebuffer fetcher method; returns combined Color+Alpha and Depth buffers in bottom-up format as Python buffers" + ) + .def("blenderCombinedDepthRects", +- &PyContext::blenderCombinedDepthRects, ++ &PyLuxContext::blenderCombinedDepthRects, + args("Context"), + "Blender framebuffer fetcher method; returns combined Color+Alpha and Depth buffers in bottom-up format" + ) + .def("camera", +- &PyContext::camera, ++ &PyLuxContext::camera, + args("Context", "type", "ParamSet"), + ds_pylux_Context_camera + ) + .def("cleanup", +- &PyContext::cleanup, ++ &PyLuxContext::cleanup, + args("Context"), + ds_pylux_Context_cleanup + ) + .def("concatTransform", +- &PyContext::concatTransform, ++ &PyLuxContext::concatTransform, + args("Context", "transform"), + ds_pylux_Context_concatTransform + ) + .def("coordSysTransform", +- &PyContext::coordSysTransform, ++ &PyLuxContext::coordSysTransform, + args("Context", "name"), + ds_pylux_Context_coordSysTransform + ) + .def("coordinateSystem", +- &PyContext::coordinateSystem, ++ &PyLuxContext::coordinateSystem, + args("Context", "name"), + ds_pylux_Context_coordinateSystem + ) + .def("disableRandomMode", +- &PyContext::disableRandomMode, ++ &PyLuxContext::disableRandomMode, + args("Context"), + ds_pylux_Context_disableRandomMode + ) + .def("enableDebugMode", +- &PyContext::enableDebugMode, ++ &PyLuxContext::enableDebugMode, + args("Context"), + ds_pylux_Context_enableDebugMode + ) + .def("exit", +- &PyContext::exit, ++ &PyLuxContext::exit, + args("Context"), + ds_pylux_Context_exit + ) + .def("exterior", +- &PyContext::exterior, ++ &PyLuxContext::exterior, + args("Context", "VolumeName"), + ds_pylux_Context_exterior + ) + .def("film", +- &PyContext::film, ++ &PyLuxContext::film, + args("Context", "type", "ParamSet"), + ds_pylux_Context_film + ) + .def("framebuffer", +- &PyContext::framebuffer, ++ &PyLuxContext::framebuffer, + args("Context"), + ds_pylux_Context_framebuffer + ) + .def("floatFramebuffer", +- &PyContext::floatFramebuffer, ++ &PyLuxContext::floatFramebuffer, + args("Context"), + ds_pylux_Context_floatframebuffer + ) + .def("alphaBuffer", +- &PyContext::alphaBuffer, ++ &PyLuxContext::alphaBuffer, + args("Context"), + ds_pylux_Context_alphabuffer + ) + .def("zBuffer", +- &PyContext::zBuffer, ++ &PyLuxContext::zBuffer, + args("Context"), + ds_pylux_Context_zbuffer + ) + .def("getDefaultParameterValue", +- &PyContext::getDefaultParameterValue, ++ &PyLuxContext::getDefaultParameterValue, + args("Context", "component", "parameter", "index"), + ds_pylux_Context_getDefaultParameterValue + ) + .def("getDefaultStringParameterValue", +- &PyContext::getDefaultStringParameterValue, ++ &PyLuxContext::getDefaultStringParameterValue, + args("Context"), + ds_pylux_Context_getDefaultStringParameterValue + ) + .def("getHistogramImage", +- &PyContext::getHistogramImage, ++ &PyLuxContext::getHistogramImage, + args("Context", "width", "height", "options"), + ds_pylux_Context_getHistogramImage + ) + .def("getNetworkServerUpdateInterval", +- &PyContext::getNetworkServerUpdateInterval, ++ &PyLuxContext::getNetworkServerUpdateInterval, + args("Context"), + ds_pylux_Context_getNetworkServerUpdateInterval + ) + .def("getAttribute", +- &PyContext::getAttribute, ++ &PyLuxContext::getAttribute, + args("Context"), + ds_pylux_Context_getAttribute + ) + .def("getAttributes", +- &PyContext::getAttributes, ++ &PyLuxContext::getAttributes, + args("Context"), + ds_pylux_Context_getAttributes + ) + .def("getParameterValue", +- &PyContext::getParameterValue, ++ &PyLuxContext::getParameterValue, + args("Context", "component", "parameter", "index"), + ds_pylux_Context_getParameterValue + ) + .def("getRenderingServersStatus", +- &PyContext::getRenderingServersStatus, ++ &PyLuxContext::getRenderingServersStatus, + args("Context"), + ds_pylux_Context_getRenderingServersStatus + ) + .def("getServerCount", +- &PyContext::getServerCount, ++ &PyLuxContext::getServerCount, + args("Context"), + ds_pylux_Context_getServerCount + ) + .def("getStringParameterValue", +- &PyContext::getStringParameterValue, ++ &PyLuxContext::getStringParameterValue, + args("Context"), + ds_pylux_Context_getStringParameterValue + ) + .def("identity", +- &PyContext::identity, ++ &PyLuxContext::identity, + args("Context"), + ds_pylux_Context_identity + ) + .def("interior", +- &PyContext::interior, ++ &PyLuxContext::interior, + args("Context", "VolumeName"), + ds_pylux_Context_interior + ) + .def("lightGroup", +- &PyContext::lightGroup, ++ &PyLuxContext::lightGroup, + args("Context", "name", "ParamSet"), + ds_pylux_Context_lightGroup + ) + .def("lightSource", +- &PyContext::lightSource, ++ &PyLuxContext::lightSource, + args("Context", "type", "ParamSet"), + ds_pylux_Context_lightSource + ) + .def("loadFLM", +- &PyContext::loadFLM, ++ &PyLuxContext::loadFLM, + args("Context", "filename"), + ds_pylux_Context_loadFLM + ) + .def("lookAt", +- &PyContext::lookAt, ++ &PyLuxContext::lookAt, + args("Context", "pos0", "pos1", "pos2", "trg0", "trg1", "trg2", "up0", "up1", "up2"), + ds_pylux_Context_lookAt + ) + .def("makeNamedMaterial", +- &PyContext::makeNamedMaterial, ++ &PyLuxContext::makeNamedMaterial, + args("Context", "name", "ParamSet"), + ds_pylux_Context_makeNamedMaterial + ) + .def("makeNamedVolume", +- &PyContext::makeNamedVolume, ++ &PyLuxContext::makeNamedVolume, + args("Context", "name", "type", "ParamSet"), + ds_pylux_Context_makeNamedVolume + ) + .def("material", +- &PyContext::material, ++ &PyLuxContext::material, + args("Context", "type", "ParamSet"), + ds_pylux_Context_material + ) + .def("motionBegin", +- &PyContext::motionBegin, ++ &PyLuxContext::motionBegin, + args("Context"), + ds_pylux_Context_motionBegin + ) + .def("motionEnd", +- &PyContext::motionEnd, ++ &PyLuxContext::motionEnd, + args("Context"), + ds_pylux_Context_motionEnd + ) + .def("motionInstance", +- &PyContext::motionInstance, ++ &PyLuxContext::motionInstance, + args("Context"), + ds_pylux_Context_motionInstance + ) + .def("namedMaterial", +- &PyContext::namedMaterial, ++ &PyLuxContext::namedMaterial, + args("Context", "name"), + ds_pylux_Context_namedMaterial + ) + .def("objectBegin", +- &PyContext::objectBegin, ++ &PyLuxContext::objectBegin, + args("Context", "name"), + ds_pylux_Context_objectBegin + ) + .def("objectEnd", +- &PyContext::objectEnd, ++ &PyLuxContext::objectEnd, + args("Context"), + ds_pylux_Context_objectEnd + ) + .def("objectInstance", +- &PyContext::objectInstance, ++ &PyLuxContext::objectInstance, + args("Context", "name"), + ds_pylux_Context_objectInstance + ) + .def("overrideResumeFLM", +- &PyContext::overrideResumeFLM, ++ &PyLuxContext::overrideResumeFLM, + args("Context"), + ds_pylux_Context_overrideResumeFLM + ) + .def("parse", +- &PyContext::parse, ++ &PyLuxContext::parse, + args("Context", "filename", "asynchronous"), + ds_pylux_Context_parse + ) + .def("parsePartial", +- &PyContext::parsePartial, ++ &PyLuxContext::parsePartial, + args("Context", "filename", "asynchronous"), + ds_pylux_Context_parsePartial + ) + .def("parseSuccessful", +- &PyContext::parseSuccessful, ++ &PyLuxContext::parseSuccessful, + args("Context") + ) + .def("pause", +- &PyContext::pause, ++ &PyLuxContext::pause, + args("Context"), + ds_pylux_Context_pause + ) + .def("renderer", +- &PyContext::renderer, ++ &PyLuxContext::renderer, + args("Context", "type", "ParamSet"), + ds_pylux_Context_renderer + ) + .def("pixelFilter", +- &PyContext::pixelFilter, ++ &PyLuxContext::pixelFilter, + args("Context", "type", "ParamSet"), + ds_pylux_Context_pixelFilter + ) + .def("portalShape", +- &PyContext::portalShape, ++ &PyLuxContext::portalShape, + args("Context", "type", "ParamSet"), + ds_pylux_Context_portalShape + ) + .def("portalInstance", +- &PyContext::portalInstance, ++ &PyLuxContext::portalInstance, + args("Context", "name"), + ds_pylux_Context_portalInstance + ) + .def("removeServer", +- &PyContext::removeServer, ++ &PyLuxContext::removeServer, + args("Context", "address"), + ds_pylux_Context_removeServer + ) + .def("removeThread", +- &PyContext::removeThread, ++ &PyLuxContext::removeThread, + args("Context"), + ds_pylux_Context_removeThread + ) + .def("resetServer", +- &PyContext::resetServer, ++ &PyLuxContext::resetServer, + args("Context", "address", "password"), + ds_pylux_Context_resetServer + ) + .def("reverseOrientation", +- &PyContext::reverseOrientation, ++ &PyLuxContext::reverseOrientation, + args("Context"), + ds_pylux_Context_reverseOrientation + ) + .def("rotate", +- &PyContext::rotate, ++ &PyLuxContext::rotate, + args("Context", "degrees", "x", "y", "z"), + ds_pylux_Context_rotate + ) + .def("sampler", +- &PyContext::sampler, ++ &PyLuxContext::sampler, + args("Context", "type", "ParamSet"), + ds_pylux_Context_sampler + ) + .def("saveFLM", +- &PyContext::saveFLM, ++ &PyLuxContext::saveFLM, + args("Context", "filename"), + ds_pylux_Context_saveFLM + ) + .def("saveEXR", +- &PyContext::saveEXR, ++ &PyLuxContext::saveEXR, + args("Context", "filename", "useHalfFloat", "includeZBuffer", "tonemapped"), + ds_pylux_Context_saveEXR + ) + .def("scale", +- &PyContext::scale, ++ &PyLuxContext::scale, + args("Context", "x", "y", "z"), + ds_pylux_Context_scale + ) + .def("setEpsilon", +- &PyContext::setEpsilon, ++ &PyLuxContext::setEpsilon, + args("Context"), + ds_pylux_Context_setEpsilon + ) + .def("setHaltSamplesPerPixel", +- &PyContext::setHaltSamplesPerPixel, ++ &PyLuxContext::setHaltSamplesPerPixel, + args("Context"), + ds_pylux_Context_setHaltSamplesPerPixel + ) + .def("setNetworkServerUpdateInterval", +- &PyContext::setNetworkServerUpdateInterval, ++ &PyLuxContext::setNetworkServerUpdateInterval, + args("Context"), + ds_pylux_Context_setNetworkServerUpdateInterval + ) + .def("setAttribute", +- &PyContext::setAttribute, ++ &PyLuxContext::setAttribute, + args("Context"), + ds_pylux_Context_setAttribute + ) + .def("setParameterValue", +- &PyContext::setParameterValue, ++ &PyLuxContext::setParameterValue, + args("Context"), + ds_pylux_Context_setParameterValue + ) + .def("setStringParameterValue", +- &PyContext::setStringParameterValue, ++ &PyLuxContext::setStringParameterValue, + args("Context"), + ds_pylux_Context_setStringParameterValue + ) + .def("shape", +- &PyContext::shape, ++ &PyLuxContext::shape, + args("Context", "type", "ParamSet"), + ds_pylux_Context_shape + ) + .def("start", +- &PyContext::start, ++ &PyLuxContext::start, + args("Context"), + ds_pylux_Context_start + ) + .def("statistics", +- &PyContext::statistics, ++ &PyLuxContext::statistics, + args("Context", "name"), + ds_pylux_Context_statistics + ) + .def("printableStatistics", +- &PyContext::printableStatistics, ++ &PyLuxContext::printableStatistics, + args("Context", "add_total"), + ds_pylux_Context_printable_statistics + ) + .def("updateStatisticsWindow", +- &PyContext::updateStatisticsWindow, ++ &PyLuxContext::updateStatisticsWindow, + args("Context"), + ds_pylux_Context_update_statistics_window + ) + .def("surfaceIntegrator", +- &PyContext::surfaceIntegrator, ++ &PyLuxContext::surfaceIntegrator, + args("Context", "type", "ParamSet"), + ds_pylux_Context_surfaceIntegrator + ) + .def("texture", +- &PyContext::texture, ++ &PyLuxContext::texture, + args("Context", "name", "variant", "type", "ParamSet"), + ds_pylux_Context_texture + ) + .def("transform", +- &PyContext::transform, ++ &PyLuxContext::transform, + args("Context", "transform"), + ds_pylux_Context_transform + ) + .def("transformBegin", +- &PyContext::transformBegin, ++ &PyLuxContext::transformBegin, + args("Context"), + ds_pylux_Context_transformBegin + ) + .def("transformEnd", +- &PyContext::transformEnd, ++ &PyLuxContext::transformEnd, + args("Context"), + ds_pylux_Context_transformEnd + ) + .def("translate", +- &PyContext::translate, ++ &PyLuxContext::translate, + args("Context", "x", "y", "z"), + ds_pylux_Context_translate + ) + .def("updateFilmFromNetwork", +- &PyContext::updateFilmFromNetwork, ++ &PyLuxContext::updateFilmFromNetwork, + args("Context"), + ds_pylux_Context_updateFilmFromNetwork + ) + .def("updateFramebuffer", +- &PyContext::updateFramebuffer, ++ &PyLuxContext::updateFramebuffer, + args("Context"), + ds_pylux_Context_updateFramebuffer + ) + .def("volume", +- &PyContext::volume, ++ &PyLuxContext::volume, + args("Context", "type", "ParamSet"), + ds_pylux_Context_volume + ) + .def("volumeIntegrator", +- &PyContext::volumeIntegrator, ++ &PyLuxContext::volumeIntegrator, + args("Context", "type", "ParamSet"), + ds_pylux_Context_volumeIntegrator + ) + .def("wait", +- &PyContext::wait, ++ &PyLuxContext::wait, + args("Context"), + ds_pylux_Context_wait + ) + .def("worldBegin", +- &PyContext::worldBegin, ++ &PyLuxContext::worldBegin, + args("Context"), + ds_pylux_Context_worldBegin + ) + .def("worldEnd", +- &PyContext::worldEnd, ++ &PyLuxContext::worldEnd, + args("Context"), + ds_pylux_Context_worldEnd + )