/JSIL.Libraries/Sources/XNA/XNA4.js

Large files files are truncated, but you can click here to view the full file

"use strict";

if (typeof (JSIL) === "undefined") throw new Error("JSIL.Core required");

var $drawDebugRects = false, $drawDebugBoxes = false;
var $useTextCaching = true, $textCachingSupported = true;

var $jsilxna = JSIL.DeclareAssembly("JSIL.XNA");

JSIL.DeclareNamespace("JSIL");

$jsilxna.allowWebGL = true;
$jsilxna.testedWebGL = false;
$jsilxna.workingWebGL = false;

var $xnaasms = new JSIL.AssemblyCollection({
  corlib: "mscorlib",
  xna: "Microsoft.Xna.Framework",
  xnaGraphics: "Microsoft.Xna.Framework.Graphics",
  xnaGame: "Microsoft.Xna.Framework.Game",
  xnaStorage: "Microsoft.Xna.Framework.Storage",
  0: "Microsoft.Xna.Framework", 
  1: "Microsoft.Xna.Framework.Game", 
  2: "Microsoft.Xna.Framework.GamerServices", 
  4: "Microsoft.Xna.Framework.Input.Touch, Version=4.0.0.0, Culture=neutral, PublicKeyToken=842cf8be1de50553", 
  5: "mscorlib",
  11: "System.Drawing", 
  15: "System.Windows.Forms", 
  18: "Microsoft.Xna.Framework.Xact",
});

var getXnaGraphics = function () {
  return $xnaasms.xnaGraphics || $xnaasms.xna;
};

var getXnaStorage = function () {
  return $xnaasms.xnaStorage || $xnaasms.xna;
};

$jsilxna.colorRef = function () {
  var graphicsAsm = JSIL.GetAssembly("Microsoft.Xna.Framework.Graphics", true);
  if (graphicsAsm !== null)
    return $xnaasms.xna.TypeRef("Microsoft.Xna.Framework.Color");
  else 
    return $xnaasms.xna.TypeRef("Microsoft.Xna.Framework.Graphics.Color");
};

$jsilxna.graphicsRef = function (name) {
  var graphicsAsm = JSIL.GetAssembly("Microsoft.Xna.Framework.Graphics", true);
  if (graphicsAsm !== null)
    return graphicsAsm.TypeRef(name);
  else 
    return $xnaasms.xna.TypeRef(name);
};

JSIL.MakeClass($jsilcore.System.Object, "HTML5Asset", true, [], function ($) {
  $.RawMethod(false, ".ctor", function (assetName) {
    this.name = assetName;
  });

  $.RawMethod(false, "toString", function () {
    return "<XNA Asset '" + this.name + "'>";
  });
});

JSIL.MakeClass("HTML5Asset", "HTML5ImageAsset", true, [], function ($) {
  $.RawMethod(false, ".ctor", function (assetName, image) {
    HTML5Asset.prototype._ctor.call(this, assetName);
    image.assetName = assetName;

    this.image = image;
  });
  
  $.RawMethod(false, "ReadAsset",
    function HTML5ImageAsset_ReadAsset (type) {
      var tTexture = Microsoft.Xna.Framework.Graphics.Texture2D.__Type__;
      return JSIL.CreateInstanceOfType(tTexture, "$fromImage", [null, this.image]);
    }
  );
});

JSIL.MakeClass("HTML5Asset", "SoundAssetBase", true, [], function ($) {

  $.Method({Static:false, Public:true }, "Play", 
    (new JSIL.MethodSignature($.Boolean, [], [])), 
    function Play () {
      return this.Play(1, 0, 0);
    }
  );

  $.Method({Static:false, Public:true }, "Play", 
    (new JSIL.MethodSignature($.Boolean, [$.Single, $.Single, $.Single], [])), 
    function Play (volume, pitch, pan) {
      var instance = this.$newInstance();

      instance.set_volume(volume);
      instance.set_pan(pan);
      instance.set_pitch(pitch);

      instance.play();

      return true;
    }
  );

  $.Method({Static:false, Public:true }, "CreateInstance",
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Audio.SoundEffectInstance"), [], [])),
    function CreateInstance () {
      return new Microsoft.Xna.Framework.Audio.SoundEffectInstance(this, false);
    }
  );

});

JSIL.MakeClass("SoundAssetBase", "CallbackSoundAsset", true, [], function ($) {
  $.RawMethod(false, ".ctor", function (assetName, createInstance) {
    HTML5Asset.prototype._ctor.call(this, assetName);

    this.$createInstance = createInstance;
    this.freeInstances = [];
  });

  $.RawMethod(false, "$newInstance", function () {
    if (this.freeInstances.length > 0) {
      return this.freeInstances.pop();
    } else {
      return this.$createInstance(0);
    }
  });
});

JSIL.MakeClass("HTML5Asset", "RawXNBAsset", true, [], function ($) {
  var $NewCr = function () {
    return ($NewCr = JSIL.Memoize(
      new JSIL.ConstructorSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Content.ContentReader"), [
        $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Content.ContentManager"), $xnaasms[5].TypeRef("System.IO.Stream"), 
        $.String, $xnaasms[5].TypeRef("System.Action`1", [$xnaasms[5].TypeRef("System.IDisposable")]), 
        $.Int32
      ])
    )) ();
  };

  $.Method({
    Static: false,
    Public: true
  }, ".ctor", JSIL.MethodSignature.Void, function (assetName, rawBytes) {
    if (JSIL.GetAssembly("JSIL.IO", true) === null) {
      throw new Error("JSIL.IO is required");
    }

    HTML5Asset.prototype._ctor.call(this, assetName);
    this.bytes = rawBytes;
    this.contentManager = null;
  });

  $.Method({
    Static: false,
    Public: true
  }, "ReadAsset", JSIL.MethodSignature.Void, function RawXNBAsset_ReadAsset (type) {
    if (!type)
      throw new Error("ReadAsset must be provided a type object");

    var memoryStream = new System.IO.MemoryStream(this.bytes, false);

    var contentReader = $NewCr().Construct(
      this.contentManager, memoryStream, this.name, null, 0
    );

    contentReader.ReadHeader();

    var sharedResourceCount = contentReader.Read7BitEncodedInt();
    var sharedResources = new Array(sharedResourceCount);

    var mainObject = contentReader.ReadObject$b1(type)();

    for (var i = 0; i < sharedResourceCount; i++)
      sharedResources[i] = content.ReadObject$b1(System.Object)();

    return mainObject;
  });
});

JSIL.MakeClass("RawXNBAsset", "SpriteFontAsset", true, [], function ($) {
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", JSIL.MethodSignature.Void, function (assetName, rawBytes) {
    RawXNBAsset.prototype._ctor.call(this, assetName, rawBytes);
  });
});

JSIL.MakeClass("RawXNBAsset", "Texture2DAsset", true, [], function ($) {
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", JSIL.MethodSignature.Void, function (assetName, rawBytes) {
    RawXNBAsset.prototype._ctor.call(this, assetName, rawBytes);
  });
});

var vectorUtil = {
  makeOperatorCore: function (name, tVector, body, argCount, leftScalar, rightScalar) {
    var js = body.join("\r\n");

    var typeName = String(tVector.typeName);
    var suffixedName;

    if (argCount < 1) {
      suffixedName = name;
    } else {
      suffixedName = name + "[";
      if (argCount == 1) {
        suffixedName += (leftScalar ? "float" : "vec");
      } else if (argCount == 2) {
        suffixedName += (leftScalar ? "float" : "vec") + "," +
          (rightScalar ? "float" : "vec");
      }
      suffixedName += "]";
    }

    var functionName = typeName + "." + suffixedName;

    switch (argCount) {
      case 0:
        return JSIL.CreateNamedFunction(
          functionName,
          [],
          js
        );
      case 1:
        return JSIL.CreateNamedFunction(
          functionName,
          ["value"],
          js
        );
      case 2:
        return JSIL.CreateNamedFunction(
          functionName,
          ["lhs", "rhs"],
          js
        );
      case 3:
        return JSIL.CreateNamedFunction(
          functionName,
          ["lhs", "rhs", "amount"],
          js
        );      
      default:
        throw new Error("Invalid argument count");
    }
  },

  bindToPrototype: function (fn, typeRef, dataMembers) {
    var state = {
      resolvedType: null,
      typeRef: typeRef
    };

    JSIL.SetLazyValueProperty(
      state, "$instance", 
      function VectorMethod_GetCreator () {
        if (state.resolvedType === null)
          state.resolvedType = state.typeRef.get();

        var creatorBody = "";
        for (var i = 0; i < dataMembers.length; i++)
          creatorBody += "this." + dataMembers[i] + " = " + dataMembers[i] + ";\r\n";

        var creator = JSIL.CreateNamedFunction(state.resolvedType.__Type__.__FullName__, dataMembers, creatorBody, null);
        creator.prototype = state.resolvedType.prototype;
        return creator;
      }
    );

    return fn.bind(state);
  },

  makeArithmeticOperator: function ($, name, staticMethodName, operator, dataMembers, tLeft, tRight, tResult) {
    var leftScalar = (tLeft !== tResult);
    var rightScalar = (tRight !== tResult);

    if (leftScalar && rightScalar)
      throw new Error("Invalid type combination");

    var body = [];
    body.push("return new this.$instance(");

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];
      var line = "+(";

      if (leftScalar)
        line += "lhs ";
      else
        line += "lhs." + dataMember + " ";

      line += operator;

      if (rightScalar)
        line += " rhs";
      else
        line += " rhs." + dataMember + "";

      line += ")";

      if (i < (dataMembers.length - 1))
        line += ",";

      body.push(line);
    }

    body.push(");")

    var fn = vectorUtil.makeOperatorCore(name, tResult, body, 2, leftScalar, rightScalar);
    fn = vectorUtil.bindToPrototype(fn, tResult, dataMembers);

    $.Method({Static: true , Public: true }, name, 
      new JSIL.MethodSignature(tResult, [tLeft, tRight], []),
      fn
    );

    $.Method({Static: true , Public: true }, staticMethodName, 
      new JSIL.MethodSignature(tResult, [tLeft, tRight], []),
      fn
    );

    var makeRef = function (t) {
      return $jsilcore.TypeRef("JSIL.Reference", [t]);
    };

    var wrapper;

    if (leftScalar) {
      wrapper = function VectorOperator_Scalar_Ref (lhs, rhs, result) {
        result.set(fn(lhs, rhs.get()));
      }
    } else if (rightScalar) {
      wrapper = function VectorOperator_Ref_Scalar (lhs, rhs, result) {
        result.set(fn(lhs.get(), rhs));
      }
    } else {
      wrapper = function VectorOperator_Ref_Ref (lhs, rhs, result) {
        result.set(fn(lhs.get(), rhs.get()));
      }
    }

    $.Method({Static: true , Public: true }, staticMethodName,
      new JSIL.MethodSignature(null, [
        leftScalar ? tLeft : makeRef(tLeft), 
        rightScalar ? tRight : makeRef(tRight), 
        makeRef(tResult)
      ], []),
      wrapper
    );
  },

  makeLogicOperator: function ($, name, operator, bindingOperator, dataMembers, tVector) {
    var body = [];
    body.push("return (");

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];
      var line = "  (lhs." + dataMember + " ";

      line += operator;

      line += " rhs." + dataMember + ") ";

      if (i < dataMembers.length - 1)
        line += bindingOperator;

      body.push(line);
    }

    body.push(");")

    var fn = vectorUtil.makeOperatorCore(name, tVector, body, 2, false, false);

    $.Method({Static: true , Public: true }, name, 
      new JSIL.MethodSignature($.Boolean, [tVector, tVector], []),
      fn
    );
  },

  makeNegationOperator: function ($, dataMembers, tVector) {
    var body = [];
    body.push("return new this.$instance(");

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];
      var line = "-value." + dataMember;

      if (i < (dataMembers.length - 1))
        line += ",";

      body.push(line);
    }

    body.push(");");

    var fn = vectorUtil.makeOperatorCore("op_UnaryNegation", tVector, body, 1, false, false);
    fn = vectorUtil.bindToPrototype(fn, tVector, dataMembers);

    $.Method({Static: true , Public: true }, "op_UnaryNegation", 
      new JSIL.MethodSignature(tVector, [tVector], []),
      fn
    );
  },

  makeLengthGetter: function ($, name, isSquared, dataMembers, tVector) {
    var body = [];
    body.push("return " + (isSquared ? "(" : "Math.sqrt("));

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];
      var line = "  (this." + dataMember + " * this." + dataMember + ")";
      if (i < dataMembers.length - 1)
        line += " + ";
      body.push(line);
    }

    body.push(");");

    var fn = vectorUtil.makeOperatorCore(name, tVector, body, 0);

    $.Method({Static: false, Public: true }, name, 
      new JSIL.MethodSignature($.Single, [], []),
      fn
    );
  },

  makeDistanceFunction: function ($, name, isSquared, dataMembers, tVector) {
    var body = [];
    body.push("var result = +0.0, current;");

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];

      body.push("current = +(rhs." + dataMember + " - lhs." + dataMember + ");");
      body.push("result += (current * current);");
    }

    if (isSquared)
      body.push("return result;");
    else
      body.push("return Math.sqrt(result);");

    var fn = vectorUtil.makeOperatorCore(name, tVector, body, 2);

    $.Method({Static: true, Public: true }, name, 
      new JSIL.MethodSignature($.Single, [tVector, tVector], []),
      fn
    );
  },

  makeNormalizer: function ($, dataMembers, tVector) {
    var body = [];
    body.push("var factor = +1.0 / this.Length();");

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];
      var line = "this." + dataMember + " *= factor;";
      body.push(line);
    }

    var fn = vectorUtil.makeOperatorCore("Normalize", tVector, body, 0);

    $.Method({Static: false, Public: true }, "Normalize", 
      JSIL.MethodSignature.Void,
      fn
    );

    $.Method({Static: true , Public: true }, "Normalize",
      new JSIL.MethodSignature(tVector, [tVector], []),
      function Normalize_Static (v) {
        var result = v.MemberwiseClone();
        fn.call(result);
        return result;
      }
    );
  },

  makeLengthMethods: function ($, dataMembers, tVector) {
    vectorUtil.makeLengthGetter($, "LengthSquared", true, dataMembers, tVector);
    vectorUtil.makeLengthGetter($, "Length", false, dataMembers, tVector);

    vectorUtil.makeDistanceFunction($, "DistanceSquared", true, dataMembers, tVector);
    vectorUtil.makeDistanceFunction($, "Distance", false, dataMembers, tVector);

    vectorUtil.makeNormalizer($, dataMembers, tVector);
  },

  makeLerpMethod: function ($, dataMembers, tVector) {
    var name = "Lerp";
    var body = [];
    body.push("var result = lhs.MemberwiseClone();");

    for (var i = 0; i < dataMembers.length; i++) {
      var dataMember = dataMembers[i];

      body.push("result." + dataMember + " += (rhs." + dataMember + " - lhs." + dataMember + ") * amount;");
    }

    body.push("return result;");

    var fn = vectorUtil.makeOperatorCore(name, tVector, body, 3);

    $.Method({Static: true, Public: true }, name, 
      new JSIL.MethodSignature(tVector, [tVector, tVector, $.Single], []),
      fn
    );
  },

  makeOperators: function ($, dataMembers, tVector) {
    var operators = [
      ["op_Addition", "+", false, "Add"],
      ["op_Subtraction", "-", false, "Subtract"],
      ["op_Division", "/", true, "Divide"],
      ["op_Multiply", "*", true, "Multiply"]
    ];

    for (var i = 0; i < operators.length; i++) {
      var name = operators[i][0];
      var operator = operators[i][1];
      var withScalar = operators[i][2];
      var staticMethodName = operators[i][3];

      vectorUtil.makeArithmeticOperator($, name, staticMethodName, operator, dataMembers, tVector, tVector, tVector);

      if (withScalar) {
        var nameSuffixed = name + "Scalar";
        var staticMethodNameSuffixed = staticMethodName + "Scalar";
        vectorUtil.makeArithmeticOperator($, nameSuffixed, staticMethodNameSuffixed, operator, dataMembers, tVector, $.Single, tVector);

        var nameSuffixed2 = nameSuffixed + "Left";
        var staticMethodNameSuffixed2 = staticMethodNameSuffixed + "Left";
        vectorUtil.makeArithmeticOperator($, nameSuffixed2, staticMethodNameSuffixed2, operator, dataMembers, $.Single, tVector, tVector);
      }
    }

    vectorUtil.makeNegationOperator($, dataMembers, tVector);

    vectorUtil.makeLogicOperator($, "op_Equality", "===", "&&", dataMembers, tVector);
    vectorUtil.makeLogicOperator($, "op_Inequality", "!==", "||", dataMembers, tVector);

    vectorUtil.makeLengthMethods($, dataMembers, tVector);

    vectorUtil.makeLerpMethod($, dataMembers, tVector);
  },

  makeConstants: function ($, tVector, constants) {
    var makeGetter = function (values) {
      var state = null;

      return function () {
        if (state === null)
          state = JSIL.CreateInstanceOfType(
            tVector.get().__Type__, "_ctor", values
          );

        return state;
      }
    };

    for (var k in constants) {
      var values = constants[k];
      var getter = makeGetter(values);

      $.Method({Static: true , Public: true}, "get_" + k,
        new JSIL.MethodSignature(tVector, [], []),
        getter
      );
    }
  }
};

JSIL.ImplementExternals("Microsoft.Xna.Framework.Vector2", function ($) {
  vectorUtil.makeConstants(
    $, $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), {
      "UnitX": [1, 0],
      "UnitY": [0, 1],
      "Zero": [0, 0],
      "One": [1, 1]
    }
  );

  vectorUtil.makeOperators(
    $, ["X", "Y"], $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2")
  );

  $.RawMethod(false, "toString", function () {
     return "{X:" + this.X + " Y:" + this.Y + "}";
  });

  $.Method({Static:true , Public:true }, "Clamp", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), [
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"),
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), 
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2")
        ], [])), 
    function Clamp (value, min, max) {
      var result = JSIL.CreateInstanceObject(Microsoft.Xna.Framework.Vector2.prototype);
      result.X = Microsoft.Xna.Framework.MathHelper.Clamp(value.X, min.X, max.X);
      result.Y = Microsoft.Xna.Framework.MathHelper.Clamp(value.Y, min.Y, max.Y);
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "Transform", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")], [])), 
    function Transform (position, matrix) {
      var result = JSIL.CreateInstanceObject(Microsoft.Xna.Framework.Vector2.prototype);
      result.X = (position.X * matrix.xScale) + matrix.xTranslation;
      result.Y = (position.Y * matrix.yScale) + matrix.yTranslation;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "Dot", 
    (new JSIL.MethodSignature($.Single, [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2")], [])), 
    function Dot (vector1, vector2) {
      return vector1.X * vector2.X + vector1.Y * vector2.Y;
    }
  );

  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$.Single, $.Single], []), function Vector2_ctor (x, y) {
    this.X = +x;
    this.Y = +y;
  });
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$.Single], []), function Vector2_ctor (value) {
    this.X = this.Y = +value;
  });
});

JSIL.ImplementExternals("Microsoft.Xna.Framework.Vector3", function ($) {
  vectorUtil.makeConstants(
    $, $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), {
      "Backward": [0, 0, 1],
      "Forward": [0, 0, -1],
      "Left": [-1, 0, 0],
      "Right": [1, 0, 0],
      "Up": [0, 1, 0],
      "Down": [0, -1, 0],
      "UnitX": [1, 0, 0],
      "UnitY": [0, 1, 0],
      "UnitZ": [0, 0, 1],
      "Zero": [0, 0, 0],
      "One": [1, 1, 1]
    }
  );

  vectorUtil.makeOperators(
    $, ["X", "Y", "Z"], $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")
  );

  $.RawMethod(false, "toString", function () {
     return "{X:" + this.X + " Y:" + this.Y + " Z:" + this.Z + "}";
  });

  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$.Single, $.Single, $.Single], []), function Vector3_ctor (x, y, z) {
    this.X = +x;
    this.Y = +y;
    this.Z = +z;
  });
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$.Single], []), function Vector3_ctor (value) {
    this.X = this.Y = this.Z = +value;
  });
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), $.Single], []), function Vector3_ctor (xy, z) {
    this.X = +xy.X;
    this.Y = +xy.Y;
    this.Z = +z;
  });

  $.Method({Static:true , Public:true }, "Clamp", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), [
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"),
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), 
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")
        ], [])), 
    function Clamp (value, min, max) {
      var result = JSIL.CreateInstanceObject(Microsoft.Xna.Framework.Vector3.prototype);
      result.X = Microsoft.Xna.Framework.MathHelper.Clamp(value.X, min.X, max.X);
      result.Y = Microsoft.Xna.Framework.MathHelper.Clamp(value.Y, min.Y, max.Y);
      result.Z = Microsoft.Xna.Framework.MathHelper.Clamp(value.Z, min.Z, max.Z);
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "Transform", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")], [])), 
    function Transform (position, matrix) {
      var result = JSIL.CreateInstanceObject(Microsoft.Xna.Framework.Vector3.prototype);
      result.X = (position.X * matrix.xScale) + matrix.xTranslation;
      result.Y = (position.Y * matrix.yScale) + matrix.yTranslation;
      result.Z = (position.Z * matrix.zScale) + matrix.zTranslation;
      return result;
    }
  );
});

JSIL.ImplementExternals("Microsoft.Xna.Framework.Vector4", function ($) {
  vectorUtil.makeConstants(
    $, $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4"), {
      "Zero": [0, 0, 0, 0],
      "One": [1, 1, 1, 1]
    }
  );

  vectorUtil.makeOperators(
    $, ["X", "Y", "Z", "W"], $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4")
  );

  $.RawMethod(false, "toString", function () {
     return "{X:" + this.X + " Y:" + this.Y + " Z:" + this.Z + " W: " + this.W + "}";
  });

  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$.Single, $.Single, $.Single, $.Single], []), function Vector4_ctor (x, y, z, w) {
    this.X = +x;
    this.Y = +y;
    this.Z = +z;
    this.W = +w;
  });
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector2"), $.Single, $.Single], []), function Vector4_ctor (xy, z, w) {
    this.X = +xy.X;
    this.Y = +xy.Y;
    this.Z = +z;
    this.W = +w;
  });
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), $.Single], []), function Vector4_ctor (xyz, w) {
    this.X = +xyz.X;
    this.Y = +xyz.Y;
    this.Z = +xyz.Z;
    this.W = +w;
  });
  $.Method({
    Static: false,
    Public: true
  }, ".ctor", new JSIL.MethodSignature(null, [$.Single], []), function Vector4_ctor (value) {
    this.X = this.Y = this.Z = this.W = +value;
  });

  $.Method({Static:true , Public:true }, "Clamp", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4"), [
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4"),
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4"), 
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4")
        ], [])), 
    function Clamp (value, min, max) {
      var result = JSIL.CreateInstanceObject(Microsoft.Xna.Framework.Vector4.prototype);
      result.X = Microsoft.Xna.Framework.MathHelper.Clamp(value.X, min.X, max.X);
      result.Y = Microsoft.Xna.Framework.MathHelper.Clamp(value.Y, min.Y, max.Y);
      result.Z = Microsoft.Xna.Framework.MathHelper.Clamp(value.Z, min.Z, max.Z);
      result.W = Microsoft.Xna.Framework.MathHelper.Clamp(value.W, min.W, max.W);
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "Transform", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector4"), $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")], [])), 
    function Transform (position, matrix) {
      var result = JSIL.CreateInstanceObject(Microsoft.Xna.Framework.Vector4.prototype);
      result.X = (position.X * matrix.xScale) + matrix.xTranslation;
      result.Y = (position.Y * matrix.yScale) + matrix.yTranslation;
      result.Z = (position.Z * matrix.zScale) + matrix.zTranslation;
      result.W = (position.W * matrix.wScale) + matrix.wTranslation;
      return result;
    }
  );
});

JSIL.ImplementExternals("Microsoft.Xna.Framework.Matrix", function ($) {
  var matrix = $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix");

  $.Method({
    Static: true,
    Public: true
  }, ".cctor2", JSIL.MethodSignature.Void, function () {
    // FIXME
    var identity = Microsoft.Xna.Framework.Matrix._identity = new Microsoft.Xna.Framework.Matrix();

    identity.xTranslation = identity.yTranslation = identity.zTranslation = 0;
    identity.xRotation = identity.yRotation = identity.zRotation = 0;
    identity.xScale = identity.yScale = identity.zScale = 1;
  });

  $.RawMethod(false, "__CopyMembers__", 
    function Matrix_CopyMembers (source, target) {
      target.xScale = source.xScale || 0;
      target.yScale = source.yScale || 0;
      target.zScale = source.zScale || 0;
      target.xTranslation = source.xTranslation || 0;
      target.yTranslation = source.yTranslation || 0;
      target.zTranslation = source.zTranslation || 0;
      target.xRotation = source.xRotation || 0;
      target.yRotation = source.yRotation || 0;
      target.zRotation = source.zRotation || 0;
    }
  );

  $.Method({Static:true , Public:true }, "get_Identity", 
    (new JSIL.MethodSignature(matrix, [], [])), 
    function get_Identity () {
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreateLookAt", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3"), 
          $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")
        ], [])), 
    function CreateLookAt (cameraPosition, cameraTarget, cameraUpVector) {
      // FIXME
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreateLookAt", 
    (new JSIL.MethodSignature(null, [
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")]), $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")]), 
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")]), $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")])
        ], [])), 
    function CreateLookAt (/* ref */ cameraPosition, /* ref */ cameraTarget, /* ref */ cameraUpVector, /* ref */ result) {
      // FIXME
      result.set(Microsoft.Xna.Framework.Matrix._identity);
    }
  );

  $.Method({Static:true , Public:true }, "CreateOrthographic", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single, $.Single
        ], [])), 
    function CreateOrthographic (width, height, zNearPlane, zFarPlane) {
      // FIXME
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreateOrthographic", 
    (new JSIL.MethodSignature(null, [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")])
        ], [])), 
    function CreateOrthographic (width, height, zNearPlane, zFarPlane, /* ref */ result) {
      // FIXME
      result.set(Microsoft.Xna.Framework.Matrix._identity);
    }
  );

  $.Method({Static:true , Public:true }, "CreateOrthographicOffCenter", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $.Single, $.Single
        ], [])), 
    function CreateOrthographicOffCenter (left, right, bottom, top, zNearPlane, zFarPlane) {
      // FIXME
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreateOrthographicOffCenter", 
    (new JSIL.MethodSignature(null, [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $.Single, $.Single, 
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")])
        ], [])), 
    function CreateOrthographicOffCenter (left, right, bottom, top, zNearPlane, zFarPlane, /* ref */ result) {
      // FIXME
      result.set(Microsoft.Xna.Framework.Matrix._identity);
    }
  );

  $.Method({Static:true , Public:true }, "CreatePerspective", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single, $.Single
        ], [])), 
    function CreatePerspective (width, height, nearPlaneDistance, farPlaneDistance) {
      // FIXME
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreatePerspective", 
    (new JSIL.MethodSignature(null, [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")])
        ], [])), 
    function CreatePerspective (width, height, nearPlaneDistance, farPlaneDistance, /* ref */ result) {
      // FIXME
      result.set(Microsoft.Xna.Framework.Matrix._identity);
    }
  );

  $.Method({Static:true , Public:true }, "CreatePerspectiveFieldOfView", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single, $.Single
        ], [])), 
    function CreatePerspectiveFieldOfView (fieldOfView, aspectRatio, nearPlaneDistance, farPlaneDistance) {
      // FIXME
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreatePerspectiveFieldOfView", 
    (new JSIL.MethodSignature(null, [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")])
        ], [])), 
    function CreatePerspectiveFieldOfView (fieldOfView, aspectRatio, nearPlaneDistance, farPlaneDistance, /* ref */ result) {
      // FIXME
      result.set(Microsoft.Xna.Framework.Matrix._identity);
    }
  );

  $.Method({Static:true , Public:true }, "CreatePerspectiveOffCenter", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $.Single, $.Single
        ], [])), 
    function CreatePerspectiveOffCenter (left, right, bottom, top, nearPlaneDistance, farPlaneDistance) {
      // FIXME
      return Microsoft.Xna.Framework.Matrix._identity;
    }
  );

  $.Method({Static:true , Public:true }, "CreatePerspectiveOffCenter", 
    (new JSIL.MethodSignature(null, [
          $.Single, $.Single, 
          $.Single, $.Single, 
          $.Single, $.Single, 
          $jsilcore.TypeRef("JSIL.Reference", [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")])
        ], [])), 
    function CreatePerspectiveOffCenter (left, right, bottom, top, nearPlaneDistance, farPlaneDistance, /* ref */ result) {
      // FIXME
      result.set(Microsoft.Xna.Framework.Matrix._identity);
    }
  );

  $.Method({Static:true , Public:true }, "CreateRotationX", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$.Single], [])), 
    function CreateRotationX (radians) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xRotation = radians;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateRotationY", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$.Single], [])), 
    function CreateRotationY (radians) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.yRotation = radians;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateRotationZ", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$.Single], [])), 
    function CreateRotationZ (radians) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.zRotation = radians;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateScale", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")], [])), 
    function CreateScale (scales) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xScale = scales.X;
      result.yScale = scales.Y;
      result.zScale = scales.Z;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateScale", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$.Single], [])), 
    function CreateScale (scale) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xScale = scale;
      result.yScale = scale;
      result.zScale = scale;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateScale", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single
        ], [])), 
    function CreateScale (xScale, yScale, zScale) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xScale = xScale;
      result.yScale = yScale;
      result.zScale = zScale;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateTranslation", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Vector3")], [])), 
    function CreateTranslation (position) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xTranslation = position.X;
      result.yTranslation = position.Y;
      result.zTranslation = position.Z;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "CreateTranslation", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [
          $.Single, $.Single, 
          $.Single
        ], [])), 
    function CreateTranslation (xPosition, yPosition, zPosition) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xTranslation = xPosition;
      result.yTranslation = yPosition;
      result.zTranslation = zPosition;
      return result;
    }
  );

  $.Method({Static:true , Public:true }, "Invert", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")], [])), 
    function Invert (matrix) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xTranslation = -matrix.xTranslation;
      result.yTranslation = -matrix.yTranslation;
      result.zTranslation = -matrix.zTranslation;

      result.xScale = 1 / (matrix.xScale + 0.000001);
      result.yScale = 1 / (matrix.yScale + 0.000001);
      result.zScale = 1 / (matrix.zScale + 0.000001);

      return result;
    }
  );

  $.Method({Static:true , Public:true }, "op_Multiply", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), [$xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix"), $xnaasms[0].TypeRef("Microsoft.Xna.Framework.Matrix")], [])), 
    function Multiply (matrix1, matrix2) {
      // FIXME
      var result = Microsoft.Xna.Framework.Matrix._identity.MemberwiseClone();

      result.xTranslation = matrix1.xTranslation + matrix2.xTranslation;
      result.yTranslation = matrix1.yTranslation + matrix2.yTranslation;
      result.zTranslation = matrix1.zTranslation + matrix2.zTranslation;

      result.xScale = matrix1.xScale * matrix2.xScale;
      result.yScale = matrix1.yScale * matrix2.yScale;
      result.zScale = matrix1.zScale * matrix2.zScale;

      return result;
    }
  );
});

JSIL.ImplementExternals("Microsoft.Xna.Framework.GameComponentCollection", function ($) {
  $.RawMethod(false, "$internalCtor", function (game) {
    this._game = game;

    this._ctor();
  });

  $.RawMethod(false, "$OnItemAdded", function (item) {
    if (this._game.initialized) {
      if (typeof (item.Initialize) === "function")
        item.Initialize();
    }
  });
});

JSIL.ImplementExternals("Microsoft.Xna.Framework.Game", function ($) {
  $.Method({Static: true, Public: true}, "ForceQuit", 
    JSIL.MethodSignature.Void, 
    function () {
      Microsoft.Xna.Framework.Game._QuitForced = true;
    }
  );

  $.Method({Static: true, Public: true}, "ForcePause", 
    JSIL.MethodSignature.Void, 
    function () {
      Microsoft.Xna.Framework.Game._PauseForced = true;
    }
  );

  $.Method({Static: true, Public: true}, "ForceUnpause", 
    JSIL.MethodSignature.Void, 
    function () {
      Microsoft.Xna.Framework.Game._PauseForced = false;

      var ns = Microsoft.Xna.Framework.Game._NeedsStep;
      Microsoft.Xna.Framework.Game._NeedsStep = null;

      if (ns)
        ns._QueueStep();
    }
  );

  $.Method({Static:false, Public:true }, ".ctor", 
    (JSIL.MethodSignature.Void), 
    function _ctor () {
      var tContentManager = JSIL.GetTypeFromAssembly(
        $xnaasms.xna, "Microsoft.Xna.Framework.Content.ContentManager", [], true
      );

      var tGameTime = JSIL.GetTypeFromAssembly(
        $xnaasms.xnaGame, "Microsoft.Xna.Framework.GameTime", [], true
      );

      this.gameServices = new Microsoft.Xna.Framework.GameServiceContainer();
      this.content = JSIL.CreateInstanceOfType(tContentManager, [this.gameServices]);
      this.components = JSIL.CreateInstanceOfType(
        Microsoft.Xna.Framework.GameComponentCollection.__Type__, "$internalCtor", [this]
      );
      this.targetElapsedTime = System.TimeSpan.FromTicks(System.Int64.FromInt32(166667));
      this.isFixedTimeStep = true;
      this.forceElapsedTimeToZero = true;
      this._isDead = false;
      this.initialized = false;

      this._gameTime = JSIL.CreateInstanceOfType(tGameTime, null);
      this._lastFrame = this._nextFrame = this._started = 0;
    }
  );

  $.Method({Static:false, Public:true }, "get_Components", 
    (new JSIL.MethodSignature($xnaasms[1].TypeRef("Microsoft.Xna.Framework.GameComponentCollection"), [], [])), 
    function get_Components () {
      return this.components;
    }
  );

  $.Method({Static:false, Public:true }, "get_Content", 
    (new JSIL.MethodSignature($xnaasms[0].TypeRef("Microsoft.Xna.Framework.Content.ContentManager"), [], [])), 
    function get_Content () {
      return this.content;
    }
  );

  $.Method({Static:false, Public:true }, "get_GraphicsDevice", 
    (new JSIL.MethodSignature($jsilxna.graphicsRef("Microsoft.Xna.Framework.Graphics.GraphicsDevice"), [], [])), 
    function get_GraphicsDevice () {
      return this.graphicsDeviceService.GraphicsDevice;
    }
  );

  $.Method({Static:false, Public:true }, "get_IsActive", 
    (new JSIL.MethodSignature($.Boolean, [], [])), 
    function get_IsActive () {
      return JSIL.Host.isPageVisible() && !Microsoft.Xna.Framework.Game._QuitForced && !this._isDead;
    }
  );

  $.Method({Static:false, Public:true }, "get_IsFixedTimeStep", 
    (new JSIL.MethodSignature($.Boolean, [], [])), 
    function get_IsFixedTimeStep () {
      return this.isFixedTimeStep;
    }
  );

  $.Method({Static:false, Public:true }, "get_TargetElapsedTime", 
    (new JSIL.MethodSignature($xnaasms[5].TypeRef("System.TimeSpan"), [], [])), 
    function get_TargetElapsedTime () {
      return this.targetElapsedTime;
    }
  );

  $.Method({Static:false, Public:true }, "get_Services", 
    (new JSIL.MethodSignature($xnaasms[1].TypeRef("Microsoft.Xna.Framework.GameServiceContainer"), [], [])), 
    function get_Services () {
      return this.gameServices;
    }
  );

  $.Method({Static:false, Public:true }, "get_Window", 
    (new JSIL.MethodSignature($xnaasms[1].TypeRef("Microsoft.Xna.Framework.GameWindow"), [], [])), 
    function get_Window () {
      // FIXME
      if (!this._window)
        this._window = new Microsoft.Xna.Framework.GameWindow();

      return this._window;
    }
  );

  $.Method({Static:false, Public:false}, "get_IsMouseVisible", 
    (new JSIL.MethodSignature($.Boolean, [], [])), 
    function get_IsMouseVisible () {
      var oc = this.graphicsDeviceService.GraphicsDevice.originalCanvas;
      return (oc.style.cursor !== "none");
    }
  );

  $.Method({Static:false, Public:true }, "set_IsMouseVisible", 
    (new JSIL.MethodSignature(null, [$.Boolean], [])), 
    function set_IsMouseVisible (value) {
      var oc = this.graphicsDeviceService.GraphicsDevice.originalCanvas;
      oc.style.cursor = value ? "default" : "none";
    }
  );

  $.Method({Static:false, Public:true }, "set_IsFixedTimeStep", 
    (new JSIL.MethodSignature(null, [$.Boolean], [])), 
    function set_IsFixedTimeStep (value) {
      this.isFixedTimeStep = value;
    }
  );

  $.Method({Static:false, Public:true }, "set_TargetElapsedTime", 
    (new JSIL.MethodSignature(null, [$xnaasms[5].TypeRef("System.TimeSpan")], [])), 
    function set_TargetElapsedTime (value) {
      this.targetElapsedTime = value;
    }
  );

  $.Method({
    Static: false,
    Public: true
  }, "Initialize", JSIL.MethodSignature.Void, function Game_Initialize () {    
    this.initialized = true;

    for (var i = 0, l = this.components._size; i < l; i++) {
      var component = this.components._items[i];
      component.Initialize();
    }

    this.LoadContent();

    var gameControl = JSIL.Host.getService("gameControl", true);
    if (gameControl)
      gameControl.started(this);
  });
  $.Method({
    Static: false,
    Public: true
  }, "LoadContent", JSIL.MethodSignature.Void, function () {

  });
  $.Method({
    Static: false,
    Public: true
  }, "UnloadContent", JSIL.MethodSignature.Void, function () {

  });
  $.Method({
    Static: false,
    Public: true
  }, "ResetElapsedTime", JSIL.MethodSignature.Void, function () {
    this.forceElapsedTimeToZero = true;
  });

  $.RawMethod(false, "$ComponentsOfType", function Game_$ComponentsOfType (type) {
    var result = new Array();
    for (var i = 0, l = this.components._size; i < l; i++) {
      var item = this.components._items[i];

      if (type.$Is(item)) 
        result.push(item);
    }
    return result;
  });

  $.Method({Static:false, Public:false}, "Draw", 
    (new JSIL.MethodSignature(null, [$xnaasms[1].TypeRef("Microsoft.Xna.Framework.GameTime")], [])), 
    function Game_Draw (gameTime) {
      if (Microsoft.Xna.Framework.Game._QuitForced || this._isDead) 
        return;

      var drawableComponents = this.$ComponentsOfType(Microsoft.Xna.Framework.IDrawable.__Type__);
      drawableComponents.sort(function (lhs, rhs) {
        return JSIL.CompareValues(lhs.get_DrawOrder(), rhs.get_DrawOrder());
      });

      for (var i = 0, l = drawableComponents.length; i < l; i++) {
        var drawable = drawableComponents[i];

        if (drawable.Visible) 
          drawable.Draw(gameTime);
      }
    }
  );

  $.Method({Static:false, Public:false}, "Update", 
    (new JSIL.MethodSignature(null, [$xnaasms[1].TypeRef("Microsoft.Xna.Framework.GameTime")], [])), 
    function Game_Update (gameTime) {
      if (Microsoft.Xna.Framework.Game._QuitForced || this._isDead) 
        return;

      var updateableComponents = this.$ComponentsOfType(Microsoft.Xna.Framework.IUpdateable.__Type__);
      updateableComponents.sort(function (lhs, rhs) {
        return JSIL.CompareValues(lhs.get_UpdateOrder(), rhs.get_UpdateOrder());
      });

      for (var i = 0, l = updateableComponents.length; i < l; i++) {
        var updateable = updateableComponents[i];

        if (updateable.Enabled) 
          updateable.Update(gameTime);
      }
    }
  );

  $.Method({
    Static: false,
    Public: true
  }, "Run", JSIL.MethodSignature.Void, function Game_Run () {
    this._profilingMode = (document.location.search.indexOf("profile") >= 0);
    this._balanceFPSCheckbox = (document.getElementById("balanceFramerate") || null);
    if (this._balanceFPSCheckbox)
      this._balanceFPSCheckbox.checked = !this._profilingMode;

    Microsoft.Xna.Framework.Game._QuitForced = false;
    this.Initialize();
    this._QueueStep();
  });

  $.RawMethod(false, "_QueueStep", function Game_QueueStep () {
    if (Microsoft.Xna.Framework.Game._QuitForced || this._isDead) 
      return;

    var self = this;
    var stepCallback = self._Step.bind(self);

    JSIL.Host.scheduleTick(stepCallback);
  });

  $.RawMethod(false, "_TimedUpdate", function Game_TimedUpdate (longFrame) {
    // FIXME: We have to sample time in two different ways here.
    // One is used for the framerate indicator, the other is used
    //  to avoid frameskip after a really long update. We want the
    //  frameskip suppression to be consistent in replay recording situations
    //  but we want to display actual update perf when running a replay.

    var updateActuallyStarted = JSIL.$GetHighResTime();
    var updateStarted = JSIL.Host.getTickCount();

    this.Update(this._gameTime);

    var updateEnded = JSIL.Host.getTickCount();
    var updateActuallyEnded = JSIL.$GetHighResTime();

    // Detect long updates and suppress frameskip.
    if ((updateEnded - updateStarted) > longFrame) {
      this.suppressFrameskip = true;
    }
    
    this._updateTimings.push(updateActuallyEnded - updateActuallyStarted);

    var svc = JSIL.Host.getService("gameTiming", true);
    if (svc)
      svc.update(updateActuallyEnded - updateActuallyStarted);
  });

  $.RawMethod(false, "_MaybeReportFPS", function Game_MaybeReportFPS (now) {
    var elapsed = now - this._lastFPSReport;
    if (elapsed >= 250) {
      this._ReportFPS(now);
    }
  });

  $.RawMethod(false, "_ReportFPS", function Game_ReportFPS (now) {
    var maxTimingSamples = 60;

    this._lastFPSReport = now;

    // FIXME: Slower than necessary.

    while (this._drawTimings.length > maxTimingSamples)
      this._drawTimings.shift();

    while (this._updateTimings.length > maxTimingSamples)
      this._updateTimings.shift();

    var updateTimeSum = 0, drawTimeSum = 0;

    for (var i = 0, l = this._drawTimings.length; i < l; i++)
      drawTimeSum += this._drawTimings[i];

    for (var i = 0, l = this._updateTimings.length; i < l; i++)
      updateTimeSum += this._updateTimings[i];

    var updateTimeAverage = updateTimeSum / this._updateTimings.length;
    var drawTimeAverage = drawTimeSum / this._drawTimings.length;
    
    var isWebGL = this.graphicsDeviceService.GraphicsDevice.context.isWebGL || false;
    var cacheBytes = ($jsilxna.imageChannelCache.countBytes + $jsilxna.textCache.countBytes);

    JSIL.Host.reportPerformance(drawTimeAverage, updateTimeAverage, cacheBytes, isWebGL);
  });

  $.RawMethod(false, "_FixedTimeStep", function Game_FixedTimeStep (
    elapsed, frameDelay, millisecondInTicks, maxElapsedTimeMs, longFrame
  ) {
    var tInt64 = $jsilcore.System.Int64;
    var frameLength64 = tInt64.FromNumber(frameDelay * millisecondInTicks);
    this._gameTime.elapsedGameTime._ticks = frameLength64;
    this._gameTime.elapsedGameTime.$invalidate();

    elapsed += this._extraTime;
    this._extraTime = 0;

    if (elapsed > maxElapsedTimeMs) 
      elapsed = maxElapsedTimeMs;

    var numFrames = Math.floor(elapsed / frameDelay);
    if (numFrames < 1) {
      numFrames = 1;
      this._extraTime = elapsed - frameDelay;
    } else {
      this._extraTime = elapsed - (numFrames * frameDelay);
    }

    for (var i = 0; i < numFrames; i++) {
      this._gameTime.totalGameTime._ticks = tInt64.op_Addition(
        this._gameTime.totalGameTime._ticks, frameLength64, this._gameTime.totalGameTime._ticks
      );
      this._gameTime.totalGameTime.$invalidate();

      this._TimedUpdate(longFrame);
    }
  });

  $.RawMethod(false, "_VariableTimeStep", function Game_VariableTimeStep (
    elapsed, frameDelay, millisecondInTicks, maxElapsedTimeMs, longFrame
  ) {
    this._extraTime = 0;
    this.suppressFrameskip = false;

    if (elapsed > maxElapsedTimeMs)
      elapsed = maxElapsedTimeMs;

    var tInt64 = $jsilcore.System.Int64;
    var elapsed64 = tInt64.FromNumber(elapsed * millisecondInTicks);

    this._gameTime.elapsedGameTime._ticks = elapsed64;
    this._gameTime.elapsedGameTime.$invalidate();
    this._gameTime.totalGameTime._ticks = tInt64.op_Addition(
      this._gameTime.totalGameTime._ticks, elapsed64, this._gameTime.totalGameTime._ticks
    );
    this._gameTime.totalGameTime.$invalidate();

    this._TimedUpdate(longFrame);
  });

  $.RawMethod(false, "_RenderAFrame", function Game_RenderAFrame () {
    var started = JSIL.$GetHighResTime();

    var device = this.get_GraphicsDevice();

    device.$UpdateViewport();      
    device.$Clear(null);

    this.Draw(this._gameTime);

    var end…