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
|
[//]: # (generated using SlashBack 0.2.0)
# func\_packing methods
The following methods are all part of the **func\_packing methods**\.
Provides GLSL functions to pack and unpack half, single and double\-precision floating point values into more compact integer types\.
## Table of contents
* [**packDouble2x32** function](#packdouble2x32-function)
* [**packHalf2x16** function](#packhalf2x16-function)
* [**packSnorm2x16** function](#packsnorm2x16-function)
* [**packSnorm4x8** function](#packsnorm4x8-function)
* [**packUnorm2x16** function](#packunorm2x16-function)
* [**packUnorm4x8** function](#packunorm4x8-function)
* [**unpackDouble2x32** function](#unpackdouble2x32-function)
* [**unpackHalf2x16** function](#unpackhalf2x16-function)
* [**unpackSnorm2x16** function](#unpacksnorm2x16-function)
* [**unpackSnorm4x8** function](#unpacksnorm4x8-function)
* [**unpackUnorm2x16** function](#unpackunorm2x16-function)
* [**unpackUnorm4x8** function](#unpackunorm4x8-function)
### packDouble2x32\(\) function
#### <code>glm.<code>**packDouble2x32**(**v**: *uvec2*) -\> *float*</code></code>
  Returns a double\-qualifier value obtained by packing the components of ``` v ``` into a 64\-bit
  value\. If an IEEE 754 ``` Inf ``` or ``` NaN ``` is created, it will not signal, and the resulting floating
  point value is unspecified\. Otherwise, the bit\-level representation of ``` v ``` is preserved\. The
  first vector component specifies the 32 least significant bits; the second component
  specifies the 32 most significant bits\.
### packHalf2x16\(\) function
#### <code>glm.<code>**packHalf2x16**(**v**: *vec2*) -\> *int*</code></code>
  Returns an unsigned integer obtained by converting the components of a two\-component
  floating\-point vector to the 16\-bit floating\-point representation found in the OpenGL
  Specification, and then packing these two 16\-bit integers into a 32\-bit unsigned integer\.
  The first vector component specifies the 16 least\-significant bits of the result; the
  second component specifies the 16 most\-significant bits\.
### packSnorm2x16\(\) function
#### <code>glm.<code>**packSnorm2x16**(**v**: *vec2*) -\> *int*</code></code>
  First, converts each component of the normalized floating\-point value ``` v ``` into 8\- or 16\-bit
  integer values\. Then, the results are packed into the returned 32\-bit unsigned integer\.
  The conversion for component ``` c ``` of ``` v ``` to fixed point is done as follows :
  ``` round(clamp(v, -1, +1) * 32767.0) ```\. The first component of the vector will be written to
  the least significant bits of the output; the last component will be written to the most
  significant bits\.
### packSnorm4x8\(\) function
#### <code>glm.<code>**packSnorm4x8**(**v**: *vec4*) -\> *int*</code></code>
  First, converts each component of the normalized floating\-point value ``` v ``` into 8\- or 16\-bit
  integer values\. Then, the results are packed into the returned 32\-bit unsigned integer\.
  The conversion for component ``` c ``` of ``` v ``` to fixed point is done as follows :
  ``` round(clamp(c, -1, +1) * 127.0) ```\. The first component of the vector will be written to
  the least significant bits of the output; the last component will be written to the most
  significant bits\.
### packUnorm2x16\(\) function
#### <code>glm.<code>**packUnorm2x16**(**v**: *vec2*) -\> *int*</code></code>
  First, converts each component of the normalized floating\-point value ``` v ``` into 8\- or 16\-bit
  integer values\. Then, the results are packed into the returned 32\-bit unsigned integer\.
  The conversion for component ``` c ``` of ``` v ``` to fixed point is done as follows :
  ``` round(clamp(c, 0, +1) * 65535.0) ```\. The first component of the vector will be written to the
  least significant bits of the output; the last component will be written to the most
  significant bits\.
### packUnorm4x8\(\) function
#### <code>glm.<code>**packUnorm4x8**(**v**: *vec4*) -\> *int*</code></code>
  First, converts each component of the normalized floating\-point value ``` v ``` into 8\- or 16\-bit
  integer values\. Then, the results are packed into the returned 32\-bit unsigned integer\.
  The conversion for component ``` c ``` of ``` v ``` to fixed point is done as follows :
  ``` round(clamp(c, 0, +1) * 255.0) ```\. The first component of the vector will be written to the
  least significant bits of the output; the last component will be written to the most
  significant bits\.
### unpackDouble2x32\(\) function
#### <code>glm.<code>**unpackDouble2x32**(**v**: *double*) -\> *uvec2*</code></code>
  Returns a two\-component unsigned integer vector representation of ``` v ```\. The bit\-level
  representation of ``` v ``` is preserved\. The first component of the vector contains the 32 least
  significant bits of the double; the second component consists the 32 most significant bits\.
### unpackHalf2x16\(\) function
#### <code>glm.<code>**unpackHalf2x16**(**v**: *int*) -\> *vec2*</code></code>
  Returns a two\-component floating\-point vector with components obtained by unpacking a
  32\-bit unsigned integer into a pair of 16\-bit values, interpreting those values as 16\-bit
  floating\-point numbers according to the OpenGL Specification, and converting them to 32\-bit
  floating\-point values\. The first component of the vector is obtained from the 16
  least\-significant bits of ``` v ```; the second component is obtained from the 16
  most\-significant bits of ``` v ```\.
### unpackSnorm2x16\(\) function
#### <code>glm.<code>**unpackSnorm2x16**(**p**: *int*) -\> *vec2*</code></code>
  First, unpacks a single 32\-bit unsigned integer ``` p ``` into a pair of 16\-bit unsigned integers,
  four 8\-bit unsigned integers, or four 8\-bit signed integers\. Then, each component is
  converted to a normalized floating\-point value to generate the returned two\- or
  four\-component vector\. The conversion for unpacked fixed\-point value ``` f ``` to floating point
  is done as follows : ``` clamp(f / 32767.0, -1, +1) ```\. The first component of
  the returned vector will be extracted from the least significant bits of the input; the
  last component will be extracted from the most significant bits\.
### unpackSnorm4x8\(\) function
#### <code>glm.<code>**unpackSnorm4x8**(**p**: *int*) -\> *vec4*</code></code>
  First, unpacks a single 32\-bit unsigned integer ``` p ``` into a pair of 16\-bit unsigned integers,
  four 8\-bit unsigned integers, or four 8\-bit signed integers\. Then, each component is
  converted to a normalized floating\-point value to generate the returned two\- or
  four\-component vector\. The conversion for unpacked fixed\-point value ``` f ``` to floating point
  is done as follows : ``` clamp(f / 127.0, -1, +1) ```\. The first component of the
  returned vector will be extracted from the least significant bits of the input; the last
  component will be extracted from the most significant bits\.
### unpackUnorm2x16\(\) function
#### <code>glm.<code>**unpackUnorm2x16**(**p**: *int*) -\> *vec2*</code></code>
  First, unpacks a single 32\-bit unsigned integer ``` p ``` into a pair of 16\-bit unsigned integers,
  four 8\-bit unsigned integers, or four 8\-bit signed integers\. Then, each component is
  converted to a normalized floating\-point value to generate the returned two\- or
  four\-component vector\. The conversion for unpacked fixed\-point value ``` f ``` to floating point
  is done as follows : ``` f / 65535.0 ```\. The first component of the returned
  vector will be extracted from the least significant bits of the input; the last component
  will be extracted from the most significant bits\.
### unpackUnorm4x8\(\) function
#### <code>glm.<code>**unpackUnorm4x8**(**p**: *int*) -\> *vec4*</code></code>
  First, unpacks a single 32\-bit unsigned integer ``` p ``` into a pair of 16\-bit unsigned integers,
  four 8\-bit unsigned integers, or four 8\-bit signed integers\. Then, each component is
  converted to a normalized floating\-point value to generate the returned two\- or
  four\-component vector\. The conversion for unpacked fixed\-point value ``` f ``` to floating point
  is done as follows : ``` f / 255.0 ```\. The first component of the returned vector
  will be extracted from the least significant bits of the input; the last component will be
  extracted from the most significant bits\.
|
