View source

class FoxLineMesh

package foxlite.mesh

extends FoxMesh

A helper to create lines for a mesh.

Supports updating efficiently on the GPU.

Lines don't support UV mapping, instead, the data represents values as follows: - U is set to the line lerp points, it will interpolate between 0 and 1 from the line start point to the line end point - V is set to the length of the line in local space

However, lines can still use vertex colors, just make sure your material supports it.

Constructor

new(?lineMaterial:FoxMaterial)

Variables

@:value([])linePositions:Array<Float> = []

@:value([])lineColors:Array<Float> = []

@:value([])lineUVs:Array<Float> = []

@:value([])indices:Array<Int> = []

@:value(0)lineCount:Int = 0

private@:value(new IntMap())__vertexUpdates:Map<Int, Array<Float>> = new IntMap()

private@:value(new IntMap())__colorsUpdates:Map<Int, Array<Float>> = new IntMap()

private@:value(new IntMap())__uvsUpdates:Map<Int, Array<Float>> = new IntMap()

Methods

@:value({ endColor : 0xFFFFFFFF, startColor : 0xFFFFFFFF })addLine(from:Vector3D, to:Vector3D, startColor:FlxColor = 0xFFFFFFFF, endColor:FlxColor = 0xFFFFFFFF):Void

Adds a line to the mesh. Call build() when you're done

Note: This method will allocate memory each time, to update lines efficiently in real time, check updateLine()

Parameters:

from

The position where the line will start

end

The position where the line will end

color

Optional: The line color

build():Void

Callocates added lines to the GPU. Call this after creating lines with addLine()

flushUpdates():Void

Pushes all updated lines to the GPU. Call this after updating lines with updateLine()

updateLine(index:Int, from:Vector3D, to:Vector3D, ?startColor:FlxColor, ?endColor:FlxColor):Void

clear():Void

Inherited Variables

Defined by FoxMesh

@:value([null, null, null, null, null, null, null])buffers:Array<FoxVertexBuffer> = [null, null, null, null, null, null, null]

An array containing vertex buffers for this mesh.

Access them via buffers[FoxVertexBufferType.<type>]

These buffers represent Level of Detail 0

lods:Array<Array<FoxVertexBuffer>>

An array containing levels of detail for this mesh

Note: LODs are yet to be implemented

@:value(0x88E4)bufferUsage:Int = 0x88E4

The buffer usage pattern for optimization purposes. Set it to true if you're updating mesh buffers constantly

Note: This will be applied on the next call to setArrays().

@:value(null)material:FoxMaterial = null

@:value(null)assetsKey:String = null

@:value(null)bounds:BoundingBox = null

@:value(null)context:Context3D = null

@:value(false)__isCopy:Bool = false

read onlyloaded:Bool

Mesh is considered loaded when the vertex array is atleast loaded

Inherited Methods

Defined by FoxMesh

privateget_loaded():Bool

setBuffer(type:FoxVertexBufferType, data:Array<Float>):Void

Writes buffer data on the GPU

Parameters:

type

The buffer to write to

data

The data array

setBufferRaw(type:FoxVertexBufferType, data:ArrayBufferView):Void

Writes buffer data on the GPU using an existing ArrayBufferView. This method runs faster than setBuffer

setIndexBuffer(data:Array<Int>):Void

Same as setBuffer() but exclusive to the Index buffer

Note: This uses a UInt16Array internally, if your model has meshes with over 65k unique vertices, consider using setIndexBufferBig() instead

setIndexBufferBig(data:Array<Int>):Void

setIndexBufferRaw(data:ArrayBufferView):Void

@:value({ offset : 0 })updateBuffer(type:FoxVertexBufferType, data:Array<Float>, offset:Int = 0):Void

Updates buffer data on the GPU

Use this to set portions of it or are updating data constantly. Tip: Make sure the buffer is set to GL.DYNAMIC_DRAW on its usage.

Parameters:

type

The buffer to update

data

The data array

offset

The index of the buffer where to start writing data

@:value({ offset : 0 })updateIndexBuffer(data:Array<Int>, offset:Int = 0):Void

Same as updateBuffer() but exclusive to the Index buffer

@:value({ byteOffset : 0 })inlineupdateBufferRaw(type:FoxVertexBufferType, data:ArrayBufferView, byteOffset:Int = 0):Void

Same as updateBuffer() and updateIndexBuffer(), but there's no data copying to a typed array, instead, you provide it.

This method is faster than the other ones, but needs more setup.

inlinedisposeBuffer(type:FoxVertexBufferType):Void

@:value({ bigInfluence : false, bigIndices : false })setArrays(?vertices:Array<Float>, ?uvtData:Array<Float>, ?indices:Array<Int>, ?material_:FoxMaterial, ?normals:Array<Float>, ?colors:Array<Float>, ?weights:Array<Float>, ?influences:Array<Int>, bigIndices:Bool = false, bigInfluence:Bool = false):Void

Creates buffers and uploads data to the GPU.

Parameters:

vertices

Positions (xyz)

uvtData

Texture coordinates (u,v)

indices

Vertex index (i)

material_

The material for this mesh

normals

Vertex normals (x,y,z)

colors

Vertex colors (r,g,b,a)

weights

Skin weights (w1,w2,w3,w4)

influences

Joints (j1, j2, j3, j4)

bigIndices

Use ~4.3 billion vertex pointers per index instead of 65536 (UInt32 instead of UInt16)

bigInfluence

Use 65536 influence pointers per joint instead of 256 (UInt16 instead of UInt8)

getBufferByType(type:FoxVertexBufferType):FoxVertexBuffer

Deprecated:

Returns a vertex buffer of this mesh.

Parameters:

type

The buffer type. See FoxVertexBufferType

inlinegetLod(lod:Int):Array<FoxVertexBuffer>

calculateBounds(vertices:Dynamic):BoundingBox

copy():FoxMesh

Copies this mesh object, does not create new data on GPU. Use this to use different materials or mix different buffers.

Warning! destroying this copy won't free memory on the GPU unless the original is destroyed!

destroy():Void

privateset_material(v:FoxMaterial):FoxMaterial