Compatible Android
This commit is contained in:
Andros Fenollosa
@ -0,0 +1,205 @@
|
||||
-- authors: Luxinia Dev (Eike Decker & Christoph Kubisch)
|
||||
---------------------------------------------------------
|
||||
|
||||
local function fn (description)
|
||||
local description2,returns,args = description:match("(.+)%-%s*(%b())%s*(%b())")
|
||||
if not description2 then
|
||||
return {type="function",description=description,
|
||||
returns="(?)"}
|
||||
end
|
||||
return {type="function",description=description2,
|
||||
returns=returns:gsub("^%s+",""):gsub("%s+$",""), args = args}
|
||||
end
|
||||
|
||||
local function val (description)
|
||||
return {type="value",description = description}
|
||||
end
|
||||
-- docs
|
||||
local api = {
|
||||
abs = fn "returns absolute value of scalars and vectors. - (typeN)(typeN)",
|
||||
acos = fn "returns arccosine of scalars and vectors. - (typeN)(typeN)",
|
||||
all = fn "returns true if a boolean scalar or all components of a boolean vector are true. - (bool)(boolN)",
|
||||
any = fn "returns true if a boolean scalar or any component of a boolean vector is true. - (bool)(boolN)",
|
||||
asin = fn "returns arcsine of scalars and vectors. - (typeN)(typeN)",
|
||||
atan = fn "returns arctangent of scalars and vectors. - (typeN)(typeN)",
|
||||
atan2 = fn "returns the arctangent of y/x. atan2 is well defined for every point other than the origin, even if x equals 0 and y does not equal 0. - (typeN)(typeN y, typeN x)",
|
||||
ceil = fn "returns smallest integer not less than a scalar or each vector component. - (typeN)(typeN)",
|
||||
clamp = fn "returns x clamped to the range [a,b]. - (typeN)(typeN x, a, b)",
|
||||
clip = fn "conditionally (<0) kill a pixel before output. - ()(typeN)",
|
||||
cos = fn "returns cosine of scalars and vectors. - (typeN)(typeN)",
|
||||
cosh = fn "returns hyperbolic cosine of scalars and vectors. - (typeN)(typeN)",
|
||||
cross = fn "returns the cross product of two three-component vectors. - (type3)(type3 a, b)",
|
||||
ddx = fn "returns approximate partial derivative with respect to window-space X. - (typeN)(typeN)",
|
||||
ddy = fn "returns approximate partial derivative with respect to window-space Y. - (typeN)(typeN)",
|
||||
degrees = fn "converts values of scalars and vectors from radians to degrees. - (typeN)(typeN)",
|
||||
determinant = fn "returns the scalar determinant of a square matrix. - (float)(floatNxN)",
|
||||
distance = fn "return the Euclidean distance between two points. - (typeN)(typeN a, b)",
|
||||
dot = fn "returns the scalar dot product of two vectors. - (type)(typeN a, b)",
|
||||
exp = fn "returns the base-e exponential of scalars and vectors. - (typeN)(typeN)",
|
||||
exp2 = fn "returns the base-2 exponential of scalars and vectors. - (typeN)(typeN)",
|
||||
faceforward = fn "returns a normal as-is if a vertex's eye-space position vector points in the opposite direction of a geometric normal, otherwise return the negated version of the normal. - (typeN)(typeN Nperturbated, Incident, Ngeometric)",
|
||||
floatToIntBits = fn "returns the 32-bit integer representation of an IEEE 754 floating-point scalar or vector - (intN)(floatN)",
|
||||
floatToRawIntBits = fn "returns the raw 32-bit integer representation of an IEEE 754 floating-point scalar or vector. - (intN)(floatN)",
|
||||
floor = fn "returns largest integer not greater than a scalar or each vector component. - (typeN)(typeN)",
|
||||
fmod = fn "returns the remainder of x/y with the same sign as x. - (typeN)(typeN x, y)",
|
||||
frac = fn "returns the fractional portion of a scalar or each vector component. - (typeN)(typeN)",
|
||||
frexp = fn "splits scalars and vectors into normalized fraction and a power of 2. - (typeN)(typeN x, out typeN e)",
|
||||
fwidth = fn "returns sum of approximate window-space partial derivatives magnitudes. - (typeN)(typeN)",
|
||||
intBitsToFloat = fn "returns the float value corresponding to a given bit represention.of a scalar int value or vector of int values. - (floatN)(intN)",
|
||||
isfinite = fn "test whether or not a scalar or each vector component is a finite value. - (boolN)(typeN)",
|
||||
isinf = fn "test whether or not a scalar or each vector component is infinite. - (boolN)(typeN)",
|
||||
isnan = fn "test whether or not a scalar or each vector component is not-a-number. - (boolN)(typeN)",
|
||||
ldexp = fn "returns x times 2 rained to n. - (typeN)(typeN a, n)",
|
||||
length = fn "return scalar Euclidean length of a vector. - (type)(typeN)",
|
||||
lerp = fn "lerp - returns linear interpolation of two scalars or vectors based on a weight. - (typeN)(typeN a, b, weight)",
|
||||
lit = fn "computes lighting coefficients for ambient(x), diffuse(y), and specular(z) lighting contributions (w=1). - (type4)(type NdotL, NdotH, specshiny)",
|
||||
log = fn "returns the natural logarithm of scalars and vectors. - (typeN)(typeN)",
|
||||
log10 = fn "returns the base-10 logarithm of scalars and vectors. - (typeN)(typeN)",
|
||||
log2 = fn "returns the base-2 logarithm of scalars and vectors. - (typeN)(typeN)",
|
||||
max = fn "returns the maximum of two scalars or each respective component of two vectors. - (typeN)(typeN a, b)",
|
||||
min = fn "returns the minimum of two scalars or each respective component of two vectors. - (typeN)(typeN a, b)",
|
||||
mul = fn "Returns the vector result of multiplying a matrix M by a column vector v; a row vector v by a matrix M; or a matrix A by a second matrix B. - (typeN)(typeNxN/typeN a, typeN/typeNxN b)",
|
||||
normalize = fn "Returns the normalized version of a vector, meaning a vector in the same direction as the original vector but with a Euclidean length of one. - (typeN)(typeN)",
|
||||
pow = fn "returns x to the y-th power of scalars and vectors. - (typeN)(typeN x, y)",
|
||||
radians = fn "converts values of scalars and vectors from degrees to radians. - (typeN)(typeN)",
|
||||
reflect = fn "returns the reflectiton vector given an incidence vector and a normal vector. - (typeN)(typeN incidence, normal)",
|
||||
refract = fn "computes a refraction vector. - (typeN)(typeN incidence, normal, type eta)",
|
||||
round = fn "returns the rounded value of scalars or vectors. - (typeN)(typeN a)",
|
||||
rsqrt = fn "returns reciprocal square root of scalars and vectors. 1/sqrt. - (typeN)(typeN)",
|
||||
saturate = fn "returns x saturated to the range [0,1]. - (typeN)(typeN)",
|
||||
sign = fn "returns sign (1 or -1) of scalar or each vector component. - (typeN)(typeN)",
|
||||
sin = fn "returns sine of scalars and vectors. - (typeN)(typeN)",
|
||||
sincos = fn "returns sine of scalars and vectors. - ()(typeN x, out typeN sin, out typeN cos)",
|
||||
sinh = fn "returns hyperbolic sine of scalars and vectors. - (typeN)(typeN)",
|
||||
sqrt = fn "returns square root of scalars and vectors. - (typeN)(typeN)",
|
||||
step = fn "implement a step function returning either zero or one (a <= b). - (typeN)(typeN a, b)",
|
||||
tan = fn "returns tangent of scalars and vectors. - (typeN)(typeN)",
|
||||
tanh = fn "returns hyperbolic tangent of scalars and vectors. - (typeN)(typeN)",
|
||||
transpose = fn "returns transpose matrix of a matrix. - (typeRxC)(typeCxR)",
|
||||
trunc = fn "returns largest integer not greater than a scalar or each vector component. - (typeN)(typeN)",
|
||||
|
||||
tex1D = fn "performs a texture lookup in a given 1D sampler and, in some cases, a shadow comparison (as .y coord). May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(sampler1D, float/float2 s, |float dx, dy|,[int texeloffset])",
|
||||
tex1Dbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(sampler1D, float4 s, [int texeloffset])",
|
||||
tex1Dcmpbias = fn "performs a texture lookup with bias and shadow compare in a given sampler (compare as .y, bias as .w). - (float4)(sampler1D, float4 s, [int texeloffset])",
|
||||
tex1Dcmplod = fn "performs a texture lookup with a specified level of detail and a shadow compare in a given sampler (compare as .y, lod as .w). - (float4)(sampler1D, float4 s, [int texeloffset])",
|
||||
tex1Dfetch = fn "performs an unfiltered texture lookup in a given sampler (lod as .w). - (float4)(sampler1D, int4 s, [int texeloffset])",
|
||||
tex1Dlod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .w) - (float4)(sampler1D, float4 s, [int texeloffset])",
|
||||
tex1Dproj = fn "performs a texture lookup with projection in a given sampler. May perform a shadow comparison if argument for shadow comparison is provided. (shadow in .y for float3 coord, proj in .y or .z) - (float4)(sampler1D, float2/float3 s, [int texeloff])",
|
||||
tex1Dsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler1D, int lod)",
|
||||
|
||||
tex2D = fn "performs a texture lookup in a given 2D sampler and, in some cases, a shadow comparison (as .z coord). May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(sampler2D, float2/float3 s, |float2 dx, dy|,[int texeloffset])",
|
||||
tex2Dbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(sampler2D, float4 s, [int texeloffset])",
|
||||
tex2Dcmpbias = fn "performs a texture lookup with bias and shadow compare in a given sampler (compare as .z, bias as .w). - (float4)(sampler2D, float4 s, [int texeloffset])",
|
||||
tex2Dcmplod = fn "performs a texture lookup with a specified level of detail and a shadow compare in a given sampler (compare as .y, lod as .w). - (float4)(sampler2D, float4 s, [int texeloffset])",
|
||||
tex2Dfetch = fn "performs an unfiltered texture lookup in a given sampler (lod as .w). - (float4)(sampler2D, int4 s, [int texeloffset])",
|
||||
tex2Dlod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .w) - (float4)(sampler2D, float4 s, [int texeloffset])",
|
||||
tex2Dproj = fn "performs a texture lookup with projection in a given sampler. May perform a shadow comparison if argument for shadow comparison is provided. (shadow in .z for float3 coord, proj in .z or .w) - (float4)(sampler2D, float3/float4 s, [int texeloff])",
|
||||
tex2Dsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler2D, int lod)",
|
||||
tex2Dgather = fn "returns 4 texels of a given single channel texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler2D, int lod)",
|
||||
|
||||
tex3D = fn "performs a texture lookup in a given 3D sampler. May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(sampler3D, float3 s, {float3 dx, dy},[int texeloffset])",
|
||||
tex3Dbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(sampler3D, float4 s, [int texeloffset])",
|
||||
tex3Dfetch = fn "performs an unfiltered texture lookup in a given sampler (lod as .w). - (float4)(sampler3D, int4 s, [int texeloffset])",
|
||||
tex3Dlod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .w) - (float4)(sampler3D, float4 s, [int texeloffset])",
|
||||
tex3Dproj = fn "performs a texture lookup with projection in a given sampler. (proj in .w) - (float4)(sampler3D, float4 s, [int texeloff])",
|
||||
tex3Dsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler3D, int lod)",
|
||||
|
||||
texBUF = fn "performs an unfiltered texture lookup in a given texture buffer sampler. (only gp4 profiles) - (float4)(samplerBUF, int s)",
|
||||
texBUFsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(samplerBUF, int lod)",
|
||||
|
||||
texRBUF = fn "performs a multi-sampled texture lookup in a renderbuffer. (only gp4 profiles) - (float4)(samplerRBUF, int2 s, int sample)",
|
||||
texRBUFsize = fn "returns the size of a given renderbuffer. (only gp4 profiles) - (int2)(samplerBUF)",
|
||||
|
||||
texCUBE = fn "performs a texture lookup in a given CUBE sampler and, in some cases, a shadow comparison (float4 coord). May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(samplerCUBE, float3/float4 s, |float3 dx, dy|)",
|
||||
texCUBEbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(sampler1D, float4 s, [int texeloffset])",
|
||||
texCUBElod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .w) - (float4)(sampler1D, float4 s, [int texeloffset])",
|
||||
texCUBEproj = fn "performs a texture lookup with projection in a given sampler. (proj in .w) - (float4)(samplerCUBE, float4 s)",
|
||||
texCUBEsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler1D, int lod)",
|
||||
|
||||
texRECT = fn "performs a texture lookup in a given RECT sampler and, in some cases, a shadow comparison (as .z). May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(samplerRECT, float2/float3 s, |float2 dx, dy|, [int texeloff])",
|
||||
texRECTbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(samplerRECT, float4 s, [int texeloffset])",
|
||||
texRECTfetch = fn "performs an unfiltered texture lookup in a given sampler (lod as .w). - (float4)(samplerRECT, int4 s, [int texeloffset])",
|
||||
texRECTlod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .w) - (float4)(samplerRECT, float4 s, [int texeloffset])",
|
||||
texRECTproj = fn "performs a texture lookup with projection in a given sampler. May perform a shadow comparison if argument for shadow comparison is provided. (shadow in .z for float3 coord, proj in .z or .w) - (float4)(samplerRECT, float3/float4 s, [int texeloff])",
|
||||
texRECTsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(samplerRECT, int lod)",
|
||||
|
||||
tex1DARRAY = fn "performs a texture lookup in a given 1D sampler array and, in some cases, a shadow comparison (as .z). May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(sampler1DARRAY, float2/float3 s, {float dx, dy},[int texeloffset])",
|
||||
tex1DARRAYbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(sampler1DARRAY, float4 s, [int texeloffset])",
|
||||
tex1DARRAYcmpbias = fn "performs a texture lookup with bias and shadow compare in a given sampler (layer as .y, compare as .z, bias as .w). - (float4)(sampler1DARRAY, float4 s, [int texeloffset])",
|
||||
tex1DARRAYcmplod = fn "performs a texture lookup with a specified level of detail and a shadow compare in a given sampler (compare as .z, lod as .w). - (float4)(sampler1DARRAY, float4 s, [int texeloffset])",
|
||||
tex1DARRAYfetch = fn "performs an unfiltered texture lookup in a given sampler (lod as .z). - (float4)(sampler1DARRAY, int3 s, [int texeloffset])",
|
||||
tex1DARRAYlod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .z) - (float4)(sampler1DARRAY, float3 s, [int texeloffset])",
|
||||
tex1DARRAYproj = fn "performs a texture lookup with projection in a given sampler. May perform a shadow comparison if argument for shadow comparison is provided. (shadow in .z for float3 coord, proj in .z or .w) - (float4)(sampler1DARRAY, float3/float4 s, [int texeloff])",
|
||||
tex1DARRAYsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler1DARRAY, int lod)",
|
||||
|
||||
tex2DARRAY = fn "performs a texture lookup in a given 2D sampler array and, in some cases, a shadow comparison (as .w coord). May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(sampler2DARRAY, float3/float4 s, {float2 dx, dy},[int texeloffset])",
|
||||
tex2DARRAYbias = fn "performs a texture lookup with bias in a given sampler (as .w). - (float4)(sampler2DARRAY, float4 s, [int texeloffset])",
|
||||
tex2DARRAYfetch = fn "performs an unfiltered texture lookup in a given sampler (lod as .w). - (float4)(sampler2DARRAY, int4 s, [int texeloffset])",
|
||||
tex2DARRAYlod = fn "performs a texture lookup with a specified level of detail in a given sampler (lod as .w) - (float4)(sampler2DARRAY, float4 s, [int texeloffset])",
|
||||
tex2DARRAYproj = fn "performs a texture lookup with projection in a given sampler. May perform a shadow comparison if argument for shadow comparison is provided. (proj in .w) - (float4)(sampler2DARRAY, float4 s, [int texeloff])",
|
||||
tex2DARRAYsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(sampler2DARRAY, int lod)",
|
||||
|
||||
texCUBEARRAY = fn "performs a texture lookup in a given CUBE sampler array. May also use pre computed derivatives if those are provided. Texeloffset only in gp4 or higher profiles. - (float4)(samplerCUBEARRAY, float4 s, {float3 dx, dy},[int texeloffset])",
|
||||
texCUBEARRAYsize = fn "returns the size of a given texture image for a given level of detail. (only gp4 profiles) - (int3)(samplerCUBEARRAY, int lod)",
|
||||
|
||||
unpack_4ubyte = fn "interprets the single float as 4 normalized unsigned bytes and returns the vector. (only nv/gp4 profiles) - (float4)(float)",
|
||||
pack_4ubyte = fn "packs the floats into a single storing as normalized unsigned bytes.(only nv/gp4 profiles) - (float)(float4)",
|
||||
unpack_4byte = fn "interprets the single float as 4 normalized signed bytes and returns the vector. (only nv/gp4 profiles) - (float4)(float)",
|
||||
pack_4ubyte = fn "packs the floats into a single storing as normalized signed bytes.(only nv/gp4 profiles) - (float)(float4)",
|
||||
unpack_4ushort = fn "interprets the single float as 2 normalized unsigned shorts and returns the vector. (only nv/gp4 profiles) - (float2)(float)",
|
||||
pack_4ushort = fn "packs the floats into a single storing as normalized unsigned shorts.(only nv/gp4 profiles) - (float)(float2)",
|
||||
unpack_2half = fn "interprets the single float as 2 16-bit floats and returns the vector. (only nv/gp4 profiles) - (float2)(float)",
|
||||
pack_2half = fn "packs the floats into a single storing as 16-bit floats.(only nv/gp4 profiles) - (float)(float2)",
|
||||
}
|
||||
|
||||
local keyw =
|
||||
[[int half float float3 float4 float2 float3x3 float3x4 float4x3 float4x4
|
||||
float1x2 float2x1 float2x2 float2x3 float3x2 float1x3 float3x1 float4x1 float1x4
|
||||
float2x4 float4x2 double1x4 double4x4 double4x2 double4x3 double3x4 double2x4 double1x4
|
||||
double half half2 half3 half4 int2 int3 uint uint2 uint3 uint4
|
||||
int4 bool bool2 bool3 bool4 string struct typedef
|
||||
usampler usampler1D usampler2D usampler3D usamplerRECT usamplerCUBE isampler1DARRAY usampler2DARRAY usamplerCUBEARRAY
|
||||
isampler isampler1D isampler2D isampler3D isamplerRECT isamplerCUBE isampler1DARRAY isampler2DARRAY isamplerCUBEARRAY
|
||||
usamplerBUF isamplerBUF samplerBUF
|
||||
sampler sampler1D sampler2D sampler3D samplerRECT samplerCUBE sampler1DARRAY sampler2DARRAY samplerCUBEARRAY
|
||||
texture texture1D texture2D texture3D textureRECT textureCUBE texture1DARRAY texture2DARRAY textureCUBEARRAY
|
||||
|
||||
decl do else extern false for if in inline inout out pass
|
||||
pixelshader return shared static string technique true
|
||||
uniform vector vertexshader void volatile while
|
||||
|
||||
asm compile const auto break case catch char class const_cast continue default delete
|
||||
dynamic_cast enum explicit friend goto long mutable namespace new operator private protected
|
||||
public register reinterpret_case short signed sizeof static_cast switch template this throw
|
||||
try typename union unsigned using virtual
|
||||
|
||||
POSITION PSIZE DIFFUSE SPECULAR TEXCOORD FOG COLOR COLOR0 COLOR1 COLOR2 COLOR3 TEXCOORD0 TEXCOORD1 TEXCOORD2 TEXCOORD3
|
||||
TEXCOORD4 TEXCOORD5 TEXCOORD6 TEXCOORD7 TEXCOORD8 TEXCOORD9 TEXCOORD10 TEXCOORD11 TEXCOORD12 TEXCOORD13 TEXCOORD14
|
||||
TEXCOORD15
|
||||
NORMAL WPOS
|
||||
ATTR0 ATTR1 ATTR2 ATTR3 ATTR4 ATTR5 ATTR6 ATTR7 ATTR8 ATTR9 ATTR10 ATTR11 ATTR12 ATTR13 ATTR14 ATTR15
|
||||
TEXUNIT0 TEXUNIT1 TEXUNIT2 TEXUNIT3 TEXUNIT4 TEXUNIT5 TEXUNIT6 TEXUNIT7 TEXUNIT8 TEXUNIT9 TEXUNIT10 TEXUNIT11 TEXUNIT12
|
||||
TEXUNIT13 TEXUNIT14 TEXUNIT15
|
||||
|
||||
PROJ PROJECTION PROJECTIONMATRIX PROJMATRIX
|
||||
PROJMATRIXINV PROJINV PROJECTIONINV PROJINVERSE PROJECTIONINVERSE PROJINVMATRIX PROJECTIONINVMATRIX PROJINVERSEMATRIX PROJECTIONINVERSEMATRIX
|
||||
VIEW VIEWMATRIX VIEWMATRIXINV VIEWINV VIEWINVERSE VIEWINVERSEMATRIX VIEWINVMATRIX
|
||||
VIEWPROJECTION VIEWPROJ VIEWPROJMATRIX VIEWPROJECTIONMATRIX
|
||||
WORLD WORLDMATRIX WORLDVIEW WORLDVIEWMATRIX
|
||||
WORLDVIEWPROJ WORLDVIEWPROJECTION WORLDVIEWPROJMATRIX WORLDVIEWPROJECTIONMATRIX
|
||||
VIEWPORTSIZE VIEWPORTDIMENSION
|
||||
VIEWPORTSIZEINV VIEWPORTSIZEINVERSE VIEWPORTDIMENSIONINV VIEWPORTDIMENSIONINVERSE INVERSEVIEWPORTDIMENSIONS
|
||||
FOGCOLOR FOGDISTANCE CAMERAWORLDPOS CAMERAWORLDDIR
|
||||
|
||||
CENTROID FLAT NOPERSPECTIVE FACE PRIMITIVEID VERTEXID
|
||||
|
||||
]]
|
||||
|
||||
-- keywords - shouldn't be left out
|
||||
for w in keyw:gmatch("([_%w]+)") do
|
||||
api[w] = {type="keyword"}
|
||||
end
|
||||
|
||||
return api
|
||||
|
||||
|
||||
@ -0,0 +1,277 @@
|
||||
-- authors: Luxinia Dev (Eike Decker & Christoph Kubisch)
|
||||
---------------------------------------------------------
|
||||
|
||||
-- function helpers
|
||||
|
||||
local function fn (description)
|
||||
local description2,returns,args = description:match("(.+)%-%s*(%b())%s*(%b())")
|
||||
if not description2 then
|
||||
return {type="function",description=description,
|
||||
returns="(?)"}
|
||||
end
|
||||
return {type="function",description=description2,
|
||||
returns=returns:gsub("^%s+",""):gsub("%s+$",""), args = args}
|
||||
end
|
||||
|
||||
local function val (description)
|
||||
return {type="value",description = description}
|
||||
end
|
||||
-- docs
|
||||
local api = {
|
||||
radians = fn "converts degrees to radians - (vecN)(vecN)",
|
||||
degrees = fn "converts radians to degrees - (vecN)(vecN)",
|
||||
sin = fn "returns sine of scalars and vectors. - (vecN)(vecN)",
|
||||
sinh = fn "returns hyperbolic sine of scalars and vectors. - (vecN)(vecN)",
|
||||
cos = fn "returns cosine of scalars and vectors. - (vecN)(vecN)",
|
||||
cosh = fn "returns hyperbolic cosine of scalars and vectors. - (vecN)(vecN)",
|
||||
atan = fn "returns arc tangent of scalars and vectors. - (vecN)([vecN y_over_x ]/[vecN y, vecN x])",
|
||||
asin = fn "returns arc sine of scalars and vectors. - (vecN)(vecN)",
|
||||
acos = fn "returns arc cosine of scalars and vectors. - (vecN)(vecN)",
|
||||
atan = fn "returns arc tangent of scalars and vectors. - (vecN)(vecN)",
|
||||
tan = fn "returns tangent of scalars and vectors. - (vecN)(vecN)",
|
||||
tanh = fn "returns hyperbolic tangent of scalars and vectors. - (vecN)(vecN)",
|
||||
acosh = fn "returns hyperbolic arc cosine of scalars and vectors. - (vecN)(vecN)",
|
||||
asinh = fn "returns hyperbolic arc sine of scalars and vectors. - (vecN)(vecN)",
|
||||
atanh = fn "returns hyperbolic arc tangent of scalars and vectors. - (vecN)(vecN)",
|
||||
|
||||
exp = fn "returns the base-e exponential of scalars and vectors. - (vecN)(vecN)",
|
||||
exp2 = fn "returns the base-2 exponential of scalars and vectors. - (vecN)(vecN)",
|
||||
log = fn "returns the natural logarithm of scalars and vectors. - (vecN)(vecN)",
|
||||
log2 = fn "returns the base-2 logarithm of scalars and vectors. - (vecN)(vecN)",
|
||||
pow = fn "returns x to the y-th power of scalars and vectors. - (vecN)(vecN x, y)",
|
||||
sqrt = fn "returns square root of scalars and vectors. - (vecN)(vecN)",
|
||||
inversesqrt = fn "returns inverse square root of scalars and vectors. - (vecN)(vecN)",
|
||||
|
||||
abs = fn "returns absolute value of scalars and vectors. - (vecN)(vecN)",
|
||||
sign = fn "returns sign (1 or -1) of scalar or each vector component. - (vecN)(vecN)",
|
||||
floor = fn "returns largest integer not greater than a scalar or each vector component. - (vecN)(vecN)",
|
||||
ceil = fn "returns smallest integer not less than a scalar or each vector component. - (vecN)(vecN)",
|
||||
trunc = fn "returns largest integer not greater than a scalar or each vector component. - (vecN)(vecN)",
|
||||
round = fn "returns the rounded value of scalars or vectors. - (vecN)(vecN a)",
|
||||
roundEven = fn "returns the nearest even integer value of scalars or vectors. - (vecN)(vecN a)",
|
||||
fract = fn "returns the fractional portion of a scalar or each vector component. - (vecN)(vecN)",
|
||||
mod = fn "modulus - (vecN)(vecN x, y)",
|
||||
modf = fn "separate integer and fractional parts. - (vecN)(vecN x, out vecN i)",
|
||||
max = fn "returns the maximum of two scalars or each respective component of two vectors. - (vecN)(vecN a, b)",
|
||||
min = fn "returns the minimum of two scalars or each respective component of two vectors. - (vecN)(vecN a, b)",
|
||||
mix = fn "returns linear interpolation of two scalars or vectors based on a weight. - (vecN)(vecN a, b, weight)",
|
||||
step = fn "implement a step function returning either zero or one (x >= edge). - (vecN)(vecN edge, x)",
|
||||
|
||||
isinf = fn "test whether or not a scalar or each vector component is infinite. - (boolN)(vecN)",
|
||||
isnan = fn "test whether or not a scalar or each vector component is not-a-number. - (boolN)(vecN)",
|
||||
clamp = fn "returns x clamped to the range [a,b]. - (vecN)(vecN x, a, b)",
|
||||
smoothstep = fn "clip and smooth blend [a,b]. - (vecN)(vecN a, b, x)",
|
||||
floatBitsToInt = fn "returns the 32-bit integer representation of an IEEE 754 floating-point scalar or vector - (uintN/intN)(floatN)",
|
||||
intBitsToFloat = fn "returns the float value corresponding to a given bit represention.of a scalar int value or vector of int values. - (floatN)(intN)",
|
||||
uintBitsToFloat = fn "returns the float value corresponding to a given bit represention.of a scalar int value or vector of int values. - (floatN)(uintN)",
|
||||
doubleBitsToInt64 = fn "returns the 64-bit integer representation of an IEEE 754 double precision floating-point scalar or vector - (int64N)(doubleN)",
|
||||
doubleBitsToUint64 = fn "returns the 64-bit integer representation of an IEEE 754 double precision floating-point scalar or vector - (uint64N)(doubleN)",
|
||||
int64BitsToDouble = fn "returns the double value corresponding to a given bit represention.of a scalar int value or vector of int values. - (doubleN)(uint64N)",
|
||||
uint64BitsToDouble = fn "returns the double value corresponding to a given bit represention.of a scalar int value or vector of int values. - (doubleN)(uint64N)",
|
||||
|
||||
fma = fn "return a*b + c, treated as single operation when using precise - (vecN a, vecN b, vecN c)",
|
||||
frexp = fn "splits scalars and vectors into normalized fraction [0.5,1.0) and a power of 2. - (vecN)(vecN x, out vecN e)",
|
||||
ldexp = fn "build floating point number from x and the corresponding integral exponen of 2 in exp. - (vecN)(vecN x, exp)",
|
||||
|
||||
packUnorm2x16 = fn "Converts each comp. of v into 16-bit ints, packs results into the returned 32-bit uint. - (uint)(vec2 v)",
|
||||
packUnorm4x8 = fn "Converts each comp. of v into 8-bit ints, packs results into the returned 32-bit uint. - (uint)(vec4 v)",
|
||||
packSnorm4x8 = fn "Converts each comp. of v into 8-bit ints, packs results into the returned 32-bit uint. - (uint)(vec4 v)",
|
||||
packDouble2x32 = fn "Packs components of v into a 64-bit value and returns a double-prec value. - (double)(uvec2 v)",
|
||||
packHalf2x16 = fn "Converts each comp. of v into 16-bit half float, packs results into the returned 32-bit uint. - (uint)(vec2 v)",
|
||||
packInt2x32 = fn "Packs two 32 bit into one 64-bit value. - (int64_t)(ivec2)",
|
||||
packUint2x32 = fn "Packs two 32 bit into one 64-bit value. - (uint64_t)(uvec2)",
|
||||
packFloat2x16 = fn "returns an unsigned integer obtained by interpreting the components of a two-component 16-bit floating-point as integers and packing them into 32 bit. - (uint)(f16vec2 v)",
|
||||
|
||||
unpackUnorm2x16 = fn "Unpacks 32-bit p into two 16-bit uints and converts them to normalized float. - (vec2)(uint p)",
|
||||
unpackUnorm4x8 = fn "Unpacks 32-bit p into four 8-bit uints and converts them to normalized float. - (vec4)(uint p)",
|
||||
unpackSnorm4x8 = fn "Unpacks 32-bit p into four 8-bit uints and converts them to normalized float. - (vec4)(uint p)",
|
||||
unpackDouble2x32 = fn "Returns a 2 component vector representation of v. - (uvec2)(double v)",
|
||||
unpackHalf2x16 = fn "Interprets p as two 16-bit half floats and returns them as vector. - (vec2)(uint p)",
|
||||
unpackInt2x32 = fn "Unpacks 64-bit into two 32-bit values. - (ivec2)(int64_t)",
|
||||
unpackUint2x32 = fn "Unpacks 64-bit into two 32-bit values. - (uvec2)(uint64_t)",
|
||||
unpackFloat2x16 = fn "returns a two-component vector with 16-bit floating-point components obtained by unpacking a 32-bit unsigned integer into a pair of 16-bit values. - (f16vec2)(uint)",
|
||||
|
||||
|
||||
length = fn "return scalar Euclidean length of a vector. - (type)(vecN)",
|
||||
distance = fn "return the Euclidean distance between two points. - (vecN)(vecN a, b)",
|
||||
dot = fn "returns the scalar dot product of two vectors. - (type)(vecN a, b)",
|
||||
cross = fn "returns the cross product of two three-component vectors. - (type3)(type3 a, b)",
|
||||
normalize = fn "Returns the normalized version of a vector, meaning a vector in the same direction as the original vector but with a Euclidean length of one. - (vecN)(vecN)",
|
||||
reflect = fn "returns the reflectiton vector given an incidence vector and a normal vector. - (vecN)(vecN incidence, normal)",
|
||||
refract = fn "computes a refraction vector. - (vecN)(vecN incidence, normal, type eta)",
|
||||
faceforward = fn "returns a normal as-is if a vertex's eye-space position vector points in the opposite direction of a geometric normal, otherwise return the negated version of the normal. - (vecN)(vecN Nperturbated, Incident, Ngeometric)",
|
||||
|
||||
determinant = fn "returns the scalar determinant of a square matrix. - (float)(matN)",
|
||||
transpose = fn "returns transpose matrix of a matrix. - (matNxM)(matMxN)",
|
||||
inverse = fn "returns inverse matrix of a matrix. - (matN)(mat)",
|
||||
matrixCompMult = fn "component-wise multiply. - (mat)(mat a, b)",
|
||||
outerProduct = fn "outer product. - (matNxM)(vecM c, vecN r)",
|
||||
|
||||
all = fn "returns true if a boolean scalar or all components of a boolean vector are true. - (bool)(boolN)",
|
||||
any = fn "returns true if a boolean scalar or any component of a boolean vector is true. - (bool)(boolN)",
|
||||
["not"] = fn "returns logical complement. - (boolN)(boolN)",
|
||||
lessThan = fn "returns retusult of component-wise comparison. - (boolN)(vecN a,b)",
|
||||
lessThanEqual = fn "returns retusult of component-wise comparison. - (boolN)(vecN a,b)",
|
||||
greaterThan = fn "returns retusult of component-wise comparison. - (boolN)(vecN a,b)",
|
||||
greaterThanEqual = fn "returns retusult of component-wise comparison. - (boolN)(vecN a,b)",
|
||||
equal = fn "returns retusult of component-wise comparison. - (boolN)(vecN a,b)",
|
||||
notEqual = fn "returns retusult of component-wise comparison. - (boolN)(vecN a,b)",
|
||||
|
||||
uaddCarry = fn "Adds 32-bit uintx and y, returning the sum modulo 2^32. - (uintN)(uintN x, y, out carry)",
|
||||
usubBorrow = fn "Subtracts y from x, returning the difference if non-negative otherwise 2^32 plus the difference. - (uint)(uint x, y, out borrow)",
|
||||
umulExtended = fn "Multiplies 32-bit integers x and y producing 64-bit result. (uintN)(uintN x, y, out msb, out lsb)",
|
||||
imulExtended = fn "Multiplies 32-bit integers x and y producing 64-bit result. (intN)(intN x, y, out msb, out lsb)",
|
||||
bitfieldExtract = fn "Extracts bits (offset, offset + bits -1) from value and returns them in lsb of result. - (intN)(intN value, int offset, int bits)",
|
||||
bitfieldInsert = fn "Returns the insertion the bits lsb of insert into base. - (intN)(intN base insert, int offset, int bits)",
|
||||
bitfieldReverse = fn "Returns the reversal of the bits. - (intN)(intN)",
|
||||
bitCount = fn "returns the number of bits set to 1. - (intN)(intN)",
|
||||
findLSB = fn "returns bit number of lsb. - (intN)(intN)",
|
||||
findMSB = fn "returns bit number of msb. - (intN)(intN)",
|
||||
|
||||
discard = fn "conditionally (<0) kill a pixel before output. - ()(vecN)",
|
||||
dFdx = fn "returns approximate partial derivative with respect to window-space X. - (vecN)(vecN)",
|
||||
dFdxCoarse = fn "returns approximate partial derivative with respect to window-space X. - (vecN)(vecN)",
|
||||
dFdxFine = fn "returns approximate partial derivative with respect to window-space X. - (vecN)(vecN)",
|
||||
dFdy = fn "returns approximate partial derivative with respect to window-space Y. - (vecN)(vecN)",
|
||||
dFdyCoarse = fn "returns approximate partial derivative with respect to window-space Y. - (vecN)(vecN)",
|
||||
dFdyFine = fn "returns approximate partial derivative with respect to window-space Y. - (vecN)(vecN)",
|
||||
fwidth = fn "returns abs sum of approximate window-space partial derivatives magnitudes. - (vecN)(vecN)",
|
||||
fwidthFine = fn "returns abs sum of approximate window-space partial derivatives magnitudes. - (vecN)(vecN)",
|
||||
fwidthCoarse = fn "returns abs sum of approximate window-space partial derivatives magnitudes. - (vecN)(vecN)",
|
||||
interpolateAtCentroid = fn "Return value of interpolant sampled inside pixel and the primitive. - (floatN)(floatN)",
|
||||
interpolateAtSample = fn "Return value of interpolant at the location fo sample. - (floatN)(floatN, int sample)",
|
||||
interpolateAtOffset = fn "Return value of interpolant sampled at fixed offset offset from pixel center. - (floatN)(floatN, vec2 offset)",
|
||||
|
||||
noise1 = fn "returns noise value. - (float)(float)",
|
||||
noise2 = fn "returns noise value. - (vec2)(float)",
|
||||
noise3 = fn "returns noise value. - (vec3)(float)",
|
||||
noise4 = fn "returns noise value. - (vec4)(float)",
|
||||
|
||||
EmitStreamVertex = fn "Emits values of the output variables of the current output primitive stream. - ()(int stream)",
|
||||
EndStreamPrimitive = fn "Completes current output primitive stream and starts a new one. - ()(int stream)",
|
||||
EmitVertex= fn "Emits values of the output variable of the current output primitive. - ()()",
|
||||
EndPrimitive = fn "Completes current output primitive and starts a new one. - ()()",
|
||||
barrier = fn "Synchronizes across shader invocations. - ()()",
|
||||
|
||||
memoryBarrier = fn "control ordering of memory transactions issued by shader thread. - ()()",
|
||||
memoryBarrierAtomicCounter = fn "control ordering of memory transactions issued by shader thread. - ()()",
|
||||
memoryBarrierShared = fn "control ordering of memory transactions issued by shader thread. - ()()",
|
||||
memoryBarrierBuffer = fn "control ordering of memory transactions issued by shader thread. - ()()",
|
||||
memoryBarrierImage = fn "control ordering of memory transactions issued by shader thread. - ()()",
|
||||
groupMemoryBarrier = fn "control ordering of memory transactions issued by shader thread. - ()()",
|
||||
imageAtomicAdd = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicMin = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicMax = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicIncWrap = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicDecWrap = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicAnd = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicOr = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicXor = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicExchange = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageAtomicCompSwap = fn "performs atomic operation on individual texels returns old value. - (uint)(imageN, intN coord, [int sample], uint data)",
|
||||
imageStore = fn "stores the texel at the coordinate. - ()(imageN, intN coord, [int sample], vecN data)",
|
||||
imageLoad = fn "loads the texel at the coordinate. - (vecN)(imageN, intN coord, [int sample])",
|
||||
imageSize = fn "returns the size of the image. - (ivecN)(imageN)",
|
||||
imageSamples = fn "returns the samples of the multi-sampled image. - (int)(image2DMSN)",
|
||||
|
||||
atomicCounterIncrement = fn "increments counter and returns old value. - (uint)(atomic_uint)",
|
||||
atomicCounterDecrement = fn "decrements counter and returns old value. - (uint)(atomic_uint)",
|
||||
atomicCounter = fn "returns current counter value. - (uint)(atomic_uint)",
|
||||
atomicMin = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicMax = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicAdd = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicAnd = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicOr = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicXor = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicExchange = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
atomicCompSwap = fn "performs atomic operation on memory location (ssbo/shared) returns old value. - (uint)(inout uint mem, uint data)",
|
||||
|
||||
textureSize = fn "returns the size of the texture (no lod required: Rect, MS and Buffer). - (intN)(samplerN, [int lod])",
|
||||
textureSamples = fn "returns the samples of the multi-sampled texture. - (int)(texture2DMSN)",
|
||||
textureQueryLod = fn "returns the lod values for a given coordinate. - (vec2)(samplerN, vecN coord)",
|
||||
texture = fn "performs a texture lookup. Shadow samplers require base N+1 coordinate. Lod bias is optional (illegal for MS, Buffer, Rect). - (vec4)(samplerN, vecN coord, [float bias])",
|
||||
textureProj = fn "performas a projective texture lookup (only Nd samplers + Rect). Shadows require N+1 base coordinate, no Lod bias allowed for Rect. - (vec4)(samplerN, vecN+1 coord, [float bias])",
|
||||
textureLod = fn "performs a lookup with explicit LOD. Shadows require N+1 base coordinate. Illegal function for Rect, MS, Buffer. - (vec4)(samplerN, vecN coord, float lod)",
|
||||
textureOffset = fn "offset added before texture lookup. Illegal for MS, Buffer, Cube. - (vec4)(samplerN, vecN coord, intN offset, [float bias])",
|
||||
textureProjOffset = fn "projective texture lookup with offset. Illegal for MS, Buffer, Cube, Array. - (vec4)(samplerN, vecN+1 coord, intN offset, [float bias])",
|
||||
textureLodOffset = fn "offset added with explicit LOD. - (vec4)(samplerN, vecN coord, intN offset, int lod)",
|
||||
textureProjLodOffset = fn "projective lookup with offset and explicit LOD. - (vec4)(samplerN, vecN+1 coord, intN offset, int lod)",
|
||||
textureGrad = fn "lookup with explicit gradients. Illegal for MS, Buffer. - (vec4)(samplerN, vecN coord, gradX, gradY)",
|
||||
textureGradOffset = fn "lookup with explicit gradients and offset. Illegal for MS, Buffer, Cube. - (vec4)(samplerN, vecN coord, gradX, gradY, intN offset)",
|
||||
textureProjGradOffset = fn "projective lookup with exp<78>icit gradients and offset. Illegal for MS, Buffer, Cube. - (vec4)(samplerN, vecN+1 coord, vecN gradX, gradY, intN offset)",
|
||||
textureGather = fn "gather lookup (pixel quad of 4 single channel samples at once). Component 0: x, 1: y ... is ignored for shadow samplers instead reference value must be passed. Only 2D/Cube. Illegal for MS. - (vec4)(samplerN, vecN coord, [int comp] / float shadowRefZ)",
|
||||
textureGatherOffset = fn "gather lookup (pixel quad of 4 single channel samples at once) with offset. Component 0: x, 1: y ... is ignored for shadow samplers instead reference value must be passed. Only 2D/Cube. Illegal for MS. - (vec4)(samplerN, vecN coord, [float shadowRefZ], intN offset / intN offset[4] , [int comp])",
|
||||
texelFetch = fn "integer coordinate lookup for a single texel. No lod parameter for Buffer, MS, Rect. Illegal for Cube - (vec4)(samplerN, intN coord, [int lod/sample])",
|
||||
texelFetchOffset = fn "integer coordinate lookup for a single texel with offset. No lod parameter for Buffer, MS, Rect. Illegal for Cube, Buffer, MS. - (vec4)(samplerN, intN coord, [int lod/sample], intN offset)",
|
||||
|
||||
anyInvocationARB = fn "returns true if and only if <value> is true for at least one active invocation in the group. - (bool)(bool value)",
|
||||
allInvocationsARB = fn "returns true if and only if <value> is true for all active invocations in the group - (bool)(bool value)",
|
||||
allInvocationsEqualARB = fn "returns true if <value> is the same for all active invocation in the group. - (bool)(bool value)",
|
||||
}
|
||||
|
||||
local keyw =
|
||||
[[ int uint half float bool double atomic_uint binding offset
|
||||
vec2 vec3 vec4 dvec2 dvec3 dvec4
|
||||
ivec2 ivec3 ivec4 uvec2 uvec3 uvec4 bvec2 bvec3 bvec4
|
||||
mat2 mat3 mat4 mat2x2 mat3x3 mat4x4 mat2x3 mat3x2 mat4x2 mat2x4 mat4x3 mat3x4
|
||||
dmat2 dmat3 dmat4 dmat2x2 dmat3x3 dmat4x4 dmat2x3 dmat3x2 dmat4x2 dmat2x4 dmat4x3 dmat3x4
|
||||
float16_t f16vec2 f16vec3 f16vec4
|
||||
float32_t f32vec2 f32vec3 f32vec4
|
||||
float64_t f64vec2 f64vec3 f64vec4
|
||||
int8_t i8vec2 i8vec3 i8vec4
|
||||
int8_t i8vec2 i8vec3 i8vec4
|
||||
int16_t i16vec2 i16vec3 i16vec4
|
||||
int32_t i32vec2 i32vec3 i32vec4
|
||||
int64_t i64vec2 i64vec3 i64vec4
|
||||
uint8_t u8vec2 u8vec3 u8vec4
|
||||
uint16_t u16vec2 u16vec3 u16vec4
|
||||
uint32_t u32vec2 u32vec3 u32vec4
|
||||
uint64_t u64vec2 u64vec3 u64vec4
|
||||
struct typedef void
|
||||
usampler1D usampler2D usampler3D usampler2DRect usamplerCube isampler1DArray usampler2DARRAY usamplerCubeArray usampler2DMS usampler2DMSArray
|
||||
isampler1D isampler2D isampler3D isampler2DRect isamplerCube isampler1DArray isampler2DARRAY isamplerCubeArray isampler2DMS isampler2DMSArray
|
||||
sampler1D sampler2D sampler3D sampler2DRect samplerCube sampler1DArray sampler2DArray samplerCubeArray sampler2DMS sampler2DMSArray
|
||||
sampler1DShadow sampler2DShadow sampler2DRectShadow sampler1DArrayShadow sampler2DArrayShadow samplerCubeArrayShadow
|
||||
usamplerBuffer isamplerBuffer samplerBuffer samplerRenderbuffer isamplerRenderbuffer usamplerRenderbuffer
|
||||
in out inout uniform const centroid sample attribute varying patch index true false
|
||||
return switch case for do while if else break continue main inline
|
||||
layout location vertices line_strip triangle_strip max_vertices stream
|
||||
triangles quads equal_spacing isolines fractional_even_spacing lines points
|
||||
fractional_odd_spacing cw ccw point_mode lines_adjacency triangles_adjacency
|
||||
invocations offset align xfb_offset xfb_buffer
|
||||
origin_upper_left pixel_center_integer depth_greater depth_greater depth_greater depth_unchanged
|
||||
smooth flat noperspective highp mediump lowp shared packed std140 std430 row_major column_major buffer
|
||||
gl_FrontColor gl_BackColor gl_FrontSecondaryColor gl_BackSecondaryColor gl_Color gl_SecondaryColor
|
||||
subroutine gl_Position gl_FragCoord
|
||||
gl_VertexID gl_InstanceID gl_Normal gl_Vertex gl_MultiTexCoord0 gl_MultiTexCoord1
|
||||
gl_MultiTexCoord2 gl_MultiTexCoord3 gl_MultiTexCoord4 gl_MultiTexCoord5 gl_MultiTexCoord6
|
||||
gl_MultiTexCoord7 gl_FogCoord gl_PointSize gl_ClipDistance
|
||||
gl_TexCoord gl_FogFragCoord gl_ClipVertex gl_in
|
||||
gl_PatchVerticesIn
|
||||
gl_PrimitiveID gl_InvocationID gl_TessLevelOuter gl_TessLevelInner gl_TessCoord
|
||||
gl_InvocationID gl_PrimitiveIDIn gl_Layer gl_ViewportIndex gl_FrontFacing
|
||||
gl_PointCoord gl_SampleID gl_SamplePosition gl_FragColor
|
||||
gl_FragData gl_FragDepth gl_SampleMask
|
||||
gl_NumWorkGroups gl_WorkGroupSize gl_WorkGroupID gl_LocalInvocationID gl_GlobalInvocationID gl_LocalInvocationIndex
|
||||
local_size_x local_size_y local_size_z
|
||||
gl_BaseVertexARB gl_BaseInstanceARB gl_DrawIDARB
|
||||
bindless_sampler bound_sampler bindless_image bound_image early_fragment_tests
|
||||
gl_HelperInvocation gl_CullDistance gl_MaxSamples
|
||||
|
||||
coherent volatile restrict readonly writeonly
|
||||
image1D image2D image3D image2DRect imageCube imageBuffer image1DArray image2DArray imageCubeArray image2DMS image2DMSArray
|
||||
uimage1D uimage2D uimage3D uimage2DRect uimageCube uimageBuffer uimage1DArray uimage2DArray uimageCubeArray uimage2DMS uimage2DMSArray
|
||||
iimage1D iimage2D iimage3D iimage2DRect iimageCube iimageBuffer iimage1DArray iimage2DArray iimageCubeArray iimage2DMS iimage2DMSArray
|
||||
size1x8 size1x16 size1x32 size2x32 size4x32 rgba32f rgba16f rg32f rg16f r32f r16f rgba8 rgba16 r11f_g11f_b10f rgb10_a2ui
|
||||
rgb10_a2i rg16 rg8 r16 r8 rgba32i rgba16i rgba8i rg32i rg16i rg8i r32i r16i r8i rgba32ui rgba16ui rgba8ui rg32ui rg16ui rg8ui
|
||||
r32ui r16ui r8ui rgba16_snorm rgba8_snorm rg16_snorm rg8_snorm r16_snorm r8_snorm
|
||||
]]
|
||||
|
||||
-- keywords - shouldn't be left out
|
||||
for w in keyw:gmatch("([a-zA-Z_0-9]+)") do
|
||||
api[w] = {type="keyword"}
|
||||
end
|
||||
|
||||
return api
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,52 @@
|
||||
-- authors: Luxinia Dev (Eike Decker & Christoph Kubisch)
|
||||
---------------------------------------------------------
|
||||
|
||||
-- function helpers
|
||||
|
||||
local function fn (description)
|
||||
local description2,returns,args = description:match("(.+)%-%s*(%b())%s*(%b())")
|
||||
if not description2 then
|
||||
return {type="function",description=description,
|
||||
returns="(?)"}
|
||||
end
|
||||
returns = returns:gsub("^%s+",""):gsub("%s+$","")
|
||||
local ret = returns:sub(2,-2)
|
||||
local vt = ret:match("^%[?string") and "string"
|
||||
vt = vt or ret:match("^%[?table") and "table"
|
||||
vt = vt or ret:match("^%[?file") and "io"
|
||||
return {type="function",description=description2,
|
||||
returns=returns, args = args, valuetype = vt}
|
||||
end
|
||||
|
||||
local function val (description)
|
||||
return {type="value",description = description}
|
||||
end
|
||||
|
||||
---------------------------
|
||||
|
||||
local api = {
|
||||
ffi = {
|
||||
description = "FFI",
|
||||
type = "lib",
|
||||
childs = {
|
||||
cdef = fn "Adds multiple C declarations for types or external symbols - ()(string)",
|
||||
load = fn "This loads the dynamic library given by name and returns a new C library namespace which binds to its symbols. On POSIX systems, if global is true, the library symbols are loaded into the global namespace, too. - (userdata)(string,[global])",
|
||||
new = fn "The following API functions create cdata objects (type() returns 'cdata'). All created cdata objects are garbage collected. - (cdata)(string/ctype,nelement,init...)",
|
||||
typeof = fn "Creates a ctype object for the given ct. - (ctype)(ct)",
|
||||
cast = fn "Creates a scalar cdata object for the given ct. The cdata object is initialized with init according to C casting rules. - (cdata)(ctype,cdata init)",
|
||||
metatype = fn "Creates a ctype object for the given ct and associates it with a metatable. Only struct/union types, complex numbers and vectors are allowed. Other types may be wrapped in a struct, if needed. - (cdata)(ct,table meta)",
|
||||
gc = fn "Associates a finalizer with a pointer or aggregate cdata object. The cdata object is returned unchanged. - (cdata)(ct,function finalizer)",
|
||||
sizeof = fn "Returns the size of ct in bytes. Returns nil if the size is not known. - (number)(ct,[nelem])",
|
||||
alignof = fn "Returns the minimum required alignment for ct in bytes. - (number)(ct)",
|
||||
offsetof = fn "Returns the offset (in bytes) of field relative to the start of ct, which must be a struct. Additionally returns the position and the field size (in bits) for bit fields. - (number)(ct, field)",
|
||||
istype = fn "Returns true if obj has the C type given by ct. Returns false otherwise. - (boolean)(ct,obj)",
|
||||
string = fn "Creates an interned Lua string from the data pointed to by ptr. If the optional argument len is missing, ptr is converted to a 'char *' and the data is assumed to be zero-terminated. The length of the string is computed with strlen(). - (string)(ptr, [number len])",
|
||||
copy = fn "Copies the data pointed to by src to dst. dst is converted to a 'void *' and src is converted to a 'const void *'. - ()(dst,[src,len] / [string])",
|
||||
fill = fn "Fills the data pointed to by dst with len constant bytes, given by c. If c is omitted, the data is zero-filled. - ()(dst, len, [c])",
|
||||
abi = fn "Returns true if param (a Lua string) applies for the target ABI (Application Binary Interface). Returns false otherwise. 32bit 64bit lq be fpu softfp hardfp eabi win. - (boolean)(string)",
|
||||
os = val "string value of OS",
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
return api
|
||||
@ -0,0 +1,24 @@
|
||||
local function populateAPI(t)
|
||||
local api = {}
|
||||
for k,v in pairs(t) do
|
||||
api[k] = {
|
||||
type = (type(v) == "function" and "function" or "value"),
|
||||
description = "",
|
||||
returns = "",
|
||||
}
|
||||
end
|
||||
return api
|
||||
end
|
||||
|
||||
return {
|
||||
wx = {
|
||||
type = "lib",
|
||||
description = "wx lib",
|
||||
childs = populateAPI(wx),
|
||||
},
|
||||
wxstc = {
|
||||
type = "lib",
|
||||
description = "wxSTC lib",
|
||||
childs = populateAPI(wxstc),
|
||||
},
|
||||
}
|
||||
@ -0,0 +1,278 @@
|
||||
local funcstring =
|
||||
[[
|
||||
get_work_dim() Returns the number of dimensions in use
|
||||
get_global_size(uint dimindx) Returns the number of global work-items specified for dimension identified by dimindx
|
||||
get_global_id(uint dimindx) Returns the unique global work-item ID value for dimension identified by dimindx
|
||||
get_local_size(uint dimindx) Returns the number of local work-items specified in dimension identified by dimindx
|
||||
get_local_id(uint dimindx) Returns the unique local work-item ID i.e. a work-item within a specific work-group for dimension identified by dimindx.
|
||||
get_num_groups(uint dimindx) Returns the number of work-groups that will execute a kernel for dimension identified by dimindx
|
||||
get_group_id(uint dimindx) Returns the work-group ID
|
||||
acos(gentype) Arc cosine function
|
||||
acosh(gentype) Inverse hyperbolic cosine
|
||||
acospi(gentype) Compute acos (x) / PI
|
||||
asin(gentype) Arc sine function
|
||||
asinh(gentype) Inverse hyperbolic sine
|
||||
asinpi(gentype x) Compute asin (x) / PI
|
||||
atan(gentype y_over_x) Arc tangent function
|
||||
atan2(gentype y, gentype x) Arc tangent of y / x
|
||||
atanh(gentype) Hyperbolic arc tangent.
|
||||
atanpi(gentype x) Compute atan (x) / PI
|
||||
atan2pi(gentype y, gentype x) Compute atan2 (y, x) / PI
|
||||
cbrt(gentype) Compute cube-root
|
||||
ceil(gentype) Round to integral value using the round to +ve infinity rounding mode
|
||||
copysign(gentype x, gentype y) Returns x with its sign changed to match the sign of y
|
||||
cos(gentype) Compute cosine
|
||||
cosh(gentype) Compute hyperbolic consine
|
||||
cospi(gentype x) Compute cos (PI*x)
|
||||
erfc(gentype) Complementary error function
|
||||
erf(gentype) Error function encountered in integrating the normal distribution
|
||||
exp(gentype x) Compute the base- e exponential of x
|
||||
exp2(gentype) Exponential base 2 function
|
||||
exp10(gentype) Exponential base 10 function
|
||||
expm1(gentype x) Compute e^x - 1.0
|
||||
fabs(gentype) Compute absolute value of a floating-point number
|
||||
fdim(gentype x, gentype y) x - y if x > y, +0 if x is less than or equal to y
|
||||
floor(gentype) Round to integral value using the round to –ve infinity rounding mode
|
||||
fma(gentype a, gentype b, gentype c) Returns the correctly rounded floating-point representation of the sum of c with the infinitely precise product of a and b
|
||||
fmax(gentype x, gentype y) Returns y if x < y, otherwise it returns x
|
||||
fmin(gentype x, gentype y) Returns y if y < x, otherwise it returns x
|
||||
fmod(gentype x, gentype y) Modulus. Returns x – y * trunc (x/y)
|
||||
fract(gentype x, gentype *iptr) Returns fmin( x – floor (x), 0x1.fffffep-1f ).
|
||||
frexp(gentype x, intn *exp) Extract mantissa and exponent from x
|
||||
hypot(gentype x, gentype y) Compute the value of the square root of x2+y2
|
||||
ilogb(gentype x) Return the exponent as an integer value
|
||||
ldexp(gentype x, intn n) Multiply x by 2 to the power n
|
||||
lgamma(gentype x) Returns the natural logarithm of the absolute value of the gamma function
|
||||
lgamma_r(gentype x, intn *signp) Returns the natural logarithm of the absolute value of the gamma function
|
||||
log(gentype) Compute natural logarithm
|
||||
log2(gentype) Compute a base 2 logarithm
|
||||
log10(gentype) Compute a base 10 logarithm
|
||||
log1p(gentype x) Compute loge(1.0 + x)
|
||||
logb(gentype x) Compute the exponent of x, which is the integral part of logr|x|
|
||||
mad(gentype a, gentype b, gentype c) Approximates a * b + c.
|
||||
modf(gentype x, gentype *iptr) Decompose a floating-point number
|
||||
nan(uintn nancode) Returns a quiet NaN
|
||||
nextafter(gentype x, gentype y) Computes the next representable single-precision floating-point value following x in the direction of y.
|
||||
pow(gentype x, gentype y) Compute x to the power y
|
||||
pown(gentype x, intn y) Compute x to the power y, where y is an integer
|
||||
powr(gentype x, gentype y) Compute x to the power y, where x is >= 0
|
||||
remainder(gentype x, gentype y) r = x - n*y, where n is the integer nearest the exact value of x/y
|
||||
remquo(gentype x, gentype y, intn *quo) r = x - n*y, where n is the integer nearest the exact value of x/y
|
||||
rint(gentype) Round to integral value (using round to nearest even rounding mode)
|
||||
rootn(gentype x, intn y) Compute x to the power 1/y
|
||||
round(gentype x) Return the integral value nearest to x rounding halfway cases away from zero
|
||||
rsqrt(gentype) Compute inverse square root
|
||||
sin(gentype) Compute sine
|
||||
sincos(gentype x, gentype *cosval) Compute sine and cosine of x
|
||||
sinh(gentype) Compute hyperbolic sine.
|
||||
sinpi(gentype x) Compute sin (PI*x)
|
||||
sqrt(gentype) Compute square root
|
||||
tan(gentype) Compute tangent
|
||||
tanh(gentype) Compute hyperbolic tangent
|
||||
tanpi(gentype x) Compute tan (PI*x)
|
||||
tgamma(gentype) Compute the gamma function
|
||||
trunc(gentype) Round to integral value using the round to zero
|
||||
abs(gentype x) Returns |x|
|
||||
abs_diff(gentype x, gentype y) Returns |x – y| without modulo overflow
|
||||
add_sat(gentype x, gentype y) Returns x + y and saturates the result
|
||||
hadd(gentype x, gentype y) Returns (x + y) >> 1
|
||||
rhadd(gentype x, gentype y) Returns (x + y + 1) >> 1
|
||||
clz(gentype x) Returns the number of leading 0-bits in x, starting at the most significant bit position.
|
||||
mad_hi(gentype a, gentype b, gentype c) Returns mul_hi(a, b) + c
|
||||
mad_sat(gentype a, gentype b, gentype c) Returns a * b + c and saturates the result
|
||||
max(gentype x, gentype y) Returns y if x < y, otherwise it returns x
|
||||
min(gentype x, gentype y) Returns y if y < x, otherwise it returns x
|
||||
mul_hi(gentype x, gentype y) Computes x * y and returns the high half of the product of x and y
|
||||
rotate(gentype v, gentype i)
|
||||
sub_sat(gentype x, gentype y) Returns x - y and saturates the result
|
||||
upsample(charn hi, ucharn lo) result[i] = ((short)hi[i] << 8) | lo[i]
|
||||
mad24(gentype x, gentype y, gentype z)
|
||||
mul24(gentype x, gentype y)
|
||||
clamp(gentype x, gentype minval, gentype maxval) Returns fmin(fmax(x, minval), maxval)
|
||||
degrees(gentype radians) Converts radians to degrees
|
||||
max(gentype x, gentype y)
|
||||
min(gentype x, gentype y)
|
||||
mix(gentype x, gentype y, gentype a) Returns the linear blend of x&y: x + (y – x) * a
|
||||
radians(gentype degrees) Converts degrees to radians
|
||||
step(gentype edge, gentype x) Returns 0.0 if x < edge, otherwise it returns 1.0
|
||||
smoothstep(genType edge0, genType edge1, genType x)
|
||||
sign(gentype x)
|
||||
cross(float4 p0, float4 p1) Returns the cross product of p0.xyz and p1.xyz.
|
||||
dot(gentype p0, gentype p1) Compute dot product
|
||||
distance(gentype p0, gentype p1) Returns the distance between p0 and p1
|
||||
length(gentype p) Return the length of vecto
|
||||
normalize(gentype p) Returns a vector in the same direction as p but with length of 1.
|
||||
fast_distance(gentype p0, gentype p1) Returns fast_length(p0 – p1).
|
||||
fast_length(gentype p) Returns the length of vector
|
||||
fast_normalize(gentype p) Returns a vector in the same direction as p but with length of 1.
|
||||
read_imagef(image2d_t image, sampler_t sampler, int2 coord)
|
||||
read_imagei(image2d_t image, sampler_t sampler, int2 coord)
|
||||
read_imageui(image2d_t image, sampler_t sampler, int2 coord)
|
||||
write_imagef(image2d_t image, int2 coord, float4 color)
|
||||
write_imagei(image2d_t image, int2 coord, int4 color)
|
||||
write_imageui(image2d_t image, int2 coord, unsigned int4 color)
|
||||
get_image_width(image2d_t image)
|
||||
get_image_width(image3d_t image)
|
||||
get_image_height(image2d_t image)
|
||||
get_image_height(image3d_t image)
|
||||
get_image_channel_data_type(image2d_t image)
|
||||
get_image_channel_data_type(image3d_t image)
|
||||
get_image_channel_order(image2d_t image)
|
||||
get_image_channel_order(image3d_t image)
|
||||
get_image_dim(image2d_t image)
|
||||
get_image_dim(image3d_t image)
|
||||
barrier(cl_mem_fence_flags flags) All work-items in a work-group executing the kernel must execute this function before any are allowed to continue execution beyond the barrier.
|
||||
mem_fence(cl_mem_fence_flags flags) Orders loads and stores of a work-item executing a kernel.
|
||||
read_mem_fence(cl_mem_fence_flags flags) Read memory barrier that orders only loads.
|
||||
write_mem_fence(cl_mem_fence_flags flags) Write memory barrier that orders only stores.
|
||||
async_work_group_copy(gentype *dst, const gentype *src, size_t num_elements, event_t event) Perform an async copy of num_elements gentype elements from src to dst.
|
||||
wait_group_events(int num_events, event_t *event_list) Wait for events that identify the async_work_group_copy operations to complete.
|
||||
prefetch(const __global gentype *p, size_t num_elements) Prefetch num_elements * sizeof(gentype) bytes into the global cache.
|
||||
vload2(size_t offset, const type *p) Read vector data from memory
|
||||
vload4(size_t offset, const type *p) Read vector data from memory
|
||||
vload8(size_t offset, const type *p) Read vector data from memory
|
||||
vload16(size_t offset, const type *p) Read vector data from memory
|
||||
vstore2(type2 data, size_t offset, type *p) Write vector data to memory
|
||||
vstore4(type4 data, size_t offset, type *p) Write vector data to memory
|
||||
vstore8(type8 data, size_t offset, type *p) Write vector data to memory
|
||||
vstore16(type16 data, size_t offset, type *p) Write vector data to memory
|
||||
]]
|
||||
|
||||
local function fn (description)
|
||||
local description2,returns,args = description:match("(.+)%-%s*(%b())%s*(%b())")
|
||||
if not description2 then
|
||||
return {type="function",description=description,
|
||||
returns="(?)"}
|
||||
end
|
||||
return {type="function",description=description2,
|
||||
returns=returns:gsub("^%s+",""):gsub("%s+$",""), args = args}
|
||||
end
|
||||
|
||||
local function val (description)
|
||||
return {type="value",description = description}
|
||||
end
|
||||
-- docs
|
||||
local api = {
|
||||
}
|
||||
|
||||
|
||||
local convtypes = [[bool char uchar short ushort int uint long ulong float double]]
|
||||
local convout = {}
|
||||
for i in convtypes:gmatch("([%w_]+)") do
|
||||
local suffix = {"","_rte","_rtz","_rtp","_rtn"}
|
||||
for k,t in ipairs(suffix) do
|
||||
table.insert(convout,"convert_"..i..t)
|
||||
table.insert(convout,"convert_"..i.."_sat"..t)
|
||||
local vectors = {2,4,8,16}
|
||||
for n,v in ipairs(vectors) do
|
||||
table.insert(convout,"convert_"..i..v..t)
|
||||
table.insert(convout,"convert_"..i..v.."_sat"..t)
|
||||
end
|
||||
end
|
||||
end
|
||||
convout = table.concat(convout, " ")
|
||||
|
||||
local astypes = [[int uint uchar ushort float double size_t ptrdiff_t intptr_t uintptr_t
|
||||
long ulong char short unsigned
|
||||
float2 float4 float8 float16
|
||||
double2 double4 double8 double16
|
||||
char2 char4 char8 char16
|
||||
uchar2 uchar4 uchar8 uchar16
|
||||
short2 short4 short8 short16
|
||||
ushort2 ushort4 ushort8 ushort16
|
||||
int2 int4 int8 int16
|
||||
uint2 uint4 uint8 uint16
|
||||
long2 long4 long8 long16
|
||||
ulong2 ulong4 ulong8 ulong16]]
|
||||
|
||||
local astypeout = {}
|
||||
for i in astypes:gmatch("([%w_]+)") do
|
||||
table.insert(astypeout, "as_"..i)
|
||||
end
|
||||
astypeout = table.concat(astypeout, " ")
|
||||
|
||||
local keyw = astypeout.." "..convout.." "..[[
|
||||
int uint uchar ushort half float bool double size_t ptrdiff_t intptr_t uintptr_t void
|
||||
long ulong char short unsigned
|
||||
half2 half4 half8 half16
|
||||
float2 float4 float8 float16
|
||||
double2 double4 double8 double16
|
||||
char2 char4 char8 char16
|
||||
uchar2 uchar4 uchar8 uchar16
|
||||
short2 short4 short8 short16
|
||||
ushort2 ushort4 ushort8 ushort16
|
||||
int2 int4 int8 int16
|
||||
uint2 uint4 uint8 uint16
|
||||
long2 long4 long8 long16
|
||||
ulong2 ulong4 ulong8 ulong16
|
||||
image2d_t image3d_t sampler_t event_t cl_image_format
|
||||
|
||||
struct typedef void const
|
||||
return switch case for do while if else break continue volatile
|
||||
CLK_A CLK_R CLK_RG CLK_RGB CLK_RGBA CLK_ARGB CLK_BGRA CLK_INTENSITY CLK_LUMINANCE
|
||||
|
||||
MAXFLOAT HUGE_VALF INFINITY NAN
|
||||
CLK_LOCAL_MEM_FENCE CLK_GLOBAL_MEM_FENCE
|
||||
CLK_SNORM_INT8
|
||||
CLK_SNORM_INT16
|
||||
CLK_UNORM_INT8
|
||||
CLK_UNORM_INT16
|
||||
CLK_UNORM_SHORT_565
|
||||
CLK_UNORM_SHORT_555
|
||||
CLK_UNORM_SHORT_101010
|
||||
CLK_SIGNED_INT8
|
||||
CLK_SIGNED_INT16
|
||||
CLK_SIGNED_INT32
|
||||
CLK_UNSIGNED_INT8
|
||||
CLK_UNSIGNED_INT16
|
||||
CLK_UNSIGNED_INT32
|
||||
CLK_HALF_FLOAT
|
||||
CLK_FLOAT
|
||||
__FILE__ __LINE__ __OPENCL_VERSION__ __ENDIAN_LITTLE__
|
||||
__ROUNDING_MODE__ __IMAGE_SUPPORT__ __FAST_RELAXED_MATH__
|
||||
|
||||
__kernel kernel __attribute__ __read_only __write_only read_only write_only
|
||||
__constant constant __local local __global global __private private
|
||||
vec_type_hint work_group_size_hint reqd_work_group_size
|
||||
aligned packed endian host device
|
||||
|
||||
async_work_group_copy wait_group_events prefetch
|
||||
clamp min max degrees radians sign smoothstep step mix
|
||||
mem_fence read_mem_fence write_mem_fence
|
||||
cross prod distance dot length normalize fast_distance fast_length fast_normalize
|
||||
read_image write_image get_image_width get_image_height get_image_depth
|
||||
get_image_channel_data_type get_image_channel_order
|
||||
get_image_dim
|
||||
abs abs_diff add_sat clz hadd mad24 mad_hi mad_sat
|
||||
mul24 mul_hi rhadd rotate sub_sat upsample
|
||||
read_imagei write_imagei read_imageui write_imageui
|
||||
read_imagef write_imagef
|
||||
|
||||
isequal isnotequal isgreater isgreaterequal isless islessequal islessgreater
|
||||
isfinite isinf isnan isnormal isordered isunordered signbit any all bitselect select
|
||||
|
||||
acos acosh acospi asin asinh asinpi atan atan2 atanh atanpi atan2pi
|
||||
cbrt ceil copysign cos half_cos native_cos cosh cospi half_divide native_divide
|
||||
erf erfc exp half_exp native_exp exp2 half_exp2 native_exp2 exp10 half_exp10 native_exp10
|
||||
expm1 fabs fdim floor fma fmax fmin fmod fract frexp hypot ilogb
|
||||
ldexp lgamma lgamma_r log half_log native_log log2 half_log2 native_log2
|
||||
log10 half_log10 native_log10 log1p logb mad modf nan nextafter
|
||||
pow pown powr half_powr native_powr half_recip native_recip
|
||||
remainder remquo rint round rootn rsqrt half_rsqrt native_rsqrt
|
||||
sin half_sin native_sin sincos sinh sinpi sqrt half_sqrt native_sqrt
|
||||
tan half_tan native_tan tanh tanpi tgamma trunc
|
||||
|
||||
barrier
|
||||
vload2 vload4 vload8 vload16
|
||||
vload_half vload_half2 vload_half4 vload_half8 vload_half16 vloada_half4 vloada_half8 vloada_half16
|
||||
vstore2 vstore4 vstore8 vstore16
|
||||
vstore_half vstore_half2 vstore_half4 vstore_half8 vstore_half16 vstorea_half4 vstorea_half8 vstorea_half16
|
||||
get_global_id get_global_size get_group_id get_local_id get_local_size get_num_groups get_work_dim
|
||||
]]
|
||||
|
||||
-- keywords - shouldn't be left out
|
||||
for w in keyw:gmatch("([a-zA-Z_0-9]+)") do
|
||||
api[w] = {type="keyword"}
|
||||
end
|
||||
|
||||
return api
|
||||
Reference in New Issue
Block a user