Change function signatures to use 'using' aliases.
Also cleaned up some lingering type typedefs.
This commit is contained in:
parent
a8f4f13371
commit
93506d25e2
@ -65,12 +65,9 @@ class BlackScholes : public vtkm::worklet::WorkletMapField
|
||||
T Volatility;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Scalar>,
|
||||
FieldIn<Scalar>,
|
||||
FieldIn<Scalar>,
|
||||
FieldOut<Scalar>,
|
||||
FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ControlSignature =
|
||||
void(FieldIn<Scalar>, FieldIn<Scalar>, FieldIn<Scalar>, FieldOut<Scalar>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
|
||||
BlackScholes(T risk, T volatility)
|
||||
: Riskfree(risk)
|
||||
@ -131,8 +128,8 @@ public:
|
||||
class Mag : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T, typename U>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec, U& result) const
|
||||
@ -144,8 +141,8 @@ public:
|
||||
class Square : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Scalar>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T, typename U>
|
||||
VTKM_EXEC void operator()(T input, U& output) const
|
||||
@ -157,8 +154,8 @@ public:
|
||||
class Sin : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Scalar>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T, typename U>
|
||||
VTKM_EXEC void operator()(T input, U& output) const
|
||||
@ -170,8 +167,8 @@ public:
|
||||
class Cos : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Scalar>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Scalar>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T, typename U>
|
||||
VTKM_EXEC void operator()(T input, U& output) const
|
||||
@ -183,8 +180,8 @@ public:
|
||||
class FusedMath : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec, T& result) const
|
||||
@ -203,8 +200,8 @@ public:
|
||||
class GenerateEdges : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset, WholeArrayOut<> edgeIds);
|
||||
typedef void ExecutionSignature(PointIndices, ThreadIndices, _2);
|
||||
using ControlSignature = void(CellSetIn cellset, WholeArrayOut<> edgeIds);
|
||||
using ExecutionSignature = void(PointIndices, ThreadIndices, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename ConnectivityInVec, typename ThreadIndicesType, typename IdPairTableType>
|
||||
@ -229,11 +226,11 @@ public:
|
||||
class InterpolateField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Id2Type> interpolation_ids,
|
||||
using ControlSignature = void(FieldIn<Id2Type> interpolation_ids,
|
||||
FieldIn<Scalar> interpolation_weights,
|
||||
WholeArrayIn<> inputField,
|
||||
FieldOut<> output);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename WeightType, typename T, typename S, typename D>
|
||||
@ -262,8 +259,8 @@ template <typename ImplicitFunction>
|
||||
class EvaluateImplicitFunction : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
EvaluateImplicitFunction(const ImplicitFunction* function)
|
||||
: Function(function)
|
||||
@ -284,8 +281,8 @@ template <typename T1, typename T2>
|
||||
class Evaluate2ImplicitFunctions : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
Evaluate2ImplicitFunctions(const T1* f1, const T2* f2)
|
||||
: Function1(f1)
|
||||
|
@ -55,10 +55,10 @@ enum BenchmarkName
|
||||
class AveragePointToCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldInPoint<> inPoints,
|
||||
using ControlSignature = void(FieldInPoint<> inPoints,
|
||||
CellSetIn cellset,
|
||||
FieldOutCell<> outCells);
|
||||
typedef void ExecutionSignature(_1, PointCount, _3);
|
||||
using ExecutionSignature = void(_1, PointCount, _3);
|
||||
using InputDomain = _2;
|
||||
|
||||
template <typename PointValueVecType, typename OutType>
|
||||
@ -79,8 +79,8 @@ public:
|
||||
class AverageCellToPoint : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldInCell<> inCells, CellSetIn topology, FieldOut<> outPoints);
|
||||
typedef void ExecutionSignature(_1, _3, CellCount);
|
||||
using ControlSignature = void(FieldInCell<> inCells, CellSetIn topology, FieldOut<> outPoints);
|
||||
using ExecutionSignature = void(_1, _3, CellCount);
|
||||
using InputDomain = _2;
|
||||
|
||||
template <typename CellVecType, typename OutType>
|
||||
@ -106,10 +106,10 @@ template <typename T>
|
||||
class Classification : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldInPoint<> inNodes,
|
||||
using ControlSignature = void(FieldInPoint<> inNodes,
|
||||
CellSetIn cellset,
|
||||
FieldOutCell<IdComponentType> outCaseId);
|
||||
typedef void ExecutionSignature(_1, _3);
|
||||
using ExecutionSignature = void(_1, _3);
|
||||
using InputDomain = _2;
|
||||
|
||||
T IsoValue;
|
||||
|
@ -31,13 +31,9 @@
|
||||
|
||||
struct ExampleFieldWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
|
||||
using ControlSignature =
|
||||
void(FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, FieldOut<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
|
||||
|
||||
template <typename T, typename U, typename V>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec,
|
||||
|
@ -78,12 +78,12 @@ struct UpdateLifeState : public vtkm::worklet::WorkletPointNeighborhood3x3x3
|
||||
{
|
||||
using CountingHandle = vtkm::cont::ArrayHandleCounting<vtkm::Id>;
|
||||
|
||||
typedef void ControlSignature(CellSetIn,
|
||||
using ControlSignature = void(CellSetIn,
|
||||
FieldInNeighborhood<> prevstate,
|
||||
FieldOut<> state,
|
||||
FieldOut<> color);
|
||||
|
||||
typedef void ExecutionSignature(_2, _3, _4);
|
||||
using ExecutionSignature = void(_2, _3, _4);
|
||||
|
||||
template <typename NeighIn>
|
||||
VTKM_EXEC void operator()(const NeighIn& prevstate,
|
||||
|
@ -144,8 +144,8 @@ struct HelloVTKMInterop
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Vec<T, 3>& input,
|
||||
|
@ -62,8 +62,8 @@ namespace
|
||||
class TangleField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
const vtkm::Id xdim, ydim, zdim;
|
||||
|
@ -34,8 +34,8 @@
|
||||
|
||||
struct WaveField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Vec3>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Vec3>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& input, vtkm::Vec<T, 3>& output) const
|
||||
|
@ -69,8 +69,8 @@ using DeviceAdapter = VTKM_DEFAULT_DEVICE_ADAPTER_TAG;
|
||||
class TangleField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
const vtkm::Id xdim, ydim, zdim;
|
||||
|
@ -39,8 +39,8 @@ namespace
|
||||
class TangleField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
const vtkm::Id xdim, ydim, zdim;
|
||||
@ -126,8 +126,8 @@ namespace worklet
|
||||
class SineWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef _2 ExecutionSignature(_1, WorkIndex);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = _2(_1, WorkIndex);
|
||||
|
||||
VTKM_EXEC
|
||||
vtkm::Float32 operator()(vtkm::Int64 x, vtkm::Id&) const
|
||||
|
@ -77,12 +77,12 @@ public:
|
||||
DIM>;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3> points,
|
||||
using ControlSignature = void(FieldIn<Vec3> points,
|
||||
WholeCellSetIn<> cellSet,
|
||||
WholeArrayIn<Vec3> coordinates,
|
||||
FieldOut<IdType> cellIds,
|
||||
FieldOut<Vec3> parametricCoordinates);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
|
||||
template <typename CoordsPortalType, vtkm::IdComponent DIM>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<vtkm::FloatDefault, 3>& point,
|
||||
|
@ -282,10 +282,10 @@ public:
|
||||
class CountBinsL1 : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coords,
|
||||
FieldOutCell<IdType> bincount);
|
||||
typedef void ExecutionSignature(_2, _3);
|
||||
using ExecutionSignature = void(_2, _3);
|
||||
|
||||
CountBinsL1(const Grid& grid)
|
||||
: L1Grid(grid)
|
||||
@ -307,11 +307,11 @@ public:
|
||||
class FindBinsL1 : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coords,
|
||||
FieldInCell<IdType> offsets,
|
||||
WholeArrayOut<IdType> binIds);
|
||||
typedef void ExecutionSignature(_2, _3, _4);
|
||||
using ExecutionSignature = void(_2, _3, _4);
|
||||
|
||||
FindBinsL1(const Grid& grid)
|
||||
: L1Grid(grid)
|
||||
@ -340,10 +340,10 @@ public:
|
||||
class GenerateBinsL1 : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> binIds,
|
||||
using ControlSignature = void(FieldIn<IdType> binIds,
|
||||
FieldIn<IdType> cellCounts,
|
||||
WholeArrayOut<vtkm::ListTagBase<DimVec3>> dimensions);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
using InputDomain = _1;
|
||||
|
||||
@ -369,11 +369,11 @@ public:
|
||||
class CountBinsL2 : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coords,
|
||||
WholeArrayIn<vtkm::ListTagBase<DimVec3>> binDimensions,
|
||||
FieldOutCell<IdType> bincount);
|
||||
typedef void ExecutionSignature(_2, _3, _4);
|
||||
using ExecutionSignature = void(_2, _3, _4);
|
||||
|
||||
CountBinsL2(const Grid& grid)
|
||||
: L1Grid(grid)
|
||||
@ -404,14 +404,14 @@ public:
|
||||
class FindBinsL2 : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coords,
|
||||
WholeArrayIn<vtkm::ListTagBase<DimVec3>> binDimensions,
|
||||
WholeArrayIn<IdType> binStarts,
|
||||
FieldInCell<IdType> offsets,
|
||||
WholeArrayOut<IdType> binIds,
|
||||
WholeArrayOut<IdType> cellIds);
|
||||
typedef void ExecutionSignature(InputIndex, _2, _3, _4, _5, _6, _7);
|
||||
using ExecutionSignature = void(InputIndex, _2, _3, _4, _5, _6, _7);
|
||||
|
||||
FindBinsL2(const Grid& grid)
|
||||
: L1Grid(grid)
|
||||
@ -456,12 +456,12 @@ public:
|
||||
class GenerateBinsL2 : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> binIds,
|
||||
using ControlSignature = void(FieldIn<IdType> binIds,
|
||||
FieldIn<IdType> startsIn,
|
||||
FieldIn<IdType> countsIn,
|
||||
WholeArrayOut<IdType> startsOut,
|
||||
WholeArrayOut<IdType> countsOut);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
|
||||
using InputDomain = _1;
|
||||
|
||||
@ -639,13 +639,13 @@ public:
|
||||
class FindCellWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3> points,
|
||||
using ControlSignature = void(FieldIn<Vec3> points,
|
||||
WholeCellSetIn<> cellSet,
|
||||
WholeArrayIn<Vec3> coordinates,
|
||||
ExecObject lookupStruct,
|
||||
FieldOut<IdType> cellIds,
|
||||
FieldOut<Vec3> parametricCoordinates);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
|
||||
|
||||
using InputDomain = _1;
|
||||
|
||||
|
@ -46,10 +46,10 @@ namespace internal
|
||||
|
||||
struct WriteConnectivity : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInCell<IdType> offset,
|
||||
WholeArrayOut<> connectivity);
|
||||
typedef void ExecutionSignature(PointCount, PointIndices, _2, _3);
|
||||
using ExecutionSignature = void(PointCount, PointIndices, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename PointIndicesType, typename OutPortalType>
|
||||
|
@ -46,9 +46,9 @@ public:
|
||||
class BinPointsWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> coord, FieldOut<> label);
|
||||
using ControlSignature = void(FieldIn<> coord, FieldOut<> label);
|
||||
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
VTKM_CONT
|
||||
BinPointsWorklet(vtkm::Vec<T, 3> _min, vtkm::Vec<T, 3> _max, vtkm::Vec<vtkm::Id, 3> _dims)
|
||||
@ -74,7 +74,7 @@ public:
|
||||
class UniformGridSearch : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> query,
|
||||
using ControlSignature = void(FieldIn<> query,
|
||||
WholeArrayIn<> coordIn,
|
||||
WholeArrayIn<IdType> pointId,
|
||||
WholeArrayIn<IdType> cellLower,
|
||||
@ -82,7 +82,7 @@ public:
|
||||
FieldOut<IdType> neighborId,
|
||||
FieldOut<> distance);
|
||||
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7);
|
||||
|
||||
VTKM_CONT
|
||||
UniformGridSearch(const vtkm::Vec<T, 3>& _min,
|
||||
|
@ -176,11 +176,11 @@ struct ConnectivityExplicitInternals
|
||||
class ExpandIndices : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> cellIndex,
|
||||
using ControlSignature = void(FieldIn<> cellIndex,
|
||||
FieldIn<> offset,
|
||||
FieldIn<> numIndices,
|
||||
WholeArrayOut<> cellIndices);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_CONT
|
||||
@ -204,8 +204,8 @@ public:
|
||||
class ScatterValues : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> index, FieldIn<> value, WholeArrayOut<> output);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<> index, FieldIn<> value, WholeArrayOut<> output);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename T, typename PortalType>
|
||||
|
@ -488,7 +488,7 @@ void ParallelRadixSortInternal<PlainType, CompareType, UnsignedType, Encoder, Va
|
||||
}
|
||||
};
|
||||
|
||||
typedef RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>> RunTaskType;
|
||||
using RunTaskType = RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>>;
|
||||
|
||||
RunTaskType& root =
|
||||
*new (::tbb::task::allocate_root()) RunTaskType(0, 1, lambda, num_elems_, num_threads_);
|
||||
@ -563,7 +563,7 @@ void ParallelRadixSortInternal<PlainType, CompareType, UnsignedType, Encoder, Va
|
||||
}
|
||||
};
|
||||
|
||||
typedef RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>> RunTaskType;
|
||||
using RunTaskType = RunTask<PlainType, UnsignedType, Encoder, Base, std::function<void(size_t)>>;
|
||||
|
||||
RunTaskType& root =
|
||||
*new (::tbb::task::allocate_root()) RunTaskType(0, 1, lambda, num_elems_, num_threads_);
|
||||
|
@ -39,8 +39,8 @@ namespace
|
||||
|
||||
struct CopyWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<FieldCommon> in, FieldOut<FieldCommon> out);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldIn<FieldCommon> in, FieldOut<FieldCommon> out);
|
||||
using ExecutionSignature = _2(_1);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC T operator()(const T& in) const
|
||||
|
@ -90,8 +90,8 @@ struct TestingArrayHandles
|
||||
|
||||
struct PassThrough : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = _2(_1);
|
||||
|
||||
template <class ValueType>
|
||||
VTKM_EXEC ValueType operator()(const ValueType& inValue) const
|
||||
|
@ -47,11 +47,11 @@ std::default_random_engine RandomGenerator;
|
||||
class ParametricToWorldCoordinates : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coords,
|
||||
FieldInOutCell<Vec3> pcs,
|
||||
FieldOutCell<Vec3> wcs);
|
||||
typedef void ExecutionSignature(CellShape, _2, _3, _4);
|
||||
using ExecutionSignature = void(CellShape, _2, _3, _4);
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterPermutation<>;
|
||||
|
||||
|
@ -145,8 +145,8 @@ public:
|
||||
struct ClearArrayMapKernel //: public vtkm::exec::WorkletMapField
|
||||
{
|
||||
|
||||
// typedef void ControlSignature(Field(Out));
|
||||
// typedef void ExecutionSignature(_1);
|
||||
// using ControlSignature = void(Field(Out));
|
||||
// using ExecutionSignature = void(_1);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC void operator()(T& value) const
|
||||
|
@ -123,8 +123,8 @@ private:
|
||||
public:
|
||||
struct PassThrough : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = _2(_1);
|
||||
|
||||
template <class ValueType>
|
||||
VTKM_EXEC ValueType operator()(const ValueType& inValue) const
|
||||
@ -135,8 +135,8 @@ public:
|
||||
|
||||
struct InplaceFunctorPair : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldInOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC void operator()(vtkm::Pair<T, T>& value) const
|
||||
@ -604,8 +604,8 @@ private:
|
||||
// worklets.
|
||||
struct GroupVariableInputWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, WorkIndex);
|
||||
using ControlSignature = void(FieldIn<>);
|
||||
using ExecutionSignature = void(_1, WorkIndex);
|
||||
|
||||
template <typename InputType>
|
||||
VTKM_EXEC void operator()(const InputType& input, vtkm::Id workIndex) const
|
||||
@ -659,8 +659,8 @@ private:
|
||||
// worklets.
|
||||
struct GroupVariableOutputWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_2, WorkIndex);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_2, WorkIndex);
|
||||
|
||||
template <typename OutputType>
|
||||
VTKM_EXEC void operator()(OutputType& output, vtkm::Id workIndex) const
|
||||
|
@ -47,8 +47,8 @@ namespace implicit_function_detail
|
||||
class EvaluateImplicitFunction : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
EvaluateImplicitFunction(const vtkm::ImplicitFunction* function)
|
||||
: Function(function)
|
||||
|
@ -54,11 +54,11 @@ VTKM_EXEC_CONT vtkm::Id NNSVerify3D(CoordiVecT qc, CoordiPortalT coordiPortal, C
|
||||
class NearestNeighborSearchBruteForce3DWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> qcIn,
|
||||
using ControlSignature = void(FieldIn<> qcIn,
|
||||
WholeArrayIn<> treeCoordiIn,
|
||||
FieldOut<> nnIdOut,
|
||||
FieldOut<> nnDisOut);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4);
|
||||
|
||||
VTKM_CONT
|
||||
NearestNeighborSearchBruteForce3DWorklet() {}
|
||||
|
@ -74,8 +74,8 @@ vtkm::cont::CellSetExplicit<> MakeTestCellSet2()
|
||||
|
||||
struct WorkletPointToCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldOutCell<IdType> numPoints);
|
||||
typedef void ExecutionSignature(PointIndices, _2);
|
||||
using ControlSignature = void(CellSetIn cellset, FieldOutCell<IdType> numPoints);
|
||||
using ExecutionSignature = void(PointIndices, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename PointIndicesType>
|
||||
@ -87,8 +87,8 @@ struct WorkletPointToCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
|
||||
struct WorkletCellToPoint : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldOutPoint<IdType> numCells);
|
||||
typedef void ExecutionSignature(CellIndices, _2);
|
||||
using ControlSignature = void(CellSetIn cellset, FieldOutPoint<IdType> numCells);
|
||||
using ExecutionSignature = void(CellIndices, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellIndicesType>
|
||||
|
@ -32,8 +32,8 @@ namespace
|
||||
|
||||
struct WorkletPointToCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldOutCell<IdType> numPoints);
|
||||
typedef void ExecutionSignature(PointIndices, _2);
|
||||
using ControlSignature = void(CellSetIn cellset, FieldOutCell<IdType> numPoints);
|
||||
using ExecutionSignature = void(PointIndices, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename PointIndicesType>
|
||||
@ -45,8 +45,8 @@ struct WorkletPointToCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
|
||||
struct WorkletCellToPoint : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldOutPoint<IdType> numCells);
|
||||
typedef void ExecutionSignature(CellIndices, _2);
|
||||
using ControlSignature = void(CellSetIn cellset, FieldOutPoint<IdType> numCells);
|
||||
using ExecutionSignature = void(CellIndices, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellIndicesType>
|
||||
@ -58,10 +58,10 @@ struct WorkletCellToPoint : public vtkm::worklet::WorkletMapCellToPoint
|
||||
|
||||
struct CellsOfPoint : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<IdType> offset,
|
||||
WholeArrayOut<IdType> cellIds);
|
||||
typedef void ExecutionSignature(CellIndices, _2, _3);
|
||||
using ExecutionSignature = void(CellIndices, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellIndicesType, typename CellIdsPortal>
|
||||
|
@ -105,12 +105,11 @@ struct FetchArrayTopologyMapInTests
|
||||
std::cout << "Trying ArrayTopologyMapIn fetch on parameter " << ParamIndex << " with type "
|
||||
<< vtkm::testing::TypeName<T>::Name() << std::endl;
|
||||
|
||||
typedef vtkm::internal::FunctionInterface<void(vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType)>
|
||||
BaseFunctionInterface;
|
||||
using BaseFunctionInterface = vtkm::internal::FunctionInterface<void(vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType)>;
|
||||
|
||||
vtkm::internal::ConnectivityStructuredInternals<3> connectivityInternals;
|
||||
connectivityInternals.SetPointDimensions(vtkm::Id3(2, 2, 2));
|
||||
@ -181,12 +180,11 @@ void TryStructuredPointCoordinates(
|
||||
NumDimensions>& connectivity,
|
||||
const vtkm::internal::ArrayPortalUniformPointCoordinates& coordinates)
|
||||
{
|
||||
typedef vtkm::internal::FunctionInterface<void(vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType)>
|
||||
BaseFunctionInterface;
|
||||
using BaseFunctionInterface = vtkm::internal::FunctionInterface<void(vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType,
|
||||
vtkm::internal::NullType)>;
|
||||
|
||||
// Try with topology in argument 1 and point coordinates in argument 2
|
||||
TryStructuredPointCoordinatesInvocation<NumDimensions, 2>(vtkm::internal::make_Invocation<1>(
|
||||
|
@ -152,17 +152,17 @@ struct Fetch<TestFetchTagOutput,
|
||||
namespace
|
||||
{
|
||||
|
||||
typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlSignature = void(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlInterface = vtkm::internal::FunctionInterface<TestControlSignature>;
|
||||
|
||||
typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionSignature1 = void(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionInterface1 = vtkm::internal::FunctionInterface<TestExecutionSignature1>;
|
||||
|
||||
typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionSignature2 = vtkm::exec::arg::BasicArg<2>(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionInterface2 = vtkm::internal::FunctionInterface<TestExecutionSignature2>;
|
||||
|
||||
typedef vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>
|
||||
ExecutionParameterInterface;
|
||||
using ExecutionParameterInterface =
|
||||
vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>;
|
||||
|
||||
using InvocationType1 = vtkm::internal::Invocation<ExecutionParameterInterface,
|
||||
TestControlInterface,
|
||||
|
@ -160,13 +160,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -278,13 +278,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -418,13 +418,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -580,13 +580,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -764,13 +764,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -970,13 +970,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -1198,13 +1198,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -1448,13 +1448,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -1720,13 +1720,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -2014,13 +2014,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -2330,13 +2330,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -2668,13 +2668,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -3028,13 +3028,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -3410,13 +3410,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -3814,13 +3814,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -4240,13 +4240,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -4688,13 +4688,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -5158,13 +5158,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -5650,13 +5650,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
@ -6164,13 +6164,13 @@ VTKM_EXEC void DoWorkletInvokeFunctor(
|
||||
VisitArrayType>& invocation,
|
||||
const ThreadIndicesType& threadIndices)
|
||||
{
|
||||
typedef vtkm::internal::Invocation<ParameterInterface,
|
||||
using Invocation = vtkm::internal::Invocation<ParameterInterface,
|
||||
ControlInterface,
|
||||
vtkm::internal::FunctionInterface<void(P1, P2, P3, P4, P5, P6, P7, P8, P9, P10, P11, P12, P13, P14, P15, P16, P17, P18, P19, P20)>,
|
||||
InputDomainIndex,
|
||||
OutputToInputMapType,
|
||||
VisitArrayType>
|
||||
Invocation;
|
||||
;
|
||||
|
||||
using FetchInfo1 = InvocationToFetch<ThreadIndicesType, Invocation, 1>;
|
||||
using FetchType1 = typename FetchInfo1::type;
|
||||
|
@ -164,17 +164,17 @@ namespace internal
|
||||
namespace testing
|
||||
{
|
||||
|
||||
typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlSignature = void(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlInterface = vtkm::internal::FunctionInterface<TestControlSignature>;
|
||||
|
||||
typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionSignature1 = void(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionInterface1 = vtkm::internal::FunctionInterface<TestExecutionSignature1>;
|
||||
|
||||
typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionSignature2 = vtkm::exec::arg::BasicArg<2>(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionInterface2 = vtkm::internal::FunctionInterface<TestExecutionSignature2>;
|
||||
|
||||
typedef vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>
|
||||
ExecutionParameterInterface;
|
||||
using ExecutionParameterInterface =
|
||||
vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>;
|
||||
|
||||
using InvocationType1 = vtkm::internal::Invocation<ExecutionParameterInterface,
|
||||
TestControlInterface,
|
||||
|
@ -142,17 +142,17 @@ struct Fetch<TestFetchTagOutput,
|
||||
namespace
|
||||
{
|
||||
|
||||
typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlSignature = void(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlInterface = vtkm::internal::FunctionInterface<TestControlSignature>;
|
||||
|
||||
typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionSignature1 = void(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionInterface1 = vtkm::internal::FunctionInterface<TestExecutionSignature1>;
|
||||
|
||||
typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionSignature2 = vtkm::exec::arg::BasicArg<2>(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionInterface2 = vtkm::internal::FunctionInterface<TestExecutionSignature2>;
|
||||
|
||||
typedef vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>
|
||||
ExecutionParameterInterface;
|
||||
using ExecutionParameterInterface =
|
||||
vtkm::internal::FunctionInterface<void(TestExecObject, TestExecObject)>;
|
||||
|
||||
using InvocationType1 = vtkm::internal::Invocation<ExecutionParameterInterface,
|
||||
TestControlInterface,
|
||||
|
@ -142,13 +142,13 @@ struct Fetch<TestFetchTagOutput,
|
||||
namespace
|
||||
{
|
||||
|
||||
typedef void TestControlSignature(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlSignature = void(TestControlSignatureTagInput, TestControlSignatureTagOutput);
|
||||
using TestControlInterface = vtkm::internal::FunctionInterface<TestControlSignature>;
|
||||
|
||||
typedef void TestExecutionSignature1(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionSignature1 = void(vtkm::exec::arg::BasicArg<1>, vtkm::exec::arg::BasicArg<2>);
|
||||
using TestExecutionInterface1 = vtkm::internal::FunctionInterface<TestExecutionSignature1>;
|
||||
|
||||
typedef vtkm::exec::arg::BasicArg<2> TestExecutionSignature2(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionSignature2 = vtkm::exec::arg::BasicArg<2>(vtkm::exec::arg::BasicArg<1>);
|
||||
using TestExecutionInterface2 = vtkm::internal::FunctionInterface<TestExecutionSignature2>;
|
||||
|
||||
// Not a full worklet, but provides operators that we expect in a worklet.
|
||||
|
@ -155,7 +155,7 @@ template <>
|
||||
class FilterTraits<CrossProduct>
|
||||
{ //currently the CrossProduct filter only works on vector data.
|
||||
public:
|
||||
typedef TypeListTagVecCommon InputFieldTypeList;
|
||||
using InputFieldTypeList = TypeListTagVecCommon;
|
||||
};
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
@ -155,7 +155,7 @@ template <>
|
||||
class FilterTraits<DotProduct>
|
||||
{ //currently the DotProduct filter only works on vector data.
|
||||
public:
|
||||
typedef TypeListTagVecCommon InputFieldTypeList;
|
||||
using InputFieldTypeList = TypeListTagVecCommon;
|
||||
};
|
||||
}
|
||||
} // namespace vtkm::filter
|
||||
|
@ -31,8 +31,8 @@ namespace
|
||||
class TangleField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
const vtkm::Id xdim, ydim, zdim;
|
||||
|
@ -35,8 +35,8 @@ namespace vtkm_ut_mc_filter
|
||||
class TangleField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<IdType> vertexId, FieldOut<Scalar> v);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
const vtkm::Id xdim, ydim, zdim;
|
||||
|
@ -776,7 +776,7 @@ public:
|
||||
|
||||
static constexpr std::size_t newArity = NextInterfaceType::ARITY;
|
||||
static constexpr std::size_t oldArity = detail::FunctionSigInfo<OriginalFunction>::Arity;
|
||||
typedef std::integral_constant<bool, (newArity < oldArity)> ShouldDoNextTransformType;
|
||||
using ShouldDoNextTransformType = std::integral_constant<bool, (newArity < oldArity)>;
|
||||
|
||||
NextInterfaceType nextInterface = this->NewInterface.Append(newParameter);
|
||||
|
||||
|
@ -50,7 +50,7 @@ template<typename Transform,
|
||||
typename R>
|
||||
struct FunctionInterfaceStaticTransformType<R(), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
);
|
||||
};
|
||||
|
||||
@ -59,7 +59,7 @@ template<typename Transform,
|
||||
typename P1>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type
|
||||
);
|
||||
};
|
||||
@ -70,7 +70,7 @@ template<typename Transform,
|
||||
typename P2>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type
|
||||
);
|
||||
@ -83,7 +83,7 @@ template<typename Transform,
|
||||
typename P3>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type
|
||||
@ -98,7 +98,7 @@ template<typename Transform,
|
||||
typename P4>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -115,7 +115,7 @@ template<typename Transform,
|
||||
typename P5>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -134,7 +134,7 @@ template<typename Transform,
|
||||
typename P6>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -155,7 +155,7 @@ template<typename Transform,
|
||||
typename P7>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -178,7 +178,7 @@ template<typename Transform,
|
||||
typename P8>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -203,7 +203,7 @@ template<typename Transform,
|
||||
typename P9>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -230,7 +230,7 @@ template<typename Transform,
|
||||
typename P10>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -259,7 +259,7 @@ template<typename Transform,
|
||||
typename P11>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -290,7 +290,7 @@ template<typename Transform,
|
||||
typename P12>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -323,7 +323,7 @@ template<typename Transform,
|
||||
typename P13>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -358,7 +358,7 @@ template<typename Transform,
|
||||
typename P14>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -395,7 +395,7 @@ template<typename Transform,
|
||||
typename P15>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -434,7 +434,7 @@ template<typename Transform,
|
||||
typename P16>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -475,7 +475,7 @@ template<typename Transform,
|
||||
typename P17>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -518,7 +518,7 @@ template<typename Transform,
|
||||
typename P18>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -563,7 +563,7 @@ template<typename Transform,
|
||||
typename P19>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
@ -610,7 +610,7 @@ template<typename Transform,
|
||||
typename P20>
|
||||
struct FunctionInterfaceStaticTransformType<R(P1,P2,P3,P4,P5,P6,P7,P8,P9,P10,P11,P12,P13,P14,P15,P16,P17,P18,P19,P20), Transform>
|
||||
{
|
||||
typedef R(type)(
|
||||
using type = R(
|
||||
typename Transform::template ReturnType<P1,1>::type,
|
||||
typename Transform::template ReturnType<P2,2>::type,
|
||||
typename Transform::template ReturnType<P3,3>::type,
|
||||
|
@ -98,7 +98,7 @@ template<typename Transform,
|
||||
$template_params(num_params)>
|
||||
struct FunctionInterfaceStaticTransformType<$signature(num_params), Transform>
|
||||
{
|
||||
typedef $ptype(0)(type)(
|
||||
using type = $ptype(0)(
|
||||
$for(param_index in xrange(1, num_params+1))\
|
||||
typename Transform::template ReturnType<$ptype(param_index),$(param_index)>::type$comma_if(param_index<num_params)
|
||||
$endfor\
|
||||
|
@ -669,7 +669,7 @@ struct AppendType;
|
||||
template <template <typename...> class L, typename T, typename NT, typename... U>
|
||||
struct AppendType<L<T, U...>, NT>
|
||||
{
|
||||
typedef T type(U..., NT);
|
||||
using type = T(U..., NT);
|
||||
};
|
||||
|
||||
template <typename Collection>
|
||||
@ -677,7 +677,7 @@ struct AsSigType;
|
||||
template <template <typename...> class L, typename T, typename... U>
|
||||
struct AsSigType<L<T, U...>>
|
||||
{
|
||||
typedef T type(U...);
|
||||
using type = T(U...);
|
||||
};
|
||||
|
||||
template <typename Components, vtkm::IdComponent ParameterIndex, typename NewType>
|
||||
|
@ -160,7 +160,7 @@ struct AppendType;
|
||||
template <template <typename...> class L, typename T, typename NT, typename... U>
|
||||
struct AppendType<L<T, U...>, NT>
|
||||
{
|
||||
typedef T type(U..., NT);
|
||||
using type = T(U..., NT);
|
||||
};
|
||||
|
||||
template <typename Collection>
|
||||
@ -168,7 +168,7 @@ struct AsSigType;
|
||||
template <template <typename...> class L, typename T, typename... U>
|
||||
struct AsSigType<L<T, U...>>
|
||||
{
|
||||
typedef T type(U...);
|
||||
using type = T(U...);
|
||||
};
|
||||
|
||||
template <typename Components, vtkm::IdComponent ParameterIndex, typename NewType>
|
||||
|
@ -401,7 +401,7 @@ void TestTransformInvoke()
|
||||
void TestStaticTransform()
|
||||
{
|
||||
std::cout << "Trying static transform." << std::endl;
|
||||
typedef vtkm::internal::FunctionInterface<void(Type1, Type2, Type3)> OriginalType;
|
||||
using OriginalType = vtkm::internal::FunctionInterface<void(Type1, Type2, Type3)>;
|
||||
OriginalType funcInterface = vtkm::internal::make_FunctionInterface<void>(Arg1, Arg2, Arg3);
|
||||
|
||||
std::cout << "Transform with reported type." << std::endl;
|
||||
|
@ -42,8 +42,8 @@ namespace internal
|
||||
|
||||
struct ClearBuffers : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldOut<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldOut<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
VTKM_CONT
|
||||
ClearBuffers() {}
|
||||
@ -63,8 +63,8 @@ struct ClearBuffers : public vtkm::worklet::WorkletMapField
|
||||
|
||||
struct ClearBuffersExecutor
|
||||
{
|
||||
typedef vtkm::rendering::Canvas::ColorBufferType ColorBufferType;
|
||||
typedef vtkm::rendering::Canvas::DepthBufferType DepthBufferType;
|
||||
using ColorBufferType = vtkm::rendering::Canvas::ColorBufferType;
|
||||
using DepthBufferType = vtkm::rendering::Canvas::DepthBufferType;
|
||||
|
||||
ColorBufferType ColorBuffer;
|
||||
DepthBufferType DepthBuffer;
|
||||
@ -98,8 +98,8 @@ struct BlendBackground : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldInOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
|
||||
VTKM_EXEC void operator()(vtkm::Vec<vtkm::Float32, 4>& color) const
|
||||
{
|
||||
@ -116,7 +116,7 @@ struct BlendBackground : public vtkm::worklet::WorkletMapField
|
||||
|
||||
struct BlendBackgroundExecutor
|
||||
{
|
||||
typedef vtkm::rendering::Canvas::ColorBufferType ColorBufferType;
|
||||
using ColorBufferType = vtkm::rendering::Canvas::ColorBufferType;
|
||||
|
||||
ColorBufferType ColorBuffer;
|
||||
BlendBackground Worklet;
|
||||
@ -142,8 +142,8 @@ struct BlendBackgroundExecutor
|
||||
|
||||
struct DrawColorSwatch : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayInOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
VTKM_CONT
|
||||
DrawColorSwatch(vtkm::Id2 dims,
|
||||
@ -185,8 +185,8 @@ struct DrawColorSwatch : public vtkm::worklet::WorkletMapField
|
||||
|
||||
struct DrawColorBar : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayInOut<>, WholeArrayIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayInOut<>, WholeArrayIn<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
VTKM_CONT
|
||||
DrawColorBar(vtkm::Id2 dims, vtkm::Id2 xBounds, vtkm::Id2 yBounds, bool horizontal)
|
||||
|
@ -45,14 +45,14 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
WholeArrayInOut<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
WholeArrayOut<vtkm::ListTagBase<vtkm::Float32>>,
|
||||
WholeArrayOut<vtkm::ListTagBase<vtkm::Vec<vtkm::Float32, 4>>>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, WorkIndex);
|
||||
template <typename Precision,
|
||||
typename ColorPortalType,
|
||||
typename DepthBufferPortalType,
|
||||
|
@ -34,8 +34,8 @@ namespace rendering
|
||||
struct ConnectivityProxy::InternalsType
|
||||
{
|
||||
protected:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorMapType;
|
||||
typedef vtkm::rendering::raytracing::ConnectivityBase BaseType;
|
||||
using ColorMapType = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using BaseType = vtkm::rendering::raytracing::ConnectivityBase;
|
||||
|
||||
BaseType* Tracer;
|
||||
vtkm::cont::Field ScalarField;
|
||||
|
@ -42,7 +42,7 @@ namespace
|
||||
struct TypeListTagId4 : vtkm::ListTagBase<vtkm::Vec<Id, 4>>
|
||||
{
|
||||
};
|
||||
typedef TypeListTagId4 Id4Type;
|
||||
using Id4Type = TypeListTagId4;
|
||||
|
||||
class MapColorAndVertices : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
@ -59,13 +59,13 @@ public:
|
||||
, SDiff(sDiff)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<IdType> vertexId,
|
||||
using ControlSignature = void(FieldIn<IdType> vertexId,
|
||||
WholeArrayIn<Id4Type> indices,
|
||||
WholeArrayIn<Scalar> scalar,
|
||||
WholeArrayIn<Vec3> verts,
|
||||
WholeArrayOut<Scalar> out_color,
|
||||
WholeArrayOut<Scalar> out_vertices);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
|
||||
|
||||
template <typename InputArrayIndexPortalType,
|
||||
typename InputArrayPortalType,
|
||||
|
@ -47,9 +47,9 @@ public:
|
||||
VTKM_CONT
|
||||
CreateConnectivity() {}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayOut<>);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayOut<>);
|
||||
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename ConnPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Id& i, ConnPortalType& connPortal) const
|
||||
@ -88,12 +88,12 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<vtkm::TypeListTagScalarAll>,
|
||||
FieldOut<>,
|
||||
FieldOut<>);
|
||||
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4);
|
||||
template <typename ScalarType>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<vtkm::Float32, 3>& inCoord,
|
||||
const ScalarType& scalar,
|
||||
@ -149,8 +149,8 @@ struct ConvertFunctor
|
||||
#endif
|
||||
struct EdgesCounter : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellSet, FieldOutCell<> numEdges);
|
||||
typedef _2 ExecutionSignature(CellShape shape, PointCount numPoints);
|
||||
using ControlSignature = void(CellSetIn cellSet, FieldOutCell<> numEdges);
|
||||
using ExecutionSignature = _2(CellShape shape, PointCount numPoints);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellShapeTag>
|
||||
@ -170,8 +170,8 @@ struct EdgesCounter : public vtkm::worklet::WorkletMapPointToCell
|
||||
|
||||
struct EdgesExtracter : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellSet, FieldOutCell<> edgeIndices);
|
||||
typedef void ExecutionSignature(CellShape, PointIndices, VisitIndex, _2);
|
||||
using ControlSignature = void(CellSetIn cellSet, FieldOutCell<> edgeIndices);
|
||||
using ExecutionSignature = void(CellShape, PointIndices, VisitIndex, _2);
|
||||
using InputDomain = _1;
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
|
||||
|
@ -38,12 +38,9 @@ struct RenderBitmapFont : public vtkm::worklet::WorkletMapField
|
||||
using DepthBufferType = vtkm::rendering::Canvas::DepthBufferType;
|
||||
using FontTextureType = vtkm::rendering::Canvas::FontTextureType;
|
||||
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
FieldIn<>,
|
||||
ExecObject,
|
||||
WholeArrayInOut<>,
|
||||
WholeArrayInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ControlSignature =
|
||||
void(FieldIn<>, FieldIn<>, ExecObject, WholeArrayInOut<>, WholeArrayInOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_CONT
|
||||
|
@ -43,10 +43,10 @@ template <typename Device>
|
||||
class Triangulator
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Id> IdArrayHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Vec4ArrayHandle;
|
||||
typedef typename Vec4ArrayHandle::ExecutionTypes<Device>::Portal Vec4ArrayPortalType;
|
||||
typedef typename IdArrayHandle::ExecutionTypes<Device>::PortalConst IdPortalConstType;
|
||||
using IdArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using Vec4ArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
using Vec4ArrayPortalType = typename Vec4ArrayHandle::ExecutionTypes<Device>::Portal;
|
||||
using IdPortalConstType = typename IdArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
public:
|
||||
template <class T>
|
||||
@ -60,8 +60,8 @@ public:
|
||||
: Value(value)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
VTKM_EXEC
|
||||
void operator()(T& outValue) const { outValue = Value; }
|
||||
}; //class MemSet
|
||||
@ -71,8 +71,8 @@ public:
|
||||
public:
|
||||
VTKM_CONT
|
||||
CountTriangles() {}
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldOut<>);
|
||||
typedef void ExecutionSignature(CellShape, _2);
|
||||
using ControlSignature = void(CellSetIn cellset, FieldOut<>);
|
||||
using ExecutionSignature = void(CellShape, _2);
|
||||
|
||||
VTKM_EXEC
|
||||
void operator()(vtkm::CellShapeTagGeneric shapeType, vtkm::Id& triangles) const
|
||||
@ -113,9 +113,9 @@ public:
|
||||
Vec4ArrayPortalType OutputIndices;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldInTo<>);
|
||||
typedef void ExecutionSignature(FromIndices, _2);
|
||||
//typedef _1 InputDomain;
|
||||
using ControlSignature = void(CellSetIn cellset, FieldInTo<>);
|
||||
using ExecutionSignature = void(FromIndices, _2);
|
||||
//using InputDomain = _1;
|
||||
VTKM_CONT
|
||||
TrianglulateStructured(vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>& outputIndices)
|
||||
{
|
||||
@ -222,8 +222,8 @@ public:
|
||||
public:
|
||||
VTKM_CONT
|
||||
IndicesSort() {}
|
||||
typedef void ControlSignature(FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldInOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
VTKM_EXEC
|
||||
void operator()(vtkm::Vec<vtkm::Id, 4>& triangleIndices) const
|
||||
{
|
||||
@ -276,9 +276,9 @@ public:
|
||||
VTKM_CONT
|
||||
UniqueTriangles() {}
|
||||
|
||||
typedef void ControlSignature(WholeArrayIn<vtkm::ListTagBase<vtkm::Vec<vtkm::Id, 4>>>,
|
||||
using ControlSignature = void(WholeArrayIn<vtkm::ListTagBase<vtkm::Vec<vtkm::Id, 4>>>,
|
||||
WholeArrayOut<vtkm::ListTagBase<vtkm::UInt8>>);
|
||||
typedef void ExecutionSignature(_1, _2, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, WorkIndex);
|
||||
|
||||
VTKM_EXEC
|
||||
bool IsTwin(const vtkm::Vec<vtkm::Id, 4>& a, const vtkm::Vec<vtkm::Id, 4>& b) const
|
||||
@ -314,8 +314,8 @@ public:
|
||||
{
|
||||
this->OutputIndices = outputIndices.PrepareForOutput(size, Device());
|
||||
}
|
||||
typedef void ControlSignature(CellSetIn cellset, FieldInCell<>);
|
||||
typedef void ExecutionSignature(_2, CellShape, PointIndices, WorkIndex);
|
||||
using ControlSignature = void(CellSetIn cellset, FieldInCell<>);
|
||||
using ExecutionSignature = void(_2, CellShape, PointIndices, WorkIndex);
|
||||
|
||||
template <typename VecType>
|
||||
VTKM_EXEC void operator()(const vtkm::Id& triangleOffset,
|
||||
|
@ -135,8 +135,8 @@ union PackedValue {
|
||||
|
||||
struct CopyIntoFrameBuffer : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
VTKM_CONT
|
||||
CopyIntoFrameBuffer() {}
|
||||
@ -159,8 +159,8 @@ class EdgePlotter : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
using AtomicPackedFrameBufferHandle = vtkm::exec::AtomicArray<vtkm::Int64, DeviceTag>;
|
||||
|
||||
typedef void ControlSignature(FieldIn<Id2Type>, WholeArrayIn<Vec3>, WholeArrayIn<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<Id2Type>, WholeArrayIn<Vec3>, WholeArrayIn<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_CONT
|
||||
@ -395,10 +395,10 @@ public:
|
||||
VTKM_CONT
|
||||
BufferConverter() {}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
WholeArrayOut<vtkm::ListTagBase<vtkm::Float32>>,
|
||||
WholeArrayOut<vtkm::ListTagBase<vtkm::Vec<vtkm::Float32, 4>>>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, WorkIndex);
|
||||
|
||||
template <typename DepthBufferPortalType, typename ColorBufferPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Int64& packedValue,
|
||||
|
@ -88,8 +88,8 @@ class LinearBVHBuilder::CountingIterator : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
CountingIterator() {}
|
||||
typedef void ControlSignature(FieldOut<>);
|
||||
typedef void ExecutionSignature(WorkIndex, _1);
|
||||
using ControlSignature = void(FieldOut<>);
|
||||
using ExecutionSignature = void(WorkIndex, _1);
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Id& index, vtkm::Id& outId) const { outId = index; }
|
||||
}; //class countingIterator
|
||||
@ -99,7 +99,7 @@ class LinearBVHBuilder::FindAABBs : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
FindAABBs() {}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
@ -107,7 +107,7 @@ public:
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
WholeArrayIn<Vec3RenderingTypes>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
template <typename PointPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<vtkm::Id, 4> indices,
|
||||
vtkm::Float32& xmin,
|
||||
@ -162,9 +162,9 @@ template <typename Device>
|
||||
class LinearBVHBuilder::GatherFloat32 : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Float32> FloatArrayHandle;
|
||||
typedef typename FloatArrayHandle::ExecutionTypes<Device>::PortalConst PortalConst;
|
||||
typedef typename FloatArrayHandle::ExecutionTypes<Device>::Portal Portal;
|
||||
using FloatArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Float32>;
|
||||
using PortalConst = typename FloatArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using Portal = typename FloatArrayHandle::ExecutionTypes<Device>::Portal;
|
||||
PortalConst InputPortal;
|
||||
Portal OutputPortal;
|
||||
|
||||
@ -177,8 +177,8 @@ public:
|
||||
{
|
||||
this->OutputPortal = outputPortal.PrepareForOutput(size, Device());
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>);
|
||||
typedef void ExecutionSignature(WorkIndex, _1);
|
||||
using ControlSignature = void(FieldIn<>);
|
||||
using ExecutionSignature = void(WorkIndex, _1);
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Id& outIndex, const vtkm::Id& inIndex) const
|
||||
{
|
||||
@ -190,10 +190,10 @@ template <typename Device>
|
||||
class LinearBVHBuilder::GatherVecCast : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Vec4IdArrayHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>> Vec4IntArrayHandle;
|
||||
typedef typename Vec4IdArrayHandle::ExecutionTypes<Device>::PortalConst PortalConst;
|
||||
typedef typename Vec4IntArrayHandle::ExecutionTypes<Device>::Portal Portal;
|
||||
using Vec4IdArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
using Vec4IntArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>>;
|
||||
using PortalConst = typename Vec4IdArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using Portal = typename Vec4IntArrayHandle::ExecutionTypes<Device>::Portal;
|
||||
|
||||
private:
|
||||
PortalConst InputPortal;
|
||||
@ -208,8 +208,8 @@ public:
|
||||
{
|
||||
this->OutputPortal = outputPortal.PrepareForOutput(size, Device());
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>);
|
||||
typedef void ExecutionSignature(WorkIndex, _1);
|
||||
using ControlSignature = void(FieldIn<>);
|
||||
using ExecutionSignature = void(WorkIndex, _1);
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Id& outIndex, const vtkm::Id& inIndex) const
|
||||
{
|
||||
@ -278,17 +278,17 @@ template <typename Device>
|
||||
class LinearBVHBuilder::PropagateAABBs : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Id> IdArrayHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Int8> Int8Handle;
|
||||
typedef typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 2>> Float2ArrayHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 2>> VecInt2Handle;
|
||||
typedef typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 4>> Float4ArrayHandle;
|
||||
using IdArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using Int8Handle = typename vtkm::cont::ArrayHandle<vtkm::Int8>;
|
||||
using Float2ArrayHandle = typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 2>>;
|
||||
using VecInt2Handle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 2>>;
|
||||
using Float4ArrayHandle = typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 4>>;
|
||||
|
||||
typedef typename IdArrayHandle::ExecutionTypes<Device>::PortalConst IdConstPortal;
|
||||
typedef typename Float2ArrayHandle::ExecutionTypes<Device>::Portal Float2ArrayPortal;
|
||||
typedef typename VecInt2Handle::ExecutionTypes<Device>::Portal Int2ArrayPortal;
|
||||
typedef typename Int8Handle::ExecutionTypes<Device>::Portal Int8ArrayPortal;
|
||||
typedef typename Float4ArrayHandle::ExecutionTypes<Device>::Portal Float4ArrayPortal;
|
||||
using IdConstPortal = typename IdArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using Float2ArrayPortal = typename Float2ArrayHandle::ExecutionTypes<Device>::Portal;
|
||||
using Int2ArrayPortal = typename VecInt2Handle::ExecutionTypes<Device>::Portal;
|
||||
using Int8ArrayPortal = typename Int8Handle::ExecutionTypes<Device>::Portal;
|
||||
using Float4ArrayPortal = typename Float4ArrayHandle::ExecutionTypes<Device>::Portal;
|
||||
|
||||
Float4ArrayPortal FlatBVH;
|
||||
IdConstPortal Parents;
|
||||
@ -316,13 +316,13 @@ public:
|
||||
{
|
||||
this->FlatBVH = flatBVH.PrepareForOutput((LeafCount - 1) * 4, Device());
|
||||
}
|
||||
typedef void ControlSignature(WholeArrayIn<Scalar>,
|
||||
using ControlSignature = void(WholeArrayIn<Scalar>,
|
||||
WholeArrayIn<Scalar>,
|
||||
WholeArrayIn<Scalar>,
|
||||
WholeArrayIn<Scalar>,
|
||||
WholeArrayIn<Scalar>,
|
||||
WholeArrayIn<Scalar>);
|
||||
typedef void ExecutionSignature(WorkIndex, _1, _2, _3, _4, _5, _6);
|
||||
using ExecutionSignature = void(WorkIndex, _1, _2, _3, _4, _5, _6);
|
||||
|
||||
template <typename InputPortalType>
|
||||
VTKM_EXEC_CONT void operator()(const vtkm::Id workIndex,
|
||||
@ -443,10 +443,10 @@ template <typename Device>
|
||||
class LinearBVHBuilder::TreeBuilder : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::UInt32> UIntArrayHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Id> IdArrayHandle;
|
||||
typedef typename UIntArrayHandle::ExecutionTypes<Device>::PortalConst UIntPortalType;
|
||||
typedef typename IdArrayHandle::ExecutionTypes<Device>::Portal IdPortalType;
|
||||
using UIntArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::UInt32>;
|
||||
using IdArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using UIntPortalType = typename UIntArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using IdPortalType = typename IdArrayHandle::ExecutionTypes<Device>::Portal;
|
||||
|
||||
private:
|
||||
UIntPortalType MortonCodePortal;
|
||||
@ -527,8 +527,8 @@ public:
|
||||
InnerCount = LeafCount - 1;
|
||||
this->ParentPortal = parentHandle.PrepareForOutput(InnerCount + LeafCount, Device());
|
||||
}
|
||||
typedef void ControlSignature(FieldOut<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(WorkIndex, _1, _2);
|
||||
using ControlSignature = void(FieldOut<>, FieldOut<>);
|
||||
using ExecutionSignature = void(WorkIndex, _1, _2);
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Id& index, vtkm::Id& leftChild, vtkm::Id& rightChild) const
|
||||
{
|
||||
|
@ -37,8 +37,8 @@ namespace raytracing
|
||||
class VTKM_RENDERING_EXPORT LinearBVH
|
||||
{
|
||||
public:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> InnerNodesHandle;
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>> LeafNodesHandle;
|
||||
using InnerNodesHandle = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using LeafNodesHandle = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>>;
|
||||
InnerNodesHandle FlatBVH;
|
||||
LeafNodesHandle LeafNodes;
|
||||
struct ConstructFunctor;
|
||||
|
@ -106,9 +106,9 @@ public:
|
||||
return rcp((fabs(f) < 1e-8f) ? 1e-8f : f);
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldOut<>, FieldOut<>);
|
||||
using ControlSignature = void(FieldOut<>, FieldOut<>);
|
||||
|
||||
typedef void ExecutionSignature(WorkIndex, _1, _2);
|
||||
using ExecutionSignature = void(WorkIndex, _1, _2);
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Id idx, vtkm::Int32& hit, vtkm::Float32& distance) const
|
||||
{
|
||||
@ -216,15 +216,10 @@ public:
|
||||
vtkm::Normalize(nlook);
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>);
|
||||
using ControlSignature =
|
||||
void(FieldOut<>, FieldOut<>, FieldOut<>, FieldOut<>, FieldOut<>, FieldOut<>, FieldOut<>);
|
||||
|
||||
typedef void ExecutionSignature(WorkIndex, _1, _2, _3, _4, _5, _6, _7);
|
||||
using ExecutionSignature = void(WorkIndex, _1, _2, _3, _4, _5, _6, _7);
|
||||
template <typename Precision>
|
||||
VTKM_EXEC void operator()(vtkm::Id idx,
|
||||
Precision& rayDirX,
|
||||
@ -313,9 +308,9 @@ public:
|
||||
vtkm::Normalize(nlook);
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldOut<>, FieldOut<>, FieldOut<>, FieldOut<>);
|
||||
using ControlSignature = void(FieldOut<>, FieldOut<>, FieldOut<>, FieldOut<>);
|
||||
|
||||
typedef void ExecutionSignature(WorkIndex, _1, _2, _3, _4);
|
||||
using ExecutionSignature = void(WorkIndex, _1, _2, _3, _4);
|
||||
template <typename Precision>
|
||||
VTKM_EXEC void operator()(vtkm::Id idx,
|
||||
Precision& rayDirX,
|
||||
|
@ -64,8 +64,8 @@ class BufferAddition : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
BufferAddition() {}
|
||||
typedef void ControlSignature(FieldIn<>, FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldInOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename ValueType>
|
||||
VTKM_EXEC void operator()(const ValueType& value1, ValueType& value2) const
|
||||
@ -79,8 +79,8 @@ class BufferMultiply : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
BufferMultiply() {}
|
||||
typedef void ControlSignature(FieldIn<>, FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldInOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename ValueType>
|
||||
VTKM_EXEC void operator()(const ValueType& value1, ValueType& value2) const
|
||||
@ -188,8 +188,8 @@ public:
|
||||
, ChannelNum(channel)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldOut<>, WholeArrayIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, WorkIndex);
|
||||
using ControlSignature = void(FieldOut<>, WholeArrayIn<>);
|
||||
using ExecutionSignature = void(_1, _2, WorkIndex);
|
||||
template <typename T, typename BufferPortalType>
|
||||
VTKM_EXEC void operator()(T& outValue,
|
||||
const BufferPortalType& inBuffer,
|
||||
@ -257,8 +257,8 @@ public:
|
||||
: NumChannels(numChannels)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayIn<>, WholeArrayOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, WorkIndex);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayIn<>, WholeArrayOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, WorkIndex);
|
||||
template <typename T, typename IndexPortalType, typename BufferPortalType>
|
||||
VTKM_EXEC void operator()(const T& inValue,
|
||||
const IndexPortalType& sparseIndexes,
|
||||
@ -377,8 +377,8 @@ public:
|
||||
InvDeltaScalar = 1.f / (maxScalar - minScalar);
|
||||
}
|
||||
}
|
||||
typedef void ControlSignature(FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldInOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
|
||||
VTKM_EXEC
|
||||
void operator()(Precision& value) const
|
||||
|
@ -50,8 +50,8 @@ public:
|
||||
: NumChannels(numChannels)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayIn<>, FieldIn<>, WholeArrayOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, WorkIndex);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayIn<>, FieldIn<>, WholeArrayOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, WorkIndex);
|
||||
template <typename InBufferPortalType, typename OutBufferPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::UInt8& mask,
|
||||
const InBufferPortalType& inBuffer,
|
||||
@ -85,8 +85,8 @@ public:
|
||||
: NumChannels(numChannels)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldOut<>, WholeArrayIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, WorkIndex);
|
||||
using ControlSignature = void(FieldOut<>, WholeArrayIn<>);
|
||||
using ExecutionSignature = void(_1, _2, WorkIndex);
|
||||
template <typename ValueType, typename PortalType>
|
||||
VTKM_EXEC void operator()(ValueType& outValue,
|
||||
const PortalType& source,
|
||||
|
@ -145,8 +145,8 @@ public:
|
||||
: Offset(offset)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldInOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
VTKM_EXEC inline void operator()(const vtkm::UInt8& status, FloatType& distance) const
|
||||
{
|
||||
@ -169,7 +169,7 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldInOut<>,
|
||||
using ControlSignature = void(FieldInOut<>,
|
||||
WholeArrayIn<>,
|
||||
FieldIn<>,
|
||||
FieldInOut<>,
|
||||
@ -177,7 +177,7 @@ public:
|
||||
FieldInOut<>,
|
||||
FieldInOut<>,
|
||||
FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
|
||||
template <typename PointPortalType>
|
||||
VTKM_EXEC inline void operator()(vtkm::Id& currentCell,
|
||||
@ -266,8 +266,8 @@ template <vtkm::Int32 CellType, typename FloatType, typename Device, typename Me
|
||||
class RayBumper : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<FloatType> FloatTypeHandle;
|
||||
typedef typename FloatTypeHandle::template ExecutionTypes<Device>::Portal FloatTypePortal;
|
||||
using FloatTypeHandle = typename vtkm::cont::ArrayHandle<FloatType>;
|
||||
using FloatTypePortal = typename FloatTypeHandle::template ExecutionTypes<Device>::Portal;
|
||||
FloatTypePortal DirectionsX;
|
||||
FloatTypePortal DirectionsY;
|
||||
FloatTypePortal DirectionsZ;
|
||||
@ -290,14 +290,14 @@ public:
|
||||
}
|
||||
|
||||
|
||||
typedef void ControlSignature(FieldInOut<>,
|
||||
using ControlSignature = void(FieldInOut<>,
|
||||
WholeArrayIn<>,
|
||||
FieldInOut<>,
|
||||
FieldInOut<>,
|
||||
FieldInOut<>,
|
||||
FieldInOut<>,
|
||||
FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, WorkIndex, _6, _7);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, WorkIndex, _6, _7);
|
||||
|
||||
template <typename PointPortalType>
|
||||
VTKM_EXEC inline void operator()(vtkm::Id& currentCell,
|
||||
@ -405,12 +405,12 @@ public:
|
||||
VTKM_CONT
|
||||
AddPathLengths() {}
|
||||
|
||||
typedef void ControlSignature(FieldIn<RayStatusType>, // ray status
|
||||
using ControlSignature = void(FieldIn<RayStatusType>, // ray status
|
||||
FieldIn<ScalarRenderingTypes>, // cell enter distance
|
||||
FieldIn<ScalarRenderingTypes>, // cell exit distance
|
||||
FieldInOut<ScalarRenderingTypes>); // ray absorption data
|
||||
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4);
|
||||
|
||||
VTKM_EXEC inline void operator()(const vtkm::UInt8& rayStatus,
|
||||
const FloatType& enterDistance,
|
||||
@ -445,7 +445,7 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<RayStatusType>, // ray status
|
||||
using ControlSignature = void(FieldIn<RayStatusType>, // ray status
|
||||
FieldIn<ScalarRenderingTypes>, // cell enter distance
|
||||
FieldIn<ScalarRenderingTypes>, // cell exit distance
|
||||
FieldInOut<ScalarRenderingTypes>, // current distance
|
||||
@ -453,7 +453,7 @@ public:
|
||||
WholeArrayInOut<ScalarRenderingTypes>, // ray absorption data
|
||||
FieldIn<IdType>); // current cell
|
||||
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, WorkIndex);
|
||||
|
||||
template <typename CellDataPortalType, typename RayDataPortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::UInt8& rayStatus,
|
||||
@ -507,7 +507,7 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>, // ray status
|
||||
using ControlSignature = void(FieldIn<>, // ray status
|
||||
FieldIn<>, // cell enter distance
|
||||
FieldIn<>, // cell exit distance
|
||||
FieldInOut<>, // current distance
|
||||
@ -517,7 +517,7 @@ public:
|
||||
WholeArrayInOut<>, // ray emission data
|
||||
FieldIn<>); // current cell
|
||||
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8, _9, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, _9, WorkIndex);
|
||||
|
||||
template <typename CellAbsPortalType, typename CellEmisPortalType, typename RayDataPortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::UInt8& rayStatus,
|
||||
@ -604,8 +604,8 @@ public:
|
||||
, BGColor(bgcolor)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayIn<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayIn<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
|
||||
VTKM_EXEC inline bool IsBGColor(const vtkm::Vec<vtkm::Float32, 4> color) const
|
||||
@ -673,10 +673,10 @@ template <vtkm::Int32 CellType, typename FloatType, typename Device, typename Me
|
||||
class SampleCellAssocCells : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<FloatType> ColorBuffer;
|
||||
typedef typename ColorHandle::ExecutionTypes<Device>::PortalConst ColorConstPortal;
|
||||
typedef typename ColorBuffer::template ExecutionTypes<Device>::Portal ColorPortal;
|
||||
using ColorHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using ColorBuffer = typename vtkm::cont::ArrayHandle<FloatType>;
|
||||
using ColorConstPortal = typename ColorHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using ColorPortal = typename ColorBuffer::template ExecutionTypes<Device>::Portal;
|
||||
|
||||
CellSampler<CellType> Sampler;
|
||||
FloatType SampleDistance;
|
||||
@ -706,13 +706,13 @@ public:
|
||||
}
|
||||
|
||||
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
WholeArrayIn<ScalarRenderingTypes>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldInOut<>,
|
||||
FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, WorkIndex);
|
||||
|
||||
template <typename ScalarPortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::Id& currentCell,
|
||||
@ -791,10 +791,10 @@ template <vtkm::Int32 CellType, typename FloatType, typename Device, typename Me
|
||||
class SampleCellAssocPoints : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<FloatType> ColorBuffer;
|
||||
typedef typename ColorHandle::ExecutionTypes<Device>::PortalConst ColorConstPortal;
|
||||
typedef typename ColorBuffer::template ExecutionTypes<Device>::Portal ColorPortal;
|
||||
using ColorHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using ColorBuffer = typename vtkm::cont::ArrayHandle<FloatType>;
|
||||
using ColorConstPortal = typename ColorHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using ColorPortal = typename ColorBuffer::template ExecutionTypes<Device>::Portal;
|
||||
|
||||
CellSampler<CellType> Sampler;
|
||||
FloatType SampleDistance;
|
||||
@ -824,7 +824,7 @@ public:
|
||||
}
|
||||
|
||||
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
WholeArrayIn<Vec3>,
|
||||
WholeArrayIn<ScalarRenderingTypes>,
|
||||
FieldIn<>,
|
||||
@ -833,7 +833,7 @@ public:
|
||||
FieldIn<>,
|
||||
FieldInOut<>,
|
||||
FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8, WorkIndex, _9);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, WorkIndex, _9);
|
||||
|
||||
template <typename PointPortalType, typename ScalarPortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::Id& currentCell,
|
||||
|
@ -56,8 +56,8 @@ class CountFaces : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
CountFaces() {}
|
||||
typedef void ControlSignature(WholeArrayIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, WorkIndex);
|
||||
using ControlSignature = void(WholeArrayIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, WorkIndex);
|
||||
template <typename ShapePortalType>
|
||||
VTKM_EXEC inline void operator()(const ShapePortalType& shapes,
|
||||
vtkm::Id& faces,
|
||||
@ -93,13 +93,13 @@ class MortonNeighbor : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
MortonNeighbor() {}
|
||||
typedef void ControlSignature(WholeArrayIn<>,
|
||||
using ControlSignature = void(WholeArrayIn<>,
|
||||
WholeArrayInOut<Id3Type>,
|
||||
WholeArrayIn<>,
|
||||
WholeArrayIn<>,
|
||||
WholeArrayIn<>,
|
||||
WholeArrayOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, WorkIndex, _3, _4, _5, _6);
|
||||
using ExecutionSignature = void(_1, _2, WorkIndex, _3, _4, _5, _6);
|
||||
|
||||
VTKM_EXEC
|
||||
inline vtkm::Int32 GetShapeOffset(const vtkm::UInt8& shapeType) const
|
||||
@ -266,13 +266,9 @@ class ExternalTriangles : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
ExternalTriangles() {}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
WholeArrayIn<>,
|
||||
WholeArrayIn<>,
|
||||
WholeArrayIn<>,
|
||||
WholeArrayOut<>,
|
||||
FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
|
||||
using ControlSignature =
|
||||
void(FieldIn<>, WholeArrayIn<>, WholeArrayIn<>, WholeArrayIn<>, WholeArrayOut<>, FieldIn<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
|
||||
template <typename ShapePortalType,
|
||||
typename InIndicesPortalType,
|
||||
typename OutIndicesPortalType,
|
||||
@ -333,8 +329,8 @@ public:
|
||||
class WriteFaceConn : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayIn<>, WholeArrayOut<IdType>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayIn<>, WholeArrayOut<IdType>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
VTKM_CONT
|
||||
WriteFaceConn() {}
|
||||
@ -355,10 +351,9 @@ public:
|
||||
class StructuredExternalTriangles : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
protected:
|
||||
typedef vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagPoint,
|
||||
vtkm::TopologyElementTagCell,
|
||||
3>
|
||||
ConnType;
|
||||
using ConnType = vtkm::exec::ConnectivityStructured<vtkm::TopologyElementTagPoint,
|
||||
vtkm::TopologyElementTagCell,
|
||||
3>;
|
||||
ConnType Connectivity;
|
||||
vtkm::Id Segments[7];
|
||||
vtkm::Id3 CellDims;
|
||||
@ -386,8 +381,8 @@ public:
|
||||
Segments[5] = Segments[4] + cellDims[1] * cellDims[0];
|
||||
Segments[6] = Segments[5] + cellDims[1] * cellDims[0];
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
template <typename TrianglePortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::Id& index, TrianglePortalType& triangles) const
|
||||
{
|
||||
@ -492,8 +487,8 @@ class CountExternalTriangles : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
CountExternalTriangles() {}
|
||||
typedef void ControlSignature(FieldIn<>, WholeArrayIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, WholeArrayIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
template <typename ShapePortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::Vec<vtkm::Id, 3>& faceIdPair,
|
||||
const ShapePortalType& shapes,
|
||||
|
@ -54,9 +54,9 @@ class MeshConnExec
|
||||
class UnstructuredMeshConn
|
||||
{
|
||||
public:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Id> IdHandle;
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::UInt8> UCharHandle;
|
||||
using IdHandle = vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using Id4Handle = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
using UCharHandle = vtkm::cont::ArrayHandle<vtkm::UInt8>;
|
||||
// Control Environment Handles
|
||||
// FaceConn
|
||||
IdHandle FaceConnectivity;
|
||||
@ -204,11 +204,11 @@ template <typename Device>
|
||||
class MeshConnExec<UnstructuredMeshConn, Device>
|
||||
{
|
||||
protected:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Id> IdHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::UInt8> UCharHandle;
|
||||
typedef typename IdHandle::ExecutionTypes<Device>::PortalConst IdConstPortal;
|
||||
typedef typename UCharHandle::ExecutionTypes<Device>::PortalConst UCharConstPortal;
|
||||
using IdHandle = typename vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using Id4Handle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
using UCharHandle = typename vtkm::cont::ArrayHandle<vtkm::UInt8>;
|
||||
using IdConstPortal = typename IdHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using UCharConstPortal = typename UCharHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
// Constant Portals for the execution Environment
|
||||
//FaceConn
|
||||
@ -295,11 +295,11 @@ public:
|
||||
class UnstructuredMeshConnSingleType
|
||||
{
|
||||
public:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Id> IdHandle;
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
|
||||
typedef vtkm::cont::ArrayHandleCounting<vtkm::Id> CountingHandle;
|
||||
typedef vtkm::cont::ArrayHandleConstant<vtkm::UInt8> ShapesHandle;
|
||||
typedef vtkm::cont::ArrayHandleConstant<vtkm::IdComponent> NumIndicesHandle;
|
||||
using IdHandle = vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using Id4Handle = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
using CountingHandle = vtkm::cont::ArrayHandleCounting<vtkm::Id>;
|
||||
using ShapesHandle = vtkm::cont::ArrayHandleConstant<vtkm::UInt8>;
|
||||
using NumIndicesHandle = vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>;
|
||||
// Control Environment Handles
|
||||
IdHandle FaceConnectivity;
|
||||
CountingHandle CellOffsets;
|
||||
@ -456,14 +456,14 @@ template <typename Device>
|
||||
class MeshConnExec<UnstructuredMeshConnSingleType, Device>
|
||||
{
|
||||
protected:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Id> IdHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
|
||||
typedef typename vtkm::cont::ArrayHandleCounting<vtkm::Id> CountingHandle;
|
||||
typedef typename vtkm::cont::ArrayHandleConstant<vtkm::UInt8> ShapesHandle;
|
||||
using IdHandle = typename vtkm::cont::ArrayHandle<vtkm::Id>;
|
||||
using Id4Handle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
using CountingHandle = typename vtkm::cont::ArrayHandleCounting<vtkm::Id>;
|
||||
using ShapesHandle = typename vtkm::cont::ArrayHandleConstant<vtkm::UInt8>;
|
||||
|
||||
typedef typename IdHandle::ExecutionTypes<Device>::PortalConst IdConstPortal;
|
||||
typedef typename CountingHandle::ExecutionTypes<Device>::PortalConst CountingPortal;
|
||||
typedef typename vtkm::cont::ArrayHandleConstant<vtkm::IdComponent> NumIndicesHandle;
|
||||
using IdConstPortal = typename IdHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using CountingPortal = typename CountingHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using NumIndicesHandle = typename vtkm::cont::ArrayHandleConstant<vtkm::IdComponent>;
|
||||
// Constant Portals for the execution Environment
|
||||
IdConstPortal FaceConnPortal;
|
||||
IdConstPortal CellConnectivityPortal;
|
||||
@ -542,7 +542,7 @@ public:
|
||||
class StructuredMeshConn
|
||||
{
|
||||
public:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
|
||||
using Id4Handle = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
vtkm::Id3 CellDims;
|
||||
vtkm::Id3 PointDims;
|
||||
vtkm::Bounds CoordinateBounds;
|
||||
@ -658,7 +658,7 @@ template <typename Device>
|
||||
class MeshConnExec<StructuredMeshConn, Device>
|
||||
{
|
||||
protected:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>> Id4Handle;
|
||||
using Id4Handle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Id, 4>>;
|
||||
vtkm::Id3 CellDims;
|
||||
vtkm::Id3 PointDims;
|
||||
vtkm::Bounds CoordinateBounds;
|
||||
|
@ -149,13 +149,10 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
WholeArrayIn<>,
|
||||
FieldInTo<>,
|
||||
WholeArrayOut<>,
|
||||
WholeArrayOut<>);
|
||||
using ControlSignature =
|
||||
void(CellSetIn cellset, WholeArrayIn<>, FieldInTo<>, WholeArrayOut<>, WholeArrayOut<>);
|
||||
|
||||
typedef void ExecutionSignature(CellShape, FromIndices, WorkIndex, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(CellShape, FromIndices, WorkIndex, _2, _3, _4, _5);
|
||||
|
||||
template <typename CellShape,
|
||||
typename CellNodeVecType,
|
||||
@ -264,9 +261,9 @@ public:
|
||||
{
|
||||
}
|
||||
|
||||
typedef void
|
||||
ControlSignature(FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7);
|
||||
using ControlSignature =
|
||||
void(FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7);
|
||||
typedef _7 InputDomain;
|
||||
|
||||
VTKM_EXEC
|
||||
|
@ -42,8 +42,8 @@ class RayStatusFilter : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
RayStatusFilter() {}
|
||||
typedef void ControlSignature(FieldIn<>, FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldInOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
VTKM_EXEC
|
||||
void operator()(const vtkm::Id& hitIndex, vtkm::UInt8& rayStatus) const
|
||||
{
|
||||
@ -80,8 +80,8 @@ public:
|
||||
DoubleInvWidth = 2.f / static_cast<vtkm::Float32>(width);
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>, FieldInOut<>, WholeArrayIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldInOut<>, WholeArrayIn<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
template <typename Precision, typename DepthPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Id& pixelId,
|
||||
|
@ -49,14 +49,9 @@ class IntersectionPoint : public vtkm::worklet::WorkletMapField
|
||||
public:
|
||||
VTKM_CONT
|
||||
IntersectionPoint() {}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7);
|
||||
using ControlSignature =
|
||||
void(FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, FieldOut<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7);
|
||||
template <typename Precision>
|
||||
VTKM_EXEC inline void operator()(const vtkm::Id& hitIndex,
|
||||
const Precision& distance,
|
||||
@ -84,8 +79,8 @@ public:
|
||||
class CalculateNormals : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>> Vec4IntArrayHandle;
|
||||
typedef typename Vec4IntArrayHandle::ExecutionTypes<Device>::PortalConst IndicesArrayPortal;
|
||||
using Vec4IntArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>>;
|
||||
using IndicesArrayPortal = typename Vec4IntArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
IndicesArrayPortal IndicesPortal;
|
||||
|
||||
@ -95,13 +90,13 @@ public:
|
||||
: IndicesPortal(indices.PrepareForInput(Device()))
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
WholeArrayIn<Vec3RenderingTypes>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6);
|
||||
template <typename Precision, typename PointPortalType>
|
||||
VTKM_EXEC inline void operator()(const vtkm::Id& hitIndex,
|
||||
const vtkm::Vec<Precision, 3>& rayDir,
|
||||
@ -134,8 +129,8 @@ public:
|
||||
class LerpScalar : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>> Vec4IntArrayHandle;
|
||||
typedef typename Vec4IntArrayHandle::ExecutionTypes<Device>::PortalConst IndicesArrayPortal;
|
||||
using Vec4IntArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>>;
|
||||
using IndicesArrayPortal = typename Vec4IntArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
IndicesArrayPortal IndicesPortal;
|
||||
Precision MinScalar;
|
||||
@ -156,12 +151,9 @@ public:
|
||||
else
|
||||
invDeltaScalar = 1.f / minScalar;
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldOut<>,
|
||||
WholeArrayIn<ScalarRenderingTypes>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ControlSignature =
|
||||
void(FieldIn<>, FieldIn<>, FieldIn<>, FieldOut<>, WholeArrayIn<ScalarRenderingTypes>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
template <typename ScalarPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Id& hitIndex,
|
||||
const Precision& u,
|
||||
@ -188,8 +180,8 @@ public:
|
||||
class NodalScalar : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>> Vec4IntArrayHandle;
|
||||
typedef typename Vec4IntArrayHandle::ExecutionTypes<Device>::PortalConst IndicesArrayPortal;
|
||||
using Vec4IntArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>>;
|
||||
using IndicesArrayPortal = typename Vec4IntArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
IndicesArrayPortal IndicesPortal;
|
||||
Precision MinScalar;
|
||||
@ -211,9 +203,9 @@ public:
|
||||
invDeltaScalar = 1.f / minScalar;
|
||||
}
|
||||
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>, WholeArrayIn<ScalarRenderingTypes>);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>, WholeArrayIn<ScalarRenderingTypes>);
|
||||
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
template <typename ScalarPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Id& hitIndex,
|
||||
Precision& scalar,
|
||||
@ -273,8 +265,8 @@ public:
|
||||
class MapScalarToColor : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorArrayHandle;
|
||||
typedef typename ColorArrayHandle::ExecutionTypes<Device>::PortalConst ColorArrayPortal;
|
||||
using ColorArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using ColorArrayPortal = typename ColorArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
ColorArrayPortal ColorMap;
|
||||
vtkm::Int32 ColorMapSize;
|
||||
@ -311,8 +303,8 @@ public:
|
||||
LightSpecular[2] = .7f;
|
||||
SpecularExponent = 20.f;
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, WholeArrayInOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, WorkIndex);
|
||||
using ControlSignature = void(FieldIn<>, FieldIn<>, FieldIn<>, FieldIn<>, WholeArrayInOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, WorkIndex);
|
||||
template <typename ColorPortalType, typename Precision>
|
||||
VTKM_EXEC void operator()(const vtkm::Id& hitIdx,
|
||||
const Precision& scalar,
|
||||
|
@ -94,21 +94,21 @@ inline std::string GetDeviceString<vtkm::cont::DeviceAdapterTagCuda>(
|
||||
return "cuda";
|
||||
}
|
||||
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorBuffer4f;
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::UInt8, 4>> ColorBuffer4b;
|
||||
using ColorBuffer4f = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using ColorBuffer4b = vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::UInt8, 4>>;
|
||||
|
||||
//Defining types supported by the rendering
|
||||
|
||||
//vec3s
|
||||
typedef vtkm::Vec<vtkm::Float32, 3> Vec3F;
|
||||
typedef vtkm::Vec<vtkm::Float64, 3> Vec3D;
|
||||
using Vec3F = vtkm::Vec<vtkm::Float32, 3>;
|
||||
using Vec3D = vtkm::Vec<vtkm::Float64, 3>;
|
||||
struct Vec3RenderingTypes : vtkm::ListTagBase<Vec3F, Vec3D>
|
||||
{
|
||||
};
|
||||
|
||||
// Scalars Types
|
||||
typedef vtkm::Float32 ScalarF;
|
||||
typedef vtkm::Float64 ScalarD;
|
||||
using ScalarF = vtkm::Float32;
|
||||
using ScalarD = vtkm::Float64;
|
||||
|
||||
struct RayStatusType : vtkm::ListTagBase<vtkm::UInt8>
|
||||
{
|
||||
@ -122,15 +122,15 @@ struct ScalarRenderingTypes : vtkm::ListTagBase<ScalarF, ScalarD>
|
||||
namespace detail
|
||||
{
|
||||
|
||||
typedef vtkm::cont::ArrayHandleCompositeVector<vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>>
|
||||
ArrayHandleCompositeVectorFloat32_3Default;
|
||||
using ArrayHandleCompositeVectorFloat32_3Default =
|
||||
vtkm::cont::ArrayHandleCompositeVector<vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float32>>;
|
||||
|
||||
typedef vtkm::cont::ArrayHandleCompositeVector<vtkm::cont::ArrayHandle<vtkm::Float64>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64>>
|
||||
ArrayHandleCompositeVectorFloat64_3Default;
|
||||
using ArrayHandleCompositeVectorFloat64_3Default =
|
||||
vtkm::cont::ArrayHandleCompositeVector<vtkm::cont::ArrayHandle<vtkm::Float64>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64>,
|
||||
vtkm::cont::ArrayHandle<vtkm::Float64>>;
|
||||
|
||||
struct StructuredStorageListTagCoordinateSystem
|
||||
: vtkm::ListTagBase<vtkm::cont::ArrayHandleUniformPointCoordinates::StorageTag,
|
||||
@ -176,14 +176,14 @@ struct StorageListTagExplicitCoordinateSystem : vtkm::ListTagBase<vtkm::cont::St
|
||||
};
|
||||
|
||||
|
||||
typedef detail::StructuredStorageListTagCoordinateSystem StructuredStorage;
|
||||
using StructuredStorage = detail::StructuredStorageListTagCoordinateSystem;
|
||||
|
||||
typedef vtkm::cont::DynamicArrayHandleBase<ExplicitCoordinatesType, StructuredStorage>
|
||||
DynamicArrayHandleStructuredCoordinateSystem;
|
||||
using DynamicArrayHandleStructuredCoordinateSystem =
|
||||
vtkm::cont::DynamicArrayHandleBase<ExplicitCoordinatesType, StructuredStorage>;
|
||||
|
||||
typedef vtkm::cont::DynamicArrayHandleBase<ExplicitCoordinatesType,
|
||||
StorageListTagExplicitCoordinateSystem>
|
||||
DynamicArrayHandleExplicitCoordinateSystem;
|
||||
using DynamicArrayHandleExplicitCoordinateSystem =
|
||||
vtkm::cont::DynamicArrayHandleBase<ExplicitCoordinatesType,
|
||||
StorageListTagExplicitCoordinateSystem>;
|
||||
}
|
||||
}
|
||||
} //namespace vtkm::rendering::raytracing
|
||||
|
@ -705,12 +705,12 @@ template <typename Device, typename LeafIntesectorType>
|
||||
class TriangleIntersector
|
||||
{
|
||||
public:
|
||||
typedef typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 4>> Float4ArrayHandle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 2>> Int2Handle;
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>> Int4Handle;
|
||||
typedef typename Float4ArrayHandle::ExecutionTypes<Device>::PortalConst Float4ArrayPortal;
|
||||
typedef typename Int2Handle::ExecutionTypes<Device>::PortalConst Int2ArrayPortal;
|
||||
typedef typename Int4Handle::ExecutionTypes<Device>::PortalConst Int4ArrayPortal;
|
||||
using Float4ArrayHandle = typename vtkm::cont::ArrayHandle<Vec<vtkm::Float32, 4>>;
|
||||
using Int2Handle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 2>>;
|
||||
using Int4Handle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Int32, 4>>;
|
||||
using Float4ArrayPortal = typename Float4ArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using Int2ArrayPortal = typename Int2Handle::ExecutionTypes<Device>::PortalConst;
|
||||
using Int4ArrayPortal = typename Int4Handle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
class Intersector : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
@ -742,7 +742,7 @@ public:
|
||||
, Leafs(bvh.LeafNodes.PrepareForInput(Device()))
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldOut<>,
|
||||
FieldIn<>,
|
||||
@ -751,7 +751,7 @@ public:
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
WholeArrayIn<Vec3RenderingTypes>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8, _9);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8, _9);
|
||||
|
||||
|
||||
template <typename PointPortalType, typename Precision>
|
||||
@ -899,14 +899,14 @@ public:
|
||||
, Leafs(bvh.LeafNodes.PrepareForInput(Device()))
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldOut<>,
|
||||
WholeArrayIn<Vec3RenderingTypes>,
|
||||
FieldOut<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7);
|
||||
template <typename PointPortalType>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<Precision, 3>& rayDir,
|
||||
vtkm::Id& hitIndex,
|
||||
@ -1031,8 +1031,8 @@ public:
|
||||
: Leafs(bvh.LeafNodes.PrepareForInput(Device()))
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldInOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldInOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
VTKM_EXEC
|
||||
void operator()(vtkm::Id& hitIndex) const
|
||||
{
|
||||
|
@ -53,11 +53,11 @@ template <typename Device>
|
||||
class RectilinearLocator
|
||||
{
|
||||
protected:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::FloatDefault> DefaultHandle;
|
||||
typedef vtkm::cont::ArrayHandleCartesianProduct<DefaultHandle, DefaultHandle, DefaultHandle>
|
||||
CartesianArrayHandle;
|
||||
typedef typename DefaultHandle::ExecutionTypes<Device>::PortalConst DefaultConstHandle;
|
||||
typedef typename CartesianArrayHandle::ExecutionTypes<Device>::PortalConst CartesianConstPortal;
|
||||
using DefaultHandle = vtkm::cont::ArrayHandle<vtkm::FloatDefault>;
|
||||
using CartesianArrayHandle =
|
||||
vtkm::cont::ArrayHandleCartesianProduct<DefaultHandle, DefaultHandle, DefaultHandle>;
|
||||
using DefaultConstHandle = typename DefaultHandle::ExecutionTypes<Device>::PortalConst;
|
||||
using CartesianConstPortal = typename CartesianArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
vtkm::Float32 InverseDeltaScalar;
|
||||
DefaultConstHandle CoordPortals[3];
|
||||
@ -202,8 +202,8 @@ template <typename Device>
|
||||
class UniformLocator
|
||||
{
|
||||
protected:
|
||||
typedef typename vtkm::cont::ArrayHandleUniformPointCoordinates UniformArrayHandle;
|
||||
typedef typename UniformArrayHandle::ExecutionTypes<Device>::PortalConst UniformConstPortal;
|
||||
using UniformArrayHandle = typename vtkm::cont::ArrayHandleUniformPointCoordinates;
|
||||
using UniformConstPortal = typename UniformArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
|
||||
vtkm::Id3 PointDimensions;
|
||||
vtkm::Vec<vtkm::Float32, 3> Origin;
|
||||
@ -312,8 +312,8 @@ template <typename Device, typename LocatorType>
|
||||
class Sampler : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorArrayHandle;
|
||||
typedef typename ColorArrayHandle::ExecutionTypes<Device>::PortalConst ColorArrayPortal;
|
||||
using ColorArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using ColorArrayPortal = typename ColorArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
ColorArrayPortal ColorMap;
|
||||
vtkm::Id ColorMapSize;
|
||||
vtkm::Float32 MinScalar;
|
||||
@ -339,13 +339,13 @@ public:
|
||||
else
|
||||
InverseDeltaScalar = minScalar;
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
WholeArrayInOut<>,
|
||||
WholeArrayIn<ScalarRenderingTypes>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, WorkIndex);
|
||||
|
||||
template <typename ScalarPortalType, typename ColorBufferType>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<vtkm::Float32, 3>& rayDir,
|
||||
@ -508,8 +508,8 @@ template <typename Device, typename LocatorType>
|
||||
class SamplerCellAssoc : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
private:
|
||||
typedef typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>> ColorArrayHandle;
|
||||
typedef typename ColorArrayHandle::ExecutionTypes<Device>::PortalConst ColorArrayPortal;
|
||||
using ColorArrayHandle = typename vtkm::cont::ArrayHandle<vtkm::Vec<vtkm::Float32, 4>>;
|
||||
using ColorArrayPortal = typename ColorArrayHandle::ExecutionTypes<Device>::PortalConst;
|
||||
ColorArrayPortal ColorMap;
|
||||
vtkm::Id ColorMapSize;
|
||||
vtkm::Float32 MinScalar;
|
||||
@ -535,13 +535,13 @@ public:
|
||||
else
|
||||
InverseDeltaScalar = minScalar;
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
WholeArrayInOut<>,
|
||||
WholeArrayIn<ScalarRenderingTypes>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, WorkIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, WorkIndex);
|
||||
|
||||
template <typename ScalarPortalType, typename ColorBufferType>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<vtkm::Float32, 3>& rayDir,
|
||||
@ -682,8 +682,8 @@ public:
|
||||
VTKM_EXEC
|
||||
vtkm::Float32 rcp_safe(vtkm::Float32 f) const { return rcp((fabs(f) < 1e-8f) ? 1e-8f : f); }
|
||||
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>, FieldInOut<>, FieldInOut<>, FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>, FieldInOut<>, FieldInOut<>, FieldIn<>);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
template <typename Precision>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<Precision, 3>& rayDir,
|
||||
vtkm::Float32& minDistance,
|
||||
|
@ -36,9 +36,9 @@ namespace raytracing
|
||||
class VolumeRendererStructured
|
||||
{
|
||||
public:
|
||||
typedef vtkm::cont::ArrayHandle<vtkm::FloatDefault> DefaultHandle;
|
||||
typedef vtkm::cont::ArrayHandleCartesianProduct<DefaultHandle, DefaultHandle, DefaultHandle>
|
||||
CartesianArrayHandle;
|
||||
using DefaultHandle = vtkm::cont::ArrayHandle<vtkm::FloatDefault>;
|
||||
using CartesianArrayHandle =
|
||||
vtkm::cont::ArrayHandleCartesianProduct<DefaultHandle, DefaultHandle, DefaultHandle>;
|
||||
|
||||
VTKM_CONT
|
||||
VolumeRendererStructured();
|
||||
|
@ -40,8 +40,8 @@ public:
|
||||
: Value(value)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldOut<>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldOut<>);
|
||||
using ExecutionSignature = void(_1);
|
||||
VTKM_EXEC
|
||||
void operator()(T& outValue) const { outValue = Value; }
|
||||
}; //class MemSet
|
||||
@ -57,8 +57,8 @@ public:
|
||||
: Offset(offset)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
VTKM_EXEC inline void operator()(const FloatType& inValue, FloatType& outValue) const
|
||||
{
|
||||
@ -79,8 +79,8 @@ public:
|
||||
, MaskValue(mask)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, FieldInOut<>, FieldIn<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldInOut<>, FieldIn<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
template <typename MaskType>
|
||||
VTKM_EXEC inline void operator()(const FloatType& inValue,
|
||||
@ -103,8 +103,8 @@ public:
|
||||
: Value(value)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename O>
|
||||
VTKM_EXEC void operator()(const T& inValue, O& outValue) const
|
||||
@ -127,8 +127,8 @@ public:
|
||||
: Values(values)
|
||||
{
|
||||
}
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename O>
|
||||
VTKM_EXEC void operator()(const T& inValue, O& outValue) const
|
||||
|
@ -34,9 +34,9 @@ namespace
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperConnectivity M;
|
||||
typedef vtkm::rendering::CanvasRayTracer C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
using M = vtkm::rendering::MapperConnectivity;
|
||||
using C = vtkm::rendering::CanvasRayTracer;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("inferno");
|
||||
|
@ -33,10 +33,10 @@ namespace
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperRayTracer M;
|
||||
typedef vtkm::rendering::CanvasRayTracer C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
typedef vtkm::rendering::View2D V2;
|
||||
using M = vtkm::rendering::MapperRayTracer;
|
||||
using C = vtkm::rendering::CanvasRayTracer;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
using V2 = vtkm::rendering::View2D;
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("inferno");
|
||||
|
@ -34,9 +34,9 @@ namespace
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperVolume M;
|
||||
typedef vtkm::rendering::CanvasRayTracer C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
using M = vtkm::rendering::MapperVolume;
|
||||
using C = vtkm::rendering::CanvasRayTracer;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("inferno");
|
||||
|
@ -101,11 +101,11 @@ vtkm::cont::DataSet Make2DExplicitDataSet()
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperWireframer M;
|
||||
typedef vtkm::rendering::CanvasRayTracer C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
typedef vtkm::rendering::View2D V2;
|
||||
typedef vtkm::rendering::View1D V1;
|
||||
using M = vtkm::rendering::MapperWireframer;
|
||||
using C = vtkm::rendering::CanvasRayTracer;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
using V2 = vtkm::rendering::View2D;
|
||||
using V1 = vtkm::rendering::View1D;
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("samsel fire");
|
||||
|
@ -39,11 +39,11 @@ namespace
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperVolume M1;
|
||||
typedef vtkm::rendering::MapperConnectivity M2;
|
||||
typedef vtkm::rendering::MapperRayTracer R;
|
||||
typedef vtkm::rendering::CanvasRayTracer C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
using M1 = vtkm::rendering::MapperVolume;
|
||||
using M2 = vtkm::rendering::MapperConnectivity;
|
||||
using R = vtkm::rendering::MapperRayTracer;
|
||||
using C = vtkm::rendering::CanvasRayTracer;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("inferno");
|
||||
|
@ -37,11 +37,11 @@ namespace
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperGL M;
|
||||
typedef vtkm::rendering::CanvasEGL C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
typedef vtkm::rendering::View2D V2;
|
||||
typedef vtkm::rendering::View1D V1;
|
||||
using M = vtkm::rendering::MapperGL;
|
||||
using C = vtkm::rendering::CanvasEGL;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
using V2 = vtkm::rendering::View2D;
|
||||
using V1 = vtkm::rendering::View1D;
|
||||
|
||||
vtkm::cont::DataSetFieldAdd dsf;
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
|
@ -62,11 +62,11 @@ void RenderTests()
|
||||
{
|
||||
std::cout << "Press any key to cycle through datasets. ESC to quit." << std::endl;
|
||||
|
||||
typedef vtkm::rendering::MapperGL MapperType;
|
||||
typedef vtkm::rendering::CanvasGL CanvasType;
|
||||
typedef vtkm::rendering::View3D View3DType;
|
||||
typedef vtkm::rendering::View2D View2DType;
|
||||
typedef vtkm::rendering::View1D View1DType;
|
||||
using MapperType = vtkm::rendering::MapperGL;
|
||||
using CanvasType = vtkm::rendering::CanvasGL;
|
||||
using View3DType = vtkm::rendering::View3D;
|
||||
using View2DType = vtkm::rendering::View2D;
|
||||
using View1DType = vtkm::rendering::View1D;
|
||||
|
||||
vtkm::cont::DataSetFieldAdd dsf;
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
|
@ -60,10 +60,10 @@ static void displayCall()
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("inferno");
|
||||
|
||||
typedef vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG> M;
|
||||
typedef vtkm::rendering::CanvasGL C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
typedef vtkm::rendering::View2D V2;
|
||||
using M = vtkm::rendering::MapperGL<VTKM_DEFAULT_DEVICE_ADAPTER_TAG>;
|
||||
using C = vtkm::rendering::CanvasGL;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
using V2 = vtkm::rendering::View2D;
|
||||
|
||||
if (which == 0)
|
||||
vtkm::rendering::testing::Render<M, C, V3>(
|
||||
|
@ -35,11 +35,11 @@ namespace
|
||||
|
||||
void RenderTests()
|
||||
{
|
||||
typedef vtkm::rendering::MapperGL M;
|
||||
typedef vtkm::rendering::CanvasOSMesa C;
|
||||
typedef vtkm::rendering::View3D V3;
|
||||
typedef vtkm::rendering::View2D V2;
|
||||
typedef vtkm::rendering::View1D V1;
|
||||
using M = vtkm::rendering::MapperGL;
|
||||
using C = vtkm::rendering::CanvasOSMesa;
|
||||
using V3 = vtkm::rendering::View3D;
|
||||
using V2 = vtkm::rendering::View2D;
|
||||
using V1 = vtkm::rendering::View1D;
|
||||
|
||||
vtkm::cont::testing::MakeTestDataSet maker;
|
||||
vtkm::cont::ColorTable colorTable("inferno");
|
||||
|
@ -295,7 +295,7 @@ enum ArgStatus
|
||||
* @li @c Arg::Optional @copybrief Arg::Optional
|
||||
*
|
||||
*/
|
||||
typedef ArgStatus (*CheckArg)(const Option& option, bool msg);
|
||||
using CheckArg = ArgStatus (*)(const Option& option, bool msg);
|
||||
|
||||
/**
|
||||
* @brief Describes an option, its help text (usage) and how it should be parsed.
|
||||
|
@ -20,8 +20,8 @@ namespace internal {
|
||||
template <class Char>
|
||||
class FormatBuf : public std::basic_streambuf<Char> {
|
||||
private:
|
||||
typedef typename std::basic_streambuf<Char>::int_type int_type;
|
||||
typedef typename std::basic_streambuf<Char>::traits_type traits_type;
|
||||
using int_type = typename std::basic_streambuf<Char>::int_type;
|
||||
using traits_type = typename std::basic_streambuf<Char>::traits_type;
|
||||
|
||||
Buffer<Char> &buffer_;
|
||||
|
||||
@ -81,7 +81,7 @@ void format_arg(BasicFormatter<Char, ArgFormatter_> &f,
|
||||
output << value;
|
||||
|
||||
BasicStringRef<Char> str(&buffer[0], buffer.size());
|
||||
typedef internal::MakeArg< BasicFormatter<Char> > MakeArg;
|
||||
using MakeArg = internal::MakeArg< BasicFormatter<Char> >;
|
||||
format_str = f.format(format_str, MakeArg(str));
|
||||
}
|
||||
|
||||
|
@ -43,8 +43,8 @@ struct AverageByKey
|
||||
{
|
||||
struct AverageWorklet : public vtkm::worklet::WorkletReduceByKey
|
||||
{
|
||||
typedef void ControlSignature(KeysIn keys, ValuesIn<> valuesIn, ReducedValuesOut<> averages);
|
||||
typedef _3 ExecutionSignature(_2);
|
||||
using ControlSignature = void(KeysIn keys, ValuesIn<> valuesIn, ReducedValuesOut<> averages);
|
||||
using ExecutionSignature = _3(_2);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename ValuesVecType>
|
||||
@ -103,8 +103,8 @@ struct AverageByKey
|
||||
|
||||
struct DivideWorklet : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
template <class ValueType>
|
||||
VTKM_EXEC void operator()(const ValueType& v, const vtkm::Id& count, ValueType& vout) const
|
||||
|
@ -34,10 +34,10 @@ namespace worklet
|
||||
class CellAverage : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<> inPoints,
|
||||
FieldOutCell<> outCells);
|
||||
typedef void ExecutionSignature(PointCount, _2, _3);
|
||||
using ExecutionSignature = void(PointCount, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename PointValueVecType, typename OutType>
|
||||
|
@ -40,8 +40,8 @@ struct CellDeepCopy
|
||||
{
|
||||
struct CountCellPoints : vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn inputTopology, FieldOut<> numPointsInCell);
|
||||
typedef _2 ExecutionSignature(PointCount);
|
||||
using ControlSignature = void(CellSetIn inputTopology, FieldOut<> numPointsInCell);
|
||||
using ExecutionSignature = _2(PointCount);
|
||||
|
||||
VTKM_EXEC
|
||||
vtkm::IdComponent operator()(vtkm::IdComponent numPoints) const { return numPoints; }
|
||||
@ -49,10 +49,10 @@ struct CellDeepCopy
|
||||
|
||||
struct PassCellStructure : vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn inputTopology,
|
||||
using ControlSignature = void(CellSetIn inputTopology,
|
||||
FieldOut<> shapes,
|
||||
FieldOut<> pointIndices);
|
||||
typedef void ExecutionSignature(CellShape, PointIndices, _2, _3);
|
||||
using ExecutionSignature = void(CellShape, PointIndices, _2, _3);
|
||||
|
||||
template <typename CellShape, typename InPointIndexType, typename OutPointIndexType>
|
||||
VTKM_EXEC void operator()(const CellShape& inShape,
|
||||
|
@ -73,10 +73,10 @@ template <typename IntegrationTypeList>
|
||||
class CellMeasure : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> pointCoords,
|
||||
FieldOutCell<Scalar> volumesOut);
|
||||
typedef void ExecutionSignature(CellShape, PointCount, _2, _3);
|
||||
using ExecutionSignature = void(CellShape, PointCount, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellShape, typename PointCoordVecType, typename OutType>
|
||||
|
@ -231,11 +231,11 @@ public:
|
||||
using ClipTablesPortal = internal::ClipTables::DevicePortal<DeviceAdapter>;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<ScalarAll> scalars,
|
||||
FieldOutCell<IdType> clipTableIdxs,
|
||||
FieldOutCell<TypeClipStats> stats);
|
||||
typedef void ExecutionSignature(_2, CellShape, PointCount, _3, _4);
|
||||
using ExecutionSignature = void(_2, CellShape, PointCount, _3, _4);
|
||||
|
||||
VTKM_CONT
|
||||
ComputeStats(vtkm::Float64 value, const ClipTablesPortal& clipTables, bool invert)
|
||||
@ -307,7 +307,7 @@ public:
|
||||
{
|
||||
};
|
||||
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<ScalarAll> scalars,
|
||||
FieldInCell<IdType> clipTableIdxs,
|
||||
FieldInCell<TypeClipStats> cellSetIdxs,
|
||||
@ -315,7 +315,7 @@ public:
|
||||
WholeArrayInOut<EdgeInterp> interpolation,
|
||||
WholeArrayInOut<IdType> newPointsConnectivityReverseMap,
|
||||
WholeArrayOut<IdType> cellMapOutputToInput);
|
||||
typedef void ExecutionSignature(CellShape, InputIndex, _2, FromIndices, _3, _4, _5, _6, _7, _8);
|
||||
using ExecutionSignature = void(CellShape, InputIndex, _2, FromIndices, _3, _4, _5, _6, _7, _8);
|
||||
|
||||
VTKM_CONT
|
||||
GenerateCellSet(vtkm::Float64 value, const ClipTablesPortal clipTables)
|
||||
|
@ -32,8 +32,8 @@ namespace worklet
|
||||
class CrossProduct : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<VecAll>, FieldIn<VecAll>, FieldOut<VecAll>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<VecAll>, FieldIn<VecAll>, FieldOut<VecAll>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<T, 3>& vec1,
|
||||
|
@ -32,8 +32,8 @@ namespace worklet
|
||||
class DotProduct : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<VecAll>, FieldIn<VecAll>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<VecAll>, FieldIn<VecAll>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
template <typename T, vtkm::IdComponent Size>
|
||||
VTKM_EXEC void operator()(const vtkm::Vec<T, Size>& v1,
|
||||
|
@ -58,10 +58,10 @@ struct ExternalFaces
|
||||
class NumExternalFacesPerStructuredCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn inCellSet,
|
||||
using ControlSignature = void(CellSetIn inCellSet,
|
||||
FieldOut<> numFacesInCell,
|
||||
FieldInPoint<Vec3> pointCoordinates);
|
||||
typedef _2 ExecutionSignature(CellShape, _3);
|
||||
using ExecutionSignature = _2(CellShape, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_CONT
|
||||
@ -130,13 +130,13 @@ struct ExternalFaces
|
||||
class BuildConnectivityStructured : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn inCellSet,
|
||||
using ControlSignature = void(CellSetIn inCellSet,
|
||||
WholeCellSetIn<> inputCell,
|
||||
FieldOut<> faceShapes,
|
||||
FieldOut<> facePointCount,
|
||||
FieldOut<> faceConnectivity,
|
||||
FieldInPoint<Vec3> pointCoordinates);
|
||||
typedef void ExecutionSignature(CellShape, VisitIndex, InputIndex, _2, _3, _4, _5, _6);
|
||||
using ExecutionSignature = void(CellShape, VisitIndex, InputIndex, _2, _3, _4, _5, _6);
|
||||
using InputDomain = _1;
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
@ -321,8 +321,8 @@ struct ExternalFaces
|
||||
class NumFacesPerCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn inCellSet, FieldOut<> numFacesInCell);
|
||||
typedef _2 ExecutionSignature(CellShape);
|
||||
using ControlSignature = void(CellSetIn inCellSet, FieldOut<> numFacesInCell);
|
||||
using ExecutionSignature = _2(CellShape);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellShapeTag>
|
||||
@ -336,11 +336,11 @@ struct ExternalFaces
|
||||
class FaceHash : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldOut<> faceHashes,
|
||||
FieldOut<> originCells,
|
||||
FieldOut<> originFaces);
|
||||
typedef void ExecutionSignature(_2, _3, _4, CellShape, FromIndices, InputIndex, VisitIndex);
|
||||
using ExecutionSignature = void(_2, _3, _4, CellShape, FromIndices, InputIndex, VisitIndex);
|
||||
using InputDomain = _1;
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
@ -368,12 +368,12 @@ struct ExternalFaces
|
||||
class FaceCounts : public vtkm::worklet::WorkletReduceByKey
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(KeysIn keys,
|
||||
using ControlSignature = void(KeysIn keys,
|
||||
WholeCellSetIn<> inputCells,
|
||||
ValuesIn<> originCells,
|
||||
ValuesIn<> originFaces,
|
||||
ReducedValuesOut<> numOutputCells);
|
||||
typedef _5 ExecutionSignature(_2, _3, _4);
|
||||
using ExecutionSignature = _5(_2, _3, _4);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellSetType, typename OriginCellsType, typename OriginFacesType>
|
||||
@ -485,12 +485,12 @@ public:
|
||||
class NumPointsPerFace : public vtkm::worklet::WorkletReduceByKey
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(KeysIn keys,
|
||||
using ControlSignature = void(KeysIn keys,
|
||||
WholeCellSetIn<> inputCells,
|
||||
ValuesIn<> originCells,
|
||||
ValuesIn<> originFaces,
|
||||
ReducedValuesOut<> numPointsInFace);
|
||||
typedef _5 ExecutionSignature(_2, _3, _4, VisitIndex);
|
||||
using ExecutionSignature = _5(_2, _3, _4, VisitIndex);
|
||||
using InputDomain = _1;
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
@ -520,14 +520,14 @@ public:
|
||||
class BuildConnectivity : public vtkm::worklet::WorkletReduceByKey
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(KeysIn keys,
|
||||
using ControlSignature = void(KeysIn keys,
|
||||
WholeCellSetIn<> inputCells,
|
||||
ValuesIn<> originCells,
|
||||
ValuesIn<> originFaces,
|
||||
ReducedValuesOut<> shapesOut,
|
||||
ReducedValuesOut<> connectivityOut,
|
||||
ReducedValuesOut<> cellIdMapOut);
|
||||
typedef void ExecutionSignature(_2, _3, _4, VisitIndex, _5, _6, _7);
|
||||
using ExecutionSignature = void(_2, _3, _4, VisitIndex, _5, _6, _7);
|
||||
using InputDomain = _1;
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
@ -571,8 +571,8 @@ public:
|
||||
class IsPolyDataCell : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn inCellSet, FieldOut<> isPolyDataCell);
|
||||
typedef _2 ExecutionSignature(CellShape);
|
||||
using ControlSignature = void(CellSetIn inCellSet, FieldOut<> isPolyDataCell);
|
||||
using ExecutionSignature = _2(CellShape);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellShapeTag>
|
||||
@ -587,8 +587,8 @@ public:
|
||||
public:
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
|
||||
typedef void ControlSignature(CellSetIn inCellSet, FieldOut<> numPoints);
|
||||
typedef _2 ExecutionSignature(PointCount);
|
||||
using ControlSignature = void(CellSetIn inCellSet, FieldOut<> numPoints);
|
||||
using ExecutionSignature = _2(PointCount);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_EXEC vtkm::Id operator()(vtkm::Id count) const { return count; }
|
||||
@ -599,11 +599,11 @@ public:
|
||||
public:
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
|
||||
typedef void ControlSignature(CellSetIn inputTopology,
|
||||
using ControlSignature = void(CellSetIn inputTopology,
|
||||
FieldOut<> shapes,
|
||||
FieldOut<> pointIndices,
|
||||
FieldOut<> cellIdMapOut);
|
||||
typedef void ExecutionSignature(CellShape, PointIndices, InputIndex, _2, _3, _4);
|
||||
using ExecutionSignature = void(CellShape, PointIndices, InputIndex, _2, _3, _4);
|
||||
|
||||
template <typename CellShape, typename InPointIndexType, typename OutPointIndexType>
|
||||
VTKM_EXEC void operator()(const CellShape& inShape,
|
||||
|
@ -46,10 +46,10 @@ public:
|
||||
class ExtractCellsByVOI : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
WholeArrayIn<Vec3> coordinates,
|
||||
FieldOutCell<BoolType> passFlags);
|
||||
typedef _3 ExecutionSignature(PointCount, PointIndices, _2);
|
||||
using ExecutionSignature = _3(PointCount, PointIndices, _2);
|
||||
|
||||
VTKM_CONT
|
||||
ExtractCellsByVOI()
|
||||
|
@ -45,10 +45,10 @@ public:
|
||||
class ExtractPointsByVOI : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coordinates,
|
||||
FieldOutPoint<BoolType> passFlags);
|
||||
typedef _3 ExecutionSignature(_2);
|
||||
using ExecutionSignature = _3(_2);
|
||||
|
||||
VTKM_CONT
|
||||
ExtractPointsByVOI(const vtkm::ImplicitFunction* function, bool extractInside)
|
||||
|
@ -44,8 +44,8 @@ public:
|
||||
class SetBinInformationContent : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> freq, FieldOut<> informationContent);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<> freq, FieldOut<> informationContent);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
vtkm::Float64 FreqSum;
|
||||
|
||||
|
@ -67,8 +67,8 @@ public:
|
||||
class SetHistogramBin : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> value, FieldOut<> binIndex);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<> value, FieldOut<> binIndex);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
vtkm::Id numberOfBins;
|
||||
@ -98,10 +98,10 @@ public:
|
||||
class AdjacentDifference : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> inputIndex,
|
||||
using ControlSignature = void(FieldIn<IdType> inputIndex,
|
||||
WholeArrayIn<IdType> counts,
|
||||
FieldOut<IdType> outputCount);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename WholeArrayType>
|
||||
|
@ -65,12 +65,12 @@ public:
|
||||
class CalculatePowers : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> value,
|
||||
using ControlSignature = void(FieldIn<> value,
|
||||
FieldOut<> pow1Array,
|
||||
FieldOut<> pow2Array,
|
||||
FieldOut<> pow3Array,
|
||||
FieldOut<> pow4Array);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
using InputDomain = _1;
|
||||
|
||||
vtkm::Id numPowers;
|
||||
@ -98,8 +98,8 @@ public:
|
||||
class SubtractConst : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<> value, FieldOut<> diff);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldIn<> value, FieldOut<> diff);
|
||||
using ExecutionSignature = _2(_1);
|
||||
using InputDomain = _1;
|
||||
|
||||
FieldType constant;
|
||||
|
@ -168,8 +168,8 @@ struct KernelSplatterFilterUniformGrid
|
||||
//-----------------------------------------------------------------------
|
||||
struct zero_voxel : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, WorkIndex, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, WorkIndex, _2);
|
||||
//
|
||||
VTKM_CONT
|
||||
zero_voxel() {}
|
||||
@ -198,7 +198,7 @@ struct KernelSplatterFilterUniformGrid
|
||||
Kernel kernel_;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
@ -206,7 +206,7 @@ struct KernelSplatterFilterUniformGrid
|
||||
FieldOut<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
|
||||
VTKM_CONT
|
||||
GetFootprint(const vtkm::Vec<vtkm::Float64, 3>& o,
|
||||
@ -264,8 +264,8 @@ struct KernelSplatterFilterUniformGrid
|
||||
class ComputeLocalNeighborId : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, WorkIndex, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2, WorkIndex, _3);
|
||||
|
||||
VTKM_CONT
|
||||
ComputeLocalNeighborId() {}
|
||||
@ -296,7 +296,7 @@ struct KernelSplatterFilterUniformGrid
|
||||
Kernel kernel;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<>,
|
||||
using ControlSignature = void(FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
FieldIn<>,
|
||||
@ -304,7 +304,7 @@ struct KernelSplatterFilterUniformGrid
|
||||
FieldIn<>,
|
||||
FieldOut<>,
|
||||
FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, _6, _7, _8);
|
||||
|
||||
VTKM_CONT
|
||||
GetSplatValue(const vtkm::Vec<vtkm::Float64, 3>& orig,
|
||||
@ -361,8 +361,8 @@ struct KernelSplatterFilterUniformGrid
|
||||
class UpdateVoxelSplats : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<>, FieldIn<>, WholeArrayOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ControlSignature = void(FieldIn<>, FieldIn<>, WholeArrayOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
VTKM_CONT
|
||||
UpdateVoxelSplats() {}
|
||||
|
@ -32,8 +32,8 @@ namespace worklet
|
||||
class Magnitude : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<VecAll>, FieldOut<Scalar>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<VecAll>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T, typename T2>
|
||||
VTKM_EXEC void operator()(const T& inValue, T2& outValue) const
|
||||
|
@ -116,12 +116,12 @@ public:
|
||||
{
|
||||
};
|
||||
|
||||
typedef void ControlSignature(WholeArrayIn<ClassifyCellTagType> isoValues,
|
||||
using ControlSignature = void(WholeArrayIn<ClassifyCellTagType> isoValues,
|
||||
FieldInPoint<ClassifyCellTagType> fieldIn,
|
||||
CellSetIn cellset,
|
||||
FieldOutCell<IdComponentType> outNumTriangles,
|
||||
WholeArrayIn<IdComponentType> numTrianglesTable);
|
||||
typedef void ExecutionSignature(CellShape, _1, _2, _4, _5);
|
||||
using ExecutionSignature = void(CellShape, _1, _2, _4, _5);
|
||||
using InputDomain = _3;
|
||||
|
||||
template <typename IsoValuesType, typename FieldInType, typename NumTrianglesTablePortalType>
|
||||
@ -243,8 +243,8 @@ public:
|
||||
WholeArrayIn<ClassifyCellTagType> isoValues,
|
||||
FieldInPoint<ClassifyCellTagType> fieldIn // Input point field defining the contour
|
||||
);
|
||||
typedef void
|
||||
ExecutionSignature(CellShape, _2, _3, InputIndex, WorkIndex, VisitIndex, FromIndices);
|
||||
using ExecutionSignature =
|
||||
void(CellShape, _2, _3, InputIndex, WorkIndex, VisitIndex, FromIndices);
|
||||
|
||||
using InputDomain = _1;
|
||||
|
||||
@ -362,11 +362,11 @@ private:
|
||||
class MapPointField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Id2Type> interpolation_ids,
|
||||
using ControlSignature = void(FieldIn<Id2Type> interpolation_ids,
|
||||
FieldIn<Scalar> interpolation_weights,
|
||||
WholeArrayIn<> inputField,
|
||||
FieldOut<> output);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_CONT
|
||||
@ -411,12 +411,12 @@ struct MultiContourLess
|
||||
// ---------------------------------------------------------------------------
|
||||
struct MergeDuplicateValues : vtkm::worklet::WorkletReduceByKey
|
||||
{
|
||||
typedef void ControlSignature(KeysIn keys,
|
||||
using ControlSignature = void(KeysIn keys,
|
||||
ValuesIn<> valuesIn1,
|
||||
ValuesIn<> valuesIn2,
|
||||
ReducedValuesOut<> valueOut1,
|
||||
ReducedValuesOut<> valueOut2);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename T,
|
||||
@ -438,8 +438,8 @@ struct MergeDuplicateValues : vtkm::worklet::WorkletReduceByKey
|
||||
// ---------------------------------------------------------------------------
|
||||
struct CopyEdgeIds : vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<>, FieldOut<>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<>, FieldOut<>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
using InputDomain = _1;
|
||||
|
||||
VTKM_EXEC
|
||||
@ -501,13 +501,13 @@ private:
|
||||
vtkm::cont::ArrayHandleTransform<vtkm::cont::ArrayHandle<vtkm::Id2>, EdgeVertex<0>>;
|
||||
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn,
|
||||
using ControlSignature = void(CellSetIn,
|
||||
WholeCellSetIn<Point, Cell>,
|
||||
WholeArrayIn<Vec3> pointCoordinates,
|
||||
WholeArrayIn<Scalar> inputField,
|
||||
FieldOutPoint<Vec3> normals);
|
||||
|
||||
typedef void ExecutionSignature(CellCount, CellIndices, InputIndex, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(CellCount, CellIndices, InputIndex, _2, _3, _4, _5);
|
||||
|
||||
using InputDomain = _1;
|
||||
using ScatterType = vtkm::worklet::ScatterPermutation<typename PointIdsArray::StorageTag>;
|
||||
@ -580,8 +580,8 @@ public:
|
||||
WholeArrayIn<Scalar> weights,
|
||||
FieldInOutPoint<Vec3> normals);
|
||||
|
||||
typedef void
|
||||
ExecutionSignature(CellCount, CellIndices, InputIndex, _2, _3, _4, WorkIndex, _5, _6);
|
||||
using ExecutionSignature =
|
||||
void(CellCount, CellIndices, InputIndex, _2, _3, _4, WorkIndex, _5, _6);
|
||||
|
||||
using InputDomain = _1;
|
||||
using ScatterType = vtkm::worklet::ScatterPermutation<typename PointIdsArray::StorageTag>;
|
||||
|
@ -32,8 +32,8 @@ namespace worklet
|
||||
class Normal : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<VecAll>, FieldOut<VecAll>);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<VecAll>, FieldOut<VecAll>);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename T, typename T2>
|
||||
VTKM_EXEC void operator()(const T& inValue, T2& outValue) const
|
||||
@ -45,8 +45,8 @@ public:
|
||||
class Normalize : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldInOut<VecAll>);
|
||||
typedef void ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldInOut<VecAll>);
|
||||
using ExecutionSignature = void(_1);
|
||||
|
||||
template <typename T>
|
||||
VTKM_EXEC void operator()(T& value) const
|
||||
|
@ -35,10 +35,10 @@ namespace worklet
|
||||
class PointAverage : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInCell<> inCellField,
|
||||
FieldOutPoint<> outPointField);
|
||||
typedef void ExecutionSignature(CellCount, _2, _3);
|
||||
using ExecutionSignature = void(CellCount, _2, _3);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellValueVecType, typename OutType>
|
||||
|
@ -43,8 +43,8 @@ VTKM_EXEC T clamp(const T& val, const T& min, const T& max)
|
||||
class PointElevation : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Scalar>);
|
||||
using ExecutionSignature = _2(_1);
|
||||
|
||||
VTKM_CONT
|
||||
PointElevation()
|
||||
|
@ -35,8 +35,8 @@ template <typename T>
|
||||
class PointTransform : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<Vec3>, FieldOut<Vec3>);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ControlSignature = void(FieldIn<Vec3>, FieldOut<Vec3>);
|
||||
using ExecutionSignature = _2(_1);
|
||||
|
||||
VTKM_CONT
|
||||
PointTransform() {}
|
||||
|
@ -72,12 +72,12 @@ public:
|
||||
class ProbeUniformPoints : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> coords,
|
||||
WholeArrayIn<Vec3> points,
|
||||
WholeArrayOut<IdType> cellIds,
|
||||
WholeArrayOut<Vec3> parametricCoords);
|
||||
typedef void ExecutionSignature(InputIndex, CellShape, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(InputIndex, CellShape, _2, _3, _4, _5);
|
||||
using InputDomain = _1;
|
||||
|
||||
template <typename CellShapeTag,
|
||||
@ -181,12 +181,12 @@ public:
|
||||
class InterpolatePointField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> cellIds,
|
||||
using ControlSignature = void(FieldIn<IdType> cellIds,
|
||||
FieldIn<Vec3> parametricCoords,
|
||||
WholeCellSetIn<> inputCells,
|
||||
WholeArrayIn<> inputField,
|
||||
FieldOut<> result);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5);
|
||||
|
||||
template <typename ParametricCoordType, typename CellSetType, typename InputFieldPortalType>
|
||||
VTKM_EXEC void operator()(vtkm::Id cellId,
|
||||
@ -229,10 +229,10 @@ public:
|
||||
class MapCellField : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> cellIds,
|
||||
using ControlSignature = void(FieldIn<IdType> cellIds,
|
||||
WholeArrayIn<> inputField,
|
||||
FieldOut<> result);
|
||||
typedef void ExecutionSignature(_1, _2, _3);
|
||||
using ExecutionSignature = void(_1, _2, _3);
|
||||
|
||||
template <typename InputFieldPortalType>
|
||||
VTKM_EXEC void operator()(vtkm::Id cellId,
|
||||
@ -263,9 +263,9 @@ public:
|
||||
//============================================================================
|
||||
struct HiddenPointsWorklet : public WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<IdType> cellids,
|
||||
using ControlSignature = void(FieldIn<IdType> cellids,
|
||||
FieldOut<vtkm::ListTagBase<vtkm::UInt8>> hfield);
|
||||
typedef _2 ExecutionSignature(_1);
|
||||
using ExecutionSignature = _2(_1);
|
||||
|
||||
VTKM_EXEC vtkm::UInt8 operator()(vtkm::Id cellId) const { return (cellId == -1) ? HIDDEN : 0; }
|
||||
};
|
||||
@ -285,10 +285,10 @@ public:
|
||||
//============================================================================
|
||||
struct HiddenCellsWorklet : public WorkletMapPointToCell
|
||||
{
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<IdType> cellids,
|
||||
FieldOutCell<vtkm::ListTagBase<vtkm::UInt8>>);
|
||||
typedef _3 ExecutionSignature(_2, PointCount);
|
||||
using ExecutionSignature = _3(_2, PointCount);
|
||||
|
||||
template <typename CellIdsVecType>
|
||||
VTKM_EXEC vtkm::UInt8 operator()(const CellIdsVecType& cellIds,
|
||||
|
@ -51,8 +51,8 @@ public:
|
||||
///
|
||||
struct GeneratePointMask : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<> pointIndices, WholeArrayInOut<> pointMask);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<> pointIndices, WholeArrayInOut<> pointMask);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
template <typename PointMaskPortalType>
|
||||
VTKM_EXEC void operator()(vtkm::Id pointIndex, const PointMaskPortalType& pointMask) const
|
||||
@ -68,10 +68,10 @@ public:
|
||||
///
|
||||
struct TransformPointIndices : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<IdType> pointIndex,
|
||||
using ControlSignature = void(FieldIn<IdType> pointIndex,
|
||||
WholeArrayIn<IdType> indexMap,
|
||||
FieldOut<IdType> mappedPoints);
|
||||
typedef _3 ExecutionSignature(_1, _2);
|
||||
using ExecutionSignature = _3(_1, _2);
|
||||
|
||||
template <typename IndexMapPortalType>
|
||||
VTKM_EXEC vtkm::Id operator()(vtkm::Id pointIndex, const IndexMapPortalType& indexPortal) const
|
||||
|
@ -162,12 +162,12 @@ public:
|
||||
class MakeStreamLines : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(FieldIn<IdType> seedId,
|
||||
using ControlSignature = void(FieldIn<IdType> seedId,
|
||||
FieldIn<> position,
|
||||
WholeArrayOut<IdComponentType> numIndices,
|
||||
WholeArrayOut<IdComponentType> validPoint,
|
||||
WholeArrayOut<Vec3> streamLines);
|
||||
typedef void ExecutionSignature(_1, _2, _3, _4, _5, VisitIndex);
|
||||
using ExecutionSignature = void(_1, _2, _3, _4, _5, VisitIndex);
|
||||
using InputDomain = _1;
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterUniform<2>;
|
||||
|
@ -60,10 +60,10 @@ public:
|
||||
class Worklet : public vtkm::worklet::WorkletMapPointToCell
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInPoint<Vec3> points,
|
||||
FieldOutCell<Vec3> normals);
|
||||
typedef void ExecutionSignature(CellShape, _2, _3);
|
||||
using ExecutionSignature = void(CellShape, _2, _3);
|
||||
|
||||
using InputDomain = _1;
|
||||
|
||||
@ -176,10 +176,10 @@ public:
|
||||
class Worklet : public vtkm::worklet::WorkletMapCellToPoint
|
||||
{
|
||||
public:
|
||||
typedef void ControlSignature(CellSetIn cellset,
|
||||
using ControlSignature = void(CellSetIn cellset,
|
||||
FieldInCell<Vec3> faceNormals,
|
||||
FieldOutPoint<Vec3> pointNormals);
|
||||
typedef void ExecutionSignature(CellCount, _2, _3);
|
||||
using ExecutionSignature = void(CellCount, _2, _3);
|
||||
|
||||
using InputDomain = _1;
|
||||
|
||||
|
@ -36,8 +36,8 @@ public:
|
||||
//
|
||||
struct DistributeCellData : public vtkm::worklet::WorkletMapField
|
||||
{
|
||||
typedef void ControlSignature(FieldIn<> inIndices, FieldOut<> outIndices);
|
||||
typedef void ExecutionSignature(_1, _2);
|
||||
using ControlSignature = void(FieldIn<> inIndices, FieldOut<> outIndices);
|
||||
using ExecutionSignature = void(_1, _2);
|
||||
|
||||
using ScatterType = vtkm::worklet::ScatterCounting;
|
||||
|
||||
|
Some files were not shown because too many files have changed in this diff Show More
Loading…
Reference in New Issue
Block a user