683 lines
21 KiB
Text
683 lines
21 KiB
Text
import "luxe: io" for IO
|
|
import "luxe: world" for World, Entity, Modifiers, ModifierSystem, Transform
|
|
import "luxe: draw" for Draw, PathStyle, LineCap
|
|
import "luxe: color" for Color
|
|
import "luxe: render" for Geometry, Primitive, IndexType, Render, Material
|
|
import "luxe: assets" for Assets, Strings
|
|
import "luxe: bytes" for Uint16, Floats
|
|
import "luxe: math" for Math
|
|
|
|
import "trail: _queue" for Queue
|
|
|
|
import "trail: modifier/trail.modifier" for ModifierData
|
|
|
|
#doc="""
|
|
Modifier to add simple trails to entities.
|
|
Needs a Transform on the same entity to work.
|
|
|
|
```js
|
|
var entity = Entity.create(world)
|
|
Transform.create(entity)
|
|
Trail.create(entity)
|
|
|
|
//now just move and rotate the entity around
|
|
```
|
|
"""
|
|
class Trail {
|
|
static time_based{true}
|
|
static distance_based{false}
|
|
|
|
#doc="Add a trail modifier to an entity. Entity should also have a Transform."
|
|
#args=(
|
|
entity = "The entity to add the trail modifier to."
|
|
)
|
|
static create(entity: Entity): None {
|
|
Modifiers.create(This, entity)
|
|
}
|
|
|
|
#doc="Remove the trail modifier from an entity."
|
|
#args=(
|
|
entity = "The entity to remove the trail modifier from."
|
|
)
|
|
static destroy(entity: Entity): None {
|
|
Modifiers.destroy(This, entity)
|
|
}
|
|
|
|
#doc="Check whether an entity has a trail modifier or not."
|
|
#args=(
|
|
entity = "The entity to check whether it has a trail modifier."
|
|
)
|
|
static has(entity: Entity): Bool {
|
|
return Modifiers.has(This, entity)
|
|
}
|
|
|
|
#doc="Reset trail to no length."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static reset(entity: Entity): None {
|
|
Modifiers.get_system(This, entity).reset(entity )
|
|
}
|
|
|
|
#doc="Set the width of a trail."
|
|
#args=(
|
|
entity = "The entity with the trail modifier.",
|
|
width = "The new width of the trail."
|
|
)
|
|
static set_width(entity: Entity, width: Num): None {
|
|
Modifiers.get(This, entity).edge_length = width
|
|
}
|
|
|
|
#doc="Get the width of a trail."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_width(entity: Entity): Num {
|
|
return Modifiers.get(This, entity).edge_length
|
|
}
|
|
|
|
#doc="Set the length of a trail."
|
|
#args=(
|
|
entity = "The entity with the trail modifier.",
|
|
length = "The new length of the trail."
|
|
)
|
|
static set_length(entity: Entity, length: Num): None {
|
|
Modifiers.get(This, entity).length = length
|
|
//todo: recalculate transient data?
|
|
}
|
|
|
|
#doc="Get the length of a trail."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_length(entity: Entity): Num {
|
|
return Modifiers.get(This, entity).length
|
|
}
|
|
|
|
#doc="""
|
|
Set whether the trail is time based or distance based.
|
|
|
|
```js
|
|
Trail.set_time_based(entity, Trail.distance_based)
|
|
```
|
|
"""
|
|
#args=(
|
|
entity = "The entity with the trail modifier.",
|
|
time_based = "`true` if its time based, `false` if its distance based."
|
|
)
|
|
static set_time_based(entity: Entity, time_based: Bool): None {
|
|
Modifiers.get(This, entity).time_based = time_based
|
|
}
|
|
|
|
#doc="""
|
|
Get whether the trail is time based or distance based. (true if time based, false if distance based)
|
|
"""
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_time_based(entity: Entity): Bool {
|
|
return Modifiers.get(This, entity).time_based
|
|
}
|
|
|
|
#doc="""
|
|
Set whether the trail should have normalized UVs of a trail.
|
|
If the UVs are normalized, they should be linear over distance,
|
|
especially with time based trails you otherwise can get very wobbly behaviour as speed changes.
|
|
"""
|
|
#args=(
|
|
entity = "The entity with the trail modifier.",
|
|
length = "Whether the trail should have normalized uvs."
|
|
)
|
|
static set_normalize_uvs(entity: Entity, normalize_uvs: Bool): None {
|
|
Modifiers.get(This, entity).normalize_uvs = normalize_uvs
|
|
}
|
|
|
|
#doc="Get whether a trail has normalized uvs."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_normalize_uvs(entity: Entity): Bool {
|
|
return Modifiers.get(This, entity).normalize_uvs
|
|
}
|
|
|
|
#doc="Set the material the trail is rendered with via its id."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static set_material_id(entity: Entity, material_id: String): None {
|
|
Strings.add(material_id)
|
|
Modifiers.get(This, entity).material = material_id
|
|
Modifiers.get_system(This, entity).set_material_id(entity, material_id)
|
|
}
|
|
|
|
#doc="Set the material the trail is rendered with."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static set_material(entity: Entity, material: Material): None {
|
|
var material_id = Material.get_source_id(material)
|
|
Strings.add(material_id)
|
|
Modifiers.get(This, entity).material = material_id
|
|
Modifiers.get_system(This, entity).set_material(entity, material)
|
|
}
|
|
|
|
#doc="Get the id of the currently used material."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_material_id(entity: Entity): String {
|
|
return Strings.get(Modifiers.get(This, entity).material)
|
|
}
|
|
|
|
#doc="""
|
|
Set mesh subdivisions around length of the trail.
|
|
This will rebuild the mesh entirely and potentially throw away custom materials you set via `set_material`.
|
|
"""
|
|
#args=(
|
|
entity = "The entity with the trail modifier.",
|
|
subdivisions = "Subdivisions along length."
|
|
)
|
|
static set_subdivisions_length(entity: Entity, subdivisions: Num){
|
|
Modifiers.get(This, entity).subdivisions_length = subdivisions
|
|
Modifiers.get_system(This, entity).recreate_buffers(entity)
|
|
}
|
|
|
|
#doc="Get subdivisions in length of trail."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_subdivisions_length(entity: Entity): Num{
|
|
return Modifiers.get(This, entity).subdivisions_length
|
|
}
|
|
|
|
#doc="""
|
|
Set mesh subdivisions around length of the trail.
|
|
This will rebuild the mesh entirely and potentially throw away custom materials you set via `set_material`.
|
|
"""
|
|
#args=(
|
|
entity = "The entity with the trail modifier.",
|
|
subdivisions = "Subdivisions along width."
|
|
)
|
|
static set_subdivisions_width(entity: Entity, subdivisions: Num){
|
|
Modifiers.get(This, entity).subdivisions_width = subdivisions
|
|
Modifiers.get_system(This, entity).recreate_buffers(entity)
|
|
}
|
|
|
|
#doc="Get subdivisions in width of trail."
|
|
#args=(
|
|
entity = "The entity with the trail modifier."
|
|
)
|
|
static get_subdivisions_width(entity: Entity): Num{
|
|
return Modifiers.get(This, entity).subdivisions_width
|
|
}
|
|
} //Trail
|
|
|
|
#hidden
|
|
class Point {
|
|
construct new(pos: Vec, up: Vec){
|
|
_pos = pos
|
|
_up = up
|
|
}
|
|
|
|
pos{_pos}
|
|
up{_up}
|
|
}
|
|
|
|
#hidden
|
|
class TrailData {
|
|
construct new(geometry, indices, positions, colors, uvs){
|
|
_geometry = geometry
|
|
_index_buf = indices
|
|
_pos_buf = positions
|
|
_col_buf = colors
|
|
_uv_buf = uvs
|
|
|
|
_progress = 0
|
|
_progress_since_last_point = 0
|
|
_points = Queue.new()
|
|
}
|
|
|
|
geometry{_geometry}
|
|
index_buffer{_index_buf}
|
|
position_buffer{_pos_buf}
|
|
color_buffer{_col_buf}
|
|
uv_buffer{_uv_buf}
|
|
|
|
points: Queue {_points}
|
|
|
|
progress: Num {_progress}
|
|
progress=(v){_progress=v}
|
|
|
|
progress_since_last_point: Num {_progress_since_last_point}
|
|
progress_since_last_point=(v){_progress_since_last_point = v}
|
|
|
|
previous_pos: Vec {_previous_pos}
|
|
previous_pos=(v){_previous_pos=v}
|
|
|
|
previous_up: Vec {_previous_up}
|
|
previous_up=(v){_previous_up}
|
|
}
|
|
|
|
//Your modifier system implementation.
|
|
//This speaks to the engine and your user facing API
|
|
//to do the actual work. You'll get notified when things change
|
|
//in the world and respond to them here.
|
|
#hidden
|
|
class TrailSystem is ModifierSystem {
|
|
|
|
construct new() {
|
|
//called when your system is first created.
|
|
_instance_data = {}
|
|
}
|
|
|
|
init(world) {
|
|
_world = world
|
|
_draw = Draw.create(World.render_set(world))
|
|
|
|
var edge_debug = PathStyle.new()
|
|
edge_debug.color = [1,1,1,1]
|
|
edge_debug.thickness = 2
|
|
edge_debug.cap = LineCap.round
|
|
_debug_edge_style = edge_debug
|
|
|
|
var path_debug = PathStyle.new()
|
|
path_debug.color = [1, 0, 0, 1]
|
|
path_debug.thickness = 1
|
|
_debug_path_style = path_debug
|
|
|
|
var mesh_debug = PathStyle.new()
|
|
mesh_debug.color = [0, 0, 1, 1]
|
|
mesh_debug.thickness = 0.5
|
|
_debug_mesh_style = mesh_debug
|
|
}
|
|
|
|
reset(entity: Entity){
|
|
_instance_data[entity].points.clear()
|
|
}
|
|
|
|
set_material_id(entity: Entity, material_id: String){
|
|
var material = Assets.material(material_id)
|
|
set_material(entity, material)
|
|
}
|
|
|
|
set_material(entity: Entity, material: Material){
|
|
var data = _instance_data[entity]
|
|
if(!data || !material) return
|
|
Geometry.set_material(entity, material)
|
|
}
|
|
|
|
recreate_buffers(entity: Entity){
|
|
//better solution for after fixes
|
|
/*var data = get(entity)
|
|
var inst_data: TrailData = _instance_data[entity]
|
|
|
|
if(!data || !inst_data) return
|
|
|
|
inst_data.points.clear()
|
|
|
|
var index_data = create_index_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
Render.index_buffer_replace(inst_data.index_buffer, index_data, index_data.length)
|
|
|
|
var pos_data = create_position_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
Render.vertex_buffer_replace(inst_data.position_buffer, pos_data, pos_data.length)
|
|
|
|
var uv_data = create_uv_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
Render.vertex_buffer_replace(inst_data.uv_buffer, uv_data, uv_data.length)
|
|
|
|
var color_data = create_color_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
Render.vertex_buffer_replace(inst_data.color_buffer, color_data, color_data.length)*/
|
|
|
|
//...but for now...
|
|
var data = get(entity)
|
|
detach(entity, data)
|
|
attach(entity, data)
|
|
}
|
|
|
|
destroy() {
|
|
Draw.destroy(_draw)
|
|
}
|
|
|
|
attach(entity, data: ModifierData) {
|
|
|
|
var material_id = Strings.get(data.material)
|
|
var material = Assets.material(material_id)
|
|
|
|
var index_buffer = create_index_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
index_buffer = Render.create_index_buffer(index_buffer, index_buffer.length)
|
|
var geo = Geometry.create(Primitive.triangle, material, (data.subdivisions_length - 1) * 6, IndexType.u16, index_buffer)
|
|
|
|
var pos_buffer = create_position_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
pos_buffer = Render.create_vertex_buffer(pos_buffer, pos_buffer.length)
|
|
Geometry.set_vertex_buffer(geo, 0, pos_buffer)
|
|
|
|
var color_buffer = create_color_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
color_buffer = Render.create_vertex_buffer(color_buffer, color_buffer.length)
|
|
Geometry.set_vertex_buffer(geo, 1, color_buffer)
|
|
|
|
var uv_buffer = create_uv_buffer(data.subdivisions_length, data.subdivisions_width)
|
|
uv_buffer = Render.create_vertex_buffer(uv_buffer, uv_buffer.length)
|
|
Geometry.set_vertex_buffer(geo, 2, uv_buffer)
|
|
|
|
World.render_set_add(_world, geo, entity)
|
|
|
|
_instance_data[entity] = TrailData.new(geo, index_buffer, pos_buffer, color_buffer, uv_buffer)
|
|
}
|
|
|
|
create_position_buffer(subdivs_len: Num, subdivs_width: Num): Floats{
|
|
var raw = Floats.new(4 * subdivs_width * subdivs_len)
|
|
return raw
|
|
}
|
|
|
|
create_color_buffer(subdivs_len: Num, subdivs_width: Num): Floats{
|
|
var raw = Floats.new(4 * subdivs_width * subdivs_len)
|
|
for(i in 0...subdivs_len){
|
|
for(ii in 0...subdivs_width){
|
|
raw[i*subdivs_width*4 + ii*4 + 0] = 1
|
|
raw[i*subdivs_width*4 + ii*4 + 1] = 1
|
|
raw[i*subdivs_width*4 + ii*4 + 2] = 1
|
|
raw[i*subdivs_width*4 + ii*4 + 3] = 1
|
|
}
|
|
}
|
|
//var arr = (0...(raw.size/4)).map{|i|"[%(raw[i*4]), %(raw[i*4+1]), %(raw[i*4+2])]"}.join("\n")
|
|
//System.print(arr)
|
|
return raw
|
|
}
|
|
|
|
create_uv_buffer(subdivs_len: Num, subdivs_width: Num): Floats{
|
|
var raw = Floats.new(2 * subdivs_width * subdivs_len)
|
|
for(i in 0...subdivs_len){
|
|
var x = i / (subdivs_len - 1)
|
|
for(ii in 0...subdivs_width){
|
|
var y = ii / (subdivs_width - 1)
|
|
raw[i*2*subdivs_width + ii*2 + 0] = x
|
|
raw[i*2*subdivs_width + ii*2 + 1] = y
|
|
}
|
|
}
|
|
//var arr = (0...(raw.size/2)).map{|i|"[%(raw[i*2]), %(raw[i*2+1])]"}.join("\n")
|
|
//System.print(arr)
|
|
return raw
|
|
}
|
|
|
|
create_index_buffer(subdivs_len: Num, subdivs_width: Num): Uint16{
|
|
var rows = subdivs_len - 1
|
|
var cols = subdivs_width-1
|
|
var index_count = rows * cols * 6
|
|
var raw = Uint16.new(index_count)
|
|
for(i in 0...rows){
|
|
for(ii in 0...cols){
|
|
//System.print("x: %(i) | y:%(ii)")
|
|
//first triangle
|
|
raw[i*6*cols + ii*6 + 0] = i * (cols+1) + ii + 0
|
|
raw[i*6*cols + ii*6 + 1] = i * (cols+1) + ii + cols+1
|
|
raw[i*6*cols + ii*6 + 2] = i * (cols+1) + ii + 1
|
|
//System.print("(%(i*6*cols + ii*6 + 0), %(i*6*cols + ii*6 + 1), %(i*6*cols + ii*6 + 2))")
|
|
//System.print("[%(i * (cols+1) + ii + 0), %(i * (cols+1) + ii + cols+1), %(i * (cols+1) + ii + 1)]")
|
|
|
|
//second triangle
|
|
raw[i*6*cols + ii*6 + 3] = i * (cols+1) + ii + 1
|
|
raw[i*6*cols + ii*6 + 4] = i * (cols+1) + ii + cols+1
|
|
raw[i*6*cols + ii*6 + 5] = i * (cols+1) + ii + cols+2
|
|
//System.print("(%(i*6*cols + ii*6 + 3), %(i*6*cols + ii*6 + 4), %(i*6*cols + ii*6 + 5))")
|
|
//System.print("[%(i * (cols+1) + ii + 1), %(i * (cols+1) + ii + cols+1), %(i * (cols+1) + ii + cols+2)]")
|
|
}
|
|
}
|
|
//var arr = (0...(raw.length/(3*4))).map{|i|"[%(raw[i*3]), %(raw[i*3+1]), %(raw[i*3+2])]"}.join("\n")
|
|
//System.print(arr)
|
|
return raw
|
|
}
|
|
|
|
detach(entity, data: ModifierData) {
|
|
var inst_data: TrailData = _instance_data[entity]
|
|
World.render_set_remove(_world, inst_data.geometry, entity)
|
|
Geometry.destroy(inst_data.geometry)
|
|
Render.destroy_index_buffer(inst_data.index_buffer)
|
|
Render.destroy_vertex_buffer(inst_data.position_buffer)
|
|
Render.destroy_vertex_buffer(inst_data.color_buffer)
|
|
Render.destroy_vertex_buffer(inst_data.uv_buffer)
|
|
_instance_data.remove(entity)
|
|
}
|
|
|
|
tick(delta) {
|
|
//System.print("positions")
|
|
record_positions(delta)
|
|
//System.print("buffers")
|
|
update_buffers()
|
|
//System.print("debug")
|
|
//debug_draw()
|
|
//System.print("end")
|
|
} //tick
|
|
|
|
record_positions(delta: Num){
|
|
each{|entity, data: ModifierData|
|
|
if(!Transform.has(entity)) return
|
|
|
|
var instance_data: TrailData = _instance_data[entity]
|
|
|
|
var pos = Transform.get_pos_world(entity)
|
|
var up = Transform.local_dir_to_world(entity, 0, data.edge_length * 0.5, 0)
|
|
var prev_pos = instance_data.previous_pos || pos
|
|
var prev_up = instance_data.previous_up || up
|
|
|
|
var dist = instance_data.progress_since_last_point
|
|
var diff:Num
|
|
if(data.time_based){
|
|
diff = delta
|
|
} else {
|
|
diff = Math.dist(pos, prev_pos)
|
|
}
|
|
if(diff > data.length){
|
|
if(data.time_based){
|
|
var t = data.length / diff
|
|
prev_pos.x = Math.lerp(pos.x, prev_pos.x, t)
|
|
prev_pos.y = Math.lerp(pos.y, prev_pos.y, t)
|
|
prev_pos.z = Math.lerp(pos.z, prev_pos.z, t)
|
|
} else {
|
|
var dir = [prev_pos.x - pos.x, prev_pos.y - pos.y, prev_pos.z - pos.z]
|
|
Math.normalize(dir)
|
|
|
|
dir.x = dir.x * data.length
|
|
dir.y = dir.y * data.length
|
|
dir.z = dir.z * data.length
|
|
|
|
prev_pos.x = pos.x + dir.x
|
|
prev_pos.y = pos.y + dir.y
|
|
prev_pos.z = pos.z + dir.z
|
|
}
|
|
diff = data.length
|
|
}
|
|
dist = dist + diff
|
|
var step = data.length / data.subdivisions_length
|
|
while(dist > step){
|
|
dist = dist - step
|
|
var t = 1 - dist / diff
|
|
var point = Point.new([
|
|
Math.lerp(prev_pos.x, pos.x, t),
|
|
Math.lerp(prev_pos.y, pos.y, t),
|
|
Math.lerp(prev_pos.z, pos.z, t)
|
|
], [
|
|
Math.lerp(prev_up.x, up.x, t),
|
|
Math.lerp(prev_up.y, up.y, t),
|
|
Math.lerp(prev_up.z, up.z, t)
|
|
])
|
|
Math.normalize(point.up)
|
|
if(instance_data.points.count >= data.subdivisions_length) instance_data.points.dequeue()
|
|
instance_data.points.enqueue(point)
|
|
}
|
|
instance_data.progress_since_last_point = dist
|
|
|
|
instance_data.previous_pos = pos
|
|
instance_data.previous_up = up
|
|
}
|
|
}
|
|
|
|
update_buffers(){
|
|
each{|entity, data: ModifierData|
|
|
if(!Transform.has(entity)) return
|
|
|
|
var instance_data: TrailData = _instance_data[entity]
|
|
var points = instance_data.points
|
|
|
|
var pos = Transform.get_pos_world(entity)
|
|
|
|
var positions = Floats.new(Render.vertex_buffer_get_size(instance_data.position_buffer) / 4)
|
|
Render.vertex_buffer_get_data(instance_data.position_buffer, positions, positions.size * 4, 0)
|
|
|
|
var uvs: Floats
|
|
if(data.normalize_uvs){
|
|
uvs = Floats.new(Render.vertex_buffer_get_size(instance_data.uv_buffer) / 4)
|
|
Render.vertex_buffer_get_data(instance_data.uv_buffer, uvs, uvs.size * 4, 0)
|
|
}
|
|
//System.print("positions(%(Render.vertex_buffer_get_size(instance_data.position_buffer))):")
|
|
//System.print((0...(positions.size/4)).map{|i|"[%(positions[i*4]), %(positions[i*4+1]), %(positions[i*4+2])]"}.join("\n"))
|
|
var i = -1
|
|
{
|
|
i = i + 1
|
|
|
|
var start = Transform.local_point_to_world(entity, 0, data.edge_length * -0.5, 0)
|
|
var end = Transform.local_point_to_world(entity, 0, data.edge_length * 0.5, 0)
|
|
|
|
for(ii in 0...data.subdivisions_width){
|
|
var t = ii / (data.subdivisions_width-1)
|
|
var pos_x = Math.lerp(start.x, end.x, t)
|
|
var pos_y = Math.lerp(start.y, end.y, t)
|
|
var pos_z = Math.lerp(start.z, end.z, t)
|
|
positions[i*4*data.subdivisions_width + ii*4 + 0] = pos_x
|
|
positions[i*4*data.subdivisions_width + ii*4 + 1] = pos_y
|
|
positions[i*4*data.subdivisions_width + ii*4 + 2] = pos_z
|
|
}
|
|
}
|
|
|
|
var length = 0
|
|
var current_len = 0
|
|
if(data.normalize_uvs){
|
|
for(i in 0...points.count){
|
|
var from = i<(points.count-1)? points[i+1].pos : pos
|
|
var to = points[i].pos
|
|
var dist = Math.dist(from, to)
|
|
length = length + (i != (points.count-1) ? dist : dist * (1 - instance_data.progress_since_last_point / (data.length / data.subdivisions_length)))
|
|
}
|
|
|
|
current_len = points.count > 1 ? Math.dist(points[points.count-1].pos, pos) : 0
|
|
}
|
|
|
|
var step = data.length / data.subdivisions_length
|
|
var t = 1 - instance_data.progress_since_last_point / step
|
|
|
|
var point_index = points.count - 1
|
|
while(true){
|
|
if(point_index < 0) break
|
|
|
|
var p:Point
|
|
var next:Point
|
|
|
|
point_index = point_index - 1
|
|
if(point_index < 0) break
|
|
p = points[point_index]
|
|
next = points[point_index + 1]
|
|
|
|
var to = p.pos
|
|
var to_up = p.up
|
|
|
|
var from = next.pos
|
|
var from_up = next.up
|
|
|
|
|
|
var pos = [
|
|
Math.lerp(from.x, to.x, t),
|
|
Math.lerp(from.y, to.y, t),
|
|
Math.lerp(from.z, to.z, t)
|
|
]
|
|
|
|
var up = [
|
|
Math.lerp(from_up.x, to_up.x, t),
|
|
Math.lerp(from_up.y, to_up.y, t),
|
|
Math.lerp(from_up.z, to_up.z, t)
|
|
]
|
|
|
|
Math.normalize(up)
|
|
|
|
i = i + 1
|
|
for(y in 0...data.subdivisions_width){
|
|
var t = y / (data.subdivisions_width-1)
|
|
var offset_x = Math.lerp(-up.x, up.x, t)
|
|
var offset_y = Math.lerp(-up.y, up.y, t)
|
|
var offset_z = Math.lerp(-up.z, up.z, t)
|
|
positions[i*4*data.subdivisions_width + y*4 + 0] = pos.x + offset_x * data.edge_length * 0.5
|
|
positions[i*4*data.subdivisions_width + y*4 + 1] = pos.y + offset_y * data.edge_length * 0.5
|
|
positions[i*4*data.subdivisions_width + y*4 + 2] = pos.z + offset_z * data.edge_length * 0.5
|
|
}
|
|
|
|
if(data.normalize_uvs){
|
|
var segment_len = Math.dist(from, to)
|
|
current_len = current_len + segment_len * t
|
|
var x = current_len / length
|
|
for(ii in 0...data.subdivisions_width){
|
|
var y = ii / (data.subdivisions_width - 1)
|
|
uvs[i*2*data.subdivisions_width + ii*2 + 0] = x
|
|
uvs[i*2*data.subdivisions_width + ii*2 + 1] = y
|
|
}
|
|
current_len = current_len + segment_len * (1-t)
|
|
}
|
|
}
|
|
|
|
Render.vertex_buffer_replace(instance_data.position_buffer, positions, positions.length)
|
|
if(data.normalize_uvs){
|
|
Render.vertex_buffer_replace(instance_data.uv_buffer, uvs, uvs.length)
|
|
}
|
|
Geometry.set_vert_count(instance_data.geometry, i.max(0) * 6 * (data.subdivisions_width-1))
|
|
}
|
|
}
|
|
|
|
debug_draw(){
|
|
each {|entity, data: ModifierData|
|
|
var start = [0, 0]
|
|
var end = [0, data.edge_length]
|
|
var depth = 0
|
|
if(Transform.has(entity)){
|
|
start = Transform.local_point_to_world(entity, 0, data.edge_length * -0.5, 0)
|
|
end = Transform.local_point_to_world(entity, 0, data.edge_length * 0.5, 0)
|
|
depth = Transform.get_depth2D_world(entity)
|
|
}
|
|
Draw.line(_draw, start.x, start.y, end.x, end.y, depth, _debug_edge_style)
|
|
|
|
var instance_data: TrailData = _instance_data[entity]
|
|
var points = instance_data.points
|
|
|
|
if(points.count > 1){
|
|
Draw.path3D(_draw, points.map{|p:Point|p.pos}.toList, _debug_path_style, false)
|
|
}
|
|
|
|
points.each{|point: Point|
|
|
var from_x = point.pos.x + point.up.x * data.edge_length * 0.5
|
|
var from_y = point.pos.y + point.up.y * data.edge_length * 0.5
|
|
var from_z = point.pos.x + point.up.x * data.edge_length * 0.5
|
|
|
|
var to_x = point.pos.x - point.up.x * data.edge_length * 0.5
|
|
var to_y = point.pos.y - point.up.y * data.edge_length * 0.5
|
|
var to_z = point.pos.z - point.up.z * data.edge_length * 0.5
|
|
|
|
Draw.path3D(_draw, [[from_x, from_y, from_z], [to_x, to_y, to_z]], _debug_path_style, false)
|
|
}
|
|
|
|
var positions = Floats.new(Render.vertex_buffer_get_size(instance_data.position_buffer) / 4)
|
|
Render.vertex_buffer_get_data(instance_data.position_buffer, positions, positions.size * 4, 0)
|
|
var indices = Uint16.new(Render.index_buffer_get_size(instance_data.index_buffer) / 2)
|
|
Render.index_buffer_get_data(instance_data.index_buffer, indices, indices.length, 0)
|
|
for(i in 0...(Geometry.get_vert_count(instance_data.geometry) / 3)){
|
|
var i1 = indices[i * 3 + 0]
|
|
var i2 = indices[i * 3 + 1]
|
|
var i3 = indices[i * 3 + 2]
|
|
|
|
var v1 = [positions[i1 * 4 + 0], positions[i1 * 4 + 1], positions[i1 * 4 + 2]]
|
|
var v2 = [positions[i2 * 4 + 0], positions[i2 * 4 + 1], positions[i2 * 4 + 2]]
|
|
var v3 = [positions[i3 * 4 + 0], positions[i3 * 4 + 1], positions[i3 * 4 + 2]]
|
|
|
|
Draw.path3D(_draw, [v1, v2, v3], _debug_mesh_style, true)
|
|
}
|
|
}
|
|
Draw.commit(_draw)
|
|
}
|
|
|
|
} //TrailSystem
|
|
|
|
var Modifier = TrailSystem //required
|