Cleanup: Use nullptr everywhere in fluid code
Switched from NULL to nullptr.
This commit is contained in:
parent
37b155420b
commit
311031ecd0
|
@ -94,7 +94,7 @@ void PyArrayContainer::ExtractData(void *_pParentPyArray)
|
|||
|
||||
template<> PyArrayContainer fromPy<PyArrayContainer>(PyObject *obj)
|
||||
{
|
||||
if (PyArray_API == NULL) {
|
||||
if (PyArray_API == nullptr) {
|
||||
// python 3 uses the return value
|
||||
#if PY_VERSION_HEX >= 0x03000000
|
||||
import_array();
|
||||
|
@ -109,12 +109,12 @@ template<> PyArrayContainer fromPy<PyArrayContainer>(PyObject *obj)
|
|||
|
||||
PyArrayObject *obj_p = reinterpret_cast<PyArrayObject *>(
|
||||
PyArray_CheckFromAny(obj,
|
||||
NULL,
|
||||
nullptr,
|
||||
0,
|
||||
0,
|
||||
/*NPY_ARRAY_ENSURECOPY*/ NPY_ARRAY_C_CONTIGUOUS |
|
||||
NPY_ARRAY_ENSUREARRAY | NPY_ARRAY_NOTSWAPPED,
|
||||
NULL));
|
||||
nullptr));
|
||||
PyArrayContainer container = PyArrayContainer(obj_p);
|
||||
|
||||
return container;
|
||||
|
|
|
@ -98,13 +98,13 @@ string PbType::str() const
|
|||
vector<PbClass *> PbClass::mInstances;
|
||||
|
||||
PbClass::PbClass(FluidSolver *parent, const string &name, PyObject *obj)
|
||||
: mMutex(NULL), mParent(parent), mPyObject(obj), mName(name), mHidden(false)
|
||||
: mMutex(nullptr), mParent(parent), mPyObject(obj), mName(name), mHidden(false)
|
||||
{
|
||||
mMutex = new QMutex();
|
||||
}
|
||||
|
||||
PbClass::PbClass(const PbClass &a)
|
||||
: mMutex(NULL), mParent(a.mParent), mPyObject(0), mName("_unnamed"), mHidden(false)
|
||||
: mMutex(nullptr), mParent(a.mParent), mPyObject(0), mName("_unnamed"), mHidden(false)
|
||||
{
|
||||
mMutex = new QMutex();
|
||||
}
|
||||
|
@ -180,7 +180,7 @@ PbClass *PbClass::createPyObject(const string &classname,
|
|||
|
||||
void PbClass::checkParent()
|
||||
{
|
||||
if (getParent() == NULL) {
|
||||
if (getParent() == nullptr) {
|
||||
errMsg("New class " + mName + ": no parent given -- specify using parent=xxx !");
|
||||
}
|
||||
}
|
||||
|
|
|
@ -43,7 +43,7 @@ struct PbTypeVec {
|
|||
//! Base class for all classes exposed to Python
|
||||
class PbClass {
|
||||
public:
|
||||
PbClass(FluidSolver *parent, const std::string &name = "", PyObject *obj = NULL);
|
||||
PbClass(FluidSolver *parent, const std::string &name = "", PyObject *obj = nullptr);
|
||||
PbClass(const PbClass &a);
|
||||
virtual ~PbClass();
|
||||
|
||||
|
|
|
@ -491,7 +491,7 @@ template<> bool isPy<std::vector<float>>(PyObject *obj)
|
|||
//******************************************************************************
|
||||
// PbArgs class defs
|
||||
|
||||
PbArgs PbArgs::EMPTY(NULL, NULL);
|
||||
PbArgs PbArgs::EMPTY(nullptr, nullptr);
|
||||
|
||||
PbArgs::PbArgs(PyObject *linarg, PyObject *dict) : mLinArgs(0), mKwds(0)
|
||||
{
|
||||
|
@ -577,7 +577,7 @@ void PbArgs::check()
|
|||
|
||||
FluidSolver *PbArgs::obtainParent()
|
||||
{
|
||||
FluidSolver *solver = getPtrOpt<FluidSolver>("solver", -1, NULL);
|
||||
FluidSolver *solver = getPtrOpt<FluidSolver>("solver", -1, nullptr);
|
||||
if (solver != 0)
|
||||
return solver;
|
||||
|
||||
|
@ -585,7 +585,7 @@ FluidSolver *PbArgs::obtainParent()
|
|||
PbClass *obj = Pb::objFromPy(it->second.obj);
|
||||
|
||||
if (obj) {
|
||||
if (solver == NULL)
|
||||
if (solver == nullptr)
|
||||
solver = obj->getParent();
|
||||
}
|
||||
}
|
||||
|
@ -593,7 +593,7 @@ FluidSolver *PbArgs::obtainParent()
|
|||
PbClass *obj = Pb::objFromPy(it->obj);
|
||||
|
||||
if (obj) {
|
||||
if (solver == NULL)
|
||||
if (solver == nullptr)
|
||||
solver = obj->getParent();
|
||||
}
|
||||
}
|
||||
|
@ -616,7 +616,7 @@ PyObject *PbArgs::getItem(const std::string &key, bool strict, ArgLocker *lk)
|
|||
if (lu == mData.end()) {
|
||||
if (strict)
|
||||
errMsg("Argument '" + key + "' is not defined.");
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
PbClass *pbo = Pb::objFromPy(lu->second.obj);
|
||||
// try to lock
|
||||
|
@ -629,7 +629,7 @@ PyObject *PbArgs::getItem(size_t number, bool strict, ArgLocker *lk)
|
|||
{
|
||||
if (number >= mLinData.size()) {
|
||||
if (!strict)
|
||||
return NULL;
|
||||
return nullptr;
|
||||
stringstream s;
|
||||
s << "Argument number #" << number << " not specified.";
|
||||
errMsg(s.str());
|
||||
|
|
|
@ -139,9 +139,9 @@ template<> bool isPy<std::vector<float>>(PyObject *obj);
|
|||
//! Encapsulation of python arguments
|
||||
class PbArgs {
|
||||
public:
|
||||
PbArgs(PyObject *linargs = NULL, PyObject *dict = NULL);
|
||||
PbArgs(PyObject *linargs = nullptr, PyObject *dict = nullptr);
|
||||
~PbArgs();
|
||||
void setup(PyObject *linargs = NULL, PyObject *dict = NULL);
|
||||
void setup(PyObject *linargs = nullptr, PyObject *dict = nullptr);
|
||||
|
||||
void check();
|
||||
FluidSolver *obtainParent();
|
||||
|
@ -153,7 +153,7 @@ class PbArgs {
|
|||
|
||||
inline bool has(const std::string &key)
|
||||
{
|
||||
return getItem(key, false) != NULL;
|
||||
return getItem(key, false) != nullptr;
|
||||
}
|
||||
inline void deleteItem(const std::string &key)
|
||||
{
|
||||
|
@ -177,7 +177,7 @@ class PbArgs {
|
|||
DataElement el = {toPy(arg), false};
|
||||
mData[key] = el;
|
||||
}
|
||||
template<class T> inline T get(const std::string &key, int number = -1, ArgLocker *lk = NULL)
|
||||
template<class T> inline T get(const std::string &key, int number = -1, ArgLocker *lk = nullptr)
|
||||
{
|
||||
visit(number, key);
|
||||
PyObject *o = getItem(key, false, lk);
|
||||
|
@ -189,7 +189,7 @@ class PbArgs {
|
|||
errMsg("Argument '" + key + "' is not defined.");
|
||||
}
|
||||
template<class T>
|
||||
inline T getOpt(const std::string &key, int number, T defarg, ArgLocker *lk = NULL)
|
||||
inline T getOpt(const std::string &key, int number, T defarg, ArgLocker *lk = nullptr)
|
||||
{
|
||||
visit(number, key);
|
||||
PyObject *o = getItem(key, false, lk);
|
||||
|
@ -200,7 +200,7 @@ class PbArgs {
|
|||
return (o) ? fromPy<T>(o) : defarg;
|
||||
}
|
||||
template<class T>
|
||||
inline T *getPtrOpt(const std::string &key, int number, T *defarg, ArgLocker *lk = NULL)
|
||||
inline T *getPtrOpt(const std::string &key, int number, T *defarg, ArgLocker *lk = nullptr)
|
||||
{
|
||||
visit(number, key);
|
||||
PyObject *o = getItem(key, false, lk);
|
||||
|
@ -210,7 +210,8 @@ class PbArgs {
|
|||
o = getItem(number, false, lk);
|
||||
return o ? fromPyPtr<T>(o, &mTmpStorage) : defarg;
|
||||
}
|
||||
template<class T> inline T *getPtr(const std::string &key, int number = -1, ArgLocker *lk = NULL)
|
||||
template<class T>
|
||||
inline T *getPtr(const std::string &key, int number = -1, ArgLocker *lk = nullptr)
|
||||
{
|
||||
visit(number, key);
|
||||
PyObject *o = getItem(key, false, lk);
|
||||
|
@ -239,8 +240,8 @@ class PbArgs {
|
|||
static PbArgs EMPTY;
|
||||
|
||||
protected:
|
||||
PyObject *getItem(const std::string &key, bool strict, ArgLocker *lk = NULL);
|
||||
PyObject *getItem(size_t number, bool strict, ArgLocker *lk = NULL);
|
||||
PyObject *getItem(const std::string &key, bool strict, ArgLocker *lk = nullptr);
|
||||
PyObject *getItem(size_t number, bool strict, ArgLocker *lk = nullptr);
|
||||
|
||||
struct DataElement {
|
||||
PyObject *obj;
|
||||
|
|
|
@ -77,13 +77,13 @@ static PyMemberDef PbVec3Members[] = {
|
|||
{(char *)"x", T_FLOAT, offsetof(PbVec3, data), 0, (char *)"X"},
|
||||
{(char *)"y", T_FLOAT, offsetof(PbVec3, data) + sizeof(float), 0, (char *)"Y"},
|
||||
{(char *)"z", T_FLOAT, offsetof(PbVec3, data) + sizeof(float) * 2, 0, (char *)"Z"},
|
||||
{NULL} // Sentinel
|
||||
{nullptr} // Sentinel
|
||||
};
|
||||
|
||||
static PyMethodDef PbVec3Methods[] = {
|
||||
//{"name", (PyCFunction)Noddy_name, METH_NOARGS, "Return the name, combining the first and last
|
||||
//name" },
|
||||
{NULL} // Sentinel
|
||||
{nullptr} // Sentinel
|
||||
};
|
||||
|
||||
// operator overloads
|
||||
|
@ -240,7 +240,7 @@ static PyNumberMethods PbVec3NumberMethods = {
|
|||
#endif
|
||||
|
||||
PyTypeObject PbVec3Type = {
|
||||
PyVarObject_HEAD_INIT(NULL, 0) "manta.vec3", /* tp_name */
|
||||
PyVarObject_HEAD_INIT(nullptr, 0) "manta.vec3", /* tp_name */
|
||||
sizeof(PbVec3), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
(destructor)PbVec3Dealloc, /* tp_dealloc */
|
||||
|
@ -297,7 +297,7 @@ struct PbVec4 {
|
|||
};
|
||||
|
||||
static PyMethodDef PbVec4Methods[] = {
|
||||
{NULL} // Sentinel
|
||||
{nullptr} // Sentinel
|
||||
};
|
||||
|
||||
static PyMemberDef PbVec4Members[] = {
|
||||
|
@ -305,7 +305,7 @@ static PyMemberDef PbVec4Members[] = {
|
|||
{(char *)"y", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 1, 0, (char *)"Y"},
|
||||
{(char *)"z", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 2, 0, (char *)"Z"},
|
||||
{(char *)"t", T_FLOAT, offsetof(PbVec4, data) + sizeof(float) * 3, 0, (char *)"T"},
|
||||
{NULL} // Sentinel
|
||||
{nullptr} // Sentinel
|
||||
};
|
||||
|
||||
static void PbVec4Dealloc(PbVec4 *self)
|
||||
|
@ -352,7 +352,7 @@ static PyObject *PbVec4Repr(PbVec4 *self)
|
|||
}
|
||||
|
||||
PyTypeObject PbVec4Type = {
|
||||
PyVarObject_HEAD_INIT(NULL, 0) "manta.vec4", /* tp_name */
|
||||
PyVarObject_HEAD_INIT(nullptr, 0) "manta.vec4", /* tp_name */
|
||||
sizeof(PbVec4), /* tp_basicsize */
|
||||
0, /* tp_itemsize */
|
||||
(destructor)PbVec4Dealloc, /* tp_dealloc */
|
||||
|
@ -361,7 +361,7 @@ PyTypeObject PbVec4Type = {
|
|||
0, /* tp_setattr */
|
||||
0, /* tp_reserved */
|
||||
(reprfunc)PbVec4Repr, /* tp_repr */
|
||||
NULL, // &PbVec4NumberMethods, /* tp_as_number */
|
||||
nullptr, // &PbVec4NumberMethods, /* tp_as_number */
|
||||
0, /* tp_as_sequence */
|
||||
0, /* tp_as_mapping */
|
||||
0, /* tp_hash */
|
||||
|
|
|
@ -52,7 +52,7 @@ struct GetSet {
|
|||
|
||||
PyGetSetDef def()
|
||||
{
|
||||
PyGetSetDef def = {&name[0], getter, setter, &doc[0], NULL};
|
||||
PyGetSetDef def = {&name[0], getter, setter, &doc[0], nullptr};
|
||||
return def;
|
||||
}
|
||||
};
|
||||
|
@ -175,10 +175,10 @@ void cbDealloc(PbObject *self)
|
|||
PyObject *cbNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
|
||||
{
|
||||
PbObject *self = (PbObject *)type->tp_alloc(type, 0);
|
||||
if (self != NULL) {
|
||||
if (self != nullptr) {
|
||||
// lookup and link classdef
|
||||
self->classdef = WrapperRegistry::instance().lookup(type->tp_name);
|
||||
self->instance = NULL;
|
||||
self->instance = nullptr;
|
||||
// cout << "creating " << self->classdef->cName << endl;
|
||||
}
|
||||
else
|
||||
|
@ -233,7 +233,7 @@ ClassData *WrapperRegistry::getOrConstructClass(const string &classname)
|
|||
data->cPureName = classname.substr(0, tplIdx);
|
||||
data->cTemplate = classname.substr(tplIdx + 1, classname.find('>') - tplIdx - 1);
|
||||
}
|
||||
data->baseclass = NULL;
|
||||
data->baseclass = nullptr;
|
||||
data->constructor = cbDisableConstructor;
|
||||
mClasses[classname] = data;
|
||||
mClassList.push_back(data);
|
||||
|
@ -435,7 +435,7 @@ ClassData *WrapperRegistry::lookup(const string &name)
|
|||
if (it->first == name || it->second->cName == name)
|
||||
return it->second;
|
||||
}
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
void WrapperRegistry::cleanup()
|
||||
|
@ -510,7 +510,7 @@ void WrapperRegistry::runPreInit()
|
|||
PyObject *sys_path = PySys_GetObject((char *)"path");
|
||||
for (size_t i = 0; i < mPaths.size(); i++) {
|
||||
PyObject *path = Manta::toPy(mPaths[i]);
|
||||
if (sys_path == NULL || path == NULL || PyList_Append(sys_path, path) < 0) {
|
||||
if (sys_path == nullptr || path == nullptr || PyList_Append(sys_path, path) < 0) {
|
||||
errMsg("unable to set python path");
|
||||
}
|
||||
Py_DECREF(path);
|
||||
|
@ -531,7 +531,7 @@ PyObject *WrapperRegistry::createPyObject(const string &classname,
|
|||
errMsg("Class " + classname + " doesn't exist.");
|
||||
|
||||
// create object
|
||||
PyObject *obj = cbNew(&classdef->typeInfo, NULL, NULL);
|
||||
PyObject *obj = cbNew(&classdef->typeInfo, nullptr, nullptr);
|
||||
PbObject *self = (PbObject *)obj;
|
||||
PyObject *nkw = 0;
|
||||
|
||||
|
@ -578,8 +578,8 @@ inline PyObject *castPy(PyTypeObject *p)
|
|||
PyObject *WrapperRegistry::initModule()
|
||||
{
|
||||
// generate and terminate all method lists
|
||||
PyMethodDef sentinelFunc = {NULL, NULL, 0, NULL};
|
||||
PyGetSetDef sentinelGetSet = {NULL, NULL, NULL, NULL, NULL};
|
||||
PyMethodDef sentinelFunc = {nullptr, nullptr, 0, nullptr};
|
||||
PyGetSetDef sentinelGetSet = {nullptr, nullptr, nullptr, nullptr, nullptr};
|
||||
for (int i = 0; i < (int)mClassList.size(); i++) {
|
||||
ClassData *cls = mClassList[i];
|
||||
cls->genMethods.clear();
|
||||
|
@ -599,11 +599,11 @@ PyObject *WrapperRegistry::initModule()
|
|||
gDefaultModuleName.c_str(),
|
||||
"Bridge module to the C++ solver",
|
||||
-1,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL};
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr,
|
||||
nullptr};
|
||||
// get generic methods (plugin functions)
|
||||
MainModule.m_methods = &mClasses["__modclass__"]->genMethods[0];
|
||||
|
||||
|
@ -613,8 +613,8 @@ PyObject *WrapperRegistry::initModule()
|
|||
PyObject *module = Py_InitModule(gDefaultModuleName.c_str(),
|
||||
&mClasses["__modclass__"]->genMethods[0]);
|
||||
#endif
|
||||
if (module == NULL)
|
||||
return NULL;
|
||||
if (module == nullptr)
|
||||
return nullptr;
|
||||
|
||||
// load classes
|
||||
for (vector<ClassData *>::iterator it = mClassList.begin(); it != mClassList.end(); ++it) {
|
||||
|
@ -631,7 +631,7 @@ PyObject *WrapperRegistry::initModule()
|
|||
|
||||
// define python classinfo
|
||||
PyTypeObject t = {
|
||||
PyVarObject_HEAD_INIT(NULL, 0)(char *) data.pyName.c_str(), // tp_name
|
||||
PyVarObject_HEAD_INIT(nullptr, 0)(char *) data.pyName.c_str(), // tp_name
|
||||
sizeof(PbObject), // tp_basicsize
|
||||
0, // tp_itemsize
|
||||
(destructor)cbDealloc, // tp_dealloc
|
||||
|
@ -722,7 +722,7 @@ bool canConvert(PyObject *obj, const string &classname)
|
|||
Manta::PbClass *objFromPy(PyObject *obj)
|
||||
{
|
||||
if (Py_TYPE(obj)->tp_dealloc != (destructor)cbDealloc) // not a manta object
|
||||
return NULL;
|
||||
return nullptr;
|
||||
|
||||
return ((PbObject *)obj)->instance;
|
||||
}
|
||||
|
|
|
@ -270,7 +270,7 @@ inline void MTRand::seed()
|
|||
}
|
||||
|
||||
// Was not successful, so use time() and clock() instead
|
||||
seed(hash(time(NULL), clock()));
|
||||
seed(hash(time(nullptr), clock()));
|
||||
}
|
||||
|
||||
inline void MTRand::initialize(const uint32 intseed)
|
||||
|
|
|
@ -157,18 +157,18 @@ template<class N, class T> struct RCMatrix {
|
|||
{
|
||||
for (N i = 0; i < n; i++) {
|
||||
dealloc_row(i);
|
||||
matrix[i] = NULL;
|
||||
matrix[i] = nullptr;
|
||||
if (offsets.size())
|
||||
offsets[i] = 0;
|
||||
}
|
||||
};
|
||||
bool empty(N i) const
|
||||
{
|
||||
return matrix[i] == NULL;
|
||||
return matrix[i] == nullptr;
|
||||
}
|
||||
N row_nonzero_size(N i) const
|
||||
{
|
||||
return matrix[i] == NULL ? 0 : matrix[i]->index.size();
|
||||
return matrix[i] == nullptr ? 0 : matrix[i]->index.size();
|
||||
}
|
||||
void resize(N size, N expected_none_zeros = 0)
|
||||
{
|
||||
|
@ -185,7 +185,7 @@ template<class N, class T> struct RCMatrix {
|
|||
// Expanding
|
||||
matrix.resize(size);
|
||||
for (N i = n; i < size; i++) {
|
||||
matrix[i] = NULL;
|
||||
matrix[i] = nullptr;
|
||||
if (offsets.size())
|
||||
offsets[i] = 0;
|
||||
}
|
||||
|
@ -209,7 +209,7 @@ template<class N, class T> struct RCMatrix {
|
|||
if (matrix[i]) {
|
||||
if (offsets.empty() || !offsets[i])
|
||||
delete matrix[i];
|
||||
matrix[i] = NULL;
|
||||
matrix[i] = nullptr;
|
||||
if (offsets.size())
|
||||
offsets[i] = 0;
|
||||
}
|
||||
|
@ -426,7 +426,7 @@ template<class N, class T> struct RCMatrix {
|
|||
}
|
||||
operator bool() const
|
||||
{
|
||||
return rowEntry != NULL && k < (N)rowEntry->index.size();
|
||||
return rowEntry != nullptr && k < (N)rowEntry->index.size();
|
||||
}
|
||||
Iterator &operator++()
|
||||
{
|
||||
|
@ -447,7 +447,7 @@ template<class N, class T> struct RCMatrix {
|
|||
}
|
||||
N size() const
|
||||
{
|
||||
return rowEntry == NULL ? 0 : rowEntry->index.size();
|
||||
return rowEntry == nullptr ? 0 : rowEntry->index.size();
|
||||
}
|
||||
|
||||
protected:
|
||||
|
|
|
@ -35,7 +35,7 @@ bool SimpleImage::writePpm(
|
|||
}
|
||||
|
||||
FILE *fp = fopen(filename.c_str(), "wb");
|
||||
if (fp == NULL) {
|
||||
if (fp == nullptr) {
|
||||
errMsg("SimpleImage::WritePPM Unable to open '" << filename << "' for writing");
|
||||
return false;
|
||||
}
|
||||
|
@ -96,7 +96,7 @@ bool SimpleImage::initFromPpm(std::string filename)
|
|||
}
|
||||
|
||||
// 1st line: PPM or PGM
|
||||
if (fgets(line, MAXLINE, fp) == NULL) {
|
||||
if (fgets(line, MAXLINE, fp) == nullptr) {
|
||||
if (mAbortOnError)
|
||||
debMsg("SimpleImage::initFromPpm fgets failed", 1);
|
||||
return 0;
|
||||
|
@ -114,7 +114,7 @@ bool SimpleImage::initFromPpm(std::string filename)
|
|||
|
||||
// Read in width and height, & allocate space
|
||||
// 2nd line: width height
|
||||
if (fgets(line, MAXLINE, fp) == NULL) {
|
||||
if (fgets(line, MAXLINE, fp) == nullptr) {
|
||||
if (mAbortOnError)
|
||||
errMsg("SimpleImage::initFromPpm fgets failed");
|
||||
return 0;
|
||||
|
@ -156,14 +156,14 @@ bool SimpleImage::initFromPpm(std::string filename)
|
|||
|
||||
// Read in maximum value (ignore) , could be scanned with sscanf as well, but this should be
|
||||
// 255... 3rd line
|
||||
if (fgets(line, MAXLINE, fp) == NULL) {
|
||||
if (fgets(line, MAXLINE, fp) == nullptr) {
|
||||
if (mAbortOnError)
|
||||
errMsg("SimpleImage::initFromPpm fgets failed");
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Read in the pixel array row-by-row: 1st row = top scanline */
|
||||
unsigned char *ptr = NULL;
|
||||
unsigned char *ptr = nullptr;
|
||||
ptr = &pic[(windH - 1) * rowsize];
|
||||
for (int i = windH; i > 0; i--) {
|
||||
assertMsg(fread((void *)ptr, 1, rowsize, fp) == rowsize,
|
||||
|
|
|
@ -29,7 +29,7 @@ namespace Manta {
|
|||
class SimpleImage {
|
||||
public:
|
||||
// cons/des
|
||||
SimpleImage() : mSize(-1), mpData(NULL), mAbortOnError(true){};
|
||||
SimpleImage() : mSize(-1), mpData(nullptr), mAbortOnError(true){};
|
||||
virtual ~SimpleImage()
|
||||
{
|
||||
if (mpData)
|
||||
|
|
|
@ -688,7 +688,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "cgSolveDiffusion", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
|
|
@ -617,7 +617,7 @@ struct knUnprojectNormalComp : public KernelBase {
|
|||
void extrapolateMACSimple(FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
int distance = 4,
|
||||
LevelsetGrid *phiObs = NULL,
|
||||
LevelsetGrid *phiObs = nullptr,
|
||||
bool intoObs = false)
|
||||
{
|
||||
Grid<int> tmp(flags.getParent());
|
||||
|
@ -669,13 +669,13 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "extrapolateMACSimple", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
int distance = _args.getOpt<int>("distance", 2, 4, &_lock);
|
||||
LevelsetGrid *phiObs = _args.getPtrOpt<LevelsetGrid>("phiObs", 3, NULL, &_lock);
|
||||
LevelsetGrid *phiObs = _args.getPtrOpt<LevelsetGrid>("phiObs", 3, nullptr, &_lock);
|
||||
bool intoObs = _args.getOpt<bool>("intoObs", 4, false, &_lock);
|
||||
_retval = getPyNone();
|
||||
extrapolateMACSimple(flags, vel, distance, phiObs, intoObs);
|
||||
|
@ -839,7 +839,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "extrapolateMACFromWeight", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
|
@ -1092,7 +1092,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "extrapolateLsSimple", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &phi = *_args.getPtr<Grid<Real>>("phi", 0, &_lock);
|
||||
|
@ -1170,7 +1170,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "extrapolateVec3Simple", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 0, &_lock);
|
||||
|
|
|
@ -181,7 +181,7 @@ template<class T, int TDIR> class FastMarch {
|
|||
Grid<int> &fmFlags,
|
||||
Grid<Real> &levelset,
|
||||
Real maxTime,
|
||||
MACGrid *velTransport = NULL);
|
||||
MACGrid *velTransport = nullptr);
|
||||
~FastMarch()
|
||||
{
|
||||
}
|
||||
|
|
|
@ -440,7 +440,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getUniFileSize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const string &name = _args.get<string>("name", 0, &_lock);
|
||||
|
@ -479,7 +479,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "printUniFileInfoString", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const string &name = _args.get<string>("name", 0, &_lock);
|
||||
|
@ -715,7 +715,7 @@ template<> int writeGridVol<Real>(const string &name, Grid<Real> *grid)
|
|||
header.bboxMax = Vec3(0.5);
|
||||
|
||||
FILE *fp = fopen(name.c_str(), "wb");
|
||||
if (fp == NULL) {
|
||||
if (fp == nullptr) {
|
||||
errMsg("writeGridVol: Cannot open '" << name << "'");
|
||||
return 0;
|
||||
}
|
||||
|
@ -749,7 +749,7 @@ template<> int readGridVol<Real>(const string &name, Grid<Real> *grid)
|
|||
|
||||
volHeader header;
|
||||
FILE *fp = fopen(name.c_str(), "rb");
|
||||
if (fp == NULL) {
|
||||
if (fp == nullptr) {
|
||||
errMsg("readGridVol: Cannot open '" << name << "'");
|
||||
return 0;
|
||||
}
|
||||
|
@ -844,11 +844,11 @@ int readGrid4dUni(
|
|||
1);
|
||||
|
||||
#if NO_ZLIB != 1
|
||||
gzFile gzf = NULL;
|
||||
gzFile gzf = nullptr;
|
||||
char ID[5] = {0, 0, 0, 0, 0};
|
||||
|
||||
// optionally - reuse file handle, if valid one is passed in fileHandle pointer...
|
||||
if ((!fileHandle) || (fileHandle && (*fileHandle == NULL))) {
|
||||
if ((!fileHandle) || (fileHandle && (*fileHandle == nullptr))) {
|
||||
gzf = (gzFile)safeGzopen(name.c_str(), "rb");
|
||||
if (!gzf) {
|
||||
errMsg("readGrid4dUni: can't open file " << name);
|
||||
|
@ -969,11 +969,11 @@ int readGrid4dUni(
|
|||
void readGrid4dUniCleanup(void **fileHandle)
|
||||
{
|
||||
#if NO_ZLIB != 1
|
||||
gzFile gzf = NULL;
|
||||
gzFile gzf = nullptr;
|
||||
if (fileHandle) {
|
||||
gzf = (gzFile)(*fileHandle);
|
||||
gzclose(gzf);
|
||||
*fileHandle = NULL;
|
||||
*fileHandle = nullptr;
|
||||
}
|
||||
#else
|
||||
debMsg("file format not supported without zlib", 1);
|
||||
|
@ -1171,7 +1171,7 @@ int readGridsNumpy(const string &name, std::vector<PbClass *> *grids)
|
|||
|
||||
// adopted from getUniFileSize
|
||||
void getNpzFileSize(
|
||||
const string &name, int &x, int &y, int &z, int *t = NULL, std::string *info = NULL)
|
||||
const string &name, int &x, int &y, int &z, int *t = nullptr, std::string *info = nullptr)
|
||||
{
|
||||
x = y = z = 0;
|
||||
|
||||
|
@ -1207,7 +1207,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getNpzFileSize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const string &name = _args.get<string>("name", 0, &_lock);
|
||||
|
@ -1289,7 +1289,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "quantizeGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 0, &_lock);
|
||||
|
@ -1365,7 +1365,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "quantizeGridVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &grid = *_args.getPtr<Grid<Vec3>>("grid", 0, &_lock);
|
||||
|
|
|
@ -40,7 +40,7 @@ namespace Manta {
|
|||
#if defined(WIN32) || defined(_WIN32)
|
||||
static wstring stringToWstring(const char *str)
|
||||
{
|
||||
const int length_wc = MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), NULL, 0);
|
||||
const int length_wc = MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), nullptr, 0);
|
||||
wstring strWide(length_wc, 0);
|
||||
MultiByteToWideChar(CP_UTF8, 0, str, strlen(str), &strWide[0], length_wc);
|
||||
return strWide;
|
||||
|
|
|
@ -51,7 +51,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const string &name = _args.get<string>("name", 0, &_lock);
|
||||
|
@ -118,7 +118,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const string &name = _args.get<string>("name", 0, &_lock);
|
||||
|
|
|
@ -93,8 +93,8 @@ template<class T>
|
|||
int readGrid4dUni(const std::string &name,
|
||||
Grid4d<T> *grid,
|
||||
int readTslice = -1,
|
||||
Grid4d<T> *slice = NULL,
|
||||
void **fileHandle = NULL);
|
||||
Grid4d<T> *slice = nullptr,
|
||||
void **fileHandle = nullptr);
|
||||
void readGrid4dUniCleanup(void **fileHandle);
|
||||
template<class T> int writeGrid4dRaw(const std::string &name, Grid4d<T> *grid);
|
||||
template<class T> int readGrid4dRaw(const std::string &name, Grid4d<T> *grid);
|
||||
|
@ -111,8 +111,12 @@ template<class T> int writeMdataUni(const std::string &name, MeshDataImpl<T> *md
|
|||
template<class T> int readMdataUni(const std::string &name, MeshDataImpl<T> *mdata);
|
||||
|
||||
// Helpers
|
||||
void getUniFileSize(
|
||||
const std::string &name, int &x, int &y, int &z, int *t = NULL, std::string *info = NULL);
|
||||
void getUniFileSize(const std::string &name,
|
||||
int &x,
|
||||
int &y,
|
||||
int &z,
|
||||
int *t = nullptr,
|
||||
std::string *info = nullptr);
|
||||
void *safeGzopen(const char *filename, const char *mode);
|
||||
#if OPENVDB == 1
|
||||
template<class S, class T> void convertFrom(S &in, T *out);
|
||||
|
|
|
@ -172,7 +172,7 @@ PbClass *FluidSolver::create(PbType t, PbTypeVec T, const string &name)
|
|||
|
||||
PbClass *ret = PbClass::createPyObject(t.str() + T.str(), name, _args, this);
|
||||
#else
|
||||
PbClass *ret = NULL;
|
||||
PbClass *ret = nullptr;
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
@ -259,7 +259,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mantaMsg", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string &out = _args.get<std::string>("out", 0, &_lock);
|
||||
|
@ -297,7 +297,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "printBuildInfo", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
_retval = toPy(printBuildInfo());
|
||||
|
@ -331,7 +331,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setDebugLevel", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int level = _args.getOpt<int>("level", 0, 1, &_lock);
|
||||
|
@ -371,7 +371,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "assertNumpy", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
_retval = getPyNone();
|
||||
|
|
|
@ -73,7 +73,7 @@ class FluidSolver : public PbClass {
|
|||
FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FluidSolver::getGridSize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -121,7 +121,7 @@ class FluidSolver : public PbClass {
|
|||
FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FluidSolver::printMemInfo", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -147,7 +147,7 @@ class FluidSolver : public PbClass {
|
|||
FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FluidSolver::step", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -173,7 +173,7 @@ class FluidSolver : public PbClass {
|
|||
FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FluidSolver::adaptTimestep", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real maxVel = _args.get<Real>("maxVel", 0, &_lock);
|
||||
|
@ -200,7 +200,7 @@ class FluidSolver : public PbClass {
|
|||
FluidSolver *pbo = dynamic_cast<FluidSolver *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FluidSolver::create", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
PbType type = _args.get<PbType>("type", 0, &_lock);
|
||||
|
|
|
@ -1,3 +1,3 @@
|
|||
|
||||
|
||||
#define MANTA_GIT_VERSION "commit dffc3481b835dfa048effcbb8a9e613294ecae14"
|
||||
#define MANTA_GIT_VERSION "commit 73990a8a5b876e2b136a646258f714c08c5828da"
|
||||
|
|
|
@ -1290,7 +1290,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "gridMaxDiff", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &g1 = *_args.getPtr<Grid<Real>>("g1", 0, &_lock);
|
||||
|
@ -1330,7 +1330,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "gridMaxDiffInt", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<int> &g1 = *_args.getPtr<Grid<int>>("g1", 0, &_lock);
|
||||
|
@ -1377,7 +1377,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "gridMaxDiffVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &g1 = *_args.getPtr<Grid<Vec3>>("g1", 0, &_lock);
|
||||
|
@ -1470,7 +1470,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "copyMacToVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
|
||||
|
@ -1507,7 +1507,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "convertMacToVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
|
||||
|
@ -1604,7 +1604,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "resampleVec3ToMac", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
|
||||
|
@ -1697,7 +1697,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "resampleMacToVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
|
||||
|
@ -1789,7 +1789,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "copyLevelsetToReal", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
LevelsetGrid &source = *_args.getPtr<LevelsetGrid>("source", 0, &_lock);
|
||||
|
@ -1911,7 +1911,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "copyVec3ToReal", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
|
||||
|
@ -2035,7 +2035,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "copyRealToVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &sourceX = *_args.getPtr<Grid<Real>>("sourceX", 0, &_lock);
|
||||
|
@ -2074,7 +2074,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "convertLevelsetToReal", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
LevelsetGrid &source = *_args.getPtr<LevelsetGrid>("source", 0, &_lock);
|
||||
|
@ -2139,7 +2139,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "swapComponents", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 0, &_lock);
|
||||
|
@ -2181,7 +2181,7 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getUvWeight", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &uv = *_args.getPtr<Grid<Vec3>>("uv", 0, &_lock);
|
||||
|
@ -2280,7 +2280,7 @@ struct knResetUvGrid : public KernelBase {
|
|||
const Vec3 *offset;
|
||||
};
|
||||
|
||||
void resetUvGrid(Grid<Vec3> &target, const Vec3 *offset = NULL)
|
||||
void resetUvGrid(Grid<Vec3> &target, const Vec3 *offset = nullptr)
|
||||
{
|
||||
knResetUvGrid reset(target,
|
||||
offset); // note, llvm complains about anonymous declaration here... ?
|
||||
|
@ -2292,11 +2292,11 @@ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "resetUvGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 0, &_lock);
|
||||
const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 1, NULL, &_lock);
|
||||
const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 1, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
resetUvGrid(target, offset);
|
||||
_args.check();
|
||||
|
@ -2318,7 +2318,7 @@ void PbRegister_resetUvGrid()
|
|||
}
|
||||
|
||||
void updateUvWeight(
|
||||
Real resetTime, int index, int numUvs, Grid<Vec3> &uv, const Vec3 *offset = NULL)
|
||||
Real resetTime, int index, int numUvs, Grid<Vec3> &uv, const Vec3 *offset = nullptr)
|
||||
{
|
||||
const Real t = uv.getParent()->getTime();
|
||||
Real timeOff = resetTime / (Real)numUvs;
|
||||
|
@ -2357,14 +2357,14 @@ static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "updateUvWeight", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real resetTime = _args.get<Real>("resetTime", 0, &_lock);
|
||||
int index = _args.get<int>("index", 1, &_lock);
|
||||
int numUvs = _args.get<int>("numUvs", 2, &_lock);
|
||||
Grid<Vec3> &uv = *_args.getPtr<Grid<Vec3>>("uv", 3, &_lock);
|
||||
const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 4, NULL, &_lock);
|
||||
const Vec3 *offset = _args.getPtrOpt<Vec3>("offset", 4, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
updateUvWeight(resetTime, index, numUvs, uv, offset);
|
||||
_args.check();
|
||||
|
@ -2812,7 +2812,7 @@ struct knCountFluidCells : public KernelBase {
|
|||
|
||||
//! averaged value for all cells (if flags are given, only for fluid cells)
|
||||
|
||||
Real getGridAvg(Grid<Real> &source, FlagGrid *flags = NULL)
|
||||
Real getGridAvg(Grid<Real> &source, FlagGrid *flags = nullptr)
|
||||
{
|
||||
double sum = knGridTotalSum(source, flags);
|
||||
|
||||
|
@ -2837,11 +2837,11 @@ static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getGridAvg", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
|
||||
FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, NULL, &_lock);
|
||||
FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, nullptr, &_lock);
|
||||
_retval = toPy(getGridAvg(source, flags));
|
||||
_args.check();
|
||||
}
|
||||
|
@ -2920,7 +2920,7 @@ static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getComponent", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
|
||||
|
@ -3003,7 +3003,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setComponent", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
|
||||
|
@ -3373,7 +3373,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "markIsolatedFluidCell", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -3427,7 +3427,7 @@ static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "copyMACData", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MACGrid &source = *_args.getPtr<MACGrid>("source", 0, &_lock);
|
||||
|
|
|
@ -79,7 +79,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::getSizeX", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -107,7 +107,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::getSizeY", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -135,7 +135,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::getSizeZ", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -163,7 +163,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::getSize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -233,7 +233,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::is3D", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -274,7 +274,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::is4D", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -301,7 +301,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::getSizeT", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -328,7 +328,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::getStrideT", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -367,7 +367,7 @@ class GridBase : public PbClass {
|
|||
GridBase *pbo = dynamic_cast<GridBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "GridBase::setName", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string &name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -447,7 +447,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -472,7 +472,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -498,7 +498,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::clear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -625,7 +625,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::copyFrom", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -655,7 +655,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getGridType", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -680,7 +680,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::add", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -706,7 +706,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::sub", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -733,7 +733,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::setConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -760,7 +760,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::addConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -787,7 +787,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::addScaled", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -815,7 +815,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::mult", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -842,7 +842,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::multConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -869,7 +869,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::safeDivide", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -895,7 +895,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::clamp", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real min = _args.get<Real>("min", 0, &_lock);
|
||||
|
@ -923,7 +923,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::stomp", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const T &threshold = *_args.getPtr<T>("threshold", 0, &_lock);
|
||||
|
@ -950,7 +950,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::permuteAxes", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int axis0 = _args.get<int>("axis0", 0, &_lock);
|
||||
|
@ -979,7 +979,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::permuteAxesCopyToGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int axis0 = _args.get<int>("axis0", 0, &_lock);
|
||||
|
@ -1009,7 +1009,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::join", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<T> &a = *_args.getPtr<Grid<T>>("a", 0, &_lock);
|
||||
|
@ -1038,7 +1038,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getMaxAbs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1063,7 +1063,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getMax", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1088,7 +1088,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getMin", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1113,7 +1113,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getL1", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int bnd = _args.getOpt<int>("bnd", 0, 0, &_lock);
|
||||
|
@ -1139,7 +1139,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getL2", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int bnd = _args.getOpt<int>("bnd", 0, 0, &_lock);
|
||||
|
@ -1165,7 +1165,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::setBound", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T value = _args.get<T>("value", 0, &_lock);
|
||||
|
@ -1193,7 +1193,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::setBoundNeumann", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 1, &_lock);
|
||||
|
@ -1220,7 +1220,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::getDataPointer", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1245,7 +1245,7 @@ template<class T> class Grid : public GridBase {
|
|||
Grid *pbo = dynamic_cast<Grid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid::printGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int zSlice = _args.getOpt<int>("zSlice", 0, -1, &_lock);
|
||||
|
@ -1395,7 +1395,7 @@ class MACGrid : public Grid<Vec3> {
|
|||
MACGrid *pbo = dynamic_cast<MACGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MACGrid::setBoundMAC", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Vec3 value = _args.get<Vec3>("value", 0, &_lock);
|
||||
|
@ -1616,7 +1616,7 @@ class FlagGrid : public Grid<int> {
|
|||
FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FlagGrid::initDomain", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const int &boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 0, &_lock);
|
||||
|
@ -1650,7 +1650,7 @@ class FlagGrid : public Grid<int> {
|
|||
FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FlagGrid::updateFromLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock);
|
||||
|
@ -1677,7 +1677,7 @@ class FlagGrid : public Grid<int> {
|
|||
FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FlagGrid::fillGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int type = _args.getOpt<int>("type", 0, TypeFluid, &_lock);
|
||||
|
@ -1698,7 +1698,7 @@ class FlagGrid : public Grid<int> {
|
|||
//! count no. of cells matching flags via "AND"
|
||||
//! warning for large grids! only regular int returned (due to python interface)
|
||||
//! optionally creates mask in RealGrid (1 where flag matches, 0 otherwise)
|
||||
int countCells(int flag, int bnd = 0, Grid<Real> *mask = NULL);
|
||||
int countCells(int flag, int bnd = 0, Grid<Real> *mask = nullptr);
|
||||
static PyObject *_W_44(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
try {
|
||||
|
@ -1706,12 +1706,12 @@ class FlagGrid : public Grid<int> {
|
|||
FlagGrid *pbo = dynamic_cast<FlagGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "FlagGrid::countCells", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int flag = _args.get<int>("flag", 0, &_lock);
|
||||
int bnd = _args.getOpt<int>("bnd", 1, 0, &_lock);
|
||||
Grid<Real> *mask = _args.getPtrOpt<Grid<Real>>("mask", 2, NULL, &_lock);
|
||||
Grid<Real> *mask = _args.getPtrOpt<Grid<Real>>("mask", 2, nullptr, &_lock);
|
||||
pbo->_args.copy(_args);
|
||||
_retval = toPy(pbo->countCells(flag, bnd, mask));
|
||||
pbo->_args.check();
|
||||
|
|
|
@ -888,7 +888,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getComp4d", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<Vec4> &src = *_args.getPtr<Grid4d<Vec4>>("src", 0, &_lock);
|
||||
|
@ -926,7 +926,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setComp4d", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<Real> &src = *_args.getPtr<Grid4d<Real>>("src", 0, &_lock);
|
||||
|
@ -1170,7 +1170,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "grid4dMaxDiff", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Real> &g1 = *_args.getPtr<Grid4d<Real>>("g1", 0, &_lock);
|
||||
|
@ -1210,7 +1210,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "grid4dMaxDiffInt", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<int> &g1 = *_args.getPtr<Grid4d<int>>("g1", 0, &_lock);
|
||||
|
@ -1254,7 +1254,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "grid4dMaxDiffVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Vec3> &g1 = *_args.getPtr<Grid4d<Vec3>>("g1", 0, &_lock);
|
||||
|
@ -1298,7 +1298,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "grid4dMaxDiffVec4", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Vec4> &g1 = *_args.getPtr<Grid4d<Vec4>>("g1", 0, &_lock);
|
||||
|
@ -1422,7 +1422,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setRegion4d", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Real> &dst = *_args.getPtr<Grid4d<Real>>("dst", 0, &_lock);
|
||||
|
@ -1461,7 +1461,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setRegion4dVec4", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Vec4> &dst = *_args.getPtr<Grid4d<Vec4>>("dst", 0, &_lock);
|
||||
|
@ -1510,7 +1510,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getSliceFrom4d", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Real> &src = *_args.getPtr<Grid4d<Real>>("src", 0, &_lock);
|
||||
|
@ -1537,7 +1537,7 @@ void PbRegister_getSliceFrom4d()
|
|||
}
|
||||
|
||||
//! slow helper to visualize tests, get a 3d slice of a 4d vec4 grid
|
||||
void getSliceFrom4dVec(Grid4d<Vec4> &src, int srct, Grid<Vec3> &dst, Grid<Real> *dstt = NULL)
|
||||
void getSliceFrom4dVec(Grid4d<Vec4> &src, int srct, Grid<Vec3> &dst, Grid<Real> *dstt = nullptr)
|
||||
{
|
||||
const int bnd = 0;
|
||||
if (!src.isInBounds(Vec4i(bnd, bnd, bnd, srct)))
|
||||
|
@ -1561,13 +1561,13 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getSliceFrom4dVec", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Vec4> &src = *_args.getPtr<Grid4d<Vec4>>("src", 0, &_lock);
|
||||
int srct = _args.get<int>("srct", 1, &_lock);
|
||||
Grid<Vec3> &dst = *_args.getPtr<Grid<Vec3>>("dst", 2, &_lock);
|
||||
Grid<Real> *dstt = _args.getPtrOpt<Grid<Real>>("dstt", 3, NULL, &_lock);
|
||||
Grid<Real> *dstt = _args.getPtrOpt<Grid<Real>>("dstt", 3, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
getSliceFrom4dVec(src, srct, dst, dstt);
|
||||
_args.check();
|
||||
|
@ -1716,7 +1716,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "interpolateGrid4d", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Real> &target = *_args.getPtr<Grid4d<Real>>("target", 0, &_lock);
|
||||
|
@ -1763,7 +1763,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "interpolateGrid4dVec", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid4d<Vec4> &target = *_args.getPtr<Grid4d<Vec4>>("target", 0, &_lock);
|
||||
|
|
|
@ -69,7 +69,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeX", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -97,7 +97,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeY", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -125,7 +125,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeZ", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -153,7 +153,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSizeT", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -181,7 +181,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::getSize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -256,7 +256,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::is3D", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -283,7 +283,7 @@ class Grid4dBase : public PbClass {
|
|||
Grid4dBase *pbo = dynamic_cast<Grid4dBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4dBase::is4D", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -380,7 +380,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -405,7 +405,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -431,7 +431,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::clear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -535,7 +535,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::copyFrom", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
|
||||
|
@ -565,7 +565,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::add", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
|
||||
|
@ -591,7 +591,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::sub", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
|
||||
|
@ -618,7 +618,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::setConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -645,7 +645,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::addConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -672,7 +672,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::addScaled", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
|
||||
|
@ -700,7 +700,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::mult", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid4d<T> &a = *_args.getPtr<Grid4d<T>>("a", 0, &_lock);
|
||||
|
@ -727,7 +727,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::multConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -754,7 +754,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::clamp", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real min = _args.get<Real>("min", 0, &_lock);
|
||||
|
@ -783,7 +783,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::getMaxAbs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -808,7 +808,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::getMax", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -833,7 +833,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::getMin", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -858,7 +858,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::setBound", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T value = _args.get<T>("value", 0, &_lock);
|
||||
|
@ -886,7 +886,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::setBoundNeumann", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int boundaryWidth = _args.getOpt<int>("boundaryWidth", 0, 1, &_lock);
|
||||
|
@ -913,7 +913,7 @@ template<class T> class Grid4d : public Grid4dBase {
|
|||
Grid4d *pbo = dynamic_cast<Grid4d *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Grid4d::printGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int zSlice = _args.getOpt<int>("zSlice", 0, -1, &_lock);
|
||||
|
|
|
@ -510,7 +510,7 @@ static void doReinitMarch(Grid<Real> &phi,
|
|||
const int dim = (phi.is3D() ? 3 : 2);
|
||||
Grid<int> fmFlags(phi.getParent());
|
||||
|
||||
FastMarch<FmHeapEntryIn, -1> marchIn(flags, fmFlags, phi, maxTime, NULL);
|
||||
FastMarch<FmHeapEntryIn, -1> marchIn(flags, fmFlags, phi, maxTime, nullptr);
|
||||
|
||||
// march inside
|
||||
InitFmIn(flags, fmFlags, phi, ignoreWalls, obstacleType);
|
||||
|
|
|
@ -60,7 +60,7 @@ class LevelsetGrid : public Grid<Real> {
|
|||
|
||||
void reinitMarching(const FlagGrid &flags,
|
||||
Real maxTime = 4.0,
|
||||
MACGrid *velTransport = NULL,
|
||||
MACGrid *velTransport = nullptr,
|
||||
bool ignoreWalls = false,
|
||||
bool correctOuterLayer = true,
|
||||
int obstacleType = FlagGrid::TypeObstacle);
|
||||
|
@ -71,12 +71,12 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::reinitMarching", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Real maxTime = _args.getOpt<Real>("maxTime", 1, 4.0, &_lock);
|
||||
MACGrid *velTransport = _args.getPtrOpt<MACGrid>("velTransport", 2, NULL, &_lock);
|
||||
MACGrid *velTransport = _args.getPtrOpt<MACGrid>("velTransport", 2, nullptr, &_lock);
|
||||
bool ignoreWalls = _args.getOpt<bool>("ignoreWalls", 3, false, &_lock);
|
||||
bool correctOuterLayer = _args.getOpt<bool>("correctOuterLayer", 4, true, &_lock);
|
||||
int obstacleType = _args.getOpt<int>("obstacleType", 5, FlagGrid::TypeObstacle, &_lock);
|
||||
|
@ -104,7 +104,7 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::createMesh", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
@ -131,7 +131,7 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::join", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const LevelsetGrid &o = *_args.getPtr<LevelsetGrid>("o", 0, &_lock);
|
||||
|
@ -149,7 +149,9 @@ class LevelsetGrid : public Grid<Real> {
|
|||
}
|
||||
}
|
||||
|
||||
void subtract(const LevelsetGrid &o, const FlagGrid *flags = NULL, const int subtractType = 0);
|
||||
void subtract(const LevelsetGrid &o,
|
||||
const FlagGrid *flags = nullptr,
|
||||
const int subtractType = 0);
|
||||
static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
try {
|
||||
|
@ -157,11 +159,11 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::subtract", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const LevelsetGrid &o = *_args.getPtr<LevelsetGrid>("o", 0, &_lock);
|
||||
const FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, NULL, &_lock);
|
||||
const FlagGrid *flags = _args.getPtrOpt<FlagGrid>("flags", 1, nullptr, &_lock);
|
||||
const int subtractType = _args.getOpt<int>("subtractType", 2, 0, &_lock);
|
||||
pbo->_args.copy(_args);
|
||||
_retval = getPyNone();
|
||||
|
@ -186,7 +188,7 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::initFromFlags", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -215,7 +217,7 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::fillHoles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int maxDepth = _args.getOpt<int>("maxDepth", 0, 10, &_lock);
|
||||
|
@ -243,7 +245,7 @@ class LevelsetGrid : public Grid<Real> {
|
|||
LevelsetGrid *pbo = dynamic_cast<LevelsetGrid *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "LevelsetGrid::floodFill", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Real value = _args.getOpt<Real>("value", 0, -0.5, &_lock);
|
||||
|
|
|
@ -39,7 +39,7 @@ Mesh::Mesh(FluidSolver *parent) : PbClass(parent)
|
|||
Mesh::~Mesh()
|
||||
{
|
||||
for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i)
|
||||
mMeshData[i]->setMesh(NULL);
|
||||
mMeshData[i]->setMesh(nullptr);
|
||||
|
||||
if (mFreeMdata) {
|
||||
for (IndexInt i = 0; i < (IndexInt)mMeshData.size(); ++i)
|
||||
|
@ -88,7 +88,7 @@ PbClass *Mesh::create(PbType t, PbTypeVec T, const string &name)
|
|||
"Unable to get mesh data pointer from newly created object. Only create MeshData type "
|
||||
"with a Mesh.creat() call, eg, MdataReal, MdataVec3 etc.");
|
||||
delete pyObj;
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
else {
|
||||
this->registerMdata(mdata);
|
||||
|
@ -97,7 +97,7 @@ PbClass *Mesh::create(PbType t, PbTypeVec T, const string &name)
|
|||
// directly init size of new mdata field:
|
||||
mdata->resize(this->getSizeSlow());
|
||||
#else
|
||||
PbClass *pyObj = NULL;
|
||||
PbClass *pyObj = nullptr;
|
||||
#endif
|
||||
return pyObj;
|
||||
}
|
||||
|
@ -1279,7 +1279,7 @@ std::string Mesh::getTrisDataPointer()
|
|||
|
||||
// mesh data
|
||||
|
||||
MeshDataBase::MeshDataBase(FluidSolver *parent) : PbClass(parent), mMesh(NULL)
|
||||
MeshDataBase::MeshDataBase(FluidSolver *parent) : PbClass(parent), mMesh(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -1294,13 +1294,13 @@ MeshDataBase::~MeshDataBase()
|
|||
|
||||
template<class T>
|
||||
MeshDataImpl<T>::MeshDataImpl(FluidSolver *parent)
|
||||
: MeshDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
|
||||
: MeshDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
MeshDataImpl<T>::MeshDataImpl(FluidSolver *parent, MeshDataImpl<T> *other)
|
||||
: MeshDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
|
||||
: MeshDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
|
||||
{
|
||||
this->mData = other->mData;
|
||||
setName(other->getName());
|
||||
|
|
|
@ -223,7 +223,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::clear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -248,7 +248,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::fromShape", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock);
|
||||
|
@ -275,7 +275,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::advectInGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -303,7 +303,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::scale", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Vec3 s = _args.get<Vec3>("s", 0, &_lock);
|
||||
|
@ -329,7 +329,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::offset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Vec3 o = _args.get<Vec3>("o", 0, &_lock);
|
||||
|
@ -355,7 +355,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::rotate", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Vec3 thetas = _args.get<Vec3>("thetas", 0, &_lock);
|
||||
|
@ -381,7 +381,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::computeVelocity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &oldMesh = *_args.getPtr<Mesh>("oldMesh", 0, &_lock);
|
||||
|
@ -409,7 +409,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -435,7 +435,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -460,7 +460,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::computeLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
LevelsetGrid &levelset = *_args.getPtr<LevelsetGrid>("levelset", 0, &_lock);
|
||||
|
@ -488,7 +488,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::getLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real sigma = _args.get<Real>("sigma", 0, &_lock);
|
||||
|
@ -518,7 +518,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::applyMeshToGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
|
||||
|
@ -548,7 +548,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::getNodesDataPointer", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -573,7 +573,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::getTrisDataPointer", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -734,7 +734,7 @@ class Mesh : public PbClass {
|
|||
Mesh *pbo = dynamic_cast<Mesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Mesh::create", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
PbType type = _args.get<PbType>("type", 0, &_lock);
|
||||
|
@ -852,7 +852,7 @@ class MeshDataBase : public PbClass {
|
|||
virtual MeshDataBase *clone()
|
||||
{
|
||||
assertMsg(false, "Dont use, override...");
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
virtual MdataType getType() const
|
||||
{
|
||||
|
@ -952,7 +952,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -978,7 +978,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setSource", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock);
|
||||
|
@ -1026,7 +1026,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -1052,7 +1052,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstRange", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -1080,7 +1080,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::copyFrom", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1105,7 +1105,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::add", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1131,7 +1131,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sub", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1157,7 +1157,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -1183,7 +1183,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::addScaled", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1210,7 +1210,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::mult", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1236,7 +1236,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::multConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -1262,7 +1262,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::safeDiv", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<T> &a = *_args.getPtr<MeshDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1288,7 +1288,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clamp", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real min = _args.get<Real>("min", 0, &_lock);
|
||||
|
@ -1315,7 +1315,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMin", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real vmin = _args.get<Real>("vmin", 0, &_lock);
|
||||
|
@ -1341,7 +1341,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::clampMax", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real vmax = _args.get<Real>("vmax", 0, &_lock);
|
||||
|
@ -1367,7 +1367,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMaxAbs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1391,7 +1391,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMax", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1415,7 +1415,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getMin", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1431,7 +1431,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
}
|
||||
}
|
||||
|
||||
T sum(const MeshDataImpl<int> *t = NULL, const int itype = 0) const;
|
||||
T sum(const MeshDataImpl<int> *t = nullptr, const int itype = 0) const;
|
||||
static PyObject *_W_36(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
try {
|
||||
|
@ -1439,10 +1439,10 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sum", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MeshDataImpl<int> *t = _args.getPtrOpt<MeshDataImpl<int>>("t", 0, NULL, &_lock);
|
||||
const MeshDataImpl<int> *t = _args.getPtrOpt<MeshDataImpl<int>>("t", 0, nullptr, &_lock);
|
||||
const int itype = _args.getOpt<int>("itype", 1, 0, &_lock);
|
||||
pbo->_args.copy(_args);
|
||||
_retval = toPy(pbo->sum(t, itype));
|
||||
|
@ -1465,7 +1465,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumSquare", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1489,7 +1489,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::sumMagnitude", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1514,7 +1514,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::setConstIntFlag", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
T s = _args.get<T>("s", 0, &_lock);
|
||||
|
@ -1542,7 +1542,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::printMdata", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
|
||||
|
@ -1571,7 +1571,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -1596,7 +1596,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -1622,7 +1622,7 @@ template<class T> class MeshDataImpl : public MeshDataBase {
|
|||
MeshDataImpl *pbo = dynamic_cast<MeshDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MeshDataImpl::getDataPointer", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
|
|
@ -62,7 +62,7 @@ class MovingObstacle : public PbClass {
|
|||
MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MovingObstacle::add", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Shape *shape = _args.getPtr<Shape>("shape", 0, &_lock);
|
||||
|
@ -96,7 +96,7 @@ class MovingObstacle : public PbClass {
|
|||
MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MovingObstacle::moveLinear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real t = _args.get<Real>("t", 0, &_lock);
|
||||
|
@ -130,7 +130,7 @@ class MovingObstacle : public PbClass {
|
|||
MovingObstacle *pbo = dynamic_cast<MovingObstacle *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "MovingObstacle::projectOutside", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
|
|
@ -34,7 +34,7 @@ using namespace std;
|
|||
namespace Manta {
|
||||
|
||||
int WaveletNoiseField::randomSeed = 13322223;
|
||||
Real *WaveletNoiseField::mNoiseTile = NULL;
|
||||
Real *WaveletNoiseField::mNoiseTile = nullptr;
|
||||
std::atomic<int> WaveletNoiseField::mNoiseReferenceCount(0);
|
||||
|
||||
static Real _aCoeffs[32] = {
|
||||
|
|
|
@ -64,7 +64,7 @@ class WaveletNoiseField : public PbClass {
|
|||
{
|
||||
if (mNoiseTile && !mNoiseReferenceCount) {
|
||||
delete mNoiseTile;
|
||||
mNoiseTile = NULL;
|
||||
mNoiseTile = nullptr;
|
||||
}
|
||||
};
|
||||
|
||||
|
|
|
@ -37,7 +37,7 @@ ParticleBase::~ParticleBase()
|
|||
{
|
||||
// make sure data fields now parent system is deleted
|
||||
for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
|
||||
mPartData[i]->setParticleSys(NULL);
|
||||
mPartData[i]->setParticleSys(nullptr);
|
||||
|
||||
if (mFreePdata) {
|
||||
for (IndexInt i = 0; i < (IndexInt)mPartData.size(); ++i)
|
||||
|
@ -93,7 +93,7 @@ PbClass *ParticleBase::create(PbType t, PbTypeVec T, const string &name)
|
|||
"Unable to get particle data pointer from newly created object. Only create ParticleData "
|
||||
"type with a ParticleSys.creat() call, eg, PdataReal, PdataVec3 etc.");
|
||||
delete pyObj;
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
else {
|
||||
this->registerPdata(pdata);
|
||||
|
@ -102,7 +102,7 @@ PbClass *ParticleBase::create(PbType t, PbTypeVec T, const string &name)
|
|||
// directly init size of new pdata field:
|
||||
pdata->resize(this->getSizeSlow());
|
||||
#else
|
||||
PbClass *pyObj = NULL;
|
||||
PbClass *pyObj = nullptr;
|
||||
#endif
|
||||
return pyObj;
|
||||
}
|
||||
|
@ -297,7 +297,7 @@ void BasicParticleSystem::readParticles(BasicParticleSystem *from)
|
|||
|
||||
// particle data
|
||||
|
||||
ParticleDataBase::ParticleDataBase(FluidSolver *parent) : PbClass(parent), mpParticleSys(NULL)
|
||||
ParticleDataBase::ParticleDataBase(FluidSolver *parent) : PbClass(parent), mpParticleSys(nullptr)
|
||||
{
|
||||
}
|
||||
|
||||
|
@ -312,13 +312,13 @@ ParticleDataBase::~ParticleDataBase()
|
|||
|
||||
template<class T>
|
||||
ParticleDataImpl<T>::ParticleDataImpl(FluidSolver *parent)
|
||||
: ParticleDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
|
||||
: ParticleDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
|
||||
{
|
||||
}
|
||||
|
||||
template<class T>
|
||||
ParticleDataImpl<T>::ParticleDataImpl(FluidSolver *parent, ParticleDataImpl<T> *other)
|
||||
: ParticleDataBase(parent), mpGridSource(NULL), mGridSourceMAC(false)
|
||||
: ParticleDataBase(parent), mpGridSource(nullptr), mGridSourceMAC(false)
|
||||
{
|
||||
this->mData = other->mData;
|
||||
setName(other->getName());
|
||||
|
|
|
@ -86,7 +86,7 @@ class ParticleBase : public PbClass {
|
|||
virtual ParticleBase *clone()
|
||||
{
|
||||
assertMsg(false, "Dont use, override...");
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
//! slow virtual function to query size, do not use in kernels! use size() instead
|
||||
|
@ -122,7 +122,7 @@ class ParticleBase : public PbClass {
|
|||
ParticleBase *pbo = dynamic_cast<ParticleBase *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleBase::create", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
PbType type = _args.get<PbType>("type", 0, &_lock);
|
||||
|
@ -274,7 +274,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::pySize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -342,7 +342,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::setPos", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const IndexInt idx = _args.get<IndexInt>("idx", 0, &_lock);
|
||||
|
@ -373,7 +373,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::getPos", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const IndexInt idx = _args.get<IndexInt>("idx", 0, &_lock);
|
||||
|
@ -399,7 +399,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::getPosPdata", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
ParticleDataImpl<Vec3> &target = *_args.getPtr<ParticleDataImpl<Vec3>>(
|
||||
|
@ -426,7 +426,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::setPosPdata", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<Vec3> &source = *_args.getPtr<ParticleDataImpl<Vec3>>(
|
||||
|
@ -477,7 +477,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::clear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -501,7 +501,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
const bool deleteInObstacle = true,
|
||||
const bool stopInObstacle = true,
|
||||
const bool skipNew = false,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0);
|
||||
static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
|
@ -510,7 +510,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::advectInGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -520,7 +520,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
const bool stopInObstacle = _args.getOpt<bool>("stopInObstacle", 4, true, &_lock);
|
||||
const bool skipNew = _args.getOpt<bool>("skipNew", 5, false, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 6, NULL, &_lock);
|
||||
"ptype", 6, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
|
||||
pbo->_args.copy(_args);
|
||||
_retval = getPyNone();
|
||||
|
@ -552,7 +552,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::projectOutside", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &gradient = *_args.getPtr<Grid<Vec3>>("gradient", 0, &_lock);
|
||||
|
@ -573,7 +573,7 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
void projectOutOfBnd(const FlagGrid &flags,
|
||||
const Real bnd,
|
||||
const std::string &plane = "xXyYzZ",
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0);
|
||||
static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
|
@ -582,14 +582,14 @@ template<class S> class ParticleSystem : public ParticleBase {
|
|||
ParticleSystem *pbo = dynamic_cast<ParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleSystem::projectOutOfBnd", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
const Real bnd = _args.get<Real>("bnd", 1, &_lock);
|
||||
const std::string &plane = _args.getOpt<std::string>("plane", 2, "xXyYzZ", &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 3, NULL, &_lock);
|
||||
"ptype", 3, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 4, 0, &_lock);
|
||||
pbo->_args.copy(_args);
|
||||
_retval = getPyNone();
|
||||
|
@ -685,7 +685,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
|
|||
BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -710,7 +710,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
|
|||
BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -742,7 +742,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
|
|||
BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::readParticles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
BasicParticleSystem *from = _args.getPtr<BasicParticleSystem>("from", 0, &_lock);
|
||||
|
@ -772,7 +772,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
|
|||
BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::addParticle", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Vec3 pos = _args.get<Vec3>("pos", 0, &_lock);
|
||||
|
@ -804,7 +804,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
|
|||
BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::printParts", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
|
||||
|
@ -833,7 +833,7 @@ class BasicParticleSystem : public ParticleSystem<BasicParticleData> {
|
|||
BasicParticleSystem *pbo = dynamic_cast<BasicParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "BasicParticleSystem::getDataPointer", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1028,7 +1028,7 @@ class ParticleDataBase : public PbClass {
|
|||
virtual ParticleDataBase *clone()
|
||||
{
|
||||
assertMsg(false, "Dont use, override...");
|
||||
return NULL;
|
||||
return nullptr;
|
||||
}
|
||||
virtual PdataType getType() const
|
||||
{
|
||||
|
@ -1139,7 +1139,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clear", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1165,7 +1165,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setSource", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<T> *grid = _args.getPtr<Grid<T>>("grid", 0, &_lock);
|
||||
|
@ -1213,7 +1213,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::copyFrom", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1238,7 +1238,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const T &s = *_args.getPtr<T>("s", 0, &_lock);
|
||||
|
@ -1264,7 +1264,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConstRange", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const T &s = *_args.getPtr<T>("s", 0, &_lock);
|
||||
|
@ -1292,7 +1292,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::add", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1318,7 +1318,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sub", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1344,7 +1344,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::addConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const T &s = *_args.getPtr<T>("s", 0, &_lock);
|
||||
|
@ -1370,7 +1370,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::addScaled", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1397,7 +1397,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::mult", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1423,7 +1423,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::multConst", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const T &s = *_args.getPtr<T>("s", 0, &_lock);
|
||||
|
@ -1449,7 +1449,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::safeDiv", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<T> &a = *_args.getPtr<ParticleDataImpl<T>>("a", 0, &_lock);
|
||||
|
@ -1475,7 +1475,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clamp", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Real vmin = _args.get<Real>("vmin", 0, &_lock);
|
||||
|
@ -1502,7 +1502,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clampMin", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Real vmin = _args.get<Real>("vmin", 0, &_lock);
|
||||
|
@ -1528,7 +1528,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::clampMax", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Real vmax = _args.get<Real>("vmax", 0, &_lock);
|
||||
|
@ -1554,7 +1554,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMaxAbs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1578,7 +1578,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMax", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1602,7 +1602,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getMin", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1618,7 +1618,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
}
|
||||
}
|
||||
|
||||
T sum(const ParticleDataImpl<int> *t = NULL, const int itype = 0) const;
|
||||
T sum(const ParticleDataImpl<int> *t = nullptr, const int itype = 0) const;
|
||||
static PyObject *_W_41(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
try {
|
||||
|
@ -1626,11 +1626,11 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sum", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<int> *t = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"t", 0, NULL, &_lock);
|
||||
"t", 0, nullptr, &_lock);
|
||||
const int itype = _args.getOpt<int>("itype", 1, 0, &_lock);
|
||||
pbo->_args.copy(_args);
|
||||
_retval = toPy(pbo->sum(t, itype));
|
||||
|
@ -1653,7 +1653,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sumSquare", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1677,7 +1677,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::sumMagnitude", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -1702,7 +1702,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::setConstIntFlag", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const T &s = *_args.getPtr<T>("s", 0, &_lock);
|
||||
|
@ -1730,7 +1730,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::printPdata", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
IndexInt start = _args.getOpt<IndexInt>("start", 0, -1, &_lock);
|
||||
|
@ -1759,7 +1759,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::save", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -1784,7 +1784,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::load", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string name = _args.get<std::string>("name", 0, &_lock);
|
||||
|
@ -1810,7 +1810,7 @@ template<class T> class ParticleDataImpl : public ParticleDataBase {
|
|||
ParticleDataImpl *pbo = dynamic_cast<ParticleDataImpl *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "ParticleDataImpl::getDataPointer", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -2152,9 +2152,9 @@ static inline Vec3 bisectBacktracePos(const FlagGrid &flags, const Vec3 &oldp, c
|
|||
template<class S> struct KnClampPositions : public KernelBase {
|
||||
KnClampPositions(std::vector<S> &p,
|
||||
const FlagGrid &flags,
|
||||
ParticleDataImpl<Vec3> *posOld = NULL,
|
||||
ParticleDataImpl<Vec3> *posOld = nullptr,
|
||||
bool stopInObstacle = true,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
: KernelBase(p.size()),
|
||||
p(p),
|
||||
|
@ -2170,9 +2170,9 @@ template<class S> struct KnClampPositions : public KernelBase {
|
|||
inline void op(IndexInt idx,
|
||||
std::vector<S> &p,
|
||||
const FlagGrid &flags,
|
||||
ParticleDataImpl<Vec3> *posOld = NULL,
|
||||
ParticleDataImpl<Vec3> *posOld = nullptr,
|
||||
bool stopInObstacle = true,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0) const
|
||||
{
|
||||
if (p[idx].flag & ParticleBase::PDELETE)
|
||||
|
@ -2255,7 +2255,7 @@ void ParticleSystem<S>::advectInGrid(const FlagGrid &flags,
|
|||
const int exclude)
|
||||
{
|
||||
// position clamp requires old positions, backup
|
||||
ParticleDataImpl<Vec3> *posOld = NULL;
|
||||
ParticleDataImpl<Vec3> *posOld = nullptr;
|
||||
if (!deleteInObstacle) {
|
||||
posOld = new ParticleDataImpl<Vec3>(this->getParent());
|
||||
posOld->resize(mData.size());
|
||||
|
|
|
@ -1336,7 +1336,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "resetPhiInObs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -1476,7 +1476,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "advectSemiLagrange", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid *flags = _args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
|
|
@ -271,8 +271,8 @@ void apicMapPartsToMAC(const FlagGrid &flags,
|
|||
const ParticleDataImpl<Vec3> &cpx,
|
||||
const ParticleDataImpl<Vec3> &cpy,
|
||||
const ParticleDataImpl<Vec3> &cpz,
|
||||
MACGrid *mass = NULL,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
MACGrid *mass = nullptr,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0,
|
||||
const int boundaryWidth = 0)
|
||||
{
|
||||
|
@ -297,7 +297,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "apicMapPartsToMAC", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -308,9 +308,9 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const ParticleDataImpl<Vec3> &cpx = *_args.getPtr<ParticleDataImpl<Vec3>>("cpx", 4, &_lock);
|
||||
const ParticleDataImpl<Vec3> &cpy = *_args.getPtr<ParticleDataImpl<Vec3>>("cpy", 5, &_lock);
|
||||
const ParticleDataImpl<Vec3> &cpz = *_args.getPtr<ParticleDataImpl<Vec3>>("cpz", 6, &_lock);
|
||||
MACGrid *mass = _args.getPtrOpt<MACGrid>("mass", 7, NULL, &_lock);
|
||||
MACGrid *mass = _args.getPtrOpt<MACGrid>("mass", 7, nullptr, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 8, NULL, &_lock);
|
||||
"ptype", 8, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 9, 0, &_lock);
|
||||
const int boundaryWidth = _args.getOpt<int>("boundaryWidth", 10, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
|
@ -544,7 +544,7 @@ void apicMapMACGridToParts(ParticleDataImpl<Vec3> &partVel,
|
|||
const BasicParticleSystem &parts,
|
||||
const MACGrid &vel,
|
||||
const FlagGrid &flags,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0,
|
||||
const int boundaryWidth = 0)
|
||||
{
|
||||
|
@ -558,7 +558,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "apicMapMACGridToParts", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
|
||||
|
@ -570,7 +570,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 5, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 6, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 7, NULL, &_lock);
|
||||
"ptype", 7, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 8, 0, &_lock);
|
||||
const int boundaryWidth = _args.getOpt<int>("boundaryWidth", 9, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
|
|
|
@ -248,7 +248,7 @@ struct KnApplyForce : public KernelBase {
|
|||
void addGravity(const FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
Vec3 gravity,
|
||||
const Grid<Real> *exclude = NULL,
|
||||
const Grid<Real> *exclude = nullptr,
|
||||
bool scale = true)
|
||||
{
|
||||
float gridScale = (scale) ? flags.getDx() : 1;
|
||||
|
@ -262,13 +262,13 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addGravity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
Vec3 gravity = _args.get<Vec3>("gravity", 2, &_lock);
|
||||
const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, NULL, &_lock);
|
||||
const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, nullptr, &_lock);
|
||||
bool scale = _args.getOpt<bool>("scale", 4, true, &_lock);
|
||||
_retval = getPyNone();
|
||||
addGravity(flags, vel, gravity, exclude, scale);
|
||||
|
@ -294,7 +294,7 @@ void PbRegister_addGravity()
|
|||
void addGravityNoScale(const FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
const Vec3 &gravity,
|
||||
const Grid<Real> *exclude = NULL)
|
||||
const Grid<Real> *exclude = nullptr)
|
||||
{
|
||||
addGravity(flags, vel, gravity, exclude, false);
|
||||
}
|
||||
|
@ -305,13 +305,13 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addGravityNoScale", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
const Vec3 &gravity = _args.get<Vec3>("gravity", 2, &_lock);
|
||||
const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, NULL, &_lock);
|
||||
const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 3, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
addGravityNoScale(flags, vel, gravity, exclude);
|
||||
_args.check();
|
||||
|
@ -434,7 +434,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addBuoyancy", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -537,7 +537,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setOpenBound", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -567,11 +567,11 @@ void PbRegister_setOpenBound()
|
|||
//! delete fluid and ensure empty flag in outflow cells, delete particles and density and set phi
|
||||
//! to 0.5
|
||||
void resetOutflow(FlagGrid &flags,
|
||||
Grid<Real> *phi = 0,
|
||||
BasicParticleSystem *parts = 0,
|
||||
Grid<Real> *real = 0,
|
||||
Grid<int> *index = 0,
|
||||
ParticleIndexSystem *indexSys = 0)
|
||||
Grid<Real> *phi = nullptr,
|
||||
BasicParticleSystem *parts = nullptr,
|
||||
Grid<Real> *real = nullptr,
|
||||
Grid<int> *index = nullptr,
|
||||
ParticleIndexSystem *indexSys = nullptr)
|
||||
{
|
||||
// check if phi and parts -> pindex and gpi already created -> access particles from cell index,
|
||||
// avoid extra looping over particles
|
||||
|
@ -623,16 +623,17 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "resetOutflow", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 1, 0, &_lock);
|
||||
BasicParticleSystem *parts = _args.getPtrOpt<BasicParticleSystem>("parts", 2, 0, &_lock);
|
||||
Grid<Real> *real = _args.getPtrOpt<Grid<Real>>("real", 3, 0, &_lock);
|
||||
Grid<int> *index = _args.getPtrOpt<Grid<int>>("index", 4, 0, &_lock);
|
||||
Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 1, nullptr, &_lock);
|
||||
BasicParticleSystem *parts = _args.getPtrOpt<BasicParticleSystem>(
|
||||
"parts", 2, nullptr, &_lock);
|
||||
Grid<Real> *real = _args.getPtrOpt<Grid<Real>>("real", 3, nullptr, &_lock);
|
||||
Grid<int> *index = _args.getPtrOpt<Grid<int>>("index", 4, nullptr, &_lock);
|
||||
ParticleIndexSystem *indexSys = _args.getPtrOpt<ParticleIndexSystem>(
|
||||
"indexSys", 5, 0, &_lock);
|
||||
"indexSys", 5, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
resetOutflow(flags, phi, parts, real, index, indexSys);
|
||||
_args.check();
|
||||
|
@ -747,7 +748,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setInflowBcs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
|
@ -1064,13 +1065,13 @@ struct KnSetWallBcsFrac : public KernelBase {
|
|||
};
|
||||
|
||||
//! set zero normal velocity boundary condition on walls
|
||||
// (optionally with second order accuracy using the obstacle SDF , fractions grid currentlyl not
|
||||
// (optionally with second order accuracy using the obstacle SDF , fractions grid currently not
|
||||
// needed)
|
||||
void setWallBcs(const FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
const MACGrid *obvel = 0,
|
||||
const MACGrid *fractions = 0,
|
||||
const Grid<Real> *phiObs = 0,
|
||||
const MACGrid *obvel = nullptr,
|
||||
const MACGrid *fractions = nullptr,
|
||||
const Grid<Real> *phiObs = nullptr,
|
||||
int boundaryWidth = 0)
|
||||
{
|
||||
if (!phiObs || !fractions) {
|
||||
|
@ -1089,14 +1090,14 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setWallBcs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 2, 0, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 3, 0, &_lock);
|
||||
const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 4, 0, &_lock);
|
||||
const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 2, nullptr, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 3, nullptr, &_lock);
|
||||
const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 4, nullptr, &_lock);
|
||||
int boundaryWidth = _args.getOpt<int>("boundaryWidth", 5, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
setWallBcs(flags, vel, obvel, fractions, phiObs, boundaryWidth);
|
||||
|
@ -1219,7 +1220,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setInitialVelocity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -1342,7 +1343,7 @@ struct KnConfForce : public KernelBase {
|
|||
void vorticityConfinement(MACGrid &vel,
|
||||
const FlagGrid &flags,
|
||||
Real strength = 0,
|
||||
const Grid<Real> *strengthCell = NULL)
|
||||
const Grid<Real> *strengthCell = nullptr)
|
||||
{
|
||||
Grid<Vec3> velCenter(flags.getParent()), curl(flags.getParent()), force(flags.getParent());
|
||||
Grid<Real> norm(flags.getParent());
|
||||
|
@ -1351,7 +1352,7 @@ void vorticityConfinement(MACGrid &vel,
|
|||
CurlOp(velCenter, curl);
|
||||
GridNorm(norm, curl);
|
||||
KnConfForce(force, norm, curl, strength, strengthCell);
|
||||
KnApplyForceField(flags, vel, force, NULL, true, false);
|
||||
KnApplyForceField(flags, vel, force, nullptr, true, false);
|
||||
}
|
||||
static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
||||
{
|
||||
|
@ -1360,14 +1361,14 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "vorticityConfinement", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
|
||||
Real strength = _args.getOpt<Real>("strength", 2, 0, &_lock);
|
||||
const Grid<Real> *strengthCell = _args.getPtrOpt<Grid<Real>>(
|
||||
"strengthCell", 3, NULL, &_lock);
|
||||
"strengthCell", 3, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
vorticityConfinement(vel, flags, strength, strengthCell);
|
||||
_args.check();
|
||||
|
@ -1391,7 +1392,7 @@ void PbRegister_vorticityConfinement()
|
|||
void addForceField(const FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
const Grid<Vec3> &force,
|
||||
const Grid<Real> *region = NULL,
|
||||
const Grid<Real> *region = nullptr,
|
||||
bool isMAC = false)
|
||||
{
|
||||
KnApplyForceField(flags, vel, force, region, true, isMAC);
|
||||
|
@ -1403,13 +1404,13 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addForceField", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>("force", 2, &_lock);
|
||||
const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, NULL, &_lock);
|
||||
const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, nullptr, &_lock);
|
||||
bool isMAC = _args.getOpt<bool>("isMAC", 4, false, &_lock);
|
||||
_retval = getPyNone();
|
||||
addForceField(flags, vel, force, region, isMAC);
|
||||
|
@ -1434,7 +1435,7 @@ void PbRegister_addForceField()
|
|||
void setForceField(const FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
const Grid<Vec3> &force,
|
||||
const Grid<Real> *region = NULL,
|
||||
const Grid<Real> *region = nullptr,
|
||||
bool isMAC = false)
|
||||
{
|
||||
KnApplyForceField(flags, vel, force, region, false, isMAC);
|
||||
|
@ -1446,13 +1447,13 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setForceField", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
const Grid<Vec3> &force = *_args.getPtr<Grid<Vec3>>("force", 2, &_lock);
|
||||
const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, NULL, &_lock);
|
||||
const Grid<Real> *region = _args.getPtrOpt<Grid<Real>>("region", 3, nullptr, &_lock);
|
||||
bool isMAC = _args.getOpt<bool>("isMAC", 4, false, &_lock);
|
||||
_retval = getPyNone();
|
||||
setForceField(flags, vel, force, region, isMAC);
|
||||
|
@ -1645,10 +1646,10 @@ struct KnDissolveSmoke : public KernelBase {
|
|||
|
||||
void dissolveSmoke(const FlagGrid &flags,
|
||||
Grid<Real> &density,
|
||||
Grid<Real> *heat = NULL,
|
||||
Grid<Real> *red = NULL,
|
||||
Grid<Real> *green = NULL,
|
||||
Grid<Real> *blue = NULL,
|
||||
Grid<Real> *heat = nullptr,
|
||||
Grid<Real> *red = nullptr,
|
||||
Grid<Real> *green = nullptr,
|
||||
Grid<Real> *blue = nullptr,
|
||||
int speed = 5,
|
||||
bool logFalloff = true)
|
||||
{
|
||||
|
@ -1663,15 +1664,15 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "dissolveSmoke", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
|
||||
Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 2, NULL, &_lock);
|
||||
Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, NULL, &_lock);
|
||||
Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, NULL, &_lock);
|
||||
Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, NULL, &_lock);
|
||||
Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 2, nullptr, &_lock);
|
||||
Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, nullptr, &_lock);
|
||||
Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, nullptr, &_lock);
|
||||
Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, nullptr, &_lock);
|
||||
int speed = _args.getOpt<int>("speed", 6, 5, &_lock);
|
||||
bool logFalloff = _args.getOpt<bool>("logFalloff", 7, true, &_lock);
|
||||
_retval = getPyNone();
|
||||
|
|
|
@ -258,10 +258,10 @@ struct KnProcessBurn : public KernelBase {
|
|||
void processBurn(Grid<Real> &fuel,
|
||||
Grid<Real> &density,
|
||||
Grid<Real> &react,
|
||||
Grid<Real> *red = NULL,
|
||||
Grid<Real> *green = NULL,
|
||||
Grid<Real> *blue = NULL,
|
||||
Grid<Real> *heat = NULL,
|
||||
Grid<Real> *red = nullptr,
|
||||
Grid<Real> *green = nullptr,
|
||||
Grid<Real> *blue = nullptr,
|
||||
Grid<Real> *heat = nullptr,
|
||||
Real burningRate = 0.75f,
|
||||
Real flameSmoke = 1.0f,
|
||||
Real ignitionTemp = 1.25f,
|
||||
|
@ -290,16 +290,16 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "processBurn", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &fuel = *_args.getPtr<Grid<Real>>("fuel", 0, &_lock);
|
||||
Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
|
||||
Grid<Real> &react = *_args.getPtr<Grid<Real>>("react", 2, &_lock);
|
||||
Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, NULL, &_lock);
|
||||
Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, NULL, &_lock);
|
||||
Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, NULL, &_lock);
|
||||
Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 6, NULL, &_lock);
|
||||
Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 3, nullptr, &_lock);
|
||||
Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 4, nullptr, &_lock);
|
||||
Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 5, nullptr, &_lock);
|
||||
Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 6, nullptr, &_lock);
|
||||
Real burningRate = _args.getOpt<Real>("burningRate", 7, 0.75f, &_lock);
|
||||
Real flameSmoke = _args.getOpt<Real>("flameSmoke", 8, 1.0f, &_lock);
|
||||
Real ignitionTemp = _args.getOpt<Real>("ignitionTemp", 9, 1.25f, &_lock);
|
||||
|
@ -407,7 +407,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "updateFlame", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &react = *_args.getPtr<Grid<Real>>("react", 0, &_lock);
|
||||
|
|
|
@ -69,7 +69,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "sampleFlagsWithParticles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -156,7 +156,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "sampleLevelsetWithParticles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 0, &_lock);
|
||||
|
@ -200,7 +200,7 @@ void sampleShapeWithParticles(const Shape &shape,
|
|||
const Real randomness,
|
||||
const bool reset = false,
|
||||
const bool refillEmpty = false,
|
||||
const LevelsetGrid *exclude = NULL)
|
||||
const LevelsetGrid *exclude = nullptr)
|
||||
{
|
||||
const bool is3D = flags.is3D();
|
||||
const Real jlen = randomness / discretization;
|
||||
|
@ -243,7 +243,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "sampleShapeWithParticles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Shape &shape = *_args.getPtr<Shape>("shape", 0, &_lock);
|
||||
|
@ -253,7 +253,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const Real randomness = _args.get<Real>("randomness", 4, &_lock);
|
||||
const bool reset = _args.getOpt<bool>("reset", 5, false, &_lock);
|
||||
const bool refillEmpty = _args.getOpt<bool>("refillEmpty", 6, false, &_lock);
|
||||
const LevelsetGrid *exclude = _args.getPtrOpt<LevelsetGrid>("exclude", 7, NULL, &_lock);
|
||||
const LevelsetGrid *exclude = _args.getPtrOpt<LevelsetGrid>("exclude", 7, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
sampleShapeWithParticles(
|
||||
shape, flags, parts, discretization, randomness, reset, refillEmpty, exclude);
|
||||
|
@ -418,8 +418,8 @@ struct knSetNbObstacle : public KernelBase {
|
|||
};
|
||||
void markFluidCells(const BasicParticleSystem &parts,
|
||||
FlagGrid &flags,
|
||||
const Grid<Real> *phiObs = NULL,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const Grid<Real> *phiObs = nullptr,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
// remove all fluid cells
|
||||
|
@ -448,14 +448,14 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "markFluidCells", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 1, &_lock);
|
||||
const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 2, NULL, &_lock);
|
||||
const Grid<Real> *phiObs = _args.getPtrOpt<Grid<Real>>("phiObs", 2, nullptr, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 3, NULL, &_lock);
|
||||
"ptype", 3, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 4, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
markFluidCells(parts, flags, phiObs, ptype, exclude);
|
||||
|
@ -492,7 +492,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "testInitGridWithPos", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &grid = *_args.getPtr<Grid<Real>>("grid", 0, &_lock);
|
||||
|
@ -534,7 +534,7 @@ void adjustNumber(BasicParticleSystem &parts,
|
|||
const LevelsetGrid &phi,
|
||||
Real radiusFactor = 1.,
|
||||
Real narrowBand = -1.,
|
||||
const Grid<Real> *exclude = NULL)
|
||||
const Grid<Real> *exclude = nullptr)
|
||||
{
|
||||
// which levelset to use as threshold
|
||||
const Real SURFACE_LS = -1.0 * calculateRadiusFactor(phi, radiusFactor);
|
||||
|
@ -610,7 +610,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "adjustNumber", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -621,7 +621,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 5, &_lock);
|
||||
Real radiusFactor = _args.getOpt<Real>("radiusFactor", 6, 1., &_lock);
|
||||
Real narrowBand = _args.getOpt<Real>("narrowBand", 7, -1., &_lock);
|
||||
const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 8, NULL, &_lock);
|
||||
const Grid<Real> *exclude = _args.getPtrOpt<Grid<Real>>("exclude", 8, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
adjustNumber(
|
||||
parts, vel, flags, minParticles, maxParticles, phi, radiusFactor, narrowBand, exclude);
|
||||
|
@ -660,7 +660,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "debugIntToReal", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<int> &source = *_args.getPtr<Grid<int>>("source", 0, &_lock);
|
||||
|
@ -694,7 +694,7 @@ void gridParticleIndex(const BasicParticleSystem &parts,
|
|||
ParticleIndexSystem &indexSys,
|
||||
const FlagGrid &flags,
|
||||
Grid<int> &index,
|
||||
Grid<int> *counter = NULL)
|
||||
Grid<int> *counter = nullptr)
|
||||
{
|
||||
bool delCounter = false;
|
||||
if (!counter) {
|
||||
|
@ -761,14 +761,14 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "gridParticleIndex", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
ParticleIndexSystem &indexSys = *_args.getPtr<ParticleIndexSystem>("indexSys", 1, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
|
||||
Grid<int> &index = *_args.getPtr<Grid<int>>("index", 3, &_lock);
|
||||
Grid<int> *counter = _args.getPtrOpt<Grid<int>>("counter", 4, NULL, &_lock);
|
||||
Grid<int> *counter = _args.getPtrOpt<Grid<int>>("counter", 4, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
gridParticleIndex(parts, indexSys, flags, index, counter);
|
||||
_args.check();
|
||||
|
@ -932,7 +932,7 @@ void unionParticleLevelset(const BasicParticleSystem &parts,
|
|||
const Grid<int> &index,
|
||||
LevelsetGrid &phi,
|
||||
const Real radiusFactor = 1.,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
// use half a cell diagonal as base radius
|
||||
|
@ -949,7 +949,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "unionParticleLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -960,7 +960,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 4, &_lock);
|
||||
const Real radiusFactor = _args.getOpt<Real>("radiusFactor", 5, 1., &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 6, NULL, &_lock);
|
||||
"ptype", 6, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
unionParticleLevelset(parts, indexSys, flags, index, phi, radiusFactor, ptype, exclude);
|
||||
|
@ -992,8 +992,8 @@ struct ComputeAveragedLevelsetWeight : public KernelBase {
|
|||
const Real radius,
|
||||
const ParticleDataImpl<int> *ptype,
|
||||
const int exclude,
|
||||
Grid<Vec3> *save_pAcc = NULL,
|
||||
Grid<Real> *save_rAcc = NULL)
|
||||
Grid<Vec3> *save_pAcc = nullptr,
|
||||
Grid<Real> *save_rAcc = nullptr)
|
||||
: KernelBase(&index, 0),
|
||||
parts(parts),
|
||||
index(index),
|
||||
|
@ -1018,8 +1018,8 @@ struct ComputeAveragedLevelsetWeight : public KernelBase {
|
|||
const Real radius,
|
||||
const ParticleDataImpl<int> *ptype,
|
||||
const int exclude,
|
||||
Grid<Vec3> *save_pAcc = NULL,
|
||||
Grid<Real> *save_rAcc = NULL) const
|
||||
Grid<Vec3> *save_pAcc = nullptr,
|
||||
Grid<Real> *save_rAcc = nullptr) const
|
||||
{
|
||||
const Vec3 gridPos = Vec3(i, j, k) + Vec3(0.5); // shifted by half cell
|
||||
Real phiv = radius * 1.0; // outside
|
||||
|
@ -1312,7 +1312,7 @@ void averagedParticleLevelset(const BasicParticleSystem &parts,
|
|||
const Real radiusFactor = 1.,
|
||||
const int smoothen = 1,
|
||||
const int smoothenNeg = 1,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
// use half a cell diagonal as base radius
|
||||
|
@ -1340,7 +1340,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "averagedParticleLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -1353,7 +1353,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const int smoothen = _args.getOpt<int>("smoothen", 6, 1, &_lock);
|
||||
const int smoothenNeg = _args.getOpt<int>("smoothenNeg", 7, 1, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 8, NULL, &_lock);
|
||||
"ptype", 8, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 9, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
averagedParticleLevelset(
|
||||
|
@ -1523,7 +1523,7 @@ void improvedParticleLevelset(const BasicParticleSystem &parts,
|
|||
const int smoothenNeg = 1,
|
||||
const Real t_low = 0.4,
|
||||
const Real t_high = 3.5,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
// create temporary grids to store values from levelset weight computation
|
||||
|
@ -1557,7 +1557,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "improvedParticleLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -1572,7 +1572,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const Real t_low = _args.getOpt<Real>("t_low", 8, 0.4, &_lock);
|
||||
const Real t_high = _args.getOpt<Real>("t_high", 9, 3.5, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 10, NULL, &_lock);
|
||||
"ptype", 10, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 11, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
improvedParticleLevelset(parts,
|
||||
|
@ -1714,7 +1714,7 @@ void pushOutofObs(BasicParticleSystem &parts,
|
|||
const Grid<Real> &phiObs,
|
||||
const Real shift = 0,
|
||||
const Real thresh = 0,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
knPushOutofObs(parts, flags, phiObs, shift, thresh, ptype, exclude);
|
||||
|
@ -1726,7 +1726,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "pushOutofObs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -1735,7 +1735,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const Real shift = _args.getOpt<Real>("shift", 3, 0, &_lock);
|
||||
const Real thresh = _args.getOpt<Real>("thresh", 4, 0, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 5, NULL, &_lock);
|
||||
"ptype", 5, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 6, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
pushOutofObs(parts, flags, phiObs, shift, thresh, ptype, exclude);
|
||||
|
@ -1917,8 +1917,8 @@ void mapPartsToMAC(const FlagGrid &flags,
|
|||
MACGrid &velOld,
|
||||
const BasicParticleSystem &parts,
|
||||
const ParticleDataImpl<Vec3> &partVel,
|
||||
Grid<Vec3> *weight = NULL,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
Grid<Vec3> *weight = nullptr,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
// interpol -> grid. tmpgrid for particle contribution weights
|
||||
|
@ -1949,7 +1949,7 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mapPartsToMAC", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -1958,9 +1958,9 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 3, &_lock);
|
||||
const ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
|
||||
"partVel", 4, &_lock);
|
||||
Grid<Vec3> *weight = _args.getPtrOpt<Grid<Vec3>>("weight", 5, NULL, &_lock);
|
||||
Grid<Vec3> *weight = _args.getPtrOpt<Grid<Vec3>>("weight", 5, nullptr, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 6, NULL, &_lock);
|
||||
"ptype", 6, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
mapPartsToMAC(flags, vel, velOld, parts, partVel, weight, ptype, exclude);
|
||||
|
@ -2076,7 +2076,7 @@ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mapPartsToGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2118,7 +2118,7 @@ static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mapPartsToGridVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2215,7 +2215,7 @@ static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mapGridToParts", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 0, &_lock);
|
||||
|
@ -2254,7 +2254,7 @@ static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mapGridToPartsVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Vec3> &source = *_args.getPtr<Grid<Vec3>>("source", 0, &_lock);
|
||||
|
@ -2371,7 +2371,7 @@ void mapMACToParts(const FlagGrid &flags,
|
|||
const MACGrid &vel,
|
||||
const BasicParticleSystem &parts,
|
||||
ParticleDataImpl<Vec3> &partVel,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
knMapLinearMACGridToVec3_PIC(parts, flags, vel, partVel, ptype, exclude);
|
||||
|
@ -2383,7 +2383,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "mapMACToParts", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2392,7 +2392,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
ParticleDataImpl<Vec3> &partVel = *_args.getPtr<ParticleDataImpl<Vec3>>(
|
||||
"partVel", 3, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 4, NULL, &_lock);
|
||||
"ptype", 4, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 5, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
mapMACToParts(flags, vel, parts, partVel, ptype, exclude);
|
||||
|
@ -2526,7 +2526,7 @@ void flipVelocityUpdate(const FlagGrid &flags,
|
|||
const BasicParticleSystem &parts,
|
||||
ParticleDataImpl<Vec3> &partVel,
|
||||
const Real flipRatio,
|
||||
const ParticleDataImpl<int> *ptype = NULL,
|
||||
const ParticleDataImpl<int> *ptype = nullptr,
|
||||
const int exclude = 0)
|
||||
{
|
||||
knMapLinearMACGridToVec3_FLIP(parts, flags, vel, velOld, partVel, flipRatio, ptype, exclude);
|
||||
|
@ -2538,7 +2538,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipVelocityUpdate", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2549,7 +2549,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
"partVel", 4, &_lock);
|
||||
const Real flipRatio = _args.get<Real>("flipRatio", 5, &_lock);
|
||||
const ParticleDataImpl<int> *ptype = _args.getPtrOpt<ParticleDataImpl<int>>(
|
||||
"ptype", 6, NULL, &_lock);
|
||||
"ptype", 6, nullptr, &_lock);
|
||||
const int exclude = _args.getOpt<int>("exclude", 7, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
flipVelocityUpdate(flags, vel, velOld, parts, partVel, flipRatio, ptype, exclude);
|
||||
|
@ -2700,7 +2700,7 @@ struct knCombineVels : public KernelBase {
|
|||
void combineGridVel(MACGrid &vel,
|
||||
const Grid<Vec3> &weight,
|
||||
MACGrid &combineVel,
|
||||
const LevelsetGrid *phi = NULL,
|
||||
const LevelsetGrid *phi = nullptr,
|
||||
Real narrowBand = 0.0,
|
||||
Real thresh = 0.0)
|
||||
{
|
||||
|
@ -2713,13 +2713,13 @@ static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "combineGridVel", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
const Grid<Vec3> &weight = *_args.getPtr<Grid<Vec3>>("weight", 1, &_lock);
|
||||
MACGrid &combineVel = *_args.getPtr<MACGrid>("combineVel", 2, &_lock);
|
||||
const LevelsetGrid *phi = _args.getPtrOpt<LevelsetGrid>("phi", 3, NULL, &_lock);
|
||||
const LevelsetGrid *phi = _args.getPtrOpt<LevelsetGrid>("phi", 3, nullptr, &_lock);
|
||||
Real narrowBand = _args.getOpt<Real>("narrowBand", 4, 0.0, &_lock);
|
||||
Real thresh = _args.getOpt<Real>("thresh", 5, 0.0, &_lock);
|
||||
_retval = getPyNone();
|
||||
|
@ -2754,7 +2754,7 @@ static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getLaplacian", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &laplacian = *_args.getPtr<Grid<Real>>("laplacian", 0, &_lock);
|
||||
|
@ -2790,7 +2790,7 @@ static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getCurvature", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &curv = *_args.getPtr<Grid<Real>>("curv", 0, &_lock);
|
||||
|
|
|
@ -404,7 +404,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getSpiralVelocity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -454,7 +454,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setGradientYWeight", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &W = *_args.getPtr<Grid<Real>>("W", 0, &_lock);
|
||||
|
@ -574,10 +574,10 @@ void solvePressure(MACGrid &vel,
|
|||
Grid<Real> &pressure,
|
||||
const FlagGrid &flags,
|
||||
Real cgAccuracy = 1e-3,
|
||||
const Grid<Real> *phi = 0,
|
||||
const Grid<Real> *perCellCorr = 0,
|
||||
const MACGrid *fractions = 0,
|
||||
const MACGrid *obvel = 0,
|
||||
const Grid<Real> *phi = nullptr,
|
||||
const Grid<Real> *perCellCorr = nullptr,
|
||||
const MACGrid *fractions = nullptr,
|
||||
const MACGrid *obvel = nullptr,
|
||||
Real gfClamp = 1e-04,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
bool precondition = true,
|
||||
|
@ -585,9 +585,9 @@ void solvePressure(MACGrid &vel,
|
|||
bool enforceCompatibility = false,
|
||||
bool useL2Norm = false,
|
||||
bool zeroPressureFixing = false,
|
||||
const Grid<Real> *curv = NULL,
|
||||
const Grid<Real> *curv = nullptr,
|
||||
const Real surfTens = 0.0,
|
||||
Grid<Real> *retRhs = NULL);
|
||||
Grid<Real> *retRhs = nullptr);
|
||||
|
||||
//! Main function for fluid guiding , includes "regular" pressure solve
|
||||
|
||||
|
@ -603,16 +603,16 @@ void PD_fluid_guiding(MACGrid &vel,
|
|||
Real epsRel = 1e-3,
|
||||
Real epsAbs = 1e-3,
|
||||
int maxIters = 200,
|
||||
Grid<Real> *phi = 0,
|
||||
Grid<Real> *perCellCorr = 0,
|
||||
MACGrid *fractions = 0,
|
||||
MACGrid *obvel = 0,
|
||||
Grid<Real> *phi = nullptr,
|
||||
Grid<Real> *perCellCorr = nullptr,
|
||||
MACGrid *fractions = nullptr,
|
||||
MACGrid *obvel = nullptr,
|
||||
Real gfClamp = 1e-04,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
Real cgAccuracy = 1e-3,
|
||||
int preconditioner = 1,
|
||||
bool zeroPressureFixing = false,
|
||||
const Grid<Real> *curv = NULL,
|
||||
const Grid<Real> *curv = nullptr,
|
||||
const Real surfTens = 0.)
|
||||
{
|
||||
FluidSolver *parent = vel.getParent();
|
||||
|
@ -693,7 +693,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "PD_fluid_guiding", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
|
@ -708,16 +708,16 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
Real epsRel = _args.getOpt<Real>("epsRel", 9, 1e-3, &_lock);
|
||||
Real epsAbs = _args.getOpt<Real>("epsAbs", 10, 1e-3, &_lock);
|
||||
int maxIters = _args.getOpt<int>("maxIters", 11, 200, &_lock);
|
||||
Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 12, 0, &_lock);
|
||||
Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 13, 0, &_lock);
|
||||
MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 14, 0, &_lock);
|
||||
MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 15, 0, &_lock);
|
||||
Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 12, nullptr, &_lock);
|
||||
Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 13, nullptr, &_lock);
|
||||
MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 14, nullptr, &_lock);
|
||||
MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 15, nullptr, &_lock);
|
||||
Real gfClamp = _args.getOpt<Real>("gfClamp", 16, 1e-04, &_lock);
|
||||
Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 17, 1.5, &_lock);
|
||||
Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 18, 1e-3, &_lock);
|
||||
int preconditioner = _args.getOpt<int>("preconditioner", 19, 1, &_lock);
|
||||
bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 20, false, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 21, NULL, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 21, nullptr, &_lock);
|
||||
const Real surfTens = _args.getOpt<Real>("surfTens", 22, 0., &_lock);
|
||||
_retval = getPyNone();
|
||||
PD_fluid_guiding(vel,
|
||||
|
@ -775,7 +775,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "releaseBlurPrecomp", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
_retval = getPyNone();
|
||||
|
|
|
@ -154,7 +154,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "densityInflow", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -273,7 +273,7 @@ struct KnAddNoise : public KernelBase {
|
|||
void addNoise(const FlagGrid &flags,
|
||||
Grid<Real> &density,
|
||||
const WaveletNoiseField &noise,
|
||||
const Grid<Real> *sdf = NULL,
|
||||
const Grid<Real> *sdf = nullptr,
|
||||
Real scale = 1.0)
|
||||
{
|
||||
KnAddNoise(flags, density, noise, sdf, scale);
|
||||
|
@ -285,13 +285,13 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addNoise", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 1, &_lock);
|
||||
const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
|
||||
const Grid<Real> *sdf = _args.getPtrOpt<Grid<Real>>("sdf", 3, NULL, &_lock);
|
||||
const Grid<Real> *sdf = _args.getPtrOpt<Grid<Real>>("sdf", 3, nullptr, &_lock);
|
||||
Real scale = _args.getOpt<Real>("scale", 4, 1.0, &_lock);
|
||||
_retval = getPyNone();
|
||||
addNoise(flags, density, noise, sdf, scale);
|
||||
|
@ -448,7 +448,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setNoisePdata", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -489,7 +489,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setNoisePdataVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -530,7 +530,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setNoisePdataInt", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -592,7 +592,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "obstacleGradient", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -636,7 +636,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "obstacleLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -777,7 +777,7 @@ struct KnApplyEmission : public KernelBase {
|
|||
void applyEmission(FlagGrid &flags,
|
||||
Grid<Real> &target,
|
||||
Grid<Real> &source,
|
||||
Grid<Real> *emissionTexture = NULL,
|
||||
Grid<Real> *emissionTexture = nullptr,
|
||||
bool isAbsolute = true,
|
||||
int type = 0)
|
||||
{
|
||||
|
@ -790,14 +790,14 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "applyEmission", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
|
||||
Grid<Real> &source = *_args.getPtr<Grid<Real>>("source", 2, &_lock);
|
||||
Grid<Real> *emissionTexture = _args.getPtrOpt<Grid<Real>>(
|
||||
"emissionTexture", 3, NULL, &_lock);
|
||||
"emissionTexture", 3, nullptr, &_lock);
|
||||
bool isAbsolute = _args.getOpt<bool>("isAbsolute", 4, true, &_lock);
|
||||
int type = _args.getOpt<int>("type", 5, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
|
@ -925,7 +925,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "densityInflowMeshNoise", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -974,7 +974,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "densityInflowMesh", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -1161,12 +1161,12 @@ struct KnResetInObstacle : public KernelBase {
|
|||
void resetInObstacle(FlagGrid &flags,
|
||||
MACGrid &vel,
|
||||
Grid<Real> *density,
|
||||
Grid<Real> *heat = NULL,
|
||||
Grid<Real> *fuel = NULL,
|
||||
Grid<Real> *flame = NULL,
|
||||
Grid<Real> *red = NULL,
|
||||
Grid<Real> *green = NULL,
|
||||
Grid<Real> *blue = NULL,
|
||||
Grid<Real> *heat = nullptr,
|
||||
Grid<Real> *fuel = nullptr,
|
||||
Grid<Real> *flame = nullptr,
|
||||
Grid<Real> *red = nullptr,
|
||||
Grid<Real> *green = nullptr,
|
||||
Grid<Real> *blue = nullptr,
|
||||
Real resetValue = 0)
|
||||
{
|
||||
KnResetInObstacle(flags, vel, density, heat, fuel, flame, red, green, blue, resetValue);
|
||||
|
@ -1178,18 +1178,18 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "resetInObstacle", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 1, &_lock);
|
||||
Grid<Real> *density = _args.getPtr<Grid<Real>>("density", 2, &_lock);
|
||||
Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 3, NULL, &_lock);
|
||||
Grid<Real> *fuel = _args.getPtrOpt<Grid<Real>>("fuel", 4, NULL, &_lock);
|
||||
Grid<Real> *flame = _args.getPtrOpt<Grid<Real>>("flame", 5, NULL, &_lock);
|
||||
Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 6, NULL, &_lock);
|
||||
Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 7, NULL, &_lock);
|
||||
Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 8, NULL, &_lock);
|
||||
Grid<Real> *heat = _args.getPtrOpt<Grid<Real>>("heat", 3, nullptr, &_lock);
|
||||
Grid<Real> *fuel = _args.getPtrOpt<Grid<Real>>("fuel", 4, nullptr, &_lock);
|
||||
Grid<Real> *flame = _args.getPtrOpt<Grid<Real>>("flame", 5, nullptr, &_lock);
|
||||
Grid<Real> *red = _args.getPtrOpt<Grid<Real>>("red", 6, nullptr, &_lock);
|
||||
Grid<Real> *green = _args.getPtrOpt<Grid<Real>>("green", 7, nullptr, &_lock);
|
||||
Grid<Real> *blue = _args.getPtrOpt<Grid<Real>>("blue", 8, nullptr, &_lock);
|
||||
Real resetValue = _args.getOpt<Real>("resetValue", 9, 0, &_lock);
|
||||
_retval = getPyNone();
|
||||
resetInObstacle(flags, vel, density, heat, fuel, flame, red, green, blue, resetValue);
|
||||
|
@ -1216,7 +1216,7 @@ void PbRegister_resetInObstacle()
|
|||
//! check for symmetry , optionally enfore by copying
|
||||
|
||||
void checkSymmetry(
|
||||
Grid<Real> &a, Grid<Real> *err = NULL, bool symmetrize = false, int axis = 0, int bound = 0)
|
||||
Grid<Real> &a, Grid<Real> *err = nullptr, bool symmetrize = false, int axis = 0, int bound = 0)
|
||||
{
|
||||
const int c = axis;
|
||||
const int s = a.getSize()[c];
|
||||
|
@ -1241,11 +1241,11 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "checkSymmetry", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &a = *_args.getPtr<Grid<Real>>("a", 0, &_lock);
|
||||
Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, NULL, &_lock);
|
||||
Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, nullptr, &_lock);
|
||||
bool symmetrize = _args.getOpt<bool>("symmetrize", 2, false, &_lock);
|
||||
int axis = _args.getOpt<int>("axis", 3, 0, &_lock);
|
||||
int bound = _args.getOpt<int>("bound", 4, 0, &_lock);
|
||||
|
@ -1272,7 +1272,7 @@ void PbRegister_checkSymmetry()
|
|||
//! check for symmetry , mac grid version
|
||||
|
||||
void checkSymmetryVec3(Grid<Vec3> &a,
|
||||
Grid<Real> *err = NULL,
|
||||
Grid<Real> *err = nullptr,
|
||||
bool symmetrize = false,
|
||||
int axis = 0,
|
||||
int bound = 0,
|
||||
|
@ -1359,11 +1359,11 @@ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "checkSymmetryVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &a = *_args.getPtr<Grid<Vec3>>("a", 0, &_lock);
|
||||
Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, NULL, &_lock);
|
||||
Grid<Real> *err = _args.getPtrOpt<Grid<Real>>("err", 1, nullptr, &_lock);
|
||||
bool symmetrize = _args.getOpt<bool>("symmetrize", 2, false, &_lock);
|
||||
int axis = _args.getOpt<int>("axis", 3, 0, &_lock);
|
||||
int bound = _args.getOpt<int>("bound", 4, 0, &_lock);
|
||||
|
@ -1407,7 +1407,7 @@ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "projectPpmFull", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &val = *_args.getPtr<Grid<Real>>("val", 0, &_lock);
|
||||
|
@ -1453,7 +1453,7 @@ static PyObject *_W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addTestParts", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -1504,7 +1504,7 @@ static PyObject *_W_15(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "pdataMaxDiff", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<Real> *a = _args.getPtr<ParticleDataImpl<Real>>("a", 0, &_lock);
|
||||
|
@ -1539,7 +1539,7 @@ static PyObject *_W_16(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "pdataMaxDiffInt", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<int> *a = _args.getPtr<ParticleDataImpl<int>>("a", 0, &_lock);
|
||||
|
@ -1574,7 +1574,7 @@ static PyObject *_W_17(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "pdataMaxDiffVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const ParticleDataImpl<Vec3> *a = _args.getPtr<ParticleDataImpl<Vec3>>("a", 0, &_lock);
|
||||
|
@ -1620,7 +1620,7 @@ static PyObject *_W_18(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "calcCenterOfMass", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &density = *_args.getPtr<Grid<Real>>("density", 0, &_lock);
|
||||
|
@ -1842,7 +1842,7 @@ static PyObject *_W_19(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "updateFractions", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2007,9 +2007,9 @@ struct KnUpdateFlagsObs : public KernelBase {
|
|||
//! optionally uses fill fractions for obstacle
|
||||
void setObstacleFlags(FlagGrid &flags,
|
||||
const Grid<Real> &phiObs,
|
||||
const MACGrid *fractions = NULL,
|
||||
const Grid<Real> *phiOut = NULL,
|
||||
const Grid<Real> *phiIn = NULL,
|
||||
const MACGrid *fractions = nullptr,
|
||||
const Grid<Real> *phiOut = nullptr,
|
||||
const Grid<Real> *phiIn = nullptr,
|
||||
int boundaryWidth = 1)
|
||||
{
|
||||
KnUpdateFlagsObs(flags, fractions, phiObs, phiOut, phiIn, boundaryWidth);
|
||||
|
@ -2021,14 +2021,14 @@ static PyObject *_W_20(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setObstacleFlags", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 1, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 2, NULL, &_lock);
|
||||
const Grid<Real> *phiOut = _args.getPtrOpt<Grid<Real>>("phiOut", 3, NULL, &_lock);
|
||||
const Grid<Real> *phiIn = _args.getPtrOpt<Grid<Real>>("phiIn", 4, NULL, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 2, nullptr, &_lock);
|
||||
const Grid<Real> *phiOut = _args.getPtrOpt<Grid<Real>>("phiOut", 3, nullptr, &_lock);
|
||||
const Grid<Real> *phiIn = _args.getPtrOpt<Grid<Real>>("phiIn", 4, nullptr, &_lock);
|
||||
int boundaryWidth = _args.getOpt<int>("boundaryWidth", 5, 1, &_lock);
|
||||
_retval = getPyNone();
|
||||
setObstacleFlags(flags, phiObs, fractions, phiOut, phiIn, boundaryWidth);
|
||||
|
@ -2166,7 +2166,7 @@ static PyObject *_W_21(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "initVortexVelocity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &phiObs = *_args.getPtr<Grid<Real>>("phiObs", 0, &_lock);
|
||||
|
@ -2203,10 +2203,10 @@ struct GaussianKernelCreator {
|
|||
int mDim;
|
||||
float *mMat1D;
|
||||
|
||||
GaussianKernelCreator() : mSigma(0.0f), mDim(0), mMat1D(NULL)
|
||||
GaussianKernelCreator() : mSigma(0.0f), mDim(0), mMat1D(nullptr)
|
||||
{
|
||||
}
|
||||
GaussianKernelCreator(float sigma, int dim = 0) : mSigma(0.0f), mDim(0), mMat1D(NULL)
|
||||
GaussianKernelCreator(float sigma, int dim = 0) : mSigma(0.0f), mDim(0), mMat1D(nullptr)
|
||||
{
|
||||
setGaussianSigma(sigma, dim);
|
||||
}
|
||||
|
@ -2518,7 +2518,7 @@ static PyObject *_W_22(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "blurMacGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &oG = *_args.getPtr<MACGrid>("oG", 0, &_lock);
|
||||
|
@ -2554,7 +2554,7 @@ static PyObject *_W_23(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "blurRealGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &oG = *_args.getPtr<Grid<Real>>("oG", 0, &_lock);
|
||||
|
|
|
@ -305,7 +305,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "KEpsilonComputeProduction", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
|
@ -420,7 +420,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "KEpsilonSources", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 0, &_lock);
|
||||
|
@ -469,7 +469,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "KEpsilonBcs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -547,7 +547,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "KEpsilonGradientDiffusion", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &k = *_args.getPtr<Grid<Real>>("k", 0, &_lock);
|
||||
|
|
|
@ -118,7 +118,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "smoothMesh", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
@ -657,7 +657,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "subdivideMesh", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
@ -752,7 +752,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "killSmallComponents", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
|
|
@ -912,7 +912,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "releaseMG", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FluidSolver *solver = _args.getPtrOpt<FluidSolver>("solver", 0, nullptr, &_lock);
|
||||
|
@ -949,10 +949,10 @@ void computePressureRhs(Grid<Real> &rhs,
|
|||
const Grid<Real> &pressure,
|
||||
const FlagGrid &flags,
|
||||
Real cgAccuracy = 1e-3,
|
||||
const Grid<Real> *phi = 0,
|
||||
const Grid<Real> *perCellCorr = 0,
|
||||
const MACGrid *fractions = 0,
|
||||
const MACGrid *obvel = 0,
|
||||
const Grid<Real> *phi = nullptr,
|
||||
const Grid<Real> *perCellCorr = nullptr,
|
||||
const MACGrid *fractions = nullptr,
|
||||
const MACGrid *obvel = nullptr,
|
||||
Real gfClamp = 1e-04,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
bool precondition = true,
|
||||
|
@ -960,7 +960,7 @@ void computePressureRhs(Grid<Real> &rhs,
|
|||
bool enforceCompatibility = false,
|
||||
bool useL2Norm = false,
|
||||
bool zeroPressureFixing = false,
|
||||
const Grid<Real> *curv = NULL,
|
||||
const Grid<Real> *curv = nullptr,
|
||||
const Real surfTens = 0.)
|
||||
{
|
||||
// compute divergence and init right hand side
|
||||
|
@ -977,7 +977,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "computePressureRhs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &rhs = *_args.getPtr<Grid<Real>>("rhs", 0, &_lock);
|
||||
|
@ -985,10 +985,11 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
|
||||
Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-3, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, 0, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 6, 0, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, 0, &_lock);
|
||||
const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 8, 0, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, nullptr, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
|
||||
"perCellCorr", 6, nullptr, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, nullptr, &_lock);
|
||||
const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 8, nullptr, &_lock);
|
||||
Real gfClamp = _args.getOpt<Real>("gfClamp", 9, 1e-04, &_lock);
|
||||
Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 10, 1.5, &_lock);
|
||||
bool precondition = _args.getOpt<bool>("precondition", 11, true, &_lock);
|
||||
|
@ -996,7 +997,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 13, false, &_lock);
|
||||
bool useL2Norm = _args.getOpt<bool>("useL2Norm", 14, false, &_lock);
|
||||
bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 15, false, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 16, NULL, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 16, nullptr, &_lock);
|
||||
const Real surfTens = _args.getOpt<Real>("surfTens", 17, 0., &_lock);
|
||||
_retval = getPyNone();
|
||||
computePressureRhs(rhs,
|
||||
|
@ -1050,9 +1051,9 @@ void solvePressureSystem(Grid<Real> &rhs,
|
|||
Grid<Real> &pressure,
|
||||
const FlagGrid &flags,
|
||||
Real cgAccuracy = 1e-3,
|
||||
const Grid<Real> *phi = 0,
|
||||
const Grid<Real> *perCellCorr = 0,
|
||||
const MACGrid *fractions = 0,
|
||||
const Grid<Real> *phi = nullptr,
|
||||
const Grid<Real> *perCellCorr = nullptr,
|
||||
const MACGrid *fractions = nullptr,
|
||||
Real gfClamp = 1e-04,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
bool precondition = true,
|
||||
|
@ -1060,7 +1061,7 @@ void solvePressureSystem(Grid<Real> &rhs,
|
|||
const bool enforceCompatibility = false,
|
||||
const bool useL2Norm = false,
|
||||
const bool zeroPressureFixing = false,
|
||||
const Grid<Real> *curv = NULL,
|
||||
const Grid<Real> *curv = nullptr,
|
||||
const Real surfTens = 0.)
|
||||
{
|
||||
if (precondition == false)
|
||||
|
@ -1221,7 +1222,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "solvePressureSystem", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &rhs = *_args.getPtr<Grid<Real>>("rhs", 0, &_lock);
|
||||
|
@ -1229,9 +1230,10 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 2, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
|
||||
Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 4, 1e-3, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, 0, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 6, 0, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, 0, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 5, nullptr, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
|
||||
"perCellCorr", 6, nullptr, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 7, nullptr, &_lock);
|
||||
Real gfClamp = _args.getOpt<Real>("gfClamp", 8, 1e-04, &_lock);
|
||||
Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 9, 1.5, &_lock);
|
||||
bool precondition = _args.getOpt<bool>("precondition", 10, true, &_lock);
|
||||
|
@ -1240,7 +1242,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
"enforceCompatibility", 12, false, &_lock);
|
||||
const bool useL2Norm = _args.getOpt<bool>("useL2Norm", 13, false, &_lock);
|
||||
const bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 14, false, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, NULL, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, nullptr, &_lock);
|
||||
const Real surfTens = _args.getOpt<Real>("surfTens", 16, 0., &_lock);
|
||||
_retval = getPyNone();
|
||||
solvePressureSystem(rhs,
|
||||
|
@ -1284,9 +1286,9 @@ void correctVelocity(MACGrid &vel,
|
|||
Grid<Real> &pressure,
|
||||
const FlagGrid &flags,
|
||||
Real cgAccuracy = 1e-3,
|
||||
const Grid<Real> *phi = 0,
|
||||
const Grid<Real> *perCellCorr = 0,
|
||||
const MACGrid *fractions = 0,
|
||||
const Grid<Real> *phi = nullptr,
|
||||
const Grid<Real> *perCellCorr = nullptr,
|
||||
const MACGrid *fractions = nullptr,
|
||||
Real gfClamp = 1e-04,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
bool precondition = true,
|
||||
|
@ -1294,7 +1296,7 @@ void correctVelocity(MACGrid &vel,
|
|||
bool enforceCompatibility = false,
|
||||
bool useL2Norm = false,
|
||||
bool zeroPressureFixing = false,
|
||||
const Grid<Real> *curv = NULL,
|
||||
const Grid<Real> *curv = nullptr,
|
||||
const Real surfTens = 0.)
|
||||
{
|
||||
knCorrectVelocity(flags, vel, pressure);
|
||||
|
@ -1311,16 +1313,17 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "correctVelocity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 1, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
|
||||
Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 3, 1e-3, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, 0, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 5, 0, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, 0, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, nullptr, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
|
||||
"perCellCorr", 5, nullptr, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, nullptr, &_lock);
|
||||
Real gfClamp = _args.getOpt<Real>("gfClamp", 7, 1e-04, &_lock);
|
||||
Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 8, 1.5, &_lock);
|
||||
bool precondition = _args.getOpt<bool>("precondition", 9, true, &_lock);
|
||||
|
@ -1328,7 +1331,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 11, false, &_lock);
|
||||
bool useL2Norm = _args.getOpt<bool>("useL2Norm", 12, false, &_lock);
|
||||
bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 13, false, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 14, NULL, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 14, nullptr, &_lock);
|
||||
const Real surfTens = _args.getOpt<Real>("surfTens", 15, 0., &_lock);
|
||||
_retval = getPyNone();
|
||||
correctVelocity(vel,
|
||||
|
@ -1372,10 +1375,10 @@ void solvePressure(MACGrid &vel,
|
|||
Grid<Real> &pressure,
|
||||
const FlagGrid &flags,
|
||||
Real cgAccuracy = 1e-3,
|
||||
const Grid<Real> *phi = 0,
|
||||
const Grid<Real> *perCellCorr = 0,
|
||||
const MACGrid *fractions = 0,
|
||||
const MACGrid *obvel = 0,
|
||||
const Grid<Real> *phi = nullptr,
|
||||
const Grid<Real> *perCellCorr = nullptr,
|
||||
const MACGrid *fractions = nullptr,
|
||||
const MACGrid *obvel = nullptr,
|
||||
Real gfClamp = 1e-04,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
bool precondition = true,
|
||||
|
@ -1383,9 +1386,9 @@ void solvePressure(MACGrid &vel,
|
|||
bool enforceCompatibility = false,
|
||||
bool useL2Norm = false,
|
||||
bool zeroPressureFixing = false,
|
||||
const Grid<Real> *curv = NULL,
|
||||
const Grid<Real> *curv = nullptr,
|
||||
const Real surfTens = 0.,
|
||||
Grid<Real> *retRhs = NULL)
|
||||
Grid<Real> *retRhs = nullptr)
|
||||
{
|
||||
Grid<Real> rhs(vel.getParent());
|
||||
|
||||
|
@ -1455,17 +1458,18 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "solvePressure", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
Grid<Real> &pressure = *_args.getPtr<Grid<Real>>("pressure", 1, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 2, &_lock);
|
||||
Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 3, 1e-3, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, 0, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>("perCellCorr", 5, 0, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, 0, &_lock);
|
||||
const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 7, 0, &_lock);
|
||||
const Grid<Real> *phi = _args.getPtrOpt<Grid<Real>>("phi", 4, nullptr, &_lock);
|
||||
const Grid<Real> *perCellCorr = _args.getPtrOpt<Grid<Real>>(
|
||||
"perCellCorr", 5, nullptr, &_lock);
|
||||
const MACGrid *fractions = _args.getPtrOpt<MACGrid>("fractions", 6, nullptr, &_lock);
|
||||
const MACGrid *obvel = _args.getPtrOpt<MACGrid>("obvel", 7, nullptr, &_lock);
|
||||
Real gfClamp = _args.getOpt<Real>("gfClamp", 8, 1e-04, &_lock);
|
||||
Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 9, 1.5, &_lock);
|
||||
bool precondition = _args.getOpt<bool>("precondition", 10, true, &_lock);
|
||||
|
@ -1473,9 +1477,9 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
bool enforceCompatibility = _args.getOpt<bool>("enforceCompatibility", 12, false, &_lock);
|
||||
bool useL2Norm = _args.getOpt<bool>("useL2Norm", 13, false, &_lock);
|
||||
bool zeroPressureFixing = _args.getOpt<bool>("zeroPressureFixing", 14, false, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, NULL, &_lock);
|
||||
const Grid<Real> *curv = _args.getPtrOpt<Grid<Real>>("curv", 15, nullptr, &_lock);
|
||||
const Real surfTens = _args.getOpt<Real>("surfTens", 16, 0., &_lock);
|
||||
Grid<Real> *retRhs = _args.getPtrOpt<Grid<Real>>("retRhs", 17, NULL, &_lock);
|
||||
Grid<Real> *retRhs = _args.getPtrOpt<Grid<Real>>("retRhs", 17, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
solvePressure(vel,
|
||||
pressure,
|
||||
|
|
|
@ -98,7 +98,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "addForcePvel", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
ParticleDataImpl<Vec3> &vel = *_args.getPtr<ParticleDataImpl<Vec3>>("vel", 0, &_lock);
|
||||
|
@ -227,7 +227,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "updateVelocityFromDeltaPos", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -342,7 +342,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "eulerStep", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
@ -470,7 +470,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setPartType", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
|
|
@ -392,7 +392,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipComputeSecondaryParticlePotentials", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &potTA = *_args.getPtr<Grid<Real>>("potTA", 0, &_lock);
|
||||
|
@ -1041,7 +1041,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipSampleSecondaryParticles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string mode = _args.get<std::string>("mode", 0, &_lock);
|
||||
|
@ -1760,7 +1760,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipUpdateSecondaryParticles", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const std::string mode = _args.get<std::string>("mode", 0, &_lock);
|
||||
|
@ -1895,7 +1895,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipDeleteParticlesInObstacle", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
BasicParticleSystem &pts = *_args.getPtr<BasicParticleSystem>("pts", 0, &_lock);
|
||||
|
@ -1963,7 +1963,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "debugGridInfo", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2069,7 +2069,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setFlagsFromLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2170,7 +2170,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "setMACFromLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &v = *_args.getPtr<MACGrid>("v", 0, &_lock);
|
||||
|
@ -2382,7 +2382,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipComputePotentialTrappedAir", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
|
||||
|
@ -2555,7 +2555,7 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipComputePotentialKineticEnergy", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
|
||||
|
@ -2791,7 +2791,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipComputePotentialWaveCrest", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &pot = *_args.getPtr<Grid<Real>>("pot", 0, &_lock);
|
||||
|
@ -2883,7 +2883,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipComputeSurfaceNormals", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &normal = *_args.getPtr<Grid<Vec3>>("normal", 0, &_lock);
|
||||
|
@ -3040,7 +3040,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "flipUpdateNeighborRatio", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
|
|
@ -2055,7 +2055,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "particleSurfaceTurbulence", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -2159,7 +2159,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "debugCheckParts", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const BasicParticleSystem &parts = *_args.getPtr<BasicParticleSystem>("parts", 0, &_lock);
|
||||
|
|
|
@ -48,7 +48,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "markAsFixed", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
@ -111,7 +111,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "texcoordInflow", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
|
||||
|
@ -155,7 +155,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "meshSmokeInflow", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
|
||||
|
@ -239,8 +239,8 @@ struct KnAcceleration : public KernelBase {
|
|||
|
||||
void vorticitySource(VortexSheetMesh &mesh,
|
||||
Vec3 gravity,
|
||||
const MACGrid *vel = NULL,
|
||||
const MACGrid *velOld = NULL,
|
||||
const MACGrid *vel = nullptr,
|
||||
const MACGrid *velOld = nullptr,
|
||||
Real scale = 0.1,
|
||||
Real maxAmount = 0,
|
||||
Real mult = 1.0)
|
||||
|
@ -289,13 +289,13 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "vorticitySource", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
|
||||
Vec3 gravity = _args.get<Vec3>("gravity", 1, &_lock);
|
||||
const MACGrid *vel = _args.getPtrOpt<MACGrid>("vel", 2, NULL, &_lock);
|
||||
const MACGrid *velOld = _args.getPtrOpt<MACGrid>("velOld", 3, NULL, &_lock);
|
||||
const MACGrid *vel = _args.getPtrOpt<MACGrid>("vel", 2, nullptr, &_lock);
|
||||
const MACGrid *velOld = _args.getPtrOpt<MACGrid>("velOld", 3, nullptr, &_lock);
|
||||
Real scale = _args.getOpt<Real>("scale", 4, 0.1, &_lock);
|
||||
Real maxAmount = _args.getOpt<Real>("maxAmount", 5, 0, &_lock);
|
||||
Real mult = _args.getOpt<Real>("mult", 6, 1.0, &_lock);
|
||||
|
@ -373,7 +373,7 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "smoothVorticity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
|
||||
|
@ -437,7 +437,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "VPseedK41", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
VortexParticleSystem &system = *_args.getPtr<VortexParticleSystem>("system", 0, &_lock);
|
||||
|
@ -473,7 +473,7 @@ void VICintegration(VortexSheetMesh &mesh,
|
|||
Real sigma,
|
||||
Grid<Vec3> &vel,
|
||||
const FlagGrid &flags,
|
||||
Grid<Vec3> *vorticity = NULL,
|
||||
Grid<Vec3> *vorticity = nullptr,
|
||||
Real cgMaxIterFac = 1.5,
|
||||
Real cgAccuracy = 1e-3,
|
||||
Real scale = 0.01,
|
||||
|
@ -604,14 +604,14 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "VICintegration", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
VortexSheetMesh &mesh = *_args.getPtr<VortexSheetMesh>("mesh", 0, &_lock);
|
||||
Real sigma = _args.get<Real>("sigma", 1, &_lock);
|
||||
Grid<Vec3> &vel = *_args.getPtr<Grid<Vec3>>("vel", 2, &_lock);
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 3, &_lock);
|
||||
Grid<Vec3> *vorticity = _args.getPtrOpt<Grid<Vec3>>("vorticity", 4, NULL, &_lock);
|
||||
Grid<Vec3> *vorticity = _args.getPtrOpt<Grid<Vec3>>("vorticity", 4, nullptr, &_lock);
|
||||
Real cgMaxIterFac = _args.getOpt<Real>("cgMaxIterFac", 5, 1.5, &_lock);
|
||||
Real cgAccuracy = _args.getOpt<Real>("cgAccuracy", 6, 1e-3, &_lock);
|
||||
Real scale = _args.getOpt<Real>("scale", 7, 0.01, &_lock);
|
||||
|
@ -665,7 +665,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "densityFromLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const LevelsetGrid &phi = *_args.getPtr<LevelsetGrid>("phi", 0, &_lock);
|
||||
|
|
|
@ -69,7 +69,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "interpolateGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 0, &_lock);
|
||||
|
@ -116,7 +116,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "interpolateGridVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 0, &_lock);
|
||||
|
@ -263,7 +263,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "interpolateMACGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
MACGrid &target = *_args.getPtr<MACGrid>("target", 0, &_lock);
|
||||
|
@ -395,7 +395,7 @@ void applySimpleNoiseVec3(const FlagGrid &flags,
|
|||
Grid<Vec3> &target,
|
||||
const WaveletNoiseField &noise,
|
||||
Real scale = 1.0,
|
||||
const Grid<Real> *weight = NULL)
|
||||
const Grid<Real> *weight = nullptr)
|
||||
{
|
||||
// note - passing a MAC grid here is slightly inaccurate, we should evaluate each component
|
||||
// separately
|
||||
|
@ -408,14 +408,14 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "applySimpleNoiseVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Grid<Vec3> &target = *_args.getPtr<Grid<Vec3>>("target", 1, &_lock);
|
||||
const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
|
||||
Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
|
||||
const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, NULL, &_lock);
|
||||
const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
applySimpleNoiseVec3(flags, target, noise, scale, weight);
|
||||
_args.check();
|
||||
|
@ -537,7 +537,7 @@ void applySimpleNoiseReal(const FlagGrid &flags,
|
|||
Grid<Real> &target,
|
||||
const WaveletNoiseField &noise,
|
||||
Real scale = 1.0,
|
||||
const Grid<Real> *weight = NULL)
|
||||
const Grid<Real> *weight = nullptr)
|
||||
{
|
||||
knApplySimpleNoiseReal(flags, target, noise, scale, weight);
|
||||
}
|
||||
|
@ -548,14 +548,14 @@ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "applySimpleNoiseReal", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
Grid<Real> &target = *_args.getPtr<Grid<Real>>("target", 1, &_lock);
|
||||
const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
|
||||
Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
|
||||
const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, NULL, &_lock);
|
||||
const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 4, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
applySimpleNoiseReal(flags, target, noise, scale, weight);
|
||||
_args.check();
|
||||
|
@ -763,8 +763,8 @@ void applyNoiseVec3(const FlagGrid &flags,
|
|||
const WaveletNoiseField &noise,
|
||||
Real scale = 1.0,
|
||||
Real scaleSpatial = 1.0,
|
||||
const Grid<Real> *weight = NULL,
|
||||
const Grid<Vec3> *uv = NULL)
|
||||
const Grid<Real> *weight = nullptr,
|
||||
const Grid<Vec3> *uv = nullptr)
|
||||
{
|
||||
// check whether the uv grid has a different resolution
|
||||
bool uvInterpol = false;
|
||||
|
@ -794,7 +794,7 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "applyNoiseVec3", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -802,8 +802,8 @@ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
const WaveletNoiseField &noise = *_args.getPtr<WaveletNoiseField>("noise", 2, &_lock);
|
||||
Real scale = _args.getOpt<Real>("scale", 3, 1.0, &_lock);
|
||||
Real scaleSpatial = _args.getOpt<Real>("scaleSpatial", 4, 1.0, &_lock);
|
||||
const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 5, NULL, &_lock);
|
||||
const Grid<Vec3> *uv = _args.getPtrOpt<Grid<Vec3>>("uv", 6, NULL, &_lock);
|
||||
const Grid<Real> *weight = _args.getPtrOpt<Grid<Real>>("weight", 5, nullptr, &_lock);
|
||||
const Grid<Vec3> *uv = _args.getPtrOpt<Grid<Vec3>>("uv", 6, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
applyNoiseVec3(flags, target, noise, scale, scaleSpatial, weight, uv);
|
||||
_args.check();
|
||||
|
@ -905,7 +905,7 @@ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "computeEnergy", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -943,7 +943,7 @@ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "computeWaveletCoeffs", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &input = *_args.getPtr<Grid<Real>>("input", 0, &_lock);
|
||||
|
@ -968,7 +968,7 @@ void PbRegister_computeWaveletCoeffs()
|
|||
}
|
||||
|
||||
// note - alomst the same as for vorticity confinement
|
||||
void computeVorticity(const MACGrid &vel, Grid<Vec3> &vorticity, Grid<Real> *norm = NULL)
|
||||
void computeVorticity(const MACGrid &vel, Grid<Vec3> &vorticity, Grid<Real> *norm = nullptr)
|
||||
{
|
||||
Grid<Vec3> velCenter(vel.getParent());
|
||||
GetCentered(velCenter, vel);
|
||||
|
@ -983,12 +983,12 @@ static PyObject *_W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "computeVorticity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
Grid<Vec3> &vorticity = *_args.getPtr<Grid<Vec3>>("vorticity", 1, &_lock);
|
||||
Grid<Real> *norm = _args.getPtrOpt<Grid<Real>>("norm", 2, NULL, &_lock);
|
||||
Grid<Real> *norm = _args.getPtrOpt<Grid<Real>>("norm", 2, nullptr, &_lock);
|
||||
_retval = getPyNone();
|
||||
computeVorticity(vel, vorticity, norm);
|
||||
_args.check();
|
||||
|
@ -1104,7 +1104,7 @@ static PyObject *_W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "computeStrainRateMag", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
|
@ -1219,7 +1219,7 @@ static PyObject *_W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "extrapolateSimpleFlags", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -1263,7 +1263,7 @@ static PyObject *_W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "getCurl", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const MACGrid &vel = *_args.getPtr<MACGrid>("vel", 0, &_lock);
|
||||
|
|
|
@ -101,7 +101,7 @@ static PyObject *_W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "calcSecDeriv2d", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Grid<Real> &v = *_args.getPtr<Grid<Real>>("v", 0, &_lock);
|
||||
|
@ -206,7 +206,7 @@ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "totalSum", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &height = *_args.getPtr<Grid<Real>>("height", 0, &_lock);
|
||||
|
@ -243,7 +243,7 @@ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "normalizeSumTo", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Grid<Real> &height = *_args.getPtr<Grid<Real>>("height", 0, &_lock);
|
||||
|
@ -449,7 +449,7 @@ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
|
|||
FluidSolver *parent = _args.obtainParent();
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(parent, "cgSolveWE", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
|
|
@ -74,7 +74,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
|
||||
|
@ -104,7 +104,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
|
||||
|
@ -133,7 +133,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -157,7 +157,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
@ -186,7 +186,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -212,7 +212,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
const Vec3 ¢er = _args.get<Vec3>("center", 0, &_lock);
|
||||
|
@ -241,7 +241,7 @@ class Shape : public PbClass {
|
|||
Shape *pbo = dynamic_cast<Shape *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -504,7 +504,7 @@ class Cylinder : public Shape {
|
|||
Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real r = _args.get<Real>("r", 0, &_lock);
|
||||
|
@ -534,7 +534,7 @@ class Cylinder : public Shape {
|
|||
Cylinder *pbo = dynamic_cast<Cylinder *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Vec3 z = _args.get<Vec3>("z", 0, &_lock);
|
||||
|
|
|
@ -101,7 +101,7 @@ class Timings : public PbClass {
|
|||
Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Timings::display", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -128,7 +128,7 @@ class Timings : public PbClass {
|
|||
Timings *pbo = dynamic_cast<Timings *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "Timings::saveMean", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
std::string file = _args.get<std::string>("file", 0, &_lock);
|
||||
|
|
|
@ -82,7 +82,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
|
|||
Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::resetTexCoords", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
int num = _args.get<int>("num", 0, &_lock);
|
||||
|
@ -110,7 +110,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
|
|||
Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::seed", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Shape *source = _args.getPtr<Shape>("source", 0, &_lock);
|
||||
|
@ -144,7 +144,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
|
|||
Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::synthesize", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
@ -177,7 +177,7 @@ class TurbulenceParticleSystem : public ParticleSystem<TurbulenceParticleData> {
|
|||
Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "TurbulenceParticleSystem::deleteInObstacle", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
FlagGrid &flags = *_args.getPtr<FlagGrid>("flags", 0, &_lock);
|
||||
|
|
|
@ -79,7 +79,7 @@ class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
|
|||
VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::advectSelf", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Real scale = _args.getOpt<Real>("scale", 0, 1.0, &_lock);
|
||||
|
@ -106,7 +106,7 @@ class VortexParticleSystem : public ParticleSystem<VortexParticleData> {
|
|||
VortexParticleSystem *pbo = dynamic_cast<VortexParticleSystem *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "VortexParticleSystem::applyToMesh", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
|
||||
|
|
|
@ -168,7 +168,7 @@ class VortexSheetMesh : public Mesh {
|
|||
VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcCirculation", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -193,7 +193,7 @@ class VortexSheetMesh : public Mesh {
|
|||
VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::calcVorticity", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
@ -218,7 +218,7 @@ class VortexSheetMesh : public Mesh {
|
|||
VortexSheetMesh *pbo = dynamic_cast<VortexSheetMesh *>(Pb::objFromPy(_self));
|
||||
bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
|
||||
pbPreparePlugin(pbo->getParent(), "VortexSheetMesh::reinitTexCoords", !noTiming);
|
||||
PyObject *_retval = 0;
|
||||
PyObject *_retval = nullptr;
|
||||
{
|
||||
ArgLocker _lock;
|
||||
pbo->_args.copy(_args);
|
||||
|
|
Loading…
Reference in New Issue