ViennaPS/gpu/include/models/CallableWrapper.cu at cb0da4e80bc05157951c9c980068a5b836d7943b · ViennaTools/ViennaPS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
// #pragma once

#include "FaradayCage.cuh"
#include "IonBeamEtching.cuh"
#include "MultiParticle.cuh"
#include "PlasmaEtching.cuh"
#include "SingleParticle.cuh"
#include "SingleParticleALD.cuh"

//
// --- Direct Callables wrapper
//
// - Direct callables must not call any OptiX API functions
//   (e.g. OptixGetPrimitiveIndex(), etc.)
// - Every wrapper must take the same amount of parameters

// OptiX does not check for function signature, therefore
// the noop can take any parameters
extern "C" __device__ void __direct_callable__noop(void *, void *) {
  // does nothing
  // If a reflection is linked to this function, the program
  // will run indefinitely
}

//
// --- SingleParticle pipeline
//

extern "C" __device__ void
__direct_callable__singleNeutralCollision(const void *sbtData,
                                          viennaray::gpu::PerRayData *prd) {
  singleNeutralCollision(prd);
}

extern "C" __device__ void
__direct_callable__singleNeutralReflection(const void *sbtData,
                                           viennaray::gpu::PerRayData *prd) {
  singleNeutralReflection(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__singleALDNeutralReflection(const void *sbtData,
                                              viennaray::gpu::PerRayData *prd) {
  singleALDNeutralReflection(sbtData, prd);
}

//
// --- MultParticle pipeline
//

extern "C" __device__ void
__direct_callable__multiNeutralCollision(const void *sbtData,
                                         viennaray::gpu::PerRayData *prd) {
  multiNeutralCollision(prd);
}

extern "C" __device__ void
__direct_callable__multiNeutralReflection(const void *sbtData,
                                          viennaray::gpu::PerRayData *prd) {
  multiNeutralReflection(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__multiIonCollision(const void *sbtData,
                                     viennaray::gpu::PerRayData *prd) {
  multiIonCollision(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__multiIonReflection(const void *sbtData,
                                      viennaray::gpu::PerRayData *prd) {
  multiIonReflection(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__multiIonInit(const void *, viennaray::gpu::PerRayData *prd) {
  multiIonInit(prd);
}

//
// --- PlasmaEtching pipeline
//

extern "C" __device__ void
__direct_callable__plasmaNeutralCollision(const void *sbtData,
                                          viennaray::gpu::PerRayData *prd) {
  plasmaNeutralCollision(prd);
}

extern "C" __device__ void
__direct_callable__plasmaNeutralReflection(const void *sbtData,
                                           viennaray::gpu::PerRayData *prd) {
  plasmaNeutralReflection(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__plasmaNeutralReflectionNoPassivation(
    const void *sbtData, viennaray::gpu::PerRayData *prd) {
  plasmaNeutralReflectionNoPassivation(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__plasmaIonCollision(const void *sbtData,
                                      viennaray::gpu::PerRayData *prd) {
  plasmaIonCollision(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__plasmaIonReflection(const void *sbtData,
                                       viennaray::gpu::PerRayData *prd) {
  plasmaIonReflection(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__plasmaIonInit(const void *,
                                 viennaray::gpu::PerRayData *prd) {
  plasmaIonInit(prd);
}

//
// --- IonBeamEtching pipeline
//

extern "C" __device__ void
__direct_callable__IBECollision(const void *sbtData,
                                viennaray::gpu::PerRayData *prd) {
  IBECollision(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__IBEReflection(const void *sbtData,
                                 viennaray::gpu::PerRayData *prd) {
  IBEReflection(sbtData, prd);
}

extern "C" __device__ void
__direct_callable__IBEInit(const void *, viennaray::gpu::PerRayData *prd) {
  IBEInit(prd);
}

//
// --- FaradayCage pipeline
//

extern "C" __device__ void
__direct_callable__faradayCollision(const void *sbtData,
                                    viennaray::gpu::PerRayData *prd) {
  faradayIonCollision(sbtData, prd);
}