Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-08 13:23:51 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity

Change function signatures to use 'using' aliases.

Browse Source 
Also cleaned up some lingering type typedefs.
This commit is contained in:
Allison Vacanti 2018-05-25 17:18:41 -04:00
parent a8f4f13371
commit 93506d25e2
202 changed files with 1054 additions and 1104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
benchmarking/BenchmarkFieldAlgorithms.cxx
View File

@ -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)

12
benchmarking/BenchmarkTopologyAlgorithms.cxx
View File

@ -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;

10
examples/dynamic_dispatcher/main.cxx
View File

@ -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,

4
examples/game_of_life/GameOfLife.cxx
View File

@ -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,

4
examples/hello_world/HelloWorld.cxx
View File

@ -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,

4
examples/isosurface/IsosurfaceUniformGrid.cxx
View File

@ -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;

4
examples/multi_backend/IOGenerator.cxx
View File

@ -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

4
examples/tau_timing/TauTiming.cxx
View File

@ -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;

8
examples/unified_memory/UnifiedMemory.cu
View File

@ -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

4
vtkm/cont/CellLocator.h
View File

@ -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,

28
vtkm/cont/CellLocatorTwoLevelUniformGrid.h
View File

@ -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;

4
vtkm/cont/CellSetPermutation.h
View File

@ -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>

8
vtkm/cont/PointLocatorUniformGrid.h
View File

@ -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,

8
vtkm/cont/internal/ConnectivityExplicitInternals.h
View File

@ -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>

4
vtkm/cont/tbb/internal/ParallelSortTBB.cxx
View File

@ -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_);

4
vtkm/cont/testing/TestingArrayHandleVirtualCoordinates.h
View File

@ -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

4
vtkm/cont/testing/TestingArrayHandles.h
View File

@ -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

4
vtkm/cont/testing/TestingCellLocatorTwoLevelUniformGrid.h
View File

@ -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<>;

4
vtkm/cont/testing/TestingDeviceAdapter.h
View File

@ -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

16
vtkm/cont/testing/TestingFancyArrayHandles.h
View File

@ -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

4
vtkm/cont/testing/TestingImplicitFunction.h
View File

@ -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)

4
vtkm/cont/testing/TestingPointLocatorUniformGrid.h
View File

@ -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() {}

8
vtkm/cont/testing/UnitTestCellSetExplicit.cxx
View File

@ -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>

12
vtkm/cont/testing/UnitTestCellSetPermutation.cxx
View File

@ -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>

22
vtkm/exec/arg/testing/UnitTestFetchArrayTopologyMapIn.cxx
View File

@ -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>(

10
vtkm/exec/cuda/internal/testing/UnitTestTaskStrided.cu
View File

@ -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,

80
vtkm/exec/internal/WorkletInvokeFunctorDetail.h
View File

@ -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;

10
vtkm/exec/internal/testing/TestingTaskTiling.h
View File

@ -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,

10
vtkm/exec/internal/testing/UnitTestTaskSingular.cxx
View File

@ -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,

6
vtkm/exec/internal/testing/UnitTestWorkletInvokeFunctor.cxx
View File

@ -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.

2
vtkm/filter/CrossProduct.h
View File

@ -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

2
vtkm/filter/DotProduct.h
View File

@ -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

4
vtkm/filter/testing/UnitTestEntropyFilter.cxx
View File

@ -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;

4
vtkm/filter/testing/UnitTestMarchingCubesFilter.cxx
View File

@ -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;

2
vtkm/internal/FunctionInterface.h
View File

@ -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);

42
vtkm/internal/FunctionInterfaceDetailPost.h
View File

@ -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,

2
vtkm/internal/FunctionInterfaceDetailPost.h.in
View File

@ -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\

4
vtkm/internal/FunctionInterfaceDetailPre.h
View File

@ -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>

4
vtkm/internal/FunctionInterfaceDetailPre.h.in
View File

@ -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>

2
vtkm/internal/testing/UnitTestFunctionInterface.cxx
View File

@ -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;

22
vtkm/rendering/Canvas.cxx
View File

@ -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)

4
vtkm/rendering/CanvasRayTracer.cxx
View File

@ -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,

4
vtkm/rendering/ConnectivityProxy.cxx
View File

@ -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;

6
vtkm/rendering/MapperGL.cxx
View File

@ -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,

16
vtkm/rendering/MapperWireframer.cxx
View File

@ -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;

9
vtkm/rendering/TextRenderer.cxx
View File

@ -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

34
vtkm/rendering/Triangulator.h
View File

@ -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,

12
vtkm/rendering/Wireframer.h
View File

@ -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,

66
vtkm/rendering/raytracing/BoundingVolumeHierarchy.cxx
View File

@ -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
{

4
vtkm/rendering/raytracing/BoundingVolumeHierarchy.h
View File

@ -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;

19
vtkm/rendering/raytracing/Camera.cxx
View File

@ -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,

20
vtkm/rendering/raytracing/ChannelBuffer.cxx
View File

@ -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

8
vtkm/rendering/raytracing/ChannelBufferOperations.h
View File

@ -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,

56
vtkm/rendering/raytracing/ConnectivityTracer.hxx
View File

@ -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,

37
vtkm/rendering/raytracing/MeshConnectivityBuilder.h
View File

@ -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,

44
vtkm/rendering/raytracing/MeshConnectivityStructures.h
View File

@ -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;

15
vtkm/rendering/raytracing/MortonCodes.h
View File

@ -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

8
vtkm/rendering/raytracing/RayOperations.h
View File

@ -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,

48
vtkm/rendering/raytracing/RayTracer.cxx
View File

@ -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,

40
vtkm/rendering/raytracing/RayTracingTypeDefs.h
View File

@ -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

24
vtkm/rendering/raytracing/TriangleIntersector.h
View File

@ -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
{

34
vtkm/rendering/raytracing/VolumeRendererStructured.cxx
View File

@ -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,

6
vtkm/rendering/raytracing/VolumeRendererStructured.h
View File

@ -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();

20
vtkm/rendering/raytracing/Worklets.h
View File

@ -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

6
vtkm/rendering/testing/UnitTestMapperConnectivity.cxx
View File

@ -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");

8
vtkm/rendering/testing/UnitTestMapperRayTracer.cxx
View File

@ -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");

6
vtkm/rendering/testing/UnitTestMapperVolume.cxx
View File

@ -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");

10
vtkm/rendering/testing/UnitTestMapperWireframer.cxx
View File

@ -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");

10
vtkm/rendering/testing/UnitTestMultiMapper.cxx
View File

@ -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");

10
vtkm/rendering/testing/egl/UnitTestMapperEGL.cxx
View File

@ -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;

10
vtkm/rendering/testing/glfw/UnitTestMapperGLFW.cxx
View File

@ -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;

8
vtkm/rendering/testing/glut/UnitTestMapperGLUT.cxx
View File

@ -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>(

10
vtkm/rendering/testing/osmesa/UnitTestMapperOSMesa.cxx
View File

@ -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");

2
vtkm/testing/OptionParser.h
View File

@ -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.

6
vtkm/thirdparty/diy/vtkmdiy/include/vtkmdiy/fmt/ostream.h vendored
View File

@ -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));
}

8
vtkm/worklet/AverageByKey.h
View File

@ -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

4
vtkm/worklet/CellAverage.h
View File

@ -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>

8
vtkm/worklet/CellDeepCopy.h
View File

@ -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,

4
vtkm/worklet/CellMeasure.h
View File

@ -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>

8
vtkm/worklet/Clip.h
View File

@ -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)

4
vtkm/worklet/CrossProduct.h
View File

@ -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,

4
vtkm/worklet/DotProduct.h
View File

@ -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,

40
vtkm/worklet/ExternalFaces.h
View File

@ -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,

4
vtkm/worklet/ExtractGeometry.h
View File

@ -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()

4
vtkm/worklet/ExtractPoints.h
View File

@ -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)

4
vtkm/worklet/FieldEntropy.h
View File

@ -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;

8
vtkm/worklet/FieldHistogram.h
View File

@ -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>

8
vtkm/worklet/FieldStatistics.h
View File

@ -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;

20
vtkm/worklet/KernelSplatter.h
View File

@ -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() {}

4
vtkm/worklet/Magnitude.h
View File

@ -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

28
vtkm/worklet/MarchingCubes.h
View File

@ -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>;

8
vtkm/worklet/Normalize.h
View File

@ -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

4
vtkm/worklet/PointAverage.h
View File

@ -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>

4
vtkm/worklet/PointElevation.h
View File

@ -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()

4
vtkm/worklet/PointTransform.h
View File

@ -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() {}

20
vtkm/worklet/Probe.h
View File

@ -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,

8
vtkm/worklet/RemoveUnusedPoints.h
View File

@ -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

4
vtkm/worklet/StreamLineUniformGrid.h
View File

@ -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>;

8
vtkm/worklet/SurfaceNormals.h
View File

@ -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;

4
vtkm/worklet/Tetrahedralize.h
View File

@ -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