anchor.diff:              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'trySetEntityFacetNames' due to: " + scstring exn, None)
               struct (violation, World.choose oldWorld)
   
  +    let getEyePosition3d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyePosition3d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector3> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyePosition3d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setEyePosition3d value world =
  +        let oldWorld = world
  +        try
  +            let value =
  +                match ScriptingSystem.tryExport typeof<Vector3> value world with
  +                | Some value -> value :?> Vector3
  +                | None -> failwith "Invalid argument type for 'value'; expecting a value convertable to Vector3."
  +            let result = World.setEyePosition3d value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setEyePosition3d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getEyeRotation3d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyeRotation3d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Quaternion> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyeRotation3d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setEyeRotation3d value world =
  +        let oldWorld = world
  +        try
  +            let value =
  +                match ScriptingSystem.tryExport typeof<Quaternion> value world with
  +                | Some value -> value :?> Quaternion
  +                | None -> failwith "Invalid argument type for 'value'; expecting a value convertable to Quaternion."
  +            let result = World.setEyeRotation3d value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setEyeRotation3d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getEyeProjection3d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyeProjection3d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Matrix4x4> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyeProjection3d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setEyeProjection3d value world =
  +        let oldWorld = world
  +        try
  +            let value =
  +                match ScriptingSystem.tryExport typeof<Matrix4x4> value world with
  +                | Some value -> value :?> Matrix4x4
  +                | None -> failwith "Invalid argument type for 'value'; expecting a value convertable to Matrix4x4."
  +            let result = World.setEyeProjection3d value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setEyeProjection3d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getEyePosition2d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyePosition2d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyePosition2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setEyePosition2d value world =
  +        let oldWorld = world
  +        try
  +            let value =
  +                match ScriptingSystem.tryExport typeof<Vector2> value world with
  +                | Some value -> value :?> Vector2
  +                | None -> failwith "Invalid argument type for 'value'; expecting a value convertable to Vector2."
  +            let result = World.setEyePosition2d value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setEyePosition2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getEyeSize2d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyeSize2d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyeSize2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getEyeMargin2d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyeMargin2d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyeMargin2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setEyeSize2d value world =
  +        let oldWorld = world
  +        try
  +            let value =
  +                match ScriptingSystem.tryExport typeof<Vector2> value world with
  +                | Some value -> value :?> Vector2
  +                | None -> failwith "Invalid argument type for 'value'; expecting a value convertable to Vector2."
  +            let result = World.setEyeSize2d value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setEyeSize2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getEyeBounds2d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getEyeBounds2d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Box2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getEyeBounds2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getOmniScreenOpt world =
  +        let oldWorld = world
  +        try
  +            let result = World.getOmniScreenOpt world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<FSharpOption<Screen>> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getOmniScreenOpt' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setOmniScreenOpt value world =
  +        let oldWorld = world
  +        try
  +            let value =
  +                match ScriptingSystem.tryExport typeof<FSharpOption<Screen>> value world with
  +                | Some value -> value :?> FSharpOption<Screen>
  +                | None -> failwith "Invalid argument type for 'value'; expecting a value convertable to FSharpOption`1."
  +            let result = World.setOmniScreenOpt value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setOmniScreenOpt' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getOmniScreen world =
  +        let oldWorld = world
  +        try
  +            let result = World.getOmniScreen world
  +            let value = result
  +            let value = let str = scstring value in if Symbol.shouldBeExplicit str then Scripting.String str else Scripting.Keyword str
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getOmniScreen' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setOmniScreen value world =
  +        let oldWorld = world
  +        try
  +            let struct (value, world) =
  +                let context = World.getScriptContext world
  +                match World.evalInternal value world with
  +                | struct (Scripting.String str, world)
  +                | struct (Scripting.Keyword str, world) ->
  +                    let relation = Relation.makeFromString str
  +                    let address = Relation.resolve context.SimulantAddress relation
  +                    struct (Screen address, world)
  +                | struct (Scripting.Violation (_, error, _), _) -> failwith error
  +                | struct (_, _) -> failwith "Relation must be either a String or Keyword."
  +            let result = World.setOmniScreen value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setOmniScreen' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getSelectedScreenOpt world =
  +        let oldWorld = world
  +        try
  +            let result = World.getSelectedScreenOpt world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<FSharpOption<Screen>> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getSelectedScreenOpt' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let constrainEyeBounds2d bounds world =
  +        let oldWorld = world
  +        try
  +            let bounds =
  +                match ScriptingSystem.tryExport typeof<Box2> bounds world with
  +                | Some value -> value :?> Box2
  +                | None -> failwith "Invalid argument type for 'bounds'; expecting a value convertable to Box2."
  +            let result = World.constrainEyeBounds2d bounds world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'constrainEyeBounds2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getSelectedScreen world =
  +        let oldWorld = world
  +        try
  +            let result = World.getSelectedScreen world
  +            let value = result
  +            let value = let str = scstring value in if Symbol.shouldBeExplicit str then Scripting.String str else Scripting.Keyword str
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getSelectedScreen' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let setSelectedScreen value world =
  +        let oldWorld = world
  +        try
  +            let struct (value, world) =
  +                let context = World.getScriptContext world
  +                match World.evalInternal value world with
  +                | struct (Scripting.String str, world)
  +                | struct (Scripting.Keyword str, world) ->
  +                    let relation = Relation.makeFromString str
  +                    let address = Relation.resolve context.SimulantAddress relation
  +                    struct (Screen address, world)
  +                | struct (Scripting.Violation (_, error, _), _) -> failwith error
  +                | struct (_, _) -> failwith "Relation must be either a String or Keyword."
  +            let result = World.setSelectedScreen value world
  +            struct (Scripting.Unit, result)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setSelectedScreen' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getViewBoundsRelative2d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getViewBoundsRelative2d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Box2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getViewBoundsRelative2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getViewBoundsAbsolute2d world =
  +        let oldWorld = world
  +        try
  +            let result = World.getViewBoundsAbsolute2d world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Box2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getViewBoundsAbsolute2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let getViewBounds2d absolute world =
  +        let oldWorld = world
  +        try
  +            let absolute =
  +                match ScriptingSystem.tryExport typeof<Boolean> absolute world with
  +                | Some value -> value :?> Boolean
  +                | None -> failwith "Invalid argument type for 'absolute'; expecting a value convertable to Boolean."
  +            let result = World.getViewBounds2d absolute world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Box2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getViewBounds2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let isBoundsInView2d absolute bounds world =
  +        let oldWorld = world
  +        try
  +            let absolute =
  +                match ScriptingSystem.tryExport typeof<Boolean> absolute world with
  +                | Some value -> value :?> Boolean
  +                | None -> failwith "Invalid argument type for 'absolute'; expecting a value convertable to Boolean."
  +            let bounds =
  +                match ScriptingSystem.tryExport typeof<Box2> bounds world with
  +                | Some value -> value :?> Box2
  +                | None -> failwith "Invalid argument type for 'bounds'; expecting a value convertable to Box2."
  +            let result = World.isBoundsInView2d absolute bounds world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Boolean> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'isBoundsInView2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let mouseToScreen2d mousePosition world =
  +        let oldWorld = world
  +        try
  +            let mousePosition =
  +                match ScriptingSystem.tryExport typeof<Vector2> mousePosition world with
  +                | Some value -> value :?> Vector2
  +                | None -> failwith "Invalid argument type for 'mousePosition'; expecting a value convertable to Vector2."
  +            let result = World.mouseToScreen2d mousePosition world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'mouseToScreen2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let mouseToWorld2d absolute mousePosition world =
  +        let oldWorld = world
  +        try
  +            let absolute =
  +                match ScriptingSystem.tryExport typeof<Boolean> absolute world with
  +                | Some value -> value :?> Boolean
  +                | None -> failwith "Invalid argument type for 'absolute'; expecting a value convertable to Boolean."
  +            let mousePosition =
  +                match ScriptingSystem.tryExport typeof<Vector2> mousePosition world with
  +                | Some value -> value :?> Vector2
  +                | None -> failwith "Invalid argument type for 'mousePosition'; expecting a value convertable to Vector2."
  +            let result = World.mouseToWorld2d absolute mousePosition world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'mouseToWorld2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
  +    let mouseToEntity2d absolute entityPosition mousePosition world =
  +        let oldWorld = world
  +        try
  +            let absolute =
  +                match ScriptingSystem.tryExport typeof<Boolean> absolute world with
  +                | Some value -> value :?> Boolean
  +                | None -> failwith "Invalid argument type for 'absolute'; expecting a value convertable to Boolean."
  +            let entityPosition =
  +                match ScriptingSystem.tryExport typeof<Vector2> entityPosition world with
  +                | Some value -> value :?> Vector2
  +                | None -> failwith "Invalid argument type for 'entityPosition'; expecting a value convertable to Vector2."
  +            let mousePosition =
  +                match ScriptingSystem.tryExport typeof<Vector2> mousePosition world with
  +                | Some value -> value :?> Vector2
  +                | None -> failwith "Invalid argument type for 'mousePosition'; expecting a value convertable to Vector2."
  +            let result = World.mouseToEntity2d absolute entityPosition mousePosition world
  +            let value = result
  +            let value = ScriptingSystem.tryImport typeof<Vector2> value world |> Option.get
  +            struct (value, world)
  +        with exn ->
  +            let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'mouseToEntity2d' due to: " + scstring exn, None)
  +            struct (violation, World.choose oldWorld)
  +
       let getImperative world =
           let oldWorld = world
           try
  
positive.code:                 struct (violation, world)
          | Some violation -> struct (violation, world)
  
      let evalIsKeyboardKeyDownBinding fnName exprs originOpt world =
          let struct (evaleds, world) = World.evalManyInternal exprs world
          match Array.tryFind (function Scripting.Violation _ -> true | _ -> false) evaleds with
  
negative.code:             let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'reloadAudioAssets' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let hintRenderPackageUse2d packageName world =
          let oldWorld = world
          try
              let packageName =
                  match ScriptingSystem.tryExport typeof<String> packageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'packageName'; expecting a value convertable to String."
              let result = World.hintRenderPackageUse2d packageName world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'hintRenderPackageUse2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let hintRenderPackageDisuse2d packageName world =
          let oldWorld = world
          try
              let packageName =
                  match ScriptingSystem.tryExport typeof<String> packageName world with
                  | Some value -> value :?> String
                  | None -> failwith "Invalid argument type for 'packageName'; expecting a value convertable to String."
              let result = World.hintRenderPackageDisuse2d packageName world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'hintRenderPackageDisuse2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let reloadRenderAssets2d world =
          let oldWorld = world
          try
              let result = World.reloadRenderAssets2d world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'reloadRenderAssets2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let localizeBodyShape extent bodyShape world =
          let oldWorld = world
          try
              let extent =
                  match ScriptingSystem.tryExport typeof<Vector3> extent world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'extent'; expecting a value convertable to Vector3."
              let bodyShape =
                  match ScriptingSystem.tryExport typeof<BodyShape> bodyShape world with
                  | Some value -> value :?> BodyShape
                  | None -> failwith "Invalid argument type for 'bodyShape'; expecting a value convertable to BodyShape."
              let result = World.localizeBodyShape extent bodyShape world
              let value = result
              let value = ScriptingSystem.tryImport typeof<BodyShape> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'localizeBodyShape' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let bodyExists2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.bodyExists2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Boolean> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'bodyExists2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let getBodyContactNormals2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.getBodyContactNormals2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<FSharpList<Vector3>> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getBodyContactNormals2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let getBodyLinearVelocity2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.getBodyLinearVelocity2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Vector3> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getBodyLinearVelocity2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let getBodyToGroundContactNormals2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.getBodyToGroundContactNormals2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<FSharpList<Vector3>> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getBodyToGroundContactNormals2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let getBodyToGroundContactNormalOpt2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.getBodyToGroundContactNormalOpt2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<FSharpOption<Vector3>> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getBodyToGroundContactNormalOpt2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let getBodyToGroundContactTangentOpt2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.getBodyToGroundContactTangentOpt2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<FSharpOption<Vector3>> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'getBodyToGroundContactTangentOpt2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let isBodyOnGround2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.isBodyOnGround2d physicsId world
              let value = result
              let value = ScriptingSystem.tryImport typeof<Boolean> value world |> Option.get
              struct (value, world)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'isBodyOnGround2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let createBody2d entity entityId bodyProperties world =
          let oldWorld = world
          try
              let struct (entity, world) =
                  let context = World.getScriptContext world
                  match World.evalInternal entity world with
                  | struct (Scripting.String str, world)
                  | struct (Scripting.Keyword str, world) ->
                      let relation = Relation.makeFromString str
                      let address = Relation.resolve context.SimulantAddress relation
                      struct (Entity address, world)
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let entityId =
                  match ScriptingSystem.tryExport typeof<Guid> entityId world with
                  | Some value -> value :?> Guid
                  | None -> failwith "Invalid argument type for 'entityId'; expecting a value convertable to Guid."
              let bodyProperties =
                  match ScriptingSystem.tryExport typeof<BodyProperties> bodyProperties world with
                  | Some value -> value :?> BodyProperties
                  | None -> failwith "Invalid argument type for 'bodyProperties'; expecting a value convertable to BodyProperties."
              let result = World.createBody2d entity entityId bodyProperties world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'createBody2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let createBodies2d entity entityId bodiesProperties world =
          let oldWorld = world
          try
              let struct (entity, world) =
                  let context = World.getScriptContext world
                  match World.evalInternal entity world with
                  | struct (Scripting.String str, world)
                  | struct (Scripting.Keyword str, world) ->
                      let relation = Relation.makeFromString str
                      let address = Relation.resolve context.SimulantAddress relation
                      struct (Entity address, world)
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let entityId =
                  match ScriptingSystem.tryExport typeof<Guid> entityId world with
                  | Some value -> value :?> Guid
                  | None -> failwith "Invalid argument type for 'entityId'; expecting a value convertable to Guid."
              let struct (bodiesProperties, world) =
                  match World.evalInternal bodiesProperties world with
                  | struct (Scripting.List list, world) ->
                      Seq.fold (fun struct (values, world) value ->
                          let value =
                              match ScriptingSystem.tryExport typeof<BodyProperties> value world with
                              | Some value -> value :?> BodyProperties
                              | None -> failwith "Invalid argument type for 'bodiesProperties'; expecting a value convertable to BodyProperties."
                          struct (value :: values, world))
                          struct ([], world)
                          list
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let result = World.createBodies2d entity entityId bodiesProperties world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'createBodies2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let destroyBody2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.destroyBody2d physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'destroyBody2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let destroyBodies2d physicsIds world =
          let oldWorld = world
          try
              let struct (physicsIds, world) =
                  match World.evalInternal physicsIds world with
                  | struct (Scripting.List list, world) ->
                      Seq.fold (fun struct (values, world) value ->
                          let value =
                              match ScriptingSystem.tryExport typeof<PhysicsId> value world with
                              | Some value -> value :?> PhysicsId
                              | None -> failwith "Invalid argument type for 'physicsIds'; expecting a value convertable to PhysicsId."
                          struct (value :: values, world))
                          struct ([], world)
                          list
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let result = World.destroyBodies2d physicsIds world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'destroyBodies2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let createJoint2d entity entityId jointProperties world =
          let oldWorld = world
          try
              let struct (entity, world) =
                  let context = World.getScriptContext world
                  match World.evalInternal entity world with
                  | struct (Scripting.String str, world)
                  | struct (Scripting.Keyword str, world) ->
                      let relation = Relation.makeFromString str
                      let address = Relation.resolve context.SimulantAddress relation
                      struct (Entity address, world)
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let entityId =
                  match ScriptingSystem.tryExport typeof<Guid> entityId world with
                  | Some value -> value :?> Guid
                  | None -> failwith "Invalid argument type for 'entityId'; expecting a value convertable to Guid."
              let jointProperties =
                  match ScriptingSystem.tryExport typeof<JointProperties> jointProperties world with
                  | Some value -> value :?> JointProperties
                  | None -> failwith "Invalid argument type for 'jointProperties'; expecting a value convertable to JointProperties."
              let result = World.createJoint2d entity entityId jointProperties world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'createJoint2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let createJoints2d entity entityId jointsProperties world =
          let oldWorld = world
          try
              let struct (entity, world) =
                  let context = World.getScriptContext world
                  match World.evalInternal entity world with
                  | struct (Scripting.String str, world)
                  | struct (Scripting.Keyword str, world) ->
                      let relation = Relation.makeFromString str
                      let address = Relation.resolve context.SimulantAddress relation
                      struct (Entity address, world)
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let entityId =
                  match ScriptingSystem.tryExport typeof<Guid> entityId world with
                  | Some value -> value :?> Guid
                  | None -> failwith "Invalid argument type for 'entityId'; expecting a value convertable to Guid."
              let struct (jointsProperties, world) =
                  match World.evalInternal jointsProperties world with
                  | struct (Scripting.List list, world) ->
                      Seq.fold (fun struct (values, world) value ->
                          let value =
                              match ScriptingSystem.tryExport typeof<JointProperties> value world with
                              | Some value -> value :?> JointProperties
                              | None -> failwith "Invalid argument type for 'jointsProperties'; expecting a value convertable to JointProperties."
                          struct (value :: values, world))
                          struct ([], world)
                          list
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let result = World.createJoints2d entity entityId jointsProperties world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'createJoints2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let destroyJoint2d physicsId world =
          let oldWorld = world
          try
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.destroyJoint2d physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'destroyJoint2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let destroyJoints2d physicsIds world =
          let oldWorld = world
          try
              let struct (physicsIds, world) =
                  match World.evalInternal physicsIds world with
                  | struct (Scripting.List list, world) ->
                      Seq.fold (fun struct (values, world) value ->
                          let value =
                              match ScriptingSystem.tryExport typeof<PhysicsId> value world with
                              | Some value -> value :?> PhysicsId
                              | None -> failwith "Invalid argument type for 'physicsIds'; expecting a value convertable to PhysicsId."
                          struct (value :: values, world))
                          struct ([], world)
                          list
                  | struct (Scripting.Violation (_, error, _), _) -> failwith error
                  | struct (_, _) -> failwith "Relation must be either a String or Keyword."
              let result = World.destroyJoints2d physicsIds world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'destroyJoints2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let setBodyEnabled2d enabled physicsId world =
          let oldWorld = world
          try
              let enabled =
                  match ScriptingSystem.tryExport typeof<Boolean> enabled world with
                  | Some value -> value :?> Boolean
                  | None -> failwith "Invalid argument type for 'enabled'; expecting a value convertable to Boolean."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.setBodyEnabled2d enabled physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setBodyEnabled2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let setBodyPosition2d position physicsId world =
          let oldWorld = world
          try
              let position =
                  match ScriptingSystem.tryExport typeof<Vector3> position world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'position'; expecting a value convertable to Vector3."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.setBodyPosition2d position physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setBodyPosition2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let setBodyRotation rotation physicsId world =
          let oldWorld = world
          try
              let rotation =
                  match ScriptingSystem.tryExport typeof<Quaternion> rotation world with
                  | Some value -> value :?> Quaternion
                  | None -> failwith "Invalid argument type for 'rotation'; expecting a value convertable to Quaternion."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.setBodyRotation rotation physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setBodyRotation' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let setBodyLinearVelocity2d linearVelocity physicsId world =
          let oldWorld = world
          try
              let linearVelocity =
                  match ScriptingSystem.tryExport typeof<Vector3> linearVelocity world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'linearVelocity'; expecting a value convertable to Vector3."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.setBodyLinearVelocity2d linearVelocity physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setBodyLinearVelocity2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let applyBodyLinearImpulse2d linearImpulse physicsId world =
          let oldWorld = world
          try
              let linearImpulse =
                  match ScriptingSystem.tryExport typeof<Vector3> linearImpulse world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'linearImpulse'; expecting a value convertable to Vector3."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.applyBodyLinearImpulse2d linearImpulse physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'applyBodyLinearImpulse2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let setBodyAngularVelocity2d angularVelocity physicsId world =
          let oldWorld = world
          try
              let angularVelocity =
                  match ScriptingSystem.tryExport typeof<Vector3> angularVelocity world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'angularVelocity'; expecting a value convertable to Vector3."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.setBodyAngularVelocity2d angularVelocity physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'setBodyAngularVelocity2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let applyBodyAngularImpulse2d angularImpulse physicsId world =
          let oldWorld = world
          try
              let angularImpulse =
                  match ScriptingSystem.tryExport typeof<Vector3> angularImpulse world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'angularImpulse'; expecting a value convertable to Vector3."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.applyBodyAngularImpulse2d angularImpulse physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'applyBodyAngularImpulse2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let applyBodyForce2d force physicsId world =
          let oldWorld = world
          try
              let force =
                  match ScriptingSystem.tryExport typeof<Vector3> force world with
                  | Some value -> value :?> Vector3
                  | None -> failwith "Invalid argument type for 'force'; expecting a value convertable to Vector3."
              let physicsId =
                  match ScriptingSystem.tryExport typeof<PhysicsId> physicsId world with
                  | Some value -> value :?> PhysicsId
                  | None -> failwith "Invalid argument type for 'physicsId'; expecting a value convertable to PhysicsId."
              let result = World.applyBodyForce2d force physicsId world
              struct (Scripting.Unit, result)
          with exn ->
              let violation = Scripting.Violation (["InvalidBindingInvocation"], "Could not invoke binding 'applyBodyForce2d' due to: " + scstring exn, None)
              struct (violation, World.choose oldWorld)
  
      let isMouseButtonDown mouseButton world =
          let oldWorld = world
          try
  