ModelGeometry

Description

abstract class Tinman.Engine.Models.ModelGeometry

Derived from: IModelGeometry

Abstract base class for IModelGeometry implementations.

This class provides factory methods for building instances of the IModelGeometry interface:

Box: axis-aligned box
Build: custom geometry
Sphere: tessellated sphere
Wrap: wrap terrain vertex data

Public / Constructors

Append

public static method Append → (1)

geometries ⁱⁿ : IEnumerable<IModelGeometry>: The model geometries to concatenate.
returns → IModelGeometry: The resulting model geometry or null if geometries ⁱⁿ is null or if it does not contain any non-null IModelGeometry objects.

Concatenates the vertices and indices of the given model geometries ⁱⁿ.

Calling this method is equivalent to calling IModelGeometry.Append repeatedly for the elements in geometries ⁱⁿ.

Box

public static method Box → (3)

box ⁱⁿ : Box3D: The box coordinates.
normals ^opt : int32 = 0: Generate normal vectors?
> 0 : Generate normals by right-hand rule for CCW faces (see figure).
< 0 : Generate normals by right-hand rule for CW faces (see figure).
= 0 : Do not generate normals.
texCoords ^opt : int32 = 0: [>=0]
The texture coordinate repeat count per face. Set to 0 to disable texture coordinates.
returns → IModelGeometrySimple: The model geometry.

Builds an axis-aligned box.

The following figure shows the mapping from the given box ⁱⁿ to the 3D model:

   121-----221
   /|      /|
  / |     / |
122-----222 |
 | 111---|-211
 | /     | /
 |/      |/
112-----212

where 111 maps to Box3D.X1, Box3D.Y1, Box3D.Z1 and 222 maps to Box3D.X2, Box3D.Y2, Box3D.Z2.

Build

public static method Build → ()

returns → ModelGeometryBuilder: The model geometry builder.

Creates a builder for IModelGeometry objects.

Capsule

public static method Capsule → (4)

length ⁱⁿ : float64: [>=0]
The distance between A and B.
radius ⁱⁿ : float64: [>=0]
The hemisphere radius at A and B.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry.

Builds a capsule.

  ________________
 /                \     A = (0,0,0)
|  A------------B  |
 \________________/     B = (0,length,0)

   |____________|       length

                |__|    radius

See also: ModelGeometry.Generic

Cone

public static method Cone → (4)

length ⁱⁿ : float64: [>=0]
The distance between A and B.
radius ⁱⁿ : float64: [>=0]
The disc radius at A.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry.

Builds a cone.

     B
    /|\        A = (0,0,0)
   / | \
  /  |  \      B = (0,length,0)
 /   |   \
+----A----+

     |____|    radius

See also: ModelGeometry.Generic

Cylinder

public static method Cylinder → (4)

length ⁱⁿ : float64: [>=0]
The distance between A and B.
radius ⁱⁿ : float64: [>=0]
The disc radius at A and B.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry.

Builds a cylinder.

 ____________
|            |    A = (0,0,0)
A------------B
|____________|    B = (0,length,0)

See also: ModelGeometry.Generic

Disc

public static method Disc → (2)

radius ⁱⁿ : float64: [>=0]
The disc radius at A.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
returns → IModelGeometrySimple: The model geometry.

Builds a disc that is perpendicular to (0,1,0).

+--A--+    A = (0,0,0)
   |__|    radius

See also: ModelGeometry.Generic

Dynamic

public static method Dynamic → (3)

vertices ⁱⁿ : int32: [>0]
The vertex count.
format ⁱⁿ : ModelVertexFormat: The vertex format.
indices ^opt : int32 = 0: [>=0]
The index count or 0 for none.
returns → IModelGeometryDynamic: The dynamic model geometry.

Creates an instance of IModelGeometryDynamic.

See also: IModelGeometry.Dynamic

Generic

public static method Generic → (7)

length ⁱⁿ : float64: [>=0]
The distance between A and B.
radiusA ⁱⁿ : float64: [>=0]
The radius at A.
radiusB ⁱⁿ : float64: [>=0]
The radius at B.
capA ⁱⁿ : int32: The cap to build at A.
capB ⁱⁿ : int32: The cap to build at B.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry or null if empty.

Builds a 3D primitive from a generic, possibly degenerated capsule.

The point A is at (0,0,0), the point B is at (0, length ⁱⁿ ,0):

  ________________
 /                \
|  A------------B  |    Round (cap > 0)
 \________________/

    ____________
   |            |
   A------------B       Flat  (cap = 0)
   |____________|

    ____________

   A------------B       None  (cap < 0)
    ____________


   |____________|       length

|__|            |__|    radiusA, radiusB

By choosing parameter values carefully, a variety of 3D primitives can be built with this method:

Primitive  | len = 0 | rA = 0 | rB = 0 | rA = rB | cA | cB
-----------+---------+--------+--------+---------+----+----
Capsule    |    no   |    no  |    no  |   yes   |  1 |  1
-----------+---------+--------+--------+---------+----+----
Cone       |    no   |   yes  |    no  |    no   | -1 |  0
           |    no   |    no  |   yes  |    no   |  0 | -1
-----------+---------+--------+--------+---------+----+----
Cylinder   |    no   |    no  |    no  |   yes   |  0 |  0
-----------+---------+--------+--------+---------+----+----
Disc       |   yes   |    no  |    no  |   yes   |  0 |  0
-----------+---------+--------+--------+---------+----+----
Hemisphere |   yes   |    no  |    no  |    no   |  1 |  0
           |   yes   |    no  |   yes  |   yes   |  0 |  1
-----------+---------+--------+--------+---------+----+----
Line       |    no   |   yes  |   yes  |   yes   | -1 | -1
-----------+---------+--------+--------+---------+----+----
Point      |   yes   |   yes  |   yes  |   yes   | -1 | -1
-----------+---------+--------+--------+---------+----+----
Sphere     |   yes   |    no  |    no  |   yes   |  1 |  1
-----------+---------+--------+--------+---------+----+----
Tube       |    no   |    no  |    no  |   yes   | -1 | -1

where len is length ⁱⁿ, rA is radiusA ⁱⁿ, rB is radiusB ⁱⁿ, cA is capA ⁱⁿ and cB is capB ⁱⁿ.

See also: ModelGeometry.Capsule
ModelGeometry.Cone
ModelGeometry.Cylinder
ModelGeometry.Disc
ModelGeometry.Hemisphere
ModelGeometry.Line
ModelGeometry.Sphere
ModelGeometry.Tube

Hemisphere

public static method Hemisphere → (3)

radius ⁱⁿ : float64: [>=0]
The hemisphere radius at A.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry.

Builds a hemisphere.

 _
| \     A = (0,0,0)
A  B
|_/     B = (0,radius,0)

See also: ModelGeometry.Generic

Line

public static method Line → (1)

length ⁱⁿ : float64: [>=0]
The distance between A and B.
returns → IModelGeometrySimple: The model geometry.

Builds a line segment.

A------------B    A = (0,0,0)
                  B = (0,length,0)

See also: ModelGeometry.Generic

Shape

public static method Shape → (7)

shape ⁱⁿ : IShape: [not-null]
The 2D shape.
triangles ^opt : bool = true: Generate triangles?
lines ^opt : bool = true: Generate lines
u0 ^opt : float64 = 0: Texture U-coordinate to map to Box2D.X1 of IShape.Bounds.
v0 ^opt : float64 = 0: Texture V-coordinate to map to Box2D.Y1 of IShape.Bounds.
u1 ^opt : float64 = 1: Texture U-coordinate to map to Box2D.X2 of IShape.Bounds.
v1 ^opt : float64 = 1: Texture V-coordinate to map to Box2D.Y2 of IShape.Bounds.
returns → IModelGeometrySimple: The model geometry or null if empty.

Builds a 3D shape.

The shape is in the XY-plane, having the normal vector (0,0,1). Texture coordinates are generated in the range (u0 ^opt, v0 ^opt) to ( u1 ^opt, v1 ^opt), which maps to Box2D.TopLeft resp. Box2D.BottomRight of IShape.Bounds.

The triangles of the 3D shape are obtained by first converting the given shape ⁱⁿ to ShapeType.Mesh and then using IShape.TriangleAt.

The lines of the 3D shape are obtained by first converting the given shape ⁱⁿ to ShapeType.Graph and then using IShape.EdgeAt.

Sphere

public static method Sphere → (3)

radius ⁱⁿ : float64: [>=0]
The sphere radius.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry.

Builds a sphere.

  ___
 /   \
|  A  |    A = (0,0,0)
 \___/

   |__|    radius

See also: ModelGeometry.Generic

SphereIco

public static method SphereIco → (5)

center ⁱⁿ : Vec3D: The sphere center.
radius ⁱⁿ : float64: The sphere radius. If negative, the sphere will be mirrored at center ⁱⁿ, making the normals point inwards.
levels ⁱⁿ : int32: [>=0]
Subdivisions to perform for faces (see IModelGeometrySimple.Triangles). Level 7 generates approximately one million triangles.
levelsEdges ^opt : int32 = 0: [0..levels]
Subdivisions to perform for edges (see IModelGeometrySimple.Lines). Level 7 generates approximately one million lines.
textureCoordinates ^opt : bool = false: Generate U and V texture coordinates?

The U-coordinate range [0..1] is mapped to longitude [-180° .. +180°].
The V-coordinate range [0..1] is mapped to latitude  [ +90° ..  -90°].

Vertex positions are mapped to geographic coordinates using the conventions of Geocentric.

returns → IModelGeometrySimple: The model geometry.

Builds a sphere by subdividing an icosahedron.

The number of triangle vertices resp. line vertices (see PrimitiveBatch.Count) can be computed from the subdivision count levels ⁱⁿ resp. levelsEdges ^opt as follows:

vertices = 4 ^ levels * 60

The first eight subdivision levels produce the following triangle resp. line vertex counts:

count = 0 : vertices =      60
count = 1 : vertices =     240
count = 2 : vertices =     960
count = 3 : vertices =   3,840
count = 4 : vertices =  15,360
count = 5 : vertices =  61,440
count = 6 : vertices = 245,760
count = 7 : vertices = 983,040

Tube

public static method Tube → (4)

length ⁱⁿ : float64: [>=0]
The distance between A and B.
radius ⁱⁿ : float64: [>=0]
The hemisphere radius at A and B.
segments ^opt : int32 = 12: [>=3]
The number of circle segments.
modulo ^opt : int32 = 1: [>=1]
The modulo to use for generating segment lines.
returns → IModelGeometrySimple: The model geometry.

Builds a tube.

______________
                  A = (0,0,0)
A------------B
______________    B = (0,length,0)

See also: ModelGeometry.Generic

Wrap

[Pure]
public static method Wrap → (2)

vertices ⁱⁿ : VertexArrays: [not-null]
The vertex data to wrap.
indices ^opt : int32 [ ] = null: The index data to wrap or null to create non-indexed geometry.
returns → IModelGeometry: The model geometry.

Creates a new instance of ModelGeometry.

The given vertices ⁱⁿ object and indices ^opt array will be referenced by the returned IModelGeometry object, no data is copied.

Logging

Logger

public static readonly attribute Logger → (ILogger)

The logger object of this class.