|
|
@ -4,7 +4,10 @@ import scala.jdk.CollectionConverters._ |
|
|
import scala.reflect.ClassTag |
|
|
import scala.reflect.ClassTag |
|
|
|
|
|
|
|
|
import akka.actor.typed.ActorRef |
|
|
import akka.actor.typed.ActorRef |
|
|
|
|
|
import akka.actor.typed.Behavior |
|
|
|
|
|
import akka.actor.typed.Props |
|
|
import akka.actor.typed.Scheduler |
|
|
import akka.actor.typed.Scheduler |
|
|
|
|
|
import akka.actor.typed.scaladsl.ActorContext |
|
|
import akka.util.Timeout |
|
|
import akka.util.Timeout |
|
|
import com.jayfella.jme.jfx.JavaFxUI |
|
|
import com.jayfella.jme.jfx.JavaFxUI |
|
|
import com.jme3.app.Application |
|
|
import com.jme3.app.Application |
|
|
@ -14,10 +17,12 @@ import com.jme3.app.state.AppStateManager |
|
|
import com.jme3.asset.AssetLocator |
|
|
import com.jme3.asset.AssetLocator |
|
|
import com.jme3.asset.AssetManager |
|
|
import com.jme3.asset.AssetManager |
|
|
import com.jme3.bullet.BulletAppState |
|
|
import com.jme3.bullet.BulletAppState |
|
|
import com.jme3.bullet.PhysicsSpace |
|
|
|
|
|
import com.jme3.bullet.PhysicsTickListener |
|
|
import com.jme3.bullet.PhysicsTickListener |
|
|
import com.jme3.bullet.collision.PhysicsCollisionEvent |
|
|
|
|
|
import com.jme3.bullet.collision.PhysicsCollisionListener |
|
|
import com.jme3.bullet.collision.PhysicsCollisionListener |
|
|
|
|
|
import com.jme3.bullet.collision.PhysicsCollisionObject |
|
|
|
|
|
import com.jme3.bullet.collision.{ |
|
|
|
|
|
PhysicsCollisionEvent => jmePhysicsCollisionEvent |
|
|
|
|
|
} |
|
|
import com.jme3.bullet.control.BetterCharacterControl |
|
|
import com.jme3.bullet.control.BetterCharacterControl |
|
|
import com.jme3.input.Action |
|
|
import com.jme3.input.Action |
|
|
import com.jme3.input.InputManager |
|
|
import com.jme3.input.InputManager |
|
|
@ -35,14 +40,17 @@ import com.jme3.scene.SceneGraphVisitor |
|
|
import com.jme3.scene.Spatial |
|
|
import com.jme3.scene.Spatial |
|
|
import com.jme3.scene.control.CameraControl.ControlDirection |
|
|
import com.jme3.scene.control.CameraControl.ControlDirection |
|
|
import com.jme3.scene.control.Control |
|
|
import com.jme3.scene.control.Control |
|
|
|
|
|
import com.jme3.{bullet => jmeb} |
|
|
import com.simsilica.es.EntityComponent |
|
|
import com.simsilica.es.EntityComponent |
|
|
import com.simsilica.es.EntityData |
|
|
import com.simsilica.es.EntityData |
|
|
import com.simsilica.es.EntityId |
|
|
import com.simsilica.es.EntityId |
|
|
import enumeratum._ |
|
|
import enumeratum._ |
|
|
import io.odin.meta.Position |
|
|
import io.odin.meta.Position |
|
|
import io.odin.meta.Render |
|
|
import io.odin.meta.Render |
|
|
|
|
|
import monix.bio.IO |
|
|
import monix.bio.Task |
|
|
import monix.bio.Task |
|
|
import monix.bio.UIO |
|
|
import monix.bio.UIO |
|
|
|
|
|
import monix.eval.Coeval |
|
|
import monix.execution.Ack |
|
|
import monix.execution.Ack |
|
|
import monix.execution.Ack.Continue |
|
|
import monix.execution.Ack.Continue |
|
|
import monix.execution.Ack.Stop |
|
|
import monix.execution.Ack.Stop |
|
|
@ -54,6 +62,7 @@ import monix.reactive.observers.Subscriber |
|
|
import org.slf4j.Logger |
|
|
import org.slf4j.Logger |
|
|
import wow.doge.mygame.math.ImVector3f |
|
|
import wow.doge.mygame.math.ImVector3f |
|
|
import wow.doge.mygame.state.MyBaseState |
|
|
import wow.doge.mygame.state.MyBaseState |
|
|
|
|
|
import wow.doge.mygame.utils.wrappers.jme.PhysicsSpace |
|
|
|
|
|
|
|
|
final case class ActionEvent(binding: Action, value: Boolean, tpf: Float) |
|
|
final case class ActionEvent(binding: Action, value: Boolean, tpf: Float) |
|
|
final case class EnumActionEvent[T <: EnumEntry]( |
|
|
final case class EnumActionEvent[T <: EnumEntry]( |
|
|
@ -68,8 +77,15 @@ final case class EnumAnalogEvent[T <: EnumEntry]( |
|
|
value: Float, |
|
|
value: Float, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
) |
|
|
) |
|
|
final class PrePhysicsTickEvent(val space: PhysicsSpace) extends AnyVal |
|
|
|
|
|
final class PhysicsTickEvent(val space: PhysicsSpace) extends AnyVal |
|
|
|
|
|
|
|
|
final case class PrePhysicsTickEvent(space: PhysicsSpace) |
|
|
|
|
|
final case class PhysicsTickEvent(space: PhysicsSpace) |
|
|
|
|
|
final case class CollisionEvent( |
|
|
|
|
|
nodeA: Option[Spatial], |
|
|
|
|
|
nodeB: Option[Spatial], |
|
|
|
|
|
objectA: PhysicsCollisionObject, |
|
|
|
|
|
objectB: PhysicsCollisionObject, |
|
|
|
|
|
appliedImpulse: Function0[Float] |
|
|
|
|
|
) |
|
|
|
|
|
|
|
|
package object implicits { |
|
|
package object implicits { |
|
|
type PrePhysicsTickEvent = PhysicsTickEvent |
|
|
type PrePhysicsTickEvent = PhysicsTickEvent |
|
|
@ -112,10 +128,9 @@ package object implicits { |
|
|
|
|
|
|
|
|
override def init(): Unit = {} |
|
|
override def init(): Unit = {} |
|
|
|
|
|
|
|
|
override def update(tpf: Float) = { |
|
|
|
|
|
|
|
|
override def update(tpf: Float) = |
|
|
if (sub.onNext(tpf) == Ack.Stop) |
|
|
if (sub.onNext(tpf) == Ack.Stop) |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
override def stop(): Unit = {} |
|
|
override def stop(): Unit = {} |
|
|
|
|
|
|
|
|
@ -133,13 +148,11 @@ package object implicits { |
|
|
def registerLocator( |
|
|
def registerLocator( |
|
|
assetPath: os.RelPath, |
|
|
assetPath: os.RelPath, |
|
|
locator: Class[_ <: AssetLocator] |
|
|
locator: Class[_ <: AssetLocator] |
|
|
): Unit = { |
|
|
|
|
|
|
|
|
): Unit = |
|
|
am.registerLocator(assetPath.toString(), locator) |
|
|
am.registerLocator(assetPath.toString(), locator) |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
def loadModel(assetPath: os.RelPath): Spatial = { |
|
|
|
|
|
|
|
|
def loadModel(assetPath: os.RelPath): Spatial = |
|
|
am.loadModel(assetPath.toString()) |
|
|
am.loadModel(assetPath.toString()) |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
implicit final class BulletAppStateExt(private val bas: BulletAppState) |
|
|
implicit final class BulletAppStateExt(private val bas: BulletAppState) |
|
|
@ -251,7 +264,7 @@ package object implicits { |
|
|
} |
|
|
} |
|
|
// case _ => loop(subscriber, tail) |
|
|
// case _ => loop(subscriber, tail) |
|
|
} |
|
|
} |
|
|
case LazyList() => Task.unit |
|
|
|
|
|
|
|
|
case LazyList() => Task(subscriber.onComplete()) |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
|
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
|
|
@ -297,7 +310,7 @@ package object implicits { |
|
|
Task(subscriber.onComplete()) |
|
|
Task(subscriber.onComplete()) |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
case LazyList() => Task.unit |
|
|
|
|
|
|
|
|
case LazyList() => Task(subscriber.onComplete()) |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
|
|
Observable.create(OverflowStrategy.Unbounded) { sub => |
|
|
@ -372,9 +385,8 @@ package object implicits { |
|
|
*/ |
|
|
*/ |
|
|
def askL[Res]( |
|
|
def askL[Res]( |
|
|
replyTo: ActorRef[Res] => Req |
|
|
replyTo: ActorRef[Res] => Req |
|
|
)(implicit timeout: Timeout, scheduler: Scheduler): Task[Res] = { |
|
|
|
|
|
|
|
|
)(implicit timeout: Timeout, scheduler: Scheduler): Task[Res] = |
|
|
Task.deferFuture(a.ask(replyTo)(timeout, scheduler)) |
|
|
Task.deferFuture(a.ask(replyTo)(timeout, scheduler)) |
|
|
} |
|
|
|
|
|
def ??[Res]( |
|
|
def ??[Res]( |
|
|
replyTo: ActorRef[Res] => Req |
|
|
replyTo: ActorRef[Res] => Req |
|
|
)(implicit timeout: Timeout, scheduler: Scheduler): Task[Res] = |
|
|
)(implicit timeout: Timeout, scheduler: Scheduler): Task[Res] = |
|
|
@ -481,8 +493,7 @@ package object implicits { |
|
|
* @see [[ActionEvent]] |
|
|
* @see [[ActionEvent]] |
|
|
* @see [[enumObservableAction]] |
|
|
* @see [[enumObservableAction]] |
|
|
*/ |
|
|
*/ |
|
|
def observableAction(mappingNames: String*): Observable[ActionEvent] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def observableAction(mappingNames: String*): Observable[ActionEvent] = |
|
|
Observable.create(OverflowStrategy.DropOld(10)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(10)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val al = new ActionListener { |
|
|
val al = new ActionListener { |
|
|
@ -490,14 +501,13 @@ package object implicits { |
|
|
binding: String, |
|
|
binding: String, |
|
|
value: Boolean, |
|
|
value: Boolean, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
): Unit = { |
|
|
|
|
|
|
|
|
): Unit = |
|
|
if ( |
|
|
if ( |
|
|
sub.onNext(ActionEvent(Action(binding), value, tpf)) == Ack.Stop |
|
|
sub.onNext(ActionEvent(Action(binding), value, tpf)) == Ack.Stop |
|
|
) { |
|
|
) { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
inputManager.addListener(al, mappingNames: _*) |
|
|
inputManager.addListener(al, mappingNames: _*) |
|
|
@ -505,7 +515,6 @@ package object implicits { |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
/** |
|
|
* <p> |
|
|
* <p> |
|
|
@ -530,8 +539,7 @@ package object implicits { |
|
|
*/ |
|
|
*/ |
|
|
def enumObservableAction[T <: EnumEntry]( |
|
|
def enumObservableAction[T <: EnumEntry]( |
|
|
mappingEnum: Enum[T] |
|
|
mappingEnum: Enum[T] |
|
|
): Observable[EnumActionEvent[T]] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
): Observable[EnumActionEvent[T]] = |
|
|
Observable.create(OverflowStrategy.DropOld(10)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(10)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val entryNames = mappingEnum.values.map(_.entryName) |
|
|
val entryNames = mappingEnum.values.map(_.entryName) |
|
|
@ -540,14 +548,13 @@ package object implicits { |
|
|
binding: String, |
|
|
binding: String, |
|
|
value: Boolean, |
|
|
value: Boolean, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
): Unit = { |
|
|
|
|
|
|
|
|
): Unit = |
|
|
mappingEnum.withNameOption(binding).foreach { b => |
|
|
mappingEnum.withNameOption(binding).foreach { b => |
|
|
if (sub.onNext(EnumActionEvent(b, value, tpf)) == Ack.Stop) { |
|
|
if (sub.onNext(EnumActionEvent(b, value, tpf)) == Ack.Stop) { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
inputManager.addListener(al, entryNames: _*) |
|
|
inputManager.addListener(al, entryNames: _*) |
|
|
@ -555,12 +562,10 @@ package object implicits { |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
def enumEntryObservableAction[T <: EnumEntry]( |
|
|
def enumEntryObservableAction[T <: EnumEntry]( |
|
|
mappingEnumEntry: T |
|
|
mappingEnumEntry: T |
|
|
): Observable[EnumActionEvent[T]] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
): Observable[EnumActionEvent[T]] = |
|
|
Observable.create(OverflowStrategy.DropOld(10)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(10)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val al = new ActionListener { |
|
|
val al = new ActionListener { |
|
|
@ -568,7 +573,7 @@ package object implicits { |
|
|
binding: String, |
|
|
binding: String, |
|
|
value: Boolean, |
|
|
value: Boolean, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
): Unit = { |
|
|
|
|
|
|
|
|
): Unit = |
|
|
if ( |
|
|
if ( |
|
|
sub.onNext( |
|
|
sub.onNext( |
|
|
EnumActionEvent(mappingEnumEntry, value, tpf) |
|
|
EnumActionEvent(mappingEnumEntry, value, tpf) |
|
|
@ -577,7 +582,6 @@ package object implicits { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
inputManager.addListener(al, mappingEnumEntry.entryName) |
|
|
inputManager.addListener(al, mappingEnumEntry.entryName) |
|
|
@ -585,10 +589,8 @@ package object implicits { |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
def analogObservable(mappingNames: String*): Observable[AnalogEvent] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def analogObservable(mappingNames: String*): Observable[AnalogEvent] = |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val al = new AnalogListener { |
|
|
val al = new AnalogListener { |
|
|
@ -596,14 +598,13 @@ package object implicits { |
|
|
binding: String, |
|
|
binding: String, |
|
|
value: Float, |
|
|
value: Float, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
): Unit = { |
|
|
|
|
|
|
|
|
): Unit = |
|
|
if ( |
|
|
if ( |
|
|
sub.onNext(AnalogEvent(Action(binding), value, tpf)) == Ack.Stop |
|
|
sub.onNext(AnalogEvent(Action(binding), value, tpf)) == Ack.Stop |
|
|
) { |
|
|
) { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
inputManager.addListener(al, mappingNames: _*) |
|
|
inputManager.addListener(al, mappingNames: _*) |
|
|
@ -611,12 +612,10 @@ package object implicits { |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
def enumAnalogObservable[T <: EnumEntry]( |
|
|
def enumAnalogObservable[T <: EnumEntry]( |
|
|
mappingEnum: Enum[T] |
|
|
mappingEnum: Enum[T] |
|
|
): Observable[EnumAnalogEvent[T]] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
): Observable[EnumAnalogEvent[T]] = |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val entryNames = mappingEnum.values.map(_.entryName) |
|
|
val entryNames = mappingEnum.values.map(_.entryName) |
|
|
@ -625,14 +624,13 @@ package object implicits { |
|
|
binding: String, |
|
|
binding: String, |
|
|
value: Float, |
|
|
value: Float, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
): Unit = { |
|
|
|
|
|
|
|
|
): Unit = |
|
|
mappingEnum.withNameOption(binding).foreach { b => |
|
|
mappingEnum.withNameOption(binding).foreach { b => |
|
|
if (sub.onNext(EnumAnalogEvent(b, value, tpf)) == Ack.Stop) { |
|
|
if (sub.onNext(EnumAnalogEvent(b, value, tpf)) == Ack.Stop) { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
inputManager.addListener(al, entryNames: _*) |
|
|
inputManager.addListener(al, entryNames: _*) |
|
|
@ -640,49 +638,58 @@ package object implicits { |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c := Cancelable(() => inputManager.removeListener(al)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
implicit final class PhysicsSpaceExt(private val space: PhysicsSpace) |
|
|
|
|
|
|
|
|
implicit final class PhysicsSpaceExt(private val space: jmeb.PhysicsSpace) |
|
|
extends AnyVal { |
|
|
extends AnyVal { |
|
|
|
|
|
|
|
|
def collisionObservable(): Observable[PhysicsCollisionEvent] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def collisionObservable(): Observable[CollisionEvent] = |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val cl = new PhysicsCollisionListener { |
|
|
val cl = new PhysicsCollisionListener { |
|
|
override def collision(event: PhysicsCollisionEvent): Unit = { |
|
|
|
|
|
|
|
|
|
|
|
if (sub.onNext(event) == Ack.Stop) { |
|
|
|
|
|
sub.onComplete() |
|
|
|
|
|
c.cancel() |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
override def collision(event: jmePhysicsCollisionEvent): Unit = |
|
|
|
|
|
if ( |
|
|
|
|
|
sub.onNext( |
|
|
|
|
|
CollisionEvent( |
|
|
|
|
|
Option(event.getNodeA), |
|
|
|
|
|
Option(event.getNodeB), |
|
|
|
|
|
event.getObjectA, |
|
|
|
|
|
event.getObjectB, |
|
|
|
|
|
event.getAppliedImpulse _ |
|
|
|
|
|
) |
|
|
|
|
|
) == Ack.Stop |
|
|
|
|
|
) c.cancel() |
|
|
|
|
|
|
|
|
} |
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
space.addCollisionListener(cl) |
|
|
space.addCollisionListener(cl) |
|
|
|
|
|
|
|
|
c := Cancelable(() => space.removeCollisionListener(cl)) |
|
|
|
|
|
|
|
|
c := Cancelable { () => |
|
|
|
|
|
pprint.log("stopped") |
|
|
|
|
|
space.removeCollisionListener(cl) |
|
|
|
|
|
} |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
def prePhysicsTickObservable(): Observable[PrePhysicsTickEvent] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def prePhysicsTickObservable(): Observable[PrePhysicsTickEvent] = |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val cl = new PhysicsTickListener { |
|
|
val cl = new PhysicsTickListener { |
|
|
|
|
|
|
|
|
override def prePhysicsTick(space: PhysicsSpace, tpf: Float): Unit = { |
|
|
|
|
|
val event = new PrePhysicsTickEvent(space) |
|
|
|
|
|
|
|
|
override def prePhysicsTick( |
|
|
|
|
|
space: jmeb.PhysicsSpace, |
|
|
|
|
|
tpf: Float |
|
|
|
|
|
): Unit = { |
|
|
|
|
|
val event = new PrePhysicsTickEvent(new PhysicsSpace(space)) |
|
|
if (sub.onNext(event) == Ack.Stop) { |
|
|
if (sub.onNext(event) == Ack.Stop) { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
} |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
override def physicsTick(space: PhysicsSpace, tpf: Float): Unit = {} |
|
|
|
|
|
|
|
|
override def physicsTick( |
|
|
|
|
|
space: jmeb.PhysicsSpace, |
|
|
|
|
|
tpf: Float |
|
|
|
|
|
): Unit = {} |
|
|
|
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
@ -691,21 +698,22 @@ package object implicits { |
|
|
c := Cancelable(() => space.removeTickListener(cl)) |
|
|
c := Cancelable(() => space.removeTickListener(cl)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
def physicsTickObservable(): Observable[PhysicsTickEvent] = { |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
def physicsTickObservable(): Observable[PhysicsTickEvent] = |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
Observable.create(OverflowStrategy.DropOld(50)) { sub => |
|
|
val c = SingleAssignCancelable() |
|
|
val c = SingleAssignCancelable() |
|
|
val cl = new PhysicsTickListener { |
|
|
val cl = new PhysicsTickListener { |
|
|
|
|
|
|
|
|
override def prePhysicsTick( |
|
|
override def prePhysicsTick( |
|
|
space: PhysicsSpace, |
|
|
|
|
|
|
|
|
space: jmeb.PhysicsSpace, |
|
|
tpf: Float |
|
|
tpf: Float |
|
|
): Unit = {} |
|
|
): Unit = {} |
|
|
|
|
|
|
|
|
override def physicsTick(space: PhysicsSpace, tpf: Float): Unit = { |
|
|
|
|
|
val event = new PhysicsTickEvent(space) |
|
|
|
|
|
|
|
|
override def physicsTick( |
|
|
|
|
|
space: jmeb.PhysicsSpace, |
|
|
|
|
|
tpf: Float |
|
|
|
|
|
): Unit = { |
|
|
|
|
|
val event = new PhysicsTickEvent(new PhysicsSpace(space)) |
|
|
if (sub.onNext(event) == Ack.Stop) { |
|
|
if (sub.onNext(event) == Ack.Stop) { |
|
|
sub.onComplete() |
|
|
sub.onComplete() |
|
|
c.cancel() |
|
|
c.cancel() |
|
|
@ -719,7 +727,6 @@ package object implicits { |
|
|
c := Cancelable(() => space.removeTickListener(cl)) |
|
|
c := Cancelable(() => space.removeTickListener(cl)) |
|
|
c |
|
|
c |
|
|
} |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
//TODO Consider creating a typeclass for this |
|
|
//TODO Consider creating a typeclass for this |
|
|
def +=(anyObject: Any) = space.add(anyObject) |
|
|
def +=(anyObject: Any) = space.add(anyObject) |
|
|
@ -757,6 +764,7 @@ package object implicits { |
|
|
def +=:(that: ImVector3f) = v += that |
|
|
def +=:(that: ImVector3f) = v += that |
|
|
def *=(that: Vector3f) = v.multLocal(that) |
|
|
def *=(that: Vector3f) = v.multLocal(that) |
|
|
def *=(that: ImVector3f) = v.multLocal(that.x, that.y, that.z) |
|
|
def *=(that: ImVector3f) = v.multLocal(that.x, that.y, that.z) |
|
|
|
|
|
def *=(f: Float) = v.multLocal(f, f, f) |
|
|
def *=:(that: ImVector3f) = v *= that |
|
|
def *=:(that: ImVector3f) = v *= that |
|
|
def -=(that: Vector3f) = v.subtractLocal(that) |
|
|
def -=(that: Vector3f) = v.subtractLocal(that) |
|
|
def -=(that: ImVector3f) = v.subtractLocal(that.x, that.y, that.z) |
|
|
def -=(that: ImVector3f) = v.subtractLocal(that.x, that.y, that.z) |
|
|
@ -766,6 +774,7 @@ package object implicits { |
|
|
def /=:(that: ImVector3f) = v *= that |
|
|
def /=:(that: ImVector3f) = v *= that |
|
|
def unary_- = v.negateLocal() |
|
|
def unary_- = v.negateLocal() |
|
|
def immutable = ImVector3f(v.x, v.y, v.z) |
|
|
def immutable = ImVector3f(v.x, v.y, v.z) |
|
|
|
|
|
// def transformImmutable(f: Vector3f => Vector3f) = f(v).immutable |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
implicit final class ImVector3fExt(private val v: ImVector3f) extends AnyVal { |
|
|
implicit final class ImVector3fExt(private val v: ImVector3f) extends AnyVal { |
|
|
@ -858,7 +867,7 @@ package object implicits { |
|
|
|
|
|
|
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
implicit class odinLoggerExt(private val logger: io.odin.Logger[Task]) |
|
|
|
|
|
|
|
|
implicit class OdinLoggerExt(private val logger: io.odin.Logger[Task]) |
|
|
extends AnyVal { |
|
|
extends AnyVal { |
|
|
def debugU[M](msg: => M)(implicit render: Render[M], position: Position) = |
|
|
def debugU[M](msg: => M)(implicit render: Render[M], position: Position) = |
|
|
logger.debug(msg).hideErrors |
|
|
logger.debug(msg).hideErrors |
|
|
@ -871,4 +880,28 @@ package object implicits { |
|
|
def errorU[M](msg: => M)(implicit render: Render[M], position: Position) = |
|
|
def errorU[M](msg: => M)(implicit render: Render[M], position: Position) = |
|
|
logger.error(msg).hideErrors |
|
|
logger.error(msg).hideErrors |
|
|
} |
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
implicit class TypedActorContextExt[T](private val ctx: ActorContext[T]) |
|
|
|
|
|
extends AnyVal { |
|
|
|
|
|
def spawnN[U](behavior: Behavior[U], props: Props = Props.empty)(implicit |
|
|
|
|
|
name: sourcecode.Name |
|
|
|
|
|
): ActorRef[U] = |
|
|
|
|
|
ctx.spawn(behavior, name.value, props) |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
implicit class MonixEvalTaskExt[T](private val task: monix.eval.Task[T]) |
|
|
|
|
|
extends AnyVal { |
|
|
|
|
|
def toIO = IO.deferAction(implicit s => IO.from(task)) |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
implicit class MonixBioTaskExt[T](private val task: monix.bio.Task[T]) |
|
|
|
|
|
extends AnyVal { |
|
|
|
|
|
def toTask = |
|
|
|
|
|
monix.eval.Task.deferAction(implicit s => monix.eval.Task.from(task)) |
|
|
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
implicit class CoevalEitherExt[L, R](private val coeval: Coeval[Either[L, R]]) |
|
|
|
|
|
extends AnyVal { |
|
|
|
|
|
def toIO = coeval.to[Task].hideErrors.rethrow |
|
|
|
|
|
} |
|
|
} |
|
|
} |
