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
|
# $Id$
# Documentation for the vertex proxy class
class KX_VertexProxy:
"""
A vertex holds position, UV, colour and normal information.
Note:
The physics simulation is NOT currently updated - physics will not respond
to changes in the vertex position.
@ivar XYZ: The position of the vertex.
@type XYZ: list [x, y, z]
@ivar UV: The texture coordinates of the vertex.
@type UV: list [u, v]
@ivar normal: The normal of the vertex
@type normal: list [nx, ny, nz]
@ivar colour: The colour of the vertex.
Black = [0.0, 0.0, 0.0, 1.0], White = [1.0, 1.0, 1.0, 1.0]
@type colour: list [r, g, b, a]
@ivar color: Synonym for colour.
@group Position: x, y, z
@ivar x: The x coordinate of the vertex.
@type x: float
@ivar y: The y coordinate of the vertex.
@type y: float
@ivar z: The z coordinate of the vertex.
@type z: float
@group Texture Coordinates: u, v
@ivar u: The u texture coordinate of the vertex.
@type u: float
@ivar v: The v texture coordinate of the vertex.
@type v: float
@ivar u2: The second u texture coordinate of the vertex.
@type u2: float
@ivar v2: The second v texture coordinate of the vertex.
@type v2: float
@group Colour: r, g, b, a
@ivar r: The red component of the vertex colour. 0.0 <= r <= 1.0
@type r: float
@ivar g: The green component of the vertex colour. 0.0 <= g <= 1.0
@type g: float
@ivar b: The blue component of the vertex colour. 0.0 <= b <= 1.0
@type b: float
@ivar a: The alpha component of the vertex colour. 0.0 <= a <= 1.0
@type a: float
"""
def getXYZ():
"""
Gets the position of this vertex.
@rtype: list [x, y, z]
@return: this vertexes position in local coordinates.
"""
def setXYZ(pos):
"""
Sets the position of this vertex.
@type pos: list [x, y, z]
@param pos: the new position for this vertex in local coordinates.
"""
def getUV():
"""
Gets the UV (texture) coordinates of this vertex.
@rtype: list [u, v]
@return: this vertexes UV (texture) coordinates.
"""
def setUV(uv):
"""
Sets the UV (texture) coordinates of this vertex.
@type uv: list [u, v]
"""
def getUV2():
"""
Gets the 2nd UV (texture) coordinates of this vertex.
@rtype: list [u, v]
@return: this vertexes UV (texture) coordinates.
"""
def setUV2(uv):
"""
Sets the 2nd UV (texture) coordinates of this vertex.
@type uv: list [u, v]
"""
def getRGBA():
"""
Gets the colour of this vertex.
The colour is represented as four bytes packed into an integer value. The colour is
packed as RGBA.
Since Python offers no way to get each byte without shifting, you must use the struct module to
access colour in an machine independent way.
Because of this, it is suggested you use the r, g, b and a attributes or the colour attribute instead.
Example::
import struct;
col = struct.unpack('4B', struct.pack('I', v.getRGBA()))
# col = (r, g, b, a)
# black = ( 0, 0, 0, 255)
# white = (255, 255, 255, 255)
@rtype: integer
@return: packed colour. 4 byte integer with one byte per colour channel in RGBA format.
"""
def setRGBA(col):
"""
Sets the colour of this vertex.
See getRGBA() for the format of col, and its relevant problems. Use the r, g, b and a attributes
or the colour attribute instead.
setRGBA() also accepts a four component list as argument col. The list represents the colour as [r, g, b, a]
with black = [0.0, 0.0, 0.0, 1.0] and white = [1.0, 1.0, 1.0, 1.0]
Example::
v.setRGBA(0xff0000ff) # Red
v.setRGBA(0xff00ff00) # Green on little endian, transparent purple on big endian
v.setRGBA([1.0, 0.0, 0.0, 1.0]) # Red
v.setRGBA([0.0, 1.0, 0.0, 1.0]) # Green on all platforms.
@type col: integer or list [r, g, b, a]
@param col: the new colour of this vertex in packed RGBA format.
"""
def getNormal():
"""
Gets the normal vector of this vertex.
@rtype: list [nx, ny, nz]
@return: normalised normal vector.
"""
def setNormal(normal):
"""
Sets the normal vector of this vertex.
@type normal: sequence of floats [r, g, b]
@param normal: the new normal of this vertex.
"""
|
