PyXYZ.cameraPyXYZ.cameraPyXYZ.camerapos {2-tuple} – Screen position in NDC (normalized device coordinates)
vector3, vector3 - Origin and direction of the ray corresponding to that screen +
Vector3, Vector3 - Origin and direction of the ray corresponding to that screen positions
PyXYZ.colorPyXYZ.colorPyXYZ.colorPyXYZ.colorPyXYZ.colorPyXYZ.colorPyXYZ.colorPyXYZ.color
-class InvalidColorOperationException
-(op, type1, type2)
-Exception thrown when there's an invalid operation with colors
class InvalidColorOperationException(Exception):
- """Exception thrown when there's an invalid operation with colors"""
- def __init__(self, op, type1, type2):
- super().__init__(self)
- self.op = op
- self.type1 = type1
- self.type2 = type2
-
- def __str__(self):
- """Returns a readable version of the exception"""
- return f"Invalid color operation ({self.op}) between {self.type1} and {self.type2}!"
-class color
+
+class Color
(r=0, g=0, b=0, a=1)
-
@@ -387,7 +359,7 @@
Arguments
Expand source code
-class color:
+class Color:
"""Color class.
It stores RGBA values as floats, in a range from 0 to 1.
"""
@@ -418,163 +390,163 @@ Arguments
stated otherwise, and even so it might require extra setup."""
def __str__(self):
- """Converts the color to a displayable string
+ """Converts the Color to a displayable string
Returns:
String - Color in text format (r,g,b,a)"""
return f"({self.r},{self.g},{self.b},{self.a})"
def __add__(self, c):
- """Adds this color to another. No validation of the output is done, i.e. any component
- can overflow. If we try to add anything other than a color to a color, it throws the
+ """Adds this Color to another. No validation of the output is done, i.e. any component
+ can overflow. If we try to add anything other than a Color to a Color, it throws the
InvalidColorOperationException.
Arguments:
- c {color} -- Color to add
+ c {Color} -- Color to add
Returns:
- Color - Sum of this color and the given one
+ Color - Sum of this Color and the given one
"""
- if isinstance(c, color):
- return color(self.r + c.r, self.g + c.g, self.b + c.b, self.a + c.a)
+ if isinstance(c, Color):
+ return Color(self.r + c.r, self.g + c.g, self.b + c.b, self.a + c.a)
else:
raise InvalidColorOperationException("add", type(self), type(c))
def __sub__(self, c):
- """Subtracts a color to this color. No validation of the output is done, i.e.
- any component can underflow. If we try to subtract anything other than a color to
- a color, it throws the InvalidColorOperationException.
+ """Subtracts a Color to this Color. No validation of the output is done, i.e.
+ any component can underflow. If we try to subtract anything other than a Color to
+ a Color, it throws the InvalidColorOperationException.
Arguments:
- c {color} -- Color to subtract
+ c {Color} -- Color to subtract
Returns:
- Color - Subraction of the given color from this color
+ Color - Subraction of the given Color from this Color
"""
- if isinstance(c, color):
- return color(self.r - c.r, self.g - c.g, self.b - c.b, self.a - c.a)
+ if isinstance(c, Color):
+ return Color(self.r - c.r, self.g - c.g, self.b - c.b, self.a - c.a)
else:
raise InvalidColorOperationException("sub", type(self), type(c))
def __mul__(self, c):
- """Multiplies this color by another color or a scalar. No validation of the output
+ """Multiplies this Color by another Color or a scalar. No validation of the output
is done, i.e. any component can underflow. If we try to multiply anything other than a
- color or a scalar, it throws the InvalidColorOperationException.
+ Color or a scalar, it throws the InvalidColorOperationException.
Arguments:
- c {color} -- Color to multiply: a component-wise multiplication is done
+ c {Color} -- Color to multiply: a component-wise multiplication is done
or
- c {number} -- Scalar to multiply: all components of the color are multiplied by
+ c {number} -- Scalar to multiply: all components of the Color are multiplied by
this number
Returns:
- Color - Multiplication of the color
+ Color - Multiplication of the Color
"""
if isinstance(c, (int, float)):
- return color(self.r * c, self.g * c, self.b * c, self.a * c)
- elif isinstance(c, color):
- return color(self.r * c.r, self.g * c.g, self.b * c.b, self.a * c.a)
+ return Color(self.r * c, self.g * c, self.b * c, self.a * c)
+ elif isinstance(c, Color):
+ return Color(self.r * c.r, self.g * c.g, self.b * c.b, self.a * c.a)
else:
raise InvalidColorOperationException("mult", type(self), type(c))
def __truediv__(self, c):
- """Divides this color by a scalar. No validation of the output is done, i.e. any
+ """Divides this Color by a scalar. No validation of the output is done, i.e. any
component can underflow. If we try to divide anything other than a scalar, it throws
the InvalidColorOperationException.
Arguments:
- c {number} -- Scalar to divide: all components of the color are divided by this
+ c {number} -- Scalar to divide: all components of the Color are divided by this
number
Returns:
Color - Color divided by the number
"""
if isinstance(c, (int, float)):
- return color(self.r / c, self.g / c, self.b / c, self.a / c)
+ return Color(self.r / c, self.g / c, self.b / c, self.a / c)
else:
raise InvalidColorOperationException("mult", type(self), type(c))
def __eq__(self, c):
- """Checks if this color is equal to the given one, with a tolerance of 0.0001.
+ """Checks if this Color is equal to the given one, with a tolerance of 0.0001.
Exception InvalidColorOperationException is raised if we compare something other
- than a color.
+ than a Color.
Arguments:
- c {color} -- Color to compare
+ c {Color} -- Color to compare
Returns:
Bool - True if the colors are the same, false otherwise
"""
- if isinstance(c, color):
+ if isinstance(c, Color):
return ((self - c).magnitude()) < 0.0001
else:
raise InvalidColorOperationException("eq", type(self), type(c))
def __ne__(self, c):
- """Checks if this color is different to the given one, with a tolerance of 0.0001.
+ """Checks if this Color is different to the given one, with a tolerance of 0.0001.
Exception InvalidColorOperationException is raised if we compare something other
- than a color.
+ than a Color.
Arguments:
- c {color} -- Color to compare
+ c {Color} -- Color to compare
Returns:
Bool - True if the colors are different, false otherwise
"""
- if isinstance(c, color):
+ if isinstance(c, Color):
return ((self - c).magnitude()) > 0.0001
else:
raise InvalidColorOperationException("neq", type(self), type(c))
def __isub__(self, c):
- """Subtracts a color to this color. No validation of the output is done, i.e.
- any component can underflow. If we try to subtract anything other than a color to
- a color, it throws the InvalidColorOperationException.
+ """Subtracts a Color to this Color. No validation of the output is done, i.e.
+ any component can underflow. If we try to subtract anything other than a Color to
+ a Color, it throws the InvalidColorOperationException.
Arguments:
- c {color} -- Color to subtract
+ c {Color} -- Color to subtract
Returns:
- Color - Subraction of the given color from this color
+ Color - Subraction of the given Color from this Color
"""
return self - c
def __iadd__(self, c):
- """Adds this color to another. No validation of the output is done, i.e. any component
- can overflow. If we try to add anything other than a color to a color, it throws the
+ """Adds this Color to another. No validation of the output is done, i.e. any component
+ can overflow. If we try to add anything other than a Color to a Color, it throws the
InvalidColorOperationException.
Arguments:
- c {color} -- Color to add
+ c {Color} -- Color to add
Returns:
- Color - Sum of this color and the given one
+ Color - Sum of this Color and the given one
"""
return self + c
def __imul__(self, c):
- """Multiplies this color by another color or a scalar. No validation of the output
+ """Multiplies this Color by another Color or a scalar. No validation of the output
is done, i.e. any component can underflow. If we try to multiply anything other than
- a color or a scalar, it throws the InvalidColorOperationException.
+ a Color or a scalar, it throws the InvalidColorOperationException.
Arguments:
- c {color} -- Color to multiply: a component-wise multiplication is done
+ c {Color} -- Color to multiply: a component-wise multiplication is done
or
- c {number} -- Scalar to multiply: all components of the color are multiplied by this
+ c {number} -- Scalar to multiply: all components of the Color are multiplied by this
number
Returns:
- Color - Multiplication of the color
+ Color - Multiplication of the Color
"""
return self * c
def __idiv__(self, c):
- """Divides this color by a scalar. No validation of the output is done, i.e. any
+ """Divides this Color by a scalar. No validation of the output is done, i.e. any
component can underflow. If we try to divide anything other than a scalar, it
throws the InvalidColorOperationException.
Arguments:
- c {number} -- Scalar to divide: all components of the color are divided by this number
+ c {number} -- Scalar to divide: all components of the Color are divided by this number
Returns:
Color - Color divided by the number
@@ -582,39 +554,39 @@ Arguments
return self / c
def __neg__(self):
- """Inverts this color. All components except for alpha are inverted.
+ """Inverts this Color. All components except for alpha are inverted.
Returns:
Color - Color (1-r, 1-g, 1-b, a)
"""
- return color(1-self.r, 1-self.g, 1-self.b, self.a)
+ return Color(1-self.r, 1-self.g, 1-self.b, self.a)
def magnitude(self):
- """Returns the magnitude of the color.
+ """Returns the magnitude of the Color.
Returns:
- Number - Magnitude of the color as a 4D vector
+ Number - Magnitude of the Color as a 4D vector
"""
return math.sqrt(self.dot(self))
def dot(self, c):
- """Computes the dot product of this color with another.
- If we try to do this operation with anything other than a color, it throws the
+ """Computes the dot product of this Color with another.
+ If we try to do this operation with anything other than a Color, it throws the
InvalidColorOperationException.
Arguments:
- c {color} -- Color to do the dot product with
+ c {Color} -- Color to do the dot product with
Returns:
Number - Scalar value corresponding to the dot product of both colors
"""
- if isinstance(c, color):
+ if isinstance(c, Color):
return self.r * c.r + self.g * c.g + self.b * c.b + self.a * c.a
else:
raise InvalidColorOperationException("dot", type(self), type(c))
def normalize(self):
- """Normalizes this color, as if it was a 4D vector.
+ """Normalizes this Color, as if it was a 4D vector.
"""
d = 1.0 / self.magnitude()
self.r *= d
@@ -623,25 +595,25 @@ Arguments
self.a *= d
def normalized(self):
- """Returns the normalized version of this color, treating it as a 4D vector.
+ """Returns the normalized version of this Color, treating it as a 4D vector.
Returns:
- Color - Normalized color
+ Color - Normalized Color
"""
d = 1.0 / self.magnitude()
- return color(self.r * d, self.g * d, self.b * d, self.a * d)
+ return Color(self.r * d, self.g * d, self.b * d, self.a * d)
def premult_alpha(self):
"""Multiplies the RGB components with the alpha component, for use with pre-multiplied
- alpha blend mode and returns this new color.
+ alpha blend mode and returns this new Color.
Returns:
- Color - Premultiplied color
+ Color - Premultiplied Color
"""
- return color(self.r * self.a, self.g * self.a, self.b * self.a, self.a)
+ return Color(self.r * self.a, self.g * self.a, self.b * self.a, self.a)
def tuple3(self):
- """Converts a color to a 3-tuple, to be used with Pygame
+ """Converts a Color to a 3-tuple, to be used with Pygame
Returns:
Tuple - (r * 255, g * 255, b * 255)
@@ -649,7 +621,7 @@ Arguments
return (self.r * 255, self.g * 255, self.b * 255)
def tuple4(self):
- """Converts a color to a 4-tuple, to be used with Pygame
+ """Converts a Color to a 4-tuple, to be used with Pygame
Returns:
Tuple - (r * 255, g * 255, b * 255, a * 255)
@@ -657,7 +629,7 @@ Arguments
return (self.r * 255, self.g * 255, self.b * 255, self.a * 255)
def saturate(self):
- """Clamps all the color components between the valid [0..1] range
+ """Clamps all the Color components between the valid [0..1] range
"""
self.r = min(max(self.r, 0), 1)
self.g = min(max(self.g, 0), 1)
@@ -665,12 +637,12 @@ Arguments
self.a = min(max(self.a, 0), 1)
def saturated(self):
- """Returns a clamped version of this color
+ """Returns a clamped version of this Color
Returns:
- Color - Clamped color
+ Color - Clamped Color
"""
- return color(
+ return Color(
min(max(self.r, 0), 1),
min(max(self.g, 0), 1),
min(max(self.b, 0), 1),
@@ -679,23 +651,23 @@ Arguments
Instance variables
-var avar a-
{number} Alpha component. Should be in the [0..1] range, although there is no
guarantees. Note that most Pygame functions don't use the alpha component, unless
stated otherwise, and even so it might require extra setup.
-var bvar b-
{number} Blue component. Should be in the [0..1] range, although there is no
guarantees
-var gvar g-
{number} Green component. Should be in the [0..1] range, although there is no
guarantees
-var rvar r-
{number} Red component. Should be in the [0..1] range, although there is no
guarantees
@@ -703,15 +675,15 @@ Instance variables
Methods
-
+
def dot(self, c)
-
-
Computes the dot product of this color with another.
-If we try to do this operation with anything other than a color, it throws the
+
Computes the dot product of this Color with another.
+If we try to do this operation with anything other than a Color, it throws the
InvalidColorOperationException.
Arguments
-c {color} – Color to do the dot product with
+c {Color} – Color to do the dot product with
Returns
Number - Scalar value corresponding to the dot product of both colors
@@ -719,53 +691,53 @@ Returns
Expand source code
def dot(self, c):
- """Computes the dot product of this color with another.
- If we try to do this operation with anything other than a color, it throws the
+ """Computes the dot product of this Color with another.
+ If we try to do this operation with anything other than a Color, it throws the
InvalidColorOperationException.
Arguments:
- c {color} -- Color to do the dot product with
+ c {Color} -- Color to do the dot product with
Returns:
Number - Scalar value corresponding to the dot product of both colors
"""
- if isinstance(c, color):
+ if isinstance(c, Color):
return self.r * c.r + self.g * c.g + self.b * c.b + self.a * c.a
else:
raise InvalidColorOperationException("dot", type(self), type(c))
-
+
def magnitude(self)
-
-
Returns the magnitude of the color.
+Returns the magnitude of the Color.
Returns
-Number - Magnitude of the color as a 4D vector
+Number - Magnitude of the Color as a 4D vector
Expand source code
def magnitude(self):
- """Returns the magnitude of the color.
+ """Returns the magnitude of the Color.
Returns:
- Number - Magnitude of the color as a 4D vector
+ Number - Magnitude of the Color as a 4D vector
"""
return math.sqrt(self.dot(self))
-
+
def normalize(self)
-
-
Normalizes this color, as if it was a 4D vector.
+Normalizes this Color, as if it was a 4D vector.
Expand source code
def normalize(self):
- """Normalizes this color, as if it was a 4D vector.
+ """Normalizes this Color, as if it was a 4D vector.
"""
d = 1.0 / self.magnitude()
self.r *= d
@@ -774,60 +746,60 @@ Returns
self.a *= d
-
+
def normalized(self)
-
-
Returns the normalized version of this color, treating it as a 4D vector.
+Returns the normalized version of this Color, treating it as a 4D vector.
Returns
-Color - Normalized color
+Color - Normalized Color
Expand source code
def normalized(self):
- """Returns the normalized version of this color, treating it as a 4D vector.
+ """Returns the normalized version of this Color, treating it as a 4D vector.
Returns:
- Color - Normalized color
+ Color - Normalized Color
"""
d = 1.0 / self.magnitude()
- return color(self.r * d, self.g * d, self.b * d, self.a * d)
+ return Color(self.r * d, self.g * d, self.b * d, self.a * d)
-
+
def premult_alpha(self)
-
Multiplies the RGB components with the alpha component, for use with pre-multiplied
-alpha blend mode and returns this new color.
+alpha blend mode and returns this new Color.
Returns
-Color - Premultiplied color
+Color - Premultiplied Color
Expand source code
def premult_alpha(self):
"""Multiplies the RGB components with the alpha component, for use with pre-multiplied
- alpha blend mode and returns this new color.
+ alpha blend mode and returns this new Color.
Returns:
- Color - Premultiplied color
+ Color - Premultiplied Color
"""
- return color(self.r * self.a, self.g * self.a, self.b * self.a, self.a)
+ return Color(self.r * self.a, self.g * self.a, self.b * self.a, self.a)
-
+
def saturate(self)
-
-
Clamps all the color components between the valid [0..1] range
+Clamps all the Color components between the valid [0..1] range
Expand source code
def saturate(self):
- """Clamps all the color components between the valid [0..1] range
+ """Clamps all the Color components between the valid [0..1] range
"""
self.r = min(max(self.r, 0), 1)
self.g = min(max(self.g, 0), 1)
@@ -835,24 +807,24 @@ Returns
self.a = min(max(self.a, 0), 1)
-
+
def saturated(self)
-
-
Returns a clamped version of this color
+Returns a clamped version of this Color
Returns
-Color - Clamped color
+Color - Clamped Color
Expand source code
def saturated(self):
- """Returns a clamped version of this color
+ """Returns a clamped version of this Color
Returns:
- Color - Clamped color
+ Color - Clamped Color
"""
- return color(
+ return Color(
min(max(self.r, 0), 1),
min(max(self.g, 0), 1),
min(max(self.b, 0), 1),
@@ -860,11 +832,11 @@ Returns
)
-
+
def tuple3(self)
-
-
Converts a color to a 3-tuple, to be used with Pygame
+Converts a Color to a 3-tuple, to be used with Pygame
Returns
Tuple - (r * 255, g * 255, b * 255)
@@ -872,7 +844,7 @@ Returns
Expand source code
def tuple3(self):
- """Converts a color to a 3-tuple, to be used with Pygame
+ """Converts a Color to a 3-tuple, to be used with Pygame
Returns:
Tuple - (r * 255, g * 255, b * 255)
@@ -880,11 +852,11 @@ Returns
return (self.r * 255, self.g * 255, self.b * 255)
-
+
def tuple4(self)
-
-
Converts a color to a 4-tuple, to be used with Pygame
+Converts a Color to a 4-tuple, to be used with Pygame
Returns
Tuple - (r * 255, g * 255, b * 255, a * 255)
@@ -892,7 +864,7 @@ Returns
Expand source code
def tuple4(self):
- """Converts a color to a 4-tuple, to be used with Pygame
+ """Converts a Color to a 4-tuple, to be used with Pygame
Returns:
Tuple - (r * 255, g * 255, b * 255, a * 255)
@@ -902,6 +874,34 @@ Returns
+
+class InvalidColorOperationException
+(op, type1, type2)
+-
+
Exception thrown when there's an invalid operation with colors
+
+
+Expand source code
+
+class InvalidColorOperationException(Exception):
+ """Exception thrown when there's an invalid operation with colors"""
+ def __init__(self, op, type1, type2):
+ super().__init__(self)
+ self.op = op
+ self.type1 = type1
+ self.type2 = type2
+
+ def __str__(self):
+ """Returns a readable version of the exception"""
+ return f"Invalid Color operation ({self.op}) between {self.type1} and {self.type2}!"
+
+Ancestors
+
+- builtins.Exception
+- builtins.BaseException
+
+
@@ -919,26 +919,26 @@ Index
Classes
Module PyXYZ.material
class Material:
"""Material class.
Describe the properties of the mesh being drawn. Currently it only supports a
- color and a line width.
+ Color and a line width.
"""
- def __init__(self, color, name="UnknownMaterial"):
+ def __init__(self, Color, name="UnknownMaterial"):
"""
Arguments:
- color {color} -- Color of the line
+ Color {Color} -- Color of the line
name {str} -- Name of the material, defaults to 'UnknownMaterial'
"""
- self.color = color
- """{color} Color of the lines on the mesh"""
+ self.Color = Color
+ """{Color} Color of the lines on the mesh"""
self.name = name
"""{str} Name of this material"""
self.line_width = 2
@@ -61,14 +61,14 @@ Classes
class Material
-(color, name='UnknownMaterial')
+(Color, name='UnknownMaterial')
-
Material class.
Describe the properties of the mesh being drawn. Currently it only supports a
-color and a line width.
+Color and a line width.
Arguments
-color {color} – Color of the line
+Color {Color} – Color of the line
name {str} – Name of the material, defaults to 'UnknownMaterial'
@@ -77,18 +77,18 @@ Arguments
class Material:
"""Material class.
Describe the properties of the mesh being drawn. Currently it only supports a
- color and a line width.
+ Color and a line width.
"""
- def __init__(self, color, name="UnknownMaterial"):
+ def __init__(self, Color, name="UnknownMaterial"):
"""
Arguments:
- color {color} -- Color of the line
+ Color {Color} -- Color of the line
name {str} -- Name of the material, defaults to 'UnknownMaterial'
"""
- self.color = color
- """{color} Color of the lines on the mesh"""
+ self.Color = Color
+ """{Color} Color of the lines on the mesh"""
self.name = name
"""{str} Name of this material"""
self.line_width = 2
@@ -96,9 +96,9 @@ Arguments
Instance variables
-var colorvar Color-
-
{color} Color of the lines on the mesh
+{Color} Color of the lines on the mesh
var line_width-
@@ -129,7 +129,7 @@
Index
-
Material
diff --git a/doc/PyXYZ/mesh.html b/doc/PyXYZ/mesh.html
index ad45ea8..386f0c8 100644
--- a/doc/PyXYZ/mesh.html
+++ b/doc/PyXYZ/mesh.html
@@ -30,7 +30,7 @@ Module PyXYZ.mesh
"""Mesh class definition"""
import math
import pygame
-from vector3 import vector3
+from vector3 import Vector3
class Mesh:
"""Mesh class.
@@ -55,7 +55,7 @@ Module PyXYZ.mesh
self.name = name
""" {str} Name of the mesh"""
self.polygons = []
- """ {list[list[vector3]]} List of lists of polygons. A polygon is a closed shape,
+ """ {list[list[Vector3]]} List of lists of polygons. A polygon is a closed shape,
hence the need for a list of lists, if we want more complex shapes."""
def offset(self, v):
@@ -64,7 +64,7 @@ Module PyXYZ.mesh
Arguments:
- v {vector3} -- Ammount to displace the mesh
+ v {Vector3} -- Ammount to displace the mesh
"""
new_polys = []
for poly in self.polygons:
@@ -92,8 +92,8 @@ Module PyXYZ.mesh
render times, but it is normally commented out, for performance reasons. If you want
to use the statistics, uncomment the code on this funtion.
"""
- # Convert color to the pygame format
- c = material.color.tuple3()
+ # Convert Color to the pygame format
+ c = material.Color.tuple3()
# For all polygons
for poly in self.polygons:
@@ -146,26 +146,26 @@ Module PyXYZ.mesh
mesh = Mesh("UnknownCube")
# Add the 6 quads that create a cube
- Mesh.create_quad(vector3(size[0] * 0.5, 0, 0),
- vector3(0, -size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0),
- vector3(0, size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, size[1] * 0.5, 0),
- vector3(size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(0, -size[1] * 0.5, 0),
- vector3(-size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, 0, size[2] * 0.5),
- vector3(-size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
- Mesh.create_quad(vector3(0, 0, -size[2] * 0.5),
- vector3(size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(size[0] * 0.5, 0, 0),
+ Vector3(0, -size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(-size[0] * 0.5, 0, 0),
+ Vector3(0, size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, size[1] * 0.5, 0),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(0, -size[1] * 0.5, 0),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, 0, size[2] * 0.5),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(0, 0, -size[2] * 0.5),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
return mesh
@@ -196,15 +196,15 @@ Module PyXYZ.mesh
mesh = Mesh("UnknownSphere")
# Compute half-size
- if isinstance(size, vector3):
+ if isinstance(size, Vector3):
hs = size * 0.5
else:
- hs = vector3(size[0], size[1], size[2]) * 0.5
+ hs = Vector3(size[0], size[1], size[2]) * 0.5
# Sphere is going to be composed by quads in most of the surface, but triangles near the
# poles, so compute the bottom and top vertex
- bottom_vertex = vector3(0, -hs.y, 0)
- top_vertex = vector3(0, hs.y, 0)
+ bottom_vertex = Vector3(0, -hs.y, 0)
+ top_vertex = Vector3(0, hs.y, 0)
lat_inc = math.pi / res_lat
lon_inc = math.pi * 2 / res_lon
@@ -215,8 +215,8 @@ Module PyXYZ.mesh
y = hs.y * math.sin(lat + lat_inc)
c = math.cos(lat + lat_inc)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(bottom_vertex, p1, p2, mesh)
@@ -233,16 +233,16 @@ Module PyXYZ.mesh
lon = 0
for _ in range(0, res_lon):
- p1 = vector3(c1 * math.cos(lon) * hs.x,
+ p1 = Vector3(c1 * math.cos(lon) * hs.x,
y1,
c1 * math.sin(lon) * hs.z)
- p2 = vector3(c1 * math.cos(lon + lon_inc) * hs.x,
+ p2 = Vector3(c1 * math.cos(lon + lon_inc) * hs.x,
y1,
c1 * math.sin(lon + lon_inc) * hs.z)
- p3 = vector3(c2 * math.cos(lon) * hs.x,
+ p3 = Vector3(c2 * math.cos(lon) * hs.x,
y2,
c2 * math.sin(lon) * hs.z)
- p4 = vector3(c2 * math.cos(lon + lon_inc) * hs.x,
+ p4 = Vector3(c2 * math.cos(lon + lon_inc) * hs.x,
y2,
c2 * math.sin(lon + lon_inc) * hs.z)
@@ -261,8 +261,8 @@ Module PyXYZ.mesh
y = hs.y * math.sin(lat)
c = math.cos(lat)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(top_vertex, p1, p2, mesh)
@@ -279,12 +279,12 @@ Module PyXYZ.mesh
Arguments:
- origin {vector3} -- Center of the quad
+ origin {Vector3} -- Center of the quad
- axis0 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis0 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
- axis1 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis1 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -313,11 +313,11 @@ Module PyXYZ.mesh
Arguments:
- p1 {vector3} -- First vertex of the triangle
+ p1 {Vector3} -- First vertex of the triangle
- p2 {vector3} -- Second vertex of the triangle
+ p2 {Vector3} -- Second vertex of the triangle
- p3 {vector3} -- Third vertex of the triangle
+ p3 {Vector3} -- Third vertex of the triangle
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -382,7 +382,7 @@ Arguments
self.name = name
""" {str} Name of the mesh"""
self.polygons = []
- """ {list[list[vector3]]} List of lists of polygons. A polygon is a closed shape,
+ """ {list[list[Vector3]]} List of lists of polygons. A polygon is a closed shape,
hence the need for a list of lists, if we want more complex shapes."""
def offset(self, v):
@@ -391,7 +391,7 @@ Arguments
Arguments:
- v {vector3} -- Ammount to displace the mesh
+ v {Vector3} -- Ammount to displace the mesh
"""
new_polys = []
for poly in self.polygons:
@@ -419,8 +419,8 @@ Arguments
render times, but it is normally commented out, for performance reasons. If you want
to use the statistics, uncomment the code on this funtion.
"""
- # Convert color to the pygame format
- c = material.color.tuple3()
+ # Convert Color to the pygame format
+ c = material.Color.tuple3()
# For all polygons
for poly in self.polygons:
@@ -473,26 +473,26 @@ Arguments
mesh = Mesh("UnknownCube")
# Add the 6 quads that create a cube
- Mesh.create_quad(vector3(size[0] * 0.5, 0, 0),
- vector3(0, -size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0),
- vector3(0, size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, size[1] * 0.5, 0),
- vector3(size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(0, -size[1] * 0.5, 0),
- vector3(-size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, 0, size[2] * 0.5),
- vector3(-size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
- Mesh.create_quad(vector3(0, 0, -size[2] * 0.5),
- vector3(size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(size[0] * 0.5, 0, 0),
+ Vector3(0, -size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(-size[0] * 0.5, 0, 0),
+ Vector3(0, size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, size[1] * 0.5, 0),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(0, -size[1] * 0.5, 0),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, 0, size[2] * 0.5),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(0, 0, -size[2] * 0.5),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
return mesh
@@ -523,15 +523,15 @@ Arguments
mesh = Mesh("UnknownSphere")
# Compute half-size
- if isinstance(size, vector3):
+ if isinstance(size, Vector3):
hs = size * 0.5
else:
- hs = vector3(size[0], size[1], size[2]) * 0.5
+ hs = Vector3(size[0], size[1], size[2]) * 0.5
# Sphere is going to be composed by quads in most of the surface, but triangles near the
# poles, so compute the bottom and top vertex
- bottom_vertex = vector3(0, -hs.y, 0)
- top_vertex = vector3(0, hs.y, 0)
+ bottom_vertex = Vector3(0, -hs.y, 0)
+ top_vertex = Vector3(0, hs.y, 0)
lat_inc = math.pi / res_lat
lon_inc = math.pi * 2 / res_lon
@@ -542,8 +542,8 @@ Arguments
y = hs.y * math.sin(lat + lat_inc)
c = math.cos(lat + lat_inc)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(bottom_vertex, p1, p2, mesh)
@@ -560,16 +560,16 @@ Arguments
lon = 0
for _ in range(0, res_lon):
- p1 = vector3(c1 * math.cos(lon) * hs.x,
+ p1 = Vector3(c1 * math.cos(lon) * hs.x,
y1,
c1 * math.sin(lon) * hs.z)
- p2 = vector3(c1 * math.cos(lon + lon_inc) * hs.x,
+ p2 = Vector3(c1 * math.cos(lon + lon_inc) * hs.x,
y1,
c1 * math.sin(lon + lon_inc) * hs.z)
- p3 = vector3(c2 * math.cos(lon) * hs.x,
+ p3 = Vector3(c2 * math.cos(lon) * hs.x,
y2,
c2 * math.sin(lon) * hs.z)
- p4 = vector3(c2 * math.cos(lon + lon_inc) * hs.x,
+ p4 = Vector3(c2 * math.cos(lon + lon_inc) * hs.x,
y2,
c2 * math.sin(lon + lon_inc) * hs.z)
@@ -588,8 +588,8 @@ Arguments
y = hs.y * math.sin(lat)
c = math.cos(lat)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(top_vertex, p1, p2, mesh)
@@ -606,12 +606,12 @@ Arguments
Arguments:
- origin {vector3} -- Center of the quad
+ origin {Vector3} -- Center of the quad
- axis0 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis0 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
- axis1 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis1 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -640,11 +640,11 @@ Arguments
Arguments:
- p1 {vector3} -- First vertex of the triangle
+ p1 {Vector3} -- First vertex of the triangle
- p2 {vector3} -- Second vertex of the triangle
+ p2 {Vector3} -- Second vertex of the triangle
- p3 {vector3} -- Third vertex of the triangle
+ p3 {Vector3} -- Third vertex of the triangle
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -721,26 +721,26 @@ Returns
mesh = Mesh("UnknownCube")
# Add the 6 quads that create a cube
- Mesh.create_quad(vector3(size[0] * 0.5, 0, 0),
- vector3(0, -size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0),
- vector3(0, size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, size[1] * 0.5, 0),
- vector3(size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(0, -size[1] * 0.5, 0),
- vector3(-size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, 0, size[2] * 0.5),
- vector3(-size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
- Mesh.create_quad(vector3(0, 0, -size[2] * 0.5),
- vector3(size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(size[0] * 0.5, 0, 0),
+ Vector3(0, -size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(-size[0] * 0.5, 0, 0),
+ Vector3(0, size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, size[1] * 0.5, 0),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(0, -size[1] * 0.5, 0),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, 0, size[2] * 0.5),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(0, 0, -size[2] * 0.5),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
return mesh
@@ -752,10 +752,10 @@ Returns
Adds the vertices necessary to create a quad (4 sided coplanar rectangle).
If a source mesh is not given, a new mesh is created.
Arguments
-origin {vector3} – Center of the quad
-axis0 {vector3} – One of the axis of the quad. This is not normalized, since the
+
origin {Vector3} – Center of the quad
+axis0 {Vector3} – One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
-axis1 {vector3} – One of the axis of the quad. This is not normalized, since the
+
axis1 {Vector3} – One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
mesh {Mesh} – Mesh to add the polygons. If not given, create a new mesh
Returns
@@ -772,12 +772,12 @@ Returns
Arguments:
- origin {vector3} -- Center of the quad
+ origin {Vector3} -- Center of the quad
- axis0 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis0 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
- axis1 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis1 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -846,15 +846,15 @@ Returns
mesh = Mesh("UnknownSphere")
# Compute half-size
- if isinstance(size, vector3):
+ if isinstance(size, Vector3):
hs = size * 0.5
else:
- hs = vector3(size[0], size[1], size[2]) * 0.5
+ hs = Vector3(size[0], size[1], size[2]) * 0.5
# Sphere is going to be composed by quads in most of the surface, but triangles near the
# poles, so compute the bottom and top vertex
- bottom_vertex = vector3(0, -hs.y, 0)
- top_vertex = vector3(0, hs.y, 0)
+ bottom_vertex = Vector3(0, -hs.y, 0)
+ top_vertex = Vector3(0, hs.y, 0)
lat_inc = math.pi / res_lat
lon_inc = math.pi * 2 / res_lon
@@ -865,8 +865,8 @@ Returns
y = hs.y * math.sin(lat + lat_inc)
c = math.cos(lat + lat_inc)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(bottom_vertex, p1, p2, mesh)
@@ -883,16 +883,16 @@ Returns
lon = 0
for _ in range(0, res_lon):
- p1 = vector3(c1 * math.cos(lon) * hs.x,
+ p1 = Vector3(c1 * math.cos(lon) * hs.x,
y1,
c1 * math.sin(lon) * hs.z)
- p2 = vector3(c1 * math.cos(lon + lon_inc) * hs.x,
+ p2 = Vector3(c1 * math.cos(lon + lon_inc) * hs.x,
y1,
c1 * math.sin(lon + lon_inc) * hs.z)
- p3 = vector3(c2 * math.cos(lon) * hs.x,
+ p3 = Vector3(c2 * math.cos(lon) * hs.x,
y2,
c2 * math.sin(lon) * hs.z)
- p4 = vector3(c2 * math.cos(lon + lon_inc) * hs.x,
+ p4 = Vector3(c2 * math.cos(lon + lon_inc) * hs.x,
y2,
c2 * math.sin(lon + lon_inc) * hs.z)
@@ -911,8 +911,8 @@ Returns
y = hs.y * math.sin(lat)
c = math.cos(lat)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(top_vertex, p1, p2, mesh)
@@ -928,9 +928,9 @@ Returns
Adds the vertices necessary to create a triangle
If a source mesh is not given, a new mesh is created.
Arguments
-p1 {vector3} – First vertex of the triangle
-p2 {vector3} – Second vertex of the triangle
-p3 {vector3} – Third vertex of the triangle
+p1 {Vector3} – First vertex of the triangle
+p2 {Vector3} – Second vertex of the triangle
+p3 {Vector3} – Third vertex of the triangle
mesh {Mesh} – Mesh to add the polygons. If not given, create a new mesh
Returns
{Mesh} - Mesh where the polygons were added
@@ -946,11 +946,11 @@ Returns
Arguments:
- p1 {vector3} -- First vertex of the triangle
+ p1 {Vector3} -- First vertex of the triangle
- p2 {vector3} -- Second vertex of the triangle
+ p2 {Vector3} -- Second vertex of the triangle
- p3 {vector3} -- Third vertex of the triangle
+ p3 {Vector3} -- Third vertex of the triangle
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -979,7 +979,7 @@ Instance variables
var polygons-
-
{list[list[vector3]]} List of lists of polygons. A polygon is a closed shape,
+
{list[list[Vector3]]} List of lists of polygons. A polygon is a closed shape,
hence the need for a list of lists, if we want more complex shapes.
@@ -991,7 +991,7 @@ Methods
-
Offsets this mesh by a given vector. In practice, adds v to all vertex in all polygons
Arguments
-v {vector3} – Ammount to displace the mesh
+v {Vector3} – Ammount to displace the mesh
Expand source code
@@ -1002,7 +1002,7 @@ Arguments
Arguments:
- v {vector3} -- Ammount to displace the mesh
+ v {Vector3} -- Ammount to displace the mesh
"""
new_polys = []
for poly in self.polygons:
@@ -1048,8 +1048,8 @@ Arguments
render times, but it is normally commented out, for performance reasons. If you want
to use the statistics, uncomment the code on this funtion.
"""
- # Convert color to the pygame format
- c = material.color.tuple3()
+ # Convert Color to the pygame format
+ c = material.Color.tuple3()
# For all polygons
for poly in self.polygons:
diff --git a/doc/PyXYZ/object3d.html b/doc/PyXYZ/object3d.html
index 1306dbe..06c18a4 100644
--- a/doc/PyXYZ/object3d.html
+++ b/doc/PyXYZ/object3d.html
@@ -31,7 +31,7 @@ Module PyXYZ.object3d
import numpy as np
from quaternion import quaternion, as_rotation_matrix
-from vector3 import vector3
+from vector3 import Vector3
class Object3d:
"""3d object class.
@@ -45,12 +45,12 @@ Module PyXYZ.object3d
"""
self.name = name
""" {str} Name of the object"""
- self.position = vector3()
- """ {vector3} Local position of the object (relative to parent)"""
+ self.position = Vector3()
+ """ {Vector3} Local position of the object (relative to parent)"""
self.rotation = quaternion(1, 0, 0, 0)
""" {quaternion} Local rotation of the object {relative to parent)"""
- self.scale = vector3(1, 1, 1)
- """ {vector3} Local scale of the object (relative to parent)"""
+ self.scale = Vector3(1, 1, 1)
+ """ {Vector3} Local scale of the object (relative to parent)"""
self.mesh = None
""" {Mesh} Mesh to be rendered in this object"""
self.material = None
@@ -124,9 +124,9 @@ Module PyXYZ.object3d
Returns:
- {vector3} - Local position of the object
+ {Vector3} - Local position of the object
"""
- return vector3.from_np(vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
def forward(self):
"""
@@ -135,9 +135,9 @@ Module PyXYZ.object3d
Returns:
- {vector3} - Local forward vector of the object
+ {Vector3} - Local forward vector of the object
"""
- return vector3.from_np(vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
def up(self):
"""
@@ -146,9 +146,9 @@ Module PyXYZ.object3d
Returns:
- {vector3} - Local up vector of the object
+ {Vector3} - Local up vector of the object
"""
- return vector3.from_np(vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
def right(self):
"""
@@ -157,9 +157,9 @@ Module PyXYZ.object3d
Returns:
- {vector3} - Local right vector of the object
+ {Vector3} - Local right vector of the object
"""
- return vector3.from_np(vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
@staticmethod
def get_prs_matrix(position, rotation, scale):
@@ -168,11 +168,11 @@ Module PyXYZ.object3d
Arguments:
- position {vector3} - Position
+ position {Vector3} - Position
rotation {quaternion} - Rotation
- scale {vector3} - Scale
+ scale {Vector3} - Scale
Returns:
@@ -238,12 +238,12 @@ Arguments
"""
self.name = name
""" {str} Name of the object"""
- self.position = vector3()
- """ {vector3} Local position of the object (relative to parent)"""
+ self.position = Vector3()
+ """ {Vector3} Local position of the object (relative to parent)"""
self.rotation = quaternion(1, 0, 0, 0)
""" {quaternion} Local rotation of the object {relative to parent)"""
- self.scale = vector3(1, 1, 1)
- """ {vector3} Local scale of the object (relative to parent)"""
+ self.scale = Vector3(1, 1, 1)
+ """ {Vector3} Local scale of the object (relative to parent)"""
self.mesh = None
""" {Mesh} Mesh to be rendered in this object"""
self.material = None
@@ -317,9 +317,9 @@ Arguments
Returns:
- {vector3} - Local position of the object
+ {Vector3} - Local position of the object
"""
- return vector3.from_np(vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
def forward(self):
"""
@@ -328,9 +328,9 @@ Arguments
Returns:
- {vector3} - Local forward vector of the object
+ {Vector3} - Local forward vector of the object
"""
- return vector3.from_np(vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
def up(self):
"""
@@ -339,9 +339,9 @@ Arguments
Returns:
- {vector3} - Local up vector of the object
+ {Vector3} - Local up vector of the object
"""
- return vector3.from_np(vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
def right(self):
"""
@@ -350,9 +350,9 @@ Arguments
Returns:
- {vector3} - Local right vector of the object
+ {Vector3} - Local right vector of the object
"""
- return vector3.from_np(vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
@staticmethod
def get_prs_matrix(position, rotation, scale):
@@ -361,11 +361,11 @@ Arguments
Arguments:
- position {vector3} - Position
+ position {Vector3} - Position
rotation {quaternion} - Rotation
- scale {vector3} - Scale
+ scale {Vector3} - Scale
Returns:
@@ -404,9 +404,9 @@ Static methods
-
Creates a PRS matrix from the given position, rotation and scale
Arguments
-position {vector3} - Position
+position {Vector3} - Position
rotation {quaternion} - Rotation
-scale {vector3} - Scale
+scale {Vector3} - Scale
Returns
{np.array} - PRS matrix
@@ -420,11 +420,11 @@ Returns
Arguments:
- position {vector3} - Position
+ position {Vector3} - Position
rotation {quaternion} - Rotation
- scale {vector3} - Scale
+ scale {Vector3} - Scale
Returns:
@@ -477,7 +477,7 @@ Instance variables
var position-
-
{vector3} Local position of the object (relative to parent)
+{Vector3} Local position of the object (relative to parent)
var rotation-
@@ -485,7 +485,7 @@
Instance variables
var scale-
-
{vector3} Local scale of the object (relative to parent)
+{Vector3} Local scale of the object (relative to parent)
Methods
@@ -519,7 +519,7 @@ Arguments
Retrieves the local forward vector of this object. The forward vector is defined as
being the z-positive vector multiplied with the local transformation matrix
Returns
-{vector3} - Local forward vector of the object
+{Vector3} - Local forward vector of the object
Expand source code
@@ -531,9 +531,9 @@ Returns
Returns:
- {vector3} - Local forward vector of the object
+ {Vector3} - Local forward vector of the object
"""
- return vector3.from_np(vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
@@ -566,7 +566,7 @@ Returns
method actually computes the transfomation matrix and multiplies the 4d vector (0,0,0,1)
by it. Results should be very similar.
Returns
-{vector3} - Local position of the object
{Vector3} - Local position of the object
Expand source code
@@ -579,9 +579,9 @@ Returns
Returns:
- {vector3} - Local position of the object
+ {Vector3} - Local position of the object
"""
- return vector3.from_np(vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
@@ -656,7 +656,7 @@ Arguments
Retrieves the local right vector of this object. The right vector is defined as being
the x-positive vector multiplied with the local transformation matrix
Returns
-{vector3} - Local right vector of the object
+{Vector3} - Local right vector of the object
Expand source code
@@ -668,9 +668,9 @@ Returns
Returns:
- {vector3} - Local right vector of the object
+ {Vector3} - Local right vector of the object
"""
- return vector3.from_np(vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
@@ -680,7 +680,7 @@ Returns
Retrieves the local up vector of this object. The up vector is defined as being
the y-positive vector multiplied with the local transformation matrix
Returns
-{vector3} - Local up vector of the object
+{Vector3} - Local up vector of the object
Expand source code
@@ -692,9 +692,9 @@ Returns
Returns:
- {vector3} - Local up vector of the object
+ {Vector3} - Local up vector of the object
"""
- return vector3.from_np(vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
PyXYZ.sample_cubefallPyXYZ.sample_cubefallPyXYZ.sample_cubefallPyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_gamePyXYZ.sample_hierarchyPyXYZ.sample_hierarchyPyXYZ.sample_spherePyXYZ.sample_spherePyXYZ.sample_terrainPyXYZ.sample_terrainPyXYZ.sample_terrainPyXYZ.sample_terrainPyXYZ.sample_terrainPyXYZ.sample_terrainPyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3PyXYZ.vector3Returns the cross product between two vectors
v1 {vector3} - First vector -v2 {vector3} - Second vector
+v1 {Vector3} - First vector +v2 {Vector3} - Second vector
vector3 - Cross product between the vectors
Vector3 - Cross product between the vectors
Returns the dot product between two vectors
v1 {vector3} - First vector -v2 {vector3} - Second vector
+v1 {Vector3} - First vector +v2 {Vector3} - Second vector
number - Dot product between the vectors
-class vector3
+
+class Vector3
(x=0, y=0, z=0)
@@ -495,7 +495,7 @@ Arguments
Expand source code
-class vector3:
+class Vector3:
"""3d vector class.
It stores XYZ values as floats."""
@@ -523,39 +523,39 @@ Arguments
return "(" + str(self.x) + "," + str(self.y) + "," + str(self.z) + ")"
def __add__(self, v):
- """Adds this vector3 to another.
- If we try to add anything other than a vector3 to it, it throws the
+ """Adds this Vector3 to another.
+ If we try to add anything other than a Vector3 to it, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to add
+ v {Vector3} -- Vector to add
Returns:
- vector3 - Sum of this vector3 and the given one
+ Vector3 - Sum of this Vector3 and the given one
"""
- if isinstance(v, vector3):
- return vector3(self.x + v.x, self.y + v.y, self.z + v.z)
+ if isinstance(v, Vector3):
+ return Vector3(self.x + v.x, self.y + v.y, self.z + v.z)
else:
raise InvalidOperationException("add", type(self), type(v))
def __sub__(self, v):
- """Subtracts a vector3 from this one.
- If we try to subtract anything other than a vector3, it throws the
+ """Subtracts a Vector3 from this one.
+ If we try to subtract anything other than a Vector3, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to subtract
+ v {Vector3} -- Vector to subtract
Returns:
- vector3 - Subraction of the given vector from this one
+ Vector3 - Subraction of the given vector from this one
"""
- if isinstance(v, vector3):
- return vector3(self.x - v.x, self.y - v.y, self.z - v.z)
+ if isinstance(v, Vector3):
+ return Vector3(self.x - v.x, self.y - v.y, self.z - v.z)
else:
raise InvalidOperationException("sub", type(self), type(v))
def __mul__(self, v):
- """Multiplies this vector3 by a scalar.
+ """Multiplies this Vector3 by a scalar.
If we try to multiply anything other than a scalar, it throws the
InvalidOperationException.
@@ -564,15 +564,15 @@ Arguments
multiplied by this number
Returns:
- vector3 - Multiplication of the vector3
+ Vector3 - Multiplication of the Vector3
"""
if isinstance(v, (int, float)):
- return vector3(self.x * v, self.y * v, self.z * v)
+ return Vector3(self.x * v, self.y * v, self.z * v)
else:
raise InvalidOperationException("mult", type(self), type(v))
def __rmul__(self, v):
- """Multiplies this vector3 by a scalar.
+ """Multiplies this Vector3 by a scalar.
If we try to multiply anything other than a scalar, it throws the InvalidOperationException
Arguments:
@@ -580,88 +580,88 @@ Arguments
this number
Returns:
- vector3 - Multiplication of the vector3
+ Vector3 - Multiplication of the Vector3
"""
if isinstance(v, (int, float)):
- return vector3(self.x * v, self.y * v, self.z * v)
+ return Vector3(self.x * v, self.y * v, self.z * v)
else:
raise InvalidOperationException("mult", type(self), type(v))
def __truediv__(self, v):
- """Divides this vector3 by a scalar.
+ """Divides this Vector3 by a scalar.
If we try to divide anything other than a scalar, it throws the InvalidOperationException
Arguments:
v {number} -- Scalar to divide: all components of the vector are divided by this number
Returns:
- vector3 - Division of the vector3
+ Vector3 - Division of the Vector3
"""
if isinstance(v, (int, float)):
- return vector3(self.x / v, self.y / v, self.z / v)
+ return Vector3(self.x / v, self.y / v, self.z / v)
else:
raise InvalidOperationException("mult", type(self), type(v))
def __eq__(self, v):
- """Checks if this vector3 is equal to the given one, with a tolerance of 0.0001.
+ """Checks if this Vector3 is equal to the given one, with a tolerance of 0.0001.
Exception InvalidOperationException is thrown if we compare something other than a
- vector3.
+ Vector3.
Arguments:
- v {vector3} -- Vector to compare
+ v {Vector3} -- Vector to compare
Returns:
Bool - True if the vectors are the same, false otherwise
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return ((self - v).magnitude()) < 0.0001
else:
raise InvalidOperationException("eq", type(self), type(v))
def __ne__(self, v):
- """Checks if this vector3 is different to the given one, with a tolerance of 0.0001.
+ """Checks if this Vector3 is different to the given one, with a tolerance of 0.0001.
Exception InvalidOperationException is thrown if we compare something other than a
- vector3.
+ Vector3.
Arguments:
- v {vector3} -- Vector to compare
+ v {Vector3} -- Vector to compare
Returns:
Bool - True if the vectors are different, false otherwise
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return ((self - v).magnitude()) > 0.0001
else:
raise InvalidOperationException("neq", type(self), type(v))
def __isub__(self, v):
- """Subtracts a vector3 from this one.
- If we try to subtract anything other than a vector3, it throws the
+ """Subtracts a Vector3 from this one.
+ If we try to subtract anything other than a Vector3, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to subtract
+ v {Vector3} -- Vector to subtract
Returns:
- vector3 - Subraction of the given vector from this one
+ Vector3 - Subraction of the given vector from this one
"""
return self - v
def __iadd__(self, v):
- """Adds this vector3 to another.
- If we try to add anything other than a vector3 to it, it throws the
+ """Adds this Vector3 to another.
+ If we try to add anything other than a Vector3 to it, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to add
+ v {Vector3} -- Vector to add
Returns:
- vector3 - Sum of this vector3 and the given one
+ Vector3 - Sum of this Vector3 and the given one
"""
return self + v
def __imul__(self, v):
- """Multiplies this vector3 by a scalar.
+ """Multiplies this Vector3 by a scalar.
If we try to multiply anything other than a scalar, it throws the
InvalidOperationException.
@@ -670,32 +670,32 @@ Arguments
multiplied by this number.
Returns:
- vector3 - Multiplication of the vector3
+ Vector3 - Multiplication of the Vector3
"""
return self * v
def __idiv__(self, v):
- """Divides this vector3 by a scalar.
+ """Divides this Vector3 by a scalar.
If we try to divide anything other than a scalar, it throws the InvalidOperationException
Arguments:
v {number} -- Scalar to divide: all components of the vector are divided by this number
Returns:
- vector3 - Division of the vector3
+ Vector3 - Division of the Vector3
"""
return self / v
def __neg__(self):
- """Negates this vector3, component-wise. Equivelent to multiplying by (-1)
+ """Negates this Vector3, component-wise. Equivelent to multiplying by (-1)
Returns:
- vector3 - Negated vector3
+ Vector3 - Negated Vector3
"""
- return vector3(-self.x, -self.y, -self.z)
+ return Vector3(-self.x, -self.y, -self.z)
def magnitude(self):
- """Returns the magnitude of the vector3.
+ """Returns the magnitude of the Vector3.
Returns:
Number - Magnitude of the vector
@@ -703,7 +703,7 @@ Arguments
return math.sqrt(self.dot(self))
def magnitude_squared(self):
- """Returns the squared magnitude of the vector3.
+ """Returns the squared magnitude of the Vector3.
Returns:
Number - Magnitude of the vector
@@ -711,34 +711,34 @@ Arguments
return self.dot(self)
def dot(self, v):
- """Computes the dot product of this vector3 with another.
- If we try to do this operation with anything other than a vector3, it throws
+ """Computes the dot product of this Vector3 with another.
+ If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments:
- v {vector3} -- Vector3 to do the dot product with
+ v {Vector3} -- Vector3 to do the dot product with
Returns:
Number - Scalar value corresponding to the dot product of both vectors
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return self.x * v.x + self.y * v.y + self.z * v.z
else:
raise InvalidOperationException("dot", type(self), type(v))
def cross(self, v):
- """Computes the cross product of this vector3 with another.
- If we try to do this operation with anything other than a vector3, it throws
+ """Computes the cross product of this Vector3 with another.
+ If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments:
- v {vector3} -- Vector3 to do the cross product with
+ v {Vector3} -- Vector3 to do the cross product with
Returns:
- vector3 - Cross product of both vectors
+ Vector3 - Cross product of both vectors
"""
- if isinstance(v, vector3):
- return vector3(self.y * v.z - self.z * v.y,
+ if isinstance(v, Vector3):
+ return Vector3(self.y * v.z - self.z * v.y,
self.z * v.x - self.x * v.z,
self.x * v.y - self.y * v.x)
else:
@@ -752,24 +752,24 @@ Arguments
self.z *= d
def normalized(self):
- """Returns the normalized version of this vector3
+ """Returns the normalized version of this Vector3
Returns:
- vector3 - Normalized vector
+ Vector3 - Normalized vector
"""
d = 1.0 / self.magnitude()
- return vector3(self.x * d, self.y * d, self.z * d)
+ return Vector3(self.x * d, self.y * d, self.z * d)
def x0z(self):
"""Returns this vector, but with the y component zeroed.
Returns:
- vector3 - (x,0,z)
+ Vector3 - (x,0,z)
"""
- return vector3(self.x, 0, self.z)
+ return Vector3(self.x, 0, self.z)
def to_np3(self):
- """Converts a vector3 to a 3-component numpy array
+ """Converts a Vector3 to a 3-component numpy array
Returns:
np.array - [x,y,z]
@@ -777,7 +777,7 @@ Arguments
return np.array([self.x, self.y, self.z])
def to_np4(self, w=1):
- """Converts a vector3 to a 4-component numpy array, with the given w as the 4th component.
+ """Converts a Vector3 to a 4-component numpy array, with the given w as the 4th component.
Arguments:
w {number} - Value of the w component on the np.array.
@@ -789,24 +789,24 @@ Arguments
@staticmethod
def from_np(np_array):
- """Converts a np.array to a vector3. No validation is done on the array to confirm it
+ """Converts a np.array to a Vector3. No validation is done on the array to confirm it
has 3 components.
Arguments:
np_array {np.array} - np.array with 3-components (rows or columns)
Returns:
- vector3 - A vector3
+ Vector3 - A Vector3
"""
- return vector3(np_array[0], np_array[1], np_array[2])
+ return Vector3(np_array[0], np_array[1], np_array[2])
@staticmethod
def distance(v1, v2):
"""Returns the distance between two positions/vectors
Arguments:
- v1 {vector3} - First vector
- v2 {vector3} - Second vector
+ v1 {Vector3} - First vector
+ v2 {Vector3} - Second vector
Returns:
number - Distance between the two positions/vectors
@@ -815,14 +815,14 @@ Arguments
Static methods
-
+
def distance(v1, v2)
-
Returns the distance between two positions/vectors
Arguments
-v1 {vector3} - First vector
-v2 {vector3} - Second vector
+v1 {Vector3} - First vector
+v2 {Vector3} - Second vector
Returns
number - Distance between the two positions/vectors
@@ -834,8 +834,8 @@ Returns
"""Returns the distance between two positions/vectors
Arguments:
- v1 {vector3} - First vector
- v2 {vector3} - Second vector
+ v1 {Vector3} - First vector
+ v2 {Vector3} - Second vector
Returns:
number - Distance between the two positions/vectors
@@ -843,95 +843,95 @@ Returns
return (v1 - v2).magnitude()
-
+
def from_np(np_array)
-Converts a np.array to a vector3. No validation is done on the array to confirm it
+
Converts a np.array to a Vector3. No validation is done on the array to confirm it
has 3 components.
Arguments
np_array {np.array} - np.array with 3-components (rows or columns)
Returns
-vector3 - A vector3
+Vector3 - A Vector3
Expand source code
@staticmethod
def from_np(np_array):
- """Converts a np.array to a vector3. No validation is done on the array to confirm it
+ """Converts a np.array to a Vector3. No validation is done on the array to confirm it
has 3 components.
Arguments:
np_array {np.array} - np.array with 3-components (rows or columns)
Returns:
- vector3 - A vector3
+ Vector3 - A Vector3
"""
- return vector3(np_array[0], np_array[1], np_array[2])
+ return Vector3(np_array[0], np_array[1], np_array[2])
Instance variables
-var xvar x-
{number} - X component
-var yvar y-
{number} - Y component
-var zvar z-
{number} - Z component
Methods
-
+
def cross(self, v)
-
-
Computes the cross product of this vector3 with another.
-If we try to do this operation with anything other than a vector3, it throws
+
Computes the cross product of this Vector3 with another.
+If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments
-v {vector3} – Vector3 to do the cross product with
+v {Vector3} – Vector3 to do the cross product with
Returns
-vector3 - Cross product of both vectors
+Vector3 - Cross product of both vectors
Expand source code
def cross(self, v):
- """Computes the cross product of this vector3 with another.
- If we try to do this operation with anything other than a vector3, it throws
+ """Computes the cross product of this Vector3 with another.
+ If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments:
- v {vector3} -- Vector3 to do the cross product with
+ v {Vector3} -- Vector3 to do the cross product with
Returns:
- vector3 - Cross product of both vectors
+ Vector3 - Cross product of both vectors
"""
- if isinstance(v, vector3):
- return vector3(self.y * v.z - self.z * v.y,
+ if isinstance(v, Vector3):
+ return Vector3(self.y * v.z - self.z * v.y,
self.z * v.x - self.x * v.z,
self.x * v.y - self.y * v.x)
else:
raise InvalidOperationException("dot", type(self), type(v))
-
+
def dot(self, v)
-
-
Computes the dot product of this vector3 with another.
-If we try to do this operation with anything other than a vector3, it throws
+
Computes the dot product of this Vector3 with another.
+If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments
-v {vector3} – Vector3 to do the dot product with
+v {Vector3} – Vector3 to do the dot product with
Returns
Number - Scalar value corresponding to the dot product of both vectors
@@ -939,27 +939,27 @@ Returns
Expand source code
def dot(self, v):
- """Computes the dot product of this vector3 with another.
- If we try to do this operation with anything other than a vector3, it throws
+ """Computes the dot product of this Vector3 with another.
+ If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments:
- v {vector3} -- Vector3 to do the dot product with
+ v {Vector3} -- Vector3 to do the dot product with
Returns:
Number - Scalar value corresponding to the dot product of both vectors
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return self.x * v.x + self.y * v.y + self.z * v.z
else:
raise InvalidOperationException("dot", type(self), type(v))
-
+
def magnitude(self)
-
-
Returns the magnitude of the vector3.
+Returns the magnitude of the Vector3.
Returns
Number - Magnitude of the vector
@@ -967,7 +967,7 @@ Returns
Expand source code
def magnitude(self):
- """Returns the magnitude of the vector3.
+ """Returns the magnitude of the Vector3.
Returns:
Number - Magnitude of the vector
@@ -975,11 +975,11 @@ Returns
return math.sqrt(self.dot(self))
-
+
def magnitude_squared(self)
-
-
Returns the squared magnitude of the vector3.
+Returns the squared magnitude of the Vector3.
Returns
Number - Magnitude of the vector
@@ -987,7 +987,7 @@ Returns
Expand source code
def magnitude_squared(self):
- """Returns the squared magnitude of the vector3.
+ """Returns the squared magnitude of the Vector3.
Returns:
Number - Magnitude of the vector
@@ -995,7 +995,7 @@ Returns
return self.dot(self)
-
+
def normalize(self)
-
@@ -1012,32 +1012,32 @@
Returns
self.z *= d
-
+
def normalized(self)
-
-
Returns the normalized version of this vector3
+Returns the normalized version of this Vector3
Returns
-vector3 - Normalized vector
+Vector3 - Normalized vector
Expand source code
def normalized(self):
- """Returns the normalized version of this vector3
+ """Returns the normalized version of this Vector3
Returns:
- vector3 - Normalized vector
+ Vector3 - Normalized vector
"""
d = 1.0 / self.magnitude()
- return vector3(self.x * d, self.y * d, self.z * d)
+ return Vector3(self.x * d, self.y * d, self.z * d)
-
+
def to_np3(self)
-
-
Converts a vector3 to a 3-component numpy array
+Converts a Vector3 to a 3-component numpy array
Returns
np.array - [x,y,z]
@@ -1045,7 +1045,7 @@ Returns
Expand source code
def to_np3(self):
- """Converts a vector3 to a 3-component numpy array
+ """Converts a Vector3 to a 3-component numpy array
Returns:
np.array - [x,y,z]
@@ -1053,11 +1053,11 @@ Returns
return np.array([self.x, self.y, self.z])
-
+
def to_np4(self, w=1)
-
-
Converts a vector3 to a 4-component numpy array, with the given w as the 4th component.
+Converts a Vector3 to a 4-component numpy array, with the given w as the 4th component.
Arguments
w {number} - Value of the w component on the np.array.
Returns
@@ -1067,7 +1067,7 @@ Returns
Expand source code
def to_np4(self, w=1):
- """Converts a vector3 to a 4-component numpy array, with the given w as the 4th component.
+ """Converts a Vector3 to a 4-component numpy array, with the given w as the 4th component.
Arguments:
w {number} - Value of the w component on the np.array.
@@ -1078,13 +1078,13 @@ Returns
return np.array([self.x, self.y, self.z, w])
-
+
def x0z(self)
-
Returns this vector, but with the y component zeroed.
Returns
-vector3 - (x,0,z)
+Vector3 - (x,0,z)
Expand source code
@@ -1093,9 +1093,9 @@ Returns
"""Returns this vector, but with the y component zeroed.
Returns:
- vector3 - (x,0,z)
+ Vector3 - (x,0,z)
"""
- return vector3(self.x, 0, self.z)
+ return Vector3(self.x, 0, self.z)
@@ -1126,22 +1126,22 @@ Index
InvalidOperationException
-
-
vector3
+Vector3
diff --git a/material.py b/material.py
index 9a0b806..05808ec 100644
--- a/material.py
+++ b/material.py
@@ -3,18 +3,18 @@
class Material:
"""Material class.
Describe the properties of the mesh being drawn. Currently it only supports a
- color and a line width.
+ Color and a line width.
"""
- def __init__(self, color, name="UnknownMaterial"):
+ def __init__(self, Color, name="UnknownMaterial"):
"""
Arguments:
- color {color} -- Color of the line
+ Color {Color} -- Color of the line
name {str} -- Name of the material, defaults to 'UnknownMaterial'
"""
- self.color = color
- """{color} Color of the lines on the mesh"""
+ self.Color = Color
+ """{Color} Color of the lines on the mesh"""
self.name = name
"""{str} Name of this material"""
self.line_width = 2
diff --git a/mesh.py b/mesh.py
index e6cbc70..0231534 100644
--- a/mesh.py
+++ b/mesh.py
@@ -1,7 +1,7 @@
"""Mesh class definition"""
import math
import pygame
-from vector3 import vector3
+from vector3 import Vector3
class Mesh:
"""Mesh class.
@@ -26,7 +26,7 @@ def __init__(self, name="UnknownMesh"):
self.name = name
""" {str} Name of the mesh"""
self.polygons = []
- """ {list[list[vector3]]} List of lists of polygons. A polygon is a closed shape,
+ """ {list[list[Vector3]]} List of lists of polygons. A polygon is a closed shape,
hence the need for a list of lists, if we want more complex shapes."""
def offset(self, v):
@@ -35,7 +35,7 @@ def offset(self, v):
Arguments:
- v {vector3} -- Ammount to displace the mesh
+ v {Vector3} -- Ammount to displace the mesh
"""
new_polys = []
for poly in self.polygons:
@@ -63,8 +63,8 @@ def render(self, screen, clip_matrix, material):
render times, but it is normally commented out, for performance reasons. If you want
to use the statistics, uncomment the code on this funtion.
"""
- # Convert color to the pygame format
- c = material.color.tuple3()
+ # Convert Color to the pygame format
+ c = material.Color.tuple3()
# For all polygons
for poly in self.polygons:
@@ -117,26 +117,26 @@ def create_cube(size, mesh=None):
mesh = Mesh("UnknownCube")
# Add the 6 quads that create a cube
- Mesh.create_quad(vector3(size[0] * 0.5, 0, 0),
- vector3(0, -size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(-size[0] * 0.5, 0, 0),
- vector3(0, size[1] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, size[1] * 0.5, 0),
- vector3(size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
- Mesh.create_quad(vector3(0, -size[1] * 0.5, 0),
- vector3(-size[0] * 0.5, 0),
- vector3(0, 0, size[2] * 0.5), mesh)
-
- Mesh.create_quad(vector3(0, 0, size[2] * 0.5),
- vector3(-size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
- Mesh.create_quad(vector3(0, 0, -size[2] * 0.5),
- vector3(size[0] * 0.5, 0),
- vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(size[0] * 0.5, 0, 0),
+ Vector3(0, -size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(-size[0] * 0.5, 0, 0),
+ Vector3(0, size[1] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, size[1] * 0.5, 0),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+ Mesh.create_quad(Vector3(0, -size[1] * 0.5, 0),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, 0, size[2] * 0.5), mesh)
+
+ Mesh.create_quad(Vector3(0, 0, size[2] * 0.5),
+ Vector3(-size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
+ Mesh.create_quad(Vector3(0, 0, -size[2] * 0.5),
+ Vector3(size[0] * 0.5, 0),
+ Vector3(0, size[1] * 0.5, 0), mesh)
return mesh
@@ -167,15 +167,15 @@ def create_sphere(size, res_lat, res_lon, mesh=None):
mesh = Mesh("UnknownSphere")
# Compute half-size
- if isinstance(size, vector3):
+ if isinstance(size, Vector3):
hs = size * 0.5
else:
- hs = vector3(size[0], size[1], size[2]) * 0.5
+ hs = Vector3(size[0], size[1], size[2]) * 0.5
# Sphere is going to be composed by quads in most of the surface, but triangles near the
# poles, so compute the bottom and top vertex
- bottom_vertex = vector3(0, -hs.y, 0)
- top_vertex = vector3(0, hs.y, 0)
+ bottom_vertex = Vector3(0, -hs.y, 0)
+ top_vertex = Vector3(0, hs.y, 0)
lat_inc = math.pi / res_lat
lon_inc = math.pi * 2 / res_lon
@@ -186,8 +186,8 @@ def create_sphere(size, res_lat, res_lon, mesh=None):
y = hs.y * math.sin(lat + lat_inc)
c = math.cos(lat + lat_inc)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(bottom_vertex, p1, p2, mesh)
@@ -204,16 +204,16 @@ def create_sphere(size, res_lat, res_lon, mesh=None):
lon = 0
for _ in range(0, res_lon):
- p1 = vector3(c1 * math.cos(lon) * hs.x,
+ p1 = Vector3(c1 * math.cos(lon) * hs.x,
y1,
c1 * math.sin(lon) * hs.z)
- p2 = vector3(c1 * math.cos(lon + lon_inc) * hs.x,
+ p2 = Vector3(c1 * math.cos(lon + lon_inc) * hs.x,
y1,
c1 * math.sin(lon + lon_inc) * hs.z)
- p3 = vector3(c2 * math.cos(lon) * hs.x,
+ p3 = Vector3(c2 * math.cos(lon) * hs.x,
y2,
c2 * math.sin(lon) * hs.z)
- p4 = vector3(c2 * math.cos(lon + lon_inc) * hs.x,
+ p4 = Vector3(c2 * math.cos(lon + lon_inc) * hs.x,
y2,
c2 * math.sin(lon + lon_inc) * hs.z)
@@ -232,8 +232,8 @@ def create_sphere(size, res_lat, res_lon, mesh=None):
y = hs.y * math.sin(lat)
c = math.cos(lat)
for _ in range(0, res_lon):
- p1 = vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
- p2 = vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
+ p1 = Vector3(c * math.cos(lon) * hs.x, y, c * math.sin(lon) * hs.z)
+ p2 = Vector3(c * math.cos(lon + lon_inc) * hs.x, y, c * math.sin(lon + lon_inc) * hs.z)
Mesh.create_tri(top_vertex, p1, p2, mesh)
@@ -250,12 +250,12 @@ def create_quad(origin, axis0, axis1, mesh):
Arguments:
- origin {vector3} -- Center of the quad
+ origin {Vector3} -- Center of the quad
- axis0 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis0 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
- axis1 {vector3} -- One of the axis of the quad. This is not normalized, since the
+ axis1 {Vector3} -- One of the axis of the quad. This is not normalized, since the
length specifies half the length of that side along that axis
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
@@ -284,11 +284,11 @@ def create_tri(p1, p2, p3, mesh):
Arguments:
- p1 {vector3} -- First vertex of the triangle
+ p1 {Vector3} -- First vertex of the triangle
- p2 {vector3} -- Second vertex of the triangle
+ p2 {Vector3} -- Second vertex of the triangle
- p3 {vector3} -- Third vertex of the triangle
+ p3 {Vector3} -- Third vertex of the triangle
mesh {Mesh} -- Mesh to add the polygons. If not given, create a new mesh
diff --git a/object3d.py b/object3d.py
index 4865721..1e2b167 100644
--- a/object3d.py
+++ b/object3d.py
@@ -2,7 +2,7 @@
import numpy as np
from quaternion import quaternion, as_rotation_matrix
-from vector3 import vector3
+from vector3 import Vector3
class Object3d:
"""3d object class.
@@ -16,12 +16,12 @@ def __init__(self, name):
"""
self.name = name
""" {str} Name of the object"""
- self.position = vector3()
- """ {vector3} Local position of the object (relative to parent)"""
+ self.position = Vector3()
+ """ {Vector3} Local position of the object (relative to parent)"""
self.rotation = quaternion(1, 0, 0, 0)
""" {quaternion} Local rotation of the object {relative to parent)"""
- self.scale = vector3(1, 1, 1)
- """ {vector3} Local scale of the object (relative to parent)"""
+ self.scale = Vector3(1, 1, 1)
+ """ {Vector3} Local scale of the object (relative to parent)"""
self.mesh = None
""" {Mesh} Mesh to be rendered in this object"""
self.material = None
@@ -95,9 +95,9 @@ def get_position(self):
Returns:
- {vector3} - Local position of the object
+ {Vector3} - Local position of the object
"""
- return vector3.from_np(vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 0).to_np4(1) @ self.get_matrix())
def forward(self):
"""
@@ -106,9 +106,9 @@ def forward(self):
Returns:
- {vector3} - Local forward vector of the object
+ {Vector3} - Local forward vector of the object
"""
- return vector3.from_np(vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 0, 1).to_np4(0) @ self.get_matrix())
def up(self):
"""
@@ -117,9 +117,9 @@ def up(self):
Returns:
- {vector3} - Local up vector of the object
+ {Vector3} - Local up vector of the object
"""
- return vector3.from_np(vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(0, 1, 0).to_np4(0) @ self.get_matrix())
def right(self):
"""
@@ -128,9 +128,9 @@ def right(self):
Returns:
- {vector3} - Local right vector of the object
+ {Vector3} - Local right vector of the object
"""
- return vector3.from_np(vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
+ return Vector3.from_np(Vector3(1, 0, 0).to_np4(0) @ self.get_matrix())
@staticmethod
def get_prs_matrix(position, rotation, scale):
@@ -139,11 +139,11 @@ def get_prs_matrix(position, rotation, scale):
Arguments:
- position {vector3} - Position
+ position {Vector3} - Position
rotation {quaternion} - Rotation
- scale {vector3} - Scale
+ scale {Vector3} - Scale
Returns:
diff --git a/sample_cubefall.py b/sample_cubefall.py
index 83ef104..d10eaa1 100644
--- a/sample_cubefall.py
+++ b/sample_cubefall.py
@@ -10,8 +10,8 @@
from camera import Camera
from mesh import Mesh
from material import Material
-from color import color
-from vector3 import vector3
+from color import Color
+from vector3 import Vector3
GRAVITY = -9.8
@@ -20,17 +20,17 @@ class FallingCube(Object3d):
def __init__(self, mesh):
super().__init__("FallingCube")
# Create a cube on a random positions
- self.position = vector3(random.uniform(-6, 6), random.uniform(6, 10), random.uniform(3, 10))
+ self.position = Vector3(random.uniform(-6, 6), random.uniform(6, 10), random.uniform(3, 10))
self.mesh = mesh
- # Pick a random color for the cube
- self.material = Material(color(random.uniform(0.1, 1),
+ # Pick a random Color for the cube
+ self.material = Material(Color(random.uniform(0.1, 1),
random.uniform(0.1, 1),
random.uniform(0.1, 1), 1),
"FallingCubeMaterial")
# Starting velocity is zero
self.velocity = 0
# Select a random rotation axis
- self.rotation_axis = vector3(random.uniform(-1, 1),
+ self.rotation_axis = Vector3(random.uniform(-1, 1),
random.uniform(-1, 1),
random.uniform(-1, 1)).normalized()
# Select a random rotation speed
@@ -61,7 +61,7 @@ def main():
scene.camera = Camera(False, res_x, res_y)
# Moves the camera back 2 units
- scene.camera.position -= vector3(0, 0, 2)
+ scene.camera.position -= Vector3(0, 0, 2)
# Create the cube mesh we're going to use for every single object
cube_mesh = Mesh.create_cube((1, 1, 1))
diff --git a/sample_game.py b/sample_game.py
index b258c26..785ddf2 100644
--- a/sample_game.py
+++ b/sample_game.py
@@ -12,8 +12,8 @@
from camera import Camera
from mesh import Mesh
from material import Material
-from color import color
-from vector3 import vector3, dot_product, cross_product
+from color import Color
+from vector3 import Vector3, dot_product, cross_product
from perlin import noise2d
class Missile(Object3d):
@@ -29,24 +29,24 @@ class Missile(Object3d):
def __init__(self):
if Missile.missile_mesh is None:
Missile.missile_mesh = Missile.create_missile_mesh()
- Missile.missile_material = Material(color(1, 0, 0, 1), "MissileMaterial")
+ Missile.missile_material = Material(Color(1, 0, 0, 1), "MissileMaterial")
super().__init__("Missile")
# Determine the spawn position. There's 33% chance it comes from the right, 33% that it
# comes from behind the mountains, and 34% chance it comes from the left
- self.position = vector3(0, random.uniform(0, 3), 12)
+ self.position = Vector3(0, random.uniform(0, 3), 12)
r = random.uniform(0, 100)
if r > 66:
self.position.x = 7
- self.rotation = from_rotation_vector((vector3(0, 1, 0) * math.radians(90)).to_np3())
+ self.rotation = from_rotation_vector((Vector3(0, 1, 0) * math.radians(90)).to_np3())
elif r > 33:
self.position.y = -2
self.position.x = random.uniform(-4, 4)
- self.rotation = from_rotation_vector((vector3(1, 0, 0) * math.radians(90)).to_np3())
+ self.rotation = from_rotation_vector((Vector3(1, 0, 0) * math.radians(90)).to_np3())
else:
self.position.x = -7
- self.rotation = from_rotation_vector((vector3(0, 1, 0) * math.radians(-90)).to_np3())
+ self.rotation = from_rotation_vector((Vector3(0, 1, 0) * math.radians(-90)).to_np3())
# Set the mesh and material of the missile
self.mesh = Missile.missile_mesh
@@ -65,7 +65,7 @@ def update(self, delta_time):
# Rotate missile towards the player - Figure out where it is pointing and
# where do we want to point it
current_dir = self.forward()
- desired_dir = (vector3(0, 0, 0) - self.position).normalized()
+ desired_dir = (Vector3(0, 0, 0) - self.position).normalized()
# Find the angle between these two directions
dp = np.clip(dot_product(current_dir, desired_dir), -1, 1)
angle = math.acos(dp)
@@ -90,18 +90,18 @@ def create_missile_mesh():
length = 0.075
cone = 0.05
missile_mesh = Mesh.create_cube((radius * 2, radius * 2, length * 2))
- missile_mesh = Mesh.create_tri(vector3(radius, radius, length),
- vector3(radius, -radius, length),
- vector3(0, 0, length + cone), missile_mesh)
- missile_mesh = Mesh.create_tri(vector3(radius, -radius, length),
- vector3(-radius, -radius, length),
- vector3(0, 0, length + cone), missile_mesh)
- missile_mesh = Mesh.create_tri(vector3(-radius, -radius, length),
- vector3(-radius, radius, length),
- vector3(0, 0, length + cone), missile_mesh)
- missile_mesh = Mesh.create_tri(vector3(-radius, radius, length),
- vector3(radius, radius, length),
- vector3(0, 0, length + cone), missile_mesh)
+ missile_mesh = Mesh.create_tri(Vector3(radius, radius, length),
+ Vector3(radius, -radius, length),
+ Vector3(0, 0, length + cone), missile_mesh)
+ missile_mesh = Mesh.create_tri(Vector3(radius, -radius, length),
+ Vector3(-radius, -radius, length),
+ Vector3(0, 0, length + cone), missile_mesh)
+ missile_mesh = Mesh.create_tri(Vector3(-radius, -radius, length),
+ Vector3(-radius, radius, length),
+ Vector3(0, 0, length + cone), missile_mesh)
+ missile_mesh = Mesh.create_tri(Vector3(-radius, radius, length),
+ Vector3(radius, radius, length),
+ Vector3(0, 0, length + cone), missile_mesh)
return missile_mesh
@@ -117,16 +117,16 @@ class Shot(Object3d):
def __init__(self):
if Shot.shot_mesh is None:
Shot.shot_mesh = Mesh.create_sphere((0.1, 0.1, 0.1), 4, 4)
- Shot.shot_material = Material(color(1, 1, 0, 1), "ShotMaterial")
+ Shot.shot_material = Material(Color(1, 1, 0, 1), "ShotMaterial")
super().__init__("Shot")
# The position and direction will be overwritten by the code that spawns the shot
- self.position = vector3(0, 0, 0)
+ self.position = Vector3(0, 0, 0)
self.mesh = Shot.shot_mesh
self.material = Shot.shot_material
self.shot_speed = 6
- self.direction = vector3(0, 0, 0)
+ self.direction = Vector3(0, 0, 0)
def update(self, delta_time):
"""Animates the missile."""
@@ -162,17 +162,17 @@ def create_terrain():
pz = size_z / div
# For centering the terrain on the object center
- origin = vector3(-size_x * 0.5, 0, 0)
+ origin = Vector3(-size_x * 0.5, 0, 0)
terrain_mesh = Mesh("Terrain")
# Create the geometry of the terrain and add it to the mesh
for dz in range(0, div):
for dx in range(0, div):
- p1 = vector3(dx * px, 0, dz * pz) + origin
- p2 = vector3((dx + 1) * px, 0, dz * pz) + origin
- p3 = vector3((dx + 1) * px, 0, (dz + 1) * pz) + origin
- p4 = vector3(dx * px, 0, (dz + 1) * pz) + origin
+ p1 = Vector3(dx * px, 0, dz * pz) + origin
+ p2 = Vector3((dx + 1) * px, 0, dz * pz) + origin
+ p3 = Vector3((dx + 1) * px, 0, (dz + 1) * pz) + origin
+ p4 = Vector3(dx * px, 0, (dz + 1) * pz) + origin
p1.y = sample_height(p1.x, p1.z)
p2.y = sample_height(p2.x, p2.z)
@@ -188,12 +188,12 @@ def create_terrain():
terrain_mesh.polygons.append(poly)
# Create materials for the terrain
- terrain_material = Material(color(0.1, 0.6, 0.1, 1), "TerrainMaterial")
+ terrain_material = Material(Color(0.1, 0.6, 0.1, 1), "TerrainMaterial")
# Create object to display the terrain
obj = Object3d("TerrainObject")
- obj.scale = vector3(1, 1, 1)
- obj.position = vector3(0, -1, 1)
+ obj.scale = Vector3(1, 1, 1)
+ obj.position = Vector3(0, -1, 1)
obj.mesh = terrain_mesh
obj.material = terrain_material
@@ -217,7 +217,7 @@ def main():
scene.camera = Camera(False, res_x, res_y)
# Moves the camera back 2 units
- scene.camera.position -= vector3(0, 0, 0)
+ scene.camera.position -= Vector3(0, 0, 0)
# Creates the terrain meshes and materials
terrain_object = create_terrain()
@@ -232,8 +232,8 @@ def main():
# Storage for all missiles active in the game
missiles = []
- # Flashing effect color
- flash_color = color(0, 0, 0, 0)
+ # Flashing effect Color
+ flash_color = Color(0, 0, 0, 0)
# Total time of the current flash
total_flash_time = 0
# Time elapsed for the current flash
@@ -327,7 +327,7 @@ def main():
# Check if the missile is close enough to the player to hit him
if missile.position.magnitude() < 0.25:
# It has hit the player, flash the screen red for one second
- flash_color = color(1, 0, 1, 1)
+ flash_color = Color(1, 0, 1, 1)
total_flash_time = flash_timer = 1
# Destroy missile (remove it from the scene and add it to the destruction
# list so we can remove it in a bit)
@@ -358,7 +358,7 @@ def main():
for missile in missiles:
# Check the distance between the shot and the missile, it it is below
# a threshould (in this case 0.5), destroy the missile and the shot
- distance = vector3.distance(shot.position, missile.position)
+ distance = Vector3.distance(shot.position, missile.position)
if distance < 0.5:
# Add it to the missile destruction list, and remove it from the scene
missiles_to_destroy.append(missile)
@@ -367,7 +367,7 @@ def main():
shots_to_destroy.append(shot)
scene.remove_object(shot)
# Flash the screen cyan for 0.5 seconds
- flash_color = color(0, 1, 1, 1)
+ flash_color = Color(0, 1, 1, 1)
total_flash_time = flash_timer = 0.5
# Actually delete objects
diff --git a/sample_hierarchy.py b/sample_hierarchy.py
index 2a92741..fdb28b2 100644
--- a/sample_hierarchy.py
+++ b/sample_hierarchy.py
@@ -11,8 +11,8 @@
from camera import Camera
from mesh import Mesh
from material import Material
-from color import color
-from vector3 import vector3
+from color import Color
+from vector3 import Vector3
# Define a main function, just to keep things nice and tidy
def main():
@@ -32,28 +32,28 @@ def main():
scene.camera = Camera(False, res_x, res_y)
# Moves the camera back 2 units
- scene.camera.position -= vector3(0, 0, 2)
+ scene.camera.position -= Vector3(0, 0, 2)
# Create a cube and place it in a scene, at position (0,0,0)
obj1 = Object3d("TestObject")
- obj1.scale = vector3(1, 1, 1)
- obj1.position = vector3(0, -1, 0)
+ obj1.scale = Vector3(1, 1, 1)
+ obj1.position = Vector3(0, -1, 0)
obj1.mesh = Mesh.create_cube((1, 1, 1))
- obj1.material = Material(color(1, 0, 0, 1), "TestMaterial1")
+ obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1")
scene.add_object(obj1)
# Create a second object, and add it as a child of the first object
# When the first object rotates, this one will also mimic the transform
obj2 = Object3d("ChildObject")
- obj2.position += vector3(0, 0.75, 0)
+ obj2.position += Vector3(0, 0.75, 0)
obj2.mesh = Mesh.create_cube((0.5, 0.5, 0.5))
- obj2.material = Material(color(0, 1, 0, 1), "TestMaterial2")
+ obj2.material = Material(Color(0, 1, 0, 1), "TestMaterial2")
obj1.add_child(obj2)
# Specify the rotation of the object. It will rotate 15 degrees around the axis given,
# every second
angle = 15
- axis = vector3(1, 0.7, 0.2)
+ axis = Vector3(1, 0.7, 0.2)
axis.normalize()
# Timer
diff --git a/sample_sphere.py b/sample_sphere.py
index cfc1e47..d95d957 100644
--- a/sample_sphere.py
+++ b/sample_sphere.py
@@ -10,8 +10,8 @@
from camera import Camera
from mesh import Mesh
from material import Material
-from color import color
-from vector3 import vector3
+from color import Color
+from vector3 import Vector3
# Define a main function, just to keep things nice and tidy
def main():
@@ -31,20 +31,20 @@ def main():
scene.camera = Camera(False, res_x, res_y)
# Moves the camera back 2 units
- scene.camera.position -= vector3(0, 0, 2)
+ scene.camera.position -= Vector3(0, 0, 2)
# Create a sphere and place it in a scene, at position (0,0,0)
obj1 = Object3d("TestObject")
- obj1.scale = vector3(1, 1, 1)
- obj1.position = vector3(0, 0, 0)
+ obj1.scale = Vector3(1, 1, 1)
+ obj1.position = Vector3(0, 0, 0)
obj1.mesh = Mesh.create_sphere((1, 1, 1), 12, 12)
- obj1.material = Material(color(1, 0, 0, 1), "TestMaterial1")
+ obj1.material = Material(Color(1, 0, 0, 1), "TestMaterial1")
scene.add_object(obj1)
# Specify the rotation of the object. It will rotate 15 degrees around the axis given,
# every second
angle = 15
- axis = vector3(1, 0.7, 0.2)
+ axis = Vector3(1, 0.7, 0.2)
axis.normalize()
# Timer
diff --git a/sample_terrain.py b/sample_terrain.py
index 90d39fd..1d0598b 100644
--- a/sample_terrain.py
+++ b/sample_terrain.py
@@ -10,8 +10,8 @@
from camera import Camera
from mesh import Mesh
from material import Material
-from color import color
-from vector3 import vector3, dot_product, cross_product
+from color import Color
+from vector3 import Vector3, dot_product, cross_product
from perlin import noise2d
def sample_height(x, y):
@@ -49,7 +49,7 @@ def create_terrain():
pz = size_z / div
# For centering the terrain on the object center
- origin = vector3(-size_x * 0.5, 0, -size_z * 0.5)
+ origin = Vector3(-size_x * 0.5, 0, -size_z * 0.5)
# Create the meshes for each type of terrain
grass_mesh = Mesh("Terrain_Grass")
@@ -59,10 +59,10 @@ def create_terrain():
for dz in range(0, div):
for dx in range(0, div):
- p1 = vector3(dx * px, 0, dz * pz) + origin
- p2 = vector3((dx + 1) * px, 0, dz * pz) + origin
- p3 = vector3((dx + 1) * px, 0, (dz + 1) * pz) + origin
- p4 = vector3(dx * px, 0, (dz + 1) * pz) + origin
+ p1 = Vector3(dx * px, 0, dz * pz) + origin
+ p2 = Vector3((dx + 1) * px, 0, dz * pz) + origin
+ p3 = Vector3((dx + 1) * px, 0, (dz + 1) * pz) + origin
+ p4 = Vector3(dx * px, 0, (dz + 1) * pz) + origin
p1.y = sample_height(p1.x, p1.z)
p2.y = sample_height(p2.x, p2.z)
@@ -94,16 +94,16 @@ def create_terrain():
else:
# Check for cliff face, check the normal
normal = cross_product((p3 - p1).normalized(), (p2 - p1).normalized())
- if dot_product(normal, vector3(0, 1, 0)) < 0.5:
+ if dot_product(normal, Vector3(0, 1, 0)) < 0.5:
cliff_mesh.polygons.append(poly)
else:
grass_mesh.polygons.append(poly)
# Create materials for the terrain
- grass_material = Material(color(0.1, 0.6, 0.1, 1), "GrassMaterial")
- snow_material = Material(color(0.8, 0.8, 0.8, 1), "SnowMaterial")
- cliff_material = Material(color(0.4, 0.4, 0.4, 1), "CliffMaterial")
- water_material = Material(color(0, 0.5, 0.7, 1), "WaterMaterial")
+ grass_material = Material(Color(0.1, 0.6, 0.1, 1), "GrassMaterial")
+ snow_material = Material(Color(0.8, 0.8, 0.8, 1), "SnowMaterial")
+ cliff_material = Material(Color(0.4, 0.4, 0.4, 1), "CliffMaterial")
+ water_material = Material(Color(0, 0.5, 0.7, 1), "WaterMaterial")
# Return meshes and materials
meshes = [grass_mesh, snow_mesh, cliff_mesh, water_mesh]
@@ -129,22 +129,22 @@ def main():
scene.camera = Camera(False, res_x, res_y)
# Moves the camera back 2 units
- scene.camera.position -= vector3(0, 0, 4)
- scene.camera.rotation = from_rotation_vector((vector3(1, 0, 0) * math.radians(-15)).to_np3())
+ scene.camera.position -= Vector3(0, 0, 4)
+ scene.camera.rotation = from_rotation_vector((Vector3(1, 0, 0) * math.radians(-15)).to_np3())
# Creates the terrain meshes and materials
terrain_meshes, terrain_materials = create_terrain()
# Create container object for all the terrain sub-objects
master_object = Object3d("TerrainObject")
- master_object.position = vector3(0, -1, 0)
+ master_object.position = Vector3(0, -1, 0)
scene.add_object(master_object)
# Create the terrain objects and place it in a scene, at position (0,0,0)
for _, (mesh, material) in enumerate(zip(terrain_meshes, terrain_materials)):
obj = Object3d("TerrainObject")
- obj.scale = vector3(1, 1, 1)
- obj.position = vector3(0, 0, 0)
+ obj.scale = Vector3(1, 1, 1)
+ obj.position = Vector3(0, 0, 0)
obj.mesh = mesh
obj.material = material
master_object.add_child(obj)
@@ -152,7 +152,7 @@ def main():
# Specify the rotation of the object. It will rotate 15 degrees around the axis given,
# every second
angle = 15
- axis = vector3(0, 1, 0)
+ axis = Vector3(0, 1, 0)
axis.normalize()
# Timer
diff --git a/vector3.py b/vector3.py
index 64439a4..519e15b 100644
--- a/vector3.py
+++ b/vector3.py
@@ -14,7 +14,7 @@ def __str__(self):
"""Returns a readable version of the exception"""
return f"Invalid operation ({self.op}) between {self.type1} and {self.type2}!"
-class vector3:
+class Vector3:
"""3d vector class.
It stores XYZ values as floats."""
@@ -42,39 +42,39 @@ def __str__(self):
return "(" + str(self.x) + "," + str(self.y) + "," + str(self.z) + ")"
def __add__(self, v):
- """Adds this vector3 to another.
- If we try to add anything other than a vector3 to it, it throws the
+ """Adds this Vector3 to another.
+ If we try to add anything other than a Vector3 to it, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to add
+ v {Vector3} -- Vector to add
Returns:
- vector3 - Sum of this vector3 and the given one
+ Vector3 - Sum of this Vector3 and the given one
"""
- if isinstance(v, vector3):
- return vector3(self.x + v.x, self.y + v.y, self.z + v.z)
+ if isinstance(v, Vector3):
+ return Vector3(self.x + v.x, self.y + v.y, self.z + v.z)
else:
raise InvalidOperationException("add", type(self), type(v))
def __sub__(self, v):
- """Subtracts a vector3 from this one.
- If we try to subtract anything other than a vector3, it throws the
+ """Subtracts a Vector3 from this one.
+ If we try to subtract anything other than a Vector3, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to subtract
+ v {Vector3} -- Vector to subtract
Returns:
- vector3 - Subraction of the given vector from this one
+ Vector3 - Subraction of the given vector from this one
"""
- if isinstance(v, vector3):
- return vector3(self.x - v.x, self.y - v.y, self.z - v.z)
+ if isinstance(v, Vector3):
+ return Vector3(self.x - v.x, self.y - v.y, self.z - v.z)
else:
raise InvalidOperationException("sub", type(self), type(v))
def __mul__(self, v):
- """Multiplies this vector3 by a scalar.
+ """Multiplies this Vector3 by a scalar.
If we try to multiply anything other than a scalar, it throws the
InvalidOperationException.
@@ -83,15 +83,15 @@ def __mul__(self, v):
multiplied by this number
Returns:
- vector3 - Multiplication of the vector3
+ Vector3 - Multiplication of the Vector3
"""
if isinstance(v, (int, float)):
- return vector3(self.x * v, self.y * v, self.z * v)
+ return Vector3(self.x * v, self.y * v, self.z * v)
else:
raise InvalidOperationException("mult", type(self), type(v))
def __rmul__(self, v):
- """Multiplies this vector3 by a scalar.
+ """Multiplies this Vector3 by a scalar.
If we try to multiply anything other than a scalar, it throws the InvalidOperationException
Arguments:
@@ -99,88 +99,88 @@ def __rmul__(self, v):
this number
Returns:
- vector3 - Multiplication of the vector3
+ Vector3 - Multiplication of the Vector3
"""
if isinstance(v, (int, float)):
- return vector3(self.x * v, self.y * v, self.z * v)
+ return Vector3(self.x * v, self.y * v, self.z * v)
else:
raise InvalidOperationException("mult", type(self), type(v))
def __truediv__(self, v):
- """Divides this vector3 by a scalar.
+ """Divides this Vector3 by a scalar.
If we try to divide anything other than a scalar, it throws the InvalidOperationException
Arguments:
v {number} -- Scalar to divide: all components of the vector are divided by this number
Returns:
- vector3 - Division of the vector3
+ Vector3 - Division of the Vector3
"""
if isinstance(v, (int, float)):
- return vector3(self.x / v, self.y / v, self.z / v)
+ return Vector3(self.x / v, self.y / v, self.z / v)
else:
raise InvalidOperationException("mult", type(self), type(v))
def __eq__(self, v):
- """Checks if this vector3 is equal to the given one, with a tolerance of 0.0001.
+ """Checks if this Vector3 is equal to the given one, with a tolerance of 0.0001.
Exception InvalidOperationException is thrown if we compare something other than a
- vector3.
+ Vector3.
Arguments:
- v {vector3} -- Vector to compare
+ v {Vector3} -- Vector to compare
Returns:
Bool - True if the vectors are the same, false otherwise
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return ((self - v).magnitude()) < 0.0001
else:
raise InvalidOperationException("eq", type(self), type(v))
def __ne__(self, v):
- """Checks if this vector3 is different to the given one, with a tolerance of 0.0001.
+ """Checks if this Vector3 is different to the given one, with a tolerance of 0.0001.
Exception InvalidOperationException is thrown if we compare something other than a
- vector3.
+ Vector3.
Arguments:
- v {vector3} -- Vector to compare
+ v {Vector3} -- Vector to compare
Returns:
Bool - True if the vectors are different, false otherwise
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return ((self - v).magnitude()) > 0.0001
else:
raise InvalidOperationException("neq", type(self), type(v))
def __isub__(self, v):
- """Subtracts a vector3 from this one.
- If we try to subtract anything other than a vector3, it throws the
+ """Subtracts a Vector3 from this one.
+ If we try to subtract anything other than a Vector3, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to subtract
+ v {Vector3} -- Vector to subtract
Returns:
- vector3 - Subraction of the given vector from this one
+ Vector3 - Subraction of the given vector from this one
"""
return self - v
def __iadd__(self, v):
- """Adds this vector3 to another.
- If we try to add anything other than a vector3 to it, it throws the
+ """Adds this Vector3 to another.
+ If we try to add anything other than a Vector3 to it, it throws the
InvalidOperationException.
Arguments:
- v {vector3} -- Vector to add
+ v {Vector3} -- Vector to add
Returns:
- vector3 - Sum of this vector3 and the given one
+ Vector3 - Sum of this Vector3 and the given one
"""
return self + v
def __imul__(self, v):
- """Multiplies this vector3 by a scalar.
+ """Multiplies this Vector3 by a scalar.
If we try to multiply anything other than a scalar, it throws the
InvalidOperationException.
@@ -189,32 +189,32 @@ def __imul__(self, v):
multiplied by this number.
Returns:
- vector3 - Multiplication of the vector3
+ Vector3 - Multiplication of the Vector3
"""
return self * v
def __idiv__(self, v):
- """Divides this vector3 by a scalar.
+ """Divides this Vector3 by a scalar.
If we try to divide anything other than a scalar, it throws the InvalidOperationException
Arguments:
v {number} -- Scalar to divide: all components of the vector are divided by this number
Returns:
- vector3 - Division of the vector3
+ Vector3 - Division of the Vector3
"""
return self / v
def __neg__(self):
- """Negates this vector3, component-wise. Equivelent to multiplying by (-1)
+ """Negates this Vector3, component-wise. Equivelent to multiplying by (-1)
Returns:
- vector3 - Negated vector3
+ Vector3 - Negated Vector3
"""
- return vector3(-self.x, -self.y, -self.z)
+ return Vector3(-self.x, -self.y, -self.z)
def magnitude(self):
- """Returns the magnitude of the vector3.
+ """Returns the magnitude of the Vector3.
Returns:
Number - Magnitude of the vector
@@ -222,7 +222,7 @@ def magnitude(self):
return math.sqrt(self.dot(self))
def magnitude_squared(self):
- """Returns the squared magnitude of the vector3.
+ """Returns the squared magnitude of the Vector3.
Returns:
Number - Magnitude of the vector
@@ -230,34 +230,34 @@ def magnitude_squared(self):
return self.dot(self)
def dot(self, v):
- """Computes the dot product of this vector3 with another.
- If we try to do this operation with anything other than a vector3, it throws
+ """Computes the dot product of this Vector3 with another.
+ If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments:
- v {vector3} -- Vector3 to do the dot product with
+ v {Vector3} -- Vector3 to do the dot product with
Returns:
Number - Scalar value corresponding to the dot product of both vectors
"""
- if isinstance(v, vector3):
+ if isinstance(v, Vector3):
return self.x * v.x + self.y * v.y + self.z * v.z
else:
raise InvalidOperationException("dot", type(self), type(v))
def cross(self, v):
- """Computes the cross product of this vector3 with another.
- If we try to do this operation with anything other than a vector3, it throws
+ """Computes the cross product of this Vector3 with another.
+ If we try to do this operation with anything other than a Vector3, it throws
the InvalidOperationException.
Arguments:
- v {vector3} -- Vector3 to do the cross product with
+ v {Vector3} -- Vector3 to do the cross product with
Returns:
- vector3 - Cross product of both vectors
+ Vector3 - Cross product of both vectors
"""
- if isinstance(v, vector3):
- return vector3(self.y * v.z - self.z * v.y,
+ if isinstance(v, Vector3):
+ return Vector3(self.y * v.z - self.z * v.y,
self.z * v.x - self.x * v.z,
self.x * v.y - self.y * v.x)
else:
@@ -271,24 +271,24 @@ def normalize(self):
self.z *= d
def normalized(self):
- """Returns the normalized version of this vector3
+ """Returns the normalized version of this Vector3
Returns:
- vector3 - Normalized vector
+ Vector3 - Normalized vector
"""
d = 1.0 / self.magnitude()
- return vector3(self.x * d, self.y * d, self.z * d)
+ return Vector3(self.x * d, self.y * d, self.z * d)
def x0z(self):
"""Returns this vector, but with the y component zeroed.
Returns:
- vector3 - (x,0,z)
+ Vector3 - (x,0,z)
"""
- return vector3(self.x, 0, self.z)
+ return Vector3(self.x, 0, self.z)
def to_np3(self):
- """Converts a vector3 to a 3-component numpy array
+ """Converts a Vector3 to a 3-component numpy array
Returns:
np.array - [x,y,z]
@@ -296,7 +296,7 @@ def to_np3(self):
return np.array([self.x, self.y, self.z])
def to_np4(self, w=1):
- """Converts a vector3 to a 4-component numpy array, with the given w as the 4th component.
+ """Converts a Vector3 to a 4-component numpy array, with the given w as the 4th component.
Arguments:
w {number} - Value of the w component on the np.array.
@@ -308,24 +308,24 @@ def to_np4(self, w=1):
@staticmethod
def from_np(np_array):
- """Converts a np.array to a vector3. No validation is done on the array to confirm it
+ """Converts a np.array to a Vector3. No validation is done on the array to confirm it
has 3 components.
Arguments:
np_array {np.array} - np.array with 3-components (rows or columns)
Returns:
- vector3 - A vector3
+ Vector3 - A Vector3
"""
- return vector3(np_array[0], np_array[1], np_array[2])
+ return Vector3(np_array[0], np_array[1], np_array[2])
@staticmethod
def distance(v1, v2):
"""Returns the distance between two positions/vectors
Arguments:
- v1 {vector3} - First vector
- v2 {vector3} - Second vector
+ v1 {Vector3} - First vector
+ v2 {Vector3} - Second vector
Returns:
number - Distance between the two positions/vectors
@@ -336,8 +336,8 @@ def dot_product(v1, v2):
"""Returns the dot product between two vectors
Arguments:
- v1 {vector3} - First vector
- v2 {vector3} - Second vector
+ v1 {Vector3} - First vector
+ v2 {Vector3} - Second vector
Returns:
number - Dot product between the vectors
@@ -348,10 +348,10 @@ def cross_product(v1, v2):
"""Returns the cross product between two vectors
Arguments:
- v1 {vector3} - First vector
- v2 {vector3} - Second vector
+ v1 {Vector3} - First vector
+ v2 {Vector3} - Second vector
Returns:
- vector3 - Cross product between the vectors
+ Vector3 - Cross product between the vectors
"""
return v1.cross(v2)