core/com.lehaine.littlekt.graphics.util/VertexView

VertexView

class VertexView(val geometry: MeshGeometry, index: Int) : MutableVec3f

A view of a vertex within the geometry MeshGeometry.

Based the kool implementation.

Parameters

geometry

the geometry, vertices & indices, of the mesh

index

the initial vertex index to view

Constructors

VertexView

fun VertexView(geometry: MeshGeometry, index: Int)

Types

FloatView

inner class FloatView(attribOffset: Int)

Functions

add

fun add(other: Vec3f): MutableVec3f

fun add(other: Vec2f, result: MutableVec2f): MutableVec2f

fun add(other: Vec3f, result: MutableVec3f): MutableVec3f

fun add(x: Float, y: Float, z: Float): MutableVec3f

angleTo

fun angleTo(other: Vec2f): Angle

cross

fun cross(other: Vec3f): MutableVec3f

fun cross(other: Vec3f, result: MutableVec3f): MutableVec3f

distance

fun distance(other: Vec2f): Float

fun distance(other: Vec3f): Float

divAssign

operator fun divAssign(other: Vec3f)

operator fun divAssign(div: Float)

dot

fun dot(other: Vec2f): Float

fun dot(other: Vec3f): Float

equals

open operator override fun equals(other: Any?): Boolean

Checks vector components for equality (using '==' operator). For better numeric stability consider using isFuzzyEqual.

get

open operator override fun get(i: Int): Float

getColorAttribute

fun getColorAttribute(attribute: VertexAttribute): MutableColor?

getFloatAttribute

fun getFloatAttribute(attribute: VertexAttribute): VertexView.FloatView?

getVec2fAttribute

fun getVec2fAttribute(attribute: VertexAttribute): MutableVec2f?

getVec3fAttribute

fun getVec3fAttribute(attribute: VertexAttribute): MutableVec3f?

getVec4fAttribute

fun getVec4fAttribute(attribute: VertexAttribute): MutableVec4f?

getVec4iAttribute

fun getVec4iAttribute(attribute: VertexAttribute): MutableVec4i?

hashCode

open override fun hashCode(): Int

isFuzzyEqual

fun isFuzzyEqual(other: Vec2f, eps: Float = FUZZY_EQ_F): Boolean

Checks vector components for equality using com.lehaine.littlekt.math.isFuzzyEqual, that is all components must have a difference less or equal eps.

fun isFuzzyEqual(other: Vec3f, eps: Float = FUZZY_EQ_F): Boolean

Checks vector components for equality using com.lehaine.littlekt.math.isFuzzyEqual, that is all components must have a difference less or equal eps.

length

fun length(): Float

minusAssign

operator fun minusAssign(other: Vec3f)

mix

fun mix(other: Vec2f, weight: Float, result: MutableVec2f): MutableVec2f

fun mix(other: Vec3f, weight: Float, result: MutableVec3f): MutableVec3f

mul

fun mul(matrix: Mat4): MutableVec3f

fun mul(other: Vec3f): MutableVec3f

fun mul(other: Vec2f, result: MutableVec2f): MutableVec2f

fun mul(other: Vec3f, result: MutableVec3f): MutableVec3f

norm

fun norm(): MutableVec3f

fun norm(result: MutableVec2f): MutableVec2f

fun norm(result: MutableVec3f): MutableVec3f

planeSpace

fun planeSpace(p: MutableVec3f, q: MutableVec3f)

plusAssign

operator fun plusAssign(other: Vec3f)

resetToZero

fun resetToZero()

rotate

fun rotate(angle: Angle, axis: Vec3f): MutableVec3f

fun rotate(angle: Angle, result: MutableVec2f): MutableVec2f

fun rotate(angle: Angle, axis: Vec3f, result: MutableVec3f): MutableVec3f

fun rotate(angle: Angle, axisX: Float, axisY: Float, axisZ: Float): MutableVec3f

fun rotate(angle: Angle, axisX: Float, axisY: Float, axisZ: Float, result: MutableVec3f): MutableVec3f

scale

fun scale(factor: Float): MutableVec3f

fun scale(factor: Float, result: MutableVec2f): MutableVec2f

fun scale(factor: Float, result: MutableVec3f): MutableVec3f

fun scale(xFactor: Float, yFactor: Float, zFactor: Float): MutableVec3f

set

fun set(other: VertexView)

fun set(other: Vec3f): MutableVec3f

open operator override fun set(i: Int, v: Float)

fun set(x: Float, y: Float, z: Float): MutableVec3f

setLength

fun setLength(length: Float, result: MutableVec2f): MutableVec2f

setSqrLength

fun setSqrLength(sqrLength: Float, result: MutableVec2f): MutableVec2f

sqrDistance

fun sqrDistance(other: Vec2f): Float

fun sqrDistance(other: Vec3f): Float

sqrLength

open override fun sqrLength(): Float

subtract

fun subtract(other: Vec3f): MutableVec3f

fun subtract(other: Vec2f, result: MutableVec2f): MutableVec2f

fun subtract(other: Vec3f, result: MutableVec3f): MutableVec3f

times

operator fun times(other: Vec2f): Float

operator fun times(other: Vec3f): Float

timesAssign

operator fun timesAssign(factor: Float)

toMutableVec2

fun toMutableVec2(): MutableVec2f

fun toMutableVec2(result: MutableVec2f): MutableVec2f

toMutableVec3

fun toMutableVec3(): MutableVec3f

fun toMutableVec3(result: MutableVec3f): MutableVec3f

toString

open override fun toString(): String

toVec2

fun toVec2(): Vec2f

toVec3

fun toVec3(): Vec3f

Properties

array

val array: FloatArray

attributeViews

val attributeViews: Map<Int, Any>

color

val color: MutableColor

colorPacked

val colorPacked: VertexView.FloatView

geometry

val geometry: MeshGeometry

index

var index: Int

joints

val joints: MutableVec4i

normal

val normal: MutableVec3f

position

val position: MutableVec3f

texCoords

val texCoords: MutableVec2f

weights

val weights: MutableVec4f

open override var x: Float

open override var y: Float

open override var z: Float

Extensions

distanceToEdge

fun Vec3f.distanceToEdge(edgeA: Vec3f, edgeB: Vec3f): Float

fun Vec2f.distanceToEdge(edgeA: Vec2f, edgeB: Vec2f): Float

distanceToLine

fun Vec3f.distanceToLine(lineA: Vec3f, lineB: Vec3f): Float

distanceToRay

fun Vec3f.distanceToRay(ray: Ray): Float

fun Vec3f.distanceToRay(origin: Vec3f, direction: Vec3f): Float

nearestPointOnEdge

fun Vec3f.nearestPointOnEdge(edgeA: Vec3f, edgeB: Vec3f, result: MutableVec3f): MutableVec3f

fun Vec2f.nearestPointOnEdge(edgeA: Vec2f, edgeB: Vec2f, result: MutableVec2f): MutableVec2f

nearestPointOnLine

fun Vec3f.nearestPointOnLine(lineA: Vec3f, lineB: Vec3f, result: MutableVec3f): MutableVec3f

nearestPointOnRay

fun Vec3f.nearestPointOnRay(origin: Vec3f, direction: Vec3f, result: MutableVec3f): MutableVec3f

sqrDistanceToEdge

fun Vec3f.sqrDistanceToEdge(edgeA: Vec3f, edgeB: Vec3f): Float

fun Vec2f.sqrDistanceToEdge(edgeA: Vec2f, edgeB: Vec2f): Float

sqrDistanceToLine

fun Vec3f.sqrDistanceToLine(lineA: Vec3f, lineB: Vec3f): Float

sqrDistanceToRay

fun Vec3f.sqrDistanceToRay(ray: Ray): Float

fun Vec3f.sqrDistanceToRay(origin: Vec3f, direction: Vec3f): Float

fun MutableVec3f.xy(): MutableVec2f

fun Vec3f.xy(): Vec2f