repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
pavelsevecek/OpenSPH
|
core/objects/wrappers/Expected.h
|
#pragma once
/// \file Expected.h
/// \brief Wrapper of type containing either a value or an error message
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/wrappers/Variant.h"
NAMESPACE_SPH_BEGIN
struct UnexpectedTag {};
const UnexpectedTag UNEXPECTED;
/// \brief Wrapper of type that either contains a value of given type, or an error message.
///
/// Expected is designed as a return type. When talking about 'expected' value, it means no error has been
/// encounter and Expected contains value of given type; 'unexpected' value means that Expected contains an
/// error message.
///
/// Inspired by <NAME> - Systematic Error Handling in C++
/// https://channel9.msdn.com/Shows/Going+Deep/C-and-Beyond-2012-Andrei-Alexandrescu-Systematic-Error-Handling-in-C
template <typename Type, typename Error = std::string>
class Expected {
private:
/// Wrapper to avoid issues if the value type is the same as the error
struct UnexpectedWrapper {
Error error;
};
// first type is dummy to use the default constructor of variant
Variant<NothingType, Type, UnexpectedWrapper> data;
public:
/// \brief Construct the expected value using default constructor.
///
/// Should be avoided if possible as Expected is mainly designed as a value returned from function, but
/// nevertheless the default constructor is defined for convenience.
Expected() {
data.template emplace<Type>();
}
/// Constructs an expected value.
template <typename T, typename = std::enable_if_t<std::is_constructible<Type, T>::value>>
Expected(T&& value) {
data.template emplace<Type>(std::forward<T>(value));
}
/// Constructs an unexpected value.
template <typename TError, typename = std::enable_if_t<std::is_constructible<Error, TError>::value>>
Expected(UnexpectedTag, TError&& error) {
data.template emplace<UnexpectedWrapper>(UnexpectedWrapper{ std::forward<TError>(error) });
}
/// Conversion to bool, checking whether object constains expected value.
explicit operator bool() const {
return isExpected();
}
/// Negation operator, returns true if object does NOT contain expected value.
bool operator!() const {
return !isExpected();
}
/// \brief Returns the reference to expected value.
///
/// Object must not contain unexpected value, checked by assert.
Type& value() {
SPH_ASSERT(isExpected());
return data.template get<Type>();
}
/// \brief Returns the const reference to expected value.
///
/// Object must not contain unexpected value, checked by assert.
const Type& value() const {
SPH_ASSERT(isExpected());
return data.template get<Type>();
}
/// \brief Returns the expected value or given alternative if the object contains unexpected value.
Type valueOr(const Type& other) const {
if (isExpected()) {
return this->value();
} else {
return other;
}
}
/// \brief Returns the error message.
///
/// Object must contain unexpected value, checked by assert.
const Error& error() const {
SPH_ASSERT(!isExpected());
return data.template get<UnexpectedWrapper>().error;
}
/// \brief Operator -> for convenient access to member variables and functions of expected value.
///
/// If the object contains unexpected, throws an assert.
Type* operator->() {
SPH_ASSERT(isExpected());
return &value();
}
/// \copydoc Type* operator->()
const Type* operator->() const {
SPH_ASSERT(isExpected());
return &value();
}
private:
bool isExpected() const {
return data.getTypeIdx() == 1;
}
};
/// \brief Prints the expected value into a stream.
///
/// If the object contains an expected value, prints the value into the stream, otherwise print the error
/// message. Enabled only if the wrapped type defines the operator<<, to that it corretly works with Catch
/// framework.
template <typename T, typename = decltype(std::declval<std::ostream&>() << std::declval<T>())>
inline std::ostream& operator<<(std::ostream& stream, const Expected<T>& expected) {
if (expected) {
stream << expected.value();
} else {
stream << expected.error();
}
return stream;
}
/// \brief Constructs an unexpected value of given type, given error message as std::string.
///
/// For other type of error messages, use constructor of Expected.
template <typename Type>
Expected<Type> makeUnexpected(const std::string& error) {
return Expected<Type>(UNEXPECTED, error);
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/io/Logger.h
|
<gh_stars>10-100
#pragma once
/// \file Logger.h
/// \brief Logging routines of the run.
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/Globals.h"
#include "io/Path.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/AutoPtr.h"
#include "objects/wrappers/Flags.h"
#include "system/Timer.h"
#include <iomanip>
NAMESPACE_SPH_BEGIN
/// \brief Interface providing generic (text, human readable) output of the program.
///
/// It's meant for logging current time, some statistics of the simulation, encountered warnings and errors,
/// etc. For output of particle quantities, use \ref IOutput.
class ILogger : public Polymorphic, public Noncopyable {
private:
Size precision = PRECISION;
bool scientific = true;
public:
/// \brief Logs a string message.
///
/// \todo different types (log, warning, error, ...) and levels of verbosity
virtual void writeString(const std::string& s) = 0;
/// \brief Creates and logs a message by concatenating arguments.
///
/// Adds a new line to the output.
template <typename... TArgs>
void write(TArgs&&... args) {
std::stringstream ss;
writeImpl(ss, std::forward<TArgs>(args)...);
ss << std::endl;
this->writeString(ss.str());
}
/// \brief Changes the precision of printed numbers.
///
/// The default value is given by global PRECISION constant.
void setPrecision(const Size newPrecision) {
precision = newPrecision;
}
/// \brief Sets/unsets scientific notation
void setScientific(const bool newScientific) {
scientific = newScientific;
}
private:
template <typename T0, typename... TArgs>
void writeImpl(std::stringstream& ss, T0&& first, TArgs&&... rest) {
ss << std::setprecision(precision);
if (scientific) {
ss << std::scientific;
}
ss << first;
writeImpl(ss, std::forward<TArgs>(rest)...);
}
void writeImpl(std::stringstream& UNUSED(ss)) {}
};
struct Console {
enum class Foreground {
BLACK = 30,
RED = 31,
GREEN = 32,
YELLOW = 33,
BLUE = 34,
MAGENTA = 35,
CYAN = 36,
LIGHT_GRAY = 37,
DARK_GRAY = 90,
LIGHT_RED = 91,
LIGHT_GREEN = 92,
LIGHT_YELLOW = 93,
LIGHT_BLUE = 94,
LIGHT_MAGENTA = 95,
LIGHT_CYAN = 96,
WHITE = 97,
DEFAULT = 39,
UNCHANGED = 0,
} fg = Foreground::UNCHANGED;
enum class Background {
RED = 41,
GREEN = 42,
BLUE = 44,
DEFAULT = 49,
UNCHANGED = 0
} bg = Background::UNCHANGED;
enum class Series {
NORMAL = 0,
BOLD = 1,
} series = Series::NORMAL;
Console() = default;
Console(const Foreground fg)
: fg(fg) {}
Console(const Background bg)
: bg(bg) {}
Console(const Series series)
: series(series) {}
friend std::ostream& operator<<(std::ostream& stream, const Console& mod) {
if (mod.bg != Background::UNCHANGED) {
stream << "\033[" << int(mod.bg) << "m";
}
if (mod.fg != Foreground::UNCHANGED) {
stream << "\033[" << int(mod.fg) << "m";
}
stream << "\e[" << int(mod.series) << "m";
return stream;
}
};
struct ScopedConsole {
ScopedConsole(const Console console);
~ScopedConsole();
};
/// \brief Standard output logger.
///
/// This is just a wrapper of std::cout with ILogger interface, it does not tructed on spot with no
/// cost. All StdOutLoggers print to the same output.
class StdOutLogger : public ILogger {
public:
virtual void writeString(const std::string& s) override;
};
/// \brief Logger writing messages to string stream
class StringLogger : public ILogger {
private:
std::stringstream ss;
public:
virtual void writeString(const std::string& s) override;
/// Removes all written messages from the string.
void clean();
/// Returns all written messages as a string. Messages are not erased from the logger by this
std::string toString() const;
};
/// File output logger
class FileLogger : public ILogger {
public:
enum class Options {
/// Opens the associated file when the logger is constructed and closes it in destructor. This is
/// the default behavior of the logger, nevertheless this option can be explicitly specified to
/// increase readability of the code.
KEEP_OPENED = 0,
/// Open the file only for writing and close it immediately afterwards. If the file cannot be opened,
/// the message is not written into the log without throwing any exception. This option implies
/// appending to existing content.
OPEN_WHEN_WRITING = 1 << 0,
/// If the file already exists, the new messages are appended to existing content instead of erasing
/// the file.
APPEND = 1 << 1,
/// Adds a time of writing before each message.
ADD_TIMESTAMP = 1 << 2,
};
private:
AutoPtr<std::ofstream> stream;
Path path;
Flags<Options> flags;
public:
FileLogger(const Path& path, const Flags<Options> flags = EMPTY_FLAGS);
~FileLogger();
virtual void writeString(const std::string& s) override;
};
/// \brief Class holding multiple loggers and writing messages to all of them.
///
/// The objects is the owner of loggers.
class MultiLogger : public ILogger {
private:
Array<AutoPtr<ILogger>> loggers;
public:
Size getLoggerCnt() const {
return loggers.size();
}
void add(AutoPtr<ILogger>&& logger) {
loggers.push(std::move(logger));
}
virtual void writeString(const std::string& s) override {
for (auto& l : loggers) {
l->writeString(s);
}
}
};
/// \brief Helper logger that does not write anything.
class NullLogger : public ILogger {
public:
virtual void writeString(const std::string& UNUSED(s)) override {}
};
/// \brief RAII guard writing called functions and their durations to a special verbose logger.
class VerboseLogGuard : public Noncopyable {
private:
Timer timer;
public:
/// \brief Creates a guard, should be at the very beginning of a function/scope.
VerboseLogGuard(const std::string& functionName);
~VerboseLogGuard();
};
/// \brief Creates a global verbose logger.
///
/// Provided logger is stored and subsequently used by all \ref VerboseLogGuard objects. There can be only one
/// logger at the same time. Verbose logging can be disabled by passing nullptr into the function.
void setVerboseLogger(AutoPtr<ILogger>&& logger);
/// \brief Helper macro, creating \brief VerboseLogGuard with name of the current function.
#define VERBOSE_LOG VerboseLogGuard __verboseLogGuard(__PRETTY_FUNCTION__);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/utility/OutputIterators.h
|
#pragma once
/// \file OutputIterators.h
/// \brief Helper iterators allowing to save values to containers.
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/Assert.h"
#include <type_traits>
NAMESPACE_SPH_BEGIN
struct OutputIterator {
using iterator_category = std::output_iterator_tag;
using value_type = void;
using difference_type = ptrdiff_t;
using pointer = void;
using reference = void;
};
/// \brief Helper output iterator that simply ignores the written values.
class NullInserter : public OutputIterator {
public:
NullInserter& operator*() {
return *this;
}
NullInserter& operator++() {
return *this;
}
template <typename TValue>
NullInserter& operator=(TValue&&) {
return *this;
}
};
/// \brief Output iterator that inserts the written values to the given container using \ref insert function.
template <typename TContainer>
class Inserter : public OutputIterator {
private:
TContainer& container;
public:
explicit Inserter(TContainer& container)
: container(container) {}
Inserter& operator*() {
return *this;
}
Inserter& operator++() {
return *this;
}
template <typename TValue>
Inserter& operator=(TValue&& value) {
container.insert(std::forward<TValue>(value));
return *this;
}
};
template <typename TContainer>
Inserter<TContainer> inserter(TContainer& c) {
return Inserter<TContainer>(c);
}
/// \brief Output iterator that inserts the written values to the given container using \ref push function.
template <typename TContainer>
class BackInserter : public OutputIterator {
private:
TContainer& container;
public:
explicit BackInserter(TContainer& container)
: container(container) {}
BackInserter& operator*() {
return *this;
}
BackInserter& operator++() {
return *this;
}
template <typename TValue>
BackInserter& operator=(TValue&& value) {
container.push(std::forward<TValue>(value));
return *this;
}
};
template <typename TContainer>
BackInserter<TContainer> backInserter(TContainer& c) {
return BackInserter<TContainer>(c);
}
/// \brief Output iterator that calls given functor for all written values.
template <typename TFunctor>
class FunctorCaller : public OutputIterator {
private:
TFunctor func;
public:
FunctorCaller(TFunctor&& func)
: func(std::move(func)) {}
FunctorCaller& operator*() {
return *this;
}
FunctorCaller& operator++() {
return *this;
}
template <typename TValue>
FunctorCaller& operator=(TValue&& value) {
func(std::forward<TValue>(value));
return *this;
}
};
template <typename TFunctor>
FunctorCaller<std::decay_t<TFunctor>> functorCaller(TFunctor&& functor) {
return FunctorCaller<std::decay_t<TFunctor>>(std::forward<TFunctor>(functor));
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/post/Plot.h
|
<gh_stars>10-100
#pragma once
/// \file Plot.h
/// \brief Drawing quantity values as functions of time or spatial coordinates
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/containers/Queue.h"
#include "objects/utility/OperatorTemplate.h"
#include "physics/Integrals.h"
#include "post/Analysis.h"
NAMESPACE_SPH_BEGIN
struct PlotPoint;
struct ErrorPlotPoint;
class AffineMatrix2;
class IDrawPath : public Polymorphic {
public:
/// \brief Adds a next point on the path
virtual void addPoint(const PlotPoint& point) = 0;
/// \brief Closes the path, connecting to the first point on the path
virtual void closePath() = 0;
/// \brief Finalizes the path. Does not connect the last point to anything.
virtual void endPath() = 0;
};
/// \brief Abstraction of a drawing context.
///
/// Object operates in plot coordinates.
class IDrawingContext : public Polymorphic {
public:
/// \brief Adds a single point to the plot
///
/// The plot is drawn by implementation-defined style.
virtual void drawPoint(const PlotPoint& point) = 0;
/// \brief Adds a point with error bars to the plot.
virtual void drawErrorPoint(const ErrorPlotPoint& point) = 0;
/// \brief Draws a line connecting two points.
///
/// The ending points are not drawn; call \ref drawPoint manually if you wish to draw both lines and the
/// points.
virtual void drawLine(const PlotPoint& from, const PlotPoint& to) = 0;
/// \brief Draws a path connecting points.
///
/// The path copies the state from the parent drawing context, so if a drawing style of the context
/// changes, the change does not affect already existing paths.
virtual AutoPtr<IDrawPath> drawPath() = 0;
/// \brief Changes the current drawing style.
///
/// Interpretation of the style is implementation-defined. It is assumed that the derived classes will
/// have a predefined set of drawing styles, this function will then selects the style with appropriate
/// index.
/// \param index Index of the selected style.
virtual void setStyle(const Size index) = 0;
/// \brief Applies the given tranformation matrix on all primitives.
///
/// This does not affect already drawn primitives.
virtual void setTransformMatrix(const AffineMatrix2& matrix) = 0;
};
/// \brief Interface for constructing generic plots from quantities stored in storage.
///
/// The plot can currently be only 2D, typically showing a quantity dependence on time or on some spatial
/// coordinate.
class IPlot : public Polymorphic {
protected:
struct {
Interval x;
Interval y;
} ranges;
public:
/// \brief Returns the plotted range in x-coordinate.
Interval rangeX() const {
return ranges.x;
}
/// \brief Returns the plotted range in y-coordinate.
Interval rangeY() const {
return ranges.y;
}
/// \brief Returns the caption of the plot
virtual std::string getCaption() const = 0;
/// \brief Updates the plot with new data.
///
/// Called every time step.
virtual void onTimeStep(const Storage& storage, const Statistics& stats) = 0;
/// \brief Clears all cached data, prepares for next run.
virtual void clear() = 0;
/// \brief Draws the plot into the drawing context
virtual void plot(IDrawingContext& dc) const = 0;
};
/// \brief Base class for plots showing a dependence of given quantity on a spatial coordinate.
///
/// Currently only works with scalar quantities.
/// \todo Needs to limit the number of drawn points - we definitely dont want to draw 10^5 points.
template <typename TDerived>
class SpatialPlot : public IPlot {
protected:
QuantityId id;
Array<PlotPoint> points;
Optional<Size> binCnt;
public:
/// \brief Constructs the spatial plot.
/// \param id Quantity to plot
/// \param binCnt Number of points in the plot; if NOTHING, each particle is plotted as a point.
explicit SpatialPlot(const QuantityId id, const Optional<Size> binCnt = NOTHING)
: id(id)
, binCnt(binCnt) {}
virtual std::string getCaption() const override {
return getMetadata(id).quantityName;
}
virtual void onTimeStep(const Storage& storage, const Statistics& UNUSED(stats)) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
private:
Float getX(const Vector r) const {
return static_cast<const TDerived*>(this)->getX(r);
}
};
/// \brief Plots a dependence of given quantity on the distance from given axis.
class AxialDistributionPlot : public SpatialPlot<AxialDistributionPlot> {
private:
Vector axis;
public:
AxialDistributionPlot(const Vector& axis, const QuantityId id, const Optional<Size> binCnt = NOTHING)
: SpatialPlot<AxialDistributionPlot>(id, binCnt)
, axis(axis) {}
INLINE Float getX(const Vector& r) const {
return getLength(r - dot(r, axis) * axis);
}
};
/// \brief Plots a dependence of given quantity on the distance from the origin
class RadialDistributionPlot : public SpatialPlot<RadialDistributionPlot> {
public:
RadialDistributionPlot(const QuantityId id, const Optional<Size> binCnt = NOTHING);
INLINE Float getX(const Vector& r) const {
return getLength(r);
}
};
/// \brief Plot of temporal dependence of a scalar quantity.
///
/// Plot shows a given segment of history of a quantity. This segment moves as time goes. Alternatively, the
/// segment can be (formally) infinite, meaning the plot shows the whole history of a quantity; the x-range is
/// rescaled as time goes.
class TemporalPlot : public IPlot {
public:
/// Parameters of the plot
struct Params {
/// Plotted time segment
Float segment = INFTY;
/// Fixed x-range for the plot. If empty, a dynamic range is used.
Interval fixedRangeX = Interval{};
/// Minimal size of the y-range
Float minRangeY = 0._f;
/// When discarting points out of plotted range, shrink y-axis to fit currently visible points
bool shrinkY = false;
/// Maximum number of points on the plot. When exceeded, every second point is removed and the plot
/// period is doubled.
Size maxPointCnt = 100;
/// Time that needs to pass before a new point is added
Float period = 0._f;
};
private:
/// Integral being plotted
IntegralWrapper integral;
/// Points on the timeline; x coordinate is time, y coordinate is the value of the quantity
Queue<PlotPoint> points;
/// Last time a point has been added
Float lastTime = -INFTY;
/// Parameters used to create the plot.
const Params params;
/// Current period of the plot. Initialized with params.period, but may change during the run.
Float actPeriod;
public:
/// Creates a plot showing the whole history of given integral.
TemporalPlot(const IntegralWrapper& integral, const Params& params)
: integral(integral)
, params(params) {
SPH_ASSERT(params.segment > 0._f);
actPeriod = params.period;
}
virtual std::string getCaption() const override {
return integral.getName();
}
virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
private:
/// Checks if given point is presently expired and should be removed from the queue.
bool isExpired(const Float x, const Float t) const;
};
/// \brief Differential histogram of quantities
///
/// Plot doesn't store any history, it is drawed each timestep independently.
class HistogramPlot : public IPlot {
protected:
/// ID of a quantity from which the histogram is constructed.
Post::ExtHistogramId id;
/// Points representing the histogram
Array<Post::HistPoint> points;
/// Interval for which the histogram is constructed.
///
/// If NOTHING, the interval is created by enclosing all x values.
Optional<Interval> interval;
/// Period of redrawing the histogram. Zero means the histogram is drawn every time step.
Float period;
/// Displayed name of the histogram.
std::string name;
Float lastTime = -INFTY;
public:
HistogramPlot(const Post::HistogramId id,
const Optional<Interval> interval,
const Float period,
const std::string& name)
: id(id)
, interval(interval)
, period(period)
, name(name) {}
HistogramPlot(const QuantityId id, const Optional<Interval> interval, const Float period)
: id(id)
, interval(interval)
, period(period) {
name = getMetadata(id).quantityName;
}
virtual std::string getCaption() const override {
return name;
}
virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
};
/// \brief Differential histogram of angular distribution.
///
/// Currently fixed for velocities.
class AngularHistogramPlot : public IPlot {
/// Histogram points
Array<PlotPoint> points;
Float period;
Float lastTime = -INFTY;
public:
explicit AngularHistogramPlot(const Float period);
virtual std::string getCaption() const override {
return "Angular histogram of velocities";
}
virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
};
class SfdPlot : public IPlot {
private:
Post::HistogramSource source;
Flags<Post::ComponentFlag> connect;
Float period;
std::string name;
Float lastTime = -INFTY;
Array<PlotPoint> sfd;
public:
/// \brief Plots SFD of components, given their connectivity.
SfdPlot(const Flags<Post::ComponentFlag> connectivity, const Float period);
/// \brief Plots SFD of individual particles, makes only sense when merging the particles on collisions.
SfdPlot(const Float period);
virtual std::string getCaption() const override;
virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
};
enum class AxisScaleEnum {
LOG_X = 1 << 0,
LOG_Y = 1 << 1,
};
/// \brief Plots given array of points.
class DataPlot : public IPlot {
private:
Array<PlotPoint> values;
std::string name;
public:
DataPlot(const Array<Post::HistPoint>& points, const Flags<AxisScaleEnum> scale, const std::string& name);
virtual std::string getCaption() const override;
virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
};
/// \brief Helper object used for drawing multiple plots into the same device.
class MultiPlot : public IPlot {
private:
Array<AutoPtr<IPlot>> plots;
public:
explicit MultiPlot(Array<AutoPtr<IPlot>>&& plots)
: plots(std::move(plots)) {}
virtual std::string getCaption() const override {
return plots[0]->getCaption(); /// ??
}
virtual void onTimeStep(const Storage& storage, const Statistics& stats) override;
virtual void clear() override;
virtual void plot(IDrawingContext& dc) const override;
};
/// \brief Returns the tics to be drawn on a linear axis of a plot.
///
/// The tics are not necessarily equidistant.
Array<Float> getLinearTics(const Interval& interval, const Size minCount);
/// \brief Returns the tics to be drawn on a logarithmic axis of a plot.
Array<Float> getLogTics(const Interval& interval, const Size minCount);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/containers/Array.h
|
<reponame>pavelsevecek/OpenSPH
#pragma once
/// \file Array.h
/// \brief Generic dynamically allocated resizable storage
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "math/MathBasic.h"
#include "objects/containers/BasicAllocators.h"
#include "objects/containers/ArrayView.h"
#ifdef SPH_GCC
#pragma GCC diagnostic ignored "-Wstringop-overflow"
#endif
NAMESPACE_SPH_BEGIN
template <typename T, typename TAllocator = Mallocator, typename TCounter = Size>
class CopyableArray;
/// \brief Helper class, used to avoid including large header limits.h
template <typename TValue>
struct NumericLimits;
template <>
struct NumericLimits<uint64_t> {
static constexpr uint64_t max() {
return uint64_t(-1);
}
};
template <>
struct NumericLimits<uint32_t> {
static constexpr uint32_t max() {
return uint32_t(-1);
}
};
/// \brief Generic dynamically allocated resizable storage.
///
/// Can also be used with STL algorithms.
template <typename T, typename TAllocator = Mallocator, typename TCounter = Size>
class Array : private TAllocator, public Noncopyable {
private:
using StorageType = typename WrapReferenceType<T>::Type;
StorageType* data = nullptr;
TCounter actSize = 0;
TCounter maxSize = 0;
static constexpr TCounter maxValue = NumericLimits<TCounter>::max();
public:
using Type = T;
using Counter = TCounter;
Array() = default;
/// \brief Constructs array of given size.
///
/// \param elementCnt Number of elements to be constructed (using default constructor)
/// \param allocatedSize Number of allocated elements.
explicit Array(const TCounter elementCnt, const TCounter allocatedSize = maxValue) {
this->alloc(elementCnt, allocatedSize);
// emplace elements
if (!std::is_trivially_default_constructible<T>::value) {
for (TCounter i = 0; i < actSize; ++i) {
new (data + i) StorageType();
}
}
}
/// \brief Constructs array from initialized list.
///
/// Allocate only enough elements to store the list. Elements are constructed using copy constructor of
/// stored type.
Array(std::initializer_list<StorageType> list) {
actSize = list.size();
maxSize = actSize;
MemoryBlock block = TAllocator::allocate(maxSize * sizeof(StorageType), alignof(StorageType));
SPH_ASSERT(block.ptr);
data = (StorageType*)block.ptr;
TCounter i = 0;
for (auto& l : list) {
new (data + i) StorageType(l);
i++;
}
}
/// \brief Move constructor from array of the same type
Array(Array&& other) {
std::swap(data, other.data);
std::swap(maxSize, other.maxSize);
std::swap(actSize, other.actSize);
}
~Array() {
// explicitly destroy all constructed elements
if (!std::is_trivially_destructible<T>::value) {
for (TCounter i = 0; i < actSize; ++i) {
data[i].~StorageType();
}
}
if (data) {
MemoryBlock block(data, maxSize * sizeof(StorageType));
TAllocator::deallocate(block);
data = nullptr;
}
}
Array& operator=(Array&& other) {
std::swap(data, other.data);
std::swap(maxSize, other.maxSize);
std::swap(actSize, other.actSize);
return *this;
}
/// \brief Performs deep-copy of array elements, resizing array if needed.
///
/// This is only way to copy elements, as for Array object deep-copying of elements is forbidden as it is
/// rarely needed and deleting copy constructor helps us avoid accidental deep-copy, for example when
/// passing array as an argument of function.
Array& operator=(const CopyableArray<T, TAllocator, TCounter>& other) {
const Array& rhs = other;
this->resize(rhs.size());
for (TCounter i = 0; i < rhs.size(); ++i) {
data[i] = rhs[i];
}
return *this;
}
/// \brief For l-value references assign each value (does not actually move anything).
///
/// Works only for arrays of same size, for simplicity.
template <typename U, typename = std::enable_if_t<std::is_lvalue_reference<T>::value, U>>
Array& operator=(Array<U>&& other) {
SPH_ASSERT(this->size() == other.size());
for (TCounter i = 0; i < other.size(); ++i) {
(*this)[i] = std::forward<U>(other[i]);
}
return *this;
}
/// \brief Performs a deep copy of all elements of the array.
///
/// All elements are created using copy-constructor.
Array clone() const {
Array newArray;
newArray.reserve(actSize);
for (const T& value : *this) {
newArray.emplaceBack(value);
}
return newArray;
}
INLINE T& operator[](const TCounter idx) noexcept {
SPH_ASSERT(unsigned(idx) < unsigned(actSize), idx, actSize);
return data[idx];
}
INLINE const T& operator[](const TCounter idx) const noexcept {
SPH_ASSERT(unsigned(idx) < unsigned(actSize), idx, actSize);
return data[idx];
}
INLINE T& front() noexcept {
SPH_ASSERT(actSize > 0);
return data[0];
}
INLINE const T& front() const noexcept {
SPH_ASSERT(actSize > 0);
return data[0];
}
INLINE T& back() noexcept {
SPH_ASSERT(actSize > 0);
return data[actSize - 1];
}
INLINE const T& back() const noexcept {
SPH_ASSERT(actSize > 0);
return data[actSize - 1];
}
/// \brief Sets all elements of the array to given value.
void fill(const T& t) {
for (auto& v : *this) {
v = t;
}
}
INLINE TCounter size() const noexcept {
return actSize;
}
INLINE TCounter capacity() const noexcept {
return maxSize;
}
INLINE bool empty() const noexcept {
return actSize == 0;
}
/// \brief Resizes the array to new size.
///
/// This potentially allocated more memory than required, to speed up the allocations. If the new size is
/// bigger than the current size, new elements are created using default constructor, all currently stored
/// values (within interval [0, newSize-1]) are preserved, possibly moved using their move constructor.
/// If the new size is lower than the current size, elements at the end of the array are destroyed.
/// However, the array is not reallocated, the size is kept for future growth.
///
/// \attention This invalidates all references, pointers, iterators, array views, etc. pointed to the
/// elements of the array.
void resize(const TCounter newSize) {
// check suspiciously high values
SPH_ASSERT(newSize < (NumericLimits<TCounter>::max() >> 1));
if (newSize <= maxSize) {
// enough elements is already allocated
if (newSize >= actSize) {
// enlarging array, we need to construct some new elements
if (!std::is_trivially_default_constructible<T>::value) {
for (TCounter i = actSize; i < newSize; ++i) {
new (data + i) StorageType();
}
}
} else {
if (!std::is_trivially_destructible<T>::value) {
// shrinking array, we need to delete some elements
for (TCounter i = newSize; i < actSize; ++i) {
data[i].~StorageType();
}
}
}
} else {
// requested more elements than allocate, need to reallocated.
// allocate twice the current number or the new size, whatever is higher, to avoid frequent
// reallocation when pushing elements one by one
const TCounter actNewSize = max(2 * maxSize, newSize);
Array newArray(0, actNewSize);
// copy all elements into the new array, using move constructor
for (TCounter i = 0; i < actSize; ++i) {
new (newArray.data + i) StorageType(std::move(data[i]));
}
// default-construct new elements
if (!std::is_trivially_default_constructible<T>::value) {
for (TCounter i = actSize; i < newSize; ++i) {
new (newArray.data + i) StorageType();
}
}
// move the array into this
*this = std::move(newArray);
}
actSize = newSize;
}
/// \brief Resizes the array to new size and assigns a given value to all newly created elements.
///
/// Previously stored elements are not modified, they are possibly moved using their move operator.
/// If the new size is lower than the current size, elements at the end are destroyed; the given value is
/// then irrelevant.
///
/// \attention This invalidates all references, pointers, iterators, array views, etc. pointed to the
/// elements of the array.
void resizeAndSet(const TCounter newSize, const T& value) {
const TCounter currentSize = actSize;
this->resize(newSize);
for (TCounter i = currentSize; i < actSize; ++i) {
(*this)[i] = value;
}
}
/// \brief Allocates enough memory to store the given number of elements.
///
/// If enough memory is already allocated, the function does nothing.
///
/// \attention This invalidates all references, pointers, iterators, array views, etc. pointed to the
/// elements of the array.
void reserve(const TCounter newMaxSize) {
SPH_ASSERT(newMaxSize < (NumericLimits<TCounter>::max() >> 1));
if (newMaxSize > maxSize) {
const TCounter actNewSize = max(2 * maxSize, newMaxSize);
Array newArray;
// don't use the Array(0, actNewSize) constructor to allow using emplaceBack for types without
// default constructor
newArray.alloc(0, actNewSize);
// copy all elements into the new array, using move constructor
for (TCounter i = 0; i < actSize; ++i) {
new (newArray.data + i) StorageType(std::move(data[i]));
}
newArray.actSize = actSize;
// move the array into this
*this = std::move(newArray);
}
}
/// \brief Reallocates the array, removing the unused elements to save memory.
void shrink() {
Array newArray;
newArray.pushAll(std::move(*this));
*this = std::move(newArray);
}
/// \brief Adds new element to the end of the array, resizing the array if necessary.
template <typename U>
INLINE void push(U&& u) {
resize(actSize + 1);
data[actSize - 1] = std::forward<U>(u);
}
template <typename TIter>
void pushAll(const TIter first, const TIter last) {
for (TIter iter = first; iter != last; ++iter) {
push(*iter);
}
}
void pushAll(const Array& other) {
reserve(actSize + other.size());
pushAll(other.cbegin(), other.cend());
}
void pushAll(Array&& other) {
reserve(actSize + other.size());
for (T& value : other) {
push(std::move(value));
}
}
/// \brief Constructs a new element at the end of the array in place, using the provided arguments.
template <typename... TArgs>
StorageType& emplaceBack(TArgs&&... args) {
reserve(actSize + 1);
SPH_ASSERT(maxSize > actSize);
StorageType* ptr = new (data + actSize) StorageType(std::forward<TArgs>(args)...);
SPH_ASSERT(ptr);
actSize++;
return *ptr;
}
/// \brief Inserts a new element to given position in the array.
///
/// All the existing elements after the given positions are moved using move operator.
template <typename U>
void insert(const TCounter position, U&& value) {
SPH_ASSERT(position <= actSize);
this->resize(actSize + 1);
std::move_backward(this->begin() + position, this->end() - 1, this->end());
data[position] = std::forward<U>(value);
}
/// \brief Inserts a range of values into the array, starting at given position.
///
/// This has the same effect as calling \ref insert for every element in the range. All the existing
/// elements after the given positions are moved using move operator.
template <typename TIterator>
void insert(const TCounter position, const TIterator first, const TIterator last) {
SPH_ASSERT(position <= actSize);
if (SPH_UNLIKELY(first == last)) {
// inserting an empty range
return;
}
const Size count = std::distance(first, last);
this->resize(actSize + count);
std::move_backward(this->begin() + position, this->end() - count, this->end());
Size i = position;
for (TIterator iter = first; iter != last; ++iter) {
data[i++] = *iter;
}
}
/// \brief Removes the last element from the array and return its value.
///
/// Asserts if the array is empty.
INLINE T pop() {
SPH_ASSERT(actSize > 0);
T value = data[actSize - 1];
resize(actSize - 1);
return value;
}
/// \brief Removes an element with given index from the array.
void remove(const TCounter idx) {
SPH_ASSERT(idx < actSize);
for (TCounter i = idx; i < actSize - 1; ++i) {
data[i] = std::move(data[i + 1]);
}
resize(actSize - 1);
}
/// \brief Removes elements specified by indices from the array.
///
/// This is effectively the same as calling \ref remove with each index separately. The given array of
/// indices must be sorted (from smallest to largest), checked by assert.
void remove(const ArrayView<const TCounter> idxs) {
Size shift = 0;
if (SPH_UNLIKELY(idxs.empty())) {
return;
}
// move all elements between indices
for (Size k = 0; k < idxs.size() - 1; ++k) {
SPH_ASSERT(idxs[k] < idxs[k + 1]);
for (TCounter i = idxs[k]; i < idxs[k + 1] - 1; ++i) {
data[i - shift] = std::move(data[i + 1]);
}
shift++;
}
// move all elements after last index
for (TCounter i = idxs.back(); i < actSize - 1; ++i) {
data[i - shift] = std::move(data[i + 1]);
}
resize(actSize - idxs.size());
}
/// \brief Removes all elements in given range.
template <typename TIter>
void remove(TIter first, TIter last) {
SPH_ASSERT(first <= last);
if (SPH_UNLIKELY(first == last)) {
return;
}
const Size count = last - first;
SPH_ASSERT(Size(first - begin()) + count <= actSize);
for (TIter iter = first; iter != end() - count; ++iter) {
*iter = std::move(*(iter + count));
}
resize(actSize - count);
}
/// \brief Removes all elements from the array, but does NOT release the memory.
void clear() {
if (!std::is_trivially_destructible<T>::value) {
for (TCounter i = 0; i < actSize; ++i) {
data[i].~StorageType();
}
}
actSize = 0;
}
/// \brief Swaps content of two arrays
void swap(Array& other) {
std::swap(data, other.data);
std::swap(maxSize, other.maxSize);
std::swap(actSize, other.actSize);
}
INLINE Iterator<StorageType> begin() noexcept {
return Iterator<StorageType>(data, data, data + actSize);
}
INLINE Iterator<const StorageType> begin() const noexcept {
return Iterator<const StorageType>(data, data, data + actSize);
}
INLINE Iterator<const StorageType> cbegin() const noexcept {
return Iterator<const StorageType>(data, data, data + actSize);
}
INLINE Iterator<StorageType> end() noexcept {
return Iterator<StorageType>(data + actSize, data, data + actSize);
}
INLINE Iterator<const StorageType> end() const noexcept {
return Iterator<const StorageType>(data + actSize, data, data + actSize);
}
INLINE Iterator<const StorageType> cend() const noexcept {
return Iterator<const StorageType>(data + actSize, data, data + actSize);
}
/// \brief Returns the interface to the allocator.
const TAllocator& allocator() const {
return *this;
}
/// \brief Returns the interface to the allocator.
TAllocator& allocator() {
return *this;
}
/// \brief Implicit conversion to arrayview.
INLINE operator ArrayView<T, TCounter>() noexcept {
return ArrayView<T, TCounter>(data, actSize);
}
/// \brief Implicit conversion to arrayview, const version.
INLINE operator ArrayView<const T, TCounter>() const noexcept {
return ArrayView<const T, TCounter>(data, actSize);
}
/// \brief Explicit conversion to arrayview
ArrayView<T, TCounter> view() noexcept {
return ArrayView<T, TCounter>(data, actSize);
}
/// \brief Explicit conversion to arrayview, const version
ArrayView<const T, TCounter> view() const noexcept {
return ArrayView<const T, TCounter>(data, actSize);
}
/// \brief Comparison operator, comparings array element-by-element.
///
/// If arrays differ in number of constructed elements, the comparison always returns false; allocated
/// size does not play role here.
bool operator==(const Array& other) const noexcept {
return view() == other.view();
}
/// \brief Inequality operator
bool operator!=(const Array& other) const noexcept {
return view() != other.view();
}
/// \brief Prints content of array to stream.
///
/// Enabled only if the stored type has overloaded << operator.
template <typename TStream, typename = std::enable_if_t<HasStreamOperator<T, TStream>::value>>
friend TStream& operator<<(TStream& stream, const Array& array) {
for (const T& t : array) {
stream << t << std::endl;
}
return stream;
}
private:
void alloc(const TCounter elementCnt, const TCounter allocatedSize) {
actSize = elementCnt;
maxSize = allocatedSize;
if (allocatedSize == maxValue) {
maxSize = actSize;
}
// allocate maxSize elements
MemoryBlock block = TAllocator::allocate(maxSize * sizeof(StorageType), alignof(StorageType));
SPH_ASSERT(block.ptr);
data = (StorageType*)block.ptr;
}
};
template <typename T, typename TAllocator, typename TCounter>
class CopyableArray {
private:
const Array<T, TAllocator, TCounter>& array;
public:
CopyableArray(const Array<T, TAllocator, TCounter>& array)
: array(array) {}
operator const Array<T, TAllocator, TCounter>&() const {
return array;
}
};
/// \todo test
template <typename T, typename TAllocator, typename TCounter>
INLINE CopyableArray<T, TAllocator, TCounter> copyable(const Array<T, TAllocator, TCounter>& array) {
return CopyableArray<T, TAllocator, TCounter>(array);
}
/// \brief Creates an array from a list of parameters.
template <typename T0, typename... TArgs>
Array<std::decay_t<T0>> makeArray(T0&& t0, TArgs&&... rest) {
return Array<std::decay_t<T0>>{ std::forward<T0>(t0), std::forward<TArgs>(rest)... };
}
/// \brief Creates a l-value reference array from a list of l-value references.
template <typename T0, typename... TArgs>
Array<T0&> tieToArray(T0& t0, TArgs&... rest) {
return Array<T0&>{ t0, rest... };
}
NAMESPACE_SPH_END
/// Overload of std::swap for Sph::Array.
namespace std {
template <typename T, typename TCounter>
void swap(Sph::Array<T, TCounter>& ar1, Sph::Array<T, TCounter>& ar2) {
ar1.swap(ar2);
}
} // namespace std
|
pavelsevecek/OpenSPH
|
core/system/Settings.h
|
<reponame>pavelsevecek/OpenSPH<gh_stars>10-100
#pragma once
/// \file Settings.h
/// \brief Generic storage and input/output routines of settings.
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/Exceptions.h"
#include "objects/geometry/TracelessTensor.h"
#include "objects/utility/EnumMap.h"
#include "objects/wrappers/ClonePtr.h"
#include "objects/wrappers/Expected.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Interval.h"
#include "objects/wrappers/Outcome.h"
#include "objects/wrappers/Variant.h"
#include <typeinfo>
NAMESPACE_SPH_BEGIN
class Path;
template <typename TEnum>
class Settings;
template <typename TEnum>
class SettingsIterator;
/// Tag for initialization of empty settings object.
struct EmptySettingsTag {};
const EmptySettingsTag EMPTY_SETTINGS;
/// \brief Wrapper of an enum.
///
/// Used to store an enum in settings while keeping the type safety.
struct EnumWrapper {
int value = 0;
EnumIndex index = NOTHING;
EnumWrapper() = default;
template <typename TEnum>
explicit EnumWrapper(TEnum e)
: value(int(e))
, index(typeid(TEnum)) {
static_assert(std::is_enum<TEnum>::value, "Can be used only for enums");
}
EnumWrapper(const int value, const EnumIndex& index)
: value(value)
, index(index) {}
explicit operator int() const {
return value;
}
template <typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
explicit operator T() const {
SPH_ASSERT(std::type_index(typeid(T)) == index);
return T(value);
}
bool operator==(const EnumWrapper& other) const {
return value == other.value && index == other.index;
}
friend std::ostream& operator<<(std::ostream& ofs, const EnumWrapper& e) {
ofs << e.value << " (" << (e.index ? e.index->hash_code() : 0) << ")";
return ofs;
}
};
/// \brief Exception thrown on invalid access to entries of a \ref Settings object.
class InvalidSettingsAccess : public Exception {
public:
template <typename TEnum>
explicit InvalidSettingsAccess(const TEnum key)
: Exception("Error accessing parameter '" +
Settings<TEnum>::getEntryName(key).valueOr("unknown parameter") + "'") {
static_assert(std::is_enum<TEnum>::value, "InvalidSettingsAccess can only be used with enums");
}
};
template <typename TEnum>
INLINE void checkSettingsAccess(const bool result, const TEnum key) {
if (!result) {
throw InvalidSettingsAccess(key);
}
}
/// \brief Generic object containing various settings and parameters of the run.
///
/// Settings is a storage containing pairs key-value objects, where key is one of predefined enums. The value
/// can have multiple types within the same \ref Settings object. Currently following types can be stored:
/// bool, int, enums, float (or double), std::string, \ref Interval, \ref Vector, \ref SymmetricTensor, \ref
/// TracelessTensor.
///
/// The template cannot be used directly as it is missing default values of parameters; instead
/// specializations for specific enums should be used. The code defines two base specializations:
/// - \ref BodySettings (specialization with enum \ref BodySettingsId)
/// - \ref RunSettings (specialization with enum \ref RunSettingsId)
///
/// The object can be specialized for other usages, provided static member \ref Settings::instance is created,
/// see one of existing specializations.
template <typename TEnum>
class Settings {
template <typename>
friend class SettingsIterator;
private:
/// \brief List of types that can be stored in settings
enum Types {
BOOL,
INT,
FLOAT,
INTERVAL,
STRING,
VECTOR,
SYMMETRIC_TENSOR,
TRACELESS_TENSOR,
ENUM,
};
/// \brief Storage type of settings entries.
///
/// Order of types in the variant must correspond to the values in enum \ref Types. It is possible to add
/// other types to the settings, but always to the END of the variant to keep the backwards compatibility
/// of serializer.
///
/// \todo Possibly refactor by using some polymorphic holder (Any-type) rather than variant, this will
/// allow to add more types for other Settings specializations (GuiSettings, etc.)
using Value = Variant<bool,
int,
Float,
Interval,
std::string,
Vector,
SymmetricTensor,
TracelessTensor,
EnumWrapper>;
struct Entry {
/// Index of the property
TEnum id;
/// Unique text identifier of the property
std::string name;
/// Current value
Value value;
/// Description of the property. Can be empty.
std::string desc;
Entry() = default;
Entry(TEnum id, const std::string& name, const Value& value, const std::string& desc = "")
: id(id)
, name(name)
, value(value)
, desc(desc) {}
template <typename T, typename = std::enable_if_t<std::is_enum<T>::value>>
Entry(TEnum id, const std::string& name, const T& value, const std::string& desc = "")
: id(id)
, name(name)
, value(EnumWrapper(value))
, desc(desc) {}
template <typename T>
Entry(TEnum id, const std::string& name, Flags<T> flags, const std::string& desc = "")
: id(id)
, name(name)
, value(EnumWrapper(T(flags.value())))
, desc(desc) {}
template <typename T>
INLINE bool hasType(std::enable_if_t<!std::is_enum<T>::value, int> = 0) const {
return value.has<T>();
}
template <typename T>
INLINE bool hasType(std::enable_if_t<std::is_enum<T>::value, int> = 0) const {
return value.has<EnumWrapper>() && value.get<EnumWrapper>().index == std::type_index(typeid(T));
}
};
FlatMap<TEnum, Entry> entries;
static AutoPtr<Settings> instance;
/// Constructs settings from list of key-value pairs.
Settings(std::initializer_list<Entry> list);
public:
/// \brief Initialize settings by settings all value to their defaults.
Settings();
/// \brief Initialize empty settings object.
Settings(EmptySettingsTag);
Settings(const Settings& other);
Settings(Settings&& other);
/// \brief Assigns a list of settings into the object, erasing all previous entries.
Settings& operator=(std::initializer_list<Entry> list);
Settings& operator=(const Settings& other);
Settings& operator=(Settings&& other);
/// \brief Saves a value into the settings.
///
/// Any previous value of the same ID is overriden.
/// \tparam TValue Type of the value to be saved. Does not have to be specified, type deduction can be
/// used to determine it. Must be one of types listed in object description. Using other
/// types will result in compile error.
/// \param idx Key identifying the value. This key can be used to retrive the value later.
/// \param value Value being stored into settings.
/// \returns Reference to the settings object, allowing to queue multiple set functions.
/// \throw InvalidSettingsAccess if settings value of different type than the one currently stored.
template <typename TValue>
Settings& set(const TEnum idx,
TValue&& value,
std::enable_if_t<!std::is_enum<std::decay_t<TValue>>::value, int> = 0) {
Optional<Entry&> entry = entries.tryGet(idx);
if (!entry) {
Entry& newEntry = entries.insert(idx, Entry{});
newEntry.value = std::forward<TValue>(value);
} else {
checkSettingsAccess(entry->template hasType<std::decay_t<TValue>>(), idx);
entry->value = std::forward<TValue>(value);
}
return *this;
}
/// \copydoc set
template <typename TValue>
Settings& set(const TEnum idx,
TValue&& value,
std::enable_if_t<std::is_enum<std::decay_t<TValue>>::value, int> = 0) {
Optional<Entry&> entry = entries.tryGet(idx);
if (!entry) {
Entry& newEntry = entries.insert(idx, Entry{});
newEntry.value = EnumWrapper(value);
} else {
checkSettingsAccess(entry->template hasType<std::decay_t<TValue>>(), idx);
entry->value = EnumWrapper(value);
}
return *this;
}
/// \brief Saves flags into the settings.
///
/// Flags are not considered as a different type, they are internally saved as enum wrapper.
/// \returns Reference to the settings object.
/// \throw InvalidSettingsAccess if settings value of different type than the one currently stored.
template <typename TValue, typename = std::enable_if_t<std::is_enum<TValue>::value>>
Settings& set(const TEnum idx, const Flags<TValue> flags) {
return this->set(idx, EnumWrapper(TValue(flags.value())));
}
/// \brief Clear flags of given parameter in settings.
///
/// This function can be used only if the value is already stored in the settings.
/// \returns Reference to the settings object.
/// \throw InvalidSettingsAccess if the value is not stored or has a different type.
Settings& set(const TEnum idx, EmptyFlags) {
Optional<Entry&> entry = entries.tryGet(idx);
checkSettingsAccess(entry && entry->value.template has<EnumWrapper>(), idx);
entry->value.template get<EnumWrapper>().value = 0;
return *this;
}
/// \brief Special setter for value of type EnumWrapper.
///
/// While usually the enum can be stored directly, this overload is useful for deserialization, etc.
/// \returns Reference to the settings object.
/// \throw InvalidSettingsAccess if settings value of different type than the one currently stored.
Settings& set(const TEnum idx, const EnumWrapper ew) {
Optional<Entry&> entry = entries.tryGet(idx);
if (entry) {
Optional<EnumWrapper> current = entry->value.template tryGet<EnumWrapper>();
checkSettingsAccess(current && current->index == ew.index, idx);
}
this->set(idx, ew, 0); // zero needed to call the other overload
return *this;
}
/// \brief Adds entries from different \ref Settings object into this one, overriding current entries.
///
/// Entries not stored in the given settings are kept unchanged.
/// \throw InvalidSettingsAccess if the settings share entries that differ in type.
void addEntries(const Settings& settings) {
for (const typename SettingsIterator<TEnum>::IteratorValue& iv : settings) {
Optional<Entry&> entry = entries.tryGet(iv.id);
if (!entry) {
Entry& newEntry = entries.insert(iv.id, getDefaults().entries[iv.id]);
newEntry.value = iv.value;
} else {
checkSettingsAccess(entry->value.getTypeIdx() == iv.value.getTypeIdx(), iv.id);
entry->value = iv.value;
}
}
}
/// \brief Removes given parameter from settings.
///
/// If the parameter is not in settings, nothing happens (it isn't considered as an error).
void unset(const TEnum idx) {
entries.tryRemove(idx);
}
/// \brief Returns a value of given type from the settings.
///
/// Value must be stored in settings and must have corresponding type.
/// \tparam TValue Type of the value we wish to return. This type must match the type of the saved
/// quantity.
/// \param idx Key of the value.
/// \returns Value correponsing to given key.
/// \throw InvalidSettingsAccess if value is not stored in the settings or has a different type.
template <typename TValue>
TValue get(const TEnum idx, std::enable_if_t<!std::is_enum<std::decay_t<TValue>>::value, int> = 0) const {
Optional<const Entry&> entry = entries.tryGet(idx);
checkSettingsAccess(entry && entry->value.template has<TValue>(), idx);
return entry->value.template get<TValue>();
}
/// \copydoc get
template <typename TValue>
TValue get(const TEnum idx, std::enable_if_t<std::is_enum<std::decay_t<TValue>>::value, int> = 0) const {
Optional<const Entry&> entry = entries.tryGet(idx);
checkSettingsAccess(entry && entry->value.template has<EnumWrapper>(), idx);
const EnumWrapper wrapper = entry->value.template get<EnumWrapper>();
checkSettingsAccess(wrapper.index == std::type_index(typeid(TValue)), idx);
return TValue(wrapper.value);
}
/// \brief Returns Flags from underlying value stored in settings.
///
/// Syntactic suggar, avoid cumbersome conversion to underlying type and then to Flags.
template <typename TValue>
Flags<TValue> getFlags(const TEnum idx) const {
static_assert(std::is_enum<TValue>::value, "Can be only used for enums");
TValue value = this->get<TValue>(idx);
return Flags<TValue>::fromValue(std::underlying_type_t<TValue>(value));
}
/// \brief Returns the human-readable name of the entry with given index.
///
/// If the index does not correspond to any parameter, returns string NOTHING.
static Optional<std::string> getEntryName(const TEnum idx) {
const Settings& settings = getDefaults();
Optional<const Entry&> entry = settings.entries.tryGet(idx);
if (entry) {
return entry->name;
} else {
// idx might be invalid if loaded from older config file
return NOTHING;
}
}
/// \brief Returns the type of the entry with given index.
///
/// If the index does not correspond to any parameter, returns NOTHING.
static Optional<int> getEntryType(const TEnum idx) {
const Settings& settings = getDefaults();
Optional<const Entry&> entry = settings.entries.tryGet(idx);
if (entry) {
return entry->value.getTypeIdx();
} else {
return NOTHING;
}
}
/// \brief Returns the string name for given type index.
///
/// \throw Exception for unknown type index
static std::string typeToString(const int type);
/// \brief Returns a description of the entry with given index.
///
/// If the index does not correspond to any parameter, returns string NOTHING.
static Optional<std::string> getEntryDesc(const TEnum idx) {
const Settings& settings = getDefaults();
Optional<const Entry&> entry = settings.entries.tryGet(idx);
if (entry) {
return entry->desc;
} else {
// idx might be invalid if loaded from older config file
return NOTHING;
}
}
/// \brief Returns an ID for given entry name.
///
/// This is the inverse of function \ref getEntryName.
static Optional<TEnum> getEntryId(const std::string& name) {
const Settings& settings = getDefaults();
for (const auto& p : settings.entries) {
if (p.value().name == name) {
return p.key();
}
}
return NOTHING;
}
/// \brief Checks if the given entry is stored in the settings.
bool has(const TEnum idx) const {
return entries.contains(idx);
}
/// \brief Checks if the given entry has specified type.
///
/// \throw InvalidSettingsAccess if the entry is not in settings.
template <typename TValue>
bool hasType(const TEnum idx) const {
Optional<const Entry&> entry = entries.tryGet(idx);
checkSettingsAccess(bool(entry), idx);
return entry->value.template has<TValue>();
}
/// \brief Saves all values stored in settings into file.
///
/// \param path Path (relative or absolute) to the file. The file will be created, any previous
/// content will be overriden.
/// \returns SUCCESS if the file has been correctly written, otherwise returns encountered error.
Outcome saveToFile(const Path& path) const;
/// \brief Loads the settings from file.
///
/// Previous values stored in settings are removed. The file must have a valid settings format.
/// \param path Path to the file. The file must exist.
/// \returns SUCCESS if the settings were correctly parsed from the file, otherwise returns encountered
/// error.
Outcome loadFromFile(const Path& path);
/// \brief If the specified file exists, loads the settings from it, otherwise creates the file and saves
/// the current values.
///
/// This is a standard behavior of configuration files used in the simulation. First time the simulation
/// is started, the configuration files are created with default values. The files can then be modified by
/// the user and the next time simulation is started, the parameters are parsed and used instead of the
/// defaults.
///
/// For convenience, it is possible to pass a set of overrides, which are used instead of the values
/// loaded from the configuration file (or defaults, if the file does not exist). This can be used to
/// specify settings as command-line parameters, for example.
/// \param path Path to the configuration file.
/// \param overrides Set of overrides applied on the current values or after the settings are loaded.
/// \returns True if the settings have been successfully loaded, false if the configuration file did not
/// exist, in which case the function attempted to create the file using current values (with
/// applied overrides).
/// \throw Exception if loading of the file failed (invalid content, unknown parameters, ...).
///
/// \note Function returns a valid result (false) even if the configuration file cannot be created, for
/// example if the directory access is denied. This does not prohibit the simulation in any way, the
/// settings object is in valid state.
bool tryLoadFileOrSaveCurrent(const Path& path, const Settings& overrides = EMPTY_SETTINGS);
/// \brief Iterator to the first entry of the settings storage.
SettingsIterator<TEnum> begin() const;
/// \brief Iterator to the one-past-end entry the settings storage.
SettingsIterator<TEnum> end() const;
/// \brief Returns the number of entries in the settings.
///
/// This includes default entries in case the object was not constructed with EMPTY_SETTINGS tag.
Size size() const;
/// \\brief Returns a reference to object containing default values of all settings.
static const Settings& getDefaults();
private:
bool setValueByType(Entry& entry, const Value& defaultValue, const std::string& str);
};
/// \brief Iterator useful for iterating over all entries in the settings.
template <typename TEnum>
class SettingsIterator {
private:
using ActIterator = Iterator<const typename FlatMap<TEnum, typename Settings<TEnum>::Entry>::Element>;
ActIterator iter;
public:
/// Constructs an iterator from iternal implementation; use Settings::begin and Settings::end.
SettingsIterator(const ActIterator& iter, Badge<Settings<TEnum>>);
struct IteratorValue {
/// ID of settings entry
TEnum id;
/// Variant holding the value of the entry
typename Settings<TEnum>::Value value;
};
/// Dereference the iterator, yielding a pair of entry ID and its value.
IteratorValue operator*() const;
/// Moves to next entry.
SettingsIterator& operator++();
/// Equality operator between settings operators.
bool operator==(const SettingsIterator& other) const;
/// Unequality operator between settings operators.
bool operator!=(const SettingsIterator& other) const;
};
enum class KernelEnum {
/// M4 B-spline (piecewise cubic polynomial)
CUBIC_SPLINE,
/// M5 B-spline (piecewise 4th-order polynomial)
FOURTH_ORDER_SPLINE,
/// Gaussian function
GAUSSIAN,
/// Simple triangle (piecewise linear) kernel
TRIANGLE,
/// Core Triangle (CT) kernel by Read et al. (2010)
CORE_TRIANGLE,
/// Modification of the standard M4 B-spline kernel, used to avoid particle clustering
THOMAS_COUCHMAN,
/// Wendland kernel C2
WENDLAND_C2,
/// Wendland kernel C4
WENDLAND_C4,
/// Wendland kernel C6
WENDLAND_C6,
};
enum class TimesteppingEnum {
/// Explicit (forward) 1st-order integration
EULER_EXPLICIT,
/// Leap-frog 2nd-order integration
LEAP_FROG,
/// Runge-Kutta 4-th order integration
RUNGE_KUTTA,
/// Predictor-corrector scheme
PREDICTOR_CORRECTOR,
/// Modified midpoint method with constant number of substeps
MODIFIED_MIDPOINT,
/// Bulirsch-Stoer integrator
BULIRSCH_STOER
};
enum class TimeStepCriterionEnum {
/// Time step determined using CFL condition
COURANT = 1 << 1,
/// Time step computed by limiting value-to-derivative ratio of quantiites.
DERIVATIVES = 1 << 2,
/// Time step computed from ratio of acceleration and smoothing length.
ACCELERATION = 1 << 3,
/// Time step computed from velocity divergence
DIVERGENCE = 1 << 4,
/// Value for using all criteria.
ALL = COURANT | DERIVATIVES | ACCELERATION | DIVERGENCE,
};
enum class FinderEnum {
/// Brute-force search by going through each pair of particles (O(N^2) complexity)
BRUTE_FORCE,
/// Using K-d tree
KD_TREE,
/// Using octree
OCTREE,
/// Using linked list
LINKED_LIST,
/// Partitioning particles into a grid uniform in space
UNIFORM_GRID,
/// Using hash map
HASH_MAP,
};
enum class BoundaryEnum {
/// Do not use any boundary conditions (= vacuum conditions)
NONE,
/// Highest derivatives of all particles close to the boundary are set to zero.
FROZEN_PARTICLES,
/// Create ghosts to keep particles inside domain.
GHOST_PARTICLES,
/// Creates dummy particles along the boundary.
FIXED_PARTICLES,
/// Extension of Frozen Particles, pushing particles inside the domain and removing them on the other end.
WIND_TUNNEL,
/// Periodic boundary conditions
PERIODIC,
/// Particles are duplicated along the z=0 plane
SYMMETRIC,
/// Removes particles outside the domain
KILL_ESCAPERS,
/// Project all movement onto a line, effectivelly reducing the simulation to 1D
PROJECT_1D
};
enum class DomainEnum {
/// No computational domain (can only be used with BoundaryEnum::NONE)
NONE,
/// Sphere with given radius
SPHERICAL,
/// Axis-aligned ellipsoid
ELLIPSOIDAL,
/// Block with edge sizes given by vector
BLOCK,
/// Cylindrical domain aligned with z axis
CYLINDER,
/// Gaussian random sphere
GAUSSIAN_SPHERE,
/// Half-space z>0
HALF_SPACE,
};
/// List of forces to compute by the solver. This does not include numerical terms, see
/// ArtificialViscosityEnum.
enum class ForceEnum {
/// Use force from pressure gradient in the solver.
PRESSURE = 1 << 0,
/// Use force from stress divergence in the model. Must be used together with PRESSURE_GRADIENT.
/// Stress tensor is then evolved in time using Hooke's equation.
SOLID_STRESS = 1 << 1,
/// Stress tensor for the simulation of fluids. Must be used together with PRESSURE_GRADIENT, cannot
/// be used together with solid stress force.
NAVIER_STOKES = 1 << 2,
/// Use internal friction given by the viscosity in the material.
INTERNAL_FRICTION = 1 << 3,
/// Use centrifugal force and Coriolis forces given by angular frequency of the coordinate frame.
INERTIAL = 1 << 4,
/// Use gravitational force in the model
SELF_GRAVITY = 1 << 5,
/// Surface force proportional to surface curvature
SURFACE_TENSION = 1 << 6,
};
enum class ArtificialViscosityEnum {
/// No artificial viscosity
NONE,
/// Standard artificial viscosity term by Monaghan (1989).
STANDARD,
/// Artificial viscosity term analogous to Riemann solvers by Monaghan (1997)
RIEMANN,
/// Time-dependent artificial viscosity by Morris & Monaghan (1997).
MORRIS_MONAGHAN,
};
enum class SolverEnum {
/// SPH formulation using symmetrized evaluation of derivatives.
SYMMETRIC_SOLVER,
/// Generic solver evaluating all derivatives asymmetrically.
ASYMMETRIC_SOLVER,
/// Density is obtained by direct summation over nearest SPH particles.
SUMMATION_SOLVER,
/// Special solver used to simulate deformations of perfectly elastic bodies
ELASTIC_DEFORMATION_SOLVER,
/// Density independent solver by Saitoh & Makino (2013).
DENSITY_INDEPENDENT,
/// Solver advancing internal energy using pair-wise work done by particles, by Owen (2009).
ENERGY_CONSERVING_SOLVER,
/// Simple solver with pressure gradient only, mainly used for supporting purposes (benchmarking,
/// teaching, etc.)
SIMPLE_SOLVER,
};
enum class ContinuityEnum {
/// Normal continuity equation, using velocity divergence computed from all neighbors.
STANDARD,
/// Computes the velocity divergence using only undamaged neighbors. For fully damaged particle, the
/// standard continuity equation is used instead.
SUM_ONLY_UNDAMAGED,
};
enum class DiscretizationEnum {
/// P_i / rho_i^2 + P_j / rho_j^2
STANDARD,
/// (P_i + P_j) / (rho_i rho_j)
BENZ_ASPHAUG,
};
enum class YieldingEnum {
/// Gass or material with no stress tensor
NONE,
/// No yielding, just elastic deformations following Hooke's law
ELASTIC,
/// Von Mises criterion
VON_MISES,
/// Drucker-Prager pressure dependent yielding stress
DRUCKER_PRAGER,
/// No stress tensor, only the pressure is limited to positive values.
DUST,
};
enum class FractureEnum {
/// No fragmentation
NONE,
/// Grady-Kipp model of fragmentation using scalar damage
SCALAR_GRADY_KIPP,
/// Grady-Kipp model of fragmentation using tensor damage
TENSOR_GRADY_KIPP
};
enum class SmoothingLengthEnum {
/// Smoothing length is evolved using continuity equation
CONTINUITY_EQUATION = 1 << 1,
/// Number of neighbors is kept fixed by adding additional derivatives of smoothing length, scaled by
/// local sound speed
SOUND_SPEED_ENFORCING = 1 << 2
};
enum class SignalSpeedEnum {
/// Signal speed given by the absolute value of pressure difference, as in Price (2008)
PRESSURE_DIFFERENCE,
/// Signal speed given by relative velocity projected to the positive vector, as in Valdarnini (2018),
VELOCITY_DIFFERENCE,
};
enum class GravityEnum {
/// Approximated gravity, assuming the matter is a simple homogeneous sphere.
SPHERICAL,
/// Brute-force summation over all particle pairs (O(N^2) complexity)
BRUTE_FORCE,
/// Use Barnes-Hut algorithm, approximating gravity by multipole expansion (up to octupole order)
BARNES_HUT,
};
enum class GravityKernelEnum {
/// Point-like particles with zero radius
POINT_PARTICLES,
/// Use gravity smoothing kernel corresponding to selected SPH kernel
SPH_KERNEL,
/// Use kernel representing gravity of solid spheres. Useful for N-body simulations where overlaps are
/// allowed.
SOLID_SPHERES,
};
enum class CollisionHandlerEnum {
/// No collision handling
NONE,
/// All collided particles merge, creating larger spherical particles. Particles are merged
/// unconditionally, regardless of their relative velocity or their angular frequencies.
PERFECT_MERGING,
/// Collided particles bounce with some energy dissipation, specified by the coefficients of restitution.
/// No merging, number of particles remains contant.
ELASTIC_BOUNCE,
/// If the relative speed of the collided particles is lower than the escape velocity, the particles are
/// merged, otherwise the particle bounce. To ensure that the particles are always merged, set the
/// COLLISION_MERGE_LIMIT to zero, on the other hand large values make particles more difficult to merge.
MERGE_OR_BOUNCE,
};
enum class OverlapEnum {
/// All overlaps are ignored
NONE,
/// Overlapping particles are merged
FORCE_MERGE,
/// Particles are shifted until no overlap happens
REPEL,
/// Particles are either repeled (and bounced) or merged, based on the ratio of their relative velocity to
/// the escape velocity (similar to MERGE_OR_BOUNCE).
REPEL_OR_MERGE,
/// Particles are allowed to overlap and they bounce if moving towards each other.
INTERNAL_BOUNCE,
PASS_OR_MERGE,
};
enum class LoggerEnum {
/// Do not log anything
NONE,
/// Print log to standard output
STD_OUT,
/// Print log to file
FILE
/// \todo print using callback to gui application
};
enum class IoEnum {
/// No input/output
NONE,
/// Formatted human-readable text file
TEXT_FILE,
/// Extension of text file, additionally executing given gnuplot script, generating a plot from every
/// dump.
GNUPLOT_OUTPUT,
/// Full binary output file. This data dump is lossless and can be use to restart run from saved snapshot.
/// Stores values, all derivatives and materials of the storage.
BINARY_FILE,
/// Compressed binary output file, containing only few selected quantities. This is the most convenient
/// format for storing full simulation in high resolution in time.
COMPRESSED_FILE,
/// File format used by Visualization Toolkit (VTK). Useful to view the results in Paraview and other
/// visualization tools.
VTK_FILE,
/// File format for storing scientific data. Currently tailored for files generated by the code
/// miluphcuda. Requires to build code with libhdf5.
HDF5_FILE,
/// Export from Minor Planet Center Orbit Database
MPCORP_FILE,
/// Pkdgrav input file.
PKDGRAV_INPUT,
};
/// \brief Returns the file extension associated with given IO type.
///
/// Result NOTHING indicates there is no particular extension associated with the IO type.
Optional<std::string> getIoExtension(const IoEnum type);
/// \brief Returns the file type from file extension.
///
/// Result NOTHING indicates there is no file type associated with the extension.
Optional<IoEnum> getIoEnum(const std::string& ext);
/// \brief Returns a short description of the file format.
std::string getIoDescription(const IoEnum type);
enum class IoCapability {
/// The format can be used as file input
INPUT = 1 << 1,
/// The format can be used as file output
OUTPUT = 1 << 2,
};
/// \brief Returns the capabilities of given file format.
Flags<IoCapability> getIoCapabilities(const IoEnum type);
enum class OutputSpacing {
/// Constant time between consecutive output times
LINEAR,
/// Constant ratio between consecutive output times
LOGARITHMIC,
/// User-defined list of output times
CUSTOM,
};
enum class RngEnum {
/// Mersenne Twister PRNG from Standard library
UNIFORM,
/// Halton QRNG
HALTON,
/// Same RNG as used in SPH5, used for 1-1 comparison
BENZ_ASPHAUG
};
enum class UvMapEnum {
/// Planar mapping
PLANAR,
/// Spherical mapping
SPHERICAL,
};
/// Settings relevant for whole run of the simulation
enum class RunSettingsId {
/// User-specified name of the run, used in some output files
RUN_NAME,
/// User-specified comment
RUN_COMMENT,
/// Name of the person running the simulation
RUN_AUTHOR,
/// E-mail of the person running the simulation.
RUN_EMAIL,
/// Specifies the type of the simulation. Does not have to be specified to run the simulation; this
/// information is saved in output files and taken into account by visualization tools, for example.
RUN_TYPE,
/// Selected format of the output file, see \ref IoEnum
RUN_OUTPUT_TYPE,
/// Time interval of dumping data to disk.
RUN_OUTPUT_INTERVAL,
/// Type of output spacing in time, see enum OutputSpacing
RUN_OUTPUT_SPACING,
/// List of comma-separated output times, used when RUN_OUTPUT_SPACING is set to CUSTOM
RUN_OUTPUT_CUSTOM_TIMES,
/// Index of the first generated output file. Might not be zero if the simulation is resumed.
RUN_OUTPUT_FIRST_INDEX,
/// File name of the output file (including extension), where %d is a placeholder for output number.
RUN_OUTPUT_NAME,
/// Path where all output files (dumps, logs, ...) will be written
RUN_OUTPUT_PATH,
/// List of quantities to write to text output. Binary output always stores all quantitites.
RUN_OUTPUT_QUANTITIES,
/// Number of threads used by the code. If 0, all available threads are used.
RUN_THREAD_CNT,
/// Number of particles processed by one thread in a single batch. Lower number can help to distribute
/// tasks between threads more evenly, higher number means faster processing of particles within single
/// thread.
RUN_THREAD_GRANULARITY,
/// Selected logger of a run, see LoggerEnum
RUN_LOGGER,
/// Path of a file where the log is printed, used only when selected logger is LoggerEnum::FILE
RUN_LOGGER_FILE,
/// Number specifying log verbosity. Can be between 0 and 3, going from least to most verbose.
RUN_LOGGER_VERBOSITY,
/// Enables verbose log of a simulation.
RUN_VERBOSE_ENABLE,
/// Path of a file where the verbose log is printed.
RUN_VERBOSE_NAME,
/// Starting time of the simulation in seconds. This is usually 0, although it can be set to a non-zero
/// for simulations resumed from saved state.
RUN_START_TIME,
/// End time of the simulation in seconds. For new simulations (not resumed from saved state), this
/// corresponds to the total duration of the simulation.
RUN_END_TIME,
/// Maximum number of timesteps after which run ends. 0 means run duration is not limited by number of
/// timesteps. Note that if adaptive timestepping is used, run can end at different times for
/// different initial conditions. This condition should only be used for debugging purposes.
RUN_TIMESTEP_CNT,
/// Maximum duration of the run in milliseconds, measured in real-world time. 0 means run duration is not
/// limited by this value.
RUN_WALLCLOCK_TIME,
/// Selected random-number generator used within the run.
RUN_RNG,
/// Seed for the random-number generator
RUN_RNG_SEED,
/// Time period (in run time) of running diagnostics of the run. 0 means the diagnostics are run every
/// time step.
RUN_DIAGNOSTICS_INTERVAL,
/// Selected solver for computing derivatives of physical variables.
SPH_SOLVER_TYPE,
/// List of forces to compute by the solver.
SPH_SOLVER_FORCES,
/// Solution for evolutions of the smoothing length
SPH_ADAPTIVE_SMOOTHING_LENGTH,
/// Maximum number of iterations for self-consistent density computation of summation solver.
SPH_SUMMATION_MAX_ITERATIONS,
/// Target relative difference of density in successive iterations. Density computation in summation
/// solver is ended when the density changes by less than the delta or the iteration number exceeds
/// SOLVER_SUMMATION_MAX_ITERATIONS.
SPH_SUMMATION_DENSITY_DELTA,
/// If true, the SPH solver computes a hash map connecting position in space with required search radius.
/// Otherwise, the radius is determined from the maximal smoothing length in the simulation. Used only by
/// the AsymmetricSolver.
SPH_ASYMMETRIC_COMPUTE_RADII_HASH_MAP,
/// Index of SPH Kernel, see KernelEnum
SPH_KERNEL,
/// Structure for searching nearest neighbors of particles
SPH_FINDER,
/// Specifies a discretization of SPH equations; see \ref DiscretizationEnum.
SPH_DISCRETIZATION,
/// If true, the kernel gradient for evaluation of strain rate will be corrected for each particle by an
/// inversion of an SPH-discretized identity matrix. This generally improves stability of the run and
/// conservation of total angular momentum, but comes at the cost of higher memory consumption and slower
/// evaluation of SPH derivatives.
SPH_STRAIN_RATE_CORRECTION_TENSOR,
/// If true, derivatives with flag DerivativeFlag::SUM_ONLY_UNDAMAGED will evaluate only undamaged
/// particles belonging to the same body. Otherwise, all particle are evaluated, regardless of derivative
/// flags.
SPH_SUM_ONLY_UNDAMAGED,
/// Specifies how the density is evolved, see \ref ContinuityEnum.
SPH_CONTINUITY_MODE,
/// Evolve particle phase angle
SPH_PHASE_ANGLE,
/// Minimum and maximum number of neighbors SPH solver tries to enforce. Note that the solver cannot
/// guarantee the actual number of neighbors will be within the range.
SPH_NEIGHBOR_RANGE,
/// Strength of enforcing neighbor number. Higher value makes enforcing more strict (number of neighbors
/// gets into required range faster), but also makes code less stable. Can be a negative number, -INFTY
/// technically disables enforcing altogether.
SPH_NEIGHBOR_ENFORCING,
/// Artificial viscosity alpha coefficient
SPH_AV_ALPHA,
/// Artificial viscosity beta coefficient
SPH_AV_BETA,
/// Minimal value of smoothing length
SPH_SMOOTHING_LENGTH_MIN,
/// Type of used artificial viscosity.
SPH_AV_TYPE,
/// Whether to use balsara switch for computing artificial viscosity dissipation. If no artificial
/// viscosity is used, the value has no effect.
SPH_AV_USE_BALSARA,
/// If true, Balsara factors will be saved as quantity AV_BALSARA. Mainly for debugging purposes.
SPH_AV_BALSARA_STORE,
/// Enables the artificial thermal conductivity term.
SPH_USE_AC,
/// Artificial conductivity alpha coefficient
SPH_AC_ALPHA,
/// Artificial conductivity beta coefficient
SPH_AC_BETA,
/// Type of the signal speed used by artificial conductivity
SPH_AC_SIGNAL_SPEED,
/// Turn on the XSPH correction
SPH_USE_XSPH,
/// Epsilon-factor of XSPH correction (Monaghan, 1992). Value 0 turns off the correction, epsilon
/// shouldn't be larger than 1.
SPH_XSPH_EPSILON,
/// Turn on the delta-SPH correction
SPH_USE_DELTASPH,
/// Delta-coefficient of the delta-SPH modification, see Marrone et al. 2011
SPH_DENSITY_DIFFUSION_DELTA,
/// Alpha-coefficient of the delta-SPH modification.
SPH_VELOCITY_DIFFUSION_ALPHA,
/// Whether to use artificial stress.
SPH_AV_USE_STRESS,
/// Weighting function exponent n in artificial stress term
SPH_AV_STRESS_EXPONENT,
/// Multiplicative factor of the artificial stress term (= strength of the viscosity)
SPH_AV_STRESS_FACTOR,
/// Damping coefficient of particle velocities, mainly intended for setting up initial conditions. Higher
/// values damp the oscillation/instabilities faster, but may converge to incorrect (unstable)
/// configuration. Lower values lead to (slower) convergence to correct (stable) configuration, but it may
/// cause body dissintegration if the initial conditions are to far from the stable solution. Zero
/// disables the damping.
SPH_STABILIZATION_DAMPING,
/// Alpha parameter of the density-independent solver.
SPH_DI_ALPHA,
/// Enables or disables scripted term.
SPH_SCRIPT_ENABLE,
/// Path of an arbitrary ChaiScript script executed each timestep.
SPH_SCRIPT_FILE,
/// Period or time point to execute the script. Zero means the time step is executed immediately or every
/// time step, depending on the value of SPH_SCRIPT_ONESHOT.
SPH_SCRIPT_PERIOD,
/// Whether to execute the script only once or periodically.
SPH_SCRIPT_ONESHOT,
/// If true, all particles have also a moment of inertia, representing a non-homogeneous mass
/// distribution. Otherwise, particles are spherical with inertia tensor I = 2/5 mr^2
NBODY_INERTIA_TENSOR,
/// \todo
NBODY_MAX_ROTATION_ANGLE,
/// If true, colliding particles form aggregates, which then move and rotate as rigid bodies. There are no
/// collisions between particles belonging to the same aggregate, only collisions of different aggregates
/// need to be handled. Note that enabling aggregates overrides handlers of collisions and overlaps.
NBODY_AGGREGATES_ENABLE,
/// Specifies the initial aggregates used in the simulation. See \ref AggregateEnum.
NBODY_AGGREGATES_SOURCE,
/// Algorithm to compute gravitational acceleration
GRAVITY_SOLVER,
/// Opening angle Theta for multipole approximation of gravity
GRAVITY_OPENING_ANGLE,
/// Order of multipole expansion
GRAVITY_MULTIPOLE_ORDER,
/// Gravity smoothing kernel
GRAVITY_KERNEL,
/// Gravitational constant. To be generalized.
GRAVITY_CONSTANT,
/// Period of gravity evaluation. If zero, gravity is computed every time step, for any positive value,
/// gravitational acceleration is cached for each particle and used each time step until next
/// recomputation.
GRAVITY_RECOMPUTATION_PERIOD,
/// Specifies how the collisions of particles should be handler; see CollisionHandlerEnum.
COLLISION_HANDLER,
/// Specifies how particle overlaps should be handled.
COLLISION_OVERLAP,
/// Coefficient of restitution for normal component (alongside particle direction vector) of velocity.
/// Applicable only for bounce collisions.
COLLISION_RESTITUTION_NORMAL,
/// Coefficient of restitution for tangent component (perpendicular to particle direction vector) of
/// velocity. Applicable only for bounce collisions.
COLLISION_RESTITUTION_TANGENT,
/// Relative particle overlap (0 for particles in contact, 1 for particles lying on top of each other) for
/// which the collision is handled as overlap. Used to avoid very small (<EPS) overlaps not being handled
/// as collision due to numerical imprecisions.
COLLISION_ALLOWED_OVERLAP,
/// Multiplier of the relative velocity, used when determining whether to merge the collided particles or
/// reject the collision. If zero, particles are always merged. Larger values than 1 can be used to merge
/// only very slowly moving particles.
COLLISION_BOUNCE_MERGE_LIMIT,
/// Parameter analogous to COLLISION_BOUNCE_MERGE_LIMIT, but used for the rotation of the merger.
/// Particles can only be merged if the angular frequency multiplied by this parameter is lower than the
/// breakup frequency. If zero, particles are always merged, values larger than 1 can be used to avoid
/// fast rotators in the simulation.
COLLISION_ROTATION_MERGE_LIMIT,
/// Magnitude of the repel force for the soft-body solver
SOFT_REPEL_STRENGTH,
/// Magnitude of the friction force for the soft-body solver
SOFT_FRICTION_STRENGTH,
/// Selected timestepping integrator
TIMESTEPPING_INTEGRATOR,
/// Courant number
TIMESTEPPING_COURANT_NUMBER,
/// Upper limit of the time step. The timestep is guaranteed to never exceed this value for any timestep
/// criterion. The lowest possible timestep is not set, timestep can be any positive value.
TIMESTEPPING_MAX_TIMESTEP,
/// Initial value of time step. If dynamic timestep is disabled, the run will keep the initial timestep
/// for the whole duration. Some timestepping algorithms might not use the initial timestep and directly
/// compute new value of timestep, in which case this parameter has no effect.
TIMESTEPPING_INITIAL_TIMESTEP,
/// Criterion used to determine value of time step. More criteria may be compined, in which case the
/// smallest time step of all is selected.
TIMESTEPPING_CRITERION,
/// Multiplicative factor k for the derivative criterion; dt = k * v / dv
TIMESTEPPING_DERIVATIVE_FACTOR,
/// Multiplicative factor for the divergence criterion
TIMESTEPPING_DIVERGENCE_FACTOR,
/// Power of the generalized mean, used to compute the final timestep from timesteps of individual
/// particles. Negative infinity means the minimal timestep is used. This value will also set statistics
/// of the restricting particle, namely the particle index and the quantity value and corresponding
/// derivative of the particle; these statistics are not saved for other powers.
TIMESTEPPING_MEAN_POWER,
/// Maximum relative increase of a timestep in two subsequent timesteps. Used to 'smooth' the timesteps,
/// as it prevents very fast increase of the time step, especially if the initial time step is very low.
/// Used only by \ref MultiCriterion.
TIMESTEPPING_MAX_INCREASE,
/// Number of sub-steps in the modified midpoint method.
TIMESTEPPING_MIDPOINT_COUNT,
/// Required relative accuracy of the Bulirsch-Stoer integrator.
TIMESTEPPING_BS_ACCURACY,
/// Global rotation of the coordinate system around axis (0, 0, 1) passing through origin. If non-zero,
/// causes non-intertial acceleration.
FRAME_ANGULAR_FREQUENCY,
FRAME_CONSTANT_ACCELERATION,
FRAME_TIDES_MASS,
FRAME_TIDES_POSITION,
/// Maximum number of particles in a leaf node.
FINDER_LEAF_SIZE,
/// Maximal in a a tree depth to be processed in parallel. While a larger value implies better
/// distribution of work between threads, it also comes up with performance penalty due to scheduling
/// overhead.
FINDER_MAX_PARALLEL_DEPTH,
/// Computational domain, enforced by boundary conditions
DOMAIN_TYPE,
/// Type of boundary conditions.
DOMAIN_BOUNDARY,
/// Center point of the domain
DOMAIN_CENTER,
/// Radius of a spherical and cylindrical domain
DOMAIN_RADIUS,
/// Height of a cylindrical domain
DOMAIN_HEIGHT,
/// (Vector) size of a block domain
DOMAIN_SIZE,
/// Minimal distance between a particle and its ghost, in units of smoothing length.
DOMAIN_GHOST_MIN_DIST,
/// Distance to the boundary in units of smoothing length under which the particles are frozen.
DOMAIN_FROZEN_DIST,
/// If true, the mapping coordinates will be computed and saved for all bodies in the simulation.
GENERATE_UVWS,
/// Type of the UV mapping
UVW_MAPPING,
};
enum class DistributionEnum {
/// Hexagonally close packing
HEXAGONAL,
/// Cubic close packing
CUBIC,
/// Random distribution of particles
RANDOM,
/// Isotropic uniform distribution by Diehl et al. (2012)
DIEHL_ET_AL,
/// Stratified distribution to reduce clustering
STRATIFIED,
/// Parametrized spiraling scheme by Saff & Kuijlaars (1997)
PARAMETRIZED_SPIRALING,
/// Distributes particles uniformly on line
LINEAR
};
enum class EosEnum {
/// No equation of state
NONE,
/// Equation of state for ideal gas
IDEAL_GAS,
/// Tait equation of state for simulations of liquids
TAIT,
/// Mie-Gruneisen equation of state
MIE_GRUNEISEN,
/// Tillotson (1962) equation of state
TILLOTSON,
/// Murnaghan equation of state
MURNAGHAN,
/// Simplified version of the Tillotson equation of state
SIMPLIFIED_TILLOTSON,
/// ANEOS given by look-up table
ANEOS
};
/// \brief Settings of a single body / gas phase / ...
///
/// Combines material parameters and numerical parameters of the SPH method specific for one body. Values of
/// parameters CANNOT be changed to preserve backward compatibility of serializer. New IDs can be created as
/// needed, parameters no longer needed can be removed.
enum class BodySettingsId {
/// Equation of state for this material, see EosEnum for options.
EOS = 0,
/// Initial distribution of SPH particles within the domain, see DistributionEnum for options.
INITIAL_DISTRIBUTION = 1,
/// If true, generated particles will be moved so that their center of mass corresponds to the center of
/// selected domain. Note that this will potentially move some particles outside of the domain, which can
/// clash with boundary conditions.
CENTER_PARTICLES = 2,
/// If true, particles are sorted using Morton code, preserving locality in memory.
PARTICLE_SORTING = 3,
/// Turns on 'SPH5 compatibility' mode when generating particle positions. This allows 1-1 comparison of
/// generated arrays, but results in too many generated particles (by about factor 1.4). The option also
/// implies CENTER_PARTICLES.
DISTRIBUTE_MODE_SPH5 = 4,
/// Strength parameter of the Diehl's distribution.
DIEHL_STRENGTH = 5,
/// Maximum allowed difference between the expected number of particles and the actual number of generated
/// particles. Higher value speed up the generation of particle positions.
DIEHL_MAX_DIFFERENCE = 6,
/// Number of iterations of particle repelling.
DIEHL_ITERATION_COUNT = 71,
/// Eta-factor between smoothing length and particle concentration (h = eta * n^(-1/d) )
SMOOTHING_LENGTH_ETA = 72,
/// Density at zero pressure
DENSITY = 7,
/// Allowed range of density. Densities of all particles all clamped to fit in the range.
DENSITY_RANGE = 8,
/// Estimated minimal value of density. This value is NOT used to clamp densities, but for
/// determining error of timestepping.
DENSITY_MIN = 9,
/// Initial specific internal energy
ENERGY = 10,
/// Allowed range of specific internal energy.
ENERGY_RANGE = 11,
/// Estimated minimal value of energy used to determine timestepping error.
ENERGY_MIN = 12,
/// Initial values of the deviatoric stress tensor
STRESS_TENSOR = 13,
/// Estimated minial value of stress tensor components used to determined timestepping error.
STRESS_TENSOR_MIN = 14,
/// Initial damage of the body.
DAMAGE = 15,
/// Allowed range of damage.
DAMAGE_RANGE = 16,
/// Estimate minimal value of damage used to determine timestepping error.
DAMAGE_MIN = 17,
/// Adiabatic index used by some equations of state (such as ideal gas)
ADIABATIC_INDEX = 18,
/// Exponent of density, representing a compressibility of a fluid. Used in Tait equation of state.
TAIT_GAMMA = 19,
/// Sound speed used in Tait equation of state
TAIT_SOUND_SPEED = 20,
/// Bulk modulus of the material
BULK_MODULUS = 21,
/// Coefficient B of the nonlinear compressive term in Tillotson equation
TILLOTSON_NONLINEAR_B = 22,
/// "Small a" coefficient in Tillotson equation
TILLOTSON_SMALL_A = 23,
/// "Small b" coefficient in Tillotson equation
TILLOTSON_SMALL_B = 24,
/// Alpha coefficient in expanded phase of Tillotson equation
TILLOTSON_ALPHA = 25,
/// Beta coefficient in expanded phase of Tillotson equation
TILLOTSON_BETA = 26,
/// Specific sublimation energy
TILLOTSON_SUBLIMATION = 27,
/// Specific energy of incipient vaporization
TILLOTSON_ENERGY_IV = 28,
/// Specific energy of complete vaporization
TILLOTSON_ENERGY_CV = 29,
/// Gruneisen's gamma paraemter used in Mie-Gruneisen equation of state
GRUNEISEN_GAMMA = 30,
/// Used in Mie-Gruneisen equations of state
BULK_SOUND_SPEED = 31,
/// Linear Hugoniot slope coefficient used in Mie-Gruneisen equation of state
HUGONIOT_SLOPE = 32,
/// Model of stress reducing used within the rheological model
RHEOLOGY_YIELDING = 33,
/// Model of fragmentation used within the rheological model
RHEOLOGY_DAMAGE = 34,
/// Shear modulus mu (a.k.a Lame's second parameter) of the material
SHEAR_MODULUS = 35,
/// Young modulus of the material
YOUNG_MODULUS = 36,
/// Elastic modulus lambda (a.k.a Lame's first parameter) of the material
ELASTIC_MODULUS = 37,
/// Elasticity limit of the von Mises yielding criterion
ELASTICITY_LIMIT = 38,
/// Melting energy, used for temperature-dependence of the stress tensor
MELT_ENERGY = 39,
/// Cohesion, yield strength at zero pressure
COHESION = 40,
/// Coefficient of friction for undamaged material
INTERNAL_FRICTION = 41,
/// Coefficient of friction for fully damaged material
DRY_FRICTION = 42,
/// Whether to use the acoustic fludization model.
USE_ACOUSTIC_FLUDIZATION = 43,
/// Characteristic decay time of acoustic oscillations in the material
OSCILLATION_DECAY_TIME = 44,
/// Regeneration efficiency of acoustric oscillations
OSCILLATION_REGENERATION = 74,
/// Effective viscosity of acoustic fludizations
FLUIDIZATION_VISCOSITY = 45,
/// Speed of crack growth, in units of local sound speed.
RAYLEIGH_SOUND_SPEED = 47,
/// Coefficient (multiplier) of the Weibull distribution of flaws
WEIBULL_COEFFICIENT = 48,
/// Exponent of the Weibull distribution of flaws
WEIBULL_EXPONENT = 49,
/// Whether to use precomputed distributions for flaw sampling. Otherwise, flaws are sampled using uniform
/// random number generator, which may be prohibitively slow for large particle counts.
WEIBULL_SAMPLE_DISTRIBUTIONS = 66,
/// Initial value of the material distention, used in the P-alpha model.
DISTENTION = 81,
BULK_VISCOSITY = 50,
SHEAR_VISCOSITY = 51,
DAMPING_COEFFICIENT = 52,
DIFFUSIVITY = 53,
/// Coefficient of surface tension
SURFACE_TENSION = 54,
/// Number of SPH particles in the body
PARTICLE_COUNT = 55,
/// Minimal number of particles per one body. Used when creating 'sub-bodies' withing one 'parent' body,
/// for example when creating rubble-pile asteroids, ice blocks inside an asteroid, etc. Parameter has no
/// effect for creation of a single monolithic body; the number of particles from PARTICLE_COUNT is used
/// in any case.
MIN_PARTICLE_COUNT = 56,
/// Initial alpha coefficient of the artificial viscosity. This is only used if the coefficient is
/// different for each particle. For constant coefficient shared for all particles, use value from global
/// settings.
AV_ALPHA = 57,
/// Lower and upper bound of the alpha coefficient, used only for time-dependent artificial viscosity.
AV_ALPHA_RANGE = 58,
/// Bulk (macro)porosity of the body
BULK_POROSITY = 64,
/// Heat capacity at constant pressure,
HEAT_CAPACITY = 67,
BODY_SHAPE_TYPE = 59,
/// Center point of the body. Currently used only by \ref StabilizationSolver.
BODY_CENTER = 61,
BODY_RADIUS = 68,
BODY_DIMENSIONS = 69,
BODY_HEIGHT = 73,
BODY_SPIN_RATE = 70,
VISUALIZATION_TEXTURE = 80,
/// Arbitrary string identifying this material
IDENTIFIER = 99,
};
using RunSettings = Settings<RunSettingsId>;
template <>
AutoPtr<RunSettings> RunSettings::instance;
using BodySettings = Settings<BodySettingsId>;
template <>
AutoPtr<BodySettings> BodySettings::instance;
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/objects/Palette.h
|
#pragma once
#include "gui/objects/Color.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/Function.h"
#include "objects/wrappers/Outcome.h"
#include "quantities/QuantityIds.h"
NAMESPACE_SPH_BEGIN
class Path;
enum class PaletteScale {
/// Control points are interpolated on linear scale
LINEAR,
/// Control points are interpolated on logarithmic scale. All points must be positive!
LOGARITHMIC,
/// Logarithic scale for values > 1 and < -1, linear scale on interval <-1, 1>
HYBRID
};
/// \brief Represents a color palette, used for mapping arbitrary number to a color.
class Palette {
public:
struct Point {
float value;
Rgba color;
};
private:
Array<Point> points;
Interval range;
PaletteScale scale;
public:
Palette() = default;
Palette(const Palette& other);
Palette(Palette&& other) = default;
Palette& operator=(const Palette& other);
Palette& operator=(Palette&& other) = default;
/// \brief Creates a color palette given control points and their colors.
///
/// For linear and hybrid scale, controls points can be both positive or negative numbers, for logarithmic
/// scale only positive numbers (and zero) are allowed. Control points must be passed in increasing order.
Palette(Array<Point>&& controlPoints, const PaletteScale scale);
/// \brief Returns the interval for which the palette is defined.
///
/// Values outside the interval will be mapped to the colors at the boundary of the interval.
Interval getInterval() const;
void setInterval(const Interval& newRange);
/// \brief Returns the scale of the palette.
PaletteScale getScale() const;
/// \brief Returns the color mapped to given number.
Rgba operator()(const float value) const;
/// \brief Returns the palette with colors modified by generic transform.
Palette transform(Function<Rgba(const Rgba&)> func) const;
/// \brief Converts a relative position to an absolute position on a palette.
///
/// The relative position is in interval <0, 1>, the absolute position is given by the control points of
/// the palette. For linear palette, this function is simply scaling of the interval, for logarithmic and
/// hybrid palettes it also transforms the input value by the corresponding function.
float relativeToPalette(const float value) const;
/// \brief Inverse transform to \ref relativeToPalette.
float paletteToRelative(const float value) const;
/// \brief Checks if the palette holds some data.
bool empty() const;
/// \brief Loads the palette from given input stream.
Outcome loadFromStream(std::istream& ifs);
/// \brief Loads the palette from given .csv file.
Outcome loadFromFile(const Path& path);
/// \brief Saves the palettes into given output stream.
Outcome saveToStream(std::ostream& ofs, const Size lineCnt = 256) const;
/// \brief Saves the palette to a .csv file.
Outcome saveToFile(const Path& path, const Size lineCnt = 256) const;
private:
float linearToPalette(const float value) const;
float paletteToLinear(const float value) const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/wrappers/Function.h
|
#pragma once
/// \file Function.h
/// \brief Generic wrappers of lambdas, functors and other callables
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/Traits.h"
#include "objects/wrappers/SharedPtr.h"
NAMESPACE_SPH_BEGIN
namespace Detail {
template <typename TSignature>
class Callable;
template <typename TReturn, typename... TArgs>
class Callable<TReturn(TArgs...)> : public Polymorphic {
public:
virtual TReturn operator()(TArgs... args) = 0;
};
} // namespace Detail
template <typename TSignature>
class Function;
/// \brief Wrapper of callable objects.
///
/// Function is copyable, having a pointer semantics. Copied object reference the same callable.
template <typename TReturn, typename... TArgs>
class Function<TReturn(TArgs...)> {
private:
SharedPtr<Detail::Callable<TReturn(TArgs...)>> holder;
template <typename TFunctor>
class FunctorCallable : public Detail::Callable<TReturn(TArgs...)> {
private:
TFunctor functor;
public:
FunctorCallable(TFunctor&& functor)
: functor(std::forward<TFunctor>(functor)) {}
virtual TReturn operator()(TArgs... args) override {
return functor(args...);
}
};
public:
Function() = default;
/// \brief Creates a function given a callable object.
///
/// The functor is passed by value on purpose, we do not want to store references in the function. It also
/// helps avoiding calling this constructor instead of copy/move constructors.
template <typename TFunctor, typename = std::enable_if_t<IsCallable<TFunctor, TArgs...>::value>>
Function(TFunctor functor)
: holder(makeShared<FunctorCallable<TFunctor>>(std::move(functor))) {}
Function(const Function& other)
: holder(other.holder) {}
Function(Function&& other)
: holder(std::move(other.holder)) {}
Function(std::nullptr_t)
: holder(nullptr) {}
template <typename TFunctor>
Function& operator=(TFunctor functor) {
holder = makeShared<FunctorCallable<TFunctor>>(std::move(functor));
return *this;
}
Function& operator=(const Function& other) {
holder = other.holder;
return *this;
}
Function& operator=(Function&& other) {
holder = std::move(other.holder);
return *this;
}
Function& operator=(std::nullptr_t) {
holder = nullptr;
return *this;
}
/// Calls the function, given argument list.
template <typename... Ts>
TReturn operator()(Ts&&... args) const {
SPH_ASSERT(holder);
return (*holder)(std::forward<Ts>(args)...);
}
/// Calls the function is set, otherwise it does nothing.
template <typename... Ts>
void callIfNotNull(Ts&&... args) const {
if (holder) {
this->operator()(std::forward<Ts>(args)...);
}
}
INLINE explicit operator bool() const {
return bool(holder);
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/finders/KdTree.inl.h
|
<reponame>pavelsevecek/OpenSPH
#include "objects/finders/KdTree.h" // including the header just to make syntax highlighting work and code navigation
NAMESPACE_SPH_BEGIN
enum class KdChild {
LEFT = 0,
RIGHT = 1,
};
template <typename TNode, typename TMetric>
void KdTree<TNode, TMetric>::buildImpl(IScheduler& scheduler, ArrayView<const Vector> points) {
VERBOSE_LOG
static_assert(sizeof(LeafNode<TNode>) == sizeof(InnerNode<TNode>), "Sizes of nodes must match");
// clean the current tree
const Size currentCnt = nodes.size();
this->init();
for (const auto& i : iterateWithIndex(points)) {
entireBox.extend(i.value());
idxs.push(i.index());
}
if (SPH_UNLIKELY(points.empty())) {
return;
}
const Size nodeCnt = max(2 * points.size() / config.leafSize + 1, currentCnt);
nodes.resize(nodeCnt);
SharedPtr<ITask> rootTask = scheduler.submit([this, &scheduler, points] {
this->buildTree(scheduler, ROOT_PARENT_NODE, KdChild(-1), 0, points.size(), entireBox, 0, 0);
});
rootTask->wait();
// shrink nodes to only the constructed ones
nodes.resize(nodeCounter);
SPH_ASSERT(this->sanityCheck(), this->sanityCheck().error());
}
template <typename TNode, typename TMetric>
void KdTree<TNode, TMetric>::buildTree(IScheduler& scheduler,
const Size parent,
const KdChild child,
const Size from,
const Size to,
const Box& box,
const Size slidingCnt,
const Size depth) {
Box box1, box2;
Vector boxSize = box.size();
// split by the dimension of largest extent
Size splitIdx = argMax(boxSize);
bool slidingMidpoint = false;
bool degeneratedBox = false;
if (to - from <= config.leafSize) {
// enough points to fit inside one leaf
this->addLeaf(parent, child, from, to);
return;
} else {
// check for singularity of dimensions
for (Size dim = 0; dim < 3; ++dim) {
if (this->isSingular(from, to, splitIdx)) {
boxSize[splitIdx] = 0.f;
// find new largest dimension
splitIdx = argMax(boxSize);
if (boxSize == Vector(0._f)) {
// too many overlapping points, just split until they fit within a leaf,
// the code can handle this case, but it smells with an error ...
SPH_ASSERT(false, "Too many overlapping points, something is probably wrong ...");
degeneratedBox = true;
break;
}
} else {
break;
}
}
// split around center of the box
Float splitPosition = box.center()[splitIdx];
std::make_signed_t<Size> n1 = from, n2 = to - 1; // use ints for easier for loop ending with 0
if (slidingCnt <= 5 && !degeneratedBox) {
for (;; std::swap(idxs[n1], idxs[n2])) {
for (; n1 < int(to) && this->values[idxs[n1]][splitIdx] <= splitPosition; ++n1)
;
for (; n2 >= int(from) && this->values[idxs[n2]][splitIdx] >= splitPosition; --n2)
;
if (n1 >= n2) {
break;
}
}
if (n1 == int(from)) {
Size idx = from;
splitPosition = this->values[idxs[from]][splitIdx];
for (Size i = from + 1; i < to; ++i) {
const Float x1 = this->values[idxs[i]][splitIdx];
if (x1 < splitPosition) {
idx = i;
splitPosition = x1;
}
}
std::swap(idxs[from], idxs[idx]);
n1++;
slidingMidpoint = true;
} else if (n1 == int(to)) {
Size idx = from;
splitPosition = this->values[idxs[from]][splitIdx];
for (Size i = from + 1; i < to; ++i) {
const Float x2 = this->values[idxs[i]][splitIdx];
if (x2 > splitPosition) {
idx = i;
splitPosition = x2;
}
}
std::swap(idxs[to - 1], idxs[idx]);
n1--;
slidingMidpoint = true;
}
tie(box1, box2) = box.split(splitIdx, splitPosition);
} else {
n1 = (from + to) >> 1;
// do quick select to sort elements around the midpoint
Iterator<Size> iter = idxs.begin();
if (!degeneratedBox) {
std::nth_element(iter + from, iter + n1, iter + to, [this, splitIdx](Size i1, Size i2) {
return this->values[i1][splitIdx] < this->values[i2][splitIdx];
});
}
tie(box1, box2) = box.split(splitIdx, this->values[idxs[n1]][splitIdx]);
}
// sanity check
SPH_ASSERT(this->checkBoxes(from, to, n1, box1, box2));
// add inner node and connect it to the parent
const Size index = this->addInner(parent, child, splitPosition, splitIdx);
// recurse to left and right subtree
const Size nextSlidingCnt = slidingMidpoint ? slidingCnt + 1 : 0;
auto processRightSubTree = [this, &scheduler, index, to, n1, box2, nextSlidingCnt, depth] {
this->buildTree(scheduler, index, KdChild::RIGHT, n1, to, box2, nextSlidingCnt, depth + 1);
};
if (depth < config.maxParallelDepth) {
// ad hoc decision - split the build only for few topmost nodes, there is no point in splitting
// the work for child node in the bottom, it would only overburden the ThreadPool.
scheduler.submit(processRightSubTree);
} else {
// otherwise simply process both subtrees in the same thread
processRightSubTree();
}
this->buildTree(scheduler, index, KdChild::LEFT, from, n1, box1, nextSlidingCnt, depth + 1);
}
}
template <typename TNode, typename TMetric>
void KdTree<TNode, TMetric>::addLeaf(const Size parent, const KdChild child, const Size from, const Size to) {
const Size index = nodeCounter++;
if (index >= nodes.size()) {
// needs more nodes than estimated; allocate up to 2x more than necessary to avoid frequent
// reallocations
nodesMutex.lock();
nodes.resize(max(2 * index, nodes.size()));
nodesMutex.unlock();
}
nodesMutex.lock_shared();
auto releaseLock = finally([this] { nodesMutex.unlock_shared(); });
LeafNode<TNode>& node = (LeafNode<TNode>&)nodes[index];
node.type = KdNode::Type::LEAF;
SPH_ASSERT(node.isLeaf());
#ifdef SPH_DEBUG
node.from = node.to = -1;
#endif
node.from = from;
node.to = to;
// find the bounding box of the leaf
Box box;
for (Size i = from; i < to; ++i) {
box.extend(this->values[idxs[i]]);
}
node.box = box;
if (parent == ROOT_PARENT_NODE) {
return;
}
InnerNode<TNode>& parentNode = (InnerNode<TNode>&)nodes[parent];
SPH_ASSERT(!parentNode.isLeaf());
if (child == KdChild::LEFT) {
// left child
parentNode.left = index;
} else {
SPH_ASSERT(child == KdChild::RIGHT);
// right child
parentNode.right = index;
}
}
template <typename TNode, typename TMetric>
Size KdTree<TNode, TMetric>::addInner(const Size parent,
const KdChild child,
const Float splitPosition,
const Size splitIdx) {
static_assert(int(KdNode::Type::X) == 0 && int(KdNode::Type::Y) == 1 && int(KdNode::Type::Z) == 2,
"Invalid values of KdNode::Type enum");
const Size index = nodeCounter++;
if (index >= nodes.size()) {
// needs more nodes than estimated; allocate up to 2x more than necessary to avoid frequent
// reallocations
nodesMutex.lock();
nodes.resize(max(2 * index, nodes.size()));
nodesMutex.unlock();
}
nodesMutex.lock_shared();
auto releaseLock = finally([this] { nodesMutex.unlock_shared(); });
InnerNode<TNode>& node = (InnerNode<TNode>&)nodes[index];
node.type = KdNode::Type(splitIdx);
SPH_ASSERT(!node.isLeaf());
#ifdef SPH_DEBUG
node.left = node.right = -1;
node.box = Box(); // will be computed later
#endif
node.splitPosition = float(splitPosition);
if (parent == ROOT_PARENT_NODE) {
// no need to set up parents
return index;
}
InnerNode<TNode>& parentNode = (InnerNode<TNode>&)nodes[parent];
if (child == KdChild::LEFT) {
// left child
SPH_ASSERT(parentNode.left == Size(-1));
parentNode.left = index;
} else {
SPH_ASSERT(child == KdChild::RIGHT);
// right child
SPH_ASSERT(parentNode.right == Size(-1));
parentNode.right = index;
}
return index;
}
template <typename TNode, typename TMetric>
void KdTree<TNode, TMetric>::init() {
entireBox = Box();
idxs.clear();
nodes.clear();
nodeCounter = 0;
}
template <typename TNode, typename TMetric>
bool KdTree<TNode, TMetric>::isSingular(const Size from, const Size to, const Size splitIdx) const {
for (Size i = from; i < to; ++i) {
if (this->values[idxs[i]][splitIdx] != this->values[idxs[to - 1]][splitIdx]) {
return false;
}
}
return true;
}
template <typename TNode, typename TMetric>
bool KdTree<TNode, TMetric>::checkBoxes(const Size from,
const Size to,
const Size mid,
const Box& box1,
const Box& box2) const {
for (Size i = from; i < to; ++i) {
if (i < mid && !box1.contains(this->values[idxs[i]])) {
return false;
}
if (i >= mid && !box2.contains(this->values[idxs[i]])) {
return false;
}
}
return true;
}
/// \brief Object used during traversal.
///
/// Holds an index of the node and squared distance of the bounding box.
struct ProcessedNode {
/// Index into the nodeStack array. We cannot use pointers because the array might get reallocated.
Size idx;
Vector sizeSqr;
Float distanceSqr;
};
/// \brief Cached stack to avoid reallocation
///
/// It is thread_local to allow using KdTree from multiple threads
extern thread_local Array<ProcessedNode> nodeStack;
template <typename TNode, typename TMetric>
template <bool FindAll>
Size KdTree<TNode, TMetric>::find(const Vector& r0,
const Size index,
const Float radius,
Array<NeighborRecord>& neighbors) const {
SPH_ASSERT(neighbors.empty());
const Float radiusSqr = sqr(radius);
const Vector maxDistSqr = sqr(max(Vector(0._f), entireBox.lower() - r0, r0 - entireBox.upper()));
// L1 norm
const Float l1 = l1Norm(maxDistSqr);
ProcessedNode node{ 0, maxDistSqr, l1 };
SPH_ASSERT(nodeStack.empty()); // not sure if there can be some nodes from previous search ...
TMetric metric;
while (node.distanceSqr < radiusSqr) {
if (nodes[node.idx].isLeaf()) {
// for leaf just add all
const LeafNode<TNode>& leaf = (const LeafNode<TNode>&)nodes[node.idx];
if (leaf.size() > 0) {
const Float leafDistSqr =
metric(max(Vector(0._f), leaf.box.lower() - r0, r0 - leaf.box.upper()));
if (leafDistSqr < radiusSqr) {
// leaf intersects the sphere
for (Size i = leaf.from; i < leaf.to; ++i) {
const Size actIndex = idxs[i];
const Float distSqr = metric(this->values[actIndex] - r0);
if (distSqr < radiusSqr && (FindAll || this->rank[actIndex] < this->rank[index])) {
/// \todo order part
neighbors.push(NeighborRecord{ actIndex, distSqr });
}
}
}
}
if (nodeStack.empty()) {
break;
}
node = nodeStack.pop();
} else {
// inner node
const InnerNode<TNode>& inner = (InnerNode<TNode>&)nodes[node.idx];
const Size splitDimension = Size(inner.type);
SPH_ASSERT(splitDimension < 3);
const Float splitPosition = inner.splitPosition;
if (r0[splitDimension] < splitPosition) {
// process left subtree, put right on stack
ProcessedNode right = node;
node.idx = inner.left;
const Float dx = splitPosition - r0[splitDimension];
right.distanceSqr += sqr(dx) - right.sizeSqr[splitDimension];
right.sizeSqr[splitDimension] = sqr(dx);
if (right.distanceSqr < radiusSqr) {
const InnerNode<TNode>& next = (const InnerNode<TNode>&)nodes[right.idx];
right.idx = next.right;
nodeStack.push(right);
}
} else {
// process right subtree, put left on stack
ProcessedNode left = node;
node.idx = inner.right;
const Float dx = splitPosition - r0[splitDimension];
left.distanceSqr += sqr(dx) - left.sizeSqr[splitDimension];
left.sizeSqr[splitDimension] = sqr(dx);
if (left.distanceSqr < radiusSqr) {
const InnerNode<TNode>& next = (const InnerNode<TNode>&)nodes[left.idx];
left.idx = next.left;
nodeStack.push(left);
}
}
}
}
return neighbors.size();
}
template <typename TNode, typename TMetric>
Outcome KdTree<TNode, TMetric>::sanityCheck() const {
if (this->values.size() != idxs.size()) {
return makeFailed("Number of values does not match the number of indices");
}
// check bounding box
for (const Vector& v : this->values) {
if (!entireBox.contains(v)) {
return makeFailed("Points are not strictly within the bounding box");
}
}
// check node connectivity
Size counter = 0;
std::set<Size> indices;
Function<Outcome(const Size idx)> countNodes = [this, &indices, &counter, &countNodes](
const Size idx) -> Outcome {
// count this
counter++;
// check index validity
if (idx >= nodes.size()) {
return makeFailed("Invalid index found: ", idx, " (", nodes.size(), ")");
}
// if inner node, count children
if (!nodes[idx].isLeaf()) {
const InnerNode<TNode>& inner = (const InnerNode<TNode>&)nodes[idx];
return countNodes(inner.left) && countNodes(inner.right);
} else {
// check that all points fit inside the bounding box of the leaf
const LeafNode<TNode>& leaf = (const LeafNode<TNode>&)nodes[idx];
if (leaf.to == leaf.from) {
// empty leaf?
return makeFailed("Empty leaf: ", leaf.to);
}
for (Size i = leaf.from; i < leaf.to; ++i) {
if (!leaf.box.contains(this->values[idxs[i]])) {
return makeFailed("Leaf points do not fit inside the bounding box");
}
if (indices.find(i) != indices.end()) {
// child referenced twice?
return makeFailed("Index repeated: ", i);
}
indices.insert(i);
}
}
return SUCCESS;
};
const Outcome result = countNodes(0);
if (!result) {
return result;
}
// we should count exactly nodes.size()
if (counter != nodes.size()) {
return makeFailed("Unexpected number of nodes: ", counter, " == ", nodes.size());
}
// each index should have been inserted exactly once
Size i = 0;
for (Size idx : indices) {
// std::set is sorted, so we can check sequentially
if (idx != i) {
return makeFailed("Invalid index: ", idx, " == ", i);
}
++i;
}
return SUCCESS;
}
template <IterateDirection Dir, typename TNode, typename TMetric, typename TFunctor>
void iterateTree(KdTree<TNode, TMetric>& tree,
IScheduler& scheduler,
const TFunctor& functor,
const Size nodeIdx,
const Size depthLimit) {
TNode& node = tree.getNode(nodeIdx);
if (Dir == IterateDirection::TOP_DOWN) {
if (node.isLeaf()) {
functor(node, nullptr, nullptr);
} else {
InnerNode<TNode>& inner = reinterpret_cast<InnerNode<TNode>&>(node);
if (!functor(inner, &tree.getNode(inner.left), &tree.getNode(inner.right))) {
return;
}
}
}
SharedPtr<ITask> task;
if (!node.isLeaf()) {
InnerNode<TNode>& inner = reinterpret_cast<InnerNode<TNode>&>(node);
const Size newDepth = depthLimit == 0 ? 0 : depthLimit - 1;
auto iterateRightSubtree = [&tree, &scheduler, &functor, &inner, newDepth] {
iterateTree<Dir>(tree, scheduler, functor, inner.right, newDepth);
};
if (newDepth > 0) {
task = scheduler.submit(iterateRightSubtree);
} else {
iterateRightSubtree();
}
iterateTree<Dir>(tree, scheduler, functor, inner.left, newDepth);
}
if (task) {
task->wait();
}
if (Dir == IterateDirection::BOTTOM_UP) {
if (node.isLeaf()) {
functor(node, nullptr, nullptr);
} else {
InnerNode<TNode>& inner = reinterpret_cast<InnerNode<TNode>&>(node);
functor(inner, &tree.getNode(inner.left), &tree.getNode(inner.right));
}
}
}
/// \copydoc iterateTree
template <IterateDirection Dir, typename TNode, typename TMetric, typename TFunctor>
void iterateTree(const KdTree<TNode, TMetric>& tree,
IScheduler& scheduler,
const TFunctor& functor,
const Size nodeIdx,
const Size depthLimit) {
// use non-const overload using const_cast, but call the functor with const reference
auto actFunctor = [&functor](TNode& node, TNode* left, TNode* right)
INL { return functor(asConst(node), left, right); };
iterateTree<Dir>(const_cast<KdTree<TNode, TMetric>&>(tree), scheduler, actFunctor, nodeIdx, depthLimit);
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/wrappers/LockingPtr.h
|
<reponame>pavelsevecek/OpenSPH
#pragma once
/// \file LockingPtr.h
/// \brief Smart pointer associated with a mutex
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/wrappers/AlignedStorage.h"
#include "objects/wrappers/SharedPtr.h"
#include <atomic>
#include <mutex>
NAMESPACE_SPH_BEGIN
namespace Detail {
template <typename T, typename TMutex = std::mutex>
class LockingControlBlock : public ControlBlock<T> {
private:
TMutex mutex;
bool locked = false;
public:
LockingControlBlock(T* ptr)
: ControlBlock<T>(ptr) {}
void lock() {
mutex.lock();
locked = true;
}
void unlock() {
mutex.unlock();
locked = false;
}
bool isLocked() const {
return locked;
}
};
} // namespace Detail
template <typename T>
class LockingPtr {
template <typename>
friend class LockingPtr;
private:
SharedPtr<T> resource;
Detail::LockingControlBlock<T>* block = nullptr;
public:
LockingPtr() = default;
LockingPtr(T* ptr)
: resource(ptr, ptr ? alignedNew<Detail::LockingControlBlock<T>>(ptr) : nullptr) {
block = static_cast<Detail::LockingControlBlock<T>*>(resource.block);
}
LockingPtr(AutoPtr<T>&& other)
: LockingPtr(&*other) {
other.release();
}
LockingPtr(const LockingPtr& other)
: resource(other.resource)
, block(other.block) {}
template <typename T2>
LockingPtr(const LockingPtr<T2>& other)
: resource(other.resource) {
block = static_cast<Detail::LockingControlBlock<T>*>(resource.block);
}
LockingPtr(LockingPtr&& other)
: resource(std::move(other.resource))
, block(other.block) {
other.block = nullptr;
}
template <typename T2>
LockingPtr(LockingPtr<T2>&& other)
: resource(std::move(other.resource))
, block((Detail::LockingControlBlock<T>*)other.block) {
// type safety is already guarandeed by SharedPtr, so hopefully we can simply cast the block (the
// Locking block only adds a mutex that's independend on T)
other.block = nullptr;
}
~LockingPtr() {
if (block) {
// make sure all the proxies are destroyed before killing the object
std::unique_lock<Detail::LockingControlBlock<T>> lock(*block);
}
}
LockingPtr& operator=(const LockingPtr& other) {
if (block) {
std::unique_lock<Detail::LockingControlBlock<T>> lock(*block);
resource = other.resource;
block = other.block;
} else {
resource = other.resource;
block = other.block;
}
return *this;
}
LockingPtr& operator=(LockingPtr&& other) {
if (block) {
std::unique_lock<Detail::LockingControlBlock<T>> lock(*block);
resource = std::move(other.resource);
std::swap(block, other.block);
} else {
resource = std::move(other.resource);
std::swap(block, other.block);
}
return *this;
}
class Proxy {
template <typename>
friend class LockingPtr;
private:
RawPtr<T> ptr;
std::unique_lock<Detail::LockingControlBlock<T>> lock;
Proxy()
: ptr(nullptr) {}
Proxy(const SharedPtr<T>& ptr, Detail::LockingControlBlock<T>* block)
: ptr(ptr.get())
, lock(*block) {
SPH_ASSERT(ptr != nullptr);
}
public:
Proxy(Proxy&& proxy)
: ptr(proxy.ptr)
, lock(std::move(proxy.lock)) {}
RawPtr<T> operator->() {
SPH_ASSERT(ptr != nullptr);
return ptr;
}
T& operator*() {
SPH_ASSERT(ptr != nullptr);
return *ptr;
}
RawPtr<T> get() {
return ptr;
}
bool isLocked() {
return lock.owns_lock();
}
void release() {
if (lock.owns_lock()) {
lock.unlock();
}
ptr = nullptr;
}
};
struct ProxyRef {
Proxy proxy;
operator T&() {
return *proxy;
}
};
Proxy lock() const {
if (resource) {
return Proxy(resource, block);
} else {
return Proxy();
}
}
Proxy operator->() const {
SPH_ASSERT(resource);
return Proxy(resource, block);
}
ProxyRef operator*() const {
SPH_ASSERT(resource);
return ProxyRef{ Proxy(resource, block) };
}
explicit operator bool() const {
return bool(resource);
}
bool operator!() const {
return !resource;
}
void reset() {
if (block) {
std::unique_lock<Detail::LockingControlBlock<T>> lock(*block);
block = nullptr;
resource.reset();
} else {
resource.reset();
}
}
};
template <typename T, typename... TArgs>
LockingPtr<T> makeLocking(TArgs&&... args) {
return LockingPtr<T>(alignedNew<T>(std::forward<TArgs>(args)...));
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/objects/RenderJobs.h
|
<gh_stars>10-100
#pragma once
#include "gui/Settings.h"
#include "gui/objects/Bitmap.h"
#include "gui/objects/CameraJobs.h"
#include "gui/renderers/IRenderer.h"
NAMESPACE_SPH_BEGIN
class IColorizer;
struct RenderParams;
class JobNode;
class Palette;
enum class RenderColorizerId;
enum class AnimationType {
SINGLE_FRAME = 0,
FILE_SEQUENCE = 2,
};
class IRenderPreview : public Polymorphic {
public:
virtual void render(const Pixel resolution, IRenderOutput& output) = 0;
virtual void update(RenderParams&& params) = 0;
virtual void update(AutoPtr<ICamera>&& newCamera) = 0;
virtual void update(AutoPtr<IColorizer>&& colorizer) = 0;
virtual void update(AutoPtr<IRenderer>&& renderer) = 0;
virtual void update(Palette&& palette) = 0;
virtual void cancel() = 0;
};
class IImageJob : public IJob {
private:
SharedPtr<Bitmap<Rgba>> result;
protected:
GuiSettings gui;
public:
explicit IImageJob(const std::string& name)
: IJob(name) {}
virtual ExtJobType provides() const override final {
return GuiJobType::IMAGE;
}
virtual JobContext getResult() const override final {
return result;
}
};
struct AnimationFrame : public IStorageUserData {
Bitmap<Rgba> bitmap;
Array<IRenderOutput::Label> labels;
};
class AnimationJob : public IImageJob {
private:
GuiSettings gui;
EnumWrapper colorizerId;
bool addSurfaceGravity = true;
Path directory;
std::string fileMask = "img_%d.png";
EnumWrapper animationType;
bool transparentBackground = false;
int extraFrames = 0;
struct {
Path firstFile = Path("out_0000.ssf");
} sequence;
public:
explicit AnimationJob(const std::string& name);
virtual std::string className() const override {
return "render animation";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "particles", JobType::PARTICLES },
{ "camera", GuiJobType::CAMERA },
};
}
virtual UnorderedMap<std::string, ExtJobType> requires() const override;
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
AutoPtr<IRenderPreview> getRenderPreview(const RunSettings& global) const;
// needed for interactive rendering
AutoPtr<IRenderer> getRenderer(const RunSettings& global) const;
AutoPtr<IColorizer> getColorizer(const RunSettings& global) const;
RenderParams getRenderParams() const;
private:
RenderParams getRenderParams(const GuiSettings& gui) const;
};
class VdbJob : public IParticleJob {
private:
Vector gridStart = Vector(-1.e5_f);
Vector gridEnd = Vector(1.e5_f);
int dimPower = 10;
Float surfaceLevel = 0.13_f;
struct {
bool enabled = false;
Path firstFile = Path("out_0000.ssf");
} sequence;
Path path = Path("grid.vdb");
public:
VdbJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "save VDB grid";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual UnorderedMap<std::string, ExtJobType>
requires() const override {
if (sequence.enabled) {
return {};
} else {
return { { "particles", JobType::PARTICLES } };
}
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
private:
void generate(Storage& storage, const RunSettings& global, const Path& outputPath);
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/system/Platform.h
|
<reponame>pavelsevecek/OpenSPH<gh_stars>10-100
#pragma once
/// \file Platform.h
/// \brief System functions
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/wrappers/Expected.h"
#include "objects/wrappers/Outcome.h"
#include <stdio.h>
NAMESPACE_SPH_BEGIN
class Path;
/// Returns the absolute path to the currently running executable.
Expected<Path> getExecutablePath();
/// \brief Sends a mail with given message.
Outcome sendMail(const std::string& to,
const std::string& from,
const std::string& subject,
const std::string& message);
/// \brief Shows a notification using 'notify-send' command.
///
/// The function is non-blocking, the notification disappears on timeout or when user hides it.
Outcome showNotification(const std::string& title, const std::string& message);
/// \brief Sends a push notification to an Android device, using SimplePush API.
///
/// Requires installed curl on the system.
/// \param key SimplePush key of the Android device.
/// \param title Title of the notification.
/// \param message Notification message.
Outcome sendPushNotification(const std::string& key, const std::string& title, const std::string& message);
/// \brief Returns git commit hash of the current or older commit as string.
///
/// If the git repository is not found or command fails, returns error message
/// \param pathToGitRoot Path to where the source code is located
/// \param prev Number of commits into the history. For 0, the current commit is returned.
Expected<std::string> getGitCommit(const Path& pathToGitRoot, const Size prev = 0);
Optional<Float> getCpuUsage();
/// \brief Returns true if the program is running with attached debugger.
bool isDebuggerPresent();
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
test/utils/Config.h
|
#pragma once
#include "io/Path.h"
NAMESPACE_SPH_BEGIN
#ifndef SPH_CONFIG_SET
static_assert(false,
"You need to modify these paths according to your system. Then define macro SPH_CONFIG_SET and rebuild "
"the tests.");
#else
/// Directory containing auxiliary resources for tests (serialized storage, etc.)
const Path RESOURCE_PATH = Path("/home/pavel/projects/astro/sph/src/test/resources");
/// Working directory of the executable, used for testing of Path class.
#ifdef SPH_DEBUG
const Path WORKING_DIR = Path("/home/pavel/projects/astro/sph/build-debug/test/");
#else
const Path WORKING_DIR = Path("/home/pavel/projects/astro/sph/build-release/test/");
#endif
#endif
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/renderers/RayMarcher.h
|
#pragma once
#include "gui/Settings.h"
#include "gui/objects/Color.h"
#include "gui/renderers/Brdf.h"
#include "gui/renderers/IRenderer.h"
#include "objects/finders/Bvh.h"
#include "sph/kernel/Kernel.h"
NAMESPACE_SPH_BEGIN
class FrameBuffer;
class IBrdf;
class IColorMap;
class RayMarcher : public IRaytracer {
private:
/// BVH for finding intersections of rays with particles
Bvh<BvhSphere> bvh;
/// Finder for finding neighbors of intersected particles
AutoPtr<IBasicFinder> finder;
LutKernel<3> kernel;
/// \brief Parameters fixed for the renderer.
///
/// Note that additional parameters which can differ for each rendered image are passed to \ref render.
struct {
/// Direction to sun; sun is assumed to be a point light source.
Vector dirToSun;
/// BRDF used to get the surface reflectance.
AutoPtr<IBrdf> brdf;
/// Cast shadows
bool shadows = true;
/// Render surface of spheres instead of an isosurface.
bool renderSpheres = true;
} fixed;
struct MarchData {
/// Neighbor indices of the current particle
Array<Size> neighs;
/// Intersection for the current ray
Array<IntersectionInfo> intersections;
/// Cached index of the previously evaluated particle, used for optimizations.
Size previousIdx;
MarchData() = default;
MarchData(MarchData&& other) = default;
MarchData(const MarchData& other)
: neighs(other.neighs.clone())
, intersections(other.intersections.clone())
, previousIdx(other.previousIdx) {
// needed to be used in Any, but never should be actually called
SPH_ASSERT(false);
}
};
struct {
/// Particle positions
Array<Vector> r;
/// Particle colors
Array<Rgba> colors;
/// Mapping coordinates. May be empty.
Array<Vector> uvws;
/// Particle volume (=mass/density)
Array<Float> v;
/// Particle indices
Array<Size> flags;
/// Material ID for each particle
Array<Size> materialIDs;
/// Textures of the rendered bodies. Can be empty. The textures are assigned to the bodies using their
/// material IDs.
Array<SharedPtr<Texture>> textures;
/// If true, the colors are used for emission, otherwise for diffuse reflectance.
bool doEmission;
} cached;
public:
RayMarcher(SharedPtr<IScheduler> scheduler, const GuiSettings& settings);
~RayMarcher() override;
virtual void initialize(const Storage& storage,
const IColorizer& colorizer,
const ICamera& camera) override;
virtual bool isInitialized() const override;
virtual void setColorizer(const IColorizer& colorizer) override;
private:
virtual Rgba shade(const RenderParams& params,
const CameraRay& cameraRay,
ThreadData& data) const override;
/// \param Creates a neighbor list for given particle.
///
/// The neighbor list is cached and can be reused by the calling thread next time the function is called.
/// \return View on the cached neighbor light.
ArrayView<const Size> getNeighborList(MarchData& data, const Size index) const;
/// \brief Returns the intersection of the iso-surface.
///
/// If no intersection exists, function returns NOTHING.
Optional<Vector> intersect(MarchData& data,
const Ray& ray,
const Float surfaceLevel,
const bool occlusion) const;
struct IntersectContext {
/// Particle hit by the ray.
Size index;
/// Ray casted from the camera.
Ray ray;
/// Distance of the sphere hit, i.e. the minimap distance of the actual hit.
Float t_min;
/// Selected value of the iso-surface.
Float surfaceLevel;
};
/// \brief Finds the actual surface point for given shade context.
///
/// If no such point exists, function returns NOTHING.
Optional<Vector> getSurfaceHit(MarchData& data,
const IntersectContext& context,
const bool occlusion) const;
/// \brief Returns the color of given hit point.
Rgba getSurfaceColor(MarchData& data,
const RenderParams& params,
const Size index,
const Vector& hit,
const Vector& dir) const;
Float evalField(ArrayView<const Size> neighs, const Vector& pos) const;
Vector evalGradient(ArrayView<const Size> neighs, const Vector& pos) const;
Rgba evalColor(ArrayView<const Size> neighs, const Vector& pos1) const;
Vector evalUvws(ArrayView<const Size> neighs, const Vector& pos1) const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/finders/Bvh.inl.h
|
#include "objects/finders/Bvh.h"
NAMESPACE_SPH_BEGIN
struct BvhTraversal {
Size idx;
Float t_min;
};
struct BvhBuildEntry {
Size parent;
Size start;
Size end;
};
bool intersectBox(const Box& box, const Ray& ray, Float& t_min, Float& t_max) {
StaticArray<Vector, 2> b = { box.lower(), box.upper() };
Float tmin = (b[ray.signs[X]][X] - ray.orig[X]) * ray.invDir[X];
Float tmax = (b[1 - ray.signs[X]][X] - ray.orig[X]) * ray.invDir[X];
SPH_ASSERT(!std::isnan(tmin) && !std::isnan(tmax)); // they may be inf though
const Float tymin = (b[ray.signs[Y]][Y] - ray.orig[Y]) * ray.invDir[Y];
const Float tymax = (b[1 - ray.signs[Y]][Y] - ray.orig[Y]) * ray.invDir[Y];
SPH_ASSERT(!std::isnan(tymin) && !std::isnan(tymax));
if ((tmin > tymax) || (tymin > tmax)) {
return false;
}
tmin = max(tmin, tymin);
tmax = min(tmax, tymax);
const Float tzmin = (b[ray.signs[Z]][Z] - ray.orig[Z]) * ray.invDir[Z];
const Float tzmax = (b[1 - ray.signs[Z]][Z] - ray.orig[Z]) * ray.invDir[Z];
SPH_ASSERT(!std::isnan(tzmin) && !std::isnan(tzmax));
if ((tmin > tzmax) || (tzmin > tmax)) {
return false;
}
tmin = max(tmin, tzmin);
tmax = min(tmax, tzmax);
t_min = tmin;
t_max = tmax;
// reject intersections at t<0
return t_max > 0.f;
}
template <typename TBvhObject>
template <typename TAddIntersection>
void Bvh<TBvhObject>::getIntersections(const Ray& ray, const TAddIntersection& addIntersection) const {
StaticArray<Float, 4> boxHits{ LARGE, LARGE, LARGE, LARGE };
Size closer;
Size other;
StaticArray<BvhTraversal, 64> stack;
int stackIdx = 0;
stack[stackIdx].idx = 0;
stack[stackIdx].t_min = 0._f; // -INFTY;
while (stackIdx >= 0) {
const Size idx = stack[stackIdx].idx;
// const Float t_min = stack[stackIdx].t_min;
stackIdx--;
const BvhNode& node = nodes[idx];
/// \todo optimization for the single intersection case
/* if (t_min > intersection.t) {
continue;
}*/
if (node.rightOffset == 0) {
// leaf
for (Size primIdx = 0; primIdx < node.primCnt; ++primIdx) {
IntersectionInfo current;
const TBvhObject& obj = objects[node.start + primIdx];
const bool hit = obj.getIntersection(ray, current);
if (hit) {
SPH_ASSERT(current.t >= 0.f); // objects should not give us intersections at t<0
const bool doContinue = addIntersection(current);
if (!doContinue) {
return;
}
}
}
} else {
// inner node
const bool hitc0 = intersectBox(nodes[idx + 1].box, ray, boxHits[0], boxHits[1]);
const bool hitc1 = intersectBox(nodes[idx + node.rightOffset].box, ray, boxHits[2], boxHits[3]);
if (hitc0 && hitc1) {
closer = idx + 1;
other = idx + node.rightOffset;
if (boxHits[2] < boxHits[0]) {
std::swap(boxHits[0], boxHits[2]);
std::swap(boxHits[1], boxHits[3]);
std::swap(closer, other);
}
stack[++stackIdx] = BvhTraversal{ other, boxHits[2] };
stack[++stackIdx] = BvhTraversal{ closer, boxHits[0] };
} else if (hitc0) {
stack[++stackIdx] = BvhTraversal{ idx + 1, boxHits[0] };
} else if (hitc1) {
stack[++stackIdx] = BvhTraversal{ idx + node.rightOffset, boxHits[2] };
}
}
}
}
template <typename TBvhObject>
bool Bvh<TBvhObject>::getFirstIntersection(const Ray& ray, IntersectionInfo& intersection) const {
intersection.t = INFTY;
intersection.object = nullptr;
this->getIntersections(ray, [&intersection](IntersectionInfo& current) {
if (current.t < intersection.t) {
intersection = current;
}
return true;
});
return intersection.object != nullptr;
}
template <typename TBvhObject>
template <typename TOutIter>
Size Bvh<TBvhObject>::getAllIntersections(const Ray& ray, TOutIter iter) const {
Size count = 0;
this->getIntersections(ray, [&iter, &count](IntersectionInfo& current) { //
*iter = current;
++iter;
++count;
return true;
});
return count;
}
template <typename TBvhObject>
bool Bvh<TBvhObject>::isOccluded(const Ray& ray) const {
bool occluded = false;
this->getIntersections(ray, [&occluded](IntersectionInfo&) {
occluded = true;
return false; // do not continue with traversal
});
return occluded;
}
template <typename TBvhObject>
void Bvh<TBvhObject>::build(Array<TBvhObject>&& objs) {
objects = std::move(objs);
SPH_ASSERT(!objects.empty());
nodeCnt = 0;
leafCnt = 0;
StaticArray<BvhBuildEntry, 128> stack;
Size stackIdx = 0;
constexpr Size UNTOUCHED = 0xffffffff;
constexpr Size NO_PARENT = 0xfffffffc;
constexpr Size TOUCHED_TWICE = 0xfffffffd;
// Push the root
stack[stackIdx].start = 0;
stack[stackIdx].end = objects.size();
stack[stackIdx].parent = NO_PARENT;
stackIdx++;
BvhNode node;
Array<BvhNode> buildNodes;
buildNodes.reserve(2 * objects.size());
while (stackIdx > 0) {
BvhBuildEntry& nodeEntry = stack[--stackIdx];
const Size start = nodeEntry.start;
const Size end = nodeEntry.end;
const Size primCnt = end - start;
nodeCnt++;
node.start = start;
node.primCnt = primCnt;
node.rightOffset = UNTOUCHED;
Box bbox = objects[start].getBBox();
const Vector center = objects[start].getCenter();
Box boxCenter(center, center);
for (Size i = start + 1; i < end; ++i) {
bbox.extend(objects[i].getBBox());
boxCenter.extend(objects[i].getCenter());
}
node.box = bbox;
if (primCnt <= leafSize) {
node.rightOffset = 0;
leafCnt++;
}
buildNodes.push(node);
if (nodeEntry.parent != NO_PARENT) {
buildNodes[nodeEntry.parent].rightOffset--;
if (buildNodes[nodeEntry.parent].rightOffset == TOUCHED_TWICE) {
buildNodes[nodeEntry.parent].rightOffset = nodeCnt - 1 - nodeEntry.parent;
}
}
if (node.rightOffset == 0) {
continue;
}
const Size splitDim = argMax(boxCenter.size());
const Float split = 0.5_f * (boxCenter.lower()[splitDim] + boxCenter.upper()[splitDim]);
Size mid = start;
for (Size i = start; i < end; ++i) {
if (objects[i].getCenter()[splitDim] < split) {
std::swap(objects[i], objects[mid]);
++mid;
}
}
if (mid == start || mid == end) {
mid = start + (end - start) / 2;
}
stack[stackIdx++] = { nodeCnt - 1, mid, end };
stack[stackIdx++] = { nodeCnt - 1, start, mid };
}
SPH_ASSERT(buildNodes.size() == nodeCnt);
nodes = std::move(buildNodes);
}
template <typename TBvhObject>
Box Bvh<TBvhObject>::getBoundingBox() const {
return nodes[0].box;
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/thread/OpenMp.h
|
<reponame>pavelsevecek/OpenSPH<filename>core/thread/OpenMp.h
#pragma once
#include "thread/Scheduler.h"
NAMESPACE_SPH_BEGIN
/// \brief Scheduler encapsulating OpenMP directives.
///
/// Need to be compiled with -fopenmp.
class OmpScheduler : public IScheduler {
private:
static SharedPtr<OmpScheduler> globalInstance;
Size granularity = 100;
public:
OmpScheduler(const Size numThreads = 0);
void setGranularity(const Size newGranularity) {
granularity = newGranularity;
}
virtual SharedPtr<ITask> submit(const Function<void()>& task) override;
virtual Optional<Size> getThreadIdx() const override;
virtual Size getThreadCnt() const override;
virtual Size getRecommendedGranularity() const override;
virtual void parallelFor(const Size from,
const Size to,
const Size granularity,
const Function<void(Size n1, Size n2)>& functor) override;
static SharedPtr<OmpScheduler> getGlobalInstance();
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/utility/EnumMap.h
|
#pragma once
/// \file EnumMap.h
/// \brief Helper object for converting enums to string, listing all available values of enum, etc.
/// \author <NAME> (sevecek at sirrah.<EMAIL>
/// \date 2016-2021
#include "objects/containers/FlatMap.h"
#include <typeindex>
NAMESPACE_SPH_BEGIN
struct EnumValue {
/// Text of the value
std::string value;
/// Description
std::string desc;
};
/// Maps a numerical value to a string value and description.
using EnumRecord = FlatMap<int, EnumValue>;
/// Unique identifier of an enum type.
///
/// Made optional to be default-constructible and usable in FlatMap.
using EnumIndex = Optional<std::type_index>;
template <typename TEnum>
struct EnumInputValue {
TEnum id;
std::string value;
std::string desc;
};
class EnumMap {
private:
struct CompareEnums {
INLINE bool operator()(const EnumIndex& key1, const EnumIndex& key2) const {
if (key1 && key2) {
return key1.value() < key2.value();
} else if (key2) {
return true;
} else {
return false;
}
}
};
FlatMap<EnumIndex, EnumRecord, CompareEnums> records;
public:
template <typename TEnum>
static EnumMap& addEnum(Array<EnumInputValue<TEnum>>&& input) {
EnumMap& instance = getInstance();
// convert enum values to ints to get rid of the type
FlatMap<int, EnumValue> map;
for (auto value : input) {
map.insert(int(value.id), EnumValue{ value.value, value.desc });
}
const EnumIndex index = std::type_index(typeid(TEnum));
instance.records.insert(index, std::move(map));
return instance;
}
template <typename TEnum>
static std::string toString(const TEnum value) {
return toString(int(value), std::type_index(typeid(TEnum)));
}
static std::string toString(const int value, const EnumIndex& index) {
EnumMap& instance = getInstance();
Optional<EnumRecord&> record = instance.records.tryGet(index);
SPH_ASSERT(record);
if (Optional<EnumValue&> e = record->tryGet(value)) {
// this is one of the enum values, return the text value
return e->value;
} else {
// the value is not directly in the enum, but can be composed of flags
std::string result;
for (int i = 1; i <= value; i *= 2) {
if ((value & i) == 0) {
continue;
}
Optional<EnumValue&> pair = record->tryGet(i);
SPH_ASSERT(pair, i, value);
if (!result.empty()) {
result += " | ";
}
result += pair->value;
}
if (result.empty()) {
// empty flags, represent by 0
result += '0';
}
return result;
}
}
template <typename TEnum>
static Optional<TEnum> fromString(const std::string& value) {
Optional<int> id = fromString(value, std::type_index(typeid(TEnum)));
return optionalCast<TEnum>(id);
}
static Optional<int> fromString(const std::string& value, const EnumIndex& index) {
EnumMap& instance = getInstance();
Optional<EnumRecord&> record = instance.records.tryGet(index);
SPH_ASSERT(record);
for (auto pair : record.value()) {
if (pair.value().value == value) { // erm ...
return pair.key();
}
}
return NOTHING;
}
template <typename TEnum>
static std::string getDesc() {
return getDesc(std::type_index(typeid(TEnum)));
}
static std::string getDesc(const EnumIndex& index) {
EnumMap& instance = getInstance();
Optional<EnumRecord&> record = instance.records.tryGet(index);
SPH_ASSERT(record);
std::string desc;
Size idx = 0;
for (auto pair : record.value()) {
if (idx > 0) {
desc += "\n";
}
desc += " - " + pair.value().value + ": " + pair.value().desc;
++idx;
}
return desc;
}
template <typename TEnum>
static Array<TEnum> getAll() {
EnumMap& instance = getInstance();
const EnumIndex index = std::type_index(typeid(TEnum));
Optional<EnumRecord&> record = instance.records.tryGet(index);
SPH_ASSERT(record);
Array<TEnum> enums;
for (auto pair : record.value()) {
enums.push(TEnum(pair.key()));
}
return enums;
}
static Array<int> getAll(const EnumIndex& index) {
EnumMap& instance = getInstance();
Optional<EnumRecord&> record = instance.records.tryGet(index);
SPH_ASSERT(record);
Array<int> enums;
for (auto pair : record.value()) {
enums.push(pair.key());
}
return enums;
}
private:
static EnumMap& getInstance() {
static EnumMap instance;
return instance;
}
};
/// \brief Helper class for adding individual enums to the enum map.
template <typename TEnum>
struct RegisterEnum {
public:
RegisterEnum(Array<EnumInputValue<TEnum>>&& input) {
EnumMap::addEnum(std::move(input));
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/run/jobs/InitialConditionJobs.h
|
<reponame>pavelsevecek/OpenSPH<gh_stars>10-100
#pragma once
#include "objects/containers/Grid.h"
#include "run/jobs/MaterialJobs.h"
#include "sph/initial/Galaxy.h"
NAMESPACE_SPH_BEGIN
/// \brief Creates a single monolithic body
class MonolithicBodyIc : public IParticleJob, public MaterialProvider {
protected:
struct {
bool shape = false;
bool material = false;
} slotUsage;
public:
MonolithicBodyIc(const std::string& name, const BodySettings& overrides = EMPTY_SETTINGS);
virtual std::string className() const override {
return "create monolithic body";
}
virtual UnorderedMap<std::string, ExtJobType>
requires() const override;
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "shape", JobType::GEOMETRY }, { "material", JobType::MATERIAL } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
protected:
virtual void addParticleCategory(VirtualSettings& settings);
};
/// \brief Creates a single differentiated body.
class DifferentiatedBodyIc : public IParticleJob {
private:
BodySettings mainBody;
int layerCnt = 1;
public:
explicit DifferentiatedBodyIc(const std::string& name);
virtual std::string className() const override {
return "create differentiated body";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
UnorderedMap<std::string, ExtJobType> slots = {
{ "base shape", JobType::GEOMETRY },
{ "base material", JobType::MATERIAL },
};
for (int i = 0; i < layerCnt; ++i) {
slots.insert("shape " + std::to_string(i + 1), JobType::GEOMETRY);
slots.insert("material " + std::to_string(i + 1), JobType::MATERIAL);
}
return slots;
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class SingleParticleIc : public IParticleJob {
private:
Vector r0 = Vector(0._f);
Vector v0 = Vector(0._f);
Float mass = Constants::M_earth;
Float radius = Constants::R_earth;
public:
explicit SingleParticleIc(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "create single particle";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class ImpactorIc : public MonolithicBodyIc {
public:
ImpactorIc(const std::string& name, const BodySettings& overrides = EMPTY_SETTINGS)
: MonolithicBodyIc(name, overrides) {}
virtual std::string className() const override {
return "create impactor";
}
virtual UnorderedMap<std::string, ExtJobType>
requires() const override {
UnorderedMap<std::string, ExtJobType> map = MonolithicBodyIc::requires();
map.insert("target", JobType::PARTICLES);
return map;
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "target", JobType::PARTICLES },
{ "shape", JobType::GEOMETRY },
{ "material", JobType::MATERIAL },
};
}
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
private:
virtual void addParticleCategory(VirtualSettings& settings) override;
};
class EquilibriumIc : public IParticleJob {
private:
EnumWrapper solver;
int boundaryThreshold;
public:
explicit EquilibriumIc(const std::string& name);
virtual std::string className() const override {
return "set equilibrium energy";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class KeplerianVelocityIc : public IParticleJob {
public:
explicit KeplerianVelocityIc(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "set Keplerian velocity";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "orbiting", JobType::PARTICLES },
{ "gravity source", JobType::PARTICLES },
};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class ModifyQuantityIc : public IParticleJob {
private:
EnumWrapper id;
EnumWrapper mode;
Float centralValue = 1.f;
Float radialGrad = 0.f;
ExtraEntry curve;
public:
ModifyQuantityIc(const std::string& name);
virtual std::string className() const override {
return "modify quantity";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class NoiseQuantityIc : public IParticleJob {
private:
EnumWrapper id;
Float mean = 1.f;
Float magnitude = 1.f;
public:
NoiseQuantityIc(const std::string& name);
virtual std::string className() const override {
return "Perlin noise";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
private:
template <Size Dims, typename TSetter>
void randomize(IRunCallbacks& callbacks, ArrayView<const Vector> r, const TSetter& setter) const;
Float perlin(const Grid<Vector>& gradients, const Vector& v) const;
Float dotGradient(const Grid<Vector>& gradients, const Indices& i, const Vector& v) const;
};
enum class NBodySettingsId {
PARTICLE_COUNT,
TOTAL_MASS,
RADIAL_PROFILE,
HEIGHT_SCALE,
POWER_LAW_INTERVAL,
POWER_LAW_EXPONENT,
MIN_SEPARATION,
VELOCITY_MULTIPLIER,
VELOCITY_DISPERSION,
};
using NBodySettings = Settings<NBodySettingsId>;
class NBodyIc : public IParticleJob {
private:
NBodySettings settings;
public:
NBodyIc(const std::string& name, const NBodySettings& overrides = EMPTY_SETTINGS);
virtual std::string className() const override {
return "N-body ICs";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "domain", JobType::GEOMETRY },
};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class PolytropeIc : public IParticleJob {
private:
int particleCnt = 10000;
EnumWrapper distId = EnumWrapper(DistributionEnum::PARAMETRIZED_SPIRALING);
Float radius = 1.e7_f;
Float rho_min = 10._f;
Float n = 1._f;
Float eta = 1.3_f;
public:
explicit PolytropeIc(const std::string& name);
virtual std::string className() const override {
return "polytrope ICs";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "material", JobType::MATERIAL } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class IsothermalSphereIc : public IParticleJob {
private:
Float radius = 1.e6_f;
Float centralDensity = 1000._f;
Float centralEnergy = 1000._f;
Float gamma = 4._f / 3._f;
int particleCnt = 10000;
public:
explicit IsothermalSphereIc(const std::string& name);
virtual std::string className() const override {
return "isothermal sphere ICs";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class GalaxyIc : public IParticleJob {
private:
GalaxySettings settings;
public:
explicit GalaxyIc(const std::string& name, const GalaxySettings& overrides = EMPTY_SETTINGS);
virtual std::string className() const override {
return "galaxy ICs";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/renderers/VolumeRenderer.h
|
#pragma once
#include "gui/objects/Color.h"
#include "gui/renderers/IRenderer.h"
#include "objects/finders/Bvh.h"
#include <atomic>
NAMESPACE_SPH_BEGIN
class VolumeRenderer : public IRaytracer {
private:
/// BVH for finding intersections of rays with particles
Bvh<BvhSphere> bvh;
struct {
/// Particle positions
Array<Vector> r;
/// Particle colors
Array<Rgba> colors;
/// Mass-based radii
Array<float> referenceRadii;
/// Distention factor of each particle
Array<float> distention;
} cached;
struct RayData {
/// Intersection for the current ray
Array<IntersectionInfo> intersections;
RayData() = default;
RayData(RayData&& other) = default;
RayData(const RayData& other)
: intersections(other.intersections.clone()) {
// needed to be used in Any, but never should be actually called
SPH_ASSERT(false);
}
};
public:
VolumeRenderer(SharedPtr<IScheduler> scheduler, const GuiSettings& settings);
~VolumeRenderer();
virtual void initialize(const Storage& storage,
const IColorizer& colorizer,
const ICamera& camera) override;
virtual bool isInitialized() const override;
virtual void setColorizer(const IColorizer& colorizer) override;
private:
virtual Rgba shade(const RenderParams& params,
const CameraRay& cameraRay,
ThreadData& data) const override;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/containers/FlatMap.h
|
<reponame>pavelsevecek/OpenSPH
#pragma once
/// \file FlatMap.h
/// \brief Key-value associative container implemented as a sorted array
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/containers/Array.h"
#include "objects/containers/Tags.h"
#include "objects/wrappers/Optional.h"
#include <algorithm>
NAMESPACE_SPH_BEGIN
/// \brief Container of key-value pairs.
///
/// Elements are stored in an array sorted according to key. The value look-up is O(log(N)), while inserting
/// or deletion of elements is currently O(N).
template <typename TKey, typename TValue, typename TLess = std::less<TKey>>
class FlatMap : TLess, Noncopyable {
public:
/// Element of the container.
class Element {
TKey k;
TValue v;
public:
Element() = default;
Element(const TKey& k, const TValue& v)
: k(k)
, v(v) {}
Element(const TKey& k, TValue&& v)
: k(k)
, v(std::move(v)) {}
INLINE const TKey& key() const {
return k;
}
INLINE const TValue& value() const {
return v;
}
INLINE TValue& value() {
return v;
}
};
private:
Array<Element> data;
public:
FlatMap() = default;
/// \brief Constructs the map from initializer list of elements.
///
/// Tag specifies an optimization hint; it can be ELEMENTS_COMMON, ELEMENTS_UNIQUE, or
/// ELEMENTS_SORTED_UNIQUE.
template <typename Tag>
FlatMap(Tag t, std::initializer_list<Element> list)
: data(list) {
this->create(t);
}
/// \brief Constructs the map from array of elements.
///
/// Tag specifies an optimization hint; it can be ELEMENTS_COMMON, ELEMENTS_UNIQUE, or
/// ELEMENTS_SORTED_UNIQUE.
template <typename Tag>
FlatMap(Tag t, Array<Element>&& values)
: data(std::move(values)) {
this->create(t);
}
/// \brief Returns a reference to the element, given its key.
///
/// The element must exists in the map, checked by assert.
INLINE TValue& operator[](const TKey& key) {
Element* element = this->find(key);
SPH_ASSERT(element);
return element->value();
}
/// \brief Returns a reference to the element, given its key.
///
/// The element must exists in the map, checked by assert.
INLINE const TValue& operator[](const TKey& key) const {
const Element* element = this->find(key);
SPH_ASSERT(element);
return element->value();
}
/// \brief Adds a new element into the map or sets new value of element with the same key.
INLINE TValue& insert(const TKey& key, const TValue& value) {
Element* element = this->find(key);
if (!element) {
return this->add(key, value);
} else {
element->value() = value;
return element->value();
}
}
/// \copydoc insert
INLINE TValue& insert(const TKey& key, TValue&& value) {
Element* element = this->find(key);
if (!element) {
return this->add(key, std::move(value));
} else {
element->value() = std::move(value);
return element->value();
}
}
/// \brief Removes element with given key from the map.
///
/// The element must exists in the map, checked by assert.
INLINE void remove(const TKey& key) {
Element* element = this->find(key);
SPH_ASSERT(element);
const Size index = element - &data[0];
data.remove(index);
}
/// \brief Removes element with given key if present, otherwise it does nothing.
///
/// \return True if the element was removed, false otherwise.
INLINE bool tryRemove(const TKey& key) {
Element* element = this->find(key);
if (!element) {
return false;
} else {
const Size index = element - &data[0];
data.remove(index);
return true;
}
}
/// \brief Removes all elements from the map.
INLINE void clear() {
data.clear();
}
/// \brief Returns a reference to the value matching the given key, or NOTHING if no such value exists.
///
/// Safe alternative to operator[].
INLINE Optional<TValue&> tryGet(const TKey& key) {
Element* element = this->find(key);
if (!element) {
return NOTHING;
} else {
return element->value();
}
}
/// \brief Returns a reference to the value matching the given key, or NOTHING if no such value exists.
INLINE Optional<const TValue&> tryGet(const TKey& key) const {
const Element* element = this->find(key);
if (!element) {
return NOTHING;
} else {
return element->value();
}
}
/// \brief Returns true if the map contains element of given key.
///
/// Equivalent to bool(tryGet(key)).
INLINE bool contains(const TKey& key) const {
return this->find(key) != nullptr;
}
/// Returns the number of elements in the map.
INLINE Size size() const {
return data.size();
}
/// Returns true if the map contains no elements, false otherwise.
INLINE Size empty() const {
return data.empty();
}
/// \brief Returns the iterator pointing to the first element.
INLINE Iterator<Element> begin() {
return data.begin();
}
/// \brief Returns the iterator pointing to the first element.
INLINE Iterator<const Element> begin() const {
return data.begin();
}
/// \brief Returns the iterator pointing to the one-past-last element.
INLINE Iterator<Element> end() {
return data.end();
}
/// \brief Returns the iterator pointing to the one-past-last element.
INLINE Iterator<const Element> end() const {
return data.end();
}
INLINE operator ArrayView<Element>() {
return data;
}
INLINE operator ArrayView<const Element>() const {
return data;
}
FlatMap clone() const {
FlatMap cloned;
cloned.data = data.clone();
return cloned;
}
private:
void create(ElementsCommonTag) {
std::sort(data.begin(), data.end(), [this](const Element& e1, const Element& e2) {
return less(e1.key(), e2.key());
});
auto end = std::unique(data.begin(), data.end(), [this](const Element& e1, const Element& e2) {
return equal(e1.key(), e2.key());
});
data.resize(end - data.begin());
SPH_ASSERT(this->keysSortedAndUnique());
}
void create(ElementsUniqueTag) {
std::sort(data.begin(), data.end(), [this](const Element& e1, const Element& e2) {
return less(e1.key(), e2.key());
});
SPH_ASSERT(this->keysSortedAndUnique());
}
void create(ElementsSortedUniqueTag) {
SPH_ASSERT(this->keysSortedAndUnique());
}
bool keysSortedAndUnique() const {
if (!std::is_sorted(data.begin(), data.end(), [this](const Element& e1, const Element& e2) {
return less(e1.key(), e2.key());
})) {
return false;
}
for (Size i = 1; i < data.size(); ++i) {
if (equal(data[i].key(), data[i - 1].key())) {
return false;
}
}
return true;
}
INLINE bool less(const TKey& key1, const TKey& key2) const {
return TLess::operator()(key1, key2);
}
INLINE bool equal(const TKey& key1, const TKey& key2) const {
return !less(key1, key2) && !less(key2, key1);
}
/// Returns a pointer to the element with given key or nullptr if no such element exists.
INLINE Element* find(const TKey& key) {
auto compare = [this](const Element& element, const TKey& key) { return less(element.key(), key); };
auto iter = std::lower_bound(data.begin(), data.end(), key, compare);
if (iter != data.end() && equal(iter->key(), key)) {
return &*iter;
} else {
return nullptr;
}
}
INLINE const Element* find(const TKey& key) const {
return const_cast<FlatMap*>(this)->find(key);
}
/// Adds new element into the map, assuming no element with the same key exists.
template <typename T>
INLINE TValue& add(const TKey& key, T&& value) {
Size from = 0;
Size to = data.size();
Size mid = Size(-1);
while (from < to && from != mid) {
mid = (from + to) / 2;
SPH_ASSERT(!equal(data[mid].key(), key));
if (less(data[mid].key(), key)) {
from = mid + 1;
} else {
to = mid;
}
}
data.insert(from, Element{ key, std::forward<T>(value) });
return data[from].value();
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/objects/RenderContext.h
|
<gh_stars>10-100
#pragma once
#include "gui/Utils.h"
#include "gui/objects/Bitmap.h"
#include "gui/objects/Color.h"
#include "gui/renderers/IRenderer.h"
#include "sph/kernel/Kernel.h"
#include <wx/dc.h>
NAMESPACE_SPH_BEGIN
enum class ColorFlag {
LINE = 1 << 0,
FILL = 1 << 1,
TEXT = 1 << 2,
};
/// \brief Abstraction of a device used for rendering.
///
/// The interface is currently quite minimalistic, can be extended if needed.
class IRenderContext : public Polymorphic {
public:
/// \brief Returns the size of the canvas associated with the context.
virtual Pixel size() const = 0;
/// \brief Selects the color for one or more drawing modes.
virtual void setColor(const Rgba& color, const Flags<ColorFlag> flags) = 0;
/// \brief Modifies the thickness of the lines.
virtual void setThickness(const float thickness) = 0;
virtual void setFontSize(const int fontSize) = 0;
/// \brief Fills the whole canvas with given color.
///
/// This erases any previous content.
virtual void fill(const Rgba& color) = 0;
/// \brief Draws a line connecting two points.
virtual void drawLine(const Coords p1, const Coords p2) = 0;
/// \brief Draws a circle, given its center and a radius.
virtual void drawCircle(const Coords center, const float radius) = 0;
/// \brief Draws a triangle given three points.
virtual void drawTriangle(const Coords p1, const Coords p2, const Coords p3) = 0;
/// \brief Draws a bitmap, given the position of its left-top corner.
virtual void drawBitmap(const Coords p, const Bitmap<Rgba>& bitmap) = 0;
virtual void drawText(const Coords p, const Flags<TextAlign> align, const std::string& s) = 0;
virtual void drawText(const Coords p, const Flags<TextAlign> align, const std::wstring& s) = 0;
virtual Array<IRenderOutput::Label> getLabels() const {
return {};
}
};
struct OverridePixelOp {
INLINE Rgba operator()(const Rgba&, const Rgba& color) const {
return color;
}
};
struct OverPixelOp {
INLINE Rgba operator()(const Rgba& prev, const Rgba& color) const {
return color.over(prev);
}
};
template <typename PixelOp>
class PreviewRenderContext : public IRenderContext {
protected:
PixelOp pixelOp;
Bitmap<Rgba>& bitmap;
Array<IRenderOutput::Label> labels;
struct {
Rgba line = Rgba::black();
Rgba fill = Rgba::black();
Rgba text = Rgba::white();
} colors;
float thickness = 1._f;
int fontSize = 9;
public:
explicit PreviewRenderContext(Bitmap<Rgba>& bitmap)
: bitmap(bitmap) {}
virtual Pixel size() const override {
return bitmap.size();
}
virtual void setColor(const Rgba& color, const Flags<ColorFlag> flags) override;
virtual void setThickness(const float newThickness) override;
virtual void setFontSize(const int newFontSize) override;
virtual void fill(const Rgba& color) override;
virtual void drawLine(const Coords p1, const Coords p2) override;
virtual void drawCircle(const Coords center, const float radius) override;
virtual void drawTriangle(const Coords p1, const Coords p2, const Coords p3) override;
virtual void drawBitmap(const Coords p, const Bitmap<Rgba>& subBitmap) override;
virtual void drawText(const Coords p, const Flags<TextAlign> align, const std::string& s) override;
virtual void drawText(const Coords p, const Flags<TextAlign> align, const std::wstring& s) override;
virtual Array<IRenderOutput::Label> getLabels() const override {
return labels.clone();
}
private:
void drawSafe(const Pixel p, const Rgba c) {
if (p.x >= 0 && p.y >= 0 && p.x < bitmap.size().x && p.y < bitmap.size().y) {
bitmap[p] = pixelOp(bitmap[p], c);
}
}
void drawSafe(const Coords p, const Rgba c) {
this->drawSafe(Pixel(p), c);
}
void draw(const Pixel p, const Rgba c) {
bitmap[p] = pixelOp(bitmap[p], c);
}
void draw(const Coords p, const Rgba c) {
this->draw(Pixel(p), c);
}
};
/// \todo do not derive from PreviewRenderContext, rather some RenderContextBase; AA context is NOT a preview
/// render context!
class AntiAliasedRenderContext : public PreviewRenderContext<OverPixelOp> {
public:
AntiAliasedRenderContext(Bitmap<Rgba>& bitmap)
: PreviewRenderContext(bitmap) {}
virtual void drawCircle(const Coords center, const float radius) override;
protected:
void drawSafe(const Pixel p, const Rgba c) {
if (p.x >= 0 && p.y >= 0 && p.x < bitmap.size().x && p.y < bitmap.size().y) {
bitmap[Pixel(p)] = c.over(bitmap[Pixel(p)]);
}
}
};
class SmoothedRenderContext : public AntiAliasedRenderContext {
private:
LutKernel<2> kernel;
public:
SmoothedRenderContext(Bitmap<Rgba>& bitmap, const LutKernel<2>& kernel)
: AntiAliasedRenderContext(bitmap)
, kernel(kernel) {}
virtual void drawCircle(const Coords center, const float radius) override;
};
/// \brief Render context drawing directly into wxDC.
///
/// Must be used only in main thread!!
class WxRenderContext : public IRenderContext {
private:
wxDC& dc;
wxPen pen;
wxBrush brush;
public:
WxRenderContext(wxDC& dc)
: dc(dc) {
pen = dc.GetPen();
brush = dc.GetBrush();
}
virtual Pixel size() const override {
const wxSize s = dc.GetSize();
return Pixel(s.x, s.y);
}
virtual void setColor(const Rgba& color, const Flags<ColorFlag> flags) override {
if (flags.has(ColorFlag::LINE)) {
pen.SetColour(wxColour(color));
dc.SetPen(pen);
}
if (flags.has(ColorFlag::FILL)) {
brush.SetColour(wxColour(color));
dc.SetBrush(brush);
}
if (flags.has(ColorFlag::TEXT)) {
dc.SetTextForeground(wxColour(color));
}
}
virtual void setThickness(const float UNUSED(newThickness)) override { /// \todo
}
virtual void setFontSize(const int newFontSize) override {
wxFont font = dc.GetFont();
font.SetPointSize(newFontSize);
dc.SetFont(font);
}
virtual void fill(const Rgba& color) override {
brush.SetColour(wxColour(color));
dc.SetBrush(brush);
dc.DrawRectangle(wxPoint(0, 0), dc.GetSize());
}
virtual void drawLine(const Coords p1, const Coords p2) override {
dc.DrawLine(wxPoint(p1), wxPoint(p2));
}
virtual void drawCircle(const Coords center, const float radius) override {
dc.DrawCircle(wxPoint(center), int(radius));
}
virtual void drawTriangle(const Coords, const Coords, const Coords) override {
NOT_IMPLEMENTED;
}
virtual void drawBitmap(const Coords, const Bitmap<Rgba>&) override {
NOT_IMPLEMENTED;
}
virtual void drawText(const Coords p, const Flags<TextAlign> align, const std::string& s) override {
std::wstring ws(s.begin(), s.end());
this->drawText(p, align, ws);
}
virtual void drawText(const Coords p, const Flags<TextAlign> align, const std::wstring& s) override {
IRenderOutput::Label label;
label.text = s;
label.align = align;
label.fontSize = dc.GetFont().GetPointSize();
label.color = Rgba(dc.GetTextForeground());
label.position = Pixel(p);
printLabels(dc, Array<IRenderOutput::Label>{ label });
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/common/Assert.h
|
<filename>core/common/Assert.h
#pragma once
/// \file Assert.h
/// \brief Custom assertions
/// \author <NAME> (sevecek at sirrah.<EMAIL>)
/// \date 2016-2021
#include "common/Globals.h"
#include <exception>
#include <sstream>
NAMESPACE_SPH_BEGIN
struct Assert {
static bool isTest;
/// \brief If true, assert throws an exception.
static bool throwAssertException;
typedef bool (*Handler)(const std::string& message);
/// \brief Custom assert handler.
///
/// Assert message is passed as an argument. If it returns false, the assert is ignored and the program
/// continues. Note that assert can be fired from any thread, so it has to be thread-safe.
static Handler handler;
class Exception : public std::exception {
private:
const std::string message;
public:
Exception(const std::string& message)
: message(message) {}
virtual const char* what() const noexcept override {
return message.c_str();
}
};
struct ScopedAssertExceptionEnabler {
const bool originalValue;
ScopedAssertExceptionEnabler()
: originalValue(throwAssertException) {
throwAssertException = true;
}
~ScopedAssertExceptionEnabler() {
throwAssertException = originalValue;
}
};
template <typename T0, typename... TArgs>
static void stringify(std::stringstream& ss, T0&& t0, TArgs&&... rest) {
ss << t0;
if (sizeof...(TArgs) > 0) {
ss << " ,";
}
stringify(ss, std::forward<TArgs>(rest)...);
}
static void stringify(std::stringstream& UNUSED(ss)) {}
template <typename... TArgs>
static void fire(const char* message,
const char* file,
const char* func,
const int line,
TArgs&&... args) {
std::stringstream ss;
stringify(ss, std::forward<TArgs>(args)...);
fireParams(message, file, func, line, ss.str().c_str());
}
static void fireParams(const char* message,
const char* file,
const char* func,
const int line,
const char* params = "");
static void todo(const char* message, const char* func, const int line);
};
#define TODO(x) Assert::todo(x, __FUNCTION__, __LINE__);
#ifdef SPH_DEBUG
#define SPH_ASSERT(x, ...) \
if (!bool(x)) { \
Assert::fire(#x, __FILE__, __FUNCTION__, __LINE__, ##__VA_ARGS__); \
}
#define CONSTEXPR_SPH_ASSERT(x) assert(x)
#define SPH_ASSERT_UNEVAL(x, ...) SPH_ASSERT(x, ##__VA_ARGS__)
#else
#define SPH_ASSERT(x, ...) MARK_USED(x)
#define CONSTEXPR_SPH_ASSERT(x) MARK_USED(x)
#define SPH_ASSERT_UNEVAL(x, ...)
#endif
/// Helper macro marking missing implementation
#define NOT_IMPLEMENTED \
SPH_ASSERT(false, "not implemented"); \
throw Assert::Exception(std::string("Functionality not implemented in function ") + __PRETTY_FUNCTION__);
/// Helper macro marking code that should never be executed (default branch of switch where there is finite
/// number of options, for example)
#define STOP \
SPH_ASSERT(false, "stop"); \
throw std::exception();
/// Helper cast, performing a static_cast, but checking that the cast is valid using dynamic_cast in assert
/// and debug builds.
template <typename TDerived, typename TBase>
INLINE TDerived* assertCast(TBase* value) {
SPH_ASSERT(!value || dynamic_cast<TDerived*>(value) != nullptr, value);
return static_cast<TDerived*>(value);
}
#define SPH_STR(x) SPH_XSTR(x)
#define SPH_XSTR(x) #x
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/io/Table.h
|
<gh_stars>10-100
#pragma once
/// \file Table.h
/// \brief Helper container allowing to store strings in cells and print them into table
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/containers/Array.h"
NAMESPACE_SPH_BEGIN
class Table {
private:
using Row = Array<std::string>;
Array<Row> rows;
struct {
Size colSep;
Size minColWidth;
} params;
public:
/// \brief Creates an empty table
///
/// \param colSep Minimal number of characters between columns.
/// \param minColWidth Minimal width of a column; the column gets strethed if needed.
Table(const Size colSep = 1, const Size minColWidth = 5)
: params{ colSep, minColWidth } {}
/// \brief Sets the text in given cell.
///
/// If the cell already exists, the previous text is replaced, otherwise a new cell is created, extending
/// the number of cells and rows if needed.
void setCell(const Size colIdx, const Size rowIdx, std::string text) {
// extend rows
for (Size i = rows.size(); i <= rowIdx; ++i) {
rows.emplaceBack(this->columnCnt());
}
// extend columns
if (colIdx >= this->columnCnt()) {
for (Row& row : rows) {
row.resize(colIdx + 1);
}
}
rows[rowIdx][colIdx] = std::move(text);
}
Size rowCnt() const {
return rows.size();
}
Size columnCnt() const {
return rows.empty() ? 0 : rows[0].size();
}
/// \brief Creates the text representation of the table.
std::string toString() const {
if (rows.empty()) {
return std::string();
}
Array<Size> colWidths(this->columnCnt());
colWidths.fill(0);
for (const Row& row : rows) {
for (Size colIdx = 0; colIdx < row.size(); ++colIdx) {
colWidths[colIdx] = max(colWidths[colIdx], Size(row[colIdx].size()));
}
}
for (Size colIdx = 0; colIdx < rows[0].size(); ++colIdx) {
colWidths[colIdx] = max(colWidths[colIdx] + params.colSep, params.minColWidth);
}
std::stringstream ss;
for (const Row& row : rows) {
for (Size colIdx = 0; colIdx < row.size(); ++colIdx) {
ss << std::setw(colWidths[colIdx]) << row[colIdx];
}
ss << std::endl;
}
return ss.str();
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/objects/Colorizer.h
|
#pragma once
/// \file Colorizer.h
/// \brief Object converting quantity values of particles into colors.
/// \author <NAME> (sevecek at <EMAIL>)
/// \date 2016-2021
#include "gravity/AggregateSolver.h"
#include "gui/Settings.h"
#include "gui/objects/Palette.h"
#include "gui/objects/Point.h"
#include "gui/objects/Texture.h"
#include "gui/renderers/Spectrum.h"
#include "objects/containers/ArrayRef.h"
#include "objects/finders/NeighborFinder.h"
#include "objects/utility/Dynamic.h"
#include "post/Analysis.h"
#include "quantities/IMaterial.h"
#include "quantities/Particle.h"
#include "sph/kernel/Kernel.h"
#include "system/Factory.h"
#include "thread/Scheduler.h"
NAMESPACE_SPH_BEGIN
class Particle;
/// \brief Interface for objects assigning colors to particles.
///
/// Used to add a layer of abstraction between quantity values and displayed colors, allowing to visualize
/// various information that isn't directly stored as quantity, like relative values of quantitiees, angular
/// dependence of velocities, etc. Usually though, one wants to display raw quantity values, which can be
/// accomplished by \ref TypedColorizer.
class IColorizer : public Polymorphic {
public:
/// \brief Checks if the storage constains all data necessary to initialize the colorizer.
virtual bool hasData(const Storage& storage) const = 0;
/// \brief Initialize the colorizer before by getting necessary quantities from storage.
///
/// Can only be called if \ref hasData returns true. Must be called before \ref evalColor is called, every
/// time step as ArrayViews taken from storage might be invalidated.
/// \param storage Particle storage containing source data to be drawn.
/// \param ref Specifies how the object refereneces the data required for evaluation; either the buffers
/// are copied and stored in the colorizer, or only references to the the storage are kept.
virtual void initialize(const Storage& storage, const RefEnum ref) = 0;
/// \brief Checks if the colorizer has been initialized.
virtual bool isInitialized() const = 0;
/// \brief Returns the color of idx-th particle.
virtual Rgba evalColor(const Size idx) const = 0;
/// \brief Returns the scalar representation of the colorized quantity for idx-th particle.
///
/// If there is no reasonable scalar representation (boundary particles, for example), returns NOTHING
virtual Optional<float> evalScalar(const Size UNUSED(idx)) const {
return NOTHING;
}
/// \brief Returns the vector representation of the colorized quantity for idx-th particle.
///
/// If there is no reasonable vector representation (which is true for any non-vector quantity) or the
/// function is not defined, return NOTHING.
virtual Optional<Vector> evalVector(const Size UNUSED(idx)) const {
return NOTHING;
}
/// \brief Returns the original value of the displayed quantity.
///
/// If no such value exists, returns NOTHING.
virtual Optional<Particle> getParticle(const Size idx) const = 0;
/// \brief Returns recommended palette for drawing this colorizer.
///
/// In case there is no palette, returns NOTHING.
virtual Optional<Palette> getPalette() const = 0;
/// \brief Modifies the palette used by ths colorizer.
virtual void setPalette(const Palette& newPalette) = 0;
/// \brief Returns the name of the colorizer.
///
/// This is used when showing the colorizer in the window and as filename suffix.
virtual std::string name() const = 0;
};
/// \todo
/// Types
/// Scalar -> scalar
/// Vector -> size, x, y, z
/// Tensor -> trace, 2nd inv, xx, yy, zz, xy, xz, yz, largest eigen, smallest eigen
namespace Detail {
/// Helper function returning a scalar representation of given quantity.
///
/// This value is later converted to color, using provided palette.
template <typename Type>
INLINE float getColorizerValue(const Type& value) {
SPH_ASSERT(isReal(value));
return float(value);
}
template <>
INLINE float getColorizerValue(const Vector& value) {
const Float result = getLength(value);
SPH_ASSERT(isReal(result), value);
return float(result);
}
template <>
INLINE float getColorizerValue(const TracelessTensor& value) {
return float(sqrt(ddot(value, value)));
}
template <>
INLINE float getColorizerValue(const SymmetricTensor& value) {
return float(sqrt(ddot(value, value)));
}
/// Helper function returning vector representation of given quantity.
///
/// Only meaningful result is returned for vector quantity, other quantities simply return zero vector.
/// The function is useful to avoid specializing colorizers for different types.
template <typename Type>
INLINE Optional<Vector> getColorizerVector(const Type& UNUSED(value)) {
return NOTHING;
}
template <>
INLINE Optional<Vector> getColorizerVector(const Vector& value) {
return value;
}
} // namespace Detail
/// \brief Special colorizers that do not directly correspond to quantities.
///
/// Must have strictly negative values. Function taking \ref ColorizerId as an argument also acceps \ref
/// QuantityId casted to \ref ColorizerId, interpreting as \ref TypedColorizer with given quantity ID.
enum class ColorizerId {
VELOCITY = -1, ///< Particle velocities
ACCELERATION = -2, ///< Acceleration of particles
MOVEMENT_DIRECTION = -3, ///< Projected direction of motion
COROTATING_VELOCITY = -4, ///< Velocities with a respect to the rotating body
DISPLACEMENT = -5, ///< Difference between current positions and initial position
DENSITY_PERTURBATION = -6, ///< Relative difference of density and initial density (rho/rho0 - 1)
SUMMED_DENSITY = -7, ///< Density computed from particle masses by direct summation of neighbors
TOTAL_STRESS = -8, ///< Total stress (sigma = S - pI)
TOTAL_ENERGY = -9, ///< Sum of kinetic and internal energy for given particle
TEMPERATURE = -10, ///< Temperature, computed from internal energy
YIELD_REDUCTION = -11, ///< Reduction of stress tensor due to yielding (1 - f_vonMises)
DAMAGE_ACTIVATION = -12, ///< Ratio of the stress and the activation strain
RADIUS = -13, ///< Radii/smoothing lenghts of particles
UVW = -15, ///< Shows UV mapping, u-coordinate in red and v-coordinate in blur
BOUNDARY = -16, ///< Shows boundary particles
PARTICLE_ID = -17, ///< Each particle drawn with different color
COMPONENT_ID = -18, ///< Color assigned to each component (group of connected particles)
BOUND_COMPONENT_ID = -19, ///< Color assigned to each group of gravitationally bound particles
AGGREGATE_ID = -20, ///< Color assigned to each aggregate
FLAG = -21, ///< Particles of different bodies are colored differently
MATERIAL_ID = -22, ///< Particles with different materials are colored differently
BEAUTY = -23, ///< Attempts to show the real-world look
};
using ExtColorizerId = ExtendedEnum<ColorizerId>;
SPH_EXTEND_ENUM(QuantityId, ColorizerId);
/// \brief Default colorizer simply converting quantity value to color using defined palette.
///
/// Vector and tensor quantities are converted to floats using suitable norm.
template <typename Type>
class TypedColorizer : public IColorizer {
protected:
QuantityId id;
Palette palette;
ArrayRef<const Type> values;
public:
TypedColorizer(const QuantityId id, Palette palette)
: id(id)
, palette(std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return storage.has(id);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
values = makeArrayRef(storage.getValue<Type>(id), ref);
}
virtual bool isInitialized() const override {
return !values.empty();
}
virtual Rgba evalColor(const Size idx) const override {
return palette(this->evalScalar(idx).value());
}
virtual Optional<float> evalScalar(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return Detail::getColorizerValue(values[idx]);
}
virtual Optional<Vector> evalVector(const Size idx) const override {
return Detail::getColorizerVector(values[idx]);
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(id, values[idx], idx);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return getMetadata(id).quantityName;
}
};
inline bool hasVelocity(const Storage& storage) {
return storage.has<Vector>(QuantityId::POSITION, OrderEnum::FIRST) ||
storage.has<Vector>(QuantityId::POSITION, OrderEnum::SECOND);
}
/// \brief Displays the magnitudes of particle velocities.
class VelocityColorizer : public TypedColorizer<Vector> {
public:
explicit VelocityColorizer(Palette palette)
: TypedColorizer<Vector>(QuantityId::POSITION, std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return hasVelocity(storage);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
values = makeArrayRef(storage.getDt<Vector>(QuantityId::POSITION), ref);
}
virtual Optional<Vector> evalVector(const Size idx) const override {
return values[idx];
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(idx).addDt(QuantityId::POSITION, values[idx]);
}
virtual std::string name() const override {
return "Velocity";
}
};
/// \brief Displays the magnitudes of accelerations.
class AccelerationColorizer : public TypedColorizer<Vector> {
public:
explicit AccelerationColorizer(Palette palette)
: TypedColorizer<Vector>(QuantityId::POSITION, std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return storage.has<Vector>(QuantityId::POSITION, OrderEnum::SECOND);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
values = makeArrayRef(storage.getD2t<Vector>(QuantityId::POSITION), ref);
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(idx).addD2t(QuantityId::POSITION, values[idx]);
}
virtual std::string name() const override {
return "Acceleration";
}
};
/// \brief Shows direction of particle movement in color.
class DirectionColorizer : public IColorizer {
private:
Palette palette;
Vector axis;
Vector dir1, dir2;
ArrayRef<const Vector> values;
public:
DirectionColorizer(const Vector& axis, const Palette& palette);
virtual bool hasData(const Storage& storage) const override {
return hasVelocity(storage);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
values = makeArrayRef(storage.getDt<Vector>(QuantityId::POSITION), ref);
}
virtual bool isInitialized() const override {
return !values.empty();
}
virtual Optional<float> evalScalar(const Size idx) const override;
virtual Rgba evalColor(const Size idx) const override {
return palette(this->evalScalar(idx).value());
}
virtual Optional<Particle> getParticle(const Size idx) const override {
// return velocity of the particle
return Particle(idx).addDt(QuantityId::POSITION, values[idx]);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Direction";
}
};
/// \brief Shows particle velocities with subtracted corotating component
class CorotatingVelocityColorizer : public IColorizer {
private:
Palette palette;
ArrayRef<const Vector> r;
ArrayRef<const Vector> v;
ArrayRef<const Size> matIds;
struct BodyMetadata {
Vector center;
Vector omega;
};
Array<BodyMetadata> data;
public:
explicit CorotatingVelocityColorizer(Palette palette)
: palette(std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return hasVelocity(storage) && storage.has(QuantityId::MATERIAL_ID);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual bool isInitialized() const override {
return !v.empty();
}
virtual Rgba evalColor(const Size idx) const override {
SPH_ASSERT(!v.empty() && !r.empty());
return palette(float(getLength(this->getCorotatingVelocity(idx))));
}
virtual Optional<Vector> evalVector(const Size idx) const override {
return this->getCorotatingVelocity(idx);
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(idx).addDt(QuantityId::POSITION, this->getCorotatingVelocity(idx));
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Corot. velocity";
}
private:
Vector getCorotatingVelocity(const Size idx) const {
const BodyMetadata& body = data[matIds[idx]];
return v[idx] - cross(body.omega, r[idx] - body.center);
}
};
class DensityPerturbationColorizer : public IColorizer {
private:
Palette palette;
ArrayRef<const Float> rho;
Array<Float> rho0;
public:
explicit DensityPerturbationColorizer(Palette palette)
: palette(std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return storage.has(QuantityId::DENSITY);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
rho = makeArrayRef(storage.getValue<Float>(QuantityId::DENSITY), ref);
rho0.resize(rho.size());
for (Size i = 0; i < rho.size(); ++i) {
rho0[i] = storage.getMaterialOfParticle(i)->getParam<Float>(BodySettingsId::DENSITY);
}
}
virtual bool isInitialized() const override {
return !rho.empty();
}
virtual Rgba evalColor(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return palette(float(rho[idx] / rho0[idx] - 1._f));
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(QuantityId::DENSITY, rho[idx] / rho0[idx] - 1.f, idx);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Delta Density";
}
};
class SummedDensityColorizer : public IColorizer {
private:
Palette palette;
ArrayRef<const Float> m;
ArrayRef<const Vector> r;
AutoPtr<IBasicFinder> finder;
LutKernel<3> kernel;
public:
SummedDensityColorizer(const RunSettings& settings, Palette palette);
virtual bool hasData(const Storage& UNUSED(storage)) const override {
// mass and positions must always be present
return true;
}
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual bool isInitialized() const override {
return !m.empty();
}
virtual Optional<float> evalScalar(const Size idx) const override {
return sum(idx);
}
virtual Rgba evalColor(const Size idx) const override {
return palette(sum(idx));
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(QuantityId::DENSITY, Float(sum(idx)), idx);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Summed Density";
}
private:
float sum(const Size idx) const;
};
class StressColorizer : public IColorizer {
Palette palette;
ArrayRef<const Float> p;
ArrayRef<const TracelessTensor> s;
public:
explicit StressColorizer(Palette palette)
: palette(std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return storage.has(QuantityId::DEVIATORIC_STRESS) && storage.has(QuantityId::PRESSURE);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
s = makeArrayRef(storage.getValue<TracelessTensor>(QuantityId::DEVIATORIC_STRESS), ref);
p = makeArrayRef(storage.getValue<Float>(QuantityId::PRESSURE), ref);
}
virtual bool isInitialized() const override {
return !s.empty() && !p.empty();
}
virtual Rgba evalColor(const Size idx) const override {
return palette(this->evalScalar(idx).value());
}
virtual Optional<float> evalScalar(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
SymmetricTensor sigma = SymmetricTensor(s[idx]) - p[idx] * SymmetricTensor::identity();
// StaticArray<Float, 3> eigens = findEigenvalues(sigma);
// return max(abs(eigens[0]), abs(eigens[1]), abs(eigens[2]));
return float(sqrt(ddot(sigma, sigma)));
}
virtual Optional<Vector> evalVector(const Size UNUSED(idx)) const override {
return NOTHING;
}
virtual Optional<Particle> getParticle(const Size idx) const override {
SymmetricTensor sigma = SymmetricTensor(s[idx]) - p[idx] * SymmetricTensor::identity();
return Particle(QuantityId::DEVIATORIC_STRESS, sigma, idx);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Total stress";
}
};
class EnergyColorizer : public IColorizer {
Palette palette;
ArrayRef<const Float> u;
ArrayRef<const Vector> v;
public:
explicit EnergyColorizer(Palette palette)
: palette(std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override {
return hasVelocity(storage) && storage.has(QuantityId::ENERGY);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
u = makeArrayRef(storage.getValue<Float>(QuantityId::ENERGY), ref);
v = makeArrayRef(storage.getDt<Vector>(QuantityId::POSITION), ref);
}
virtual bool isInitialized() const override {
return !u.empty();
}
virtual Rgba evalColor(const Size idx) const override {
return palette(this->evalScalar(idx).value());
}
virtual Optional<float> evalScalar(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return float(u[idx] + 0.5_f * getSqrLength(v[idx]));
}
virtual Optional<Vector> evalVector(const Size UNUSED(idx)) const override {
return NOTHING;
}
virtual Optional<Particle> getParticle(const Size idx) const override {
const Float value = evalScalar(idx).value();
return Particle(QuantityId::ENERGY, value, idx);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Total energy";
}
};
class TemperatureColorizer : public TypedColorizer<Float> {
Float cp;
public:
explicit TemperatureColorizer()
: TypedColorizer<Float>(QuantityId::ENERGY, getEmissionPalette(Interval(500, 10000))) {}
virtual bool hasData(const Storage& storage) const override {
return storage.has(QuantityId::ENERGY) && storage.getMaterialCnt() > 0;
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
TypedColorizer<Float>::initialize(storage, ref);
cp = storage.getMaterial(0)->getParam<Float>(BodySettingsId::HEAT_CAPACITY);
}
virtual Optional<float> evalScalar(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return float(this->values[idx] / cp);
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(QuantityId::TEMPERATURE, values[idx] / cp, idx);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Temperature";
}
};
class YieldReductionColorizer : public TypedColorizer<Float> {
public:
explicit YieldReductionColorizer(Palette palette)
: TypedColorizer<Float>(QuantityId::STRESS_REDUCING, std::move(palette)) {}
virtual Rgba evalColor(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
SPH_ASSERT(values[idx] >= 0._f && values[idx] <= 1._f);
return palette(float(1._f - values[idx]));
}
virtual std::string name() const override {
return "Yield reduction";
}
};
class DamageActivationColorizer : public IColorizer {
private:
Palette palette;
Array<float> ratio;
public:
explicit DamageActivationColorizer(const Palette& palette)
: palette(std::move(palette)) {}
virtual bool hasData(const Storage& storage) const override;
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual bool isInitialized() const override {
return !ratio.empty();
}
virtual Rgba evalColor(const Size idx) const override {
return palette(ratio[idx]);
}
virtual Optional<Particle> getParticle(const Size UNUSED(idx)) const override {
return NOTHING;
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Damage activation ratio";
}
};
class BeautyColorizer : public IColorizer {
private:
ArrayRef<const Float> u;
Palette palette;
const float u_0 = 3.e4f;
const float u_red = 3.e5f;
const float u_glow = 0.5f * u_red;
const float u_yellow = 5.e6f;
float f_glow;
public:
BeautyColorizer();
virtual bool hasData(const Storage& storage) const override {
return storage.has(QuantityId::ENERGY);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
u = makeArrayRef(storage.getValue<Float>(QuantityId::ENERGY), ref);
}
virtual bool isInitialized() const override {
return !u.empty();
}
virtual Rgba evalColor(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return palette(float(u[idx]));
}
virtual Optional<float> evalScalar(const Size idx) const override {
const float f = palette.paletteToRelative(u[idx]);
return max(0.f, (f - f_glow) / (1.f - f_glow));
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(idx).addValue(QuantityId::ENERGY, u[idx]);
}
virtual Optional<Palette> getPalette() const override {
return palette;
}
virtual void setPalette(const Palette& newPalette) override {
palette = newPalette;
}
virtual std::string name() const override {
return "Beauty";
}
};
class RadiusColorizer : public TypedColorizer<Vector> {
public:
explicit RadiusColorizer(Palette palette)
: TypedColorizer<Vector>(QuantityId::SMOOTHING_LENGTH, std::move(palette)) {}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
values = makeArrayRef(storage.getValue<Vector>(QuantityId::POSITION), ref);
}
virtual Rgba evalColor(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return palette(float(values[idx][H]));
}
virtual Optional<Particle> getParticle(const Size idx) const override {
return Particle(idx).addValue(QuantityId::SMOOTHING_LENGTH, values[idx][H]);
}
virtual bool hasData(const Storage& UNUSED(storage)) const override {
// radii are always present
return true;
}
virtual std::string name() const override {
return "Radius";
}
};
class UvwColorizer : public IColorizer {
private:
ArrayRef<const Vector> uvws;
public:
virtual bool hasData(const Storage& storage) const override {
return storage.has(QuantityId::UVW);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
uvws = makeArrayRef(storage.getValue<Vector>(QuantityId::UVW), ref);
}
virtual bool isInitialized() const override {
return !uvws.empty();
}
virtual Rgba evalColor(const Size idx) const override {
SPH_ASSERT(this->isInitialized());
return Rgba(float(uvws[idx][X]), 0.f, float(uvws[idx][Y]));
}
virtual Optional<Particle> getParticle(const Size UNUSED(idx)) const override {
return NOTHING;
}
virtual Optional<Palette> getPalette() const override {
return NOTHING;
}
virtual void setPalette(const Palette& UNUSED(newPalette)) override {}
virtual std::string name() const override {
return "Uvws";
}
};
/// Shows boundary of bodies in the simulation.
class BoundaryColorizer : public IColorizer {
public:
enum class Detection {
/// Particles with fewer neighbors are considered boundary. Not suitable if number of neighbors is
/// enforced by adapting smoothing length. Note that increasing the threshold adds more particles into
/// the boundary.
NEIGBOUR_THRESHOLD,
/// Boundary is determined by relative position vectors approximating surface normal. Has higher
/// overhead, but does not depend sensitively on number of neighbors. Here, increasing the threshold
/// leads to fewer boundary particles.
NORMAL_BASED,
};
private:
Detection detection;
struct {
ArrayRef<const Vector> values;
Float threshold;
} normals;
struct {
ArrayRef<const Size> values;
Size threshold;
} neighbors;
public:
BoundaryColorizer(const Detection detection, const Float threshold = 15._f);
virtual bool hasData(const Storage& storage) const override;
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual bool isInitialized() const override;
virtual Rgba evalColor(const Size idx) const override;
virtual Optional<Particle> getParticle(const Size UNUSED(idx)) const override {
// doesn't really make sense to assign some value to boundary
return NOTHING;
}
virtual Optional<Palette> getPalette() const override {
return NOTHING;
}
virtual void setPalette(const Palette& UNUSED(newPalette)) override {}
virtual std::string name() const override {
return "Boundary";
}
private:
bool isBoundary(const Size idx) const;
};
template <typename TDerived>
class IdColorizerTemplate : public IColorizer {
private:
Rgba backgroundColor;
Size seed = 1;
public:
explicit IdColorizerTemplate(const GuiSettings& gui) {
backgroundColor = gui.get<Rgba>(GuiSettingsId::BACKGROUND_COLOR);
}
void setSeed(const Size newSeed) {
seed = newSeed;
}
virtual Rgba evalColor(const Size idx) const override;
virtual Optional<Particle> getParticle(const Size idx) const override;
virtual Optional<Palette> getPalette() const override {
return NOTHING;
}
virtual void setPalette(const Palette& UNUSED(newPalette)) override {}
};
class ParticleIdColorizer : public IdColorizerTemplate<ParticleIdColorizer> {
private:
ArrayRef<const Size> persistentIdxs;
public:
using IdColorizerTemplate<ParticleIdColorizer>::IdColorizerTemplate;
INLINE Optional<Size> evalId(const Size idx) const {
if (!persistentIdxs.empty() && idx < persistentIdxs.size()) {
return persistentIdxs[idx];
} else {
return idx;
}
}
virtual bool hasData(const Storage& UNUSED(storage)) const override {
return true;
}
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual bool isInitialized() const override {
return true;
}
virtual Optional<Particle> getParticle(const Size idx) const override;
virtual std::string name() const override {
return "Particle ID";
}
};
class ComponentIdColorizer : public IdColorizerTemplate<ComponentIdColorizer> {
private:
Flags<Post::ComponentFlag> connectivity;
Array<Size> components;
ArrayRef<const Float> m;
ArrayRef<const Vector> r, v;
Optional<Size> highlightIdx;
/// \todo hacked optimization to avoid rebuilding the colorizer if only highlight idx changed. Should be
/// done more generally and with lower memory footprint
struct {
Array<Vector> r;
} cached;
public:
explicit ComponentIdColorizer(const GuiSettings& gui,
const Flags<Post::ComponentFlag> connectivity,
const Optional<Size> highlightIdx = NOTHING);
void setHighlightIdx(const Optional<Size> newHighlightIdx);
Optional<Size> getHighlightIdx() const {
return highlightIdx;
}
void setConnectivity(const Flags<Post::ComponentFlag> newConnectivity) {
connectivity = newConnectivity;
cached.r.clear();
}
Flags<Post::ComponentFlag> getConnectivity() const {
return connectivity;
}
INLINE Optional<Size> evalId(const Size idx) const {
return components[idx];
}
virtual Rgba evalColor(const Size idx) const override;
virtual Optional<Particle> getParticle(const Size idx) const override;
virtual bool hasData(const Storage& storage) const override;
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual bool isInitialized() const override {
return !components.empty();
}
virtual std::string name() const override;
};
class AggregateIdColorizer : public IdColorizerTemplate<AggregateIdColorizer> {
private:
ArrayView<const Size> ids;
public:
using IdColorizerTemplate<AggregateIdColorizer>::IdColorizerTemplate;
INLINE Optional<Size> evalId(const Size idx) const {
if (ids[idx] != Size(-1)) {
return ids[idx];
} else {
return NOTHING;
}
}
virtual bool hasData(const Storage& storage) const override {
return storage.has(QuantityId::AGGREGATE_ID) && storage.getUserData() != nullptr;
}
virtual void initialize(const Storage& storage, const RefEnum UNUSED(ref)) override {
ids = storage.getValue<Size>(QuantityId::AGGREGATE_ID);
}
virtual bool isInitialized() const override {
return ids != nullptr;
}
virtual std::string name() const override {
return "Aggregate ID";
}
};
class IndexColorizer : public IdColorizerTemplate<IndexColorizer> {
private:
QuantityId id;
ArrayRef<const Size> idxs;
public:
IndexColorizer(const QuantityId id, const GuiSettings& gui)
: IdColorizerTemplate<IndexColorizer>(gui)
, id(id) {}
INLINE Optional<Size> evalId(const Size idx) const {
return idxs[idx];
}
virtual bool hasData(const Storage& storage) const override {
return storage.has(id);
}
virtual void initialize(const Storage& storage, const RefEnum ref) override {
idxs = makeArrayRef(storage.getValue<Size>(id), ref);
}
virtual bool isInitialized() const override {
return !idxs.empty();
}
virtual std::string name() const override {
return getMetadata(id).quantityName;
}
};
class MaterialColorizer : public IndexColorizer {
private:
Array<std::string> eosNames;
Array<std::string> rheoNames;
public:
MaterialColorizer(const GuiSettings& gui)
: IndexColorizer(QuantityId::MATERIAL_ID, gui) {}
virtual void initialize(const Storage& storage, const RefEnum ref) override;
virtual Optional<Particle> getParticle(const Size idx) const override;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/system/Settings.impl.h
|
#include "io/FileSystem.h"
#include "objects/Exceptions.h"
#include "objects/utility/StringUtils.h"
#include "objects/wrappers/Outcome.h"
#include "system/Settings.h"
#include <fstream>
#include <regex>
/// Settigs implementation, needs to be included in cpp with explicit instantiation of Settings.
NAMESPACE_SPH_BEGIN
template <typename TEnum>
Settings<TEnum>::Settings(std::initializer_list<Entry> list) {
for (auto& entry : list) {
SPH_ASSERT(!entries.contains(entry.id), "Duplicate settings ID ", int(entry.id));
entries.insert(entry.id, entry);
}
}
template <typename TEnum>
Settings<TEnum>::Settings()
: Settings(Settings::getDefaults()) {}
template <typename TEnum>
Settings<TEnum>::Settings(EmptySettingsTag) {}
template <typename TEnum>
Settings<TEnum>::Settings(const Settings& other)
: entries(other.entries.clone()) {}
template <typename TEnum>
Settings<TEnum>::Settings(Settings&& other)
: entries(std::move(other.entries)) {}
template <typename TEnum>
Settings<TEnum>& Settings<TEnum>::operator=(std::initializer_list<Entry> list) {
entries.clear();
for (auto& entry : list) {
entries.insert(entry.id, entry);
}
return *this;
}
template <typename TEnum>
Settings<TEnum>& Settings<TEnum>::operator=(const Settings& other) {
entries = other.entries.clone();
return *this;
}
template <typename TEnum>
Settings<TEnum>& Settings<TEnum>::operator=(Settings&& other) {
entries = std::move(other.entries);
return *this;
}
template <typename TEnum>
bool Settings<TEnum>::setValueByType(Entry& entry, const Value& defaultValue, const std::string& str) {
const Size typeIdx = defaultValue.getTypeIdx();
std::stringstream ss(str.c_str());
switch (typeIdx) {
case BOOL: {
std::string value;
ss >> value;
if (ss.fail()) {
return false;
} else if (value == "true") {
entry.value = true;
return true;
} else if (value == "false") {
entry.value = false;
return true;
} else {
return false;
}
}
case INT:
int i;
ss >> i;
if (ss.fail()) {
return false;
} else {
entry.value = i;
return true;
}
case FLOAT:
Float f;
ss >> f;
if (ss.fail()) {
return false;
} else {
entry.value = f;
return true;
}
case INTERVAL: {
std::string s1, s2;
ss >> s1 >> s2;
if (ss.fail()) {
return false;
}
Float lower, upper;
if (s1 == "-infinity") {
lower = -INFTY;
} else {
ss.clear();
ss.str(s1);
Float value;
ss >> value;
lower = value;
}
if (s2 == "infinity") {
upper = INFTY;
} else {
ss.clear();
ss.str(s2);
Float value;
ss >> value;
upper = value;
}
if (ss.fail()) {
return false;
} else {
entry.value = Interval(lower, upper);
return true;
}
}
case STRING: {
// trim leading and trailing spaces
const std::string trimmed = trim(str);
entry.value = trimmed;
return true;
}
case VECTOR:
Float v1, v2, v3;
ss >> v1 >> v2 >> v3;
if (ss.fail()) {
return false;
} else {
entry.value = Vector(v1, v2, v3);
return true;
}
case SYMMETRIC_TENSOR:
Float sxx, syy, szz, sxy, sxz, syz;
ss >> sxx >> syy >> szz >> sxy >> sxz >> syz;
if (ss.fail()) {
return false;
} else {
entry.value = SymmetricTensor(Vector(sxx, syy, szz), Vector(sxy, sxz, syz));
return true;
}
case TRACELESS_TENSOR:
Float txx, tyy, txy, txz, tyz;
ss >> txx >> tyy >> txy >> txz >> tyz;
if (ss.fail()) {
return false;
} else {
entry.value = TracelessTensor(txx, tyy, txy, txz, tyz);
return true;
}
case ENUM: {
const EnumIndex index = defaultValue.template get<EnumWrapper>().index;
std::string textValue;
int flags = 0;
while (true) {
ss >> textValue;
if (ss.fail()) {
return false;
}
if (textValue == "0") {
// special value representing empty flags;
// we need to check that this is the only thing on the line
ss >> textValue;
if (!ss && flags == 0) {
flags = 0;
break;
} else {
return false;
}
}
Optional<int> value = EnumMap::fromString(textValue, index);
if (!value) {
return false;
} else {
flags |= value.value();
}
ss >> textValue;
if (!ss || textValue != "|") {
break;
}
}
entry.value = EnumWrapper(flags, index);
return true;
}
default:
NOT_IMPLEMENTED;
}
}
template <typename TEnum>
Outcome Settings<TEnum>::loadFromFile(const Path& path) {
std::ifstream ifs(path.native());
if (!ifs) {
return makeFailed("File ", path.native(), " cannot be opened for reading.");
}
std::string line;
const Settings& descriptors = getDefaults();
while (std::getline(ifs, line, '\n')) {
if (line.empty() || line[0] == '#') {
continue;
}
const std::size_t idx = line.find("=", 0);
if (idx == std::string::npos) {
return makeFailed("Invalid format of the file, didn't find separating '='");
}
std::string key = line.substr(0, idx);
std::string value = line.substr(idx + 1);
// throw away spaces from key
std::string trimmedKey = trim(key);
// find the key in decriptor settings
bool found = false;
for (auto& e : descriptors.entries) {
if (e.value().name == trimmedKey) {
entries.insert(e.value().id, e.value());
if (!setValueByType(entries[e.value().id], e.value().value, value)) {
return makeFailed("Invalid value of key ", trimmedKey, ": ", value);
}
found = true;
break;
}
}
if (!found) {
return makeFailed("Key ", trimmedKey, " was not find in settings");
}
}
ifs.close();
return SUCCESS;
}
template <typename TEnum>
Outcome Settings<TEnum>::saveToFile(const Path& path) const {
const Outcome dirCreated = FileSystem::createDirectory(path.parentPath());
if (!dirCreated) {
return makeFailed("Cannot save settings: ", dirCreated.error());
}
const Settings& descriptors = getDefaults();
try {
std::ofstream ofs(path.native());
for (auto& e : entries) {
const Entry& entry = e.value();
const Entry& descriptor = descriptors.entries[e.key()];
if (!descriptor.desc.empty()) {
std::string desc = "# " + descriptor.desc;
desc = setLineBreak(desc, 120);
desc = replaceAll(desc, "\n", "\n# ");
ofs << desc << std::endl;
}
ofs << std::setw(30) << std::left << descriptor.name << " = ";
switch (entry.value.getTypeIdx()) {
case BOOL:
ofs << (entry.value.template get<bool>() ? "true" : "false");
break;
case INT:
ofs << entry.value.template get<int>();
break;
case FLOAT:
ofs << entry.value.template get<Float>();
break;
case INTERVAL:
ofs << entry.value.template get<Interval>();
break;
case STRING:
ofs << entry.value.template get<std::string>();
break;
case VECTOR:
ofs << entry.value.template get<Vector>();
break;
case SYMMETRIC_TENSOR:
ofs << entry.value.template get<SymmetricTensor>();
break;
case TRACELESS_TENSOR:
ofs << entry.value.template get<TracelessTensor>();
break;
case ENUM: {
EnumWrapper e = entry.value.template get<EnumWrapper>();
ofs << EnumMap::toString(e.value, e.index);
break;
}
default:
NOT_IMPLEMENTED;
}
ofs << std::endl;
}
ofs.close();
return SUCCESS;
} catch (const std::exception& e) {
return makeFailed("Cannot save settings: ", e.what());
}
}
template <typename TEnum>
bool Settings<TEnum>::tryLoadFileOrSaveCurrent(const Path& path, const Settings& overrides) {
if (FileSystem::pathExists(path)) {
// load from file and apply the overrides
const Outcome result = this->loadFromFile(path);
if (!result) {
throw IoError(result.error());
}
this->addEntries(overrides);
return true;
} else {
// apply overrides and then save
this->addEntries(overrides);
this->saveToFile(path);
return false;
}
}
template <typename TEnum>
std::string Settings<TEnum>::typeToString(const int type) {
static StaticArray<std::string, 9> names = {
"bool",
"int",
"float",
"interval",
"string",
"vector",
"symmetric_tensor",
"traceless_tensor",
"enum",
};
if (type >= 0 && type < int(names.size())) {
return names[type];
} else {
throw Exception("Unknown settings type " + std::to_string(type));
}
}
template <typename TEnum>
SettingsIterator<TEnum> Settings<TEnum>::begin() const {
return SettingsIterator<TEnum>(entries.begin(), {});
}
template <typename TEnum>
SettingsIterator<TEnum> Settings<TEnum>::end() const {
return SettingsIterator<TEnum>(entries.end(), {});
}
template <typename TEnum>
Size Settings<TEnum>::size() const {
return entries.size();
}
template <typename TEnum>
const Settings<TEnum>& Settings<TEnum>::getDefaults() {
SPH_ASSERT(instance != nullptr);
return *instance;
}
template <typename TEnum>
SettingsIterator<TEnum>::SettingsIterator(const ActIterator& iter, Badge<Settings<TEnum>>)
: iter(iter) {}
template <typename TEnum>
typename SettingsIterator<TEnum>::IteratorValue SettingsIterator<TEnum>::operator*() const {
return { iter->key(), iter->value().value };
}
template <typename TEnum>
SettingsIterator<TEnum>& SettingsIterator<TEnum>::operator++() {
++iter;
return *this;
}
template <typename TEnum>
bool SettingsIterator<TEnum>::operator==(const SettingsIterator& other) const {
return iter == other.iter;
}
template <typename TEnum>
bool SettingsIterator<TEnum>::operator!=(const SettingsIterator& other) const {
return iter != other.iter;
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/objects/SvgContext.h
|
<filename>gui/objects/SvgContext.h
#pragma once
/// \file SvgContext.h
/// \brief Implementation of IDrawingContext for creating vector images (.svg)
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "gui/objects/Point.h"
#include "io/Path.h"
#include "post/Plot.h"
#include <wx/dcsvg.h>
NAMESPACE_SPH_BEGIN
class SvgPath : public IDrawPath {
private:
wxSVGFileDC& dc;
AffineMatrix2 matrix;
PlotPoint prev{ -1, -1 };
PlotPoint first;
public:
SvgPath(wxSVGFileDC& dc, const AffineMatrix2& matrix)
: dc(dc)
, matrix(matrix) {}
virtual void addPoint(const PlotPoint& point) override {
if (prev == PlotPoint{ -1, -1 }) {
first = point;
} else {
const PlotPoint p1 = matrix.transformPoint(prev);
const PlotPoint p2 = matrix.transformPoint(point);
dc.DrawLine({ int(p1.x), int(p1.y) }, { int(p2.x), int(p2.y) });
}
prev = point;
}
virtual void closePath() override {
const PlotPoint p1 = matrix.transformPoint(prev);
const PlotPoint p2 = matrix.transformPoint(first);
dc.DrawLine({ int(p1.x), int(p1.y) }, { int(p2.x), int(p2.y) });
}
virtual void endPath() override {
// do nothing
}
};
class SvgContext : public IDrawingContext {
private:
wxSVGFileDC dc;
int pointSize = 3;
AffineMatrix2 matrix;
public:
SvgContext(const Path& path, const Pixel size, const double dpi = 72)
: dc(path.native(), size.x, size.y, dpi) {}
virtual void drawPoint(const PlotPoint& point) override {
const PlotPoint p = matrix.transformPoint(point);
dc.DrawCircle(int(p.x), int(p.y), pointSize);
}
virtual void drawErrorPoint(const ErrorPlotPoint& point) override {
const PlotPoint p = matrix.transformPoint(point);
dc.DrawCircle(int(p.x), int(p.y), pointSize);
}
virtual void drawLine(const PlotPoint& from, const PlotPoint& to) override {
const PlotPoint p1 = matrix.transformPoint(from);
const PlotPoint p2 = matrix.transformPoint(to);
dc.DrawLine({ int(p1.x), int(p1.y) }, { int(p2.x), int(p2.y) });
}
virtual AutoPtr<IDrawPath> drawPath() override {
return makeAuto<SvgPath>(dc, matrix);
}
virtual void setStyle(const Size UNUSED(index)) override {
// currently not implemented
}
virtual void setTransformMatrix(const AffineMatrix2& newMatrix) override {
matrix = newMatrix;
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/ImageTransform.h
|
#pragma once
#include "gui/objects/Bitmap.h"
#include "thread/Scheduler.h"
NAMESPACE_SPH_BEGIN
template <typename Transform>
Bitmap<Rgba> transform(const Bitmap<Rgba>& input, const Transform& func) {
Bitmap<Rgba> result(input.size());
for (int y = 0; y < input.size().y; ++y) {
for (int x = 0; x < input.size().x; ++x) {
result(x, y) = func(Pixel(x, y), input(x, y));
}
}
return result;
}
Rgba interpolate(const Bitmap<Rgba>& bitmap, const float x, const float y);
Bitmap<Rgba> resize(const Bitmap<Rgba>& input, const Pixel size);
Bitmap<float> detectEdges(const Bitmap<Rgba>& input);
Bitmap<Rgba> gaussianBlur(IScheduler& scheduler, const Bitmap<Rgba>& input, const int radius);
Bitmap<Rgba> bloomEffect(IScheduler& scheduler,
const Bitmap<Rgba>& input,
const int radius = 25,
const float magnitude = 1.f,
const float brightnessThreshold = 0.5f);
struct DenoiserParams {
Size filterRadius = 5;
Size patchRadius = 2;
float sigma = 0.02f;
};
Bitmap<Rgba> denoise(IScheduler& scheduler, const Bitmap<Rgba>& input, const DenoiserParams& params);
Bitmap<Rgba> denoiseLowFrequency(IScheduler& scheduler,
const Bitmap<Rgba>& input,
const DenoiserParams& params,
const Size levels = 2);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/sph/Materials.h
|
<filename>core/sph/Materials.h
#pragma once
/// \file Materials.h
/// \brief SPH-specific implementation of particle materials
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "quantities/IMaterial.h"
NAMESPACE_SPH_BEGIN
class IEos;
class IRheology;
/// \brief Material holding equation of state
///
/// Pressure and sound speed are computed in \ref initialize function, so the EoS does not have to be
/// evaluated manually. If this is necessary for some reason (when setting pressure-dependent initial
/// conditions or checking if we selected correct EoS, for example), functions \ref evaluate and \ref getEos
/// can be used. This is not part of the IMaterial interface, so dynamic_cast have to be used to access it.
class EosMaterial : public IMaterial {
private:
AutoPtr<IEos> eos;
public:
/// \brief Creates the material by specifying an equation of state.
///
/// Equation of state must not be nullptr.
EosMaterial(const BodySettings& body, AutoPtr<IEos>&& eos);
/// \brief Creates the material.
///
/// Equation of state is constructed from parameters in settings.
explicit EosMaterial(const BodySettings& body);
/// Returns the equation of state.
const IEos& getEos() const;
virtual void create(Storage& storage, const MaterialInitialContext& context) override;
virtual void initialize(IScheduler& scheduler, Storage& storage, const IndexSequence sequence) override;
virtual void finalize(IScheduler& UNUSED(scheduler),
Storage& UNUSED(storage),
const IndexSequence UNUSED(sequence)) override {
// nothing
}
};
/// \brief Generalization of material with equation of state.
///
/// It holds a rheology implementation that modifies pressure and stress tensor. This is done in \ref
/// initialize function, function \ref finalize then integrates the fragmentation model (if used, of course).
class SolidMaterial : public EosMaterial {
private:
AutoPtr<IRheology> rheology;
public:
SolidMaterial(const BodySettings& body, AutoPtr<IEos>&& eos, AutoPtr<IRheology>&& rheology);
explicit SolidMaterial(const BodySettings& body);
virtual void create(Storage& storage, const MaterialInitialContext& context) override;
virtual void initialize(IScheduler& scheduler, Storage& storage, const IndexSequence sequence) override;
virtual void finalize(IScheduler& scheduler, Storage& storage, const IndexSequence sequence) override;
};
/// \brief Basic materials available in the code.
///
/// Parameters were taken from Reinhardt and Stadel (2016).
enum class MaterialEnum {
BASALT,
IRON,
ICE,
OLIVINE,
};
AutoPtr<IMaterial> getMaterial(const MaterialEnum type);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/windows/GridPage.h
|
<reponame>pavelsevecek/OpenSPH<gh_stars>10-100
#pragma once
#include "post/Analysis.h"
#include "quantities/Storage.h"
#include <thread>
#include <wx/grid.h>
#include <wx/panel.h>
NAMESPACE_SPH_BEGIN
enum class CheckFlag;
class GridPage : public wxPanel {
private:
wxGrid* grid = nullptr;
std::thread thread;
const Storage& storage;
wxSpinCtrl* countSpinner;
public:
GridPage(wxWindow* parent, const wxSize size, const Storage& storage);
~GridPage();
private:
struct Config {
Float moonLimit = 0.1f;
Float radiiLimit = 2.f;
};
void update(const Storage& storage, const Config& config);
void updateAsync(const Storage& storage,
const Size fragmentCnt,
const Flags<CheckFlag> checks,
const Config& config);
template <typename T>
void updateCell(const Size rowIdx, const Size colIdx, const T& value);
wxCheckBox* getCheck(const CheckFlag check) const;
Size getCheckedCount() const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/renderers/IRenderer.h
|
<reponame>pavelsevecek/OpenSPH
#pragma once
/// \file IRenderer.h
/// \brief Interface for renderers
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "gui/objects/Color.h"
#include "gui/objects/Point.h"
#include "gui/objects/Texture.h"
#include "objects/wrappers/Any.h"
#include "objects/wrappers/Flags.h"
#include "quantities/Particle.h"
#include "thread/ThreadLocal.h"
#include <atomic>
NAMESPACE_SPH_BEGIN
class ICamera;
struct CameraRay;
class ITracker;
class IColorizer;
class IColorMap;
class FrameBuffer;
class Statistics;
class GuiSettings;
enum class TextAlign {
LEFT = 1 << 0,
RIGHT = 1 << 1,
HORIZONTAL_CENTER = 1 << 2,
TOP = 1 << 3,
BOTTOM = 1 << 4,
VERTICAL_CENTER = 1 << 5,
};
class IRenderOutput : public Polymorphic {
public:
/// \todo would be nice to make it more general, cleaner
struct Label {
std::wstring text;
Rgba color;
int fontSize;
Flags<TextAlign> align;
Pixel position;
};
/// May be called once after render finishes or multiple times for progressive renderers.
virtual void update(const Bitmap<Rgba>& bitmap, Array<Label>&& labels, const bool isFinal) = 0;
/// \copydoc update
virtual void update(Bitmap<Rgba>&& bitmap, Array<Label>&& labels, const bool isFinal) = 0;
};
/// \brief Parameters of the rendered image
///
/// Partially overlaps with GuiSettings, but it's better to have render specific settings in one struct than
/// one huge catch-all settings.
struct RenderParams {
/// \brief Camera used for rendering.
AutoPtr<ICamera> camera;
/// \brief Tracker used for camera motion.
///
/// May be nullptr for static camera.
AutoPtr<ITracker> tracker;
/// \brief Background color of the rendered image.
Rgba background = Rgba::black();
/// \brief If true, a color palette and a distance scale is included in the image.
bool showKey = true;
/// \brief Parameters of the particle renderer
struct {
/// \brief Scaling factor of drawn particles relative to 1.
///
/// Can be (in theory) any positive value.
float scale = 1.f;
/// \brief Highlighted particle (only for interactive view).
///
/// If NOTHING, no particle is selected.
Optional<Size> selected = NOTHING;
/// \brief If true, the palette is converted to grayscale.
bool grayScale = false;
/// \brief If true, the particles will be drawn with antialiasing.
///
/// This will generally improve quality, but may slow down the rendering.
bool doAntialiasing = false;
/// \brief If true, particles will be smoothed using cubic spline.
///
/// Only used if doAntialiasing is true.
bool smoothed = false;
/// \brief If true, ghost particles (if present) will be rendered as empty circles.
bool renderGhosts = true;
} particles;
/// \brief Parameters of rendered vectors
struct {
/// \brief Length of the drawn vectors in pixels;
float length = 100.f;
} vectors;
/// \brief Parameters of rendered surface
struct {
/// \brief Value of the iso-surface defining the rendered surface
float level = 0.15f;
/// \brief Intensity of the ambient light, illuminating every point unconditionally.
float ambientLight = 0.3f;
/// \brief Intensity of the sunlight.
float sunLight = 0.7f;
/// \brief Emission multiplier
float emission = 1.f;
/// \brief Width of the image reconstruction filter
float filterWidth = 2.f;
} surface;
/// \brief Parameters of volumetric renderer
struct {
/// \brief Emission per unit distance [m^-1]
float emission = 1.f;
/// \brief Absorption coefficient [m^-1]
float absorption = 0.f;
/// \brief Compression factor of the logarithmic tonemapper
float compressionFactor = 2.f;
/// \brief Suppress the low-frequency noise
bool denoise;
/// \brief Magnitude of bloom effect
float bloomIntensity = 0.f;
} volume;
struct {
/// \brief Step between subsequent iso-lines
float isoStep = 30.f;
/// \brief Horizontal resolution of the grid
Size gridSize = 100;
/// \brief Show numerical values of iso-lines
bool showLabels = true;
} contours;
/// \brief Sets up parameters using values stored in settings.
///
/// This does NOT initialize camera and resolution of the render.
void initialize(const GuiSettings& gui);
};
/// \brief Interface used to implement renderers.
class IRenderer : public Polymorphic {
public:
/// \brief Prepares the objects for rendering and updates its data.
///
/// Called every time a parameter changes. Renderer should cache any data necessary for rendering of
/// particles (particle positions, colors, etc.).
/// \param storage Storage containing positions of particles, must match the particles in colorizer.
/// \param colorizer Data-to-color conversion object for particles. Must be already initialized!
/// \param camera Camera used for rendering.
virtual void initialize(const Storage& storage, const IColorizer& colorizer, const ICamera& camera) = 0;
/// \brief Checks if the renderer has been initialized.
virtual bool isInitialized() const = 0;
/// \brief Called if only the colorizer changed since the last call of \ref initialize.
virtual void setColorizer(const IColorizer& colorizer) = 0;
/// \brief Draws particles into the bitmap, given the data provided in \ref initialize.
///
/// This function is called every time the view changes (display parameters change, camera pan & zoom,
/// ...). Implementation shall be callable from any thread, but does not have to be thread-safe (never
/// will be executed from multiple threads at once).
/// \param params Parameters of the render
/// \param stats Input-output parameter, contains run statistics that can be included in the render
/// (run time, timestep, ...), renderers can also output some statistics of their own
/// (time used in rendering, framerate, ...)
virtual void render(const RenderParams& params, Statistics& stats, IRenderOutput& output) const = 0;
/// \brief Stops the rendering if it is currently in progress.
virtual void cancelRender() = 0;
};
/// \brief Base class for renderers based on raytracing
class IRaytracer : public IRenderer {
protected:
SharedPtr<IScheduler> scheduler;
struct ThreadData {
/// Random-number generator for this thread.
UniformRng rng;
/// Additional data used by the implementation
Any data;
ThreadData(int seed);
};
mutable ThreadLocal<ThreadData> threadData;
mutable std::atomic_bool shouldContinue;
private:
/// \brief Parameters fixed for the renderer.
///
/// Note that additional parameters which can differ for each rendered image are passed to \ref render.
struct {
/// Color mapping operator
AutoPtr<IColorMap> colorMap;
struct {
Rgba color = Rgba::black();
/// HDRI for the background. Can be empty.
Texture hdri;
} enviro;
/// Number of iterations of the progressive renderer.
Size iterationLimit;
/// Number of subsampled iterations.
Size subsampling;
} fixed;
public:
IRaytracer(SharedPtr<IScheduler> scheduler, const GuiSettings& gui);
virtual void render(const RenderParams& params, Statistics& stats, IRenderOutput& output) const final;
virtual void cancelRender() override {
shouldContinue = false;
}
protected:
virtual Rgba shade(const RenderParams& params, const CameraRay& ray, ThreadData& data) const = 0;
Rgba getEnviroColor(const CameraRay& ray) const;
private:
void refine(const RenderParams& params, const Size iteration, FrameBuffer& fb) const;
void postProcess(FrameBuffer& fb,
const RenderParams& params,
const bool isFinal,
IRenderOutput& output) const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/run/jobs/ParticleJobs.h
|
<reponame>pavelsevecek/OpenSPH
#pragma once
#include "run/Job.h"
NAMESPACE_SPH_BEGIN
class JoinParticlesJob : public IParticleJob {
private:
Vector offset = Vector(0._f);
Vector velocity = Vector(0._f);
bool moveToCom = false;
bool uniqueFlags = true;
public:
explicit JoinParticlesJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "join";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "particles A", JobType::PARTICLES },
{ "particles B", JobType::PARTICLES },
};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class OrbitParticlesJob : public IParticleJob {
private:
Float a = 1.e6_f;
Float e = 0._f;
Float v = 0._f;
public:
explicit OrbitParticlesJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "orbit";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "particles A", JobType::PARTICLES },
{ "particles B", JobType::PARTICLES },
};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class MultiJoinParticlesJob : public IParticleJob {
private:
int slotCnt = 3;
bool moveToCom = false;
bool uniqueFlags = true;
public:
explicit MultiJoinParticlesJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "multi join";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
UnorderedMap<std::string, ExtJobType> map;
for (int i = 0; i < slotCnt; ++i) {
map.insert("particles " + std::to_string(i + 1), JobType::PARTICLES);
}
return map;
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class TransformParticlesJob : public IParticleJob {
private:
struct {
Vector offset = Vector(0._f);
Vector angles = Vector(0._f);
} positions;
struct {
Vector offset = Vector(0._f);
Float mult = 1.;
} velocities;
Vector spin = Vector(0._f);
public:
explicit TransformParticlesJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "transform";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class CenterParticlesJob : public IParticleJob {
private:
bool centerPositions = true;
bool centerVelocities = false;
public:
explicit CenterParticlesJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "center";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
enum class ChangeMaterialSubset {
ALL,
MATERIAL_ID,
INSIDE_DOMAIN,
};
class ChangeMaterialJob : public IParticleJob {
private:
EnumWrapper type = EnumWrapper(ChangeMaterialSubset::ALL);
int matId = 0;
public:
explicit ChangeMaterialJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "change material";
}
virtual UnorderedMap<std::string, ExtJobType>
requires() const override {
UnorderedMap<std::string, ExtJobType> map{
{ "particles", JobType::PARTICLES },
{ "material", JobType::MATERIAL },
};
if (ChangeMaterialSubset(type) == ChangeMaterialSubset::INSIDE_DOMAIN) {
map.insert("domain", JobType::GEOMETRY);
}
return map;
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES },
{ "material", JobType::MATERIAL },
{ "domain", JobType::GEOMETRY } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
enum class CollisionGeometrySettingsId {
/// Impact angle in degrees, i.e. angle between velocity vector and normal at the impact point.
IMPACT_ANGLE,
/// Impact speed in m/s
IMPACT_SPEED,
/// Initial distance of the impactor from the impact point. This value is in units of smoothing length h.
/// Should not be lower than kernel.radius() * eta.
IMPACTOR_OFFSET,
/// If true, derivatives in impactor will be computed with lower precision. This significantly improves
/// the performance of the code. The option is intended mainly for cratering impacts and should be always
/// false when simulating collision of bodies of comparable sizes.
IMPACTOR_OPTIMIZE,
/// If true, positions and velocities of particles are modified so that center of mass is at origin and
/// has zero velocity.
CENTER_OF_MASS_FRAME,
};
using CollisionGeometrySettings = Settings<CollisionGeometrySettingsId>;
class CollisionGeometrySetup : public IParticleJob {
private:
CollisionGeometrySettings geometry;
public:
explicit CollisionGeometrySetup(const std::string& name,
const CollisionGeometrySettings& overrides = EMPTY_SETTINGS);
virtual std::string className() const override {
return "collision setup";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "target", JobType::PARTICLES }, { "impactor", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
/// \brief Determines how to compute the radii of the spheres
enum class HandoffRadius {
/// The created sphere has the same volume as the SPH particles (=mass/density)
EQUAL_VOLUME,
/// The radius is proportional to the smoothing length of the particles.
SMOOTHING_LENGTH,
};
class SmoothedToSolidHandoff : public IParticleJob {
private:
EnumWrapper type = EnumWrapper(HandoffRadius::EQUAL_VOLUME);
/// \brief Conversion factor between smoothing length and particle radius.
///
/// Used only for Radius::SMOOTHING_LENGTH.
Float radiusMultiplier = 0.333_f;
public:
explicit SmoothedToSolidHandoff(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "smoothed-to-solid handoff";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
class ExtractComponentJob : public IParticleJob {
private:
int componentIdx = 0;
Float factor = 1.5_f;
bool center = false;
public:
explicit ExtractComponentJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "extract component";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class RemoveParticlesJob : public IParticleJob {
private:
bool removeDamaged = true;
bool removeExpanded = false;
Float damageLimit = 1._f;
Float energyLimit = 1.e6_f;
public:
explicit RemoveParticlesJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "remove particles";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
enum class ConnectivityEnum {
OVERLAP,
ESCAPE_VELOCITY,
};
class MergeComponentsJob : public IParticleJob {
private:
Float factor = 1.5_f;
EnumWrapper connectivity = EnumWrapper(ConnectivityEnum::OVERLAP);
public:
explicit MergeComponentsJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "merge components";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class ExtractParticlesInDomainJob : public IParticleJob {
private:
bool center = false;
public:
explicit ExtractParticlesInDomainJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "extract particles in domain";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES }, { "domain", JobType::GEOMETRY } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class EmplaceComponentsAsFlagsJob : public IParticleJob {
private:
Float factor = 1.5_f;
public:
explicit EmplaceComponentsAsFlagsJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "emplace components";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "fragments", JobType::PARTICLES },
{ "original", JobType::PARTICLES },
};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class SubsampleJob : public IParticleJob {
private:
Float fraction = 0.5_f;
bool adjustMass = true;
bool adjustRadii = true;
public:
explicit SubsampleJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "subsampler";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
enum class CompareMode {
PARTICLE_WISE,
LARGE_PARTICLES_ONLY,
};
class CompareJob : public IParticleJob {
EnumWrapper mode = EnumWrapper(CompareMode::PARTICLE_WISE);
Float eps = 1.e-4_f;
Float fraction = 0.2_f;
Float maxDeviation = 0.5_f;
public:
explicit CompareJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "compare";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {
{ "test particles", JobType::PARTICLES },
{ "reference particles", JobType::PARTICLES },
};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/math/AffineMatrix.h
|
<reponame>pavelsevecek/OpenSPH<filename>core/math/AffineMatrix.h
#pragma once
/// \file AffineMatrix.h
/// \brief Three-dimensional affine matrix
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/geometry/Vector.h"
#include "objects/wrappers/Optional.h"
NAMESPACE_SPH_BEGIN
/// \todo somewhat duplicate of Tensor, but many function differ slightly due to translation, different
/// asserts, etc. Probably not worth having common parent.
class AffineMatrix {
private:
Vector v[3]; // rows
public:
AffineMatrix() = default;
/// \brief Construct the matrix from vectors as rows.
///
/// Translation is stored as 4th components of vectors
AffineMatrix(const Vector& v1, const Vector& v2, const Vector& v3)
: v{ v1, v2, v3 } {}
/// \param i Row index
/// \param j Column index
INLINE Float& operator()(const Size i, const Size j) {
SPH_ASSERT(i < 3 && j < 4, i, j);
return v[i][j];
}
INLINE Float operator()(const Size i, const Size j) const {
SPH_ASSERT(i < 3 && j < 4, i, j);
return v[i][j];
}
INLINE Vector column(const Size idx) const {
SPH_ASSERT(idx < 4, idx);
return Vector(v[0][idx], v[1][idx], v[2][idx]);
}
INLINE Vector row(const Size idx) const {
SPH_ASSERT(idx < 3, idx);
return v[idx];
}
INLINE Vector translation() const {
return Vector(v[0][3], v[1][3], v[2][3]);
}
INLINE AffineMatrix& removeTranslation() {
v[0][3] = v[1][3] = v[2][3] = 0._f;
return *this;
}
INLINE AffineMatrix& translate(const Vector& t) {
v[0][3] += t[0];
v[1][3] += t[1];
v[2][3] += t[2];
return *this;
}
/// \brief Returns the transposed matrix.
///
/// Translation vector is copied into the transposed matrix, so that double-transposed matrix is equal to
/// the original matrix.
INLINE AffineMatrix transpose() const {
AffineMatrix transposed(column(0), column(1), column(2));
transposed(0, 3) = v[0][3];
transposed(1, 3) = v[1][3];
transposed(2, 3) = v[2][3];
return transposed;
}
/// \brief Computes determinant of the matrix.
///
/// The translation is ignored, as determinant is defined for square matrices
INLINE Float determinant() const {
return v[0][0] * (v[1][1] * v[2][2] - v[2][1] * v[1][2]) -
v[0][1] * (v[1][0] * v[2][2] - v[1][2] * v[2][0]) +
v[0][2] * (v[1][0] * v[2][1] - v[1][1] * v[2][0]);
}
Optional<AffineMatrix> tryInverse(const Float limit = 1.e-20_f) const {
const Float det = this->determinant();
if (abs(det) < limit) {
return NOTHING;
}
// from https://stackoverflow.com/questions/1148309/inverting-a-4x4-matrix
AffineMatrix inv;
inv(0, 0) = v[1][1] * v[2][2] - v[2][1] * v[1][2];
inv(1, 0) = -v[1][0] * v[2][2] + v[2][0] * v[1][2];
inv(2, 0) = v[1][0] * v[2][1] - v[2][0] * v[1][1];
inv(0, 1) = -v[0][1] * v[2][2] + v[2][1] * v[0][2];
inv(1, 1) = v[0][0] * v[2][2] - v[2][0] * v[0][2];
inv(2, 1) = -v[0][0] * v[2][1] + v[2][0] * v[0][1];
inv(0, 2) = v[0][1] * v[1][2] - v[1][1] * v[0][2];
inv(1, 2) = -v[0][0] * v[1][2] + v[1][0] * v[0][2];
inv(2, 2) = v[0][0] * v[1][1] - v[1][0] * v[0][1];
inv(0, 3) = -v[0][1] * v[1][2] * v[2][3] + v[0][1] * v[1][3] * v[2][2] + v[1][1] * v[0][2] * v[2][3] -
v[1][1] * v[0][3] * v[2][2] - v[2][1] * v[0][2] * v[1][3] + v[2][1] * v[0][3] * v[1][2];
inv(1, 3) = v[0][0] * v[1][2] * v[2][3] - v[0][0] * v[1][3] * v[2][2] - v[1][0] * v[0][2] * v[2][3] +
v[1][0] * v[0][3] * v[2][2] + v[2][0] * v[0][2] * v[1][3] - v[2][0] * v[0][3] * v[1][2];
inv(2, 3) = -v[0][0] * v[1][1] * v[2][3] + v[0][0] * v[1][3] * v[2][1] + v[1][0] * v[0][1] * v[2][3] -
v[1][0] * v[0][3] * v[2][1] - v[2][0] * v[0][1] * v[1][3] + v[2][0] * v[0][3] * v[1][1];
return inv / det;
}
AffineMatrix inverse() const {
Optional<AffineMatrix> inv = tryInverse();
SPH_ASSERT(inv);
return inv.value();
}
bool isOrthogonal() const {
for (Size i = 0; i < 3; ++i) {
for (Size j = 0; j < 3; ++j) {
const Float x = dot(v[i], v[j]);
if (!almostEqual(x, i == j ? 1._f : 0._f, 1.e-6_f)) {
return false;
}
}
}
return true;
}
bool isIsotropic() const {
return v[0][0] == v[1][1] && v[0][0] == v[2][2] && v[0][1] == 0._f && v[0][2] == 0._f &&
v[1][2] == 0._f;
}
static AffineMatrix null() {
return AffineMatrix(Vector(0._f), Vector(0._f), Vector(0._f));
}
static AffineMatrix identity() {
return AffineMatrix(Vector(1._f, 0._f, 0._f), Vector(0._f, 1._f, 0._f), Vector(0._f, 0._f, 1._f));
}
static AffineMatrix scale(const Vector& scaling) {
return AffineMatrix(
Vector(scaling[X], 0._f, 0._f), Vector(0._f, scaling[Y], 0._f), Vector(0._f, 0._f, scaling[Z]));
}
static AffineMatrix rotateX(const Float angle) {
const Float c = cos(angle);
const Float s = sin(angle);
return AffineMatrix(Vector(1._f, 0._f, 0._f), Vector(0._f, c, -s), Vector(0._f, s, c));
}
static AffineMatrix rotateY(const Float angle) {
const Float c = cos(angle);
const Float s = sin(angle);
return AffineMatrix(Vector(c, 0._f, s), Vector(0._f, 1._f, 0._f), Vector(-s, 0._f, c));
}
static AffineMatrix rotateZ(const Float angle) {
const Float c = cos(angle);
const Float s = sin(angle);
return AffineMatrix(Vector(c, -s, 0._f), Vector(s, c, 0._f), Vector(0._f, 0._f, 1._f));
}
static AffineMatrix rotateAxis(const Vector& axis, const Float angle) {
SPH_ASSERT(almostEqual(getSqrLength(axis), 1._f), getSqrLength(axis));
const Float u = axis[0];
const Float v = axis[1];
const Float w = axis[2];
const Float s = sin(angle);
const Float c = cos(angle);
return {
Vector(u * u + (v * v + w * w) * c, u * v * (1 - c) - w * s, u * w * (1 - c) + v * s),
Vector(u * v * (1 - c) + w * s, v * v + (u * u + w * w) * c, v * w * (1 - c) - u * s),
Vector(u * w * (1 - c) - v * s, v * w * (1 - c) + u * s, w * w + (u * u + v * v) * c),
};
}
static AffineMatrix crossProductOperator(const Vector& a) {
return {
Vector(0._f, -a[Z], a[Y]),
Vector(a[Z], 0._f, -a[X]),
Vector(-a[Y], a[X], 0._f),
};
}
INLINE AffineMatrix operator+(const AffineMatrix& other) const {
return AffineMatrix(v[0] + other.v[0], v[1] + other.v[1], v[2] + other.v[2]);
}
INLINE AffineMatrix operator-(const AffineMatrix& other) const {
return AffineMatrix(v[0] - other.v[0], v[1] - other.v[1], v[2] - other.v[2]);
}
/// Matrix multiplication
INLINE AffineMatrix operator*(const AffineMatrix& other) const {
AffineMatrix result = AffineMatrix::identity();
for (Size i = 0; i < 3; ++i) {
for (Size j = 0; j < 3; ++j) {
result(i, j) = dot(this->row(i), other.column(j));
}
}
// add translation part
Vector t(0._f);
const Vector lhs = this->translation();
const Vector rhs = other.translation();
for (Size i = 0; i < 3; ++i) {
t[i] = dot(this->row(i), rhs) + lhs[i];
}
result.translate(t);
return result;
}
INLINE Vector operator*(const Vector& u) const {
return Vector(dot(v[0], u) + v[0][3], dot(v[1], u) + v[1][3], dot(v[2], u) + v[2][3]);
}
INLINE friend AffineMatrix operator*(const AffineMatrix& t, const Float v) {
return AffineMatrix(t.row(0) * v, t.row(1) * v, t.row(2) * v);
}
INLINE friend AffineMatrix operator*(const Float v, const AffineMatrix& t) {
return t * v;
}
INLINE friend AffineMatrix operator/(const AffineMatrix& t, const Float v) {
SPH_ASSERT(v != 0._f);
return AffineMatrix(t.row(0) / v, t.row(1) / v, t.row(2) / v);
}
INLINE AffineMatrix& operator+=(const AffineMatrix& other) {
v[0] += other.v[0];
v[1] += other.v[1];
v[2] += other.v[2];
return *this;
}
INLINE AffineMatrix& operator-=(const AffineMatrix& other) {
v[0] -= other.v[0];
v[1] -= other.v[1];
v[2] -= other.v[2];
return *this;
}
/// \todo test
INLINE AffineMatrix& operator*=(const Float value) {
v[0] *= value;
v[1] *= value;
v[2] *= value;
return *this;
}
INLINE AffineMatrix& operator/=(const Float value) {
SPH_ASSERT(value != 0._f);
v[0] /= value;
v[1] /= value;
v[2] /= value;
return *this;
}
INLINE bool operator==(const AffineMatrix& other) const {
// vectors check only first 3 components, can be optimized
return v[0] == other.v[0] && v[0][3] == other.v[0][3] && //
v[1] == other.v[1] && v[1][3] == other.v[1][3] && //
v[2] == other.v[2] && v[2][3] == other.v[2][3];
}
INLINE bool operator!=(const AffineMatrix& other) const {
return !(*this == other);
}
friend std::ostream& operator<<(std::ostream& stream, const AffineMatrix& t) {
stream << std::setprecision(PRECISION);
for (Size i = 0; i < 3; ++i) {
for (Size j = 0; j < 4; ++j) {
stream << std::setw(20) << t(i, j);
}
stream << std::endl;
}
return stream;
}
};
INLINE bool almostEqual(const AffineMatrix& m1, const AffineMatrix& m2, const Float eps = EPS) {
for (Size i = 0; i < 4; ++i) {
if (!almostEqual(m1.column(i), m2.column(i), eps)) {
return false;
}
}
return true;
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/io/Path.h
|
#pragma once
/// \file Path.h
/// \brief Object representing a path on a filesystem, similar to std::filesystem::path in c++17
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/Assert.h"
#include <unistd.h>
NAMESPACE_SPH_BEGIN
/// \brief Object representing a path on a filesystem
///
/// Can represent both directory and file paths. Object does not check existence or accesibility of the path
/// in any way, only syntactic aspects of the path are considered.
class Path {
private:
std::string path;
static constexpr char SEPARATOR = '/';
public:
/// Constructs an empty path
Path() = default;
/// Constructs a path from string
explicit Path(const std::string& path);
/// \defgroup queries Path queries
/// Checks if the path is empty
bool empty() const;
/// Checks if the file is hidden, i.e. starts with a dot (makes only sense on Unit based systems).
bool isHidden() const;
/// Checks if the path is absolute.
/// \todo generalize, currently only checks for path starting with '/'
bool isAbsolute() const;
/// Checks if the path is relative. Empty path is not considered relative.
bool isRelative() const;
/// Checks if the object holds root path.
bool isRoot() const;
/// Checks if the file has an extension.
bool hasExtension() const;
/// \defgroup parts Parts of the path
/// Returns the parent directory. If the path is empty or root, return empty path.
Path parentPath() const;
/// \brief Returns the filename of the path.
///
/// This is an empty path for directories. The file name includes the extension, if present.
Path fileName() const;
/// \brief Returns the extension of the filename.
///
/// This is an empty path for directories or for files without extensions. If the file has more than one
/// extension, returns only the last one.
/// Example:
/// /usr/lib -> ""
/// file.txt -> "txt"
/// archive.tar.gz -> "gz"
/// .gitignore -> ""
Path extension() const;
/// \defgroup observers Format observers
/// Returns the native version of the path
std::string native() const;
/// \defgroup modifiers Path modifiers
/// \brief Changes the extension of the file.
///
/// If the file has no extension, adds the given extension. For files with more than one extensions
/// (.tar.gz, etc.), removes all extensions and adds the new one. If the new extension is empty, it
/// behaves as removeExtension function.
/// \return Reference to itself, allowing to chain function calls
Path& replaceExtension(const std::string& newExtension);
/// \brief Removes the extension from the path.
///
/// If the path has no extension, the function does nothing.
Path& removeExtension();
/// \brief Removes . and .. directories from the path
Path& removeSpecialDirs();
/// \brief Turns the path into an absolute path.
///
/// If the path already is absolute, function does nothing.
Path& makeAbsolute();
/// \brief Turns the path into a relative path.
///
/// If the path already is relative, function does nothing.
Path& makeRelative();
/// \defgroup static Static functions
/// Returns the current working directory, or empty path if the function failed.
static Path currentPath();
/// \defgroup operators Operators
/// Appends two paths together.
Path operator/(const Path& other) const;
/// Appends another path to this one.
Path& operator/=(const Path& other);
/// \brief Checks if two objects represent the same path.
///
/// Note that this does not check for the actual file, so relative and absolute path to the same file are
/// considered different, it ignores symlinks etc.
bool operator==(const Path& other) const;
/// \brief Checks if two objects represent different paths.
bool operator!=(const Path& other) const;
/// \brief Does lexicographical comparison of two paths.
///
/// Mainly needed for using Path in associative containers.
bool operator<(const Path& other) const;
/// Prints the path into the stream
friend std::ostream& operator<<(std::ostream& stream, const Path& path);
private:
/// Converts all separators into the selected one.
void convert();
/// Finds a given folder in a path.
std::size_t findFolder(const std::string& folder);
};
/// Useful literal returning path from given string.
///
/// Given path cannot be empty.
Path operator"" _path(const char* nativePath, const std::size_t size);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/ArcBall.h
|
#pragma once
/// \file ArcBall.h
/// \brief Helper class for rotating objects by mouse drag
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "gui/objects/Point.h"
#include "math/AffineMatrix.h"
#include "math/Quat.h"
NAMESPACE_SPH_BEGIN
/// \brief Helper object providing rotation matrix based on mouse drag.
///
/// Member function correspond need to be called from mouse events, function \ref drag then returns the
/// rotation matrix. The functions must be called in order: click - drag - drag - ... - drag - stop - click -
/// drag ..., etc. Order is checked by assert.
///
/// Done according to https://gist.github.com/vilmosioo/5318327
class ArcBall {
private:
/// Starting point of the rotation
Vector start{ NAN };
/// Size of the image
Pixel size;
public:
ArcBall() {
size = Pixel(0, 0);
}
explicit ArcBall(const Pixel size)
: size(size) {}
void resize(const Pixel newSize) {
size = newSize;
}
/// \brief Called on mouse click, starting the rotation
void click(const Pixel point) {
start = this->mapToSphere(point);
}
/// \brief Called when mouse moves, rotating the object.
///
/// \param point Current mouse position in image space.
/// \param pivot Center of rotation.
/// \return New rotation matrix of the object
AffineMatrix drag(const Pixel point, const Vector& pivot) {
SPH_ASSERT(isReal(start));
const Vector end = this->mapToSphere(point);
const Vector perp = cross(start, end);
if (getSqrLength(perp) > EPS) {
Quat q;
q[0] = perp[0];
q[1] = perp[1];
q[2] = perp[2];
q[3] = dot(start, end);
AffineMatrix result = AffineMatrix::identity();
result.translate(pivot);
result = result * q.convert();
result.translate(-pivot);
return result;
} else {
return AffineMatrix::identity();
}
}
private:
Vector mapToSphere(const Pixel point) {
// rescale to <-1, 1> and invert y
SPH_ASSERT(size.x > 0 && size.y > 0);
const Vector p(2.f * float(point.x) / size.x - 1.f, 1.f - 2.f * float(point.y) / size.y, 0._f);
const Float lengthSqr = getSqrLength(p);
if (lengthSqr > 1.f) {
const Float length = sqrt(lengthSqr);
return p / length;
} else {
return Vector(p[X], p[Y], sqrt(1.f - lengthSqr));
}
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/wrappers/Outcome.h
|
#pragma once
/// \file Outcome.h
/// \brief Return value of function that may fail, containing either SUCCEES (true) or error message
/// \author <NAME> (sevecek ar <EMAIL>)
/// \date 2016-2021
#include "objects/wrappers/Optional.h"
NAMESPACE_SPH_BEGIN
struct SuccessTag {};
struct FailTag {};
/// \brief Utility functions used within \ref BasicOutcome.
///
/// Has to be specialized for each error type.
template <typename TError>
struct OutcomeTraits {
/// \brief Helper function returning default error message.
INLINE static TError defaultError();
/// \brief Concatenated two error messages.
INLINE static TError concatenate(const TError& e1, const TError& e2);
};
template <>
struct OutcomeTraits<std::string> {
INLINE static std::string defaultError() {
return "ERROR";
}
INLINE static std::string concatenate(const std::string& e1, const std::string& e2) {
return e1 + " AND " + e2;
}
};
/// \brief Expected-like class that does not contain any value.
///
/// Either contains "success" (no error), or error message. The error message must be default-constructible.
template <typename TError>
class BasicOutcome {
private:
Optional<TError> e;
public:
/// \brief Constructs object with success (no error)
INLINE BasicOutcome(SuccessTag) {}
/// \brief Constructs object with defautl error message.
INLINE BasicOutcome(FailTag)
: e(OutcomeTraits<TError>::defaultError()) {}
/// \brief Constructs object from boolean result.
///
/// If true, reports success, otherwise reports default error message.
INLINE explicit BasicOutcome(const bool value) {
if (!value) {
e.emplace(OutcomeTraits<TError>::defaultError());
}
}
/// \brief Constructs object given error message.
template <typename T, typename = std::enable_if_t<std::is_constructible<TError, T>::value>>
INLINE explicit BasicOutcome(T&& error)
: e(std::forward<T>(error)) {}
/// \brief Checks whether the object contains success, i.e. no error is stored.
INLINE bool success() const {
return !e;
}
/// \brief Conversion to bool, returning true if no error is stored.
INLINE explicit operator bool() const {
return success();
}
/// \brief Inversion operator
INLINE bool operator!() const {
return !success();
}
/// \brief Returns the error message.
///
/// If the object contains success (no error), asserts.
INLINE const TError& error() const {
SPH_ASSERT(!success());
return e.value();
}
/// \brief Compares two outcomes.
///
/// Outcomes are only considered equal if both are successful or both contain equal error message.
bool operator==(const BasicOutcome& other) const {
return (!e && !other.e) || (e == other.e);
}
/// \brief Prints "success" or error message into the output stream.
friend std::ostream& operator<<(std::ostream& stream, const BasicOutcome& outcome) {
if (outcome) {
stream << "success";
} else {
stream << outcome.error();
}
return stream;
}
/// \brief Logical 'or' operator, returning SUCCESS if either of the values is a SUCCESS.
///
/// If both values contain an error message, they are concatenated.
friend BasicOutcome operator||(const BasicOutcome& o1, const BasicOutcome& o2) {
if (!o1 && !o2) {
return BasicOutcome(OutcomeTraits<TError>::concatenate(o1.error(), o2.error()));
}
return SuccessTag{};
}
/// \brief Logical 'and' operator, returning SUCCESS if both values are SUCCESS.
///
/// Returns the error message if one of the values contains an error message.
/// If both values contain an error message, they are concatenated.
friend BasicOutcome operator&&(const BasicOutcome& o1, const BasicOutcome& o2) {
if (!o1 && !o2) {
return BasicOutcome(OutcomeTraits<TError>::concatenate(o1.error(), o2.error()));
} else if (!o1) {
return BasicOutcome(o1.error());
} else if (!o2) {
return BasicOutcome(o2.error());
} else {
return SuccessTag{};
}
}
};
/// Alias for string error message
using Outcome = BasicOutcome<std::string>;
/// Global constant for successful outcome
const SuccessTag SUCCESS;
namespace Detail {
INLINE void printArgs(std::stringstream&) {}
template <typename T0, typename... TArgs>
INLINE void printArgs(std::stringstream& ss, T0&& t0, TArgs&&... args) {
ss << t0;
printArgs(ss, std::forward<TArgs>(args)...);
}
} // namespace Detail
/// \brief Constructs failed object with error message.
///
/// Error message is constructed by converting arguments to string and concatenating them.
template <typename... TArgs>
INLINE Outcome makeFailed(TArgs&&... args) {
std::stringstream ss;
Detail::printArgs(ss, std::forward<TArgs>(args)...);
SPH_ASSERT(!ss.str().empty());
return Outcome(ss.str());
}
/// \brief Constructs outcome object given the condition.
///
/// If condition equals false, print error message using argument list.
template <typename... TArgs>
INLINE Outcome makeOutcome(const bool condition, TArgs&&... args) {
if (condition) {
return SUCCESS;
} else {
std::stringstream ss;
Detail::printArgs(ss, std::forward<TArgs>(args)...);
SPH_ASSERT(!ss.str().empty());
return Outcome(ss.str());
}
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/sph/equations/Accumulated.h
|
<filename>core/sph/equations/Accumulated.h
#pragma once
/// \file Accumulated.h
/// \brief Buffer storing quantity values accumulated by summing over particle pairs
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/ForwardDecl.h"
#include "objects/containers/Array.h"
#include "objects/geometry/TracelessTensor.h"
#include "objects/wrappers/Variant.h"
#include "quantities/QuantityIds.h"
NAMESPACE_SPH_BEGIN
enum class OrderEnum;
enum class BufferSource {
/// Only a single derivative accumulates to this buffer
UNIQUE,
/// Multiple derivatives may accumulate into the buffer
SHARED,
};
/// \brief Storage for accumulating derivatives.
///
/// Each thread shall own its own Accumulated storage. Each accumulated buffer is associated with a quantity
/// using QuantityId.
class Accumulated {
private:
template <typename... TArgs>
using HolderVariant = Variant<Array<TArgs>...>;
using Buffer = HolderVariant<Size, Float, Vector, TracelessTensor, SymmetricTensor>;
struct Element {
/// ID of accumulated quantity, used to stored the quantity into the storage
QuantityId id;
/// Order, specifying whether we are accumulating values or derivatives
OrderEnum order;
/// Accumulated data
Buffer buffer;
};
Array<Element> buffers;
struct QuantityRecord {
QuantityId id;
bool unique;
};
/// Debug array, holding IDs of all quantities to check for uniqueness.
Array<QuantityRecord> records;
public:
/// \brief Creates a new storage with given ID.
///
/// Should be called once for each thread when the solver is initialized.
/// \param id ID of the accumulated quantity
/// \param order Order of the quantity. Only highest order can be accumulated, this parameter is used to
/// ensure the derivative is used consistently.
/// \param unique Whether this buffer is being accumulated by a single derivative. It has no effect on
/// the simulation, but ensures a consistency of the run (that we don't accumulate two
/// different velocity gradients, for example).
template <typename TValue>
void insert(const QuantityId id, const OrderEnum order, const BufferSource source);
/// \brief Initialize all storages.
///
/// Storages are resized if needed and cleared out of all previously accumulated values.
void initialize(const Size size);
/// \brief Returns the buffer of given quantity and given order.
///
/// \note Accumulated can store only one buffer per quantity, so the order is not neccesary to retrive the
/// buffer, but it is required to check that we are indeed returning the required order of quantity. It
/// also makes the code more readable.
template <typename TValue>
Array<TValue>& getBuffer(const QuantityId id, const OrderEnum order);
/// \brief Sums values of a list of storages.
///
/// Storages must have the same number of buffers and the matching buffers must have the same type and
/// same size.
void sum(ArrayView<Accumulated*> others);
/// \brief Sums values, concurently over different quantities
void sum(IScheduler& scheduler, ArrayView<Accumulated*> others);
/// \brief Stores accumulated values to corresponding quantities.
///
/// The accumulated quantity must already exist in the storage and its order must be at least the order of
/// the accumulated buffer. The accumulated buffer is cleared (filled with zeroes) after storing the
/// values into the storage.
void store(Storage& storage);
Size getBufferCnt() const;
private:
template <typename Type>
Array<Iterator<Type>> getBufferIterators(const QuantityId id, ArrayView<Accumulated*> others);
template <typename Type>
void sumBuffer(Array<Type>& buffer1, const QuantityId id, ArrayView<Accumulated*> others);
template <typename Type>
void sumBuffer(IScheduler& scheduler,
Array<Type>& buffer1,
const QuantityId id,
ArrayView<Accumulated*> others);
bool hasBuffer(const QuantityId id, const OrderEnum order) const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/system/ArgsParser.h
|
#pragma once
#include "io/Logger.h"
#include "objects/Exceptions.h"
#include "objects/containers/FlatMap.h"
#include "objects/wrappers/Function.h"
#include "objects/wrappers/SharedPtr.h"
#include "objects/wrappers/Variant.h"
#include "system/Settings.h"
NAMESPACE_SPH_BEGIN
enum class ArgEnum {
NONE, ///< No value after the argument
BOOL,
INT,
FLOAT,
STRING,
};
/// \brief Exception thrown if the arguments are invalid
class ArgError : public Exception {
public:
explicit ArgError(const std::string& message)
: Exception(message) {}
};
/// \brief Exception thrown when used passes -h or --help parameter.
///
/// The exception message contains the parameter description.
class HelpException : public Exception {
public:
explicit HelpException(const std::string& message)
: Exception(message) {}
};
/// \brief Descriptor of a command-line argument.
struct ArgDesc {
/// Short name, prefixed by single dash (e.g. -h)
std::string shortName;
/// Long name, prefixed by double-dash (e.g. --help)
std::string longName;
/// Type of the parameter
ArgEnum type;
/// Parameter description, printed in help
std::string desc;
/// Generic callback executed when the parameter is parsed
Function<void()> callback = nullptr;
/// \brief Checks if the descriptor matches given argument.
bool matches(const std::string& name) {
return (name == "-" + shortName) || (name == "--" + longName);
}
};
/// \brief Provides functions for parsing command-line arguments.
class ArgParser {
private:
using ArgValue = Variant<int, Float, bool, std::string>;
/// Input argument descriptors
Array<ArgDesc> descs;
/// Parsed argument values
FlatMap<std::string, ArgValue> params;
public:
/// \brief Creates a parser, given a set of parameter descriptors.
///
/// The "help" parameter (-h or --help) is automatically added into the set. It can be used to print the
/// program help, using data provided in the descriptors.
explicit ArgParser(ArrayView<const ArgDesc> args);
/// \brief Parses the input arguments and stored the parsed values.
///
/// Parsed values can be later queried using \ref getArg or \ref forEach functions. Previous values are
/// removed.
/// \throw ArgError if the input is not valid.
void parse(const int argc, char** argv);
/// \brief Prints the help information into given logger.
///
/// This is automatically called when \ref parse is called with argument -h or --help.
void printHelp(ILogger& logger);
/// \brief Returns the value of an argument, given its short name (without the dash).
///
/// \throw ArgError if the argument was not been parsed or it has different type.
template <typename TValue>
TValue getArg(const std::string& name) const {
throwIfUnknownArg(name);
Optional<const ArgValue&> value = params.tryGet(name);
if (value && value->has<TValue>()) {
return value->get<TValue>();
} else {
const std::string message = value ? "Invalid type of argument -" : "Missing argument -" + name;
throw ArgError(message);
}
}
/// \brief Returns the value of an argument or NOTHING if the argument was not parsed.
///
/// \throw ArgError if the name does not match any argument descriptor or it has different type.
template <typename TValue>
Optional<TValue> tryGetArg(const std::string& name) const {
throwIfUnknownArg(name);
Optional<const ArgValue&> value = params.tryGet(name);
if (value) {
if (!value->has<TValue>()) {
throw ArgError("Invalid type");
}
return value->get<TValue>();
} else {
return NOTHING;
}
}
/// \brief Stores the value of given argument into an instance of \ref Settings.
///
/// If the value was not parsed, no value is stored and function returns false. Otherwise, true is
/// returned.
/// \param settings \ref Settings object where the parsed value is stored (if present).
/// \param name Short name identifying the argument.
/// \param idx Index of the target entry in \ref Settings.
/// \param conv Generic value convertor, applied on value saved to \ref Settings. Applied only on float
/// arguments.
/// \throw ArgError if the name does not match any argument descriptor.
template <typename TEnum, typename TConvertor>
bool tryStore(Settings<TEnum>& settings, const std::string& name, const TEnum idx, TConvertor&& conv) {
throwIfUnknownArg(name);
auto value = params.tryGet(name);
if (value) {
// special handling of floats - convert units
if (value->has<Float>()) {
settings.set(idx, conv(value->get<Float>()));
} else {
forValue(value.value(), [&settings, idx](auto& value) { settings.set(idx, value); });
}
return true;
}
return false;
}
/// \brief Stores the value of given argument into an instance of \ref Settings.
///
/// Overload without value convertor.
template <typename TEnum>
bool tryStore(Settings<TEnum>& settings, const std::string& name, const TEnum idx) {
return tryStore(settings, name, idx, [](Float value) { return value; });
}
/// \brief Enumerates all parsed arguments and executes a generic functor with parsed values.
///
/// Functor must be either generic lambda, or it must overload operator() for each parsed type, as listed
/// in enum \ref ArgEnum. The operator must have signature void(std::string, Type). The arguments are
/// identified using its short name, without the dash.
template <typename TFunctor>
void forEach(const TFunctor& functor) {
for (auto& e : params) {
forValue(e.value(), [&e, &functor](auto& value) { functor(e.key(), value); });
}
}
/// \brief Returns the number of parsed arguments.
Size size() const {
return params.size();
}
/// \brief Returns true if no arguments have been parsed.
bool empty() const {
return params.empty();
}
private:
void parseValuelessArg(const ArgDesc& desc);
void parseValueArg(const ArgDesc& desc, const std::string& value);
template <typename TValue>
void insertArg(const std::string& name, const std::string& textValue);
void throwIfUnknownArg(const std::string& name) const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/gravity/Collision.h
|
<filename>core/gravity/Collision.h
#pragma once
/// \file Collision.h
/// \brief Collision handling
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/containers/FlatSet.h"
#include "physics/Functions.h"
#include "quantities/Storage.h"
#include "system/Settings.h"
NAMESPACE_SPH_BEGIN
enum class CollisionResult {
NONE, ///< No collision took place
BOUNCE, ///< Bounce/scatter collision, no merging and no fragmentation
FRAGMENTATION, ///< Target was disrupted, creating largest remnant and fragments
MERGER, ///< Particles merged together
EVAPORATION, ///< No asteroids survived the collision
};
/// \brief Abstraction of collision outcome.
///
/// Collision can arbitrarily change the number of particles in the storage. It can one or both colliding
/// particles ("merger" or "evaporation"), or it can even add more particles into the storage
/// ("fragmentation"). It is necessary to update all pointers and array views if collision handler returns
/// true, or keep pointers to the arrays (at a cost of double indirection).
class ICollisionHandler : public Polymorphic {
public:
virtual void initialize(Storage& storage) = 0;
/// \brief Computes the outcome of collision between i-th and j-th particle
///
/// It is guaranteed that this function is called after \ref initialize has been called (at least once)
/// and that the storage object passed to \ref initialize is valid, so it is allowed (and recommended) to
/// storage a pointer to the storage.
/// \param i,j Indices of particles in the storage.
/// \param toRemove Indices of particles to be removed from the storage. May already contain some indices,
/// collision handler should only add new indices and it shall not clear the storage.
/// \return True if the collision took place, false to reject the collision.
///
/// \todo Needs to be generatelized for fragmentation handlers. Currently the function CANNOT change the
/// number of particles as it would invalidate arrayviews and we would lost the track of i-th and j-th
/// particle (which we need for decreasing movement time).
virtual CollisionResult collide(const Size i, const Size j, FlatSet<Size>& toRemove) = 0;
};
/// \brief Handles overlaps of particles.
///
/// Interface similar to \ref ICollisionHandler, but unlike collision result, overlaps has no result -
/// particles either overlap or not. Note that overlaps are processed before collisions and if two particles
/// do not overlap (\ref overlaps returns false), the check for collisions is skipped.
class IOverlapHandler : public Polymorphic {
public:
virtual void initialize(Storage& storage) = 0;
/// \brief Returns true if two particles overlaps
///
/// If so, the overlap is then resolved using \ref handle.
/// \param i,j Indices of particles in the storage.
virtual bool overlaps(const Size i, const Size j) const = 0;
/// \brief Handles the overlap of two particles.
///
/// When called, the particles must actually overlap (\ref overlaps must return true). This is checked by
/// assert.
virtual void handle(const Size i, const Size j, FlatSet<Size>& toRemove) = 0;
};
/// \brief Helper function sorting two values
template <typename T>
Tuple<T, T> minMax(const T& t1, const T& t2) {
if (t1 < t2) {
return { t1, t2 };
} else {
return { t2, t1 };
}
}
template <typename T>
INLINE T weightedAverage(const T& v1, const Float w1, const T& v2, const Float w2) {
SPH_ASSERT(w1 + w2 > 0._f, w1, w2);
return (v1 * w1 + v2 * w2) / (w1 + w2);
}
INLINE bool areParticlesBound(const Float m_sum, const Float h_sum, const Vector& dv, const Float limit) {
const Float vEscSqr = 2._f * Constants::gravity * m_sum / h_sum;
const Float vRelSqr = getSqrLength(dv);
return vRelSqr * limit < vEscSqr;
}
// ----------------------------------------------------------------------------------------------------------
// Collision Handlers
// ----------------------------------------------------------------------------------------------------------
/// \brief Helper handler always returning CollisionResult::NONE.
///
/// Cannot be used directly as collision always have to return a valid result (not NONE), but it can be used
/// for testing purposes or in composite handlers (such as \ref FallbackHandler).
class NullCollisionHandler : public ICollisionHandler {
public:
virtual void initialize(Storage& UNUSED(storage)) override {}
virtual CollisionResult collide(const Size UNUSED(i),
const Size UNUSED(j),
FlatSet<Size>& UNUSED(toRemove)) override {
return CollisionResult::NONE;
}
};
/// \brief Handler merging particles into a single, larger particles.
///
/// The volume of the merger is the sum of volumes of colliders. Particles are only merged if the relative
/// velocity of collision is lower than the escape velocity and if the angular frequency of the would-be
/// merger is lower than the break-up frequency; if not, CollisionResult::NONE is returned.
class MergingCollisionHandler : public ICollisionHandler {
private:
ArrayView<Vector> r, v;
ArrayView<Float> m;
ArrayView<Vector> L;
ArrayView<Vector> omega;
ArrayView<SymmetricTensor> I;
ArrayView<Tensor> E;
/// \todo filling factor, collapse of particles in contact must result in sphere of same volume!
Float bounceLimit;
Float rotationLimit;
public:
explicit MergingCollisionHandler(const RunSettings& settings) {
bounceLimit = settings.get<Float>(RunSettingsId::COLLISION_BOUNCE_MERGE_LIMIT);
rotationLimit = settings.get<Float>(RunSettingsId::COLLISION_ROTATION_MERGE_LIMIT);
}
explicit MergingCollisionHandler(const Float bounceLimit, const Float rotationLimit)
: bounceLimit(bounceLimit)
, rotationLimit(rotationLimit) {}
virtual void initialize(Storage& storage) override {
ArrayView<Vector> dv;
tie(r, v, dv) = storage.getAll<Vector>(QuantityId::POSITION);
m = storage.getValue<Float>(QuantityId::MASS);
omega = storage.getValue<Vector>(QuantityId::ANGULAR_FREQUENCY);
if (storage.has(QuantityId::MOMENT_OF_INERTIA)) {
I = storage.getValue<SymmetricTensor>(QuantityId::MOMENT_OF_INERTIA);
E = storage.getValue<Tensor>(QuantityId::LOCAL_FRAME);
L = storage.getValue<Vector>(QuantityId::ANGULAR_MOMENTUM);
}
}
virtual CollisionResult collide(const Size i, const Size j, FlatSet<Size>& toRemove) override {
// set radius of the merger so that the volume is conserved
const Float h_merger = root<3>(pow<3>(r[i][H]) + pow<3>(r[j][H]));
// conserve total mass
const Float m_merger = m[i] + m[j];
// merge so that the center of mass remains unchanged
const Vector r_merger = weightedAverage(r[i], m[i], r[j], m[j]);
// converve momentum
const Vector v_merger = weightedAverage(v[i], m[i], v[j], m[j]);
Vector omega_merger;
SymmetricTensor I_merger;
Vector L_merger;
Tensor E_merger = Tensor::identity();
// Never modify particle values below UNTIL we know the collision is accepted; save the preliminary
// values to _merger variables!
if (I) {
// So far this is just an experimental branch, not intended to be used for "serious" simulations.
// This assert is just a check that it does not get enabled by accident.
SPH_ASSERT(Assert::isTest);
// compute inertia tensors in inertial frame
const SymmetricTensor I1 = transform(I[i], convert<AffineMatrix>(E[i]));
const SymmetricTensor I2 = transform(I[j], convert<AffineMatrix>(E[j]));
// sum up the inertia tensors, but first move them to new origin
I_merger = Rigid::parallelAxisTheorem(I1, m[i], r_merger - r[i]) +
Rigid::parallelAxisTheorem(I2, m[j], r_merger - r[j]);
// compute the total angular momentum - has to be conserved
L_merger = m[i] * cross(r[i] - r_merger, v[i] - v_merger) + //
m[j] * cross(r[j] - r_merger, v[j] - v_merger) + //
L[i] + L[j];
// L = I*omega => omega = I^-1 * L
omega_merger = I_merger.inverse() * L_merger;
// compute the new local frame of the merger and inertia tensor in this frame
Eigen eigen = eigenDecomposition(I_merger);
I_merger = SymmetricTensor(eigen.values, Vector(0._f));
SPH_ASSERT(isReal(I_merger));
E_merger = convert<Tensor>(eigen.vectors);
SPH_ASSERT(isReal(E_merger));
SPH_ASSERT(isReal(L_merger) && isReal(omega_merger), L_merger, omega_merger);
/// \todo remove, we have unit tests for this
SPH_ASSERT(almostEqual(getSqrLength(E_merger.row(0)), 1._f, 1.e-6_f));
SPH_ASSERT(almostEqual(getSqrLength(E_merger.row(1)), 1._f, 1.e-6_f));
SPH_ASSERT(almostEqual(getSqrLength(E_merger.row(2)), 1._f, 1.e-6_f));
} else {
L_merger = m[i] * cross(r[i] - r_merger, v[i] - v_merger) + //
m[j] * cross(r[j] - r_merger, v[j] - v_merger) + //
Rigid::sphereInertia(m[i], r[i][H]) * omega[i] + //
Rigid::sphereInertia(m[j], r[j][H]) * omega[j];
omega_merger = Rigid::sphereInertia(m_merger, h_merger).inverse() * L_merger;
}
if (!this->acceptMerge(i, j, h_merger, omega_merger)) {
return CollisionResult::NONE;
}
// NOW we can save the values
m[i] = m_merger;
r[i] = r_merger;
r[i][H] = h_merger;
v[i] = v_merger;
v[i][H] = 0._f;
omega[i] = omega_merger;
if (I) {
I[i] = I_merger;
L[i] = L_merger;
E[i] = E_merger;
}
SPH_ASSERT(isReal(v[i]) && isReal(r[i]));
toRemove.insert(j);
return CollisionResult::MERGER;
}
private:
/// \brief Checks if the particles should be merged
///
/// We merge particles if their relative velocity is lower than the escape velocity AND if the angular
/// velocity of the merger is lower than the breakup limit.
/// \param i, j Particle indices
/// \param h Radius of the merger
/// \param omega Angular velocity of the merger
INLINE bool acceptMerge(const Size i, const Size j, const Float h, const Vector& omega) const {
if (!areParticlesBound(m[i] + m[j], r[i][H] + r[j][H], v[i] - v[j], bounceLimit)) {
// moving too fast, reject the merge
/// \todo shouldn't we check velocities AFTER the bounce?
return false;
}
const Float omegaCritSqr = Constants::gravity * (m[i] + m[j]) / pow<3>(h);
const Float omegaSqr = getSqrLength(omega);
if (omegaSqr * rotationLimit > omegaCritSqr) {
// rotates too fast, reject the merge
return false;
}
return true;
}
};
/// \brief Handler for bounce on collision.
///
/// No merging takes place. Particles lose fraction of momentum, given by coefficients of restitution.
/// \todo if restitution.t < 1, we should spin up the particles to conserve the angular momentum!!
class ElasticBounceHandler : public ICollisionHandler {
protected:
ArrayView<Vector> r, v;
ArrayView<Float> m;
/// Coefficients of restitution
struct {
/// Normal;
Float n;
/// Tangential
Float t;
} restitution;
public:
explicit ElasticBounceHandler(const RunSettings& settings) {
restitution.n = settings.get<Float>(RunSettingsId::COLLISION_RESTITUTION_NORMAL);
restitution.t = settings.get<Float>(RunSettingsId::COLLISION_RESTITUTION_TANGENT);
}
ElasticBounceHandler(const Float n, const Float t) {
restitution.n = n;
restitution.t = t;
}
virtual void initialize(Storage& storage) override {
ArrayView<Vector> dv;
tie(r, v, dv) = storage.getAll<Vector>(QuantityId::POSITION);
m = storage.getValue<Float>(QuantityId::MASS);
}
virtual CollisionResult collide(const Size i, const Size j, FlatSet<Size>& UNUSED(toRemove)) override {
const Vector dr = getNormalized(r[i] - r[j]);
const Vector v_com = weightedAverage(v[i], m[i], v[j], m[j]);
v[i] = this->reflect(v[i], v_com, -dr);
v[j] = this->reflect(v[j], v_com, dr);
// no change of radius
v[i][H] = 0._f;
v[j][H] = 0._f;
SPH_ASSERT(isReal(v[i]) && isReal(v[j]));
return CollisionResult::BOUNCE;
}
private:
INLINE Vector reflect(const Vector& v, const Vector& v_com, const Vector& dir) {
SPH_ASSERT(almostEqual(getSqrLength(dir), 1._f), dir);
const Vector v_rel = v - v_com;
const Float proj = dot(v_rel, dir);
const Vector v_t = v_rel - proj * dir;
const Vector v_n = proj * dir;
// flip the orientation of normal component (bounce) and apply coefficients of restitution
return restitution.t * v_t - restitution.n * v_n + v_com;
}
};
/// \brief Composite handler, choosing another collision handler if the primary handler rejects the
/// collision by returning \ref CollisionResult::NONE.
template <typename TPrimary, typename TFallback>
class FallbackHandler : public ICollisionHandler {
private:
TPrimary primary;
TFallback fallback;
public:
FallbackHandler(const RunSettings& settings)
: primary(settings)
, fallback(settings) {}
virtual void initialize(Storage& storage) override {
primary.initialize(storage);
fallback.initialize(storage);
}
virtual CollisionResult collide(const Size i, const Size j, FlatSet<Size>& toRemove) override {
CollisionResult result = primary.collide(i, j, toRemove);
if (result == CollisionResult::NONE) {
return fallback.collide(i, j, toRemove);
} else {
return result;
}
}
};
class FragmentationHandler : public ICollisionHandler {
public:
// ParametricRelations, directionality of fragments
virtual CollisionResult collide(const Size i, const Size j, FlatSet<Size>& UNUSED(toRemove)) override {
(void)i;
(void)j;
/// \todo
NOT_IMPLEMENTED;
return CollisionResult::FRAGMENTATION;
}
};
// ----------------------------------------------------------------------------------------------------------
// Overlap Handlers
// ----------------------------------------------------------------------------------------------------------
/// \brief Handler simply ignoring overlaps.
class NullOverlapHandler : public IOverlapHandler {
public:
virtual void initialize(Storage& UNUSED(storage)) override {}
virtual bool overlaps(const Size UNUSED(i), const Size UNUSED(j)) const override {
return false;
}
virtual void handle(const Size UNUSED(i),
const Size UNUSED(j),
FlatSet<Size>& UNUSED(toRemove)) override {}
};
/// \brief Handler unconditionally merging the overlapping particles.
///
/// Behaves similarly to collision handler \ref MergingCollisionHandler, but there is no check for relative
/// velocities of particles nor angular frequency of the merger - particles are always merged.
class MergeOverlapHandler : public IOverlapHandler {
private:
MergingCollisionHandler handler;
public:
MergeOverlapHandler()
: handler(0._f, 0._f) {}
virtual void initialize(Storage& storage) override {
handler.initialize(storage);
}
virtual bool overlaps(const Size UNUSED(i), const Size UNUSED(j)) const override {
return true;
}
virtual void handle(const Size i, const Size j, FlatSet<Size>& toRemove) override {
handler.collide(i, j, toRemove);
}
};
/// \brief Handler displacing the overlapping particles so that they just touch.
///
/// Particles are moved alongside their relative position vector. They must not overlap perfectly, as in such
/// a case the displacement direction is undefined. The handler is templated, allowing to specify a followup
/// handler that is applied after the particles have been moved. This can be another \ref IOverlapHandler, but
/// also a \ref ICollisionHandler, as the two interfaces are similar.
template <typename TFollowupHandler>
class RepelHandler : public IOverlapHandler {
private:
TFollowupHandler handler;
ArrayView<Vector> r, v;
ArrayView<Float> m;
public:
explicit RepelHandler(const RunSettings& settings)
: handler(settings) {}
virtual void initialize(Storage& storage) override {
ArrayView<Vector> dv;
tie(r, v, dv) = storage.getAll<Vector>(QuantityId::POSITION);
m = storage.getValue<Float>(QuantityId::MASS);
handler.initialize(storage);
}
virtual bool overlaps(const Size UNUSED(i), const Size UNUSED(j)) const override {
// this function is called only if the spheres intersect, which is the only condition for this handler
return true;
}
virtual void handle(const Size i, const Size j, FlatSet<Size>& toRemove) override {
Vector dir;
Float dist;
tieToTuple(dir, dist) = getNormalizedWithLength(r[i] - r[j]);
dir[H] = 0._f; // don't mess up radii
// can be only used for overlapping particles
SPH_ASSERT(dist < r[i][H] + r[j][H], dist, r[i][H] + r[i][H]);
const Float x1 = (r[i][H] + r[j][H] - dist) / (1._f + m[i] / m[j]);
const Float x2 = m[i] / m[j] * x1;
r[i] += dir * x1;
r[j] -= dir * x2;
SPH_ASSERT(almostEqual(getSqrLength(r[i] - r[j]), sqr(r[i][H] + r[j][H])),
getSqrLength(r[i] - r[j]),
sqr(r[i][H] + r[j][H]));
SPH_ASSERT(isReal(v[i]) && isReal(v[j]));
SPH_ASSERT(isReal(r[i]) && isReal(r[j]));
// Now when the two particles are touching, handle the collision using the followup handler.
handler.collide(i, j, toRemove);
}
};
/// \brief Overlap handler performing a bounce of particles.
///
/// Particles only bounce if their centers are moving towards each other. This way we prevent particles
/// bouncing infinitely - after the first bounce, the particle move away from each other and they are not
/// classified as overlaps by the handler.
class InternalBounceHandler : public IOverlapHandler {
private:
ElasticBounceHandler handler;
ArrayView<Vector> r, v;
public:
explicit InternalBounceHandler(const RunSettings& settings)
: handler(settings) {
// this handler allows overlaps of particles, so it should never be used with point particles, as we
// could potentially get infinite accelerations
SPH_ASSERT(settings.get<GravityKernelEnum>(RunSettingsId::GRAVITY_KERNEL) !=
GravityKernelEnum::POINT_PARTICLES);
}
virtual void initialize(Storage& storage) override {
ArrayView<Vector> dv;
tie(r, v, dv) = storage.getAll<Vector>(QuantityId::POSITION);
handler.initialize(storage);
}
virtual bool overlaps(const Size i, const Size j) const override {
// overlap needs to be handled only if the particles are moving towards each other
const Vector dr = r[i] - r[j];
const Vector dv = v[i] - v[j];
return dot(dr, dv) < 0._f;
}
virtual void handle(const Size i, const Size j, FlatSet<Size>& toRemove) override {
handler.collide(i, j, toRemove);
}
};
/// \brief Handler merging overlapping particles if their relative velocity is lower than the escape velocity.
///
/// If the relative veloity is too high, the particles are allowed to simply pass each other - this situation
/// is not classified as overlap.
class MergeBoundHandler : public IOverlapHandler {
private:
MergingCollisionHandler handler;
public:
ArrayView<Vector> r, v, omega;
ArrayView<Float> m;
Float bounceLimit;
Float rotationLimit;
public:
explicit MergeBoundHandler(const RunSettings& settings)
: handler(settings) {
bounceLimit = settings.get<Float>(RunSettingsId::COLLISION_BOUNCE_MERGE_LIMIT);
rotationLimit = settings.get<Float>(RunSettingsId::COLLISION_ROTATION_MERGE_LIMIT);
}
virtual void initialize(Storage& storage) override {
ArrayView<Vector> dv;
tie(r, v, dv) = storage.getAll<Vector>(QuantityId::POSITION);
omega = storage.getValue<Vector>(QuantityId::ANGULAR_FREQUENCY);
m = storage.getValue<Float>(QuantityId::MASS);
handler.initialize(storage);
}
virtual bool overlaps(const Size i, const Size j) const override {
const Float m_merger = m[i] + m[j];
if (!areParticlesBound(m_merger, r[i][H] + r[j][H], v[i] - v[j], bounceLimit)) {
// moving too fast, reject the merge
/// \todo shouldn't we check velocities AFTER the bounce?
return false;
}
const Float h_merger = root<3>(pow<3>(r[i][H]) + pow<3>(r[j][H]));
const Float omegaCritSqr = Constants::gravity * (m[i] + m[j]) / pow<3>(h_merger);
const Vector r_merger = weightedAverage(r[i], m[i], r[j], m[j]);
const Vector v_merger = weightedAverage(v[i], m[i], v[j], m[j]);
const Vector L_merger = m[i] * cross(r[i] - r_merger, v[i] - v_merger) + //
m[j] * cross(r[j] - r_merger, v[j] - v_merger) + //
Rigid::sphereInertia(m[i], r[i][H]) * omega[i] + //
Rigid::sphereInertia(m[j], r[j][H]) * omega[j];
const Vector omega_merger = Rigid::sphereInertia(m_merger, h_merger).inverse() * L_merger;
const Float omegaSqr = getSqrLength(omega_merger);
if (omegaSqr * rotationLimit > omegaCritSqr) {
// rotates too fast, reject the merge
return false;
}
return true;
}
virtual void handle(const Size i, const Size j, FlatSet<Size>& toRemove) override {
handler.collide(i, j, toRemove);
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/gravity/Moments.h
|
#pragma once
#include "objects/geometry/Multipole.h"
NAMESPACE_SPH_BEGIN
template <Size N>
INLINE void computeGreenGamma(ArrayView<Float> gamma, const Vector dr) {
const Float invDistSqr = 1._f / getSqrLength(dr);
gamma[0] = -sqrt(invDistSqr);
for (Size i = 1; i < N + 2; ++i) {
gamma[i] = -(2._f * i - 1._f) * invDistSqr * gamma[i - 1];
}
}
template <Size M>
struct ComputeTrace;
template <>
struct ComputeTrace<1> {
template <Size N>
INLINE static Multipole<N - 2> make(const Multipole<N>& m) {
static_assert(N >= 2, "invalid parameter");
return makeMultipole<N - 2>(MomentOperators::makeContraction(m));
}
};
template <>
struct ComputeTrace<2> {
template <Size N>
INLINE static Multipole<N - 4> make(const Multipole<N>& m) {
static_assert(N >= 4, "invalid parameter");
return makeMultipole<N - 4>(MomentOperators::makeContraction(MomentOperators::makeContraction(m)));
}
};
/// Computes M-fold trace of given multipole moment
template <Size M, Size N>
Multipole<N - 2 * M> computeTrace(const Multipole<N>& m) {
static_assert(N >= 2 * M, "invalid parameter");
return ComputeTrace<M>::make(m);
}
template <Size N, Size M>
INLINE Float reducedFactor() {
static_assert(N > 0, "Cannot be used for N == 0");
static_assert(2 * N - 2 * M > 0, "invalid parameter");
const SignedSize sign = (isOdd(M) ? -1 : 1);
const Float num = doubleFactorial(2 * N - 2 * M - 1);
const Float denom = factorial(M) * doubleFactorial(2 * N - 1);
const Float factor = sign * num / denom;
return factor;
}
template <Size N>
TracelessMultipole<N> computeReducedMultipole(const Multipole<N>& m);
template <>
inline TracelessMultipole<4> computeReducedMultipole(const Multipole<4>& m) {
// compute traces
const Multipole<4>& T0 = m;
Multipole<2> T1 = computeTrace<1>(m);
Float T2 = computeTrace<2>(m).value();
// compute factors
const Float f0 = reducedFactor<4, 0>();
const Float f1 = reducedFactor<4, 1>();
const Float f2 = reducedFactor<4, 2>();
using namespace MomentOperators;
// sum up the terms
return makeTracelessMultipole<4>(T0 * f0 + makePermutations(Delta<2>{}, T1) * f1 + Delta<4>{} * T2 * f2);
}
template <>
inline TracelessMultipole<3> computeReducedMultipole(const Multipole<3>& m) {
const Multipole<3>& T0 = m;
Multipole<1> T1 = computeTrace<1>(m);
const Float f0 = reducedFactor<3, 0>();
const Float f1 = reducedFactor<3, 1>();
using namespace MomentOperators;
return makeTracelessMultipole<3>(T0 * f0 + makePermutations(Delta<2>{}, T1) * f1);
}
template <>
inline TracelessMultipole<2> computeReducedMultipole(const Multipole<2>& m) {
const Multipole<2>& T0 = m;
Multipole<0> T1 = computeTrace<1>(m);
const Float f0 = reducedFactor<2, 0>();
const Float f1 = reducedFactor<2, 1>();
using namespace MomentOperators;
return makeTracelessMultipole<2>(T0 * f0 + makePermutations(Delta<2>{}, T1) * f1);
}
template <>
inline TracelessMultipole<1> computeReducedMultipole(const Multipole<1>& m) {
const Multipole<1>& T0 = m;
const Float f0 = reducedFactor<1, 0>();
using namespace MomentOperators;
return makeTracelessMultipole<1>(T0 * f0);
}
template <>
inline TracelessMultipole<0> computeReducedMultipole(const Multipole<0>& m) {
return makeTracelessMultipole<0>(m);
}
template <Size M, Size N>
std::enable_if_t<(M < N), TracelessMultipole<M>> computeMultipolePotential(const TracelessMultipole<N>& q,
const Vector& r) {
static_assert(M <= N, "Incorrect parameters");
using namespace MomentOperators;
OuterProduct<N - M> dr{ r };
return makeTracelessMultipole<M>(makeInner<N - M>(dr, q) * (1._f / factorial(N - M)));
}
template <Size M, Size N>
std::enable_if_t<M == N, TracelessMultipole<M>> computeMultipolePotential(const TracelessMultipole<N>& q,
const Vector& UNUSED(r)) {
return q;
}
template <Size M, Size N>
std::enable_if_t<(M > N), TracelessMultipole<M>> computeMultipolePotential(
const TracelessMultipole<N>& UNUSED(q),
const Vector& UNUSED(r)) {
return TracelessMultipole<M>(0._f);
}
namespace Detail {
template <Size N>
INLINE Multipole<N> computeMultipoleImpl(const Vector& dr, const Float m) {
return makeMultipole<N>(MomentOperators::OuterProduct<N>{ dr }) * m;
}
template <>
INLINE Multipole<0> computeMultipoleImpl(const Vector& UNUSED(dr), const Float m) {
return m;
}
} // namespace Detail
template <Size N, typename TSequence>
Multipole<N> computeMultipole(ArrayView<const Vector> r,
ArrayView<const Float> m,
const Vector& r0,
const TSequence& sequence) {
Multipole<N> moments(0._f);
for (Size i : sequence) {
const Vector dr = r[i] - r0;
moments += Detail::computeMultipoleImpl<N>(dr, m[i]);
}
return moments;
}
INLINE TracelessMultipole<1> parallelAxisTheorem(const TracelessMultipole<1>& Qi,
const Float Q,
const Vector& d) {
using namespace MomentOperators;
return makeTracelessMultipole<1>(Qi + OuterProduct<1>{ d } * Q);
}
INLINE TracelessMultipole<2> parallelAxisTheorem(const TracelessMultipole<2>& Qij,
const Float Q,
const Vector& d) {
using namespace MomentOperators;
const Multipole<2> d2 = makeMultipole<2>(OuterProduct<2>{ d });
const TracelessMultipole<2> f2 = computeReducedMultipole(d2);
return makeTracelessMultipole<2>(Qij + f2 * Q);
}
namespace MomentOperators {
struct Term2 {
const TracelessMultipole<2>& Q;
const Vector& d;
template <Size I, Size J, Size K, Size L>
INLINE Float perm() const {
const Delta<2> delta;
return delta.value<I, J>() * Q.value<K, L>() + delta.value<I, K>() * Q.value<J, L>() +
delta.value<J, K>() * Q.value<I, L>();
}
template <Size I, Size J, Size K>
INLINE Float value() const {
return -2._f / 5._f *
(perm<I, J, K, 0>() * d[0] + perm<I, J, K, 1>() * d[1] + perm<I, J, K, 2>() * d[2]);
}
};
struct Term30 {
const TracelessMultipole<3>& Q;
const Vector& d;
template <Size I, Size J, Size K, Size L, Size M>
INLINE Float perm() const {
const Delta<2> delta;
return delta.value<I, J>() * Q.value<K, L, M>() + delta.value<I, K>() * Q.value<J, L, M>() +
delta.value<I, L>() * Q.value<J, K, M>() + delta.value<J, K>() * Q.value<I, L, M>() +
delta.value<J, L>() * Q.value<I, K, M>() + delta.value<K, L>() * Q.value<I, J, M>();
}
template <Size I, Size J, Size K, Size L>
INLINE Float value() const {
return perm<I, J, K, L, 0>() * d[0] + perm<I, J, K, L, 1>() * d[1] + perm<I, J, K, L, 2>() * d[2];
}
};
struct Term31 {
const TracelessMultipole<2>& Q;
const TracelessMultipole<2>& f2;
const static Delta<2> delta1, delta2;
template <Size I, Size J, Size K, Size L, Size M, Size N>
INLINE Float ddq() const {
return delta1.template value<I, J>() * delta2.template value<K, M>() * Q.template value<L, N>();
}
template <Size I, Size J, Size K, Size L, Size M, Size N>
INLINE Float perm() const {
#if 0
return ddq<I, J, K, L, M, N>() + ddq<I, J, L, K, M, N>() + ddq<I, L, J, K, M, N>() +
ddq<I, L, K, J, M, N>() + ddq<I, K, J, L, M, N>() + ddq<I, K, L, J, M, N>() +
ddq<J, K, L, I, M, N>() + ddq<J, K, I, L, M, N>() + ddq<J, L, I, K, M, N>() +
ddq<J, L, K, I, M, N>() + ddq<K, L, I, J, M, N>() + ddq<K, L, J, I, M, N>();
#else
return ddq<I, J, K, L, M, N>() + ddq<I, L, J, K, M, N>() + ddq<I, K, J, L, M, N>() +
ddq<J, K, L, I, M, N>() + ddq<J, L, I, K, M, N>() + ddq<K, L, I, J, M, N>();
#endif
}
template <Size I, Size J, Size K, Size L>
INLINE Float value() const {
return perm<I, J, K, L, 0, 0>() * f2.template value<0, 0>() +
perm<I, J, K, L, 0, 1>() * f2.template value<0, 1>() +
perm<I, J, K, L, 0, 2>() * f2.template value<0, 2>() +
perm<I, J, K, L, 1, 0>() * f2.template value<1, 0>() +
perm<I, J, K, L, 1, 1>() * f2.template value<1, 1>() +
perm<I, J, K, L, 1, 2>() * f2.template value<1, 2>() +
perm<I, J, K, L, 2, 0>() * f2.template value<2, 0>() +
perm<I, J, K, L, 2, 1>() * f2.template value<2, 1>() +
perm<I, J, K, L, 2, 2>() * f2.template value<2, 2>();
}
};
struct Term32 {
const TracelessMultipole<2>& Q;
const TracelessMultipole<2>& f2;
template <Size I, Size J, Size K, Size L>
INLINE Float value() const {
return makePermutations(Delta<2>{}, Delta<2>{}).template value<I, J, K, L>() *
makeInner<2>(Q, f2).value() * (-1._f / 5._f);
}
};
} // namespace MomentOperators
INLINE TracelessMultipole<3> parallelAxisTheorem(const TracelessMultipole<3>& Qijk,
const TracelessMultipole<2>& Qij,
const Float Q,
const Vector& d) {
using namespace MomentOperators;
const OuterProduct<1> d1{ d };
const Multipole<3> d3 = makeMultipole<3>(OuterProduct<3>{ d });
const TracelessMultipole<3> f3 = computeReducedMultipole(d3);
return makeTracelessMultipole<3>(Qijk + f3 * Q + makePermutations(Qij, d1) + Term2{ Qij, d });
}
INLINE TracelessMultipole<4> parallelAxisTheorem(const TracelessMultipole<4>& Qijkl,
const TracelessMultipole<3>& Qijk,
const TracelessMultipole<2>& Qij,
const Float Q,
const Vector& d) {
using namespace MomentOperators;
OuterProduct<1> d1{ d };
OuterProduct<2> d2{ d };
OuterProduct<4> d4{ d };
const TracelessMultipole<2> f2 = computeReducedMultipole(makeMultipole<2>(d2));
const TracelessMultipole<4> f4 = computeReducedMultipole(makeMultipole<4>(d4));
return makeTracelessMultipole<4>(
Qijkl + f4 * Q + makePermutations(Qijk, d1) + makePermutations(Qij, f2) +
(Term30{ Qijk, d } + Term31{ Qij, f2 } + Term32{ Qij, f2 }) * (-2._f / 7._f));
}
template <Size M, Size N>
INLINE Vector computeMultipoleAcceleration(const MultipoleExpansion<N>& ms,
ArrayView<const Float> gamma,
const Vector& dr) {
const TracelessMultipole<M>& q = ms.template order<M>();
const Float Q0 = computeMultipolePotential<0>(q, dr).value();
const Vector Q1 = (N > 0) ? computeMultipolePotential<1>(q, dr).vector() : Vector(0._f);
const Vector a = gamma[M + 1] * dr * Q0 + gamma[M] * Q1;
SPH_ASSERT(isReal(a), dr, Q0, Q1, gamma);
return a;
}
enum class MultipoleOrder {
MONOPOLE = 0,
QUADRUPOLE = 2,
OCTUPOLE = 3,
HEXADECAPOLE = 4,
};
template <Size N>
Vector evaluateGravity(const Vector& dr, const MultipoleExpansion<N>& ms, const MultipoleOrder maxOrder) {
StaticArray<Float, N + 2> gamma;
#ifdef SPH_DEBUG
gamma.fill(NAN);
#endif
computeGreenGamma<N>(gamma, dr);
Vector a(0._f);
switch (maxOrder) {
case MultipoleOrder::OCTUPOLE:
a += computeMultipoleAcceleration<3>(ms, gamma, -dr);
SPH_FALLTHROUGH
case MultipoleOrder::QUADRUPOLE:
a += computeMultipoleAcceleration<2>(ms, gamma, -dr);
SPH_FALLTHROUGH
case MultipoleOrder::MONOPOLE:
a += computeMultipoleAcceleration<0>(ms, gamma, -dr);
break;
default:
NOT_IMPLEMENTED;
};
SPH_ASSERT(isReal(a) && getSqrLength(a) > 0._f);
return a;
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/utility/StringUtils.h
|
<reponame>pavelsevecek/OpenSPH<filename>core/objects/utility/StringUtils.h
#pragma once
#include "objects/containers/Array.h"
#include "objects/containers/StaticArray.h"
#include "objects/wrappers/Optional.h"
#include <set>
#include <string>
NAMESPACE_SPH_BEGIN
/// Converts a string to given type.
template <typename T>
Optional<T> fromString(const std::string& s);
/// Checks if the given string starts with given substring.
bool startsWith(const std::string& s, const std::string& start);
/// Removes all leading and trailing spaces from a string.
std::string trim(const std::string& s);
/// Converts all uppercase characters to their lowercase variants. Other characters are unchanged.
std::string lowercase(const std::string& s);
/// Replaces first occurence of string with a new string.
std::string replaceFirst(const std::string& source, const std::string& old, const std::string& s);
/// Replaces all occurences of string with a new string
std::string replaceAll(const std::string& source, const std::string& old, const std::string& s);
/// Inserts \n to string so that no line is longer than given limit
std::string setLineBreak(const std::string& s, const Size lineWidth);
/// Splits a string into an array of string using given delimiter.
Array<std::string> split(const std::string& s, const char delimiter);
/// Splits a string into two parts, using first occurence of given delimiter.
Pair<std::string> splitByFirst(const std::string& s, const char delimiter);
/// Capitalizes first letters of all words in the string, except for words like 'and', 'or', etc.
std::string capitalize(const std::string& s);
/// Helper class for generating unique names.
///
/// Calling \ref getName stores the name in the object. If the function is called with the same parameter for
/// the second time, the name is made unique by appending a suitable suffix.
class UniqueNameManager {
private:
std::set<std::string> names;
public:
UniqueNameManager() = default;
explicit UniqueNameManager(ArrayView<const std::string> initial);
std::string getName(const std::string& name);
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/windows/BatchDialog.h
|
<reponame>pavelsevecek/OpenSPH<filename>gui/windows/BatchDialog.h
#pragma once
#include "gui/objects/Bitmap.h"
#include "run/Node.h"
#include <wx/dialog.h>
#include <wx/grid.h>
NAMESPACE_SPH_BEGIN
class Config;
class BatchManager {
private:
struct Col {
SharedPtr<JobNode> node;
std::string key;
};
Array<Col> cols;
Array<std::string> rows;
Bitmap<std::string> cells;
public:
BatchManager() {
this->resize(4, 3);
}
BatchManager clone() const {
BatchManager copy;
copy.cols = cols.clone();
copy.rows = rows.clone();
copy.cells = cells.clone();
return copy;
}
Size getRunCount() const {
return rows.size();
}
std::string getRunName(const Size rowIdx) const {
if (rows[rowIdx].empty()) {
return "Run " + std::to_string(rowIdx + 1);
} else {
return rows[rowIdx];
}
}
Size getParamCount() const {
return cols.size();
}
std::string getParamKey(const Size colIdx) const {
return cols[colIdx].key;
}
SharedPtr<JobNode> getParamNode(const Size colIdx) const {
return cols[colIdx].node;
}
std::string getCell(const Size colIdx, const Size rowIdx) const {
return cells[Pixel(colIdx, rowIdx)];
}
void setRunName(const Size rowIdx, const std::string& name) {
rows[rowIdx] = name;
}
void setParam(const Size colIdx, const SharedPtr<JobNode>& node, const std::string& key) {
cols[colIdx].key = key;
cols[colIdx].node = node;
}
void setCell(const Size colIdx, const Size rowIdx, const std::string& value) {
cells[Pixel(colIdx, rowIdx)] = value;
}
void resize(const Size rowCnt, const Size colCnt) {
cols.resize(colCnt);
rows.resize(rowCnt);
Bitmap<std::string> oldCells = cells.clone();
cells.resize(Pixel(colCnt, rowCnt), "");
const Size minRowCnt = min(cells.size().y, oldCells.size().y);
const Size minColCnt = min(cells.size().x, oldCells.size().x);
for (Size j = 0; j < minRowCnt; ++j) {
for (Size i = 0; i < minColCnt; ++i) {
cells[Pixel(i, j)] = oldCells[Pixel(i, j)];
}
}
}
void duplicateRun(const Size rowIdx) {
const std::string runName = rows[rowIdx];
rows.insert(rowIdx, runName);
Bitmap<std::string> newCells(Pixel(cols.size(), rows.size()));
for (Size j = 0; j < rows.size(); ++j) {
for (Size i = 0; i < cols.size(); ++i) {
const Size j0 = j <= rowIdx ? j : j - 1;
newCells[Pixel(i, j)] = cells[Pixel(i, j0)];
}
}
cells = std::move(newCells);
}
void deleteRun(const Size rowIdx) {
rows.remove(rowIdx);
Bitmap<std::string> newCells(Pixel(cols.size(), rows.size()));
for (Size j = 0; j < rows.size(); ++j) {
for (Size i = 0; i < cols.size(); ++i) {
const Size j0 = j <= rowIdx ? j : j + 1;
newCells[Pixel(i, j)] = cells[Pixel(i, j0)];
}
}
cells = std::move(newCells);
}
/// \brief Modifies the settings of the given node hierarchy.
///
/// Nodes are modified according to parameters of given run. Other parameters or nodes not specified in
/// the manager are unchanged.
void modifyHierarchy(const Size runIdx, JobNode& node);
void load(Config& config, ArrayView<const SharedPtr<JobNode>> nodes);
void save(Config& config);
private:
void modifyNode(JobNode& node, const Size runIdx, const Size paramIdx);
};
class BatchDialog : public wxDialog {
private:
BatchManager manager;
Array<SharedPtr<JobNode>> nodes;
wxGrid* grid;
public:
BatchDialog(wxWindow* parent, const BatchManager& manager, Array<SharedPtr<JobNode>>&& nodes);
~BatchDialog();
BatchManager& getBatch() {
return manager;
}
private:
/// Loads grid data from the manager.
void update();
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/objects/Camera.h
|
#pragma once
/// \file Camera.h
/// \brief Defines projection transforming 3D particles onto 2D screen
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "gui/objects/Point.h"
#include "math/AffineMatrix.h"
#include "objects/wrappers/ClonePtr.h"
#include "objects/wrappers/Optional.h"
NAMESPACE_SPH_BEGIN
class Storage;
class ITracker : public Polymorphic {
public:
// position and velocity
virtual Pair<Vector> getTrackedPoint(const Storage& storage) const = 0;
};
class ParticleTracker : public ITracker {
private:
Size index;
public:
explicit ParticleTracker(const Size index)
: index(index) {}
virtual Pair<Vector> getTrackedPoint(const Storage& storage) const override;
};
class MedianTracker : public ITracker {
private:
Vector offset;
public:
explicit MedianTracker(const Vector& offset)
: offset(offset) {}
virtual Pair<Vector> getTrackedPoint(const Storage& storage) const override;
};
/// \brief Represents a particle projected onto image plane
struct ProjectedPoint {
/// Point in image coordinates
Coords coords;
/// Projected radius of the particle
float radius;
};
/// \brief Ray given by origin and target point
struct CameraRay {
Vector origin;
Vector target;
};
/// \brief Interface defining a camera or view, used by a renderer.
class ICamera : public Polymorphic {
public:
/// \brief Initializes the camera, using the provided particle storage.
virtual void autoSetup(const Storage& storage) = 0;
/// \brief Returns projected position of particle on the image.
///
/// If the particle is outside of the image region or is clipped by the projection, returns NOTHING.
virtual Optional<ProjectedPoint> project(const Vector& r) const = 0;
/// \brief Returns a ray in particle coordinates corresponding to given coordinates in the image plane.
virtual Optional<CameraRay> unproject(const Coords& coords) const = 0;
/// \brief Returns the current resolution of the camera
virtual Pixel getSize() const = 0;
/// \brief Returns the transformation matrix converting camera space to world space.
///
/// In the camera space, camera direction is aligned with the z-axis, y-axis corresponds to the up-vector
/// and x-axis is perpendicular, i.e. left-vector.
virtual AffineMatrix getFrame() const = 0;
/// \brief Returns the current target point of the camera.
virtual Vector getTarget() const = 0;
/// \brief Returns the reference "up" direction of the camera.
virtual Vector getUpVector() const = 0;
/// \brief Returns the clipping distance from plane passing through origin, perpendicular to camera
/// direction.
///
/// If no clipping is used, the function returns NOTHING. Useful to view a section through a body rather
/// than its surface.
virtual Optional<float> getCutoff() const = 0;
/// \brief Returns the world-to-pixel ratio.
virtual Optional<float> getWorldToPixel() const = 0;
/// \brief Modifies the clipping distance of the camera.
///
/// The clipping can be disabled by passing NOTHING.
virtual void setCutoff(const Optional<float> newCutoff) = 0;
/// \param Applies zoom to the camera.
///
/// This is usually equivalent to transforming the view with scaling matrix, alhough it can be implemented
/// differently.
/// \param fixedPoint Point that remains fixed after the zoom (for magnitude != 1, there is exactly one)
/// \param magnitude Relative zoom amount, value <1 means zooming out, value >1 means zooming in.
virtual void zoom(const Pixel fixedPoint, const float magnitude) = 0;
/// \brief Moves the camera to new position in world space.
virtual void setPosition(const Vector& newPosition) = 0;
virtual void setTarget(const Vector& newTarget) = 0;
/// \brief Transforms the current view by given matrix.
///
/// This replaces previous transformation matrix, i.e. subsequent calls do not accumulate.
/// \param matrix Transform matrix applied to the camera.
virtual void transform(const AffineMatrix& matrix) = 0;
/// \brief Moves the camera by relative offset in image space.
virtual void pan(const Pixel offset) = 0;
/// \brief Changes the image size.
virtual void resize(const Pixel newSize) = 0;
/// \todo revert to ClonePtr!
virtual AutoPtr<ICamera> clone() const = 0;
};
struct CameraParams {
/// Size of the image
Pixel imageSize = Pixel(1024, 768);
/// Camera position in space
Vector position = Vector(0._f, 0._f, -1._f);
/// Look-at point in space
Vector target = Vector(0._f);
/// Up vector of the camera (direction)
Vector up = Vector(0._f, 1._f, 0._f);
/// Defines the clipping planes of the camera.
Interval clipping = Interval(EPS, INFTY);
struct {
/// Field of view (angle)
Float fov = PI / 3._f;
} perspective;
struct {
/// Field of view (world units).
float fov = 1.e5_f;
/// Cutoff distance of the camera.
Optional<float> cutoff = NOTHING;
} ortho;
};
/// \brief Orthographic camera.
class OrthoCamera : public ICamera {
private:
CameraParams data;
/// Cached transformed values
struct {
Vector u, v, w;
} cached;
public:
explicit OrthoCamera(const CameraParams& data);
virtual void autoSetup(const Storage& storage) override;
virtual Optional<ProjectedPoint> project(const Vector& r) const override;
virtual Optional<CameraRay> unproject(const Coords& coords) const override;
virtual Pixel getSize() const override;
virtual AffineMatrix getFrame() const override;
virtual Vector getTarget() const override;
virtual Vector getUpVector() const override;
virtual Optional<float> getCutoff() const override;
virtual Optional<float> getWorldToPixel() const override;
virtual void setCutoff(const Optional<float> newCutoff) override;
virtual void zoom(const Pixel fixedPoint, const float magnitude) override;
virtual void setPosition(const Vector& newPosition) override;
virtual void setTarget(const Vector& newTarget) override;
virtual void transform(const AffineMatrix& matrix) override;
virtual void pan(const Pixel offset) override;
virtual void resize(const Pixel newSize) override;
virtual AutoPtr<ICamera> clone() const override {
return makeAuto<OrthoCamera>(*this);
}
private:
void update();
Optional<CameraRay> unprojectImpl(const Coords& coords, const bool adjustZ) const;
float estimateFov(const Storage& storage) const;
};
/// \brief Perspective camera
class PerspectiveCamera : public ICamera {
private:
CameraParams data;
struct {
/// Unit direction of the camera
Vector dir;
/// Up vector of the camera, size of which of represents the image size at unit distance
Vector up;
/// Left vector of the camera, size of which of represents the image size at unit distance
Vector left;
Vector velocity;
} cached;
public:
PerspectiveCamera(const CameraParams& data);
virtual void autoSetup(const Storage& storage) override;
virtual Optional<ProjectedPoint> project(const Vector& r) const override;
virtual Optional<CameraRay> unproject(const Coords& coords) const override;
virtual Pixel getSize() const override;
virtual AffineMatrix getFrame() const override;
virtual Vector getTarget() const override;
virtual Vector getUpVector() const override;
virtual Optional<float> getCutoff() const override;
virtual Optional<float> getWorldToPixel() const override;
virtual void setCutoff(const Optional<float> newCutoff) override;
virtual void zoom(const Pixel UNUSED(fixedPoint), const float magnitude) override;
virtual void setPosition(const Vector& newPosition) override;
virtual void setTarget(const Vector& newTarget) override;
virtual void transform(const AffineMatrix& matrix) override;
virtual void pan(const Pixel offset) override;
virtual void resize(const Pixel newSize) override;
virtual AutoPtr<ICamera> clone() const override {
return makeAuto<PerspectiveCamera>(*this);
}
private:
void update();
};
/// \brief Common base for panoramic cameras.
class PanoCameraBase : public ICamera {
protected:
CameraParams data;
AffineMatrix matrix;
AffineMatrix matrixInv;
public:
explicit PanoCameraBase(const CameraParams& data);
virtual void autoSetup(const Storage& storage) override;
virtual Optional<ProjectedPoint> project(const Vector& r) const override;
virtual Pixel getSize() const override;
virtual AffineMatrix getFrame() const override;
virtual Vector getTarget() const override;
virtual Vector getUpVector() const override;
virtual Optional<float> getCutoff() const override;
virtual Optional<float> getWorldToPixel() const override;
virtual void setCutoff(const Optional<float> newCutoff) override;
virtual void zoom(const Pixel UNUSED(fixedPoint), const float magnitude) override;
virtual void setPosition(const Vector& newPosition) override;
virtual void setTarget(const Vector& newTarget) override;
virtual void transform(const AffineMatrix& matrix) override;
virtual void pan(const Pixel offset) override;
virtual void resize(const Pixel newSize) override;
protected:
virtual void update();
};
/// \brief Fisheye camera
class FisheyeCamera : public PanoCameraBase {
private:
struct {
Coords center;
float radius;
} cached;
public:
explicit FisheyeCamera(const CameraParams& data);
virtual Optional<ProjectedPoint> project(const Vector& r) const override;
virtual Optional<CameraRay> unproject(const Coords& coords) const override;
virtual AutoPtr<ICamera> clone() const override {
return makeAuto<FisheyeCamera>(*this);
}
private:
virtual void update() override;
};
/// \brief Spherical camera
class SphericalCamera : public PanoCameraBase {
public:
explicit SphericalCamera(const CameraParams& data);
virtual Optional<ProjectedPoint> project(const Vector& r) const override;
virtual Optional<CameraRay> unproject(const Coords& coords) const override;
virtual AutoPtr<ICamera> clone() const override {
return makeAuto<SphericalCamera>(*this);
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/run/jobs/IoJobs.h
|
#pragma once
#include "run/Job.h"
NAMESPACE_SPH_BEGIN
class Triangle;
enum class UnitEnum {
SI,
CGS,
NBODY,
};
class LoadFileJob : public IParticleJob {
private:
Path path;
EnumWrapper units = EnumWrapper(UnitEnum::SI);
public:
LoadFileJob(const Path& path = Path("file.ssf"))
: IParticleJob("")
, path(path.native()) {}
virtual std::string instanceName() const override {
if (instName.empty()) {
return "Load '" + path.fileName().native() + "'";
} else {
return instName;
}
}
virtual std::string className() const override {
return "load file";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
FlatMap<Size, Path> getFileSequence(const Path& firstFile);
class FileSequenceJob : public IParticleJob {
private:
Path firstFile;
int maxFps = 10;
public:
FileSequenceJob(const std::string& name, const Path& firstFile = Path("file_0000.ssf"))
: IParticleJob(name)
, firstFile(firstFile.native()) {}
virtual std::string className() const override {
return "load sequence";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return {};
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
class SaveFileJob : public IParticleJob {
private:
RunSettings settings;
public:
explicit SaveFileJob(const std::string& name);
virtual std::string instanceName() const override {
if (instName.empty()) {
const Path path(settings.get<std::string>(RunSettingsId::RUN_OUTPUT_NAME));
return "Save to '" + path.fileName().native() + "'";
} else {
return instName;
}
}
virtual std::string className() const override {
return "save file";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& callbacks) override;
};
enum class MeshAlgorithm {
MARCHING_CUBES,
ALPHA_SHAPE,
};
class SaveMeshJob : public IParticleJob {
private:
Path path = Path("surface.ply");
Float resolution = 0.5_f;
EnumWrapper algorithm = EnumWrapper(MeshAlgorithm::MARCHING_CUBES);
Float level = 0.13_f;
Float smoothingMult = 1._f;
bool anisotropic = false;
Float alpha = 4._f;
bool scaleToUnit = false;
bool refine = false;
public:
explicit SaveMeshJob(const std::string& name)
: IParticleJob(name) {}
virtual std::string className() const override {
return "save mesh";
}
virtual UnorderedMap<std::string, ExtJobType> getSlots() const override {
return { { "particles", JobType::PARTICLES } };
}
virtual VirtualSettings getSettings() override;
virtual void evaluate(const RunSettings& global, IRunCallbacks& UNUSED(callbacks)) override;
private:
Array<Triangle> runMarchingCubes(const Storage& storage,
const RunSettings& global,
IRunCallbacks& callbacks) const;
Array<Triangle> runAlphaShape(const Storage& storage, IRunCallbacks& callbacks) const;
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/windows/CurveDialog.h
|
<gh_stars>10-100
#pragma once
#include "gui/objects/Color.h"
#include "gui/objects/Point.h"
#include "math/Curve.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/Function.h"
#include "objects/wrappers/Optional.h"
#include <algorithm>
#include <wx/dcclient.h>
#include <wx/frame.h>
#include <wx/panel.h>
#include <wx/propgrid/editors.h>
#include <wx/propgrid/propgrid.h>
#include <wx/sizer.h>
NAMESPACE_SPH_BEGIN
class CurvePanel : public wxPanel {
private:
Curve curve;
wxPoint mousePosition = wxDefaultPosition;
Optional<Size> lockedIdx;
Optional<Size> highlightIdx;
Optional<Size> highlightSegment;
public:
CurvePanel(wxWindow* parent);
void setCurve(const Curve& newCurve) {
curve = newCurve;
}
Curve getCurve() const {
return curve;
}
private:
void onPaint(wxPaintEvent& evt);
void onLeftDown(wxMouseEvent& evt);
void onLeftUp(wxMouseEvent& evt);
void onRightUp(wxMouseEvent& evt);
void onMouseMotion(wxMouseEvent& evt);
const static int padding = 30;
template <typename TPoint, typename T = int>
TPoint curveToWindow(const CurvePoint& p) const;
CurvePoint windowToCurve(const wxPoint2DDouble p) const;
Optional<Size> getIdx(const wxPoint mousePos) const;
Optional<Size> getSegment(const wxPoint mousePos) const;
};
class CurveEditor : public wxPGEditor {
public:
virtual wxPGWindowList CreateControls(wxPropertyGrid* propgrid,
wxPGProperty* property,
const wxPoint& pos,
const wxSize& size) const override;
virtual void UpdateControl(wxPGProperty* property, wxWindow* ctrl) const override;
virtual void DrawValue(wxDC& dc,
const wxRect& rect,
wxPGProperty* property,
const wxString& text) const override;
virtual bool OnEvent(wxPropertyGrid* propgrid,
wxPGProperty* property,
wxWindow* wnd_primary,
wxEvent& event) const override;
};
class CurveProperty : public wxStringProperty {
private:
Curve curve;
public:
CurveProperty(const wxString& label, const Curve& curve)
: wxStringProperty(label, "curve")
, curve(curve) {}
virtual const wxPGEditor* DoGetEditorClass() const override {
static wxPGEditor* editor = wxPropertyGrid::RegisterEditorClass(new CurveEditor(), "MyEditor");
return editor;
}
void setCurve(const Curve& newCurve) {
curve = newCurve;
}
const Curve& getCurve() const {
return curve;
}
};
class CurveDialog : public wxFrame {
private:
Function<void(const Curve&)> curveChanged;
public:
CurveDialog(wxWindow* parent, const Curve& curve, Function<void(const Curve&)> curveChanged);
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/quantities/Storage.h
|
#pragma once
/// \file Storage.h
/// \brief Container for storing particle quantities and materials.
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/ForwardDecl.h"
#include "objects/Exceptions.h"
#include "objects/containers/Array.h"
#include "objects/containers/FlatMap.h"
#include "objects/wrappers/Flags.h"
#include "objects/wrappers/Function.h"
#include "objects/wrappers/Outcome.h"
#include "objects/wrappers/SharedPtr.h"
#include "quantities/QuantityIds.h"
NAMESPACE_SPH_BEGIN
class IMaterial;
class Quantity;
class Box;
class StorageSequence;
class ConstStorageSequence;
struct Attractor;
enum class OrderEnum;
enum class VisitorEnum;
struct StorageElement {
QuantityId id;
Quantity& quantity;
};
struct ConstStorageElement {
QuantityId id;
const Quantity& quantity;
};
/// \brief Helper class for iterating over quantities stored in \ref Storage.
class StorageIterator {
private:
using ActIterator = Iterator<FlatMap<QuantityId, Quantity>::Element>;
ActIterator iter;
public:
StorageIterator(const ActIterator iterator, Badge<StorageSequence>);
StorageIterator& operator++();
StorageElement operator*();
bool operator==(const StorageIterator& other) const;
bool operator!=(const StorageIterator& other) const;
};
/// \brief Helper class for iterating over quantities stored in \ref Storage, const version.
class ConstStorageIterator {
private:
using ActIterator = Iterator<const FlatMap<QuantityId, Quantity>::Element>;
ActIterator iter;
public:
ConstStorageIterator(const ActIterator iterator, Badge<ConstStorageSequence>);
ConstStorageIterator& operator++();
ConstStorageElement operator*();
bool operator==(const ConstStorageIterator& other) const;
bool operator!=(const ConstStorageIterator& other) const;
};
/// \brief Helper class, provides functions \ref begin and \ref end, returning iterators to the first and last
/// quantity in \ref Storage, respectively.
class StorageSequence {
private:
FlatMap<QuantityId, Quantity>& quantities;
public:
StorageSequence(FlatMap<QuantityId, Quantity>& quantities, Badge<Storage>);
/// \brief Returns iterator pointing to the beginning of the quantity storage.
///
/// Dereferencing the iterator yields \ref StorageElement, holding the \ref QuantityId and the reference
/// to the \ref Quantity.
StorageIterator begin();
/// \brief Returns iterator pointing to the one-past-the-end element of the quantity storage.
StorageIterator end();
/// \brief Returns the number of quantities.
Size size() const;
};
/// \brief Helper class, provides functions \ref begin and \ref end, returning const iterators to the first
/// and last quantity in \ref Storage, respectively.
class ConstStorageSequence {
private:
const FlatMap<QuantityId, Quantity>& quantities;
public:
ConstStorageSequence(const FlatMap<QuantityId, Quantity>& quantities, Badge<Storage>);
/// \brief Returns iterator pointing to the beginning of the quantity storage.
///
/// Dereferencing the iterator yields \ref ConstStorageElement, holding the \ref QuantityId and the
/// reference to the \ref Quantity.
ConstStorageIterator begin();
/// Returns iterator pointing to the one-past-the-end element of the quantity storage.
ConstStorageIterator end();
/// Returns the number of quantities.
Size size() const;
};
/// \brief Base class for arbitrary data stored in the storage alongside particles
class IStorageUserData : public Polymorphic {};
/// \brief Exception thrown when accessing missing quantities, casting to different types, etc.
class InvalidStorageAccess : public Exception {
public:
explicit InvalidStorageAccess(const QuantityId id);
explicit InvalidStorageAccess(const std::string& message);
};
/// \brief Container storing all quantities used within the simulations.
///
/// Storage provides a convenient way to store quantities, iterate over specified subset of quantities, modify
/// quantities etc. Every quantity is a \ref Quantity object and is identified by \ref QuantityId key. The
/// quantities are stored as key-value pairs; for every \ref QuantityId there can be at most one \ref Quantity
/// stored.
///
/// Storage can contain scalar, vector, tensor and integer quantities. Every quantity can also have associated
/// one or two derivatives. There is no constraint on quantity order or type for given \ref QuantityId, i.e.
/// as far as \ref Storage object is concerned, one can create a QuantityId::ENERGY tensor quantity with
/// second derivatives or integer quantity QuantityId::SOUND_SPEED. Different parts of the code require
/// certain types for some quantities, though. Particle positions, QuantityId::POSITION, are mostly assumed
/// to be vector quantities of second order. Inconsistency of types will cause an assert when encountered.
///
/// Storage can hold arbitrary number of materials, objects derived from \ref IMaterial. In theory,
/// every particle can have a different material (different equation of state, different rheology, ...).
/// The storage can also exist with no material; this is a valid state, useful for situations where no
/// material is necessary. A storage with material can be created using constructor
/// Storage(AutoPtr<IMaterial>&& material). All particles subsequently added into the storage
/// will have the material passed in the parameter of the constructor. Storage with multiple materials can
/// then be created by merging the storage with another object, using function \ref merge.
///
/// Storage is not thread-safe. If used in multithreaded context, any calls of member functions must be
/// synchonized by the caller.
///
/// The following demostrates how to access the particle data:
/// \code
/// // Get particle masses from the storage
/// ArrayView<Float> m = storage.getValue<Float>(QuantityId::MASS);
/// std::cout << "Mass of 5th particle = " << m[5] << std::endl;
///
/// // Get particle velocities (=derivative of positions) and accelerations (=second derivative of positions)
/// ArrayView<Vector> v = storage.getDt<Vector>(QuantityId::POSITION);
/// ArrayView<Vector> dv = storage.getD2t<Vector>(QuantityId::POSITION);
///
/// // To get values and all derivatives at once, we can use the getAll function. The function returns an
/// // array containing all buffers, which can be "decomposed" into individual variables using tie function
/// // (similarly to std::tie).
/// ArrayView<Vector> r;
/// tie(r, v, dv) = storage.getAll<Vector>(QuantityId::POSITION); // return value is "decomposed"
///
/// // Lastly, if we want to get multiple values (not derivatives) of the same type, we can use getValues. We
/// // can also utilize the function tie; make sure to list the variables in the same order as the IDs.
/// ArrayView<Float> rho, u;
/// tie(rho, u, m) = storage.getValues<Float>(QuantityId::DENSITY, QuantityId::ENERGY, QuantityId::MASS);
/// \endcode
///
/// When adding a new quantity into the storage, it is necessary to specify the type of the quantity and the
/// number of derivatives using \ref OrderEnum. Quantity can be either initialized by providing a single
/// default value (used for all particles), or an array of values; see functions \ref insert. To add arbitrary
/// quantity, use:
/// \code
/// // Fill the array of angular frequencies
/// Array<Vector> omega(storage.getParticleCnt());
/// omega.fill(Vector(0, 0, 5)); // initialize it to 5 rad/s parallel to z-axis.
/// // Add angular frequencies to the storage, evolved as first-order quantity
/// storage.insert<Vector>(QuantityId::ANGULAR_FREQUENCY, OrderEnum::FIRST, std::move(omega));
///
/// // Add moment of inertia (with no derivatives)
/// const SymmetricTensor I = Rigid::sphereInertia(3, 2); // moment of a sphere with mass 3kg and radius 2m
/// storage.insert<SymmetricTensor>(QuantityId::MOMENT_OF_INERTIA, OrderEnum::ZERO, I);
/// \endcode
///
/// In some cases, it is useful to read or modify all quantities in the storage, without the need to fetch
/// them manually using \ref getValue and related function. There are two different ways to iterate over
/// quantities stored in storage. You can use the function \ref getQuantities, which returns a range (pair of
/// iterators) and thus allows to visit quantities in a for-loop:
/// \code
/// for (StorageElement element : storage.getQuantities()) {
/// std::cout << "Quantity " << element.id << std::endl
/// std::cout << " - order " << int(element.quantity.getOrderEnum()) << std::endl;
/// std::cout << " - type " << int(element.quantity.getValueEnum()) << std::endl;
/// }
/// \endcode
/// This approach can be utilized to access properties of the quantities (as in the example above), clone
/// quantities, etc. The downside is that we still need to know the value type to actually access the quantity
/// values. To overcome this problem and access the quantity values in generic (type-agnostic) way, consider
/// using the function \ref iterate:
/// \code
/// // Iterate over all first order quantities in the storage
/// iterate<VisitorEnum::FIRST_ORDER>(storage, [](QuantityId id, auto& values, auto& derivatives) {
/// // Values and derivatives are arrays with quantity values. The type of the values can be Float,
/// // Vector, SymmetricTensor, etc., depending on the actual type of the stored quantity. Therefore, we
/// // can only use generic code here (functions overload for all quantity types).
/// std::cout << "Quantity " << id << std::endl;
/// std::cout << "Particle 0: " << values[0] << ", derivative ", derivatives[0] << std::endl;
/// });
///
/// // Iterates over all arrays in the storage, meaning all quantity values and derivatives.
/// iterate<VisitorEnum::ALL_BUFFERS>(storage, [](auto& array) {
/// // Use decltype to determine the type of the array
/// using Type = std::decay_t<decltype(array)>::Type;
///
/// // Set all values and all derivatives to zero (zero vector, zero tensor)
/// array.fill(Type(0._f));
/// });
/// \endcode
/// Note that arguments of the provided functor differ for each \ref VisitorEnum.
class Storage : public Noncopyable {
private:
/// \brief Stored quantities (array of arrays). All arrays must be the same size at all times.
FlatMap<QuantityId, Quantity> quantities;
/// \brief Holds information about a material and particles with this material.
struct MatRange {
/// Actual implementation of the material
SharedPtr<IMaterial> material;
/// First index of particle with this material
Size from = 0;
/// One-past-last index of particle with this material
Size to = 0;
MatRange() = default;
MatRange(const SharedPtr<IMaterial>& material, const Size from, const Size to);
};
/// \brief Materials of particles in the storage.
///
/// Particles of the same material are stored consecutively; first material always starts with index 0 and
/// last material ends with index equal to the number of particles.
Array<MatRange> mats;
/// \brief Cached view of material IDs of particles.
///
/// Used for fast access of material properties.
ArrayView<Size> matIds;
/// \brief Additional point masses that only interact with other particles gravitationally.
Array<Attractor> attractors;
/// \brief Dependent storages, modified when the number of particles of this storage is changed.
///
/// Needed in order to keep the number of particles in dependent storages the same.
Array<WeakPtr<Storage>> dependent;
/// \brief Arbitrary data set by \ref setUserData.
///
/// May be nullptr.
SharedPtr<IStorageUserData> userData;
public:
/// \brief Creates a storage with no material.
///
/// Any call of \ref getMaterial function will result in an assert.
Storage();
/// \brief Initialize a storage with a material.
///
/// All particles of the storage will have the same material. To create a heterogeneous storage, it is
/// necessary to merge another storage object into this one, using \ref merge function.
explicit Storage(const SharedPtr<IMaterial>& material);
~Storage();
Storage(Storage&& other);
Storage& operator=(Storage&& other);
/// \brief Checks if the storage contains quantity with given key.
///
/// Type or order of unit is not specified, any quantity with this key will match.
bool has(const QuantityId key) const;
/// \brief Checks if the storage contains quantity with given key, value type and order.
template <typename TValue>
bool has(const QuantityId key, const OrderEnum order) const;
/// \brief Retrieves quantity with given key from the storage.
///
/// Quantity must be already stored, function throws an exception otherwise.
Quantity& getQuantity(const QuantityId key);
/// \brief Retrieves quantity with given key from the storage, const version.
const Quantity& getQuantity(const QuantityId key) const;
/// \brief Retrieves quantity buffers from the storage, given its key and value type.
///
/// The stored quantity must be of type TValue, checked by assert. Quantity must already exist in the
/// storage, checked by assert. To check whether the quantity is stored, use has() method.
/// \return Array of references to Arrays, containing quantity values and all derivatives.
template <typename TValue>
StaticArray<Array<TValue>&, 3> getAll(const QuantityId key);
/// \brief Retrieves quantity buffers from the storage, given its key and value type, const version.
template <typename TValue>
StaticArray<const Array<TValue>&, 3> getAll(const QuantityId key) const;
/// \brief Retrieves a quantity values from the storage, given its key and value type.
///
/// The stored quantity must be of type TValue, checked by assert. Quantity must already exist in the
/// storage, checked by assert.
/// \return Array reference containing stored quantity values.
template <typename TValue>
Array<TValue>& getValue(const QuantityId key);
/// \copydoc getValue
template <typename TValue>
const Array<TValue>& getValue(const QuantityId key) const;
/// \brief Retrieves a quantity derivative from the storage, given its key and value type.
///
/// The stored quantity must be of type TValue, checked by assert. Quantity must already exist in the
/// storage and must be first or second order, checked by assert.
/// \return Array reference containing quantity derivatives.
template <typename TValue>
Array<TValue>& getDt(const QuantityId key);
/// \brief Retrieves a quantity derivative from the storage, given its key and value type, const version.
template <typename TValue>
const Array<TValue>& getDt(const QuantityId key) const;
/// \brief Retrieves a quantity second derivative from the storage, given its key and value type.
///
/// The stored quantity must be of type TValue, checked by assert. Quantity must already exist in the
/// storage and must be second order, checked by assert.
/// \return Array reference containing quantity second derivatives.
template <typename TValue>
Array<TValue>& getD2t(const QuantityId key);
/// \copydoc getD2t
template <typename TValue>
const Array<TValue>& getD2t(const QuantityId key) const;
/// \brief Retrieves an array of quantities from the key.
///
/// The type of all quantities must be the same and equal to TValue, checked by assert.
template <typename TValue, typename... TArgs>
auto getValues(const QuantityId first, const QuantityId second, const TArgs... others) {
return tie(getValue<TValue>(first), getValue<TValue>(second), getValue<TValue>(others)...);
}
/// \brief Retrieves an array of quantities from the key, const version.
template <typename TValue, typename... TArgs>
auto getValues(const QuantityId first, const QuantityId second, const TArgs... others) const {
// better not const_cast here as we are deducing return type
return tie(getValue<TValue>(first), getValue<TValue>(second), getValue<TValue>(others)...);
}
/// \brief Creates a quantity in the storage, given its key, value type and order.
///
/// Quantity is resized and filled with default value. This cannot be used to set number of particles, the
/// size of the quantity is set to match current particle number. If the quantity is already stored in the
/// storage, function only checks that the type of the quantity matches, but otherwise keeps the
/// previously stored values. If the required order of quantity is larger than the one currently stored,
/// additional derivatives are created with no assert nor exception, otherwise the order is unchanged.
/// \tparam TValue Type of the quantity. Can be scalar, vector, tensor or traceless tensor.
/// \param key Unique key of the quantity.
/// \param TOrder Order (number of derivatives) associated with the quantity.
/// \param defaultValue Value to which quantity is initialized. If the quantity already exists in the
/// storage, the value is unused.
/// \returns Reference to the inserted quantity.
template <typename TValue>
Quantity& insert(const QuantityId key, const OrderEnum order, const TValue& defaultValue);
/// \brief Creates a quantity in the storage, given array of values.
///
/// The size of the array must match the number of particles. Derivatives of the quantity are set to zero.
/// If this is the first quantity inserted into the storage, it sets the number of particles; all
/// quantities added after that must have the same size. If a quantity with the same key already exists in
/// the storage, its values are overriden. Derivatives are not changed. In this case, the function checks
/// that the quantity type is the same; if it isn't, InvalidSetup exception is thrown.
/// \returns Reference to the inserted quantity.
template <typename TValue>
Quantity& insert(const QuantityId key, const OrderEnum order, Array<TValue>&& values);
/// \brief Adds a point-mass attractor to the storage.
void addAttractor(const Attractor& a);
/// \brief Registers a dependent storage.
///
/// A dependent storage mirrors changes of particle counts. Every time new particles are added into the
/// storage or when some particles are removed, the same action is performed on all (existing) dependent
/// storages. However, no other action is handled this way, namely new quantities have to be added
/// manually to all storages. Same goes for clearing the derivatives, changing materials, etc.
///
/// Note that the storage holds weak references, the dependent storages must be held in SharedPtr
/// somewhere to keep the link.
void addDependent(const WeakPtr<Storage>& other);
/// \brief Returns an object containing a reference to given material.
///
/// The object can also be used to iterate over indices of particles belonging to given material.
/// \param matIdx Index of given material in storage. Materials are stored in unspecified order; to get
/// material of given particle, use \ref getMaterialOfParticle.
MaterialView getMaterial(const Size matIdx) const;
/// \brief Returns material view for material of given particle.
MaterialView getMaterialOfParticle(const Size particleIdx) const;
/// \brief Modifies material with given index.
///
/// The new material cannot be nullptr.
void setMaterial(const Size matIdx, const SharedPtr<IMaterial>& material);
/// \brief Returns the bounding range of given quantity.
///
/// Provides an easy access to the material range without construcing intermediate object of \ref
/// MaterialView, otherwise this function is equivalent to: \code getMaterial(matIdx)->range(id) \endcode
Interval getRange(const QuantityId id, const Size matIdx) const;
/// \brief Returns the given material parameter for all materials in the storage.
///
/// To get the material parameter for given particle, use the index given by material ID.
template <typename TValue>
Array<TValue> getMaterialParams(const BodySettingsId param) const;
/// \brief Checks if the particles in the storage are homogeneous with respect to given parameter.
///
/// It is assumed that the parameter is scalar.
bool isHomogeneous(const BodySettingsId param) const;
/// \brief Returns the sequence of quantities.
StorageSequence getQuantities();
/// \brief Returns the sequence of quantities, const version.
ConstStorageSequence getQuantities() const;
/// \brief Returns the sequence of stored point-mass attractors.
ArrayView<Attractor> getAttractors();
/// \brief Returns the sequence of stored point-mass attractors, const version.
ArrayView<const Attractor> getAttractors() const;
/// \brief Executes a given functor recursively for all dependent storages.
///
/// This storage is not visited, the functor is executed with child storages, grandchild storages, etc. If
/// one of dependent storages expired (no shared pointer is currently holding it), it is removed from the
/// list.
void propagate(const Function<void(Storage& storage)>& functor);
/// \brief Return the number of materials in the storage.
///
/// Material indices from 0 to (getMaterialCnt() - 1) are valid input for \ref getMaterialView function.
Size getMaterialCnt() const;
/// \brief Returns the number of stored quantities.
Size getQuantityCnt() const;
/// \brief Returns the number of particles.
///
/// The number of particle is always the same for all quantities.
/// \warning This count does not include the number of attractors.
Size getParticleCnt() const;
/// \brief Returns the number of attractors.
Size getAttractorCnt() const;
/// \brief Checks if the storage is empty, i.e. without particles.
bool empty() const;
/// \brief Merges another storage into this object.
///
/// The passed storage is moved in the process. All materials in the merged storage are conserved;
/// particles will keep the materials they had before the merge. The merge is only allowed for storages
/// that both have materials or neither have one. Merging a storage without a material into a storage with
/// at least one material will result in assert. Similarly for merging a storage with materials into a
/// storage without materials.
///
/// The function invalidates any reference or \ref ArrayView to quantity values or derivatives. For this
/// reason, storages can only be merged when setting up initial conditions or inbetween timesteps, never
/// while evaluating solver!
void merge(Storage&& other);
/// \brief Sets all highest-level derivatives of quantities to zero.
///
/// Other values are unchanged.
void zeroHighestDerivatives();
enum class IndicesFlag {
/// Use if the given array is already sorted (optimization)
INDICES_SORTED = 1 << 0,
};
/// \brief Duplicates some particles in the storage.
///
/// New particles are added to an unspecified positions in the storage, copying all the quantities and
/// materials from the source particles. Note that this is not intended to be used without further
/// modifications of the newly created particles as we never want to create particle pairs; make sure to
/// move the created particles to required positions and modify their quantities as needed. The function
/// can be used to add new particles with materials already existing in the storage.
/// \param idxs Indices of the particles to duplicate.
/// \return Indices of the newly created particles (in the modified storage). Note that the original
/// indices passed into the storage are no longer valid after the function is called.
Array<Size> duplicate(ArrayView<const Size> idxs, const Flags<IndicesFlag> flags = EMPTY_FLAGS);
/// \brief Removes specified particles from the storage.
///
/// If all particles of some material are removed by this, the material is also removed from the storage.
/// Same particles are also removed from all dependent storages.
/// \param idxs Indices of particles to remove. No need to sort the indices.
void remove(ArrayView<const Size> idxs, const Flags<IndicesFlag> flags = EMPTY_FLAGS);
/// \brief Removes all particles with all quantities (including materials) from the storage.
///
/// The storage is left is a state as if it was default-constructed. Dependent storages are also cleared.
void removeAll();
/// \brief Clones specified buffers of the storage.
///
/// Cloned (sub)set of buffers is given by flags. Cloned storage will have the same number of quantities
/// and the order and types of quantities will match; if some buffer is excluded from cloning, it is
/// simply left empty.
/// Note that materials are NOT cloned, but rather shared with the parent storage. Modifying material
/// parameters in cloned storage will also modify the parameters in the parent storage.
Storage clone(const Flags<VisitorEnum> buffers) const;
/// Options for the storage resize
enum class ResizeFlag {
/// Empty buffers will not be resized to new values.
KEEP_EMPTY_UNCHANGED = 1 << 0,
};
/// \brief Changes number of particles for all quantities stored in the storage.
///
/// If the new number of particles is larger than the current one, the quantities of the newly created
/// particles are set to zero, regardless of the actual initial value. This is true for all quantity
/// values and derivatives. Storage must already contain at least one quantity, checked by assert.
/// All dependent storages are resized as well. Can be only used on storages with no material or storages
/// with only a single material, checked by assert.
/// \param newParticleCnt New number of particles.
/// \param flags Options of the resizing, see ResizeFlag enum. By default, all quantities are resized.
void resize(const Size newParticleCnt, const Flags<ResizeFlag> flags = EMPTY_FLAGS);
/// \brief Swap quantities or given subset of quantities between two storages.
///
/// Note that materials of the storages are NOT changed.
void swap(Storage& other, const Flags<VisitorEnum> flags);
enum class ValidFlag {
/// Checks that the storage is complete, i.e. there are no empty buffers.
COMPLETE = 1 << 0,
};
/// \brief Checks whether the storage is in valid state.
///
/// The valid state means that all quantities have the same number of particles and materials are stored
/// consecutively in the storage. This should be handled automatically, the function is mainly for
/// debugging purposes.
Outcome isValid(const Flags<ValidFlag> flags = ValidFlag::COMPLETE) const;
/// \brief Stores new user data into the storage.
///
/// Previous user data are overriden.
void setUserData(SharedPtr<IStorageUserData> newData);
/// \brief Returns the stored user data.
///
/// If no data are stored, the function returns nullptr.
SharedPtr<IStorageUserData> getUserData() const;
private:
/// \brief Inserts all quantities contained in source storage that are not present in this storage.
///
/// All added quantities are initialized to zero.
void addMissingBuffers(const Storage& source);
/// \brief Updates the cached matIds view.
void update();
};
/// \brief Adds or updates a quantity holding particle indices to the storage.
///
/// The indices are accessible through quantity QuantityId::PERSISTENT_INDEX. Initially, particle are numbered
/// from 0 to #particleCnt - 1, but the indices are persistent, meaning they remain unchanged when removing
/// particles from the storage. When a particle is removed from the storage, its index can be then re-used by
/// another particle added into the storage.
///
/// When merging two storages, indices remain unchanged in the storage where the particles are into, but they
/// are reset in the storage being merged, as they could be collisions of indices. Same goes to particles
/// added via \ref duplicate function.
void setPersistentIndices(Storage& storage);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/sph/equations/DerivativeHelpers.h
|
#pragma once
#include "quantities/Quantity.h"
#include "sph/equations/Derivative.h"
NAMESPACE_SPH_BEGIN
enum class DerivativeFlag {
/// \brief Use correction tensor on kernel gradient when evaluating the derivative.
///
/// Can be currently only used for asymmetric derivatives. Implies \ref SUM_ONLY_UNDAMAGED - the
/// correction tensor is only computed for undamaged particles.
CORRECTED = 1 << 0,
/// \brief Only undamaged particles (particles with damage > 0) from the same body (body with the same
/// flag) will contribute to the sum.
SUM_ONLY_UNDAMAGED = 1 << 1,
};
/// \brief Helper template for derivatives that define both the symmetrized and asymmetric variant.
///
/// This class template is mainly used to reduce the boilerplate code. It allows to easily implement the \ref
/// ISymmetricDerivative interface by defining a single function; the derived class must implement \a eval
/// templated member function, taking the indices of the particles and the gradient as arguments. The template
/// parameter is a bool, where false means asymmetric evaluation (only the first particle should be modified),
/// and true means symmetric evaluation. The loop over the real neighbors (whether all neighbors or just
/// undamaged particles is specified by the flags passed in the constructor) is automatically performed by
/// \ref DerivativeTemplate and does not have to be re-implemented by the derived classes.
///
/// Derived class must also implement functions \a additionalCreate and \a additionalInitialize. These
/// functions have the same signatures are their virtual counterparts in \ref IDerivative, they are used to
/// initialize additional ArrayViews and other parameters specific for the derived class, without the need to
/// override the virtual function and manually call the function of a parent (which is why the functions are
/// marked as final).
///
/// \note It is mandatory to implement the additional* function, even if the implementation is empty, so that
/// it is ensured the correct function is called and avoid subtle bugs if the "overriding" function is
/// misspelled.
template <typename TDerived>
class DerivativeTemplate : public ISymmetricDerivative {
private:
ArrayView<const Size> idxs;
ArrayView<const Float> reduce;
ArrayView<const SymmetricTensor> C;
Flags<DerivativeFlag> flags;
public:
explicit DerivativeTemplate(const RunSettings& settings, const Flags<DerivativeFlag> flags = EMPTY_FLAGS)
: flags(flags) {
const bool useCorrectionTensor = settings.get<bool>(RunSettingsId::SPH_STRAIN_RATE_CORRECTION_TENSOR);
if (!useCorrectionTensor) {
// 'global' override for correction tensor
this->flags.unset(DerivativeFlag::CORRECTED);
}
const bool sumOnlyUndamaged = settings.get<bool>(RunSettingsId::SPH_SUM_ONLY_UNDAMAGED);
if (!sumOnlyUndamaged) {
// 'global' override - always sum all particles
this->flags.unset(DerivativeFlag::SUM_ONLY_UNDAMAGED);
}
}
virtual void create(Accumulated& results) override final {
derived()->additionalCreate(results);
}
virtual void initialize(const Storage& input, Accumulated& results) override final {
if (flags.has(DerivativeFlag::CORRECTED)) {
C = results.getBuffer<SymmetricTensor>(
QuantityId::STRAIN_RATE_CORRECTION_TENSOR, OrderEnum::ZERO);
} else {
C = nullptr;
}
if (flags.has(DerivativeFlag::SUM_ONLY_UNDAMAGED) && input.has(QuantityId::STRESS_REDUCING)) {
idxs = input.getValue<Size>(QuantityId::FLAG);
reduce = input.getValue<Float>(QuantityId::STRESS_REDUCING);
} else {
idxs = nullptr;
reduce = nullptr;
}
derived()->additionalInitialize(input, results);
}
virtual bool equals(const IDerivative& other) const override final {
if (typeid(*this) != typeid(other)) {
return false;
}
const TDerived* actOther = assertCast<const TDerived>(&other);
return (flags == actOther->flags) && derived()->additionalEquals(*actOther);
}
virtual void evalNeighs(const Size idx,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads) override {
SPH_ASSERT(neighs.size() == grads.size());
if (C) {
sum(idx, neighs, grads, [this](Size i, Size j, const Vector& grad) INL {
SPH_ASSERT(C[i] != SymmetricTensor::null());
derived()->template eval<false>(i, j, C[i] * grad);
});
} else {
sum(idx, neighs, grads, [this](Size i, Size j, const Vector& grad) INL {
derived()->template eval<false>(i, j, grad);
});
}
}
virtual void evalSymmetric(const Size idx,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads) override {
SPH_ASSERT(neighs.size() == grads.size());
SPH_ASSERT(!flags.has(DerivativeFlag::CORRECTED));
sum(idx, neighs, grads, [this](Size i, Size j, const Vector& grad) INL {
derived()->template eval<true>(i, j, grad);
});
}
private:
template <typename TFunctor>
INLINE void sum(const Size i,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads,
const TFunctor& functor) {
if (reduce) {
for (Size k = 0; k < neighs.size(); ++k) {
const Size j = neighs[k];
if (idxs[i] != idxs[j] || reduce[i] == 0._f || reduce[j] == 0._f) {
continue;
}
functor(i, j, grads[k]);
}
} else {
for (Size k = 0; k < neighs.size(); ++k) {
const Size j = neighs[k];
functor(i, j, grads[k]);
}
}
}
TDerived* derived() {
return static_cast<TDerived*>(this);
}
const TDerived* derived() const {
return static_cast<const TDerived*>(this);
}
};
/// \brief Helper template specifically used to implement forces.
///
/// Similarly to \ref DerivativeTemplate, this is mainly used to reduce the boilerplate code and avoid error
/// by implementing the member functions of \ref IAcceleration inconsistently. Derived must implement
/// Tuple<Vector, Float> eval(), returning force and heating.
///
/// Acceleration is never corrected! That would break the conservation of momentum.
template <typename TDerived>
class AccelerationTemplate : public IAcceleration {
private:
ArrayView<Vector> dv;
ArrayView<Float> du;
ArrayView<const Float> m;
ArrayView<const Size> idxs;
ArrayView<const Float> reduce;
bool sumOnlyUndamaged;
public:
explicit AccelerationTemplate(const RunSettings& settings,
const Flags<DerivativeFlag> flags = EMPTY_FLAGS) {
SPH_ASSERT(!flags.has(DerivativeFlag::CORRECTED), "Forces should be never corrected");
// sum only undamaged if specified by the flag and it is specified by the 'global' override
sumOnlyUndamaged = flags.has(DerivativeFlag::SUM_ONLY_UNDAMAGED) &&
settings.get<bool>(RunSettingsId::SPH_SUM_ONLY_UNDAMAGED);
}
virtual void create(Accumulated& results) override final {
results.insert<Vector>(QuantityId::POSITION, OrderEnum::SECOND, BufferSource::SHARED);
results.insert<Float>(QuantityId::ENERGY, OrderEnum::FIRST, BufferSource::SHARED);
derived()->additionalCreate(results);
}
virtual void initialize(const Storage& input, Accumulated& results) override final {
dv = results.getBuffer<Vector>(QuantityId::POSITION, OrderEnum::SECOND);
du = results.getBuffer<Float>(QuantityId::ENERGY, OrderEnum::FIRST);
m = input.getValue<Float>(QuantityId::MASS);
if (sumOnlyUndamaged && input.has(QuantityId::STRESS_REDUCING)) {
idxs = input.getValue<Size>(QuantityId::FLAG);
reduce = input.getValue<Float>(QuantityId::STRESS_REDUCING);
} else {
idxs = nullptr;
reduce = nullptr;
}
derived()->additionalInitialize(input, results);
}
virtual bool equals(const IDerivative& other) const override final {
if (typeid(*this) != typeid(other)) {
return false;
}
const TDerived* actOther = assertCast<const TDerived>(&other);
return (sumOnlyUndamaged == actOther->sumOnlyUndamaged) && derived()->additionalEquals(*actOther);
}
virtual void evalNeighs(const Size idx,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads) override {
SPH_ASSERT(neighs.size() == grads.size());
sum(idx, neighs, grads, [this](Size UNUSED(k), Size i, Size j, const Vector& grad) INL {
Vector f;
Float de;
tieToTuple(f, de) = derived()->template eval<false>(i, j, grad);
dv[i] += m[j] * f;
du[i] += m[j] * de;
});
}
virtual void evalSymmetric(const Size idx,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads) override {
SPH_ASSERT(neighs.size() == grads.size());
sum(idx, neighs, grads, [this](Size UNUSED(k), Size i, Size j, const Vector& grad) INL {
Vector f;
Float de;
tieToTuple(f, de) = derived()->template eval<true>(i, j, grad);
dv[i] += m[j] * f;
dv[j] -= m[i] * f;
du[i] += m[j] * de;
du[j] += m[i] * de;
});
}
virtual void evalAcceleration(const Size idx,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads,
ArrayView<Vector> dv) override {
SPH_ASSERT(neighs.size() == grads.size() && neighs.size() == dv.size());
sum(idx, neighs, grads, [this, &dv](Size k, Size i, Size j, const Vector& grad) INL {
Vector f;
tieToTuple(f, IGNORE) = derived()->template eval<false>(i, j, grad);
dv[k] += m[j] * f;
});
}
private:
template <typename TFunctor>
INLINE void sum(const Size i,
ArrayView<const Size> neighs,
ArrayView<const Vector> grads,
const TFunctor& functor) {
if (reduce) {
for (Size k = 0; k < neighs.size(); ++k) {
const Size j = neighs[k];
if (idxs[i] != idxs[j] || reduce[i] == 0._f || reduce[j] == 0._f) {
continue;
}
functor(k, i, j, grads[k]);
}
} else {
for (Size k = 0; k < neighs.size(); ++k) {
const Size j = neighs[k];
functor(k, i, j, grads[k]);
}
}
}
INLINE TDerived* derived() {
return static_cast<TDerived*>(this);
}
INLINE const TDerived* derived() const {
return static_cast<const TDerived*>(this);
}
};
/// \brief Discretization using the density of the center particle.
///
/// Represents:
/// 1/rho[i] sum_j m[j]*(v[j]-v[i]) * grad_ji
/// This is the discretization of velocity divergence (and other gradients) in standard SPH formulation.
class CenterDensityDiscr {
ArrayView<const Float> rho, m;
public:
void initialize(const Storage& input) {
tie(rho, m) = input.getValues<Float>(QuantityId::DENSITY, QuantityId::MASS);
}
template <typename T>
INLINE T eval(const Size i, const Size j, const T& value) {
return m[j] / rho[i] * value;
}
};
/// \brief Discretization using the densities of summed particles.
///
/// Represents:
/// sum_j m[j]/rho[j]*(v[j]-v[i]) * grad_ji
/// This is the discretization used in SPH5 code/
class NeighborDensityDiscr {
ArrayView<const Float> rho, m;
public:
void initialize(const Storage& input) {
tie(rho, m) = input.getValues<Float>(QuantityId::DENSITY, QuantityId::MASS);
}
template <typename T>
INLINE T eval(const Size UNUSED(i), const Size j, const T& value) {
return m[j] / rho[j] * value;
}
};
template <QuantityId Id, typename Discr, typename Traits>
class VelocityTemplate : public DerivativeTemplate<VelocityTemplate<Id, Discr, Traits>> {
private:
/// Velocity buffer
ArrayView<const Vector> v;
/// Discretization type
Discr discr;
/// Target buffer where derivatives are written
ArrayView<typename Traits::Type> deriv;
public:
using DerivativeTemplate<VelocityTemplate<Id, Discr, Traits>>::DerivativeTemplate;
INLINE void additionalCreate(Accumulated& results) {
results.insert<typename Traits::Type>(Id, OrderEnum::ZERO, BufferSource::UNIQUE);
}
INLINE void additionalInitialize(const Storage& input, Accumulated& results) {
v = input.getDt<Vector>(QuantityId::POSITION);
discr.initialize(input);
deriv = results.getBuffer<typename Traits::Type>(Id, OrderEnum::ZERO);
}
INLINE bool additionalEquals(const VelocityTemplate& UNUSED(other)) const {
return true;
}
template <bool Symmetrize>
INLINE void eval(const Size i, const Size j, const Vector& grad) {
const typename Traits::Type dv = Traits::eval(v[j] - v[i], grad);
deriv[i] += discr.eval(i, j, dv);
if (Symmetrize) {
deriv[j] += discr.eval(j, i, dv);
}
}
};
struct DivergenceTraits {
using Type = Float;
INLINE static Float eval(const Vector& v, const Vector& grad) {
return dot(v, grad);
}
};
struct RotationTraits {
using Type = Vector;
INLINE static Vector eval(const Vector& v, const Vector& grad) {
// nabla x v
return cross(grad, v);
}
};
struct GradientTraits {
using Type = SymmetricTensor;
INLINE static SymmetricTensor eval(const Vector& v, const Vector& grad) {
return symmetricOuter(v, grad);
}
};
template <typename Discr>
using VelocityDivergence = VelocityTemplate<QuantityId::VELOCITY_DIVERGENCE, Discr, DivergenceTraits>;
template <typename Discr>
using VelocityRotation = VelocityTemplate<QuantityId::VELOCITY_ROTATION, Discr, RotationTraits>;
template <typename Discr>
using VelocityGradient = VelocityTemplate<QuantityId::VELOCITY_GRADIENT, Discr, GradientTraits>;
/// \brief Creates a given velocity derivative, using discretization given by selected SPH formulation.
///
/// Note that other formulations can still be used, provided the specialization of VelocityTemplate for given
/// discretization is defined.
template <template <class> class TVelocityDerivative>
AutoPtr<IDerivative> makeDerivative(const RunSettings& settings, Flags<DerivativeFlag> flags = EMPTY_FLAGS) {
const DiscretizationEnum formulation =
settings.get<DiscretizationEnum>(RunSettingsId::SPH_DISCRETIZATION);
switch (formulation) {
case DiscretizationEnum::STANDARD:
return makeAuto<TVelocityDerivative<CenterDensityDiscr>>(settings, flags);
case DiscretizationEnum::BENZ_ASPHAUG:
return makeAuto<TVelocityDerivative<NeighborDensityDiscr>>(settings, flags);
default:
NOT_IMPLEMENTED;
}
}
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/containers/Queue.h
|
#pragma once
/// \file Queue.h
/// \brief Double-ended queue
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2017
#include "math/MathUtils.h"
#include "objects/containers/ArrayView.h"
#include <mm_malloc.h>
NAMESPACE_SPH_BEGIN
/// \brief Container allowing to add and remove elements from both ends.
template <typename T, typename TCounter = Size>
class Queue : public Noncopyable {
private:
using StorageType = typename WrapReferenceType<T>::Type;
/// Allocated data (not necessarily constructed)
StorageType* data = nullptr;
/// First constructed element in the array
TCounter first = 0;
/// One-past-last constructed element in the array
TCounter last = 0;
/// Number of allocated elements
TCounter maxSize = 0;
public:
/// \brief Constructs an empty queue.
Queue() = default;
/// \brief Constructs a queue with given number of elements.
///
/// The elements are default-constructed.
Queue(const TCounter size) {
this->alloc(size, 0, 0);
for (TCounter i = 0; i < maxSize; ++i) {
new (data + i) StorageType();
}
last = maxSize;
}
/// \brief Constructs a queue from initializer list.
///
/// The elements are created using copy constructor.
Queue(std::initializer_list<StorageType> list) {
this->alloc(list.size(), 0, 0);
TCounter i = 0;
for (auto& l : list) {
new (data + i) StorageType(l);
i++;
}
last = maxSize;
}
Queue(Queue&& other)
: data(other.data)
, first(other.first)
, last(other.last)
, maxSize(other.maxSize) {
other.data = nullptr;
other.first = other.last = other.maxSize = 0;
}
~Queue() {
for (TCounter i = first; i < last; ++i) {
data[i].~StorageType();
}
if (data) {
_mm_free(data);
data = nullptr;
}
}
Queue& operator=(Queue&& other) {
std::swap(data, other.data);
std::swap(first, other.first);
std::swap(last, other.last);
std::swap(maxSize, other.maxSize);
return *this;
}
/// \brief Returns a reference to idx-th element in the queue.
///
/// If the index is out of bounds, an assert is issued.
INLINE T& operator[](const TCounter idx) {
SPH_ASSERT(idx < this->size());
return data[first + idx];
}
/// \brief Returns a const reference to idx-th element in the queue
///
/// If the index is out of bounds, an assert is issued.
INLINE const T& operator[](const TCounter idx) const {
SPH_ASSERT(idx < this->size());
return data[first + idx];
}
/// \brief Returns a reference to the first element in the queue
///
/// If the queue contains no elements, an assert is issued.
INLINE T& front() {
SPH_ASSERT(!this->empty());
return data[first];
}
/// \brief Returns a const reference to the first element in the queue
///
/// If the queue contains no elements, an assert is issued.
INLINE const T& front() const {
SPH_ASSERT(!this->empty());
return data[first];
}
/// \brief Returns a reference to the last element in the queue
///
/// If the queue contains no elements, an assert is issued.
INLINE T& back() {
SPH_ASSERT(!this->empty());
return data[last - 1];
}
/// \brief Returns a const reference to the last element in the queue
///
/// If the queue contains no elements, an assert is issued.
INLINE const T& back() const {
SPH_ASSERT(!this->empty());
return data[last - 1];
}
/// \brief Returns the number of elements in the queue.
///
/// Note that the number of allocated elements may be bigger.
INLINE Size size() const {
return last - first;
}
/// \brief Returns true if the queue contains no elements.
///
/// Note that this does not mean no memory is allocated.
INLINE bool empty() const {
return last == first;
}
/// \brief Adds a new element to the front of the queue.
///
/// A new element in the queue is default-constructed and the given value is assigned using copy operator.
void pushFront(const T& value) {
if (first == 0) {
// no place for new elements, needs to resize
this->reserveFront(1);
}
SPH_ASSERT(first > 0);
--first;
new (data + first) StorageType();
data[first] = value;
}
/// \brief Adds a new element to the back of the queue.
///
/// A new element in the queue is default-constructed and the given value is assigned using copy operator.
void pushBack(const T& value) {
if (last == maxSize) {
// no place for new elements, needs to resize
this->reserveBack(1);
}
SPH_ASSERT(last < maxSize);
++last;
new (data + last - 1) StorageType();
data[last - 1] = value;
}
/// \brief Removes an element from the front of the queue.
///
/// \return The value of the removed element.
T popFront() {
SPH_ASSERT(!this->empty());
T value = this->front();
data[first].~StorageType();
++first;
return value;
}
/// \brief Removes an element from the back of the queue.
///
/// \return The value of the removed element.
T popBack() {
SPH_ASSERT(!this->empty());
T value = this->back();
data[last - 1].~StorageType();
--last;
return value;
}
/// \brief Removes all elements from the queue.
///
/// Note that this does not deallocate the queue. This is done in destructor.
void clear() {
for (TCounter i = first; i < last; ++i) {
data[i].~StorageType();
}
last = first;
}
/// \brief Returns an iterator pointing to the first element of the queue.
INLINE Iterator<StorageType> begin() {
return Iterator<StorageType>(data + first, data + first, data + last);
}
/// \brief Returns a const iterator pointing to the first element of the queue.
INLINE Iterator<const StorageType> begin() const {
return Iterator<const StorageType>(data + first, data + first, data + last);
}
/// \brief Returns an iterator pointing to the one-past-last element of the queue.
INLINE Iterator<StorageType> end() {
return Iterator<StorageType>(data + last, data + first, data + last);
}
/// \brief Returns a const iterator pointing to the one-past-last element of the queue.
INLINE Iterator<const StorageType> end() const {
return Iterator<const StorageType>(data + last, data + first, data + last);
}
/// \brief Implicit conversion to arrayview.
INLINE operator ArrayView<T, TCounter>() {
return ArrayView<T, TCounter>(data + first, this->size());
}
/// \brief Implicit conversion to const arrayview.
INLINE operator ArrayView<const T, TCounter>() const {
return ArrayView<const T, TCounter>(data + first, this->size());
}
private:
/// Allocates memory given extra space for element in the front and in the back.
/// Does not construct any elements
void alloc(const TCounter size, const TCounter extraFront, const TCounter extraBack) {
maxSize = size + extraFront + extraBack;
first = last = extraFront;
data = (StorageType*)_mm_malloc(maxSize * sizeof(StorageType), alignof(StorageType));
}
/// If there is currently less than num free elements in the front, reallocates the queue, adding at least
/// num free elements to the front.
void reserveFront(const TCounter num) {
if (num > first) {
Queue newQueue;
newQueue.alloc(this->size(), max(num, this->size()), min(maxSize - last, this->size()));
this->moveElements(std::move(newQueue));
}
SPH_ASSERT(num <= first);
}
/// If there is currently less than num free elements in the back, reallocates the queue, adding at least
/// num free elements to the back.
void reserveBack(const TCounter num) {
if (num > maxSize - last) {
Queue newQueue;
newQueue.alloc(this->size(), min(first, this->size()), max(num, this->size()));
this->moveElements(std::move(newQueue));
}
SPH_ASSERT(num <= maxSize - last);
}
/// Moves all elements from this queue to a new one, assuming enough memory is allocated.
void moveElements(Queue&& newQueue) {
newQueue.last = newQueue.first + this->size();
SPH_ASSERT(newQueue.last <= newQueue.maxSize);
// construct all element in the new queue using move constructor
for (TCounter i = 0; i < this->size(); ++i) {
new (newQueue.data + newQueue.first + i) StorageType(std::move(data[i + first]));
}
// replace queues
*this = std::move(newQueue);
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/containers/StaticArray.h
|
<reponame>pavelsevecek/OpenSPH<filename>core/objects/containers/StaticArray.h<gh_stars>10-100
#pragma once
#include "objects/containers/ArrayView.h"
#include "objects/wrappers/AlignedStorage.h"
#include <initializer_list>
NAMESPACE_SPH_BEGIN
const struct EmptyArray {
} EMPTY_ARRAY;
/// \brief Array with fixed number of allocated elements.
///
/// Number of actually created elements can be different and it can also be changed; elements can be created
/// and destroyed, although it is not possible to construct more elements than the maximum allocated number,
/// determined by template parameter N or function \ref maxSize. The array is intentionally non-copyable to
/// avoid accidentaly copying values, where move or pass-by-reference is possible.
template <typename T, int N, typename TCounter = Size>
class StaticArray {
private:
AlignedStorage<T> data[N];
TCounter actSize;
using StorageType = WrapReference<T>;
public:
/// \brief Default constructor, calls default constructor on all elements.
StaticArray() {
if (!std::is_trivially_default_constructible<T>::value) {
for (TCounter i = 0; i < N; ++i) {
data[i].emplace();
}
}
actSize = N;
}
/// \brief Initialize an empty array.
///
/// This effectively creates an empty stack; all N elements are allocated, but none is constructed and
/// size of the array is zero.
StaticArray(const EmptyArray&) {
actSize = 0;
}
/// \brief Initialize using initializer_list.
///
/// The size of the list must be smaller or equal to N. All N elements are all allocated, elements are
/// constructed from initializer_list using copy constructor.
StaticArray(std::initializer_list<StorageType> list) {
actSize = 0;
SPH_ASSERT(list.size() <= N);
for (auto& i : list) {
data[actSize++].emplace(i);
}
}
StaticArray(const StaticArray& other) = delete;
StaticArray(StaticArray&& other) {
actSize = 0;
for (TCounter i = 0; i < other.size(); ++i) {
// move if it contains values, just copy if it contains references
data[actSize++].emplace(std::forward<T>(other[i]));
}
}
/// \brief Destructor, destroys all constructed elements in the array.
~StaticArray() {
if (!std::is_trivially_destructible<T>::value) {
for (TCounter i = 0; i < actSize; ++i) {
data[i].destroy();
}
}
actSize = 0;
}
StaticArray& operator=(const StaticArray& other) = delete;
/// \brief Move operator for arrays holding default-constructible types.
///
/// Resizes array and moves all elements of the rhs array.
template <typename U, typename = std::enable_if_t<std::is_default_constructible<T>::value, U>>
StaticArray& operator=(StaticArray<U, N>&& other) {
this->resize(other.size());
for (TCounter i = 0; i < other.size(); ++i) {
// move if it contains values, just copy if it contains references
(*this)[i] = std::forward<T>(other[i]);
}
return *this;
}
/// \brief Special assignment operator for array of references on left-hand side.
///
/// Can be used similarly to std::tie; a function may return multiple values by wrapping them into
/// StaticArray<T>, these values can be then saved individual variables by wrapping the variables into
/// \ref StaticArray<T&>. A big advantage over tuple is the option to return a variable number of elements
/// (i.e. number of arguments is not known at compile time).
template <typename U, int M, typename = std::enable_if_t<std::is_lvalue_reference<T>::value, U>>
StaticArray& operator=(StaticArray<U, M>&& other) {
SPH_ASSERT(this->size() == other.size());
for (TCounter i = 0; i < other.size(); ++i) {
(*this)[i] = std::forward<U>(other[i]);
}
return *this;
}
/// \brief Clones the array, calling copy constructor on all elements.
///
/// The size of the cloned array corresponds to current size of this array.
StaticArray clone() const {
StaticArray cloned(EMPTY_ARRAY);
for (TCounter i = 0; i < actSize; ++i) {
cloned.push(data[i].get());
}
return cloned;
}
/// \brief Assigns a value to all constructed elements of the array.
///
/// Does not resize the array.
void fill(const T& value) {
for (TCounter i = 0; i < actSize; ++i) {
data[i].get() = value;
}
}
/// \brief Returns the element with given index.
INLINE T& operator[](const TCounter idx) noexcept {
SPH_ASSERT(idx >= 0 && idx < actSize, idx, actSize);
return data[idx].get();
}
/// \brief Returns the element with given index.
INLINE const T& operator[](const TCounter idx) const noexcept {
SPH_ASSERT(idx >= 0 && idx < actSize, idx, actSize);
return data[idx].get();
}
/// \brief Returns the maximum allowed size of the array.
INLINE constexpr TCounter maxSize() const noexcept {
return N;
}
/// \brief Returns the current size of the array (number of constructed elements).
///
/// Can be between 0 and N.
INLINE TCounter size() const {
return actSize;
}
/// \brief Return true if the array is empty.
///
/// Depends only on number of constructed elements, not allocated size.
INLINE bool empty() const {
return actSize == 0;
}
/// \brief Inserts a value to the end of the array using copy/move constructor.
///
/// The current size of the array must be less than N, checked by assert.
template <typename U, typename = std::enable_if_t<std::is_constructible<StorageType, U>::value>>
INLINE void push(U&& value) {
SPH_ASSERT(actSize < N);
data[actSize++].emplace(std::forward<U>(value));
}
/// \brief Removes and destroys element from the end of the array.
///
/// The removed element is returned from the function. Array must not be empty, checked by assert.
INLINE T pop() {
SPH_ASSERT(actSize > 0);
T value = data[actSize - 1];
data[actSize - 1].destroy();
actSize--;
return value;
}
/// \brief Changes size of the array.
///
/// New size must be between 0 and N. If the array is shrinked, elements from the end of the array are
/// destroyed; if the array is enlarged, new elements are created using default constructor.
void resize(const TCounter newSize) {
SPH_ASSERT(unsigned(newSize) <= N);
if (!std::is_trivially_default_constructible<T>::value) {
if (newSize > actSize) {
for (TCounter i = actSize; i < newSize; ++i) {
data[i].emplace();
}
} else {
for (TCounter i = newSize; i < actSize; ++i) {
data[i].destroy();
}
}
}
actSize = newSize;
}
INLINE Iterator<StorageType> begin() {
return Iterator<StorageType>(rawData(), rawData(), rawData() + actSize);
}
INLINE Iterator<const StorageType> begin() const {
return Iterator<const StorageType>(rawData(), rawData(), rawData() + actSize);
}
INLINE Iterator<const StorageType> cbegin() const {
return Iterator<const StorageType>(rawData(), rawData(), rawData() + actSize);
}
INLINE Iterator<StorageType> end() {
return Iterator<StorageType>(rawData() + actSize, rawData(), rawData() + actSize);
}
INLINE Iterator<const StorageType> end() const {
return Iterator<const StorageType>(rawData() + actSize, rawData(), rawData() + actSize);
}
INLINE Iterator<const StorageType> cend() const {
return Iterator<const StorageType>(rawData() + actSize, rawData(), rawData() + actSize);
}
operator ArrayView<T>() {
return ArrayView<T>(rawData(), actSize);
}
operator ArrayView<const T>() const {
return ArrayView<const T>(rawData(), actSize);
}
bool operator==(const StaticArray& other) const {
if (actSize != other.actSize) {
return false;
}
for (TCounter i = 0; i < actSize; ++i) {
if (data[i].get() != other.data[i].get()) {
return false;
}
}
return true;
}
bool operator!=(const StaticArray& other) const {
return !(*this == other);
}
/// \brief Prints content of array to stream.
///
/// Stored values must have overloaded << operator.
template <typename TStream>
friend TStream& operator<<(TStream& stream, const StaticArray& array) {
for (const T& t : array) {
stream << t << std::endl;
}
return stream;
}
private:
INLINE StorageType* rawData() {
return reinterpret_cast<StorageType*>(data);
}
INLINE const StorageType* rawData() const {
return reinterpret_cast<const StorageType*>(data);
}
};
/// \brief Creates a static array from a list of parameters.
///
/// All parameters must have the same type. Both the allocated size of the array and the number of constructed
/// elements equal to the number of parameters.
template <typename T0, typename... TArgs>
StaticArray<T0, sizeof...(TArgs) + 1> makeStatic(T0&& t0, TArgs&&... rest) {
return StaticArray<T0, sizeof...(TArgs) + 1>({ std::forward<T0>(t0), std::forward<TArgs>(rest)... });
}
/// \brief Creates a static array from a list of l-value references.
///
/// All parameters must have the same type. Both the allocated size of the array and the number of constructed
/// elements equal to the number of parameters.
template <typename T0, typename... TArgs>
StaticArray<T0&, sizeof...(TArgs) + 1> tie(T0& t0, TArgs&... rest) {
return StaticArray<T0&, sizeof...(TArgs) + 1>({ t0, rest... });
}
/// \brief Alias for array holding two elements of the same type.
template <typename T>
using Pair = StaticArray<T, 2>;
/// \brief Container similar to \ref StaticArray, but with constexpr constructors and getters.
template <typename T, Size N>
class ConstexprArray {
private:
T data[N];
public:
template <typename... TArgs>
constexpr ConstexprArray(TArgs&&... args)
: data{ std::forward<TArgs>(args)... } {}
constexpr const T& operator[](const Size idx) const {
return data[idx];
}
constexpr T& operator[](const Size idx) {
return data[idx];
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/containers/String.h
|
#pragma once
/// \file String.h
/// \brief Object representing a sequence of characters
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/containers/Array.h"
#include <string.h>
NAMESPACE_SPH_BEGIN
class String {
private:
Array<char> data = { '\0' };
public:
String() = default;
String(const String& other)
: data(other.data.clone()) {}
String(String&& other) {
// we need to put '\0' before swapping to leave other in consistent state
data = std::move(other.data);
}
String(Array<char>&& buffer)
: data(std::move(buffer)) {
SPH_ASSERT(sanityCheck());
}
String(const char* s) {
data.pop(); // pop terminating zero
const Size length = strlen(s);
data.reserve(length + 1);
for (Size i = 0; i < length; ++i) {
data.push(s[i]);
}
data.push('\0');
}
String& operator=(const String& other) {
data = copyable(other.data);
return *this;
}
String& operator=(String&& other) {
data = std::move(other.data);
return *this;
}
String& operator+=(const String& other) {
data.pop(); // pop terminating zero
data.pushAll(other.data); // push all characters including terminating zero
SPH_ASSERT(sanityCheck());
return *this;
}
friend String operator+(const String& s1, const String& s2) {
String s = s1;
s += s2;
return s;
}
String& operator+=(const char c) {
data.pop();
data.push(c);
data.push('\0');
return *this;
}
bool operator==(const String& other) const {
return data == other.data;
}
bool operator!=(const String& other) const {
return data != other.data;
}
const char* cStr() const {
return &data[0];
}
INLINE char operator[](const Size idx) const {
SPH_ASSERT(idx < this->size());
return data[idx];
}
INLINE Size size() const {
return data.size() - 1;
}
INLINE bool empty() const {
return data.size() == 1;
}
/// \section Iterators
Iterator<char> begin() {
return data.begin();
}
Iterator<const char> begin() const {
return data.begin();
}
Iterator<char> end() {
return data.end() - 1;
}
Iterator<const char> end() const {
return data.end() - 1;
}
friend std::ostream& operator<<(std::ostream& stream, const String& str) {
stream << str.cStr();
return stream;
}
/// \addtogroup utility Utility functions
static Size npos;
Size find(const String& s, const Size pos = 0) const;
Size findAny(ArrayView<String> ss, const Size pos) const;
Size findLast(const String& s) const;
void replace(const Size pos, const Size n, const String& s);
void replace(const String& old, const String& s);
template <typename... TArgs>
void replace(const String& old, const String& s, TArgs&&... args) {
replace(old, s);
replace(std::forward<TArgs>(args)...);
}
String substr(const Size pos, const Size n = String::npos) const;
String trim() const;
String lower() const;
private:
bool sanityCheck() {
return !data.empty() && data.size() < npos / 2 && data[data.size() - 1] == '\0';
}
};
INLINE bool operator<(const String& s1, const String& s2) {
return std::lexicographical_compare(s1.begin(), s1.end(), s2.begin(), s2.end());
}
INLINE String operator"" _s(const char* s, std::size_t UNUSED(len)) {
return String(s);
}
template <typename T>
INLINE String toString(const T& value) {
std::stringstream ss;
ss << value;
return ss.str().c_str();
}
/// Utility functions
/// Returns the current time, formatted by given formatting string.
String getFormattedTime(const String& format);
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/containers/BasicAllocators.h
|
<filename>core/objects/containers/BasicAllocators.h
#pragma once
/// \file BasicAllocators.h
/// \brief Allocators used by containers
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/Assert.h"
#include <mm_malloc.h>
NAMESPACE_SPH_BEGIN
struct MemoryBlock {
void* ptr;
std::size_t size;
MemoryBlock() = default;
MemoryBlock(void* ptr, const std::size_t size)
: ptr(ptr)
, size(size) {}
INLINE static MemoryBlock EMPTY() {
return { nullptr, 0 };
}
};
template <typename T, typename TAllocator, typename... TArgs>
T* allocatorNew(TAllocator& allocator, TArgs&&... args) {
MemoryBlock block = allocator.allocate(sizeof(T), alignof(T));
if (block.ptr) {
return new (block.ptr) T(std::forward<TArgs>(args)...);
} else {
return nullptr;
}
}
template <typename T, typename TAllocator>
void allocatorDelete(TAllocator& allocator, T* ptr) {
if (!ptr) {
return;
}
ptr->~T();
MemoryBlock block(ptr, sizeof(T));
allocator.deallocate(block);
}
INLINE constexpr std::size_t roundToAlignment(const std::size_t value, const std::size_t align) noexcept {
const std::size_t remainder = value % align;
return value + ((remainder == 0) ? 0 : (align - remainder));
}
template <typename T>
INLINE T* roundToAlignment(T* value, const std::size_t align) noexcept {
const std::size_t remainder = reinterpret_cast<std::size_t>(value) % align;
return value + ((remainder == 0) ? 0 : (align - remainder));
}
INLINE bool isAligned(const std::size_t value, const std::size_t align) noexcept {
return value % align == 0;
}
template <typename T>
INLINE bool isAligned(const T* value, const std::size_t align) noexcept {
return reinterpret_cast<std::size_t>(value) % align == 0;
}
/// \brief Default allocator, simply wrapping _mm_malloc and _mm_free calls.
class Mallocator {
public:
INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
MemoryBlock block;
block.ptr = _mm_malloc(size, align);
if (block.ptr) {
block.size = size;
} else {
block.size = 0;
}
return block;
}
INLINE void deallocate(MemoryBlock& block) noexcept {
_mm_free(block.ptr);
block.ptr = nullptr;
}
};
/// \brief Allocator used pre-allocated fixed-size buffer on stack.
///
/// Function \ref allocate returns an empty block if the allocator does not have enough available memory.
template <std::size_t TSize, Size TAlign = 16>
class StackAllocator : public Immovable, Local {
private:
alignas(TAlign) uint8_t data[TSize];
/// Current position in the buffer
uint8_t* pos = data;
public:
INLINE MemoryBlock allocate(const std::size_t size, const std::size_t UNUSED(align)) noexcept {
SPH_ASSERT(size > 0);
const std::size_t actSize = roundToAlignment(size, TAlign);
if (pos - data + actSize > TSize) {
return MemoryBlock::EMPTY();
}
void* ptr = pos;
pos += size;
return { ptr, size };
}
INLINE void deallocate(MemoryBlock& block) noexcept {
if (!block.ptr) {
return;
}
if ((uint8_t*)block.ptr + block.size == pos) {
pos = static_cast<uint8_t*>(block.ptr);
}
block = MemoryBlock::EMPTY();
}
INLINE bool owns(const MemoryBlock& block) const noexcept {
return block.ptr >= data && block.ptr < data + TSize;
}
};
/// \brief Allocator that attemps to allocate using given primary allocator, and if the allocation fails, it
/// allocates using a second fallback allocator.
///
/// Note that this is just a simple compositor and it doesn't guarantee that the fallback allocation succeeds.
/// To ensure the allocation is successful, consider nesting multiple fallback allocators together and provide
/// an allocator that cannot fail as the last one.
template <typename TPrimary, typename TFallback>
class FallbackAllocator : private TPrimary, private TFallback {
public:
INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
MemoryBlock block = TPrimary::allocate(size, align);
if (block.ptr) {
return block;
} else {
return TFallback::allocate(size, align);
}
}
INLINE void deallocate(MemoryBlock& block) noexcept {
if (TPrimary::owns(block)) {
TPrimary::deallocate(block);
} else {
TFallback::deallocate(block);
}
}
INLINE const TPrimary& primary() const {
return *this;
}
INLINE TPrimary& primary() {
return *this;
}
INLINE const TFallback& fallback() const {
return *this;
}
INLINE TFallback& fallback() {
return *this;
}
};
/// \brief Compositor that uses one allocator for small allocations and another allocator for large
/// allocations.
template <std::size_t TLimit, typename TSmall, typename TLarge>
class Segregator : private TSmall, private TLarge {
public:
INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
if (size <= TLimit) {
return TSmall::allocate(size, align);
} else {
return TLarge::allocate(size, align);
}
}
INLINE void deallocate(MemoryBlock& block) noexcept {
if (block.size <= TLimit) {
TSmall::deallocate(block);
} else {
TLarge::deallocate(block);
}
}
INLINE bool owns(const MemoryBlock& block) const noexcept {
if (block.size <= TLimit) {
return TSmall::owns(block);
} else {
return TLarge::owns(block);
}
}
INLINE const TSmall& small() const {
return *this;
}
INLINE const TLarge& large() const {
return *this;
}
};
/// \brief Helper allocator that keeps track on allocated memory.
template <typename TAllocator>
class TrackingAllocator : private TAllocator {
private:
std::size_t memory = 0;
public:
INLINE MemoryBlock allocate(const std::size_t size, const std::size_t align) noexcept {
MemoryBlock block = TAllocator::allocate(size, align);
if (block.ptr) {
memory += size;
}
return block;
}
INLINE void deallocate(MemoryBlock& block) noexcept {
if (block.ptr) {
memory -= block.size;
}
TAllocator::deallocate(block);
}
INLINE bool owns(const MemoryBlock& block) const noexcept {
return TAllocator::owns(block);
}
INLINE std::size_t allocated() const {
return memory;
}
INLINE const TAllocator& underlying() const {
return *this;
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
gui/windows/RunPage.h
|
<gh_stars>10-100
#pragma once
#include "gui/Settings.h"
#include "gui/windows/Widgets.h"
#include "objects/containers/Array.h"
#include "objects/wrappers/LockingPtr.h"
#include "system/Settings.h"
#include "system/Timer.h"
#include <wx/panel.h>
class wxBoxSizer;
class wxGauge;
class wxCheckBox;
class wxTextCtrl;
class wxPanel;
class wxDialog;
class wxAuiManager;
class wxAuiNotebookEvent;
NAMESPACE_SPH_BEGIN
class IColorizer;
class IGraphicsPane;
class IPlot;
class IPluginControls;
class Controller;
class OrthoPane;
class ParticleProbe;
class PlotView;
class Particle;
class Rgba;
class Statistics;
class Storage;
struct DiagnosticsError;
class SelectedParticlePlot;
class TimeLine;
class ProgressPanel;
class PalettePanel;
/// \brief Main frame of the application.
///
/// Run is coupled with the window; currently there can only be one window and one run at the same time. Run
/// is ended when user closes the window.
class RunPage : public ClosablePage {
private:
/// Parent control object
RawPtr<Controller> controller;
AutoPtr<wxAuiManager> manager;
/// Gui settings
GuiSettings& gui;
/// Drawing pane (owned by wxWidgets)
RawPtr<IGraphicsPane> pane;
RawPtr<ParticleProbe> probe;
Array<LockingPtr<IPlot>> plots;
Array<RawPtr<PlotView>> plotViews;
LockingPtr<SelectedParticlePlot> selectedParticlePlot;
PalettePanel* palettePanel = nullptr;
wxTextCtrl* statsText = nullptr;
Timer statsTimer;
/// Additional wx controls
ComboBox* quantityBox = nullptr;
Size selectedIdx = 0;
wxPanel* quantityPanel = nullptr;
TimeLine* timelineBar = nullptr;
ProgressPanel* progressBar = nullptr;
wxPanel* statsBar = nullptr;
/// Colorizers corresponding to the items in combobox
Array<SharedPtr<IColorizer>> colorizerList;
public:
RunPage(wxWindow* window, Controller* controller, GuiSettings& guiSettings);
~RunPage();
void refresh();
void showTimeLine(const bool show);
void runStarted(const Storage& storage, const Path& path);
void onTimeStep(const Storage& storage, const Statistics& stats);
void onRunEnd();
void setProgress(const Statistics& stats);
void newPhase(const std::string& className, const std::string& instanceName);
void setColorizerList(Array<SharedPtr<IColorizer>>&& colorizers);
void setSelectedParticle(const Particle& particle, const Rgba color);
void deselectParticle();
wxSize getCanvasSize() const;
private:
virtual bool isRunning() const override;
virtual void stop() override;
virtual void quit() override;
/// Toolbar on the top, containing buttons for controlling the run.
// wxPanel* createToolBar();
/// Panel on the right with particle data
wxPanel* createProbeBar();
/// Panel on the right with plots
wxPanel* createPlotBar();
/// Panel on the left, with visualization controls
wxPanel* createVisBar();
/// Panel on the right, with run statistics and error reporting
wxPanel* createStatsBar();
wxWindow* createParticleBox(wxPanel* parent);
wxWindow* createRaymarcherBox(wxPanel* parent);
wxWindow* createVolumeBox(wxPanel* parent);
void makeStatsText(const Size particleCnt, const Size pointCnt, const Statistics& stats);
void setColorizer(const Size idx);
void replaceQuantityBar(const Size idx);
void addComponentIdBar(wxWindow* parent, wxSizer* sizer, SharedPtr<IColorizer> colorizer);
void updateCutoff(const double cutoff);
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/quantities/Attractor.h
|
#pragma once
#include "system/Settings.h"
NAMESPACE_SPH_BEGIN
enum class AttractorSettingsId {
/// String identifier of the attractor
LABEL = 0,
/// If true, the attractor absorbs any particle that falls below the attractor's radius.
BLACK_HOLE = 1,
/// Texture
VISUALIZATION_TEXTURE = 100,
};
using AttractorSettings = Settings<AttractorSettingsId>;
/// \brief Single point-mass particle.
///
/// Extra properties of the attractor can be stored in the settings member variable.
struct Attractor {
Vector position;
Vector velocity = Vector(0._f);
Vector acceleration = Vector(0._f);
Float radius;
Float mass;
AttractorSettings settings = EMPTY_SETTINGS;
Attractor() = default;
Attractor(const Vector& position, const Vector& velocity, const Float radius, const Float mass)
: position(position)
, velocity(velocity)
, radius(radius)
, mass(mass) {}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/objects/finders/NeighborFinder.h
|
#pragma once
/// \file NeighborFinder.h
/// \brief Base class defining interface for kNN queries.
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "objects/containers/ArrayView.h"
#include "objects/finders/Order.h"
#include "objects/geometry/Vector.h"
#include "objects/wrappers/Flags.h"
NAMESPACE_SPH_BEGIN
class IScheduler;
/// \brief Holds information about a neighbor particles
struct NeighborRecord {
/// Index of particle in the storage
Size index;
/// Squared distance of the particle from the queried particle / position
Float distanceSqr;
bool operator!=(const NeighborRecord& other) const {
return index != other.index || distanceSqr != other.distanceSqr;
}
/// Sort by the distance
bool operator<(const NeighborRecord& other) const {
return distanceSqr < other.distanceSqr;
}
};
/// \brief Interface of objects finding neighboring particles.
///
/// Provides queries for searching particles within given radius from given particle or given point in space.
/// Object has to be built before neighbor queries can be made.
class IBasicFinder : public Polymorphic {
protected:
/// View of the source datapoints, updated every time (re)build is called
ArrayView<const Vector> values;
public:
/// \brief Constructs the struct with an array of vectors.
///
/// Must be called before \ref findAll is called or if the referenced array is invalidated.
/// \param scheduler Scheduler that can be used for parallelization.
/// \param points View of the array of points in space.
void build(IScheduler& scheduler, ArrayView<const Vector> points);
/// \brief Finds all neighbors within given radius from the point given by index.
///
/// Point view passed in \ref build must not be invalidated, in particular the number of particles must
/// not change before function \ref findAll is called. Note that the particle itself (index-th particle)
/// is also included in the list of neighbors.
/// \param index Index of queried particle in the view given in \ref build function.
/// \param radius Radius in which the neighbors are searched. Must be a positive value.
/// \param neighbors Output parameter, containing the list of neighbors as indices to the array. The
/// array is cleared by the function.
/// \return The number of located neighbors.
virtual Size findAll(const Size index, const Float radius, Array<NeighborRecord>& neighbors) const = 0;
/// \brief Finds all points within given radius from given position.
///
/// The position may not correspond to any point.
virtual Size findAll(const Vector& pos, const Float radius, Array<NeighborRecord>& neighbors) const = 0;
protected:
/// \brief Builds finder from set of vectors.
///
/// This must be called before \ref findAll, can be called more than once.
/// \param scheduler Scheduler that can be used for parallelization.
/// \param points View of the array of points in space.
virtual void buildImpl(IScheduler& scheduler, ArrayView<const Vector> points) = 0;
};
enum class FinderFlag {
/// Creates the ranks of particles. Without this flag, only the IBasicFinder interface can be used.
MAKE_RANK = 1 << 0,
/// The rank of particles is not created. 'Dummy' option that can be used to improve readability.
SKIP_RANK = 0,
};
/// \brief Generates the ranks of particles, according to generic predicate.
template <typename TCompare>
static Order makeRank(const Size size, TCompare&& comp) {
Order tmp(size);
// sort using the given comparator
tmp.shuffle(comp);
// invert to get the rank
return tmp.getInverted();
}
/// \brief Extension of IBasicFinder, allowing to search only particles with lower rank in smoothing length.
///
/// This is useful to find each pair of neighboring particles only once; if i-th particle 'sees' j-th
/// particle, j-th particle does not 'see' i-th particle. This can be a significant optimization as only half
/// of the neighbors is evaluated.
class ISymmetricFinder : public IBasicFinder {
protected:
/// Ranks of particles according to their smoothing lengths
Order rank;
public:
/// \brief Constructs the struct with an array of vectors.
void build(IScheduler& scheduler,
ArrayView<const Vector> points,
Flags<FinderFlag> flags = FinderFlag::MAKE_RANK);
/// \brief Constructs the struct with custom predicate for ordering particles.
template <typename TCompare>
void buildWithRank(IScheduler& scheduler, ArrayView<const Vector> points, TCompare&& comp) {
values = points;
rank = makeRank(values.size(), comp);
this->buildImpl(scheduler, values);
}
/// \brief Finds all points within radius that have a lower rank in smoothing length.
///
/// The sorting of particles with equal smoothing length is not specified, but it is ensured that all
/// found neighbors will not find the queries particle if \ref findAsymmetric is called with that
/// particle. Note that this does NOT find the queried particle itself.
/// \param index Index of queried particle in the view given in \ref build function.
/// \param radius Radius in which the neighbors are searched. Must be a positive value.
/// \param neighbors Output parameter, containing the list of neighbors as indices to the array. The
/// array is cleared by the function.
/// \return The number of located neighbors. Can be zero.
virtual Size findLowerRank(const Size index,
const Float radius,
Array<NeighborRecord>& neighbors) const = 0;
};
/// \brief Helper template, allowing to define all three functions with a single function.
template <typename TDerived>
class FinderTemplate : public ISymmetricFinder {
public:
virtual Size findAll(const Size index,
const Float radius,
Array<NeighborRecord>& neighbors) const override {
neighbors.clear();
return static_cast<const TDerived*>(this)->template find<true>(
values[index], index, radius, neighbors);
}
virtual Size findAll(const Vector& pos,
const Float radius,
Array<NeighborRecord>& neighbors) const override {
neighbors.clear();
if (SPH_UNLIKELY(values.empty())) {
return 0._f;
}
// the index here is irrelevant, so let's use something that would cause assert in case we messed
// something up
const Size index = values.size();
return static_cast<const TDerived*>(this)->template find<true>(pos, index, radius, neighbors);
}
virtual Size findLowerRank(const Size index,
const Float radius,
Array<NeighborRecord>& neighbors) const override {
neighbors.clear();
return static_cast<const TDerived*>(this)->template find<false>(
values[index], index, radius, neighbors);
}
};
NAMESPACE_SPH_END
|
pavelsevecek/OpenSPH
|
core/sph/boundary/Boundary.h
|
<gh_stars>10-100
#pragma once
/// \file Boundary.h
/// \brief Boundary conditions
/// \author <NAME> (sevecek at s<EMAIL>)
/// \date 2016-2021
#include "common/ForwardDecl.h"
#include "objects/containers/Array.h"
#include "objects/geometry/Domain.h"
#include "objects/geometry/Vector.h"
#include "objects/wrappers/AutoPtr.h"
#include "objects/wrappers/Interval.h"
#include "quantities/Storage.h"
#include <set>
NAMESPACE_SPH_BEGIN
class ISymmetricFinder;
/// \brief Base object for boundary conditions.
///
/// All boundary conditions behave similarly to equation terms, meaning they can modify the storage each time
/// step before the derivatives are computed (in \ref initialize function) and after derivatives are computed
/// (in \ref finalize function).
/// They do not create any quantities nor they compute derivatives. In solver, boundary conditions are
/// evaluated after all the equations have been evaluated. This is needed in order to copy the correct
/// quantities on ghosts, make sure that derivatives are zero/clamped as needed, etc.
class IBoundaryCondition : public Polymorphic {
public:
/// \brief Applies the boundary conditions before the derivatives are computed.
///
/// Called every time step after equations are initialized.
virtual void initialize(Storage& storage) = 0;
/// \brief Applies the boundary conditions after the derivatives are computed.
///
/// Called every time step after equations are evaluated (finalized).
virtual void finalize(Storage& storage) = 0;
};
struct NullBoundaryCondition : public IBoundaryCondition {
virtual void initialize(Storage& UNUSED(storage)) override {}
virtual void finalize(Storage& UNUSED(storage)) override {}
};
/// \brief Provides a way to access ghost particle data outside the solver.
class GhostParticlesData : public IStorageUserData {
private:
Array<Ghost> ghosts;
public:
explicit GhostParticlesData(Array<Ghost>&& ghosts)
: ghosts(std::move(ghosts)) {}
/// \brief Returns the reference to ghost particle with given index.
Ghost& getGhost(const Size idx) {
return ghosts[idx];
}
/// \brief Returns the total number of ghost particles.
Size size() const {
return ghosts.size();
}
};
/// \brief Adds ghost particles symmetrically for each SPH particle close to boundary.
///
/// All physical quantities are copied on them. This acts as a natural boundary for SPH particles without
/// creating unphysical gradients due to discontinuity.
class GhostParticles : public IBoundaryCondition {
public:
/// Special flag denoting ghost particles.
static constexpr Size FLAG = Size(-1);
private:
Array<Ghost> ghosts;
Array<Size> ghostIdxs;
SharedPtr<IDomain> domain;
/// Parameters of the BCs
struct {
Float searchRadius;
Float minimalDist;
} params;
/// Optional; specifies a functor returning a velocity assigned to given ghost.
Function<Optional<Vector>(const Vector& r)> ghostVelocity;
/// Used as consistency check; currently we don't allow any other object to add or remove particles if
/// GhostParticles are used.
Size particleCnt;
public:
/// \brief Creates new boundary conditions.
/// \param domain Selected computational domain; particles close to the boundary will spawn ghosts.
/// \param searchRadius Radius of a single particle, in units of smoothing length.
/// \param minimalDist Minimal allowed distance between a particle and its ghost.
GhostParticles(SharedPtr<IDomain> domain, const Float searchRadius, const Float minimalDist);
/// \brief Creates new boundary conditions, using parameters specified in settings.
GhostParticles(SharedPtr<IDomain> domain, const RunSettings& settings);
/// \brief Specifies a functor that overrides the default velocity assinged to each ghost.
///
/// By default, the velocity of a ghost is mirrored with a respect to the boundary; the tangential
/// conponents of the velocities of the particle and the corresponding ghost are equal. The provided
/// function may return a different velocity to obtain different boundary condition at different parts of
/// the boundary, for example it may return zero velocity to create friction between the particles and the
/// boundary.
/// \param ghostVelocity Functor taking ghost position as parameter and returning velocity assigned to
/// the ghost or NOTHING to assign the default velocity.
void setVelocityOverride(Function<Optional<Vector>(const Vector& r)> ghostVelocity);
virtual void initialize(Storage& storage) override;
virtual void finalize(Storage& storage) override;
};
/// \brief Places immovable particles along boundary.
///
/// The dummy particles can have generally different material than the rest of the simulation.
class FixedParticles : public IBoundaryCondition {
public:
struct Params {
/// Computational domain; dummy particles will be placed outside of the domain
AutoPtr<IDomain> domain;
/// Distribution used to create the dummy particles
AutoPtr<IDistribution> distribution;
/// Material of the dummy particles. This can be generally different than the material of "real"
/// particles in the simulation, specifically the material is not copied as for ghost particles.
AutoPtr<IMaterial> material;
/// Maximum size of the boundary layer. Note that this is an absolute value, it is NOT in units of
/// smoothing length.
Float thickness = NAN;
};
private:
/// Storage containing the fixed particles.
Storage fixedParticles;
public:
FixedParticles(const RunSettings& settings, Params&& params);
virtual void initialize(Storage& storage) override;
virtual void finalize(Storage& storage) override;
};
/// \brief Boundary condition that nulls all highest derivates of selected particles.
///
/// Term can freeze particles close to the boundary and/or particles of given body or list of bodies. This
/// will cause the particles to keep quantity values given by their initial conditions and move with initial
/// velocity. The 'frozen' particles affect other particles normally and contribute to all integrals, such as
/// total mometum or energy.
class FrozenParticles : public IBoundaryCondition {
protected:
SharedPtr<IDomain> domain;
Float radius;
std::set<Size> frozen;
Array<Float> distances;
Array<Size> idxs;
public:
/// \brief Constructs boundary conditions with no particles frozen.
///
/// These can be later added using freeze function.
FrozenParticles();
~FrozenParticles();
/// \brief Constructs boundary conditions with frozen particles near boundary.
///
/// \param domain Domain defining the boundary
/// \param radius Search radius (in units of smoothing length) up to which the particles will be frozen.
FrozenParticles(SharedPtr<IDomain> domain, const Float radius);
/// \brief Adds body ID particles of which shall be frozen by boundary conditions.
void freeze(const Size flag);
/// \brief Remove a body from the list of frozen bodies.
///
/// If the body is not on the list, nothing happens.
void thaw(const Size flag);
virtual void initialize(Storage& UNUSED(storage)) override {}
virtual void finalize(Storage& storage) override;
};
/// \brief Boundary conditions creating particles with given velocity at the boundary of the domain.
///
/// Outgoing particles are removed at the other side of the boundary, particles inside the domain are kept in
/// place using either ghost particles or by freezing them. This is fine-tuned for simulations of a meteorite
/// passing through athmosphere.
class WindTunnel : public FrozenParticles {
public:
WindTunnel(SharedPtr<IDomain> domain, const Float radius);
virtual void initialize(Storage& UNUSED(storage)) override {}
virtual void finalize(Storage& storage) override;
};
/// \brief Boundary condition moving all particles passed through the domain to the other side of the domain.
class PeriodicBoundary : public IBoundaryCondition {
private:
Box domain;
Array<Ghost> ghosts;
Array<Size> ghostIdxs;
public:
explicit PeriodicBoundary(const Box& domain);
virtual void initialize(Storage& storage) override;
virtual void finalize(Storage& storage) override;
};
/// \brief Boundary duplicating particles along z=0 plane.
///
/// Particles from z>0 half-space are copied into the z<0 half-space. Any particles originally located in the
/// negative half-space are first projected to the z=0 plane.
class SymmetricBoundary : public IBoundaryCondition {
private:
Array<Ghost> ghosts;
Array<Size> ghostIdxs;
public:
virtual void initialize(Storage& storage) override;
virtual void finalize(Storage& storage) override;
};
/// \brief Boundary condition that removes particles outside the domain.
class KillEscapersBoundary : public IBoundaryCondition {
private:
SharedPtr<IDomain> domain;
public:
explicit KillEscapersBoundary(SharedPtr<IDomain> domain);
virtual void initialize(Storage& storage) override;
virtual void finalize(Storage& storage) override;
};
/// Helper tool for 1D tests, projects all particles onto a 1D line.
class Projection1D : public IBoundaryCondition {
private:
Interval domain;
ArrayView<Vector> r, v;
public:
/// Constructs using range as 1D domain
explicit Projection1D(const Interval& domain);
virtual void initialize(Storage& UNUSED(storage)) override {}
virtual void finalize(Storage& storage) override;
};
NAMESPACE_SPH_END
|
konevas/cortex-m3_fault_handler
|
fault.h
|
/**
* @brief Fault handler header
*
* @author <NAME>.
*/
/* Should be used as fault handlers entry in vector table */
void fault_entry(void);
/* Reqired to be defined */
/* void fault_common_handler(const int * stack_ptr, int handler_index); */
|
anjunhu/flakes
|
TISGrabberGlobalDefs.h
|
<reponame>anjunhu/flakes
#ifndef __GLOBALDEFS_H__
#define __GLOBALDEFS_H__
typedef enum
{
FILETYPE_BMP,
FILETYPE_JPEG,
FILETYPE_MEGA=65536 // Borland C++ 6 compatibility
} IMG_FILETYPE;
typedef enum
{
Y800,
RGB24,
RGB32,
UYVY,
Y16,
NONE, // used as return value
COLORFORMAT_MEGA=65536 // Borland C++ 6 compatibility
} COLORFORMAT;
typedef enum
{
PROP_VID_BRIGHTNESS = 0,
PROP_VID_CONTRAST,
PROP_VID_HUE,
PROP_VID_SATURATION,
PROP_VID_SHARPNESS,
PROP_VID_GAMMA,
PROP_VID_COLORENABLE,
PROP_VID_WHITEBALANCE,
PROP_VID_BLACKLIGHTCOMPENSATION,
PROP_VID_GAIN,
PROP_VID_MEGA=65536 // Borland C++ 6 compatibility
} VIDEO_PROPERTY;
typedef enum
{
PROP_CAM_PAN = 0,
PROP_CAM_TILT,
PROP_CAM_ROLL,
PROP_CAM_ZOOM,
PROP_CAM_EXPOSURE,
PROP_CAM_IRIS,
PROP_CAM_FOCUS,
PROP_CAM_MEGA=65536 // Borland C++ 6 compatibility
} CAMERA_PROPERTY;
typedef enum
{
eParamLong,
eParamBoolean,
eParamFloat,
eParamString,
eParamData
} FRAMEFILTER_PARAM_TYPE;
typedef enum
{
ePropertyRange,
ePropertyAbsoluteValue,
ePropertySwitch,
ePropertyButton,
ePropertyMapStrings,
ePropertyUnknown
} PROPERTY_INTERFACE_TYPE;
#endif
|
anjunhu/flakes
|
tisgrabber.h
|
<reponame>anjunhu/flakes<filename>tisgrabber.h<gh_stars>0
#ifndef _TISGRABBER
#define _TISGRABBER
//////////////////////////////////////////////////////////////////////////
/*! @mainpage
Please see "tisgrabber.h" for the function documentation.
*/
#include "TISGrabberGlobalDefs.h"
// WINAPI for Visual Basic
//#define AC WINAPI
//////////////////////////////////////////////////////////////////////////
/*! Calling convention of the DLL functions. For internal use only.
*/
#define AC __stdcall ///< __stdcall for Borland C and Ansi C
#ifndef _WINUSER_
//////////////////////////////////////////////////////////////////////////
/*! Workaround if we are in non windows environment.
*/
#define NOHWNDDEFINED 1
#define __HWND int ///< Workaround if we are in non windows environment.
#else
#define __HWND HWND ///<Workaround if we are in windows environment.
#endif
//////////////////////////////////////////////////////////////////////////
/*! This is the handle of an grabber object. Please use the HGRABBER type to access
this object.
*/
typedef struct HGRABBER_t__ { int unused; } HGRABBER_t; ///<Internal structure of the grabber object handle.
//////////////////////////////////////////////////////////////////////////
/*! The HGRABBER type is used to hold a handle to a grabber object. Each variable of
HGRABBER type can contain one video capture device. It is possible to create more
than one variables of this type:
HGRABBER camera1 = IC_CreateGrabber();
HGRABBER camera2 = IC_CreateGrabber();
*/
#define HGRABBER HGRABBER_t* ///< Type of grabber object handle. Used for all functions.
typedef int _cdecl IC_ENUMCB( char* Name, void*);
typedef struct FILTERPARAMETER_t__
{
char Name[30];
FRAMEFILTER_PARAM_TYPE Type;
} FILTERPARAMETER_t;
typedef struct HFRAMEFILTER_t__
{
void *pFilter;
int bHasDialog;
int ParameterCount;
FILTERPARAMETER_t *Parameters;
} HFRAMEFILTER_t;
#define HFRAMEFILTER HFRAMEFILTER_t
//////////////////////////////////////////////////////////////////////////
/*! A return value of IC_SUCCESS indicates that a function has been performed
without an error.
*/
#define IC_SUCCESS 1 ///< Return value for success.
//////////////////////////////////////////////////////////////////////////
/*! If a function returns IC_ERROR, then something went wrong.
*/
#define IC_ERROR 0 ///< Return value that indicates an error.
//////////////////////////////////////////////////////////////////////////
/*! This error indicates, that an HGRABBER handle has not been created yet. Please
see IC_CreateGrabber() for creating an HGRABBER handle.
*/
#define IC_NO_HANDLE -1 ///< No device handle. HGRABBER is NULL.
//////////////////////////////////////////////////////////////////////////
/*! This return values indicates that no device has been opened. Please refer to
IC_OpenVideoCaptureDevice().
*/
#define IC_NO_DEVICE -2 ///< No device opened, but HGRABBER is valid.
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that the video capture device is not in live mode,
but live mode is for the current function call required. Please refer to
IC_StartLive().
*/
#define IC_NOT_AVAILABLE -3 ///< Property not avaiable, but HGRABBER is valid.
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that the video capture device does not support
the specified property.
*/
#define IC_NO_PROPERTYSET -3 ///< The Propertyset was not queried.
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that the porperty set was not queried for
the current grabber handle. Please check, whether IC_QueryPropertySet()
was called once before using the function.
*/
#define IC_DEFAULT_WINDOW_SIZE_SET -3 ///< The live display window size could not be set
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that setting of a custom live display window size
failed, because IC_SetDefaultWindowPosition() was not called with parameter false
somewhere before.
@sa IC_SetDefaultWindowPosition
@sa IC_SetWindowPosition
*/
#define IC_NOT_IN_LIVEMODE -3 ///< A device has been opened, but is is not in live mode.
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that a device does not support the requested property, or
the name of a property was written in wrong way.
@sa IC_GetPropertyValueRange
*/
#define IC_PROPERTY_ITEM_NOT_AVAILABLE -4 ///< A requested property item is not available
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that a device does not support the requested element property, or
the name of an element was written in wrong way.
@sa IC_GetPropertyValueRange
*/
#define IC_PROPERTY_ELEMENT_NOT_AVAILABLE -5 ///< A requested element of a given property item is not available
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that a property element does not support
the request, that is wanted. e.g. Exposure Auto has no range, therefore
IC_GetPropertyValueRange(hGrabber, "Epxosure","Auto", &min, &max )
will return IC_PROPERTY_ELEMENT_WRONG_INTERFACE.
@sa IC_GetPropertyValueRange
*/
#define IC_PROPERTY_ELEMENT_WRONG_INTERFACE -6 ///< A requested element has not the interface, which is needed.
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that there was an index passed, which
was out of range of the number of available elements
@sa IC_ListDevicesbyIndex
*/
#define IC_INDEX_OUT_OF_RANGE -7 ///< A requested element has not the interface, which is needed.
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that that the passed XML file contains no valid XML
data.
@sa IC_LoadDeviceStateFromFileEx
*/
#define IC_WRONG_XML_FORMAT -1
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that the passed XML file contains no compatible XML
data.
@sa IC_LoadDeviceStateFromFileEx
*/
#define IC_WRONG_INCOMPATIBLE_XML -3
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that not all properties have been restored
as desired, but the camera itself was opened.
@sa IC_LoadDeviceStateFromFileEx
*/
#define IC_NOT_ALL_PROPERTIES_RESTORED -4
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that the device specified in the XML was not
found. E.g. The same model, but different serial number, or no camera
connected at all.
@sa IC_LoadDeviceStateFromFileEx
*/
#define IC_DEVICE_NOT_FOUND -5
//////////////////////////////////////////////////////////////////////////
/*! This return value indicates, that the passed file does not exist
@sa IC_LoadDeviceStateFromFileEx
*/
#define IC_FILE_NOT_FOUND 35
#if defined(__cplusplus)
extern "C"
{
#endif
//////////////////////////////////////////////////////////////////////////
/*! Initialize the ICImagingControl class library. This function must be called
only once before any other functions of this library are called.
@param szLicenseKey IC Imaging Control license key or NULL if only a trial version is available.
@retval IC_SUCCESS on success.
@retval IC_ERROR on wrong license key or other errors.
@sa IC_CloseLibrary
*/
int AC IC_InitLibrary( char* szLicenseKey );///<Initialize the library.
//////////////////////////////////////////////////////////////////////////
/*! Creates a new grabber handle and returns it. A new created grabber should be
release with a call to IC_ReleaseGrabber if it is no longer needed.
@retval IC_SUCCESS on success.
@retval IC_ERROR if an error occurred.
@sa IC_ReleaseGrabber
*/
HGRABBER AC IC_CreateGrabber();///<Create a new grabber handle
//////////////////////////////////////////////////////////////////////////
/*! Release the grabber object. Must be called, if the calling application
does no longer need the grabber.
@param hGrabber The handle to grabber to be released.
@sa IC_CreateGrabber
*/
void AC IC_ReleaseGrabber( HGRABBER *hGrabber ); ///< Release an HGRABBER object.
//////////////////////////////////////////////////////////////////////////
/* Must be called at the of the application to release allocated memory.
@sa IC_InitLibrary
*/
void AC IC_CloseLibrary(); ///< Closes the library, cleans up memory.
//////////////////////////////////////////////////////////////////////////
/*! Open a video capture device. The hGrabber handle must have been created previously by
a call to IC_CreateGrabber(). Once a hGrabber handle has been created it can be
recycled to open different video capture devices in sequence.
@param hGrabber The handle to grabber object, that has been created by a call to IC_CreateGrabber
@param szDeviceName Friendly name of the video capture device e.g. "DFK 21F04".
@retval IC_SUCCESS on success.
@retval IC_ERROR on errors.
@sa IC_CloseVideoCaptureDevice
@code
#include "tisgrabber.h"
void main()
{
HGRABBER hGrabber;
if( IC_InitLibrary(0) == IC_SUCCESS )
{
hGrabber = IC_CreateGrabber();
if( hGrabber )
{
if( IC_OpenVideoCaptureDevice(hGrabber,"DFK 21F04") == IC_SUCCESS )
{
// .. do something with the video capture device.
// Now clean up.
IC_CloseVideoCaptureDevice( hGrabber );
IC_ReleaseGrabber( hGrabber );
}
IC_CloseLibrary();
}
}
@endcode
*/
int AC IC_OpenVideoCaptureDevice( HGRABBER hGrabber, char *szDeviceName ); ///< Opens a video capture device.
//////////////////////////////////////////////////////////////////////////
/*! Close the current video capture device. The HGRABBER object will not be deleted.
It can be used again for opening another video capture device.
@param hGrabber The handle to the grabber object.
*/
void AC IC_CloseVideoCaptureDevice( HGRABBER hGrabber ); ///<Closes a video capture device.
//////////////////////////////////////////////////////////////////////////
/*! Retrieve the name of the current video capture device. If the device is
invalid, NULL is returned.
@param hGrabber The handle to the grabber object.
@retval char* The name of the video capture device
@retval NULL If no video capture device is currently opened.
*/
char* AC IC_GetDeviceName(HGRABBER hGrabber ); ///<Returns the name of the current video capture device.
int AC IC_GetVideoFormatWidth( HGRABBER hGrabber); ///<Returns the width of the video format.
int AC IC_GetVideoFormatHeight( HGRABBER hGrabber);///<returns the height of the video format.
//////////////////////////////////////////////////////////////////////////
/*! Set the sink type. A sink type must be set before images can be snapped.
The sink type basically describes the format of the buffer where the snapped
images are stored.
Possible values for format are:
@li Y800
@li RGB24
@li RGB32
@li UYVY
The sink type may differ from the currently set video format.
@param hGrabber The handle to the grabber object.
@param format The desired color format. Possible values for format are:
@li Y800
@li RGB24
@li RGB32
@li UYVY
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@note Please note that UYVY can only be used in conjunction with a UYVY video format.
*/
int AC IC_SetFormat( HGRABBER hGrabber, COLORFORMAT format ); ///< Sets the color format of the sink.
//////////////////////////////////////////////////////////////////////////
/*! Retrieves the format of the sink type currently set (See IC_SetFormat()
for possible formats). If no sink type is set
or an error occurred, NONE is returned.
The function returns a valid value only after IC_PreprareLive() or IC_StartLive()
was called. Before these calls, NONE is returned.
@param hGrabber The handle to the grabber object.
@return The current sink color format.
*/
COLORFORMAT AC IC_GetFormat( HGRABBER hGrabber ); ///<Returns the current color format of the sink.
//////////////////////////////////////////////////////////////////////////
/*! Set a video format for the current video capture device. The video format
must be supported by the current video capture device.
@param hGrabber The handle to the grabber object.
@param szFormat A string that contains the desired video format.
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@code
#include "tisgrabber.h"
void main()
{
HGRABBER hGrabber;
if( IC_InitLibrary(0) == IC_SUCCESS )
{
hGrabber = IC_CreateGrabber();
if( hGrabber )
{
if( IC_OpenVideoCaptureDevice(hGrabber,"DFK 21F04") == IC_SUCCESS )
{
if( IC_SetVideoFormat(hGrabber,"UYVY (640x480)" == IC_SUCCESS )
{
// .. do something with the video capture device.
}
// Now clean up.
IC_CloseVideoCaptureDevice( hGrabber );
IC_ReleaseGrabber( hGrabber );
}
IC_CloseLibrary();
}
}
}
@endcode
*/
int AC IC_SetVideoFormat( HGRABBER hGrabber, char *szFormat ); ///<Sets the video format.
//////////////////////////////////////////////////////////////////////////
/*! Set a video norm for the current video capture device.
@note The current video capture device must support video norms.
@param hGrabber The handle to the grabber object.
@param szNorm A string that contains the desired video format.
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
*/
int AC IC_SetVideoNorm( HGRABBER hGrabber, char *szNorm ); ///<Set the video norm.
//////////////////////////////////////////////////////////////////////////
/*! Set a input channel for the current video capture device.
@note The current video capture device must support input channels..
@param hGrabber The handle to the grabber object.
@param szChannel A string that contains the desired video format.
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
*/
int AC IC_SetInputChannel( HGRABBER hGrabber, char *szChannel ); ///<Sets an input channel.
//////////////////////////////////////////////////////////////////////////
/*! Start the live video.
@param hGrabber The handle to the grabber object.
@param iShow The parameter indicates: @li 1 : Show the video @li 0 : Do not show the video, but deliver frames. (For callbacks etc.)
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@sa IC_StopLive
*/
int AC IC_StartLive( HGRABBER hGrabber, int iShow ); ///<Starts the live video.
int AC IC_PrepareLive( HGRABBER hGrabber, int iShow); ///<Prepare the grabber for starting the live video.
int AC IC_SuspendLive(HGRABBER hGrabber); ///<Suspends an image stream and puts it into prepared state.
//////////////////////////////////////////////////////////////////////////
/*! Check, whether the passed grabber already provides are live video
@param hGrabber The handle to the grabber object.
@retval 1 : Livevideo is running, 0 : Livevideo is not running.
@retval IC_NO_HANDLE hGrabber is not a valid handle. GetGrabber was not called.
@retval IC_NO_DEVICE No device opened. Open a device, before this function can be used.
*/
int AC IC_IsLive( HGRABBER hGrabber );
//////////////////////////////////////////////////////////////////////////
/*! Stop the live video.
@param hGrabber The handle to the grabber object.
@sa IC_StartLive
*/
void AC IC_StopLive( HGRABBER hGrabber ); ///<Stops the live video.
//////////////////////////////////////////////////////////////////////////
/*! Check, whether a property is supported by the current video capture device.
@param hGrabber The handle to the grabber object.
@sa eProperty The cammera property to be checked
@retval IC_SUCCESS The property is supported.
@retval IC_ERROR The property is not supported.
@retval IC_NO_HANDLE hGrabber is not a valid handle. GetGrabber was not called.
@retval IC_NO_DEVICE No device opened. Open a device, before this function can be used.
*/
int AC IC_IsCameraPropertyAvailable( HGRABBER hGrabber, CAMERA_PROPERTY eProperty ); ///< Check whether a camera property is available.
//////////////////////////////////////////////////////////////////////////
/*! Set a camera property like exposure, zoom.
@param hGrabber The handle to the grabber object.
@param eProperty The property to be set. It can have following values:
@li PROP_CAM_PAN
@li PROP_CAM_TILT,
@li PROP_CAM_ROLL,
@li PROP_CAM_ZOOM,
@li PROP_CAM_EXPOSURE,
@li PROP_CAM_IRIS,
@li PROP_CAM_FOCUS
@param lValue The value the property is to be set to.
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@note lValue should be in the range of the specified property.
If the value could not be set (out of range, auto is currently enabled), the
function returns 0. On success, the functions returns 1.
*/
int AC IC_SetCameraProperty( HGRABBER hGrabber, CAMERA_PROPERTY eProperty, long lValue ); ///< Set a camera property.
int AC IC_CameraPropertyGetRange( HGRABBER hGrabber, CAMERA_PROPERTY eProperty, long *lMin, long *lMax); ///<Get the minimum and maximum value of a camera property
int AC IC_GetCameraProperty( HGRABBER hGrabber, CAMERA_PROPERTY eProperty, long *lValue); ///< Get a camera property's value.
//////////////////////////////////////////////////////////////////////////
/*! Enable or disable automatic for a camera property.
@param hGrabber The handle to the grabber object.
@param iProperty The property to be set. It can have following values:
@li PROP_CAM_PAN
@li PROP_CAM_TILT,
@li PROP_CAM_ROLL,
@li PROP_CAM_ZOOM,
@li PROP_CAM_EXPOSURE,
@li PROP_CAM_IRIS,
@li PROP_CAM_FOCUS
@param iOnOFF Enables or disables the automation. Possible values ar
@li 1 : Enable automatic
@li 0 : Disable Automatic
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@note If the property is not supported by the current video capture device or
automation of the property is not available with the current video capture
device, the function returns 0. On success, the function returns 1.
*/
int AC IC_EnableAutoCameraProperty( HGRABBER hGrabber, int iProperty, int iOnOff ); ///<Enables or disables property automation.
int AC IC_IsCameraPropertyAutoAvailable( HGRABBER hGrabber, CAMERA_PROPERTY iProperty ); ///<Check whether automation for a camera property is available.
int AC IC_GetAutoCameraProperty( HGRABBER hGrabber, int iProperty, int *iOnOff ); ///<Retrieve whether automatic is enabled for the specifield camera property.
int AC IC_IsVideoPropertyAvailable( HGRABBER hGrabber, VIDEO_PROPERTY eProperty ); ///<Check whether the specified video property is available.
int AC IC_VideoPropertyGetRange( HGRABBER hGrabber, VIDEO_PROPERTY eProperty, long *lMin, long *lMax); ///<Retrieve the lower and upper limit of a video property.
int AC IC_GetVideoProperty( HGRABBER hGrabber, VIDEO_PROPERTY eProperty, long *lValue ); ///< Retrieve the the current value of the specified video property.
int AC IC_IsVideoPropertyAutoAvailable( HGRABBER hGrabber, VIDEO_PROPERTY eProperty ); ///<Check whether the specified video property supports automation.
int AC IC_GetAutoVideoProperty( HGRABBER hGrabber, int iProperty, int *iOnOff ); ///<Get the automation state of a video property.
//////////////////////////////////////////////////////////////////////////
/*! Set a video property like brightness, contrast.
@param hGrabber The handle to the grabber object.
@param eProperty The property to be set. It can have following values:
@li PROP_VID_BRIGHTNESS ,
@li PROP_VID_CONTRAST,
@li PROP_VID_HUE,
@li PROP_VID_SATURATION,
@li PROP_VID_SHARPNESS,
@li PROP_VID_GAMMA,
@li PROP_VID_COLORENABLE,
@li PROP_VID_WHITEBALANCE,
@li PROP_VID_BLACKLIGHTCOMPENSATION,
@li PROP_VID_GAIN
@param lValue The value the property is to be set to.
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@note lValue should be in the range of the specified property.
If the value could not be set (out of range, auto is currently enabled), the
function returns 0. On success, the functions returns 1.
*/
int AC IC_SetVideoProperty( HGRABBER hGrabber, VIDEO_PROPERTY eProperty, long lValue ); ///<Set a video property.
//////////////////////////////////////////////////////////////////////////
/*! Enable or disable automatic for a video propertery.
@param hGrabber The handle to the grabber object.
@param iProperty The property to be set. It can have following values:
@li PROP_VID_BRIGHTNESS,
@li PROP_VID_CONTRAST,
@li PROP_VID_HUE,
@li PROP_VID_SATURATION,
@li PROP_VID_SHARPNESS,
@li PROP_VID_GAMMA,
@li PROP_VID_COLORENABLE,
@li PROP_VID_WHITEBALANCE,
@li PROP_VID_BLACKLIGHTCOMPENSATION,
@li PROP_VID_GAIN
@param iOnOFF Enables or disables the automation. Possible values ar
@li 1 : Enable automatic
@li 0 : Disable Automatic
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
@note If the property is not supported by the current video capture device or
automation of the property is not available with the current video capture
device, the function reurns 0. On success, the function returns 1.
*/
int AC IC_EnableAutoVideoProperty( HGRABBER hGrabber, int iProperty, int iOnOff ); ///< Switch automatition for a video property,
//////////////////////////////////////////////////////////////////////////
/*! Retrieve the properties of the current video format and sink type
@param hGrabber The handle to the grabber object.
@param *lWidth This recieves the width of the image buffer.
@param *lHeight This recieves the height of the image buffer.
@param *iBitsPerPixel This recieves the count of bits per pixel.
@param *format This recieves the current color format.
@retval IC_SUCCESS on success
@retval IC_ERROR if something went wrong.
*/
int AC IC_GetImageDescription( HGRABBER hGrabber, long *lWidth, long *lHeight, int *iBitsPerPixel, COLORFORMAT *format );///<Retrieve the properties of the current video format and sink typ.
//////////////////////////////////////////////////////////////////////////
/*! Snaps an image. The video capture device must be set to live mode and a
sink type has to be set before this call. The format of the snapped images depend on
the selected sink type.
@param hGrabber The handle to the grabber object.
@param iTimeOutMillisek The Timeout time is passed in milli seconds. A value of -1 indicates, that
no time out is set.
@retval IC_SUCCESS if an image has been snapped
@retval IC_ERROR if something went wrong.
@retval IC_NOT_IN_LIVEMODE if the live video has not been started.
@sa IC_StartLive
@sa IC_SetFormat
*/
int AC IC_SnapImage( HGRABBER hGrabber, int iTimeOutMillisek); ///<Snaps an image from the live stream.
//////////////////////////////////////////////////////////////////////////
/*! Save the contents of the last snapped image by IC_SnapImage into a file.
@param hGrabber The handle to the grabber object.
@param szFileName String containing the file name to be saved to.
@param ft File type if the image, It have be
@li FILETYPE_BMP for bitmap files
@li FILETYPE_JPEG for JPEG file.
@param quality If the JPEG format is used, the image quality must be specified in a range from 0 to 100.
@retval IC_SUCCESS if an image has been snapped
@retval IC_ERROR if something went wrong.
@remarks
The format of the saved images depend on the sink type. If the sink type
is set to Y800, the saved image will be an 8 Bit grayscale image. In any
other case the saved image will be a 24 Bit RGB image.
@note IC Imaging Control 1.41 only supports FILETYPE_BMP.
@sa IC_SnapImage
@sa IC_SetFormat
*/
int AC IC_SaveImage( HGRABBER hGrabber, char *szFileName, IMG_FILETYPE ft, long quality ); ///< Saves an image to a file.
//////////////////////////////////////////////////////////////////////////
/*! Retrieve a byte pointer to the image data (pixel data) of the last snapped
image (see SnapImage()). If the function fails, the return value is NULL
otherwise the value is a pointer to the first byte in the lowest image line
(the image is saved bottom up!).
@param hGrabber The handle to the grabber object.
@retval Nonnull Pointer to the image data
@retval NULL Indicates that an error occurred.
@sa IC_SnapImage
@sa IC_SetFormat
*/
unsigned char* AC IC_GetImagePtr( HGRABBER hGrabber ); ///< Retuns a pointer to the image data
//////////////////////////////////////////////////////////////////////////
/*! Assign an Window handle to display the video in.
@param hGrabber The handle to the grabber object.
@param hWnd The handle of the window where to display the live video in.
@retval IC_SUCCESS if an image has been snapped
@retval IC_ERROR if something went wrong.
*/
int AC IC_SetHWnd( HGRABBER hGrabber, __HWND hWnd ); ///< Sets a window handle for live display
//////////////////////////////////////////////////////////////////////////
/*! Return the serialnumber of the current device. Memory for the serialnumber
must has been allocated by the application:
@code
char szSerial[20];
GetSerialNumber( hGrabber, szSerial );
@endcode
This function decodes the The Imaging Source serialnumbers.
@param hGrabber The handle to the grabber object.
@param szSerial char array that recieves the serial number.
@retval IC_SUCCESS The serial number could be retrieved.
@retval IC_IC_NOT_AVAILABLE The video capture device does not provide a serial number.
@retval IC_NO_DEVICE No video capture device opened-
@retval IC_NO_HANDLE hGrabber is NULL.
*/
int AC IC_GetSerialNumber( HGRABBER hGrabber, char* szSerial );///<Return the video capture device's serial number.
//////////////////////////////////////////////////////////////////////////
/*! Count all connected video capture devices. If the Parameter szDeviceList
is NULL, only the number of devices is queried. The Parameter szDeviceList
must be a two dimensional array of char. The iSize parameter specifies the
length of the strings, that are used in the array.
@param szDeviceList A two dimensional char array that recieves the list. Or NULL if only the count of devices is to be returned.
@param iSize Not used.
@retval >= 0 Success, count of found devices
@retval <0 An error occurred.
Simple sample to list the video capture devices:
@code
char szDeviceList[20][40];
int iDeviceCount;
iDeviceCount = IC_ListDevices( (char*)szDeviceList,40 );
for( i = 0; i < iDeviceCount; i++ )
{
printf("%2d. %s\n",i+1,szDeviceList[i]);
}
@endcode
*/
int AC IC_ListDevices( char *szDeviceList, int iSize );///< Count and list devices.
//////////////////////////////////////////////////////////////////////////
/*! Simpler approach of enumerating devices. No 2D char array needed
@code
char szDeviceName[40]; // Use max 39 chars for a device name
int iDeviceCount;
iDeviceCount = IC_GetDeviceCount(); // Query number of connected devices
for( i = 0; i < iDeviceCount; i++ )
{
IC_ListDevicesbyIndex(szDeviceName,39, i);
printf("%2d. %s\n",i+1,szDeviceName);
}
@endcode
@param szDeviceName Char memory, that receives the device name
@param iSize Size of the char memory. If names are longer, they will be truncated.
@param DeviceIndex Index of the device to be query. Must be between 0 and IC_GetDeviceCount.
@retval >= 0 Success, count of found devices
@retval <0 An error occurred.
*/
int AC IC_ListDevicesbyIndex( char *szDeviceName, int iSize, int DeviceIndex );
//////////////////////////////////////////////////////////////////////////
/*! Count all available video formats. If the Parameter szFormatList
is NULL, only the number of formats is queried. The Parameter szFormatList
must be a two dimensional array of char. The iSize parameter specifies the
length of the strings, that are used in the array to store the format names.
@param hGrabber The handle to the grabber object.
@param szFormatList A two dimensional char array that recieves the list. Or NULL if only the count of formats is to be returned.
@retval >= 0 Success, count of found video formats
@retval <0 An error occurred.
Simple sample to list the video capture devices:
@code
char szFormatList[80][40];
int iFormatCount;
HGRABBER hGrabber;
hGrabber = IC_CreateGrabber();
IC_OpenVideoCaptureDevice(hGrabber, "DFK 21F04" );
iFormatCount = IC_ListDevices(hGrabber, (char*)szFormatList,40 );
for( i = 0; i < min( iFormatCount, 80); i++ )
{
printf("%2d. %s\n",i+1,szFormatList[i]);
}
IC_ReleaseGrabber( hGrabber );
@endcode
*/
int AC IC_ListVideoFormats( HGRABBER hGrabber, char *szFormatList, int iSize );///<List available video formats.
//////////////////////////////////////////////////////////////////////////
/*! Simpler approach of enumerating video formats. No 2D char array needed.
@param hGrabber The handle to the grabber object.
@param szFormatName char memory, that will receive the name of the video format. Should be big enough.
@param iSize Size in byte of szFormatName
@iIndex Index of the video format to query.
@code
char szVideoFormatName[40]; // Use max 39 chars for a video format name
int FormatCount;
HGRABBER hGrabber;
hGrabber = IC_CreateGrabber();
IC_OpenVideoCaptureDevice(hGrabber, "DFK 21AU04" );
FormatCount = IC_GetVideoFormatCount(hGrabber); // Query number of connected devices
for( i = 0; i < FormatCount; i++ )
{
IC_ListVideoFormatbyIndex(szVideoFormatName,39, i);
printf("%2d. %s\n",i+1,szVideoFormatName);
}
@endcode
@param szDeviceName Char memory, that receives the device name
@param iSize Size of the char memory. If names are longer, they will be truncated.
@param DeviceIndex Index of the device to be query. Must be between 0 and IC_GetDeviceCount.
@retval IC_SUCCESS Success,
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE No handle to the grabber object.
*/
int AC IC_ListVideoFormatbyIndex( HGRABBER hGrabber, char *szFormatName, int iSize, int iIndex);
//////////////////////////////////////////////////////////////////////////
/*! Get the number of the currently available devices. This function creates an
internal array of all connected video capture devices. With each call to this
function, this array is rebuild. The name and the unique name can be retrieved
from the internal array using the functions IC_GetDevice() and IC_GetUniqueNamefromList.
They are usefull for retrieving device names for opening devices.
@retval >= 0 Success, count of found devices.
@retval IC_NO_HANDLE Internal Error.
@sa IC_GetDevice
@sa IC_GetUniqueNamefromList
*/
int AC IC_GetDeviceCount(); ///<Get the number of the currently available devices.
//////////////////////////////////////////////////////////////////////////
/*! Get a string representation of a device specified by iIndex. iIndex
must be between 0 and IC_GetDeviceCount(). IC_GetDeviceCount() must
have been called before this function, otherwise it will always fail.
@param iIndex The number of the device whose name is to be returned. It must be
in the range from 0 to IC_GetDeviceCount(),
@return Returns the string representation of the device on success, NULL
otherwise.
@sa IC_GetDeviceCount
@sa IC_GetUniqueNamefromList
*/
char* AC IC_GetDevice( int iIndex ); ///< Get the name of a video capture device.
//////////////////////////////////////////////////////////////////////////
/*! Get unique device name of a device specified by iIndex. The unique device name
consist from the device name and its serial number. It allows to differ between
more then one device of the same type connected to the computer. The unique device name
is passed to the function IC_OpenDevByUniqueName
@param iIndex The number of the device whose name is to be returned. It must be
in the range from 0 to IC_GetDeviceCount(),
@return Returns the string representation of the device on success, NULL
otherwise.
@sa IC_GetDeviceCount
@sa IC_GetUniqueNamefromList
@sa IC_OpenDevByUniqueName
*/
char* AC IC_GetUniqueNamefromList( int iIndex );///< Get the unique name of a video capture device.
//////////////////////////////////////////////////////////////////////////
/*! Get the number of the available input channels for the current device.
A video capture device must have been opened before this call.
@param hGrabber The handle to the grabber object.
@retval >= 0 Success
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE No handle to the grabber object.
@sa IC_GetInputChannel
*/
int AC IC_GetInputChannelCount( HGRABBER hGrabber ); ///<Get the number of the available input channels.
//////////////////////////////////////////////////////////////////////////
/*! Get a string representation of the input channel specified by iIndex.
iIndex must be between 0 and IC_GetInputChannelCount().
IC_GetInputChannelCount() must have been called before this function,
otherwise it will always fail.
@param hGrabber The handle to the grabber object.
@param iIndex Number of the input channel to be used..
@retval Nonnull The name of the specified input channel
@retval NULL An error occured.
@sa IC_GetInputChannelCount
*/
char* AC IC_GetInputChannel( HGRABBER hGrabber, int iIndex ); ///<Get the name of an input channel.
//////////////////////////////////////////////////////////////////////////
/*! Get the number of the available video norms for the current device.
A video capture device must have been opened before this call.
@param hGrabber The handle to the grabber object.
@retval >= 0 Success
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE No handle to the grabber object.
@sa IC_GetVideoNorm
*/
int AC IC_GetVideoNormCount( HGRABBER hGrabber ); ///<Get the count of available video norms.
//////////////////////////////////////////////////////////////////////////
/*! Get a string representation of the video norm specified by iIndex.
iIndex must be between 0 and IC_GetVideoNormCount().
IC_GetVideoNormCount() must have been called before this function,
otherwise it will always fail.
@param hGrabber The handle to the grabber object.
@param iIndex Number of the video norm to be used.
@retval Nonnull The name of the specified video norm.
@retval NULL An error occured.
@sa IC_GetVideoNormCount
*/
char* AC IC_GetVideoNorm( HGRABBER hGrabber, int iIndex ); ///<Get the name of a video norm.
//////////////////////////////////////////////////////////////////////////
/*! Get the number of the available video formats for the current device.
A video capture device must have been opened before this call.
@param hGrabber The handle to the grabber object.
@retval >= 0 Success
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE No handle to the grabber object.
@sa IC_GetVideoFormat
*/
int AC IC_GetVideoFormatCount( HGRABBER hGrabber ); ///< Returns the count of available video formats.
//////////////////////////////////////////////////////////////////////////
/*! Get a string representation of the video format specified by iIndex.
iIndex must be between 0 and IC_GetVideoFormatCount().
IC_GetVideoFormatCount() must have been called before this function,
otherwise it will always fail.
@param hGrabber The handle to the grabber object.
@param iIndex Number of the video format to be used.
@retval Nonnull The name of the specified video format.
@retval NULL An error occured.
@sa IC_GetVideoFormatCount
*/
char* AC IC_GetVideoFormat( HGRABBER hGrabber, int iIndex ); ///<Return the name of a video format.
//////////////////////////////////////////////////////////////////////////
/*! Save the state of a video capture device to a file.
@param hGrabber The handle to the grabber object.
@param szFileName Name of the file where to save to.
@retval IC_SUCCESS if an image has been snapped
@retval IC_ERROR if something went wrong.
@sa IC_LoadDeviceStateFromFile
*/
int AC IC_SaveDeviceStateToFile(HGRABBER hGrabber, char* szFileName);///<Save the state of a video capture device to a file.
//////////////////////////////////////////////////////////////////////////
/*! Load a device settings file. On success the device is opened automatically.
@param hGrabber The handle to the grabber object. If it is NULL then a new HGRABBER handle is
created. This should be released by a call to IC_ReleaseGrabber when it is no longer needed.
@param szFileName Name of the file where to save to.
@return HGRABBER The handle of the grabber object, that contains the new opened video capture device.
@sa IC_SaveDeviceStateToFile
@sa IC_ReleaseGrabber
*/
HGRABBER AC IC_LoadDeviceStateFromFile(HGRABBER hGrabber, char* szFileName); ///<Load a device settings file.
//////////////////////////////////////////////////////////////////////////
/*! Load a device settings file.
@param hGrabber The handle to the grabber object. If it is NULL then a new HGRABBER handle is
created, in case OpenDevice is true. If OpenDevice is set to false, the a device must be already
open in the grabber handle. The properties in the passed XML file will be apllied to
the opened device.
This should be released by a call to IC_ReleaseGrabber when it is no longer needed.
@param szFileName Name of the file where to save to.
@param OpenDevice If 1, the device specified in the XML file is opened. If 0, then a device must be opened in the hGrabber.
The properties and video format specified in the XML file will be applied to the opened device.
@return IC_SUCCESS The device was successfully opened and the settings saved in the XML file were set.
@return IC_NO_DEVICE False was passed to OpenDevice, but no device was opened in the grabber handle or the handle is NULL
@return IC_WRONG_XML_FORMAT No device opened.
@return IC_WRONG_INCOMPATIBLE_XML No device opened.
@return IC_DEVICE_NOT_FOUND No device opened.
@return IC_FILE_NOT_FOUND Passed XML file does not exist.
@return IC_NOT_ALL_PROPERTIES_RESTORED The device was opened, but not all properties could be set as wanted.
@sa IC_SaveDeviceStateToFile
@sa IC_ReleaseGrabber
*/
int AC IC_LoadDeviceStateFromFileEx(HGRABBER hGrabber, char* szFileName, int OpenDevice); ///<Load a device settings file.
//////////////////////////////////////////////////////////////////////////
/*! Save the device settings to a file specified by szFilename. When used
with IC Imaging Control 1.41 the device name, the input channel, the
video norm and the video format are saved. When used with IC Imaging
Control 2.0, the VCDProperties are saved as well. Returns 1 on success,
0 otherwise.
Notice that in IC Imaging Control 1.41 the device name includes the trailing
number if there is more than one device of the same type available. This can
cause IC_OpenDeviceBySettings() to fail if one of those devices is unplugged.
When used with IC Imaging Control 2.0, this cannot happen because the device
name is stored without the trailing number. Instead the first device that
matches the type specified in the settings file is opened.
@deprecated Use IC_SaveDeviceStateToFile instead.
*/
int AC IC_SaveDeviceSettings( HGRABBER hGrabber, char* szFilename );
//////////////////////////////////////////////////////////////////////////
/*! Open a device by a settings file specified by szFilename. If succedeed,
1 is returned and a device specified in the settings file is opened and
initialized with the settings data. If failed, 0 is returned.
@deprecated Use IC_LoadDeviceStateFromFile instead.
*/
int AC IC_OpenDeviceBySettings( HGRABBER hGrabber, char* szFilename );
//////////////////////////////////////////////////////////////////////////
/*! Load device settings from a file specified by szFilename. A device must
have been opened before this function is called. A check is performed whether
the current device matches the device type stored in the settings file.
If so, the settings are loaded and set.
Returns 1 on success, 0 otherwise.
Notice: This function will only work with IC Imaging Control 2.0. When used
with IC Imaging Control 1.41, it will always return 0.
@deprecated Use IC_LoadDeviceStateFromFile instead.
*/
int AC IC_LoadDeviceSettings( HGRABBER hGrabber, char* szFilename );
//////////////////////////////////////////////////////////////////////////
/*! Open a video capture by using its DisplayName.
@param hGrabber The handle to the grabber object.
@param szDisplayname Displayname of the device. Can be retrieved by a call to IC_GetDisplayName().
@retval IC_SUCCESS if an image has been snapped
@retval IC_ERROR if something went wrong.
@sa IC_GetDisplayName
*/
int AC IC_OpenDevByDisplayName( HGRABBER hGrabber, char *szDisplayname); ///<Open a video capture by using its DisplayName.
//////////////////////////////////////////////////////////////////////////
/*! Get a DisplayName from a currently open device. The display name of a
device can be another on different computer for the same video capture
device.
@param hGrabber Handle to a grabber object
@param szDisplayName Memory that will take the display name. If it is NULL, the
length of the display name will be returned.
@param iLen Size in Bytes of the memory allocated by szDisplayName.
@retval IC_SUCCESS On success. szDisplayName contains the display name of the device.
@retval IC_ERROR iLen is less than the length of the retrieved display name.
@retval IC_NO_HANDLE hGrabber is not a valid handle. GetGrabber was not called.
@retval IC_NO_DEVICE No device opened. Open a device, before this function can be used.
@retval >1 Length of the display name, if szDisplayName is NULL.
@sa IC_OpenDevByDisplayName
@sa IC_ReleaseGrabber
*/
int AC IC_GetDisplayName( HGRABBER hGrabber, char *szDisplayname, int iLen); ///<Get the display name of a device.
//////////////////////////////////////////////////////////////////////////
/*! Open a video capture by using its UniqueName. Use IC_GetUniqueName() to
retrieve the unique name of a camera.
@param hGrabber Handle to a grabber object
@param szDisplayName Memory that will take the display name.
@sa IC_GetUniqueName
@sa IC_ReleaseGrabber
*/
int AC IC_OpenDevByUniqueName( HGRABBER hGrabber, char *szDisplayname);
//////////////////////////////////////////////////////////////////////////
/*! Get a UniqueName from a currently open device.
@param hGrabber Handle to a grabber object
@param szUniqueName Memory that will take the Unique name. If it is NULL, the
length of the Unique name will be returned.
@param iLen Size in Bytes of the memory allocated by szUniqueName.
@retval IC_SUCCESS On success. szUniqueName contains the Unique name of the device.
@retval IC_ERROR iLen is less than the length of the retrieved Unique name.
@retval IC_NO_HANDLE hGrabber is not a valid handle. GetGrabber was not called.
@retval IC_NO_DEVICE No device opened. Open a device, before this function can be used.
@retval >1 Length of the Unique name, if szUniqueName is NULL.
*/
int AC IC_GetUniqueName( HGRABBER hGrabber, char *szUniquename, int iLen); ///<Get a UniqueName from a currently open device.
//////////////////////////////////////////////////////////////////////////
/*! This returns 1, if a valid device has been opened, otherwise it is 0.
@param hGrabber Handle to a grabber object.
@retval IC_ERROR There is no valid video capture device opened
@retval IC_SUCCESS There is a valid video capture device openend.
*/
int AC IC_IsDevValid( HGRABBER hGrabber); ///<Returns whether a video capture device is valid.
//////////////////////////////////////////////////////////////////////////
/*! Show the VCDProperty dialog.
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS on success
@retval IC_ERROR on error.
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE Nullpointer.
*/
int AC IC_ShowPropertyDialog( HGRABBER hGrabber ); ///<Show the VCDProperty dialog.
//////////////////////////////////////////////////////////////////////////
/*! Show the device selection dialog. This dialogs enables to select the
video capture device, the video norm, video format, input channel and
frame rate.
@param hGrabber Handle to a grabber object.
@return The passed hGrabber object or a new created if hGrabber was NULL.
@code
HGRABBER hTheGrabber;
hTheGrabber = IC_ShowDeviceSelectionDialog( NULL );
if( hTheGrabber != NULL )
{
IC_StartLive( hTheGrabber, 1 ); // Show the live video of this grabber
IC_ShowPropertyDialog( hTheGrabber ); // Show the property page of this grabber
}
@endcode
*/
HGRABBER AC IC_ShowDeviceSelectionDialog( HGRABBER hGrabber ); ///<Show the device selection dialog.
//////////////////////////////////////////////////////////////////////////
/*!
Return whether the current video capture device supports an external
trigger.
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS An external trigger is supported
@retval IC_ERROR No external trigger is supported.
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE Internal Grabber does not exist.
@sa IC_EnableTrigger
*/
int AC IC_IsTriggerAvailable( HGRABBER hGrabber ); ///<Check for external trigger support.
//////////////////////////////////////////////////////////////////////////
/*! Enable or disable the external trigger.
@param hGrabber Handle to a grabber object.
@param iEnable 1 = enable the trigger, 0 = disable the trigger
@retval IC_SUCCESS Trigger was enabled or disabled successfully.
@retval IC_NOT_AVAILABLE The device does not support triggering.
@retval IC_NO_PROPERTYSET Failed to query the property set of the device.
@retval IC_NO_DEVICE No video capture device selected.
@retval IC_NO_HANDLE Internal Grabber does not exist or hGrabber is NULL.
@sa IC_IsTriggerAvailable
*/
int AC IC_EnableTrigger( HGRABBER hGrabber, int iEnable );
//////////////////////////////////////////////////////////////////////////
/*! Remove or insert the the overlay bitmap to the grabber object. If
Y16 format is used, the overlay must be removed,
@param hGrabber Handle to a grabber object.
@param iEnable = 1 inserts overlay, 0 removes the overlay.
*/
void AC IC_RemoveOverlay( HGRABBER hGrabber, int iEnable );
//////////////////////////////////////////////////////////////////////////
/*! Enable or disable the overlay bitmap on the live video
@param hGrabber Handle to a grabber object.
@param iEnable = 1 enables the overlay, 0 disables the overlay.
*/
void AC IC_EnableOverlay( HGRABBER hGrabber, int iEnable ); ///<Enable or disable the overlay bitmap.
//////////////////////////////////////////////////////////////////////////
/*! BeginPaint returns an HDC for GDI painting purposes (like TextOut() etc.)
When the paintings are finished, the function IC_EndPaint must be called.
@param hGrabber Handle to a grabber object.
@return HDC The function returns not NULL, if the HDC could be retrieved. If the HDC
could not be retrieved or an error has occured, the function returns 0.
Sample code:
@code
HDC hPaintDC;
hPaintDC = IC_BeginPaint(hGrabber);
if( hPaintDC != NULL )
{
TextOut( hPaintDC,10,10,"Text",4);
}
IC_EndPaint(hGrabber)
@endcode
@sa IC_EndPaint
*/
long AC IC_BeginPaint( HGRABBER hGrabber ); ///< BeginPaint returns an HDC for GDI painting purposes.
//////////////////////////////////////////////////////////////////////////
/*! The EndPaint functions must be called, after BeginPaint has been called,
and the painting operations have been finished.
@param hGrabber Handle to a grabber object.
@sa IC_BeginPaint
*/
void AC IC_EndPaint( HGRABBER hGrabber ); ///< End painting functions on the overlay bitmap.
//////////////////////////////////////////////////////////////////////////
/*! Display a windows messagebox.
@param szText Message text
@param zsTitle Title of the messagebox.
*/
void AC IC_MsgBox( char * szText, char* szTitle ); ///<Display a windows messagebox.
//////////////////////////////////////////////////////////////////////////
/*! Type declaration for the frame ready callback function.
@sa IC_SetFrameReadyCallback
@sa IC_SetCallbacks
@retval IC_SUCCESS Callback was set successfully
@retval IC_ERROR An error occurred, e.g. hGrabber is NULL.
*/
typedef void (*FRAME_READY_CALLBACK)
(HGRABBER hGrabber, unsigned char* pData, unsigned long frameNumber, void* );
//////////////////////////////////////////////////////////////////////////
/*! Type declaration for the device lost callback function.
@sa IC_SetCallbacks
*/
typedef void (*DEVICE_LOST_CALLBACK)(HGRABBER hGrabber, void* );
//////////////////////////////////////////////////////////////////////////
/*! Enable frame ready callback.
@param hGrabber Handle to a grabber object.
@param cb Callback function of type FRAME_READY_CALLBACK
@param x1_argument_in_void_userdata Pointer to some userdata.
@retval IC_SUCCESS Callback was set successfully
@retval IC_ERROR An error occurred, e.g. hGrabber is NULL.
@sa FRAME_READY_CALLBACK
*/
int AC IC_SetFrameReadyCallback(
HGRABBER hGrabber,
FRAME_READY_CALLBACK cb,
void* x1_argument_in_void_userdata);
/*! Set callback function
@param hGrabber Handle to a grabber object.
@param cb Callback function of type FRAME_READY_CALLBACK, can be NULL, if no callback is needed
@param dlcb Callback function of type DEVICE:LOST_CALLBACK, can be NULL, if no device lost handler is needed
@param x1_argument_in_void_userdata Pointer to some userdata.
@sa FRAME_READY_CALLBACK
*/
int AC IC_SetCallbacks(
HGRABBER hGrabber,
FRAME_READY_CALLBACK cb,
void* x1_argument_in_void_userdata,
DEVICE_LOST_CALLBACK dlCB,
void* x2_argument_in_void_userdata);
/////////////////////////////////////////////////////////////////////////
/*! Set Continuous mode
In continuous mode, the callback is called for each frame,
so that there is no need to use IC_SnapImage etc.
@param hGrabber Handle to a grabber object.
@param cont 0 : Snap continouos, 1 : do not automatically snap.
@retval IC_SUCCESS Success
@retval IC_NOT_IN_LIVEMODE The device is currently streaming, therefore setting continuous mode failed.
@retval IC_NO_HANDLE Internal Grabber does not exist or hGrabber is NULL
@remarks
Not available in live mode.
*/
int AC IC_SetContinuousMode( HGRABBER hGrabber, int cont ); ///<Set Continuous mode.
//////////////////////////////////////////////////////////////////////////
/*! SignalDetected
Detects whether a video signal is available.
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS Signal detected
@retval IC_ERROR No video signal detected
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_NOT_IN_LIVEMODE No live mode, startlive was not called
*/
int AC IC_SignalDetected( HGRABBER hGrabber ); ///<Detects whether a video signal is available.
//////////////////////////////////////////////////////////////////////////
/*! Get trigger modes.
Simple sample to list the video capture devices:
@param hGrabber Handle to a grabber object.
@param szModeList Twodimensional array of char that will recieve the mode list.
@param iSze Size of the array (first dimension)
@retval 0 : No trigger modes available
@retval >0 : Count of available trigger modes
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@code
char szModes[20][10];
int iModeCount;
iModeCount = IC_GetTriggerModes(hGrabber, (char*)szModes,20);
for( int i = 0; i < min( iModeCount, 20); i++ )
{
printf("%2d. %s\n",i+1,szModes[i]);
}
@endcode
*/
int AC IC_GetTriggerModes( HGRABBER hGrabber, char *szModeList, int iSize ); ///<Get trigger modes.
//////////////////////////////////////////////////////////////////////////
/*! Set the trigger mode.
Sets the mode that has been retrieved by a call to IC_GetTriggerModes.
@param hGrabber Handle to a grabber object.
@param szMode String containing the name of the mode.
@retval IC_SUCCESS Success.
@retval IC_NOT_AVAILABLE Triggermode is not supported by the current device.
@retval IC_ERROR An error occurred
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_SetTriggerMode( HGRABBER hGrabber, char* szMode ); ///<Set the trigger mode.
//////////////////////////////////////////////////////////////////////////
/*! Set the trigger polarity
Sample:
@code
IC_SetTriggerPolarity(hGrabber, 0);
@endcode
or
@code
IC_SetTriggerPolarity(hGrabber, 1);
@endcode
@param hGrabber Handle to a grabber object.
@param iPolarity
@li 0 : Polarity on direction
@li 1 : Polarity the other direction
@retval IC SUCCESS : Polarity could be set successfully
@retval IC_NOT_AVAILABLE Triggerpolarity is not supported by the current device.
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_SetTriggerPolarity( HGRABBER hGrabber, int iPolarity ); ///< Set the trigger polarity.
int AC IC_GetExpRegValRange( HGRABBER hGrabber, long *lMin, long *lMax ); ///< Retrieve exposure register values lower and upper limits.
int AC IC_GetExpRegVal( HGRABBER hGrabber, long *lValue ); ///< Retrieve the current register value of exposure.
int AC IC_SetExpRegVal( HGRABBER hGrabber, long lValue ); ///<Set a register value for exposure.
int AC IC_EnableExpRegValAuto( HGRABBER hGrabber, int iOnOff ); ///<Enable or disable automatic of exposure.
int AC IC_GetExpRegValAuto( HGRABBER hGrabber, int *iOnOff );///<Check whether automatic exposure is enabled.
//////////////////////////////////////////////////////////////////////////
/*! Functions for the absolute values interface of exposure.
*/
int AC IC_IsExpAbsValAvailable( HGRABBER hGrabber);
int AC IC_GetExpAbsValRange(HGRABBER hGrabber, float *fMin, float *fMax);
int AC IC_GetExpAbsVal(HGRABBER hGrabber, float *fValue);
int AC IC_SetExpAbsVal(HGRABBER hGrabber, float fValue );
///////////////////////////////////////////////////////////////////
/*! Gets the current value of Colorenhancement property
Sample:
@code
int OnOFF
IC_GetColorEnhancement(hGrabber, &OnOFF);
@endcode
@param hGrabber Handle to a grabber object.
@param OnOff
@li 0 : Color enhancement is off
@li 1 : Color enhancement is on
@retval IC_SUCCESS : Success
@retval IC_NOT:AVAILABLE : The property is not supported by the current device
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_GetColorEnhancement(HGRABBER hGrabber, int *OnOff);
///////////////////////////////////////////////////////////////////
/*! Sets the value of Colorenhancement property
Sample:
@code
int OnOFF = 1
IC_GetColorEnhancement(hGrabber, OnOFF);
@endcode
@param hGrabber Handle to a grabber object.
@param OnOff
@li 0 : Color enhancement is off
@li 1 : Color enhancement is on
@retval IC_SUCCESS : Success
@retval IC_NOT:AVAILABLE : The property is not supported by the current device
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_SetColorEnhancement(HGRABBER hGrabber, int OnOff);
///////////////////////////////////////////////////////////////////
/*! Sends a software trigger to the camera. The camera must support
external trigger. The external trigger has to be enabled previously
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS : Success
@retval IC_NOT:AVAILABLE : The property is not supported by the current device
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@sa IC_EnableTrigger
*/
int AC IC_SoftwareTrigger(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! Sets a new frame rate.
@param hGrabber Handle to a grabber object.
@param FrameRate The new frame rate.
@retval IC_SUCCESS : Success
@retval IC_NOT_AVAILABLE : The property is not supported by the current device
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_NOT_IN_LIVEMODE Frame rate can not set, while live video is shown. Stop Live video first!
*/
int AC IC_SetFrameRate(HGRABBER hGrabber,float FrameRate);
///////////////////////////////////////////////////////////////////
/*! Retrieves the current frame rate
@param hGrabber Handle to a grabber object.
@retval The current frame rate. If it is 0.0, then frame rates are not supported.
*/
float AC IC_GetFrameRate(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! Retrieves available frame rates.
The count of available frame rates depends on the used video capture
device and the currently used video format. After a video was changed,
the available frame rates usually are changed by the video capture device
too.
@code
int Index = 0;
float fps = 0.0f;
while( IC_GetAvailableFrameRates(hGrabber, Index, &fps ) == IC_SUCCESS )
{
printf("Frame rate %d : %f fps\n", Index, fps);
Index++;
}
@endcode
@param hGrabber Handle to a grabber object.
@param Index Index of the frame rates, starting at 0
@param fps Pointer to a float variable, that will receive the frame rate of the passed index.
@retval IC_SUCCESS, if the frame rate at Index exists, otherwise IC_ERROR,
*/
int AC IC_GetAvailableFrameRates(HGRABBER hGrabber, int Index, float *fps);
int AC IC_SetWhiteBalanceAuto( HGRABBER hGrabber, int iOnOff);
///////////////////////////////////////////////////////////////////
/*! Sets the value for white balance red.
@param hGrabber Handle to a grabber object.
@param Value Value of the red white balance to be set
@retval IC_SUCCESS : Success
@retval IC_NO_HANDLE : Invalid grabber handle
@retval IC_NO_DEVICE : No video capture device opened
@retval IC_NOT_AVAILABLE : The property is not supported by the current device
*/
int AC IC_SetWhiteBalanceRed(HGRABBER hGrabber, long Value);
///////////////////////////////////////////////////////////////////
/*! Sets the value for white balance green.
@param hGrabber Handle to a grabber object.
@param Value Value of the green white balance to be set
@retval IC_SUCCESS : Success
@retval IC_NO_HANDLE : Invalid grabber handle
@retval IC_NO_DEVICE : No video capture device opened
@retval IC_NOT_AVAILABLE : The property is not supported by the current device
*/
int AC IC_SetWhiteBalanceGreen(HGRABBER hGrabber, long Value);
///////////////////////////////////////////////////////////////////
/*! Sets the value for white balance blue.
@param hGrabber Handle to a grabber object.
@param Value Value of the blue white balance to be set
@retval IC_SUCCESS : Success
@retval IC_NO_HANDLE : Invalid grabber handle
@retval IC_NO_DEVICE : No video capture device opened
@retval IC_NOT_AVAILABLE : The property is not supported by the current device
*/
int AC IC_SetWhiteBalanceBlue(HGRABBER hGrabber, long Value);
///////////////////////////////////////////////////////////////////
/*! Performs the one push for Focus
@param hGrabber Handle to a grabber object.
@param Value Value of the blue white balance to be set
@retval IC_SUCCESS : Success
@retval IC_NO_HANDLE : Invalid grabber handle
@retval IC_NO_DEVICE : No video capture device opened
@retval IC_NOT_AVAILABLE : The property is not supported by the current device
*/
int AC IC_FocusOnePush(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! Show the internal property page of the camera
*/
int AC IC_ShowInternalPropertyPage(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! Resets all properties to their default values. If a property has
automation, the automatic will be enabled.
If the device supports external trigger, the external trigger will
be disabled.
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_ResetProperties(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! Resets the driver. Do not use, for internl purposes only.
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_ResetUSBCam(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! This function queries the internal property set (KsPropertySet) of the driver.
It allows an application to access all properties of a video capture devices
using the enums and GUIDs from the header files fwcam1394propguid.h and
fwcam1394props.h.
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_ERROR The property could not have been retrieved
*/
int AC IC_QueryPropertySet(HGRABBER hGrabber);
///////////////////////////////////////////////////////////////////
/*! This function sets a value or structure to the internal property set
of the video capture device. The properties and structures are defined
in the header file fwcam1394props.h. Before using this function, the
properties set must have been queried once using the function IC_QueryPropertySet().
@param hGrabber Handle to a grabber object.
@retval IC_SUCCESS Success
@retval IC_ERROR Setting of the values failed
@retval IC_NO_PROPERTYSET The property set was not retrieved or is not available.
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@sa IC_QueryPropertySet
*/
//int AC IC_PropertySet_Set(HGRABBER hGrabber, FWCAM1394_CUSTOM_PROP prop, FWCAM1394_CUSTOM_PROP_S& rstruct );
///////////////////////////////////////////////////////////////////
/*! Enables or disables the default window size lock of the video window.
@param hGrabber Handle to a grabber object.
@param Default 0 = disable, custome size can be set, 1 = enable, the standard size, which is video format, is used.
@retval IC_SUCCESS Success
@retval IC_ERROR Setting of the values failed
@retval IC_NO_PROPERTYSET The property set was not retrieved or is not available.
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_SetDefaultWindowPosition(HGRABBER hGrabber, int Default);
///////////////////////////////////////////////////////////////////
/*! This function Sets the position and size of the video window.
@param hGrabber Handle to a grabber object.
@param PosX Specifies the x-coordinate of the upper left hand corner of the video window. It defaults to 0.
@param PosY Specifies the y-coordinate of the upper left hand corner of the video window. It defaults to 0.
@param width Specifies the width of the video window.
@param height Specifies the height of the video window.
@retval IC_SUCCESS Success
@retval IC_ERROR Setting of the values failed
@retval IC_DEFAULT_WINDOW_SIZE_SET The property set was not retrieved or is not available.
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
*/
int AC IC_SetWindowPosition(HGRABBER hGrabber, int PosX, int PosY, int Width, int Height );
///////////////////////////////////////////////////////////////////
/*! Enumerate the available properties of a video capture device.
@param hGrabber Handle to a grabber object.
@param cb Callback functions called by the enum function.
@param data User data
@retval IC_SUCCESS No error otherwise an error occured, e.g. no device selected.
*/
int AC IC_enumProperties(HGRABBER hGrabber, IC_ENUMCB cb, void* data);
///////////////////////////////////////////////////////////////////
/*! Enumerate the available elements of a video capture device and a property.
@param hGrabber Handle to a grabber object.
@param Property Name of the property
@param cb Callback functions called by the enum function.
@param data User data
@retval IC_SUCCESS No error otherwise an error occured, e.g. no device selected.
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE The passed property in Property is not avaialble.
*/
int AC IC_enumPropertyElements(HGRABBER hGrabber, char* Property, IC_ENUMCB cb, void* data);
///////////////////////////////////////////////////////////////////
/*! Enumerate the available interfaces of of a video capture device, property and element.
The string passed to the callback function can contain
- Range
- Switch
- Button
- Mapstrings
- AbsoluteValues
- Unknown
@param hGrabber Handle to a grabber object.
@param Property Name of the property
@param Property Name of the elemt
@param cb Callback functions called by the enum function.
@param data User data
@retval IC_SUCCESS No error otherwise an error occured, e.g. no device selected.
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE The passed property in Property is not avaialble.
*/
int AC IC_enumPropertyElementInterfaces(HGRABBER hGrabber, char* Property, char* Element, IC_ENUMCB cb, void* data);
///////////////////////////////////////////////////////////////////
/*! Check, whether a property is available.. For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is not checked.
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
Simple call:
@code
if( IC_IsPropertyAvailable( hGrabber, "Brightness",NULL) == IC_SUCCESS )
{
printf("Brightness is supported\n");
}
else
{
printf("Brightness is not supported\n");
}
@endcode
Complex call for a special element:
@code
if( IC_IsPropertyAvailable( hGrabber, "Trigger","Software Trigger") == IC_SUCCESS )
{
printf("Software trigger is supported\n");
}
else
{
printf("Software trigger is not supported\n");
}
@endcode
*/
int AC IC_IsPropertyAvailable(HGRABBER hGrabber, char* Property, char *Element );
///////////////////////////////////////////////////////////////////
/*! This returns the range of a property. For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Value".
@param Min Receives the min value of the property
@param Max Receives the max value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
@code
HGRABBER hGrabber; // The handle of the grabber object.
int Min;
int Max;
int Result = IC_ERROR;
HGRABBER hGrabber;
if( IC_InitLibrary(0) )
{
hGrabber = IC_CreateGrabber();
IC_OpenVideoCaptureDevice(hGrabber, "DFx 31BG03.H");
if( hGrabber )
{
Result = IC_GetPropertyValueRange(hGrabber,"Exposure","Auto Reference", &Min, &Max );
if( Result == IC_SUCCESS )
printf("Expsure Auto Reference Min %d, Max %d\n", Min, Max);
Result = IC_GetPropertyValueRange(hGrabber,"Exposure",NULL, &Min, &Max );
if( Result == IC_SUCCESS )
printf("Exposure Value Min %d, Max %d\n", Min, Max);
}
IC_ReleaseGrabber( hGrabber );
@endcode
*/
int AC IC_GetPropertyValueRange(HGRABBER hGrabber, char* Property, char *Element, int *Min, int *Max );
///////////////////////////////////////////////////////////////////
/*! This returns the current value of a property. For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Value".
@param Value Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_GetPropertyValue(HGRABBER hGrabber, char* Property, char *Element, int *Value );
///////////////////////////////////////////////////////////////////
/*! This sets a new value of a property. For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Value".
@param Value Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_SetPropertyValue(HGRABBER hGrabber, char* Property, char *Element, int Value );
///////////////////////////////////////////////////////////////////
/*! This returns the range of an absolute value property. Usually it is used for exposure.
a list of properties and elements use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Value".
@param Min Receives the min value of the property
@param Max Receives the max value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_GetPropertyAbsoluteValueRange(HGRABBER hGrabber, char* Property, char *Element, float *Min, float *Max );
///////////////////////////////////////////////////////////////////
/*! This returns the current value of an absolute value property.
Usually it is used for exposure. For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Value".
@param Value Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_GetPropertyAbsoluteValue(HGRABBER hGrabber, char* Property, char *Element, float *Value );
///////////////////////////////////////////////////////////////////
/*! This sets a new value of an absolute value property. Usually it is used for exposure.
a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Value".
@param Value Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_SetPropertyAbsoluteValue(HGRABBER hGrabber, char* Property, char *Element, float Value );
///////////////////////////////////////////////////////////////////
/*! This returns the current value of a switch property. Switch properties
are usually used for enabling and disabling of automatics.
For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Auto".
@param On Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_GetPropertySwitch(HGRABBER hGrabber, char* Property, char *Element, int *On );
///////////////////////////////////////////////////////////////////
/*! This sets the value of a switch property. Switch properties
are usually used for enabling and disabling of automatics.
For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. Gain, Exposure
@param Element The type of the interface, e.g. Value, Auto. If NULL, it is "Auto".
@param On Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_SetPropertySwitch(HGRABBER hGrabber, char* Property, char *Element, int On );
//////////////////////////////////////////////////////////////////
/*! This executes the on push on a property. These properties are used
for white balance one push or for software trigger.
For a list of properties and elements
use the VCDPropertyInspector of IC Imaging Control.
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. "Trigger"
@param Element The type of the interface, e.g. "Software Trigger"
@param On Receives the value of the property
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_PropertyOnePush(HGRABBER hGrabber, char* Property, char *Element );
//////////////////////////////////////////////////////////////////
/*!
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. "Strobe"
@param Element The type of the interface, e.g. "Mode"
@param StringCount Receives the count of strings, that is modes, availble
@param Strings pointer to an array of char*, that will contain the mode strings. The array size should be StringCount * 20. Parameter can be null in order to query the number of strings
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_GetPropertyMapStrings(HGRABBER hGrabber, char* Property, char *Element, int *StringCount, char **Strings );
//////////////////////////////////////////////////////////////////
/*! Return the current set string of a mapstring interface
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. "Strobe"
@param Element The type of the interface, e.g. "Mode"
@param String pointer to a char*. Size should be atleast 50. There is no check! This contains the result.
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_GetPropertyMapString(HGRABBER hGrabber, char* Property, char *Element, char *String );
//////////////////////////////////////////////////////////////////
/*! Set the string of a mapstring interface
@param hGrabber Handle to a grabber object.
@param Property The name of the property, e.g. "Strobe"
@param Element The type of the interface, e.g. "Mode"
@param String pointer to a char*. Size should be atleast 50. There is no check! This contains the result.
@retval IC_SUCCESS Success
@retval IC_NO_HANDLE Invalid grabber handle
@retval IC_NO_DEVICE No video capture device opened
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE A requested property item is not available
@retval IC_PROPERTY_ELEMENT_NOT_AVAILABLE A requested element of a given property item is not available
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE requested element has not the interface, which is needed.
*/
int AC IC_SetPropertyMapString(HGRABBER hGrabber, char* Property, char *Element, char *String );
//////////////////////////////////////////////////////////////////
/*! Query number of avaialable frame filters
@retval The count of found frame filters.
*/
int AC IC_GetAvailableFrameFilterCount();
//////////////////////////////////////////////////////////////////
/*! Query a list of framefilters
@param szFilterList A two dimensional char array that recieves the list of found frame filters
@param iSize The number of entries in the above list.
@code
char szFilterList[80][40];
int iCount;
iCount = IC_GetAvailableFrameFilterCount();
iFormatCount = IC_GetAvailableFrameFilters(szFormatList,iCount );
for( i = 0; i < iCount; i++ )
{
printf("%2d. %s\n",i+1,szFormatList[i]);
}
@endcode
*/
int AC IC_GetAvailableFrameFilters(char **szFilterList, int iSize );
//////////////////////////////////////////////////////////////////
/*! Create a frame filter
@param szFilterName Name of the filter to create
@param FilterHandle Address of a pointer, that will receive the handle of the created filter
@retval IC_SUCCESS Success
@retval IC_ERROR If the filter creation failed.
@sa IC_DeleteFrameFilter
*/
int AC IC_CreateFrameFilter(char *szFilterName, HFRAMEFILTER *FilterHandle );
//////////////////////////////////////////////////////////////////
/*! Add the frame filter to the device's filter list. It is possible to add several
frame filter to a grabber, so a filter chain for image processing can be created.
A frame filter is removed by a call to IC_RemoveFrameFilter
@param hGrabber Handle to a grabber object.
@param FilterHandle Handle to a frame filter object.
@retval IC_SUCCESS Success
@retval IC_ERROR Either hGrabber or FilterHandle was NULL
@sa IC_RemoveFrameFilterFromDevice
@sa IC_CreateFrameFilter
*/
int AC IC_AddFrameFilterToDevice(HGRABBER hGrabber, HFRAMEFILTER FilterHandle );
//////////////////////////////////////////////////////////////////
/*! Removes a previously added frame filter from the frame filter list
@param hGrabber Handle to a grabber object, that uses the passed frame filter.
@param FilterHandle Handle to a frame filter object, to be removed
@sa IC_AddFrameFilterToDevice
@sa IC_CreateFrameFilter
*/
void AC IC_RemoveFrameFilterFromDevice(HGRABBER hGrabber, HFRAMEFILTER FilterHandle );
//////////////////////////////////////////////////////////////////
/*! Deletes a previously created frame filter. Make sure, the frame filter to be deleted
is not in use anymore, otherwise a null pointer access violation will occur.
@param FilterHandle Handle to a frame filter object.
*/
void AC IC_DeleteFrameFilter( HFRAMEFILTER FilterHandle );
///////////////////////////////////////////////////////////////
/* Delete the memory allocated by the HFRAMEFILTER structure. Please remove the frame filter from the HGrabber,
before deleting it.
@param FilterHandle Handle to a frame filter object.
@retval IC_SUCCESS Success
@retval IC_ERROR Either hGrabber or FilterHandle was NULL or the frame filter has no dialog.
*/
int AC IC_FrameFilterShowDialog( HFRAMEFILTER FilterHandle );
///////////////////////////////////////////////////////////////
/*! Query a parameter value of a frame filter
@param FilterHandle Handle to a frame filter object.
@param ParameterName Name of the parameter whose value is to be queried
@param Data pointer to the data, that receives the value. Memory must be allocated before.
@retval IC_SUCCESS Success
@retval IC_ERROR Maybe the parameter name does not exist.
*/
int AC IC_FrameFilterGetParameter(HFRAMEFILTER FilterHandle, char* ParameterName, void* Data );
/*! Set an int parameter value of a frame filter
@param FilterHandle Handle to a frame filter object.
@param ParameterName Name of the parameter whose value is to be set
@param Data The data, that contains the value.
@retval IC_SUCCESS Success
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE the parameter givven by ParameterName does not exist
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE The data type, e.g. int does not match to the parameter type, e.g. float
@retval IC_ERROR Unknown error
*/
int AC IC_FrameFilterSetParameterInt(HFRAMEFILTER FilterHandle, char* ParameterName, int Data );
/*! Set a float parameter value of a frame filter
@param FilterHandle Handle to a frame filter object.
@param ParameterName Name of the parameter whose value is to be set
@param Data The data, that contains the value.
@retval IC_SUCCESS Success
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE the parameter givven by ParameterName does not exist
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE The data type, e.g. int does not match to the parameter type, e.g. float
@retval IC_ERROR Unknown error
*/
int AC IC_FrameFilterSetParameterFloat(HFRAMEFILTER FilterHandle, char* ParameterName, float Data );
/*! Set a boolean parameter value of a frame filter. boolean means int here.
@param FilterHandle Handle to a frame filter object.
@param ParameterName Name of the parameter whose value is to be set
@param Data The data, that contains the value.
@retval IC_SUCCESS Success
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE the parameter givven by ParameterName does not exist
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE The data type, e.g. int does not match to the parameter type, e.g. float
@retval IC_ERROR Unknown error
*/
int AC IC_FrameFilterSetParameterBoolean(HFRAMEFILTER FilterHandle, char* ParameterName, int Data );
/*! Set a string parameter value of a frame filter
@param FilterHandle Handle to a frame filter object.
@param ParameterName Name of the parameter whose value is to be set
@param Data The data, that contains the value.
@retval IC_SUCCESS Success
@retval IC_PROPERTY_ITEM_NOT_AVAILABLE the parameter givven by ParameterName does not exist
@retval IC_PROPERTY_ELEMENT_WRONG_INTERFACE The data type, e.g. int does not match to the parameter type, e.g. float
@retval IC_ERROR Unknown error
*/
int AC IC_FrameFilterSetParameterString(HFRAMEFILTER FilterHandle, char* ParameterName, char* Data );
////////////////////////////////////////////////////////////////////////////
/*! Remove all frame filters from the Grabber's device path
@param hGrabber Handle to a grabber object.
*/
int AC IC_FrameFilterDeviceClear(HGRABBER hGrabber );
typedef struct CODECHANDLE_t__ { int unused; } CODECHANDLE_t; ///<Internal structure of the grabber object handle.
//////////////////////////////////////////////////////////////////////////
/*!
*/
#define HCODEC CODECHANDLE_t* ///< Type of grabber object handle. Used for all functions.
////////////////////////////////////////////////////////////////////////////
/*! Callback type definition for the codec enumenration callback called by
IC_enumCodecs
@retval 1 : Terminate the enumeration, 0 continue enumrating
*/
typedef int _cdecl ENUMCODECCB( char* CodecName, void*);
////////////////////////////////////////////////////////////////////////////
/*! Enumerate all installed codecs. It calls the callback function passed by
the cb parameter. It ends, if cb returns 0 or all codecs have been enumerated.
@param cb pallack function of type ENUMCODECCB
@param data Pointer to user data
*/
void AC IC_enumCodecs(ENUMCODECCB cb, void* data);
////////////////////////////////////////////////////////////////////////////
/*! Creates the codec by the passed name
@param Name Name of the codec to be created
@retval NULL on error, otherwise the created HCODEC
*/
HCODEC IC_Codec_Create(char* Name);
void AC IC_Codec_Release(HCODEC Codec);
////////////////////////////////////////////////////////////////////////////
/*! Queries a name of a codec passed by _Codec
@param _Codec Handle to the codec
@param l Size in bytes of the memory allocated for name
@param name String that will receive the name of the codec terminated by a \0
@retval IC_SUCCESS on success
@retval IC_NO_HANDLE if _Codec or Name is NULL
*/
int AC IC_Codec_getName(HCODEC Codec, int l, char* Name);
////////////////////////////////////////////////////////////////////////////
/*! Return whether a codec passed by _Codec has a property dialog
@param _Codec Handle to the codec
@retval IC_SUCCESS The codec has a dialog
@retval IC_ERROR The codec has no dialog
@retval IC_NO_HANDLE _Codec is NULL
*/
int AC IC_Codec_hasDialog(HCODEC Codec);
////////////////////////////////////////////////////////////////////////////
/*! Shows the property dialog of a codec passed by _Codec
@param name String that will receive the name of the codec terminated by a \0
@retval IC_SUCCESS on success
@retval IC_ERROR On error, e.g. something went wrong with the codec's dialog.
@retval IC_NO_HANDLE if _Codec or Name is NULL
*/
int AC IC_Codec_showDialog(HCODEC Codec);
////////////////////////////////////////////////////////////////////////////
/*! Assigns the selected Codec to the Grabber. AVI Capture is prepared. Image
capture does not work anymore.
After doing so, a call to IC_Startlive() starts AVI Capture and IC_Stoplive stopps it,
@param hlGrabber Handle to a grabber with a valid device
@param Codec Handle to the selected codec.
@retval IC_SUCCESS on success
*/
int AC IC_SetCodec(HGRABBER hlGrabber,HCODEC Codec);
////////////////////////////////////////////////////////////////////////////
/*! Set the file name for the AVI file
After doing so, a call to IC_Startlive() starts AVI Capture and IC_Stoplive stopps it,
@param hlGrabber Handle to a grabber with a valid device
@param FileName Filename
@retval IC_SUCCESS on success
@retval IC_NO_HANDLE if the grabber is invalid
*/
int IC_SetAVIFileName(HGRABBER hlGrabber,char * FileName);
////////////////////////////////////////////////////////////////////////////
/*! Pauses or continues AVI Capture. This allows, to start the stream and see the live video
but images are not saved into the AVI file.
@param hlGrabber Handle to a grabber with a valid device
@param pause 1 = Pause, nothing saved, 0 = save images!
@retval IC_SUCCESS on success
@retval IC_NO_HANDLE if the grabber is invalid
*/
int IC_enableAVICapturePause(HGRABBER hlGrabber, int Pause );
#if defined(__cplusplus)
}
#endif
#endif
|
cbarrett/XPC-Calc
|
XPC Calc/XPC_CalcAppDelegate.h
|
<reponame>cbarrett/XPC-Calc<filename>XPC Calc/XPC_CalcAppDelegate.h
//
// XPC_CalcAppDelegate.h
// XPC Calc
//
// Created by <NAME> on 8/6/11.
// Copyright 2011 __MyCompanyName__. All rights reserved.
//
#import <Cocoa/Cocoa.h>
#import <xpc/xpc.h>
@interface XPC_CalcAppDelegate : NSObject <NSApplicationDelegate> {
NSWindow *window;
NSTextField *inputTextField;
xpc_connection_t serviceConnection;
NSTextView *stackTextView;
xpc_object_t stack;
}
@property (assign) IBOutlet NSTextView *stackTextView;
@property (assign) IBOutlet NSTextField *inputTextField;
@property (assign) IBOutlet NSWindow *window;
- (IBAction)push:(id)sender;
- (IBAction)add:(id)sender;
- (IBAction)subtract:(id)sender;
- (IBAction)multiply:(id)sender;
- (IBAction)divide:(id)sender;
- (IBAction)clear:(id)sender;
@end
|
cbarrett/XPC-Calc
|
Haskell Service/main.c
|
//
// main.c
// XPC Calc
//
// Created by <NAME> on 8/7/11.
// Copyright 2011 __MyCompanyName__. All rights reserved.
//
#include "main.h"
#include <stdio.h>
#include "HsFFI.h"
#include "HsXPC_stub.h"
extern void __stginit_HsXPC();
void hsxpc_dictionary_get_keys_and_values(xpc_object_t dictionary, const char **keys, xpc_object_t *values)
{
__block size_t idx = 0;
xpc_dictionary_apply(dictionary, ^ bool (const char *key, xpc_object_t value) {
keys[idx] = key;
values[idx] = value;
++idx;
return true;
});
}
static void XPC_Calc_Service_event_handler(xpc_connection_t peer)
{
// By defaults, new connections will target the default dispatch
// concurrent queue.
xpc_connection_set_event_handler(peer, ^(xpc_object_t event) {
hsEventHandler(peer, event);
});
// This will tell the connection to begin listening for events. If you
// have some other initialization that must be done asynchronously, then
// you can defer this call until after that initialization is done.
xpc_connection_resume(peer);
}
int main(int argc, char *argv[])
{
hs_init(&argc, &argv);
hs_add_root(__stginit_HsXPC);
xpc_main(XPC_Calc_Service_event_handler);
hs_exit();
return 0;
}
|
cbarrett/XPC-Calc
|
Shared.h
|
<gh_stars>1-10
//
// Shared.h
// XPC Calc
//
// Created by <NAME> on 8/6/11.
// Copyright 2011 __MyCompanyName__. All rights reserved.
//
#ifndef XPC_Calc_Shared_h
#define XPC_Calc_Shared_h
enum {
OperatorAdd,
OperatorSub,
OperatorMul,
OperatorDiv
};
#endif
|
cbarrett/XPC-Calc
|
Haskell Service/main.h
|
<gh_stars>1-10
#include <xpc/xpc.h>
void hsxpc_dictionary_get_keys_and_values(xpc_object_t dictionary, const char **keys, xpc_object_t *values);
|
CychUC/SmallBase
|
user/menu/menu.h
|
#pragma once
#include <common.h>
namespace Small {
class Menu {
public:
void Init();
void Loop();
public:
bool initialized_;
bool opened_;
};
inline Menu menu;
}
|
CychUC/SmallBase
|
appdata/il2cpp-api-functions-ptr.h
|
// Generated C++ file by Il2CppInspector - http://www.djkaty.com - https://github.com/djkaty
// Target Unity version: 2020.2.4 - 2020.3.99
// ******************************************************************************
// * IL2CPP API function pointers
// ******************************************************************************
#define il2cpp_add_internal_call_ptr 0x00106A30
#define il2cpp_alloc_ptr 0x00106A40
#define il2cpp_allocation_granularity_ptr 0x00042FF0
#define il2cpp_array_class_get_ptr 0x00106A50
#define il2cpp_array_element_size_ptr 0x00106A60
#define il2cpp_array_get_byte_length_ptr 0x00106A70
#define il2cpp_array_length_ptr 0x00106A80
#define il2cpp_array_new_ptr 0x00106A90
#define il2cpp_array_new_full_ptr 0x00106AA0
#define il2cpp_array_new_specific_ptr 0x00106AB0
#define il2cpp_array_object_header_size_ptr 0x00106AC0
#define il2cpp_assembly_get_image_ptr 0x00106AD0
#define il2cpp_bounded_array_class_get_ptr 0x00106AE0
#define il2cpp_capture_memory_snapshot_ptr 0x00106AF0
#define il2cpp_class_array_element_size_ptr 0x00106B00
#define il2cpp_class_enum_basetype_ptr 0x00106B10
#define il2cpp_class_for_each_ptr 0x00106B20
#define il2cpp_class_from_il2cpp_type_ptr 0x00106B30
#define il2cpp_class_from_name_ptr 0x00106B40
#define il2cpp_class_from_system_type_ptr 0x00106B50
#define il2cpp_class_from_type_ptr 0x00106B30
#define il2cpp_class_get_assemblyname_ptr 0x00106B60
#define il2cpp_class_get_bitmap_ptr 0x00106B70
#define il2cpp_class_get_bitmap_size_ptr 0x00106B90
#define il2cpp_class_get_data_size_ptr 0x00106BA0
#define il2cpp_class_get_declaring_type_ptr 0x00106BB0
#define il2cpp_class_get_element_class_ptr 0x00106BC0
#define il2cpp_class_get_events_ptr 0x00106BD0
#define il2cpp_class_get_field_from_name_ptr 0x00106BE0
#define il2cpp_class_get_fields_ptr 0x00106BF0
#define il2cpp_class_get_flags_ptr 0x00106C00
#define il2cpp_class_get_image_ptr 0x00106AD0
#define il2cpp_class_get_interfaces_ptr 0x00106C10
#define il2cpp_class_get_method_from_name_ptr 0x00106C20
#define il2cpp_class_get_methods_ptr 0x00106C30
#define il2cpp_class_get_name_ptr 0x00106C40
#define il2cpp_class_get_namespace_ptr 0x00106C50
#define il2cpp_class_get_nested_types_ptr 0x00106C60
#define il2cpp_class_get_parent_ptr 0x00106C70
#define il2cpp_class_get_properties_ptr 0x00106C80
#define il2cpp_class_get_property_from_name_ptr 0x00106C90
#define il2cpp_class_get_rank_ptr 0x00106CA0
#define il2cpp_class_get_static_field_data_ptr 0x00002420
#define il2cpp_class_get_type_ptr 0x00106CB0
#define il2cpp_class_get_type_token_ptr 0x00003BD0
#define il2cpp_class_get_userdata_offset_ptr 0x00106CC0
#define il2cpp_class_has_attribute_ptr 0x00106CD0
#define il2cpp_class_has_parent_ptr 0x00106CE0
#define il2cpp_class_has_references_ptr 0x00106CF0
#define il2cpp_class_instance_size_ptr 0x00106D00
#define il2cpp_class_is_abstract_ptr 0x00106D10
#define il2cpp_class_is_assignable_from_ptr 0x00106D20
#define il2cpp_class_is_blittable_ptr 0x00106D30
#define il2cpp_class_is_enum_ptr 0x00106D40
#define il2cpp_class_is_generic_ptr 0x00106D50
#define il2cpp_class_is_inflated_ptr 0x00106D60
#define il2cpp_class_is_interface_ptr 0x00106D70
#define il2cpp_class_is_subclass_of_ptr 0x00106D80
#define il2cpp_class_is_valuetype_ptr 0x00106D90
#define il2cpp_class_num_fields_ptr 0x00106DA0
#define il2cpp_class_set_userdata_ptr 0x00106DB0
#define il2cpp_class_value_size_ptr 0x00106DC0
#define il2cpp_current_thread_get_frame_at_ptr 0x00106DD0
#define il2cpp_current_thread_get_stack_depth_ptr 0x00106DE0
#define il2cpp_current_thread_get_top_frame_ptr 0x00106E00
#define il2cpp_current_thread_walk_frame_stack_ptr 0x00106E10
#define il2cpp_custom_attrs_construct_ptr 0x00106E20
#define il2cpp_custom_attrs_free_ptr 0x000024A0
#define il2cpp_custom_attrs_from_class_ptr 0x00106E30
#define il2cpp_custom_attrs_from_method_ptr 0x00106E40
#define il2cpp_custom_attrs_get_attr_ptr 0x00106E50
#define il2cpp_custom_attrs_has_attr_ptr 0x00106E60
#define il2cpp_debug_get_method_info_ptr 0x00106E70
#define il2cpp_debugger_set_agent_options_ptr 0x000024A0
#define il2cpp_domain_assembly_open_ptr 0x00106E80
#define il2cpp_domain_get_ptr 0x00106E90
#define il2cpp_domain_get_assemblies_ptr 0x00106EA0
#define il2cpp_exception_from_name_msg_ptr 0x00106ED0
#define il2cpp_field_get_flags_ptr 0x00106EE0
#define il2cpp_field_get_name_ptr 0x00106AD0
#define il2cpp_field_get_offset_ptr 0x00106EF0
#define il2cpp_field_get_parent_ptr 0x00106C40
#define il2cpp_field_get_type_ptr 0x00106F00
#define il2cpp_field_get_value_ptr 0x00106F10
#define il2cpp_field_get_value_object_ptr 0x00106F20
#define il2cpp_field_has_attribute_ptr 0x00106F30
#define il2cpp_field_is_literal_ptr 0x00106F40
#define il2cpp_field_set_value_ptr 0x00106F50
#define il2cpp_field_set_value_object_ptr 0x00106F60
#define il2cpp_field_static_get_value_ptr 0x00106F70
#define il2cpp_field_static_set_value_ptr 0x00106F80
#define il2cpp_format_exception_ptr 0x00106F90
#define il2cpp_format_stack_trace_ptr 0x00107020
#define il2cpp_free_ptr 0x001070B0
#define il2cpp_free_captured_memory_snapshot_ptr 0x001070C0
#define il2cpp_gc_collect_ptr 0x001070D0
#define il2cpp_gc_collect_a_little_ptr 0x001070E0
#define il2cpp_gc_disable_ptr 0x001070F0
#define il2cpp_gc_enable_ptr 0x00107100
#define il2cpp_gc_foreach_heap_ptr 0x00107110
#define il2cpp_gc_get_heap_size_ptr 0x00107140
#define il2cpp_gc_get_max_time_slice_ns_ptr 0x00107150
#define il2cpp_gc_get_used_size_ptr 0x00107160
#define il2cpp_gc_has_strict_wbarriers_ptr 0x00023EF0
#define il2cpp_gc_is_disabled_ptr 0x00107170
#define il2cpp_gc_is_incremental_ptr 0x00107180
#define il2cpp_gc_set_external_allocation_tracker_ptr 0x000024A0
#define il2cpp_gc_set_external_wbarrier_tracker_ptr 0x000024A0
#define il2cpp_gc_set_max_time_slice_ns_ptr 0x00107190
#define il2cpp_gc_set_mode_ptr 0x001071A0
#define il2cpp_gc_start_incremental_collection_ptr 0x001071B0
#define il2cpp_gc_wbarrier_set_field_ptr 0x001071C0
#define il2cpp_gchandle_foreach_get_target_ptr 0x001071D0
#define il2cpp_gchandle_free_ptr 0x00107200
#define il2cpp_gchandle_get_target_ptr 0x00107210
#define il2cpp_gchandle_new_ptr 0x00107220
#define il2cpp_gchandle_new_weakref_ptr 0x00107230
#define il2cpp_get_corlib_ptr 0x00107240
#define il2cpp_get_exception_argument_null_ptr 0x00107250
#define il2cpp_image_get_assembly_ptr 0x00106C40
#define il2cpp_image_get_class_ptr 0x00107260
#define il2cpp_image_get_class_count_ptr 0x00107270
#define il2cpp_image_get_entry_point_ptr 0x00107280
#define il2cpp_image_get_filename_ptr 0x00106AD0
#define il2cpp_image_get_name_ptr 0x00106AD0
#define il2cpp_init_ptr 0x00107290
#define il2cpp_init_utf16_ptr 0x001072C0
#define il2cpp_is_debugger_attached_ptr 0x00107350
#define il2cpp_is_vm_thread_ptr 0x00107360
#define il2cpp_method_get_class_ptr 0x00106C50
#define il2cpp_method_get_declaring_type_ptr 0x00106C50
#define il2cpp_method_get_flags_ptr 0x00107370
#define il2cpp_method_get_from_reflection_ptr 0x00106C40
#define il2cpp_method_get_name_ptr 0x00106C40
#define il2cpp_method_get_object_ptr 0x001073A0
#define il2cpp_method_get_param_ptr 0x001073B0
#define il2cpp_method_get_param_count_ptr 0x001073C0
#define il2cpp_method_get_param_name_ptr 0x001073D0
#define il2cpp_method_get_return_type_ptr 0x001073E0
#define il2cpp_method_get_token_ptr 0x001073F0
#define il2cpp_method_has_attribute_ptr 0x00107400
#define il2cpp_method_is_generic_ptr 0x00107410
#define il2cpp_method_is_inflated_ptr 0x00107420
#define il2cpp_method_is_instance_ptr 0x00107430
#define il2cpp_monitor_enter_ptr 0x00107440
#define il2cpp_monitor_exit_ptr 0x00107450
#define il2cpp_monitor_pulse_ptr 0x00107460
#define il2cpp_monitor_pulse_all_ptr 0x00107470
#define il2cpp_monitor_try_enter_ptr 0x00107480
#define il2cpp_monitor_try_wait_ptr 0x00107490
#define il2cpp_monitor_wait_ptr 0x001074A0
#define il2cpp_native_stack_trace_ptr 0x001074B0
#define il2cpp_object_get_class_ptr 0x00106AD0
#define il2cpp_object_get_size_ptr 0x00107580
#define il2cpp_object_get_virtual_method_ptr 0x00107590
#define il2cpp_object_header_size_ptr 0x00042FF0
#define il2cpp_object_new_ptr 0x001075A0
#define il2cpp_object_unbox_ptr 0x001075C0
#define il2cpp_offset_of_array_bounds_in_array_object_header_ptr 0x00042FF0
#define il2cpp_offset_of_array_length_in_array_object_header_ptr 0x001075D0
#define il2cpp_override_stack_backtrace_ptr 0x001075E0
#define il2cpp_profiler_install_ptr 0x001075F0
#define il2cpp_profiler_install_allocation_ptr 0x00107600
#define il2cpp_profiler_install_enter_leave_ptr 0x00107610
#define il2cpp_profiler_install_fileio_ptr 0x00107620
#define il2cpp_profiler_install_gc_ptr 0x00107630
#define il2cpp_profiler_install_thread_ptr 0x00107640
#define il2cpp_profiler_set_events_ptr 0x00107650
#define il2cpp_property_get_flags_ptr 0x00107660
#define il2cpp_property_get_get_method_ptr 0x00106C40
#define il2cpp_property_get_name_ptr 0x00106F00
#define il2cpp_property_get_parent_ptr 0x00106AD0
#define il2cpp_property_get_set_method_ptr 0x00106C50
#define il2cpp_raise_exception_ptr 0x00107670
#define il2cpp_register_debugger_agent_transport_ptr 0x000024A0
#define il2cpp_register_log_callback_ptr 0x00107680
#define il2cpp_resolve_icall_ptr 0x00107690
#define il2cpp_runtime_class_init_ptr 0x001076A0
#define il2cpp_runtime_invoke_ptr 0x001076B0
#define il2cpp_runtime_invoke_convert_args_ptr 0x001076D0
#define il2cpp_runtime_object_init_ptr 0x001076F0
#define il2cpp_runtime_object_init_exception_ptr 0x00107700
#define il2cpp_runtime_unhandled_exception_policy_set_ptr 0x00107710
#define il2cpp_set_commandline_arguments_ptr 0x00107720
#define il2cpp_set_commandline_arguments_utf16_ptr 0x00107730
#define il2cpp_set_config_ptr 0x00107740
#define il2cpp_set_config_dir_ptr 0x00107750
#define il2cpp_set_config_utf16_ptr 0x00107760
#define il2cpp_set_data_dir_ptr 0x00107770
#define il2cpp_set_default_thread_affinity_ptr 0x0001A2F0
#define il2cpp_set_find_plugin_callback_ptr 0x00107780
#define il2cpp_set_memory_callbacks_ptr 0x00107790
#define il2cpp_set_temp_dir_ptr 0x001077A0
#define il2cpp_shutdown_ptr 0x001077B0
#define il2cpp_start_gc_world_ptr 0x001077C0
#define il2cpp_stats_dump_to_file_ptr 0x001077D0
#define il2cpp_stats_get_value_ptr 0x00107A50
#define il2cpp_stop_gc_world_ptr 0x00107AE0
#define il2cpp_string_chars_ptr 0x00107AF0
#define il2cpp_string_intern_ptr 0x00107B00
#define il2cpp_string_is_interned_ptr 0x00107B10
#define il2cpp_string_length_ptr 0x00107B20
#define il2cpp_string_new_ptr 0x00107B30
#define il2cpp_string_new_len_ptr 0x00107B40
#define il2cpp_string_new_utf16_ptr 0x00107B50
#define il2cpp_string_new_wrapper_ptr 0x00107B30
#define il2cpp_thread_attach_ptr 0x00107B60
#define il2cpp_thread_current_ptr 0x00107B70
#define il2cpp_thread_detach_ptr 0x00107B80
#define il2cpp_thread_get_all_attached_threads_ptr 0x00107B90
#define il2cpp_thread_get_frame_at_ptr 0x00107BA0
#define il2cpp_thread_get_stack_depth_ptr 0x00107BB0
#define il2cpp_thread_get_top_frame_ptr 0x00107BC0
#define il2cpp_thread_walk_frame_stack_ptr 0x00107BD0
#define il2cpp_type_equals_ptr 0x00107BE0
#define il2cpp_type_get_assembly_qualified_name_ptr 0x00107BF0
#define il2cpp_type_get_attrs_ptr 0x00107C90
#define il2cpp_type_get_class_or_element_class_ptr 0x00107CA0
#define il2cpp_type_get_name_ptr 0x00107CB0
#define il2cpp_type_get_name_chunked_ptr 0x00107D50
#define il2cpp_type_get_object_ptr 0x00107D60
#define il2cpp_type_get_type_ptr 0x00107D70
#define il2cpp_type_is_byref_ptr 0x00107D80
#define il2cpp_type_is_pointer_type_ptr 0x00107D90
#define il2cpp_type_is_static_ptr 0x00107DA0
#define il2cpp_unhandled_exception_ptr 0x00107DB0
#define il2cpp_unity_install_unitytls_interface_ptr 0x00107DC0
#define il2cpp_unity_liveness_calculation_begin_ptr 0x00107DD0
#define il2cpp_unity_liveness_calculation_end_ptr 0x00107DE0
#define il2cpp_unity_liveness_calculation_from_root_ptr 0x00107DF0
#define il2cpp_unity_liveness_calculation_from_statics_ptr 0x00107E00
#define il2cpp_value_box_ptr 0x00107E10
|
CychUC/SmallBase
|
appdata/il2cpp-types-ptr.h
|
// Generated C++ file by Il2CppInspector - http://www.djkaty.com - https://github.com/djkaty
// Target Unity version: 2020.2.4 - 2020.3.99
// ******************************************************************************
// * IL2CPP application-specific type definition addresses
// ******************************************************************************
DO_TYPEDEF(0x038B54B8, Object);
DO_TYPEDEF(0x03873C98, ValueType);
DO_TYPEDEF(0x038A72E8, Int32);
DO_TYPEDEF(0x0387F928, Char);
DO_TYPEDEF(0x03868AD0, String);
DO_TYPEDEF(0x0387C5B0, Boolean);
DO_TYPEDEF(0x0389FD58, IFormatProvider);
DO_TYPEDEF(0x03893E48, Enum);
DO_TYPEDEF(0x0386FD10, TypeCode__Enum);
DO_TYPEDEF(0x0387CFB8, Byte);
DO_TYPEDEF(0x038C31C0, SByte);
DO_TYPEDEF(0x038A7138, Int16);
DO_TYPEDEF(0x03870F98, UInt16);
DO_TYPEDEF(0x03871148, UInt32);
DO_TYPEDEF(0x038A7520, Int64);
DO_TYPEDEF(0x038712F8, UInt64);
DO_TYPEDEF(0x038C7DA8, Single);
DO_TYPEDEF(0x0388B158, Double);
DO_TYPEDEF(0x03888608, Decimal);
DO_TYPEDEF(0x03878630, Array);
DO_TYPEDEF(0x03870C98, UInt32__Array);
DO_TYPEDEF(0x0389F800, IEnumerator);
DO_TYPEDEF(0x0389DAF0, IComparer);
DO_TYPEDEF(0x0389F930, IEqualityComparer);
DO_TYPEDEF(0x03887AC8, DateTime);
DO_TYPEDEF(0x0386D280, Int32__Array);
DO_TYPEDEF(0x038ADF68, MemberInfo_1);
DO_TYPEDEF(0x038A77E8, IntPtr);
DO_TYPEDEF(0x038C30A0, RuntimeTypeHandle);
DO_TYPEDEF(0x0386FA40, Type);
DO_TYPEDEF(0x0386E240, Object__Array);
DO_TYPEDEF(0x038C3010, RuntimeType);
DO_TYPEDEF(0x038B0228, Module);
DO_TYPEDEF(0x03889570, Delegate);
DO_TYPEDEF(0x038B1138, MulticastDelegate);
DO_TYPEDEF(0x03870218, TypeFilter);
DO_TYPEDEF(0x038C6B18, SerializationInfo);
DO_TYPEDEF(0x0386FC50, String__Array);
DO_TYPEDEF(0x03870A58, Type__Array);
DO_TYPEDEF(0x038A7468, Dictionary_2_System_String_System_Int32_);
DO_TYPEDEF(0x038B5098, IEnumerator_1_System_String_);
DO_TYPEDEF(0x038B4C18, IEnumerator_1_System_Int32_);
DO_TYPEDEF(0x038B2278, ICollection_1_System_String_);
DO_TYPEDEF(0x038B2158, ICollection_1_System_Int32_);
DO_TYPEDEF(0x0389D928, ICollection);
DO_TYPEDEF(0x0389ECB8, IDictionaryEnumerator);
DO_TYPEDEF(0x03868A40, StreamingContext);
DO_TYPEDEF(0x0389FF20, IFormatterConverter);
DO_TYPEDEF(0x038AEFA8, MethodBase);
DO_TYPEDEF(0x038AF0C8, MethodInfo_1);
DO_TYPEDEF(0x038C2D40, RuntimeMethodInfo);
DO_TYPEDEF(0x038B0738, MonoMethod);
DO_TYPEDEF(0x038B78B8, ParameterInfo_1);
DO_TYPEDEF(0x038796C8, Attribute);
DO_TYPEDEF(0x038AD200, MarshalAsAttribute);
DO_TYPEDEF(0x0386E478, ParameterInfo_1__Array);
DO_TYPEDEF(0x038C2CB0, RuntimeMethodHandle);
DO_TYPEDEF(0x03888C90, DefaultBinder);
DO_TYPEDEF(0x0386DF70, MethodBase__Array);
DO_TYPEDEF(0x0386A090, Boolean__Array);
DO_TYPEDEF(0x0386E508, ParameterModifier__Array);
DO_TYPEDEF(0x03884040, CultureInfo);
DO_TYPEDEF(0x038B3148, NumberFormatInfo);
DO_TYPEDEF(0x03887C88, DateTimeFormatInfo);
DO_TYPEDEF(0x03883FA8, CultureData);
DO_TYPEDEF(0x0387E4F8, CalendarData);
DO_TYPEDEF(0x0386A3F0, CalendarData__Array);
DO_TYPEDEF(0x03881630, CompareInfo);
DO_TYPEDEF(0x038816C8, CompareOptions__Enum);
DO_TYPEDEF(0x0389A4E8, Guid);
DO_TYPEDEF(0x038BE6F0, RandomNumberGenerator);
DO_TYPEDEF(0x038BDA90, RNGCryptoServiceProvider);
DO_TYPEDEF(0x038C7B68, SimpleCollator);
DO_TYPEDEF(0x0386C530, TextInfo);
DO_TYPEDEF(0x038809B8, CodePointIndexer);
DO_TYPEDEF(0x03871E08, CodePointIndexer_TableRange__Array);
DO_TYPEDEF(0x03882E78, Contraction);
DO_TYPEDEF(0x038AA420, Level2Map);
DO_TYPEDEF(0x038A7BA8, Dictionary_2_System_String_Mono_Globalization_Unicode_SimpleCollator_);
DO_TYPEDEF(0x03866918, SortKey);
DO_TYPEDEF(0x0387E460, Calendar);
DO_TYPEDEF(0x0389A1F0, GregorianCalendarTypes__Enum);
DO_TYPEDEF(0x0389A0C0, GregorianCalendar);
DO_TYPEDEF(0x03888018, DayOfWeek__Enum);
DO_TYPEDEF(0x0389BAE0, Hashtable);
DO_TYPEDEF(0x03872A68, Hashtable_bucket__Array);
DO_TYPEDEF(0x0386DC40, TokenHashValue);
DO_TYPEDEF(0x03870668, TokenHashValue__Array);
DO_TYPEDEF(0x038A52D8, Dictionary_2_System_Int32_System_Globalization_CultureInfo_);
DO_TYPEDEF(0x0386AAB0, CultureInfo__Array);
DO_TYPEDEF(0x038B4558, IEnumerator_1_System_Globalization_CultureInfo_);
DO_TYPEDEF(0x038A7078, Dictionary_2_System_String_System_Globalization_CultureInfo_);
DO_TYPEDEF(0x03896690, FieldInfo_1);
DO_TYPEDEF(0x038C2B90, RuntimeFieldInfo);
DO_TYPEDEF(0x038C24D0, RtFieldInfo);
DO_TYPEDEF(0x038C2B00, RuntimeFieldHandle);
DO_TYPEDEF(0x038B0588, MonoField);
DO_TYPEDEF(0x0386BA58, FieldInfo_1__Array);
DO_TYPEDEF(0x038BC140, PropertyInfo_1);
DO_TYPEDEF(0x038C2EF0, RuntimePropertyInfo);
DO_TYPEDEF(0x038B08E8, MonoProperty);
DO_TYPEDEF(0x0386E000, MethodInfo_1__Array);
DO_TYPEDEF(0x0389E070, MonoProperty_GetterAdapter);
DO_TYPEDEF(0x0386AE98, Delegate__Array);
DO_TYPEDEF(0x0389CC18, IAsyncResult);
DO_TYPEDEF(0x03878FB0, AsyncCallback);
DO_TYPEDEF(0x0386EC90, PropertyInfo_1__Array);
DO_TYPEDEF(0x03895608, ExceptionHandlingClauseOptions__Enum);
DO_TYPEDEF(0x03889608, DelegateData);
DO_TYPEDEF(0x03878A58, Assembly);
DO_TYPEDEF(0x0388BB90, Assembly_ResolveEventHolder);
DO_TYPEDEF(0x038AD290, MarshalByRefObject);
DO_TYPEDEF(0x03868800, Stream);
DO_TYPEDEF(0x038B5398, ObjRef);
DO_TYPEDEF(0x0389D3D0, IChannelInfo);
DO_TYPEDEF(0x038A31D8, IRemotingTypeInfo);
DO_TYPEDEF(0x0389F898, IEnvoyInfo);
DO_TYPEDEF(0x0386B848, Task);
DO_TYPEDEF(0x03866618, Task_1_System_Int32_);
DO_TYPEDEF(0x038ABA18, Stream_ReadWriteTask);
DO_TYPEDEF(0x03867608, StackGuard);
DO_TYPEDEF(0x0387EAE8, CancellationToken);
DO_TYPEDEF(0x0386BA88, TaskFactory);
DO_TYPEDEF(0x0387EC18, CancellationTokenSource);
DO_TYPEDEF(0x03875818, WaitHandle);
DO_TYPEDEF(0x038ACFC8, ManualResetEvent);
DO_TYPEDEF(0x038C4570, SafeHandle);
DO_TYPEDEF(0x038C48D0, SafeWaitHandle);
DO_TYPEDEF(0x038C4450, SafeFileHandle);
DO_TYPEDEF(0x038C7A18, SparselyPopulatedArray_1_CancellationCallbackInfo_);
DO_TYPEDEF(0x0387EA50, CancellationCallbackInfo);
DO_TYPEDEF(0x0389F0A8, Action_1_Object_);
DO_TYPEDEF(0x03869B20, SynchronizationContext);
DO_TYPEDEF(0x038C60F8, SendOrPostCallback);
DO_TYPEDEF(0x038957D0, ExecutionContext);
DO_TYPEDEF(0x038AC128, LogicalCallContext);
DO_TYPEDEF(0x0387E590, CallContextRemotingData);
DO_TYPEDEF(0x0387E628, CallContextSecurityData);
DO_TYPEDEF(0x0386C3E0, Header__Array);
DO_TYPEDEF(0x038A4FA8, IllogicalCallContext);
DO_TYPEDEF(0x038A49D8, Dictionary_2_System_Threading_IAsyncLocal_System_Object_);
DO_TYPEDEF(0x0389CB80, IAsyncLocal);
DO_TYPEDEF(0x038B4E58, IEnumerator_1_System_Object_);
DO_TYPEDEF(0x038B21E8, ICollection_1_System_Object_);
DO_TYPEDEF(0x038BB0C0, List_1_System_Threading_IAsyncLocal_);
DO_TYPEDEF(0x03882C18, ContextCallback);
DO_TYPEDEF(0x03869040, SparselyPopulatedArray_1_CancellationCallbackInfo___Array);
DO_TYPEDEF(0x0387EB80, CancellationTokenRegistration);
DO_TYPEDEF(0x0386A5A0, CancellationTokenRegistration__Array);
DO_TYPEDEF(0x0386D850, Timer);
DO_TYPEDEF(0x038AE0B8, Timer_Scheduler);
DO_TYPEDEF(0x03866A38, SortedList);
DO_TYPEDEF(0x038AB1B8, SortedList_KeyList);
DO_TYPEDEF(0x038AB368, SortedList_ValueList);
DO_TYPEDEF(0x038A15B0, IList);
DO_TYPEDEF(0x0386D8E0, TimerCallback);
DO_TYPEDEF(0x0386BB18, TaskScheduler);
DO_TYPEDEF(0x038A2ED8, ConditionalWeakTable_2_System_Threading_Tasks_TaskScheduler_System_Object_);
DO_TYPEDEF(0x0386B430, Ephemeron__Array);
DO_TYPEDEF(0x03894568, EventArgs);
DO_TYPEDEF(0x03872BB8, UnobservedTaskExceptionEventArgs);
DO_TYPEDEF(0x03895440, Exception);
DO_TYPEDEF(0x03876880, AggregateException);
DO_TYPEDEF(0x0389EC20, IDictionary);
DO_TYPEDEF(0x038C47B0, SafeSerializationManager);
DO_TYPEDEF(0x038B5D88, IList_1_System_Object_);
DO_TYPEDEF(0x038C4720, SafeSerializationEventArgs);
DO_TYPEDEF(0x038BD8B0, List_1_System_Object_);
DO_TYPEDEF(0x03867728, StackTrace);
DO_TYPEDEF(0x03867578, StackFrame);
DO_TYPEDEF(0x0386FBC0, StackTrace__Array);
DO_TYPEDEF(0x0386D3A0, IntPtr__Array);
DO_TYPEDEF(0x038C7088, ReadOnlyCollection_1_System_Exception_);
DO_TYPEDEF(0x038B5B48, IList_1_System_Exception_);
DO_TYPEDEF(0x0386B6F8, Exception__Array);
DO_TYPEDEF(0x038B4708, IEnumerator_1_System_Exception_);
DO_TYPEDEF(0x0386D070, ThreadPoolTaskScheduler);
DO_TYPEDEF(0x038B7A68, ParameterizedThreadStart);
DO_TYPEDEF(0x038A5B38, Dictionary_2_System_Int32_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x03870398, Task__Array);
DO_TYPEDEF(0x038B5128, IEnumerator_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038B2308, ICollection_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038ACED8, Task_ContingentProperties);
DO_TYPEDEF(0x038AD058, ManualResetEventSlim);
DO_TYPEDEF(0x0386B9F8, TaskExceptionHolder);
DO_TYPEDEF(0x03894A28, EventHandler);
DO_TYPEDEF(0x038BA8E0, List_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_);
DO_TYPEDEF(0x03895570, ExceptionDispatchInfo);
DO_TYPEDEF(0x0386B788, ExceptionDispatchInfo__Array);
DO_TYPEDEF(0x038C77D8, Shared_1_System_Threading_CancellationTokenRegistration_);
DO_TYPEDEF(0x038BF9E0, List_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038AD648, Func_1_System_Threading_Tasks_Task_ContingentProperties_);
DO_TYPEDEF(0x038C5BC0, Predicate_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038C58F0, Predicate_1_Object_);
DO_TYPEDEF(0x03869E80, SystemException);
DO_TYPEDEF(0x0386CEC0, ThreadAbortException);
DO_TYPEDEF(0x038666A8, Task_1_Task_);
DO_TYPEDEF(0x038C5F50, SemaphoreSlim);
DO_TYPEDEF(0x03866588, Task_1_System_Boolean_);
DO_TYPEDEF(0x038A74C8, SemaphoreSlim_TaskNode);
DO_TYPEDEF(0x038968F0, FileAccess__Enum);
DO_TYPEDEF(0x03872B28, UnmanagedMemoryStream);
DO_TYPEDEF(0x03878CB8, AssemblyNameFlags__Enum);
DO_TYPEDEF(0x03878AF0, AssemblyHashAlgorithm__Enum);
DO_TYPEDEF(0x03878D50, AssemblyVersionCompatibility__Enum);
DO_TYPEDEF(0x03878C20, AssemblyName);
DO_TYPEDEF(0x038692B0, StrongNameKeyPair);
DO_TYPEDEF(0x038745B8, Version);
DO_TYPEDEF(0x038ACF38, ManifestResourceInfo);
DO_TYPEDEF(0x038829B8, ConstructorInfo);
DO_TYPEDEF(0x038C2830, RuntimeConstructorInfo);
DO_TYPEDEF(0x038B0348, MonoCMethod);
DO_TYPEDEF(0x0386A870, ConstructorInfo__Array);
DO_TYPEDEF(0x03894B58, EventInfo_1);
DO_TYPEDEF(0x038C2A70, RuntimeEventInfo);
DO_TYPEDEF(0x038B04F8, MonoEvent);
DO_TYPEDEF(0x0386B670, EventInfo_1__Array);
DO_TYPEDEF(0x0386DDC0, MemberInfo_1__Array);
DO_TYPEDEF(0x038B3508, IEnumerable_1_System_Reflection_FieldInfo_);
DO_TYPEDEF(0x038B0CC8, MonoTypeInfo);
DO_TYPEDEF(0x038ADE48, MemberFilter);
DO_TYPEDEF(0x0386A240, Byte__Array);
DO_TYPEDEF(0x0386A630, Char__Array);
DO_TYPEDEF(0x038C27A0, RuntimeClassHandle);
DO_TYPEDEF(0x038C29E0, RuntimeEventHandle);
DO_TYPEDEF(0x038C2E60, RuntimePropertyHandle);
DO_TYPEDEF(0x03866138, SmallXmlParser);
DO_TYPEDEF(0x038C5AD0, SecurityParser);
DO_TYPEDEF(0x038AAC28, SmallXmlParser_IContentHandler);
DO_TYPEDEF(0x0386C800, TextReader);
DO_TYPEDEF(0x038AEDC8, Func_2_Object_String_);
DO_TYPEDEF(0x038AED38, Func_2_Object_Int32_);
DO_TYPEDEF(0x03867458, Stack);
DO_TYPEDEF(0x03868B60, StringBuilder);
DO_TYPEDEF(0x038AAB08, SmallXmlParser_AttrListImpl);
DO_TYPEDEF(0x038BF320, List_1_System_String_);
DO_TYPEDEF(0x038C59B0, SecurityElement);
DO_TYPEDEF(0x038786C8, ArrayList);
DO_TYPEDEF(0x038AAB98, SmallXmlParser_IAttrList);
DO_TYPEDEF(0x038661C8, SmallXmlParserException);
DO_TYPEDEF(0x0386B460, TailoringInfo);
DO_TYPEDEF(0x03882F10, ContractionComparer);
DO_TYPEDEF(0x0389C820, MSCompatUnicodeTable_c);
DO_TYPEDEF(0x038A25D8, Comparison_1_Mono_Globalization_Unicode_Level2Map_);
DO_TYPEDEF(0x038669A8, SortKeyBuffer);
DO_TYPEDEF(0x03875D40, ASN1);
DO_TYPEDEF(0x038A1EE8, PKCS7_ContentInfo);
DO_TYPEDEF(0x038A1F78, PKCS7_EncryptedData);
DO_TYPEDEF(0x03872DF8, Uri);
DO_TYPEDEF(0x03874AE0, Uri_UriScheme__Array);
DO_TYPEDEF(0x038C43C0, SafeBag);
DO_TYPEDEF(0x038B7288, PKCS12);
DO_TYPEDEF(0x03877A80, X509CertificateCollection);
DO_TYPEDEF(0x03880040, CipherMode__Enum);
DO_TYPEDEF(0x038B73A8, PaddingMode__Enum);
DO_TYPEDEF(0x03869A90, SymmetricAlgorithm);
DO_TYPEDEF(0x038A98F8, KeySizes);
DO_TYPEDEF(0x0386D8B0, KeySizes__Array);
DO_TYPEDEF(0x0389E630, ICryptoTransform);
DO_TYPEDEF(0x038BD850, RC4);
DO_TYPEDEF(0x03875AE0, ARC4Managed);
DO_TYPEDEF(0x038A21B8, PKCS8_PrivateKeyInfo);
DO_TYPEDEF(0x03877658, X509Certificate);
DO_TYPEDEF(0x03878DE8, AsymmetricAlgorithm);
DO_TYPEDEF(0x038BDB20, RSA);
DO_TYPEDEF(0x038BDCD0, RSAEncryptionPaddingMode__Enum);
DO_TYPEDEF(0x0389B880, HashAlgorithmName);
DO_TYPEDEF(0x038BDC40, RSAEncryptionPadding);
DO_TYPEDEF(0x038BE4B0, RSASignaturePaddingMode__Enum);
DO_TYPEDEF(0x038BE420, RSASignaturePadding);
DO_TYPEDEF(0x038BDDF0, RSAManaged);
DO_TYPEDEF(0x0387AF20, BigInteger);
DO_TYPEDEF(0x038A5B08, RSAManaged_KeyGeneratedEventHandler);
DO_TYPEDEF(0x03884F98, DSA);
DO_TYPEDEF(0x038850C8, DSAManaged);
DO_TYPEDEF(0x03890E70, DSAManaged_KeyGeneratedEventHandler);
DO_TYPEDEF(0x038785C8, X509ExtensionCollection);
DO_TYPEDEF(0x038A1D38, PKCS12_DeriveBytes);
DO_TYPEDEF(0x038B1AF8, X509CertificateCollection_X509CertificateEnumerator);
DO_TYPEDEF(0x03878400, X509Extension);
DO_TYPEDEF(0x038A9868, KeyPairPersistence);
DO_TYPEDEF(0x03883CB0, CspParameters);
DO_TYPEDEF(0x038C5800, SecureString);
DO_TYPEDEF(0x0389B7E8, HashAlgorithm);
DO_TYPEDEF(0x038AC6C8, MD2Managed);
DO_TYPEDEF(0x038AC7E8, MD4Managed);
DO_TYPEDEF(0x038A2128, PKCS8_EncryptedPrivateKeyInfo);
DO_TYPEDEF(0x03884A50, DESTransform);
DO_TYPEDEF(0x0388C7F0, BigInteger_ModulusRing);
DO_TYPEDEF(0x03869EE0, BigInteger__Array);
DO_TYPEDEF(0x038BB9F0, PrimalityTest);
DO_TYPEDEF(0x03881E70, ConfidenceFactor__Enum);
DO_TYPEDEF(0x038C63C8, SequentialSearchPrimeGeneratorBase);
DO_TYPEDEF(0x038B6E38, UnsafeNativeMethods_ManifestEtw_EtwEnableCallback);
DO_TYPEDEF(0x03894860, EventDescriptor);
DO_TYPEDEF(0x038C0B80, RegistryKey);
DO_TYPEDEF(0x038C4690, SafeRegistryHandle);
DO_TYPEDEF(0x038A3148, IRegistryApi);
DO_TYPEDEF(0x038C0AF0, RegistryHive__Enum);
DO_TYPEDEF(0x038A2188, IOException);
DO_TYPEDEF(0x03895998, ExpandString);
DO_TYPEDEF(0x038C0C10, RegistryKeyComparer);
DO_TYPEDEF(0x038A9748, KeyHandler);
DO_TYPEDEF(0x03872A08, UnixRegistryApi);
DO_TYPEDEF(0x0386D310, Int64__Array);
DO_TYPEDEF(0x03876F38, Win32RegistryApi);
DO_TYPEDEF(0x038B19D8, Win32Native_WIN32_FIND_DATA);
DO_TYPEDEF(0x038C44E0, SafeFindHandle);
DO_TYPEDEF(0x038954D8, ExceptionArgument__Enum);
DO_TYPEDEF(0x03873C08, ValueTuple);
DO_TYPEDEF(0x0388B8A0, Array_ArrayEnumerator);
DO_TYPEDEF(0x038B33E8, IEnumerable_1_System_Exception_);
DO_TYPEDEF(0x038B3478, IEnumerable_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_);
DO_TYPEDEF(0x038B5BD8, IList_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_);
DO_TYPEDEF(0x0387E820, _Filters);
DO_TYPEDEF(0x038AB9E8, LocalDataStoreHolder);
DO_TYPEDEF(0x038AB8C8, LocalDataStore);
DO_TYPEDEF(0x038AB958, LocalDataStoreElement);
DO_TYPEDEF(0x0386DB80, LocalDataStoreElement__Array);
DO_TYPEDEF(0x038ABA78, LocalDataStoreMgr);
DO_TYPEDEF(0x038BC980, List_1_System_LocalDataStore_);
DO_TYPEDEF(0x038A7580, Dictionary_2_System_String_System_LocalDataStoreSlot_);
DO_TYPEDEF(0x038ABB08, LocalDataStoreSlot);
DO_TYPEDEF(0x03875F98, Action);
DO_TYPEDEF(0x03877E78, AppDomainUnloadedException);
DO_TYPEDEF(0x03878338, ArgumentException);
DO_TYPEDEF(0x038783D0, ArgumentNullException);
DO_TYPEDEF(0x03878468, ArgumentOutOfRangeException);
DO_TYPEDEF(0x03878500, ArithmeticException);
DO_TYPEDEF(0x03878928, ArrayTypeMismatchException);
DO_TYPEDEF(0x03869B80, Attribute__Array);
DO_TYPEDEF(0x03879928, AttributeUsageAttribute);
DO_TYPEDEF(0x0387A5A0, BadImageFormatException);
DO_TYPEDEF(0x0387FA58, CharEnumerator);
DO_TYPEDEF(0x038824F8, ConsoleCancelEventHandler);
DO_TYPEDEF(0x03882460, ConsoleCancelEventArgs);
DO_TYPEDEF(0x03882628, ConsoleKeyInfo);
DO_TYPEDEF(0x0389E3D0, IConvertible);
DO_TYPEDEF(0x0386D340, TimeSpan);
DO_TYPEDEF(0x03887DB8, DateTimeOffset);
DO_TYPEDEF(0x03884888, DBNull);
DO_TYPEDEF(0x03891460, DefaultBinder_BinderState);
DO_TYPEDEF(0x038913C8, DefaultBinder_c);
DO_TYPEDEF(0x038C5D70, Predicate_1_Type_);
DO_TYPEDEF(0x03870608, TypeLoadException);
DO_TYPEDEF(0x0388ADC8, DllNotFoundException);
DO_TYPEDEF(0x03893008, Empty);
DO_TYPEDEF(0x03893DB0, EntryPointNotFoundException);
DO_TYPEDEF(0x03893B80, Enum_ValuesAndNames);
DO_TYPEDEF(0x03870D28, UInt64__Array);
DO_TYPEDEF(0x03895868, ExecutionEngineException);
DO_TYPEDEF(0x038ADC98, MemberAccessException);
DO_TYPEDEF(0x03896560, FieldAccessException);
DO_TYPEDEF(0x03897B58, FormatException);
DO_TYPEDEF(0x0387E788, _DTString);
DO_TYPEDEF(0x038910D0, DateTimeParse_MatchNumberDelegate);
DO_TYPEDEF(0x038A5308, IndexOutOfRangeException);
DO_TYPEDEF(0x038A8828, InvalidCastException);
DO_TYPEDEF(0x038A8A68, InvalidOperationException);
DO_TYPEDEF(0x038A8AF8, InvalidTimeZoneException);
DO_TYPEDEF(0x038AEF18, MethodAccessException);
DO_TYPEDEF(0x038AF538, MissingMemberException);
DO_TYPEDEF(0x038AF420, MissingFieldException);
DO_TYPEDEF(0x038AF5C8, MissingMethodException);
DO_TYPEDEF(0x038B11C8, MulticastNotSupportedException);
DO_TYPEDEF(0x038B2A88, NonSerializedAttribute);
DO_TYPEDEF(0x038B2C38, NotImplementedException);
DO_TYPEDEF(0x038B2CC8, NotSupportedException);
DO_TYPEDEF(0x038B30B8, NullReferenceException);
DO_TYPEDEF(0x0389EC50, Number_NumberBuffer);
DO_TYPEDEF(0x038B55D8, ObjectDisposedException);
DO_TYPEDEF(0x038B5DB8, ObsoleteAttribute);
DO_TYPEDEF(0x038B68F8, OperationCanceledException);
DO_TYPEDEF(0x038B6CE8, OutOfMemoryException);
DO_TYPEDEF(0x038B6D78, OverflowException);
DO_TYPEDEF(0x038B7AF8, ParamsArray);
DO_TYPEDEF(0x038BA2E0, PlatformNotSupportedException);
DO_TYPEDEF(0x038BE660, Random);
DO_TYPEDEF(0x038BE9C0, RankException);
DO_TYPEDEF(0x0386F860, RuntimeType__Array);
DO_TYPEDEF(0x038C2710, RuntimeAssembly);
DO_TYPEDEF(0x0386F740, RuntimeMethodInfo__Array);
DO_TYPEDEF(0x0386F590, RuntimeConstructorInfo__Array);
DO_TYPEDEF(0x0386F7D0, RuntimePropertyInfo__Array);
DO_TYPEDEF(0x0386F6B0, RuntimeFieldInfo__Array);
DO_TYPEDEF(0x0386F620, RuntimeEventInfo__Array);
DO_TYPEDEF(0x038BF980, ReflectionOnlyType);
DO_TYPEDEF(0x038C6608, SerializableAttribute);
DO_TYPEDEF(0x038C7AD8, SharedStatics);
DO_TYPEDEF(0x038AE5C0, Tokenizer_StringMaker);
DO_TYPEDEF(0x03867698, StackOverflowException);
DO_TYPEDEF(0x038B3C58, IEnumerable_1_System_String_);
DO_TYPEDEF(0x03869100, StringSplitOptions__Enum);
DO_TYPEDEF(0x03893728, Encoding);
DO_TYPEDEF(0x03880920, CodePageDataItem);
DO_TYPEDEF(0x03893430, EncoderFallback);
DO_TYPEDEF(0x038A8288, InternalEncoderBestFitFallback);
DO_TYPEDEF(0x03893560, EncoderNLS);
DO_TYPEDEF(0x038A8318, InternalEncoderBestFitFallbackBuffer);
DO_TYPEDEF(0x03888868, DecoderFallback);
DO_TYPEDEF(0x038A8168, InternalDecoderBestFitFallback);
DO_TYPEDEF(0x038A81F8, InternalDecoderBestFitFallbackBuffer);
DO_TYPEDEF(0x03875C10, ASCIIEncoding);
DO_TYPEDEF(0x03888998, DecoderNLS);
DO_TYPEDEF(0x03868D10, StringComparer);
DO_TYPEDEF(0x03883F10, CultureAwareComparer);
DO_TYPEDEF(0x038B6BC8, OrdinalComparer);
DO_TYPEDEF(0x038C4150, List_1_System_TimeZoneInfo_AdjustmentRule_);
DO_TYPEDEF(0x038ADDE8, TimeZoneInfo_TransitionTime);
DO_TYPEDEF(0x038ADD58, TimeZoneInfo_AdjustmentRule);
DO_TYPEDEF(0x03874918, TimeZoneInfo_AdjustmentRule__Array);
DO_TYPEDEF(0x0386D6A0, TimeZoneInfo);
DO_TYPEDEF(0x038B8330, List_1_KeyValuePair_2_System_DateTime_System_TimeType_);
DO_TYPEDEF(0x0386D580, TimeType);
DO_TYPEDEF(0x038C72C8, ReadOnlyCollection_1_System_TimeZoneInfo_);
DO_TYPEDEF(0x038B51B8, IEnumerator_1_System_TimeZoneInfo_);
DO_TYPEDEF(0x038BFB90, List_1_System_TimeZoneInfo_);
DO_TYPEDEF(0x038A5870, Dictionary_2_System_Int32_System_String_);
DO_TYPEDEF(0x038A5C58, Dictionary_2_System_Int32_System_TimeType_);
DO_TYPEDEF(0x038ADCC8, TimeZoneInfo_c);
DO_TYPEDEF(0x038A29C8, Comparison_1_TimeZoneInfo_AdjustmentRule_);
DO_TYPEDEF(0x0386D730, TimeZoneNotFoundException);
DO_TYPEDEF(0x038ADC68, Func_2_System_Reflection_AssemblyName_System_Reflection_Assembly_);
DO_TYPEDEF(0x038B0828, Func_4_System_Reflection_Assembly_String_Boolean_Type_);
DO_TYPEDEF(0x03870578, TypeInitializationException);
DO_TYPEDEF(0x03871FE8, UnauthorizedAccessException);
DO_TYPEDEF(0x03872228, UnhandledExceptionEventHandler);
DO_TYPEDEF(0x038AF390, Missing);
DO_TYPEDEF(0x03877CB0, AppDomain);
DO_TYPEDEF(0x038A76A0, Dictionary_2_System_String_System_Object_);
DO_TYPEDEF(0x038B6F88, KeyValuePair_2_System_String_System_Object_);
DO_TYPEDEF(0x038B4288, IEnumerator_1_KeyValuePair_2_System_String_System_Object_);
DO_TYPEDEF(0x03878B88, AssemblyLoadEventArgs);
DO_TYPEDEF(0x038C1870, ResolveEventHandler);
DO_TYPEDEF(0x038C17E0, ResolveEventArgs);
DO_TYPEDEF(0x03877DE0, AppDomainSetup);
DO_TYPEDEF(0x038714A8, UIntPtr);
DO_TYPEDEF(0x03882B80, Context);
DO_TYPEDEF(0x038A1BE8, IMessageSink);
DO_TYPEDEF(0x038BB270, List_1_System_Runtime_Remoting_Contexts_IContextProperty_);
DO_TYPEDEF(0x0389E040, IContextProperty);
DO_TYPEDEF(0x0386C7D0, IContextProperty__Array);
DO_TYPEDEF(0x0388BB60, DynamicPropertyCollection);
DO_TYPEDEF(0x03882CB0, ContextCallbackObject);
DO_TYPEDEF(0x0387D478, CADMethodCallMessage);
DO_TYPEDEF(0x0387D3E0, CADArgHolder);
DO_TYPEDEF(0x0387D5A8, CADMethodReturnMessage);
DO_TYPEDEF(0x038BA250, PlatformID__Enum);
DO_TYPEDEF(0x038B6868, OperatingSystem);
DO_TYPEDEF(0x0386C890, TextWriter);
DO_TYPEDEF(0x038689B0, StreamWriter);
DO_TYPEDEF(0x038B4A38, Console_WindowsConsole_WindowsCancelHandler);
DO_TYPEDEF(0x0388D888, Console_InternalCancelHandler);
DO_TYPEDEF(0x0389DD50, IConsoleDriver);
DO_TYPEDEF(0x038919B8, DelegateSerializationHolder_DelegateEntry);
DO_TYPEDEF(0x038A4E88, Identity);
DO_TYPEDEF(0x038C7028, ServerIdentity);
DO_TYPEDEF(0x03880590, ClientIdentity);
DO_TYPEDEF(0x03898608, GCHandle);
DO_TYPEDEF(0x03875E08, WeakReference);
DO_TYPEDEF(0x038AA158, Lease);
DO_TYPEDEF(0x038BD580, Queue);
DO_TYPEDEF(0x0389B9E0, Lease_RenewalDelegate);
DO_TYPEDEF(0x038A1480, ILease);
DO_TYPEDEF(0x038A3928, ISponsor);
DO_TYPEDEF(0x038803C8, ClientActivatedIdentity);
DO_TYPEDEF(0x038A1B58, IMessage);
DO_TYPEDEF(0x0389E760, ICustomAttributeProvider);
DO_TYPEDEF(0x03884298, CustomAttributeData);
DO_TYPEDEF(0x038B5AB8, IList_1_System_Reflection_CustomAttributeTypedArgument_);
DO_TYPEDEF(0x038B5A28, IList_1_System_Reflection_CustomAttributeNamedArgument_);
DO_TYPEDEF(0x0388E038, CustomAttributeData_LazyCAttrData);
DO_TYPEDEF(0x0389DFD8, MonoCustomAttrs_AttributeInfo);
DO_TYPEDEF(0x038B3028, NullConsoleDriver);
DO_TYPEDEF(0x038B31D8, NumberFormatter);
DO_TYPEDEF(0x0386CE30, Thread);
DO_TYPEDEF(0x038A13B0, AsyncLocal_1_System_Globalization_CultureInfo_);
DO_TYPEDEF(0x0389E430, Action_1_System_Threading_AsyncLocalValueChangedArgs_1_);
DO_TYPEDEF(0x0389ECE8, NumberFormatter_CustomInfo);
DO_TYPEDEF(0x0386BE78, TermInfoDriver);
DO_TYPEDEF(0x0386BF08, TermInfoReader);
DO_TYPEDEF(0x03868920, StreamReader);
DO_TYPEDEF(0x0387E200, CStreamWriter);
DO_TYPEDEF(0x0387D2B0, ByteMatcher);
DO_TYPEDEF(0x0386BF98, TermInfoStrings__Enum);
DO_TYPEDEF(0x03873FC8, ParameterizedStrings_FormatParam__Array);
DO_TYPEDEF(0x038A2488, ParameterizedStrings_LowLevelStack);
DO_TYPEDEF(0x0386D610, TimeZone);
DO_TYPEDEF(0x038707B8, TypeName);
DO_TYPEDEF(0x038AF568, TypeIdentifiers_Display);
DO_TYPEDEF(0x03870338, TypeIdentifier);
DO_TYPEDEF(0x038787F8, ArraySpec);
DO_TYPEDEF(0x038BB0F0, PointerSpec);
DO_TYPEDEF(0x03870848, TypeSpec);
DO_TYPEDEF(0x038C0010, List_1_System_TypeIdentifier_);
DO_TYPEDEF(0x038C00A0, List_1_System_TypeSpec_);
DO_TYPEDEF(0x038BCFB0, List_1_System_ModifierSpec_);
DO_TYPEDEF(0x038B0198, ModifierSpec);
DO_TYPEDEF(0x03877068, WindowsConsoleDriver);
DO_TYPEDEF(0x03888738, DecoderExceptionFallback);
DO_TYPEDEF(0x038887D0, DecoderExceptionFallbackBuffer);
DO_TYPEDEF(0x03888900, DecoderFallbackException);
DO_TYPEDEF(0x03888A30, DecoderReplacementFallback);
DO_TYPEDEF(0x03888AC8, DecoderReplacementFallbackBuffer);
DO_TYPEDEF(0x03893300, EncoderExceptionFallback);
DO_TYPEDEF(0x03893398, EncoderExceptionFallbackBuffer);
DO_TYPEDEF(0x038934C8, EncoderFallbackException);
DO_TYPEDEF(0x038935F8, EncoderReplacementFallback);
DO_TYPEDEF(0x03893690, EncoderReplacementFallbackBuffer);
DO_TYPEDEF(0x038939B8, Encoding_DefaultEncoder);
DO_TYPEDEF(0x03893920, Encoding_DefaultDecoder);
DO_TYPEDEF(0x03893AE8, Encoding_EncodingCharBuffer);
DO_TYPEDEF(0x03893A50, Encoding_EncodingByteBuffer);
DO_TYPEDEF(0x038A9D70, Latin1Encoding);
DO_TYPEDEF(0x03893858, EncodingProvider);
DO_TYPEDEF(0x038722B8, UnicodeEncoding);
DO_TYPEDEF(0x038AFB08, UnicodeEncoding_Decoder);
DO_TYPEDEF(0x038716E8, UTF32Encoding);
DO_TYPEDEF(0x038AF688, UTF32Encoding_UTF32Decoder);
DO_TYPEDEF(0x03871778, UTF7Encoding);
DO_TYPEDEF(0x0386F8F0, SByte__Array);
DO_TYPEDEF(0x038AF718, UTF7Encoding_Decoder);
DO_TYPEDEF(0x038AF8C8, UTF7Encoding_Encoder);
DO_TYPEDEF(0x038AF7A8, UTF7Encoding_DecoderUTF7Fallback);
DO_TYPEDEF(0x038AF838, UTF7Encoding_DecoderUTF7FallbackBuffer);
DO_TYPEDEF(0x03871808, UTF8Encoding);
DO_TYPEDEF(0x038AF9E8, UTF8Encoding_UTF8Encoder);
DO_TYPEDEF(0x038AF958, UTF8Encoding_UTF8Decoder);
DO_TYPEDEF(0x03896430, FastResourceComparer);
DO_TYPEDEF(0x03896AB8, FileBasedResourceGroveler);
DO_TYPEDEF(0x038A6A20, ResourceManager_ResourceManagerMediator);
DO_TYPEDEF(0x038C1990, ResourceManager);
DO_TYPEDEF(0x038A79F8, Dictionary_2_System_String_System_Resources_ResourceSet_);
DO_TYPEDEF(0x038C1B40, ResourceSet);
DO_TYPEDEF(0x038A32F8, IResourceReader);
DO_TYPEDEF(0x038A6990, ResourceManager_CultureNameResourceSetPair);
DO_TYPEDEF(0x038A3268, IResourceGroveler);
DO_TYPEDEF(0x038ACD88, ManifestBasedResourceGroveler);
DO_TYPEDEF(0x038AF4B0, MissingManifestResourceException);
DO_TYPEDEF(0x038AF6E8, MissingSatelliteAssemblyException);
DO_TYPEDEF(0x038C1900, ResourceFallbackManager);
DO_TYPEDEF(0x038A6900, ResourceFallbackManager_GetEnumerator_d_5);
DO_TYPEDEF(0x038C1BD0, ResourceTypeCode__Enum);
DO_TYPEDEF(0x038C1AB0, ResourceReader);
DO_TYPEDEF(0x0387BB00, BinaryReader);
DO_TYPEDEF(0x038A7968, Dictionary_2_System_String_System_Resources_ResourceLocator_);
DO_TYPEDEF(0x0387B6D8, BinaryFormatter);
DO_TYPEDEF(0x038A3C88, ISurrogateSelector);
DO_TYPEDEF(0x038A9180, Dictionary_2_System_Type_System_Runtime_Serialization_Formatters_Binary_TypeInformation_);
DO_TYPEDEF(0x038704E8, TypeInformation);
DO_TYPEDEF(0x038B52D8, IEnumerator_1_System_Type_);
DO_TYPEDEF(0x038A6AA8, ResourceReader_ResourceEnumerator);
DO_TYPEDEF(0x0388A318, DictionaryEntry);
DO_TYPEDEF(0x038C2F80, RuntimeResourceSet);
DO_TYPEDEF(0x038C49F0, SatelliteContractVersionAttribute);
DO_TYPEDEF(0x03876DD8, AmbiguousMatchException);
DO_TYPEDEF(0x03889018, DefaultMemberAttribute);
DO_TYPEDEF(0x038A89D8, InvalidFilterCriteriaException);
DO_TYPEDEF(0x038BAEB0, Pointer_1);
DO_TYPEDEF(0x038BFB30, ReflectionTypeLoadException);
DO_TYPEDEF(0x0386B580, TargetException);
DO_TYPEDEF(0x0386B6A0, TargetInvocationException);
DO_TYPEDEF(0x0386B728, TargetParameterCountException);
DO_TYPEDEF(0x0388BC28, Assembly_UnmanagedMemoryStreamForModule);
DO_TYPEDEF(0x03884330, CustomAttributeFormatException);
DO_TYPEDEF(0x03884460, CustomAttributeTypedArgument);
DO_TYPEDEF(0x038843C8, CustomAttributeNamedArgument);
DO_TYPEDEF(0x038B0858, MonoParameterInfo);
DO_TYPEDEF(0x0387BC30, BinaryWriter);
DO_TYPEDEF(0x0388A7D8, DirectoryInfo);
DO_TYPEDEF(0x03896BE8, FileInfo);
DO_TYPEDEF(0x03891AE0, Directory_SearchData);
DO_TYPEDEF(0x0388A870, DirectoryNotFoundException);
DO_TYPEDEF(0x0388B618, DriveNotFoundException);
DO_TYPEDEF(0x03893AB8, EndOfStreamException);
DO_TYPEDEF(0x03896C80, FileLoadException);
DO_TYPEDEF(0x03896DB0, FileNotFoundException);
DO_TYPEDEF(0x03869070, StringResultHandler);
DO_TYPEDEF(0x038C56E0, SearchResult);
DO_TYPEDEF(0x038AE238, MemoryStream);
DO_TYPEDEF(0x038B8BD0, PathTooLongException);
DO_TYPEDEF(0x038BA0A0, PinnedBufferMemoryStream);
DO_TYPEDEF(0x038AB8F8, Stream_NullStream);
DO_TYPEDEF(0x038ABAA8, Stream_SynchronousAsyncResult);
DO_TYPEDEF(0x038B5968, Stream_SynchronousAsyncResult_c);
DO_TYPEDEF(0x038ACF98, Func_1_System_Threading_ManualResetEvent_);
DO_TYPEDEF(0x038AB870, Stream_c);
DO_TYPEDEF(0x038AD1D0, Func_1_System_Threading_SemaphoreSlim_);
DO_TYPEDEF(0x038B0AF0, Func_5_System_IO_Stream_System_IO_Stream_ReadWriteParameters_AsyncCallback_Object_IAsyncResult_);
DO_TYPEDEF(0x038AB988, Stream_ReadWriteParameters);
DO_TYPEDEF(0x038B0438, Func_3_System_IO_Stream_IAsyncResult_Int32_);
DO_TYPEDEF(0x038A0EF0, Action_2_System_Threading_Tasks_Task_Object_);
DO_TYPEDEF(0x038B04C8, Func_3_System_IO_Stream_IAsyncResult_System_Threading_Tasks_VoidTaskResult_);
DO_TYPEDEF(0x038ABB38, StreamReader_NullStreamReader);
DO_TYPEDEF(0x03868FE0, StringReader);
DO_TYPEDEF(0x03869220, StringWriter);
DO_TYPEDEF(0x038AD7C8, TextReader_NullTextReader);
DO_TYPEDEF(0x038AD850, TextReader_SyncTextReader);
DO_TYPEDEF(0x038AD738, TextReader_c);
DO_TYPEDEF(0x038AD970, TextWriter_NullTextWriter);
DO_TYPEDEF(0x038ADA00, TextWriter_SyncTextWriter);
DO_TYPEDEF(0x038AD8E0, TextWriter_c);
DO_TYPEDEF(0x0386AFB8, DirectoryInfo__Array);
DO_TYPEDEF(0x03896E48, FileStream);
DO_TYPEDEF(0x03896D18, FileMode__Enum);
DO_TYPEDEF(0x03894A58, FileStream_ReadDelegate);
DO_TYPEDEF(0x03894AF0, FileStream_WriteDelegate);
DO_TYPEDEF(0x03896EE0, FileStreamAsyncResult);
DO_TYPEDEF(0x038B06A8, MonoIOError__Enum);
DO_TYPEDEF(0x03872108, UnexceptionalStreamReader);
DO_TYPEDEF(0x03872198, UnexceptionalStreamWriter);
DO_TYPEDEF(0x0387E170, CStreamReader);
DO_TYPEDEF(0x038C4DB0, Nullable_1_Int32_);
DO_TYPEDEF(0x038840D8, CultureNotFoundException);
DO_TYPEDEF(0x038A7C38, Dictionary_2_System_String_System_String_);
DO_TYPEDEF(0x03887D20, DateTimeFormatInfoScanner);
DO_TYPEDEF(0x038941D8, EraInfo);
DO_TYPEDEF(0x0389A158, GregorianCalendarHelper);
DO_TYPEDEF(0x0386B4C0, EraInfo__Array);
DO_TYPEDEF(0x038970D8, HebrewNumber_HebrewValue);
DO_TYPEDEF(0x0389BFA0, HijriCalendar);
DO_TYPEDEF(0x038A91A8, JapaneseCalendar);
DO_TYPEDEF(0x0386B4F0, TaiwanCalendar);
DO_TYPEDEF(0x0386CDA0, ThaiBuddhistCalendar);
DO_TYPEDEF(0x03874880, TimeSpanParse_TimeSpanToken__Array);
DO_TYPEDEF(0x038749B0, UmAlQuraCalendar_DateMapping__Array);
DO_TYPEDEF(0x03871F58, UmAlQuraCalendar);
DO_TYPEDEF(0x038A4F18, IdnMapping);
DO_TYPEDEF(0x038BCF50, Punycode);
DO_TYPEDEF(0x038C08B0, RegionInfo);
DO_TYPEDEF(0x03879598, AtomicBoolean);
DO_TYPEDEF(0x0387E9B8, CancellationCallbackCoreWorkArguments);
DO_TYPEDEF(0x0386A510, CancellationToken__Array);
DO_TYPEDEF(0x038A1858, AsyncTaskMethodBuilder_1_System_Boolean_);
DO_TYPEDEF(0x0389CCB0, IAsyncStateMachine);
DO_TYPEDEF(0x03866EB8, SpinLock);
DO_TYPEDEF(0x03875DD8, AbandonedMutexException);
DO_TYPEDEF(0x038B1408, Mutex);
DO_TYPEDEF(0x03879E80, AutoResetEvent);
DO_TYPEDEF(0x038ABCB8, LockRecursionException);
DO_TYPEDEF(0x038C5EC0, SemaphoreFullException);
DO_TYPEDEF(0x038B3388, OSSpecificSynchronizationContext);
DO_TYPEDEF(0x038A2DB8, ConditionalWeakTable_2_System_Object_System_Threading_OSSpecificSynchronizationContext_);
DO_TYPEDEF(0x0389EEB0, OSSpecificSynchronizationContext_InvocationEntryDelegate);
DO_TYPEDEF(0x0389EE18, OSSpecificSynchronizationContext_InvocationContext);
DO_TYPEDEF(0x0389ED80, OSSpecificSynchronizationContext_c);
DO_TYPEDEF(0x038A31A8, ConditionalWeakTable_2_TKey_TValue_CreateValueCallback_System_Object_System_Threading_OSSpecificSynchronizationContext_);
DO_TYPEDEF(0x03869C40, SynchronizationLockException);
DO_TYPEDEF(0x0386CF50, ThreadHelper);
DO_TYPEDEF(0x0386D220, ThreadStart);
DO_TYPEDEF(0x03875520, WaitCallback);
DO_TYPEDEF(0x03875948, WaitOrTimerCallback);
DO_TYPEDEF(0x0386D100, ThreadPoolWorkQueue);
DO_TYPEDEF(0x038ADBA8, ThreadPoolWorkQueue_QueueSegment);
DO_TYPEDEF(0x038A3F58, IThreadPoolWorkItem);
DO_TYPEDEF(0x0386CE00, IThreadPoolWorkItem__Array);
DO_TYPEDEF(0x038C7988, ThreadPoolWorkQueue_SparseArray_1_ThreadPoolWorkQueue_WorkStealingQueue_);
DO_TYPEDEF(0x038ADC38, ThreadPoolWorkQueue_WorkStealingQueue);
DO_TYPEDEF(0x0386D190, ThreadPoolWorkQueueThreadLocals);
DO_TYPEDEF(0x038BD610, QueueUserWorkItemCallback);
DO_TYPEDEF(0x038C09D0, RegisteredWaitHandle);
DO_TYPEDEF(0x0386D2B0, ThreadStateException);
DO_TYPEDEF(0x03871118, WaitHandle__Array);
DO_TYPEDEF(0x038758B0, WaitHandleCannotBeOpenedException);
DO_TYPEDEF(0x038AE148, Timer_TimerComparer);
DO_TYPEDEF(0x038BFC20, List_1_System_Threading_Timer_);
DO_TYPEDEF(0x038B7798, ParallelOptions);
DO_TYPEDEF(0x0389EC80, Action_1_Int32_);
DO_TYPEDEF(0x038B7678, ParallelLoopStateFlags);
DO_TYPEDEF(0x038B75E8, ParallelLoopState32);
DO_TYPEDEF(0x038B7708, ParallelLoopStateFlags32);
DO_TYPEDEF(0x038BE930, RangeWorker);
DO_TYPEDEF(0x038C7868, Shared_1_System_Int64_);
DO_TYPEDEF(0x0386CF20, IndexRange__Array);
DO_TYPEDEF(0x038BE8A0, RangeManager);
DO_TYPEDEF(0x0386B968, TaskContinuation);
DO_TYPEDEF(0x038678D8, StandardTaskContinuation);
DO_TYPEDEF(0x0386BCC8, TaskStatus__Enum);
DO_TYPEDEF(0x038C7118, ReadOnlyCollection_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_);
DO_TYPEDEF(0x0389F698, Action_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038A3DA8, ITaskCompletionAction);
DO_TYPEDEF(0x038B3CE8, IEnumerable_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038ACFF8, Task_SetOnInvokeMres);
DO_TYPEDEF(0x03866738, Task_1_VoidTaskResult_);
DO_TYPEDEF(0x038ACF68, Task_DelayPromise);
DO_TYPEDEF(0x038ACE48, Task_c_DisplayClass178_0);
DO_TYPEDEF(0x038ACDB8, Task_c);
DO_TYPEDEF(0x03881A50, CompletionActionInvoker);
DO_TYPEDEF(0x038B7558, ParallelForReplicatingTask);
DO_TYPEDEF(0x038B74C8, ParallelForReplicaTask);
DO_TYPEDEF(0x0386B8D8, TaskCanceledException);
DO_TYPEDEF(0x03882DE0, ContinuationTaskFromTask);
DO_TYPEDEF(0x03879FB0, AwaitTaskContinuation);
DO_TYPEDEF(0x03869BB0, SynchronizationContextAwaitTaskContinuation);
DO_TYPEDEF(0x038ABF20, SynchronizationContextAwaitTaskContinuation_c);
DO_TYPEDEF(0x0386BBA8, TaskSchedulerAwaitTaskContinuation);
DO_TYPEDEF(0x038AD110, TaskSchedulerAwaitTaskContinuation_c);
DO_TYPEDEF(0x0388C2A0, AwaitTaskContinuation_c);
DO_TYPEDEF(0x038B5EA8, IList_1_System_Threading_Tasks_Task_);
DO_TYPEDEF(0x038AD088, TaskFactory_CompleteOnInvokePromise);
DO_TYPEDEF(0x0386BC38, TaskSchedulerException);
DO_TYPEDEF(0x038AD230, TaskToApm_TaskWrapperAsyncResult);
DO_TYPEDEF(0x038AD1A0, TaskToApm_c_DisplayClass3_0);
DO_TYPEDEF(0x038C5920, SecurityDocument);
DO_TYPEDEF(0x038A7438, SecurityElement_SecurityAttribute);
DO_TYPEDEF(0x038C5A40, SecurityException);
DO_TYPEDEF(0x0387D4A8, XmlSyntaxException);
DO_TYPEDEF(0x038942A0, Evidence_EvidenceEnumerator);
DO_TYPEDEF(0x038B7CA8, Parser);
DO_TYPEDEF(0x0386DD60, Tokenizer);
DO_TYPEDEF(0x038AE4A0, Tokenizer_ITokenReader);
DO_TYPEDEF(0x0386DE80, TokenizerStream);
DO_TYPEDEF(0x0386DDF0, TokenizerShortBlock);
DO_TYPEDEF(0x0386D1F0, Int16__Array);
DO_TYPEDEF(0x0386DF10, TokenizerStringBlock);
DO_TYPEDEF(0x038AE530, Tokenizer_StreamTokenReader);
DO_TYPEDEF(0x03880298, ClaimsIdentity);
DO_TYPEDEF(0x03876FD0, WindowsAccountType__Enum);
DO_TYPEDEF(0x03877100, WindowsIdentity);
DO_TYPEDEF(0x038B9DA0, List_1_System_Security_Claims_Claim_);
DO_TYPEDEF(0x03880200, Claim);
DO_TYPEDEF(0x038B44C8, IEnumerator_1_System_Security_Claims_Claim_);
DO_TYPEDEF(0x038A2158, Collection_1_System_Collections_Generic_IEnumerable_1_);
DO_TYPEDEF(0x038B3238, IEnumerable_1_System_Security_Claims_Claim_);
DO_TYPEDEF(0x03877198, WindowsImpersonationContext);
DO_TYPEDEF(0x038B29C8, IDictionary_2_System_String_System_String_);
DO_TYPEDEF(0x038A00E8, IIdentity);
DO_TYPEDEF(0x0388D330, ClaimsIdentity_get_Claims_d_51);
DO_TYPEDEF(0x03876750, Aes);
DO_TYPEDEF(0x038C1FC0, Rijndael);
DO_TYPEDEF(0x038C2050, RijndaelManaged);
DO_TYPEDEF(0x038BDE80, RSAOAEPKeyExchangeDeformatter);
DO_TYPEDEF(0x038BDF10, RSAOAEPKeyExchangeFormatter);
DO_TYPEDEF(0x03878E80, AsymmetricSignatureDeformatter);
DO_TYPEDEF(0x03885160, DSASignatureDeformatter);
DO_TYPEDEF(0x03878F18, AsymmetricSignatureFormatter);
DO_TYPEDEF(0x03885290, DSASignatureFormatter);
DO_TYPEDEF(0x03883AE8, CryptographicException);
DO_TYPEDEF(0x03883B80, CryptographicUnexpectedOperationException);
DO_TYPEDEF(0x03883A58, CryptoStream);
DO_TYPEDEF(0x038A1A08, AsyncTaskMethodBuilder_1_System_Int32_);
DO_TYPEDEF(0x038A1CD8, AsyncTaskMethodBuilder_1_System_Threading_Tasks_VoidTaskResult_);
DO_TYPEDEF(0x03879468, AsyncTaskMethodBuilder);
DO_TYPEDEF(0x03884920, DES);
DO_TYPEDEF(0x038849B8, DESCryptoServiceProvider);
DO_TYPEDEF(0x038A9A18, KeyedHashAlgorithm);
DO_TYPEDEF(0x0389A9A8, HMAC);
DO_TYPEDEF(0x0389AA40, HMACMD5);
DO_TYPEDEF(0x0389AAD8, HMACRIPEMD160);
DO_TYPEDEF(0x0389AB70, HMACSHA1);
DO_TYPEDEF(0x0389AC08, HMACSHA256);
DO_TYPEDEF(0x0389ACA0, HMACSHA384);
DO_TYPEDEF(0x0389AD38, HMACSHA512);
DO_TYPEDEF(0x038AC3F8, MACTripleDES);
DO_TYPEDEF(0x0386B3D0, TailStream);
DO_TYPEDEF(0x0386F530, TripleDES);
DO_TYPEDEF(0x0386F5C0, TripleDESCryptoServiceProvider);
DO_TYPEDEF(0x038B7318, PKCS1MaskGenerationMethod);
DO_TYPEDEF(0x038AC878, MD5);
DO_TYPEDEF(0x038AC908, MD5CryptoServiceProvider);
DO_TYPEDEF(0x038BD6A0, RC2);
DO_TYPEDEF(0x038BD730, RC2CryptoServiceProvider);
DO_TYPEDEF(0x038C1D80, Rfc2898DeriveBytes);
DO_TYPEDEF(0x038C20E0, RijndaelManagedTransform);
DO_TYPEDEF(0x038BD970, RIPEMD160);
DO_TYPEDEF(0x038BDA00, RIPEMD160Managed);
DO_TYPEDEF(0x038BDBB0, RSACryptoServiceProvider);
DO_TYPEDEF(0x03883C18, CspKeyContainerInfo);
DO_TYPEDEF(0x038BDFA0, RSAPKCS1KeyExchangeDeformatter);
DO_TYPEDEF(0x038BE030, RSAPKCS1KeyExchangeFormatter);
DO_TYPEDEF(0x038C3B50, SHA1);
DO_TYPEDEF(0x038C3D00, SHA1Managed);
DO_TYPEDEF(0x038C3D90, SHA256);
DO_TYPEDEF(0x038C3E20, SHA256Managed);
DO_TYPEDEF(0x038C3EB0, SHA384);
DO_TYPEDEF(0x038C3F40, SHA384Managed);
DO_TYPEDEF(0x038C3FD0, SHA512);
DO_TYPEDEF(0x038C4060, SHA512Managed);
DO_TYPEDEF(0x038BE0C0, RSAPKCS1SHA1SignatureDescription);
DO_TYPEDEF(0x038BE150, RSAPKCS1SHA256SignatureDescription);
DO_TYPEDEF(0x038BE1E0, RSAPKCS1SHA384SignatureDescription);
DO_TYPEDEF(0x038BE270, RSAPKCS1SHA512SignatureDescription);
DO_TYPEDEF(0x038851F8, DSASignatureDescription);
DO_TYPEDEF(0x03885030, DSACryptoServiceProvider);
DO_TYPEDEF(0x038BD7C0, RC2Transform);
DO_TYPEDEF(0x03870C08, UInt16__Array);
DO_TYPEDEF(0x038BE300, RSAPKCS1SignatureDeformatter);
DO_TYPEDEF(0x038BE390, RSAPKCS1SignatureFormatter);
DO_TYPEDEF(0x038C3C70, SHA1Internal);
DO_TYPEDEF(0x038C3BE0, SHA1CryptoServiceProvider);
DO_TYPEDEF(0x0386F650, TripleDESTransform);
DO_TYPEDEF(0x038776F0, X509Certificate_1);
DO_TYPEDEF(0x03877BB0, X509CertificateImpl);
DO_TYPEDEF(0x03877CE0, X509CertificateImplMono);
DO_TYPEDEF(0x03889A30, DeserializationEventHandler);
DO_TYPEDEF(0x038C67B8, SerializationEventHandler);
DO_TYPEDEF(0x03897C88, FormatterConverter);
DO_TYPEDEF(0x03894F18, FormatterServices_c_DisplayClass9_0);
DO_TYPEDEF(0x038ADED8, MemberHolder);
DO_TYPEDEF(0x038B58A8, ObjectIDGenerator);
DO_TYPEDEF(0x038B5938, ObjectManager);
DO_TYPEDEF(0x038B56F8, ObjectHolder);
DO_TYPEDEF(0x038A36E8, ISerializationSurrogate);
DO_TYPEDEF(0x03897568, FixupHolderList);
DO_TYPEDEF(0x038974D0, FixupHolder);
DO_TYPEDEF(0x0386BC08, FixupHolder__Array);
DO_TYPEDEF(0x038AC1B8, LongList);
DO_TYPEDEF(0x03873D28, ValueTypeFixupInfo);
DO_TYPEDEF(0x03870698, TypeLoadExceptionHolder);
DO_TYPEDEF(0x0386E2D0, ObjectHolder__Array);
DO_TYPEDEF(0x038B5788, ObjectHolderList);
DO_TYPEDEF(0x038B5818, ObjectHolderListEnumerator);
DO_TYPEDEF(0x038C6848, SerializationEvents);
DO_TYPEDEF(0x038BCE90, List_1_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038C6968, SerializationException);
DO_TYPEDEF(0x038C69F8, SerializationFieldInfo);
DO_TYPEDEF(0x038C6BA8, SerializationInfoEnumerator);
DO_TYPEDEF(0x038C6728, SerializationEntry);
DO_TYPEDEF(0x038C6C38, SerializationObjectManager);
DO_TYPEDEF(0x0387BB98, BinaryTypeEnum__Enum);
DO_TYPEDEF(0x03877360, WriteObjectInfo);
DO_TYPEDEF(0x038C6458, SerObjectInfoCache);
DO_TYPEDEF(0x038C64E8, SerObjectInfoInit);
DO_TYPEDEF(0x038C6578, SerStack);
DO_TYPEDEF(0x038A85E8, InternalPrimitiveTypeE__Enum);
DO_TYPEDEF(0x038B5D28, ObjectWriter);
DO_TYPEDEF(0x0387E6F0, _BinaryWriter);
DO_TYPEDEF(0x0387B770, BinaryMethodCall);
DO_TYPEDEF(0x0387B808, BinaryMethodReturn);
DO_TYPEDEF(0x0387B8A0, BinaryObject);
DO_TYPEDEF(0x0387E658, _BinaryParser);
DO_TYPEDEF(0x038B5C98, ObjectReader);
DO_TYPEDEF(0x038A8438, InternalFE);
DO_TYPEDEF(0x038A7998, IntSizedArray);
DO_TYPEDEF(0x038B1648, NameCache);
DO_TYPEDEF(0x038A2C98, ConcurrentDictionary_2_System_String_System_Object_);
DO_TYPEDEF(0x038C8190, SizedArray);
DO_TYPEDEF(0x038A8558, InternalParseTypeE__Enum);
DO_TYPEDEF(0x038A84C8, InternalObjectTypeE__Enum);
DO_TYPEDEF(0x038A80D8, InternalArrayTypeE__Enum);
DO_TYPEDEF(0x038B7C18, ParseRecord);
DO_TYPEDEF(0x038BEDB0, ReadObjectInfo);
DO_TYPEDEF(0x038BFF80, List_1_System_Type_);
DO_TYPEDEF(0x038BBA80, PrimitiveArray);
DO_TYPEDEF(0x0386B1F8, Double__Array);
DO_TYPEDEF(0x0386FAA0, Single__Array);
DO_TYPEDEF(0x0387B2B0, BinaryAssemblyInfo);
DO_TYPEDEF(0x0387B9D0, BinaryObjectWithMap);
DO_TYPEDEF(0x0387BA68, BinaryObjectWithMapTyped);
DO_TYPEDEF(0x03869F70, BinaryTypeEnum__Enum__Array);
DO_TYPEDEF(0x0387B938, BinaryObjectString);
DO_TYPEDEF(0x0387B5A8, BinaryCrossAppDomainString);
DO_TYPEDEF(0x038ADFF8, MemberPrimitiveTyped);
DO_TYPEDEF(0x038AE088, MemberPrimitiveUnTyped);
DO_TYPEDEF(0x038AE118, MemberReference);
DO_TYPEDEF(0x038B5AE8, ObjectNull);
DO_TYPEDEF(0x038AED68, MessageEnd);
DO_TYPEDEF(0x0387B180, BinaryArrayTypeEnum__Enum);
DO_TYPEDEF(0x0387B0E8, BinaryArray);
DO_TYPEDEF(0x0387B218, BinaryAssembly);
DO_TYPEDEF(0x038C6A88, SerializationHeaderRecord);
DO_TYPEDEF(0x0387B478, BinaryCrossAppDomainAssembly);
DO_TYPEDEF(0x0387B510, BinaryCrossAppDomainMap);
DO_TYPEDEF(0x038B59C8, ObjectMap);
DO_TYPEDEF(0x038B5C08, ObjectProgress);
DO_TYPEDEF(0x038B1768, NameInfo);
DO_TYPEDEF(0x03871238, WriteObjectInfo__Array);
DO_TYPEDEF(0x038B5A58, ObjectMapInfo);
DO_TYPEDEF(0x038A07A0, ObjectReader_TypeNAssembly);
DO_TYPEDEF(0x038A0708, ObjectReader_TopLevelAssemblyTypeResolver);
DO_TYPEDEF(0x03873B78, ValueFixup);
DO_TYPEDEF(0x0387F7F8, ChannelInfo);
DO_TYPEDEF(0x038700F8, TypeEntry);
DO_TYPEDEF(0x038761F8, ActivatedClientTypeEntry);
DO_TYPEDEF(0x0389DFA8, IContextAttribute);
DO_TYPEDEF(0x03876290, ActivatedServiceTypeEntry);
DO_TYPEDEF(0x038940A8, EnvoyInfo);
DO_TYPEDEF(0x03866258, SoapAttribute);
DO_TYPEDEF(0x03876C40, WellKnownClientTypeEntry);
DO_TYPEDEF(0x03876CD8, WellKnownServiceTypeEntry);
DO_TYPEDEF(0x0387F760, ChannelData);
DO_TYPEDEF(0x038BCAD0, ProviderData);
DO_TYPEDEF(0x03881FA0, ConfigHandler);
DO_TYPEDEF(0x03897D20, FormatterData);
DO_TYPEDEF(0x038C0F70, RemotingException);
DO_TYPEDEF(0x038A1D98, IMethodReturnMessage);
DO_TYPEDEF(0x038A1C78, IMethodCallMessage);
DO_TYPEDEF(0x038C1000, RemotingProxy);
DO_TYPEDEF(0x038AF038, MethodCall);
DO_TYPEDEF(0x03882758, ConstructionCall);
DO_TYPEDEF(0x0389C9B8, IActivator);
DO_TYPEDEF(0x038A1D08, IMethodMessage);
DO_TYPEDEF(0x038A67E8, RemotingServices_CACD);
DO_TYPEDEF(0x038C7FE8, SingletonIdentity);
DO_TYPEDEF(0x038C7EC8, SingleCallIdentity);
DO_TYPEDEF(0x0388AC00, DisposerReplySink);
DO_TYPEDEF(0x0389EDE8, IDisposable);
DO_TYPEDEF(0x038AAD48, SoapServices_TypeInfo);
DO_TYPEDEF(0x03870458, TypeInfo_1);
DO_TYPEDEF(0x038BCBF0, ProxyAttribute);
DO_TYPEDEF(0x0386F380, TransparentProxy);
DO_TYPEDEF(0x038B07C8, MonoMethodMessage);
DO_TYPEDEF(0x03879338, AsyncResult);
DO_TYPEDEF(0x038AECD8, MessageDictionary);
DO_TYPEDEF(0x038AC488, MCMDictionary);
DO_TYPEDEF(0x038AA1E8, LeaseManager);
DO_TYPEDEF(0x038AA278, LeaseSink);
DO_TYPEDEF(0x0389F5A0, IDynamicProperty);
DO_TYPEDEF(0x0389DDE8, IConstructionCallMessage);
DO_TYPEDEF(0x03892620, DynamicPropertyCollection_DynamicPropertyReg);
DO_TYPEDEF(0x0389F508, IDynamicMessageSink);
DO_TYPEDEF(0x03883928, CrossContextChannel);
DO_TYPEDEF(0x0388DCB0, CrossContextChannel_ContextRestoreSink);
DO_TYPEDEF(0x0389D500, IChannelSender);
DO_TYPEDEF(0x0389D2A0, IChannel);
DO_TYPEDEF(0x038C1CF0, ReturnMessage);
DO_TYPEDEF(0x038AF1E8, MethodReturnDictionary);
DO_TYPEDEF(0x03878208, ArgInfo);
DO_TYPEDEF(0x038837F8, CrossAppDomainData);
DO_TYPEDEF(0x03883760, CrossAppDomainChannel);
DO_TYPEDEF(0x03883890, CrossAppDomainSink);
DO_TYPEDEF(0x0388DC18, CrossAppDomainSink_ProcessMessageRes);
DO_TYPEDEF(0x038792A0, AsyncRequest);
DO_TYPEDEF(0x038C8070, SinkProviderData);
DO_TYPEDEF(0x03877D48, AppDomainLevelActivator);
DO_TYPEDEF(0x0389DE80, IConstructionReturnMessage);
DO_TYPEDEF(0x03882888, ConstructionLevelActivator);
DO_TYPEDEF(0x03882D48, ContextLevelActivator);
DO_TYPEDEF(0x038662E8, SoapFieldAttribute);
DO_TYPEDEF(0x03866378, SoapMethodAttribute);
DO_TYPEDEF(0x03866408, SoapParameterAttribute);
DO_TYPEDEF(0x03866528, SoapTypeAttribute);
DO_TYPEDEF(0x0387D640, CADObjRef);
DO_TYPEDEF(0x0387D510, CADMethodRef);
DO_TYPEDEF(0x038804F8, ClientContextTerminatorSink);
DO_TYPEDEF(0x03880460, ClientContextReplySink);
DO_TYPEDEF(0x038827F0, ConstructionCallDictionary);
DO_TYPEDEF(0x038AF158, MethodResponse);
DO_TYPEDEF(0x03882920, ConstructionResponse);
DO_TYPEDEF(0x03894140, EnvoyTerminatorSink);
DO_TYPEDEF(0x038943A0, ErrorMessage);
DO_TYPEDEF(0x0389D9F0, MessageDictionary_DictionaryEnumerator);
DO_TYPEDEF(0x038C1120, RemotingSurrogate);
DO_TYPEDEF(0x038B5428, ObjRefSurrogate);
DO_TYPEDEF(0x038C11B0, RemotingSurrogateSelector);
DO_TYPEDEF(0x038C6F98, ServerContextTerminatorSink);
DO_TYPEDEF(0x038C7148, ServerObjectTerminatorSink);
DO_TYPEDEF(0x038C70B8, ServerObjectReplySink);
DO_TYPEDEF(0x038674E8, StackBuilderSink);
DO_TYPEDEF(0x03869310, Task_1_System_Int32___Array);
DO_TYPEDEF(0x0388BE88, AsyncMethodBuilderCore_MoveNextRunner);
DO_TYPEDEF(0x0388BDF0, AsyncMethodBuilderCore_ContinuationWrapper);
DO_TYPEDEF(0x0388BD58, AsyncMethodBuilderCore_c_DisplayClass4_0);
DO_TYPEDEF(0x0388BCC0, AsyncMethodBuilderCore_c);
DO_TYPEDEF(0x038702A8, TypeForwardedFromAttribute);
DO_TYPEDEF(0x038B2F38, YieldAwaitable_YieldAwaiter);
DO_TYPEDEF(0x03881208, ComImportAttribute);
DO_TYPEDEF(0x038BB840, PreserveSigAttribute);
DO_TYPEDEF(0x038A5158, InAttribute);
DO_TYPEDEF(0x038B6C58, OutAttribute);
DO_TYPEDEF(0x038B6AA8, OptionalAttribute);
DO_TYPEDEF(0x0388AD30, DllImportAttribute);
DO_TYPEDEF(0x038967C0, FieldOffsetAttribute);
DO_TYPEDEF(0x0387DE80, COMException);
DO_TYPEDEF(0x038AC368, LowLevelComparer);
DO_TYPEDEF(0x0388BA60, ArrayList_IListWrapper);
DO_TYPEDEF(0x0388BAF8, ArrayList_ReadOnlyArrayList);
DO_TYPEDEF(0x0388B9C8, ArrayList_ArrayListEnumeratorSimple);
DO_TYPEDEF(0x0387F040, CaseInsensitiveComparer);
DO_TYPEDEF(0x0387F0D8, CaseInsensitiveHashCodeProvider);
DO_TYPEDEF(0x03881760, Comparer);
DO_TYPEDEF(0x03881928, CompatibleComparer);
DO_TYPEDEF(0x038A0050, IHashCodeProvider);
DO_TYPEDEF(0x03893138, EmptyReadOnlyDictionaryInternal);
DO_TYPEDEF(0x03893888, EmptyReadOnlyDictionaryInternal_NodeEnumerator);
DO_TYPEDEF(0x03896E78, Hashtable_KeyCollection);
DO_TYPEDEF(0x03896FA8, Hashtable_ValueCollection);
DO_TYPEDEF(0x03896F10, Hashtable_SyncHashtable);
DO_TYPEDEF(0x03896DE0, Hashtable_HashtableEnumerator);
DO_TYPEDEF(0x038A2E48, ConditionalWeakTable_2_System_Object_System_Runtime_Serialization_SerializationInfo_);
DO_TYPEDEF(0x038AB338, ListDictionaryInternal);
DO_TYPEDEF(0x0389C490, ListDictionaryInternal_DictionaryNode);
DO_TYPEDEF(0x0389C528, ListDictionaryInternal_NodeEnumerator);
DO_TYPEDEF(0x0389C5C0, ListDictionaryInternal_NodeKeyValueCollection);
DO_TYPEDEF(0x038B5698, ListDictionaryInternal_NodeKeyValueCollection_NodeKeyValueEnumerator);
DO_TYPEDEF(0x038A5A78, Queue_QueueEnumerator);
DO_TYPEDEF(0x038AB2D8, SortedList_SyncSortedList);
DO_TYPEDEF(0x038AB248, SortedList_SortedListEnumerator);
DO_TYPEDEF(0x038AB518, Stack_StackEnumerator);
DO_TYPEDEF(0x03894BF0, EventLevel__Enum);
DO_TYPEDEF(0x03894F80, EventSource);
DO_TYPEDEF(0x0387D898, CDSCollectionETWBCLProvider);
DO_TYPEDEF(0x0386E978, TraceLoggingEventTypes);
DO_TYPEDEF(0x03894DB8, EventOpcode__Enum);
DO_TYPEDEF(0x0386EA88, TraceLoggingTypeInfo);
DO_TYPEDEF(0x03870818, TraceLoggingTypeInfo__Array);
DO_TYPEDEF(0x038B16D8, NameInfo_1);
DO_TYPEDEF(0x03872288, EventSource_EventMetadata__Array);
DO_TYPEDEF(0x03894698, EventCommandEventArgs);
DO_TYPEDEF(0x03894990, EventDispatcher);
DO_TYPEDEF(0x03894C88, EventListener);
DO_TYPEDEF(0x038950B0, EventSourceCreatedEventArgs);
DO_TYPEDEF(0x03895310, EventWrittenEventArgs);
DO_TYPEDEF(0x038C71A8, ReadOnlyCollection_1_System_Object_);
DO_TYPEDEF(0x038C7238, ReadOnlyCollection_1_System_String_);
DO_TYPEDEF(0x038B5E18, IList_1_System_String_);
DO_TYPEDEF(0x038763C0, ActivityFilter);
DO_TYPEDEF(0x038A2B78, ConcurrentDictionary_2_System_Guid_System_Int32_);
DO_TYPEDEF(0x038B6B08, KeyValuePair_2_System_Guid_System_Int32_);
DO_TYPEDEF(0x038A2AE8, ConcurrentDictionary_2_System_Guid_System_Tuple_2_);
DO_TYPEDEF(0x0389E988, Action_1_Guid_);
DO_TYPEDEF(0x038C0A30, List_1_System_WeakReference_);
DO_TYPEDEF(0x03894EE8, EventProvider);
DO_TYPEDEF(0x03894170, EventSource_OverideEventProvider);
DO_TYPEDEF(0x038C2920, List_1_System_Diagnostics_Tracing_EventProvider_SessionInfo_);
DO_TYPEDEF(0x038940D8, EventProvider_SessionInfo);
DO_TYPEDEF(0x03894438, EtwSession);
DO_TYPEDEF(0x038B8960, List_1_System_WeakReference_1_);
DO_TYPEDEF(0x03867D28, WeakReference_1_System_Diagnostics_Tracing_EtwSession_);
DO_TYPEDEF(0x0386B550, EtwSession__Array);
DO_TYPEDEF(0x038BA6A0, List_1_System_Diagnostics_Tracing_EtwSession_);
DO_TYPEDEF(0x03876458, ActivityTracker);
DO_TYPEDEF(0x038A1448, AsyncLocal_1_System_Diagnostics_Tracing_ActivityTracker_ActivityInfo_);
DO_TYPEDEF(0x0389E4C8, Action_1_System_Threading_AsyncLocalValueChangedArgs_1__1);
DO_TYPEDEF(0x0388B480, ActivityTracker_ActivityInfo);
DO_TYPEDEF(0x038B29F8, NonRandomizedStringEqualityComparer);
DO_TYPEDEF(0x038B5668, ObjectEqualityComparer);
DO_TYPEDEF(0x0387D218, ByteEqualityComparer);
DO_TYPEDEF(0x038A8708, InternalStringComparer);
DO_TYPEDEF(0x038A97D8, KeyNotFoundException);
DO_TYPEDEF(0x03885328, DataCollector);
DO_TYPEDEF(0x03894E50, EventPayload);
DO_TYPEDEF(0x03893FA8, EventPayload_GetEnumerator_d_17);
DO_TYPEDEF(0x03896728, FieldMetadata);
DO_TYPEDEF(0x038BBE70, PropertyAnalysis);
DO_TYPEDEF(0x0387C810, BooleanTypeInfo);
DO_TYPEDEF(0x0386EA00, TraceLoggingMetadataCollector);
DO_TYPEDEF(0x038AE888, TraceLoggingMetadataCollector_Impl);
DO_TYPEDEF(0x038BAA00, List_1_System_Diagnostics_Tracing_FieldMetadata_);
DO_TYPEDEF(0x0386E8F0, TraceLoggingDataCollector);
DO_TYPEDEF(0x0387D348, ByteTypeInfo);
DO_TYPEDEF(0x038C32E0, SByteTypeInfo);
DO_TYPEDEF(0x038A7258, Int16TypeInfo);
DO_TYPEDEF(0x038710B8, UInt16TypeInfo);
DO_TYPEDEF(0x038A7498, Int32TypeInfo);
DO_TYPEDEF(0x03871268, UInt32TypeInfo);
DO_TYPEDEF(0x038A7640, Int64TypeInfo);
DO_TYPEDEF(0x03871418, UInt64TypeInfo);
DO_TYPEDEF(0x038A7908, IntPtrTypeInfo);
DO_TYPEDEF(0x038715C8, UIntPtrTypeInfo);
DO_TYPEDEF(0x0388B3B8, DoubleTypeInfo);
DO_TYPEDEF(0x038C7F58, SingleTypeInfo);
DO_TYPEDEF(0x0387FAF0, CharTypeInfo);
DO_TYPEDEF(0x0387C648, BooleanArrayTypeInfo);
DO_TYPEDEF(0x0387D180, ByteArrayTypeInfo);
DO_TYPEDEF(0x038C3250, SByteArrayTypeInfo);
DO_TYPEDEF(0x038A71C8, Int16ArrayTypeInfo);
DO_TYPEDEF(0x03871028, UInt16ArrayTypeInfo);
DO_TYPEDEF(0x038A7378, Int32ArrayTypeInfo);
DO_TYPEDEF(0x038711D8, UInt32ArrayTypeInfo);
DO_TYPEDEF(0x038A75B0, Int64ArrayTypeInfo);
DO_TYPEDEF(0x03871388, UInt64ArrayTypeInfo);
DO_TYPEDEF(0x038A7878, IntPtrArrayTypeInfo);
DO_TYPEDEF(0x03871538, UIntPtrArrayTypeInfo);
DO_TYPEDEF(0x0387F9C0, CharArrayTypeInfo);
DO_TYPEDEF(0x0388B1F0, DoubleArrayTypeInfo);
DO_TYPEDEF(0x038C7E38, SingleArrayTypeInfo);
DO_TYPEDEF(0x03869190, StringTypeInfo);
DO_TYPEDEF(0x0389A618, GuidTypeInfo);
DO_TYPEDEF(0x0389A580, GuidArrayTypeInfo);
DO_TYPEDEF(0x0386C2C0, Guid__Array);
DO_TYPEDEF(0x03887F80, DateTimeTypeInfo);
DO_TYPEDEF(0x03887E50, DateTimeOffsetTypeInfo);
DO_TYPEDEF(0x0386D4F0, TimeSpanTypeInfo);
DO_TYPEDEF(0x038886A0, DecimalTypeInfo);
DO_TYPEDEF(0x038B3BC8, IEnumerable_1_System_Reflection_PropertyInfo_);
DO_TYPEDEF(0x038B9920, List_1_System_Byte_);
DO_TYPEDEF(0x038ACE18, ManifestBuilder);
DO_TYPEDEF(0x038A98C8, Dictionary_2_System_UInt64_System_String_);
DO_TYPEDEF(0x038A7CC0, Dictionary_2_System_String_System_Type_);
DO_TYPEDEF(0x038A6BF8, Dictionary_2_System_String_List_1_System_Int32_);
DO_TYPEDEF(0x038BC110, List_1_System_Int32_);
DO_TYPEDEF(0x03868F20, List_1_System_Int32___Array);
DO_TYPEDEF(0x03894600, EventAttribute);
DO_TYPEDEF(0x0386FC80, TypeAnalysis);
DO_TYPEDEF(0x0386E6D0, TplEtwProvider);
DO_TYPEDEF(0x038B88D0, List_1_System_Tuple_2_);
DO_TYPEDEF(0x038A0738, Action_2_Int32_Int64_);
DO_TYPEDEF(0x03894040, EventProvider_c_DisplayClass44_0);
DO_TYPEDEF(0x03895018, EventSourceAttribute);
DO_TYPEDEF(0x038B31A8, IEnumerable_1_System_Tuple_2_);
DO_TYPEDEF(0x0388B3E8, ActivityFilter_GetFilterAsTuple_d_7);
DO_TYPEDEF(0x038B4438, IEnumerator_1_System_Tuple_2__1);
DO_TYPEDEF(0x0388B2B8, ActivityFilter_c_DisplayClass11_0);
DO_TYPEDEF(0x0388B350, ActivityFilter_c_DisplayClass13_0);
DO_TYPEDEF(0x03893DE0, EtwSession_c_DisplayClass1_0);
DO_TYPEDEF(0x03893D48, EtwSession_c);
DO_TYPEDEF(0x038C5230, Predicate_1_WeakReference_1_System_Diagnostics_Tracing_EtwSession_);
DO_TYPEDEF(0x038BA220, List_1_System_Globalization_CultureInfo_);
DO_TYPEDEF(0x0389CBB0, ManifestBuilder_c_DisplayClass22_0);
DO_TYPEDEF(0x0389CC48, ManifestBuilder_c_DisplayClass22_1);
DO_TYPEDEF(0x03895148, EventSourceException);
DO_TYPEDEF(0x0387E8B8, _Il2CppComObject);
DO_TYPEDEF(0x0387BEC0, XmlReader);
DO_TYPEDEF(0x0387BF58, XmlReaderSettings);
DO_TYPEDEF(0x038B1888, NameTable);
DO_TYPEDEF(0x0389E660, NameTable_Entry);
DO_TYPEDEF(0x03873D88, NameTable_Entry__Array);
DO_TYPEDEF(0x0387E230, XmlUrlResolver);
DO_TYPEDEF(0x0389E468, ICredentials);
DO_TYPEDEF(0x038A4588, IWebProxy);
DO_TYPEDEF(0x03872E88, Uri_1);
DO_TYPEDEF(0x038731E8, UriParser);
DO_TYPEDEF(0x038A7D50, Dictionary_2_System_String_System_UriParser_);
DO_TYPEDEF(0x03873038, UriFormatException);
DO_TYPEDEF(0x03872FA8, UriComponents__Enum);
DO_TYPEDEF(0x038B02E8, Uri_UriInfo);
DO_TYPEDEF(0x038B0258, Uri_MoreInfo);
DO_TYPEDEF(0x0387CB38, XmlSchemaSet);
DO_TYPEDEF(0x038739C8, ValidationEventHandler);
DO_TYPEDEF(0x0387C710, XmlSchemaException);
DO_TYPEDEF(0x0387C840, XmlSchemaObjectCollection);
DO_TYPEDEF(0x038C4F00, SchemaInfo);
DO_TYPEDEF(0x038A9C20, Dictionary_2_System_Xml_XmlQualifiedName_System_Xml_Schema_SchemaElementDecl_);
DO_TYPEDEF(0x0387BE28, XmlQualifiedName);
DO_TYPEDEF(0x038B2518, XmlQualifiedName_HashCodeOfStringDelegate);
DO_TYPEDEF(0x038C4DE0, SchemaElementDecl);
DO_TYPEDEF(0x03885588, DatatypeImplementation);
DO_TYPEDEF(0x03885D38, Datatype_anySimpleType);
DO_TYPEDEF(0x03885880, Datatype_List);
DO_TYPEDEF(0x0387D960, XmlTypeCode__Enum);
DO_TYPEDEF(0x0387A240, XmlBaseConverter);
DO_TYPEDEF(0x038A4CD8, IXmlNamespaceResolver);
DO_TYPEDEF(0x0387BBC8, XmlNumeric10Converter);
DO_TYPEDEF(0x0387CBC8, XmlSchemaSimpleType);
DO_TYPEDEF(0x038716B8, XmlSchemaSimpleType__Array);
DO_TYPEDEF(0x0386ABD0, DatatypeImplementation__Array);
DO_TYPEDEF(0x03891038, DatatypeImplementation_SchemaDatatypeMap);
DO_TYPEDEF(0x03871FB8, DatatypeImplementation_SchemaDatatypeMap__Array);
DO_TYPEDEF(0x038A9B90, Dictionary_2_System_Xml_XmlQualifiedName_System_Xml_Schema_SchemaAttDef_);
DO_TYPEDEF(0x038C4D50, SchemaAttDef);
DO_TYPEDEF(0x03871598, XmlQualifiedName__Array);
DO_TYPEDEF(0x038BB390, List_1_System_Xml_IDtdDefaultAttributeInfo_);
DO_TYPEDEF(0x0389F0E0, IDtdDefaultAttributeInfo);
DO_TYPEDEF(0x038B4828, IEnumerator_1_System_Xml_IDtdDefaultAttributeInfo_);
DO_TYPEDEF(0x038A9D40, Dictionary_2_System_Xml_XmlQualifiedName_System_Xml_XmlQualifiedName_);
DO_TYPEDEF(0x03882AE8, ContentValidator);
DO_TYPEDEF(0x0387C5E0, XmlSchemaContentProcessing__Enum);
DO_TYPEDEF(0x0387C380, XmlSchemaAnyAttribute);
DO_TYPEDEF(0x038B1A38, NamespaceList);
DO_TYPEDEF(0x0389EFB0, IDtdAttributeInfo);
DO_TYPEDEF(0x038B3598, IEnumerable_1_System_Xml_IDtdDefaultAttributeInfo_);
DO_TYPEDEF(0x038A9CB0, Dictionary_2_System_Xml_XmlQualifiedName_System_Xml_Schema_SchemaEntity_);
DO_TYPEDEF(0x038C4E70, SchemaEntity);
DO_TYPEDEF(0x038A6F58, Dictionary_2_System_String_System_Boolean_);
DO_TYPEDEF(0x038A7B18, Dictionary_2_System_String_System_Xml_Schema_SchemaNotation_);
DO_TYPEDEF(0x038C4F90, SchemaNotation);
DO_TYPEDEF(0x0389F048, IDtdAttributeListInfo);
DO_TYPEDEF(0x0389F178, IDtdEntityInfo);
DO_TYPEDEF(0x0387C4B0, XmlSchemaCompilationSettings);
DO_TYPEDEF(0x0387D708, XmlTextReader);
DO_TYPEDEF(0x0387A4A0, XmlCharType);
DO_TYPEDEF(0x0387BA98, XmlNodeType__Enum);
DO_TYPEDEF(0x0387D7A0, XmlTextReaderImpl);
DO_TYPEDEF(0x0387BCF8, XmlParserContext);
DO_TYPEDEF(0x0387B838, XmlNamespaceManager);
DO_TYPEDEF(0x03874DD8, XmlNamespaceManager_NamespaceDeclaration__Array);
DO_TYPEDEF(0x038B2CF8, XmlTextReaderImpl_NodeData);
DO_TYPEDEF(0x03874E70, XmlTextReaderImpl_NodeData__Array);
DO_TYPEDEF(0x038B2D88, XmlTextReaderImpl_XmlContext);
DO_TYPEDEF(0x03874F08, XmlTextReaderImpl_ParsingState__Array);
DO_TYPEDEF(0x0389F210, IDtdInfo);
DO_TYPEDEF(0x038A44F8, IValidationEventHandling);
DO_TYPEDEF(0x038A4B88, Dictionary_2_System_Xml_IDtdEntityInfo_System_Xml_IDtdEntityInfo_);
DO_TYPEDEF(0x03866B28, Tuple_4_Int32_Int32_Int32_Boolean_);
DO_TYPEDEF(0x038A4D68, IXmlSchemaInfo);
DO_TYPEDEF(0x03875CA8, ASN1_1);
DO_TYPEDEF(0x038A1DC8, PKCS7_ContentInfo_1);
DO_TYPEDEF(0x038A1E58, PKCS7_EncryptedData_1);
DO_TYPEDEF(0x038C4330, SafeBag_1);
DO_TYPEDEF(0x038B71F8, PKCS12_1);
DO_TYPEDEF(0x038779E8, X509CertificateCollection_1);
DO_TYPEDEF(0x038A2098, PKCS8_PrivateKeyInfo_1);
DO_TYPEDEF(0x038775C0, X509Certificate_2);
DO_TYPEDEF(0x03878530, X509ExtensionCollection_1);
DO_TYPEDEF(0x038A1CA8, PKCS12_DeriveBytes_1);
DO_TYPEDEF(0x038B1A68, X509CertificateCollection_X509CertificateEnumerator_1);
DO_TYPEDEF(0x03878368, X509Extension_1);
DO_TYPEDEF(0x0387F598, ChallengeResponse);
DO_TYPEDEF(0x038AEC48, MessageBase);
DO_TYPEDEF(0x0386FB60, Type2Message);
DO_TYPEDEF(0x0386FAD0, Type1Message);
DO_TYPEDEF(0x0386FBF0, Type3Message);
DO_TYPEDEF(0x03876AE0, AlertLevel__Enum);
DO_TYPEDEF(0x03876A48, AlertDescription__Enum);
DO_TYPEDEF(0x038769B0, Alert);
DO_TYPEDEF(0x038B0978, MonoSslPolicyErrors__Enum);
DO_TYPEDEF(0x03873AE8, ValidationResult);
DO_TYPEDEF(0x0389D208, ICertificateValidator2);
DO_TYPEDEF(0x0386DA90, TlsProtocols__Enum);
DO_TYPEDEF(0x038B0BB0, MonoTlsSettings);
DO_TYPEDEF(0x03877D78, X509Chain);
DO_TYPEDEF(0x038B00A8, UnityTls_unitytls_x509list_ref);
DO_TYPEDEF(0x03878070, X509ChainImplUnityTls);
DO_TYPEDEF(0x03877EA8, X509ChainElementCollection);
DO_TYPEDEF(0x03878108, X509ChainPolicy);
DO_TYPEDEF(0x038B5ED8, OidCollection);
DO_TYPEDEF(0x03877B18, X509CertificateCollection_2);
DO_TYPEDEF(0x03877820, X509Certificate2Collection);
DO_TYPEDEF(0x038C0B50, List_1_System_Security_Cryptography_X509Certificates_X509ChainStatus_);
DO_TYPEDEF(0x03878238, X509ChainStatusFlags__Enum);
DO_TYPEDEF(0x038781A0, X509ChainStatus);
DO_TYPEDEF(0x038712C8, X509ChainStatus__Array);
DO_TYPEDEF(0x038800D0, CipherSuiteCode__Enum);
DO_TYPEDEF(0x0389D170, ICertificateValidator);
DO_TYPEDEF(0x038B0A90, MonoTlsProvider);
DO_TYPEDEF(0x03867338, SslProtocols__Enum);
DO_TYPEDEF(0x038A1E28, IMonoSslStream);
DO_TYPEDEF(0x038673C8, SslStream);
DO_TYPEDEF(0x038AFFE8, MobileAuthenticatedStream);
DO_TYPEDEF(0x03872738, UnityTlsContext);
DO_TYPEDEF(0x038AFE68, UnityTls_unitytls_tlsctx_read_callback);
DO_TYPEDEF(0x038AFC28, UnityTls_unitytls_error_code__Enum);
DO_TYPEDEF(0x038AFEF8, UnityTls_unitytls_tlsctx_write_callback);
DO_TYPEDEF(0x038AFD48, UnityTls_unitytls_tlsctx_certificate_callback);
DO_TYPEDEF(0x038AFF88, UnityTls_unitytls_tlsctx_x509verify_callback);
DO_TYPEDEF(0x038B0138, UnityTls_unitytls_x509verify_result__Enum);
DO_TYPEDEF(0x038B0A08, MonoTlsConnectionInfo);
DO_TYPEDEF(0x03879048, AsyncHandshakeRequest);
DO_TYPEDEF(0x0387CC30, BufferOffsetSize);
DO_TYPEDEF(0x0387CD60, BufferOffsetSize2);
DO_TYPEDEF(0x038727C8, UnityTlsStream);
DO_TYPEDEF(0x0386DA00, TlsException);
DO_TYPEDEF(0x038AC638, MD2Managed_1);
DO_TYPEDEF(0x038AC758, MD4Managed_1);
DO_TYPEDEF(0x038A2008, PKCS8_EncryptedPrivateKeyInfo_1);
DO_TYPEDEF(0x038BDD60, RSAManaged_1);
DO_TYPEDEF(0x0387AE88, BigInteger_1);
DO_TYPEDEF(0x0388C760, BigInteger_ModulusRing_1);
DO_TYPEDEF(0x03869E50, BigInteger_1__Array);
DO_TYPEDEF(0x038BB960, PrimalityTest_1);
DO_TYPEDEF(0x03881DD8, ConfidenceFactor__Enum_1);
DO_TYPEDEF(0x038C6338, SequentialSearchPrimeGeneratorBase_1);
DO_TYPEDEF(0x0387DF18, CSharpCodeProvider);
DO_TYPEDEF(0x03878958, XPathItem);
DO_TYPEDEF(0x038789F0, XPathNavigator);
DO_TYPEDEF(0x038788C0, XPathDocumentNavigator);
DO_TYPEDEF(0x03878A88, XPathNavigatorKeyComparer);
DO_TYPEDEF(0x0387D670, XmlTextEncoder);
DO_TYPEDEF(0x038A5278, IncrementalReadDummyDecoder);
DO_TYPEDEF(0x038C5890, SecureStringHasher);
DO_TYPEDEF(0x038A73A8, SecureStringHasher_HashCodeOfStringDelegate);
DO_TYPEDEF(0x038B2C68, XmlTextReaderImpl_NoNamespaceManager);
DO_TYPEDEF(0x038B2BD8, XmlTextReaderImpl_DtdParserProxy);
DO_TYPEDEF(0x038B2B48, XmlTextReaderImpl_DtdDefaultAttributeInfoToNodeDataComparer);
DO_TYPEDEF(0x0387D830, XmlTextWriter);
DO_TYPEDEF(0x038750D0, XmlTextWriter_TagInfo__Array);
DO_TYPEDEF(0x03875038, XmlTextWriter_State__Enum__Array);
DO_TYPEDEF(0x03874FA0, XmlTextWriter_Namespace__Array);
DO_TYPEDEF(0x0388B028, DomNameTable);
DO_TYPEDEF(0x0387B5D8, XmlName);
DO_TYPEDEF(0x0387B8D0, XmlNode);
DO_TYPEDEF(0x0387AA90, XmlDocument);
DO_TYPEDEF(0x03879EB0, XmlAttribute);
DO_TYPEDEF(0x0387B2E0, XmlLinkedNode);
DO_TYPEDEF(0x0387A370, XmlCDataSection);
DO_TYPEDEF(0x0387A5D0, XmlChildNodes);
DO_TYPEDEF(0x0387B708, XmlNamedNodeMap);
DO_TYPEDEF(0x03879FE0, XmlAttributeCollection);
DO_TYPEDEF(0x0387B968, XmlNodeChangedEventArgs);
DO_TYPEDEF(0x0387ACF0, XmlElement);
DO_TYPEDEF(0x0387B248, XmlImplementation);
DO_TYPEDEF(0x038930A0, EmptyEnumerator);
DO_TYPEDEF(0x0387ABC0, XmlDocumentType);
DO_TYPEDEF(0x0387A9F8, XmlDeclaration);
DO_TYPEDEF(0x0387A700, XmlComment);
DO_TYPEDEF(0x0387AB28, XmlDocumentFragment);
DO_TYPEDEF(0x0387AFE8, XmlEntityReference);
DO_TYPEDEF(0x0387BD90, XmlProcessingInstruction);
DO_TYPEDEF(0x0387D540, XmlText);
DO_TYPEDEF(0x0387D378, XmlSignificantWhitespace);
DO_TYPEDEF(0x0387E2C8, XmlWhitespace);
DO_TYPEDEF(0x0387C8D8, XmlSchemaParticle);
DO_TYPEDEF(0x0387C678, XmlSchemaElement);
DO_TYPEDEF(0x0387C418, XmlSchemaAttribute);
DO_TYPEDEF(0x03871478, XmlName__Array);
DO_TYPEDEF(0x0387A538, XmlChildEnumerator);
DO_TYPEDEF(0x0387AF50, XmlEntity);
DO_TYPEDEF(0x0387B410, XmlLoader);
DO_TYPEDEF(0x0387B670, XmlNameEx);
DO_TYPEDEF(0x038B7108, XmlNamedNodeMap_SmallXmlNodeList_SingleObjectEnumerator);
DO_TYPEDEF(0x0387BB30, XmlNotation);
DO_TYPEDEF(0x0387E108, XmlUnspecifiedAttribute);
DO_TYPEDEF(0x0388B740, DtdParser);
DO_TYPEDEF(0x0389F340, IDtdParserAdapter);
DO_TYPEDEF(0x0389F470, IDtdParserAdapterWithValidation);
DO_TYPEDEF(0x038A8258, Dictionary_2_System_String_System_Xml_DtdParser_UndeclaredNotation_);
DO_TYPEDEF(0x03892458, DtdParser_UndeclaredNotation);
DO_TYPEDEF(0x0389F2A8, IDtdParser);
DO_TYPEDEF(0x038B7DC8, ParticleContentValidator);
DO_TYPEDEF(0x03869A00, SymbolsDictionary);
DO_TYPEDEF(0x038BB450, Positions);
DO_TYPEDEF(0x03869CD0, SyntaxTreeNode);
DO_TYPEDEF(0x038AA038, LeafNode);
DO_TYPEDEF(0x038A8048, InteriorNode);
DO_TYPEDEF(0x038C62A8, SequenceNode);
DO_TYPEDEF(0x0387C058, BitSet);
DO_TYPEDEF(0x0386A000, BitSet__Array);
DO_TYPEDEF(0x038923C0, DtdParser_ParseElementOnlyContent_LocalFrame);
DO_TYPEDEF(0x0387A960, XmlDateTimeSerializationMode__Enum);
DO_TYPEDEF(0x0387AC58, XmlDownloadManager);
DO_TYPEDEF(0x038B2488, XmlDownloadManager_c_DisplayClass4_0);
DO_TYPEDEF(0x038A1BB8, AsyncTaskMethodBuilder_1_System_IO_Stream_);
DO_TYPEDEF(0x03876520, WebRequest);
DO_TYPEDEF(0x038C1750, RequestCacheProtocol);
DO_TYPEDEF(0x038C16C0, RequestCache);
DO_TYPEDEF(0x038B1708, WebRequest_DesignerWebRequestCreate);
DO_TYPEDEF(0x038B17F8, NameObjectCollectionBase);
DO_TYPEDEF(0x038B1918, NameValueCollection);
DO_TYPEDEF(0x03876358, WebHeaderCollection);
DO_TYPEDEF(0x0389E530, NameObjectCollectionBase_NameObjectEntry);
DO_TYPEDEF(0x0389BC10, HeaderInfoTable);
DO_TYPEDEF(0x0389BB78, HeaderInfo);
DO_TYPEDEF(0x0389BCA8, HeaderParser);
DO_TYPEDEF(0x03874D40, WebHeaderCollection_RfcChar__Enum__Array);
DO_TYPEDEF(0x03876780, WebResponse);
DO_TYPEDEF(0x038667C8, Task_1_System_Net_WebResponse_);
DO_TYPEDEF(0x038B67D8, OpenedHost);
DO_TYPEDEF(0x0387C120, XmlRegisteredNonCachedStream);
DO_TYPEDEF(0x0387A408, XmlCachedStream);
DO_TYPEDEF(0x03871658, UTF16Decoder);
DO_TYPEDEF(0x038C42A0, SafeAsciiDecoder);
DO_TYPEDEF(0x03871B68, Ucs4Encoding);
DO_TYPEDEF(0x03871AD8, Ucs4Decoder4321);
DO_TYPEDEF(0x03871BF8, Ucs4Encoding1234);
DO_TYPEDEF(0x03871DA8, Ucs4Encoding4321);
DO_TYPEDEF(0x03871C88, Ucs4Encoding2143);
DO_TYPEDEF(0x03871D18, Ucs4Encoding3412);
DO_TYPEDEF(0x03871928, Ucs4Decoder1234);
DO_TYPEDEF(0x038719B8, Ucs4Decoder2143);
DO_TYPEDEF(0x03871A48, Ucs4Decoder3412);
DO_TYPEDEF(0x0387B118, XmlException);
DO_TYPEDEF(0x038A4C48, IXmlLineInfo);
DO_TYPEDEF(0x038A1A98, AsyncTaskMethodBuilder_1_System_Object_);
DO_TYPEDEF(0x0387D2E0, XmlSerializerNamespaces);
DO_TYPEDEF(0x0387A078, XmlAttributeEventArgs);
DO_TYPEDEF(0x0387AEB8, XmlElementEventArgs);
DO_TYPEDEF(0x0387BA00, XmlNodeEventArgs);
DO_TYPEDEF(0x03872C48, UnreferencedObjectEventArgs);
DO_TYPEDEF(0x038BF7D0, ReflectionHelper);
DO_TYPEDEF(0x0387E070, XmlTypeMapping);
DO_TYPEDEF(0x0386FEB8, TypeData);
DO_TYPEDEF(0x0387C970, XmlSchemaPatternFacet);
DO_TYPEDEF(0x03870728, TypeMember);
DO_TYPEDEF(0x03879A88, XmlAnyElementAttribute);
DO_TYPEDEF(0x03879B20, XmlAnyElementAttributes);
DO_TYPEDEF(0x03879C50, XmlArrayAttribute);
DO_TYPEDEF(0x03879CE8, XmlArrayItemAttribute);
DO_TYPEDEF(0x03879D80, XmlArrayItemAttributes);
DO_TYPEDEF(0x03879F48, XmlAttributeAttribute);
DO_TYPEDEF(0x0387A110, XmlAttributeOverrides);
DO_TYPEDEF(0x0387A1A8, XmlAttributes);
DO_TYPEDEF(0x03879958, XmlAnyAttributeAttribute);
DO_TYPEDEF(0x0387A668, XmlChoiceIdentifierAttribute);
DO_TYPEDEF(0x0387AE20, XmlElementAttributes);
DO_TYPEDEF(0x0387B080, XmlEnumAttribute);
DO_TYPEDEF(0x0387C1B8, XmlRootAttribute);
DO_TYPEDEF(0x0387D5D8, XmlTextAttribute);
DO_TYPEDEF(0x0387D8C8, XmlTypeAttribute);
DO_TYPEDEF(0x0387AD88, XmlElementAttribute);
DO_TYPEDEF(0x0387B1B0, XmlIgnoreAttribute);
DO_TYPEDEF(0x0387B4A8, XmlMembersMapping);
DO_TYPEDEF(0x0387BFF0, XmlReflectionImporter);
DO_TYPEDEF(0x038C1210, List_1_System_Xml_Serialization_XmlReflectionMember_);
DO_TYPEDEF(0x0387C088, XmlReflectionMember);
DO_TYPEDEF(0x0387DB20, XmlTypeMapMember);
DO_TYPEDEF(0x0387DA88, XmlTypeMapElementInfoList);
DO_TYPEDEF(0x0387DD80, XmlTypeMapMemberElement);
DO_TYPEDEF(0x038B25A8, XmlReflectionImporter_c);
DO_TYPEDEF(0x038A28A8, Comparison_1_System_Xml_Serialization_XmlReflectionMember_);
DO_TYPEDEF(0x0387CA08, XmlSchemaProviderAttribute);
DO_TYPEDEF(0x0387CE28, XmlSerializationCollectionFixupCallback);
DO_TYPEDEF(0x0387CEB8, XmlSerializationFixupCallback);
DO_TYPEDEF(0x0387CF50, XmlSerializationReadCallback);
DO_TYPEDEF(0x0387D248, XmlSerializer);
DO_TYPEDEF(0x0387D118, XmlSerializationWriter);
DO_TYPEDEF(0x0387D1B0, XmlSerializationWriterInterpreter);
DO_TYPEDEF(0x0387CFE8, XmlSerializationReaderInterpreter);
DO_TYPEDEF(0x038B26C8, XmlSerializationReader_CollectionFixup);
DO_TYPEDEF(0x038B27E8, XmlSerializationReader_Fixup);
DO_TYPEDEF(0x038B2758, XmlSerializationReader_CollectionItemFixup);
DO_TYPEDEF(0x038B2878, XmlSerializationReader_WriteCallbackInfo);
DO_TYPEDEF(0x038A4DF8, IXmlSerializable);
DO_TYPEDEF(0x03880330, ClassMap);
DO_TYPEDEF(0x0387DCE8, XmlTypeMapMemberAttribute);
DO_TYPEDEF(0x038717D8, XmlTypeMapMemberAttribute__Array);
DO_TYPEDEF(0x0387DE18, XmlTypeMapMemberExpandable);
DO_TYPEDEF(0x0387DC50, XmlTypeMapMemberAnyElement);
DO_TYPEDEF(0x0387DBB8, XmlTypeMapMemberAnyAttribute);
DO_TYPEDEF(0x0387DFD8, XmlTypeMapMemberNamespaces);
DO_TYPEDEF(0x0387D9F8, XmlTypeMapElementInfo);
DO_TYPEDEF(0x038B2908, XmlSerializationReaderInterpreter_FixupCallbackInfo);
DO_TYPEDEF(0x038B2998, XmlSerializationReaderInterpreter_ReaderCallbackInfo);
DO_TYPEDEF(0x0387D080, XmlSerializationWriteCallback);
DO_TYPEDEF(0x038B2A28, XmlSerializationWriter_WriteCallbackInfo);
DO_TYPEDEF(0x038AB458, ListMap);
DO_TYPEDEF(0x038B2AB8, XmlSerializationWriterInterpreter_CallbackInfo);
DO_TYPEDEF(0x0387DF48, XmlTypeMapMemberList);
DO_TYPEDEF(0x0387DEB0, XmlTypeMapMemberFlatList);
DO_TYPEDEF(0x0387CD90, XmlSerializableMapping);
DO_TYPEDEF(0x0387C250, XmlSchema);
DO_TYPEDEF(0x0387C548, XmlSchemaComplexType);
DO_TYPEDEF(0x03893EE0, EnumMap);
DO_TYPEDEF(0x03893C18, EnumMap_EnumMapMember);
DO_TYPEDEF(0x038721F8, EnumMap_EnumMapMember__Array);
DO_TYPEDEF(0x03872CD8, UpaException);
DO_TYPEDEF(0x038BB330, Position);
DO_TYPEDEF(0x038B1AC8, NamespaceListNode);
DO_TYPEDEF(0x0387FFA8, ChoiceNode);
DO_TYPEDEF(0x038BAD00, PlusNode);
DO_TYPEDEF(0x038BD100, QmarkNode);
DO_TYPEDEF(0x03867968, StarNode);
DO_TYPEDEF(0x038AA0C8, LeafRangeNode);
DO_TYPEDEF(0x038695E0, Int32__Array__Array);
DO_TYPEDEF(0x0388A150, DfaContentValidator);
DO_TYPEDEF(0x038B28D8, NfaContentValidator);
DO_TYPEDEF(0x038BE810, RangeContentValidator);
DO_TYPEDEF(0x0387E528, XsdSimpleValue);
DO_TYPEDEF(0x038874E0, Datatype_union);
DO_TYPEDEF(0x03885CA0, Datatype_anyAtomicType);
DO_TYPEDEF(0x038877D8, Datatype_untypedAtomicType);
DO_TYPEDEF(0x03887150, Datatype_string);
DO_TYPEDEF(0x03885F00, Datatype_boolean);
DO_TYPEDEF(0x038867E0, Datatype_float);
DO_TYPEDEF(0x03886588, Datatype_double);
DO_TYPEDEF(0x038864F0, Datatype_decimal);
DO_TYPEDEF(0x038866B0, Datatype_duration);
DO_TYPEDEF(0x03887A30, Datatype_yearMonthDuration);
DO_TYPEDEF(0x03886458, Datatype_dayTimeDuration);
DO_TYPEDEF(0x0387E490, XsdDateTimeFlags__Enum);
DO_TYPEDEF(0x038861F8, Datatype_dateTimeBase);
DO_TYPEDEF(0x03886290, Datatype_dateTimeNoTimeZone);
DO_TYPEDEF(0x03886328, Datatype_dateTimeTimeZone);
DO_TYPEDEF(0x03886160, Datatype_dateTime);
DO_TYPEDEF(0x03887280, Datatype_timeNoTimeZone);
DO_TYPEDEF(0x03887318, Datatype_timeTimeZone);
DO_TYPEDEF(0x038871E8, Datatype_time);
DO_TYPEDEF(0x038860C8, Datatype_date);
DO_TYPEDEF(0x03887998, Datatype_yearMonth);
DO_TYPEDEF(0x03887908, Datatype_year);
DO_TYPEDEF(0x03886C98, Datatype_monthDay);
DO_TYPEDEF(0x038863C0, Datatype_day);
DO_TYPEDEF(0x03886C00, Datatype_month);
DO_TYPEDEF(0x03886908, Datatype_hexBinary);
DO_TYPEDEF(0x03885E68, Datatype_base64Binary);
DO_TYPEDEF(0x03885DD0, Datatype_anyURI);
DO_TYPEDEF(0x03885B78, Datatype_QName);
DO_TYPEDEF(0x03886EF0, Datatype_normalizedString);
DO_TYPEDEF(0x03886F88, Datatype_normalizedStringV1Compat);
DO_TYPEDEF(0x038873B0, Datatype_token);
DO_TYPEDEF(0x03887448, Datatype_tokenV1Compat);
DO_TYPEDEF(0x03886AD0, Datatype_language);
DO_TYPEDEF(0x038859B0, Datatype_NMTOKEN);
DO_TYPEDEF(0x03885AE0, Datatype_Name);
DO_TYPEDEF(0x03885918, Datatype_NCName);
DO_TYPEDEF(0x03885750, Datatype_ID);
DO_TYPEDEF(0x038857E8, Datatype_IDREF);
DO_TYPEDEF(0x03885620, Datatype_ENTITY);
DO_TYPEDEF(0x03885A48, Datatype_NOTATION);
DO_TYPEDEF(0x03886A38, Datatype_integer);
DO_TYPEDEF(0x03886E60, Datatype_nonPositiveInteger);
DO_TYPEDEF(0x03886D30, Datatype_negativeInteger);
DO_TYPEDEF(0x03886B68, Datatype_long);
DO_TYPEDEF(0x038869A0, Datatype_int);
DO_TYPEDEF(0x038870B8, Datatype_short);
DO_TYPEDEF(0x03885F98, Datatype_byte);
DO_TYPEDEF(0x03886DC8, Datatype_nonNegativeInteger);
DO_TYPEDEF(0x038876A8, Datatype_unsignedLong);
DO_TYPEDEF(0x03887610, Datatype_unsignedInt);
DO_TYPEDEF(0x03887740, Datatype_unsignedShort);
DO_TYPEDEF(0x03887578, Datatype_unsignedByte);
DO_TYPEDEF(0x03887020, Datatype_positiveInteger);
DO_TYPEDEF(0x03886618, Datatype_doubleXdr);
DO_TYPEDEF(0x03886870, Datatype_floatXdr);
DO_TYPEDEF(0x03885C08, Datatype_QNameXdr);
DO_TYPEDEF(0x038856B8, Datatype_ENUMERATION);
DO_TYPEDEF(0x03886030, Datatype_char);
DO_TYPEDEF(0x03886748, Datatype_fixed);
DO_TYPEDEF(0x03887870, Datatype_uuid);
DO_TYPEDEF(0x038924F0, DtdValidator_NamespaceManager);
DO_TYPEDEF(0x038B3268, Numeric10FacetsChecker);
DO_TYPEDEF(0x038B32F8, Numeric2FacetsChecker);
DO_TYPEDEF(0x0388B998, DurationFacetsChecker);
DO_TYPEDEF(0x03887B60, DateTimeFacetsChecker);
DO_TYPEDEF(0x038C03A0, RegexOptions__Enum);
DO_TYPEDEF(0x038BFE90, Regex);
DO_TYPEDEF(0x038956A0, ExclusiveReference);
DO_TYPEDEF(0x038C05E0, RegexRunner);
DO_TYPEDEF(0x0389A320, Group);
DO_TYPEDEF(0x038AD4C8, Match);
DO_TYPEDEF(0x0389A3B8, GroupCollection);
DO_TYPEDEF(0x0386C230, Group__Array);
DO_TYPEDEF(0x038C01F0, RegexInterpreter);
DO_TYPEDEF(0x038C0040, RegexCode);
DO_TYPEDEF(0x038C04C0, RegexPrefix);
DO_TYPEDEF(0x038BFF20, RegexBoyerMoore);
DO_TYPEDEF(0x038C7A48, SharedReference);
DO_TYPEDEF(0x038B72E8, LinkedList_1_System_Text_RegularExpressions_CachedCodeEntry_);
DO_TYPEDEF(0x0387E298, CachedCodeEntry);
DO_TYPEDEF(0x03868E30, StringFacetsChecker);
DO_TYPEDEF(0x038BD070, QNameFacetsChecker);
DO_TYPEDEF(0x038AF300, MiscFacetsChecker);
DO_TYPEDEF(0x0387B640, BinaryFacetsChecker);
DO_TYPEDEF(0x038AB3C8, ListFacetsChecker);
DO_TYPEDEF(0x03872348, UnionFacetsChecker);
DO_TYPEDEF(0x03879E18, XmlAtomicValue);
DO_TYPEDEF(0x038B23F8, XmlAtomicValue_NamespacePrefixForQName);
DO_TYPEDEF(0x0387C2E8, XmlSchemaAny);
DO_TYPEDEF(0x0387C7A8, XmlSchemaInfo);
DO_TYPEDEF(0x038B2638, XmlSchemaParticle_EmptyParticle);
DO_TYPEDEF(0x0387CAA0, XmlSchemaSequence);
DO_TYPEDEF(0x03871628, XmlSchema__Array);
DO_TYPEDEF(0x0387CC60, XmlSchemaSimpleTypeList);
DO_TYPEDEF(0x0387CCF8, XmlSchemaSimpleTypeRestriction);
DO_TYPEDEF(0x0387BC60, XmlNumeric2Converter);
DO_TYPEDEF(0x0387A8C8, XmlDateTimeConverter);
DO_TYPEDEF(0x0387A2D8, XmlBooleanConverter);
DO_TYPEDEF(0x0387B540, XmlMiscConverter);
DO_TYPEDEF(0x0387D410, XmlStringConverter);
DO_TYPEDEF(0x0387B378, XmlListConverter);
DO_TYPEDEF(0x0387E1A0, XmlUntypedConverter);
DO_TYPEDEF(0x038799F0, XmlAnyConverter);
DO_TYPEDEF(0x03879BB8, XmlAnyListConverter);
DO_TYPEDEF(0x0389F768, IEnumerable);
DO_TYPEDEF(0x0387E3F8, XsdDateTime);
DO_TYPEDEF(0x03871748, XmlTypeCode__Enum__Array);
DO_TYPEDEF(0x038B2E18, XsdDateTime_Parser);
DO_TYPEDEF(0x038B2EA8, XsdDuration_DurationType__Enum);
DO_TYPEDEF(0x038AFDD8, UnityTls_unitytls_tlsctx_protocolrange);
DO_TYPEDEF(0x038B5D58, UnityTls_unitytls_interface_struct_unitytls_errorstate_create_t);
DO_TYPEDEF(0x038B5DE8, UnityTls_unitytls_interface_struct_unitytls_errorstate_raise_error_t);
DO_TYPEDEF(0x038B5F08, UnityTls_unitytls_interface_struct_unitytls_key_get_ref_t);
DO_TYPEDEF(0x038B5F98, UnityTls_unitytls_interface_struct_unitytls_key_parse_der_t);
DO_TYPEDEF(0x038B6028, UnityTls_unitytls_interface_struct_unitytls_key_parse_pem_t);
DO_TYPEDEF(0x038B5E78, UnityTls_unitytls_interface_struct_unitytls_key_free_t);
DO_TYPEDEF(0x038B6928, UnityTls_unitytls_interface_struct_unitytls_x509_export_der_t);
DO_TYPEDEF(0x038B0018, UnityTls_unitytls_x509_ref);
DO_TYPEDEF(0x038B6BF8, UnityTls_unitytls_interface_struct_unitytls_x509list_get_ref_t);
DO_TYPEDEF(0x038B6C88, UnityTls_unitytls_interface_struct_unitytls_x509list_get_x509_t);
DO_TYPEDEF(0x038B6AD8, UnityTls_unitytls_interface_struct_unitytls_x509list_create_t);
DO_TYPEDEF(0x038B6A48, UnityTls_unitytls_interface_struct_unitytls_x509list_append_t);
DO_TYPEDEF(0x038B69B8, UnityTls_unitytls_interface_struct_unitytls_x509list_append_der_t);
DO_TYPEDEF(0x038B6B68, UnityTls_unitytls_interface_struct_unitytls_x509list_free_t);
DO_TYPEDEF(0x038B6D18, UnityTls_unitytls_interface_struct_unitytls_x509verify_default_ca_t);
DO_TYPEDEF(0x038B6DA8, UnityTls_unitytls_interface_struct_unitytls_x509verify_explicit_ca_t);
DO_TYPEDEF(0x038B61D8, UnityTls_unitytls_interface_struct_unitytls_tlsctx_create_server_t);
DO_TYPEDEF(0x038AFCB8, UnityTls_unitytls_tlsctx_callbacks);
DO_TYPEDEF(0x038B6148, UnityTls_unitytls_interface_struct_unitytls_tlsctx_create_client_t);
DO_TYPEDEF(0x038B65C8, UnityTls_unitytls_interface_struct_unitytls_tlsctx_server_require_client_authentication_t);
DO_TYPEDEF(0x038B6658, UnityTls_unitytls_interface_struct_unitytls_tlsctx_set_certificate_callback_t);
DO_TYPEDEF(0x038B6778, UnityTls_unitytls_interface_struct_unitytls_tlsctx_set_trace_callback_t);
DO_TYPEDEF(0x038B6808, UnityTls_unitytls_interface_struct_unitytls_tlsctx_set_x509verify_callback_t);
DO_TYPEDEF(0x038B66E8, UnityTls_unitytls_interface_struct_unitytls_tlsctx_set_supported_ciphersuites_t);
DO_TYPEDEF(0x038B62F8, UnityTls_unitytls_interface_struct_unitytls_tlsctx_get_ciphersuite_t);
DO_TYPEDEF(0x038B6388, UnityTls_unitytls_interface_struct_unitytls_tlsctx_get_protocol_t);
DO_TYPEDEF(0x038B64A8, UnityTls_unitytls_interface_struct_unitytls_tlsctx_process_handshake_t);
DO_TYPEDEF(0x038B6538, UnityTls_unitytls_interface_struct_unitytls_tlsctx_read_t);
DO_TYPEDEF(0x038B6898, UnityTls_unitytls_interface_struct_unitytls_tlsctx_write_t);
DO_TYPEDEF(0x038B6418, UnityTls_unitytls_interface_struct_unitytls_tlsctx_notify_close_t);
DO_TYPEDEF(0x038B6268, UnityTls_unitytls_interface_struct_unitytls_tlsctx_free_t);
DO_TYPEDEF(0x038B60B8, UnityTls_unitytls_interface_struct_unitytls_random_generate_bytes_t);
DO_TYPEDEF(0x0387D930, CFArray);
DO_TYPEDEF(0x0387DCB8, CFString);
DO_TYPEDEF(0x0387D9C8, CFDictionary);
DO_TYPEDEF(0x0387DD50, CFUrl);
DO_TYPEDEF(0x0387DC20, CFRunLoop);
DO_TYPEDEF(0x0387DAF0, CFProxy);
DO_TYPEDEF(0x0387DB88, CFProxySettings);
DO_TYPEDEF(0x0388CCA8, CFNetwork_CFProxyAutoConfigurationResultCallback);
DO_TYPEDEF(0x0386A2D0, CFProxy__Array);
DO_TYPEDEF(0x0388CDD8, CFNetwork_GetProxyData);
DO_TYPEDEF(0x0388CD40, CFNetwork_CFWebProxy);
DO_TYPEDEF(0x038B2698, NetworkCredential);
DO_TYPEDEF(0x0388CC10, CFNetwork_c_DisplayClass13_0);
DO_TYPEDEF(0x03879178, AsyncProtocolResult);
DO_TYPEDEF(0x038A17C8, AsyncTaskMethodBuilder_1_Mono_Net_Security_AsyncProtocolResult_);
DO_TYPEDEF(0x038A14E0, AsyncTaskMethodBuilder_1_System_Nullable_1_);
DO_TYPEDEF(0x03879210, AsyncReadRequest);
DO_TYPEDEF(0x03879500, AsyncWriteRequest);
DO_TYPEDEF(0x038C6E78, ServerCertValidationCallback);
DO_TYPEDEF(0x038C0CA0, RemoteCertificateValidationCallback);
DO_TYPEDEF(0x038672A8, SslPolicyErrors__Enum);
DO_TYPEDEF(0x0387F500, ChainValidationHelper);
DO_TYPEDEF(0x038AB840, LocalCertSelectionCallback);
DO_TYPEDEF(0x03876228, WebExceptionStatus__Enum);
DO_TYPEDEF(0x038B0C38, MonoTlsStream);
DO_TYPEDEF(0x038B2848, NetworkStream);
DO_TYPEDEF(0x03876620, AddressFamily__Enum);
DO_TYPEDEF(0x038665B8, Socket);
DO_TYPEDEF(0x038C4840, SafeSocketHandle);
DO_TYPEDEF(0x038BFB00, List_1_System_Threading_Thread_);
DO_TYPEDEF(0x038A8648, Dictionary_2_System_Threading_Thread_System_Diagnostics_StackTrace_);
DO_TYPEDEF(0x03866648, SocketAddress);
DO_TYPEDEF(0x038A20F8, IOAsyncCallback);
DO_TYPEDEF(0x03866768, SocketAsyncResult);
DO_TYPEDEF(0x038A2608, IPAddress);
DO_TYPEDEF(0x0386CCE0, IPAddress__Array);
DO_TYPEDEF(0x038B5878, IList_1_System_ArraySegment_1_);
DO_TYPEDEF(0x03897170, HttpWebRequest_NtlmAuthState__Enum);
DO_TYPEDEF(0x0389C4F8, HttpWebRequest);
DO_TYPEDEF(0x03883468, CookieContainer);
DO_TYPEDEF(0x0386C500, HeaderVariantInfo__Array);
DO_TYPEDEF(0x038C7268, ServicePoint);
DO_TYPEDEF(0x038A27B8, IPHostEntry);
DO_TYPEDEF(0x038A2698, IPEndPoint);
DO_TYPEDEF(0x038C7388, ServicePointScheduler);
DO_TYPEDEF(0x038A7788, ServicePointScheduler_AsyncManualResetEvent);
DO_TYPEDEF(0x03866228, TaskCompletionSource_1_System_Boolean_);
DO_TYPEDEF(0x038A7818, ServicePointScheduler_ConnectionGroup);
DO_TYPEDEF(0x038B7498, LinkedList_1_System_Net_WebConnection_);
DO_TYPEDEF(0x03875FC8, WebConnection);
DO_TYPEDEF(0x03876060, WebConnectionTunnel);
DO_TYPEDEF(0x038763F0, WebOperation);
DO_TYPEDEF(0x0387CCC8, BufferOffsetSize_1);
DO_TYPEDEF(0x038662B8, TaskCompletionSource_1_System_Net_WebRequestStream_);
DO_TYPEDEF(0x03876650, WebRequestStream);
DO_TYPEDEF(0x03875F30, WebCompletionSource);
DO_TYPEDEF(0x038663D8, TaskCompletionSource_1_System_Net_WebCompletionSource_Result_);
DO_TYPEDEF(0x038B15E8, WebCompletionSource_Result);
DO_TYPEDEF(0x03866348, TaskCompletionSource_1_System_Net_WebResponseStream_);
DO_TYPEDEF(0x0389C3C8, HttpStatusCode__Enum);
DO_TYPEDEF(0x03876818, WebResponseStream);
DO_TYPEDEF(0x038B03D8, MonoChunkStream);
DO_TYPEDEF(0x03866198, TaskCompletionSource_1_System_ValueTuple_2_);
DO_TYPEDEF(0x03866468, Task_1_System_ValueTuple_2_);
DO_TYPEDEF(0x038B7528, LinkedList_1_System_Net_WebOperation_);
DO_TYPEDEF(0x038A8528, Dictionary_2_System_String_System_Net_ServicePointScheduler_ConnectionGroup_);
DO_TYPEDEF(0x038B7138, LinkedList_1_System_ValueTuple_2_);
DO_TYPEDEF(0x03869430, ValueTuple_2_System_Net_ServicePointScheduler_ConnectionGroup_System_Net_WebOperation___Array);
DO_TYPEDEF(0x038B71C8, LinkedList_1_System_ValueTuple_3_);
DO_TYPEDEF(0x038694C0, ValueTuple_3_System_Net_ServicePointScheduler_ConnectionGroup_System_Net_WebConnection_System_Threading_Tasks_Task___Array);
DO_TYPEDEF(0x0389C590, HttpWebResponse);
DO_TYPEDEF(0x038833D0, CookieCollection);
DO_TYPEDEF(0x0389DC50, MobileAuthenticatedStream_c_DisplayClass66_0);
DO_TYPEDEF(0x0388CE70, CallbackHelpers_c_DisplayClass5_0);
DO_TYPEDEF(0x0388CF08, CallbackHelpers_c_DisplayClass8_0);
DO_TYPEDEF(0x038B2F08, NtlmSession);
DO_TYPEDEF(0x03879DE8, Authorization);
DO_TYPEDEF(0x038B2DE8, NtlmClient);
DO_TYPEDEF(0x038A2D28, ConditionalWeakTable_2_System_Net_HttpWebRequest_Mono_Http_NtlmSession_);
DO_TYPEDEF(0x0389EBB8, NtlmClient_c);
DO_TYPEDEF(0x038A3118, ConditionalWeakTable_2_TKey_TValue_CreateValueCallback_System_Net_HttpWebRequest_Mono_Http_NtlmSession_);
DO_TYPEDEF(0x038C4600, SafeProcessHandle);
DO_TYPEDEF(0x03872F18, UriBuilder);
DO_TYPEDEF(0x038A8B88, InvariantComparer);
DO_TYPEDEF(0x03873158, UriKind__Enum);
DO_TYPEDEF(0x038B0378, UriParser_BuiltInUriParser);
DO_TYPEDEF(0x038A2218, IOSelectorJob);
DO_TYPEDEF(0x03889998, DescriptionAttribute);
DO_TYPEDEF(0x0386FD98, TypeConverter);
DO_TYPEDEF(0x038A4228, ITypeDescriptorContext);
DO_TYPEDEF(0x038BC0B0, PropertyDescriptorCollection);
DO_TYPEDEF(0x038ADD28, MemberDescriptor);
DO_TYPEDEF(0x038BC020, PropertyDescriptor);
DO_TYPEDEF(0x03879760, AttributeCollection);
DO_TYPEDEF(0x03871C58, AttributeCollection_AttributeEntry__Array);
DO_TYPEDEF(0x0388B930, ArrayConverter_ArrayPropertyDescriptor);
DO_TYPEDEF(0x0386EC00, PropertyDescriptor__Array);
DO_TYPEDEF(0x038AEF48, TypeConverter_StandardValuesCollection);
DO_TYPEDEF(0x038AD558, MatchCollection);
DO_TYPEDEF(0x038BFFB0, RegexCharClass);
DO_TYPEDEF(0x038C3C40, List_1_System_Text_RegularExpressions_RegexCharClass_SingleRange_);
DO_TYPEDEF(0x038A6488, RegexCharClass_SingleRange);
DO_TYPEDEF(0x038757E8, String__Array_1);
DO_TYPEDEF(0x03874178, RegexCharClass_LowerCaseMapping__Array);
DO_TYPEDEF(0x038A6518, RegexCharClass_SingleRangeComparer);
DO_TYPEDEF(0x038C0670, RegexTree);
DO_TYPEDEF(0x038C0310, RegexNode);
DO_TYPEDEF(0x038BE7E0, List_1_System_Text_RegularExpressions_RegexNode_);
DO_TYPEDEF(0x038C0160, RegexFCD);
DO_TYPEDEF(0x038C00D0, RegexFC);
DO_TYPEDEF(0x0386F1A0, RegexFC__Array);
DO_TYPEDEF(0x0389A450, GroupEnumerator);
DO_TYPEDEF(0x038AD708, MatchSparse);
DO_TYPEDEF(0x038AD5E8, MatchEnumerator);
DO_TYPEDEF(0x038C0280, RegexMatchTimeoutException);
DO_TYPEDEF(0x038C0550, RegexReplacement);
DO_TYPEDEF(0x038C0430, RegexParser);
DO_TYPEDEF(0x038BE870, List_1_System_Text_RegularExpressions_RegexOptions_);
DO_TYPEDEF(0x038C0700, RegexWriter);
DO_TYPEDEF(0x03869970, Switch);
DO_TYPEDEF(0x0387C778, BooleanSwitch);
DO_TYPEDEF(0x0386E868, TraceListenerCollection);
DO_TYPEDEF(0x0386E7E0, TraceListener);
DO_TYPEDEF(0x03889278, DefaultTraceListener);
DO_TYPEDEF(0x0386EB10, TraceSwitch);
DO_TYPEDEF(0x03881B80, Component);
DO_TYPEDEF(0x038BBBA0, Process);
DO_TYPEDEF(0x038A3898, ISite);
DO_TYPEDEF(0x03894AC0, EventHandlerList);
DO_TYPEDEF(0x03893E78, EventHandlerList_ListEntry);
DO_TYPEDEF(0x038BBC30, ProcessStartInfo);
DO_TYPEDEF(0x038A3D18, ISynchronizeInvoke);
DO_TYPEDEF(0x0386EAE0, Process__Array);
DO_TYPEDEF(0x038BBCC0, ProcessWaitHandle);
DO_TYPEDEF(0x03896F78, FileVersionInfo);
DO_TYPEDEF(0x038686E0, Stopwatch);
DO_TYPEDEF(0x038764F0, AddingNewEventArgs);
DO_TYPEDEF(0x03876588, AddingNewEventHandler);
DO_TYPEDEF(0x03876D40, AmbientValueAttribute);
DO_TYPEDEF(0x03878890, ArraySubsetEnumerator);
DO_TYPEDEF(0x038790E0, AsyncOperation);
DO_TYPEDEF(0x03879890, AttributeProviderAttribute);
DO_TYPEDEF(0x0387A508, BackgroundWorker);
DO_TYPEDEF(0x0388C338, BackgroundWorker_WorkerThreadStartDelegate);
DO_TYPEDEF(0x0388AEF8, DoWorkEventArgs);
DO_TYPEDEF(0x038C25F0, RunWorkerCompletedEventArgs);
DO_TYPEDEF(0x038BBD50, ProgressChangedEventArgs);
DO_TYPEDEF(0x0388AF90, DoWorkEventHandler);
DO_TYPEDEF(0x038BBDE0, ProgressChangedEventHandler);
DO_TYPEDEF(0x038C2680, RunWorkerCompletedEventHandler);
DO_TYPEDEF(0x0387BCC8, BindableAttribute);
DO_TYPEDEF(0x0387C6E0, BooleanConverter);
DO_TYPEDEF(0x0387CB98, BrowsableAttribute);
DO_TYPEDEF(0x0387F208, CategoryAttribute);
DO_TYPEDEF(0x03881AE8, ComplexBindingPropertiesAttribute);
DO_TYPEDEF(0x0389DF18, IContainer);
DO_TYPEDEF(0x03881CA8, ComponentCollection);
DO_TYPEDEF(0x0389DB88, IComponent);
DO_TYPEDEF(0x0386C740, IComponent__Array);
DO_TYPEDEF(0x038BF590, ReferenceConverter);
DO_TYPEDEF(0x038C78F8, SortedList_2_System_String_System_Object_);
DO_TYPEDEF(0x038B2818, IComparer_1_System_String_);
DO_TYPEDEF(0x0386CD70, ISite__Array);
DO_TYPEDEF(0x03882A50, ContainerFilterService);
DO_TYPEDEF(0x0388D9B8, Container_Site);
DO_TYPEDEF(0x0388DF08, CultureInfoConverter_CultureComparer);
DO_TYPEDEF(0x0389E928, ICustomTypeDescriptor);
DO_TYPEDEF(0x038947C8, EventDescriptor_1);
DO_TYPEDEF(0x038BF620, ReflectEventDescriptor);
DO_TYPEDEF(0x038948F8, EventDescriptorCollection);
DO_TYPEDEF(0x0386B5E0, EventDescriptor_1__Array);
DO_TYPEDEF(0x038853C0, DataObjectAttribute);
DO_TYPEDEF(0x03885458, DataObjectFieldAttribute);
DO_TYPEDEF(0x038854F0, DataObjectMethodAttribute);
DO_TYPEDEF(0x03888D28, DefaultBindingPropertyAttribute);
DO_TYPEDEF(0x03888EE8, DefaultEventAttribute);
DO_TYPEDEF(0x03889148, DefaultPropertyAttribute);
DO_TYPEDEF(0x03889310, DefaultValueAttribute);
DO_TYPEDEF(0x0386FF48, TypeDescriptionProvider);
DO_TYPEDEF(0x038896A0, DelegatingTypeDescriptionProvider);
DO_TYPEDEF(0x038AEFD8, TypeDescriptionProvider_EmptyCustomTypeDescriptor);
DO_TYPEDEF(0x038A3808, IServiceProvider);
DO_TYPEDEF(0x0389FCC0, IExtenderProvider);
DO_TYPEDEF(0x0386C8F0, IExtenderProvider__Array);
DO_TYPEDEF(0x03889BF8, DesignOnlyAttribute);
DO_TYPEDEF(0x03889C90, DesignTimeVisibleAttribute);
DO_TYPEDEF(0x03889D28, DesignerAttribute);
DO_TYPEDEF(0x03889DC0, DesignerCategoryAttribute);
DO_TYPEDEF(0x03889E58, DesignerSerializationVisibilityAttribute);
DO_TYPEDEF(0x0388AB68, DisplayNameAttribute);
DO_TYPEDEF(0x03892ED8, EditorAttribute);
DO_TYPEDEF(0x03892F70, EditorBrowsableAttribute);
DO_TYPEDEF(0x03895C88, ExtendedPropertyDescriptor);
DO_TYPEDEF(0x0387C0F0, BitVector32);
DO_TYPEDEF(0x038BF6B0, ReflectPropertyDescriptor);
DO_TYPEDEF(0x03895D20, ExtenderProvidedPropertyAttribute);
DO_TYPEDEF(0x038A50C8, ImmutableObjectAttribute);
DO_TYPEDEF(0x038A7018, InstallerTypeAttribute);
DO_TYPEDEF(0x038A8948, InvalidEnumArgumentException);
DO_TYPEDEF(0x038AA778, LicenseProvider);
DO_TYPEDEF(0x0389BC40, LicFileLicenseProvider_LicFileLicense);
DO_TYPEDEF(0x038AA658, LicenseException);
DO_TYPEDEF(0x038AA6E8, LicenseManager);
DO_TYPEDEF(0x03889EF0, DesigntimeLicenseContext);
DO_TYPEDEF(0x038B5578, LicenseManager_LicenseInteropHelper_CLRLicenseContext);
DO_TYPEDEF(0x038AA808, LicenseProviderAttribute);
DO_TYPEDEF(0x038AB0F8, ListBindableAttribute);
DO_TYPEDEF(0x038AB188, ListChangedEventArgs);
DO_TYPEDEF(0x038AB218, ListChangedEventHandler);
DO_TYPEDEF(0x038AB4E8, ListSortDescription);
DO_TYPEDEF(0x038ABC28, LocalizableAttribute);
DO_TYPEDEF(0x038AC2D8, LookupBindingPropertiesAttribute);
DO_TYPEDEF(0x038AD318, MarshalByValueComponent);
DO_TYPEDEF(0x038AD438, MaskedTextProvider);
DO_TYPEDEF(0x038C3190, List_1_System_ComponentModel_MaskedTextProvider_CharDescriptor_);
DO_TYPEDEF(0x0389CD78, MaskedTextProvider_CaseConversion__Enum);
DO_TYPEDEF(0x0389CEA8, MaskedTextProvider_CharType__Enum);
DO_TYPEDEF(0x0389CE10, MaskedTextProvider_CharDescriptor);
DO_TYPEDEF(0x038AE358, MergablePropertyAttribute);
DO_TYPEDEF(0x0389E9F0, NestedContainer_Site);
DO_TYPEDEF(0x038B87E0, PasswordPropertyTextAttribute);
DO_TYPEDEF(0x038BBF00, PropertyChangedEventArgs);
DO_TYPEDEF(0x038BBF90, PropertyChangedEventHandler);
DO_TYPEDEF(0x038A5608, PropertyDescriptorCollection_PropertyDescriptorEnumerator);
DO_TYPEDEF(0x038BCA40, ProvidePropertyAttribute);
DO_TYPEDEF(0x038BEE40, ReadOnlyAttribute);
DO_TYPEDEF(0x038BF080, RecommendedAsConfigurableAttribute);
DO_TYPEDEF(0x038A6018, ReferenceConverter_ReferenceComparer);
DO_TYPEDEF(0x038BF740, ReflectTypeDescriptionProvider);
DO_TYPEDEF(0x038A60A8, ReflectTypeDescriptionProvider_ReflectedTypeData);
DO_TYPEDEF(0x038BFCE0, RefreshEventArgs);
DO_TYPEDEF(0x038BFD70, RefreshEventHandler);
DO_TYPEDEF(0x038C2560, RunInstallerAttribute);
DO_TYPEDEF(0x038C7538, SettingsBindableAttribute);
DO_TYPEDEF(0x0386E150, ToolboxItemFilterType__Enum);
DO_TYPEDEF(0x0386E0C0, ToolboxItemFilterAttribute);
DO_TYPEDEF(0x0386FE28, TypeConverterAttribute);
DO_TYPEDEF(0x0386FFD8, TypeDescriptionProviderAttribute);
DO_TYPEDEF(0x03870068, TypeDescriptor);
DO_TYPEDEF(0x03875D70, WeakHashtable);
DO_TYPEDEF(0x0389D9C0, IComNativeDescriptorHandler);
DO_TYPEDEF(0x0389EAF0, IDesigner);
DO_TYPEDEF(0x038AF450, TypeDescriptor_TypeDescriptionNode);
DO_TYPEDEF(0x038AF0F8, TypeDescriptor_AttributeProvider);
DO_TYPEDEF(0x038B5B18, TypeDescriptor_AttributeProvider_AttributeTypeDescriptor);
DO_TYPEDEF(0x038AF188, TypeDescriptor_ComNativeDescriptionProvider);
DO_TYPEDEF(0x038B5BA8, TypeDescriptor_ComNativeDescriptionProvider_ComNativeTypeDescriptor);
DO_TYPEDEF(0x038AF068, TypeDescriptor_AttributeFilterCacheItem);
DO_TYPEDEF(0x038AF218, TypeDescriptor_FilterCacheItem);
DO_TYPEDEF(0x038A42B8, ITypeDescriptorFilterService);
DO_TYPEDEF(0x038AF330, TypeDescriptor_MemberDescriptorComparer);
DO_TYPEDEF(0x038AF3C0, TypeDescriptor_MergedTypeDescriptor);
DO_TYPEDEF(0x038B5C38, TypeDescriptor_TypeDescriptionNode_DefaultExtendedTypeDescriptor);
DO_TYPEDEF(0x038B5CC8, TypeDescriptor_TypeDescriptionNode_DefaultTypeDescriptor);
DO_TYPEDEF(0x03876D70, Win32Exception);
DO_TYPEDEF(0x038A5428, InheritanceLevel__Enum);
DO_TYPEDEF(0x038A5398, InheritanceAttribute);
DO_TYPEDEF(0x038B2D58, NotifyParentPropertyAttribute);
DO_TYPEDEF(0x038B7B88, ParenthesizePropertyNameAttribute);
DO_TYPEDEF(0x038BC2F0, PropertyTabAttribute);
DO_TYPEDEF(0x0386ED20, PropertyTabScope__Enum__Array);
DO_TYPEDEF(0x038BFE00, RefreshPropertiesAttribute);
DO_TYPEDEF(0x0386E030, ToolboxItemAttribute);
DO_TYPEDEF(0x038B1558, WeakHashtable_WeakKeyComparer);
DO_TYPEDEF(0x038B14C8, WeakHashtable_EqualityWeakReference);
DO_TYPEDEF(0x0387FF10, CheckoutException);
DO_TYPEDEF(0x038C2C20, RuntimeLicenseContext);
DO_TYPEDEF(0x038A70A8, InstanceDescriptor);
DO_TYPEDEF(0x03879B88, AuthenticationException);
DO_TYPEDEF(0x038B5E48, Oid);
DO_TYPEDEF(0x038B5F68, OidEnumerator);
DO_TYPEDEF(0x038789C0, AsnEncodedData);
DO_TYPEDEF(0x038BCC80, PublicKey);
DO_TYPEDEF(0x03878498, X509Extension_2);
DO_TYPEDEF(0x03877528, X509BasicConstraintsExtension);
DO_TYPEDEF(0x03877788, X509Certificate2);
DO_TYPEDEF(0x038778B8, X509Certificate2Impl);
DO_TYPEDEF(0x03877950, X509Certificate2ImplMono);
DO_TYPEDEF(0x03878660, X509ExtensionCollection_2);
DO_TYPEDEF(0x03877C48, X509CertificateImplCollection);
DO_TYPEDEF(0x038C0AC0, List_1_System_Security_Cryptography_X509Certificates_X509CertificateImpl_);
DO_TYPEDEF(0x038B1B88, X509CertificateCollection_X509CertificateEnumerator_2);
DO_TYPEDEF(0x03877E10, X509ChainElement);
DO_TYPEDEF(0x03877F40, X509ChainElementEnumerator);
DO_TYPEDEF(0x03877FD8, X509ChainImplMono);
DO_TYPEDEF(0x038782D0, X509EnhancedKeyUsageExtension);
DO_TYPEDEF(0x038B1C18, X509Helper2_MyNativeHelper);
DO_TYPEDEF(0x03878790, X509KeyUsageExtension);
DO_TYPEDEF(0x03878828, X509SubjectKeyIdentifierExtension);
DO_TYPEDEF(0x03898F88, GZipStream);
DO_TYPEDEF(0x03889440, DeflateStream);
DO_TYPEDEF(0x038894D8, DeflateStreamNative);
DO_TYPEDEF(0x03891920, DeflateStreamNative_UnmanagedReadOrWrite);
DO_TYPEDEF(0x03891888, DeflateStreamNative_SafeDeflateStreamHandle);
DO_TYPEDEF(0x03891758, DeflateStream_ReadMethod);
DO_TYPEDEF(0x038917F0, DeflateStream_WriteMethod);
DO_TYPEDEF(0x03878760, ArrayPoolEventSource);
DO_TYPEDEF(0x0387F170, CaseSensitiveStringDictionary);
DO_TYPEDEF(0x0389C7F0, HybridDictionary);
DO_TYPEDEF(0x038AB2A8, ListDictionary);
DO_TYPEDEF(0x0389C2C8, ListDictionary_DictionaryNode);
DO_TYPEDEF(0x0389C360, ListDictionary_NodeEnumerator);
DO_TYPEDEF(0x0389C3F8, ListDictionary_NodeKeyValueCollection);
DO_TYPEDEF(0x038B5608, ListDictionary_NodeKeyValueCollection_NodeKeyValueEnumerator);
DO_TYPEDEF(0x0389E5C8, NameObjectCollectionBase_NameObjectKeysEnumerator);
DO_TYPEDEF(0x038819B8, CompatibleComparer_1);
DO_TYPEDEF(0x038B6B38, OrderedDictionary);
DO_TYPEDEF(0x038A12E8, OrderedDictionary_OrderedDictionaryEnumerator);
DO_TYPEDEF(0x038A1380, OrderedDictionary_OrderedDictionaryKeyValueCollection);
DO_TYPEDEF(0x03868C80, StringCollection);
DO_TYPEDEF(0x038B2608, NetEventSource);
DO_TYPEDEF(0x03869F10, SystemNetworkCredential);
DO_TYPEDEF(0x038A83A8, InternalException);
DO_TYPEDEF(0x038760F8, WebException);
DO_TYPEDEF(0x038765B8, WebRequestPrefixElement);
DO_TYPEDEF(0x038A4618, IWebRequestCreate);
DO_TYPEDEF(0x038BC9B0, ProtocolViolationException);
DO_TYPEDEF(0x0387EFA8, CaseInsensitiveAscii);
DO_TYPEDEF(0x03876488, WebProxy);
DO_TYPEDEF(0x0386F110, Regex__Array);
DO_TYPEDEF(0x038B1798, WebRequest_WebProxyWrapper);
DO_TYPEDEF(0x038B1678, WebRequest_c_DisplayClass79_0);
DO_TYPEDEF(0x0389B948, LazyAsyncResult_ThreadContext);
DO_TYPEDEF(0x038A9F18, LazyAsyncResult);
DO_TYPEDEF(0x038AE268, TimerThread_TimerNode);
DO_TYPEDEF(0x038AE2F8, TimerThread_TimerQueue);
DO_TYPEDEF(0x038AE1D8, TimerThread_InfiniteTimerQueue);
DO_TYPEDEF(0x03893268, EmptyWebProxy);
DO_TYPEDEF(0x03883338, Cookie);
DO_TYPEDEF(0x038817F8, Comparer_1);
DO_TYPEDEF(0x03883630, CookieTokenizer);
DO_TYPEDEF(0x03871F28, CookieTokenizer_RecognizedAttribute__Array);
DO_TYPEDEF(0x03883598, CookieParser);
DO_TYPEDEF(0x0388DAE8, CookieCollection_CookieCollectionEnumerator);
DO_TYPEDEF(0x038B8990, PathList);
DO_TYPEDEF(0x038A3298, PathList_PathListComparer);
DO_TYPEDEF(0x03883500, CookieException);
DO_TYPEDEF(0x03897010, FileWebRequest);
DO_TYPEDEF(0x038970A8, FileWebRequestCreator);
DO_TYPEDEF(0x038971D8, FileWebStream);
DO_TYPEDEF(0x03897140, FileWebResponse);
DO_TYPEDEF(0x03875E98, WebClient);
DO_TYPEDEF(0x038A7550, ServerCertValidationCallback_CallbackContext);
DO_TYPEDEF(0x0387A9C8, BasicClient);
DO_TYPEDEF(0x0388A6A8, DigestHeaderParser);
DO_TYPEDEF(0x0388A740, DigestSession);
DO_TYPEDEF(0x0388A610, DigestClient);
DO_TYPEDEF(0x038664F8, Task_1_System_Net_IPAddress_);
DO_TYPEDEF(0x03891C08, Dns_GetHostAddressesCallback);
DO_TYPEDEF(0x038980B0, FtpAsyncResult);
DO_TYPEDEF(0x038983A8, FtpWebResponse);
DO_TYPEDEF(0x03898310, FtpWebRequest);
DO_TYPEDEF(0x03898148, FtpDataStream);
DO_TYPEDEF(0x03895048, FtpDataStream_WriteDelegate);
DO_TYPEDEF(0x03894FB0, FtpDataStream_ReadDelegate);
DO_TYPEDEF(0x038981E0, FtpRequestCreator);
DO_TYPEDEF(0x03898278, FtpStatus);
DO_TYPEDEF(0x0389C330, HttpRequestCreator);
DO_TYPEDEF(0x038A1978, AsyncTaskMethodBuilder_1_System_Net_HttpWebResponse_);
DO_TYPEDEF(0x038A1738, AsyncTaskMethodBuilder_1_System_ValueTuple_5_);
DO_TYPEDEF(0x038A18E8, AsyncTaskMethodBuilder_1_System_Net_BufferOffsetSize_);
DO_TYPEDEF(0x0389DF40, MonoChunkStream_Chunk);
DO_TYPEDEF(0x038B2E78, NtlmClient_1);
DO_TYPEDEF(0x0389CD48, IAuthenticationModule);
DO_TYPEDEF(0x0389D0D8, ICertificatePolicy);
DO_TYPEDEF(0x038A7700, ServicePointManager_SPKey);
DO_TYPEDEF(0x038B58D8, ServicePointScheduler_AsyncManualResetEvent_c);
DO_TYPEDEF(0x038AECA8, Func_2_Object_Boolean_);
DO_TYPEDEF(0x038A1D68, AsyncTaskMethodBuilder_1_System_Net_WebRequestStream_);
DO_TYPEDEF(0x038A16A8, AsyncTaskMethodBuilder_1_System_ValueTuple_3_);
DO_TYPEDEF(0x038A1578, AsyncTaskMethodBuilder_1_System_ValueTuple_2_);
DO_TYPEDEF(0x038B1828, WebResponseStream_c_DisplayClass48_0);
DO_TYPEDEF(0x038A1610, AsyncTaskMethodBuilder_1_System_ValueTuple_2__1);
DO_TYPEDEF(0x03866888, SocketException);
DO_TYPEDEF(0x038667F8, SocketError__Enum);
DO_TYPEDEF(0x038AB068, LingerOption);
DO_TYPEDEF(0x038AAE60, Socket_c);
DO_TYPEDEF(0x038AAEF0, Socket_c_DisplayClass243_0);
DO_TYPEDEF(0x038AAF80, Socket_c_DisplayClass299_0);
DO_TYPEDEF(0x038666D8, SocketAsyncEventArgs);
DO_TYPEDEF(0x038AB008, SocketAsyncResult_c);
DO_TYPEDEF(0x038AB098, SocketTaskExtensions_c);
DO_TYPEDEF(0x038B08B8, Func_4_System_Net_EndPoint_AsyncCallback_Object_IAsyncResult_);
DO_TYPEDEF(0x0389EA20, Action_1_IAsyncResult_);
DO_TYPEDEF(0x038B0A68, Func_5_System_Net_IPAddress_Int32_AsyncCallback_Object_IAsyncResult_);
DO_TYPEDEF(0x038A2728, IPGlobalProperties);
DO_TYPEDEF(0x038B2728, NetworkInformationException);
DO_TYPEDEF(0x038728E8, UnixIPGlobalProperties);
DO_TYPEDEF(0x03872978, UnixNoLibCIPGlobalProperties);
DO_TYPEDEF(0x038AF278, MibIPGlobalProperties);
DO_TYPEDEF(0x03876E08, Win32IPGlobalProperties);
DO_TYPEDEF(0x038891E0, DefaultProxySectionInternal);
DO_TYPEDEF(0x038C75C8, SettingsSectionInternal);
DO_TYPEDEF(0x03876BA8, WebSocketState__Enum);
DO_TYPEDEF(0x03876948, WebSocketCloseStatus__Enum);
DO_TYPEDEF(0x038ACCF8, ManagedWebSocket);
DO_TYPEDEF(0x03876B10, WebSocketReceiveResult);
DO_TYPEDEF(0x038A1280, ArraySegment_1_Byte_);
DO_TYPEDEF(0x038711A8, WebSocketState__Enum__Array);
DO_TYPEDEF(0x0389CB18, ManagedWebSocket_Utf8MessageState);
DO_TYPEDEF(0x0389CA80, ManagedWebSocket_c);
DO_TYPEDEF(0x038A1DF8, AsyncTaskMethodBuilder_1_System_Net_WebSockets_WebSocketReceiveResult_);
DO_TYPEDEF(0x038806C0, ClientWebSocket);
DO_TYPEDEF(0x03880758, ClientWebSocketOptions);
DO_TYPEDEF(0x03876A78, WebSocketHandle);
DO_TYPEDEF(0x038B18B8, WebSocketHandle_c);
DO_TYPEDEF(0x038A1B28, AsyncTaskMethodBuilder_1_System_Net_Sockets_Socket_);
DO_TYPEDEF(0x038B1948, WebSocketHandle_c_DisplayClass28_0);
DO_TYPEDEF(0x038A1C48, AsyncTaskMethodBuilder_1_System_String_);
DO_TYPEDEF(0x038769E0, WebSocketException);
DO_TYPEDEF(0x038BEED0, ReaderWriterCount);
DO_TYPEDEF(0x038BEF60, ReaderWriterLockSlim);
DO_TYPEDEF(0x038767E8, AesTransform);
DO_TYPEDEF(0x038B3868, IEnumerable_1_System_Int32_);
DO_TYPEDEF(0x03893CB0, Enumerable_RangeIterator_d_115);
DO_TYPEDEF(0x03895A28, Expression);
DO_TYPEDEF(0x038A1E88, CacheDict_2_System_Type_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038A9CE0, LambdaExpression);
DO_TYPEDEF(0x038ADDB8, MemberExpression);
DO_TYPEDEF(0x038703C8, TypeInferenceRules__Enum);
DO_TYPEDEF(0x03899318, GenericStack);
DO_TYPEDEF(0x038A9AA8, Keyframe);
DO_TYPEDEF(0x0386D940, Keyframe__Array);
DO_TYPEDEF(0x038773C8, AnimationCurve);
DO_TYPEDEF(0x03877230, WrapMode__Enum);
DO_TYPEDEF(0x038C2DD0, RuntimePlatform__Enum);
DO_TYPEDEF(0x0388B808, Application_LogCallback);
DO_TYPEDEF(0x038ABE68, LogType__Enum);
DO_TYPEDEF(0x038723D8, UnityAction);
DO_TYPEDEF(0x0389E690, Action_1_Boolean_);
DO_TYPEDEF(0x0387C8A8, BootConfigData);
DO_TYPEDEF(0x038B5548, Object_1);
DO_TYPEDEF(0x03881C10, Component_1);
DO_TYPEDEF(0x0387ACC0, Behaviour);
DO_TYPEDEF(0x0387E758, Camera);
DO_TYPEDEF(0x0388CFA0, Camera_CameraCallback);
DO_TYPEDEF(0x038C1630, RenderingPath__Enum);
DO_TYPEDEF(0x038B62C8, OpaqueSortMode__Enum);
DO_TYPEDEF(0x0386F2F0, TransparencySortMode__Enum);
DO_TYPEDEF(0x0387E920, CameraType__Enum);
DO_TYPEDEF(0x03880CB0, Color);
DO_TYPEDEF(0x0387E7F0, CameraClearFlags__Enum);
DO_TYPEDEF(0x03889900, DepthTextureMode__Enum);
DO_TYPEDEF(0x038C76E8, Shader);
DO_TYPEDEF(0x038BF110, Rect);
DO_TYPEDEF(0x0386C920, Texture);
DO_TYPEDEF(0x038C13F0, RenderTexture);
DO_TYPEDEF(0x038ADC08, Matrix4x4);
DO_TYPEDEF(0x03874358, Vector4);
DO_TYPEDEF(0x03874118, Vector3);
DO_TYPEDEF(0x038BEAE0, Ray);
DO_TYPEDEF(0x03873DB8, Vector2);
DO_TYPEDEF(0x03870F68, Vector3__Array);
DO_TYPEDEF(0x03868530, StereoTargetEyeMask__Enum);
DO_TYPEDEF(0x0386A480, Camera__Array);
DO_TYPEDEF(0x03881338, CommandBuffer);
DO_TYPEDEF(0x0388DE78, CullingGroup_StateChanged);
DO_TYPEDEF(0x03883E78, CullingGroupEvent);
DO_TYPEDEF(0x038BFA10, ReflectionProbe);
DO_TYPEDEF(0x03888310, DebugLogHandler);
DO_TYPEDEF(0x038A17F8, ILogger);
DO_TYPEDEF(0x0387C940, Bounds);
DO_TYPEDEF(0x0386E7B0, Plane__Array);
DO_TYPEDEF(0x038BF1A0, RectInt);
DO_TYPEDEF(0x038BF230, RectOffset);
DO_TYPEDEF(0x038AE3E0, Mesh);
DO_TYPEDEF(0x038BD2B0, Quaternion);
DO_TYPEDEF(0x0387AC28, BeforeRenderOrderAttribute);
DO_TYPEDEF(0x0388AAD0, Display);
DO_TYPEDEF(0x0386B0D8, Display__Array);
DO_TYPEDEF(0x03883D48, CubemapFace__Enum);
DO_TYPEDEF(0x0386F230, RenderBuffer__Array);
DO_TYPEDEF(0x03881D40, ComputeBuffer);
DO_TYPEDEF(0x038AD798, Material);
DO_TYPEDEF(0x038AD8B0, MaterialPropertyBlock);
DO_TYPEDEF(0x038C79B8, ShadowCastingMode__Enum);
DO_TYPEDEF(0x0386F260, Transform);
DO_TYPEDEF(0x038AA9B8, LightProbeUsage__Enum);
DO_TYPEDEF(0x0386DD30, Matrix4x4__Array);
DO_TYPEDEF(0x03870E48, Vector2__Array);
DO_TYPEDEF(0x038BCAA0, List_1_UnityEngine_Matrix4x4_);
DO_TYPEDEF(0x038779B8, AnisotropicFiltering__Enum);
DO_TYPEDEF(0x038999A0, Gradient);
DO_TYPEDEF(0x03871088, Vector4__Array);
DO_TYPEDEF(0x038BEFC0, List_1_System_Single_);
DO_TYPEDEF(0x038C0760, List_1_UnityEngine_Vector4_);
DO_TYPEDEF(0x0386DC10, Material__Array);
DO_TYPEDEF(0x038B0DE8, MotionVectorGenerationMode__Enum);
DO_TYPEDEF(0x038BFAA0, ReflectionProbeUsage__Enum);
DO_TYPEDEF(0x038990B8, GameObject);
DO_TYPEDEF(0x038BCA10, List_1_UnityEngine_Material_);
DO_TYPEDEF(0x038AD820, MaterialGlobalIlluminationFlags__Enum);
DO_TYPEDEF(0x0386A6C0, Color__Array);
DO_TYPEDEF(0x03897600, Flare);
DO_TYPEDEF(0x038AA928, Light);
DO_TYPEDEF(0x038AAD18, LightType__Enum);
DO_TYPEDEF(0x038AAC88, LightShadows__Enum);
DO_TYPEDEF(0x038AABF8, LightShadowResolution__Enum);
DO_TYPEDEF(0x038AAAD8, LightRenderMode__Enum);
DO_TYPEDEF(0x03866018, Skybox);
DO_TYPEDEF(0x038AE618, MeshFilter);
DO_TYPEDEF(0x03865F88, SkinnedMeshRenderer);
DO_TYPEDEF(0x03865EF8, SkinQuality__Enum);
DO_TYPEDEF(0x038708A8, Transform__Array);
DO_TYPEDEF(0x038AE978, MeshRenderer);
DO_TYPEDEF(0x038A9BC0, LOD);
DO_TYPEDEF(0x0386F3E0, Renderer__Array);
DO_TYPEDEF(0x0386D9D0, LOD__Array);
DO_TYPEDEF(0x0387C3E8, BoneWeight);
DO_TYPEDEF(0x03880E78, Color32);
DO_TYPEDEF(0x0386A750, Color32__Array);
DO_TYPEDEF(0x038C06D0, List_1_UnityEngine_Vector3_);
DO_TYPEDEF(0x038B9EC0, List_1_UnityEngine_Color_);
DO_TYPEDEF(0x038B9F50, List_1_UnityEngine_Color32_);
DO_TYPEDEF(0x038C0640, List_1_UnityEngine_Vector2_);
DO_TYPEDEF(0x0387C480, BoneWeight1);
DO_TYPEDEF(0x0386CD10, TextureWrapMode__Enum);
DO_TYPEDEF(0x03897270, FilterMode__Enum);
DO_TYPEDEF(0x0386CAD0, TextureFormat__Enum);
DO_TYPEDEF(0x03899F90, GraphicsFormat__Enum);
DO_TYPEDEF(0x03897BF0, FormatUsage__Enum);
DO_TYPEDEF(0x038724F8, UnityException);
DO_TYPEDEF(0x0386C9B0, Texture2D);
DO_TYPEDEF(0x0386CA40, Texture3D);
DO_TYPEDEF(0x038C1510, RenderTextureFormat__Enum);
DO_TYPEDEF(0x038C1480, RenderTextureDescriptor);
DO_TYPEDEF(0x038ABEF0, Logger);
DO_TYPEDEF(0x038A1768, ILogHandler);
DO_TYPEDEF(0x03872588, UnityLogWriter);
DO_TYPEDEF(0x03899AD0, GradientColorKey);
DO_TYPEDEF(0x03899A38, GradientAlphaKey);
DO_TYPEDEF(0x0386C1A0, GradientColorKey__Array);
DO_TYPEDEF(0x0386C110, GradientAlphaKey__Array);
DO_TYPEDEF(0x03899B68, GradientMode__Enum);
DO_TYPEDEF(0x03873ED8, Vector2Int);
DO_TYPEDEF(0x03874238, Vector3Int);
DO_TYPEDEF(0x038BA880, PlayerConnectionInternal);
DO_TYPEDEF(0x038BAB50, PlayerPrefsException);
DO_TYPEDEF(0x038C1C60, ResourcesAPI);
DO_TYPEDEF(0x0389E5F8, Action_1_UnityEngine_AsyncOperation_);
DO_TYPEDEF(0x038B9FE0, List_1_UnityEngine_Component_);
DO_TYPEDEF(0x0386A7E0, Component_1__Array);
DO_TYPEDEF(0x03875780, WaitForSecondsRealtime);
DO_TYPEDEF(0x0386BED8, GameObject__Array);
DO_TYPEDEF(0x038C4BA0, Scene);
DO_TYPEDEF(0x038A9DF8, LayerMask);
DO_TYPEDEF(0x038B02B8, MonoBehaviour);
DO_TYPEDEF(0x038C5260, ScriptableObject);
DO_TYPEDEF(0x038AF658, MissingReferenceException);
DO_TYPEDEF(0x0386C2F0, TextAsset);
DO_TYPEDEF(0x0386EF00, TrackedReference);
DO_TYPEDEF(0x038AFA78, UnhandledExceptionHandler_c);
DO_TYPEDEF(0x0389BE70, HideFlags__Enum);
DO_TYPEDEF(0x03872618, UnitySynchronizationContext);
DO_TYPEDEF(0x038C4420, List_1_UnityEngine_UnitySynchronizationContext_WorkRequest_);
DO_TYPEDEF(0x038AFB98, UnitySynchronizationContext_WorkRequest);
DO_TYPEDEF(0x038755B8, WaitForEndOfFrame);
DO_TYPEDEF(0x03875650, WaitForFixedUpdate);
DO_TYPEDEF(0x038756E8, WaitForSeconds);
DO_TYPEDEF(0x038759E0, WaitUntil);
DO_TYPEDEF(0x038AC968, Func_1_Boolean_);
DO_TYPEDEF(0x03899EF8, GraphicsDeviceType__Enum);
DO_TYPEDEF(0x0386E4A8, TouchScreenKeyboard);
DO_TYPEDEF(0x0386E538, TouchScreenKeyboardType__Enum);
DO_TYPEDEF(0x038BB210, Pose);
DO_TYPEDEF(0x038BF3E0, RectTransform);
DO_TYPEDEF(0x038A5F88, RectTransform_ReapplyDrivenProperties);
DO_TYPEDEF(0x038AED98, Transform_Enumerator);
DO_TYPEDEF(0x03867188, SpriteRenderer);
DO_TYPEDEF(0x03867068, Sprite);
DO_TYPEDEF(0x0389F4D0, Action_1_UnityEngine_U2D_SpriteAtlas_);
DO_TYPEDEF(0x038C49C0, NativeArray_1_System_Byte_);
DO_TYPEDEF(0x038883A8, DebugScreenCapture);
DO_TYPEDEF(0x038AEE88, MetaData);
DO_TYPEDEF(0x038A3F88, PhraseRecognitionSystem_ErrorDelegate);
DO_TYPEDEF(0x03866C78, SpeechError__Enum);
DO_TYPEDEF(0x03866D98, SpeechSystemStatus__Enum);
DO_TYPEDEF(0x03881F08, ConfidenceLevel__Enum);
DO_TYPEDEF(0x038A4018, PhraseRecognizer_PhraseRecognizedDelegate);
DO_TYPEDEF(0x038B9C20, PhraseRecognizedEventArgs);
DO_TYPEDEF(0x0386FA10, SemanticMeaning__Array);
DO_TYPEDEF(0x0388A280, DictationCompletionCause__Enum);
DO_TYPEDEF(0x038A9B30, KeywordRecognizer);
DO_TYPEDEF(0x038A34D8, PhotoCapture_PhotoCaptureResult);
DO_TYPEDEF(0x038B8EA0, PhotoCapture);
DO_TYPEDEF(0x038B8F30, PhotoCaptureFrame);
DO_TYPEDEF(0x038B0918, VideoCapture_VideoCaptureResult);
DO_TYPEDEF(0x03874780, VideoCapture);
DO_TYPEDEF(0x038782A0, ArgumentCache);
DO_TYPEDEF(0x0387A930, BaseInvokableCall);
DO_TYPEDEF(0x038A8C18, InvokableCall);
DO_TYPEDEF(0x038A8CA8, InvokableCallList);
DO_TYPEDEF(0x038B95C0, List_1_UnityEngine_Events_BaseInvokableCall_);
DO_TYPEDEF(0x038B8E10, PersistentCallGroup);
DO_TYPEDEF(0x038BDB80, List_1_UnityEngine_Events_PersistentCall_);
DO_TYPEDEF(0x03872468, UnityEvent);
DO_TYPEDEF(0x038B1018, MovedFromAttribute);
DO_TYPEDEF(0x038BACD0, List_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x038C4CC0, SceneManagerAPI);
DO_TYPEDEF(0x03867AE8, UnityAction_2_UnityEngine_SceneManagement_Scene_UnityEngine_SceneManagement_LoadSceneMode_);
DO_TYPEDEF(0x03867B78, UnityAction_2_UnityEngine_SceneManagement_Scene_UnityEngine_SceneManagement_Scene_);
DO_TYPEDEF(0x038AEDF8, MessageEventArgs);
DO_TYPEDEF(0x038BA7F0, PlayerConnection);
DO_TYPEDEF(0x038A29F8, IPlayerEditorConnectionNative);
DO_TYPEDEF(0x038BA910, PlayerEditorConnectionEvents);
DO_TYPEDEF(0x038C3B20, List_1_UnityEngine_Networking_PlayerConnection_PlayerEditorConnectionEvents_MessageTypeSubscribers_);
DO_TYPEDEF(0x038A4888, PlayerEditorConnectionEvents_MessageTypeSubscribers);
DO_TYPEDEF(0x038A47F8, PlayerEditorConnectionEvents_MessageEvent);
DO_TYPEDEF(0x038B5758, IEnumerator_1_UnityEngine_Networking_PlayerConnection_PlayerEditorConnectionEvents_MessageTypeSubscribers_);
DO_TYPEDEF(0x038A4768, PlayerEditorConnectionEvents_ConnectionChangeEvent);
DO_TYPEDEF(0x03867788, UnityAction_1_UnityEngine_Networking_PlayerConnection_MessageEventArgs_);
DO_TYPEDEF(0x03867668, UnityAction_1_System_Int32_);
DO_TYPEDEF(0x038A4408, PlayerConnection_c_DisplayClass12_0);
DO_TYPEDEF(0x038A4498, PlayerConnection_c_DisplayClass13_0);
DO_TYPEDEF(0x038A4528, PlayerConnection_c_DisplayClass20_0);
DO_TYPEDEF(0x038A45B8, PlayerEditorConnectionEvents_c_DisplayClass6_0);
DO_TYPEDEF(0x038A4648, PlayerEditorConnectionEvents_c_DisplayClass7_0);
DO_TYPEDEF(0x038A46D8, PlayerEditorConnectionEvents_c_DisplayClass8_0);
DO_TYPEDEF(0x038893A8, DefaultValueAttribute_1);
DO_TYPEDEF(0x0387CDF8, BuiltinRenderTextureType__Enum);
DO_TYPEDEF(0x038C1360, RenderTargetIdentifier);
DO_TYPEDEF(0x038C1240, RenderPipelineAsset);
DO_TYPEDEF(0x0386F2C0, RenderTargetIdentifier__Array);
DO_TYPEDEF(0x038A9C50, LODParameters);
DO_TYPEDEF(0x0387AAF8, BatchCullingContext);
DO_TYPEDEF(0x038C52F0, ScriptableRenderContext);
DO_TYPEDEF(0x038C7898, ShaderTagId);
DO_TYPEDEF(0x0388D038, Camera_RenderRequest);
DO_TYPEDEF(0x03869850, SupportedRenderingFeatures);
DO_TYPEDEF(0x038BA520, PlayableHandle);
DO_TYPEDEF(0x038BA370, Playable);
DO_TYPEDEF(0x038BA490, PlayableGraph);
DO_TYPEDEF(0x038BA640, PlayableOutputHandle);
DO_TYPEDEF(0x038BA5B0, PlayableOutput);
DO_TYPEDEF(0x0389C100, Lightmapping_RequestLightsDelegate);
DO_TYPEDEF(0x0386DAF0, Light__Array);
DO_TYPEDEF(0x038C4A50, NativeArray_1_UnityEngine_Experimental_GlobalIllumination_LightDataGI_);
DO_TYPEDEF(0x0389C068, Lightmapping_c);
DO_TYPEDEF(0x0387CE88, BuiltinRuntimeReflectionSystem);
DO_TYPEDEF(0x038A3418, IScriptableRuntimeReflectionSystem);
DO_TYPEDEF(0x038C5410, ScriptableRuntimeReflectionSystemWrapper);
DO_TYPEDEF(0x038A9628, KeyCode__Enum);
DO_TYPEDEF(0x038706F8, Touch__Array);
DO_TYPEDEF(0x03897990, FontStyle__Enum);
DO_TYPEDEF(0x0386C260, TextAnchor__Enum);
DO_TYPEDEF(0x038746E8, VerticalWrapMode__Enum);
DO_TYPEDEF(0x0389C038, HorizontalWrapMode__Enum);
DO_TYPEDEF(0x038977C8, Font);
DO_TYPEDEF(0x0389E858, Action_1_UnityEngine_Font_);
DO_TYPEDEF(0x0386C4A0, TextGenerator);
DO_TYPEDEF(0x038C02E0, List_1_UnityEngine_UIVertex_);
DO_TYPEDEF(0x03870F08, UIVertex);
DO_TYPEDEF(0x03870B78, UIVertex__Array);
DO_TYPEDEF(0x038C01C0, List_1_UnityEngine_UICharInfo_);
DO_TYPEDEF(0x03870CC8, UICharInfo);
DO_TYPEDEF(0x038C0250, List_1_UnityEngine_UILineInfo_);
DO_TYPEDEF(0x03870DE8, UILineInfo);
DO_TYPEDEF(0x038B6058, IList_1_UnityEngine_UIVertex_);
DO_TYPEDEF(0x038B5F38, IList_1_UnityEngine_UICharInfo_);
DO_TYPEDEF(0x038B5FC8, IList_1_UnityEngine_UILineInfo_);
DO_TYPEDEF(0x038944D0, Event);
DO_TYPEDEF(0x03895278, EventType__Enum);
DO_TYPEDEF(0x03894D20, EventModifiers__Enum);
DO_TYPEDEF(0x038950E0, GUI_WindowFunction);
DO_TYPEDEF(0x03898738, GUIContent);
DO_TYPEDEF(0x03898C90, GUIStyle);
DO_TYPEDEF(0x03898D28, GUIStyleState);
DO_TYPEDEF(0x03898B60, GUISkin);
DO_TYPEDEF(0x0386BE48, GUIStyle__Array);
DO_TYPEDEF(0x03898AC8, GUISettings);
DO_TYPEDEF(0x038A7348, Dictionary_2_System_String_UnityEngine_GUIStyle_);
DO_TYPEDEF(0x0386C410, TextEditor);
DO_TYPEDEF(0x038A4678, Dictionary_2_UnityEngine_Event_UnityEngine_TextEditor_TextEditOp_);
DO_TYPEDEF(0x038AD588, TextEditor_TextEditOp__Enum);
DO_TYPEDEF(0x0386BD28, GUIContent__Array);
DO_TYPEDEF(0x0386EFF0, Rect__Array);
DO_TYPEDEF(0x03895210, GUILayout_HorizontalScope);
DO_TYPEDEF(0x03898900, GUILayoutOption);
DO_TYPEDEF(0x0386BDB8, GUILayoutOption__Array);
DO_TYPEDEF(0x038952A8, GUILayout_LayoutedWindow);
DO_TYPEDEF(0x03895340, GUILayout_VerticalScope);
DO_TYPEDEF(0x03895178, GUILayout_AreaScope);
DO_TYPEDEF(0x038953D8, GUILayoutUtility_LayoutCache);
DO_TYPEDEF(0x038987D0, GUILayoutEntry);
DO_TYPEDEF(0x03898868, GUILayoutGroup);
DO_TYPEDEF(0x038BAC40, List_1_UnityEngine_GUILayoutEntry_);
DO_TYPEDEF(0x03895900, ExitGUIException);
DO_TYPEDEF(0x03898EF0, GUIWordWrapSizer);
DO_TYPEDEF(0x03898A30, GUIScrollGroup);
DO_TYPEDEF(0x038C5650, ScrollViewState);
DO_TYPEDEF(0x038660A8, SliderState);
DO_TYPEDEF(0x0388C0E0, AudioSettings_AudioConfigurationChangeHandler);
DO_TYPEDEF(0x038799C0, AudioClip);
DO_TYPEDEF(0x0388BF20, AudioClip_PCMReaderCallback);
DO_TYPEDEF(0x0388BFB0, AudioClip_PCMSetPositionCallback);
DO_TYPEDEF(0x038B9F80, PhysicsScene2D);
DO_TYPEDEF(0x038BEC00, RaycastHit2D);
DO_TYPEDEF(0x0386EF60, RaycastHit2D__Array);
DO_TYPEDEF(0x03880B80, Collider2D);
DO_TYPEDEF(0x038B9E60, PhysicsMaterial2D);
DO_TYPEDEF(0x03880168, CircleCollider2D);
DO_TYPEDEF(0x0387EF10, CapsuleCollider2D);
DO_TYPEDEF(0x03892E40, EdgeCollider2D);
DO_TYPEDEF(0x0387CB08, BoxCollider2D);
DO_TYPEDEF(0x038BB180, PolygonCollider2D);
DO_TYPEDEF(0x03880AE8, Collider);
DO_TYPEDEF(0x0387FC20, CharacterController);
DO_TYPEDEF(0x0386A900, ContactPoint__Array);
DO_TYPEDEF(0x038B9CB0, PhysicMaterial);
DO_TYPEDEF(0x038B9D40, PhysicMaterialCombine__Enum);
DO_TYPEDEF(0x038BEB70, RaycastHit);
DO_TYPEDEF(0x038C1E10, Rigidbody);
DO_TYPEDEF(0x038C1EA0, RigidbodyConstraints__Enum);
DO_TYPEDEF(0x03880C18, CollisionDetectionMode__Enum);
DO_TYPEDEF(0x038C1F30, RigidbodyInterpolation__Enum);
DO_TYPEDEF(0x038AE470, MeshCollider);
DO_TYPEDEF(0x0387EE78, CapsuleCollider);
DO_TYPEDEF(0x0387CA70, BoxCollider);
DO_TYPEDEF(0x03866E28, SphereCollider);
DO_TYPEDEF(0x038B9EF0, PhysicsScene);
DO_TYPEDEF(0x038BD4F0, QueryTriggerInteraction__Enum);
DO_TYPEDEF(0x0386EED0, RaycastHit__Array);
DO_TYPEDEF(0x038A3BF8, ISubsystemDescriptor);
DO_TYPEDEF(0x038A3B68, ISubsystem);
DO_TYPEDEF(0x0386C140, TerrainData);
DO_TYPEDEF(0x038704B8, Terrain__Array);
DO_TYPEDEF(0x03875750, Single__Array_1);
DO_TYPEDEF(0x038AD3D8, TerrainUtility_TerrainGroups);
DO_TYPEDEF(0x038AD468, TerrainUtility_TerrainMap);
DO_TYPEDEF(0x038AA1B8, Dictionary_2_UnityEngine_Experimental_TerrainAPI_TerrainUtility_TerrainMap_TileCoord_UnityEngine_Terrain_);
DO_TYPEDEF(0x038B5A88, TerrainUtility_TerrainMap_TerrainFilter);
DO_TYPEDEF(0x038B59F8, TerrainUtility_TerrainMap_c_DisplayClass4_0);
DO_TYPEDEF(0x038AD2C0, TerrainUtility_c_DisplayClass4_0);
DO_TYPEDEF(0x038AD348, TerrainUtility_c_DisplayClass4_1);
DO_TYPEDEF(0x03899870, GlyphRect);
DO_TYPEDEF(0x038997D8, GlyphMetrics);
DO_TYPEDEF(0x03899740, Glyph);
DO_TYPEDEF(0x03899908, GlyphValueRecord);
DO_TYPEDEF(0x038BAE80, List_1_UnityEngine_TextCore_GlyphRect_);
DO_TYPEDEF(0x0386C088, GlyphRect__Array);
DO_TYPEDEF(0x038C0400, List_1_System_UInt32_);
DO_TYPEDEF(0x0386BF68, Glyph__Array);
DO_TYPEDEF(0x0386BFF8, GlyphMarshallingStruct__Array);
DO_TYPEDEF(0x0387E5C0, YogaMeasureMode__Enum);
DO_TYPEDEF(0x038753F0, WWWForm);
DO_TYPEDEF(0x038B89F0, List_1_System_Byte__1);
DO_TYPEDEF(0x03872858, UnityWebRequest);
DO_TYPEDEF(0x0388B4E8, DownloadHandlerBuffer);
DO_TYPEDEF(0x03872D68, UploadHandlerRaw);
DO_TYPEDEF(0x038B23C8, NavMeshPath);
DO_TYPEDEF(0x038BD310, List_1_UnityEngine_AI_NavMeshBuildMarkup_);
DO_TYPEDEF(0x038B2068, NavMeshBuildMarkup);
DO_TYPEDEF(0x038BD3A0, List_1_UnityEngine_AI_NavMeshBuildSource_);
DO_TYPEDEF(0x038B20F8, NavMeshBuildSource);
DO_TYPEDEF(0x038B2188, NavMeshData);
DO_TYPEDEF(0x0389E8C0, NavMesh_OnNavMeshPreUpdate);
DO_TYPEDEF(0x03877200, AndroidJavaRunnable);
DO_TYPEDEF(0x03877038, AndroidJavaException);
DO_TYPEDEF(0x03899610, GlobalJavaObjectRef);
DO_TYPEDEF(0x03877168, AndroidJavaProxy);
DO_TYPEDEF(0x03877298, AndroidJavaRunnableProxy);
DO_TYPEDEF(0x038770D0, AndroidJavaObject);
DO_TYPEDEF(0x03876FA0, AndroidJavaClass);
DO_TYPEDEF(0x03869940, AndroidJavaObject__Array);
DO_TYPEDEF(0x03871868, jvalue__Array);
DO_TYPEDEF(0x03877920, AnimatorControllerPlayable);
DO_TYPEDEF(0x0388B770, Animation_Enumerator);
DO_TYPEDEF(0x0389C628, HumanBodyBones__Enum);
DO_TYPEDEF(0x0389C6C0, HumanPoseHandler);
DO_TYPEDEF(0x03877460, AnimationLayerMixerPlayable);
DO_TYPEDEF(0x038774F8, AnimationMixerPlayable);
DO_TYPEDEF(0x03877590, AnimationMotionXToDeltaPlayable);
DO_TYPEDEF(0x03877628, AnimationOffsetPlayable);
DO_TYPEDEF(0x038776C0, AnimationPosePlayable);
DO_TYPEDEF(0x03877758, AnimationRemoveScalePlayable);
DO_TYPEDEF(0x038777F0, AnimationScriptPlayable);
DO_TYPEDEF(0x038B1D98, NativeUpdateCallback);
DO_TYPEDEF(0x038B1C78, NativeInputUpdateType__Enum);
DO_TYPEDEF(0x038A07D0, Action_2_Int32_String_);
DO_TYPEDEF(0x038B7E58, ParticleSystem);
DO_TYPEDEF(0x038A2A28, ParticleSystem_MainModule);
DO_TYPEDEF(0x038A26C8, ParticleSystem_EmissionModule);
DO_TYPEDEF(0x038A2D88, ParticleSystem_ShapeModule);
DO_TYPEDEF(0x038A3178, ParticleSystem_VelocityOverLifetimeModule);
DO_TYPEDEF(0x038A2998, ParticleSystem_LimitVelocityOverLifetimeModule);
DO_TYPEDEF(0x038A2878, ParticleSystem_InheritVelocityModule);
DO_TYPEDEF(0x038A27E8, ParticleSystem_ForceOverLifetimeModule);
DO_TYPEDEF(0x038A2638, ParticleSystem_ColorOverLifetimeModule);
DO_TYPEDEF(0x038A25A8, ParticleSystem_ColorBySpeedModule);
DO_TYPEDEF(0x038A2E18, ParticleSystem_SizeBySpeedModule);
DO_TYPEDEF(0x038A2CF8, ParticleSystem_RotationOverLifetimeModule);
DO_TYPEDEF(0x038A2C68, ParticleSystem_RotationBySpeedModule);
DO_TYPEDEF(0x038A2758, ParticleSystem_ExternalForcesModule);
DO_TYPEDEF(0x038A2BD8, ParticleSystem_NoiseModule);
DO_TYPEDEF(0x038A2518, ParticleSystem_CollisionModule);
DO_TYPEDEF(0x038A30E8, ParticleSystem_TriggerModule);
DO_TYPEDEF(0x038A2F38, ParticleSystem_SubEmittersModule);
DO_TYPEDEF(0x038A2FC8, ParticleSystem_TextureSheetAnimationModule);
DO_TYPEDEF(0x038A2908, ParticleSystem_LightsModule);
DO_TYPEDEF(0x038A3058, ParticleSystem_TrailModule);
DO_TYPEDEF(0x038B81B8, ParticleSystemCurveMode__Enum);
DO_TYPEDEF(0x038A2AB8, ParticleSystem_MinMaxCurve);
DO_TYPEDEF(0x038B8240, ParticleSystemGradientMode__Enum);
DO_TYPEDEF(0x038A2B48, ParticleSystem_MinMaxGradient);
DO_TYPEDEF(0x038B8630, ParticleSystemSimulationSpace__Enum);
DO_TYPEDEF(0x038B8510, ParticleSystemScalingMode__Enum);
DO_TYPEDEF(0x038B85A0, ParticleSystemShapeType__Enum);
DO_TYPEDEF(0x038B8360, ParticleSystemMeshShapeType__Enum);
DO_TYPEDEF(0x038B8128, ParticleSystemCollisionType__Enum);
DO_TYPEDEF(0x038B8008, ParticleSystemCollisionMode__Enum);
DO_TYPEDEF(0x038B8098, ParticleSystemCollisionQuality__Enum);
DO_TYPEDEF(0x038B8480, ParticleSystemOverlapAction__Enum);
DO_TYPEDEF(0x038B7F78, ParticleSystemAnimationType__Enum);
DO_TYPEDEF(0x038B7EE8, ParticleSystemAnimationRowMode__Enum);
DO_TYPEDEF(0x03871898, UVChannelFlags__Enum);
DO_TYPEDEF(0x038B82D0, ParticleSystemInheritVelocityMode__Enum);
DO_TYPEDEF(0x038A2EA8, ParticleSystem_SizeOverLifetimeModule);
DO_TYPEDEF(0x038B83F0, ParticleSystemNoiseQuality__Enum);
DO_TYPEDEF(0x038B86C0, ParticleSystemTrailTextureMode__Enum);
DO_TYPEDEF(0x038BDA60, List_1_UnityEngine_ParticleCollisionEvent_);
DO_TYPEDEF(0x038B7D38, ParticleCollisionEvent);
DO_TYPEDEF(0x0386DE50, Mesh__Array);
DO_TYPEDEF(0x0386C0B8, TerrainCollider);
DO_TYPEDEF(0x038A3FE8, ITilemap);
DO_TYPEDEF(0x0386FB30, Sprite__Array);
DO_TYPEDEF(0x0387ED48, CanvasGroup);
DO_TYPEDEF(0x0387ECB0, Canvas);
DO_TYPEDEF(0x0388D0D0, Canvas_WillRenderCanvases);
DO_TYPEDEF(0x03876F08, AnalyticsSessionState__Enum);
DO_TYPEDEF(0x0388B450, DownloadHandlerAudioClip);
DO_TYPEDEF(0x03873668, VFXEventAttribute);
DO_TYPEDEF(0x03874948, VisualEffectAsset);
DO_TYPEDEF(0x038736F8, VFXExpressionValues);
DO_TYPEDEF(0x03873818, VFXSpawnerState);
DO_TYPEDEF(0x03873788, VFXOutputEventArgs);
DO_TYPEDEF(0x0389ABA0, InputTracking_TrackingStateEventType__Enum);
DO_TYPEDEF(0x038C1180, List_1_UnityEngine_XR_XRNodeState_);
DO_TYPEDEF(0x03879530, XRNodeState);
DO_TYPEDEF(0x0389B588, HapticCapabilities);
DO_TYPEDEF(0x038A6578, InputFeatureUsage);
DO_TYPEDEF(0x038A5DA8, InputDevice);
DO_TYPEDEF(0x038C0F40, List_1_UnityEngine_XR_XRInputSubsystem_);
DO_TYPEDEF(0x03879110, XRInputSubsystem);
DO_TYPEDEF(0x0389F7C8, Action_1_UnityEngine_XR_XRInputSubsystem_);
DO_TYPEDEF(0x038C0490, List_1_System_UInt64_);
DO_TYPEDEF(0x038A5EC8, InputDeviceCharacteristics__Enum);
DO_TYPEDEF(0x0389B458, Hand);
DO_TYPEDEF(0x03896018, Eyes);
DO_TYPEDEF(0x0387C350, Bone);
DO_TYPEDEF(0x038BBF60, List_1_UnityEngine_XR_InputDevice_);
DO_TYPEDEF(0x0389EB50, Action_1_UnityEngine_XR_InputDevice_);
DO_TYPEDEF(0x0386EF90, TrackingOriginModeFlags__Enum);
DO_TYPEDEF(0x038AE7C8, MeshId);
DO_TYPEDEF(0x038AE738, MeshGenerationStatus__Enum);
DO_TYPEDEF(0x038AEB28, MeshVertexAttributes__Enum);
DO_TYPEDEF(0x038AE6A8, MeshGenerationResult);
DO_TYPEDEF(0x0387AFB8, BigInteger_2);
DO_TYPEDEF(0x03877888, AnimationTriggers);
DO_TYPEDEF(0x03880F10, ColorBlock);
DO_TYPEDEF(0x038C5DA0, Selectable);
DO_TYPEDEF(0x0386F980, Selectable__Array);
DO_TYPEDEF(0x03899C98, Graphic);
DO_TYPEDEF(0x03874650, VertexHelper);
DO_TYPEDEF(0x03866D68, TweenRunner_1_ColorTween_);
DO_TYPEDEF(0x038B9BF0, List_1_UnityEngine_CanvasGroup_);
DO_TYPEDEF(0x0387A898, BaseEventData);
DO_TYPEDEF(0x038B0F90, MoveDirection__Enum);
DO_TYPEDEF(0x0387A178, AxisEventData);
DO_TYPEDEF(0x038951E0, EventSystem);
DO_TYPEDEF(0x038B9530, List_1_UnityEngine_EventSystems_BaseInputModule_);
DO_TYPEDEF(0x038BE510, List_1_UnityEngine_EventSystems_RaycastResult_);
DO_TYPEDEF(0x038BEC90, RaycastResult);
DO_TYPEDEF(0x03899D30, GraphicRaycaster);
DO_TYPEDEF(0x038BAF10, List_1_UnityEngine_UI_Graphic_);
DO_TYPEDEF(0x038A4D98, PointerEventData_InputButton__Enum);
DO_TYPEDEF(0x038BAFD0, PointerEventData);
DO_TYPEDEF(0x038A56C8, Dictionary_2_System_Int32_UnityEngine_EventSystems_PointerEventData_);
DO_TYPEDEF(0x038A4F48, PointerInputModule_MouseState);
DO_TYPEDEF(0x038C3BB0, List_1_UnityEngine_EventSystems_PointerInputModule_ButtonState_);
DO_TYPEDEF(0x038A4E28, PointerInputModule_ButtonState);
DO_TYPEDEF(0x038A4EB8, PointerInputModule_MouseButtonEventData);
DO_TYPEDEF(0x038BA730, List_1_UnityEngine_EventSystems_EventSystem_);
DO_TYPEDEF(0x038A2668, Comparison_1_UnityEngine_EventSystems_RaycastResult_);
DO_TYPEDEF(0x0388C9B8, Button_ButtonClickedEvent);
DO_TYPEDEF(0x0388C920, Button_OnFinishSubmit_d_9);
DO_TYPEDEF(0x0387EDE0, CanvasUpdateRegistry);
DO_TYPEDEF(0x038B6568, IndexedSet_1_UnityEngine_UI_ICanvasElement_);
DO_TYPEDEF(0x038BB150, List_1_UnityEngine_UI_ICanvasElement_);
DO_TYPEDEF(0x0389CFA8, ICanvasElement);
DO_TYPEDEF(0x038A4A68, Dictionary_2_UnityEngine_UI_ICanvasElement_System_Int32_);
DO_TYPEDEF(0x038A2398, Comparison_1_UnityEngine_UI_ICanvasElement_);
DO_TYPEDEF(0x038807F0, ClipperRegistry);
DO_TYPEDEF(0x038B65F8, IndexedSet_1_UnityEngine_UI_IClipper_);
DO_TYPEDEF(0x0389D760, IClipper);
DO_TYPEDEF(0x038A4AF8, Dictionary_2_UnityEngine_UI_IClipper_System_Int32_);
DO_TYPEDEF(0x038BE630, List_1_UnityEngine_UI_RectMask2D_);
DO_TYPEDEF(0x038BF500, RectangularVertexClipper);
DO_TYPEDEF(0x038B12B8, HashSet_1_UnityEngine_UI_MaskableGraphic_);
DO_TYPEDEF(0x038AD3A8, MaskableGraphic);
DO_TYPEDEF(0x0389CCE0, MaskableGraphic_CullStateChangedEvent);
DO_TYPEDEF(0x038B0ED8, HashSet_1_UnityEngine_UI_IClippable_);
DO_TYPEDEF(0x0389D6C8, IClippable);
DO_TYPEDEF(0x03891590, DefaultControls_IFactoryControls);
DO_TYPEDEF(0x0386C1D0, Text);
DO_TYPEDEF(0x03897860, FontData);
DO_TYPEDEF(0x038914F8, DefaultControls_DefaultRuntimeFactory);
DO_TYPEDEF(0x0388B6A8, Dropdown);
DO_TYPEDEF(0x03898930, Image_Type__Enum);
DO_TYPEDEF(0x03898898, Image_FillMethod__Enum);
DO_TYPEDEF(0x038A5038, Image);
DO_TYPEDEF(0x038BBC90, List_1_UnityEngine_UI_Image_);
DO_TYPEDEF(0x03892328, Dropdown_OptionDataList);
DO_TYPEDEF(0x038C2890, List_1_UnityEngine_UI_Dropdown_OptionData_);
DO_TYPEDEF(0x03892290, Dropdown_OptionData);
DO_TYPEDEF(0x038921F8, Dropdown_DropdownEvent);
DO_TYPEDEF(0x038C2800, List_1_UnityEngine_UI_Dropdown_DropdownItem_);
DO_TYPEDEF(0x038BFCB0, List_1_UnityEngine_UI_Toggle_);
DO_TYPEDEF(0x038B5248, IEnumerator_1_UnityEngine_UI_Toggle_);
DO_TYPEDEF(0x038AE388, Toggle_ToggleEvent);
DO_TYPEDEF(0x03866DF8, TweenRunner_1_FloatTween_);
DO_TYPEDEF(0x038920C8, Dropdown_c_DisplayClass63_0);
DO_TYPEDEF(0x03892160, Dropdown_DelayedDestroyDropdownList_d_75);
DO_TYPEDEF(0x038B5C68, IList_1_UnityEngine_UI_Graphic_);
DO_TYPEDEF(0x03895D50, GraphicRaycaster_c);
DO_TYPEDEF(0x038A2308, Comparison_1_UnityEngine_UI_Graphic_);
DO_TYPEDEF(0x03899DC8, GraphicRegistry);
DO_TYPEDEF(0x038A41F8, Dictionary_2_UnityEngine_Canvas_UnityEngine_UI_Collections_IndexedSet_1_);
DO_TYPEDEF(0x038B64D8, IndexedSet_1_UnityEngine_UI_Graphic_);
DO_TYPEDEF(0x038A4828, Dictionary_2_UnityEngine_UI_Graphic_System_Int32_);
DO_TYPEDEF(0x038B2038, ICollection_1_UnityEngine_UI_Graphic_);
DO_TYPEDEF(0x038A6608, InputField);
DO_TYPEDEF(0x0389A5B0, InputField_SubmitEvent);
DO_TYPEDEF(0x0389A480, InputField_OnChangeEvent);
DO_TYPEDEF(0x0389A518, InputField_OnValidateInput);
DO_TYPEDEF(0x03873758, InputField_ContentType__Enum__Array);
DO_TYPEDEF(0x0389A350, InputField_CaretBlink_d_161);
DO_TYPEDEF(0x0389A3E8, InputField_MouseDragOutsideRect_d_183);
DO_TYPEDEF(0x038BE6C0, List_1_UnityEngine_RectTransform_);
DO_TYPEDEF(0x0389B780, LayoutGroup_DelayedSetDirty_d_56);
DO_TYPEDEF(0x038A9E88, LayoutRebuilder);
DO_TYPEDEF(0x038C5110, ObjectPool_1_LayoutRebuilder_);
DO_TYPEDEF(0x038676F8, UnityAction_1_UnityEngine_UI_LayoutRebuilder_);
DO_TYPEDEF(0x03867428, UnityAction_1_UnityEngine_Component_);
DO_TYPEDEF(0x0389B818, LayoutRebuilder_c);
DO_TYPEDEF(0x038C53E0, Predicate_1_UnityEngine_Component_);
DO_TYPEDEF(0x038AE440, Func_2_UnityEngine_UI_ILayoutElement_Single_);
DO_TYPEDEF(0x038A12B8, ILayoutElement);
DO_TYPEDEF(0x0389B8B0, LayoutUtility_c);
DO_TYPEDEF(0x038BEA50, RawImage);
DO_TYPEDEF(0x038C55C0, ScrollRect);
DO_TYPEDEF(0x038A7318, Scrollbar_ScrollEvent);
DO_TYPEDEF(0x038A71F8, ScrollRect_ScrollRectEvent);
DO_TYPEDEF(0x038A7288, Scrollbar_ClickRepeat_d_58);
DO_TYPEDEF(0x038BEE10, List_1_UnityEngine_UI_Selectable_);
DO_TYPEDEF(0x038AAA78, Slider_SliderEvent);
DO_TYPEDEF(0x03868418, StencilOp__Enum);
DO_TYPEDEF(0x03881598, CompareFunction__Enum);
DO_TYPEDEF(0x03881170, ColorWriteMask__Enum);
DO_TYPEDEF(0x038AB5A8, StencilMaterial_MatEntry);
DO_TYPEDEF(0x038B3D78, IEnumerable_1_UnityEngine_UI_Toggle_);
DO_TYPEDEF(0x038AE410, ToggleGroup_c);
DO_TYPEDEF(0x038C5C50, Predicate_1_UnityEngine_UI_Toggle_);
DO_TYPEDEF(0x038AF6B8, Func_2_UnityEngine_UI_Toggle_Boolean_);
DO_TYPEDEF(0x038BF8F0, ReflectionMethodsCache);
DO_TYPEDEF(0x038A6368, ReflectionMethodsCache_Raycast3DCallback);
DO_TYPEDEF(0x038A63F8, ReflectionMethodsCache_RaycastAllCallback);
DO_TYPEDEF(0x038A6250, ReflectionMethodsCache_GetRaycastNonAllocCallback);
DO_TYPEDEF(0x038A62E0, ReflectionMethodsCache_Raycast2DCallback);
DO_TYPEDEF(0x038A6130, ReflectionMethodsCache_GetRayIntersectionAllCallback);
DO_TYPEDEF(0x038A61C0, ReflectionMethodsCache_GetRayIntersectionAllNonAllocCallback);
DO_TYPEDEF(0x0388D460, ColorTween_ColorTweenCallback);
DO_TYPEDEF(0x03867398, UnityAction_1_UnityEngine_Color_);
DO_TYPEDEF(0x03894CB8, FloatTween_FloatTweenCallback);
DO_TYPEDEF(0x03867938, UnityAction_1_System_Single_);
DO_TYPEDEF(0x038C29B0, List_1_UnityEngine_EventSystems_EventTrigger_Entry_);
DO_TYPEDEF(0x03894208, EventTrigger_TriggerEvent);
DO_TYPEDEF(0x038A2BA8, IPointerEnterHandler);
DO_TYPEDEF(0x038A2C38, IPointerExitHandler);
DO_TYPEDEF(0x038A2B18, IPointerDownHandler);
DO_TYPEDEF(0x038A2CC8, IPointerUpHandler);
DO_TYPEDEF(0x038A2A88, IPointerClickHandler);
DO_TYPEDEF(0x038A0218, IInitializePotentialDragHandler);
DO_TYPEDEF(0x0389CDE0, IBeginDragHandler);
DO_TYPEDEF(0x0389EE80, IDragHandler);
DO_TYPEDEF(0x0389F6D0, IEndDragHandler);
DO_TYPEDEF(0x0389EF18, IDropHandler);
DO_TYPEDEF(0x038A34A8, IScrollHandler);
DO_TYPEDEF(0x038A4468, IUpdateSelectedHandler);
DO_TYPEDEF(0x038A35C8, ISelectHandler);
DO_TYPEDEF(0x0389E9C0, IDeselectHandler);
DO_TYPEDEF(0x038A1EB8, IMoveHandler);
DO_TYPEDEF(0x038A3AD8, ISubmitHandler);
DO_TYPEDEF(0x0389CF10, ICancelHandler);
DO_TYPEDEF(0x038ABAD8, ExecuteEvents_EventFunction_1_IPointerEnterHandler_);
DO_TYPEDEF(0x038ABB68, ExecuteEvents_EventFunction_1_IPointerExitHandler_);
DO_TYPEDEF(0x038ABA48, ExecuteEvents_EventFunction_1_IPointerDownHandler_);
DO_TYPEDEF(0x038ABBF8, ExecuteEvents_EventFunction_1_IPointerUpHandler_);
DO_TYPEDEF(0x038AB9B8, ExecuteEvents_EventFunction_1_IPointerClickHandler_);
DO_TYPEDEF(0x038AB8A0, ExecuteEvents_EventFunction_1_IInitializePotentialDragHandler_);
DO_TYPEDEF(0x038AB548, ExecuteEvents_EventFunction_1_IBeginDragHandler_);
DO_TYPEDEF(0x038AB6F0, ExecuteEvents_EventFunction_1_IDragHandler_);
DO_TYPEDEF(0x038AB810, ExecuteEvents_EventFunction_1_IEndDragHandler_);
DO_TYPEDEF(0x038AB780, ExecuteEvents_EventFunction_1_IDropHandler_);
DO_TYPEDEF(0x038ABC88, ExecuteEvents_EventFunction_1_IScrollHandler_);
DO_TYPEDEF(0x038ABE38, ExecuteEvents_EventFunction_1_IUpdateSelectedHandler_);
DO_TYPEDEF(0x038ABD18, ExecuteEvents_EventFunction_1_ISelectHandler_);
DO_TYPEDEF(0x038AB668, ExecuteEvents_EventFunction_1_IDeselectHandler_);
DO_TYPEDEF(0x038AB928, ExecuteEvents_EventFunction_1_IMoveHandler_);
DO_TYPEDEF(0x038ABDA8, ExecuteEvents_EventFunction_1_ISubmitHandler_);
DO_TYPEDEF(0x038AB5D8, ExecuteEvents_EventFunction_1_ICancelHandler_);
DO_TYPEDEF(0x038943D0, ExecuteEvents_c);
DO_TYPEDEF(0x0389FB90, IEventSystemHandler);
DO_TYPEDEF(0x038B9650, List_1_UnityEngine_EventSystems_BaseRaycaster_);
DO_TYPEDEF(0x038A40A8, PhysicsRaycaster_RaycastHitComparer);
DO_TYPEDEF(0x0387D050, ByteArraySlice);
DO_TYPEDEF(0x0387D0E8, ByteArraySlicePool);
DO_TYPEDEF(0x038C7AA8, Stack_1_ExitGames_Client_Photon_ByteArraySlice_);
DO_TYPEDEF(0x038690D0, Stack_1_ExitGames_Client_Photon_ByteArraySlice___Array);
DO_TYPEDEF(0x038A68A0, Dictionary_2_System_Object_System_Object_);
DO_TYPEDEF(0x0389BA48, Hashtable_1);
DO_TYPEDEF(0x038B6D48, KeyValuePair_2_System_Object_System_Object_);
DO_TYPEDEF(0x038AB0C8, Dictionary_2_TKey_TValue_Enumerator_System_Object_System_Object_);
DO_TYPEDEF(0x03872A98, UnknownType);
DO_TYPEDEF(0x03893B50, EnetChannel);
DO_TYPEDEF(0x038C4B70, NonAllocDictionary_2_System_Int32_NCommand_);
DO_TYPEDEF(0x038B1498, NCommand);
DO_TYPEDEF(0x03868890, StreamBuffer);
DO_TYPEDEF(0x038B1528, NCommandPool);
DO_TYPEDEF(0x038C7D78, Stack_1_ExitGames_Client_Photon_NCommand_);
DO_TYPEDEF(0x038C6398, Queue_1_ExitGames_Client_Photon_NCommand_);
DO_TYPEDEF(0x038B1108, HashSet_1_System_Int32_);
DO_TYPEDEF(0x03882200, ConnectionProtocol__Enum);
DO_TYPEDEF(0x03882298, ConnectionStateValue__Enum);
DO_TYPEDEF(0x038B8C60, PeerBase);
DO_TYPEDEF(0x03893BE8, EnetPeer);
DO_TYPEDEF(0x0386B610, TargetFrameworks__Enum);
DO_TYPEDEF(0x038C6CC8, SerializationProtocol__Enum);
DO_TYPEDEF(0x038B9290, PhotonPeer);
DO_TYPEDEF(0x038A44C8, Dictionary_2_ExitGames_Client_Photon_ConnectionProtocol_System_Type_);
DO_TYPEDEF(0x038A28D8, IPhotonPeerListener);
DO_TYPEDEF(0x0389E728, Action_1_ExitGames_Client_Photon_DisconnectMessage_);
DO_TYPEDEF(0x0388A9A0, DisconnectMessage);
DO_TYPEDEF(0x038A3F28, Dictionary_2_System_Byte_System_Object_);
DO_TYPEDEF(0x038B69E8, KeyValuePair_2_System_Byte_System_Object_);
DO_TYPEDEF(0x038A4108, ITrafficRecorder);
DO_TYPEDEF(0x0386F0B0, TrafficStats);
DO_TYPEDEF(0x0386F140, TrafficStatsGameLevel);
DO_TYPEDEF(0x038A2848, IPhotonEncryptor);
DO_TYPEDEF(0x03889738, DeliveryMode__Enum);
DO_TYPEDEF(0x038C6070, SendOptions);
DO_TYPEDEF(0x038B7828, ParameterDictionary);
DO_TYPEDEF(0x038C4AE0, NonAllocDictionary_2_System_Byte_System_Object_);
DO_TYPEDEF(0x038693D0, StructWrapperPools);
DO_TYPEDEF(0x038772C8, WrappedType__Enum);
DO_TYPEDEF(0x03869340, StructWrapper);
DO_TYPEDEF(0x038C81F0, StructWrapper_1_System_Byte_);
DO_TYPEDEF(0x038691F0, StructWrapper_1_System_Byte___Array);
DO_TYPEDEF(0x038C8160, StructWrapper_1_System_Boolean_);
DO_TYPEDEF(0x03869160, StructWrapper_1_System_Boolean___Array);
DO_TYPEDEF(0x038A90F0, Dictionary_2_System_Type_ExitGames_Client_Photon_StructWrapping_StructWrapperPool_);
DO_TYPEDEF(0x038BB300, List_1_System_IDisposable_);
DO_TYPEDEF(0x038BC890, Protocol16);
DO_TYPEDEF(0x03894730, EventData);
DO_TYPEDEF(0x038B6A18, OperationResponse);
DO_TYPEDEF(0x038B6988, OperationRequest);
DO_TYPEDEF(0x038B94D0, PhotonSocketState__Enum);
DO_TYPEDEF(0x038A2968, IPhotonSocket);
DO_TYPEDEF(0x038C69C8, Queue_1_ExitGames_Client_Photon_PeerBase_MyAction_);
DO_TYPEDEF(0x038A3448, PeerBase_MyAction);
DO_TYPEDEF(0x038C6428, Queue_1_ExitGames_Client_Photon_StreamBuffer_);
DO_TYPEDEF(0x0389E598, ICryptoProvider);
DO_TYPEDEF(0x038B7378, LinkedList_1_ExitGames_Client_Photon_SimulationItem_);
DO_TYPEDEF(0x038C7D18, SimulationItem);
DO_TYPEDEF(0x038B27B8, NetworkSimulationSet);
DO_TYPEDEF(0x038BD1F0, List_1_ExitGames_Client_Photon_NCommand_);
DO_TYPEDEF(0x0386B310, EnetChannel__Array);
DO_TYPEDEF(0x038C6308, Queue_1_System_Int32_);
DO_TYPEDEF(0x03897D50, IPhotonSocket_c);
DO_TYPEDEF(0x038AE4D0, Func_2_System_Net_IPAddress_String_);
DO_TYPEDEF(0x038A3328, PeerBase_c_DisplayClass108_0);
DO_TYPEDEF(0x038A33B8, PeerBase_c_DisplayClass109_0);
DO_TYPEDEF(0x038B8CF0, PeerStateValue__Enum);
DO_TYPEDEF(0x038ABE08, SupportClass_IntegerMillisecondsDelegate);
DO_TYPEDEF(0x038C6D58, SerializeMethod);
DO_TYPEDEF(0x03889AC8, DeserializeMethod);
DO_TYPEDEF(0x038C6DE8, SerializeStreamMethod);
DO_TYPEDEF(0x03889B60, DeserializeStreamMethod);
DO_TYPEDEF(0x038846C0, CustomType);
DO_TYPEDEF(0x038BC800, Protocol);
DO_TYPEDEF(0x038A8B58, Dictionary_2_System_Type_ExitGames_Client_Photon_CustomType_);
DO_TYPEDEF(0x038A3E98, Dictionary_2_System_Byte_ExitGames_Client_Photon_CustomType_);
DO_TYPEDEF(0x038A88B8, InvalidDataException);
DO_TYPEDEF(0x038BC920, Protocol18);
DO_TYPEDEF(0x038A5728, Protocol18_GpType__Enum);
DO_TYPEDEF(0x0386FCE0, StructWrapper__Array);
DO_TYPEDEF(0x0386C350, Hashtable_1__Array);
DO_TYPEDEF(0x0386C860, IDictionary__Array);
DO_TYPEDEF(0x038AB128, SocketTcpAsync_ReceiveContext);
DO_TYPEDEF(0x038697C0, SupportClass);
DO_TYPEDEF(0x038ABE98, SupportClass_ThreadSafeRandom);
DO_TYPEDEF(0x038ABD78, SupportClass_c_DisplayClass6_0);
DO_TYPEDEF(0x038ABCE8, SupportClass_c);
DO_TYPEDEF(0x0386B2B8, TPeer);
DO_TYPEDEF(0x038BF290, List_1_ExitGames_Client_Photon_StreamBuffer_);
DO_TYPEDEF(0x03893A20, EncryptorNet);
DO_TYPEDEF(0x0388A578, DiffieHellmanCryptoProvider);
DO_TYPEDEF(0x03897EE8, FourCC);
DO_TYPEDEF(0x038A69F0, InputStateBlock);
DO_TYPEDEF(0x038A8798, InternedString);
DO_TYPEDEF(0x038BBB10, PrimitiveValue);
DO_TYPEDEF(0x038A5B68, InputControl);
DO_TYPEDEF(0x038A5FE8, InputDeviceDescription);
DO_TYPEDEF(0x038A5D18, InputDevice_1);
DO_TYPEDEF(0x0386EBA0, TrackedDevice);
DO_TYPEDEF(0x0386D790, InternedString__Array);
DO_TYPEDEF(0x0386D0D0, InputControl__Array);
DO_TYPEDEF(0x038A5F58, InputDeviceCommand);
DO_TYPEDEF(0x038A7A28, IntegerControl);
DO_TYPEDEF(0x038A68D0, InputProcessor);
DO_TYPEDEF(0x038A6310, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_System_Type_);
DO_TYPEDEF(0x0387A0E0, AxisDeadzoneProcessor);
DO_TYPEDEF(0x038B68C8, InputControl_1_System_Single_);
DO_TYPEDEF(0x0387A048, AxisControl);
DO_TYPEDEF(0x0387CF20, ButtonControl);
DO_TYPEDEF(0x03877A50, AnyKeyControl);
DO_TYPEDEF(0x03873E48, Vector2Control);
DO_TYPEDEF(0x0388B580, DpadControl);
DO_TYPEDEF(0x03878E18, XRControllerWithRumble);
DO_TYPEDEF(0x038A5930, InputActionType__Enum);
DO_TYPEDEF(0x038A5A48, InputBinding);
DO_TYPEDEF(0x038A54B8, InputAction);
DO_TYPEDEF(0x0386D040, InputBinding__Array);
DO_TYPEDEF(0x038A55D8, InputActionMap);
DO_TYPEDEF(0x038A5548, InputActionAsset);
DO_TYPEDEF(0x038A5C88, InputControlScheme);
DO_TYPEDEF(0x03899CC8, InputControlScheme_DeviceRequirement);
DO_TYPEDEF(0x038735A8, InputControlScheme_DeviceRequirement__Array);
DO_TYPEDEF(0x0386D160, InputControlScheme__Array);
DO_TYPEDEF(0x038A58A0, InputActionState);
DO_TYPEDEF(0x038A03E0, IInputInteraction);
DO_TYPEDEF(0x038A5AD8, InputBindingComposite);
DO_TYPEDEF(0x038990E8, InputActionState_GlobalState);
DO_TYPEDEF(0x0386BC98, GCHandle__Array);
DO_TYPEDEF(0x038A0868, Action_2_Object_UnityEngine_InputSystem_InputActionChange_);
DO_TYPEDEF(0x038A6458, InputEventPtr);
DO_TYPEDEF(0x038B3748, IEnumerable_1_UnityEngine_InputSystem_InputBinding_);
DO_TYPEDEF(0x038C6C08, ReadOnlyArray_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038B4AF8, IEnumerator_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038B4A68, IEnumerator_1_UnityEngine_InputSystem_InputControlScheme_);
DO_TYPEDEF(0x038B48B8, IEnumerator_1_UnityEngine_InputSystem_InputAction_);
DO_TYPEDEF(0x0386CFB0, InputAction__Array);
DO_TYPEDEF(0x0389FEE8, Action_1_UnityEngine_InputSystem_InputAction_CallbackContext_);
DO_TYPEDEF(0x038989C8, InputAction_CallbackContext);
DO_TYPEDEF(0x038C6B78, ReadOnlyArray_1_UnityEngine_InputSystem_InputBinding_);
DO_TYPEDEF(0x038B49D8, IEnumerator_1_UnityEngine_InputSystem_InputBinding_);
DO_TYPEDEF(0x038A5668, InputActionPhase__Enum);
DO_TYPEDEF(0x038C6AE8, ReadOnlyArray_1_UnityEngine_InputSystem_InputActionMap_);
DO_TYPEDEF(0x038B4948, IEnumerator_1_UnityEngine_InputSystem_InputActionMap_);
DO_TYPEDEF(0x038731B8, InputActionMap_BindingJson__Array);
DO_TYPEDEF(0x03873248, InputActionMap_ReadActionJson__Array);
DO_TYPEDEF(0x038732D8, InputActionMap_ReadMapJson__Array);
DO_TYPEDEF(0x03875620, InputControlScheme_SchemeJson_DeviceJson__Array);
DO_TYPEDEF(0x03873638, InputControlScheme_SchemeJson__Array);
DO_TYPEDEF(0x03898AF8, InputActionAsset_get_bindings_d_8);
DO_TYPEDEF(0x03898A60, InputActionAsset_GetEnumerator_d_31);
DO_TYPEDEF(0x038B36B8, IEnumerable_1_UnityEngine_InputSystem_InputActionMap_);
DO_TYPEDEF(0x03898C28, InputActionMap_BindingOverrideJson);
DO_TYPEDEF(0x03873368, InputActionMap_WriteActionJson__Array);
DO_TYPEDEF(0x03898D58, InputActionMap_WriteFileJson);
DO_TYPEDEF(0x038733F8, InputActionMap_WriteMapJson__Array);
DO_TYPEDEF(0x038A5788, InputActionReference);
DO_TYPEDEF(0x038A0348, IInputActionCollection2);
DO_TYPEDEF(0x038C2E30, List_1_UnityEngine_InputSystem_InputActionMap_BindingOverrideJson_);
DO_TYPEDEF(0x03898F20, InputActionRebindingExtensions_RebindingOperation);
DO_TYPEDEF(0x0389FF80, Action_1_UnityEngine_InputSystem_InputActionRebindingExtensions_RebindingOperation_);
DO_TYPEDEF(0x038A06A0, Action_2_UnityEngine_InputSystem_LowLevel_InputEventPtr_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038A6160, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_UnityEngine_InputSystem_Layouts_InputControlLayout_);
DO_TYPEDEF(0x038B6718, InlinedArray_1_InternedString_);
DO_TYPEDEF(0x038A5BF8, InputControlLayout);
DO_TYPEDEF(0x038C6C98, ReadOnlyArray_1_InternedString_);
DO_TYPEDEF(0x038C6DB8, ReadOnlyArray_1_NamedValue_);
DO_TYPEDEF(0x038C6D28, ReadOnlyArray_1_NameAndParameters_);
DO_TYPEDEF(0x038998A0, InputControlLayout_ControlItem);
DO_TYPEDEF(0x038B19A8, NamedValue);
DO_TYPEDEF(0x0386E120, NamedValue__Array);
DO_TYPEDEF(0x038B4DC8, IEnumerator_1_UnityEngine_InputSystem_Utilities_NamedValue_);
DO_TYPEDEF(0x038B15B8, NameAndParameters);
DO_TYPEDEF(0x038B4D38, IEnumerator_1_UnityEngine_InputSystem_Utilities_NameAndParameters_);
DO_TYPEDEF(0x03873488, InputControlLayout_ControlItem__Array);
DO_TYPEDEF(0x038A6280, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_System_String_);
DO_TYPEDEF(0x038A6048, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_System_Func_1_);
DO_TYPEDEF(0x038ACBA8, Func_1_UnityEngine_InputSystem_Layouts_InputControlLayout_);
DO_TYPEDEF(0x038A61F0, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_UnityEngine_InputSystem_Utilities_InternedString_);
DO_TYPEDEF(0x038A60D8, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_UnityEngine_InputSystem_Utilities_InternedString__1);
DO_TYPEDEF(0x038B1198, HashSet_1_UnityEngine_InputSystem_Utilities_InternedString_);
DO_TYPEDEF(0x038A6398, Dictionary_2_UnityEngine_InputSystem_Utilities_InternedString_UnityEngine_InputSystem_Layouts_InputControlLayout_Collection_PrecompiledLayout_);
DO_TYPEDEF(0x038ACC38, Func_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038C4930, List_1_UnityEngine_InputSystem_Layouts_InputControlLayout_Collection_LayoutMatcher_);
DO_TYPEDEF(0x038A6190, InputDeviceMatcher);
DO_TYPEDEF(0x038B4EB8, InputControlLayout_Collection_LayoutMatcher);
DO_TYPEDEF(0x038A4F78, Dictionary_2_UnityEngine_InputSystem_InputControl_System_Single_);
DO_TYPEDEF(0x03898E88, InputActionRebindingExtensions_DeferBindingResolutionWrapper);
DO_TYPEDEF(0x038B4D08, InputActionRebindingExtensions_RebindingOperation_c_DisplayClass32_0);
DO_TYPEDEF(0x03898DF0, InputActionRebindingExtensions_c_DisplayClass8_0);
DO_TYPEDEF(0x03898FB8, InputActionSetupExtensions_c_DisplayClass5_0);
DO_TYPEDEF(0x038BD280, List_1_UnityEngine_InputSystem_Utilities_NameAndParameters_);
DO_TYPEDEF(0x038BBD20, List_1_UnityEngine_InputSystem_InputAction_);
DO_TYPEDEF(0x03899050, InputActionState_c);
DO_TYPEDEF(0x03867038, SavedStructState_1_T_TypedRestore_UnityEngine_InputSystem_InputActionState_GlobalState_);
DO_TYPEDEF(0x038993E0, InputBinding_c);
DO_TYPEDEF(0x038AF248, Func_2_String_Boolean_);
DO_TYPEDEF(0x03899478, InputBindingComposite_GetPartNames_d_12);
DO_TYPEDEF(0x038B4168, IEnumerable_1_UnityEngine_InputSystem_InputBindingCompositeContext_PartBinding_);
DO_TYPEDEF(0x038995A8, InputBindingCompositeContext_PartBinding);
DO_TYPEDEF(0x03899510, InputBindingCompositeContext_get_controls_d_2);
DO_TYPEDEF(0x038B56C8, IEnumerator_1_UnityEngine_InputSystem_InputBindingCompositeContext_PartBinding_);
DO_TYPEDEF(0x03899D60, InputControlScheme_MatchResult);
DO_TYPEDEF(0x038B5188, InputControlScheme_MatchResult_Match);
DO_TYPEDEF(0x038B50F8, InputControlScheme_MatchResult_Enumerator);
DO_TYPEDEF(0x038A0AC8, Action_2_String_UnityEngine_InputSystem_InputControlLayoutChange_);
DO_TYPEDEF(0x038A0608, Action_2_UnityEngine_InputSystem_InputDevice_UnityEngine_InputSystem_InputDeviceChange_);
DO_TYPEDEF(0x038A6100, InputDeviceFindControlLayoutDelegate);
DO_TYPEDEF(0x038A6078, InputDeviceExecuteCommandDelegate);
DO_TYPEDEF(0x038BBFF0, List_1_UnityEngine_InputSystem_Layouts_InputDeviceDescription_);
DO_TYPEDEF(0x038A63C8, InputEventListener);
DO_TYPEDEF(0x0389A0F0, InputEventListener_ObserverState);
DO_TYPEDEF(0x038B6298, IObserver_1_UnityEngine_InputSystem_LowLevel_InputEventPtr_);
DO_TYPEDEF(0x038A6DD8, InputUpdateType__Enum);
DO_TYPEDEF(0x0389A8A8, InputSettings_UpdateMode__Enum);
DO_TYPEDEF(0x038B1618, HashSet_1_System_String_);
DO_TYPEDEF(0x038A6A78, InputStateBuffers);
DO_TYPEDEF(0x038A6338, InputEventBuffer);
DO_TYPEDEF(0x038A6840, InputManager);
DO_TYPEDEF(0x038A5368, Dictionary_2_System_Int32_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038B4B88, IEnumerator_1_UnityEngine_InputSystem_LowLevel_InputEventPtr_);
DO_TYPEDEF(0x038A0478, IInputRuntime);
DO_TYPEDEF(0x038A05A8, IInputStateChangeMonitor);
DO_TYPEDEF(0x03873878, InputManager_StateChangeMonitorsForDevice__Array);
DO_TYPEDEF(0x0389A810, InputRemoting_Subscriber);
DO_TYPEDEF(0x038B6328, IObserver_1_UnityEngine_InputSystem_InputRemoting_Message_);
DO_TYPEDEF(0x03873908, InputRemoting_RemoteInputDevice__Array);
DO_TYPEDEF(0x0389A778, InputRemoting_Message);
DO_TYPEDEF(0x0389AB08, InputSystem_c);
DO_TYPEDEF(0x038AE678, Func_2_UnityEngine_InputSystem_LowLevel_InputEventPtr_UnityEngine_InputSystem_InputControl_);
DO_TYPEDEF(0x038AE560, Func_2_UnityEngine_InputSystem_InputControl_Boolean_);
DO_TYPEDEF(0x038996D8, InputControlExtensions_InputEventControlEnumerator);
DO_TYPEDEF(0x03899640, InputControlExtensions_GetAllButtonPresses_d_43);
DO_TYPEDEF(0x03869610, Substring);
DO_TYPEDEF(0x038B67A8, InlinedArray_1_Substring_);
DO_TYPEDEF(0x03899C30, InputControlPath_ParsedPathComponent);
DO_TYPEDEF(0x038B5068, InputControlPath_ParsedPathComponent_c);
DO_TYPEDEF(0x038AF3F0, Func_2_UnityEngine_InputSystem_Utilities_Substring_String_);
DO_TYPEDEF(0x03899B00, InputControlPath_c);
DO_TYPEDEF(0x03899B98, InputControlPath_Parse_d_33);
DO_TYPEDEF(0x038991E8, Gamepad);
DO_TYPEDEF(0x038685C0, StickControl);
DO_TYPEDEF(0x038A92C8, Joystick);
DO_TYPEDEF(0x038A9988, Keyboard);
DO_TYPEDEF(0x038A96B8, KeyControl);
DO_TYPEDEF(0x0386D820, KeyControl__Array);
DO_TYPEDEF(0x038A1888, IMECompositionString);
DO_TYPEDEF(0x038BAF40, Pointer_2);
DO_TYPEDEF(0x038B0E78, Mouse);
DO_TYPEDEF(0x038B8D80, Pen);
DO_TYPEDEF(0x0388AA38, DiscreteButtonControl);
DO_TYPEDEF(0x0386E648, Touchscreen);
DO_TYPEDEF(0x0386E270, TouchControl);
DO_TYPEDEF(0x0386E420, TouchPressControl);
DO_TYPEDEF(0x0386E390, TouchPhaseControl);
DO_TYPEDEF(0x0386E300, TouchPhase__Enum_1);
DO_TYPEDEF(0x0388B288, DoubleControl);
DO_TYPEDEF(0x03870788, TouchControl__Array);
DO_TYPEDEF(0x038B53C8, InputRemoting_NewDeviceMsg_c);
DO_TYPEDEF(0x038AE8B8, Func_2_UnityEngine_InputSystem_Utilities_InternedString_String_);
DO_TYPEDEF(0x038B5338, InputRemoting_ChangeUsageMsg_c);
DO_TYPEDEF(0x038C0D30, RemoteInputPlayerConnection);
DO_TYPEDEF(0x0389F638, IEditorPlayerConnection);
DO_TYPEDEF(0x038A6758, RemoteInputPlayerConnection_Subscriber);
DO_TYPEDEF(0x03875E68, Accelerometer);
DO_TYPEDEF(0x0389A6B0, Gyroscope);
DO_TYPEDEF(0x0389A028, GravitySensor);
DO_TYPEDEF(0x03879630, AttitudeSensor);
DO_TYPEDEF(0x038AAF50, LinearAccelerationSensor);
DO_TYPEDEF(0x038ACB48, MagneticFieldSensor);
DO_TYPEDEF(0x038AAB68, LightSensor);
DO_TYPEDEF(0x038BB8D0, PressureSensor);
DO_TYPEDEF(0x038BCB60, ProximitySensor);
DO_TYPEDEF(0x0389C758, HumiditySensor);
DO_TYPEDEF(0x03876CA8, AmbientTemperatureSensor);
DO_TYPEDEF(0x038684A8, StepCounter);
DO_TYPEDEF(0x038B4D98, InputAnalytics_StartupEventData_DeviceInfo);
DO_TYPEDEF(0x0389A6E0, InputManager_ListControlLayouts_d_76);
DO_TYPEDEF(0x0389A648, InputManager_c);
DO_TYPEDEF(0x038AE5F0, Func_2_UnityEngine_InputSystem_InputDevice_String_);
DO_TYPEDEF(0x03888F80, DefaultInputActions);
DO_TYPEDEF(0x03891628, DefaultInputActions_IPlayerActions);
DO_TYPEDEF(0x038916C0, DefaultInputActions_IUIActions);
DO_TYPEDEF(0x038A6F88, InputValue);
DO_TYPEDEF(0x038A6E68, InputUser);
DO_TYPEDEF(0x038BA9A0, PlayerInput);
DO_TYPEDEF(0x03870E78, UIPointerType__Enum);
DO_TYPEDEF(0x038A6B98, InputSystemUIInputModule);
DO_TYPEDEF(0x038A4EE8, Dictionary_2_UnityEngine_InputSystem_InputAction_UnityEngine_InputSystem_UI_InputSystemUIInputModule_InputActionReferenceState_);
DO_TYPEDEF(0x03895BF0, ExtendedPointerEventData);
DO_TYPEDEF(0x038A49A8, PlayerInput_DeviceLostEvent);
DO_TYPEDEF(0x038A4A38, PlayerInput_DeviceRegainedEvent);
DO_TYPEDEF(0x038A4918, PlayerInput_ControlsChangedEvent);
DO_TYPEDEF(0x0389ACD0, InputUser_GlobalState);
DO_TYPEDEF(0x038A6EF8, InputUserAccountHandle);
DO_TYPEDEF(0x038A02B0, IInputActionCollection);
DO_TYPEDEF(0x038A1150, Action_3_UnityEngine_InputSystem_Users_InputUser_UnityEngine_InputSystem_Users_InputUserChange_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038A0570, Action_2_UnityEngine_InputSystem_InputControl_UnityEngine_InputSystem_LowLevel_InputEventPtr_);
DO_TYPEDEF(0x038B0288, Func_3_UnityEngine_InputSystem_InputDevice_UnityEngine_InputSystem_LowLevel_InputEventPtr_Boolean_);
DO_TYPEDEF(0x038BAA30, PlayerInputManager);
DO_TYPEDEF(0x038A4AC8, PlayerInputManager_PlayerJoinedEvent);
DO_TYPEDEF(0x038A4B58, PlayerInputManager_PlayerLeftEvent);
DO_TYPEDEF(0x03878FE0, XRFeatureDescriptor);
DO_TYPEDEF(0x03873278, UsageHint);
DO_TYPEDEF(0x03879368, XRLayoutBuilder);
DO_TYPEDEF(0x0386B9C8, FeatureType__Enum__Array);
DO_TYPEDEF(0x038B1E58, XRLayoutBuilder_c_DisplayClass5_0);
DO_TYPEDEF(0x0389AC38, InputUser_c);
DO_TYPEDEF(0x038670C8, SavedStructState_1_T_TypedRestore_UnityEngine_InputSystem_Users_InputUser_GlobalState_);
DO_TYPEDEF(0x03895B58, ExtendedAxisEventData);
DO_TYPEDEF(0x038B1378, MultiplayerEventSystem);
DO_TYPEDEF(0x0386EDE0, TrackedDeviceRaycaster);
DO_TYPEDEF(0x038C4270, List_1_UnityEngine_InputSystem_UI_TrackedDeviceRaycaster_RaycastHitData_);
DO_TYPEDEF(0x038AEBE8, TrackedDeviceRaycaster_RaycastHitData);
DO_TYPEDEF(0x038AEB58, TrackedDeviceRaycaster_c);
DO_TYPEDEF(0x038A2A58, Comparison_1_UnityEngine_InputSystem_UI_TrackedDeviceRaycaster_RaycastHitData_);
DO_TYPEDEF(0x038B61A8, OnScreenControl);
DO_TYPEDEF(0x038964F8, HID_UsagePage__Enum);
DO_TYPEDEF(0x03896298, HID_HIDDeviceDescriptor);
DO_TYPEDEF(0x0389A878, HID);
DO_TYPEDEF(0x03896330, HID_HIDElementDescriptor);
DO_TYPEDEF(0x03896208, HID_HIDCollectionDescriptor);
DO_TYPEDEF(0x038963C8, HID_HIDLayoutBuilder);
DO_TYPEDEF(0x038B4BE8, HID_HIDLayoutBuilder_c);
DO_TYPEDEF(0x038C5E00, Predicate_1_UnityEngine_InputSystem_HID_HID_HIDElementDescriptor_);
DO_TYPEDEF(0x038AFCE8, Func_2_UnityEngine_InputSystem_Layouts_InputControlLayout_ControlItem_String_);
DO_TYPEDEF(0x03899808, InputControlLayout_Builder);
DO_TYPEDEF(0x038C2AD0, List_1_UnityEngine_InputSystem_HID_HID_HIDElementDescriptor_);
DO_TYPEDEF(0x038C2A40, List_1_UnityEngine_InputSystem_HID_HID_HIDCollectionDescriptor_);
DO_TYPEDEF(0x03896170, HID_GenericDesktop__Enum);
DO_TYPEDEF(0x038960D8, HID_c_DisplayClass12_0);
DO_TYPEDEF(0x038C2B60, List_1_UnityEngine_InputSystem_HID_HIDParser_HIDReportData_);
DO_TYPEDEF(0x03896590, HIDParser_HIDReportData);
DO_TYPEDEF(0x038C6ED8, ReadOnlyArray_1_UnityEngine_InputSystem_HID_HIDSupport_HIDPageUsage_);
DO_TYPEDEF(0x03896628, HIDSupport_HIDPageUsage);
DO_TYPEDEF(0x03872948, HIDSupport_HIDPageUsage__Array);
DO_TYPEDEF(0x038973A0, Finger);
DO_TYPEDEF(0x038B6958, InputStateHistory_1_TouchState_);
DO_TYPEDEF(0x038A0018, Action_1_UnityEngine_InputSystem_LowLevel_InputStateHistory_Record_);
DO_TYPEDEF(0x0389AA70, InputStateHistory_Record);
DO_TYPEDEF(0x038B0948, Func_4_UnityEngine_InputSystem_InputControl_Double_UnityEngine_InputSystem_LowLevel_InputEventPtr_Boolean_);
DO_TYPEDEF(0x038B43A8, IEnumerator_1_UnityEngine_InputSystem_LowLevel_InputStateHistory_1_Record_);
DO_TYPEDEF(0x0386E1E0, Touch_1);
DO_TYPEDEF(0x038B6838, InlinedArray_1_UnityEngine_InputSystem_Touchscreen_);
DO_TYPEDEF(0x038AE768, Touch_GlobalState);
DO_TYPEDEF(0x038AE6D8, Touch_c);
DO_TYPEDEF(0x03867158, SavedStructState_1_T_TypedRestore_UnityEngine_InputSystem_EnhancedTouch_Touch_GlobalState_);
DO_TYPEDEF(0x038AE7F8, TouchHistory_Enumerator);
DO_TYPEDEF(0x0386E5C0, TouchSimulation);
DO_TYPEDEF(0x0386A1B0, ButtonControl__Array);
DO_TYPEDEF(0x0388B900, DualShockGamepad);
DO_TYPEDEF(0x03892588, DualSenseGamepadHID_DualSenseHIDMinimalInputReport);
DO_TYPEDEF(0x0388B870, DualSenseHIDInputReport);
DO_TYPEDEF(0x03891F98, DpadControl_DpadAxisControl);
DO_TYPEDEF(0x03897CB8, IMECompositionString_Enumerator);
DO_TYPEDEF(0x03899FC0, InputEventBuffer_Enumerator);
DO_TYPEDEF(0x0389A058, InputEventListener_DisposableObserver);
DO_TYPEDEF(0x038A64E8, InputEventTrace);
DO_TYPEDEF(0x0389A188, InputEventTrace_DeviceInfo);
DO_TYPEDEF(0x038736C8, InputEventTrace_DeviceInfo__Array);
DO_TYPEDEF(0x038B6688, InlinedArray_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x0389A2B8, InputEventTrace_ReplayController);
DO_TYPEDEF(0x0389A220, InputEventTrace_Enumerator);
DO_TYPEDEF(0x038BC080, List_1_UnityEngine_InputSystem_LowLevel_InputEventPtr_);
DO_TYPEDEF(0x038B5218, InputEventTrace_ReplayController_c);
DO_TYPEDEF(0x038A2548, Comparison_1_UnityEngine_InputSystem_LowLevel_InputEventPtr_);
DO_TYPEDEF(0x038B52A8, InputEventTrace_ReplayController_c_DisplayClass43_0);
DO_TYPEDEF(0x038A6D48, InputUpdateDelegate);
DO_TYPEDEF(0x038B1B58, NativeInputRuntime);
DO_TYPEDEF(0x0389EBE8, Action_1_UnityEngine_InputSystem_LowLevel_InputUpdateType_);
DO_TYPEDEF(0x038AE798, Func_2_UnityEngine_InputSystem_LowLevel_InputUpdateType_Boolean_);
DO_TYPEDEF(0x0389E828, NativeInputRuntime_c_DisplayClass7_0);
DO_TYPEDEF(0x0389E6F8, NativeInputRuntime_c_DisplayClass10_0);
DO_TYPEDEF(0x0389E790, NativeInputRuntime_c_DisplayClass13_0);
DO_TYPEDEF(0x0389A940, InputState_StateChangeMonitorDelegate);
DO_TYPEDEF(0x0389A9D8, InputStateHistory_Enumerator);
DO_TYPEDEF(0x03868650, StickDeadzoneProcessor);
DO_TYPEDEF(0x038C6F68, ReadOnlyArray_1_UnityEngine_InputSystem_Layouts_InputControlLayout_ControlItem_);
DO_TYPEDEF(0x038C2EC0, List_1_UnityEngine_InputSystem_Layouts_InputControlLayout_ControlItem_);
DO_TYPEDEF(0x038A82E8, Dictionary_2_System_String_UnityEngine_InputSystem_Layouts_InputControlLayout_ControlItem_);
DO_TYPEDEF(0x038B72B8, InputControlLayout_Builder_ControlBuilder_c);
DO_TYPEDEF(0x038AF2D8, Func_2_String_UnityEngine_InputSystem_Utilities_InternedString_);
DO_TYPEDEF(0x038999D0, InputControlLayout_LayoutJson);
DO_TYPEDEF(0x03899938, InputControlLayout_ControlItemJson);
DO_TYPEDEF(0x03873518, InputControlLayout_ControlItemJson__Array);
DO_TYPEDEF(0x038B4FD8, InputControlLayout_LayoutJson_c);
DO_TYPEDEF(0x038B4F48, InputControlLayout_ControlItemJson_c);
DO_TYPEDEF(0x038AEB88, Func_2_UnityEngine_InputSystem_Utilities_NamedValue_String_);
DO_TYPEDEF(0x038AEAF8, Func_2_UnityEngine_InputSystem_Utilities_NameAndParameters_String_);
DO_TYPEDEF(0x038B4E28, InputControlLayout_Collection_GetBaseLayouts_d_24);
DO_TYPEDEF(0x03899A68, InputControlLayout_LayoutNotFoundException);
DO_TYPEDEF(0x03899770, InputControlLayout_c);
DO_TYPEDEF(0x038A5E38, InputDeviceBuilder);
DO_TYPEDEF(0x038B3088, IEnumerable_1_KeyValuePair_2_System_String_System_Object_);
DO_TYPEDEF(0x03899F28, InputDeviceMatcher_get_patterns_d_4);
DO_TYPEDEF(0x03899E90, InputDeviceMatcher_c);
DO_TYPEDEF(0x038ADEA8, Func_2_Char_Boolean_);
DO_TYPEDEF(0x038B5638, IEnumerator_1_UnityEngine_InputSystem_Utilities_InputActionTrace_ActionEventPtr_);
DO_TYPEDEF(0x03899180, InputActionTrace_ActionEventPtr);
DO_TYPEDEF(0x03899218, InputActionTrace_Enumerator);
DO_TYPEDEF(0x038A9358, JsonParser);
DO_TYPEDEF(0x0389B2C0, JsonParser_JsonString);
DO_TYPEDEF(0x0389B358, JsonParser_JsonValue);
DO_TYPEDEF(0x038C3070, List_1_UnityEngine_InputSystem_Utilities_JsonParser_JsonValue_);
DO_TYPEDEF(0x038B54E8, JsonParser_JsonValue_c);
DO_TYPEDEF(0x038AFD78, Func_2_UnityEngine_InputSystem_Utilities_JsonParser_JsonValue_String_);
DO_TYPEDEF(0x038AD9A0, Func_2_System_Collections_Generic_KeyValuePair_2_String_);
DO_TYPEDEF(0x038B3988, IEnumerable_1_UnityEngine_InputSystem_Utilities_NameAndParameters_);
DO_TYPEDEF(0x0389E498, NameAndParameters_c);
DO_TYPEDEF(0x03897AC0, ForDeviceEventObservable);
DO_TYPEDEF(0x038B6208, IObservable_1_UnityEngine_InputSystem_LowLevel_InputEventPtr_);
DO_TYPEDEF(0x03894DE8, ForDeviceEventObservable_ForDevice);
DO_TYPEDEF(0x038AF360, Func_2_String_String_);
DO_TYPEDEF(0x038ABC58, StringHelpers_Tokenize_d_8);
DO_TYPEDEF(0x038ABBC8, StringHelpers_Split_d_9);
DO_TYPEDEF(0x038AF5F8, TypeTable_c);
DO_TYPEDEF(0x038AEC78, TrackedPoseDriver_TrackedPose__Enum);
DO_TYPEDEF(0x03880D48, Color2);
DO_TYPEDEF(0x0386F800, TweenCallback);
DO_TYPEDEF(0x03892DA8, EaseFunction);
DO_TYPEDEF(0x038ABD48, LogBehaviour__Enum);
DO_TYPEDEF(0x03884E70, DOTweenSettings);
DO_TYPEDEF(0x03890B78, DOTweenSettings_SafeModeOptions);
DO_TYPEDEF(0x03890AE0, DOTweenSettings_ModulesSetup);
DO_TYPEDEF(0x0386F770, Tween);
DO_TYPEDEF(0x038C6188, Sequence);
DO_TYPEDEF(0x038BFE60, List_1_DG_Tweening_Tween_);
DO_TYPEDEF(0x03870938, Tween__Array);
DO_TYPEDEF(0x038B8BA0, List_1_DG_Tweening_Core_ABSSequentiable_);
DO_TYPEDEF(0x038A3508, DOGetter_1_System_Single_);
DO_TYPEDEF(0x038A3AA8, DOSetter_1_System_Single_);
DO_TYPEDEF(0x03897730, FloatPlugin);
DO_TYPEDEF(0x0388B320, DoublePlugin);
DO_TYPEDEF(0x038A3358, DOGetter_1_System_Int32_);
DO_TYPEDEF(0x038A38F8, DOSetter_1_System_Int32_);
DO_TYPEDEF(0x038A7758, IntPlugin);
DO_TYPEDEF(0x03871E38, UintPlugin);
DO_TYPEDEF(0x038AC248, LongPlugin);
DO_TYPEDEF(0x03871EC8, UlongPlugin);
DO_TYPEDEF(0x038A3598, DOGetter_1_System_String_);
DO_TYPEDEF(0x038A3B38, DOSetter_1_System_String_);
DO_TYPEDEF(0x03868EC0, StringPlugin);
DO_TYPEDEF(0x038B9D10, List_1_System_Char_);
DO_TYPEDEF(0x038A3628, DOGetter_1_UnityEngine_Vector2_);
DO_TYPEDEF(0x038A3BC8, DOSetter_1_UnityEngine_Vector2_);
DO_TYPEDEF(0x03874088, Vector2Plugin);
DO_TYPEDEF(0x038A36B8, DOGetter_1_UnityEngine_Vector3_);
DO_TYPEDEF(0x038A3C58, DOSetter_1_UnityEngine_Vector3_);
DO_TYPEDEF(0x038742C8, Vector3Plugin);
DO_TYPEDEF(0x038A3748, DOGetter_1_UnityEngine_Vector4_);
DO_TYPEDEF(0x038A3CE8, DOSetter_1_UnityEngine_Vector4_);
DO_TYPEDEF(0x03874488, Vector4Plugin);
DO_TYPEDEF(0x03866E88, TweenerCore_3_UnityEngine_Quaternion_UnityEngine_Vector3_DG_Tweening_Plugins_Options_QuaternionOptions_);
DO_TYPEDEF(0x038A33E8, DOGetter_1_UnityEngine_Quaternion_);
DO_TYPEDEF(0x038A3988, DOSetter_1_UnityEngine_Quaternion_);
DO_TYPEDEF(0x038BD340, QuaternionPlugin);
DO_TYPEDEF(0x038A3238, DOGetter_1_UnityEngine_Color_);
DO_TYPEDEF(0x038A37D8, DOSetter_1_UnityEngine_Color_);
DO_TYPEDEF(0x038810D8, ColorPlugin);
DO_TYPEDEF(0x038A3478, DOGetter_1_UnityEngine_Rect_);
DO_TYPEDEF(0x038A3A18, DOSetter_1_UnityEngine_Rect_);
DO_TYPEDEF(0x038BF350, RectPlugin);
DO_TYPEDEF(0x03866F18, TweenerCore_3_UnityEngine_Vector3_UnityEngine_Vector3_DG_Tweening_Plugins_Options_Vector3ArrayOptions_);
DO_TYPEDEF(0x038741A8, Vector3ArrayPlugin);
DO_TYPEDEF(0x038A32C8, DOGetter_1_DG_Tweening_Color2_);
DO_TYPEDEF(0x038A3868, DOSetter_1_DG_Tweening_Color2_);
DO_TYPEDEF(0x03880DE0, Color2Plugin);
DO_TYPEDEF(0x03884CB0, DOTween);
DO_TYPEDEF(0x038BFEF0, List_1_DG_Tweening_TweenCallback_);
DO_TYPEDEF(0x0388E168, DOTween_c_DisplayClass66_0);
DO_TYPEDEF(0x03890C10, DOVirtual_c_DisplayClass0_0);
DO_TYPEDEF(0x03890CA8, DOVirtual_c_DisplayClass1_0);
DO_TYPEDEF(0x03890D40, DOVirtual_c_DisplayClass2_0);
DO_TYPEDEF(0x03890DD8, DOVirtual_c_DisplayClass3_0);
DO_TYPEDEF(0x03893758, EaseFactory_c_DisplayClass2_0);
DO_TYPEDEF(0x038BCFE0, PureQuaternionPlugin);
DO_TYPEDEF(0x038B8AB0, PathOptions);
DO_TYPEDEF(0x03866FA8, TweenerCore_3_UnityEngine_Vector3_DG_Tweening_Plugins_Core_PathCore_Path_DG_Tweening_Plugins_Options_PathOptions_);
DO_TYPEDEF(0x038B8870, Path_1);
DO_TYPEDEF(0x0387F2A0, CatmullRomDecoder);
DO_TYPEDEF(0x03883DE0, CubicBezierDecoder);
DO_TYPEDEF(0x0386AA20, ControlPoint__Array);
DO_TYPEDEF(0x038AAFD8, LinearDecoder);
DO_TYPEDEF(0x038A79C8, ShortcutExtensions_c_DisplayClass0_0);
DO_TYPEDEF(0x038A7FE8, ShortcutExtensions_c_DisplayClass1_0);
DO_TYPEDEF(0x038A8618, ShortcutExtensions_c_DisplayClass2_0);
DO_TYPEDEF(0x038A8C48, ShortcutExtensions_c_DisplayClass3_0);
DO_TYPEDEF(0x038A91D8, ShortcutExtensions_c_DisplayClass4_0);
DO_TYPEDEF(0x038A9778, ShortcutExtensions_c_DisplayClass5_0);
DO_TYPEDEF(0x038A9DA0, ShortcutExtensions_c_DisplayClass6_0);
DO_TYPEDEF(0x038AA2A8, ShortcutExtensions_c_DisplayClass7_0);
DO_TYPEDEF(0x038AA338, ShortcutExtensions_c_DisplayClass8_0);
DO_TYPEDEF(0x038AA3C8, ShortcutExtensions_c_DisplayClass9_0);
DO_TYPEDEF(0x038A7A58, ShortcutExtensions_c_DisplayClass10_0);
DO_TYPEDEF(0x038A7AE8, ShortcutExtensions_c_DisplayClass11_0);
DO_TYPEDEF(0x038A7B78, ShortcutExtensions_c_DisplayClass12_0);
DO_TYPEDEF(0x038A7C08, ShortcutExtensions_c_DisplayClass13_0);
DO_TYPEDEF(0x038A7C90, ShortcutExtensions_c_DisplayClass14_0);
DO_TYPEDEF(0x038A7D20, ShortcutExtensions_c_DisplayClass15_0);
DO_TYPEDEF(0x038A7DB0, ShortcutExtensions_c_DisplayClass16_0);
DO_TYPEDEF(0x038A7E40, ShortcutExtensions_c_DisplayClass17_0);
DO_TYPEDEF(0x038A7EC8, ShortcutExtensions_c_DisplayClass18_0);
DO_TYPEDEF(0x038A7F58, ShortcutExtensions_c_DisplayClass19_0);
DO_TYPEDEF(0x038A8078, ShortcutExtensions_c_DisplayClass20_0);
DO_TYPEDEF(0x038A8108, ShortcutExtensions_c_DisplayClass21_0);
DO_TYPEDEF(0x038A8198, ShortcutExtensions_c_DisplayClass22_0);
DO_TYPEDEF(0x038A8228, ShortcutExtensions_c_DisplayClass23_0);
DO_TYPEDEF(0x038A82B8, ShortcutExtensions_c_DisplayClass24_0);
DO_TYPEDEF(0x038A8348, ShortcutExtensions_c_DisplayClass25_0);
DO_TYPEDEF(0x038A83D8, ShortcutExtensions_c_DisplayClass26_0);
DO_TYPEDEF(0x038A8468, ShortcutExtensions_c_DisplayClass27_0);
DO_TYPEDEF(0x038A84F8, ShortcutExtensions_c_DisplayClass28_0);
DO_TYPEDEF(0x038A8588, ShortcutExtensions_c_DisplayClass29_0);
DO_TYPEDEF(0x038A86A8, ShortcutExtensions_c_DisplayClass30_0);
DO_TYPEDEF(0x038A8738, ShortcutExtensions_c_DisplayClass31_0);
DO_TYPEDEF(0x038A87C8, ShortcutExtensions_c_DisplayClass32_0);
DO_TYPEDEF(0x038A8858, ShortcutExtensions_c_DisplayClass33_0);
DO_TYPEDEF(0x038A88E8, ShortcutExtensions_c_DisplayClass34_0);
DO_TYPEDEF(0x038A8978, ShortcutExtensions_c_DisplayClass35_0);
DO_TYPEDEF(0x038A8A08, ShortcutExtensions_c_DisplayClass36_0);
DO_TYPEDEF(0x038A8A98, ShortcutExtensions_c_DisplayClass37_0);
DO_TYPEDEF(0x038A8B28, ShortcutExtensions_c_DisplayClass38_0);
DO_TYPEDEF(0x038A8BB8, ShortcutExtensions_c_DisplayClass39_0);
DO_TYPEDEF(0x038A8CD8, ShortcutExtensions_c_DisplayClass40_0);
DO_TYPEDEF(0x038A8D68, ShortcutExtensions_c_DisplayClass41_0);
DO_TYPEDEF(0x038A8DF8, ShortcutExtensions_c_DisplayClass42_0);
DO_TYPEDEF(0x038A8E88, ShortcutExtensions_c_DisplayClass43_0);
DO_TYPEDEF(0x038A8F18, ShortcutExtensions_c_DisplayClass44_0);
DO_TYPEDEF(0x038A8FA0, ShortcutExtensions_c_DisplayClass45_0);
DO_TYPEDEF(0x038A9030, ShortcutExtensions_c_DisplayClass46_0);
DO_TYPEDEF(0x038A90C0, ShortcutExtensions_c_DisplayClass47_0);
DO_TYPEDEF(0x038A9150, ShortcutExtensions_c_DisplayClass48_0);
DO_TYPEDEF(0x038A9268, ShortcutExtensions_c_DisplayClass51_0);
DO_TYPEDEF(0x038A92F8, ShortcutExtensions_c_DisplayClass52_0);
DO_TYPEDEF(0x038A9388, ShortcutExtensions_c_DisplayClass53_0);
DO_TYPEDEF(0x038A9418, ShortcutExtensions_c_DisplayClass54_0);
DO_TYPEDEF(0x038A94A8, ShortcutExtensions_c_DisplayClass55_0);
DO_TYPEDEF(0x038A9538, ShortcutExtensions_c_DisplayClass56_0);
DO_TYPEDEF(0x038A95C8, ShortcutExtensions_c_DisplayClass57_0);
DO_TYPEDEF(0x038A9658, ShortcutExtensions_c_DisplayClass58_0);
DO_TYPEDEF(0x038A96E8, ShortcutExtensions_c_DisplayClass59_0);
DO_TYPEDEF(0x038A9808, ShortcutExtensions_c_DisplayClass60_0);
DO_TYPEDEF(0x038A9898, ShortcutExtensions_c_DisplayClass61_0);
DO_TYPEDEF(0x038A9928, ShortcutExtensions_c_DisplayClass62_0);
DO_TYPEDEF(0x038A99B8, ShortcutExtensions_c_DisplayClass63_0);
DO_TYPEDEF(0x038A9A48, ShortcutExtensions_c_DisplayClass64_0);
DO_TYPEDEF(0x038A9AD8, ShortcutExtensions_c_DisplayClass65_0);
DO_TYPEDEF(0x038A9B60, ShortcutExtensions_c_DisplayClass66_0);
DO_TYPEDEF(0x038A9BF0, ShortcutExtensions_c_DisplayClass67_0);
DO_TYPEDEF(0x038A9C80, ShortcutExtensions_c_DisplayClass68_0);
DO_TYPEDEF(0x038A9D10, ShortcutExtensions_c_DisplayClass69_0);
DO_TYPEDEF(0x038A9E28, ShortcutExtensions_c_DisplayClass70_0);
DO_TYPEDEF(0x038A9EB8, ShortcutExtensions_c_DisplayClass71_0);
DO_TYPEDEF(0x038A9F48, ShortcutExtensions_c_DisplayClass72_0);
DO_TYPEDEF(0x038A9FD8, ShortcutExtensions_c_DisplayClass73_0);
DO_TYPEDEF(0x038AA068, ShortcutExtensions_c_DisplayClass74_0);
DO_TYPEDEF(0x038AA0F8, ShortcutExtensions_c_DisplayClass75_0);
DO_TYPEDEF(0x038AA188, ShortcutExtensions_c_DisplayClass76_0);
DO_TYPEDEF(0x038AA218, ShortcutExtensions_c_DisplayClass77_0);
DO_TYPEDEF(0x0386F9B0, TweenParams);
DO_TYPEDEF(0x038BF2C0, RectOffsetPlugin);
DO_TYPEDEF(0x0388E590, DOTweenComponent_WaitForCompletion_d_17);
DO_TYPEDEF(0x0388E7E8, DOTweenComponent_WaitForRewind_d_18);
DO_TYPEDEF(0x0388E6C0, DOTweenComponent_WaitForKill_d_19);
DO_TYPEDEF(0x0388E628, DOTweenComponent_WaitForElapsedLoops_d_20);
DO_TYPEDEF(0x0388E758, DOTweenComponent_WaitForPosition_d_21);
DO_TYPEDEF(0x0388E880, DOTweenComponent_WaitForStart_d_22);
DO_TYPEDEF(0x038A11E8, Action_4_DG_Tweening_Plugins_Options_PathOptions_DG_Tweening_Tween_UnityEngine_Quaternion_UnityEngine_Transform_);
DO_TYPEDEF(0x038C6218, SequenceCallback);
DO_TYPEDEF(0x0386F890, TweenLink);
DO_TYPEDEF(0x038937F0, EaseManager_c);
DO_TYPEDEF(0x03892D10, EaseCurve);
DO_TYPEDEF(0x03879AF0, AuthModeOption__Enum);
DO_TYPEDEF(0x03877FA8, AppSettings);
DO_TYPEDEF(0x03882168, ConnectionHandler);
DO_TYPEDEF(0x03893988, EncryptionMode__Enum);
DO_TYPEDEF(0x038C4D20, Nullable_1_ExitGames_Client_Photon_ConnectionProtocol_);
DO_TYPEDEF(0x038B9440, PhotonPortDefinition);
DO_TYPEDEF(0x038C6F08, ServerConnection__Enum);
DO_TYPEDEF(0x03880628, ClientState__Enum);
DO_TYPEDEF(0x0388A908, DisconnectCause__Enum);
DO_TYPEDEF(0x038AB578, LoadBalancingClient);
DO_TYPEDEF(0x038AB608, LoadBalancingPeer);
DO_TYPEDEF(0x038C51A0, Pool_1_ParameterDictionary_);
DO_TYPEDEF(0x038AD028, Func_1_ExitGames_Client_Photon_ParameterDictionary_);
DO_TYPEDEF(0x0389F270, Action_1_ExitGames_Client_Photon_ParameterDictionary_);
DO_TYPEDEF(0x038AB720, LobbyType__Enum);
DO_TYPEDEF(0x03870968, TypedLobby);
DO_TYPEDEF(0x03893D18, EnterRoomParams);
DO_TYPEDEF(0x038C2290, RoomOptions);
DO_TYPEDEF(0x038B6238, OpJoinRandomRoomParams);
DO_TYPEDEF(0x03884590, CustomAuthenticationType__Enum);
DO_TYPEDEF(0x03879D50, AuthenticationValues);
DO_TYPEDEF(0x038BE5D0, RaiseEventOptions);
DO_TYPEDEF(0x038762C0, WebFlags);
DO_TYPEDEF(0x038A4438, Dictionary_2_ExitGames_Client_Photon_ConnectionProtocol_System_Int32_);
DO_TYPEDEF(0x038A0310, Action_2_Photon_Realtime_ClientState_Photon_Realtime_ClientState_);
DO_TYPEDEF(0x0389E7C0, Action_1_ExitGames_Client_Photon_EventData_);
DO_TYPEDEF(0x0389F1D8, Action_1_ExitGames_Client_Photon_OperationResponse_);
DO_TYPEDEF(0x038BB1E0, List_1_Photon_Realtime_IConnectionCallbacks_);
DO_TYPEDEF(0x038820D0, ConnectionCallbacksContainer);
DO_TYPEDEF(0x0389DCB8, IConnectionCallbacks);
DO_TYPEDEF(0x038C0820, RegionHandler);
DO_TYPEDEF(0x038BE900, List_1_Photon_Realtime_Region_);
DO_TYPEDEF(0x038C0790, Region_1);
DO_TYPEDEF(0x038BE990, List_1_Photon_Realtime_RegionPinger_);
DO_TYPEDEF(0x038C0940, RegionPinger);
DO_TYPEDEF(0x0389F308, Action_1_Photon_Realtime_Region_);
DO_TYPEDEF(0x038B9320, PhotonPing);
DO_TYPEDEF(0x0389F3A0, Action_1_Photon_Realtime_RegionHandler_);
DO_TYPEDEF(0x038BB660, List_1_Photon_Realtime_IMatchmakingCallbacks_);
DO_TYPEDEF(0x038AD678, MatchMakingCallbacksContainer);
DO_TYPEDEF(0x038A19A8, IMatchmakingCallbacks);
DO_TYPEDEF(0x038BABB0, List_1_Photon_Realtime_FriendInfo_);
DO_TYPEDEF(0x03897F80, FriendInfo);
DO_TYPEDEF(0x038BB4B0, List_1_Photon_Realtime_IInRoomCallbacks_);
DO_TYPEDEF(0x038A51E8, InRoomCallbacksContainer);
DO_TYPEDEF(0x038A0180, IInRoomCallbacks);
DO_TYPEDEF(0x038BA760, Player);
DO_TYPEDEF(0x038C2200, RoomInfo);
DO_TYPEDEF(0x038C2170, Room);
DO_TYPEDEF(0x038A5638, Dictionary_2_System_Int32_Photon_Realtime_Player_);
DO_TYPEDEF(0x0386E8C0, Player__Array);
DO_TYPEDEF(0x038BB5D0, List_1_Photon_Realtime_ILobbyCallbacks_);
DO_TYPEDEF(0x038AB690, LobbyCallbacksContainer);
DO_TYPEDEF(0x038A1648, ILobbyCallbacks);
DO_TYPEDEF(0x038BECF0, List_1_Photon_Realtime_RoomInfo_);
DO_TYPEDEF(0x038C0130, List_1_Photon_Realtime_TypedLobbyInfo_);
DO_TYPEDEF(0x038709F8, TypedLobbyInfo);
DO_TYPEDEF(0x038BB810, List_1_Photon_Realtime_IWebRpcCallback_);
DO_TYPEDEF(0x038768B0, WebRpcCallbacksContainer);
DO_TYPEDEF(0x038A46A8, IWebRpcCallback);
DO_TYPEDEF(0x038BB420, List_1_Photon_Realtime_IErrorInfoCallback_);
DO_TYPEDEF(0x03894308, ErrorInfoCallbacksContainer);
DO_TYPEDEF(0x0389F9C8, IErrorInfoCallback);
DO_TYPEDEF(0x03894270, ErrorInfo);
DO_TYPEDEF(0x038C6818, Queue_1_Photon_Realtime_LoadBalancingClient_CallbackTargetChange_);
DO_TYPEDEF(0x0389C658, LoadBalancingClient_CallbackTargetChange);
DO_TYPEDEF(0x038B1468, HashSet_1_System_Object_);
DO_TYPEDEF(0x038B3AA8, IEnumerable_1_System_Object_);
DO_TYPEDEF(0x0389C6F0, LoadBalancingPeer_c);
DO_TYPEDEF(0x038BA010, PingMono);
DO_TYPEDEF(0x038A65A8, RegionHandler_c);
DO_TYPEDEF(0x038A26F8, Comparison_1_Photon_Realtime_Region_);
DO_TYPEDEF(0x038A6638, RegionHandler_c_DisplayClass23_0);
DO_TYPEDEF(0x038A66C8, RegionPinger_RegionPingCoroutine_d_19);
DO_TYPEDEF(0x03885B10, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A);
DO_TYPEDEF(0x03875B78, ARTrackablesParentTransformChangedEventArgs);
DO_TYPEDEF(0x038795C8, XROrigin);
DO_TYPEDEF(0x0389E560, Action_1_Unity_XR_CoreUtils_ARTrackablesParentTransformChangedEventArgs_);
DO_TYPEDEF(0x038BEB40, List_1_UnityEngine_Renderer_);
DO_TYPEDEF(0x038AF748, Func_2_Type_Boolean_);
DO_TYPEDEF(0x038BA970, List_1_System_Reflection_FieldInfo_);
DO_TYPEDEF(0x038B4798, IEnumerator_1_System_Reflection_FieldInfo_);
DO_TYPEDEF(0x038BE240, List_1_System_Reflection_PropertyInfo_);
DO_TYPEDEF(0x038B5008, IEnumerator_1_System_Reflection_PropertyInfo_);
DO_TYPEDEF(0x038B3E08, IEnumerable_1_System_Type_);
DO_TYPEDEF(0x038AF4E0, TypeExtensions_c_DisplayClass2_0);
DO_TYPEDEF(0x0389E8F0, Action_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x03895768, GameObjectUtils_c_DisplayClass20_0);
DO_TYPEDEF(0x038B8B10, List_1_System_Type__1);
DO_TYPEDEF(0x038B8188, List_1_Dictionary_2_System_String_System_Type_);
DO_TYPEDEF(0x0389F730, Action_1_Type_);
DO_TYPEDEF(0x038C54A0, ScriptableSettingsBase);
DO_TYPEDEF(0x038C6698, SerializableGuid);
DO_TYPEDEF(0x038B1F78, XROrigin_RepeatInitializeCamera_d_47);
DO_TYPEDEF(0x03879078, XRGeneralSettings);
DO_TYPEDEF(0x038C10F0, List_1_UnityEngine_XR_Management_XRLoader_);
DO_TYPEDEF(0x038BAFA0, List_1_UnityEngine_Rendering_GraphicsDeviceType_);
DO_TYPEDEF(0x038B1858, HashSet_1_UnityEngine_XR_Management_XRLoader_);
DO_TYPEDEF(0x038A8D98, Dictionary_2_System_Type_UnityEngine_ISubsystem_);
DO_TYPEDEF(0x038B1EE8, XRManagerSettings_InitializeLoader_d_24);
DO_TYPEDEF(0x03880FA8, ColorComparison__Enum);
DO_TYPEDEF(0x038BC380, ProtectedFloat);
DO_TYPEDEF(0x038BC410, ProtectedInt16);
DO_TYPEDEF(0x038BC4A0, ProtectedInt32);
DO_TYPEDEF(0x038BC530, ProtectedInt64);
DO_TYPEDEF(0x038BC5C0, ProtectedString);
DO_TYPEDEF(0x038BC650, ProtectedUInt16);
DO_TYPEDEF(0x038BC6E0, ProtectedUInt32);
DO_TYPEDEF(0x038BC770, ProtectedUInt64);
DO_TYPEDEF(0x038965F8, FieldCheatDetector);
DO_TYPEDEF(0x038B6118, OnFieldCheatDetected);
DO_TYPEDEF(0x0389B6B8, HapticException);
DO_TYPEDEF(0x0388B0C0, DotPoint);
DO_TYPEDEF(0x038B8B40, PathPoint);
DO_TYPEDEF(0x038BB3C0, PositionType__Enum);
DO_TYPEDEF(0x0389B750, HapticFeedback);
DO_TYPEDEF(0x038964C8, FeedbackMode__Enum);
DO_TYPEDEF(0x038BA6D0, PlaybackType__Enum);
DO_TYPEDEF(0x038B8A20, PathMovingPattern__Enum);
DO_TYPEDEF(0x038C23B0, RotationOption);
DO_TYPEDEF(0x038C4B10, ScaleOption);
DO_TYPEDEF(0x038A8EE8, JSONNode);
DO_TYPEDEF(0x038A8D38, JSONArray);
DO_TYPEDEF(0x038BC500, List_1_Bhaptics_Tact_JSONNode_);
DO_TYPEDEF(0x038A74F8, Dictionary_2_System_String_Bhaptics_Tact_JSONNode_);
DO_TYPEDEF(0x038A9090, JSONObject);
DO_TYPEDEF(0x038A9120, JSONString);
DO_TYPEDEF(0x038A9000, JSONNumber);
DO_TYPEDEF(0x038A8DC8, JSONBool);
DO_TYPEDEF(0x038A8F70, JSONNull);
DO_TYPEDEF(0x038A8E58, JSONLazyCreator);
DO_TYPEDEF(0x0387FEA8, u0A66u0A73u0A71u0A6Du0A67u0A68u0A6Du0A74u0A6Eu0A74u0A65);
DO_TYPEDEF(0x038B2FC8, u0A66u0A73u0A71u0A6Du0A67u0A68u0A6Du0A74u0A6Eu0A74u0A65_u0A6Fu0A6Bu0A6Du0A71u0A6Bu0A6Fu0A6Du0A67u0A66u0A73u0A69);
DO_TYPEDEF(0x038756B8, Double__Array_1);
DO_TYPEDEF(0x03886DF8, u0A70u0A65u0A66u0A74u0A73u0A65u0A68u0A74u0A65u0A65u0A6D);
DO_TYPEDEF(0x03882950, u0A6Au0A69u0A72u0A67u0A6Du0A6Bu0A6Bu0A66u0A6Bu0A67u0A6F);
DO_TYPEDEF(0x03883070, u0A6Au0A74u0A71u0A6Cu0A6Eu0A66u0A6Du0A72u0A65u0A70u0A66);
DO_TYPEDEF(0x0386DCD0, TokenSet);
DO_TYPEDEF(0x0389F568, Action_1_String_);
DO_TYPEDEF(0x0388AC98, DissonanceComms);
DO_TYPEDEF(0x03884B18, u0A6Du0A73u0A6Du0A72u0A71u0A70u0A70u0A65u0A68u0A69u0A6E);
DO_TYPEDEF(0x03882EA8, u0A6Au0A72u0A6Bu0A6Du0A69u0A6Eu0A6Au0A72u0A70u0A74u0A65);
DO_TYPEDEF(0x0387F498, u0A65u0A73u0A69u0A6Bu0A6Eu0A65u0A6Bu0A6Au0A65u0A70u0A68);
DO_TYPEDEF(0x038C1330, List_1_u0A65u0A73u0A69u0A6Bu0A6Eu0A65u0A6Bu0A6Au0A65u0A70u0A68_);
DO_TYPEDEF(0x03884238, u0A6Cu0A71u0A69u0A73u0A69u0A72u0A6Cu0A6Cu0A6Au0A68u0A73);
DO_TYPEDEF(0x03882FD8, u0A6Au0A73u0A73u0A68u0A6Fu0A72u0A6Au0A72u0A6Bu0A74u0A6B);
DO_TYPEDEF(0x038885A0, u0A71u0A6Fu0A68u0A72u0A6Eu0A70u0A68u0A6Au0A6Au0A67u0A67);
DO_TYPEDEF(0x038878A0, u0A70u0A70u0A73u0A6Au0A67u0A70u0A6Au0A6Fu0A6Bu0A6Bu0A6C);
DO_TYPEDEF(0x03868980, u0A6Eu0A6Eu0A65u0A66u0A6Au0A6Cu0A74u0A6Eu0A70u0A6Bu0A67_u0A71u0A6Fu0A68u0A72u0A6Eu0A70u0A68u0A6Au0A6Au0A67u0A67_);
DO_TYPEDEF(0x038AD498, Func_1_u0A71u0A6Fu0A68u0A72u0A6Eu0A70u0A68u0A6Au0A6Au0A67u0A67_);
DO_TYPEDEF(0x038A0D28, Action_2_String_u0A71u0A6Fu0A68u0A72u0A6Eu0A70u0A68u0A6Au0A6Au0A67u0A67_);
DO_TYPEDEF(0x03886190, u0A6Fu0A66u0A70u0A67u0A6Au0A68u0A69u0A6Cu0A6Bu0A6Eu0A6B);
DO_TYPEDEF(0x0388A8A0, u0A74u0A68u0A73u0A6Fu0A71u0A6Eu0A69u0A6Fu0A68u0A71u0A74);
DO_TYPEDEF(0x038811A0, u0A68u0A67u0A6Du0A6Bu0A72u0A6Fu0A6Fu0A74u0A6Du0A67u0A6F);
DO_TYPEDEF(0x038AD528, Func_1_u0A73u0A71u0A65u0A70u0A65u0A65u0A70u0A69u0A67u0A74u0A6D_);
DO_TYPEDEF(0x0388A180, u0A73u0A71u0A65u0A70u0A65u0A65u0A70u0A69u0A67u0A74u0A6D);
DO_TYPEDEF(0x0389F990, Action_1_u0A67u0A66u0A68u0A74u0A68u0A6Cu0A67u0A73u0A74u0A65u0A6E_);
DO_TYPEDEF(0x0387F958, u0A66u0A69u0A6Eu0A6Eu0A72u0A6Fu0A6Au0A66u0A69u0A6Eu0A67__Enum);
DO_TYPEDEF(0x03880230, u0A67u0A66u0A68u0A74u0A68u0A6Cu0A67u0A73u0A74u0A65u0A6E);
DO_TYPEDEF(0x03886228, u0A6Fu0A67u0A6Cu0A6Eu0A6Au0A6Cu0A6Fu0A72u0A6Au0A6Du0A65);
DO_TYPEDEF(0x03884BB0, u0A6Du0A73u0A72u0A69u0A72u0A6Eu0A6Bu0A69u0A66u0A6Bu0A6A);
DO_TYPEDEF(0x038A7E70, Dictionary_2_System_String_u0A6Au0A69u0A66u0A6Eu0A66u0A74u0A73u0A65u0A66u0A66u0A6E_);
DO_TYPEDEF(0x038828B8, u0A6Au0A69u0A66u0A6Eu0A66u0A74u0A73u0A65u0A66u0A66u0A6E);
DO_TYPEDEF(0x038836F8, u0A6Bu0A6Cu0A6Fu0A6Au0A6Fu0A67u0A73u0A74u0A6Eu0A69u0A6A);
DO_TYPEDEF(0x038A7DE0, Dictionary_2_System_String_u0A65u0A6Eu0A67u0A6Au0A6Du0A74u0A73u0A70u0A70u0A6Du0A66_);
DO_TYPEDEF(0x0387F238, u0A65u0A6Eu0A67u0A6Au0A6Du0A74u0A73u0A70u0A70u0A6Du0A66);
DO_TYPEDEF(0x0389F860, Action_1_u0A65u0A6Eu0A67u0A6Au0A6Du0A74u0A73u0A70u0A70u0A6Du0A66_);
DO_TYPEDEF(0x038A0F88, Action_2_u0A65u0A6Eu0A67u0A6Au0A6Du0A74u0A73u0A70u0A70u0A6Du0A66_String_);
DO_TYPEDEF(0x03881238, u0A68u0A67u0A70u0A70u0A65u0A72u0A67u0A65u0A74u0A67u0A65);
DO_TYPEDEF(0x03880490, u0A67u0A67u0A74u0A6Au0A70u0A67u0A67u0A65u0A66u0A6Fu0A68);
DO_TYPEDEF(0x0387F108, u0A65u0A6Cu0A6Fu0A73u0A66u0A70u0A74u0A66u0A73u0A67u0A73);
DO_TYPEDEF(0x03880FD8, u0A68u0A65u0A66u0A6Cu0A6Cu0A6Du0A6Cu0A70u0A73u0A6Cu0A70);
DO_TYPEDEF(0x03880A80, u0A67u0A6Eu0A6Au0A66u0A74u0A6Bu0A6Cu0A71u0A72u0A6Au0A6A);
DO_TYPEDEF(0x038C1C30, List_1_u0A6Eu0A68u0A6Du0A69u0A74u0A68u0A6Fu0A6Bu0A70u0A69u0A6D_);
DO_TYPEDEF(0x03885060, u0A6Eu0A68u0A6Du0A69u0A74u0A68u0A6Fu0A6Bu0A70u0A69u0A6D);
DO_TYPEDEF(0x038C12A0, List_1_u0A65u0A6Eu0A67u0A6Au0A6Du0A74u0A73u0A70u0A70u0A6Du0A66_);
DO_TYPEDEF(0x038C7358, ReadOnlyCollection_1_u0A65u0A6Eu0A67u0A6Au0A6Du0A74u0A73u0A70u0A70u0A6Du0A66_);
DO_TYPEDEF(0x0388A218, u0A73u0A71u0A6Cu0A71u0A73u0A6Cu0A6Cu0A72u0A6Fu0A6Eu0A69);
DO_TYPEDEF(0x038688F0, u0A6Eu0A6Eu0A65u0A66u0A6Au0A6Cu0A74u0A6Eu0A70u0A6Bu0A67_Dissonance_Audio_Playback_VoicePlayback_);
DO_TYPEDEF(0x038AD378, Func_1_Dissonance_Audio_Playback_VoicePlayback_);
DO_TYPEDEF(0x03886488, u0A6Fu0A69u0A69u0A73u0A6Du0A71u0A6Bu0A6Eu0A69u0A66u0A6E__Enum);
DO_TYPEDEF(0x03881FD0, u0A69u0A6Au0A65u0A72u0A73u0A73u0A72u0A73u0A65u0A6Du0A6C);
DO_TYPEDEF(0x038879C8, u0A70u0A71u0A6Au0A68u0A71u0A70u0A74u0A6Cu0A6Cu0A66u0A74);
DO_TYPEDEF(0x03874F38, VoicePlayback);
DO_TYPEDEF(0x03889FB8, u0A73u0A6Eu0A68u0A67u0A69u0A6Du0A67u0A68u0A6Du0A73u0A6A);
DO_TYPEDEF(0x038C6668, Queue_1_u0A67u0A68u0A6Au0A74u0A66u0A73u0A73u0A69u0A6Fu0A65u0A6D_);
DO_TYPEDEF(0x038860F8, u0A6Fu0A66u0A68u0A70u0A65u0A72u0A69u0A6Eu0A6Cu0A70u0A73);
DO_TYPEDEF(0x03880528, u0A67u0A68u0A6Au0A74u0A66u0A73u0A73u0A69u0A6Fu0A65u0A6D);
DO_TYPEDEF(0x038805C0, u0A67u0A68u0A6Eu0A72u0A6Au0A73u0A65u0A70u0A6Du0A67u0A71);
DO_TYPEDEF(0x038866E0, u0A6Fu0A6Eu0A6Cu0A6Eu0A72u0A6Bu0A6Eu0A6Fu0A6Eu0A6Cu0A70);
DO_TYPEDEF(0x03880BB0, u0A67u0A72u0A69u0A68u0A66u0A70u0A6Eu0A73u0A67u0A6Au0A6C);
DO_TYPEDEF(0x038826F0, u0A6Au0A65u0A6Bu0A70u0A66u0A6Eu0A6Bu0A6Du0A6Eu0A71u0A65);
DO_TYPEDEF(0x03886810, u0A6Fu0A6Fu0A69u0A73u0A6Fu0A73u0A72u0A72u0A6Au0A69u0A6D);
DO_TYPEDEF(0x0389FC88, Action_1_u0A6Fu0A6Fu0A69u0A73u0A6Fu0A73u0A72u0A72u0A6Au0A69u0A6D_);
DO_TYPEDEF(0x038681A8, u0A68u0A69u0A6Au0A6Bu0A6Eu0A6Bu0A6Fu0A6Eu0A68u0A6Fu0A70_u0A73u0A72u0A73u0A74u0A68u0A67u0A6Fu0A65u0A66u0A6Eu0A69_);
DO_TYPEDEF(0x0388A348, u0A73u0A72u0A73u0A74u0A68u0A67u0A6Fu0A65u0A66u0A6Eu0A69);
DO_TYPEDEF(0x03868B30, u0A73u0A72u0A65u0A6Du0A72u0A74u0A6Au0A65u0A6Bu0A70u0A73_System_Byte_);
DO_TYPEDEF(0x038AC848, Func_1_Byte_);
DO_TYPEDEF(0x038686B0, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Int32_);
DO_TYPEDEF(0x03868AA0, u0A73u0A72u0A65u0A6Du0A72u0A74u0A6Au0A65u0A6Bu0A70u0A73_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x038AC698, Func_1_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x038819E8, u0A68u0A71u0A66u0A72u0A70u0A72u0A66u0A69u0A68u0A69u0A6E);
DO_TYPEDEF(0x03886D60, u0A6Fu0A74u0A6Du0A65u0A73u0A6Eu0A71u0A6Bu0A72u0A6Eu0A6C);
DO_TYPEDEF(0x03867F68, u0A66u0A71u0A68u0A6Du0A70u0A72u0A6Fu0A73u0A6Fu0A67u0A69_u0A73u0A72u0A73u0A74u0A68u0A67u0A6Fu0A65u0A66u0A6Eu0A69_);
DO_TYPEDEF(0x0389FDB8, Action_1_u0A73u0A72u0A73u0A74u0A68u0A67u0A6Fu0A65u0A66u0A6Eu0A69_);
DO_TYPEDEF(0x03887938, u0A70u0A71u0A67u0A72u0A6Eu0A6Au0A6Au0A6Au0A6Bu0A6Cu0A6B);
DO_TYPEDEF(0x038806F0, u0A67u0A69u0A73u0A67u0A6Fu0A66u0A66u0A71u0A67u0A69u0A6F);
DO_TYPEDEF(0x03883660, u0A6Bu0A6Cu0A6Eu0A72u0A6Du0A74u0A72u0A6Bu0A74u0A6Du0A73);
DO_TYPEDEF(0x03867ED8, u0A65u0A6Eu0A70u0A6Du0A6Eu0A72u0A6Eu0A6Du0A70u0A68u0A72_u0A70u0A65u0A66u0A74u0A73u0A65u0A68u0A74u0A65u0A65u0A6D_);
DO_TYPEDEF(0x03867E48, u0A65u0A6Eu0A70u0A6Du0A6Eu0A72u0A6Eu0A6Du0A70u0A68u0A72_u0A66u0A71u0A67u0A68u0A68u0A6Cu0A6Cu0A6Bu0A68u0A6Du0A6D_);
DO_TYPEDEF(0x03868478, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x03887050, u0A70u0A67u0A74u0A6Au0A6Au0A6Bu0A65u0A74u0A74u0A68u0A67);
DO_TYPEDEF(0x03888638, u0A71u0A6Fu0A69u0A6Au0A74u0A67u0A73u0A6Cu0A6Bu0A66u0A71);
DO_TYPEDEF(0x0388B220, u0A74u0A74u0A6Bu0A70u0A65u0A74u0A74u0A71u0A6Cu0A6Du0A6B);
DO_TYPEDEF(0x038C4960, SamplePlaybackComponent);
DO_TYPEDEF(0x03888340, u0A71u0A6Bu0A72u0A67u0A73u0A6Fu0A6Cu0A6Bu0A6Au0A72u0A72);
DO_TYPEDEF(0x03889340, u0A72u0A70u0A6Fu0A70u0A68u0A66u0A6Fu0A65u0A66u0A6Fu0A73__Enum);
DO_TYPEDEF(0x0388A0E8, u0A73u0A70u0A6Fu0A65u0A71u0A73u0A66u0A67u0A69u0A66u0A6D__Enum);
DO_TYPEDEF(0x03887348, u0A70u0A6Au0A70u0A66u0A6Eu0A74u0A67u0A74u0A71u0A6Au0A69);
DO_TYPEDEF(0x03887180, u0A70u0A69u0A65u0A72u0A74u0A6Au0A6Du0A69u0A72u0A73u0A73);
DO_TYPEDEF(0x038845C0, u0A6Du0A6Au0A6Au0A66u0A6Au0A68u0A6Au0A6Fu0A69u0A6Fu0A65);
DO_TYPEDEF(0x03883FD8, u0A6Cu0A6Du0A6Au0A71u0A6Eu0A6Au0A71u0A67u0A67u0A6Du0A6E);
DO_TYPEDEF(0x0387EF40, u0A65u0A69u0A6Fu0A69u0A6Cu0A69u0A72u0A6Bu0A70u0A67u0A74);
DO_TYPEDEF(0x0387F368, u0A65u0A70u0A69u0A73u0A6Bu0A70u0A6Du0A67u0A6Bu0A68u0A66);
DO_TYPEDEF(0x03881498, u0A68u0A6Au0A67u0A70u0A6Bu0A70u0A72u0A72u0A71u0A6Fu0A66);
DO_TYPEDEF(0x03889508, u0A72u0A71u0A66u0A74u0A69u0A6Du0A65u0A68u0A74u0A71u0A66);
DO_TYPEDEF(0x03868740, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_u0A68u0A6Fu0A69u0A67u0A68u0A68u0A66u0A69u0A72u0A6Au0A6C_);
DO_TYPEDEF(0x038818C0, u0A68u0A6Fu0A69u0A67u0A68u0A68u0A66u0A69u0A72u0A6Au0A6C);
DO_TYPEDEF(0x03882CE0, u0A6Au0A6Cu0A69u0A6Bu0A6Au0A68u0A6Cu0A73u0A66u0A65u0A71);
DO_TYPEDEF(0x03868118, u0A68u0A69u0A6Au0A6Bu0A6Eu0A6Bu0A6Fu0A6Eu0A68u0A6Fu0A70_System_Single_);
DO_TYPEDEF(0x03889AF8, u0A73u0A6Au0A73u0A68u0A6Du0A65u0A6Cu0A71u0A74u0A6Au0A6D);
DO_TYPEDEF(0x0388A3E0, u0A73u0A74u0A67u0A73u0A6Bu0A68u0A69u0A6Du0A6Bu0A72u0A65);
DO_TYPEDEF(0x03883A80, u0A6Bu0A73u0A6Du0A68u0A74u0A71u0A6Au0A6Cu0A74u0A66u0A6C);
DO_TYPEDEF(0x038C1D50, List_1_u0A6Eu0A6Eu0A68u0A73u0A69u0A6Fu0A74u0A6Eu0A6Au0A6Eu0A67_);
DO_TYPEDEF(0x038852C0, u0A6Eu0A6Eu0A68u0A73u0A69u0A6Fu0A74u0A6Eu0A6Au0A6Eu0A67);
DO_TYPEDEF(0x038C1840, List_1_u0A6Au0A67u0A72u0A65u0A6Fu0A69u0A66u0A69u0A6Bu0A65u0A71_);
DO_TYPEDEF(0x03882788, u0A6Au0A67u0A72u0A65u0A6Fu0A69u0A66u0A69u0A6Bu0A65u0A71);
DO_TYPEDEF(0x038C07F0, List_1_Dissonance_Audio_Playback_VoicePlayback_);
DO_TYPEDEF(0x038C5E30, SemanticVersion);
DO_TYPEDEF(0x03875100, VolumeFaderSettings);
DO_TYPEDEF(0x038B3718, u0A6Cu0A71u0A69u0A73u0A69u0A72u0A6Cu0A6Cu0A6Au0A68u0A73_c);
DO_TYPEDEF(0x038B3EF8, u0A6Fu0A66u0A70u0A67u0A6Au0A68u0A69u0A6Cu0A6Bu0A6Eu0A6B_c);
DO_TYPEDEF(0x03891B70, DissonanceComms_u0A65u0A67u0A6Du0A69u0A72u0A6Au0A6Eu0A73u0A68u0A73u0A72);
DO_TYPEDEF(0x038868A0, u0A6Fu0A6Fu0A6Fu0A67u0A71u0A65u0A6Cu0A70u0A71u0A72u0A6B);
DO_TYPEDEF(0x03880820, u0A67u0A6Cu0A65u0A6Du0A74u0A6Au0A6Au0A69u0A73u0A72u0A66__Enum);
DO_TYPEDEF(0x038850F8, u0A6Eu0A6Bu0A69u0A69u0A69u0A71u0A6Fu0A6Eu0A6Fu0A67u0A6E__Enum);
DO_TYPEDEF(0x03887F18, u0A71u0A68u0A6Bu0A70u0A69u0A72u0A70u0A67u0A69u0A71u0A74);
DO_TYPEDEF(0x03885520, u0A6Eu0A6Fu0A70u0A68u0A67u0A6Cu0A68u0A6Eu0A6Fu0A66u0A65);
DO_TYPEDEF(0x03869C10, AudioClip__Array);
DO_TYPEDEF(0x03889D58, u0A73u0A6Cu0A68u0A71u0A6Du0A6Bu0A66u0A65u0A69u0A6Fu0A73);
DO_TYPEDEF(0x03889898, u0A72u0A74u0A70u0A72u0A70u0A70u0A74u0A6Eu0A6Eu0A68u0A68);
DO_TYPEDEF(0x03882A80, u0A6Au0A6Bu0A66u0A6Cu0A70u0A72u0A6Au0A71u0A71u0A6Cu0A74);
DO_TYPEDEF(0x03882068, u0A69u0A6Au0A6Cu0A68u0A65u0A6Eu0A66u0A69u0A71u0A6Eu0A6F);
DO_TYPEDEF(0x03868358, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Collections_Generic_List_1__1);
DO_TYPEDEF(0x03868500, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Collections_Generic_List_1__2);
DO_TYPEDEF(0x0387FCE8, u0A66u0A71u0A71u0A69u0A72u0A6Eu0A67u0A6Au0A6Fu0A65u0A66__Enum);
DO_TYPEDEF(0x03883B18, u0A6Cu0A65u0A71u0A70u0A73u0A6Bu0A72u0A6Eu0A6Eu0A74u0A6C__Enum);
DO_TYPEDEF(0x038B47F8, u0A72u0A74u0A70u0A72u0A70u0A70u0A74u0A6Eu0A6Eu0A68u0A68_u0A73u0A70u0A69u0A69u0A67u0A6Fu0A68u0A66u0A67u0A68u0A6E);
DO_TYPEDEF(0x03867DB8, u0A65u0A6Eu0A70u0A6Du0A6Eu0A72u0A6Eu0A6Du0A70u0A68u0A72_System_IntPtr_);
DO_TYPEDEF(0x038BE1B0, List_1_System_ComponentModel_PropertyChangedEventHandler_);
DO_TYPEDEF(0x038B4768, u0A72u0A74u0A70u0A72u0A70u0A70u0A74u0A6Eu0A6Eu0A68u0A68_u0A67u0A69u0A67u0A6Du0A71u0A70u0A6Fu0A6Cu0A66u0A72u0A73);
DO_TYPEDEF(0x038C6788, Queue_1_Dissonance_Demo_ChatLogController_u0A6Fu0A6Du0A72u0A70u0A66u0A69u0A6Du0A70u0A6Au0A6Du0A67_);
DO_TYPEDEF(0x0388D298, ChatLogController_u0A6Fu0A6Du0A72u0A70u0A66u0A69u0A6Du0A70u0A6Au0A6Du0A67);
DO_TYPEDEF(0x0388D200, ChatInputController_c);
DO_TYPEDEF(0x038AE708, Func_2_UnityEngine_UI_InputField_Boolean_);
DO_TYPEDEF(0x03882658, u0A69u0A74u0A73u0A6Du0A65u0A6Fu0A66u0A69u0A67u0A69u0A70);
DO_TYPEDEF(0x03881660, u0A68u0A6Bu0A6Cu0A73u0A6Du0A65u0A6Du0A72u0A70u0A67u0A6F);
DO_TYPEDEF(0x0389DA88, MicSubscriberPlayer_u0A67u0A65u0A6Au0A69u0A6Cu0A73u0A6Cu0A71u0A6Du0A6Eu0A6A);
DO_TYPEDEF(0x0389DB20, MicSubscriberPlayer_u0A6Eu0A74u0A65u0A6Au0A68u0A65u0A6Du0A69u0A6Eu0A67u0A68);
DO_TYPEDEF(0x038AB3F8, SpeakerIndicator_u0A6Cu0A71u0A66u0A68u0A71u0A6Fu0A74u0A69u0A6Eu0A6Eu0A65);
DO_TYPEDEF(0x038AEE28, TriggerVisualizer_c);
DO_TYPEDEF(0x038ADCF8, Func_2_Dissonance_BaseCommsTrigger_Boolean_);
DO_TYPEDEF(0x03887510, u0A70u0A6Cu0A6Eu0A66u0A70u0A70u0A6Bu0A69u0A6Du0A6Fu0A73);
DO_TYPEDEF(0x038C0370, List_1_System_UInt16_);
DO_TYPEDEF(0x038C1720, List_1_u0A68u0A68u0A69u0A73u0A6Cu0A70u0A6Du0A6Au0A69u0A71u0A6C_);
DO_TYPEDEF(0x038812D0, u0A68u0A68u0A69u0A73u0A6Cu0A70u0A6Du0A6Au0A69u0A71u0A6C);
DO_TYPEDEF(0x038B4138, u0A70u0A6Cu0A6Eu0A66u0A70u0A70u0A6Bu0A69u0A6Du0A6Fu0A73_c);
DO_TYPEDEF(0x038B0558, Func_3_String_Int32_System_Collections_Generic_KeyValuePair_2_);
DO_TYPEDEF(0x038ADB48, Func_2_System_Collections_Generic_KeyValuePair_2_Boolean_);
DO_TYPEDEF(0x03881B18, u0A68u0A72u0A69u0A68u0A73u0A73u0A74u0A72u0A6Du0A67u0A74__Enum);
DO_TYPEDEF(0x03883498, u0A6Bu0A69u0A6Au0A72u0A67u0A6Bu0A71u0A69u0A6Fu0A6Eu0A6E);
DO_TYPEDEF(0x038A6C88, Dictionary_2_System_String_List_1_System_UInt16_);
DO_TYPEDEF(0x038838C0, u0A6Bu0A6Fu0A68u0A73u0A6Du0A6Fu0A6Bu0A71u0A6Du0A6Fu0A6B);
DO_TYPEDEF(0x038B60E8, IList_1_u0A6Bu0A73u0A6Bu0A6Fu0A71u0A67u0A73u0A71u0A67u0A72u0A69_);
DO_TYPEDEF(0x038873E0, u0A70u0A6Bu0A65u0A68u0A67u0A6Bu0A71u0A68u0A73u0A71u0A6D);
DO_TYPEDEF(0x038C6158, Queue_1_KeyValuePair_2_System_DateTime_System_UInt32_);
DO_TYPEDEF(0x03888E88, u0A72u0A68u0A6Fu0A6Au0A6Eu0A69u0A6Eu0A67u0A70u0A70u0A67);
DO_TYPEDEF(0x03868590, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Collections_Generic_List_1__3);
DO_TYPEDEF(0x038C4780, List_1_u0A72u0A68u0A6Fu0A6Au0A6Eu0A69u0A6Eu0A67u0A70u0A70u0A67_u0A6Eu0A6Bu0A67u0A6Au0A73u0A71u0A6Au0A6Cu0A67u0A66u0A67_);
DO_TYPEDEF(0x038B4408, u0A72u0A68u0A6Fu0A6Au0A6Eu0A69u0A6Eu0A67u0A70u0A70u0A67_u0A6Eu0A6Bu0A67u0A6Au0A73u0A71u0A6Au0A6Cu0A67u0A66u0A67);
DO_TYPEDEF(0x03868620, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_u0A6Eu0A6Eu0A65u0A66u0A6Au0A6Cu0A74u0A6Eu0A70u0A6Bu0A67_System_Byte_);
DO_TYPEDEF(0x03868860, u0A6Eu0A6Eu0A65u0A66u0A6Au0A6Cu0A74u0A6Eu0A70u0A6Bu0A67_System_Byte_);
DO_TYPEDEF(0x03868CE0, u0A74u0A6Bu0A66u0A72u0A71u0A74u0A71u0A74u0A74u0A69u0A71_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x038A0C90, Action_2_String_u0A69u0A6Au0A65u0A72u0A73u0A73u0A72u0A73u0A65u0A6Du0A6C_);
DO_TYPEDEF(0x0389FAC0, Action_1_u0A67u0A6Eu0A6Au0A66u0A74u0A6Bu0A6Cu0A71u0A72u0A6Au0A6A_);
DO_TYPEDEF(0x038839F0, u0A6Bu0A73u0A6Bu0A6Fu0A71u0A67u0A73u0A71u0A67u0A72u0A69);
DO_TYPEDEF(0x03889210, u0A72u0A6Cu0A6Au0A70u0A65u0A6Bu0A6Bu0A6Au0A71u0A67u0A6F);
DO_TYPEDEF(0x038870E8, u0A70u0A68u0A74u0A6Eu0A69u0A66u0A73u0A6Bu0A65u0A67u0A69);
DO_TYPEDEF(0x038A53F8, Dictionary_2_System_Int32_System_Int32_);
DO_TYPEDEF(0x038B2668, ICollection_1_u0A6Eu0A68u0A6Du0A69u0A74u0A68u0A6Fu0A6Bu0A70u0A69u0A6D_);
DO_TYPEDEF(0x0388A5A8, u0A74u0A65u0A74u0A66u0A6Cu0A70u0A72u0A65u0A69u0A67u0A74);
DO_TYPEDEF(0x038B8A80, List_1_System_Single__1);
DO_TYPEDEF(0x0387FDE8, ChatRoomSettings);
DO_TYPEDEF(0x038A94D8, Dictionary_2_System_UInt16_System_String_);
DO_TYPEDEF(0x03888440, DebugSettings);
DO_TYPEDEF(0x038C1CC0, List_1_u0A6Eu0A6Bu0A69u0A69u0A69u0A71u0A6Fu0A6Eu0A6Fu0A67u0A6E_);
DO_TYPEDEF(0x03891330, DebugSettings_c);
DO_TYPEDEF(0x038AFBC8, Func_2_u0A67u0A6Cu0A65u0A6Du0A74u0A6Au0A6Au0A69u0A73u0A72u0A66_Int32_);
DO_TYPEDEF(0x03875068, VoiceSettings);
DO_TYPEDEF(0x038B0F30, VoiceSettings_c);
DO_TYPEDEF(0x038A0DC0, Action_2_String_u0A72u0A70u0A6Fu0A70u0A68u0A66u0A6Fu0A65u0A66u0A6Fu0A73_);
DO_TYPEDEF(0x038A0E58, Action_2_String_u0A73u0A70u0A6Fu0A65u0A71u0A73u0A66u0A67u0A69u0A66u0A6D_);
DO_TYPEDEF(0x038B0708, Func_3_String_u0A72u0A70u0A6Fu0A70u0A68u0A66u0A6Fu0A65u0A66u0A6Fu0A73_u0A72u0A70u0A6Fu0A70u0A68u0A66u0A6Fu0A65u0A66u0A6Fu0A73_);
DO_TYPEDEF(0x038B0798, Func_3_String_u0A73u0A70u0A6Fu0A65u0A71u0A73u0A66u0A67u0A69u0A66u0A6D_u0A73u0A70u0A6Fu0A65u0A71u0A73u0A66u0A67u0A69u0A66u0A6D_);
DO_TYPEDEF(0x03889A60, u0A73u0A67u0A68u0A65u0A6Cu0A6Au0A6Eu0A6Fu0A74u0A68u0A67);
DO_TYPEDEF(0x03880D78, u0A67u0A73u0A6Au0A68u0A6Cu0A66u0A73u0A69u0A65u0A6Au0A67);
DO_TYPEDEF(0x038B4018, u0A6Fu0A6Fu0A69u0A73u0A6Fu0A73u0A72u0A72u0A6Au0A69u0A6D_u0A68u0A74u0A66u0A73u0A73u0A6Cu0A6Eu0A69u0A6Au0A73u0A6A);
DO_TYPEDEF(0x038B3F88, u0A6Fu0A6Fu0A69u0A73u0A6Fu0A73u0A72u0A72u0A6Au0A69u0A6D_c);
DO_TYPEDEF(0x03868BC0, u0A73u0A72u0A65u0A6Du0A72u0A74u0A6Au0A65u0A6Bu0A70u0A73_u0A6Fu0A6Fu0A69u0A73u0A6Fu0A73u0A72u0A72u0A6Au0A69u0A6D_);
DO_TYPEDEF(0x038AD408, Func_1_u0A6Fu0A6Fu0A69u0A73u0A6Fu0A73u0A72u0A72u0A6Au0A69u0A6D_);
DO_TYPEDEF(0x038B3E68, u0A6Eu0A73u0A73u0A6Du0A71u0A71u0A6Eu0A67u0A6Du0A74u0A70_u0A70u0A72u0A6Eu0A6Bu0A6Cu0A73u0A6Eu0A74u0A6Eu0A68u0A6E);
DO_TYPEDEF(0x038B40A8, u0A6Fu0A74u0A6Du0A65u0A73u0A6Eu0A71u0A6Bu0A72u0A6Eu0A6C_u0A6Fu0A71u0A68u0A74u0A74u0A69u0A67u0A74u0A6Fu0A6Eu0A69);
DO_TYPEDEF(0x0388AD60, u0A74u0A6Du0A66u0A6Du0A72u0A72u0A74u0A6Au0A68u0A69u0A6C);
DO_TYPEDEF(0x03885780, u0A6Eu0A72u0A6Cu0A67u0A74u0A67u0A6Du0A68u0A65u0A6Fu0A74);
DO_TYPEDEF(0x0387ECE0, u0A65u0A66u0A6Cu0A6Du0A68u0A69u0A73u0A73u0A72u0A72u0A6C);
DO_TYPEDEF(0x038B3B08, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A74u0A74u0A67u0A65u0A68u0A74u0A6Du0A6Cu0A6Bu0A6Fu0A65);
DO_TYPEDEF(0x038B0EA8, VoicePlayback_c);
DO_TYPEDEF(0x03883F40, u0A6Cu0A6Du0A68u0A72u0A66u0A69u0A67u0A6Bu0A6Eu0A65u0A70);
DO_TYPEDEF(0x038802C8, u0A67u0A66u0A72u0A74u0A6Fu0A73u0A6Fu0A72u0A71u0A66u0A70);
DO_TYPEDEF(0x038B3958, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A70u0A68u0A70u0A6Bu0A66u0A65u0A70u0A74u0A69u0A67u0A66__Enum);
DO_TYPEDEF(0x038846F0, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71);
DO_TYPEDEF(0x038B37A8, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A65u0A6Au0A67u0A67u0A69u0A65u0A6Eu0A66u0A6Au0A6Cu0A67__Enum);
DO_TYPEDEF(0x038B3A78, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A72u0A68u0A6Cu0A69u0A6Eu0A6Du0A6Bu0A66u0A6Eu0A67u0A70);
DO_TYPEDEF(0x038B3838, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A66u0A72u0A74u0A6Cu0A67u0A6Cu0A6Bu0A73u0A6Cu0A6Du0A6B);
DO_TYPEDEF(0x038B38C8, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A6Fu0A74u0A65u0A69u0A6Fu0A71u0A72u0A6Cu0A6Eu0A6Du0A6E);
DO_TYPEDEF(0x03886520, u0A6Fu0A6Au0A6Cu0A66u0A6Bu0A6Du0A68u0A6Eu0A6Du0A67u0A74);
DO_TYPEDEF(0x03880360, u0A67u0A67u0A65u0A65u0A6Fu0A6Bu0A74u0A6Au0A6Au0A67u0A6B);
DO_TYPEDEF(0x038895A0, u0A72u0A72u0A66u0A72u0A6Au0A73u0A65u0A70u0A65u0A66u0A6A);
DO_TYPEDEF(0x03882D78, u0A6Au0A6Fu0A6Cu0A6Eu0A70u0A72u0A66u0A74u0A6Fu0A67u0A6C);
DO_TYPEDEF(0x038B49A8, u0A74u0A65u0A74u0A6Du0A66u0A6Eu0A6Eu0A6Bu0A74u0A6Cu0A6D_u0A67u0A70u0A70u0A67u0A72u0A6Fu0A73u0A66u0A69u0A65u0A6E__Enum);
DO_TYPEDEF(0x0387AA60, BasicMicrophoneCapture);
DO_TYPEDEF(0x038B7228, u0A72u0A74u0A70u0A72u0A70u0A70u0A74u0A6Eu0A6Eu0A68u0A68_u0A73u0A70u0A69u0A69u0A67u0A6Fu0A68u0A66u0A67u0A68u0A6E_c);
DO_TYPEDEF(0x038AF988, Func_2_Dissonance_Config_VoiceSettings_u0A66u0A71u0A71u0A69u0A72u0A6Eu0A67u0A6Au0A6Fu0A65u0A66_);
DO_TYPEDEF(0x038AFB38, Func_2_Dissonance_Config_VoiceSettings_u0A71u0A6Fu0A69u0A6Du0A6Bu0A6Cu0A6Du0A68u0A72u0A74u0A69_);
DO_TYPEDEF(0x038AFA18, Func_2_Dissonance_Config_VoiceSettings_u0A67u0A67u0A69u0A74u0A73u0A68u0A65u0A6Eu0A6Du0A6Du0A73_);
DO_TYPEDEF(0x038AFAA8, Func_2_Dissonance_Config_VoiceSettings_u0A6Cu0A65u0A71u0A70u0A73u0A6Bu0A72u0A6Eu0A6Eu0A74u0A6C_);
DO_TYPEDEF(0x038B7198, u0A72u0A74u0A70u0A72u0A70u0A70u0A74u0A6Eu0A6Eu0A68u0A68_u0A67u0A69u0A67u0A6Du0A71u0A70u0A6Fu0A6Cu0A66u0A72u0A73_c);
DO_TYPEDEF(0x038AF868, Func_2_Dissonance_Config_VoiceSettings_Boolean_);
DO_TYPEDEF(0x038AF8F8, Func_2_Dissonance_Config_VoiceSettings_Single_);
DO_TYPEDEF(0x03885948, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_1);
DO_TYPEDEF(0x038B4DF8, ObiSolver);
DO_TYPEDEF(0x0389FEB8, ObiSolver_u0A72u0A66u0A69u0A6Bu0A6Du0A6Eu0A74u0A6Eu0A73u0A65u0A73);
DO_TYPEDEF(0x0389FE20, ObiSolver_u0A71u0A68u0A74u0A6Cu0A70u0A73u0A69u0A72u0A68u0A65u0A69);
DO_TYPEDEF(0x03867FF8, u0A67u0A67u0A6Cu0A6Au0A6Du0A70u0A6Eu0A72u0A73u0A68u0A6B_u0A73u0A6Du0A73u0A6Au0A6Du0A68u0A6Du0A6Eu0A6Eu0A73u0A6D_u0A6Bu0A72u0A74u0A6Au0A65u0A69u0A69u0A6Bu0A70u0A6Du0A6C_);
DO_TYPEDEF(0x038B4888, u0A73u0A6Du0A73u0A6Au0A6Du0A68u0A6Du0A6Eu0A6Eu0A73u0A6D_u0A6Bu0A72u0A74u0A6Au0A65u0A69u0A69u0A6Bu0A70u0A6Du0A6C);
DO_TYPEDEF(0x038754F0, u0A73u0A6Du0A73u0A6Au0A6Du0A68u0A6Du0A6Eu0A6Eu0A73u0A6D_u0A6Bu0A72u0A74u0A6Au0A65u0A69u0A69u0A6Bu0A70u0A6Du0A6C__Array);
DO_TYPEDEF(0x038B57E8, IEnumerator_1_u0A73u0A6Du0A73u0A6Au0A6Du0A68u0A6Du0A6Eu0A6Eu0A73u0A6D_u0A6Bu0A72u0A74u0A6Au0A65u0A69u0A69u0A6Bu0A70u0A6Du0A6C_);
DO_TYPEDEF(0x0389FFE8, ObiSolver_u0A73u0A66u0A6Du0A67u0A6Cu0A72u0A6Du0A6Bu0A70u0A74u0A6D);
DO_TYPEDEF(0x0389FF50, ObiSolver_u0A72u0A6Fu0A74u0A69u0A66u0A70u0A6Au0A68u0A65u0A69u0A72);
DO_TYPEDEF(0x03888930, u0A71u0A72u0A6Bu0A71u0A70u0A74u0A6Cu0A6Cu0A68u0A6Fu0A74);
DO_TYPEDEF(0x0388ACC8, u0A74u0A6Bu0A6Eu0A65u0A70u0A70u0A70u0A68u0A74u0A70u0A72);
DO_TYPEDEF(0x038BD700, List_1_Obi_ObiActor_);
DO_TYPEDEF(0x0389EFE0, ObiActor_u0A6Fu0A68u0A6Bu0A6Eu0A6Au0A6Fu0A6Du0A73u0A6Cu0A6Cu0A68);
DO_TYPEDEF(0x0389F1A8, ObiActorBlueprint_u0A6Bu0A72u0A6Du0A6Du0A72u0A68u0A74u0A6Bu0A67u0A66u0A73);
DO_TYPEDEF(0x0386EE40, Quaternion__Array);
DO_TYPEDEF(0x038C4ED0, ObiConstraints_1_ObiDistanceConstraintsBatch_);
DO_TYPEDEF(0x038B3AD8, ObiDistanceConstraintsData);
DO_TYPEDEF(0x038B3A48, ObiDistanceConstraintsBatch);
DO_TYPEDEF(0x038B42B8, ObiNativeIntList);
DO_TYPEDEF(0x038B4108, ObiNativeFloatList);
DO_TYPEDEF(0x038853F0, u0A6Eu0A6Fu0A69u0A6Cu0A6Bu0A6Au0A6Fu0A6Du0A70u0A65u0A73);
DO_TYPEDEF(0x03881530, u0A68u0A6Au0A6Bu0A6Bu0A73u0A6Fu0A70u0A67u0A6Du0A6Cu0A6B);
DO_TYPEDEF(0x038B34A8, ObiAerodynamicConstraintsBatch);
DO_TYPEDEF(0x038875A8, u0A70u0A6Du0A68u0A67u0A71u0A71u0A6Bu0A6Cu0A65u0A6Cu0A66);
DO_TYPEDEF(0x03881958, u0A68u0A6Fu0A74u0A74u0A68u0A6Du0A70u0A6Cu0A70u0A66u0A6B);
DO_TYPEDEF(0x038B4738, ObiNativeVector2List);
DO_TYPEDEF(0x03887FB0, u0A71u0A68u0A70u0A72u0A6Eu0A67u0A6Fu0A6Bu0A65u0A67u0A69);
DO_TYPEDEF(0x038C4E40, ObiConstraints_1_ObiBendConstraintsBatch_);
DO_TYPEDEF(0x038B3658, ObiBendConstraintsData);
DO_TYPEDEF(0x038B35C8, ObiBendConstraintsBatch);
DO_TYPEDEF(0x03883400, u0A6Bu0A69u0A67u0A70u0A72u0A6Cu0A66u0A72u0A67u0A6Bu0A6E);
DO_TYPEDEF(0x038C4FF0, ObiConstraints_1_ObiSkinConstraintsBatch_);
DO_TYPEDEF(0x038B4CD8, ObiSkinConstraintsData);
DO_TYPEDEF(0x038B4C48, ObiSkinConstraintsBatch);
DO_TYPEDEF(0x03885650, u0A6Eu0A71u0A6Cu0A70u0A72u0A71u0A69u0A72u0A72u0A6Du0A69);
DO_TYPEDEF(0x038B4858, ObiNativeVector4List);
DO_TYPEDEF(0x038B5158, ObiTetherConstraintsData);
DO_TYPEDEF(0x038B50C8, ObiTetherConstraintsBatch);
DO_TYPEDEF(0x038831A0, u0A6Bu0A66u0A6Fu0A68u0A73u0A71u0A66u0A6Eu0A69u0A74u0A73);
DO_TYPEDEF(0x038B4F18, ObiStretchShearConstraintsData);
DO_TYPEDEF(0x038B4E88, ObiStretchShearConstraintsBatch);
DO_TYPEDEF(0x03884528, u0A6Du0A67u0A68u0A67u0A6Bu0A69u0A73u0A6Fu0A6Au0A6Du0A69);
DO_TYPEDEF(0x038B43D8, ObiNativeQuaternionList);
DO_TYPEDEF(0x038B47C8, ObiNativeVector3List);
DO_TYPEDEF(0x038B3778, ObiBendTwistConstraintsData);
DO_TYPEDEF(0x038B36E8, ObiBendTwistConstraintsBatch);
DO_TYPEDEF(0x03887E80, u0A71u0A66u0A71u0A6Cu0A6Au0A6Eu0A6Eu0A72u0A66u0A6Bu0A6C);
DO_TYPEDEF(0x038B4BB8, ObiShapeMatchingConstraintsData);
DO_TYPEDEF(0x038B4B28, ObiShapeMatchingConstraintsBatch);
DO_TYPEDEF(0x038863F0, u0A6Fu0A68u0A74u0A73u0A6Bu0A72u0A71u0A73u0A69u0A73u0A72);
DO_TYPEDEF(0x038B4348, ObiNativeMatrix4x4List);
DO_TYPEDEF(0x038B3538, ObiAerodynamicConstraintsData);
DO_TYPEDEF(0x038B3898, ObiChainConstraintsData);
DO_TYPEDEF(0x038B3808, ObiChainConstraintsBatch);
DO_TYPEDEF(0x0387F070, u0A65u0A6Cu0A66u0A74u0A6Bu0A74u0A6Fu0A73u0A72u0A6Du0A70);
DO_TYPEDEF(0x038B5308, ObiVolumeConstraintsData);
DO_TYPEDEF(0x038B5278, ObiVolumeConstraintsBatch);
DO_TYPEDEF(0x03888A60, u0A71u0A73u0A66u0A69u0A6Au0A70u0A65u0A66u0A65u0A71u0A70);
DO_TYPEDEF(0x038BD790, List_1_Obi_ObiParticleGroup_);
DO_TYPEDEF(0x0389B3C0, HalfEdgeMesh);
DO_TYPEDEF(0x038C2D10, List_1_Obi_HalfEdgeMesh_Vertex_);
DO_TYPEDEF(0x03896920, HalfEdgeMesh_Vertex);
DO_TYPEDEF(0x038B55A8, IEnumerator_1_Obi_HalfEdgeMesh_Vertex_);
DO_TYPEDEF(0x038C2C80, List_1_Obi_HalfEdgeMesh_HalfEdge_);
DO_TYPEDEF(0x03896888, HalfEdgeMesh_HalfEdge);
DO_TYPEDEF(0x038B5518, IEnumerator_1_Obi_HalfEdgeMesh_HalfEdge_);
DO_TYPEDEF(0x038C2BF0, List_1_Obi_HalfEdgeMesh_Face_);
DO_TYPEDEF(0x038967F0, HalfEdgeMesh_Face);
DO_TYPEDEF(0x038B5488, IEnumerator_1_Obi_HalfEdgeMesh_Face_);
DO_TYPEDEF(0x038BE2D0, List_1_UnityEngine_Quaternion_);
DO_TYPEDEF(0x0389EF48, ObiActor_u0A67u0A65u0A69u0A71u0A6Du0A72u0A74u0A72u0A72u0A71u0A69);
DO_TYPEDEF(0x0389F078, ObiActor_u0A73u0A6Du0A66u0A6Du0A67u0A66u0A6Au0A68u0A6Du0A6Du0A6F);
DO_TYPEDEF(0x038C4F60, ObiConstraints_1_ObiPinConstraintsBatch_);
DO_TYPEDEF(0x038B4A08, ObiPinConstraintsData);
DO_TYPEDEF(0x038B4978, ObiPinConstraintsBatch);
DO_TYPEDEF(0x0387EEA8, u0A65u0A69u0A67u0A6Bu0A71u0A6Au0A73u0A73u0A6Eu0A72u0A74);
DO_TYPEDEF(0x038C1BA0, List_1_u0A6Eu0A68u0A66u0A68u0A69u0A72u0A6Au0A69u0A65u0A67u0A6A_);
DO_TYPEDEF(0x03884F38, u0A6Eu0A68u0A66u0A68u0A69u0A72u0A6Au0A69u0A65u0A67u0A6A);
DO_TYPEDEF(0x03880B18, u0A67u0A6Eu0A70u0A6Eu0A6Cu0A70u0A67u0A71u0A6Bu0A73u0A70);
DO_TYPEDEF(0x0387FC50, u0A66u0A71u0A6Au0A71u0A66u0A6Cu0A6Au0A66u0A6Eu0A6Eu0A66);
DO_TYPEDEF(0x03888C28, u0A72u0A65u0A6Du0A70u0A65u0A6Au0A6Au0A6Du0A6Du0A68u0A6B);
DO_TYPEDEF(0x038BA2B0, List_1_Obi_DFNode_);
DO_TYPEDEF(0x03884AE8, DFNode);
DO_TYPEDEF(0x038B3928, ObiClothBase);
DO_TYPEDEF(0x038B39B8, ObiClothRendererBase);
DO_TYPEDEF(0x0389FD88, ObiSolver_ParticleInActor);
DO_TYPEDEF(0x03873E18, ObiSolver_ParticleInActor__Array);
DO_TYPEDEF(0x03871AA8, u0A71u0A68u0A70u0A72u0A6Eu0A67u0A6Fu0A6Bu0A65u0A67u0A69__Array);
DO_TYPEDEF(0x038B4228, ObiNativeInt4List);
DO_TYPEDEF(0x0386E1B0, ObiSolver__Array);
DO_TYPEDEF(0x038A6818, Dictionary_2_Obi_ObiSolver_Obi_ObiSolver_u0A71u0A68u0A74u0A6Cu0A70u0A73u0A69u0A72u0A68u0A65u0A69_);
DO_TYPEDEF(0x038B1A08, HashSet_1_ObiContactGrabber_u0A65u0A67u0A74u0A74u0A67u0A73u0A6Bu0A6Eu0A70u0A66u0A73_);
DO_TYPEDEF(0x0389F960, ObiContactGrabber_u0A65u0A67u0A74u0A74u0A67u0A73u0A6Bu0A6Eu0A70u0A66u0A73);
DO_TYPEDEF(0x038B13D8, HashSet_1_Obi_ObiActor_);
DO_TYPEDEF(0x03875458, u0A73u0A6Du0A73u0A6Au0A6Du0A68u0A6Du0A6Eu0A6Eu0A73u0A6D_u0A6Au0A68u0A71u0A6Du0A6Eu0A73u0A6Au0A6Eu0A66u0A70u0A6B__Array);
DO_TYPEDEF(0x038B4D68, ObiSkinnedCloth);
DO_TYPEDEF(0x038B4FA8, ObiTearableCloth);
DO_TYPEDEF(0x038B5038, ObiTearableClothBlueprint);
DO_TYPEDEF(0x03870ED8, Vector2Int__Array);
DO_TYPEDEF(0x038A01B0, ObiTearableCloth_u0A67u0A68u0A66u0A72u0A65u0A6Du0A69u0A68u0A6Eu0A6Au0A67);
DO_TYPEDEF(0x038803F8, u0A67u0A67u0A65u0A74u0A66u0A6Fu0A70u0A66u0A6Bu0A6Cu0A6C);
DO_TYPEDEF(0x038A0248, ObiTearableCloth_u0A72u0A6Fu0A72u0A65u0A6Bu0A6Bu0A68u0A6Fu0A69u0A6Cu0A6F);
DO_TYPEDEF(0x03885E00, u0A6Eu0A73u0A71u0A6Au0A6Bu0A74u0A71u0A69u0A6Du0A74u0A69);
DO_TYPEDEF(0x038A0118, ObiTearableCloth_c);
DO_TYPEDEF(0x038A2938, Comparison_1_u0A67u0A67u0A65u0A74u0A66u0A6Fu0A70u0A66u0A6Bu0A6Cu0A6C_);
DO_TYPEDEF(0x038B8210, List_1_HashSet_1_System_Int32_);
DO_TYPEDEF(0x038AE828, Func_2_Int32_Boolean_);
DO_TYPEDEF(0x0389F4A0, ObiClothBlueprint_u0A6Bu0A70u0A70u0A69u0A70u0A74u0A71u0A69u0A6Du0A73u0A67);
DO_TYPEDEF(0x0389F370, ObiClothBlueprint_u0A65u0A69u0A6Cu0A68u0A73u0A72u0A69u0A71u0A71u0A6Du0A66);
DO_TYPEDEF(0x0389F408, ObiClothBlueprint_u0A68u0A6Bu0A65u0A67u0A67u0A65u0A6Au0A69u0A68u0A65u0A74);
DO_TYPEDEF(0x0389F538, ObiClothBlueprint_u0A6Cu0A72u0A69u0A66u0A71u0A6Fu0A6Au0A6Du0A6Fu0A67u0A72);
DO_TYPEDEF(0x0389F668, ObiClothBlueprint_u0A74u0A6Du0A72u0A6Bu0A71u0A65u0A74u0A69u0A71u0A67u0A67);
DO_TYPEDEF(0x0389F5D0, ObiClothBlueprint_u0A72u0A72u0A6Fu0A72u0A73u0A66u0A65u0A6Au0A70u0A6Eu0A65);
DO_TYPEDEF(0x0389F2D8, ObiClothBlueprint_c);
DO_TYPEDEF(0x038A2278, Comparison_1_System_Collections_Generic_KeyValuePair_2_);
DO_TYPEDEF(0x038B6E68, KeyValuePair_2_System_Single_System_Int32_);
DO_TYPEDEF(0x0389F700, ObiClothBlueprintBase_u0A6Du0A65u0A6Eu0A67u0A6Fu0A6Fu0A6Eu0A70u0A72u0A6Du0A6C);
DO_TYPEDEF(0x0389F798, ObiClothBlueprintBase_u0A72u0A6Cu0A6Du0A68u0A6Cu0A6Cu0A6Bu0A66u0A6Bu0A6Bu0A6B);
DO_TYPEDEF(0x0389FBC0, ObiSkinnedClothBlueprint_u0A6Bu0A68u0A69u0A6Au0A72u0A6Du0A74u0A68u0A6Bu0A66u0A67);
DO_TYPEDEF(0x0389FC58, ObiSkinnedClothBlueprint_u0A6Fu0A65u0A66u0A6Cu0A67u0A74u0A73u0A6Du0A6Eu0A6Au0A72);
DO_TYPEDEF(0x038A04A8, ObiTearableClothBlueprint_u0A74u0A68u0A66u0A6Fu0A6Bu0A70u0A72u0A65u0A65u0A66u0A72);
DO_TYPEDEF(0x038A0410, ObiTearableClothBlueprint_u0A74u0A65u0A6Bu0A67u0A74u0A70u0A70u0A74u0A6Du0A65u0A6D);
DO_TYPEDEF(0x038A0378, ObiTearableClothBlueprint_u0A6Du0A66u0A68u0A74u0A66u0A74u0A70u0A6Bu0A71u0A70u0A68);
DO_TYPEDEF(0x038A02E0, ObiTearableClothBlueprint_u0A6Au0A68u0A6Eu0A72u0A67u0A74u0A65u0A68u0A6Du0A70u0A66);
DO_TYPEDEF(0x038B40D8, IEnumerable_1_Obi_HalfEdgeMesh_Vertex_);
DO_TYPEDEF(0x038B4048, IEnumerable_1_Obi_HalfEdgeMesh_HalfEdge_);
DO_TYPEDEF(0x038B3FB8, IEnumerable_1_Obi_HalfEdgeMesh_Face_);
DO_TYPEDEF(0x03896A50, HalfEdgeMesh_u0A70u0A6Au0A71u0A70u0A6Bu0A6Eu0A6Eu0A6Bu0A67u0A65u0A70);
DO_TYPEDEF(0x03896AE8, HalfEdgeMesh_u0A70u0A72u0A74u0A68u0A68u0A67u0A66u0A73u0A71u0A6Eu0A65);
DO_TYPEDEF(0x038969B8, HalfEdgeMesh_u0A6Cu0A66u0A70u0A73u0A65u0A69u0A69u0A66u0A6Du0A70u0A66);
DO_TYPEDEF(0x038C3460, List_1_Obi_ObiTriangleSkinMap_SlaveVertex_);
DO_TYPEDEF(0x038A0540, ObiTriangleSkinMap_SlaveVertex);
DO_TYPEDEF(0x038A05D8, ObiTriangleSkinMap_u0A67u0A67u0A74u0A6Au0A72u0A66u0A65u0A67u0A6Cu0A71u0A6D);
DO_TYPEDEF(0x038A0670, ObiTriangleSkinMap_u0A6Eu0A67u0A6Au0A71u0A65u0A73u0A73u0A66u0A70u0A6Eu0A6A);
DO_TYPEDEF(0x03873EA8, ObiTriangleSkinMap_u0A67u0A67u0A74u0A6Au0A72u0A66u0A65u0A67u0A6Cu0A71u0A6D__Array);
DO_TYPEDEF(0x03882198, u0A69u0A6Au0A72u0A6Eu0A6Eu0A66u0A67u0A70u0A70u0A66u0A68);
DO_TYPEDEF(0x03889638, u0A72u0A72u0A67u0A71u0A65u0A6Cu0A66u0A6Cu0A6Eu0A6Cu0A6C);
DO_TYPEDEF(0x038B3BF8, ObiNativeAabbList);
DO_TYPEDEF(0x038B44F8, ObiNativeQueryShapeList);
DO_TYPEDEF(0x038B3C88, ObiNativeAffineTransformList);
DO_TYPEDEF(0x038B4468, ObiNativeQueryResultList);
DO_TYPEDEF(0x038718F8, u0A66u0A72u0A74u0A74u0A68u0A6Du0A6Au0A6Fu0A6Fu0A6Bu0A65__Array);
DO_TYPEDEF(0x03883C48, u0A6Cu0A67u0A68u0A65u0A73u0A67u0A72u0A71u0A6Fu0A70u0A65);
DO_TYPEDEF(0x03882528, u0A69u0A6Cu0A71u0A6Cu0A65u0A72u0A66u0A74u0A6Cu0A6Bu0A6B);
DO_TYPEDEF(0x03883828, u0A6Bu0A6Fu0A66u0A6Fu0A66u0A6Eu0A6Eu0A73u0A6Eu0A68u0A68);
DO_TYPEDEF(0x03887478, u0A70u0A6Bu0A6Bu0A67u0A6Bu0A6Cu0A66u0A72u0A65u0A67u0A66);
DO_TYPEDEF(0x0387F790, u0A66u0A68u0A68u0A6Bu0A70u0A6Au0A71u0A6Au0A67u0A6Bu0A6D);
DO_TYPEDEF(0x038865B8, u0A6Fu0A6Bu0A71u0A6Du0A73u0A73u0A65u0A6Bu0A6Au0A69u0A6E);
DO_TYPEDEF(0x03871A18, u0A6Fu0A6Bu0A71u0A6Du0A73u0A73u0A65u0A6Bu0A6Au0A69u0A6E__Array);
DO_TYPEDEF(0x03868A10, u0A6Eu0A71u0A6Bu0A66u0A6Du0A73u0A6Cu0A66u0A6Au0A66u0A6E_u0A6Au0A70u0A6Fu0A74u0A6Bu0A6Eu0A65u0A68u0A6Fu0A6Au0A6A_);
DO_TYPEDEF(0x03883958, u0A6Bu0A6Fu0A71u0A6Bu0A69u0A68u0A71u0A67u0A6Eu0A68u0A71);
DO_TYPEDEF(0x03887808, u0A70u0A70u0A6Eu0A65u0A74u0A70u0A73u0A6Cu0A6Au0A6Du0A6C);
DO_TYPEDEF(0x03881400, u0A68u0A69u0A73u0A73u0A6Fu0A6Cu0A67u0A68u0A6Cu0A70u0A6F);
DO_TYPEDEF(0x03889DF0, u0A73u0A6Du0A66u0A6Cu0A6Eu0A6Du0A73u0A6Du0A6Du0A6Du0A69);
DO_TYPEDEF(0x03888210, u0A71u0A6Bu0A6Fu0A72u0A71u0A70u0A73u0A65u0A6Fu0A74u0A67);
DO_TYPEDEF(0x03889CC0, u0A73u0A6Bu0A72u0A65u0A6Du0A65u0A6Du0A69u0A72u0A72u0A6F);
DO_TYPEDEF(0x03881E08, u0A69u0A66u0A72u0A72u0A67u0A68u0A68u0A68u0A69u0A6Eu0A67);
DO_TYPEDEF(0x0387FB20, u0A66u0A6Eu0A6Cu0A6Cu0A6Eu0A74u0A72u0A6Du0A6Cu0A6Cu0A73);
DO_TYPEDEF(0x0387FBB8, u0A66u0A70u0A71u0A68u0A6Fu0A6Au0A66u0A6Eu0A74u0A6Eu0A6E);
DO_TYPEDEF(0x03884EA0, u0A6Eu0A66u0A72u0A6Du0A6Fu0A71u0A6Cu0A6Bu0A65u0A70u0A73);
DO_TYPEDEF(0x03887DE8, u0A71u0A66u0A6Fu0A73u0A66u0A68u0A6Au0A65u0A68u0A6Cu0A67);
DO_TYPEDEF(0x03885228, u0A6Eu0A6Eu0A66u0A6Bu0A72u0A68u0A65u0A6Du0A65u0A74u0A70);
DO_TYPEDEF(0x03886F20, u0A70u0A65u0A6Fu0A6Au0A69u0A6Eu0A71u0A6Fu0A65u0A71u0A71);
DO_TYPEDEF(0x0387FF40, u0A66u0A74u0A65u0A6Fu0A69u0A66u0A66u0A6Bu0A66u0A72u0A6E);
DO_TYPEDEF(0x03888AF8, u0A71u0A73u0A66u0A73u0A71u0A74u0A66u0A69u0A6Eu0A65u0A74);
DO_TYPEDEF(0x03882B18, u0A6Au0A6Bu0A66u0A70u0A73u0A6Au0A65u0A67u0A68u0A67u0A71);
DO_TYPEDEF(0x03880CE0, u0A67u0A73u0A6Au0A65u0A6Bu0A6Au0A6Au0A6Bu0A6Cu0A72u0A65);
DO_TYPEDEF(0x03881F38, u0A69u0A68u0A74u0A70u0A65u0A6Au0A74u0A6Eu0A74u0A72u0A6C);
DO_TYPEDEF(0x0388B058, u0A74u0A71u0A6Eu0A6Eu0A74u0A6Eu0A72u0A73u0A69u0A6Fu0A65);
DO_TYPEDEF(0x03886B00, u0A6Fu0A71u0A74u0A6Eu0A65u0A6Fu0A69u0A6Cu0A68u0A70u0A6D);
DO_TYPEDEF(0x03889C28, u0A73u0A6Bu0A6Fu0A6Cu0A69u0A65u0A74u0A66u0A6Au0A66u0A6D);
DO_TYPEDEF(0x038823F8, u0A69u0A6Cu0A6Au0A72u0A74u0A68u0A70u0A6Du0A72u0A71u0A65);
DO_TYPEDEF(0x0388A478, u0A73u0A74u0A6Du0A65u0A66u0A74u0A66u0A6Cu0A6Cu0A69u0A6A);
DO_TYPEDEF(0x038B3DA8, ObiNativeColliderShapeList);
DO_TYPEDEF(0x038B4588, ObiNativeRigidbodyList);
DO_TYPEDEF(0x038B3E38, ObiNativeCollisionMaterialList);
DO_TYPEDEF(0x038B46A8, ObiNativeTriangleMeshHeaderList);
DO_TYPEDEF(0x038B3D18, ObiNativeBIHNodeList);
DO_TYPEDEF(0x0387FA88, u0A66u0A6Bu0A67u0A74u0A69u0A68u0A6Cu0A6Au0A72u0A6Cu0A67);
DO_TYPEDEF(0x038B4618, ObiNativeTriangleList);
DO_TYPEDEF(0x03880100, u0A67u0A65u0A6Fu0A72u0A72u0A70u0A69u0A6Fu0A6Au0A6Au0A70);
DO_TYPEDEF(0x038B4078, ObiNativeEdgeMeshHeaderList);
DO_TYPEDEF(0x038B3FE8, ObiNativeEdgeList);
DO_TYPEDEF(0x03885FC8, u0A6Eu0A74u0A6Fu0A68u0A6Au0A6Du0A67u0A6Eu0A6Cu0A66u0A70);
DO_TYPEDEF(0x038B3F58, ObiNativeDistanceFieldHeaderList);
DO_TYPEDEF(0x038B3EC8, ObiNativeDFNodeList);
DO_TYPEDEF(0x038B4198, ObiNativeHeightFieldHeaderList);
DO_TYPEDEF(0x038B3F28, IEnumerable_1_u0A71u0A68u0A70u0A72u0A6Eu0A67u0A6Fu0A6Bu0A65u0A67u0A69_);
DO_TYPEDEF(0x0389F110, ObiActorBlueprint_u0A68u0A6Eu0A6Bu0A6Eu0A6Bu0A66u0A71u0A69u0A74u0A6Du0A6D);
DO_TYPEDEF(0x038B53F8, IEnumerator_1_u0A71u0A68u0A70u0A72u0A6Eu0A67u0A6Fu0A6Bu0A65u0A67u0A69_);
DO_TYPEDEF(0x0389F240, ObiActorBlueprint_u0A71u0A6Au0A6Au0A6Eu0A69u0A6Bu0A74u0A6Bu0A73u0A6Eu0A6B);
DO_TYPEDEF(0x03886C30, u0A6Fu0A73u0A6Bu0A66u0A72u0A70u0A73u0A70u0A67u0A6Au0A6D);
DO_TYPEDEF(0x03887B90, u0A70u0A74u0A69u0A67u0A65u0A6Au0A68u0A6Cu0A73u0A6Cu0A67);
DO_TYPEDEF(0x03880E10, u0A67u0A73u0A6Bu0A65u0A6Au0A74u0A6Au0A6Eu0A6Au0A6Du0A67);
DO_TYPEDEF(0x03882F40, u0A6Au0A73u0A6Bu0A70u0A73u0A6Bu0A72u0A6Eu0A70u0A66u0A68);
DO_TYPEDEF(0x0387F9F0, u0A66u0A6Au0A66u0A65u0A70u0A68u0A6Fu0A6Du0A70u0A6Bu0A6A);
DO_TYPEDEF(0x03882BB0, u0A6Au0A6Bu0A6Bu0A6Fu0A72u0A66u0A6Au0A69u0A73u0A6Au0A67);
DO_TYPEDEF(0x03886778, u0A6Fu0A6Eu0A74u0A73u0A6Fu0A68u0A69u0A68u0A6Au0A74u0A68);
DO_TYPEDEF(0x038856E8, u0A6Eu0A72u0A68u0A6Cu0A74u0A67u0A6Fu0A6Du0A72u0A65u0A69);
DO_TYPEDEF(0x03884C48, u0A6Du0A74u0A69u0A6Du0A6Bu0A66u0A66u0A6Bu0A6Au0A68u0A6C);
DO_TYPEDEF(0x03888D58, u0A72u0A67u0A6Cu0A6Au0A66u0A74u0A66u0A74u0A65u0A73u0A69);
DO_TYPEDEF(0x03880788, u0A67u0A6Au0A66u0A74u0A67u0A68u0A73u0A66u0A66u0A72u0A66);
DO_TYPEDEF(0x03886A68, u0A6Fu0A71u0A67u0A6Au0A67u0A74u0A65u0A6Eu0A6Cu0A67u0A66);
DO_TYPEDEF(0x03880658, u0A67u0A69u0A70u0A73u0A6Eu0A72u0A69u0A6Eu0A67u0A65u0A69);
DO_TYPEDEF(0x03889178, u0A72u0A6Au0A74u0A65u0A72u0A6Eu0A6Fu0A68u0A66u0A6Cu0A73);
DO_TYPEDEF(0x03881070, u0A68u0A66u0A65u0A6Cu0A73u0A69u0A6Eu0A6Du0A6Cu0A71u0A73);
DO_TYPEDEF(0x038C1DE0, List_1_u0A6Fu0A6Cu0A71u0A68u0A6Au0A67u0A6Au0A69u0A65u0A6Eu0A68_);
DO_TYPEDEF(0x03886648, u0A6Fu0A6Cu0A71u0A68u0A6Au0A67u0A6Au0A69u0A65u0A6Eu0A68);
DO_TYPEDEF(0x038C1600, List_1_u0A67u0A6Eu0A70u0A6Eu0A6Cu0A70u0A67u0A71u0A6Bu0A73u0A70_);
DO_TYPEDEF(0x038C1450, List_1_u0A66u0A71u0A6Au0A71u0A66u0A6Cu0A6Au0A66u0A6Eu0A6Eu0A66_);
DO_TYPEDEF(0x03884788, u0A6Du0A6Bu0A6Au0A66u0A72u0A67u0A6Bu0A6Eu0A6Fu0A68u0A65);
DO_TYPEDEF(0x038A6548, Dictionary_2_UnityEngine_Mesh_u0A67u0A6Au0A66u0A74u0A67u0A68u0A73u0A66u0A66u0A72u0A66_);
DO_TYPEDEF(0x038B4CA8, IEnumerator_1_UnityEngine_Mesh_);
DO_TYPEDEF(0x0387FFD8, u0A66u0A74u0A6Fu0A6Du0A65u0A73u0A6Bu0A65u0A6Du0A72u0A72);
DO_TYPEDEF(0x038A45E8, Dictionary_2_UnityEngine_EdgeCollider2D_u0A6Au0A73u0A6Bu0A70u0A73u0A6Bu0A72u0A6Eu0A70u0A66u0A68_);
DO_TYPEDEF(0x038869D0, u0A6Fu0A6Fu0A70u0A73u0A71u0A68u0A67u0A72u0A73u0A6Au0A66);
DO_TYPEDEF(0x038A6788, Dictionary_2_Obi_ObiDistanceField_u0A6Du0A74u0A69u0A6Du0A6Bu0A66u0A66u0A6Bu0A6Au0A68u0A6C_);
DO_TYPEDEF(0x03881368, u0A68u0A68u0A6Fu0A68u0A73u0A68u0A70u0A73u0A6Bu0A66u0A6B);
DO_TYPEDEF(0x038A85B8, Dictionary_2_UnityEngine_TerrainData_u0A72u0A6Au0A74u0A65u0A72u0A6Eu0A6Fu0A68u0A66u0A6Cu0A73_);
DO_TYPEDEF(0x038BD820, List_1_Obi_ObiSolver_);
DO_TYPEDEF(0x0389F9F8, ObiDistanceField_u0A6Eu0A6Cu0A72u0A72u0A66u0A71u0A6Fu0A6Eu0A6Cu0A6Du0A72);
DO_TYPEDEF(0x038B3058, u0A66u0A74u0A6Fu0A6Du0A65u0A73u0A6Bu0A65u0A6Du0A72u0A72_c);
DO_TYPEDEF(0x038A3088, Converter_2_u0A71u0A72u0A6Eu0A69u0A6Bu0A69u0A72u0A6Fu0A72u0A66u0A6C_u0A6Eu0A74u0A6Fu0A68u0A6Au0A6Du0A67u0A6Eu0A6Cu0A66u0A70_);
DO_TYPEDEF(0x038889C8, u0A71u0A72u0A6Eu0A69u0A6Bu0A69u0A72u0A6Fu0A72u0A66u0A6C);
DO_TYPEDEF(0x038B3B98, u0A6Du0A6Bu0A6Au0A66u0A72u0A67u0A6Bu0A6Eu0A6Fu0A68u0A65_c);
DO_TYPEDEF(0x038A2FF8, Converter_2_u0A71u0A72u0A6Eu0A69u0A6Bu0A69u0A72u0A6Fu0A72u0A66u0A6C_u0A67u0A65u0A6Fu0A72u0A72u0A70u0A69u0A6Fu0A6Au0A6Au0A70_);
DO_TYPEDEF(0x03888898, u0A71u0A70u0A74u0A6Bu0A6Bu0A6Fu0A70u0A73u0A69u0A73u0A68);
DO_TYPEDEF(0x038B4258, u0A71u0A70u0A74u0A6Bu0A6Bu0A6Fu0A70u0A73u0A69u0A73u0A68_c);
DO_TYPEDEF(0x038B42E8, u0A71u0A70u0A74u0A6Bu0A6Bu0A6Fu0A70u0A73u0A69u0A73u0A68_u0A6Cu0A6Au0A73u0A69u0A65u0A67u0A66u0A74u0A67u0A6Au0A6E);
DO_TYPEDEF(0x03871B38, u0A71u0A72u0A6Eu0A69u0A6Bu0A69u0A72u0A6Fu0A72u0A66u0A6C__Array);
DO_TYPEDEF(0x038AEBB8, MeshVoxelizer);
DO_TYPEDEF(0x03870FF8, Vector3Int__Array);
DO_TYPEDEF(0x03873CF8, MeshVoxelizer_u0A72u0A70u0A74u0A73u0A69u0A65u0A6Cu0A70u0A6Au0A6Cu0A73__Enum__Array);
DO_TYPEDEF(0x0389D8C0, MeshVoxelizer_u0A6Au0A70u0A70u0A66u0A70u0A66u0A6Eu0A6Du0A72u0A67u0A6D);
DO_TYPEDEF(0x0389D958, MeshVoxelizer_u0A6Cu0A66u0A6Eu0A6Bu0A67u0A6Cu0A66u0A66u0A6Bu0A6Eu0A6D);
DO_TYPEDEF(0x038C65D8, Queue_1_UnityEngine_Vector3Int_);
DO_TYPEDEF(0x038759B0, Vector3Int__Array_1);
DO_TYPEDEF(0x038B4378, u0A71u0A73u0A6Fu0A66u0A70u0A6Du0A6Du0A6Cu0A74u0A74u0A72_u0A6Fu0A65u0A67u0A6Bu0A6Cu0A68u0A72u0A6Fu0A6Eu0A6Cu0A6E);
DO_TYPEDEF(0x03875880, Boolean__Array_1);
DO_TYPEDEF(0x03868D70, u0A74u0A70u0A71u0A71u0A6Du0A6Au0A65u0A6Fu0A70u0A68u0A68_u0A6Cu0A6Fu0A74u0A6Cu0A73u0A6Eu0A67u0A66u0A6Eu0A68u0A6C_u0A70u0A6Fu0A74u0A6Du0A73u0A6Eu0A74u0A74u0A66u0A72u0A6F_);
DO_TYPEDEF(0x038B3688, u0A6Cu0A6Fu0A74u0A6Cu0A73u0A6Eu0A67u0A66u0A6Eu0A68u0A6C_u0A70u0A6Fu0A74u0A6Du0A73u0A6Eu0A74u0A74u0A66u0A72u0A6F);
DO_TYPEDEF(0x038B00D8, Func_2_u0A6Cu0A6Fu0A74u0A6Cu0A73u0A6Eu0A67u0A66u0A6Eu0A68u0A6C_u0A70u0A6Fu0A74u0A6Du0A73u0A6Eu0A74u0A74u0A66u0A72u0A6F_Boolean_);
DO_TYPEDEF(0x038AF7D8, Func_2_UnityEngine_Vector3Int_Single_);
DO_TYPEDEF(0x038B3568, u0A6Cu0A6Fu0A74u0A6Cu0A73u0A6Eu0A67u0A66u0A6Eu0A68u0A6C_c);
DO_TYPEDEF(0x038B35F8, u0A6Cu0A6Fu0A74u0A6Cu0A73u0A6Eu0A67u0A66u0A6Eu0A68u0A6C_u0A65u0A6Au0A6Bu0A70u0A66u0A73u0A6Du0A6Au0A69u0A68u0A69);
DO_TYPEDEF(0x038B3B68, ObiInstancedParticleRenderer);
DO_TYPEDEF(0x038B48E8, ObiParticleRenderer);
DO_TYPEDEF(0x03888508, u0A71u0A6Fu0A66u0A73u0A73u0A74u0A66u0A74u0A73u0A6Au0A65);
DO_TYPEDEF(0x038BCB30, List_1_UnityEngine_Mesh_);
DO_TYPEDEF(0x038B38F8, IEnumerable_1_UnityEngine_Mesh_);
DO_TYPEDEF(0x03883790, u0A6Bu0A6Eu0A6Eu0A74u0A67u0A72u0A66u0A71u0A6Du0A6Du0A65);
DO_TYPEDEF(0x038BE3F0, List_1_UnityEngine_Ray_);
DO_TYPEDEF(0x0389FCF0, ObiSolver_c);
DO_TYPEDEF(0x038AFE08, Func_2_Obi_ObiSolver_ParticleInActor_Boolean_);
DO_TYPEDEF(0x038B51E8, ObiUpdater);
DO_TYPEDEF(0x038C21D0, List_1_u0A72u0A72u0A67u0A71u0A65u0A6Cu0A66u0A6Cu0A6Eu0A6Cu0A6C_);
DO_TYPEDEF(0x0389FA90, ObiLateFixedUpdater_u0A71u0A6Du0A6Du0A66u0A69u0A6Eu0A6Au0A72u0A71u0A68u0A66);
DO_TYPEDEF(0x038832D0, u0A6Bu0A68u0A65u0A6Cu0A6Cu0A65u0A6Du0A66u0A72u0A70u0A74);
DO_TYPEDEF(0x038B3CB8, u0A6Du0A6Fu0A68u0A74u0A67u0A71u0A6Du0A74u0A6Cu0A6Au0A6B_u0A74u0A70u0A68u0A66u0A69u0A66u0A67u0A69u0A69u0A6Au0A66);
DO_TYPEDEF(0x038B3C28, u0A6Du0A6Fu0A68u0A74u0A67u0A71u0A6Du0A74u0A6Cu0A6Au0A6B_u0A69u0A6Du0A66u0A6Eu0A67u0A6Du0A6Bu0A73u0A67u0A6Eu0A68);
DO_TYPEDEF(0x0389F8C8, ObiContactEventDispatcher_u0A6Cu0A65u0A6Fu0A6Fu0A67u0A72u0A6Fu0A65u0A6Au0A66u0A69);
DO_TYPEDEF(0x0389F830, ObiContactEventDispatcher_ContactCallback);
DO_TYPEDEF(0x0389FB28, ObiParticlePicker_u0A67u0A65u0A6Eu0A69u0A73u0A65u0A6Bu0A66u0A6Eu0A69u0A6A);
DO_TYPEDEF(0x038B4A98, ObiProfiler);
DO_TYPEDEF(0x038C33D0, List_1_Obi_ObiStitcher_Stitch_);
DO_TYPEDEF(0x038A0080, ObiStitcher_Stitch);
DO_TYPEDEF(0x038841A0, u0A6Cu0A71u0A68u0A68u0A6Cu0A6Fu0A6Au0A6Du0A72u0A6Du0A6B);
DO_TYPEDEF(0x038B3D48, u0A6Du0A70u0A6Bu0A71u0A6Au0A6Du0A65u0A67u0A6Fu0A6Du0A6D_u0A70u0A70u0A6Au0A6Du0A71u0A74u0A70u0A6Du0A69u0A72u0A6F);
DO_TYPEDEF(0x038859E0, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_2);
DO_TYPEDEF(0x038B90E0, PhotonHandler);
DO_TYPEDEF(0x038A3CB8, PhotonHandler_c);
DO_TYPEDEF(0x038C71D8, ServerSettings);
DO_TYPEDEF(0x038B7048, OwnershipOption__Enum);
DO_TYPEDEF(0x038B9B00, PhotonView);
DO_TYPEDEF(0x0386E090, MonoBehaviour__Array);
DO_TYPEDEF(0x038C6A58, Queue_1_Photon_Pun_PhotonView_CallbackTargetChange_);
DO_TYPEDEF(0x038A24E8, IOnPhotonViewPreNetDestroy);
DO_TYPEDEF(0x038A2458, IOnPhotonViewOwnerChange);
DO_TYPEDEF(0x038A23C8, IOnPhotonViewControllerChange);
DO_TYPEDEF(0x038C2440, RpcTarget__Enum);
DO_TYPEDEF(0x038B0E48, HashSet_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x0386E728, PhotonView__Array);
DO_TYPEDEF(0x038C4C00, NonAllocDictionary_2_System_Int32_Photon_Pun_PhotonView_);
DO_TYPEDEF(0x038A0900, Action_2_Photon_Pun_PhotonView_Photon_Realtime_Player_);
DO_TYPEDEF(0x038A2F08, IPunPrefabPool);
DO_TYPEDEF(0x038A3DD8, PhotonNetwork_SerializeViewBatch);
DO_TYPEDEF(0x038A3D48, PhotonNetwork_c);
DO_TYPEDEF(0x038AF128, Func_2_Photon_Realtime_Player_Int32_);
DO_TYPEDEF(0x038AF098, Func_2_Photon_Realtime_Player_Boolean_);
DO_TYPEDEF(0x038AE3B8, Func_2_Photon_Realtime_IConnectionCallbacks_String_);
DO_TYPEDEF(0x038B95F0, PhotonStreamQueue);
DO_TYPEDEF(0x038B9560, PhotonStream);
DO_TYPEDEF(0x038B9170, PhotonMessageInfo);
DO_TYPEDEF(0x038890B0, DefaultPool);
DO_TYPEDEF(0x038A73D8, Dictionary_2_System_String_UnityEngine_GameObject_);
DO_TYPEDEF(0x038C3A00, List_1_Photon_Pun_PhotonAnimatorView_SynchronizedParameter_);
DO_TYPEDEF(0x038A39E8, PhotonAnimatorView_SynchronizedParameter);
DO_TYPEDEF(0x038C3970, List_1_Photon_Pun_PhotonAnimatorView_SynchronizedLayer_);
DO_TYPEDEF(0x038A3958, PhotonAnimatorView_SynchronizedLayer);
DO_TYPEDEF(0x038A35F8, PhotonAnimatorView_c_DisplayClass18_0);
DO_TYPEDEF(0x038A3688, PhotonAnimatorView_c_DisplayClass19_0);
DO_TYPEDEF(0x038A3718, PhotonAnimatorView_c_DisplayClass22_0);
DO_TYPEDEF(0x038A37A8, PhotonAnimatorView_c_DisplayClass23_0);
DO_TYPEDEF(0x038A3838, PhotonAnimatorView_c_DisplayClass24_0);
DO_TYPEDEF(0x038A38C8, PhotonAnimatorView_c_DisplayClass25_0);
DO_TYPEDEF(0x038B9830, PhotonTransformViewPositionModel);
DO_TYPEDEF(0x038B9950, PhotonTransformViewRotationModel);
DO_TYPEDEF(0x038B9A70, PhotonTransformViewScaleModel);
DO_TYPEDEF(0x038B97A0, PhotonTransformViewPositionControl);
DO_TYPEDEF(0x038C6548, Queue_1_UnityEngine_Vector3_);
DO_TYPEDEF(0x038B98C0, PhotonTransformViewRotationControl);
DO_TYPEDEF(0x038B99E0, PhotonTransformViewScaleControl);
DO_TYPEDEF(0x03885BA8, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_3);
DO_TYPEDEF(0x038B7948, ParameterOverride);
DO_TYPEDEF(0x03876B78, AmbientOcclusionModeParameter);
DO_TYPEDEF(0x03876C10, AmbientOcclusionQualityParameter);
DO_TYPEDEF(0x038BB600, PostProcessEffectSettings);
DO_TYPEDEF(0x0387C518, BoolParameter);
DO_TYPEDEF(0x038B4F78, IEnumerator_1_UnityEngine_Rendering_PostProcessing_ParameterOverride_);
DO_TYPEDEF(0x038BB7B0, PostProcessRenderContext);
DO_TYPEDEF(0x03870548, Texture2D__Array);
DO_TYPEDEF(0x038A5578, PostProcessResources_Shaders);
DO_TYPEDEF(0x038A54E8, PostProcessResources_ComputeShaders);
DO_TYPEDEF(0x038BC260, PropertySheetFactory);
DO_TYPEDEF(0x038A6B68, Dictionary_2_UnityEngine_Shader_UnityEngine_Rendering_PostProcessing_PropertySheet_);
DO_TYPEDEF(0x038BC1D0, PropertySheet);
DO_TYPEDEF(0x038A66F8, Dictionary_2_UnityEngine_Rendering_PostProcessing_MonitorType_UnityEngine_Rendering_PostProcessing_Monitor_);
DO_TYPEDEF(0x0386F350, RenderTexture__Array);
DO_TYPEDEF(0x03869670, RenderTexture__Array__Array);
DO_TYPEDEF(0x038ABDD8, LogHistogram);
DO_TYPEDEF(0x03873FF8, Vector2Parameter);
DO_TYPEDEF(0x03897698, FloatParameter);
DO_TYPEDEF(0x03895EE8, EyeAdaptationParameter);
DO_TYPEDEF(0x03881040, ColorParameter);
DO_TYPEDEF(0x038BB570, PostProcessEffectRenderer);
DO_TYPEDEF(0x0389CA50, IAmbientOcclusionMethod);
DO_TYPEDEF(0x0386C6B0, IAmbientOcclusionMethod__Array);
DO_TYPEDEF(0x038C4A80, ScalableAO);
DO_TYPEDEF(0x038B10A8, MultiScaleVO);
DO_TYPEDEF(0x0386CC80, TextureParameter);
DO_TYPEDEF(0x03871D78, BloomRenderer_Level__Array);
DO_TYPEDEF(0x03899C00, GradingModeParameter);
DO_TYPEDEF(0x0386DFA0, TonemapperParameter);
DO_TYPEDEF(0x038743F0, Vector4Parameter);
DO_TYPEDEF(0x03866FD8, SplineParameter);
DO_TYPEDEF(0x03866F48, Spline);
DO_TYPEDEF(0x0389B328, HableCurve);
DO_TYPEDEF(0x038966C0, HableCurve_Segment);
DO_TYPEDEF(0x038729D8, HableCurve_Segment__Array);
DO_TYPEDEF(0x03896758, HableCurve_Uniforms);
DO_TYPEDEF(0x038A93E8, KernelSizeParameter);
DO_TYPEDEF(0x038A76D0, IntParameter);
DO_TYPEDEF(0x038C50B0, ScreenSpaceReflectionPresetParameter);
DO_TYPEDEF(0x038C5140, ScreenSpaceReflectionResolutionParameter);
DO_TYPEDEF(0x038A7168, ScreenSpaceReflectionsRenderer_QualityPreset);
DO_TYPEDEF(0x038743C0, ScreenSpaceReflectionsRenderer_QualityPreset__Array);
DO_TYPEDEF(0x038748B0, VignetteModeParameter);
DO_TYPEDEF(0x038BB4E0, PostProcessBundle);
DO_TYPEDEF(0x038A5338, PostProcessLayer_SerializedBundleRef);
DO_TYPEDEF(0x038A69C0, Dictionary_2_UnityEngine_Rendering_PostProcessing_PostProcessEvent_List_1_UnityEngine_Rendering_PostProcessing_PostProcessLayer_SerializedBundleRef_);
DO_TYPEDEF(0x038A8FD0, Dictionary_2_System_Type_UnityEngine_Rendering_PostProcessing_PostProcessBundle_);
DO_TYPEDEF(0x0386B7B8, TargetPool);
DO_TYPEDEF(0x038BDEE0, List_1_UnityEngine_Rendering_PostProcessing_PostProcessEffectRenderer_);
DO_TYPEDEF(0x038BEA20, List_1_UnityEngine_Rendering_RenderTargetIdentifier_);
DO_TYPEDEF(0x038A4FD8, PostProcessEffectSettings_c);
DO_TYPEDEF(0x038ADFC8, Func_2_System_Reflection_FieldInfo_Boolean_);
DO_TYPEDEF(0x038AE058, Func_2_System_Reflection_FieldInfo_Int32_);
DO_TYPEDEF(0x038BB690, PostProcessEventComparer);
DO_TYPEDEF(0x038BDF70, List_1_UnityEngine_Rendering_PostProcessing_PostProcessEffectSettings_);
DO_TYPEDEF(0x038A50F8, PostProcessLayer_c_DisplayClass54_0);
DO_TYPEDEF(0x038A5188, PostProcessLayer_c_DisplayClass54_1);
DO_TYPEDEF(0x038A5218, PostProcessLayer_c_DisplayClass54_2);
DO_TYPEDEF(0x038A52A8, PostProcessLayer_c_DisplayClass54_3);
DO_TYPEDEF(0x038A5068, PostProcessLayer_c);
DO_TYPEDEF(0x038ADAB8, Func_2_System_Collections_Generic_KeyValuePair_2_UnityEngine_Rendering_PostProcessing_PostProcessBundle_);
DO_TYPEDEF(0x038BB720, PostProcessManager);
DO_TYPEDEF(0x038A5098, Dictionary_2_System_Int32_List_1_UnityEngine_Rendering_PostProcessing_PostProcessVolume_);
DO_TYPEDEF(0x038BE000, List_1_UnityEngine_Rendering_PostProcessing_PostProcessVolume_);
DO_TYPEDEF(0x038B9E30, List_1_UnityEngine_Collider_);
DO_TYPEDEF(0x038A51B8, Dictionary_2_System_Int32_System_Boolean_);
DO_TYPEDEF(0x038A8F48, Dictionary_2_System_Type_UnityEngine_Rendering_PostProcessing_PostProcessAttribute_);
DO_TYPEDEF(0x038A53C8, PostProcessManager_c);
DO_TYPEDEF(0x038A5458, PostProcessProfile_c);
DO_TYPEDEF(0x038C5A10, Predicate_1_UnityEngine_Rendering_PostProcessing_PostProcessEffectSettings_);
DO_TYPEDEF(0x038A6E98, RuntimeUtilities_c);
DO_TYPEDEF(0x038ADBD8, Func_2_System_Reflection_Assembly_System_Collections_Generic_IEnumerable_1_);
DO_TYPEDEF(0x0386CBF0, TextureLerper);
DO_TYPEDEF(0x038BEAB0, List_1_UnityEngine_RenderTexture_);
DO_TYPEDEF(0x03896398, FastAction);
DO_TYPEDEF(0x038B7258, LinkedList_1_System_Action_);
DO_TYPEDEF(0x038A3D78, Dictionary_2_System_Action_LinkedListNode_1_System_Action_);
DO_TYPEDEF(0x038AD940, MaterialReferenceManager);
DO_TYPEDEF(0x038A5518, Dictionary_2_System_Int32_UnityEngine_Material_);
DO_TYPEDEF(0x038A5990, Dictionary_2_System_Int32_TMPro_TMP_FontAsset_);
DO_TYPEDEF(0x0386A4B0, TMP_FontAsset);
DO_TYPEDEF(0x038BADF0, List_1_UnityEngine_TextCore_Glyph_);
DO_TYPEDEF(0x038A9568, Dictionary_2_System_UInt32_UnityEngine_TextCore_Glyph_);
DO_TYPEDEF(0x038BF5F0, List_1_TMPro_TMP_Character_);
DO_TYPEDEF(0x0386A270, TMP_Character);
DO_TYPEDEF(0x038A9688, Dictionary_2_System_UInt32_TMPro_TMP_Character_);
DO_TYPEDEF(0x0386A6F0, TMP_Glyph);
DO_TYPEDEF(0x038A9508, KerningTable);
DO_TYPEDEF(0x038BC620, List_1_TMPro_KerningPair_);
DO_TYPEDEF(0x038A9478, KerningPair);
DO_TYPEDEF(0x0386A5D0, TMP_FontFeatureTable);
DO_TYPEDEF(0x038BF710, List_1_TMPro_TMP_GlyphPairAdjustmentRecord_);
DO_TYPEDEF(0x0386A780, TMP_GlyphPairAdjustmentRecord);
DO_TYPEDEF(0x038A9718, Dictionary_2_System_UInt32_TMPro_TMP_GlyphPairAdjustmentRecord_);
DO_TYPEDEF(0x038BF680, List_1_TMPro_TMP_FontAsset_);
DO_TYPEDEF(0x0386FE88, TMP_FontWeightPair__Array);
DO_TYPEDEF(0x038B17C8, HashSet_1_System_UInt32_);
DO_TYPEDEF(0x038A5A20, Dictionary_2_System_Int32_TMPro_TMP_SpriteAsset_);
DO_TYPEDEF(0x0386AC00, TMP_SpriteAsset);
DO_TYPEDEF(0x038A95F8, Dictionary_2_System_UInt32_System_Int32_);
DO_TYPEDEF(0x038BF7A0, List_1_TMPro_TMP_SpriteCharacter_);
DO_TYPEDEF(0x0386AC90, TMP_SpriteCharacter);
DO_TYPEDEF(0x038A97A8, Dictionary_2_System_UInt32_TMPro_TMP_SpriteCharacter_);
DO_TYPEDEF(0x038BF830, List_1_TMPro_TMP_SpriteGlyph_);
DO_TYPEDEF(0x0386AD18, TMP_SpriteGlyph);
DO_TYPEDEF(0x038A9838, Dictionary_2_System_UInt32_TMPro_TMP_SpriteGlyph_);
DO_TYPEDEF(0x038A5900, Dictionary_2_System_Int32_TMPro_TMP_ColorGradient_);
DO_TYPEDEF(0x0386A300, TMP_ColorGradient);
DO_TYPEDEF(0x0386FDF8, TMP_ColorGradient__Array);
DO_TYPEDEF(0x0386DCA0, MaterialReference__Array);
DO_TYPEDEF(0x0386B198, TMP_Vertex);
DO_TYPEDEF(0x0386AA50, TMP_Offset);
DO_TYPEDEF(0x0389BF08, HighlightState);
DO_TYPEDEF(0x0388D3C8, ColorTween_ColorTweenCallback_1);
DO_TYPEDEF(0x03894C20, FloatTween_FloatTweenCallback_1);
DO_TYPEDEF(0x03895E50, Extents);
DO_TYPEDEF(0x0386AE38, TMP_Text);
DO_TYPEDEF(0x038A3EC8, ITextPreprocessor);
DO_TYPEDEF(0x038BF8C0, List_1_TMPro_TMP_Style_);
DO_TYPEDEF(0x0386ADA8, TMP_Style);
DO_TYPEDEF(0x038A5AA8, Dictionary_2_System_Int32_TMPro_TMP_Style_);
DO_TYPEDEF(0x0386C620, HorizontalAlignmentOptions__Enum__Array);
DO_TYPEDEF(0x0386AEC8, TMP_TextInfo);
DO_TYPEDEF(0x0386FD68, TMP_CharacterInfo__Array);
DO_TYPEDEF(0x03870278, TMP_WordInfo__Array);
DO_TYPEDEF(0x0386FFA8, TMP_LinkInfo__Array);
DO_TYPEDEF(0x0386FF18, TMP_LineInfo__Array);
DO_TYPEDEF(0x038700C8, TMP_PageInfo__Array);
DO_TYPEDEF(0x0386A9C0, TMP_MeshInfo);
DO_TYPEDEF(0x03870038, TMP_MeshInfo__Array);
DO_TYPEDEF(0x038B0318, Func_3_Int32_String_TMPro_TMP_FontAsset_);
DO_TYPEDEF(0x038B03A8, Func_3_Int32_String_TMPro_TMP_SpriteAsset_);
DO_TYPEDEF(0x0389F600, Action_1_TMPro_TMP_TextInfo_);
DO_TYPEDEF(0x0386F500, RichTextTagAttribute__Array);
DO_TYPEDEF(0x038747E8, TMP_Text_UnicodeChar__Array);
DO_TYPEDEF(0x0386C590, HighlightState__Array);
DO_TYPEDEF(0x03869280, TMP_TextProcessingStack_1_System_Int32___Array);
DO_TYPEDEF(0x0386AD78, Decimal__Array);
DO_TYPEDEF(0x0386A420, TMP_Dropdown);
DO_TYPEDEF(0x038AC1E8, TMP_Dropdown_OptionDataList);
DO_TYPEDEF(0x038C3FA0, List_1_TMPro_TMP_Dropdown_OptionData_);
DO_TYPEDEF(0x038AC158, TMP_Dropdown_OptionData);
DO_TYPEDEF(0x038AC0D0, TMP_Dropdown_DropdownEvent);
DO_TYPEDEF(0x038C3F10, List_1_TMPro_TMP_Dropdown_DropdownItem_);
DO_TYPEDEF(0x03866CD8, TweenRunner_1_FloatTween__1);
DO_TYPEDEF(0x038ABFB0, TMP_Dropdown_c_DisplayClass69_0);
DO_TYPEDEF(0x038AC040, TMP_Dropdown_DelayedDestroyDropdownList_d_81);
DO_TYPEDEF(0x038AC278, TMP_FontAsset_c);
DO_TYPEDEF(0x038AF480, Func_2_TMPro_TMP_Character_UInt32_);
DO_TYPEDEF(0x038AE208, Func_2_UnityEngine_TextCore_Glyph_UInt32_);
DO_TYPEDEF(0x0389B488, KerningTable_c_DisplayClass3_0);
DO_TYPEDEF(0x0389B520, KerningTable_c_DisplayClass4_0);
DO_TYPEDEF(0x0389B5B8, KerningTable_c_DisplayClass5_0);
DO_TYPEDEF(0x0389B3F0, KerningTable_c);
DO_TYPEDEF(0x038AE948, Func_2_TMPro_KerningPair_UInt32_);
DO_TYPEDEF(0x0386A540, TMP_FontAssetUtilities);
DO_TYPEDEF(0x038AC308, TMP_FontFeatureTable_c);
DO_TYPEDEF(0x038AF510, Func_2_TMPro_TMP_GlyphPairAdjustmentRecord_UInt32_);
DO_TYPEDEF(0x0386A810, TMP_InputField);
DO_TYPEDEF(0x038AC5D8, TMP_InputField_SubmitEvent);
DO_TYPEDEF(0x038AC548, TMP_InputField_SelectionEvent);
DO_TYPEDEF(0x038AC668, TMP_InputField_TextSelectionEvent);
DO_TYPEDEF(0x038AC4B8, TMP_InputField_OnChangeEvent);
DO_TYPEDEF(0x038AC6F8, TMP_InputField_TouchScreenKeyboardEvent);
DO_TYPEDEF(0x03874750, TMP_InputField_ContentType__Enum__Array);
DO_TYPEDEF(0x038AC398, TMP_InputField_CaretBlink_d_276);
DO_TYPEDEF(0x038AC428, TMP_InputField_MouseDragOutsideRect_d_294);
DO_TYPEDEF(0x038AC9C8, TMP_MaterialManager_FallbackMaterial);
DO_TYPEDEF(0x038ACA58, TMP_MaterialManager_MaskingMaterial);
DO_TYPEDEF(0x038AC938, TMP_MaterialManager_c_DisplayClass9_0);
DO_TYPEDEF(0x038AC788, TMP_MaterialManager_c_DisplayClass11_0);
DO_TYPEDEF(0x038AC818, TMP_MaterialManager_c_DisplayClass12_0);
DO_TYPEDEF(0x038AC8A8, TMP_MaterialManager_c_DisplayClass13_0);
DO_TYPEDEF(0x038B5CF8, IList_1_System_Int32_);
DO_TYPEDEF(0x0386AB70, TMP_Settings);
DO_TYPEDEF(0x038ACAE8, TMP_Settings_LineBreakingTable);
DO_TYPEDEF(0x038A5248, Dictionary_2_System_Int32_System_Char_);
DO_TYPEDEF(0x0386AAE0, TMP_ResourceManager);
DO_TYPEDEF(0x038ACB78, TMP_SpriteAnimator_DoSpriteAnimationInternal_d_7);
DO_TYPEDEF(0x038ACC08, TMP_SpriteAsset_c);
DO_TYPEDEF(0x038AF628, Func_2_TMPro_TMP_SpriteGlyph_UInt32_);
DO_TYPEDEF(0x038AF598, Func_2_TMPro_TMP_SpriteCharacter_UInt32_);
DO_TYPEDEF(0x0386C6E0, TextMeshPro);
DO_TYPEDEF(0x03870158, TMP_SubMesh__Array);
DO_TYPEDEF(0x0386C770, TextMeshProUGUI);
DO_TYPEDEF(0x038701E8, TMP_SubMeshUI__Array);
DO_TYPEDEF(0x038ACC98, TMP_Text_c);
DO_TYPEDEF(0x0386AF58, TMP_TextParsingUtilities);
DO_TYPEDEF(0x0386B078, TMP_UpdateManager);
DO_TYPEDEF(0x038BF950, List_1_TMPro_TMP_Text_);
DO_TYPEDEF(0x0386B108, TMP_UpdateRegistry);
DO_TYPEDEF(0x0386C380, TextContainer);
DO_TYPEDEF(0x038AD618, TextMeshProUGUI_DelayedGraphicRebuild_d_89);
DO_TYPEDEF(0x038AD6A8, TextMeshProUGUI_DelayedMaterialRebuild_d_90);
DO_TYPEDEF(0x038ADA88, TexturePacker_JsonArray_Frame);
DO_TYPEDEF(0x03876030, ActionBasedController);
DO_TYPEDEF(0x03878D80, XRControllerState);
DO_TYPEDEF(0x03878CE8, XRController_1);
DO_TYPEDEF(0x038C0D90, List_1_UnityEngine_XR_Interaction_Toolkit_XRControllerState_);
DO_TYPEDEF(0x038A4978, IXRHoverInteractor);
DO_TYPEDEF(0x038A48E8, IXRHoverInteractable);
DO_TYPEDEF(0x038A4BB8, IXRSelectInteractor);
DO_TYPEDEF(0x038A4B28, IXRSelectInteractable);
DO_TYPEDEF(0x03879828, XRTintInteractableVisual);
DO_TYPEDEF(0x038A4A08, IXRInteractable);
DO_TYPEDEF(0x0389C168, HoverEnterEventArgs);
DO_TYPEDEF(0x038A4A98, IXRInteractor);
DO_TYPEDEF(0x03879238, XRInteractionManager);
DO_TYPEDEF(0x0389EE48, Action_1_UnityEngine_XR_Interaction_Toolkit_InteractorRegisteredEventArgs_);
DO_TYPEDEF(0x038A7F28, InteractorRegisteredEventArgs);
DO_TYPEDEF(0x0389EEE0, Action_1_UnityEngine_XR_Interaction_Toolkit_InteractorUnregisteredEventArgs_);
DO_TYPEDEF(0x038A7FB8, InteractorUnregisteredEventArgs);
DO_TYPEDEF(0x0389ED18, Action_1_UnityEngine_XR_Interaction_Toolkit_InteractableRegisteredEventArgs_);
DO_TYPEDEF(0x038A7AB8, InteractableRegisteredEventArgs);
DO_TYPEDEF(0x0389EDB0, Action_1_UnityEngine_XR_Interaction_Toolkit_InteractableUnregisteredEventArgs_);
DO_TYPEDEF(0x038A7B48, InteractableUnregisteredEventArgs);
DO_TYPEDEF(0x038C1060, List_1_UnityEngine_XR_Interaction_Toolkit_XRInteractionManager_);
DO_TYPEDEF(0x038A4318, Dictionary_2_UnityEngine_Collider_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_);
DO_TYPEDEF(0x038C7598, XRInteractionManager_RegistrationList_1_IXRInteractor_);
DO_TYPEDEF(0x038BBAE0, List_1_UnityEngine_XR_Interaction_Toolkit_IXRInteractor_);
DO_TYPEDEF(0x038C7508, XRInteractionManager_RegistrationList_1_IXRInteractable_);
DO_TYPEDEF(0x038BBA50, List_1_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_);
DO_TYPEDEF(0x038B0FF0, HashSet_1_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_);
DO_TYPEDEF(0x038BB930, List_1_UnityEngine_XR_Interaction_Toolkit_IXRHoverInteractable_);
DO_TYPEDEF(0x038BBB70, List_1_UnityEngine_XR_Interaction_Toolkit_IXRSelectInteractable_);
DO_TYPEDEF(0x038C0C70, List_1_UnityEngine_XR_Interaction_Toolkit_XRBaseInteractable_);
DO_TYPEDEF(0x03878BB8, XRBaseInteractable);
DO_TYPEDEF(0x0389C0D0, HoverEnterEvent);
DO_TYPEDEF(0x0389C200, HoverExitEvent);
DO_TYPEDEF(0x038C5B60, SelectEnterEvent);
DO_TYPEDEF(0x038C5C80, SelectExitEvent);
DO_TYPEDEF(0x038760C8, ActivateEvent);
DO_TYPEDEF(0x038880B0, DeactivateEvent);
DO_TYPEDEF(0x038BB9C0, List_1_UnityEngine_XR_Interaction_Toolkit_IXRHoverInteractor_);
DO_TYPEDEF(0x038BBC00, List_1_UnityEngine_XR_Interaction_Toolkit_IXRSelectInteractor_);
DO_TYPEDEF(0x038A4E58, Dictionary_2_UnityEngine_XR_Interaction_Toolkit_IXRSelectInteractor_UnityEngine_Pose_);
DO_TYPEDEF(0x038A4D38, Dictionary_2_UnityEngine_XR_Interaction_Toolkit_IXRInteractor_UnityEngine_GameObject_);
DO_TYPEDEF(0x038791A8, XRInteractableEvent);
DO_TYPEDEF(0x038C0D00, List_1_UnityEngine_XR_Interaction_Toolkit_XRBaseInteractor_);
DO_TYPEDEF(0x03878C50, XRBaseInteractor);
DO_TYPEDEF(0x038A4DC8, Dictionary_2_UnityEngine_XR_Interaction_Toolkit_IXRSelectInteractable_UnityEngine_Pose_);
DO_TYPEDEF(0x038B0F60, HashSet_1_UnityEngine_XR_Interaction_Toolkit_IXRHoverInteractable_);
DO_TYPEDEF(0x038B1078, HashSet_1_UnityEngine_XR_Interaction_Toolkit_IXRSelectInteractable_);
DO_TYPEDEF(0x038792D0, XRInteractorEvent);
DO_TYPEDEF(0x0389C298, HoverExitEventArgs);
DO_TYPEDEF(0x038C5BF0, SelectEnterEventArgs);
DO_TYPEDEF(0x038C5D10, SelectExitEventArgs);
DO_TYPEDEF(0x03876160, ActivateEventArgs);
DO_TYPEDEF(0x03888148, DeactivateEventArgs);
DO_TYPEDEF(0x038B7A38, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_SelectEnterEventArgs_);
DO_TYPEDEF(0x038AD0B8, Func_1_UnityEngine_XR_Interaction_Toolkit_SelectEnterEventArgs_);
DO_TYPEDEF(0x038B7AC8, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_SelectExitEventArgs_);
DO_TYPEDEF(0x038AD140, Func_1_UnityEngine_XR_Interaction_Toolkit_SelectExitEventArgs_);
DO_TYPEDEF(0x038B76D8, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_HoverEnterEventArgs_);
DO_TYPEDEF(0x038ACA88, Func_1_UnityEngine_XR_Interaction_Toolkit_HoverEnterEventArgs_);
DO_TYPEDEF(0x038B7768, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_HoverExitEventArgs_);
DO_TYPEDEF(0x038ACB18, Func_1_UnityEngine_XR_Interaction_Toolkit_HoverExitEventArgs_);
DO_TYPEDEF(0x038B7918, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_InteractorRegisteredEventArgs_);
DO_TYPEDEF(0x038ACE78, Func_1_UnityEngine_XR_Interaction_Toolkit_InteractorRegisteredEventArgs_);
DO_TYPEDEF(0x038B79A8, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_InteractorUnregisteredEventArgs_);
DO_TYPEDEF(0x038ACF08, Func_1_UnityEngine_XR_Interaction_Toolkit_InteractorUnregisteredEventArgs_);
DO_TYPEDEF(0x038B77F8, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_InteractableRegisteredEventArgs_);
DO_TYPEDEF(0x038ACD58, Func_1_UnityEngine_XR_Interaction_Toolkit_InteractableRegisteredEventArgs_);
DO_TYPEDEF(0x038B7888, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_InteractableUnregisteredEventArgs_);
DO_TYPEDEF(0x038ACDE8, Func_1_UnityEngine_XR_Interaction_Toolkit_InteractableUnregisteredEventArgs_);
DO_TYPEDEF(0x0389EF78, Action_1_UnityEngine_XR_Interaction_Toolkit_LocomotionSystem_);
DO_TYPEDEF(0x038A1518, ILineRenderable);
DO_TYPEDEF(0x03878B20, XRBaseControllerInteractor);
DO_TYPEDEF(0x038B75B8, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_ActivateEventArgs_);
DO_TYPEDEF(0x038AC8D8, Func_1_UnityEngine_XR_Interaction_Toolkit_ActivateEventArgs_);
DO_TYPEDEF(0x038B7648, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_DeactivateEventArgs_);
DO_TYPEDEF(0x038AC9F8, Func_1_UnityEngine_XR_Interaction_Toolkit_DeactivateEventArgs_);
DO_TYPEDEF(0x038BB8A0, List_1_UnityEngine_XR_Interaction_Toolkit_IXRActivateInteractable_);
DO_TYPEDEF(0x038A4738, IXRActivateInteractable);
DO_TYPEDEF(0x038B1CA8, XRBaseControllerInteractor_c);
DO_TYPEDEF(0x03878F48, XRDirectInteractor);
DO_TYPEDEF(0x0386F4A0, TriggerContactMonitor);
DO_TYPEDEF(0x0389EAB8, Action_1_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_);
DO_TYPEDEF(0x038B0C10, HashSet_1_UnityEngine_Collider_);
DO_TYPEDEF(0x038B1D38, XRDirectInteractor_UpdateCollidersAfterOnTriggerStay_d_11);
DO_TYPEDEF(0x03879660, XRRayInteractor);
DO_TYPEDEF(0x038798C0, XRUIInputModule);
DO_TYPEDEF(0x038A0A30, Action_2_UnityEngine_EventSystems_PointerEventData_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x038A04D8, Action_2_UnityEngine_GameObject_UnityEngine_EventSystems_PointerEventData_);
DO_TYPEDEF(0x038A0440, Action_2_UnityEngine_GameObject_UnityEngine_EventSystems_BaseEventData_);
DO_TYPEDEF(0x038A03A8, Action_2_UnityEngine_GameObject_UnityEngine_EventSystems_AxisEventData_);
DO_TYPEDEF(0x038A5CE8, Dictionary_2_System_Int32_UnityEngine_XR_Interaction_Toolkit_UI_TrackedDeviceEventData_);
DO_TYPEDEF(0x0386EC30, TrackedDeviceEventData);
DO_TYPEDEF(0x038C45D0, List_1_UnityEngine_XR_Interaction_Toolkit_UI_XRUIInputModule_RegisteredTouch_);
DO_TYPEDEF(0x038B2368, XRUIInputModule_RegisteredTouch);
DO_TYPEDEF(0x038C4540, List_1_UnityEngine_XR_Interaction_Toolkit_UI_XRUIInputModule_RegisteredInteractor_);
DO_TYPEDEF(0x0386ED50, TrackedDeviceModel);
DO_TYPEDEF(0x038B22D8, XRUIInputModule_RegisteredInteractor);
DO_TYPEDEF(0x038A43D8, IUIInteractor);
DO_TYPEDEF(0x038B2008, XRRayInteractor_RaycastHitComparer);
DO_TYPEDEF(0x038C44B0, List_1_UnityEngine_XR_Interaction_Toolkit_XRRayInteractor_SamplePoint_);
DO_TYPEDEF(0x038B2098, XRRayInteractor_SamplePoint);
DO_TYPEDEF(0x03879790, XRSocketInteractor);
DO_TYPEDEF(0x038A4C18, Dictionary_2_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_System_ValueTuple_2_);
DO_TYPEDEF(0x038693A0, ValueTuple_2_UnityEngine_MeshFilter_UnityEngine_Renderer___Array);
DO_TYPEDEF(0x038BCC50, List_1_UnityEngine_MeshFilter_);
DO_TYPEDEF(0x038B2128, XRSocketInteractor_UpdateCollidersAfterOnTriggerStay_d_38);
DO_TYPEDEF(0x038C5530, ScriptableSettingsBase_1);
DO_TYPEDEF(0x0386BD58, TeleportingEvent);
DO_TYPEDEF(0x0386BDE8, TeleportingEventArgs);
DO_TYPEDEF(0x038A47C8, IXRActivateInteractor);
DO_TYPEDEF(0x038B1DC8, XRInteractionManager_c);
DO_TYPEDEF(0x038796F8, XRRig);
DO_TYPEDEF(0x03889F88, DeviceBasedContinuousMoveProvider);
DO_TYPEDEF(0x038C0BE0, List_1_UnityEngine_XR_Interaction_Toolkit_XRBaseController_);
DO_TYPEDEF(0x03868E00, InputFeatureUsage_1_UnityEngine_Vector2___Array);
DO_TYPEDEF(0x0388A020, DeviceBasedContinuousTurnProvider);
DO_TYPEDEF(0x0388A0B8, DeviceBasedSnapTurnProvider);
DO_TYPEDEF(0x038B7B58, LinkedPool_1_UnityEngine_XR_Interaction_Toolkit_TeleportingEventArgs_);
DO_TYPEDEF(0x038AD2F0, Func_1_UnityEngine_XR_Interaction_Toolkit_TeleportingEventArgs_);
DO_TYPEDEF(0x0388C468, BaseTeleportationInteractable_c);
DO_TYPEDEF(0x0386ECC0, TrackedDeviceGraphicRaycaster);
DO_TYPEDEF(0x038AE918, TrackedDeviceGraphicRaycaster_RaycastHitComparer);
DO_TYPEDEF(0x038AE9A8, TrackedDeviceGraphicRaycaster_RaycastHitData);
DO_TYPEDEF(0x038C41E0, List_1_UnityEngine_XR_Interaction_Toolkit_UI_TrackedDeviceGraphicRaycaster_RaycastHitData_);
DO_TYPEDEF(0x038AEAC8, TrackedDevicePhysicsRaycaster_RaycastHitComparer);
DO_TYPEDEF(0x038AEA38, TrackedDevicePhysicsRaycaster_RaycastHitArraySegment);
DO_TYPEDEF(0x038BE480, List_1_UnityEngine_RaycastHit_);
DO_TYPEDEF(0x038C5770, SectorInteraction);
DO_TYPEDEF(0x038B6748, OpenXRSettings);
DO_TYPEDEF(0x038B63E8, OpenXRFeature);
DO_TYPEDEF(0x0386E3F0, OpenXRFeature__Array);
DO_TYPEDEF(0x038BD9D0, List_1_UnityEngine_XR_OpenXR_Features_OpenXRFeature_);
DO_TYPEDEF(0x038A0B30, OpenXRAnalytics_c);
DO_TYPEDEF(0x038AEE58, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRFeature_Boolean_);
DO_TYPEDEF(0x038AEF78, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRFeature_String_);
DO_TYPEDEF(0x0388A1E8, DiagnosticReport);
DO_TYPEDEF(0x038A0CF8, OpenXRFeature_NativeEvent__Enum);
DO_TYPEDEF(0x038B6598, OpenXRLoaderBase);
DO_TYPEDEF(0x038C0EB0, List_1_UnityEngine_XR_XRDisplaySubsystemDescriptor_);
DO_TYPEDEF(0x038C0FD0, List_1_UnityEngine_XR_XRInputSubsystemDescriptor_);
DO_TYPEDEF(0x038C3850, List_1_UnityEngine_XR_OpenXR_OpenXRLoaderBase_LoaderState_);
DO_TYPEDEF(0x038A11B8, OpenXRLoaderBase_ReceiveNativeEventDelegate);
DO_TYPEDEF(0x038A1120, OpenXRLoaderBase_c);
DO_TYPEDEF(0x038AEEE8, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRFeature_Int32_);
DO_TYPEDEF(0x038B6628, OpenXRRestarter);
DO_TYPEDEF(0x038A1250, OpenXRRestarter_RestartCoroutine_d_13);
DO_TYPEDEF(0x038B6508, OpenXRInteractionFeature);
DO_TYPEDEF(0x038C3730, List_1_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_ActionMapConfig_);
DO_TYPEDEF(0x038A0FF0, OpenXRInteractionFeature_ActionMapConfig);
DO_TYPEDEF(0x038C37C0, List_1_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_DeviceConfig_);
DO_TYPEDEF(0x038A1088, OpenXRInteractionFeature_DeviceConfig);
DO_TYPEDEF(0x038C36A0, List_1_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_ActionConfig_);
DO_TYPEDEF(0x038A0F58, OpenXRInteractionFeature_ActionConfig);
DO_TYPEDEF(0x038C3610, List_1_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_ActionBinding_);
DO_TYPEDEF(0x038A0EC0, OpenXRInteractionFeature_ActionBinding);
DO_TYPEDEF(0x038A0E28, OpenXRInput_SerializedBinding);
DO_TYPEDEF(0x038A0D90, OpenXRInput_c);
DO_TYPEDEF(0x038AF008, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_Boolean_);
DO_TYPEDEF(0x038AFFB8, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_DeviceConfig_String_);
DO_TYPEDEF(0x038AFF28, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_ActionBinding_Boolean_);
DO_TYPEDEF(0x038AFE98, Func_2_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_ActionBinding_System_Collections_Generic_IEnumerable_1_);
DO_TYPEDEF(0x038A0C60, OpenXRFeature_LoaderEvent__Enum);
DO_TYPEDEF(0x038996A8, GlobalWind);
DO_TYPEDEF(0x038A16D8, ILog);
DO_TYPEDEF(0x038ABF80, Logger_1);
DO_TYPEDEF(0x038C7E08, Stack_1_System_Diagnostics_Stopwatch_);
DO_TYPEDEF(0x038A5960, QualitySettings_InteractionQuality);
DO_TYPEDEF(0x038A0148, Action_1_VisualDesignCafe_Nature_QualitySettings_InteractionQuality_);
DO_TYPEDEF(0x038A58D0, QualitySettings_GraphicsQuality);
DO_TYPEDEF(0x038A00B0, Action_1_VisualDesignCafe_Nature_QualitySettings_GraphicsQuality_);
DO_TYPEDEF(0x038A59F0, QualitySettings_OverlayQuality);
DO_TYPEDEF(0x038A01E0, Action_1_VisualDesignCafe_Nature_QualitySettings_OverlayQuality_);
DO_TYPEDEF(0x038C2950, RuntimeEntryPoint);
DO_TYPEDEF(0x038C7808, ShaderResources);
DO_TYPEDEF(0x038A6D78, RuntimeGlobalWindInitializer_c);
DO_TYPEDEF(0x038AE178, Func_2_UnityEngine_GameObject_Boolean_);
DO_TYPEDEF(0x038A7938, ShaderResources_c_DisplayClass9_0);
DO_TYPEDEF(0x038B1EB8, NatureOverlay);
DO_TYPEDEF(0x038BB540, List_1_VisualDesignCafe_Nature_Rendering_IInstance_);
DO_TYPEDEF(0x038A0770, IInstance);
DO_TYPEDEF(0x038B6E08, OverlayCamera);
DO_TYPEDEF(0x038B6E98, OverlayEntryPoint);
DO_TYPEDEF(0x038A5E98, Dictionary_2_System_Int32_VisualDesignCafe_Nature_Overlay_OverlayEntryPoint_PerCameraData_);
DO_TYPEDEF(0x038A1548, OverlayEntryPoint_PerCameraData);
DO_TYPEDEF(0x038B6F28, OverlayRenderer);
DO_TYPEDEF(0x038A1678, OverlayRenderer_OverlayDrawCall);
DO_TYPEDEF(0x0389E6C8, ICuller);
DO_TYPEDEF(0x038B6FB8, OverlayZone);
DO_TYPEDEF(0x038A15E0, OverlayRenderer_OverlayCuller);
DO_TYPEDEF(0x038A7BD8, InteractionCamera);
DO_TYPEDEF(0x038A7CF0, InteractionEntryPoint);
DO_TYPEDEF(0x038A5E08, Dictionary_2_System_Int32_VisualDesignCafe_Nature_Interaction_InteractionEntryPoint_PerCameraData_);
DO_TYPEDEF(0x0389AE00, InteractionEntryPoint_PerCameraData);
DO_TYPEDEF(0x038A7E10, InteractionRenderer);
DO_TYPEDEF(0x0389AF30, InteractionRenderer_InteractionDrawCall);
DO_TYPEDEF(0x038A7E98, InteractionZone);
DO_TYPEDEF(0x038B1E28, NatureCollider);
DO_TYPEDEF(0x0389AE98, InteractionRenderer_InteractionCuller);
DO_TYPEDEF(0x038C1A20, ResourceManager_1);
DO_TYPEDEF(0x038BD940, List_1_UnityEngine_Object_);
DO_TYPEDEF(0x03885818, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_4);
DO_TYPEDEF(0x0387F6C8, ChannelCreationOptions);
DO_TYPEDEF(0x0387FCB8, ChatChannel);
DO_TYPEDEF(0x0387FE78, ChatState__Enum);
DO_TYPEDEF(0x038844F8, CustomAuthenticationType__Enum_1);
DO_TYPEDEF(0x03879CB8, AuthenticationValues_1);
DO_TYPEDEF(0x038A6FE8, Dictionary_2_System_String_Photon_Chat_ChatChannel_);
DO_TYPEDEF(0x0389D598, IChatClientListener);
DO_TYPEDEF(0x0387FD50, ChatPeer);
DO_TYPEDEF(0x03885A78, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_5);
DO_TYPEDEF(0x0387F338, CellTree);
DO_TYPEDEF(0x0387F3D0, CellTreeNode);
DO_TYPEDEF(0x038B9C80, List_1_Photon_Pun_UtilityScripts_CellTreeNode_);
DO_TYPEDEF(0x038BAE20, PointedAtGameObjectInfo);
DO_TYPEDEF(0x038679F8, StatesGui);
DO_TYPEDEF(0x038B9680, PhotonTeam);
DO_TYPEDEF(0x038A0998, Action_2_Photon_Realtime_Player_Photon_Pun_UtilityScripts_PhotonTeam_);
DO_TYPEDEF(0x038B9710, PhotonTeamsManager);
DO_TYPEDEF(0x038BDCA0, List_1_Photon_Pun_UtilityScripts_PhotonTeam_);
DO_TYPEDEF(0x038A3FB8, Dictionary_2_System_Byte_Photon_Pun_UtilityScripts_PhotonTeam_);
DO_TYPEDEF(0x038A77B8, Dictionary_2_System_String_Photon_Pun_UtilityScripts_PhotonTeam_);
DO_TYPEDEF(0x038A3E08, Dictionary_2_System_Byte_HashSet_1_Photon_Realtime_Player_);
DO_TYPEDEF(0x038B1588, HashSet_1_Photon_Realtime_Player_);
DO_TYPEDEF(0x038A4C78, PlayerNumbering_PlayerNumberingChanged);
DO_TYPEDEF(0x038BAAC0, PlayerNumbering);
DO_TYPEDEF(0x038A4BE8, PlayerNumbering_c);
DO_TYPEDEF(0x038BCEC0, PunTeams);
DO_TYPEDEF(0x038AA008, Dictionary_2_Photon_Pun_UtilityScripts_PunTeams_Team_List_1_Photon_Realtime_Player_);
DO_TYPEDEF(0x038A5840, PunTeams_Team__Enum);
DO_TYPEDEF(0x038BDE50, List_1_Photon_Realtime_Player_);
DO_TYPEDEF(0x038A0A00, OnClickDestroy_DestroyRpc_d_4);
DO_TYPEDEF(0x038A0A98, OnClickRpc_ClickFlash_d_8);
DO_TYPEDEF(0x038BFDD0, List_1_UnityEngine_Transform_);
DO_TYPEDEF(0x038C7B38, Stack_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x0388DB80, CountdownTimer_CountdownTimerHasExpired);
DO_TYPEDEF(0x038836C8, CountdownTimer);
DO_TYPEDEF(0x038A2F98, IPunTurnManagerCallbacks);
DO_TYPEDEF(0x038A86D8, Dictionary_2_UnityEngine_UI_Toggle_Photon_Pun_UtilityScripts_TabViewManager_Tab_);
DO_TYPEDEF(0x038ACD28, TabViewManager_c_DisplayClass7_0);
DO_TYPEDEF(0x03885C38, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_6);
DO_TYPEDEF(0x03885CD0, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_7);
DO_TYPEDEF(0x03890FA0, DataPrivacy_UserPostData);
DO_TYPEDEF(0x03890F08, DataPrivacy_c_DisplayClass9_0);
DO_TYPEDEF(0x038BEFF0, RebindActionUI);
DO_TYPEDEF(0x038A5DD8, RebindActionUI_UpdateBindingUIEvent);
DO_TYPEDEF(0x038A5D48, RebindActionUI_InteractiveRebindEvent);
DO_TYPEDEF(0x038BE5A0, List_1_UnityEngine_InputSystem_Samples_RebindUI_RebindActionUI_);
DO_TYPEDEF(0x038A5EF8, RebindActionUI_u0A71u0A72u0A6Du0A67u0A71u0A6Au0A6Du0A71u0A6Du0A6Eu0A6C);
DO_TYPEDEF(0x038A5E68, RebindActionUI_u0A6Eu0A71u0A6Au0A6Au0A74u0A6Eu0A6Fu0A72u0A69u0A65u0A73);
DO_TYPEDEF(0x03885D68, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_8);
DO_TYPEDEF(0x03882038, ConformanceAutomationFeature);
DO_TYPEDEF(0x0389DEB0, MockRuntime_ScriptEventDelegate);
DO_TYPEDEF(0x0389DE18, MockRuntime_ScriptEvent__Enum);
DO_TYPEDEF(0x038B0108, MockRuntime);
DO_TYPEDEF(0x038A8378, Dictionary_2_System_String_UnityEngine_XR_OpenXR_Features_Mock_MockRuntime_AfterFunctionDelegate_);
DO_TYPEDEF(0x0389DCE8, MockRuntime_AfterFunctionDelegate);
DO_TYPEDEF(0x0387E360, XrResult__Enum);
DO_TYPEDEF(0x038A8408, Dictionary_2_System_String_UnityEngine_XR_OpenXR_Features_Mock_MockRuntime_BeforeFunctionDelegate_);
DO_TYPEDEF(0x0389DD80, MockRuntime_BeforeFunctionDelegate);
DO_TYPEDEF(0x038C28C0, RuntimeDebuggerOpenXRFeature);
DO_TYPEDEF(0x03892A48, ES3AutoSave_c);
DO_TYPEDEF(0x0388BEF0, ES3AutoSaveMgr);
DO_TYPEDEF(0x03892918, ES3_Location__Enum);
DO_TYPEDEF(0x038927E8, ES3_EncryptionType__Enum);
DO_TYPEDEF(0x038926B8, ES3_CompressionType__Enum);
DO_TYPEDEF(0x03892750, ES3_Directory__Enum);
DO_TYPEDEF(0x03892880, ES3_Format__Enum);
DO_TYPEDEF(0x038929B0, ES3_ReferenceMode__Enum);
DO_TYPEDEF(0x0388CE40, ES3Settings);
DO_TYPEDEF(0x0388CDA8, ES3SerializableSettings);
DO_TYPEDEF(0x038B0D28, HashSet_1_ES3AutoSave_);
DO_TYPEDEF(0x0388C600, ES3Member);
DO_TYPEDEF(0x0386B288, ES3Member__Array);
DO_TYPEDEF(0x0388DC80, ES3Type_ES3Prefab);
DO_TYPEDEF(0x0388C148, ES3File);
DO_TYPEDEF(0x038A7198, Dictionary_2_System_String_ES3File_);
DO_TYPEDEF(0x038A7108, Dictionary_2_System_String_ES3Internal_ES3Data_);
DO_TYPEDEF(0x038B6EF8, KeyValuePair_2_System_String_ES3Internal_ES3Data_);
DO_TYPEDEF(0x0388C988, ES3ReferenceMgrBase);
DO_TYPEDEF(0x038B0DB8, HashSet_1_ES3Internal_ES3ReferenceMgrBase_);
DO_TYPEDEF(0x038BA4F0, List_1_ES3Internal_ES3Prefab_);
DO_TYPEDEF(0x0388C730, ES3Prefab);
DO_TYPEDEF(0x0388C8F0, ES3RefIdDictionary);
DO_TYPEDEF(0x0388C3A0, ES3IdRefDictionary);
DO_TYPEDEF(0x0388CED8, ES3Spreadsheet);
DO_TYPEDEF(0x038A9E58, Dictionary_2_ES3Spreadsheet_Index_System_String_);
DO_TYPEDEF(0x0388C438, ES3JSONReader);
DO_TYPEDEF(0x03893038, ES3Reader_ES3ReaderPropertyEnumerator);
DO_TYPEDEF(0x038930D0, ES3Reader_ES3ReaderRawEnumerator);
DO_TYPEDEF(0x038B4AC8, ES3Reader_ES3ReaderPropertyEnumerator_GetEnumerator_d_2);
DO_TYPEDEF(0x038B4B58, ES3Reader_ES3ReaderRawEnumerator_GetEnumerator_d_2);
DO_TYPEDEF(0x0386B3A0, Enum__Array);
DO_TYPEDEF(0x0388C858, ES3Ref);
DO_TYPEDEF(0x038B8450, List_1_KeyValuePair_2_System_String_System_String_);
DO_TYPEDEF(0x03892F08, ES3Cloud_Sync_d_20);
DO_TYPEDEF(0x03892FA0, ES3Cloud_UploadFile_d_33);
DO_TYPEDEF(0x03892B78, ES3Cloud_DownloadFile_d_44);
DO_TYPEDEF(0x03892C10, ES3Cloud_DownloadFile_d_45);
DO_TYPEDEF(0x03892AE0, ES3Cloud_DeleteFile_d_53);
DO_TYPEDEF(0x03892DD8, ES3Cloud_RenameFile_d_60);
DO_TYPEDEF(0x03892CA8, ES3Cloud_DownloadFilenames_d_61);
DO_TYPEDEF(0x03892E70, ES3Cloud_SearchFilenames_d_62);
DO_TYPEDEF(0x03892D40, ES3Cloud_DownloadTimestamp_d_70);
DO_TYPEDEF(0x03896A20, FileBasedPrefsSaveFileModel);
DO_TYPEDEF(0x038949C0, FileBasedPrefsSaveFileModel_StringItem);
DO_TYPEDEF(0x03872678, FileBasedPrefsSaveFileModel_StringItem__Array);
DO_TYPEDEF(0x03894928, FileBasedPrefsSaveFileModel_IntItem);
DO_TYPEDEF(0x038725E8, FileBasedPrefsSaveFileModel_IntItem__Array);
DO_TYPEDEF(0x03894890, FileBasedPrefsSaveFileModel_FloatItem);
DO_TYPEDEF(0x03872558, FileBasedPrefsSaveFileModel_FloatItem__Array);
DO_TYPEDEF(0x038947F8, FileBasedPrefsSaveFileModel_BoolItem);
DO_TYPEDEF(0x038724C8, FileBasedPrefsSaveFileModel_BoolItem__Array);
DO_TYPEDEF(0x038B0F00, MouseLook);
DO_TYPEDEF(0x03896270, FOVKick);
DO_TYPEDEF(0x03884208, CurveControlledBob);
DO_TYPEDEF(0x03871CE8, AutoMobileShaderSwitch_ReplacementDefinition__Array);
DO_TYPEDEF(0x03892030, DragRigidbody_DragObject_d_8);
DO_TYPEDEF(0x038AA398, LerpControlledBob);
DO_TYPEDEF(0x0389BA78, LerpControlledBob_DoBobCycle_d_4);
DO_TYPEDEF(0x038A0838, ObjectResetter_ResetCoroutine_d_6);
DO_TYPEDEF(0x038A3208, ParticleSystemDestroyer_Start_d_4);
DO_TYPEDEF(0x0386E590, ParticleSystem__Array);
DO_TYPEDEF(0x038AE028, TimedObjectActivator_Entries);
DO_TYPEDEF(0x038ADE78, TimedObjectActivator_Activate_d_5);
DO_TYPEDEF(0x038ADF08, TimedObjectActivator_Deactivate_d_6);
DO_TYPEDEF(0x038ADF98, TimedObjectActivator_ReloadLevel_d_7);
DO_TYPEDEF(0x038B1438, WaypointCircuit_WaypointList);
DO_TYPEDEF(0x03894500, ExplosionFireAndDebris_Start_d_4);
DO_TYPEDEF(0x03894598, ExplosionPhysicsForce_Start_d_1);
DO_TYPEDEF(0x03894630, Explosive_OnCollisionEnter_d_8);
DO_TYPEDEF(0x03875CD8, WaterHoseParticles);
DO_TYPEDEF(0x0387C2B8, Blur);
DO_TYPEDEF(0x0387E888, CameraMotionBlur);
DO_TYPEDEF(0x03889868, DepthOfFieldDeprecated);
DO_TYPEDEF(0x038B2968, NoiseAndGrain);
DO_TYPEDEF(0x038BD190, Quads);
DO_TYPEDEF(0x0386F410, Triangles);
DO_TYPEDEF(0x0388B648, AmbientOcclusion_Settings);
DO_TYPEDEF(0x038A6F28, SMAA_QualitySettings);
DO_TYPEDEF(0x038C40F0, SMAA);
DO_TYPEDEF(0x03874328, SMAA_QualitySettings__Array);
DO_TYPEDEF(0x03894760, FXAA_Preset);
DO_TYPEDEF(0x03896300, FXAA);
DO_TYPEDEF(0x03872438, FXAA_Preset__Array);
DO_TYPEDEF(0x0389CAE8, IAntiAliasing);
DO_TYPEDEF(0x038C15A0, RenderTextureUtility);
DO_TYPEDEF(0x03891A50, DepthOfField_QualitySettings);
DO_TYPEDEF(0x038720D8, DepthOfField_QualitySettings__Array);
DO_TYPEDEF(0x038A70D8, ScreenSpaceReflection_SSRSettings);
DO_TYPEDEF(0x038C5020, ScreenSpaceReflection);
DO_TYPEDEF(0x0388DD48, CrossPlatformInputManager_VirtualAxis);
DO_TYPEDEF(0x0388DDE0, CrossPlatformInputManager_VirtualButton);
DO_TYPEDEF(0x038A8138, Dictionary_2_System_String_UnityStandardAssets_CrossPlatformInput_CrossPlatformInputManager_VirtualAxis_);
DO_TYPEDEF(0x038A81C8, Dictionary_2_System_String_UnityStandardAssets_CrossPlatformInput_CrossPlatformInputManager_VirtualButton_);
DO_TYPEDEF(0x038B0078, MobileInput);
DO_TYPEDEF(0x03867848, StandaloneInput);
DO_TYPEDEF(0x038A6BC8, RigidbodyFirstPersonController_MovementSettings);
DO_TYPEDEF(0x038A6B38, RigidbodyFirstPersonController_AdvancedSettings);
DO_TYPEDEF(0x038A5698, ProtectCameraFromWallClip_RayHitComparer);
DO_TYPEDEF(0x0387D770, CCallbackBase);
DO_TYPEDEF(0x0387D800, CCallbackBaseVTable);
DO_TYPEDEF(0x0388CB78, CCallbackBaseVTable_RunCRDel);
DO_TYPEDEF(0x0388CAE0, CCallbackBaseVTable_RunCBDel);
DO_TYPEDEF(0x0388CA48, CCallbackBaseVTable_GetCallbackSizeBytesDel);
DO_TYPEDEF(0x0387E6C0, CallbackIdentityAttribute);
DO_TYPEDEF(0x03898800, ISteamMatchmakingServerListResponse_VTable);
DO_TYPEDEF(0x03898768, ISteamMatchmakingServerListResponse_InternalServerResponded);
DO_TYPEDEF(0x0389ADD0, HServerListRequest);
DO_TYPEDEF(0x038986D0, ISteamMatchmakingServerListResponse_InternalServerFailedToRespond);
DO_TYPEDEF(0x03898638, ISteamMatchmakingServerListResponse_InternalRefreshComplete);
DO_TYPEDEF(0x0388BC90, EMatchMakingServerResponse__Enum);
DO_TYPEDEF(0x038980E0, ISteamMatchmakingPingResponse_VTable);
DO_TYPEDEF(0x03898048, ISteamMatchmakingPingResponse_InternalServerResponded);
DO_TYPEDEF(0x0387EC48, servernetadr_t);
DO_TYPEDEF(0x0387E0D8, CSteamID);
DO_TYPEDEF(0x0387E9E8, gameserveritem_t);
DO_TYPEDEF(0x03897FB0, ISteamMatchmakingPingResponse_InternalServerFailedToRespond);
DO_TYPEDEF(0x03898340, ISteamMatchmakingPlayersResponse_VTable);
DO_TYPEDEF(0x03898178, ISteamMatchmakingPlayersResponse_InternalAddPlayerToList);
DO_TYPEDEF(0x03898210, ISteamMatchmakingPlayersResponse_InternalPlayersFailedToRespond);
DO_TYPEDEF(0x038982A8, ISteamMatchmakingPlayersResponse_InternalPlayersRefreshComplete);
DO_TYPEDEF(0x038985A0, ISteamMatchmakingRulesResponse_VTable);
DO_TYPEDEF(0x03898508, ISteamMatchmakingRulesResponse_InternalRulesResponded);
DO_TYPEDEF(0x038983D8, ISteamMatchmakingRulesResponse_InternalRulesFailedToRespond);
DO_TYPEDEF(0x03898470, ISteamMatchmakingRulesResponse_InternalRulesRefreshComplete);
DO_TYPEDEF(0x0389B0F8, InteropHelp_UTF8StringHandle);
DO_TYPEDEF(0x0389B060, InteropHelp_SteamParamStringArray);
DO_TYPEDEF(0x038AC998, MMKVPMarshaller);
DO_TYPEDEF(0x03877F10, AppId_t);
DO_TYPEDEF(0x0389B0C8, HSteamPipe);
DO_TYPEDEF(0x0389B160, HSteamUser);
DO_TYPEDEF(0x0389AF98, HSteamNetConnection);
DO_TYPEDEF(0x0389AF00, HSteamListenSocket);
DO_TYPEDEF(0x038682F8, SteamNetworkingPOPID);
DO_TYPEDEF(0x03869A60, AppId_t__Array);
DO_TYPEDEF(0x038897D0, DepotId_t);
DO_TYPEDEF(0x03867DE8, SteamAPIWarningMessageHook_t);
DO_TYPEDEF(0x03883170, ControllerHandle_t);
DO_TYPEDEF(0x03882FA8, ControllerActionSetHandle_t);
DO_TYPEDEF(0x038830D8, ControllerDigitalActionHandle_t);
DO_TYPEDEF(0x03883040, ControllerAnalogActionHandle_t);
DO_TYPEDEF(0x0387DDE8, CGameID);
DO_TYPEDEF(0x03898018, FriendsGroupID_t);
DO_TYPEDEF(0x0386A360, CSteamID__Array);
DO_TYPEDEF(0x0389A748, HAuthTicket);
DO_TYPEDEF(0x0389A7E0, HHTMLBrowser);
DO_TYPEDEF(0x0389B290, HTTPRequestHandle);
DO_TYPEDEF(0x03867D58, SteamAPICall_t);
DO_TYPEDEF(0x0389B1F8, HTTPCookieContainerHandle);
DO_TYPEDEF(0x038A6698, InputHandle_t);
DO_TYPEDEF(0x038A5810, InputActionSetHandle_t);
DO_TYPEDEF(0x038A62B0, InputDigitalActionHandle_t);
DO_TYPEDEF(0x038A59C0, InputAnalogActionHandle_t);
DO_TYPEDEF(0x03867E78, SteamInventoryResult_t);
DO_TYPEDEF(0x03868028, SteamItemInstanceID_t);
DO_TYPEDEF(0x03867F98, SteamItemDef_t);
DO_TYPEDEF(0x03867F08, SteamInventoryUpdateHandle_t);
DO_TYPEDEF(0x0389AE68, HServerQuery);
DO_TYPEDEF(0x038B8750, PartyBeaconID_t);
DO_TYPEDEF(0x038C4210, SNetSocket_t);
DO_TYPEDEF(0x038C4180, SNetListenSocket_t);
DO_TYPEDEF(0x03868268, SteamNetworkingMicroseconds);
DO_TYPEDEF(0x0389B030, HSteamNetPollGroup);
DO_TYPEDEF(0x038BE540, RTime32);
DO_TYPEDEF(0x038746B8, SteamDatagramRelayAuthTicket_ExtraField__Array);
DO_TYPEDEF(0x03892C78, ESteamNetworkingSocketsDebugOutputType__Enum);
DO_TYPEDEF(0x038C0DC0, RemotePlaySessionID_t);
DO_TYPEDEF(0x03870A88, UGCFileWriteStreamHandle_t);
DO_TYPEDEF(0x03870B18, UGCHandle_t);
DO_TYPEDEF(0x038BCD10, PublishedFileId_t);
DO_TYPEDEF(0x038BCDA0, PublishedFileUpdateHandle_t);
DO_TYPEDEF(0x038C51D0, ScreenshotHandle);
DO_TYPEDEF(0x03875F00, AccountID_t);
DO_TYPEDEF(0x0386EDB0, PublishedFileId_t__Array);
DO_TYPEDEF(0x03870BA8, UGCQueryHandle_t);
DO_TYPEDEF(0x03870C38, UGCUpdateHandle_t);
DO_TYPEDEF(0x03868148, SteamLeaderboard_t);
DO_TYPEDEF(0x038680B8, SteamLeaderboardEntries_t);
DO_TYPEDEF(0x038ACEA8, ManifestId_t);
DO_TYPEDEF(0x038C8100, SiteId_t);
DO_TYPEDEF(0x038699D0, AnimationClip__Array);
DO_TYPEDEF(0x0387A768, BakerTransform);
DO_TYPEDEF(0x03869DC0, BakerTransform__Array);
DO_TYPEDEF(0x0386B340, TQ);
DO_TYPEDEF(0x0387A638, BakerHumanoidQT);
DO_TYPEDEF(0x0387A6D0, BakerMuscle);
DO_TYPEDEF(0x03869D30, BakerMuscle__Array);
DO_TYPEDEF(0x0387BDF8, BipedLimbOrientations);
DO_TYPEDEF(0x0388C888, BipedLimbOrientations_LimbOrientation);
DO_TYPEDEF(0x03869700, String__Array__Array);
DO_TYPEDEF(0x0387BF28, BipedReferences);
DO_TYPEDEF(0x0387BD60, BipedIKSolvers);
DO_TYPEDEF(0x038A10F0, IKSolverTrigonometric);
DO_TYPEDEF(0x038A0FC0, IKSolverLimb);
DO_TYPEDEF(0x03897760, IKSolver_UpdateDelegate);
DO_TYPEDEF(0x038976C8, IKSolver_Point);
DO_TYPEDEF(0x03897500, IKSolver_Bone);
DO_TYPEDEF(0x03872CA8, IKSolver_Bone__Array);
DO_TYPEDEF(0x03872DC8, IKSolver_Point__Array);
DO_TYPEDEF(0x038A0B98, IKSolverAim);
DO_TYPEDEF(0x03897598, IKSolver_IterationDelegate);
DO_TYPEDEF(0x03897890, IKSolverTrigonometric_TrigonometricBone);
DO_TYPEDEF(0x03872E58, IKSolverLimb_AxisDirection__Array);
DO_TYPEDEF(0x038A0D60, IKSolverFABRIK);
DO_TYPEDEF(0x038A1058, IKSolverLookAt);
DO_TYPEDEF(0x038977F8, IKSolverLookAt_LookAtBone);
DO_TYPEDEF(0x03872EE8, IKSolverLookAt_LookAtBone__Array);
DO_TYPEDEF(0x038826C0, Constraints);
DO_TYPEDEF(0x0386CC50, IKSolverLimb__Array);
DO_TYPEDEF(0x0386CBC0, IKSolver__Array);
DO_TYPEDEF(0x03897308, Finger_1);
DO_TYPEDEF(0x0386BB78, Finger_1__Array);
DO_TYPEDEF(0x0389A288, Grounding);
DO_TYPEDEF(0x03895DE8, Grounding_Leg);
DO_TYPEDEF(0x038728B8, Grounding_Leg__Array);
DO_TYPEDEF(0x03896048, Grounding_Pelvis);
DO_TYPEDEF(0x03895F18, Grounding_OnRaycastDelegate);
DO_TYPEDEF(0x03895E80, Grounding_OnCapsuleCastDelegate);
DO_TYPEDEF(0x03895FB0, Grounding_OnSphereCastDelegate);
DO_TYPEDEF(0x038984D8, FullBodyBipedIK);
DO_TYPEDEF(0x03876918, AimIK);
DO_TYPEDEF(0x038A0E90, IKSolverFullBodyBiped);
DO_TYPEDEF(0x03896140, FBIKChain);
DO_TYPEDEF(0x03897630, IKSolver_Node);
DO_TYPEDEF(0x03872D38, IKSolver_Node__Array);
DO_TYPEDEF(0x038946C8, FBIKChain_ChildConstraint);
DO_TYPEDEF(0x038723A8, FBIKChain_ChildConstraint__Array);
DO_TYPEDEF(0x038A08A0, IKConstraintBend);
DO_TYPEDEF(0x0386B938, FBIKChain__Array);
DO_TYPEDEF(0x038A0938, IKEffector);
DO_TYPEDEF(0x0386CA10, IKEffector__Array);
DO_TYPEDEF(0x038A0B00, IKMappingSpine);
DO_TYPEDEF(0x03897468, IKMapping_BoneMap);
DO_TYPEDEF(0x03872C18, IKMapping_BoneMap__Array);
DO_TYPEDEF(0x038A09D0, IKMappingBone);
DO_TYPEDEF(0x0386CAA0, IKMappingBone__Array);
DO_TYPEDEF(0x038A0A68, IKMappingLimb);
DO_TYPEDEF(0x0386CB30, IKMappingLimb__Array);
DO_TYPEDEF(0x03898440, FullBodyBipedEffector__Enum);
DO_TYPEDEF(0x03872798, GrounderFBBIK_SpineEffector__Array);
DO_TYPEDEF(0x0386C980, IK__Array);
DO_TYPEDEF(0x03872828, GrounderQuadruped_Foot__Array);
DO_TYPEDEF(0x038A0C30, IKSolverArm);
DO_TYPEDEF(0x03897928, IKSolverVR_Arm);
DO_TYPEDEF(0x03897C20, IKSolverVR_VirtualBone);
DO_TYPEDEF(0x03873128, IKSolverVR_VirtualBone__Array);
DO_TYPEDEF(0x038A0CC8, IKSolverCCD);
DO_TYPEDEF(0x038960B0, FABRIKRoot);
DO_TYPEDEF(0x038A0DF8, IKSolverFABRIKRoot);
DO_TYPEDEF(0x0386B8A8, FABRIKChain__Array);
DO_TYPEDEF(0x038AA308, LegIK);
DO_TYPEDEF(0x038A0F28, IKSolverLeg);
DO_TYPEDEF(0x03897A58, IKSolverVR_Leg);
DO_TYPEDEF(0x038AAEC0, LimbIK);
DO_TYPEDEF(0x038B0528, VRIK_References);
DO_TYPEDEF(0x038A1188, IKSolverVR);
DO_TYPEDEF(0x03897B88, IKSolverVR_Spine);
DO_TYPEDEF(0x038B4C78, IKSolverVR_Locomotion_Mode__Enum);
DO_TYPEDEF(0x03897AF0, IKSolverVR_Locomotion);
DO_TYPEDEF(0x038979C0, IKSolverVR_Footstep);
DO_TYPEDEF(0x03873008, IKSolverVR_Footstep__Array);
DO_TYPEDEF(0x03873098, IKSolverVR_Leg__Array);
DO_TYPEDEF(0x03872F78, IKSolverVR_Arm__Array);
DO_TYPEDEF(0x03872318, FBBIKHeadEffector_BendBone__Array);
DO_TYPEDEF(0x038709C8, TwistSolver__Array);
DO_TYPEDEF(0x038A7C60, InteractionEffector);
DO_TYPEDEF(0x038B5458, InteractionObject_WeightCurve_Type__Enum);
DO_TYPEDEF(0x038BC350, List_1_RootMotion_FinalIK_InteractionTrigger_);
DO_TYPEDEF(0x03873998, InteractionTrigger_Range__Array);
DO_TYPEDEF(0x0389AFC8, InteractionSystem_InteractionDelegate);
DO_TYPEDEF(0x038A7D80, InteractionLookAt);
DO_TYPEDEF(0x0386D430, InteractionEffector__Array);
DO_TYPEDEF(0x0386D550, InteractionTarget__Array);
DO_TYPEDEF(0x03895800, GenericPoser_Map);
DO_TYPEDEF(0x03872708, GenericPoser_Map__Array);
DO_TYPEDEF(0x038B9770, List_1_System_Boolean_);
DO_TYPEDEF(0x0386D4C0, InteractionObject__Array);
DO_TYPEDEF(0x038A5CB8, RagdollUtility_Rigidbone);
DO_TYPEDEF(0x038740E8, RagdollUtility_Rigidbone__Array);
DO_TYPEDEF(0x038A5C28, RagdollUtility_Child);
DO_TYPEDEF(0x03874058, RagdollUtility_Child__Array);
DO_TYPEDEF(0x038A5B98, RagdollUtility_DisableRagdollSmooth_d_21);
DO_TYPEDEF(0x038C2320, RotationLimitHinge);
DO_TYPEDEF(0x038A6C58, RotationLimitPolygonal_LimitPoint);
DO_TYPEDEF(0x03874208, RotationLimitPolygonal_LimitPoint__Array);
DO_TYPEDEF(0x038A6CE8, RotationLimitPolygonal_ReachCone);
DO_TYPEDEF(0x03874298, RotationLimitPolygonal_ReachCone__Array);
DO_TYPEDEF(0x0388B5B0, AimController_TurnToTarget_d_37);
DO_TYPEDEF(0x03871BC8, AimPoser_Pose__Array);
DO_TYPEDEF(0x03873F38, OffsetPose_EffectorLink__Array);
DO_TYPEDEF(0x038A08D0, OffsetModifier_Initiate_d_8);
DO_TYPEDEF(0x038A0968, OffsetModifierVRIK_Initiate_d_7);
DO_TYPEDEF(0x038B0648, VRIKCalibrator_CalibrationData);
DO_TYPEDEF(0x038B6F58, VRIKCalibrator_CalibrationData_Target);
DO_TYPEDEF(0x0389CF40, MechSpiderLeg_Step_d_33);
DO_TYPEDEF(0x038A6870, ResetInteractionObject_ResetObject_d_7);
DO_TYPEDEF(0x038AADD0, SoccerDemo_ResetDelayed_d_4);
DO_TYPEDEF(0x038A4138, PlatformRotator_SwitchRotation_d_14);
DO_TYPEDEF(0x038B05B8, VRIKCalibrationBasic_Start_d_11);
DO_TYPEDEF(0x0388D168, CharacterThirdPerson_JumpSmooth_d_79);
DO_TYPEDEF(0x0388DD18, ES3Type_ES3PrefabInternal);
DO_TYPEDEF(0x0388C018, ES3CollectionType);
DO_TYPEDEF(0x0388BD28, ES32DArrayType);
DO_TYPEDEF(0x0388BDC0, ES33DArrayType);
DO_TYPEDEF(0x0388BE58, ES3ArrayType);
DO_TYPEDEF(0x0388C0B0, ES3DictionaryType);
DO_TYPEDEF(0x03893460, ES3Reflection_ES3ReflectedMethod);
DO_TYPEDEF(0x0388C270, ES3HashSetType);
DO_TYPEDEF(0x0388C568, ES3ListType);
DO_TYPEDEF(0x0388C7C0, ES3QueueType);
DO_TYPEDEF(0x0388CF70, ES3StackType);
DO_TYPEDEF(0x038928E8, ES3UnityObjectType);
DO_TYPEDEF(0x0388FD08, ES3Type_Random);
DO_TYPEDEF(0x0388CA18, ES3ReflectedComponentType);
DO_TYPEDEF(0x0388CB48, ES3ReflectedScriptableObjectType);
DO_TYPEDEF(0x0388FDA0, ES3Type_RandomArray);
DO_TYPEDEF(0x0388DB50, ES3Type_DateTime);
DO_TYPEDEF(0x0388DBE8, ES3Type_DateTimeArray);
DO_TYPEDEF(0x0388DDB0, ES3Type_ES3Ref);
DO_TYPEDEF(0x0388DE48, ES3Type_ES3RefArray);
DO_TYPEDEF(0x0388DED8, ES3Type_ES3RefDictionary);
DO_TYPEDEF(0x038910A0, ES3Type_UIntPtr);
DO_TYPEDEF(0x03891138, ES3Type_UIntPtrArray);
DO_TYPEDEF(0x03891858, ES3Type_bool);
DO_TYPEDEF(0x038918F0, ES3Type_boolArray);
DO_TYPEDEF(0x03891988, ES3Type_byte);
DO_TYPEDEF(0x03891A20, ES3Type_byteArray);
DO_TYPEDEF(0x03891AB0, ES3Type_char);
DO_TYPEDEF(0x03891B40, ES3Type_charArray);
DO_TYPEDEF(0x03891BD8, ES3Type_decimal);
DO_TYPEDEF(0x03891C70, ES3Type_decimalArray);
DO_TYPEDEF(0x03891D08, ES3Type_double);
DO_TYPEDEF(0x03891DA0, ES3Type_doubleArray);
DO_TYPEDEF(0x03891E38, ES3Type_enum);
DO_TYPEDEF(0x03891ED0, ES3Type_float);
DO_TYPEDEF(0x03891F68, ES3Type_floatArray);
DO_TYPEDEF(0x03892000, ES3Type_int);
DO_TYPEDEF(0x03892098, ES3Type_intArray);
DO_TYPEDEF(0x0388EA10, ES3Type_IntPtr);
DO_TYPEDEF(0x0388EAA8, ES3Type_IntPtrArray);
DO_TYPEDEF(0x03892130, ES3Type_long);
DO_TYPEDEF(0x038921C8, ES3Type_longArray);
DO_TYPEDEF(0x03892260, ES3Type_sbyte);
DO_TYPEDEF(0x038922F8, ES3Type_sbyteArray);
DO_TYPEDEF(0x03892390, ES3Type_short);
DO_TYPEDEF(0x03892428, ES3Type_shortArray);
DO_TYPEDEF(0x038924C0, ES3Type_string);
DO_TYPEDEF(0x03890A18, ES3Type_StringArray);
DO_TYPEDEF(0x03892558, ES3Type_uint);
DO_TYPEDEF(0x038925F0, ES3Type_uintArray);
DO_TYPEDEF(0x03892688, ES3Type_ulong);
DO_TYPEDEF(0x03892720, ES3Type_ulongArray);
DO_TYPEDEF(0x038927B8, ES3Type_ushort);
DO_TYPEDEF(0x03892850, ES3Type_ushortArray);
DO_TYPEDEF(0x0388CAB0, ES3ReflectedObjectType);
DO_TYPEDEF(0x0388CBE0, ES3ReflectedValueType);
DO_TYPEDEF(0x0388D4C8, ES3Type_BoxCollider);
DO_TYPEDEF(0x0388D560, ES3Type_BoxCollider2D);
DO_TYPEDEF(0x0388D5F8, ES3Type_Camera);
DO_TYPEDEF(0x0388D690, ES3Type_CapsuleCollider);
DO_TYPEDEF(0x0388E008, ES3Type_EventSystem);
DO_TYPEDEF(0x0388E850, ES3Type_Image);
DO_TYPEDEF(0x0388E8E8, ES3Type_ImageArray);
DO_TYPEDEF(0x0388F260, ES3Type_MeshCollider);
DO_TYPEDEF(0x0388F2F8, ES3Type_MeshColliderArray);
DO_TYPEDEF(0x0388F390, ES3Type_MeshFilter);
DO_TYPEDEF(0x0388F428, ES3Type_MeshFilterArray);
DO_TYPEDEF(0x0388F4C0, ES3Type_MeshRenderer);
DO_TYPEDEF(0x0388F558, ES3Type_MeshRendererArray);
DO_TYPEDEF(0x0388F7B8, ES3Type_ParticleSystem);
DO_TYPEDEF(0x0388FAA8, ES3Type_PolygonCollider2D);
DO_TYPEDEF(0x0388FB40, ES3Type_PolygonCollider2DArray);
DO_TYPEDEF(0x0388FE38, ES3Type_RawImage);
DO_TYPEDEF(0x0388FED0, ES3Type_RawImageArray);
DO_TYPEDEF(0x038901C8, ES3Type_Rigidbody);
DO_TYPEDEF(0x03892AB0, ES3UserType_RigidbodyArray);
DO_TYPEDEF(0x038907B8, ES3Type_SphereCollider);
DO_TYPEDEF(0x03890B48, ES3Type_Text);
DO_TYPEDEF(0x03890F70, ES3Type_Transform);
DO_TYPEDEF(0x0388D0A0, ES3Type_AnimationCurve);
DO_TYPEDEF(0x0388D138, ES3Type_AudioClip);
DO_TYPEDEF(0x0388D1D0, ES3Type_AudioClipArray);
DO_TYPEDEF(0x0388D268, ES3Type_BoneWeight);
DO_TYPEDEF(0x0388D300, ES3Type_BoneWeightArray);
DO_TYPEDEF(0x0388D398, ES3Type_Bounds);
DO_TYPEDEF(0x0388D430, ES3Type_BoundsArray);
DO_TYPEDEF(0x0388D728, ES3Type_CollisionModule);
DO_TYPEDEF(0x0388D7C0, ES3Type_Color);
DO_TYPEDEF(0x0388D988, ES3Type_ColorArray);
DO_TYPEDEF(0x0388D858, ES3Type_Color32);
DO_TYPEDEF(0x0388D8F0, ES3Type_Color32Array);
DO_TYPEDEF(0x0388DA20, ES3Type_ColorBySpeedModule);
DO_TYPEDEF(0x0388DAB8, ES3Type_ColorOverLifetimeModule);
DO_TYPEDEF(0x0388DF70, ES3Type_EmissionModule);
DO_TYPEDEF(0x0388E0A0, ES3Type_ExternalForcesModule);
DO_TYPEDEF(0x0388E138, ES3Type_Flare);
DO_TYPEDEF(0x0388E1D0, ES3Type_FlareArray);
DO_TYPEDEF(0x0388E268, ES3Type_Font);
DO_TYPEDEF(0x0388E300, ES3Type_FontArray);
DO_TYPEDEF(0x0388E398, ES3Type_ForceOverLifetimeModule);
DO_TYPEDEF(0x0388E430, ES3Type_GameObject);
DO_TYPEDEF(0x038934F8, ES3Type_GameObject_c_DisplayClass8_0);
DO_TYPEDEF(0x0388E4C8, ES3Type_GameObjectArray);
DO_TYPEDEF(0x0388E560, ES3Type_Gradient);
DO_TYPEDEF(0x0388E5F8, ES3Type_GradientAlphaKey);
DO_TYPEDEF(0x0388E690, ES3Type_GradientAlphaKeyArray);
DO_TYPEDEF(0x0388E728, ES3Type_GradientColorKey);
DO_TYPEDEF(0x0388E7B8, ES3Type_GradientColorKeyArray);
DO_TYPEDEF(0x0388E980, ES3Type_InheritVelocityModule);
DO_TYPEDEF(0x0388EB40, ES3Type_Keyframe);
DO_TYPEDEF(0x0388EBD8, ES3Type_KeyframeArray);
DO_TYPEDEF(0x0388EC70, ES3Type_LayerMask);
DO_TYPEDEF(0x0388ED08, ES3Type_Light);
DO_TYPEDEF(0x0388EDA0, ES3Type_LightsModule);
DO_TYPEDEF(0x0388EE38, ES3Type_LimitVelocityOverLifetimeModule);
DO_TYPEDEF(0x0388EED0, ES3Type_MainModule);
DO_TYPEDEF(0x0388EF68, ES3Type_Material);
DO_TYPEDEF(0x0388F000, ES3Type_MaterialArray);
DO_TYPEDEF(0x0388F098, ES3Type_Matrix4x4);
DO_TYPEDEF(0x0388F130, ES3Type_Matrix4x4Array);
DO_TYPEDEF(0x0388F1C8, ES3Type_Mesh);
DO_TYPEDEF(0x0388F5F0, ES3Type_MinMaxCurve);
DO_TYPEDEF(0x0388F688, ES3Type_MinMaxGradient);
DO_TYPEDEF(0x0388F720, ES3Type_NoiseModule);
DO_TYPEDEF(0x0388F850, ES3Type_PhysicMaterial);
DO_TYPEDEF(0x0388F8E0, ES3Type_PhysicMaterialArray);
DO_TYPEDEF(0x0388F978, ES3Type_PhysicsMaterial2D);
DO_TYPEDEF(0x0388FA10, ES3Type_PhysicsMaterial2DArray);
DO_TYPEDEF(0x0388FBD8, ES3Type_Quaternion);
DO_TYPEDEF(0x0388FC70, ES3Type_QuaternionArray);
DO_TYPEDEF(0x0388FF68, ES3Type_Rect);
DO_TYPEDEF(0x03890000, ES3Type_RectTransform);
DO_TYPEDEF(0x03890098, ES3Type_RenderTexture);
DO_TYPEDEF(0x03890130, ES3Type_RenderTextureArray);
DO_TYPEDEF(0x03890260, ES3Type_RotationBySpeedModule);
DO_TYPEDEF(0x038902F8, ES3Type_RotationOverLifetimeModule);
DO_TYPEDEF(0x03890390, ES3Type_Shader);
DO_TYPEDEF(0x03890428, ES3Type_ShaderArray);
DO_TYPEDEF(0x038904C0, ES3Type_ShapeModule);
DO_TYPEDEF(0x03890558, ES3Type_SizeBySpeedModule);
DO_TYPEDEF(0x038905F0, ES3Type_SizeOverLifetimeModule);
DO_TYPEDEF(0x03890688, ES3Type_SkinnedMeshRenderer);
DO_TYPEDEF(0x03890720, ES3Type_SkinnedMeshRendererArray);
DO_TYPEDEF(0x03890850, ES3Type_Sprite);
DO_TYPEDEF(0x038908E8, ES3Type_SpriteRenderer);
DO_TYPEDEF(0x03890980, ES3Type_SpriteRendererArray);
DO_TYPEDEF(0x03890AB0, ES3Type_SubEmittersModule);
DO_TYPEDEF(0x03890BE0, ES3Type_Texture);
DO_TYPEDEF(0x03890DA8, ES3Type_TextureArray);
DO_TYPEDEF(0x03890C78, ES3Type_Texture2D);
DO_TYPEDEF(0x03890D10, ES3Type_Texture2DArray);
DO_TYPEDEF(0x03890E40, ES3Type_TextureSheetAnimationModule);
DO_TYPEDEF(0x03890ED8, ES3Type_TrailModule);
DO_TYPEDEF(0x03891008, ES3Type_TriggerModule);
DO_TYPEDEF(0x038911D0, ES3Type_Vector2);
DO_TYPEDEF(0x03891268, ES3Type_Vector2Array);
DO_TYPEDEF(0x03891300, ES3Type_Vector2Int);
DO_TYPEDEF(0x03891398, ES3Type_Vector2IntArray);
DO_TYPEDEF(0x03891430, ES3Type_Vector3);
DO_TYPEDEF(0x038914C8, ES3Type_Vector3Array);
DO_TYPEDEF(0x03891560, ES3Type_Vector3Int);
DO_TYPEDEF(0x038915F8, ES3Type_Vector3IntArray);
DO_TYPEDEF(0x03891690, ES3Type_Vector4);
DO_TYPEDEF(0x03891728, ES3Type_Vector4Array);
DO_TYPEDEF(0x038917C0, ES3Type_VelocityOverLifetimeModule);
DO_TYPEDEF(0x03875A48, AESEncryptionAlgorithm);
DO_TYPEDEF(0x03872078, UnbufferedCryptoStream);
DO_TYPEDEF(0x038A5F28, Dictionary_2_System_Int64_System_Int64_);
DO_TYPEDEF(0x03893200, ES3ReferenceMgrBase_c_DisplayClass29_0);
DO_TYPEDEF(0x038AD7F8, Func_2_System_Collections_Generic_KeyValuePair_2_Boolean__1);
DO_TYPEDEF(0x03893298, ES3ReferenceMgrBase_c_DisplayClass30_0);
DO_TYPEDEF(0x038AD910, Func_2_System_Collections_Generic_KeyValuePair_2_Boolean__2);
DO_TYPEDEF(0x03893168, ES3ReferenceMgrBase_c);
DO_TYPEDEF(0x038AD880, Func_2_System_Collections_Generic_KeyValuePair_2_Int64_);
DO_TYPEDEF(0x03872168, ES3Reflection_ES3ReflectedMember__Array);
DO_TYPEDEF(0x038933C8, ES3Reflection_c_DisplayClass27_0);
DO_TYPEDEF(0x0389E398, _f_AnonymousType0_2_System_Reflection_Assembly_System_Type_);
DO_TYPEDEF(0x03893330, ES3Reflection_c);
DO_TYPEDEF(0x038B0168, Func_3_System_Reflection_Assembly_Type_f_AnonymousType0_2_);
DO_TYPEDEF(0x038AD768, Func_2_f_AnonymousType0_2_Type_);
DO_TYPEDEF(0x0388C1D8, ES3FileStream);
DO_TYPEDEF(0x0388C698, ES3PlayerPrefsStream);
DO_TYPEDEF(0x0388CD10, ES3ResourcesStream);
DO_TYPEDEF(0x03893590, ES3WebClass_SendWebRequest_d_19);
DO_TYPEDEF(0x0388C4D0, ES3JSONWriter);
DO_TYPEDEF(0x0388E918, DOTweenModuleAudio_c_DisplayClass0_0);
DO_TYPEDEF(0x0388E9B0, DOTweenModuleAudio_c_DisplayClass1_0);
DO_TYPEDEF(0x0388EA40, DOTweenModuleAudio_c_DisplayClass2_0);
DO_TYPEDEF(0x0388EAD8, DOTweenModulePhysics_c_DisplayClass0_0);
DO_TYPEDEF(0x0388EC08, DOTweenModulePhysics_c_DisplayClass1_0);
DO_TYPEDEF(0x0388ECA0, DOTweenModulePhysics_c_DisplayClass2_0);
DO_TYPEDEF(0x0388ED38, DOTweenModulePhysics_c_DisplayClass3_0);
DO_TYPEDEF(0x0388EDD0, DOTweenModulePhysics_c_DisplayClass4_0);
DO_TYPEDEF(0x0388EE68, DOTweenModulePhysics_c_DisplayClass5_0);
DO_TYPEDEF(0x0388EF00, DOTweenModulePhysics_c_DisplayClass6_0);
DO_TYPEDEF(0x0388EF98, DOTweenModulePhysics_c_DisplayClass7_0);
DO_TYPEDEF(0x0388F030, DOTweenModulePhysics_c_DisplayClass8_0);
DO_TYPEDEF(0x0388F0C8, DOTweenModulePhysics_c_DisplayClass9_0);
DO_TYPEDEF(0x0388EB70, DOTweenModulePhysics_c_DisplayClass10_0);
DO_TYPEDEF(0x0388F160, DOTweenModuleUI_c_DisplayClass0_0);
DO_TYPEDEF(0x0388F7E8, DOTweenModuleUI_c_DisplayClass1_0);
DO_TYPEDEF(0x0388FE68, DOTweenModuleUI_c_DisplayClass2_0);
DO_TYPEDEF(0x038904F0, DOTweenModuleUI_c_DisplayClass3_0);
DO_TYPEDEF(0x038906B8, DOTweenModuleUI_c_DisplayClass4_0);
DO_TYPEDEF(0x03890750, DOTweenModuleUI_c_DisplayClass5_0);
DO_TYPEDEF(0x038907E8, DOTweenModuleUI_c_DisplayClass7_0);
DO_TYPEDEF(0x03890880, DOTweenModuleUI_c_DisplayClass8_0);
DO_TYPEDEF(0x03890918, DOTweenModuleUI_c_DisplayClass9_0);
DO_TYPEDEF(0x0388F1F8, DOTweenModuleUI_c_DisplayClass10_0);
DO_TYPEDEF(0x0388F290, DOTweenModuleUI_c_DisplayClass11_0);
DO_TYPEDEF(0x0388F328, DOTweenModuleUI_c_DisplayClass12_0);
DO_TYPEDEF(0x0388F3C0, DOTweenModuleUI_c_DisplayClass13_0);
DO_TYPEDEF(0x0388F458, DOTweenModuleUI_c_DisplayClass14_0);
DO_TYPEDEF(0x0388F4F0, DOTweenModuleUI_c_DisplayClass15_0);
DO_TYPEDEF(0x0388F588, DOTweenModuleUI_c_DisplayClass16_0);
DO_TYPEDEF(0x0388F620, DOTweenModuleUI_c_DisplayClass17_0);
DO_TYPEDEF(0x0388F6B8, DOTweenModuleUI_c_DisplayClass18_0);
DO_TYPEDEF(0x0388F750, DOTweenModuleUI_c_DisplayClass19_0);
DO_TYPEDEF(0x0388F880, DOTweenModuleUI_c_DisplayClass20_0);
DO_TYPEDEF(0x0388F910, DOTweenModuleUI_c_DisplayClass21_0);
DO_TYPEDEF(0x0388F9A8, DOTweenModuleUI_c_DisplayClass22_0);
DO_TYPEDEF(0x0388FA40, DOTweenModuleUI_c_DisplayClass23_0);
DO_TYPEDEF(0x0388FAD8, DOTweenModuleUI_c_DisplayClass24_0);
DO_TYPEDEF(0x0388FB70, DOTweenModuleUI_c_DisplayClass25_0);
DO_TYPEDEF(0x0388FC08, DOTweenModuleUI_c_DisplayClass26_0);
DO_TYPEDEF(0x0388FCA0, DOTweenModuleUI_c_DisplayClass27_0);
DO_TYPEDEF(0x0388FD38, DOTweenModuleUI_c_DisplayClass28_0);
DO_TYPEDEF(0x0388FDD0, DOTweenModuleUI_c_DisplayClass29_0);
DO_TYPEDEF(0x0388FF00, DOTweenModuleUI_c_DisplayClass30_0);
DO_TYPEDEF(0x0388FF98, DOTweenModuleUI_c_DisplayClass31_0);
DO_TYPEDEF(0x03890030, DOTweenModuleUI_c_DisplayClass32_0);
DO_TYPEDEF(0x038900C8, DOTweenModuleUI_c_DisplayClass33_0);
DO_TYPEDEF(0x03890160, DOTweenModuleUI_c_DisplayClass34_0);
DO_TYPEDEF(0x038901F8, DOTweenModuleUI_c_DisplayClass35_0);
DO_TYPEDEF(0x03890290, DOTweenModuleUI_c_DisplayClass36_0);
DO_TYPEDEF(0x03890328, DOTweenModuleUI_c_DisplayClass37_0);
DO_TYPEDEF(0x038903C0, DOTweenModuleUI_c_DisplayClass38_0);
DO_TYPEDEF(0x03890458, DOTweenModuleUI_c_DisplayClass39_0);
DO_TYPEDEF(0x03890588, DOTweenModuleUI_c_DisplayClass40_0);
DO_TYPEDEF(0x03890620, DOTweenModuleUI_c_DisplayClass41_0);
DO_TYPEDEF(0x038909B0, DOTweenModuleUnityVersion_c_DisplayClass8_0);
DO_TYPEDEF(0x03890A48, DOTweenModuleUnityVersion_c_DisplayClass9_0);
DO_TYPEDEF(0x0388E200, DOTweenCYInstruction_WaitForCompletion);
DO_TYPEDEF(0x0388E460, DOTweenCYInstruction_WaitForRewind);
DO_TYPEDEF(0x0388E330, DOTweenCYInstruction_WaitForKill);
DO_TYPEDEF(0x0388E298, DOTweenCYInstruction_WaitForElapsedLoops);
DO_TYPEDEF(0x0388E3C8, DOTweenCYInstruction_WaitForPosition);
DO_TYPEDEF(0x0388E4F8, DOTweenCYInstruction_WaitForStart);
DO_TYPEDEF(0x038B9020, List_1_UnityEngine_AzureSky_AzureCelestialBody_);
DO_TYPEDEF(0x038B90B0, List_1_UnityEngine_AzureSky_AzureCustomEvent_);
DO_TYPEDEF(0x038B9410, List_1_UnityEngine_AzureSky_AzureWeatherProfile_);
DO_TYPEDEF(0x038B9140, List_1_UnityEngine_AzureSky_AzureCustomProperty_);
DO_TYPEDEF(0x038B92F0, List_1_UnityEngine_AzureSky_AzureProfileProperty_);
DO_TYPEDEF(0x0387A340, AzureProfileProperty);
DO_TYPEDEF(0x038B91D0, List_1_UnityEngine_AzureSky_AzureGlobalWeather_);
DO_TYPEDEF(0x038B94A0, List_1_UnityEngine_AzureSky_AzureWeatherZone_);
DO_TYPEDEF(0x038B9260, List_1_UnityEngine_AzureSky_AzureOverrideProperty_);
DO_TYPEDEF(0x0387A2A8, AzureOverrideProperty);
DO_TYPEDEF(0x038C25C0, List_1_UnityEngine_AzureSky_AzureOverrideProperty_OverridePropertySetup_);
DO_TYPEDEF(0x038B9380, List_1_UnityEngine_AzureSky_AzureThunderSettings_);
DO_TYPEDEF(0x03896B50, FileHapticClip);
DO_TYPEDEF(0x03878598, ArmsHapticClip);
DO_TYPEDEF(0x03882820, u0A6Au0A68u0A6Au0A73u0A6Fu0A72u0A66u0A73u0A6Cu0A68u0A6C__Enum);
DO_TYPEDEF(0x038BA3D0, List_1_Bhaptics_Tact_DotPoint_);
DO_TYPEDEF(0x0388C598, BhapticsFpsView_u0A70u0A70u0A73u0A74u0A73u0A74u0A74u0A73u0A68u0A67u0A71);
DO_TYPEDEF(0x0388C630, BhapticsIdentifierPlayExample_u0A72u0A6Bu0A74u0A6Au0A72u0A73u0A74u0A68u0A66u0A68u0A70);
DO_TYPEDEF(0x0388C6C8, BhapticsShootingCharacter_u0A69u0A69u0A6Cu0A66u0A6Fu0A72u0A6Eu0A70u0A70u0A6Cu0A6F);
DO_TYPEDEF(0x0387AD58, BhapticsAndroidManager);
DO_TYPEDEF(0x038C0520, List_1_UnityEngine_Events_UnityAction_);
DO_TYPEDEF(0x03888DF0, u0A72u0A68u0A6Cu0A6Eu0A74u0A6Cu0A6Eu0A72u0A6Du0A6Fu0A65);
DO_TYPEDEF(0x0388A050, u0A73u0A70u0A67u0A6Au0A65u0A6Du0A73u0A66u0A6Du0A73u0A6C);
DO_TYPEDEF(0x038876D8, u0A70u0A6Eu0A70u0A66u0A6Fu0A66u0A6Du0A6Eu0A6Eu0A66u0A6F);
DO_TYPEDEF(0x0387ADF0, Bhaptics_Setup);
DO_TYPEDEF(0x038B4918, u0A73u0A72u0A73u0A6Bu0A74u0A65u0A67u0A73u0A6Bu0A6Du0A6A_u0A6Eu0A69u0A6Du0A69u0A67u0A67u0A74u0A69u0A6Eu0A6Au0A67);
DO_TYPEDEF(0x03875358, Voxelize);
DO_TYPEDEF(0x038A65D8, Dictionary_2_UnityEngine_Mesh_Voxelize_u0A68u0A6Fu0A74u0A6Eu0A67u0A6Cu0A6Fu0A66u0A72u0A6Cu0A6F_);
DO_TYPEDEF(0x038B13A8, Voxelize_u0A68u0A6Fu0A74u0A6Eu0A67u0A6Cu0A6Fu0A66u0A72u0A6Cu0A6F);
DO_TYPEDEF(0x03875918, Byte__Array_1);
DO_TYPEDEF(0x038B18E8, HashSet_1_u0A68u0A6Au0A6Fu0A6Fu0A6Fu0A69u0A72u0A70u0A6Cu0A69u0A71_);
DO_TYPEDEF(0x038815C8, u0A68u0A6Au0A6Fu0A6Fu0A6Fu0A69u0A72u0A70u0A6Cu0A69u0A71);
DO_TYPEDEF(0x038AC5A8, MCS_RemoveTrisBelowSurface);
DO_TYPEDEF(0x0389C198, Lightning_u0A6Bu0A6Du0A6Fu0A68u0A67u0A66u0A6Eu0A71u0A6Fu0A73u0A67);
DO_TYPEDEF(0x0389C230, Lightning_u0A6Fu0A6Fu0A67u0A69u0A69u0A6Eu0A74u0A69u0A70u0A71u0A73);
DO_TYPEDEF(0x038A57B8, ProtonPack_u0A72u0A69u0A66u0A69u0A69u0A73u0A6Fu0A69u0A6Fu0A6Du0A65);
DO_TYPEDEF(0x0387EA80, maskChannelModeParameter);
DO_TYPEDEF(0x0388A6D8, u0A74u0A66u0A69u0A69u0A67u0A74u0A6Du0A71u0A6Au0A66u0A69);
DO_TYPEDEF(0x0387E950, bleedModeParameter);
DO_TYPEDEF(0x038843F8, u0A6Du0A65u0A68u0A6Eu0A6Du0A70u0A72u0A6Eu0A68u0A71u0A6A);
DO_TYPEDEF(0x0387FE18, u0A66u0A73u0A69u0A71u0A69u0A72u0A69u0A6Du0A6Au0A6Cu0A70);
DO_TYPEDEF(0x0387EBB0, resModeParameter);
DO_TYPEDEF(0x03873F68, Vector2IntParameter);
DO_TYPEDEF(0x0387EB18, preLParameter);
DO_TYPEDEF(0x0388AF28, u0A74u0A70u0A69u0A6Au0A6Cu0A70u0A6Du0A6Au0A66u0A72u0A71);
DO_TYPEDEF(0x03897438, FisheyeTypeParameter);
DO_TYPEDEF(0x03887D50, u0A71u0A65u0A68u0A6Eu0A71u0A65u0A6Bu0A69u0A70u0A68u0A69);
DO_TYPEDEF(0x03887A60, u0A70u0A71u0A6Au0A71u0A70u0A6Du0A65u0A6Fu0A69u0A67u0A6C);
DO_TYPEDEF(0x0388A9D0, u0A74u0A69u0A68u0A67u0A67u0A68u0A67u0A69u0A67u0A6Eu0A6F);
DO_TYPEDEF(0x03885358, u0A6Eu0A6Eu0A69u0A6Au0A6Eu0A6Eu0A6Eu0A6Fu0A69u0A70u0A66);
DO_TYPEDEF(0x03887640, u0A70u0A6Eu0A6Du0A6Du0A6Au0A72u0A6Eu0A6Du0A71u0A6Du0A6F);
DO_TYPEDEF(0x03888800, u0A71u0A70u0A65u0A68u0A67u0A70u0A66u0A6Au0A6Bu0A67u0A6D);
DO_TYPEDEF(0x03881C40, u0A69u0A65u0A6Au0A6Bu0A65u0A72u0A6Du0A73u0A71u0A73u0A69);
DO_TYPEDEF(0x03886CC8, u0A6Fu0A73u0A71u0A6Du0A66u0A65u0A67u0A74u0A73u0A68u0A66);
DO_TYPEDEF(0x03889930, u0A73u0A65u0A69u0A6Du0A72u0A72u0A6Cu0A68u0A6Cu0A72u0A66);
DO_TYPEDEF(0x0387F660, u0A66u0A65u0A71u0A6Du0A67u0A6Du0A73u0A6Cu0A6Eu0A66u0A66);
DO_TYPEDEF(0x03875B10, WarpModeParameter);
DO_TYPEDEF(0x03882E10, u0A6Au0A70u0A6Bu0A6Eu0A67u0A72u0A6Cu0A69u0A6Eu0A71u0A73);
DO_TYPEDEF(0x03874818, VignetteModeParameter_1);
DO_TYPEDEF(0x0387C220, BlendModeParameter);
DO_TYPEDEF(0x03882490, u0A69u0A6Cu0A6Bu0A65u0A6Eu0A66u0A6Bu0A72u0A6Du0A65u0A68);
DO_TYPEDEF(0x03883EA8, u0A6Cu0A6Cu0A73u0A67u0A70u0A71u0A66u0A74u0A6Eu0A6Eu0A66);
DO_TYPEDEF(0x03884A80, u0A6Du0A70u0A6Eu0A6Au0A69u0A68u0A66u0A6Bu0A73u0A66u0A6F);
DO_TYPEDEF(0x0388AFC0, u0A74u0A70u0A71u0A73u0A6Fu0A69u0A73u0A68u0A6Fu0A70u0A72);
DO_TYPEDEF(0x0389EB20, Nightvision_VignetteSettings);
DO_TYPEDEF(0x038B5848, Nightvision_VignetteSettings_TextureSettings);
DO_TYPEDEF(0x038B57B8, Nightvision_VignetteSettings_ProceduralSettings);
DO_TYPEDEF(0x0389EA88, Nightvision_NoiseSettings);
DO_TYPEDEF(0x038B5728, Nightvision_NoiseSettings_TextureSettings);
DO_TYPEDEF(0x03882C48, u0A6Au0A6Bu0A73u0A74u0A71u0A6Bu0A70u0A72u0A70u0A6Au0A74);
DO_TYPEDEF(0x03879F18, AutomaticLOD);
DO_TYPEDEF(0x038C2530, List_1_AutomaticLOD_LODLevelData_);
DO_TYPEDEF(0x0388C208, AutomaticLOD_LODLevelData);
DO_TYPEDEF(0x038B8F90, List_1_AutomaticLOD_);
DO_TYPEDEF(0x038C7C88, Simplifier);
DO_TYPEDEF(0x038C3D60, List_1_UltimateGameTools_MeshSimplifier_Simplifier_u0A6Bu0A68u0A6Fu0A6Bu0A68u0A65u0A72u0A6Du0A67u0A66u0A6A_);
DO_TYPEDEF(0x038AA4E0, Simplifier_u0A6Bu0A68u0A6Fu0A6Bu0A68u0A65u0A72u0A6Du0A67u0A66u0A6A);
DO_TYPEDEF(0x038C3CD0, List_1_UltimateGameTools_MeshSimplifier_Simplifier_u0A68u0A65u0A6Cu0A65u0A65u0A67u0A66u0A71u0A6Cu0A6Au0A70_);
DO_TYPEDEF(0x038AA450, Simplifier_u0A68u0A65u0A6Cu0A65u0A65u0A67u0A66u0A71u0A6Cu0A6Au0A70);
DO_TYPEDEF(0x038744F0, Simplifier_u0A6Bu0A68u0A6Fu0A6Bu0A68u0A65u0A72u0A6Du0A67u0A66u0A6A__Array);
DO_TYPEDEF(0x038AA838, Simplifier_u0A70u0A6Au0A67u0A72u0A6Au0A6Eu0A66u0A73u0A6Fu0A6Eu0A6A);
DO_TYPEDEF(0x03874588, Simplifier_u0A70u0A6Au0A67u0A72u0A6Au0A6Eu0A66u0A73u0A6Fu0A6Eu0A6A__Array);
DO_TYPEDEF(0x038AEA08, MeshUniqueVertices);
DO_TYPEDEF(0x038C3220, List_1_UltimateGameTools_MeshSimplifier_MeshUniqueVertices_SerializableBoneWeight_);
DO_TYPEDEF(0x0389D660, MeshUniqueVertices_SerializableBoneWeight);
DO_TYPEDEF(0x0389D5C8, MeshUniqueVertices_ListIndices);
DO_TYPEDEF(0x03873C68, MeshUniqueVertices_ListIndices__Array);
DO_TYPEDEF(0x038A4168, Dictionary_2_UnityEngine_Camera_System_Int32_);
DO_TYPEDEF(0x038A4798, Dictionary_2_UnityEngine_GameObject_UnityEngine_Material_);
DO_TYPEDEF(0x0389B6E8, LODPreview_u0A71u0A6Au0A71u0A70u0A67u0A6Eu0A66u0A6Cu0A67u0A67u0A6D);
DO_TYPEDEF(0x038A6AD8, Dictionary_2_UnityEngine_Renderer_UnityEngine_Material_);
DO_TYPEDEF(0x038AA718, Simplifier_u0A6Fu0A6Au0A67u0A73u0A70u0A66u0A71u0A72u0A67u0A66u0A6E);
DO_TYPEDEF(0x038B87B0, List_1_List_1_UnityEngine_Renderer_);
DO_TYPEDEF(0x038B3448, u0A6Cu0A66u0A71u0A70u0A70u0A69u0A67u0A6Cu0A6Eu0A6Cu0A70_u0A6Cu0A6Eu0A6Au0A65u0A65u0A71u0A69u0A71u0A68u0A71u0A74);
DO_TYPEDEF(0x038AF1B8, Func_2_UnityEngine_Renderer_Boolean_);
DO_TYPEDEF(0x038B34D8, u0A6Cu0A66u0A71u0A70u0A70u0A69u0A67u0A6Cu0A6Eu0A6Cu0A70_u0A6Fu0A6Eu0A69u0A65u0A66u0A70u0A71u0A68u0A72u0A6Au0A6B);
DO_TYPEDEF(0x038BCD70, List_1_MeshSimplify_);
DO_TYPEDEF(0x038AA9E8, SimplifyMeshPreview_u0A74u0A69u0A72u0A68u0A69u0A6Au0A71u0A74u0A70u0A6Fu0A65);
DO_TYPEDEF(0x038A6E08, RuntimeMeshSimplifier_u0A6Eu0A72u0A67u0A6Eu0A74u0A68u0A67u0A6Bu0A6Bu0A6Eu0A6C);
DO_TYPEDEF(0x038B3298, u0A6Au0A71u0A69u0A6Cu0A67u0A69u0A66u0A72u0A70u0A6Au0A6B_u0A70u0A66u0A72u0A65u0A70u0A65u0A6Cu0A73u0A6Du0A74u0A6B);
DO_TYPEDEF(0x038B3178, u0A6Au0A71u0A69u0A6Cu0A67u0A69u0A66u0A72u0A70u0A6Au0A6B_u0A6Au0A71u0A6Au0A6Cu0A6Eu0A71u0A72u0A6Eu0A66u0A6Fu0A6A);
DO_TYPEDEF(0x038B3208, u0A6Au0A71u0A69u0A6Cu0A67u0A69u0A66u0A72u0A70u0A6Au0A6B_u0A6Eu0A6Bu0A73u0A73u0A73u0A67u0A65u0A71u0A70u0A74u0A6F);
DO_TYPEDEF(0x038BA460, List_1_EMF_);
DO_TYPEDEF(0x038BF050, List_1_SoundSensor_);
DO_TYPEDEF(0x038738A8, VRGrabbable);
DO_TYPEDEF(0x03899020, GameController);
DO_TYPEDEF(0x0388AB00, u0A74u0A6Au0A6Au0A69u0A72u0A67u0A6Bu0A6Au0A6Au0A66u0A71);
DO_TYPEDEF(0x038BDDC0, List_1_Player_);
DO_TYPEDEF(0x038C3100, List_1_Key_u0A6Au0A73u0A6Eu0A73u0A70u0A6Eu0A6Fu0A6Eu0A6Fu0A6Au0A67_);
DO_TYPEDEF(0x038BC8F0, List_1_LightSwitch_);
DO_TYPEDEF(0x038BC860, List_1_LightSource_);
DO_TYPEDEF(0x038BE750, List_1_UnityEngine_ReflectionProbe_);
DO_TYPEDEF(0x0386B168, Door__Array);
DO_TYPEDEF(0x038B9890, List_1_UnityEngine_BoxCollider_);
DO_TYPEDEF(0x0387D6D8, CCTVController);
DO_TYPEDEF(0x038B99B0, List_1_CCTV_);
DO_TYPEDEF(0x038C7658, SetupPhaseController);
DO_TYPEDEF(0x038AA4B0, LevelController);
DO_TYPEDEF(0x03895B88, GhostAI_u0A70u0A70u0A6Au0A68u0A66u0A74u0A68u0A66u0A6Fu0A68u0A71__Enum);
DO_TYPEDEF(0x038848B8, u0A6Du0A6Fu0A74u0A72u0A70u0A6Au0A70u0A6Cu0A70u0A6Cu0A72);
DO_TYPEDEF(0x03885488, u0A6Eu0A6Fu0A6Eu0A65u0A6Au0A6Bu0A71u0A69u0A69u0A6Au0A65);
DO_TYPEDEF(0x038B41C8, u0A71u0A6Du0A65u0A71u0A73u0A6Eu0A6Bu0A6Bu0A72u0A6Bu0A74_u0A6Au0A67u0A65u0A6Cu0A69u0A65u0A6Eu0A6Fu0A6Fu0A70u0A69__Enum);
DO_TYPEDEF(0x038C1F90, List_1_u0A70u0A6Cu0A6Eu0A73u0A66u0A74u0A67u0A6Cu0A6Au0A69u0A6B_);
DO_TYPEDEF(0x038B8E70, List_1_UnityEngine_AudioClip_);
DO_TYPEDEF(0x038BDC10, List_1_PhotonObjectInteract_);
DO_TYPEDEF(0x03866B58, SoundController);
DO_TYPEDEF(0x038ACBD8, MainManager);
DO_TYPEDEF(0x038AB6C0, StoreSDKManager_u0A72u0A74u0A72u0A71u0A6Du0A6Au0A72u0A68u0A74u0A67u0A6A__Enum);
DO_TYPEDEF(0x03868770, StoreSDKManager);
DO_TYPEDEF(0x03874EA0, ViveportInitialiser);
DO_TYPEDEF(0x038681D8, SteamManager);
DO_TYPEDEF(0x038BC470, List_1_InventoryItem_);
DO_TYPEDEF(0x038C2F50, List_1_InventoryItem_u0A74u0A6Fu0A6Fu0A6Du0A6Au0A6Au0A6Fu0A69u0A6Cu0A6Cu0A6C_);
DO_TYPEDEF(0x0389B190, InventoryItem_u0A74u0A6Fu0A6Fu0A6Du0A6Au0A6Au0A6Fu0A69u0A6Cu0A6Cu0A6C);
DO_TYPEDEF(0x03899280, GamepadUISelector);
DO_TYPEDEF(0x038BA070, List_1_Contract_);
DO_TYPEDEF(0x0388DA50, Contract_u0A6Bu0A6Du0A6Du0A6Fu0A70u0A68u0A71u0A6Cu0A6Cu0A70u0A6D__Enum);
DO_TYPEDEF(0x03883108, u0A6Bu0A65u0A66u0A70u0A66u0A71u0A67u0A6Cu0A6Cu0A6Fu0A71__Enum);
DO_TYPEDEF(0x038C1570, List_1_u0A67u0A6Cu0A6Eu0A73u0A6Bu0A6Fu0A73u0A68u0A68u0A72u0A65_);
DO_TYPEDEF(0x038808B8, u0A67u0A6Cu0A6Eu0A73u0A6Bu0A6Fu0A73u0A68u0A68u0A72u0A65);
DO_TYPEDEF(0x038BEF30, List_1_ServerItem_);
DO_TYPEDEF(0x038B8F00, List_1_AudioGroupOverride_);
DO_TYPEDEF(0x0386DA60, LevelRoom__Array);
DO_TYPEDEF(0x038BC590, List_1_JournalController_);
DO_TYPEDEF(0x0389B228, JournalController_u0A74u0A6Fu0A6Fu0A66u0A6Du0A65u0A70u0A69u0A68u0A66u0A72);
DO_TYPEDEF(0x038C2FE0, List_1_JournalController_u0A74u0A6Fu0A6Fu0A66u0A6Du0A65u0A70u0A69u0A68u0A66u0A72_);
DO_TYPEDEF(0x038BA190, List_1_Crucifix_);
DO_TYPEDEF(0x038BFD40, List_1_Torch_);
DO_TYPEDEF(0x038BAB20, List_1_FireSource_);
DO_TYPEDEF(0x0386DEE0, MeshRenderer__Array);
DO_TYPEDEF(0x038B93B0, PhotonPlayer);
DO_TYPEDEF(0x038BD8E0, RENDERING_PIPELINE__Enum);
DO_TYPEDEF(0x038C3AC0, SDKVector3);
DO_TYPEDEF(0x038C3760, SDKQuaternion);
DO_TYPEDEF(0x038C3520, SDKMatrix4x4);
DO_TYPEDEF(0x038C39A0, SDKTrackedSpace);
DO_TYPEDEF(0x038C35B0, SDKOutputFrame);
DO_TYPEDEF(0x038C3640, SDKPose);
DO_TYPEDEF(0x038C3400, SDKClipPlane);
DO_TYPEDEF(0x038C3A30, SDKTransform);
DO_TYPEDEF(0x038961D8, FEATURES__Enum);
DO_TYPEDEF(0x038C36D0, SDKPriority);
DO_TYPEDEF(0x038C3490, SDKInputFrame);
DO_TYPEDEF(0x038C37F0, SDKRender);
DO_TYPEDEF(0x03887770, u0A70u0A70u0A6Eu0A65u0A71u0A6Bu0A6Au0A67u0A6Eu0A6Eu0A68);
DO_TYPEDEF(0x0388ADF8, u0A74u0A6Eu0A65u0A72u0A68u0A67u0A6Bu0A6Au0A6Du0A6Cu0A73);
DO_TYPEDEF(0x038C22F0, List_1_u0A74u0A6Au0A6Au0A69u0A72u0A67u0A6Bu0A6Au0A6Au0A66u0A71_);
DO_TYPEDEF(0x03866D08, SpeechRecognitionController);
DO_TYPEDEF(0x038C2260, List_1_u0A73u0A6Du0A74u0A73u0A6Eu0A73u0A6Du0A70u0A65u0A6Fu0A73_);
DO_TYPEDEF(0x03889F20, u0A73u0A6Du0A74u0A73u0A6Eu0A73u0A6Du0A70u0A65u0A6Fu0A73);
DO_TYPEDEF(0x038BA580, List_1_EVPRecorder_);
DO_TYPEDEF(0x038C2140, List_1_u0A71u0A74u0A73u0A6Au0A6Eu0A71u0A6Fu0A6Du0A65u0A6Bu0A68_);
DO_TYPEDEF(0x03888B90, u0A71u0A74u0A73u0A6Au0A6Eu0A71u0A6Fu0A6Du0A65u0A6Bu0A68);
DO_TYPEDEF(0x038B12E8, MultiplayerController);
DO_TYPEDEF(0x038BD670, List_1_Noise_);
DO_TYPEDEF(0x0387F1A0, u0A65u0A6Du0A6Au0A73u0A6Fu0A66u0A6Fu0A70u0A67u0A6Eu0A69);
DO_TYPEDEF(0x03883530, u0A6Bu0A6Bu0A6Bu0A6Fu0A70u0A6Du0A6Au0A66u0A6Fu0A70u0A6F);
DO_TYPEDEF(0x038880E0, u0A71u0A69u0A66u0A69u0A70u0A66u0A66u0A65u0A68u0A68u0A67);
DO_TYPEDEF(0x03881D70, u0A69u0A66u0A71u0A65u0A6Au0A71u0A6Eu0A68u0A66u0A6Fu0A71);
DO_TYPEDEF(0x03888768, u0A71u0A6Fu0A74u0A6Du0A65u0A6Au0A65u0A6Cu0A74u0A6Fu0A6F);
DO_TYPEDEF(0x038842C8, u0A6Cu0A73u0A72u0A72u0A72u0A65u0A6Au0A71u0A71u0A68u0A6A);
DO_TYPEDEF(0x03889048, u0A72u0A69u0A72u0A69u0A6Fu0A70u0A6Du0A6Fu0A74u0A68u0A71);
DO_TYPEDEF(0x03895C20, GhostAI_u0A73u0A73u0A6Eu0A66u0A71u0A6Eu0A6Du0A69u0A6Du0A65u0A6E);
DO_TYPEDEF(0x038959C0, GhostAI_u0A6Au0A72u0A69u0A72u0A6Fu0A70u0A6Du0A6Cu0A6Eu0A71u0A6F);
DO_TYPEDEF(0x03895A58, GhostAI_u0A6Cu0A69u0A66u0A70u0A65u0A73u0A6Au0A68u0A6Fu0A67u0A6C);
DO_TYPEDEF(0x03895AF0, GhostAI_u0A6Cu0A74u0A70u0A69u0A73u0A65u0A67u0A74u0A67u0A6Du0A6B);
DO_TYPEDEF(0x03895898, GhostAI_u0A65u0A6Bu0A67u0A6Du0A68u0A74u0A72u0A71u0A67u0A66u0A6C);
DO_TYPEDEF(0x03895930, GhostAI_u0A69u0A6Fu0A6Du0A6Bu0A66u0A6Cu0A67u0A73u0A66u0A67u0A6F);
DO_TYPEDEF(0x03895CB8, GhostActivity_u0A6Au0A6Cu0A66u0A65u0A65u0A6Au0A6Fu0A73u0A71u0A67u0A65);
DO_TYPEDEF(0x038953A8, EvidenceController);
DO_TYPEDEF(0x038BA7C0, List_1_Evidence_);
DO_TYPEDEF(0x038BB780, List_1_IRLightSensor_);
DO_TYPEDEF(0x038BAA90, List_1_Fingerprint_);
DO_TYPEDEF(0x0387F5C8, u0A66u0A65u0A6Eu0A68u0A67u0A68u0A6Fu0A6Fu0A68u0A6Bu0A68);
DO_TYPEDEF(0x03882100, u0A69u0A6Au0A70u0A66u0A6Fu0A70u0A66u0A6Du0A6Fu0A6Bu0A6D);
DO_TYPEDEF(0x03888CC0, u0A72u0A67u0A6Au0A6Au0A74u0A6Bu0A6Du0A68u0A6Du0A70u0A67);
DO_TYPEDEF(0x0389BBA8, LevelValues_u0A6Cu0A68u0A73u0A70u0A6Eu0A6Cu0A65u0A67u0A66u0A6Du0A74__Enum);
DO_TYPEDEF(0x0387A470, BHapticsController);
DO_TYPEDEF(0x03880F40, u0A67u0A73u0A73u0A6Eu0A69u0A74u0A65u0A68u0A67u0A66u0A65);
DO_TYPEDEF(0x03889B90, u0A73u0A6Bu0A66u0A6Au0A72u0A6Fu0A65u0A6Eu0A72u0A74u0A72);
DO_TYPEDEF(0x03884490, u0A6Du0A67u0A65u0A73u0A65u0A68u0A73u0A68u0A66u0A68u0A74);
DO_TYPEDEF(0x03887CB8, u0A70u0A74u0A70u0A6Fu0A6Bu0A73u0A72u0A65u0A66u0A70u0A6C);
DO_TYPEDEF(0x0387ED78, u0A65u0A66u0A6Eu0A66u0A6Bu0A70u0A71u0A66u0A66u0A67u0A6C);
DO_TYPEDEF(0x03883E10, u0A6Cu0A6Cu0A73u0A67u0A70u0A6Eu0A65u0A6Bu0A6Au0A6Du0A65);
DO_TYPEDEF(0x0388AC30, u0A74u0A6Bu0A6Cu0A65u0A68u0A6Eu0A68u0A68u0A69u0A6Au0A67);
DO_TYPEDEF(0x03889800, u0A72u0A74u0A68u0A67u0A68u0A74u0A66u0A70u0A6Au0A72u0A6D);
DO_TYPEDEF(0x03884D70, u0A6Du0A74u0A73u0A73u0A72u0A70u0A6Cu0A6Du0A6Bu0A6Au0A6C);
DO_TYPEDEF(0x03881BB0, u0A68u0A74u0A69u0A70u0A67u0A73u0A66u0A69u0A68u0A65u0A6F);
DO_TYPEDEF(0x03884FC8, u0A6Eu0A68u0A69u0A6Fu0A70u0A6Cu0A74u0A6Bu0A6Eu0A69u0A72);
DO_TYPEDEF(0x038835C8, u0A6Bu0A6Cu0A65u0A70u0A6Fu0A6Eu0A68u0A6Eu0A6Bu0A68u0A72);
DO_TYPEDEF(0x0387F400, u0A65u0A71u0A6Eu0A6Eu0A6Bu0A73u0A6Eu0A67u0A65u0A66u0A66);
DO_TYPEDEF(0x03881A80, u0A68u0A72u0A65u0A67u0A6Fu0A67u0A65u0A6Fu0A6Fu0A66u0A72);
DO_TYPEDEF(0x03880950, u0A67u0A6Du0A66u0A69u0A6Fu0A6Eu0A68u0A68u0A6Du0A65u0A6C);
DO_TYPEDEF(0x038829E8, u0A6Au0A6Au0A68u0A6Fu0A6Du0A68u0A71u0A67u0A6Eu0A69u0A66);
DO_TYPEDEF(0x03880070, u0A67u0A65u0A6Fu0A67u0A6Au0A6Du0A6Au0A6Au0A73u0A73u0A74);
DO_TYPEDEF(0x0387F8C0, u0A66u0A69u0A6Du0A74u0A6Eu0A74u0A65u0A67u0A6Cu0A6Cu0A6D);
DO_TYPEDEF(0x038899C8, u0A73u0A66u0A74u0A6Bu0A6Eu0A68u0A69u0A66u0A69u0A70u0A6D);
DO_TYPEDEF(0x0388B0F0, u0A74u0A71u0A71u0A73u0A74u0A72u0A74u0A6Au0A72u0A6Cu0A74);
DO_TYPEDEF(0x038AE2C8, MenuAudio);
DO_TYPEDEF(0x0389CFD8, MenuAudio_u0A72u0A74u0A65u0A68u0A6Au0A6Cu0A66u0A72u0A71u0A6Eu0A6D);
DO_TYPEDEF(0x03884170, CursedItemsController);
DO_TYPEDEF(0x038C09A0, List_1_VoodooDollPin_);
DO_TYPEDEF(0x038881E0, DeadZoneController);
DO_TYPEDEF(0x03891200, DeadZoneController_u0A6Du0A68u0A72u0A65u0A6Bu0A66u0A71u0A6Au0A73u0A6Du0A73);
DO_TYPEDEF(0x03891298, DeadZoneController_u0A70u0A71u0A68u0A71u0A6Bu0A6Au0A73u0A6Bu0A69u0A74u0A71);
DO_TYPEDEF(0x0388A448, DifficultyController);
DO_TYPEDEF(0x03894338, EvidenceController_u0A6Cu0A65u0A67u0A6Fu0A69u0A67u0A74u0A6Eu0A6Fu0A68u0A6D);
DO_TYPEDEF(0x03895508, GameController_u0A6Du0A66u0A6Cu0A70u0A74u0A68u0A6Au0A6Fu0A69u0A66u0A65);
DO_TYPEDEF(0x03895470, GameController_u0A6Bu0A74u0A73u0A6Fu0A71u0A74u0A69u0A66u0A74u0A6Du0A6D);
DO_TYPEDEF(0x038956D0, GameController_u0A74u0A6Au0A6Au0A6Eu0A6Au0A6Cu0A6Du0A6Fu0A6Fu0A68u0A70);
DO_TYPEDEF(0x03895638, GameController_u0A72u0A73u0A6Cu0A65u0A65u0A6Du0A71u0A6Eu0A68u0A68u0A6A);
DO_TYPEDEF(0x038955A0, GameController_u0A6Du0A67u0A73u0A6Cu0A6Du0A67u0A72u0A71u0A66u0A6Fu0A73);
DO_TYPEDEF(0x038994E0, GhostController);
DO_TYPEDEF(0x038C46F0, List_1_u0A71u0A6Du0A65u0A71u0A73u0A6Eu0A6Bu0A6Bu0A72u0A6Bu0A74_u0A6Au0A67u0A65u0A6Cu0A69u0A65u0A6Eu0A6Fu0A6Fu0A70u0A69_);
DO_TYPEDEF(0x0389BB10, LevelController_u0A74u0A6Cu0A6Eu0A69u0A66u0A73u0A71u0A69u0A6Bu0A6Fu0A74);
DO_TYPEDEF(0x038AA540, LevelStats);
DO_TYPEDEF(0x038AA5D0, LevelValues);
DO_TYPEDEF(0x038AAE30, LightningController);
DO_TYPEDEF(0x03888F18, u0A72u0A68u0A73u0A73u0A66u0A6Bu0A6Bu0A6Fu0A74u0A74u0A6E);
DO_TYPEDEF(0x038AA128, Dictionary_2_u0A72u0A68u0A73u0A73u0A66u0A6Bu0A6Bu0A6Fu0A74u0A74u0A6E_u0A67u0A72u0A71u0A72u0A6Au0A69u0A6Du0A6Fu0A6Eu0A66u0A6B_System_String_);
DO_TYPEDEF(0x038B8840, List_1_List_1_System_String_);
DO_TYPEDEF(0x038AD0E0, MapController);
DO_TYPEDEF(0x038B0D58, MotionSensorData);
DO_TYPEDEF(0x038BD160, List_1_MotionSensor_);
DO_TYPEDEF(0x038B5B78, ObjectPooler);
DO_TYPEDEF(0x038C34F0, List_1_ObjectPooler_Pool_);
DO_TYPEDEF(0x038A6DA8, Dictionary_2_System_String_Queue_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x038C6278, Queue_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x038A3EF8, PhraseListenerController_u0A6Fu0A6Cu0A67u0A6Fu0A6Du0A6Cu0A74u0A6Fu0A70u0A72u0A6D);
DO_TYPEDEF(0x038BABE0, PlayerVolumes);
DO_TYPEDEF(0x038A7048, SanityEffectsController_u0A71u0A6Bu0A69u0A6Du0A66u0A6Au0A6Du0A72u0A6Au0A72u0A73);
DO_TYPEDEF(0x0386F1D0, TrainingController);
DO_TYPEDEF(0x038B3328, u0A6Bu0A67u0A6Bu0A72u0A6Eu0A65u0A66u0A67u0A6Au0A74u0A6F_u0A74u0A68u0A6Au0A6Au0A69u0A6Bu0A68u0A6Bu0A72u0A74u0A74);
DO_TYPEDEF(0x03883238, u0A6Bu0A67u0A6Bu0A72u0A6Eu0A65u0A66u0A67u0A6Au0A74u0A6F);
DO_TYPEDEF(0x0388A2B0, u0A73u0A72u0A6Fu0A6Bu0A70u0A6Cu0A69u0A70u0A6Eu0A74u0A66);
DO_TYPEDEF(0x038C4660, List_1_u0A6Bu0A67u0A6Bu0A72u0A6Eu0A65u0A66u0A67u0A6Au0A74u0A6F_u0A74u0A68u0A6Au0A6Au0A69u0A6Bu0A68u0A6Bu0A72u0A74u0A74_);
DO_TYPEDEF(0x038822C8, u0A69u0A6Bu0A6Du0A72u0A73u0A73u0A68u0A65u0A70u0A74u0A69);
DO_TYPEDEF(0x038C18D0, List_1_u0A6Bu0A67u0A6Bu0A72u0A6Eu0A65u0A66u0A67u0A6Au0A74u0A6F_);
DO_TYPEDEF(0x038809E8, u0A67u0A6Du0A73u0A74u0A67u0A6Bu0A67u0A72u0A6Eu0A6Cu0A70__Enum);
DO_TYPEDEF(0x03875198, VolumetricFog);
DO_TYPEDEF(0x03874B78, VolumetricFog_PointLightParams__Array);
DO_TYPEDEF(0x038C0880, List_1_VolumetricFogAndMist_VolumetricFog_);
DO_TYPEDEF(0x03874C10, VolumetricFog_u0A6Fu0A6Bu0A74u0A66u0A6Au0A66u0A6Cu0A69u0A66u0A65u0A6A__Array);
DO_TYPEDEF(0x038BE780, RandomWeather);
DO_TYPEDEF(0x0388E0D0, DNAEvidence_u0A6Du0A68u0A6Bu0A6Fu0A70u0A6Du0A70u0A69u0A67u0A66u0A67);
DO_TYPEDEF(0x038A23F8, ParabolicSound_u0A6Fu0A69u0A68u0A6Au0A65u0A74u0A6Cu0A69u0A6Fu0A6Bu0A71);
DO_TYPEDEF(0x038A2368, ParabolicSound_u0A6Bu0A6Bu0A70u0A67u0A6Eu0A72u0A6Au0A66u0A74u0A6Eu0A71);
DO_TYPEDEF(0x0388C048, AudioListenerTempMute_u0A73u0A74u0A6Du0A70u0A69u0A6Cu0A69u0A67u0A6Bu0A6Bu0A70);
DO_TYPEDEF(0x0387A800, BannedWords);
DO_TYPEDEF(0x0388C3D0, BannedWords_c);
DO_TYPEDEF(0x038825C0, u0A69u0A72u0A67u0A65u0A6Bu0A72u0A6Cu0A65u0A6Fu0A70u0A73);
DO_TYPEDEF(0x0389BD70, LightPulse_u0A69u0A6Bu0A73u0A6Au0A65u0A6Eu0A73u0A6Cu0A73u0A73u0A70);
DO_TYPEDEF(0x0388AA68, u0A74u0A69u0A6Fu0A73u0A73u0A71u0A66u0A6Eu0A65u0A66u0A6E);
DO_TYPEDEF(0x03891CA0, Door_u0A66u0A67u0A69u0A71u0A67u0A6Bu0A6Au0A6Cu0A6Eu0A6Du0A71);
DO_TYPEDEF(0x03891D38, Door_u0A6Bu0A72u0A65u0A69u0A67u0A70u0A6Du0A6Bu0A69u0A6Fu0A67);
DO_TYPEDEF(0x03891E68, Door_u0A6Fu0A66u0A68u0A74u0A74u0A6Cu0A71u0A69u0A73u0A73u0A68);
DO_TYPEDEF(0x03891F00, Door_u0A72u0A70u0A6Bu0A6Du0A6Au0A6Du0A71u0A6Fu0A66u0A70u0A70);
DO_TYPEDEF(0x03891DD0, Door_u0A6Eu0A6Du0A69u0A6Au0A6Cu0A71u0A6Du0A70u0A66u0A6Du0A6F);
DO_TYPEDEF(0x0389BFD0, LightSwitch_u0A70u0A6Au0A6Fu0A6Bu0A6Du0A74u0A6Fu0A66u0A68u0A69u0A70);
DO_TYPEDEF(0x0389BE08, LightSwitch_u0A66u0A6Fu0A6Cu0A6Du0A71u0A6Bu0A67u0A6Eu0A68u0A72u0A72);
DO_TYPEDEF(0x0389BF38, LightSwitch_u0A6Eu0A72u0A6Fu0A6Au0A6Au0A6Du0A67u0A6Bu0A71u0A72u0A74);
DO_TYPEDEF(0x0389BEA0, LightSwitch_u0A6Bu0A6Eu0A74u0A6Fu0A69u0A6Du0A67u0A74u0A65u0A6Bu0A6B);
DO_TYPEDEF(0x038936C0, EVPRecorder_u0A6Bu0A68u0A73u0A71u0A6Eu0A73u0A6Cu0A6Du0A65u0A74u0A74);
DO_TYPEDEF(0x03893628, EVPRecorder_u0A6Au0A6Du0A6Bu0A72u0A6Fu0A71u0A74u0A6Au0A72u0A6Au0A74);
DO_TYPEDEF(0x03894B88, FireSource_u0A74u0A73u0A6Du0A66u0A67u0A6Bu0A6Du0A70u0A71u0A6Eu0A66);
DO_TYPEDEF(0x0389B4F0, HandCamera);
DO_TYPEDEF(0x03896C18, HandCamera_u0A71u0A73u0A6Eu0A6Au0A73u0A74u0A72u0A69u0A6Eu0A72u0A6B);
DO_TYPEDEF(0x03896B80, HandCamera_u0A6Fu0A67u0A69u0A6Bu0A72u0A6Fu0A72u0A73u0A74u0A6Fu0A71);
DO_TYPEDEF(0x03897040, HauntedMirror_u0A6Au0A72u0A65u0A66u0A69u0A70u0A68u0A68u0A68u0A65u0A67);
DO_TYPEDEF(0x03897F18, IRLightSensor_u0A74u0A6Au0A6Fu0A74u0A74u0A67u0A67u0A6Fu0A69u0A67u0A6E);
DO_TYPEDEF(0x03897DE8, IRLightSensor_u0A65u0A74u0A6Fu0A70u0A70u0A73u0A65u0A6Du0A72u0A74u0A71);
DO_TYPEDEF(0x03897E80, IRLightSensor_u0A66u0A68u0A6Cu0A72u0A6Bu0A6Eu0A67u0A70u0A70u0A67u0A65);
DO_TYPEDEF(0x0389E108, MotionSensor_u0A67u0A70u0A6Fu0A65u0A67u0A6Fu0A72u0A6Au0A70u0A70u0A72);
DO_TYPEDEF(0x0389E1A0, MotionSensor_u0A73u0A71u0A6Bu0A6Fu0A70u0A67u0A74u0A71u0A6Fu0A72u0A65);
DO_TYPEDEF(0x038A14B0, OuijaBoard_u0A6Bu0A65u0A66u0A71u0A6Fu0A67u0A6Cu0A6Eu0A70u0A73u0A6A);
DO_TYPEDEF(0x038A1418, OuijaBoard_c);
DO_TYPEDEF(0x038A2248, PainKillers_u0A69u0A6Fu0A70u0A68u0A6Eu0A6Au0A6Au0A69u0A71u0A6Bu0A72);
DO_TYPEDEF(0x038A22D8, ParabolicMicrophone_u0A6Du0A66u0A68u0A6Eu0A71u0A67u0A6Du0A74u0A72u0A65u0A74);
DO_TYPEDEF(0x038AB750, Stream_u0A6Bu0A66u0A74u0A6Eu0A69u0A6Bu0A70u0A6Eu0A74u0A69u0A67);
DO_TYPEDEF(0x038AB7E0, Stream_u0A72u0A6Fu0A6Cu0A6Bu0A71u0A6Au0A69u0A6Eu0A73u0A6Bu0A66);
DO_TYPEDEF(0x038A6FB8, SaltShaker_u0A67u0A71u0A6Cu0A6Fu0A68u0A70u0A69u0A67u0A6Fu0A69u0A6D);
DO_TYPEDEF(0x038ADB18, Thermometer_u0A66u0A72u0A74u0A74u0A67u0A74u0A72u0A6Cu0A66u0A73u0A6B);
DO_TYPEDEF(0x038AE648, Torch_u0A6Fu0A6Fu0A72u0A6Au0A74u0A65u0A70u0A70u0A6Au0A6Cu0A71);
DO_TYPEDEF(0x038B1318, VoodooDollPin_u0A6Eu0A70u0A65u0A6Bu0A72u0A69u0A6Au0A72u0A6Bu0A6Bu0A70);
DO_TYPEDEF(0x038B1288, VoodooDollPin_c);
DO_TYPEDEF(0x0388A4E0, DifficultySettings);
DO_TYPEDEF(0x038ABB98, LocalisationSystem);
DO_TYPEDEF(0x038749E0, ViveportAuth);
DO_TYPEDEF(0x038A7A88, Dictionary_2_System_String_Photon_Realtime_RoomInfo_);
DO_TYPEDEF(0x0388D6C0, ConnectToServer_c);
DO_TYPEDEF(0x0388D758, ConnectToServer_u0A74u0A6Au0A67u0A74u0A70u0A6Eu0A6Fu0A6Au0A65u0A67u0A6E);
DO_TYPEDEF(0x0389C788, LobbyManager_u0A6Eu0A6Bu0A6Bu0A74u0A70u0A6Au0A6Cu0A66u0A6Eu0A72u0A66);
DO_TYPEDEF(0x0389C8B8, MainManager_u0A69u0A6Cu0A6Au0A66u0A6Eu0A70u0A65u0A68u0A74u0A68u0A74);
DO_TYPEDEF(0x038A18B8, PCManager_u0A6Fu0A6Eu0A6Au0A72u0A66u0A67u0A6Du0A70u0A6Fu0A72u0A6E);
DO_TYPEDEF(0x038A7670, ServerManager_u0A69u0A68u0A6Eu0A65u0A74u0A72u0A6Bu0A68u0A71u0A6Au0A6F);
DO_TYPEDEF(0x038A75E0, ServerManager_u0A68u0A65u0A65u0A6Cu0A71u0A74u0A71u0A6Fu0A65u0A73u0A6C);
DO_TYPEDEF(0x038AB488, SplashScreen_u0A67u0A69u0A67u0A74u0A68u0A6Cu0A71u0A6Du0A68u0A6Du0A67);
DO_TYPEDEF(0x038B06D8, VRManager_u0A74u0A66u0A6Du0A6Eu0A6Du0A6Du0A70u0A66u0A74u0A69u0A74);
DO_TYPEDEF(0x03874FD0, VoiceRecognitionManager);
DO_TYPEDEF(0x038AF778, Mission);
DO_TYPEDEF(0x038AFC88, MissionGhostType);
DO_TYPEDEF(0x038AFDA8, MissionManager);
DO_TYPEDEF(0x038BCF20, List_1_Mission_);
DO_TYPEDEF(0x0389DBB8, MissionManager_u0A6Au0A6Eu0A6Cu0A6Eu0A70u0A6Bu0A6Fu0A6Du0A6Eu0A6Au0A66);
DO_TYPEDEF(0x038AF808, MissionAverageSanity);
DO_TYPEDEF(0x038AF898, MissionBurnSage);
DO_TYPEDEF(0x038AF928, MissionCandle);
DO_TYPEDEF(0x038AF9B8, MissionCapturePhoto);
DO_TYPEDEF(0x038AFA48, MissionCrucifix);
DO_TYPEDEF(0x038AFAD8, MissionEMFEvidence);
DO_TYPEDEF(0x038AFB68, MissionEscapeGhost);
DO_TYPEDEF(0x038AFBF8, MissionGhostEvent);
DO_TYPEDEF(0x038AFD18, MissionHuntSmudge);
DO_TYPEDEF(0x038AFE38, MissionMotionSensor);
DO_TYPEDEF(0x038AFEC8, MissionParabolic);
DO_TYPEDEF(0x038AFF58, MissionSalt);
DO_TYPEDEF(0x038BD0D0, List_1_UnityEngine_MonoBehaviour_);
DO_TYPEDEF(0x038B9B60, List_1_UnityEngine_Camera_);
DO_TYPEDEF(0x038A1798, PCControls_BindingWrapperClass);
DO_TYPEDEF(0x038C38E0, List_1_PCControls_BindingSerializable_);
DO_TYPEDEF(0x038A1708, PCControls_BindingSerializable);
DO_TYPEDEF(0x038A1828, PCCrouch_u0A6Cu0A6Du0A69u0A71u0A70u0A71u0A70u0A69u0A71u0A73u0A74);
DO_TYPEDEF(0x038A1948, PCMenu_c);
DO_TYPEDEF(0x038A19D8, PCMenu_u0A65u0A6Cu0A73u0A68u0A72u0A69u0A6Fu0A72u0A6Au0A6Bu0A67);
DO_TYPEDEF(0x038A1A68, PCMenu_u0A6Eu0A68u0A6Cu0A6Du0A69u0A67u0A6Au0A71u0A66u0A70u0A6B);
DO_TYPEDEF(0x038A1AF8, PCMenu_u0A6Fu0A71u0A68u0A6Fu0A74u0A6Eu0A70u0A72u0A74u0A68u0A74);
DO_TYPEDEF(0x038A1B88, PCMenu_u0A70u0A6Au0A6Cu0A69u0A6Bu0A70u0A69u0A6Bu0A73u0A70u0A73);
DO_TYPEDEF(0x038A1C18, PCPropGrab_u0A65u0A68u0A73u0A69u0A6Cu0A71u0A68u0A69u0A68u0A73u0A6B);
DO_TYPEDEF(0x03891168, DeadPlayer_u0A67u0A6Eu0A65u0A6Cu0A74u0A65u0A71u0A6Bu0A6Du0A6Du0A6B);
DO_TYPEDEF(0x03894D50, FootstepController_u0A70u0A72u0A67u0A6Bu0A66u0A73u0A70u0A6Cu0A6Du0A6Bu0A66);
DO_TYPEDEF(0x038A4258, Player_u0A70u0A6Cu0A66u0A71u0A65u0A66u0A6Au0A6Cu0A72u0A65u0A69);
DO_TYPEDEF(0x038A41C8, Player_u0A6Cu0A74u0A65u0A69u0A65u0A65u0A69u0A6Au0A6Eu0A67u0A6A);
DO_TYPEDEF(0x038A42E8, Player_u0A71u0A66u0A6Fu0A73u0A73u0A6Bu0A72u0A74u0A68u0A6Fu0A6C);
DO_TYPEDEF(0x038A4378, PlayerAudio_u0A6Fu0A65u0A73u0A6Bu0A65u0A66u0A65u0A71u0A6Eu0A6Du0A6E);
DO_TYPEDEF(0x038A4D08, PlayerVoice_u0A65u0A69u0A70u0A6Du0A65u0A6Fu0A70u0A65u0A70u0A6Au0A6A);
DO_TYPEDEF(0x038B0FC0, VoiceVolume_u0A6Du0A6Bu0A6Cu0A71u0A74u0A6Au0A70u0A66u0A69u0A69u0A72);
DO_TYPEDEF(0x038AB638, StoreSDKManager_u0A6Du0A71u0A65u0A68u0A6Bu0A6Fu0A74u0A69u0A72u0A6Eu0A70);
DO_TYPEDEF(0x038AACB8, Snowball_u0A68u0A72u0A73u0A6Bu0A6Eu0A6Au0A6Cu0A73u0A69u0A66u0A6F);
DO_TYPEDEF(0x0388C178, AutoPlayAudio_u0A65u0A6Cu0A65u0A6Au0A74u0A6Bu0A69u0A68u0A67u0A6Au0A72);
DO_TYPEDEF(0x03893F10, EventObject_u0A6Eu0A73u0A6Du0A67u0A6Bu0A72u0A6Bu0A6Du0A6Au0A6Au0A72);
DO_TYPEDEF(0x03899578, GlitchyText);
DO_TYPEDEF(0x0389AD68, InteractEffects_u0A6Du0A6Fu0A65u0A68u0A6Bu0A71u0A69u0A70u0A74u0A67u0A6F);
DO_TYPEDEF(0x0388BBF8, EMFData);
DO_TYPEDEF(0x03894468, ExitLevel_u0A70u0A6Cu0A6Bu0A6Au0A6Fu0A6Bu0A67u0A73u0A68u0A67u0A74);
DO_TYPEDEF(0x0389BD40, HeartRateData);
DO_TYPEDEF(0x0389BCD8, LiftButton_u0A73u0A6Du0A70u0A6Au0A6Eu0A6Du0A71u0A70u0A65u0A6Bu0A67);
DO_TYPEDEF(0x0389E2D0, MotionSensorData_u0A69u0A6Bu0A6Eu0A69u0A65u0A72u0A6Bu0A6Du0A72u0A6Eu0A68);
DO_TYPEDEF(0x0389E400, MotionSensorData_u0A70u0A6Au0A70u0A67u0A6Eu0A6Au0A70u0A72u0A72u0A6Eu0A6A);
DO_TYPEDEF(0x0389E238, MotionSensorData_u0A66u0A71u0A6Cu0A67u0A66u0A6Au0A6Du0A72u0A6Au0A6Au0A6B);
DO_TYPEDEF(0x0389E368, MotionSensorData_u0A6Du0A71u0A69u0A67u0A70u0A69u0A73u0A6Du0A6Du0A6Cu0A65);
DO_TYPEDEF(0x03866BE8, SoundSensorData);
DO_TYPEDEF(0x038AEEB8, TruckRadioController_u0A6Au0A6Cu0A68u0A6Fu0A73u0A71u0A6Eu0A73u0A65u0A6Fu0A72);
DO_TYPEDEF(0x038B33B8, u0A6Bu0A69u0A65u0A67u0A6Bu0A73u0A6Au0A74u0A67u0A74u0A74_u0A6Fu0A6Cu0A74u0A66u0A72u0A6Eu0A6Eu0A74u0A67u0A6Cu0A6E__Enum);
DO_TYPEDEF(0x038B0408, VRCalibration_u0A71u0A73u0A71u0A68u0A67u0A65u0A74u0A72u0A6Au0A66u0A70);
DO_TYPEDEF(0x038B0498, VRGrabbable_u0A67u0A65u0A68u0A6Bu0A6Bu0A69u0A6Bu0A67u0A6Eu0A6Eu0A73);
DO_TYPEDEF(0x038C05B0, List_1_VRGrabbable_);
DO_TYPEDEF(0x038B0768, VRSocket_u0A65u0A73u0A6Au0A72u0A72u0A6Du0A67u0A6Fu0A73u0A6Eu0A71);
DO_TYPEDEF(0x038B07F8, VRSwitcher_u0A6Fu0A67u0A72u0A67u0A74u0A65u0A6Eu0A70u0A6Au0A72u0A71);
DO_TYPEDEF(0x038B0888, VRVoice_u0A6Eu0A72u0A66u0A6Fu0A65u0A69u0A67u0A67u0A68u0A6Au0A69);
DO_TYPEDEF(0x03874A78, ViveportDemo);
DO_TYPEDEF(0x038B09A8, ViveportDemo_u0A72u0A67u0A74u0A67u0A68u0A6Au0A68u0A70u0A6Au0A70u0A65);
DO_TYPEDEF(0x03874B10, ViveportDemo_ArcadeSession);
DO_TYPEDEF(0x038B0A38, ViveportDemo_ArcadeSession_u0A68u0A67u0A71u0A6Fu0A72u0A73u0A67u0A6Bu0A6Fu0A6Cu0A70);
DO_TYPEDEF(0x03874BA8, ViveportDemo_DLC);
DO_TYPEDEF(0x03874C40, ViveportDemo_Deeplink);
DO_TYPEDEF(0x038B0BE0, ViveportDemo_Deeplink_u0A6Cu0A68u0A70u0A6Cu0A71u0A6Bu0A6Cu0A68u0A74u0A71u0A69);
DO_TYPEDEF(0x038B0AC0, ViveportDemo_Deeplink_c);
DO_TYPEDEF(0x038B0B50, ViveportDemo_Deeplink_u0A6Au0A6Bu0A65u0A6Au0A6Fu0A72u0A65u0A6Bu0A6Fu0A70u0A6B);
DO_TYPEDEF(0x038B0C68, ViveportDemo_Deeplink_u0A6Cu0A6Eu0A69u0A73u0A73u0A74u0A66u0A6Du0A66u0A70u0A73);
DO_TYPEDEF(0x03874CD8, ViveportDemo_IAP);
DO_TYPEDEF(0x038B0CF8, ViveportDemo_IAP_u0A66u0A68u0A6Eu0A70u0A6Du0A6Fu0A71u0A6Au0A66u0A6Cu0A70);
DO_TYPEDEF(0x03897338, IAPurchase_QueryResponse);
DO_TYPEDEF(0x038972A0, IAPurchase_QueryListResponse);
DO_TYPEDEF(0x038C2DA0, List_1_Viveport_IAPurchase_QueryResponse2_);
DO_TYPEDEF(0x038973D0, IAPurchase_QueryResponse2);
DO_TYPEDEF(0x038B0D88, ViveportDemo_IAP_u0A74u0A6Eu0A73u0A67u0A71u0A69u0A71u0A6Fu0A67u0A6Fu0A6C);
DO_TYPEDEF(0x03874D70, ViveportDemo_MainThreadDispatcher);
DO_TYPEDEF(0x038B0E18, ViveportDemo_MainThreadDispatcher_u0A71u0A73u0A6Cu0A74u0A6Bu0A68u0A67u0A6Bu0A65u0A74u0A6B);
DO_TYPEDEF(0x038B6FE8, ViveportDemo_MainThreadDispatcher_u0A71u0A73u0A6Cu0A74u0A6Bu0A68u0A67u0A6Bu0A65u0A74u0A6B_u0A73u0A6Du0A73u0A67u0A69u0A66u0A6Eu0A70u0A6Cu0A70u0A72);
DO_TYPEDEF(0x038B7078, ViveportDemo_MainThreadDispatcher_u0A74u0A72u0A6Cu0A6Fu0A69u0A72u0A6Au0A69u0A65u0A69u0A73_u0A6Bu0A66u0A70u0A6Bu0A6Fu0A72u0A70u0A74u0A73u0A6Au0A70);
DO_TYPEDEF(0x03874E08, ViveportDemo_Subscription);
DO_TYPEDEF(0x03883D78, u0A6Cu0A6Bu0A74u0A66u0A71u0A6Fu0A72u0A69u0A71u0A6Bu0A71);
DO_TYPEDEF(0x038ACC68, MainThreadDispatcher);
DO_TYPEDEF(0x038C61E8, Queue_1_System_Action_);
DO_TYPEDEF(0x0389C950, MainThreadDispatcher_c_DisplayClass6_0);
DO_TYPEDEF(0x0389C9E8, MainThreadDispatcher_ActionWrapper_d_12);
DO_TYPEDEF(0x03867B18, StatusCallback);
DO_TYPEDEF(0x03867C38, StatusCallback2);
DO_TYPEDEF(0x038BD3D0, QueryRuntimeModeCallback);
DO_TYPEDEF(0x038A9FA8, Leaderboard);
DO_TYPEDEF(0x03869580, SubscriptionStatus);
DO_TYPEDEF(0x038C3E80, List_1_Viveport_SubscriptionStatus_Platform_);
DO_TYPEDEF(0x03877AE8, Api);
DO_TYPEDEF(0x038BAD60, List_1_Viveport_Internal_GetLicenseCallback_);
DO_TYPEDEF(0x03899448, GetLicenseCallback);
DO_TYPEDEF(0x038BF170, List_1_Viveport_Internal_StatusCallback_);
DO_TYPEDEF(0x03867BA8, StatusCallback_1);
DO_TYPEDEF(0x038BE360, List_1_Viveport_Internal_QueryRuntimeModeCallback_);
DO_TYPEDEF(0x038BD460, QueryRuntimeModeCallback_1);
DO_TYPEDEF(0x038BF200, List_1_Viveport_Internal_StatusCallback2_);
DO_TYPEDEF(0x03867CC8, StatusCallback2_1);
DO_TYPEDEF(0x038C24A0, List_1_Viveport_Api_LicenseChecker_);
DO_TYPEDEF(0x03873308, User);
DO_TYPEDEF(0x03873428, UserStats);
DO_TYPEDEF(0x038780D8, ArcadeLeaderboard);
DO_TYPEDEF(0x0389C888, IAPurchase);
DO_TYPEDEF(0x0389C920, IAPurchaseCallback);
DO_TYPEDEF(0x03897208, IAPurchase_IAPHandler);
DO_TYPEDEF(0x03884B80, DLC);
DO_TYPEDEF(0x03869460, Subscription);
DO_TYPEDEF(0x03888B60, Deeplink);
DO_TYPEDEF(0x0386DB20, Token);
DO_TYPEDEF(0x03878170, ArcadeLeaderboard_1);
DO_TYPEDEF(0x03877B80, Api_1);
DO_TYPEDEF(0x03873398, User_1);
DO_TYPEDEF(0x038734B8, UserStats_1);
DO_TYPEDEF(0x03884C18, DLC_1);
DO_TYPEDEF(0x038694F0, Subscription_1);
DO_TYPEDEF(0x0386DBB0, Token_1);
DO_TYPEDEF(0x03888BF8, Deeplink_1);
DO_TYPEDEF(0x038C74A8, SessionCallback);
DO_TYPEDEF(0x038C7418, Session_1);
DO_TYPEDEF(0x038A78A8, Session_SessionHandler);
DO_TYPEDEF(0x038AC010, Logger_2);
DO_TYPEDEF(0x03888178, u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74);
DO_TYPEDEF(0x038B6178, IList_1_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038B2AE8, IDictionary_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038B5908, IList_1_KeyValuePair_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x03880C48, u0A67u0A73u0A66u0A69u0A67u0A6Fu0A70u0A65u0A66u0A69u0A71);
DO_TYPEDEF(0x03889470, u0A72u0A71u0A65u0A65u0A74u0A6Eu0A72u0A74u0A72u0A68u0A72);
DO_TYPEDEF(0x038C7FB8, Stack_1_u0A72u0A71u0A65u0A65u0A74u0A6Eu0A72u0A74u0A72u0A68u0A72_);
DO_TYPEDEF(0x0387F828, u0A66u0A68u0A6Au0A6Bu0A6Bu0A6Au0A66u0A72u0A6Au0A71u0A6D);
DO_TYPEDEF(0x0388B188, u0A74u0A73u0A70u0A6Cu0A70u0A6Fu0A70u0A6Cu0A6Au0A6Eu0A6A);
DO_TYPEDEF(0x038B4318, IEnumerator_1_KeyValuePair_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038883D8, u0A71u0A6Eu0A69u0A6Fu0A6Bu0A65u0A71u0A65u0A71u0A6Bu0A6E);
DO_TYPEDEF(0x0388AB98, u0A74u0A6Au0A74u0A70u0A65u0A65u0A6Eu0A71u0A70u0A6Fu0A6F__Enum);
DO_TYPEDEF(0x038B2A58, IDictionary_2_System_String_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x03884658, u0A6Du0A6Au0A6Bu0A66u0A69u0A6Du0A69u0A6Eu0A67u0A6Bu0A70);
DO_TYPEDEF(0x0388A770, u0A74u0A67u0A6Bu0A6Du0A74u0A69u0A72u0A69u0A71u0A73u0A74);
DO_TYPEDEF(0x038890E0, u0A72u0A6Au0A66u0A6Au0A70u0A67u0A71u0A6Bu0A69u0A71u0A65);
DO_TYPEDEF(0x03888048, u0A71u0A68u0A73u0A6Cu0A66u0A6Fu0A6Du0A68u0A69u0A6Eu0A6E);
DO_TYPEDEF(0x038B28A8, IDictionary_2_System_Int32_IDictionary_2_System_Int32_System_Int32_);
DO_TYPEDEF(0x038C7BC8, Stack_1_System_Int32_);
DO_TYPEDEF(0x038892A8, u0A72u0A6Cu0A6Du0A6Cu0A6Bu0A73u0A67u0A6Au0A69u0A72u0A65);
DO_TYPEDEF(0x038B46D8, u0A72u0A6Cu0A6Du0A6Cu0A6Bu0A73u0A67u0A6Au0A69u0A72u0A65_u0A66u0A69u0A74u0A71u0A66u0A6Fu0A74u0A70u0A71u0A72u0A68);
DO_TYPEDEF(0x03884108, u0A6Cu0A70u0A66u0A6Au0A6Du0A6Au0A71u0A73u0A71u0A67u0A68);
DO_TYPEDEF(0x03875328, u0A72u0A6Cu0A6Du0A6Cu0A6Bu0A73u0A67u0A6Au0A69u0A72u0A65_u0A66u0A69u0A74u0A71u0A66u0A6Fu0A74u0A70u0A71u0A72u0A68__Array);
DO_TYPEDEF(0x038B2C08, IDictionary_2_System_Type_IDictionary_2_System_Type_u0A74u0A67u0A6Bu0A6Du0A74u0A69u0A72u0A69u0A71u0A73u0A74_);
DO_TYPEDEF(0x03885190, u0A6Eu0A6Bu0A70u0A70u0A66u0A6Au0A71u0A71u0A6Eu0A65u0A67);
DO_TYPEDEF(0x038B2ED8, IDictionary_2_System_Type_u0A6Du0A6Au0A6Bu0A66u0A69u0A6Du0A69u0A6Eu0A67u0A6Bu0A70_);
DO_TYPEDEF(0x038B2E48, IDictionary_2_System_Type_u0A69u0A70u0A71u0A6Eu0A6Fu0A70u0A66u0A67u0A6Bu0A69u0A6B_);
DO_TYPEDEF(0x038B2B78, IDictionary_2_System_Type_IDictionary_2_System_Type_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038B2DB8, IDictionary_2_System_Type_u0A65u0A6Fu0A68u0A6Bu0A6Fu0A68u0A6Cu0A67u0A71u0A68u0A71_);
DO_TYPEDEF(0x038B2C98, IDictionary_2_System_Type_IList_1_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038B3DD8, u0A6Eu0A6Bu0A70u0A70u0A66u0A6Au0A71u0A71u0A6Eu0A65u0A67_c);
DO_TYPEDEF(0x038B8FC0, Photon3DAudio);
DO_TYPEDEF(0x038A3568, Photon3DAudio_Start_d_1);
DO_TYPEDEF(0x0389D790, MeshUniqueVertices_u0A68u0A6Cu0A70u0A72u0A68u0A6Eu0A6Cu0A70u0A6Eu0A6Cu0A73);
DO_TYPEDEF(0x0389D828, MeshUniqueVertices_u0A6Du0A6Du0A6Eu0A70u0A70u0A6Fu0A73u0A74u0A6Bu0A74u0A6C);
DO_TYPEDEF(0x0389D6F8, MeshUniqueVertices_u0A67u0A74u0A66u0A6Du0A6Du0A73u0A74u0A73u0A6Eu0A68u0A72);
DO_TYPEDEF(0x038C32B0, List_1_UltimateGameTools_MeshSimplifier_MeshUniqueVertices_u0A6Du0A6Du0A6Eu0A70u0A70u0A6Fu0A73u0A74u0A6Bu0A74u0A6C_);
DO_TYPEDEF(0x038AA958, Simplifier_u0A74u0A70u0A67u0A73u0A6Fu0A6Du0A71u0A6Fu0A65u0A65u0A70);
DO_TYPEDEF(0x038AA8C8, Simplifier_u0A74u0A68u0A6Cu0A66u0A73u0A6Bu0A69u0A69u0A67u0A6Cu0A69);
DO_TYPEDEF(0x038AA688, Simplifier_u0A6Fu0A69u0A6Bu0A71u0A66u0A6Au0A6Du0A72u0A69u0A69u0A6B);
DO_TYPEDEF(0x038AA570, Simplifier_u0A6Eu0A66u0A70u0A72u0A69u0A68u0A69u0A68u0A70u0A66u0A67);
DO_TYPEDEF(0x038AA7A8, Simplifier_u0A6Fu0A70u0A67u0A70u0A6Eu0A72u0A6Au0A6Cu0A6Fu0A73u0A6B);
DO_TYPEDEF(0x038B8720, List_1_List_1_System_Int32_);
DO_TYPEDEF(0x038B96E0, List_1_UnityEngine_BoneWeight_);
DO_TYPEDEF(0x038AA098, Dictionary_2_UltimateGameTools_MeshSimplifier_Simplifier_u0A74u0A68u0A6Cu0A66u0A73u0A6Bu0A69u0A69u0A67u0A6Cu0A69_System_Int32_);
DO_TYPEDEF(0x038AA600, Simplifier_u0A6Fu0A68u0A6Cu0A74u0A69u0A70u0A69u0A6Bu0A6Bu0A66u0A69);
DO_TYPEDEF(0x038A4048, Dictionary_2_UnityEngine_Camera_System_Boolean_);
DO_TYPEDEF(0x03875C40, WaterBase);
DO_TYPEDEF(0x03875BA8, Water);
DO_TYPEDEF(0x038A40D8, Dictionary_2_UnityEngine_Camera_UnityEngine_Camera_);
DO_TYPEDEF(0x0388AE60, DoNotDestroyBehaviour);
DO_TYPEDEF(0x038752C0, VolumetricLight);
DO_TYPEDEF(0x038896D0, u0A72u0A73u0A70u0A73u0A66u0A6Du0A69u0A70u0A6Fu0A66u0A71);
DO_TYPEDEF(0x038C0910, List_1_VolumetricLights_VolumetricLight_);
DO_TYPEDEF(0x038B1048, VolumetricFog_c);
DO_TYPEDEF(0x038A2818, Comparison_1_VolumetricFogAndMist_VolumetricFog_);
DO_TYPEDEF(0x03875230, VolumetricFogMaterialIntegration);
DO_TYPEDEF(0x03874CA8, VolumetricFogMaterialIntegration_u0A6Fu0A6Bu0A6Fu0A68u0A70u0A74u0A73u0A71u0A74u0A6Eu0A71__Array);
DO_TYPEDEF(0x0387EE10, u0A65u0A66u0A71u0A70u0A67u0A6Au0A69u0A6Eu0A73u0A70u0A6A__Enum);
DO_TYPEDEF(0x0388BA30, DynamicFogBase);
DO_TYPEDEF(0x0388BAC8, DynamicFogOfWar);
DO_TYPEDEF(0x0388B518, AdvancedNightVision_u0A6Au0A6Fu0A65u0A73u0A73u0A6Eu0A65u0A70u0A69u0A74u0A6C__Enum);
DO_TYPEDEF(0x038766B8, AdvancedNightVision);
DO_TYPEDEF(0x038BC7D0, List_1_UnityEngine_Light_);
DO_TYPEDEF(0x038AE590, MeshCombiner);
DO_TYPEDEF(0x0389D530, MeshCombiner_u0A71u0A6Bu0A68u0A65u0A69u0A6Fu0A71u0A67u0A6Au0A6Fu0A69);
DO_TYPEDEF(0x038BCBC0, List_1_MeshCombineStudio_MeshCombiner_);
DO_TYPEDEF(0x0389D238, MeshCombineJobManager_u0A71u0A6Cu0A68u0A74u0A6Cu0A6Fu0A72u0A72u0A6Du0A68u0A6B__Enum);
DO_TYPEDEF(0x0389D1A0, MeshCombineJobManager_u0A6Eu0A73u0A65u0A66u0A71u0A65u0A74u0A73u0A74u0A66u0A68__Enum);
DO_TYPEDEF(0x0389D070, MeshCombineJobManager_JobSettings);
DO_TYPEDEF(0x0389D400, MeshCombiner_LODGroupSettings);
DO_TYPEDEF(0x0389D498, MeshCombiner_LODSettings);
DO_TYPEDEF(0x03873B48, MeshCombiner_LODSettings__Array);
DO_TYPEDEF(0x03873AB8, MeshCombiner_LODGroupSettings__Array);
DO_TYPEDEF(0x038B4498, u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A65u0A6Bu0A6Au0A74u0A6Au0A73u0A6Bu0A69u0A6Eu0A72u0A74);
DO_TYPEDEF(0x038C4810, List_1_u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A65u0A6Cu0A71u0A6Eu0A73u0A74u0A6Au0A6Cu0A6Fu0A70u0A70_);
DO_TYPEDEF(0x038B4528, u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A65u0A6Cu0A71u0A6Eu0A73u0A74u0A6Au0A6Cu0A6Fu0A70u0A70);
DO_TYPEDEF(0x038B4648, u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A69u0A6Bu0A6Bu0A65u0A66u0A6Au0A6Fu0A69u0A73u0A70u0A6F);
DO_TYPEDEF(0x038B45B8, u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A66u0A71u0A6Eu0A6Bu0A69u0A6Bu0A6Eu0A67u0A6Fu0A74u0A6B);
DO_TYPEDEF(0x038AC218, FastList_1_CachedGameObject_);
DO_TYPEDEF(0x0387E330, CachedGameObject);
DO_TYPEDEF(0x038A43A8, Dictionary_2_MeshCombineStudio_CombineCondition_MeshCombineStudio_MeshObjectsHolder_);
DO_TYPEDEF(0x038812A0, CombineCondition);
DO_TYPEDEF(0x038AE8E8, MeshObjectsHolder);
DO_TYPEDEF(0x038AC338, FastList_1_MeshObject_);
DO_TYPEDEF(0x038AE858, MeshObject);
DO_TYPEDEF(0x03880198, u0A67u0A66u0A66u0A6Au0A72u0A72u0A71u0A66u0A73u0A6Cu0A6F);
DO_TYPEDEF(0x038B30E8, u0A67u0A66u0A66u0A6Au0A72u0A72u0A71u0A66u0A73u0A6Cu0A6F_u0A6Bu0A74u0A6Au0A6Fu0A6Au0A6Cu0A6Bu0A69u0A67u0A68u0A65);
DO_TYPEDEF(0x03875168, u0A67u0A66u0A66u0A6Au0A72u0A72u0A71u0A66u0A73u0A6Cu0A6F_u0A6Bu0A74u0A6Au0A6Fu0A6Au0A6Cu0A6Bu0A69u0A67u0A68u0A65__Array);
DO_TYPEDEF(0x038AC3C8, FastList_1_UnityEngine_MeshRenderer_);
DO_TYPEDEF(0x03875200, u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A66u0A71u0A6Eu0A6Bu0A69u0A6Bu0A6Eu0A67u0A6Fu0A74u0A6B__Array);
DO_TYPEDEF(0x03875290, u0A72u0A6Bu0A69u0A6Du0A67u0A6Cu0A6Fu0A70u0A72u0A71u0A6D_u0A69u0A6Bu0A6Bu0A65u0A66u0A6Au0A6Fu0A69u0A73u0A70u0A6F__Array);
DO_TYPEDEF(0x03873BD8, MeshCombiner_LodParentHolder__Array);
DO_TYPEDEF(0x038B9A40, List_1_MeshCombineStudio_CachedGameObject_);
DO_TYPEDEF(0x038B9AD0, List_1_MeshCombineStudio_CachedLodGameObject_);
DO_TYPEDEF(0x0387E3C8, CachedLodGameObject);
DO_TYPEDEF(0x038BC6B0, List_1_UnityEngine_LODGroup_);
DO_TYPEDEF(0x038B1228, HashSet_1_UnityEngine_LODGroup_);
DO_TYPEDEF(0x038B1348, HashSet_1_UnityEngine_Mesh_);
DO_TYPEDEF(0x03897E50, FoundCombineConditions);
DO_TYPEDEF(0x038B0C98, HashSet_1_MeshCombineStudio_CombineCondition_);
DO_TYPEDEF(0x038B1978, HashSet_1_MeshCombineStudio_MeshCombineJobManager_u0A74u0A74u0A72u0A74u0A72u0A73u0A67u0A74u0A6Fu0A6Au0A6B_);
DO_TYPEDEF(0x0389D368, MeshCombineJobManager_u0A74u0A74u0A72u0A74u0A72u0A73u0A67u0A74u0A6Fu0A6Au0A6B);
DO_TYPEDEF(0x038A4288, Dictionary_2_UnityEngine_Collider_MeshCombineStudio_CachedGameObject_);
DO_TYPEDEF(0x038A6428, Dictionary_2_UnityEngine_LODGroup_MeshCombineStudio_CachedGameObject_);
DO_TYPEDEF(0x038AC4E8, FastList_1_u0A66u0A66u0A6Fu0A70u0A6Eu0A71u0A73u0A73u0A73u0A65u0A6C_);
DO_TYPEDEF(0x038B1738, HashSet_1_UnityEngine_Transform_);
DO_TYPEDEF(0x0388D4F8, CombinedLODManager_LOD);
DO_TYPEDEF(0x03871E98, CombinedLODManager_LOD__Array);
DO_TYPEDEF(0x0388D590, CombinedLODManager_u0A66u0A73u0A74u0A6Eu0A6Au0A6Au0A67u0A66u0A66u0A6Eu0A74);
DO_TYPEDEF(0x0388D628, CombinedLODManager_u0A74u0A70u0A68u0A72u0A67u0A69u0A6Du0A6Cu0A72u0A74u0A67);
DO_TYPEDEF(0x038BCCE0, List_1_UnityEngine_MeshRenderer_);
DO_TYPEDEF(0x03868FB0, List_1_UnityEngine_MeshRenderer___Array);
DO_TYPEDEF(0x038AE500, MeshCombineJobManager);
DO_TYPEDEF(0x038AC578, FastList_1_MeshCombineJobManager_u0A67u0A66u0A6Au0A6Cu0A67u0A68u0A67u0A66u0A6Eu0A65u0A6C_);
DO_TYPEDEF(0x0389D108, MeshCombineJobManager_u0A67u0A66u0A6Au0A6Cu0A67u0A68u0A67u0A66u0A6Eu0A65u0A6C);
DO_TYPEDEF(0x038AC458, FastList_1_UnityEngine_Vector3_);
DO_TYPEDEF(0x038A64B8, Dictionary_2_UnityEngine_Mesh_u0A67u0A66u0A66u0A6Au0A72u0A72u0A71u0A66u0A73u0A6Cu0A6F_);
DO_TYPEDEF(0x038C6938, Queue_1_MeshCombineStudio_MeshCombineJobManager_u0A74u0A74u0A72u0A74u0A72u0A73u0A67u0A74u0A6Fu0A6Au0A6B_);
DO_TYPEDEF(0x0389D2D0, MeshCombineJobManager_u0A73u0A6Du0A6Eu0A73u0A6Au0A68u0A6Eu0A6Bu0A70u0A6Au0A74);
DO_TYPEDEF(0x038C68A8, Queue_1_MeshCombineStudio_MeshCombineJobManager_u0A67u0A66u0A6Au0A6Cu0A67u0A68u0A67u0A66u0A6Eu0A65u0A6C_);
DO_TYPEDEF(0x03873A28, MeshCombineJobManager_u0A73u0A6Du0A6Eu0A73u0A6Au0A68u0A6Eu0A6Bu0A70u0A6Au0A74__Array);
DO_TYPEDEF(0x0386A120, Bounds__Array);
DO_TYPEDEF(0x038698E0, SwapCombineKey);
DO_TYPEDEF(0x0387F6F8, u0A66u0A66u0A6Au0A67u0A6Du0A65u0A68u0A68u0A74u0A6Bu0A74);
DO_TYPEDEF(0x03882330, Console_1);
DO_TYPEDEF(0x038C26E0, List_1_MeshCombineStudio_Console_u0A6Du0A6Au0A6Au0A67u0A69u0A71u0A69u0A6Au0A69u0A6Au0A71_);
DO_TYPEDEF(0x0388D7F0, Console_u0A6Du0A6Au0A6Au0A67u0A69u0A71u0A69u0A6Au0A69u0A6Au0A71);
DO_TYPEDEF(0x038AC518, MCS_FPSCounter);
DO_TYPEDEF(0x038AC2A8, FastList_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x0389B650, LIV_WaitForUnityEndOfFrame_d_68);
DO_TYPEDEF(0x0386A150, TEXTURE_ID__Enum);
DO_TYPEDEF(0x0386A030, TEXTURE_DEVICE__Enum);
DO_TYPEDEF(0x0386A1E0, TEXTURE_TYPE__Enum);
DO_TYPEDEF(0x0386A0C0, TEXTURE_FORMAT__Enum);
DO_TYPEDEF(0x03869FA0, TEXTURE_COLOR_SPACE__Enum);
DO_TYPEDEF(0x038C3910, SDKTexture);
DO_TYPEDEF(0x03892980, ES3UserType_CalibrationData);
DO_TYPEDEF(0x03892A18, ES3UserType_CalibrationDataArray);
DO_TYPEDEF(0x03892B48, ES3UserType_Target);
DO_TYPEDEF(0x03892BE0, ES3UserType_TargetArray);
DO_TYPEDEF(0x038882A8, u0A71u0A6Bu0A71u0A71u0A65u0A65u0A6Du0A6Fu0A6Eu0A65u0A6C);
DO_TYPEDEF(0x038B1D68, ICollection_1_u0A68u0A6Bu0A68u0A67u0A68u0A73u0A68u0A74u0A6Bu0A65u0A6F_);
DO_TYPEDEF(0x03884070, u0A6Cu0A6Du0A72u0A71u0A74u0A67u0A65u0A66u0A67u0A70u0A70);
DO_TYPEDEF(0x038B7018, KeyValuePair_2_System_UInt16_System_Int32_);
DO_TYPEDEF(0x038682C8, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Collections_Generic_List_1__4);
DO_TYPEDEF(0x038B80F8, List_1_System_ArraySegment_1_);
DO_TYPEDEF(0x038B5998, IList_1_u0A68u0A6Bu0A68u0A67u0A68u0A73u0A68u0A74u0A6Bu0A65u0A6F_);
DO_TYPEDEF(0x038C1F00, List_1_u0A70u0A68u0A74u0A6Eu0A69u0A66u0A73u0A6Bu0A65u0A67u0A69_);
DO_TYPEDEF(0x038683E8, u0A68u0A74u0A6Eu0A67u0A71u0A71u0A72u0A6Du0A73u0A74u0A6A_System_Collections_Generic_List_1__6);
DO_TYPEDEF(0x038C1960, List_1_u0A6Bu0A73u0A6Bu0A6Fu0A71u0A67u0A73u0A71u0A67u0A72u0A69_);
DO_TYPEDEF(0x038687D0, u0A6Fu0A74u0A68u0A72u0A6Bu0A6Du0A73u0A71u0A65u0A65u0A66_TPeer_u0A6Du0A72u0A68u0A67u0A68u0A65u0A66u0A6Bu0A74u0A73u0A6F_System_Int32_);
DO_TYPEDEF(0x038B8570, List_1_KeyValuePair_2_System_String_u0A71u0A6Fu0A68u0A72u0A6Eu0A70u0A68u0A6Au0A6Au0A67u0A67_);
DO_TYPEDEF(0x03885F30, u0A6Eu0A74u0A66u0A69u0A66u0A70u0A68u0A69u0A6Cu0A6Eu0A72);
DO_TYPEDEF(0x0389FE50, Action_1_u0A74u0A70u0A6Eu0A65u0A74u0A72u0A6Au0A6Fu0A6Cu0A69u0A65_);
DO_TYPEDEF(0x038A10B8, Action_2_u0A74u0A70u0A6Eu0A65u0A74u0A72u0A6Au0A6Fu0A6Cu0A69u0A65_u0A74u0A70u0A6Eu0A65u0A74u0A72u0A6Au0A6Fu0A6Cu0A69u0A65_);
DO_TYPEDEF(0x038C2410, List_1_u0A74u0A70u0A6Eu0A65u0A74u0A72u0A6Au0A6Fu0A6Cu0A69u0A65_);
DO_TYPEDEF(0x038C7478, ReadOnlyCollection_1_u0A74u0A70u0A6Eu0A65u0A74u0A72u0A6Au0A6Fu0A6Cu0A69u0A65_);
DO_TYPEDEF(0x038A5758, Dictionary_2_System_Int32_Photon_Realtime_RaiseEventOptions_);
DO_TYPEDEF(0x0389FB58, Action_1_u0A68u0A72u0A69u0A68u0A73u0A73u0A74u0A72u0A6Du0A67u0A74_);
DO_TYPEDEF(0x03888FB0, u0A72u0A69u0A6Fu0A6Du0A6Du0A6Du0A70u0A71u0A6Bu0A69u0A6D);
DO_TYPEDEF(0x03868C50, u0A73u0A72u0A65u0A6Du0A72u0A74u0A6Au0A65u0A6Bu0A70u0A73_Dissonance_Integrations_PhotonUnityNetworking2_PhotonCommsNetwork_u0A70u0A73u0A6Du0A70u0A6Du0A68u0A6Eu0A6Bu0A6Du0A65u0A69_);
DO_TYPEDEF(0x038AD5B8, Func_1_Dissonance_Integrations_PhotonUnityNetworking2_PhotonCommsNetwork_u0A70u0A73u0A6Du0A70u0A6Du0A68u0A6Eu0A6Bu0A6Du0A65u0A69_);
DO_TYPEDEF(0x038A3C28, PhotonCommsNetwork_u0A70u0A73u0A6Du0A70u0A6Du0A68u0A6Eu0A6Bu0A6Du0A65u0A69);
DO_TYPEDEF(0x038B82A0, List_1_KeyValuePair_2_System_Byte_Dissonance_Integrations_PhotonUnityNetworking2_PhotonCommsNetwork_u0A6Cu0A6Du0A6Bu0A74u0A65u0A68u0A6Du0A6Fu0A71u0A67u0A6F_);
DO_TYPEDEF(0x038A3B98, PhotonCommsNetwork_u0A6Cu0A6Du0A6Bu0A74u0A65u0A68u0A6Du0A6Fu0A71u0A67u0A6F);
DO_TYPEDEF(0x038B0B80, HashSet_1_System_Byte_);
DO_TYPEDEF(0x038C3A90, List_1_Dissonance_Integrations_PhotonUnityNetworking2_PhotonCommsNetwork_u0A69u0A68u0A6Au0A69u0A72u0A6Du0A74u0A6Fu0A6Eu0A74u0A71_);
DO_TYPEDEF(0x038A3B08, PhotonCommsNetwork_u0A69u0A68u0A6Au0A69u0A72u0A6Du0A74u0A6Fu0A6Eu0A74u0A71);
DO_TYPEDEF(0x038A3A78, PhotonCommsNetwork_c);
DO_TYPEDEF(0x038A3E68, PhotonPlayer_u0A73u0A72u0A74u0A73u0A74u0A72u0A6Fu0A70u0A71u0A67u0A68);
DO_TYPEDEF(0x03886060, u0A6Fu0A65u0A70u0A66u0A6Fu0A6Au0A68u0A72u0A6Cu0A71u0A65);
DO_TYPEDEF(0x038BB030, List_1_Bhaptics_Tact_Unity_HapticDevice_);
DO_TYPEDEF(0x0389B620, HapticDevice);
DO_TYPEDEF(0x0386E9D0, PositionType__Enum__Array);
DO_TYPEDEF(0x038A6930, Dictionary_2_Bhaptics_Tact_PositionType_System_Int32_);
DO_TYPEDEF(0x038BDAF0, List_1_Bhaptics_Tact_PathPoint_);
DO_TYPEDEF(0x03887218, u0A70u0A69u0A6Au0A65u0A68u0A6Fu0A73u0A6Eu0A6Cu0A66u0A6A);
DO_TYPEDEF(0x038B8CC0, List_1_Bhaptics_Tact_Unity_AndroidWidget_PairedDeviceUI_);
DO_TYPEDEF(0x038B8D50, List_1_Bhaptics_Tact_Unity_AndroidWidget_ScannedDeviceUI_);
DO_TYPEDEF(0x0388B6D8, AndroidWidget_UI_u0A74u0A68u0A6Fu0A6Bu0A66u0A6Bu0A71u0A71u0A6Au0A70u0A68);
DO_TYPEDEF(0x038753C0, u0A73u0A6Cu0A6Fu0A73u0A6Bu0A72u0A6Eu0A65u0A6Fu0A6Bu0A6C_u0A6Au0A6Bu0A6Du0A6Fu0A65u0A73u0A69u0A69u0A6Eu0A6Fu0A6E__Array);
DO_TYPEDEF(0x03886938, u0A6Fu0A6Fu0A6Fu0A6Bu0A6Fu0A74u0A68u0A73u0A66u0A71u0A6C);
DO_TYPEDEF(0x0388A808, u0A74u0A68u0A73u0A6Au0A71u0A68u0A67u0A70u0A6Bu0A74u0A74);
DO_TYPEDEF(0x03886E90, u0A70u0A65u0A69u0A6Du0A6Au0A69u0A74u0A68u0A67u0A74u0A6C);
DO_TYPEDEF(0x03881828, u0A68u0A6Fu0A66u0A6Cu0A68u0A65u0A68u0A65u0A6Du0A68u0A74);
DO_TYPEDEF(0x038A7EF8, Dictionary_2_System_String_u0A6Du0A65u0A65u0A66u0A6Au0A68u0A69u0A66u0A66u0A65u0A71_);
DO_TYPEDEF(0x03884360, u0A6Du0A65u0A65u0A66u0A6Au0A68u0A69u0A66u0A66u0A65u0A71);
DO_TYPEDEF(0x038893D8, u0A72u0A70u0A74u0A73u0A65u0A71u0A71u0A65u0A71u0A69u0A6E);
DO_TYPEDEF(0x03883CE0, u0A6Cu0A6Bu0A6Eu0A67u0A74u0A6Cu0A70u0A67u0A72u0A67u0A6F);
DO_TYPEDEF(0x0388AE90, u0A74u0A6Eu0A6Cu0A6Du0A6Du0A6Fu0A6Eu0A65u0A73u0A6Eu0A6E);
DO_TYPEDEF(0x03881790, u0A68u0A6Fu0A65u0A6Du0A74u0A6Eu0A72u0A6Bu0A68u0A6Du0A6A);
DO_TYPEDEF(0x03881108, u0A68u0A66u0A6Eu0A66u0A73u0A69u0A66u0A6Cu0A65u0A6Bu0A72);
DO_TYPEDEF(0x03883BB0, u0A6Cu0A66u0A65u0A72u0A70u0A67u0A6Cu0A69u0A6Eu0A72u0A6D);
DO_TYPEDEF(0x0387F2D0, u0A65u0A6Fu0A6Fu0A69u0A73u0A68u0A6Eu0A69u0A68u0A72u0A69);
DO_TYPEDEF(0x038A6EC8, Dictionary_2_System_String_u0A6Du0A70u0A6Au0A72u0A6Bu0A73u0A74u0A72u0A6Bu0A67u0A69_);
DO_TYPEDEF(0x03884950, u0A6Du0A70u0A6Au0A72u0A6Bu0A73u0A74u0A72u0A6Bu0A67u0A69);
DO_TYPEDEF(0x03886FB8, u0A70u0A67u0A67u0A70u0A66u0A6Eu0A6Au0A72u0A71u0A72u0A6D);
DO_TYPEDEF(0x03880EA8, u0A67u0A73u0A71u0A6Fu0A66u0A66u0A67u0A67u0A69u0A68u0A74);
DO_TYPEDEF(0x03896D48, HapticSource_u0A6Au0A6Cu0A69u0A66u0A71u0A6Bu0A71u0A6Au0A6Fu0A69u0A68);
DO_TYPEDEF(0x03896CB0, HapticSource_u0A69u0A73u0A74u0A70u0A71u0A6Au0A6Du0A71u0A6Bu0A66u0A74);
DO_TYPEDEF(0x038C7BF8, SimpleHapticClip);
DO_TYPEDEF(0x038BAD90, Point);
DO_TYPEDEF(0x0386E948, Point__Array);
DO_TYPEDEF(0x038B2218, NavMeshLink);
DO_TYPEDEF(0x038BD430, List_1_UnityEngine_AI_NavMeshLink_);
DO_TYPEDEF(0x038B22A8, NavMeshModifier);
DO_TYPEDEF(0x038BD4C0, List_1_UnityEngine_AI_NavMeshModifier_);
DO_TYPEDEF(0x038B2338, NavMeshModifierVolume);
DO_TYPEDEF(0x038BD550, List_1_UnityEngine_AI_NavMeshModifierVolume_);
DO_TYPEDEF(0x038B2458, NavMeshSurface);
DO_TYPEDEF(0x038BD5E0, List_1_UnityEngine_AI_NavMeshSurface_);
DO_TYPEDEF(0x0389E958, NavMeshSurface_c);
DO_TYPEDEF(0x038C5860, Predicate_1_UnityEngine_AI_NavMeshModifierVolume_);
DO_TYPEDEF(0x038C57D0, Predicate_1_UnityEngine_AI_NavMeshModifier_);
DO_TYPEDEF(0x038C5740, Predicate_1_UnityEngine_AI_NavMeshBuildSource_);
DO_TYPEDEF(0x0387A210, AzureFogScattering);
DO_TYPEDEF(0x038858B0, u0A6Eu0A73u0A68u0A68u0A67u0A66u0A71u0A6Fu0A6Bu0A72u0A6A_9);
DO_TYPEDEF(0x038B6B98, KeyValuePair_2_System_Int64_System_Object_);
DO_TYPEDEF(0x038B6CB8, KeyValuePair_2_System_Object_System_Int64_);
DO_TYPEDEF(0x038B70A8, KeyValuePair_2_System_UInt16_System_Object_);
DO_TYPEDEF(0x038AE9D8, Func_2_UnityEngine_LOD_Boolean_);
DO_TYPEDEF(0x038AFC58, Func_2_UnityEngine_InputSystem_Layouts_InputControlLayout_ControlItem_Boolean_);
DO_TYPEDEF(0x038B6DD8, KeyValuePair_2_System_Object_UnityEngine_InputSystem_Utilities_JsonParser_JsonValue_);
DO_TYPEDEF(0x0389E300, _f_AnonymousType0_1_System_String_);
DO_TYPEDEF(0x038C64B8, Queue_1_UnityEngine_Transform_);
DO_TYPEDEF(0x038ADD88, Func_2_System_Threading_CancellationToken_System_Threading_Tasks_Task_1_);
DO_TYPEDEF(0x038A1318, AsyncLocalValueChangedArgs_1_System_Object_);
DO_TYPEDEF(0x038A7408, Int32Enum__Enum);
DO_TYPEDEF(0x0389F010, Action_1_UnityEngineInternal_Input_NativeInputUpdateType_);
DO_TYPEDEF(0x0389F140, Action_1_UnityEngine_Object_);
DO_TYPEDEF(0x0389F438, Action_1_Single_);
DO_TYPEDEF(0x0389F8F8, Action_1_u0A66u0A71u0A71u0A69u0A72u0A6Eu0A67u0A6Au0A6Fu0A65u0A66_);
DO_TYPEDEF(0x0389FA28, Action_1_u0A67u0A67u0A69u0A74u0A73u0A68u0A65u0A6Eu0A6Du0A6Du0A73_);
DO_TYPEDEF(0x0389FBF0, Action_1_u0A6Cu0A65u0A71u0A70u0A73u0A6Bu0A72u0A6Eu0A6Eu0A74u0A6C_);
DO_TYPEDEF(0x0389FD20, Action_1_u0A71u0A6Fu0A69u0A6Du0A6Bu0A6Cu0A6Du0A68u0A72u0A74u0A69_);
DO_TYPEDEF(0x038A0278, Action_2_Char_String_);
DO_TYPEDEF(0x038A0B60, Action_2_String_Int32_);
DO_TYPEDEF(0x038A0BF8, Action_2_String_Single_);
DO_TYPEDEF(0x038A1020, Action_2_u0A74u0A70u0A6Eu0A65u0A74u0A72u0A6Au0A6Fu0A6Cu0A69u0A65_String_);
DO_TYPEDEF(0x038B6A78, KeyValuePair_2_System_DateTime_System_Object_);
DO_TYPEDEF(0x038A21E8, Comparison_1_System_Collections_Generic_KeyValuePair_2__3);
DO_TYPEDEF(0x038B6C28, KeyValuePair_2_System_Object_System_ArraySegment_1_);
DO_TYPEDEF(0x0386AC60, DateTime__Array);
DO_TYPEDEF(0x038A2788, Comparison_1_String_);
DO_TYPEDEF(0x038705D8, TimeSpan__Array);
DO_TYPEDEF(0x03887AF8, u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69);
DO_TYPEDEF(0x0388C500, BeforeRenderHelper_OrderBlock);
DO_TYPEDEF(0x038AED08, TrackedPoseDriverDataDescription_PoseData);
DO_TYPEDEF(0x038C4300, List_1_UnityEngine_SpatialTracking_TrackedPoseDriver_TrackedPose_);
DO_TYPEDEF(0x03875588, InputAnalytics_StartupEventData_DeviceInfo__Array);
DO_TYPEDEF(0x038A1F18, CachedInvokableCall_1_System_Boolean_);
DO_TYPEDEF(0x03867308, UnityAction_1_System_Boolean_);
DO_TYPEDEF(0x038A1FA8, CachedInvokableCall_1_System_Int32_);
DO_TYPEDEF(0x038A2038, CachedInvokableCall_1_System_Single_);
DO_TYPEDEF(0x038A20C8, CachedInvokableCall_1_System_String_);
DO_TYPEDEF(0x038679C8, UnityAction_1_System_String_);
DO_TYPEDEF(0x038931D0, EmptyStruct);
DO_TYPEDEF(0x038A2428, Comparison_1_System_Net_IPAddress_);
DO_TYPEDEF(0x038A24B8, Comparison_1_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_);
DO_TYPEDEF(0x0386AF28, DictionaryEntry__Array);
DO_TYPEDEF(0x038A2C08, ConcurrentDictionary_2_System_Runtime_Serialization_MemberHolder_System_Reflection_MemberInfo_);
DO_TYPEDEF(0x038AEA68, Func_2_System_Runtime_Serialization_MemberHolder_System_Reflection_MemberInfo_);
DO_TYPEDEF(0x038A2F68, Converter_2_Byte_Int32_);
DO_TYPEDEF(0x038AB038, Dictionary_2_TKey_TValue_Enumerator_ES3Ref_ES3Ref_);
DO_TYPEDEF(0x038A4558, Dictionary_2_ES3Internal_ES3SpecialByte_System_Type_);
DO_TYPEDEF(0x038A4708, Dictionary_2_UnityEngine_Font_HashSet_1_UnityEngine_UI_Text_);
DO_TYPEDEF(0x038B16A8, HashSet_1_UnityEngine_UI_Text_);
DO_TYPEDEF(0x038A48B8, Dictionary_2_System_Guid_Mono_Security_Interface_MonoTlsProvider_);
DO_TYPEDEF(0x038A4948, Dictionary_2_System_Guid_System_String_);
DO_TYPEDEF(0x038A4CA8, Dictionary_2_UnityEngine_XR_Interaction_Toolkit_IXRInteractable_System_Single_);
DO_TYPEDEF(0x038A5008, Dictionary_2_System_Int32_IDictionary_2_System_Int32_System_Int32_);
DO_TYPEDEF(0x038B2938, IDictionary_2_System_Int32_System_Int32_);
DO_TYPEDEF(0x038A5128, Dictionary_2_System_Int32_System_Int32__1);
DO_TYPEDEF(0x038A5488, Dictionary_2_System_Int32_System_Int64_);
DO_TYPEDEF(0x038A55A8, Dictionary_2_System_Int32_System_Object_);
DO_TYPEDEF(0x038A57E8, Dictionary_2_System_Int32_UnityEngine_RenderTextureFormat_);
DO_TYPEDEF(0x038A5BC8, Dictionary_2_System_Int32_UnityEngine_Texture2D_);
DO_TYPEDEF(0x038A5D78, Dictionary_2_System_Int32_UnityEngine_GUILayoutUtility_LayoutCache_);
DO_TYPEDEF(0x038A5FB8, Dictionary_2_System_Int64_TMPro_TMP_MaterialManager_FallbackMaterial_);
DO_TYPEDEF(0x038A6668, Dictionary_2_System_Reflection_MethodInfo_System_Reflection_ParameterInfo_);
DO_TYPEDEF(0x038B5368, IEnumerator_1_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038B26F8, ICollection_1_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038A6A50, Dictionary_2_UnityEngine_PrimitiveType_UnityEngine_Mesh_);
DO_TYPEDEF(0x038AB158, Dictionary_2_TKey_TValue_Enumerator_System_String_List_1_System_UInt16_);
DO_TYPEDEF(0x038A6D18, Dictionary_2_System_String_List_1_UnityEngine_XR_OpenXR_Input_OpenXRInput_SerializedBinding_);
DO_TYPEDEF(0x038C3580, List_1_UnityEngine_XR_OpenXR_Input_OpenXRInput_SerializedBinding_);
DO_TYPEDEF(0x038A6E38, Dictionary_2_System_String_System_Tuple_2_);
DO_TYPEDEF(0x03866858, Tuple_2_Guid_String_);
DO_TYPEDEF(0x038A7228, Dictionary_2_System_String_System_ComponentModel_EventDescriptor_);
DO_TYPEDEF(0x038A72B8, Dictionary_2_System_String_Bhaptics_Tact_FeedbackMode_);
DO_TYPEDEF(0x038A7610, Dictionary_2_System_String_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038A7730, Dictionary_2_System_String_Bhaptics_Tact_PathMovingPattern_);
DO_TYPEDEF(0x038A7848, Dictionary_2_System_String_Bhaptics_Tact_PlaybackType_);
DO_TYPEDEF(0x038A78D8, Dictionary_2_System_String_System_ComponentModel_PropertyDescriptor_);
DO_TYPEDEF(0x038A7F88, Dictionary_2_System_String_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038A8018, Dictionary_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038B2788, ICollection_1_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038A80A8, Dictionary_2_System_String_u0A72u0A68u0A73u0A73u0A66u0A6Bu0A6Bu0A6Fu0A74u0A74u0A6E_);
DO_TYPEDEF(0x038A8498, Dictionary_2_System_String_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_ActionType_);
DO_TYPEDEF(0x038A8768, Dictionary_2_DG_Tweening_Tween_DG_Tweening_Core_TweenLink_);
DO_TYPEDEF(0x038A87F8, Dictionary_2_System_Type_IDictionary_2_System_Type_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038B2D28, IDictionary_2_System_Type_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038A8888, Dictionary_2_System_Type_IDictionary_2_System_Type_u0A74u0A67u0A6Bu0A6Du0A74u0A69u0A72u0A69u0A71u0A73u0A74_);
DO_TYPEDEF(0x038B2F68, IDictionary_2_System_Type_u0A74u0A67u0A6Bu0A6Du0A74u0A69u0A72u0A69u0A71u0A73u0A74_);
DO_TYPEDEF(0x038A8918, Dictionary_2_System_Type_IList_1_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038A89A8, Dictionary_2_System_Type_List_1_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038A8A38, Dictionary_2_System_Type_System_Type_);
DO_TYPEDEF(0x038A8AC8, Dictionary_2_System_Type_System_AttributeUsageAttribute_);
DO_TYPEDEF(0x038A8BE8, Dictionary_2_System_Type_ES3Internal_ES3SpecialByte_);
DO_TYPEDEF(0x038A8C78, Dictionary_2_System_Type_ES3Types_ES3Type_);
DO_TYPEDEF(0x038A8D08, Dictionary_2_System_Type_System_Collections_ICollection_);
DO_TYPEDEF(0x038A8E28, Dictionary_2_System_Type_DG_Tweening_Plugins_Core_ITweenPlugin_);
DO_TYPEDEF(0x038A8EB8, Dictionary_2_System_Type_System_Reflection_MethodInfo_);
DO_TYPEDEF(0x038A9060, Dictionary_2_System_Type_UnityEngine_PrimitiveType_);
DO_TYPEDEF(0x038A9208, Dictionary_2_System_Type_u0A65u0A6Fu0A68u0A6Bu0A6Fu0A68u0A6Cu0A67u0A71u0A68u0A71_);
DO_TYPEDEF(0x038A9298, Dictionary_2_System_Type_u0A69u0A70u0A71u0A6Eu0A6Fu0A70u0A66u0A67u0A6Bu0A69u0A6B_);
DO_TYPEDEF(0x038A9328, Dictionary_2_System_Type_u0A6Du0A6Au0A6Bu0A66u0A69u0A6Du0A69u0A6Eu0A67u0A6Bu0A70_);
DO_TYPEDEF(0x038A93B8, Dictionary_2_System_Type_u0A74u0A67u0A6Bu0A6Du0A74u0A69u0A72u0A69u0A71u0A73u0A74_);
DO_TYPEDEF(0x038A9448, Dictionary_2_System_Type_System_MonoCustomAttrs_AttributeInfo_);
DO_TYPEDEF(0x038AB308, Dictionary_2_TKey_TValue_Enumerator_System_UInt16_u0A6Au0A73u0A73u0A68u0A6Fu0A72u0A6Au0A72u0A6Bu0A74u0A6B_);
DO_TYPEDEF(0x038AB398, Dictionary_2_TKey_TValue_Enumerator_System_UInt16_u0A74u0A68u0A73u0A6Fu0A71u0A6Eu0A69u0A6Fu0A68u0A71u0A74_);
DO_TYPEDEF(0x038A9958, Dictionary_2_UnityEngine_Vector2Int_Obi_HalfEdgeMesh_HalfEdge_);
DO_TYPEDEF(0x038A99E8, Dictionary_2_UnityEngine_Vector3_System_Int32_);
DO_TYPEDEF(0x038A9A78, Dictionary_2_UnityEngine_Vector3_UnityEngine_Vector3_);
DO_TYPEDEF(0x038A9B08, Dictionary_2_UnityEngine_Vector3_Obi_HalfEdgeMesh_Vertex_);
DO_TYPEDEF(0x038AB428, Dictionary_2_TKey_TValue_Enumerator_System_Xml_XmlQualifiedName_System_Xml_Schema_SchemaAttDef_);
DO_TYPEDEF(0x038AB4B8, Dictionary_2_TKey_TValue_Enumerator_System_Xml_XmlQualifiedName_System_Xml_Schema_SchemaElementDecl_);
DO_TYPEDEF(0x038A9DD0, Dictionary_2_u0A70u0A71u0A6Au0A68u0A71u0A70u0A74u0A6Cu0A6Cu0A66u0A74_u0A73u0A72u0A65u0A6Du0A72u0A74u0A6Au0A65u0A6Bu0A70u0A73_);
DO_TYPEDEF(0x038A9EE8, Dictionary_2_UltimateGameTools_MeshSimplifier_MeshUniqueVertices_u0A68u0A6Cu0A70u0A72u0A68u0A6Eu0A6Cu0A70u0A6Eu0A6Cu0A73_UltimateGameTools_MeshSimplifier_MeshUniqueVertices_u0A67u0A74u0A66u0A6Du0A6Du0A73u0A74u0A73u0A6Eu0A68u0A72_);
DO_TYPEDEF(0x038A9F78, Dictionary_2_Photon_Pun_PhotonNetwork_RaiseEventBatch_Photon_Pun_PhotonNetwork_SerializeViewBatch_);
DO_TYPEDEF(0x038BA400, PlayableBinding);
DO_TYPEDEF(0x0386E838, PlayableBinding__Array);
DO_TYPEDEF(0x038C4C90, NullTypeInfo_1_EmptyStruct_);
DO_TYPEDEF(0x038B83C0, List_1_KeyValuePair_2_System_Single_System_Int32_);
DO_TYPEDEF(0x038B9800, List_1_UnityEngine_Bounds_);
DO_TYPEDEF(0x038AAB38, List_1_T_Enumerator_UnityEngine_GameObject_);
DO_TYPEDEF(0x038AABC8, List_1_T_Enumerator_VisualDesignCafe_Nature_Rendering_IInstance_);
DO_TYPEDEF(0x038BB6F0, List_1_System_Net_IPAddress_);
DO_TYPEDEF(0x038BBE40, List_1_UnityEngine_InputSystem_InputBinding_);
DO_TYPEDEF(0x038AACE8, ReadOnlyArray_1_TValue_Enumerator_UnityEngine_InputSystem_InputControl_);
DO_TYPEDEF(0x038AAD78, ReadOnlyArray_1_TValue_Enumerator_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038BC1A0, List_1_UnityEngine_IntegratedSubsystem_);
DO_TYPEDEF(0x038BC230, List_1_UnityEngine_IntegratedSubsystemDescriptor_);
DO_TYPEDEF(0x038BC3E0, List_1_UnityEngine_InputSystem_Utilities_InternedString_);
DO_TYPEDEF(0x038AAE00, List_1_T_Enumerator_UnityEngine_Rendering_PostProcessing_PostProcessEffectSettings_);
DO_TYPEDEF(0x038BEBD0, List_1_UnityEngine_Rigidbody_);
DO_TYPEDEF(0x038AAE90, List_1_T_Enumerator_System_String_);
DO_TYPEDEF(0x038AAF20, List_1_T_Enumerator_System_UInt16_);
DO_TYPEDEF(0x038C0E20, List_1_UnityEngine_XR_XRDisplaySubsystem_);
DO_TYPEDEF(0x038C13C0, List_1_u0A66u0A6Bu0A67u0A74u0A69u0A68u0A6Cu0A6Au0A72u0A6Cu0A67_);
DO_TYPEDEF(0x038C14E0, List_1_u0A67u0A67u0A65u0A74u0A66u0A6Fu0A70u0A66u0A6Bu0A6Cu0A6C_);
DO_TYPEDEF(0x038AAFB0, List_1_T_Enumerator_u0A68u0A68u0A69u0A73u0A6Cu0A70u0A6Du0A6Au0A69u0A71u0A6C_);
DO_TYPEDEF(0x038C2020, List_1_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038C2650, List_1_UnityEngine_BeforeRenderHelper_OrderBlock_);
DO_TYPEDEF(0x038C3340, List_1_System_Net_MonoChunkStream_Chunk_);
DO_TYPEDEF(0x038C80D0, Stack_1_System_Xml_Schema_SequenceNode_SequenceConstructPosContext_);
DO_TYPEDEF(0x038C4390, List_1_UnityEngine_SpatialTracking_TrackedPoseDriverDataDescription_PoseData_);
DO_TYPEDEF(0x038C48A0, List_1_UnityEngine_InputSystem_InputAnalytics_StartupEventData_DeviceInfo_);
DO_TYPEDEF(0x038C6E48, ReadOnlyArray_1_System_Object_);
DO_TYPEDEF(0x038AB278, Dictionary_2_TKey_TValue_KeyCollection_TKey_TValue_Enumerator_System_String_System_String_);
DO_TYPEDEF(0x038ABEC8, FastAction_1_System_Boolean_);
DO_TYPEDEF(0x038ABF50, FastAction_1_UnityEngine_Object_);
DO_TYPEDEF(0x038ABFE0, FastAction_2_System_Boolean_UnityEngine_Material_);
DO_TYPEDEF(0x038AC070, FastAction_2_System_Boolean_UnityEngine_Object_);
DO_TYPEDEF(0x038AC100, FastAction_2_System_Object_Compute_DT_EventArgs_);
DO_TYPEDEF(0x038AC188, FastAction_3_UnityEngine_GameObject_UnityEngine_Material_UnityEngine_Material_);
DO_TYPEDEF(0x038C2770, List_1_System_IO_Directory_SearchData_);
DO_TYPEDEF(0x038AC608, FileSystemEnumerableIterator_1_System_String_);
DO_TYPEDEF(0x038AC728, Func_1_System_Threading_Tasks_Task_1_);
DO_TYPEDEF(0x038AC7B8, Func_1_System_Threading_Tasks_Task_1__1);
DO_TYPEDEF(0x038ACCC8, Func_1_Int32_);
DO_TYPEDEF(0x038AD260, Func_1_System_IO_Stream_);
DO_TYPEDEF(0x038AD6D8, Func_2_f_AnonymousType0_2_Boolean_);
DO_TYPEDEF(0x038ADA30, Func_2_System_Collections_Generic_KeyValuePair_2_Boolean__8);
DO_TYPEDEF(0x038ADE18, Func_2_System_Threading_CancellationToken_System_Threading_Tasks_Task_1__2);
DO_TYPEDEF(0x038ADF38, Func_2_Evidence_Single_);
DO_TYPEDEF(0x038AE0E8, Func_2_System_Reflection_FieldInfo_UnityEngine_Rendering_PostProcessing_ParameterOverride_);
DO_TYPEDEF(0x038AE298, Func_2_IAsyncResult_System_Net_IPAddress_);
DO_TYPEDEF(0x038AE328, Func_2_IAsyncResult_System_Net_WebResponse_);
DO_TYPEDEF(0x038AEC18, Func_2_UnityEngineInternal_Input_NativeInputUpdateType_Boolean_);
DO_TYPEDEF(0x038B0048, Func_2_UnityEngine_Networking_PlayerConnection_PlayerEditorConnectionEvents_MessageTypeSubscribers_Boolean_);
DO_TYPEDEF(0x038B01F8, Func_3_AsyncCallback_Object_IAsyncResult_);
DO_TYPEDEF(0x038B05E8, Func_3_String_Int32_Int32_);
DO_TYPEDEF(0x038B0678, Func_3_String_Single_Single_);
DO_TYPEDEF(0x038B09D8, Func_4_String_AsyncCallback_Object_IAsyncResult_);
DO_TYPEDEF(0x038C5350, Predicate_1_UnityEngine_Collider_);
DO_TYPEDEF(0x038B14F8, HashSet_1_Photon_Pun_PhotonView_);
DO_TYPEDEF(0x038B7408, LinkedList_1_System_WeakReference_);
DO_TYPEDEF(0x038B2FF8, IEnumerable_1_KeyValuePair_2_System_Byte_System_Object_);
DO_TYPEDEF(0x038B84E0, List_1_KeyValuePair_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038B8600, List_1_List_1_UnityEngine_InputSystem_InputAction_);
DO_TYPEDEF(0x038B8690, List_1_List_1_UnityEngine_InputSystem_InputBinding_);
DO_TYPEDEF(0x038B8C30, List_1_System_AggregateException_);
DO_TYPEDEF(0x038B8DE0, List_1_System_Reflection_Assembly_);
DO_TYPEDEF(0x038C52C0, Predicate_1_UnityEngine_Events_BaseInvokableCall_);
DO_TYPEDEF(0x038BA100, List_1_Mono_Globalization_Unicode_Contraction_);
DO_TYPEDEF(0x038BA340, List_1_Door_);
DO_TYPEDEF(0x038BA610, List_1_System_Enum_);
DO_TYPEDEF(0x038BA850, List_1_System_Exception_);
DO_TYPEDEF(0x038C5470, Predicate_1_UnityEngine_GameObject_);
DO_TYPEDEF(0x038A1A38, IMaterialModifier);
DO_TYPEDEF(0x038B3628, IEnumerable_1_UnityEngine_InputSystem_InputAction_);
DO_TYPEDEF(0x038BBDB0, List_1_UnityEngine_InputSystem_InputActionMap_);
DO_TYPEDEF(0x038C5500, Predicate_1_UnityEngine_InputSystem_InputBinding_);
DO_TYPEDEF(0x038BBED0, List_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038BC2C0, List_1_RootMotion_FinalIK_InteractionTarget_);
DO_TYPEDEF(0x038C5620, Predicate_1_TMPro_KerningPair_);
DO_TYPEDEF(0x038C56B0, Predicate_1_UnityEngine_LOD_);
DO_TYPEDEF(0x038BC740, List_1_Mono_Globalization_Unicode_Level2Map_);
DO_TYPEDEF(0x038BCE00, List_1_System_Reflection_MethodBase_);
DO_TYPEDEF(0x038BD040, List_1_System_Reflection_Module_);
DO_TYPEDEF(0x038B3A18, IEnumerable_1_UnityEngine_InputSystem_Utilities_NamedValue_);
DO_TYPEDEF(0x038BDD30, List_1_Photon_Pun_PhotonView_);
DO_TYPEDEF(0x038C5980, Predicate_1_UnityEngine_Rendering_PostProcessing_PostProcessBundle_);
DO_TYPEDEF(0x038BE090, List_1_System_Diagnostics_Process_);
DO_TYPEDEF(0x038BE120, List_1_System_Diagnostics_Tracing_PropertyAnalysis_);
DO_TYPEDEF(0x038C5AA0, Predicate_1_Photon_Realtime_Region_);
DO_TYPEDEF(0x038BEC60, List_1_UnityEngine_Rigidbody2D_);
DO_TYPEDEF(0x038BED80, List_1_System_RuntimeType_);
DO_TYPEDEF(0x038BEEA0, List_1_System_Runtime_Serialization_SerializationFieldInfo_);
DO_TYPEDEF(0x038BF0E0, List_1_System_Diagnostics_StackFrame_);
DO_TYPEDEF(0x038C5B30, Predicate_1_String_);
DO_TYPEDEF(0x038BF3B0, List_1_UnityEngine_Subsystem_);
DO_TYPEDEF(0x038BF440, List_1_UnityEngine_SubsystemDescriptor_);
DO_TYPEDEF(0x038BF4D0, List_1_UnityEngine_SubsystemsImplementation_SubsystemDescriptorWithProvider_);
DO_TYPEDEF(0x038BF560, List_1_UnityEngine_SubsystemsImplementation_SubsystemWithProvider_);
DO_TYPEDEF(0x038BFA70, List_1_UnityEngine_Terrain_);
DO_TYPEDEF(0x038C5CE0, Predicate_1_UnityEngine_Transform_);
DO_TYPEDEF(0x038C1690, List_1_u0A68u0A66u0A6Eu0A66u0A73u0A69u0A66u0A6Cu0A65u0A6Bu0A72_);
DO_TYPEDEF(0x038C17B0, List_1_u0A68u0A6Fu0A66u0A6Cu0A68u0A65u0A68u0A65u0A6Du0A68u0A74_);
DO_TYPEDEF(0x038C19F0, List_1_u0A6Cu0A66u0A65u0A72u0A70u0A67u0A6Cu0A69u0A6Eu0A72u0A6D_);
DO_TYPEDEF(0x038C1A80, List_1_u0A6Cu0A6Bu0A6Eu0A67u0A74u0A6Cu0A70u0A67u0A72u0A67u0A6F_);
DO_TYPEDEF(0x038C1B10, List_1_u0A6Du0A70u0A6Au0A72u0A6Bu0A73u0A74u0A72u0A6Bu0A67u0A69_);
DO_TYPEDEF(0x038C73E8, ReadOnlyCollection_1_u0A6Eu0A68u0A6Du0A69u0A74u0A68u0A6Fu0A6Bu0A70u0A69u0A6D_);
DO_TYPEDEF(0x038C1E70, List_1_u0A70u0A65u0A69u0A6Du0A6Au0A69u0A74u0A68u0A67u0A74u0A6C_);
DO_TYPEDEF(0x038B3E98, IEnumerable_1_u0A70u0A72u0A6Au0A69u0A6Fu0A72u0A67u0A74u0A68u0A70u0A69_);
DO_TYPEDEF(0x038C20B0, List_1_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038C2380, List_1_u0A74u0A6Eu0A6Cu0A6Du0A6Du0A6Fu0A6Eu0A65u0A73u0A6Eu0A6E_);
DO_TYPEDEF(0x038C5F20, Predicate_1_Photon_Pun_PhotonAnimatorView_SynchronizedLayer_);
DO_TYPEDEF(0x038C5FB0, Predicate_1_Photon_Pun_PhotonAnimatorView_SynchronizedParameter_);
DO_TYPEDEF(0x038C6040, Predicate_1_UnityEngine_Rendering_PostProcessing_PostProcessLayer_SerializedBundleRef_);
DO_TYPEDEF(0x038C3DF0, List_1_UnityEngine_UI_StencilMaterial_MatEntry_);
DO_TYPEDEF(0x038C4030, List_1_TMPro_TMP_MaterialManager_FallbackMaterial_);
DO_TYPEDEF(0x038C40C0, List_1_TMPro_TMP_MaterialManager_MaskingMaterial_);
DO_TYPEDEF(0x038C60D0, Predicate_1_TMPro_TMP_MaterialManager_MaskingMaterial_);
DO_TYPEDEF(0x038C5080, ObjectPool_1_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x038671E8, UnityAction_1_System_Collections_Generic_List_1_);
DO_TYPEDEF(0x038C5590, Predicate_1_UnityEngine_InputSystem_InputControlScheme_);
DO_TYPEDEF(0x038C5E90, Predicate_1_UnityEngine_InputSystem_LowLevel_InputEventTrace_DeviceInfo_);
DO_TYPEDEF(0x038C66F8, Queue_1_Mono_Net_CFNetwork_GetProxyData_);
DO_TYPEDEF(0x038AAC58, ReadOnlyArray_1_TValue_Enumerator_UnityEngine_InputSystem_InputAction_);
DO_TYPEDEF(0x038B4678, IEnumerator_1_System_Reflection_CustomAttributeNamedArgument_);
DO_TYPEDEF(0x038C6FF8, ReadOnlyCollection_1_System_Reflection_CustomAttributeTypedArgument_);
DO_TYPEDEF(0x0386AB40, CustomAttributeTypedArgument__Array);
DO_TYPEDEF(0x038C7628, SavedStructState_1_UnityEngine_InputSystem_InputActionState_GlobalState_);
DO_TYPEDEF(0x038C76B8, SavedStructState_1_UnityEngine_InputSystem_Users_InputUser_GlobalState_);
DO_TYPEDEF(0x038C7748, SavedStructState_1_UnityEngine_InputSystem_EnhancedTouch_Touch_GlobalState_);
DO_TYPEDEF(0x038C7C58, Stack_1_System_Xml_Schema_InteriorNode_);
DO_TYPEDEF(0x038C7CE8, Stack_1_Bhaptics_Tact_JSONNode_);
DO_TYPEDEF(0x038C7E98, Stack_1_UnityEngine_Transform_);
DO_TYPEDEF(0x038C7F28, Stack_1_DG_Tweening_Tween_);
DO_TYPEDEF(0x038C8040, Stack_1_System_Xml_DtdParser_ParseElementOnlyContent_LocalFrame_);
DO_TYPEDEF(0x03865F58, StructWrapper_1_System_Object_);
DO_TYPEDEF(0x038668E8, Tuple_2_System_IO_Stream_System_IO_Stream_ReadWriteTask_);
DO_TYPEDEF(0x03866978, Tuple_2_System_IO_TextWriter_Char_);
DO_TYPEDEF(0x03866A08, Tuple_2_System_IO_TextWriter_String_);
DO_TYPEDEF(0x03866A98, Tuple_3_System_Threading_Tasks_Task_System_Threading_Tasks_Task_System_Threading_Tasks_TaskContinuation_);
DO_TYPEDEF(0x03866BB8, Tuple_4_System_IO_TextReader_Char_Int32_Int32_);
DO_TYPEDEF(0x03866C48, Tuple_4_System_IO_TextWriter_Char_Int32_Int32_);
DO_TYPEDEF(0x03867278, UnityAction_1_UnityEngine_XR_Interaction_Toolkit_ActivateEventArgs_);
DO_TYPEDEF(0x038674B8, UnityAction_1_UnityEngine_XR_Interaction_Toolkit_DeactivateEventArgs_);
DO_TYPEDEF(0x03867548, UnityAction_1_UnityEngine_XR_Interaction_Toolkit_HoverEnterEventArgs_);
DO_TYPEDEF(0x038675D8, UnityAction_1_UnityEngine_XR_Interaction_Toolkit_HoverExitEventArgs_);
DO_TYPEDEF(0x03867818, UnityAction_1_UnityEngine_XR_Interaction_Toolkit_SelectEnterEventArgs_);
DO_TYPEDEF(0x038678A8, UnityAction_1_UnityEngine_XR_Interaction_Toolkit_SelectExitEventArgs_);
DO_TYPEDEF(0x03867A58, UnityAction_1_Obi_ObiParticlePicker_u0A67u0A65u0A6Eu0A69u0A73u0A65u0A6Bu0A66u0A6Eu0A69u0A6A_);
DO_TYPEDEF(0x03867C08, UnityAction_3_Player_LevelRoom_LevelRoom_);
DO_TYPEDEF(0x03867C98, UnityAction_4_UnityEngine_InputSystem_Samples_RebindUI_RebindActionUI_System_String_System_String_System_String_);
DO_TYPEDEF(0x038AB1E8, Dictionary_2_TKey_TValue_ValueCollection_TKey_TValue_Enumerator_System_String_UnityEngine_GUIStyle_);
DO_TYPEDEF(0x03886358, u0A6Fu0A67u0A71u0A70u0A6Bu0A67u0A73u0A74u0A66u0A71u0A6E);
DO_TYPEDEF(0x038855B8, u0A6Eu0A70u0A65u0A71u0A68u0A6Fu0A6Cu0A69u0A71u0A6Cu0A6C);
DO_TYPEDEF(0x03868238, u0A68u0A69u0A6Au0A6Bu0A6Eu0A6Bu0A6Fu0A6Eu0A68u0A6Fu0A70_u0A71u0A6Eu0A6Cu0A6Eu0A73u0A72u0A6Au0A66u0A6Au0A67u0A6E_u0A67u0A6Du0A6Au0A6Bu0A68u0A69u0A66u0A65u0A66u0A71u0A72_);
DO_TYPEDEF(0x038B45E8, IEnumerator_1_System_Reflection_CustomAttributeData_);
DO_TYPEDEF(0x0386A990, ContactPoint2D__Array);
DO_TYPEDEF(0x0386D5E0, InternalCodePageDataItem__Array);
DO_TYPEDEF(0x0386D670, InternalEncodingDataItem__Array);
DO_TYPEDEF(0x038737E8, InputHelpers_ButtonInfo__Array);
DO_TYPEDEF(0x03874458, SendMouseEvents_HitInfo__Array);
DO_TYPEDEF(0x03874620, Socket_WSABUF__Array);
DO_TYPEDEF(0x038A1220, ILayoutController);
DO_TYPEDEF(0x038A4858, IXRCustomReticleProvider);
DO_TYPEDEF(0x0388A510, u0A74u0A65u0A68u0A6Eu0A69u0A72u0A74u0A69u0A72u0A70u0A6B);
DO_TYPEDEF(0x0386E6A0, ParticleSystemSubEmitterType__Enum__Array);
DO_TYPEDEF(0x0386E618, ParticleSystemSubEmitterProperties__Enum__Array);
DO_TYPEDEF(0x038B41F8, IEnumerable_1_UnityEngine_Networking_PlayerConnection_PlayerEditorConnectionEvents_MessageTypeSubscribers_);
DO_TYPEDEF(0x038B3B38, IEnumerable_1_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_);
DO_TYPEDEF(0x038A2D58, IPunInstantiateMagicCallback);
DO_TYPEDEF(0x03898CC0, InputActionMap_BindingOverrideListJson);
DO_TYPEDEF(0x03899DF8, InputDeviceDescription_DeviceDescriptionJson);
DO_TYPEDEF(0x038B6448, IReadOnlyList_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x03871358, XmlAtomicValue__Array);
DO_TYPEDEF(0x03865FE8, TMP_ListPool_1_UnityEngine_Canvas_);
DO_TYPEDEF(0x03866078, TMP_ListPool_1_UnityEngine_UI_IMaterialModifier_);
DO_TYPEDEF(0x03866108, TMP_ListPool_1_UnityEngine_UI_Mask_);
DO_TYPEDEF(0x03866498, SoapServices);
DO_TYPEDEF(0x03866AC8, SortingHelpers);
DO_TYPEDEF(0x038670F8, SpriteAtlasManager);
DO_TYPEDEF(0x03867218, SpriteShapeRenderer);
DO_TYPEDEF(0x038677B8, StackTraceUtility);
DO_TYPEDEF(0x03867A88, Statics);
DO_TYPEDEF(0x03868088, u0A67u0A6Du0A65u0A74u0A6Bu0A6Du0A6Bu0A67u0A6Bu0A6Du0A6F_System_String_);
DO_TYPEDEF(0x03868388, StencilMaterial);
DO_TYPEDEF(0x03868BF0, StringBuilderCache);
DO_TYPEDEF(0x03868DA0, StringExtensions_1);
DO_TYPEDEF(0x03868E90, KeyValuePair_2_System_Byte_System_Text_Encoding___Array);
DO_TYPEDEF(0x03868F50, StringPluginExtensions);
DO_TYPEDEF(0x03869550, Attribute__Array__Array);
DO_TYPEDEF(0x038696A0, SubsystemDescriptorStore);
DO_TYPEDEF(0x03869730, SubsystemManager);
DO_TYPEDEF(0x03872048, DateTimeParse_DS__Enum__Array);
DO_TYPEDEF(0x03869790, DateTimeParse_DS__Enum__Array__Array);
DO_TYPEDEF(0x03872AF8, HebrewNumber_HS__Enum__Array);
DO_TYPEDEF(0x03869820, HebrewNumber_HS__Enum__Array__Array);
DO_TYPEDEF(0x038698B0, AndroidJavaClass__Array);
DO_TYPEDEF(0x03869AF0, AssetLoadingSubsystem__Enum__Array);
DO_TYPEDEF(0x03869CA0, AxisTouchButton__Array);
DO_TYPEDEF(0x03869D60, SystemCertificateValidator);
DO_TYPEDEF(0x03869DF0, SystemClock);
DO_TYPEDEF(0x0386A390, TMP_DefaultControls);
DO_TYPEDEF(0x0386A660, TMP_FontUtilities);
DO_TYPEDEF(0x0386A8A0, TMP_MaterialManager);
DO_TYPEDEF(0x0386A930, TMP_Math);
DO_TYPEDEF(0x0386ACE8, DateTimeConstantAttribute__Array);
DO_TYPEDEF(0x0386AE08, DecimalConstantAttribute__Array);
DO_TYPEDEF(0x0386AFE8, TMP_TextUtilities);
DO_TYPEDEF(0x0386B048, DisallowMultipleComponent__Array);
DO_TYPEDEF(0x0386B228, TMPro_EventManager);
DO_TYPEDEF(0x0386B818, ExecuteInEditMode__Array);
DO_TYPEDEF(0x0386BAE8, FileReadType__Enum__Array);
DO_TYPEDEF(0x0386C028, TerrainCallbacks);
DO_TYPEDEF(0x0386C470, HeaderInfo__Array);
DO_TYPEDEF(0x0386C5C0, TextInfoToLowerData);
DO_TYPEDEF(0x0386C650, TextInfoToUpperData);
DO_TYPEDEF(0x0386CB60, TextureFormatUtilities);
DO_TYPEDEF(0x038A4078, ITrackingHandler);
DO_TYPEDEF(0x0386CE90, ITrackingHandler__Array);
DO_TYPEDEF(0x0386CFE0, ThreadPoolGlobals);
DO_TYPEDEF(0x0386D3D0, TimeSpanFormat);
DO_TYPEDEF(0x0386D460, TimeSpanParse);
DO_TYPEDEF(0x0386D700, InternalPrimitiveTypeE__Enum__Array);
DO_TYPEDEF(0x0386D7C0, Timeout);
DO_TYPEDEF(0x0386D970, TimerThread);
DO_TYPEDEF(0x0386E360, ObsoleteAttribute__Array);
DO_TYPEDEF(0x0386E758, TraceInternal);
DO_TYPEDEF(0x0386EA58, Priority__Enum__Array);
DO_TYPEDEF(0x0386EB70, ProcessingState__Enum__Array);
DO_TYPEDEF(0x0386EE70, TrackedPoseDriverDataDescription);
DO_TYPEDEF(0x0386F020, TrackingServices);
DO_TYPEDEF(0x0386F080, ReflectPropertyDescriptor__Array);
DO_TYPEDEF(0x0386F470, RequireComponent__Array);
DO_TYPEDEF(0x0386F6E0, TurnExtensions);
DO_TYPEDEF(0x0386F920, TweenManager);
DO_TYPEDEF(0x03870188, TypeExtensions);
DO_TYPEDEF(0x03870308, TailoringInfo__Array);
DO_TYPEDEF(0x03870428, TermInfoStrings__Enum__Array);
DO_TYPEDEF(0x038708D8, TypeTranslator);
DO_TYPEDEF(0x03870AE8, TypeCode__Enum__Array);
DO_TYPEDEF(0x03870D58, UIElementsRuntimeUtilityNative);
DO_TYPEDEF(0x03870DB8, UnknownType__Array);
DO_TYPEDEF(0x038713E8, XmlIncludeAttribute__Array);
DO_TYPEDEF(0x03871508, XmlNode__Array);
DO_TYPEDEF(0x03871988, u0A67u0A6Cu0A65u0A6Du0A74u0A6Au0A6Au0A69u0A73u0A72u0A66__Enum__Array);
DO_TYPEDEF(0x038726A8, UnityTls);
DO_TYPEDEF(0x03872B88, HebrewNumber_HebrewValue__Array);
DO_TYPEDEF(0x038730C8, UriHelper);
DO_TYPEDEF(0x03873548, Utility);
DO_TYPEDEF(0x038735D8, Utils);
DO_TYPEDEF(0x03873938, ValidateNames);
DO_TYPEDEF(0x03873A58, ValidationHelper);
DO_TYPEDEF(0x0389EA58, IDeserializationCallback);
DO_TYPEDEF(0x03874520, Version_1);
DO_TYPEDEF(0x03874A48, UnityTls_unitytls_ciphersuite__Enum__Array);
DO_TYPEDEF(0x03875488, WWWTranscoder);
DO_TYPEDEF(0x03875A78, Warning);
DO_TYPEDEF(0x03876190, WebExceptionMapping);
DO_TYPEDEF(0x03876328, ActivationServices);
DO_TYPEDEF(0x038766E8, WebRequestUtils);
DO_TYPEDEF(0x03876E70, AnalyticsSessionInfo);
DO_TYPEDEF(0x03876EA0, Win32NetworkInterface);
DO_TYPEDEF(0x03877330, AndroidReflection);
DO_TYPEDEF(0x038773F8, X501_1);
DO_TYPEDEF(0x03877490, X501);
DO_TYPEDEF(0x03877C18, AppContextSwitches);
DO_TYPEDEF(0x03878040, Application);
DO_TYPEDEF(0x038786F8, X509Helper);
DO_TYPEDEF(0x03878EB0, XRDevice);
DO_TYPEDEF(0x038793D0, AsyncTaskCache);
DO_TYPEDEF(0x03879400, XRLoggingUtils);
DO_TYPEDEF(0x03879498, XRManagementAnalytics);
DO_TYPEDEF(0x038797F8, AttributeHelperEngine);
DO_TYPEDEF(0x03879A58, AudioSettings);
DO_TYPEDEF(0x03879C20, AuthenticationManager);
DO_TYPEDEF(0x038832A0, Converter);
DO_TYPEDEF(0x0387A3D8, AzureShaderUniforms);
DO_TYPEDEF(0x0387A798, XmlConvert);
DO_TYPEDEF(0x0387A830, XmlCustomFormatter);
DO_TYPEDEF(0x0387AB90, BeforeRenderHelper);
DO_TYPEDEF(0x0387B050, BigIntegerCalculator);
DO_TYPEDEF(0x0387B348, BinaryCompatibility);
DO_TYPEDEF(0x0387B3E0, BinaryCompatibility_1);
DO_TYPEDEF(0x0387B7A0, XmlNamespaceDeclarationsAttribute);
DO_TYPEDEF(0x0387BE90, BipedNaming);
DO_TYPEDEF(0x0387BFC0, BitConverter);
DO_TYPEDEF(0x0387C188, Bits);
DO_TYPEDEF(0x0387C9D8, BoundsUtils);
DO_TYPEDEF(0x03898DC0, GUITargetAttribute);
DO_TYPEDEF(0x0387DA58, CFNetwork);
DO_TYPEDEF(0x0387DFA8, CSteamAPIContext);
DO_TYPEDEF(0x0387E040, CSteamGameServerAPIContext);
DO_TYPEDEF(0x0389D468, IChannelReceiver);
DO_TYPEDEF(0x0389D630, IClientChannelSinkProvider);
DO_TYPEDEF(0x0387EFD8, u0A65u0A6Au0A6Eu0A70u0A72u0A69u0A71u0A67u0A74u0A67u0A6A);
DO_TYPEDEF(0x0389DC20, IComponentChangeService);
DO_TYPEDEF(0x0389E890, ICustomFormatter);
DO_TYPEDEF(0x0389EB88, IDesignerHost);
DO_TYPEDEF(0x0387F468, CertificateValidationHelper);
DO_TYPEDEF(0x0387F530, u0A65u0A74u0A6Au0A72u0A6Eu0A6Du0A6Eu0A6Eu0A67u0A68u0A69);
DO_TYPEDEF(0x0389ED50, IDictionaryService);
DO_TYPEDEF(0x0387F630, ChallengeResponse2);
DO_TYPEDEF(0x0387F890, ChannelServices);
DO_TYPEDEF(0x0389FC28, IExtenderListService);
DO_TYPEDEF(0x038A0640, IInputStateTypeInfo);
DO_TYPEDEF(0x0387FB88, CharUnicodeInfo);
DO_TYPEDEF(0x0387FD80, u0A66u0A72u0A6Fu0A6Au0A6Eu0A71u0A67u0A70u0A6Du0A6Fu0A69);
DO_TYPEDEF(0x038A1350, ILayoutIgnorer);
DO_TYPEDEF(0x038A1AC8, IMeshModifier);
DO_TYPEDEF(0x038A2068, INotifyPropertyChanged);
DO_TYPEDEF(0x038A3028, IReferenceService);
DO_TYPEDEF(0x038A3658, ISerializable);
DO_TYPEDEF(0x038A3778, IServerChannelSinkProvider);
DO_TYPEDEF(0x03880888, CodeIdentifier);
DO_TYPEDEF(0x038A4348, ITypeResolutionService);
DO_TYPEDEF(0x03880A50, CollectionExtensions);
DO_TYPEDEF(0x038813D0, CommonUsages_1);
DO_TYPEDEF(0x03881468, CommonUsages);
DO_TYPEDEF(0x03881500, CompModSwitches);
DO_TYPEDEF(0x038816F8, u0A68u0A6Cu0A67u0A6Du0A67u0A66u0A68u0A6Cu0A6Fu0A70u0A69);
DO_TYPEDEF(0x03881890, CompatibilitySwitches);
DO_TYPEDEF(0x03881CD8, u0A69u0A65u0A74u0A68u0A70u0A73u0A6Du0A68u0A73u0A6Au0A70);
DO_TYPEDEF(0x03881EA0, u0A69u0A67u0A6Eu0A74u0A6Eu0A71u0A74u0A66u0A6Eu0A73u0A6C);
DO_TYPEDEF(0x03882230, u0A69u0A6Au0A73u0A66u0A70u0A6Bu0A66u0A6Fu0A70u0A67u0A73);
DO_TYPEDEF(0x03882360, u0A69u0A6Cu0A66u0A73u0A6Cu0A67u0A66u0A6Fu0A71u0A6Bu0A6B);
DO_TYPEDEF(0x038823C8, Console);
DO_TYPEDEF(0x03882590, ConsoleDriver);
DO_TYPEDEF(0x03883208, Convert);
DO_TYPEDEF(0x03883368, u0A6Bu0A69u0A65u0A67u0A6Bu0A73u0A6Au0A74u0A67u0A74u0A74);
DO_TYPEDEF(0x038B0468, MonoCustomAttrs);
DO_TYPEDEF(0x038839C0, CrossPlatformInputManager);
DO_TYPEDEF(0x03884628, CustomRenderTextureManager);
DO_TYPEDEF(0x03884758, CustomTypes);
DO_TYPEDEF(0x038847F0, CustomTypesUnity);
DO_TYPEDEF(0x03884820, u0A6Du0A6Fu0A65u0A6Au0A74u0A74u0A70u0A73u0A6Fu0A69u0A74);
DO_TYPEDEF(0x038849E8, u0A6Du0A70u0A6Bu0A71u0A6Au0A6Du0A65u0A67u0A6Fu0A6Du0A6D);
DO_TYPEDEF(0x03884CE0, u0A6Du0A74u0A6Eu0A73u0A6Bu0A6Bu0A6Bu0A73u0A72u0A6Fu0A70);
DO_TYPEDEF(0x03884D40, DOTweenExternalCommand);
DO_TYPEDEF(0x03884DD8, DOTweenModuleUtils);
DO_TYPEDEF(0x03884E08, u0A6Eu0A66u0A6Du0A72u0A65u0A69u0A70u0A69u0A72u0A74u0A6A);
DO_TYPEDEF(0x03884F08, DOTweenUtils);
DO_TYPEDEF(0x038B9DD0, Physics2D);
DO_TYPEDEF(0x03885E98, u0A6Eu0A73u0A73u0A6Du0A71u0A71u0A6Eu0A67u0A6Du0A74u0A70);
DO_TYPEDEF(0x038862C0, u0A6Fu0A67u0A6Du0A6Du0A70u0A74u0A67u0A6Eu0A6Bu0A74u0A6E);
DO_TYPEDEF(0x03886B98, u0A6Fu0A72u0A6Au0A70u0A67u0A6Au0A6Cu0A68u0A73u0A6Bu0A73);
DO_TYPEDEF(0x038872B0, u0A70u0A6Au0A65u0A6Au0A6Eu0A6Du0A6Fu0A69u0A6Cu0A66u0A67);
DO_TYPEDEF(0x03887BF0, DateTimeFormat);
DO_TYPEDEF(0x03887C20, u0A70u0A74u0A6Fu0A69u0A67u0A6Fu0A70u0A65u0A6Fu0A66u0A69);
DO_TYPEDEF(0x03887EE8, DateTimeParse);
DO_TYPEDEF(0x03888278, Debug_2);
DO_TYPEDEF(0x03888470, u0A71u0A6Eu0A6Cu0A6Eu0A73u0A72u0A6Au0A66u0A6Au0A67u0A6E);
DO_TYPEDEF(0x038884D8, Debugger_1);
DO_TYPEDEF(0x03888570, Debugger);
DO_TYPEDEF(0x038886D0, u0A71u0A6Fu0A70u0A69u0A72u0A70u0A6Fu0A67u0A6Au0A6Eu0A69);
DO_TYPEDEF(0x03888DC0, DefaultCertificatePolicy);
DO_TYPEDEF(0x03888E58, DefaultControls);
DO_TYPEDEF(0x03889768, u0A72u0A74u0A65u0A6Du0A6Eu0A6Bu0A6Eu0A68u0A72u0A6Bu0A73);
DO_TYPEDEF(0x03889E88, u0A73u0A6Du0A73u0A6Au0A6Du0A68u0A6Du0A6Eu0A6Eu0A73u0A6D);
DO_TYPEDEF(0x0388A3B0, DictionaryHashHelpers);
DO_TYPEDEF(0x0388A640, u0A74u0A65u0A74u0A6Du0A66u0A6Eu0A6Eu0A6Bu0A74u0A6Cu0A6D);
DO_TYPEDEF(0x0388A938, u0A74u0A69u0A67u0A66u0A66u0A6Fu0A73u0A71u0A72u0A70u0A6D);
DO_TYPEDEF(0x0388B7D8, DtdValidator);
DO_TYPEDEF(0x0388BF80, ES3Binary);
DO_TYPEDEF(0x0388C308, ES3IO);
DO_TYPEDEF(0x0388CC78, ES3Reflection);
DO_TYPEDEF(0x0388D008, ES3TypeMgr);
DO_TYPEDEF(0x0388D920, Console_WindowsConsole);
DO_TYPEDEF(0x0388DFA0, CultureInfoConverter_CultureInfoMapper);
DO_TYPEDEF(0x038937C0, EncodingHelper);
DO_TYPEDEF(0x038938F0, EncodingTable);
DO_TYPEDEF(0x03893C80, EnhancedTouchSupport);
DO_TYPEDEF(0x03893F78, EnumParser);
DO_TYPEDEF(0x03894010, Environment);
DO_TYPEDEF(0x03894E80, FormatProvider_Number);
DO_TYPEDEF(0x03895738, ExecuteEvents);
DO_TYPEDEF(0x03895AC0, Ext);
DO_TYPEDEF(0x03895DB8, Extensions);
DO_TYPEDEF(0x03895F80, EyeTrackingUsages);
DO_TYPEDEF(0x03896460, HID_Simulation__Enum);
DO_TYPEDEF(0x03896858, File);
DO_TYPEDEF(0x03896988, FileBasedPrefs);
DO_TYPEDEF(0x038978F8, FontEngine);
DO_TYPEDEF(0x03897A28, FontUpdateTracker);
DO_TYPEDEF(0x03897DB8, FormatterServices);
DO_TYPEDEF(0x03898570, GC_1);
DO_TYPEDEF(0x038986A0, GUI);
DO_TYPEDEF(0x03898998, GUILayoutUtility);
DO_TYPEDEF(0x03898B90, InputActionAsset_WriteFileJson);
DO_TYPEDEF(0x03898BF8, GUIStateObjects);
DO_TYPEDEF(0x03898E58, GUIUtility);
DO_TYPEDEF(0x03899150, GameObjectUtils);
DO_TYPEDEF(0x038992B0, InputAnalytics_ShutdownEventData);
DO_TYPEDEF(0x03899348, InputAnalytics_StartupEventData);
DO_TYPEDEF(0x038993B0, GeometryUtils);
DO_TYPEDEF(0x03899E60, Graphics);
DO_TYPEDEF(0x0389A910, HIDSupport);
DO_TYPEDEF(0x0389B918, HashHelpers_1);
DO_TYPEDEF(0x0389B9B0, HashHelpers);
DO_TYPEDEF(0x0389BDD8, HebrewNumber);
DO_TYPEDEF(0x0389C460, HttpVersion);
DO_TYPEDEF(0x0389CE78, IBindingList);
DO_TYPEDEF(0x0389D040, ICanvasRaycastFilter);
DO_TYPEDEF(0x0389D338, IChannelDataStore);
DO_TYPEDEF(0x0389D7F8, ICloneable);
DO_TYPEDEF(0x0389D890, ICloseEx);
DO_TYPEDEF(0x0389DA58, IComparable);
DO_TYPEDEF(0x0389E0D8, IContributeClientContextSink);
DO_TYPEDEF(0x0389E170, IContributeDynamicSink);
DO_TYPEDEF(0x0389E208, IContributeEnvoySink);
DO_TYPEDEF(0x0389E2A0, IContributeObjectSink);
DO_TYPEDEF(0x0389E338, IContributeServerContextSink);
DO_TYPEDEF(0x0389E500, ICriticalNotifyCompletion);
DO_TYPEDEF(0x0389E7F8, ICustomDeviceReset);
DO_TYPEDEF(0x0389F3D8, IDtdParserAdapterV1);
DO_TYPEDEF(0x0389FA60, IEventMerger);
DO_TYPEDEF(0x0389FAF8, IEventPreProcessor);
DO_TYPEDEF(0x0389FDF0, IFormattable);
DO_TYPEDEF(0x0389FE88, IFormatter);
DO_TYPEDEF(0x0389FFB8, IHaptics);
DO_TYPEDEF(0x038A0510, IInputStateCallbackReceiver);
DO_TYPEDEF(0x038A06D8, IInputUpdateCallbackReceiver);
DO_TYPEDEF(0x038A0808, IInternalMessage);
DO_TYPEDEF(0x038A0BC8, OpenXRAnalytics_InitializeEvent);
DO_TYPEDEF(0x038A13E8, ILayoutSelfController);
DO_TYPEDEF(0x038A1918, IMaskable);
DO_TYPEDEF(0x038A1F48, INestedSite);
DO_TYPEDEF(0x038A1FD8, INotifyCompletion);
DO_TYPEDEF(0x038A22A8, IObjectReference);
DO_TYPEDEF(0x038A2338, IOnEventCallback);
DO_TYPEDEF(0x038A2578, IOrderedDictionary);
DO_TYPEDEF(0x038A2DE8, IPunObservable);
DO_TYPEDEF(0x038A2E78, IPunOwnershipCallbacks);
DO_TYPEDEF(0x038A30B8, IReflectableType);
DO_TYPEDEF(0x038A3388, ISafeSerializationData);
DO_TYPEDEF(0x038A3538, ISecurableChannel);
DO_TYPEDEF(0x038A39B8, IStructuralComparable);
DO_TYPEDEF(0x038A3A48, IStructuralEquatable);
DO_TYPEDEF(0x038A3E38, ITextInputReceiver);
DO_TYPEDEF(0x038A4198, ITupleInternal);
DO_TYPEDEF(0x038A56F8, InputActionRebindingExtensions);
DO_TYPEDEF(0x038A6220, InputDevices);
DO_TYPEDEF(0x038A6728, InputHelpers);
DO_TYPEDEF(0x038A67B8, InputInteraction);
DO_TYPEDEF(0x038A6960, InputRuntime);
DO_TYPEDEF(0x038A6B08, InputSystem);
DO_TYPEDEF(0x038A6C28, InputTracking);
DO_TYPEDEF(0x038A6CB8, InputUpdate);
DO_TYPEDEF(0x038A8678, InternalRemotingServices);
DO_TYPEDEF(0x038A9238, JobsUtility);
DO_TYPEDEF(0x038A9598, KeyBuilder);
DO_TYPEDEF(0x038AA248, EmptyArray_1_Byte_);
DO_TYPEDEF(0x038AA2D8, EmptyArray_1_Char_);
DO_TYPEDEF(0x038AA368, EmptyArray_1_System_Reflection_CustomAttributeNamedArgument_);
DO_TYPEDEF(0x038AA3F8, EmptyArray_1_System_Reflection_CustomAttributeTypedArgument_);
DO_TYPEDEF(0x038AA480, EmptyArray_1_Object_);
DO_TYPEDEF(0x038AA510, EmptyArray_1_System_Reflection_ParameterInfo_);
DO_TYPEDEF(0x038AA5A0, EmptyArray_1_System_Reflection_ParameterModifier_);
DO_TYPEDEF(0x038AA630, EmptyArray_1_Type_);
DO_TYPEDEF(0x038AA6B8, EnumHelper_1_System_Byte_);
DO_TYPEDEF(0x038AA748, EnumHelper_1_System_Int16_);
DO_TYPEDEF(0x038AA7D8, EnumHelper_1_System_Int32_);
DO_TYPEDEF(0x038AA868, EnumHelper_1_System_Int64_);
DO_TYPEDEF(0x038AA898, LifetimeServices);
DO_TYPEDEF(0x038AA8F8, EnumHelper_1_System_SByte_);
DO_TYPEDEF(0x038AA988, EnumHelper_1_System_UInt16_);
DO_TYPEDEF(0x038AAA18, EnumHelper_1_System_UInt32_);
DO_TYPEDEF(0x038AAA48, LightProbes);
DO_TYPEDEF(0x038AAAA8, EnumHelper_1_System_UInt64_);
DO_TYPEDEF(0x038AADA0, Lightmapping);
DO_TYPEDEF(0x038AB7B0, LocalAppContextSwitches);
DO_TYPEDEF(0x038AC0A0, Logging);
DO_TYPEDEF(0x038ACA28, MSCompatUnicodeTable);
DO_TYPEDEF(0x038ACAB8, MSCompatUnicodeTableUtil);
DO_TYPEDEF(0x038AD170, Marshal);
DO_TYPEDEF(0x038AD4F8, TextAsset_EncodingUtility);
DO_TYPEDEF(0x038AD9D0, Math);
DO_TYPEDEF(0x038ADA58, MathUtility);
DO_TYPEDEF(0x038ADAE8, Mathf);
DO_TYPEDEF(0x038ADB78, MathfInternal);
DO_TYPEDEF(0x038AE1A8, MemoryProfiler);
DO_TYPEDEF(0x038AEA98, MeshUtilities);
DO_TYPEDEF(0x038AF2A8, TypeDescriptor_IUnimplemented);
DO_TYPEDEF(0x038B01C8, UnsafeNclNativeMethods_HttpApi);
DO_TYPEDEF(0x038B0618, MonoIO);
DO_TYPEDEF(0x038B0B20, MonoTlsProviderFactory_1);
DO_TYPEDEF(0x038B10D8, VolumetricFog_u0A6Cu0A70u0A6Du0A74u0A66u0A66u0A68u0A6Eu0A6Fu0A66u0A73);
DO_TYPEDEF(0x038B1168, VolumetricFog_u0A73u0A6Cu0A66u0A74u0A70u0A6Cu0A6Bu0A71u0A6Eu0A72u0A65);
DO_TYPEDEF(0x038B11F8, VolumetricLight_u0A67u0A6Cu0A67u0A6Bu0A6Fu0A72u0A71u0A72u0A69u0A6Bu0A6A);
DO_TYPEDEF(0x038B1258, MulticastOption);
DO_TYPEDEF(0x038B1A98, ICollection_1_System_ArraySegment_1_);
DO_TYPEDEF(0x038B1B28, ICollection_1_KeyValuePair_2_System_String_System_String_);
DO_TYPEDEF(0x038B1BB8, ICollection_1_KeyValuePair_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038B1BE8, NativeInputSystem);
DO_TYPEDEF(0x038B1C48, ICollection_1_KeyValuePair_2_System_Type_IDictionary_2_System_Type_u0A74u0A67u0A6Bu0A6Du0A74u0A69u0A72u0A69u0A71u0A73u0A74_);
DO_TYPEDEF(0x038B1CD8, ICollection_1_KeyValuePair_2_System_Type_u0A6Du0A6Au0A6Bu0A66u0A69u0A6Du0A69u0A6Eu0A67u0A6Bu0A70_);
DO_TYPEDEF(0x038B1D08, NativeLeakDetection);
DO_TYPEDEF(0x038B1DF8, ICollection_1_System_Reflection_CustomAttributeNamedArgument_);
DO_TYPEDEF(0x038B1E88, ICollection_1_System_Reflection_CustomAttributeTypedArgument_);
DO_TYPEDEF(0x038B1F18, ICollection_1_System_Exception_);
DO_TYPEDEF(0x038B1F48, NatureShadersConfig);
DO_TYPEDEF(0x038B1FA8, ICollection_1_System_Runtime_ExceptionServices_ExceptionDispatchInfo_);
DO_TYPEDEF(0x038B1FD8, NavMesh);
DO_TYPEDEF(0x038B20C8, ICollection_1_UnityEngine_EventSystems_IEventSystemHandler_);
DO_TYPEDEF(0x038B21B8, XRSocketInteractor_ShaderPropertyLookup);
DO_TYPEDEF(0x038B2248, XRTintInteractableVisual_ShaderPropertyLookup);
DO_TYPEDEF(0x038B2398, ICollection_1_UnityEngine_Transform_);
DO_TYPEDEF(0x038B2428, ICollection_1_UnityEngine_UICharInfo_);
DO_TYPEDEF(0x038B24B8, ICollection_1_UnityEngine_UILineInfo_);
DO_TYPEDEF(0x038B24E8, NclUtilities);
DO_TYPEDEF(0x038B2548, ICollection_1_UnityEngine_UIVertex_);
DO_TYPEDEF(0x038B2578, NestedComponentUtilities);
DO_TYPEDEF(0x038B25D8, ICollection_1_u0A6Bu0A73u0A6Bu0A6Fu0A71u0A67u0A73u0A71u0A67u0A72u0A69_);
DO_TYPEDEF(0x038B2B18, Normalization);
DO_TYPEDEF(0x038B2BA8, NormalizationTableUtil);
DO_TYPEDEF(0x038B2F98, NtlmSettings);
DO_TYPEDEF(0x038B3118, IEnumerable_1_KeyValuePair_2_System_String_u0A71u0A6Bu0A69u0A6Cu0A6Bu0A66u0A70u0A71u0A71u0A69u0A74_);
DO_TYPEDEF(0x038B32C8, IEnumerable_1_System_Reflection_CustomAttributeData_);
DO_TYPEDEF(0x038B3358, IEnumerable_1_System_Reflection_CustomAttributeNamedArgument_);
DO_TYPEDEF(0x038B3418, OakleyGroups);
DO_TYPEDEF(0x038B37D8, IEnumerable_1_UnityEngine_InputSystem_InputControlScheme_);
DO_TYPEDEF(0x038B39E8, u0A6Du0A6Bu0A68u0A67u0A68u0A67u0A6Fu0A6Cu0A74u0A66u0A71_u0A71u0A74u0A6Bu0A69u0A73u0A6Eu0A6Bu0A74u0A70u0A68u0A6D__Enum);
DO_TYPEDEF(0x038B4EE8, IEnumerator_1_UnityEngine_XR_OpenXR_Features_OpenXRInteractionFeature_);
DO_TYPEDEF(0x038B5FF8, OidGroup__Enum_1);
DO_TYPEDEF(0x038B6088, OnDemandRendering);
DO_TYPEDEF(0x038B6358, OpenXRAnalytics);
DO_TYPEDEF(0x038B63B8, IReadOnlyCollection_1_UnityEngine_InputSystem_InputDevice_);
DO_TYPEDEF(0x038B6478, OpenXRInput);
DO_TYPEDEF(0x038B66B8, OpenXRRuntime);
DO_TYPEDEF(0x038B6EC8, UnsafeNclNativeMethods_HttpApi_HTTP_REQUEST_HEADER_ID);
DO_TYPEDEF(0x038B70D8, PKCS1_1);
DO_TYPEDEF(0x038B7168, PKCS1);
DO_TYPEDEF(0x038B7438, Parallel);
DO_TYPEDEF(0x038B79D8, ParameterizedStrings);
DO_TYPEDEF(0x038B7BE8, ListPool_1_UnityEngine_Canvas_);
DO_TYPEDEF(0x038B7C78, ListPool_1_UnityEngine_Color32_);
DO_TYPEDEF(0x038B7D08, ListPool_1_UnityEngine_Component_);
DO_TYPEDEF(0x038B7D98, ListPool_1_System_Int32_);
DO_TYPEDEF(0x038B7E28, ListPool_1_Mask_);
DO_TYPEDEF(0x038B7EB8, ListPool_1_RectMask2D_);
DO_TYPEDEF(0x038B7F48, ListPool_1_UnityEngine_UIVertex_);
DO_TYPEDEF(0x038B7FD8, ListPool_1_UnityEngine_Vector3_);
DO_TYPEDEF(0x038B8068, ListPool_1_UnityEngine_Vector4_);
DO_TYPEDEF(0x038B8900, Path);
DO_TYPEDEF(0x038B9050, PhotonCodes);
DO_TYPEDEF(0x038B9200, PhotonNetwork);
DO_TYPEDEF(0x038B9B90, PhraseRecognitionSystem);
DO_TYPEDEF(0x038BA130, Platform);
DO_TYPEDEF(0x038BA1C0, PlatformHelper);
DO_TYPEDEF(0x038BAC70, PluginsManager);
DO_TYPEDEF(0x038BB060, PointerId);
DO_TYPEDEF(0x038BB2A0, PoseDataSource);
DO_TYPEDEF(0x038BCE30, PunExtensions);
DO_TYPEDEF(0x038BD220, QualitySettings_1);
DO_TYPEDEF(0x038BED20, RaycasterManager);
DO_TYPEDEF(0x038BF470, RectTransformUtility);
DO_TYPEDEF(0x038BF860, ReflectionHelper_1);
DO_TYPEDEF(0x038BFBC0, ReflectionUtils);
DO_TYPEDEF(0x038BFC50, ReflectionUtils_1);
DO_TYPEDEF(0x038C0A60, Registry);
DO_TYPEDEF(0x038C0E50, RemoteSettings);
DO_TYPEDEF(0x038C0EE0, RemotingConfiguration);
DO_TYPEDEF(0x038C1090, RemotingServices);
DO_TYPEDEF(0x038C12D0, RenderPipelineManager);
DO_TYPEDEF(0x038C3130, RuntimeUtilities);
DO_TYPEDEF(0x038C3370, SDKBridge);
DO_TYPEDEF(0x038C3880, SDKShaders);
DO_TYPEDEF(0x038C4C30, SceneManager);
DO_TYPEDEF(0x038C5380, ScriptableRuntimeReflectionSystemSettings);
DO_TYPEDEF(0x038C5FE0, SendMouseEvents);
DO_TYPEDEF(0x038C68D8, SerializationEventsCache);
DO_TYPEDEF(0x038C72F8, ServicePointManager);
DO_TYPEDEF(0x038C7778, ShaderIDs);
DO_TYPEDEF(0x038C7928, ShaderUtilities);
|
CychUC/SmallBase
|
appdata/il2cpp-metadata-version.h
|
// Generated C++ file by Il2CppInspector - http://www.djkaty.com - https://github.com/djkaty
// Target Unity version: 2020.2.4 - 2020.3.99
#define __IL2CPP_METADATA_VERSION 271
|
CychUC/SmallBase
|
user/hooking/hooking.h
|
#pragma once
#include <common.h>
#include <detours/detours.h>
namespace Small {
struct Hooks {
static HRESULT HookPresent(IDXGISwapChain* this_, UINT sync_, UINT flags_);
static LRESULT HookWndProc(HWND hwnd_, UINT msg_, WPARAM wparam_, LPARAM lparam_);
};
class Hooking {
friend Hooks;
public:
explicit Hooking();
~Hooking();
void AddHook(PVOID* original_function, PVOID detour_function, std::string hook_name);
void ApplyHooks();
void RemoveHooks();
public:
ID3DPresent original_present_{};
WNDPROC original_wndproc_{};
private:
std::vector<std::tuple<std::string, PVOID*, PVOID>> hooks_;
};
inline Hooking* hooking{};
}
|
dguerizec/teleinfo
|
firmware/teleinfo.h
|
<reponame>dguerizec/teleinfo
#ifndef __TELEINFO_H__
#define __TELEINFO_H__
#include "application.h"
#define FRAME_START 0x02
#define FRAME_END 0x03
#define FRAME_MAX_LEN 1024
#define FRAME_READ_TIMEOUT 2000
class Teleinfo {
private:
Stream *stream;
bool verbose;
String *frame;
String *buffer;
String *output;
char *items[64];
int idx;
uint32_t tmout_us;
void parse_frame();
public:
Teleinfo(Stream &s, uint32_t timeout_us=2000000L, bool verbose=0);
~Teleinfo();
void read_frame();
void read_byte();
void loop();
const char *get_next();
};
#endif // __TELEINFO_H__
|
timpur/esphome-components
|
esphome-components/freqtiny/freqtiny.h
|
#pragma once
#include "esphome/components/i2c/i2c.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/core/component.h"
namespace esphome {
namespace freqtiny {
enum FreqTinyPin {
FREQTINY_PIN_5 = 0b00,
FREQTINY_PIN_3 = 0b01,
FREQTINY_PIN_4 = 0b10,
FREQTINY_PIN_1 = 0b11,
};
enum FreqTinyPulseWidthFilter {
FREQTINY_PULSE_WIDTH_FILTER_OFF = 0b000,
FREQTINY_PULSE_WIDTH_FILTER_50_US = 0b001,
FREQTINY_PULSE_WIDTH_FILTER_100_US = 0b010,
FREQTINY_PULSE_WIDTH_FILTER_150_US = 0b011,
FREQTINY_PULSE_WIDTH_FILTER_200_US = 0b100,
FREQTINY_PULSE_WIDTH_FILTER_250_US = 0b101,
FREQTINY_PULSE_WIDTH_FILTER_300_US = 0b110,
FREQTINY_PULSE_WIDTH_FILTER_350_US = 0b111,
};
class FreqTinyComponent : public PollingComponent, public i2c::I2CDevice {
public:
void setup() override;
void dump_config() override;
float get_setup_priority() const override;
void update() override;
void set_pin(FreqTinyPin pin) { pin_ = pin; }
void set_pin_pullup(bool pin_pullup) { pin_pullup_ = pin_pullup; }
void set_filter(FreqTinyPulseWidthFilter pulse_width_filter) { pulse_width_filter_ = pulse_width_filter; }
void set_frequency_sensor(sensor::Sensor *frequency_sensor) { frequency_sensor_ = frequency_sensor; }
void set_pwm_sensor(sensor::Sensor *pwm_sensor) { pwm_sensor_ = pwm_sensor; }
void set_max_frequency_sensor(sensor::Sensor *max_frequency_sensor) { max_frequency_sensor_ = max_frequency_sensor; }
void set_max_pwm_sensor(sensor::Sensor *max_pwm_sensor) { max_pwm_sensor_ = max_pwm_sensor; }
void set_min_frequency_sensor(sensor::Sensor *min_frequency_sensor) { min_frequency_sensor_ = min_frequency_sensor; }
void set_min_pwm_sensor(sensor::Sensor *min_pwm_sensor) { min_pwm_sensor_ = min_pwm_sensor; }
protected:
FreqTinyPin pin_{FREQTINY_PIN_3};
bool pin_pullup_;
FreqTinyPulseWidthFilter pulse_width_filter_{FREQTINY_PULSE_WIDTH_FILTER_100_US};
sensor::Sensor *frequency_sensor_;
sensor::Sensor *pwm_sensor_;
sensor::Sensor *max_frequency_sensor_;
sensor::Sensor *max_pwm_sensor_;
sensor::Sensor *min_frequency_sensor_;
sensor::Sensor *min_pwm_sensor_;
enum ErrorCode {
NONE = 0,
COMMUNICATION_FAILED,
ID_REGISTERS,
} error_code_;
private:
bool read_float(uint8_t address, float *data);
};
} // namespace freqtiny
} // namespace esphome
|
timpur/esphome-components
|
esphome-components/wind/wind.h
|
<reponame>timpur/esphome-components<filename>esphome-components/wind/wind.h<gh_stars>0
#pragma once
#include "esphome/core/component.h"
#include "esphome/components/sensor/sensor.h"
#include "esphome/components/text_sensor/text_sensor.h"
namespace esphome {
namespace wind {
class WindComponent : public Component {
public:
void setup() override;
void dump_config() override;
float get_setup_priority() const override;
void set_heading_sensor(sensor::Sensor *heading_sensor) { heading_sensor_ = heading_sensor; }
void set_heading_compass_sensor(text_sensor::TextSensor *heading_compass_sensor) {
heading_compass_sensor_ = heading_compass_sensor;
}
void set_speed_sensor(sensor::Sensor *speed_sensor) { speed_sensor_ = speed_sensor; }
void set_max_speed_sensor(sensor::Sensor *max_speed_sensor) { max_speed_sensor_ = max_speed_sensor; }
void set_dependent_sensors(sensor::Sensor *dep_heading_sensor, sensor::Sensor *dep_frequency_sensor,
sensor::Sensor *dep_max_frequency_sensor) {
dep_heading_sensor_ = dep_heading_sensor;
dep_frequency_sensor_ = dep_frequency_sensor;
dep_max_frequency_sensor_ = dep_max_frequency_sensor;
}
protected:
sensor::Sensor *heading_sensor_;
text_sensor::TextSensor *heading_compass_sensor_;
sensor::Sensor *speed_sensor_;
sensor::Sensor *max_speed_sensor_;
sensor::Sensor *dep_heading_sensor_;
sensor::Sensor *dep_frequency_sensor_;
sensor::Sensor *dep_max_frequency_sensor_;
enum ErrorCode {
NONE = 0,
DEPENDENCIES_ERROR,
} error_code_;
private:
void update_heading_sensor(float value);
void update_heading_compass_sensor(float value);
void update_speed_sensor(float value);
void update_max_speed_sensor(float value);
float heading_to_heading(float value);
std::string heading_to_heading_compass(float value);
float frequency_to_speed(float value);
};
} // namespace wind
} // namespace esphome
|
regnauld/lxd
|
shared/netutils/unixfd.h
|
<gh_stars>1000+
// +build linux
// +build cgo
#ifndef LXD_UNIXFD_H
#define LXD_UNIXFD_H
#include <linux/types.h>
#include <sys/socket.h>
#include <sys/types.h>
#define KERNEL_SCM_MAX_FD 253
/* Allow the caller to set expectations. */
#define UNIX_FDS_ACCEPT_EXACT ((__u32)(1 << 0)) /* default */
#define UNIX_FDS_ACCEPT_LESS ((__u32)(1 << 1))
#define UNIX_FDS_ACCEPT_MORE ((__u32)(1 << 2)) /* wipe any extra fds */
#define UNIX_FDS_ACCEPT_NONE ((__u32)(1 << 3))
#define UNIX_FDS_ACCEPT_MASK (UNIX_FDS_ACCEPT_EXACT | UNIX_FDS_ACCEPT_LESS | UNIX_FDS_ACCEPT_MORE | UNIX_FDS_ACCEPT_NONE)
/* Allow the callee to disappoint them. */
#define UNIX_FDS_RECEIVED_EXACT ((__u32)(1 << 16))
#define UNIX_FDS_RECEIVED_LESS ((__u32)(1 << 17))
#define UNIX_FDS_RECEIVED_MORE ((__u32)(1 << 18))
#define UNIX_FDS_RECEIVED_NONE ((__u32)(1 << 19))
struct unix_fds {
__u32 fd_count_max;
__u32 fd_count_ret;
__u32 flags;
__s32 fd[KERNEL_SCM_MAX_FD];
} __attribute__((aligned(8)));
extern int lxc_abstract_unix_send_fds(int fd, int *sendfds, int num_sendfds,
void *data, size_t size);
extern ssize_t lxc_abstract_unix_recv_fds_iov(int fd, struct unix_fds *ret_fds,
struct iovec *ret_iov,
size_t size_ret_iov);
extern ssize_t lxc_abstract_unix_recv_fds(int fd, struct unix_fds *ret_fds,
void *ret_data, size_t size_ret_data);
#endif // LXD_UNIXFD_H
|
regnauld/lxd
|
lxd/include/mount_utils.h
|
<reponame>regnauld/lxd
#ifndef __LXD_MOUNT_UTILS_H
#define __LXD_MOUNT_UTILS_H
#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
#include <linux/sched.h>
#include <sched.h>
#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <sys/syscall.h>
#include <sys/wait.h>
#include <unistd.h>
#include "compiler.h"
// open_tree() flags
#ifndef OPEN_TREE_CLONE
#define OPEN_TREE_CLONE 1
#endif
#ifndef OPEN_TREE_CLOEXEC
#define OPEN_TREE_CLOEXEC O_CLOEXEC
#endif
// mount attributes
#ifndef MOUNT_ATTR_IDMAP
#define MOUNT_ATTR_IDMAP 0x00100000
#endif
// move_mount() flags
#ifndef MOVE_MOUNT_F_SYMLINKS
#define MOVE_MOUNT_F_SYMLINKS 0x00000001 /* Follow symlinks on from path */
#endif
#ifndef MOVE_MOUNT_F_AUTOMOUNTS
#define MOVE_MOUNT_F_AUTOMOUNTS 0x00000002 /* Follow automounts on from path */
#endif
#ifndef MOVE_MOUNT_F_EMPTY_PATH
#define MOVE_MOUNT_F_EMPTY_PATH 0x00000004 /* Empty from path permitted */
#endif
#ifndef MOVE_MOUNT_T_SYMLINKS
#define MOVE_MOUNT_T_SYMLINKS 0x00000010 /* Follow symlinks on to path */
#endif
#ifndef MOVE_MOUNT_T_AUTOMOUNTS
#define MOVE_MOUNT_T_AUTOMOUNTS 0x00000020 /* Follow automounts on to path */
#endif
#ifndef MOVE_MOUNT_T_EMPTY_PATH
#define MOVE_MOUNT_T_EMPTY_PATH 0x00000040 /* Empty to path permitted */
#endif
#ifndef MOVE_MOUNT__MASK
#define MOVE_MOUNT__MASK 0x00000077
#endif
#endif /* __LXD_MOUNT_UTILS_H */
|
regnauld/lxd
|
lxd/include/syscall_wrappers.h
|
#ifndef __LXD_SYSCALL_WRAPPER_H
#define __LXD_SYSCALL_WRAPPER_H
#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
#include <asm/unistd.h>
#include <errno.h>
#include <sys/syscall.h>
#include <sys/types.h>
#include <unistd.h>
#include "syscall_numbers.h"
#ifndef CLOSE_RANGE_UNSHARE
#define CLOSE_RANGE_UNSHARE (1U << 1)
#endif
static inline int lxd_close_range(unsigned int fd, unsigned int max_fd, unsigned int flags)
{
return syscall(__NR_close_range, fd, max_fd, flags);
}
static inline int open_tree(int dfd, const char *filename, unsigned int flags)
{
return syscall(__NR_open_tree, dfd, filename, flags);
}
/*
* mount_setattr()
*/
struct lxc_mount_attr {
__u64 attr_set;
__u64 attr_clr;
__u64 propagation;
__u64 userns_fd;
};
static inline int mount_setattr(int dfd, const char *path, unsigned int flags,
struct lxc_mount_attr *attr, size_t size)
{
return syscall(__NR_mount_setattr, dfd, path, flags, attr, size);
}
static inline int move_mount(int from_dfd, const char *from_pathname, int to_dfd,
const char *to_pathname, unsigned int flags)
{
return syscall(__NR_move_mount, from_dfd, from_pathname, to_dfd,
to_pathname, flags);
}
#endif /* __LXD_SYSCALL_WRAPPER_H */
|
regnauld/lxd
|
shared/netutils/unixfd.c
|
<reponame>regnauld/lxd
// +build linux
// +build cgo
#ifndef _GNU_SOURCE
#define _GNU_SOURCE 1
#endif
#include <errno.h>
#include <fcntl.h>
#include <grp.h>
#include <limits.h>
#include <poll.h>
#include <pty.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/un.h>
#include "unixfd.h"
#include "../../lxd/include/memory_utils.h"
int lxc_abstract_unix_send_fds(int fd, int *sendfds, int num_sendfds,
void *data, size_t size)
{
__do_free char *cmsgbuf = NULL;
struct msghdr msg;
struct iovec iov;
struct cmsghdr *cmsg = NULL;
char buf[1] = {0};
size_t cmsgbufsize = CMSG_SPACE(num_sendfds * sizeof(int));
memset(&msg, 0, sizeof(msg));
memset(&iov, 0, sizeof(iov));
cmsgbuf = malloc(cmsgbufsize);
if (!cmsgbuf)
return -1;
msg.msg_control = cmsgbuf;
msg.msg_controllen = cmsgbufsize;
cmsg = CMSG_FIRSTHDR(&msg);
cmsg->cmsg_level = SOL_SOCKET;
cmsg->cmsg_type = SCM_RIGHTS;
cmsg->cmsg_len = CMSG_LEN(num_sendfds * sizeof(int));
msg.msg_controllen = cmsg->cmsg_len;
memcpy(CMSG_DATA(cmsg), sendfds, num_sendfds * sizeof(int));
iov.iov_base = data ? data : buf;
iov.iov_len = data ? size : sizeof(buf);
msg.msg_iov = &iov;
msg.msg_iovlen = 1;
return sendmsg(fd, &msg, MSG_NOSIGNAL);
}
ssize_t lxc_abstract_unix_recv_fds_iov(int fd, struct unix_fds *ret_fds,
struct iovec *ret_iov, size_t size_ret_iov)
{
__do_free char *cmsgbuf = NULL;
ssize_t ret;
struct msghdr msg = {};
struct cmsghdr *cmsg = NULL;
size_t cmsgbufsize = CMSG_SPACE(sizeof(struct ucred)) +
CMSG_SPACE(ret_fds->fd_count_max * sizeof(int));
if (ret_fds->flags & ~UNIX_FDS_ACCEPT_MASK)
return ret_errno(EINVAL);
if (hweight32((ret_fds->flags & ~UNIX_FDS_ACCEPT_NONE)) > 1)
return ret_errno(EINVAL);
if (ret_fds->fd_count_max >= KERNEL_SCM_MAX_FD)
return ret_errno(EINVAL);
if (ret_fds->fd_count_ret != 0)
return ret_errno(EINVAL);
cmsgbuf = zalloc(cmsgbufsize);
if (!cmsgbuf)
return ret_errno(ENOMEM);
msg.msg_control = cmsgbuf;
msg.msg_controllen = cmsgbufsize;
msg.msg_iov = ret_iov;
msg.msg_iovlen = size_ret_iov;
again:
ret = recvmsg(fd, &msg, MSG_CMSG_CLOEXEC);
if (ret < 0) {
if (errno == EINTR)
goto again;
return -errno;
}
if (ret == 0)
return 0;
/* If SO_PASSCRED is set we will always get a ucred message. */
for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
if (cmsg->cmsg_level == SOL_SOCKET && cmsg->cmsg_type == SCM_RIGHTS) {
__u32 idx;
/*
* This causes some compilers to complain about
* increased alignment requirements but I haven't found
* a better way to deal with this yet. Suggestions
* welcome!
*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wcast-align"
int *fds_raw = (int *)CMSG_DATA(cmsg);
#pragma GCC diagnostic pop
__u32 num_raw = (cmsg->cmsg_len - CMSG_LEN(0)) / sizeof(int);
/*
* We received an insane amount of file descriptors
* which exceeds the kernel limit we know about so
* close them and return an error.
*/
if (num_raw >= KERNEL_SCM_MAX_FD) {
for (idx = 0; idx < num_raw; idx++)
close(fds_raw[idx]);
return -EFBIG;
}
if (msg.msg_flags & MSG_CTRUNC) {
for (idx = 0; idx < num_raw; idx++)
close(fds_raw[idx]);
return -EFBIG;
}
if (ret_fds->fd_count_max > num_raw) {
if (!(ret_fds->flags & UNIX_FDS_ACCEPT_LESS)) {
for (idx = 0; idx < num_raw; idx++)
close(fds_raw[idx]);
return -EINVAL;
}
/*
* Make sure any excess entries in the fd array
* are set to -EBADF so our cleanup functions
* can safely be called.
*/
for (idx = num_raw; idx < ret_fds->fd_count_max; idx++)
ret_fds->fd[idx] = -EBADF;
ret_fds->flags |= UNIX_FDS_RECEIVED_LESS;
} else if (ret_fds->fd_count_max < num_raw) {
if (!(ret_fds->flags & UNIX_FDS_ACCEPT_MORE)) {
for (idx = 0; idx < num_raw; idx++)
close(fds_raw[idx]);
return -EINVAL;
}
/* Make sure we close any excess fds we received. */
for (idx = ret_fds->fd_count_max; idx < num_raw; idx++)
close(fds_raw[idx]);
/* Cap the number of received file descriptors. */
num_raw = ret_fds->fd_count_max;
ret_fds->flags |= UNIX_FDS_RECEIVED_MORE;
} else {
ret_fds->flags |= UNIX_FDS_RECEIVED_EXACT;
}
if (hweight32((ret_fds->flags & ~UNIX_FDS_ACCEPT_MASK)) > 1) {
for (idx = 0; idx < num_raw; idx++)
close(fds_raw[idx]);
return -EINVAL;
}
memcpy(ret_fds->fd, CMSG_DATA(cmsg), num_raw * sizeof(int));
ret_fds->fd_count_ret = num_raw;
break;
}
}
if (ret_fds->fd_count_ret == 0) {
ret_fds->flags |= UNIX_FDS_RECEIVED_NONE;
/* We expected to receive file descriptors. */
if ((ret_fds->flags & UNIX_FDS_ACCEPT_MASK) &&
!(ret_fds->flags & UNIX_FDS_ACCEPT_NONE))
return -EINVAL;
}
return ret;
}
ssize_t lxc_abstract_unix_recv_fds(int fd, struct unix_fds *ret_fds,
void *ret_data, size_t size_ret_data)
{
char buf[1] = {};
struct iovec iov = {
.iov_base = ret_data ? ret_data : buf,
.iov_len = ret_data ? size_ret_data : sizeof(buf),
};
ssize_t ret;
ret = lxc_abstract_unix_recv_fds_iov(fd, ret_fds, &iov, 1);
if (ret < 0)
return ret;
return ret;
}
|
yantor3d/polySymmetry
|
src/sceneCache.h
|
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_SCENE_CACHE_H
#define POLY_SYMMETRY_SCENE_CACHE_H
#include <string>
#include <unordered_map>
#include <maya/MCallbackIdArray.h>
#include <maya/MObject.h>
#include <maya/MObjectHandle.h>
#include <maya/MStatus.h>
using namespace std;
class PolySymmetryCache
{
public:
static MStatus initialize();
static MStatus uninitialize();
static void sceneUpdateCallback(void* clientData);
static void nodeAddedCallback(MObject &node, void* clientData);
static void nodeRemovedCallback(MObject &node, void* clientData);
static void newFileCallback(void* clientData);
static void beforeOpenFileCallback(void* clientData);
static void afterOpenFileCallback(void* clientData);
static void addNodeToCache(MObject &node);
static bool getNodeFromCache(MDagPath &mesh, MObject &node);
public:
static unordered_map<string, MObjectHandle> symmetryNodeCache;
static MCallbackIdArray callbackIDs;
static bool cacheNodes;
};
#endif
|
yantor3d/polySymmetry
|
src/polySymmetryCmd.h
|
<gh_stars>10-100
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_CMD_H
#define POLY_SYMMETRY_CMD_H
#include "meshData.h"
#include "polySymmetry.h"
#include <vector>
#include <maya/MArgList.h>
#include <maya/MArgDatabase.h>
#include <maya/MPxToolCommand.h>
#include <maya/MSelectionList.h>
#include <maya/MString.h>
#include <maya/MStatus.h>
#include <maya/MSyntax.h>
using namespace std;
#define SYMMETRY_COMPONENTS_FLAG "-sym"
#define SYMMETRY_COMPONENTS_LONG_FLAG "-symmetry"
#define LEFT_SIDE_VERTEX_FLAG "-lsv"
#define LEFT_SIDE_VERTEX_LONG_FLAG "-leftSideVertex"
#define CONSTRUCTION_HISTORY_FLAG "-ch"
#define CONSTRUCTION_HISTORY_LONG_FLAG "-constructionHistory"
#define EXISTS_FLAG "-ex"
#define EXISTS_LONG_FLAG "-exists"
class PolySymmetryCommand : public MPxToolCommand
{
public:
PolySymmetryCommand();
virtual ~PolySymmetryCommand();
static void* creator();
static MSyntax getSyntax();
virtual MStatus doIt(const MArgList& argList);
virtual MStatus redoIt();
virtual MStatus undoIt();
virtual MStatus doQueryDataAction();
virtual MStatus doQueryMeshAction();
virtual MStatus doUndoableCommand();
virtual MStatus parseQueryArguments(MArgDatabase &argsData);
virtual MStatus parseArguments(MArgDatabase &argsData);
virtual MStatus getSelectedMesh(MArgDatabase &argsData);
virtual MStatus getSymmetryComponents(MArgDatabase &argsData);
virtual void setSymmetryComponents(vector<ComponentSelection> &components);
virtual MStatus getLeftSideVertexIndices(MArgDatabase &argsData);
virtual void setLeftSideVertexIndices(vector<int> &indices);
virtual MStatus getFlagStringArguments(MArgList &args, MSelectionList &selection);
virtual MStatus getSymmetricalComponentsFromNode();
virtual MStatus getSymmetricalComponentsFromScene();
virtual MStatus createResultNode();
virtual MStatus createResultString();
virtual MStatus finalize();
const bool isUndoable();
const bool hasSyntax() { return true; }
static void setJSONData(const char* key, stringstream &output, vector<int> &data, bool isLast=false);
public:
static MString COMMAND_NAME;
private:
bool constructionHistory = false;
bool isQuery = false;
bool isQueryExists = false;
MDagPath selectedMesh;
MeshData meshData;
PolySymmetryData meshSymmetryData;
MObject meshSymmetryNode;
vector<ComponentSelection> symmetryComponents;
vector<int> leftSideVertexIndices;
};
#endif
|
yantor3d/polySymmetry
|
src/polySymmetry.h
|
<gh_stars>10-100
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_H
#define POLY_SYMMETRY_H
#include "meshData.h"
#include "selection.h"
#include <queue>
#include <utility>
#include <vector>
#include <maya/MDagPath.h>
using namespace std;
class PolySymmetryData
{
public:
PolySymmetryData();
~PolySymmetryData();
virtual void clear();
virtual void reset();
virtual void initialize(MDagPath &mesh);
virtual void findSymmetricalVertices(ComponentSelection &selection);
virtual void findFirstSymmetricalVertices(ComponentSelection &selection);
virtual void findVertexSides(vector<int> &leftSideVertexIndices);
virtual void finalizeSymmetry();
private:
virtual pair<int, int> getUnexaminedFaces(pair<int, int> &edgePair);
virtual int getUnexaminedFace(int &edgeIndex);
virtual int getUnexaminedVertexSibling(int &vertexIndex, int &faceIndex);
virtual void findSymmetricalVerticesOnFace(pair<int, int> &facePair);
virtual void findSymmetricalEdgesOnFace(queue<pair<int, int>> &symmetricalEdgesQueue, int &faceIndex);
virtual void markSymmetricalVertices(int &i0, int &i1);
virtual void markSymmetricalEdges(int &i0, int &i1);
virtual void markSymmetricalFaces(int &i0, int &i1);
public:
vector<int> vertexSymmetryIndices;
vector<int> edgeSymmetryIndices;
vector<int> faceSymmetryIndices;
vector<int> vertexSides;
vector<int> edgeSides;
vector<int> faceSides;
private:
MeshData meshData;
vector<bool> examinedEdges;
vector<bool> examinedFaces;
vector<bool> examinedVertices;
vector<int> leftSideVertexIndices;
};
#endif
|
yantor3d/polySymmetry
|
src/polyDeformerWeights.h
|
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_DEFORMER_WEIGHTS_H
#define POLY_DEFORMER_WEIGHTS_H
#include <vector>
#include <maya/MArgList.h>
#include <maya/MArgDatabase.h>
#include <maya/MDagPath.h>
#include <maya/MFloatArray.h>
#include <maya/MObject.h>
#include <maya/MPxCommand.h>
#include <maya/MString.h>
#include <maya/MStatus.h>
#include <maya/MSyntax.h>
using namespace std;
class PolyDeformerWeightsCommand : public MPxCommand
{
public:
PolyDeformerWeightsCommand();
virtual ~PolyDeformerWeightsCommand();
static void* creator();
static MSyntax getSyntax();
virtual MStatus parseArguments(MArgDatabase &argsData);
virtual MStatus validateArguments();
virtual MStatus doIt(const MArgList& argList);
virtual MStatus redoIt();
virtual MStatus undoIt();
virtual float getWeight(int vertexIndex, MFloatArray &sourceWeights, vector<int> &vertexSymmetry, vector<int> vertexSides);
virtual bool isUndoable() const { return true; }
virtual bool hasSyntax() const { return true; }
public:
static MString COMMAND_NAME;
private:
int direction = 1;
bool mirrorWeights = false;
bool flipWeights = false;
uint geometryIndex;
MFloatArray oldWeightValues;
MDagPath sourceMesh;
MDagPath destinationMesh;
MObject polySymmetryData;
MObject sourceDeformer;
MObject destinationDeformer;
MObject components;
};
#endif
|
yantor3d/polySymmetry
|
src/polyChecksum.h
|
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_CHECKSUM_H
#define POLY_CHECKSUM_H
#include <cstddef>
// based on code found at http://www.relisoft.com/science/CrcOptim.html
class PolyChecksum
{
public:
PolyChecksum();
virtual void putBytes(void* bytes, size_t dataSize);
virtual int getResult();
public:
unsigned long _table[256];
unsigned long _register = 0;
unsigned long _key = 0x04c11db7;
};
#endif
|
yantor3d/polySymmetry
|
src/polySkinWeights.h
|
<reponame>yantor3d/polySymmetry
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SKIN_WEIGHTS_H
#define POLY_SKIN_WEIGHTS_H
#include <functional>
#include <string>
#include <unordered_map>
#include <vector>
#include <maya/MArgList.h>
#include <maya/MArgDatabase.h>
#include <maya/MDagPath.h>
#include <maya/MDGModifier.h>
#include <maya/MDoubleArray.h>
#include <maya/MFloatArray.h>
#include <maya/MFnSkinCluster.h>
#include <maya/MIntArray.h>
#include <maya/MObject.h>
#include <maya/MPxCommand.h>
#include <maya/MString.h>
#include <maya/MStatus.h>
#include <maya/MSyntax.h>
using namespace std;
struct JointLabel
{
int side = -1;
int type = -1;
MString otherType;
JointLabel() {}
};
class PolySkinWeightsCommand : public MPxCommand
{
public:
PolySkinWeightsCommand();
virtual ~PolySkinWeightsCommand();
static void* creator();
static MSyntax getSyntax();
virtual MStatus parseArguments(MArgDatabase &argsData);
virtual MStatus parseEditArguments(MArgDatabase &argsData);
virtual MStatus parseQueryArguments(MArgDatabase &argsData);
virtual MStatus parseInfluenceSymmetryArgument(MArgDatabase &argsData);
virtual MStatus validateArguments();
virtual MStatus validateEditArguments();
virtual MStatus validateQueryArguments();
virtual MStatus validateInfluenceSymmetryArgument();
virtual bool isDeformedBy(MObject &skin, MDagPath &mesh);
virtual MStatus doIt(const MArgList& argList);
virtual MStatus redoIt();
virtual MStatus undoIt();
virtual MStatus copyPolySkinWeights();
virtual MStatus editPolySkinWeights();
virtual MStatus queryPolySkinWeights();
virtual MStatus undoCopyPolySkinWeights();
virtual MStatus undoEditPolySkinWeights();
virtual void copyWeightsTable(vector<string> &influenceKeys);
virtual void flipWeightsTable(vector<string> &influenceKeys);
virtual void mirrorWeightsTable(vector<string> &influenceKeys);
virtual MStatus makeInfluencesMatch(MFnSkinCluster &fnSourceSkin, MFnSkinCluster &fnDestinationSkin);
virtual MStatus makeInfluenceSymmetryTable(MDagPathArray &influences, vector<string> &influenceKeys, unordered_map<string, JointLabel> &jointLabels);
virtual void setupWeightTables(vector<string> &influenceKeys);
virtual void setWeightsTable(unordered_map<string, vector<double>> &weightTable, MDoubleArray &weights, vector<string> &influenceKeys);
virtual void getWeightsTable(unordered_map<string, vector<double>> &weightTable, MDoubleArray &weights, vector<string> &influenceKeys);
virtual MStatus getInfluenceIndices(MFnSkinCluster &fnSkin, MIntArray &influenceIndices);
virtual MStatus getInfluenceKeys(MFnSkinCluster &fnSkin, vector<string> &influenceKeys);
virtual void getJointLabels(MDagPathArray &influences, vector<string> &influenceKeys, unordered_map<string, JointLabel> &jointLabels);
virtual JointLabel getJointLabel(MDagPath &influence);
virtual MStatus setJointLabel(MDagPath &influence, JointLabel &jointLabel);
virtual bool isUndoable() const;
virtual bool hasSyntax() const { return true; }
public:
static MString COMMAND_NAME;
private:
int direction = 1;
bool normalizeWeights = false;
bool mirrorWeights = false;
bool flipWeights = false;
bool isQuery = false;
bool isEdit = false;
bool isInfluenceSymmetryFlagSet = false;
bool isQueryInfluenceSymmetry = false;
uint numberOfVertices;
string leftInfluencePattern;
string rightInfluencePattern;
unordered_map<string, string> influenceSymmetry;
unordered_map<string, JointLabel> oldJointLabels;
unordered_map<string, vector<double>> oldWeights;
unordered_map<string, vector<double>> newWeights;
vector<int> selectedVertexIndices;
MDGModifier dgModifier;
MDoubleArray oldWeightValues;
MObject sourceComponents;
MDagPath sourceMesh;
MObject sourceSkin;
MObject polySymmetryData;
MObject destinationComponents;
MDagPath destinationMesh;
MObject destinationSkin;
};
#endif
|
yantor3d/polySymmetry
|
src/polySymmetryNode.h
|
<gh_stars>10-100
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_NODE_H
#define POLY_SYMMETRY_NODE_H
#include <string>
#include <vector>
#include <maya/MDagPath.h>
#include <maya/MDataHandle.h>
#include <maya/MFnDependencyNode.h>
#include <maya/MPxNode.h>
#include <maya/MObject.h>
#include <maya/MPlug.h>
#include <maya/MString.h>
#include <maya/MTypeId.h>
#define NUMBER_OF_EDGES "numberOfEdges"
#define NUMBER_OF_FACES "numberOfFaces"
#define NUMBER_OF_VERTICES "numberOfVertices"
#define VERTEX_CHECKSUM "vertexChecksum"
#define EDGE_SYMMETRY "edgeSymmetry"
#define FACE_SYMMETRY "faceSymmetry"
#define VERTEX_SYMMETRY "vertexSymmetry"
#define EDGE_SIDES "edgeSides"
#define FACE_SIDES "faceSides"
#define VERTEX_SIDES "vertexSides"
using namespace std;
class PolySymmetryNode : MPxNode
{
public:
PolySymmetryNode();
virtual ~PolySymmetryNode();
static void* creator();
static MStatus initialize();
virtual MStatus compute(const MPlug &plug, MDataBlock &dataBlock);
static MStatus setValue(MFnDependencyNode &fnNode, const char* attributeName, int &value);
static MStatus getValue(MFnDependencyNode &fnNode, const char* attributeName, int &value);
static MStatus setValues(MFnDependencyNode &fnNode, const char* attributeName, vector<int> &values);
static MStatus getValues(MFnDependencyNode &fnNode, const char* attributeName, vector<int> &values);
static MStatus onInitializePlugin();
static MStatus onUninitializePlugin();
static MStatus getCacheKey(MObject &node, string &key);
static MStatus getCacheKeyFromMesh(MDagPath &node, string &key);
public:
static MObject numberOfEdges;
static MObject numberOfFaces;
static MObject numberOfVertices;
static MObject edgeSymmetry;
static MObject faceSymmetry;
static MObject vertexSymmetry;
static MObject edgeSides;
static MObject faceSides;
static MObject vertexSides;
static MObject vertexChecksum;
static MString NODE_NAME;
static MTypeId NODE_ID;
};
#endif
|
yantor3d/polySymmetry
|
src/parseArgs.h
|
<gh_stars>10-100
#ifndef PARSE_ARGS_H
#define PARSE_ARGS_H
#include <maya/MArgDatabase.h>
#include <maya/MDagPath.h>
#include <maya/MFn.h>
#include <maya/MObject.h>
#include <maya/MStatus.h>
namespace parseArgs
{
MStatus getNodeArgument(MArgDatabase &argsData, const char* flag, MObject &node, bool required);
MStatus getDagPathArgument(MArgDatabase &argsData, const char* flag, MDagPath &path, bool required);
bool isNodeType(MObject &node, MFn::Type nodeType);
bool isNodeType(MDagPath &path, MFn::Type nodeType);
}
#endif
|
yantor3d/polySymmetry
|
src/meshData.h
|
<gh_stars>10-100
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef MESH_DATA_CMD_H
#define MESH_DATA_CMD_H
#include <vector>
#include <unordered_map>
#include <maya/MDagPath.h>
#include <maya/MItMeshEdge.h>
#include <maya/MItMeshPolygon.h>
#include <maya/MItMeshVertex.h>
using namespace std;
struct ComponentData
{
vector<int> connectedVertices;
vector<int> connectedEdges;
vector<int> connectedFaces;
};
struct VertexData : ComponentData
{
unordered_map<int,vector<int>> faceVertexSiblings;
};
struct EdgeData : ComponentData {};
struct FaceData : ComponentData {};
class MeshData
{
public:
MeshData();
virtual ~MeshData();
virtual void unpackMesh(MDagPath &meshDagPath);
virtual void clear();
static unsigned long getVertexChecksum(MDagPath &meshDagPath);
private:
virtual void unpackEdges(MItMeshEdge &edges);
virtual void unpackFaces(MItMeshPolygon &faces);
virtual void unpackVertices(MItMeshVertex &vertices);
virtual void unpackVertexSiblings();
virtual void insertAll(MIntArray &src, vector<int> &dest);
public:
int numberOfVertices = 0;
int numberOfEdges = 0;
int numberOfFaces = 0;
vector<VertexData> vertexData;
vector<EdgeData> edgeData;
vector<FaceData> faceData;
unsigned long vertexChecksum;
};
#endif
|
yantor3d/polySymmetry
|
src/polySymmetryTool.h
|
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_TOOL_H
#define POLY_SYMMETRY_TOOL_H
#include "meshData.h"
#include "polySymmetry.h"
#include <vector>
#include <maya/MColor.h>
#include <maya/MColorArray.h>
#include <maya/MDagPath.h>
#include <maya/MDGModifier.h>
#include <maya/MEvent.h>
#include <maya/MPxContext.h>
#include <maya/MPxContextCommand.h>
#include <maya/MPxSelectionContext.h>
#include <maya/MSelectionList.h>
#include <maya/MString.h>
#include <maya/MStatus.h>
using namespace std;
const int VERTICES = 1;
const int COMPONENTS = 2;
class PolySymmetryTool : public MPxSelectionContext
{
public:
PolySymmetryTool();
virtual ~PolySymmetryTool();
virtual void toolOnSetup(MEvent &event);
virtual void toolOffCleanup();
virtual MStatus helpStateHasChanged(MEvent &event);
virtual void abortAction();
virtual void completeAction();
virtual void deleteAction();
virtual void doToolCommand();
virtual MStatus getSelectedMesh();
virtual MStatus clearSelectedMesh();
virtual void updateHelpString();
virtual void recalculateSymmetry();
virtual void updateDisplayColors();
private:
MDagPath selectedMesh;
MeshData meshData;
PolySymmetryData symmetryData;
MColorArray originalVertexColors;
bool originalDisplayColors = false;
MDGModifier displayColorModifier;
vector<int> affectedVertices;
vector<ComponentSelection> selectedComponents;
vector<int> leftSideVertexIndices;
};
class PolySymmetryContextCmd : public MPxContextCommand
{
public:
PolySymmetryContextCmd();
~PolySymmetryContextCmd();
virtual MPxContext* makeObj();
static void* creator();
public:
static MString COMMAND_NAME;
};
#endif
|
yantor3d/polySymmetry
|
src/selection.h
|
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_SELECTION_H
#define POLY_SYMMETRY_SELECTION_H
#include "meshData.h"
#include <vector>
#include <utility>
#include <maya/MDagPath.h>
#include <maya/MFn.h>
#include <maya/MSelectionList.h>
using namespace std;
/*
User selection of the symmetrical components on a shell, with a
stand-alone vertex on the left side of the shell.
The first edge index is connected to the first face index.
The first vertex index is connected to the first edge index.
*/
struct ComponentSelection
{
pair<int, int> edgeIndices;
pair<int, int> faceIndices;
pair<int, int> vertexIndices;
int leftVertexIndex = -1;
ComponentSelection() {}
};
void getSelectedComponents(MDagPath &selectedMesh, MSelectionList &activeSelection, MSelectionList &selection, MFn::Type componentType);
void getSelectedComponentIndices(MSelectionList &activeSelection, vector<int> &indices, MFn::Type componentType);
bool getSymmetricalComponentSelection(MeshData &meshData, MSelectionList &selection, ComponentSelection &componentSelection, bool leftSideVertexSelected);
void getAllVertices(int &numberOfVertices, MObject &components);
#endif
|
yantor3d/polySymmetry
|
src/util.h
|
/**
Copyright (c) 2017 <NAME>
You may use, distribute, or modify this code under the terms of the MIT license.
*/
#ifndef POLY_SYMMETRY_UTIL_H
#define POLY_SYMMETRY_UTIL_H
#include <algorithm>
#include <vector>
using namespace std;
vector<int> intersection(vector<int> &a, vector<int> &b);
bool contains(vector<int> &items, int &value);
#endif
|
shobhit85/BackPocket
|
Source/ObjectSerializer.h
|
<reponame>shobhit85/BackPocket<gh_stars>0
//
// ObjectSerializer.h
//
// Created by <NAME> on 10/12/13.
//
#import <Foundation/Foundation.h>
@protocol ObjectSerializer <NSObject>
@required
- (NSData *) serialize:(NSObject *)object;
- (NSObject *) deserialize: (NSData *)bytes;
@end
|
shobhit85/BackPocket
|
Source/DataStore.h
|
<gh_stars>0
//
// Region.h
//
// Created by <NAME> on 1/3/13.
//
#import <Foundation/Foundation.h>
#import "Pool.h"
#import "ObjectSerializer.h"
@interface DataStore : NSObject {
NSNumber *size;
NSString *name;
Pool *connectionPool;
}
@property (copy, getter = getName) NSString *name;
@property (nonatomic, readwrite) Pool *connectionPool;
@property (copy) NSNumber *size;
@property id<ObjectSerializer> serializer;
- (id) initWithPool:(Pool *)pool name:(NSString *)regionName;
- (NSObject *) get: (NSObject *)key;
- (void) put:(NSObject *)value forKey:(NSObject *)key;
- (NSObject *) remove: (NSObject *)key;
- (void) putAll: (NSMapTable *)values;
- (NSMapTable *) getAll;
- (NSInteger) getSize;
@end
|
shobhit85/BackPocket
|
Examples/SampleObjectCache/SampleObjectCache/SampleObjectCacheMasterViewController.h
|
//
// SampleObjectCacheMasterViewController.h
// SampleObjectCache
//
// Created by <NAME> on 3/24/13.
// Copyright (c) 2013 shobhita. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface SampleObjectCacheMasterViewController : UITableViewController
@end
|
shobhit85/BackPocket
|
Examples/SampleObjectCache/SampleObjectCache/SampleObjectCacheDetailViewController.h
|
<filename>Examples/SampleObjectCache/SampleObjectCache/SampleObjectCacheDetailViewController.h
//
// SampleObjectCacheDetailViewController.h
// SampleObjectCache
//
// Created by <NAME> on 3/24/13.
// Copyright (c) 2013 shobhita. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface SampleObjectCacheDetailViewController : UIViewController
@property (strong, nonatomic) id detailItem;
@property (weak, nonatomic) IBOutlet UILabel *detailDescriptionLabel;
@end
|
shobhit85/BackPocket
|
Source/Pool.h
|
<filename>Source/Pool.h
//
// Pool.h
//
// Created by <NAME> on 1/6/13.
//
#import <Foundation/Foundation.h>
#import "Connection.h"
@interface Pool : NSObject
{
NSString *server;
NSInteger port;
}
@property (retain, nonatomic) NSString *server;
@property (assign, readwrite) NSInteger port;
- (id)initialize:(NSString *)serverAddress port:(NSInteger )port numConn:(int)conns;
- (Connection *) getConnection;
@end
|
shobhit85/BackPocket
|
Source/PocketFactory.h
|
<filename>Source/PocketFactory.h
//
// PocketFactory.h
//
// Created by <NAME> on 1/3/13.
//
#import <Foundation/Foundation.h>
#import "Pocket.h"
@interface PocketFactory : NSObject
{
NSDictionary *properties;
}
@property (copy, getter = getProps) NSDictionary *properties;
- (id) initWithProps:(NSDictionary *)props;
- (Pocket *)create;
@end
|
shobhit85/BackPocket
|
Source/Pocket.h
|
<reponame>shobhit85/BackPocket
//
// ClientCache.h
//
// Created by <NAME> on 1/3/13.
//
#import <Foundation/Foundation.h>
#import "DataStore.h"
#import "PoolManager.h"
@interface Pocket : NSObject
{
NSString *server;
NSInteger port;
}
@property (copy, nonatomic) NSString *server;
@property (readonly, nonatomic) NSInteger port;
- (void) initializeWithProps:(NSDictionary *) props;
- (DataStore *)createDatastore: (NSString *)storeName;
- (DataStore *)getDatastore: (NSString *)storeName;
- (void)destroyDataStore: (NSString *)storeName;
- (void)close;
@end
|
shobhit85/BackPocket
|
Source/AbstractDataStoreMap.h
|
//
// AbstractRegionMap.h
//
// Created by <NAME> on 1/22/13.
//
#import <Foundation/Foundation.h>
#import <CoreFoundation/CoreFoundation.h>
#define DEFAULT_CACHE_SIZE 1000
@class DSValue;
@interface AbstractDataStoreMap : NSObject
{
CFMutableDictionaryRef map;
DSValue *first;
DSValue *last;
int32_t size;
}
@property (atomic, readonly) CFMutableDictionaryRef map;
- (id) initWithSize:(int)maxSize;
- (id) initWithKeyCB:(CFDictionaryKeyCallBacks)kcb andWithValueCB:(CFDictionaryValueCallBacks)vcb;
- (BOOL) addValue:(id)value toKey:(id)key;
- (id) getValueForKey:(id)key;
- (id) removeValueForKey:(id)key;
- (NSInteger) getSize;
- (void) clear;
@end
@interface DSValue : NSObject <NSCoding>
@property (retain, nonatomic) NSString *lastAccessTime;
@property (retain, nonatomic) NSObject *value;
@property (retain, atomic) NSObject *key;
@property (retain, nonatomic) DSValue *prev;
@property (retain, nonatomic) DSValue *next;
-(id) initWithValue:(NSObject *)val andKey:(NSObject *)k;
@end
NSString *GFGenerateSystemTimeStampAsString(void);
|
shobhit85/BackPocket
|
Source/Message.h
|
//
// GetRequestMessage.h
//
// Created by <NAME> on 1/27/13.
//
#import <Foundation/Foundation.h>
#import "ObjectSerializer.h"
#import <objc/runtime.h>
#define OFFSETTER sizeof(int32_t)
@interface Message : NSObject
@property (assign, getter = getOpcode) int16_t op;
@property (retain, getter = getDSName) NSString *dsName;
@property (retain, getter = getKey) NSObject *key;
@property (retain, getter = getValue) NSObject *value;
@property (retain, getter = getError) NSString *error;
+ (NSData *) serializeMessageNativelyWithPropertyList:(Message *)message using:(id <ObjectSerializer>)serializer;
+ (Message *) deserializeMessageNativelyWithPropertyList:(NSData *)data using:(id <ObjectSerializer>)serializer;
+ (Message *) getNewMessage:(int16_t)op for:(NSString *)store withKey:(NSObject *)key andValue:(NSObject *)value;
@end
@interface PutAllRequestMessage : NSObject <NSCoding>
@property (retain, nonatomic) NSDictionary *keyValues;
@end
@interface PutAllReplyMessage : NSObject <NSCoding>
@property (retain, nonatomic) NSString *result;
@end
|
shobhit85/BackPocket
|
Examples/SampleObjectCache/SampleObjectCache/SampleObjectCacheAppDelegate.h
|
//
// SampleObjectCacheAppDelegate.h
// SampleObjectCache
//
// Created by <NAME> on 3/24/13.
// Copyright (c) 2013 shobhita. All rights reserved.
//
#import <UIKit/UIKit.h>
#import <BackPocket.h>
@class SampleObjectCacheMasterViewController;
@interface SampleObjectCacheAppDelegate : UIResponder <UIApplicationDelegate>
{
Pocket *cache;
DataStore *store;
}
- (NSInteger) cacheSize;
- (NSObject *) objectInListAtIndex:(NSInteger)key;
@property (strong, nonatomic) UIWindow *window;
@property (strong, nonatomic) SampleObjectCacheMasterViewController *viewController;
@property (nonatomic, readonly) Pocket *loadCache;
+ (SampleObjectCacheAppDelegate *)sharedDelegate;
@end
|
shobhit85/BackPocket
|
Source/Connection.h
|
<filename>Source/Connection.h
//
// Connection.h
//
// Created by <NAME> on 1/6/13.
//
#import <CoreFoundation/CoreFoundation.h>
#import <Foundation/Foundation.h>
@interface Connection : NSObject {
CFReadStreamRef readStream;
CFWriteStreamRef writeStream;
}
@property CFReadStreamRef readStream;
@property CFWriteStreamRef writeStream;
@property NSMutableData *dataRecieved;
@property BOOL isFree;
- (id)initWithIp:(const char *)ipAddress andPort:(int)port;
- (BOOL) sendData:(NSData *)data;
- (BOOL) waitForResult;
- (NSData *) getResultBytes;
- (void) close;
- (BOOL) isAlive;
- (BOOL) isAvailable;
@end
|
shobhit85/BackPocket
|
Source/DefaultPListObjectSerializer.h
|
<reponame>shobhit85/BackPocket
//
// DefaultPListObjectSerializer.h
//
// Created by <NAME> on 10/13/13.
//
#import "ObjectSerializer.h"
#import <objc/runtime.h>
@interface DefaultPListObjectSerializer : NSObject <ObjectSerializer>
@end
|
shobhit85/BackPocket
|
Source/PoolManager.h
|
<reponame>shobhit85/BackPocket<filename>Source/PoolManager.h<gh_stars>0
//
// PoolManager.h
//
// Created by <NAME> on 1/6/13.
//
#import <Foundation/Foundation.h>
#import "Pool.h"
#define INIT_NUM_CONN 5
@interface PoolManager : NSObject
+ (Pool *)createPoolWithAddress:(NSString *)server port:(NSInteger *)port;
@end
|
shobhit85/BackPocket
|
Source/BackPocket.h
|
//
// Created by <NAME> on 1/3/13.
//
#import <Foundation/Foundation.h>
#import "PocketFactory.h"
@interface BackPocket : NSObject
+ (PocketFactory *) getPocketFactory:(NSDictionary *) props;
@end
|
ic-lab-duth/NoCpad
|
examples/nocpad_2m-2s_2d-mesh_vc-req-resp_id-order/ic_top_2d_1noc.h
|
#ifndef AXI4_TOP_IC_H
#define AXI4_TOP_IC_H
#pragma once
#include "../../src/axi_master_if_vc.h"
#include "../../src/axi_slave_if_vc.h"
#include "../../src/router_vc.h"
#include "systemc.h"
#include "nvhls_connections.h"
#pragma hls_design top
// Bundle of configuration parameters
template <
unsigned char MASTER_NUM_ , unsigned char SLAVE_NUM_,
unsigned char RD_LANES_ , unsigned char WR_LANES_,
unsigned char RREQ_PHITS_ , unsigned char RRESP_PHITS_,
unsigned char WREQ_PHITS_ , unsigned char WRESP_PHITS_,
unsigned char ORD_SCHEME_ , unsigned char VCS_
>
struct cfg {
static const unsigned char MASTER_NUM = MASTER_NUM_;
static const unsigned char SLAVE_NUM = SLAVE_NUM_;
static const unsigned char RD_LANES = RD_LANES_;
static const unsigned char WR_LANES = WR_LANES_;
static const unsigned char RREQ_PHITS = RREQ_PHITS_;
static const unsigned char RRESP_PHITS = RRESP_PHITS_;
static const unsigned char WREQ_PHITS = WREQ_PHITS_;
static const unsigned char WRESP_PHITS = WRESP_PHITS_;
static const unsigned char ORD_SCHEME = ORD_SCHEME_;
static const unsigned char VCS = VCS_;
};
// the used configuration. 2 Masters/Slaves, 64bit AXI, 2.4.4.1 phit flits
typedef cfg<2, 2, 8, 8, 4, 4, 4, 4, 1, 2> smpl_cfg;
SC_MODULE(ic_top) {
public:
// typedef matchlib's axi with the "standard" configuration
typedef typename axi::axi4<axi::cfg::standard_duth> axi4_;
// typedef the 4 kind of flits(RD/WR Req/Resp) depending their size
typedef flit_dnp<smpl_cfg::RREQ_PHITS> rreq_flit_t;
typedef flit_dnp<smpl_cfg::RRESP_PHITS> rresp_flit_t;
typedef flit_dnp<smpl_cfg::WREQ_PHITS> wreq_flit_t;
typedef flit_dnp<smpl_cfg::WRESP_PHITS> wresp_flit_t;
typedef sc_uint<1> cr_t;
static const unsigned DIM_X = 2;
static const unsigned DIM_Y = 2;
sc_in_clk clk;
sc_in <bool> rst_n;
// IC's Address map
sc_in<sc_uint <32> > addr_map[smpl_cfg::SLAVE_NUM][2]; // [SLAVE_NUM][0:begin, 1: End]
sc_signal< sc_uint<dnp::D_W> > route_lut[2][1];
// The Node IDs are passed to IFs as signals
sc_signal< sc_uint<dnp::S_W> > NODE_IDS_MASTER[smpl_cfg::MASTER_NUM];
sc_signal< sc_uint<dnp::S_W> > NODE_IDS_SLAVE[smpl_cfg::SLAVE_NUM];
sc_signal< sc_uint<dnp::D_W> > rtr_id_x_req[DIM_X];
sc_signal< sc_uint<dnp::D_W> > rtr_id_y_req[DIM_Y];
sc_signal< sc_uint<dnp::D_W> > rtr_id_x_resp[DIM_X];
sc_signal< sc_uint<dnp::D_W> > rtr_id_y_resp[DIM_Y];
// MASTER Side AXI Channels
Connections::In<axi4_::AddrPayload> ar_in[smpl_cfg::MASTER_NUM];
Connections::Out<axi4_::ReadPayload> r_out[smpl_cfg::MASTER_NUM];
Connections::In<axi4_::AddrPayload> aw_in[smpl_cfg::MASTER_NUM];
Connections::In<axi4_::WritePayload> w_in[smpl_cfg::MASTER_NUM];
Connections::Out<axi4_::WRespPayload> b_out[smpl_cfg::MASTER_NUM];
// SLAVE Side AXI Channels
Connections::Out<axi4_::AddrPayload> ar_out[smpl_cfg::SLAVE_NUM];
Connections::In<axi4_::ReadPayload> r_in[smpl_cfg::SLAVE_NUM];
Connections::Out<axi4_::AddrPayload> aw_out[smpl_cfg::SLAVE_NUM];
Connections::Out<axi4_::WritePayload> w_out[smpl_cfg::SLAVE_NUM];
Connections::In<axi4_::WRespPayload> b_in[smpl_cfg::SLAVE_NUM];
//--- Internals ---//
// --- Master/Slave IFs ---
axi_master_if_vc < smpl_cfg > *master_if[smpl_cfg::MASTER_NUM];
axi_slave_if_vc < smpl_cfg > *slave_if[smpl_cfg::SLAVE_NUM];
// Master IF Channels
// READ Fwd Req
Connections::Buffer<rreq_flit_t, 4> rreq_m_buf_data[smpl_cfg::MASTER_NUM];
Connections::Buffer<cr_t , 4> rreq_m_buf_cr[smpl_cfg::MASTER_NUM];
Connections::Combinational<rreq_flit_t> rreq_m_chan_data[smpl_cfg::MASTER_NUM];
Connections::Combinational<cr_t> rreq_m_chan_cr[smpl_cfg::MASTER_NUM];
Connections::Combinational<rreq_flit_t> chan_rd_m2r_data[smpl_cfg::MASTER_NUM]; // M-IF_to_Rtr
Connections::Combinational<cr_t> chan_rd_m2r_cr[smpl_cfg::MASTER_NUM]; // M-IF_from_Rtr
// READ Backward Resp
Connections::Combinational<rresp_flit_t> chan_rd_r2m_data[smpl_cfg::MASTER_NUM]; // Rtr_to_S-IF
Connections::Combinational<cr_t> chan_rd_r2m_cr[smpl_cfg::MASTER_NUM]; // Rtr_from_S-IF
Connections::Buffer<rresp_flit_t, 4> rresp_m_buf_data[smpl_cfg::MASTER_NUM];
Connections::Buffer<cr_t , 4> rresp_m_buf_cr[smpl_cfg::MASTER_NUM];
Connections::Combinational<rresp_flit_t> rresp_m_chan_data[smpl_cfg::MASTER_NUM];
Connections::Combinational<cr_t> rresp_m_chan_cr[smpl_cfg::MASTER_NUM];
// WRITE Fwd Req
Connections::Buffer<wreq_flit_t, 4> wreq_m_buf_data[smpl_cfg::MASTER_NUM];
Connections::Buffer<cr_t , 4> wreq_m_buf_cr[smpl_cfg::MASTER_NUM];
Connections::Combinational<wreq_flit_t> wreq_m_chan_data[smpl_cfg::MASTER_NUM];
Connections::Combinational<cr_t> wreq_m_chan_cr[smpl_cfg::MASTER_NUM];
Connections::Combinational<wreq_flit_t> chan_wr_m2r_data[smpl_cfg::MASTER_NUM]; // M-IF_to_Rtr
Connections::Combinational<cr_t> chan_wr_m2r_cr[smpl_cfg::MASTER_NUM]; // M-IF_from_Rtr
// WRITE Backward Resp
Connections::Combinational<wresp_flit_t> chan_wr_r2m_data[smpl_cfg::MASTER_NUM]; // Rtr_to_S-IF
Connections::Combinational<cr_t> chan_wr_r2m_cr[smpl_cfg::MASTER_NUM]; // Rtr_from_S-IF
Connections::Buffer<wresp_flit_t, 4> wresp_m_buf_data[smpl_cfg::MASTER_NUM];
Connections::Buffer<cr_t , 4> wresp_m_buf_cr[smpl_cfg::MASTER_NUM];
Connections::Combinational<wresp_flit_t> wresp_m_chan_data[smpl_cfg::MASTER_NUM];
Connections::Combinational<cr_t> wresp_m_chan_cr[smpl_cfg::MASTER_NUM];
// Slave IF Channels
// READ Fwd Req
Connections::Combinational<rreq_flit_t> chan_rd_r2s_data[smpl_cfg::SLAVE_NUM]; // Rtr_to_S-IF
Connections::Combinational<cr_t> chan_rd_r2s_cr[smpl_cfg::SLAVE_NUM]; // Rtr_from_S-IF
Connections::Buffer<rreq_flit_t, 4> rreq_s_buf_data[smpl_cfg::SLAVE_NUM];
Connections::Buffer<cr_t , 4> rreq_s_buf_cr[smpl_cfg::SLAVE_NUM];
Connections::Combinational<rreq_flit_t> rreq_s_chan_data[smpl_cfg::SLAVE_NUM];
Connections::Combinational<cr_t> rreq_s_chan_cr[smpl_cfg::SLAVE_NUM];
// READ Backward Resp
Connections::Buffer<rresp_flit_t, 4> rresp_s_buf_data[smpl_cfg::SLAVE_NUM];
Connections::Buffer<cr_t , 4> rresp_s_buf_cr[smpl_cfg::SLAVE_NUM];
Connections::Combinational<rresp_flit_t> rresp_s_chan_data[smpl_cfg::SLAVE_NUM];
Connections::Combinational<cr_t> rresp_s_chan_cr[smpl_cfg::SLAVE_NUM];
Connections::Combinational<rresp_flit_t> chan_rd_s2r_data[smpl_cfg::SLAVE_NUM]; // M-IF_to_Rtr
Connections::Combinational<cr_t> chan_rd_s2r_cr[smpl_cfg::SLAVE_NUM]; // M-IF_from_Rtr
// WRITE Fwd Req
Connections::Combinational<wreq_flit_t> chan_wr_r2s_data[smpl_cfg::SLAVE_NUM]; // Rtr_to_S-IF
Connections::Combinational<cr_t> chan_wr_r2s_cr[smpl_cfg::SLAVE_NUM]; // Rtr_from_S-IF
Connections::Buffer<wreq_flit_t, 4> wreq_s_buf_data[smpl_cfg::SLAVE_NUM];
Connections::Buffer<cr_t , 4> wreq_s_buf_cr[smpl_cfg::SLAVE_NUM];
Connections::Combinational<wreq_flit_t> wreq_s_chan_data[smpl_cfg::SLAVE_NUM];
Connections::Combinational<cr_t> wreq_s_chan_cr[smpl_cfg::SLAVE_NUM];
// WRITE Backward Resp
Connections::Buffer<wresp_flit_t, 4> wresp_s_buf_data[smpl_cfg::SLAVE_NUM];
Connections::Buffer<cr_t , 4> wresp_s_buf_cr[smpl_cfg::SLAVE_NUM];
Connections::Combinational<wresp_flit_t> wresp_s_chan_data[smpl_cfg::SLAVE_NUM];
Connections::Combinational<cr_t> wresp_s_chan_cr[smpl_cfg::SLAVE_NUM];
Connections::Combinational<wresp_flit_t> chan_wr_s2r_data[smpl_cfg::SLAVE_NUM]; // M-IF_to_Rtr
Connections::Combinational<cr_t> chan_wr_s2r_cr[smpl_cfg::SLAVE_NUM]; // M-IF_from_Rtr
// Master IF Channels
// Read Req/Resp
Connections::Combinational<rreq_flit_t> chan_rd_m2r[smpl_cfg::MASTER_NUM];
Connections::Combinational<rresp_flit_t> chan_rd_r2m[smpl_cfg::MASTER_NUM];
// Write Req/Resp
Connections::Combinational<wreq_flit_t> chan_wr_m2r[smpl_cfg::MASTER_NUM];
Connections::Combinational<wresp_flit_t> chan_wr_r2m[smpl_cfg::MASTER_NUM];
// Slave IF
// Read Req/Resp
Connections::Combinational<rreq_flit_t> chan_rd_r2s[smpl_cfg::SLAVE_NUM];
Connections::Combinational<rresp_flit_t> chan_rd_s2r[smpl_cfg::SLAVE_NUM];
Connections::Combinational<wreq_flit_t> chan_wr_r2s[smpl_cfg::SLAVE_NUM];
Connections::Combinational<wresp_flit_t> chan_wr_s2r[smpl_cfg::SLAVE_NUM];
// --- NoC Channels ---
// REQ Router + In/Out Channels
rtr_vc< 4+2, 4+2, rreq_flit_t, DIM_X, 1, 2, 3, 5> rtr_inst[DIM_X][DIM_Y];
Connections::Combinational<rreq_flit_t> chan_hor_right_data[DIM_X+1][DIM_Y];
Connections::Combinational<cr_t> chan_hor_right_cr[DIM_X+1][DIM_Y];
Connections::Combinational<rreq_flit_t> chan_hor_left_data[DIM_X+1][DIM_Y];
Connections::Combinational<cr_t> chan_hor_left_cr[DIM_X+1][DIM_Y];
Connections::Combinational<rreq_flit_t> chan_ver_up_data[DIM_X][DIM_Y+1];
Connections::Combinational<cr_t> chan_ver_up_cr[DIM_X][DIM_Y+1];
Connections::Combinational<rreq_flit_t> chan_ver_down_data[DIM_X][DIM_Y+1];
Connections::Combinational<cr_t> chan_ver_down_cr[DIM_X][DIM_Y+1];
Connections::Combinational<rreq_flit_t> chan_inj_wr_data[DIM_X][DIM_Y];
Connections::Combinational<cr_t> chan_inj_wr_cr[DIM_X][DIM_Y];
Connections::Combinational<rreq_flit_t> chan_inj_rd_data[DIM_X][DIM_Y];
Connections::Combinational<cr_t> chan_inj_rd_cr[DIM_X][DIM_Y];
Connections::Combinational<rreq_flit_t> chan_ej_wr_data[DIM_X][DIM_Y];
Connections::Combinational<cr_t> chan_ej_wr_cr[DIM_X][DIM_Y];
Connections::Combinational<rreq_flit_t> chan_ej_rd_data[DIM_X][DIM_Y];
Connections::Combinational<cr_t> chan_ej_rd_cr[DIM_X][DIM_Y];
SC_CTOR(ic_top) {
route_lut[0][0] = 0;
route_lut[1][0] = 0;
// ----------------- //
// --- SLAVE-IFs --- //
// ----------------- //
for(unsigned char j=0; j<smpl_cfg::SLAVE_NUM; ++j){
NODE_IDS_SLAVE[j] = j;
unsigned col = j % DIM_X; // aka x dim
unsigned row = j / DIM_X; // aka y dim
slave_if[j] = new axi_slave_if_vc < smpl_cfg > (sc_gen_unique_name("Slave-if"));
slave_if[j]->clk(clk);
slave_if[j]->rst_n(rst_n);
slave_if[j]->THIS_ID(NODE_IDS_SLAVE[j]);
slave_if[j]->slave_base_addr(addr_map[j][0]);
// Read-NoC
slave_if[j]->rd_flit_data_in(rreq_s_chan_data[j]);
slave_if[j]->rd_flit_cr_out(rreq_s_chan_cr[j]);
slave_if[j]->rd_flit_data_out(rresp_s_chan_data[j]);
slave_if[j]->rd_flit_cr_in(rresp_s_chan_cr[j]);
// Write-NoC
slave_if[j]->wr_flit_data_in(wreq_s_chan_data[j]);
slave_if[j]->wr_flit_cr_out(wreq_s_chan_cr[j]);
slave_if[j]->wr_flit_data_out(wresp_s_chan_data[j]);
slave_if[j]->wr_flit_cr_in(wresp_s_chan_cr[j]);
// Slave-Side
slave_if[j]->ar_out(ar_out[j]);
slave_if[j]->r_in(r_in[j]);
slave_if[j]->aw_out(aw_out[j]);
slave_if[j]->w_out(w_out[j]);
slave_if[j]->b_in(b_in[j]);
// Buffer Connectivity
// Read Request
rreq_s_buf_data[j].clk(clk);
rreq_s_buf_data[j].rst(rst_n);
rreq_s_buf_data[j].enq(chan_ej_rd_data[col][row]);
rreq_s_buf_data[j].deq(rreq_s_chan_data[j]);
rreq_s_buf_cr[j].clk(clk);
rreq_s_buf_cr[j].rst(rst_n);
rreq_s_buf_cr[j].enq(rreq_s_chan_cr[j]);
rreq_s_buf_cr[j].deq(chan_ej_rd_cr[col][row]);
// Read Response
rresp_s_buf_data[j].clk(clk);
rresp_s_buf_data[j].rst(rst_n);
rresp_s_buf_data[j].enq(rresp_s_chan_data[j]);
rresp_s_buf_data[j].deq(chan_inj_rd_data[col][row]);
rresp_s_buf_cr[j].clk(clk);
rresp_s_buf_cr[j].rst(rst_n);
rresp_s_buf_cr[j].enq(chan_inj_rd_cr[col][row]);
rresp_s_buf_cr[j].deq(rresp_s_chan_cr[j]);
// Write Request
wreq_s_buf_data[j].clk(clk);
wreq_s_buf_data[j].rst(rst_n);
wreq_s_buf_data[j].enq(chan_ej_wr_data[col][row]);
wreq_s_buf_data[j].deq(wreq_s_chan_data[j]);
wreq_s_buf_cr[j].clk(clk);
wreq_s_buf_cr[j].rst(rst_n);
wreq_s_buf_cr[j].enq(wreq_s_chan_cr[j]);
wreq_s_buf_cr[j].deq(chan_ej_wr_cr[col][row]);
// Write Response
wresp_s_buf_data[j].clk(clk);
wresp_s_buf_data[j].rst(rst_n);
wresp_s_buf_data[j].enq(wresp_s_chan_data[j]);
wresp_s_buf_data[j].deq(chan_inj_wr_data[col][row]);
wresp_s_buf_cr[j].clk(clk);
wresp_s_buf_cr[j].rst(rst_n);
wresp_s_buf_cr[j].enq(chan_inj_wr_cr[col][row]);
wresp_s_buf_cr[j].deq(wresp_s_chan_cr[j]);
}
// ------------------------------ //
// --- MASTER-IFs Connectivity--- //
// ------------------------------ //
for (int i=0; i<smpl_cfg::MASTER_NUM; ++i) {
NODE_IDS_MASTER[i] = smpl_cfg::SLAVE_NUM + i;
unsigned col = (smpl_cfg::SLAVE_NUM + i) % DIM_X; // aka x dim
unsigned row = (smpl_cfg::SLAVE_NUM + i) / DIM_X; // aka y dim
master_if[i] = new axi_master_if_vc < smpl_cfg > (sc_gen_unique_name("Master-if"));
master_if[i]->clk(clk);
master_if[i]->rst_n(rst_n);
// Pass the address Map
for (int n=0; n<smpl_cfg::SLAVE_NUM; ++n) // Iterate Slaves
for (int s=0; s<2; ++s) // Iterate Begin-End Values
master_if[i]->addr_map[n][s](addr_map[n][s]);
master_if[i]->THIS_ID(NODE_IDS_MASTER[i]);
// Master-AXI-Side
master_if[i]->ar_in(ar_in[i]);
master_if[i]->r_out(r_out[i]);
master_if[i]->aw_in(aw_in[i]);
master_if[i]->w_in(w_in[i]);
master_if[i]->b_out(b_out[i]);
// Read-NoC
master_if[i]->rd_flit_data_out(rreq_m_chan_data[i]);
master_if[i]->rd_flit_cr_in(rreq_m_chan_cr[i]);
master_if[i]->rd_flit_data_in(rresp_m_chan_data[i]);
master_if[i]->rd_flit_cr_out(rresp_m_chan_cr[i]);
// Write-NoC
master_if[i]->wr_flit_data_out(wreq_m_chan_data[i]);
master_if[i]->wr_flit_cr_in(wreq_m_chan_cr[i]);
master_if[i]->wr_flit_data_in(wresp_m_chan_data[i]);
master_if[i]->wr_flit_cr_out(wresp_m_chan_cr[i]);
// Buffer Connectivity
// Read Request
rreq_m_buf_data[i].clk(clk);
rreq_m_buf_data[i].rst(rst_n);
rreq_m_buf_data[i].enq(rreq_m_chan_data[i]);
rreq_m_buf_data[i].deq(chan_inj_rd_data[col][row]);
rreq_m_buf_cr[i].clk(clk);
rreq_m_buf_cr[i].rst(rst_n);
rreq_m_buf_cr[i].enq(chan_inj_rd_cr[col][row]);
rreq_m_buf_cr[i].deq(rreq_m_chan_cr[i]);
// Read Response
rresp_m_buf_data[i].clk(clk);
rresp_m_buf_data[i].rst(rst_n);
rresp_m_buf_data[i].enq( chan_ej_rd_data[col][row]);
rresp_m_buf_data[i].deq(rresp_m_chan_data[i]);
rresp_m_buf_cr[i].clk(clk);
rresp_m_buf_cr[i].rst(rst_n);
rresp_m_buf_cr[i].enq(rresp_m_chan_cr[i]);
rresp_m_buf_cr[i].deq(chan_ej_rd_cr[col][row]);
// Write Request
wreq_m_buf_data[i].clk(clk);
wreq_m_buf_data[i].rst(rst_n);
wreq_m_buf_data[i].enq(wreq_m_chan_data[i]);
wreq_m_buf_data[i].deq( chan_inj_wr_data[col][row]);
wreq_m_buf_cr[i].clk(clk);
wreq_m_buf_cr[i].rst(rst_n);
wreq_m_buf_cr[i].enq(chan_inj_wr_cr[col][row]);
wreq_m_buf_cr[i].deq(wreq_m_chan_cr[i]);
// Write Response
wresp_m_buf_data[i].clk(clk);
wresp_m_buf_data[i].rst(rst_n);
wresp_m_buf_data[i].enq(chan_ej_wr_data[col][row]);
wresp_m_buf_data[i].deq(wresp_m_chan_data[i]);
wresp_m_buf_cr[i].clk(clk);
wresp_m_buf_cr[i].rst(rst_n);
wresp_m_buf_cr[i].enq(wresp_m_chan_cr[i]);
wresp_m_buf_cr[i].deq(chan_ej_wr_cr[col][row]);
}
// -o-o-o-o-o-o-o-o-o- //
// -o-o-o-o-o-o-o-o-o- //
for (int row=0; row<DIM_Y; ++row) rtr_id_y_req[row] = row;
for (int col=0; col<DIM_X; ++col) rtr_id_x_req[col] = col;
// --- NoC Connectivity --- //
// Req/Fwd Routers
for(int row=0; row<DIM_Y; ++row) {
for (int col=0; col<DIM_X; ++col) {
rtr_inst[col][row].clk(clk);
rtr_inst[col][row].rst_n(rst_n);
rtr_inst[col][row].route_lut[0](route_lut[0][0]);
rtr_inst[col][row].id_x(rtr_id_x_req[col]);
rtr_inst[col][row].id_y(rtr_id_y_req[row]);
rtr_inst[col][row].data_in[0] (chan_hor_right_data[col][row]);
rtr_inst[col][row].cr_out[0] (chan_hor_right_cr[col][row]);
rtr_inst[col][row].data_out[0](chan_hor_left_data[col][row]);
rtr_inst[col][row].cr_in[0] (chan_hor_left_cr[col][row]);
rtr_inst[col][row].data_in[1] (chan_hor_left_data[col+1][row]);
rtr_inst[col][row].cr_out[1] (chan_hor_left_cr[col+1][row]);
rtr_inst[col][row].data_out[1](chan_hor_right_data[col+1][row]);
rtr_inst[col][row].cr_in[1] (chan_hor_right_cr[col+1][row]);
rtr_inst[col][row].data_in[2] (chan_ver_up_data[col][row]);
rtr_inst[col][row].cr_out[2] (chan_ver_up_cr[col][row]);
rtr_inst[col][row].data_out[2](chan_ver_down_data[col][row]);
rtr_inst[col][row].cr_in[2] (chan_ver_down_cr[col][row]);
rtr_inst[col][row].data_in[3] (chan_ver_down_data[col][row+1]);
rtr_inst[col][row].cr_out[3] (chan_ver_down_cr[col][row+1]);
rtr_inst[col][row].data_out[3](chan_ver_up_data[col][row+1]);
rtr_inst[col][row].cr_in[3] (chan_ver_up_cr[col][row+1]);
rtr_inst[col][row].data_in[4] (chan_inj_rd_data[col][row]);
rtr_inst[col][row].cr_out[4] (chan_inj_rd_cr[col][row]);
rtr_inst[col][row].data_out[4](chan_ej_rd_data[col][row]);
rtr_inst[col][row].cr_in[4] (chan_ej_rd_cr[col][row]);
rtr_inst[col][row].data_in[5] (chan_inj_wr_data[col][row]);
rtr_inst[col][row].cr_out[5] (chan_inj_wr_cr[col][row]);
rtr_inst[col][row].data_out[5](chan_ej_wr_data[col][row]);
rtr_inst[col][row].cr_in[5] (chan_ej_wr_cr[col][row]);
}
}
}; // End of constructor
private:
}; // End of SC_MODULE
#endif // AXI4_TOP_IC_H
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.