PBJ.cs

using System;
namespace PBJ {

public class IMessage {
    public virtual Google.ProtocolBuffers.IMessage _PBJISuper { get { return null;} }
    protected virtual bool _HasAllPBJFields { get { return true; } }
    public void WriteTo(Google.ProtocolBuffers.CodedOutputStream output){
        _PBJISuper.WriteTo(output);
    }
    public override bool Equals (object other){
        return _PBJISuper.Equals(other);
    }
    public int SerializedSize { get { return _PBJISuper.SerializedSize; } } 

    public override int GetHashCode() {return _PBJISuper.GetHashCode();}

    public override string ToString() {
        return _PBJISuper.ToString();
    }
    public virtual IBuilder WeakCreateBuilderForType() { return null;}
    public Google.ProtocolBuffers.ByteString ToByteString () {
        return _PBJISuper.ToByteString();
    }
    public byte[] ToByteArray () {
        return _PBJISuper.ToByteArray();
    }
    public void WriteTo(global::System.IO.Stream output) {
        _PBJISuper.WriteTo(output);
    }
//    Google.ProtocolBuffers.MessageDescriptor DescriptorForType { get {return _PBJISuper.DescriptorForType;} }
    public Google.ProtocolBuffers.UnknownFieldSet UnknownFields { get { return _PBJISuper.UnknownFields;} }
    public class IBuilder {
        public virtual Google.ProtocolBuffers.IBuilder _PBJISuper { get { return null;} }
        protected virtual bool _HasAllPBJFields { get { return true; } }
    }
}

public struct Vector2f {

    public float x;
    public float y;


    public Vector2f(float _x, float _y) {
        x = _x; y = _y;
    }

    public Vector2f(Vector2f cpy) {
        x = cpy.x; y = cpy.y;
    }


    public Vector2f Negate() {
        return new Vector2f(-x, -y);
    }

    public Vector2f Add(Vector2f rhs) {
        return new Vector2f(x + rhs.x, y + rhs.y);
    }

    public Vector2f Subtract(Vector2f rhs) {
        return new Vector2f(x - rhs.x, y - rhs.y);
    }

    public Vector2f Multiply(Vector2f rhs) {
        return new Vector2f(x * rhs.x, y * rhs.y);
    }

    public Vector2f Multiply(float s) {
        return new Vector2f(x * s, y * s);
    }

    public Vector2f Divide(Vector2f rhs) {
        return new Vector2f(x / rhs.x, y / rhs.y);
    }

    public Vector2f Divide(float s) {
        return new Vector2f(x / s, y / s);
    }

    public float Dot(Vector2f rhs) {
        return (x*rhs.x + y*rhs.y);
    }

    public void Normalize() {
        float len = Length;
        if (len != 0.0) {
            x /= len; y /= len;
        }
    }

    public Vector2f Normalized {
        get {
            Vector2f normed = new Vector2f(this);
            normed.Normalize();
            return normed;
        }
    }

    public float SquaredLength {
        get {
            return (x*x + y*y);
        }
    }
    public float Length {
        get {
            return (float)Math.Sqrt(SquaredLength);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}>", x, y);
    }


    public static Vector2f operator-(Vector2f uo) {
        return uo.Negate();
    }

    public static Vector2f operator+(Vector2f lhs, Vector2f rhs) {
        return lhs.Add(rhs);
    }

    public static Vector2f operator-(Vector2f lhs, Vector2f rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector2f operator*(Vector2f lhs, Vector2f rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector2f operator*(Vector2f lhs, float rhs) {
        return lhs.Multiply(rhs);
    }
    public static Vector2f operator*(float lhs, Vector2f rhs) {
        return rhs.Multiply(lhs);
    }

    public static Vector2f operator/(Vector2f lhs, Vector2f rhs) {
        return lhs.Divide(rhs);
    }

    public static Vector2f operator/(Vector2f lhs, float rhs) {
        return lhs.Divide(rhs);
    }

} // struct Vector2f

public struct Vector2d {

    public double x;
    public double y;


    public Vector2d(double _x, double _y) {
        x = _x; y = _y;
    }

    public Vector2d(Vector2d cpy) {
        x = cpy.x; y = cpy.y;
    }


    public Vector2d Negate() {
        return new Vector2d(-x, -y);
    }

    public Vector2d Add(Vector2d rhs) {
        return new Vector2d(x + rhs.x, y + rhs.y);
    }

    public Vector2d Subtract(Vector2d rhs) {
        return new Vector2d(x - rhs.x, y - rhs.y);
    }

    public Vector2d Multiply(Vector2d rhs) {
        return new Vector2d(x * rhs.x, y * rhs.y);
    }

    public Vector2d Multiply(double s) {
        return new Vector2d(x * s, y * s);
    }

    public Vector2d Divide(Vector2d rhs) {
        return new Vector2d(x / rhs.x, y / rhs.y);
    }

    public Vector2d Divide(double s) {
        return new Vector2d(x / s, y / s);
    }

    public double Dot(Vector2d rhs) {
        return (x*rhs.x + y*rhs.y);
    }

    public void Normalize() {
        double len = Length;
        if (len != 0.0) {
            x /= len; y /= len;
        }
    }

    public Vector2d Normalized {
        get {
            Vector2d normed = new Vector2d(this);
            normed.Normalize();
            return normed;
        }
    }

    public double SquaredLength {
        get {
            return (x*x + y*y);
        }
    }
    public double Length {
        get {
            return Math.Sqrt(SquaredLength);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}>", x, y);
    }


    public static Vector2d operator-(Vector2d uo) {
        return uo.Negate();
    }

    public static Vector2d operator+(Vector2d lhs, Vector2d rhs) {
        return lhs.Add(rhs);
    }

    public static Vector2d operator-(Vector2d lhs, Vector2d rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector2d operator*(Vector2d lhs, Vector2d rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector2d operator*(Vector2d lhs, double rhs) {
        return lhs.Multiply(rhs);
    }
    public static Vector2d operator*(double lhs, Vector2d rhs) {
        return rhs.Multiply(lhs);
    }

    public static Vector2d operator/(Vector2d lhs, Vector2d rhs) {
        return lhs.Divide(rhs);
    }

    public static Vector2d operator/(Vector2d lhs, double rhs) {
        return lhs.Divide(rhs);
    }

} // struct Vector2d

public struct Vector3f {

    public float x;
    public float y;
    public float z;


    public Vector3f(float _x, float _y, float _z) {
        x = _x; y = _y; z = _z;
    }

    public Vector3f(Vector3f cpy) {
        x = cpy.x; y = cpy.y; z = cpy.z;
    }


    public Vector3f Negate() {
        return new Vector3f(-x, -y, -z);
    }

    public Vector3f Add(Vector3f rhs) {
        return new Vector3f(x + rhs.x, y + rhs.y, z + rhs.z);
    }

    public Vector3f Subtract(Vector3f rhs) {
        return new Vector3f(x - rhs.x, y - rhs.y, z - rhs.z);
    }

    public Vector3f Multiply(Vector3f rhs) {
        return new Vector3f(x * rhs.x, y * rhs.y, z * rhs.z);
    }

    public Vector3f Multiply(float s) {
        return new Vector3f(x * s, y * s, z * s);
    }

    public Vector3f Divide(Vector3f rhs) {
        return new Vector3f(x / rhs.x, y / rhs.y, z / rhs.z);
    }

    public Vector3f Divide(float s) {
        return new Vector3f(x / s, y / s, z / s);
    }

    public float Dot(Vector3f rhs) {
        return (x*rhs.x + y*rhs.y + z*rhs.z);
    }

    public Vector3f Cross(Vector3f rhs) {
        return new Vector3f( y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
    }

    public void Normalize() {
        float len = Length;
        if (len != 0.0) {
            x /= len; y /= len; z /= len;
        }
    }

    public Vector3f Normalized {
        get {
            Vector3f normed = new Vector3f(this);
            normed.Normalize();
            return normed;
        }
    }

    public float SquaredLength {
        get {
            return (x*x + y*y + z*z);
        }
    }
    public float Length {
        get {
            return (float)Math.Sqrt(SquaredLength);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}, {2}>", x, y, z);
    }


    public static Vector3f operator-(Vector3f uo) {
        return uo.Negate();
    }

    public static Vector3f operator+(Vector3f lhs, Vector3f rhs) {
        return lhs.Add(rhs);
    }

    public static Vector3f operator-(Vector3f lhs, Vector3f rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector3f operator*(Vector3f lhs, Vector3f rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector3f operator*(Vector3f lhs, float rhs) {
        return lhs.Multiply(rhs);
    }
    public static Vector3f operator*(float lhs, Vector3f rhs) {
        return rhs.Multiply(lhs);
    }

    public static Vector3f operator/(Vector3f lhs, Vector3f rhs) {
        return lhs.Divide(rhs);
    }

    public static Vector3f operator/(Vector3f lhs, float rhs) {
        return lhs.Divide(rhs);
    }

} // struct Vector3f

public struct Vector3d {

    public double x;
    public double y;
    public double z;


    public Vector3d(double _x, double _y, double _z) {
        x = _x; y = _y; z = _z;
    }

    public Vector3d(Vector3d cpy) {
        x = cpy.x; y = cpy.y; z = cpy.z;
    }


    public Vector3d Negate() {
        return new Vector3d(-x, -y, -z);
    }

    public Vector3d Add(Vector3d rhs) {
        return new Vector3d(x + rhs.x, y + rhs.y, z + rhs.z);
    }

    public Vector3d Subtract(Vector3d rhs) {
        return new Vector3d(x - rhs.x, y - rhs.y, z - rhs.z);
    }

    public Vector3d Multiply(Vector3d rhs) {
        return new Vector3d(x * rhs.x, y * rhs.y, z * rhs.z);
    }

    public Vector3d Multiply(double s) {
        return new Vector3d(x * s, y * s, z * s);
    }

    public Vector3d Divide(Vector3d rhs) {
        return new Vector3d(x / rhs.x, y / rhs.y, z / rhs.z);
    }

    public Vector3d Divide(double s) {
        return new Vector3d(x / s, y / s, z / s);
    }

    public double Dot(Vector3d rhs) {
        return (x*rhs.x + y*rhs.y + z*rhs.z);
    }

    public Vector3d Cross(Vector3d rhs) {
        return new Vector3d( y*rhs.z - z*rhs.y, z*rhs.x - x*rhs.z, x*rhs.y - y*rhs.x);
    }

    public void Normalize() {
        double len = Length;
        if (len != 0.0) {
            x /= len; y /= len; z /= len;
        }
    }

    public Vector3d Normalized {
        get {
            Vector3d normed = new Vector3d(this);
            normed.Normalize();
            return normed;
        }
    }

    public double SquaredLength {
        get {
            return (x*x + y*y + z*z);
        }
    }
    public double Length {
        get {
            return Math.Sqrt(SquaredLength);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}, {2}>", x, y, z);
    }


    public static Vector3d operator-(Vector3d uo) {
        return uo.Negate();
    }

    public static Vector3d operator+(Vector3d lhs, Vector3d rhs) {
        return lhs.Add(rhs);
    }

    public static Vector3d operator-(Vector3d lhs, Vector3d rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector3d operator*(Vector3d lhs, Vector3d rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector3d operator*(Vector3d lhs, double rhs) {
        return lhs.Multiply(rhs);
    }
    public static Vector3d operator*(double lhs, Vector3d rhs) {
        return rhs.Multiply(lhs);
    }

    public static Vector3d operator/(Vector3d lhs, Vector3d rhs) {
        return lhs.Divide(rhs);
    }

    public static Vector3d operator/(Vector3d lhs, double rhs) {
        return lhs.Divide(rhs);
    }

} // struct Vector3d

public struct Quaternion {

    public float w;
    public float x;
    public float y;
    public float z;


    public Quaternion(float _w, float _x, float _y, float _z) {
        w = _w; x = _x; y = _y; z = _z;
    }

    public Quaternion(Quaternion cpy) {
        w = cpy.w; x = cpy.x; y = cpy.y; z = cpy.z;
    }

    public static readonly Quaternion Identity = new Quaternion((float)1.0, (float)0.0, (float)0.0, (float)0.0);

    public static Quaternion FromAxisAngle(Vector3f axis, float rads) {
	float halfAngle = rads * 0.5f;
	float sinHalf = (float)Math.Sin(halfAngle);
	float w = (float)Math.Cos(halfAngle);
	float x = sinHalf*axis.x;
	float y = sinHalf*axis.y;
	float z = sinHalf*axis.z;
        return new Quaternion(w, x, y, z);
    }

    public static Quaternion FromAxisAngle(Vector3d axis, float rads) {
	float halfAngle = rads * 0.5f;
	float sinHalf = (float)Math.Sin(halfAngle);
	float w = (float)Math.Cos(halfAngle);
	float x = (float)(sinHalf*axis.x);
	float y = (float)(sinHalf*axis.y);
	float z = (float)(sinHalf*axis.z);
        return new Quaternion(w, x, y, z);
    }


    public Quaternion Add(Quaternion rhs) {
        return new Quaternion(w + rhs.w, x + rhs.x, y + rhs.y, z + rhs.z);
    }

    public Quaternion Subtract(Quaternion rhs) {
        return new Quaternion(w - rhs.w, x - rhs.x, y - rhs.y, z - rhs.z);
    }

    public Quaternion Multiply(Quaternion rhs) {
	return new Quaternion(
            w*rhs.w - x*rhs.x - y*rhs.y - z*rhs.z,
            w*rhs.x + x*rhs.w + y*rhs.z - z*rhs.y,
            w*rhs.y + y*rhs.w + z*rhs.x - x*rhs.z,
            w*rhs.z + z*rhs.w + x*rhs.y - y*rhs.x
	);
    }

    public Vector3f Multiply(Vector3f rhs) {
	Vector3f qvec = new Vector3f(x, y, z);
	Vector3f uv = qvec.Cross(rhs);
	Vector3f uuv = qvec.Cross(uv);
	uv *= 2.0f * w;
	uuv *= 2.0f;

	return rhs + uv + uuv;
    }

    public Vector3d Multiply(Vector3d rhs) {
	Vector3d qvec = new Vector3d(x, y, z);
	Vector3d uv = qvec.Cross(rhs);
	Vector3d uuv = qvec.Cross(uv);
	uv *= 2.0f * w;
	uuv *= 2.0f;

	return rhs + uv + uuv;
    }

    public Quaternion Multiply(float rhs) {
        return new Quaternion(w*rhs, x*rhs, y*rhs, z*rhs);
    }

    public Quaternion Negate() {
        return new Quaternion(-w, -x, -y, -z);
    }

    public float Dot(Quaternion rhs) {
        return (w*rhs.w + x*rhs.x + y*rhs.y + z*rhs.z);
    }

    public float Norm {
        get {
            return (float)Math.Sqrt(w*w + x*x + y*y + z*z);
        }
    }

    public float SquareNorm {
        get {
            return (w*w + x*x + y*y + z*z);
        }
    }

    public void Normalize() {
        float len = SquareNorm;
        if (len == 0.0) return;
        float factor = 1.0f / (float)Math.Sqrt(len);
        this *= factor;
    }

    public Quaternion Normalized {
        get {
            Quaternion q = new Quaternion(this);
            q.Normalize();
            return q;
        }
    }

    public Quaternion Inverse {
        get {
            float norm = SquareNorm;
            if (norm > 0.0) {
                double invnorm = 1.0 / norm;
                return new Quaternion((float)(w*invnorm), (float)(-x*invnorm), (float)(-y*invnorm), (float)(-z*invnorm));
            }
            else
                return new Quaternion((float)0.0, 0.0f, 0.0f, 0.0f);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}, {2}, {3}>", w, x, y, z);
    }



    public static Quaternion operator-(Quaternion uo) {
        return uo.Negate();
    }

    public static Quaternion operator+(Quaternion lhs, Quaternion rhs) {
        return lhs.Add(rhs);
    }

    public static Quaternion operator-(Quaternion lhs, Quaternion rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector3f operator*(Quaternion lhs, Vector3f rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector3d operator*(Quaternion lhs, Vector3d rhs) {
        return lhs.Multiply(rhs);
    }

    public static Quaternion operator*(Quaternion lhs, Quaternion rhs) {
        return lhs.Multiply(rhs);
    }

    public static Quaternion operator*(Quaternion lhs, float rhs) {
        return lhs.Multiply(rhs);
    }

    public static Quaternion operator*(float lhs, Quaternion rhs) {
        return rhs.Multiply(lhs);
    }

} // struct Quaternion


public struct Vector4f {

    public float x;
    public float y;
    public float z;
    public float w;


    public Vector4f(float _x, float _y, float _z, float _w) {
        x = _x; y = _y; z = _z; w = _w;
    }

    public Vector4f(Vector4f cpy) {
        x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w;
    }


    public Vector4f Negate() {
        return new Vector4f(-x, -y, -z, -w);
    }

    public Vector4f Add(Vector4f rhs) {
        return new Vector4f(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w);
    }

    public Vector4f Subtract(Vector4f rhs) {
        return new Vector4f(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w);
    }

    public Vector4f Multiply(Vector4f rhs) {
        return new Vector4f(x * rhs.x, y * rhs.y, z * rhs.z, w*rhs.w);
    }

    public Vector4f Multiply(float s) {
        return new Vector4f(x * s, y * s, z * s, w * s);
    }

    public Vector4f Divide(Vector4f rhs) {
        return new Vector4f(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w);
    }

    public Vector4f Divide(float s) {
        return new Vector4f(x / s, y / s, z / s, w / s);
    }

    public float Dot(Vector4f rhs) {
        return (x*rhs.x + y*rhs.y + z*rhs.z + w*rhs.w);
    }

    public void Normalize() {
        float len = Length;
        if (len != 0.0) {
            x /= len; y /= len; z /= len; w /= len;
        }
    }

    public Vector4f Normalized {
        get {
            Vector4f normed = new Vector4f(this);
            normed.Normalize();
            return normed;
        }
    }

    public float SquaredLength {
        get {
            return (x*x + y*y + z*z + w*w);
        }
    }
    public float Length {
        get {
            return (float)Math.Sqrt(SquaredLength);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w);
    }


    public static Vector4f operator-(Vector4f uo) {
        return uo.Negate();
    }

    public static Vector4f operator+(Vector4f lhs, Vector4f rhs) {
        return lhs.Add(rhs);
    }

    public static Vector4f operator-(Vector4f lhs, Vector4f rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector4f operator*(Vector4f lhs, Vector4f rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector4f operator*(Vector4f lhs, float rhs) {
        return lhs.Multiply(rhs);
    }
    public static Vector4f operator*(float lhs, Vector4f rhs) {
        return rhs.Multiply(lhs);
    }

    public static Vector4f operator/(Vector4f lhs, Vector4f rhs) {
        return lhs.Divide(rhs);
    }

    public static Vector4f operator/(Vector4f lhs, float rhs) {
        return lhs.Divide(rhs);
    }

} // struct Vector4f



public struct Vector4d {

    public double x;
    public double y;
    public double z;
    public double w;


    public Vector4d(double _x, double _y, double _z, double _w) {
        x = _x; y = _y; z = _z; w = _w;
    }

    public Vector4d(Vector4d cpy) {
        x = cpy.x; y = cpy.y; z = cpy.z; w = cpy.w;
    }


    public Vector4d Negate() {
        return new Vector4d(-x, -y, -z, -w);
    }

    public Vector4d Add(Vector4d rhs) {
        return new Vector4d(x + rhs.x, y + rhs.y, z + rhs.z, w + rhs.w);
    }

    public Vector4d Subtract(Vector4d rhs) {
        return new Vector4d(x - rhs.x, y - rhs.y, z - rhs.z, w - rhs.w);
    }

    public Vector4d Multiply(Vector4d rhs) {
        return new Vector4d(x * rhs.x, y * rhs.y, z * rhs.z, w*rhs.w);
    }

    public Vector4d Multiply(double s) {
        return new Vector4d(x * s, y * s, z * s, w * s);
    }

    public Vector4d Divide(Vector4d rhs) {
        return new Vector4d(x / rhs.x, y / rhs.y, z / rhs.z, w / rhs.w);
    }

    public Vector4d Divide(double s) {
        return new Vector4d(x / s, y / s, z / s, w / s);
    }

    public double Dot(Vector4d rhs) {
        return (x*rhs.x + y*rhs.y + z*rhs.z + w*rhs.w);
    }

    public void Normalize() {
        double len = Length;
        if (len != 0.0) {
            x /= len; y /= len; z /= len; w /= len;
        }
    }

    public Vector4d Normalized {
        get {
            Vector4d normed = new Vector4d(this);
            normed.Normalize();
            return normed;
        }
    }

    public double SquaredLength {
        get {
            return (x*x + y*y + z*z + w*w);
        }
    }
    public double Length {
        get {
            return Math.Sqrt(SquaredLength);
        }
    }


    public override string ToString() {
        return String.Format("<{0}, {1}, {2}, {3}>", x, y, z, w);
    }


    public static Vector4d operator-(Vector4d uo) {
        return uo.Negate();
    }

    public static Vector4d operator+(Vector4d lhs, Vector4d rhs) {
        return lhs.Add(rhs);
    }

    public static Vector4d operator-(Vector4d lhs, Vector4d rhs) {
        return lhs.Subtract(rhs);
    }

    public static Vector4d operator*(Vector4d lhs, Vector4d rhs) {
        return lhs.Multiply(rhs);
    }

    public static Vector4d operator*(Vector4d lhs, double rhs) {
        return lhs.Multiply(rhs);
    }
    public static Vector4d operator*(double lhs, Vector4d rhs) {
        return rhs.Multiply(lhs);
    }

    public static Vector4d operator/(Vector4d lhs, Vector4d rhs) {
        return lhs.Divide(rhs);
    }

    public static Vector4d operator/(Vector4d lhs, double rhs) {
        return lhs.Divide(rhs);
    }

} // struct Vector4d



public struct BoundingBox3f3f {
    Vector3f mMin;
    Vector3f mDiag;
    public BoundingBox3f3f(float minx, float miny, float minz,float diagx,float diagy,float diagz) {
        mMin.x=minx;
        mMin.y=miny;
        mMin.z=minz;

        mDiag.x=diagx;
        mDiag.y=diagy;
        mDiag.z=diagz;
    }
    public BoundingBox3f3f(Vector3f min, Vector3f max) {
        mMin=min;
        mDiag=(max-min);
    }
    public BoundingBox3f3f(BoundingBox3f3f cpy, Vector3f scale) {
        mMin.x=(float)(cpy.mMin.x*scale.x);
        mMin.y=(float)(cpy.mMin.y*scale.y);
        mMin.z=(float)(cpy.mMin.z*scale.z);
        
        mDiag.x=(float)(cpy.mDiag.x*scale.x);
        mDiag.y=(float)(cpy.mDiag.y*scale.y);
        mDiag.z=(float)(cpy.mDiag.z*scale.z);
    }
    public Vector3f Min {
        get {
            return new Vector3f(mMin.x,mMin.y,mMin.z);
        }
    }
    public Vector3f Max {
        get {
            return new Vector3f(mMin.x+mDiag.x,mMin.y+mDiag.y,mMin.z+mDiag.z);
        }
    }

    public Vector3f Diag {
        get {
            return new Vector3f(mDiag.x,mDiag.y,mDiag.z);
        }
    }


    public override string ToString() {
        return "["+this.Min.ToString()+" - "+this.Max.ToString()+"]";
    }
    public BoundingBox3f3f Merge(BoundingBox3f3f other) {
        Vector3f thisMax=Max;
        Vector3f otherMax=other.Max;
        bool xless=other.mMin.x>mMin.x;
        bool yless=other.mMin.y>mMin.y;
        bool zless=other.mMin.z>mMin.z;

        bool xmore=otherMax.x<thisMax.x;
        bool ymore=otherMax.y<thisMax.y;
        bool zmore=otherMax.z<thisMax.z;
        return new BoundingBox3f3f(xless?mMin.x:other.mMin.x,
                               yless?mMin.y:other.mMin.y,
                               zless?mMin.z:other.mMin.z,
                               xmore?(xless?mDiag.x:otherMax.x-mMin.x):(xless?thisMax.x-other.mMin.x:other.mDiag.x),
                               ymore?(yless?mDiag.y:otherMax.y-mMin.y):(yless?thisMax.y-other.mMin.y:other.mDiag.y),
                               zmore?(zless?mDiag.z:otherMax.z-mMin.z):(zless?thisMax.z-other.mMin.z:other.mDiag.z));
    }

} // struct BoundingBox

public struct BoundingBox3d3f {
    Vector3d mMin;
    Vector3f mDiag;
    public BoundingBox3d3f(double minx, double miny, double minz,float diagx,float diagy,float diagz) {
        mMin.x=minx;
        mMin.y=miny;
        mMin.z=minz;

        mDiag.x=diagx;
        mDiag.y=diagy;
        mDiag.z=diagz;
    }
    public BoundingBox3d3f(Vector3d min, Vector3f max) {
        mMin=min;
        
        mDiag=new Vector3f((float)(max.x-min.x),
                           (float)(max.y-min.y),
                           (float)(max.z-min.z));
    }
    public BoundingBox3d3f(BoundingBox3d3f cpy, Vector3d scale) {
        mMin.x=(double)(cpy.mMin.x*scale.x);
        mMin.y=(double)(cpy.mMin.y*scale.y);
        mMin.z=(double)(cpy.mMin.z*scale.z);
        
        mDiag.x=(float)(cpy.mDiag.x*scale.x);
        mDiag.y=(float)(cpy.mDiag.y*scale.y);
        mDiag.z=(float)(cpy.mDiag.z*scale.z);
    }
    public Vector3d Min {
        get {
            return new Vector3d(mMin.x,mMin.y,mMin.z);
        }
    }
    public Vector3d Max {
        get {
            return new Vector3d(mMin.x+mDiag.x,mMin.y+mDiag.y,mMin.z+mDiag.z);
        }
    }

    public Vector3d Diag {
        get {
            return new Vector3d(mDiag.x,mDiag.y,mDiag.z);
        }
    }


    public override string ToString() {
        return "["+this.Min.ToString()+" - "+this.Max.ToString()+"]";
    }
    public BoundingBox3d3f Merge(BoundingBox3d3f other) {
        Vector3d thisMax=Max;
        Vector3d otherMax=other.Max;
        bool xless=other.mMin.x>mMin.x;
        bool yless=other.mMin.y>mMin.y;
        bool zless=other.mMin.z>mMin.z;

        bool xmore=otherMax.x<thisMax.x;
        bool ymore=otherMax.y<thisMax.y;
        bool zmore=otherMax.z<thisMax.z;
        return new BoundingBox3d3f(xless?mMin.x:other.mMin.x,
                                   yless?mMin.y:other.mMin.y,
                                   zless?mMin.z:other.mMin.z,
                                   (float)(xmore?(xless?mDiag.x:otherMax.x-mMin.x):(xless?thisMax.x-other.mMin.x:other.mDiag.x)),
                                   (float)(ymore?(yless?mDiag.y:otherMax.y-mMin.y):(yless?thisMax.y-other.mMin.y:other.mDiag.y)),
                                   (float)(zmore?(zless?mDiag.z:otherMax.z-mMin.z):(zless?thisMax.z-other.mMin.z:other.mDiag.z)));
    }

} // struct BoundingBox




public struct BoundingSphere3f {
    Vector3f mCenter;
    float mRadius;
    public BoundingSphere3f(float x,float y,float z, float r) {
        mCenter=new Vector3f(x,y,z);
        mRadius=r;
    }
    public BoundingSphere3f(Vector3f center, float radius) {
        mCenter=center;
        mRadius=radius;
    }
    public BoundingSphere3f(BoundingSphere3f cpy, float scale) {
        mCenter=cpy.mCenter;
        mRadius=cpy.mRadius*scale;
    }
    public Vector3f Center {
        get {
            return new Vector3f(mCenter.x,mCenter.y,mCenter.z);
        }
    }
    public float Radius {
        get {
            return mRadius;
        }
    }

    public override string ToString() {
        return "["+this.Center.ToString()+" : "+this.Radius.ToString()+"]";
    }
} // struct BoundingSphere3f



public struct BoundingSphere3d {
    Vector3d mCenter;
    float mRadius;
    public BoundingSphere3d(double x,double y,double z, float r) {
        mCenter.x=x;
        mCenter.y=y;
        mCenter.z=z;
        mRadius=r;
    }
    public BoundingSphere3d(Vector3d center, float radius) {
        mCenter=center;
        mRadius=radius;
    }
    public BoundingSphere3d(BoundingSphere3d cpy, float scale) {
        mCenter=cpy.mCenter;
        mRadius=cpy.mRadius*scale;
    }
    public Vector3d Center {
        get {
            return new Vector3d(mCenter.x,mCenter.y,mCenter.z);
        }
    }
    public float Radius {
        get {
            return mRadius;
        }
    }

    public override string ToString() {
        return "["+this.Center.ToString()+" : "+this.Radius.ToString()+"]";
    }
} // struct BoundingSphere3f

public struct UUID {
    ulong mLowOrderBytes;
    ulong mHighOrderBytes;

    
    static ulong SetUUIDlow(Google.ProtocolBuffers.ByteString data, int offset) {
        ulong LowOrderBytes=0;
        int shiftVal=0;
        for (int i=0;i<8;++i) {
            ulong temp=data[i];
            LowOrderBytes|=(temp<<shiftVal);
            shiftVal+=8;
        }
        return LowOrderBytes;
    }
    static ulong SetUUIDhigh (Google.ProtocolBuffers.ByteString data) {
        return SetUUIDlow(data,8);
    }
    static ulong SetUUIDlow(byte[] data, int offset) {
        ulong LowOrderBytes=0;
        int shiftVal=0;
        for (int i=0;i<8;++i) {
            ulong temp=data[i];
            LowOrderBytes|=(temp<<shiftVal);
            shiftVal+=8;
        }
        return LowOrderBytes;
    }
    static ulong SetUUIDhigh (byte[] data) {
        return SetUUIDlow(data,8);
    }
    public bool SetUUID(byte[] data) {
        if (data.Length==16) {
            mLowOrderBytes=0;
            mHighOrderBytes=0;
            mLowOrderBytes=SetUUIDlow(data,0);
            mHighOrderBytes=SetUUIDlow(data,8);
            return true;
        }else {
            return false;
        }
    }
    public byte[] GetUUID() {
        byte[] data= new byte[16];
        int shiftVal=0;
        for (int i=0;i<8;++i) {
            ulong temp=0xff;
            temp=(mLowOrderBytes&(temp<<shiftVal));
            temp=(temp>>shiftVal);
            data[i]=(byte)temp;
            shiftVal+=8;
        }
        shiftVal=0;
        for (int i=8;i<16;++i) {
            ulong temp=0xff;
            temp=(mHighOrderBytes&(temp<<shiftVal));
            temp=(temp>>shiftVal);
            data[i]=(byte)temp;
            shiftVal+=8;
        }
        return data;
    }

    public static UUID Empty = new UUID(new byte[16]);
    public UUID(byte []data) {
        if (data.Length!=16) {
            throw new System.ArgumentException("UUIDs must be provided 16 bytes");
        }
        mLowOrderBytes=SetUUIDlow(data,0);
        mHighOrderBytes=SetUUIDhigh(data);
    }
    public UUID(Google.ProtocolBuffers.ByteString data) {
        if (data.Length!=16) {
            throw new System.ArgumentException("UUIDs must be provided 16 bytes");
        }
        mLowOrderBytes=SetUUIDlow(data,0);
        mHighOrderBytes=SetUUIDhigh(data);
    }

}


public struct SHA256 {
    ulong mLowOrderBytes;
    ulong mLowMediumOrderBytes;
    ulong mMediumHighOrderBytes;
    ulong mHighOrderBytes;

    
    static ulong SetLMH(Google.ProtocolBuffers.ByteString data, int offset) {
        ulong LowOrderBytes=0;
        int shiftVal=0;
        for (int i=0;i<8;++i) {
            ulong temp=data[i];
            LowOrderBytes|=(temp<<shiftVal);
            shiftVal+=8;
        }
        return LowOrderBytes;
    }
    static ulong SetLow(Google.ProtocolBuffers.ByteString data) {
        return SetLMH(data,0);
    }
    static ulong SetLowMedium (Google.ProtocolBuffers.ByteString data) {
        return SetLMH(data,8);
    }
    static ulong SetMediumHigh (Google.ProtocolBuffers.ByteString data) {
        return SetLMH(data,16);
    }
    static ulong SetHigh (Google.ProtocolBuffers.ByteString data) {
        return SetLMH(data,24);
    }
    static ulong SetLMH(byte[] data, int offset) {
        ulong LowOrderBytes=0;
        int shiftVal=0;
        for (int i=0;i<8;++i) {
            ulong temp=data[i];
            LowOrderBytes|=(temp<<shiftVal);
            shiftVal+=8;
        }
        return LowOrderBytes;
    }
    static ulong SetLow (byte[] data) {
        return SetLMH(data,0);
    }
    static ulong SetLowMedium (byte[] data) {
        return SetLMH(data,8);
    }
    static ulong SetMediumHigh (byte[] data) {
        return SetLMH(data,16);
    }
    static ulong SetHigh (byte[] data) {
        return SetLMH(data,24);
    }
    public bool SetSHA256(byte[] data) {
        if (data.Length==32) {
            mLowOrderBytes=SetLow(data);
            mLowMediumOrderBytes=SetLowMedium(data);
            mMediumHighOrderBytes=SetMediumHigh(data);
            mHighOrderBytes=SetHigh(data);
            return true;
        }else {
            return false;
        }
    }
    public byte[] GetBinaryData() {
        byte[] data= new byte[32];
        int shiftVal=0;
        for (int i=0;i<8;++i) {
            ulong temp=0xff;
            temp=(mLowOrderBytes&(temp<<shiftVal));
            temp=(temp>>shiftVal);
            data[i]=(byte)temp;
            shiftVal+=8;
        }
        shiftVal=0;
        for (int i=8;i<16;++i) {
            ulong temp=0xff;
            temp=(mLowMediumOrderBytes&(temp<<shiftVal));
            temp=(temp>>shiftVal);
            data[i]=(byte)temp;
            shiftVal+=8;
        }
        shiftVal=0;
        for (int i=16;i<24;++i) {
            ulong temp=0xff;
            temp=(mMediumHighOrderBytes&(temp<<shiftVal));
            temp=(temp>>shiftVal);
            data[i]=(byte)temp;
            shiftVal+=8;
        } 
        shiftVal=0;
        for (int i=24;i<32;++i) {
            ulong temp=0xff;
            temp=(mHighOrderBytes&(temp<<shiftVal));
            temp=(temp>>shiftVal);
            data[i]=(byte)temp;
            shiftVal+=8;
        }
        return data;
    }

    public static SHA256 Empty = new SHA256(new byte[32]);
    public SHA256(byte []data) {
        if (data.Length!=32) {
            throw new System.ArgumentException("SHA256s must be provided 32 bytes");
        }
        mLowOrderBytes=SetLow(data);
        mLowMediumOrderBytes=SetLowMedium(data);
        mMediumHighOrderBytes=SetMediumHigh(data);
        mHighOrderBytes=SetHigh(data);
    }
    public SHA256(Google.ProtocolBuffers.ByteString data) {
        if (data.Length!=32) {
            throw new System.ArgumentException("SHA256s must be provided 32 bytes");
        }
        mLowOrderBytes=SetLow(data);
        mLowMediumOrderBytes=SetLowMedium(data);
        mMediumHighOrderBytes=SetMediumHigh(data);
        mHighOrderBytes=SetHigh(data);
    }

}




public struct Time {
    ulong usec;
    public Time(ulong usec_since_epoch){
        usec=usec_since_epoch;
    }
    public ulong toMicro(){
        return usec;
    }
}
public class Duration {
    long usec;
    public Duration(long time_since){
        usec=time_since;
    }
    public long toMicro(){
        return usec;
    }
}

class _PBJ {

public static bool ValidateBool(bool d) {
    return true;
}
public static bool ValidateDouble(double d) {
    return true;
}
public static bool ValidateFloat(float d) {
    return true;
}
public static bool ValidateUint64(ulong d) {
    return true;
}
public static bool ValidateUint32(uint d) {
    return true;
}
public static bool ValidateUint16(ushort d) {
    return true;
}
public static bool ValidateUint16(uint d) {
    return (d >= UInt16.MinValue && d <= UInt16.MaxValue);
}
public static bool ValidateUint8(byte d) {
    return true;
}
public static bool ValidateSint64(long d) {
    return true;
}
public static bool ValidateSint32(int d) {
    return true;
}
public static bool ValidateSint16(short d) {
    return true;
}
public static bool ValidateSint16(int d) {
    return (d >= Int16.MinValue && d <= Int16.MaxValue);
}
public static bool ValidateSint8(sbyte d) {
    return true;
}
public static bool ValidateInt64(long d) {
    return true;
}
public static bool ValidateInt32(int d) {
    return true;
}
public static bool ValidateInt16(short d) {
    return true;
}
public static bool ValidateInt16(int d) {
    return (d >= Int16.MinValue && d <= Int16.MaxValue);
}
public static bool ValidateInt8(sbyte d) {
    return true;
}
public static bool ValidateString<S>(S input) {
    return true;
}
public static bool ValidateBytes<B>(B input) {
    return true;
}
public static bool ValidateUuid(Google.ProtocolBuffers.ByteString input) {
    return input.Length==16;
}
public static bool ValidateSha256(Google.ProtocolBuffers.ByteString input) {
    return input.Length==32;
}
public static bool ValidateAngle(float input) {
    return input>=0&&input<=3.1415926536*2.0;
}
public static bool ValidateSolidAngle(float input) {
    return input>=0&&input<=3.1415926536*4.0;
}
    public static bool ValidateTime(ulong input) {
        return true;
    }
    public static bool ValidateDuration(long input) {
        return true;
    }
    public static bool ValidateFlags(ulong input, ulong verification) {
        return (input&verification)==input;
    }




public static bool CastBool(bool d) {
    return d;
}
public static double CastDouble(double d) {
    return d;
}
public static float CastFloat(float d) {
    return d;
}
public static ulong CastUint64(ulong d) {
    return d;
}
public static uint CastUint32(uint d) {
    return d;
}
public static ushort CastUint16(ushort d) {
    return d;
}
public static ushort CastUint16(uint d) {
    if (d >= UInt16.MinValue && d <= UInt16.MaxValue)
        return (ushort)d;
    else
        throw new System.ArgumentException("Stored value exceeds valid range for uint16.");
}
public static byte CastUint8(byte d) {
    return d;
}
public static long CastSint64(long d) {
    return d;
}
public static int CastSint32(int d) {
    return d;
}
public static short CastSint16(short d) {
    return d;
}
public static short CastSint16(int d) {
    if (d >= Int16.MinValue && d <= Int16.MaxValue)
        return (short)d;
    else
        throw new System.ArgumentException("Stored value exceeds valid range for sint16.");
}
public static sbyte CastSint8(sbyte d) {
    return d;
}
public static long CastInt64(long d) {
    return d;
}
public static int CastInt32(int d) {
    return d;
}
public static short CastInt16(short d) {
    return d;
}
public static short CastInt16(int d) {
    if (d >= Int16.MinValue && d <= Int16.MaxValue)
        return (short)d;
    else
        throw new System.ArgumentException("Stored value exceeds valid range for sint16.");
}
public static sbyte CastInt8(sbyte d) {
    return d;
}
public static S CastString<S>(S input) {
    return input;
}
public static B CastBytes<B>(B input) {
    return input;
}



public static bool CastBool() {
    return false;
}
public static double CastDouble() {
    return 0;
}
public static float CastFloat() {
    return 0;
}
public static ulong CastUint64() {
    return 0;
}
public static uint CastUint32() {
    return 0;
}
public static ushort CastUint16() {
    return 0;
}
public static byte CastUint8() {
    return 0;
}
public static long CastSint64() {
    return 0;
}
public static int CastSint32() {
    return 0;
}
public static short CastSint16() {
    return 0;
}
public static sbyte CastSint8() {
    return 0;
}
public static long CastInt64() {
    return 0;
}
public static int CastInt32() {
    return 0;
}
public static short CastInt16() {
    return 0;
}
public static sbyte CastInt8() {
    return 0;
}
public static string CastString() {
    return "";
}
public static Google.ProtocolBuffers.ByteString CastBytes() {
    return Google.ProtocolBuffers.ByteString.Empty;
}


    public static ulong CastFlags(ulong data, ulong allFlagsOn) {
        return allFlagsOn&data;
    }
    public static ulong CastFlags(ulong allFlagsOn) {
        return 0;
    }
    
    public static Vector3f CastNormal(float x, float y) {
        float neg=(x>1.5f||y>1.5f)?-1.0f:1.0f;
        if (x>1.5)
            x-=3;
        if (y>1.5)
            y-=3;
        return new Vector3f(x,y,neg-neg*(float)Math.Sqrt(x*x+y*y));
    }
    public static Vector3f CastNormal() {
        return new Vector3f(0,1,0);
    }


    public static Vector2f CastVector2f(float x, float y) {
        return new Vector2f(x,y);
    }
    public static Vector2f CastVector2f() {
        return new Vector2f(0,0);
    }

    public static Vector3f CastVector3f(float x, float y, float z) {
        return new Vector3f(x,y,z);
    }
    public static Vector3f CastVector3f() {
        return new Vector3f(0,0,0);
    }

    public static Vector4f CastVector4f(float x, float y, float z, float w) {
        return new Vector4f(x,y,z,w);
    }
    public static Vector4f CastVector4f() {
        return new Vector4f(0,0,0,0);
    }
    public static Vector2d CastVector2d(double x, double y) {
        return new Vector2d(x,y);
    }
    public static Vector2d CastVector2d() {
        return new Vector2d(0,0);
    }

    public static Vector3d CastVector3d(double x, double y, double z) {
        return new Vector3d(x,y,z);
    }
    public static Vector3d CastVector3d() {
        return new Vector3d(0,0,0);
    }

    public static Vector4d CastVector4d(double x, double y, double z, double w) {
        return new Vector4d(x,y,z,w);
    }
    public static Vector4d CastVector4d() {
        return new Vector4d(0,0,0,0);
    }

    public static BoundingSphere3f CastBoundingsphere3f(float x, float y, float z, float r) {
        return new BoundingSphere3f(new Vector3f(x,y,z),r);
    }
    public static BoundingSphere3d CastBoundingsphere3d(double x, double y, double z, double r) {
        return new BoundingSphere3d(new Vector3d(x,y,z),(float)r);
    }

    public static BoundingSphere3f CastBoundingsphere3f() {
        return new BoundingSphere3f(new Vector3f(0,0,0),0);
    }
    public static BoundingSphere3d CastBoundingsphere3d() {
        return new BoundingSphere3d(new Vector3d(0,0,0),(float)0);
    }


    public static BoundingBox3f3f CastBoundingbox3f3f(float x, float y, float z, float dx, float dy, float dz) {
        return new BoundingBox3f3f(x,y,z,dx,dy,dz);
    }
    public static BoundingBox3d3f CastBoundingbox3d3f(double x, double y, double z, double dx, double dy, double dz) {
        return new BoundingBox3d3f(x,y,z,(float)dx,(float)dy,(float)dz);
    }

    public static BoundingBox3f3f CastBoundingbox3f3f() {
        return new BoundingBox3f3f(new Vector3f(0,0,0),new Vector3f(0,0,0));
    }
    public static BoundingBox3d3f CastBoundingbox3d3f() {
        return new BoundingBox3d3f(0,0,0,0,0,0);
    }

        

    public static Quaternion CastQuaternion(float x, float y, float z) {
        float neg=(x>1.5||y>1.5||z>1.5)?-1.0f:1.0f;
        if (x>1.5)
            x-=3.0f;
        if (y>1.5)
            y-=3.0f;
        if (z>1.5)
            z-=3.0f;
        return new Quaternion(neg-neg*(float)Math.Sqrt(x*x+y*y+z*z),x,y,z);
    }
    public static Quaternion CastQuaternion() {
        return new Quaternion(1,0,0,0);
    }

public static UUID CastUuid(Google.ProtocolBuffers.ByteString input) {
    return new UUID(input);
}
public static SHA256 CastSha256(Google.ProtocolBuffers.ByteString input) {
    return new SHA256(input);
}
public static SHA256 CastSha256() {
    return SHA256.Empty;
}
public static UUID CastUuid() {
    return UUID.Empty;
}

public static float CastAngle(float d) {
    return d;
}
public static float CastAngle() {
    return 0;
}

public static float CastSolidAngle(float d) {
    return d;
}
public static float CastSolidAngle() {
    return 0;
}

public static Time CastTime(ulong t) {
    return new Time(t);
}
public static Time CastTime() {
    return new Time(0);
}
public static Duration CastDuration(long t) {
    return new Duration(t);
}
public static Duration CastDuration() {
    return new Duration(0);
}

    public static T Construct<T>(T retval) {
        return retval;
    }
    public static long Construct(Duration d) {
        return d.toMicro();
    }
    public static ulong Construct(Time t) {
        return t.toMicro();
    }
    public static Google.ProtocolBuffers.ByteString Construct(UUID u) {
        byte[] data=u.GetUUID();
        Google.ProtocolBuffers.ByteString retval=Google.ProtocolBuffers.ByteString.CopyFrom(data,0,16);
        return retval;
    }
    public static Google.ProtocolBuffers.ByteString Construct(SHA256 u) {
        byte[] data=u.GetBinaryData();
        Google.ProtocolBuffers.ByteString retval=Google.ProtocolBuffers.ByteString.CopyFrom(data,0,16);
        return retval;
    }
    public static float[] ConstructNormal(Vector3f d) {
        return new float[]{d.x+(d.z<0?3.0f:0.0f),d.y};
    }
    public static float[] ConstructQuaternion(Quaternion d) {
        return new float[]{d.x+(d.w<0?3.0f:0.0f),d.y,d.z};
    }

    public static float[] ConstructVector2f(Vector2f d) {
        return new float[]{d.x,d.y};
    }
    public static double[] ConstructVector2d(Vector2d d) {
        return new double[]{d.x,d.y};
    }

    public static float[] ConstructVector3f(Vector3f d) {
        return new float[]{d.x,d.y,d.z};
    }
    public static double[] ConstructVector3d(Vector3d d) {
        return new double[]{d.x,d.y,d.z};
    }
    public static float[] ConstructVector4f(Vector4f d) {
        return new float[]{d.x,d.y,d.z,d.w};
    }
    public static double[] ConstructVector4d(Vector4d d) {
        return new double[]{d.x,d.y,d.z,d.w};
    }


    public static float[] ConstructBoundingsphere3f(BoundingSphere3f d) {
        return new float[]{d.Center.x,d.Center.y,d.Center.z,d.Radius};
    }
    public static double[] ConstructBoundingsphere3d(BoundingSphere3d d) {
        return new double[]{d.Center.x,d.Center.y,d.Center.z,d.Radius};
    }

    public static float[] ConstructBoundingbox3f3f(BoundingBox3f3f d) {
        return new float[]{d.Min.x,d.Min.y,d.Min.z,d.Diag.x,d.Diag.y,d.Diag.z};
    }
    public static double[] ConstructBoundingbox3d3f(BoundingBox3d3f d) {
        return new double[]{d.Min.x,d.Min.y,d.Min.z,d.Diag.x,d.Diag.y,d.Diag.z};
    }


}

}