Gjsify LogoGjsify Logo

A CoglMatrix holds a 4x4 transform matrix. This is a single precision, column-major matrix which means it is compatible with what OpenGL expects.

A CoglMatrix can represent transforms such as, rotations, scaling, translation, sheering, and linear projections. You can combine these transforms by multiplying multiple matrices in the order you want them applied.

The transformation of a vertex (x, y, z, w) by a CoglMatrix is given by:

|[ x_new = xx * x + xy * y + xz * z + xw * w y_new = yx * x + yy * y + yz * z + yw * w z_new = zx * x + zy * y + zz * z + zw * w w_new = wx * x + wy * y + wz * z + ww * w



Where w is normally 1

<note>You must consider the members of the CoglMatrix structure read only,
and all matrix modifications must be done via the cogl_matrix API. This
allows Cogl to annotate the matrices internally. Violation of this will give
undefined results. If you need to initialize a matrix with a constant other
than the identity matrix you can use cogl_matrix_init_from_array().</note>
@record

Hierarchy

  • Matrix

Index

Constructors

Properties

ww: number
wx: number
wy: number
wz: number
xw: number
xx: number
xy: number
xz: number
yw: number
yx: number
yy: number
yz: number
zw: number
zx: number
zy: number
zz: number
name: string

Methods

  • free(): void
  • frustum(left: number, right: number, bottom: number, top: number, z_near: number, z_far: number): void
  • Multiplies matrix by the given frustum perspective matrix.

    Parameters

    • left: number

      X position of the left clipping plane where it intersects the near clipping plane

    • right: number

      X position of the right clipping plane where it intersects the near clipping plane

    • bottom: number

      Y position of the bottom clipping plane where it intersects the near clipping plane

    • top: number

      Y position of the top clipping plane where it intersects the near clipping plane

    • z_near: number

      The distance to the near clipping plane (Must be positive)

    • z_far: number

      The distance to the far clipping plane (Must be positive)

    Returns void

  • get_array(): number
  • Gets the inverse transform of a given matrix and uses it to initialize a new #CoglMatrix.

    Although the first parameter is annotated as const to indicate that the transform it represents isn't modified this function may technically save a copy of the inverse transform within the given #CoglMatrix so that subsequent requests for the inverse transform may avoid costly inversion calculations.

    Returns [number, Cogl.Matrix]

  • init_from_array(array: number): void
  • Initializes matrix with the contents of array

    Parameters

    • array: number

      A linear array of 16 floats (column-major order)

    Returns void

  • init_identity(): void
  • Resets matrix to the identity matrix:

    |[ .xx=1; .xy=0; .xz=0; .xw=0; .yx=0; .yy=1; .yz=0; .yw=0; .zx=0; .zy=0; .zz=1; .zw=0; .wx=0; .wy=0; .wz=0; .ww=1;

    
    

    Returns void

  • init_translation(tx: number, ty: number, tz: number): void
  • Resets matrix to the (tx, ty, tz) translation matrix:

    |[ .xx=1; .xy=0; .xz=0; .xw=tx; .yx=0; .yy=1; .yz=0; .yw=ty; .zx=0; .zy=0; .zz=1; .zw=tz; .wx=0; .wy=0; .wz=0; .ww=1;


    @param tx x coordinate of the translation vector
    @param ty y coordinate of the translation vector
    @param tz z coordinate of the translation vector

    Parameters

    • tx: number
    • ty: number
    • tz: number

    Returns void

  • is_identity(): number
  • look_at(eye_position_x: number, eye_position_y: number, eye_position_z: number, object_x: number, object_y: number, object_z: number, world_up_x: number, world_up_y: number, world_up_z: number): void
  • Applies a view transform matrix that positions the camera at the coordinate (eye_position_x, eye_position_y, eye_position_z) looking towards an object at the coordinate (object_x, object_y, object_z). The top of the camera is aligned to the given world up vector, which is normally simply (0, 1, 0) to map up to the positive direction of the y axis.

    Because there is a lot of missleading documentation online for gluLookAt regarding the up vector we want to try and be a bit clearer here.

    The up vector should simply be relative to your world coordinates and does not need to change as you move the eye and object positions. Many online sources may claim that the up vector needs to be perpendicular to the vector between the eye and object position (partly because the man page is somewhat missleading) but that is not necessary for this function.

    You should never look directly along the world-up vector.

    It is assumed you are using a typical projection matrix where your origin maps to the center of your viewport.

    Almost always when you use this function it should be the first transform applied to a new modelview transform

    Parameters

    • eye_position_x: number

      The X coordinate to look from

    • eye_position_y: number

      The Y coordinate to look from

    • eye_position_z: number

      The Z coordinate to look from

    • object_x: number

      The X coordinate of the object to look at

    • object_y: number

      The Y coordinate of the object to look at

    • object_z: number

      The Z coordinate of the object to look at

    • world_up_x: number

      The X component of the world's up direction vector

    • world_up_y: number

      The Y component of the world's up direction vector

    • world_up_z: number

      The Z component of the world's up direction vector

    Returns void

  • Multiplies the two supplied matrices together and stores the resulting matrix inside result.

    It is possible to multiply the a matrix in-place, so result can be equal to a but can't be equal to b.

    Parameters

    Returns void

  • ortho(left: number, right: number, bottom: number, top: number, near: number, far: number): void
  • Multiplies matrix by a parallel projection matrix.

    Parameters

    • left: number

      The coordinate for the left clipping plane

    • right: number

      The coordinate for the right clipping plane

    • bottom: number

      The coordinate for the bottom clipping plane

    • top: number

      The coordinate for the top clipping plane

    • near: number

      The distance to the near clipping plane (will be negative if the plane is behind the viewer)

    • far: number

      The distance to the far clipping plane (will be negative if the plane is behind the viewer)

    Returns void

  • perspective(fov_y: number, aspect: number, z_near: number, z_far: number): void
  • Multiplies matrix by the described perspective matrix

    You should be careful not to have to great a z_far / z_near ratio since that will reduce the effectiveness of depth testing since there wont be enough precision to identify the depth of objects near to each other.

    Parameters

    • fov_y: number

      Vertical field of view angle in degrees.

    • aspect: number

      The (width over height) aspect ratio for display

    • z_near: number

      The distance to the near clipping plane (Must be positive, and must not be 0)

    • z_far: number

      The distance to the far clipping plane (Must be positive)

    Returns void

  • rotate(angle: number, x: number, y: number, z: number): void
  • Multiplies matrix with a rotation matrix that applies a rotation of angle degrees around the specified 3D vector.

    Parameters

    • angle: number

      The angle you want to rotate in degrees

    • x: number

      X component of your rotation vector

    • y: number

      Y component of your rotation vector

    • z: number

      Z component of your rotation vector

    Returns void

  • scale(sx: number, sy: number, sz: number): void
  • Multiplies matrix with a transform matrix that scales along the X, Y and Z axis.

    Parameters

    • sx: number

      The X scale factor

    • sy: number

      The Y scale factor

    • sz: number

      The Z scale factor

    Returns void

  • transform_point(x: number, y: number, z: number, w: number): [number, number, number, number]
  • Transforms a point whos position is given and returned as four float components.

    Parameters

    • x: number

      The X component of your points position

    • y: number

      The Y component of your points position

    • z: number

      The Z component of your points position

    • w: number

      The W component of your points position

    Returns [number, number, number, number]

  • translate(x: number, y: number, z: number): void
  • Multiplies matrix with a transform matrix that translates along the X, Y and Z axis.

    Parameters

    • x: number

      The X translation you want to apply

    • y: number

      The Y translation you want to apply

    • z: number

      The Z translation you want to apply

    Returns void

  • transpose(): void
  • Replaces matrix with its transpose. Ie, every element (i,j) in the new matrix is taken from element (j,i) in the old matrix.

    Returns void

  • equal(v1: object, v2: object): number
  • Compares two matrices to see if they represent the same transformation. Although internally the matrices may have different annotations associated with them and may potentially have a cached inverse matrix these are not considered in the comparison.

    Parameters

    • v1: object

      A 4x4 transformation matrix

    • v2: object

      A 4x4 transformation matrix

    Returns number

Legend

  • Module
  • Object literal
  • Variable
  • Function
  • Function with type parameter
  • Index signature
  • Type alias
  • Type alias with type parameter
  • Enumeration
  • Enumeration member
  • Property
  • Method
  • Interface
  • Interface with type parameter
  • Constructor
  • Property
  • Method
  • Index signature
  • Class
  • Class with type parameter
  • Constructor
  • Property
  • Method
  • Accessor
  • Index signature
  • Inherited constructor
  • Inherited property
  • Inherited method
  • Inherited accessor
  • Protected property
  • Protected method
  • Protected accessor
  • Private property
  • Private method
  • Private accessor
  • Static property
  • Static method