Cuboid, or rectangular prism, with 6 faces and right angles

Can be created from a Boxed3d using to_mesh.

Introduced properties

init defaultinit(width: Float, height: Float, depth: Float)

gamnit :: Cuboid :: defaultinit

fun depth: Float

gamnit :: Cuboid :: depth

Depth, on the Z axis
protected fun depth=(depth: Float)

gamnit :: Cuboid :: depth=

Depth, on the Z axis
fun height: Float

gamnit :: Cuboid :: height

Height, on the Y axis
protected fun height=(height: Float)

gamnit :: Cuboid :: height=

Height, on the Y axis
fun width: Float

gamnit :: Cuboid :: width

Width, on the X axis
protected fun width=(width: Float)

gamnit :: Cuboid :: width=

Width, on the X axis

Redefined properties

redef type SELF: Cuboid

gamnit $ Cuboid :: SELF

Type of this instance, automatically specialized in every class
redef fun center: Point3d[Float]

gamnit $ Cuboid :: center

Center coordinates of all the vertices
redef fun center=(center: Point3d[Float])

gamnit $ Cuboid :: center=

Center coordinates of all the vertices
redef fun normals: Array[Float]

gamnit $ Cuboid :: normals

Normals, 3 floats per vertex
redef fun normals=(normals: Array[Float])

gamnit $ Cuboid :: normals=

Normals, 3 floats per vertex
redef fun texture_coords: Array[Float]

gamnit $ Cuboid :: texture_coords

Coordinates on the texture, 2 floats per vertex
redef fun texture_coords=(texture_coords: Array[Float])

gamnit $ Cuboid :: texture_coords=

Coordinates on the texture, 2 floats per vertex
redef fun vertices: Array[Float]

gamnit $ Cuboid :: vertices

Vertices relative coordinates, 3 floats per vertex
redef fun vertices=(vertices: Array[Float])

gamnit $ Cuboid :: vertices=

Vertices relative coordinates, 3 floats per vertex

All properties

fun !=(other: nullable Object): Bool

core :: Object :: !=

Have self and other different values?
fun ==(other: nullable Object): Bool

core :: Object :: ==

Have self and other the same value?
type CLASS: Class[SELF]

core :: Object :: CLASS

The type of the class of self.
type SELF: Object

core :: Object :: SELF

Type of this instance, automatically specialized in every class
fun center: Point3d[Float]

gamnit :: Mesh :: center

Center coordinates of all the vertices
fun center=(center: Point3d[Float])

gamnit :: Mesh :: center=

Center coordinates of all the vertices
protected fun class_factory(name: String): CLASS

core :: Object :: class_factory

Implementation used by get_class to create the specific class.
fun class_name: String

core :: Object :: class_name

The class name of the object.
init defaultinit(width: Float, height: Float, depth: Float)

gamnit :: Cuboid :: defaultinit

fun depth: Float

gamnit :: Cuboid :: depth

Depth, on the Z axis
protected fun depth=(depth: Float)

gamnit :: Cuboid :: depth=

Depth, on the Z axis
fun dimensions: Point3d[Float]

gamnit :: Mesh :: dimensions

Dimensions of the bounding box containing all vertices
fun dimensions=(dimensions: Point3d[Float])

gamnit :: Mesh :: dimensions=

Dimensions of the bounding box containing all vertices
fun draw_mode: GLDrawMode

gamnit :: Mesh :: draw_mode

GLDrawMode used to display this mesh, defaults to gl_TRIANGLES
fun get_class: CLASS

core :: Object :: get_class

The meta-object representing the dynamic type of self.
fun hash: Int

core :: Object :: hash

The hash code of the object.
fun height: Float

gamnit :: Cuboid :: height

Height, on the Y axis
protected fun height=(height: Float)

gamnit :: Cuboid :: height=

Height, on the Y axis
fun indices: Array[Int]

gamnit :: Mesh :: indices

Indices to draw triangles with glDrawElements
fun indices=(indices: Array[Int])

gamnit :: Mesh :: indices=

Indices to draw triangles with glDrawElements
fun indices_c=(indices_c: CUInt16Array)

gamnit :: Mesh :: indices_c=

init init

core :: Object :: init

fun inspect: String

core :: Object :: inspect

Developer readable representation of self.
protected fun inspect_head: String

core :: Object :: inspect_head

Return "CLASSNAME:#OBJECTID".
intern fun is_same_instance(other: nullable Object): Bool

core :: Object :: is_same_instance

Return true if self and other are the same instance (i.e. same identity).
fun is_same_serialized(other: nullable Object): Bool

core :: Object :: is_same_serialized

Is self the same as other in a serialization context?
intern fun is_same_type(other: Object): Bool

core :: Object :: is_same_type

Return true if self and other have the same dynamic type.
fun max: Point3d[Float]

gamnit :: Mesh :: max

Maximum coordinates of all vertices on each axes
protected fun max=(max: Point3d[Float])

gamnit :: Mesh :: max=

Maximum coordinates of all vertices on each axes
fun min: Point3d[Float]

gamnit :: Mesh :: min

Minimum coordinates of all vertices on each axes
protected fun min=(min: Point3d[Float])

gamnit :: Mesh :: min=

Minimum coordinates of all vertices on each axes
fun n_vertices: Int

gamnit :: Mesh :: n_vertices

Number for vertices
fun normals: Array[Float]

gamnit :: Mesh :: normals

Normals, 3 floats per vertex
fun normals=(normals: Array[Float])

gamnit :: Mesh :: normals=

Normals, 3 floats per vertex
intern fun object_id: Int

core :: Object :: object_id

An internal hash code for the object based on its identity.
fun output

core :: Object :: output

Display self on stdout (debug only).
intern fun output_class_name

core :: Object :: output_class_name

Display class name on stdout (debug only).
fun serialization_hash: Int

core :: Object :: serialization_hash

Hash value use for serialization
intern fun sys: Sys

core :: Object :: sys

Return the global sys object, the only instance of the Sys class.
fun texture_coords: Array[Float]

gamnit :: Mesh :: texture_coords

Coordinates on the texture, 2 floats per vertex
fun texture_coords=(texture_coords: Array[Float])

gamnit :: Mesh :: texture_coords=

Coordinates on the texture, 2 floats per vertex
abstract fun to_jvalue(env: JniEnv): JValue

core :: Object :: to_jvalue

fun to_s: String

core :: Object :: to_s

User readable representation of self.
fun vertices: Array[Float]

gamnit :: Mesh :: vertices

Vertices relative coordinates, 3 floats per vertex
fun vertices=(vertices: Array[Float])

gamnit :: Mesh :: vertices=

Vertices relative coordinates, 3 floats per vertex
fun width: Float

gamnit :: Cuboid :: width

Width, on the X axis
protected fun width=(width: Float)

gamnit :: Cuboid :: width=

Width, on the X axis
package_diagram gamnit::Cuboid Cuboid gamnit::Mesh Mesh gamnit::Cuboid->gamnit::Mesh core::Object Object gamnit::Mesh->core::Object ...core::Object ... ...core::Object->core::Object gamnit::Cube Cube gamnit::Cube->gamnit::Cuboid

Ancestors

interface Object

core :: Object

The root of the class hierarchy.

Parents

class Mesh

gamnit :: Mesh

Mesh with all geometry data

Children

class Cube

gamnit :: Cube

Cube, with 6 faces, edges of equal length and square angles

Class definitions

gamnit $ Cuboid
# Cuboid, or rectangular prism, with 6 faces and right angles
#
# Can be created from a `Boxed3d` using `to_mesh`.
class Cuboid
	super Mesh

	# Width, on the X axis
	var width: Float

	# Height, on the Y axis
	var height: Float

	# Depth, on the Z axis
	var depth: Float

	redef var vertices is lazy do
		var a = [-0.5*width, -0.5*height, -0.5*depth]
		var b = [ 0.5*width, -0.5*height, -0.5*depth]
		var c = [-0.5*width,  0.5*height, -0.5*depth]
		var d = [ 0.5*width,  0.5*height, -0.5*depth]

		var e = [-0.5*width, -0.5*height,  0.5*depth]
		var f = [ 0.5*width, -0.5*height,  0.5*depth]
		var g = [-0.5*width,  0.5*height,  0.5*depth]
		var h = [ 0.5*width,  0.5*height,  0.5*depth]

		var vertices = new Array[Float]
		for v in [a, c, d, a, d, b, # front
		          f, h, g, f, g, e, # back
		          b, d, h, b, h, f, # right
		          e, g, c, e, c, a, # left
		          e, a, b, e, b, f, # bottom
		          c, g, h, c, h, d  # top
				  ] do vertices.add_all v
		return vertices
	end

	redef var normals is lazy do
		var normals = new Array[Float]
		var faces_normals = [
			[0.0, 0.0, -1.0],
			[0.0, 0.0,  1.0],
			[ 1.0, 0.0, 0.0],
			[-1.0, 0.0, 0.0],
			[0.0, -1.0, 0.0],
			[0.0,  1.0, 0.0]]
		for f in faces_normals do for i in 6.times do normals.add_all f
		return normals
	end

	redef var texture_coords: Array[Float] is lazy do
		var a = [0.0, 1.0]
		var b = [1.0, 1.0]
		var c = [0.0, 0.0]
		var d = [1.0, 0.0]

		var texture_coords = new Array[Float]
		var face = [a, c, d, a, d, b]
		for i in 6.times do for v in face do texture_coords.add_all v
		return texture_coords
	end

	redef var center = new Point3d[Float](0.0, 0.0, 0.0) is lazy
end
lib/gamnit/depth/more_meshes.nit:82,1--145,3