Welcome to mirror list, hosted at ThFree Co, Russian Federation.

git.blender.org/blender.git - Unnamed repository; edit this file 'description' to name the repository.
summaryrefslogtreecommitdiff
path: root/extern/mantaflow/preprocessed/shapes.h
diff options
context:
space:
mode:
Diffstat (limited to 'extern/mantaflow/preprocessed/shapes.h')
-rw-r--r--extern/mantaflow/preprocessed/shapes.h665
1 files changed, 665 insertions, 0 deletions
diff --git a/extern/mantaflow/preprocessed/shapes.h b/extern/mantaflow/preprocessed/shapes.h
new file mode 100644
index 00000000000..09d3d23d938
--- /dev/null
+++ b/extern/mantaflow/preprocessed/shapes.h
@@ -0,0 +1,665 @@
+
+
+// DO NOT EDIT !
+// This file is generated using the MantaFlow preprocessor (prep generate).
+
+/******************************************************************************
+ *
+ * MantaFlow fluid solver framework
+ * Copyright 2011 Tobias Pfaff, Nils Thuerey
+ *
+ * This program is free software, distributed under the terms of the
+ * Apache License, Version 2.0
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * shapes classes
+ *
+ ******************************************************************************/
+
+#ifndef _SHAPES_H
+#define _SHAPES_H
+
+#include "manta.h"
+#include "vectorbase.h"
+#include "levelset.h"
+
+namespace Manta {
+
+// forward declaration
+class Mesh;
+
+//! Base class for all shapes
+class Shape : public PbClass {
+ public:
+ enum GridType { TypeNone = 0, TypeBox = 1, TypeSphere = 2, TypeCylinder = 3, TypeSlope = 4 };
+
+ Shape(FluidSolver *parent);
+ static int _W_0(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ PbClass *obj = Pb::objFromPy(_self);
+ if (obj)
+ delete obj;
+ try {
+ PbArgs _args(_linargs, _kwds);
+ bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+ pbPreparePlugin(0, "Shape::Shape", !noTiming);
+ {
+ ArgLocker _lock;
+ FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+ obj = new Shape(parent);
+ obj->registerObject(_self, &_args);
+ _args.check();
+ }
+ pbFinalizePlugin(obj->getParent(), "Shape::Shape", !noTiming);
+ return 0;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::Shape", e.what());
+ return -1;
+ }
+ }
+
+ //! Get the type of grid
+ inline GridType getType() const
+ {
+ return mType;
+ }
+
+ //! Apply shape to flag grid, set inside cells to <value>
+ void applyToGrid(GridBase *grid, FlagGrid *respectFlags = 0);
+ static PyObject *_W_1(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
+ FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 1, 0, &_lock);
+ pbo->_args.copy(_args);
+ _retval = getPyNone();
+ pbo->applyToGrid(grid, respectFlags);
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::applyToGrid", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::applyToGrid", e.what());
+ return 0;
+ }
+ }
+
+ void applyToGridSmooth(GridBase *grid,
+ Real sigma = 1.0,
+ Real shift = 0,
+ FlagGrid *respectFlags = 0);
+ static PyObject *_W_2(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ GridBase *grid = _args.getPtr<GridBase>("grid", 0, &_lock);
+ Real sigma = _args.getOpt<Real>("sigma", 1, 1.0, &_lock);
+ Real shift = _args.getOpt<Real>("shift", 2, 0, &_lock);
+ FlagGrid *respectFlags = _args.getPtrOpt<FlagGrid>("respectFlags", 3, 0, &_lock);
+ pbo->_args.copy(_args);
+ _retval = getPyNone();
+ pbo->applyToGridSmooth(grid, sigma, shift, respectFlags);
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::applyToGridSmooth", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::applyToGridSmooth", e.what());
+ return 0;
+ }
+ }
+
+ LevelsetGrid computeLevelset();
+ static PyObject *_W_3(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ pbo->_args.copy(_args);
+ _retval = toPy(pbo->computeLevelset());
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::computeLevelset", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::computeLevelset", e.what());
+ return 0;
+ }
+ }
+
+ void collideMesh(Mesh &mesh);
+ static PyObject *_W_4(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ Mesh &mesh = *_args.getPtr<Mesh>("mesh", 0, &_lock);
+ pbo->_args.copy(_args);
+ _retval = getPyNone();
+ pbo->collideMesh(mesh);
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::collideMesh", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::collideMesh", e.what());
+ return 0;
+ }
+ }
+
+ virtual Vec3 getCenter() const
+ {
+ return Vec3::Zero;
+ }
+ static PyObject *_W_5(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ pbo->_args.copy(_args);
+ _retval = toPy(pbo->getCenter());
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::getCenter", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::getCenter", e.what());
+ return 0;
+ }
+ }
+
+ virtual void setCenter(const Vec3 &center)
+ {
+ }
+ static PyObject *_W_6(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ const Vec3 &center = _args.get<Vec3>("center", 0, &_lock);
+ pbo->_args.copy(_args);
+ _retval = getPyNone();
+ pbo->setCenter(center);
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::setCenter", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::setCenter", e.what());
+ return 0;
+ }
+ }
+
+ virtual Vec3 getExtent() const
+ {
+ return Vec3::Zero;
+ }
+ static PyObject *_W_7(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ pbo->_args.copy(_args);
+ _retval = toPy(pbo->getExtent());
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Shape::getExtent", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Shape::getExtent", e.what());
+ return 0;
+ }
+ }
+
+ //! Inside test of the shape
+ virtual bool isInside(const Vec3 &pos) const;
+ inline bool isInsideGrid(int i, int j, int k) const
+ {
+ return isInside(Vec3(i + 0.5, j + 0.5, k + 0.5));
+ };
+
+ virtual void generateMesh(Mesh *mesh){};
+ virtual void generateLevelset(Grid<Real> &phi){};
+
+ protected:
+ GridType mType;
+ public:
+ PbArgs _args;
+}
+#define _C_Shape
+;
+
+//! Dummy shape
+class NullShape : public Shape {
+ public:
+ NullShape(FluidSolver *parent) : Shape(parent)
+ {
+ }
+ static int _W_8(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ PbClass *obj = Pb::objFromPy(_self);
+ if (obj)
+ delete obj;
+ try {
+ PbArgs _args(_linargs, _kwds);
+ bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+ pbPreparePlugin(0, "NullShape::NullShape", !noTiming);
+ {
+ ArgLocker _lock;
+ FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+ obj = new NullShape(parent);
+ obj->registerObject(_self, &_args);
+ _args.check();
+ }
+ pbFinalizePlugin(obj->getParent(), "NullShape::NullShape", !noTiming);
+ return 0;
+ }
+ catch (std::exception &e) {
+ pbSetError("NullShape::NullShape", e.what());
+ return -1;
+ }
+ }
+
+ virtual bool isInside(const Vec3 &pos) const
+ {
+ return false;
+ }
+ virtual void generateMesh(Mesh *mesh)
+ {
+ }
+
+ protected:
+ virtual void generateLevelset(Grid<Real> &phi)
+ {
+ gridSetConst<Real>(phi, 1000.0f);
+ }
+ public:
+ PbArgs _args;
+}
+#define _C_NullShape
+;
+
+//! Box shape
+class Box : public Shape {
+ public:
+ Box(FluidSolver *parent,
+ Vec3 center = Vec3::Invalid,
+ Vec3 p0 = Vec3::Invalid,
+ Vec3 p1 = Vec3::Invalid,
+ Vec3 size = Vec3::Invalid);
+ static int _W_9(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ PbClass *obj = Pb::objFromPy(_self);
+ if (obj)
+ delete obj;
+ try {
+ PbArgs _args(_linargs, _kwds);
+ bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+ pbPreparePlugin(0, "Box::Box", !noTiming);
+ {
+ ArgLocker _lock;
+ FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+ Vec3 center = _args.getOpt<Vec3>("center", 1, Vec3::Invalid, &_lock);
+ Vec3 p0 = _args.getOpt<Vec3>("p0", 2, Vec3::Invalid, &_lock);
+ Vec3 p1 = _args.getOpt<Vec3>("p1", 3, Vec3::Invalid, &_lock);
+ Vec3 size = _args.getOpt<Vec3>("size", 4, Vec3::Invalid, &_lock);
+ obj = new Box(parent, center, p0, p1, size);
+ obj->registerObject(_self, &_args);
+ _args.check();
+ }
+ pbFinalizePlugin(obj->getParent(), "Box::Box", !noTiming);
+ return 0;
+ }
+ catch (std::exception &e) {
+ pbSetError("Box::Box", e.what());
+ return -1;
+ }
+ }
+
+ inline Vec3 getSize() const
+ {
+ return mP1 - mP0;
+ }
+ inline Vec3 getP0() const
+ {
+ return mP0;
+ }
+ inline Vec3 getP1() const
+ {
+ return mP1;
+ }
+ virtual void setCenter(const Vec3 &center)
+ {
+ Vec3 dh = 0.5 * (mP1 - mP0);
+ mP0 = center - dh;
+ mP1 = center + dh;
+ }
+ virtual Vec3 getCenter() const
+ {
+ return 0.5 * (mP1 + mP0);
+ }
+ virtual Vec3 getExtent() const
+ {
+ return getSize();
+ }
+ virtual bool isInside(const Vec3 &pos) const;
+ virtual void generateMesh(Mesh *mesh);
+ virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+ Vec3 mP0, mP1;
+ public:
+ PbArgs _args;
+}
+#define _C_Box
+;
+
+//! Spherical shape
+class Sphere : public Shape {
+ public:
+ Sphere(FluidSolver *parent, Vec3 center, Real radius, Vec3 scale = Vec3(1, 1, 1));
+ static int _W_10(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ PbClass *obj = Pb::objFromPy(_self);
+ if (obj)
+ delete obj;
+ try {
+ PbArgs _args(_linargs, _kwds);
+ bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+ pbPreparePlugin(0, "Sphere::Sphere", !noTiming);
+ {
+ ArgLocker _lock;
+ FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+ Vec3 center = _args.get<Vec3>("center", 1, &_lock);
+ Real radius = _args.get<Real>("radius", 2, &_lock);
+ Vec3 scale = _args.getOpt<Vec3>("scale", 3, Vec3(1, 1, 1), &_lock);
+ obj = new Sphere(parent, center, radius, scale);
+ obj->registerObject(_self, &_args);
+ _args.check();
+ }
+ pbFinalizePlugin(obj->getParent(), "Sphere::Sphere", !noTiming);
+ return 0;
+ }
+ catch (std::exception &e) {
+ pbSetError("Sphere::Sphere", e.what());
+ return -1;
+ }
+ }
+
+ virtual void setCenter(const Vec3 &center)
+ {
+ mCenter = center;
+ }
+ virtual Vec3 getCenter() const
+ {
+ return mCenter;
+ }
+ inline Real getRadius() const
+ {
+ return mRadius;
+ }
+ virtual Vec3 getExtent() const
+ {
+ return Vec3(2.0 * mRadius);
+ }
+ virtual bool isInside(const Vec3 &pos) const;
+ virtual void generateMesh(Mesh *mesh);
+ virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+ Vec3 mCenter, mScale;
+ Real mRadius;
+ public:
+ PbArgs _args;
+}
+#define _C_Sphere
+;
+
+//! Cylindrical shape
+class Cylinder : public Shape {
+ public:
+ Cylinder(FluidSolver *parent, Vec3 center, Real radius, Vec3 z);
+ static int _W_11(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ PbClass *obj = Pb::objFromPy(_self);
+ if (obj)
+ delete obj;
+ try {
+ PbArgs _args(_linargs, _kwds);
+ bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+ pbPreparePlugin(0, "Cylinder::Cylinder", !noTiming);
+ {
+ ArgLocker _lock;
+ FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+ Vec3 center = _args.get<Vec3>("center", 1, &_lock);
+ Real radius = _args.get<Real>("radius", 2, &_lock);
+ Vec3 z = _args.get<Vec3>("z", 3, &_lock);
+ obj = new Cylinder(parent, center, radius, z);
+ obj->registerObject(_self, &_args);
+ _args.check();
+ }
+ pbFinalizePlugin(obj->getParent(), "Cylinder::Cylinder", !noTiming);
+ return 0;
+ }
+ catch (std::exception &e) {
+ pbSetError("Cylinder::Cylinder", e.what());
+ return -1;
+ }
+ }
+
+ void setRadius(Real r)
+ {
+ mRadius = r;
+ }
+ static PyObject *_W_12(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ Real r = _args.get<Real>("r", 0, &_lock);
+ pbo->_args.copy(_args);
+ _retval = getPyNone();
+ pbo->setRadius(r);
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Cylinder::setRadius", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Cylinder::setRadius", e.what());
+ return 0;
+ }
+ }
+
+ void setZ(Vec3 z)
+ {
+ mZDir = z;
+ mZ = normalize(mZDir);
+ }
+ static PyObject *_W_13(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ try {
+ PbArgs _args(_linargs, _kwds);
+ 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;
+ {
+ ArgLocker _lock;
+ Vec3 z = _args.get<Vec3>("z", 0, &_lock);
+ pbo->_args.copy(_args);
+ _retval = getPyNone();
+ pbo->setZ(z);
+ pbo->_args.check();
+ }
+ pbFinalizePlugin(pbo->getParent(), "Cylinder::setZ", !noTiming);
+ return _retval;
+ }
+ catch (std::exception &e) {
+ pbSetError("Cylinder::setZ", e.what());
+ return 0;
+ }
+ }
+
+ virtual void setCenter(const Vec3 &center)
+ {
+ mCenter = center;
+ }
+ virtual Vec3 getCenter() const
+ {
+ return mCenter;
+ }
+ inline Real getRadius() const
+ {
+ return mRadius;
+ }
+ inline Vec3 getZ() const
+ {
+ return mZ * mZDir;
+ }
+ virtual Vec3 getExtent() const
+ {
+ return Vec3(2.0 * sqrt(square(mZ) + square(mRadius)));
+ }
+ virtual bool isInside(const Vec3 &pos) const;
+ virtual void generateMesh(Mesh *mesh);
+ virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+ Vec3 mCenter, mZDir;
+ Real mRadius, mZ;
+ public:
+ PbArgs _args;
+}
+#define _C_Cylinder
+;
+
+//! Slope shape
+// generates a levelset based on a plane
+// plane is specified by two angles and an offset on the y axis in (offset vector would be ( 0,
+// offset, 0) ) the two angles are specified in degrees, between: y-axis and x-axis
+// y-axis and z-axis
+class Slope : public Shape {
+ public:
+ Slope(FluidSolver *parent, Real anglexy, Real angleyz, Real origin, Vec3 gs);
+ static int _W_14(PyObject *_self, PyObject *_linargs, PyObject *_kwds)
+ {
+ PbClass *obj = Pb::objFromPy(_self);
+ if (obj)
+ delete obj;
+ try {
+ PbArgs _args(_linargs, _kwds);
+ bool noTiming = _args.getOpt<bool>("notiming", -1, 0);
+ pbPreparePlugin(0, "Slope::Slope", !noTiming);
+ {
+ ArgLocker _lock;
+ FluidSolver *parent = _args.getPtr<FluidSolver>("parent", 0, &_lock);
+ Real anglexy = _args.get<Real>("anglexy", 1, &_lock);
+ Real angleyz = _args.get<Real>("angleyz", 2, &_lock);
+ Real origin = _args.get<Real>("origin", 3, &_lock);
+ Vec3 gs = _args.get<Vec3>("gs", 4, &_lock);
+ obj = new Slope(parent, anglexy, angleyz, origin, gs);
+ obj->registerObject(_self, &_args);
+ _args.check();
+ }
+ pbFinalizePlugin(obj->getParent(), "Slope::Slope", !noTiming);
+ return 0;
+ }
+ catch (std::exception &e) {
+ pbSetError("Slope::Slope", e.what());
+ return -1;
+ }
+ }
+
+ virtual void setOrigin(const Real &origin)
+ {
+ mOrigin = origin;
+ }
+ virtual void setAnglexy(const Real &anglexy)
+ {
+ mAnglexy = anglexy;
+ }
+ virtual void setAngleyz(const Real &angleyz)
+ {
+ mAnglexy = angleyz;
+ }
+
+ inline Real getOrigin() const
+ {
+ return mOrigin;
+ }
+ inline Real getmAnglexy() const
+ {
+ return mAnglexy;
+ }
+ inline Real getmAngleyz() const
+ {
+ return mAngleyz;
+ }
+ virtual bool isInside(const Vec3 &pos) const;
+ virtual void generateMesh(Mesh *mesh);
+ virtual void generateLevelset(Grid<Real> &phi);
+
+ protected:
+ Real mAnglexy, mAngleyz;
+ Real mOrigin;
+ Vec3 mGs;
+ public:
+ PbArgs _args;
+}
+#define _C_Slope
+;
+
+} // namespace Manta
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-29 22:33:40 +0300