Game Python Reference Manual.
[blender.git] / source / gameengine / PyDoc / KX_VertexProxy.py
1 # Documentation for the vertex proxy class
2
3 class KX_VertexProxy:
4         """
5         A vertex holds position, UV, colour and normal information.
6         
7         Note:
8         The physics simulation is NOT currently updated - physics will not respond correctly
9         to changes in the vertex position.
10         """
11         
12         def getXYZ():
13                 """
14                 Gets the position of this vertex.
15                 
16                 @rtype: list [x, y, z]
17                 @return: this vertexes position in local coordinates.
18                 """
19         def setXYZ(pos):
20                 """
21                 Sets the position of this vertex.
22                 
23                 @type pos: list [x, y, z]
24                 @param: the new position for this vertex in local coordinates.
25                 """
26         def getUV():
27                 """
28                 Gets the UV (texture) coordinates of this vertex.
29                 
30                 @rtype: list [u, v]
31                 @return: this vertexes UV (texture) coordinates.
32                 """
33         def setUV(uv):
34                 """
35                 Sets the UV (texture) coordinates of this vertex.
36                 
37                 @type uv: list [u, v]
38                 """
39         def getRGBA():
40                 """
41                 Gets the colour of this vertex.
42                 
43                 Example:
44                 # Big endian:
45                 col = v.getRGBA()
46                 red = (col & 0xff000000) >> 24
47                 green = (col & 0xff0000) >> 16
48                 blue = (col & 0xff00) >> 8
49                 alpha = (col & 0xff)
50                 
51                 # Little endian:
52                 col = v.getRGBA()
53                 alpha = (col & 0xff000000) >> 24
54                 blue = (col & 0xff0000) >> 16
55                 green = (col & 0xff00) >> 8
56                 red = (col & 0xff)
57                 
58                 @rtype: integer
59                 @return: packed colour. 4 byte integer with one byte per colour channel in RGBA format.
60                 """
61         def setRGBA(col):
62                 """
63                 Sets the colour of this vertex.
64                 
65                 @type col: integer
66                 @param col: the new colour of this vertex in packed format.
67                 """
68         def getNormal():
69                 """
70                 Gets the normal vector of this vertex.
71                 
72                 @rtype: list [nx, ny, nz]
73                 @return: normalised normal vector.
74                 """