Demo.prototype.addHumanoid = function () {

    let ak47LMatrix = null;
    let ak47RMatrix = null;
    const muzzleFire = (parentId, i) => {
        const muzzleAlpha = () => {
            if (Sync.get('Humanoid:AkHand') <= 0.01) return 0.0;

            const ak47BurstRate = 100. / 60. * 25.;
            const fire = 1.0;
            const value = fire * ((Math.sin(i * 0.8 + ak47BurstRate * (getSceneTimeFromStart() + 10.0)) + 1) / 2);
            return (value < 0.95 ? 0.0 : 1.0) * Sync.get('Humanoid:AkFire', 1.0);
            //return 0.0;
        };
        const muzzleAdditive = true;
        const deg2rad = Math.PI / 180;

        const magazineSize = 90;
        let ak47BurstRateDelay = 0.25;
        let activeBulletTime = -1;
        let bullets = new Array(magazineSize);
        for (let i = 0; i < bullets.length; i++) {
            bullets[i] = {
                active: 0,
                timeStart: -1,
            };
        };

        this.loader.addAnimation({
            object: {
                name: "obj/bulletcasing.obj",
            },
            position: [{
                x: 0.0,
                y: 0.5,
                z: -0.6
            }],
            angle: [{
                degreesZ: 90
            }],
            scale: [{
                uniform3d: 1.4
            }],
            "instancer": {
                "count": Math.min(90, magazineSize),
                "runInstanceFunction": (properties, animationObjectInstance) => {

                    const i = properties.index;
                    const count = properties.count;
                    const time = properties.time;
                    let object = properties.object;
                    let color = properties.color;
                    let angle = properties.angle;


                    const bullet = bullets[i];

                    let scale = bullet.active;
                    object.scale.x = scale;
                    object.scale.y = scale;
                    object.scale.z = scale;

                    const bulletEjectTime = 0.4;

                    if (bullet.active <= 0.0) {
                        if (Math.abs(time - activeBulletTime) > ak47BurstRateDelay && Math.abs(time - bullet.timeStart) > bulletEjectTime) {
                            const alpha = muzzleAlpha();
                            const matrix = i == 1 ? ak47LMatrix : ak47RMatrix;
                            if (alpha > 0.9 && matrix) {
                                bullet.startMatrix = matrix;

                                ak47BurstRateDelay = 0.15 + Utils.random() * 0.2;
                                activeBulletTime = time;
                                bullet.active = 1;
                                bullet.timeStart = time;
                                bullet.degreesX = (Utils.random() * 20 - 10) * deg2rad;
                                bullet.degreesY = (Utils.random() * 20 - 10) * deg2rad;
                                bullet.degreesZ = (Utils.random() * 20 - 10) * deg2rad;
                            }
                        }
                        return;
                    }

                    const percent = (time - bullet.timeStart) / bulletEjectTime;
                    if (percent >= 1.0) {
                        bullet.active = 0;
                    }
                    const reversePercent = 1.0 - percent;
                    const y = (1.2 * reversePercent - 1.2) * 2;
                    const pos = -(1.0 - reversePercent) * 3;

                    if (bullet.startMatrix) {
                        animationObjectInstance.mesh.applyMatrix4(bullet.startMatrix.matrix);
                        animationObjectInstance.mesh.updateMatrix();
                    }

                    object.position.x = 0.0;
                    object.position.y = 0.5;
                    object.position.z = -0.6;
                    object.scale.x = 0.25;
                    object.scale.y = 0.25;
                    object.scale.z = 0.25;
                    angle.degreesX = 0;
                    angle.degreesY = 0;
                    angle.degreesZ = 90 * deg2rad;

                    object.position.x = (-y * y);
                    object.position.y = 0;
                    object.position.z = pos;

                    angle.degreesX = (time - bullet.timeStart) * -1000 * deg2rad + bullet.degreesX;
                    angle.degreesY = bullet.degreesY;
                    angle.degreesZ = bullet.degreesZ;
                }
            }
        });

        this.loader.addAnimation({
            "parent": parentId
            , "image": {
                "name": "scenes/intro/muzzle_flame.png"
            }
            , "additive": muzzleAdditive
            , "perspective": "3d"
            , "position": [{
                "x": -3.25,
                "y": 0.5,
                "z": 0
            }]
            , "color": [{ "a": muzzleAlpha }]
            , "angle": [{
                "degreesY": 0,
            }]
            , "scale": [{ "uniform3d": () => 2.0 + Math.sin(i * getSceneTimeFromStart() * 20.0) * 0.1 }]
            , "shader": {
                "name": "scenes/intro/muzzle.fs"
                , "variable": [
                    { "name": "strength", "value": [1.0] },
                    { "name": "iteration", "value": [Utils.random() * 30.0] }
                ]
            }
        });
        const muzzlePosition = {
            "x": -4.3,
            "y": 0.4,
            "z": 0
        };
        this.loader.addAnimation({
            "parent": parentId
            , "image": {
                "name": "scenes/intro/tex_muzzle.png"
            }
            , material: { side: 'DoubleSide' }
            , "additive": muzzleAdditive
            , "perspective": "3d"
            , "position": [muzzlePosition]
            , "color": [{ "a": muzzleAlpha }]
            , "scale": [{ "uniform3d": () => 1.0 + Math.sin(i * getSceneTimeFromStart() * 20.0) * 0.1 }]
            , "shader": {
                "name": "scenes/intro/muzzle.fs"
                , "variable": [
                    { "name": "strength", "value": [1.0] },
                    { "name": "iteration", "value": [Utils.random() * 30.0] }
                ]
            }
        });
        this.loader.addAnimation({
            "parent": parentId
            , "image": {
                "name": "scenes/intro/tex_muzzle.png"
            }
            , material: { side: 'DoubleSide' }
            , "additive": muzzleAdditive
            , "perspective": "3d"
            , "position": [muzzlePosition]
            , "color": [{ "a": muzzleAlpha }]
            , "angle": [{
                "degreesX": -90,
            }]
            , "scale": [{ "uniform3d": () => 1.0 + Math.sin(i * getSceneTimeFromStart() * 20.0) * 0.1 }]
            , "shader": {
                "name": "scenes/intro/muzzle.fs"
                , "variable": [
                    { "name": "strength", "value": [1.0] },
                    { "name": "iteration", "value": [Utils.random() * 30.0] }
                ]
            }
        });
    };

    this.loader.addAnimation([{
        id: "humanoid",
        object: {
            name: "obj/humanoid.glb",
            animations: {
                "danc1": { "weight": () => Sync.get('Humanoid:dance1'), timeScale: 1, timescale: 125 / 60 * .25, enabled: () => Sync.get('Humanoid:dance1') < 0.01 ? false : true, loop: true },
                "kittydance": { "weight": () => Sync.get('Humanoid:kittydance'), timeScale: 1, timescale: 125 / 60, enabled: () => Sync.get('Humanoid:kittydance') < 0.01 ? false : true, loop: true },


                "danc2": { "weight": () => Sync.get('Humanoid:dance2'), timeScale: 1, timescale: 145 / 60 * .5, enabled: () => Sync.get('Humanoid:dance2') < 0.01 ? false : true, loop: true },
                "hakken": { "weight": () => Sync.get('Humanoid:hakken'), timeScale: 1, timescale: 145 / 60 * .5, enabled: () => Sync.get('Humanoid:hakken') < 0.01 ? false : true, loop: true },
                "vitru": { "weight": () => Sync.get('Humanoid:vitru'), timeScale: 1, timescale: .05, enabled: () => Sync.get('Humanoid:vitru') < 0.01 ? false : true, loop: false },
                "nolegs": { "weight": () => Sync.get('Humanoid:NoLegs'), blendMode: 'Normal', timeScale: 1, timescale: .05, enabled: () => Sync.get('Humanoid:NoLegs') < 0.01 ? false : true, loop: false },
                "hitto": { "weight": () => Sync.get('Humanoid:Jesu'), blendMode: 'Normal', timeScale: 1, timescale: .05, enabled: () => Sync.get('Humanoid:Jesu') < 0.01 ? false : true, loop: true }
            }
        },
        castShadow: true,
        position: [{
            x: () => Sync.get("Humanoid:PosXSin") * Math.sin(getSceneTimeFromStart() * 10) * 0.015,
            y: () => -.5 + Sync.get("Humanoid:PosY"),
            z: 0
        }]
        , angle: [{
            degreesY: () =>
                Sync.get('Humanoid:degreesY')
            ,
            degreesX: 0,
            // degreesZ: () => Math.sin(getSceneTimeFromStart() * 1) * 40
        }]
        , scale: [{ uniform3d: .1 }],
        shader: {
            vertexShaderPrefix: `
            uniform float uvyOffset;
            `,
            vertexShaderSuffix: `
                vMapUv.y += uvyOffset;
        `,
            fragmentShaderPrefix: `
          uniform float colorR;
          uniform float colorG;
          uniform float colorB;
        `,
            fragmentShaderSuffix: `
          gl_FragColor.rgb *= vec3(colorR, colorG, colorB);
        `,
            variable: [
                { name: 'colorR', value: [() => Sync.get('Humanoid:ColorR')] },
                { name: 'colorG', value: [() => Sync.get('Humanoid:ColorG')] },
                { name: 'colorB', value: [() => Sync.get('Humanoid:ColorB')] },
                { name: 'uvyOffset', value: [() => Sync.get('Humanoid:UVYOffset')] },
            ]
        }
    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Head",
        object: {
            name: "obj/techead.obj",
        }
        , position: [{
            x: 0.0,
            y: .03,
            z: 0
        }],

        visible: () => Sync.get('Humanoid:TechheadScale') > 0.01
        , scale: [{ uniform3d: () => .075 * Sync.get('Humanoid:TechheadScale') + 0.5 * Sync.get('Music:Kick') * Sync.get('Humanoid:TechheadScale') * .03 }],
        shader: {
            fragmentShaderPrefix: window.hueFSPrefix,
            fragmentShaderSuffix: window.hueFSSuffix,
            variable: [
                { name: 'hueRotate', value: [() => Sync.get('Humanoid:HueRotateTechHead')] },
                { name: 'saturation', value: [() => Sync.get('Humanoid:SaturationTechHead')] },

                { name: 'enabled', value: [1.0] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Head",
        id: "allseeingHead",
        object: {
            name: "obj/obj_allseeing.obj",
        }
        , position: [{
            x: 0.0,
            y: .15,
            z: 0
        }]

        , angle: [{

            degreesY: () => getSceneTimeFromStart() * 90 * Sync.get('Humanoid:AllseeingDirection'),

        }],
        visible: () => Sync.get('Humanoid:AllSeeingHeadScale') > 0.01
        , scale: [{ uniform3d: () => .075 * Sync.get('Humanoid:AllSeeingHeadScale') }]
    }]);

    this.loader.addAnimation({
        parent: "allseeingHead",
        object: {
            name: null
        },
        shape:{
            type: 'TORUSKNOT',
            p:1,
            q:1,
            tube:0.05,
            radius:0.5,
        },
        angle:[{
            degreesX: 90
        }],
        position:[{x:-0.2,y:1.0,z:0}],
        visible: () => Sync.get('Humanoid:AngelWingsScale') > 0.01
        , scale: [{ uniform3d: () => Sync.get('Humanoid:AngelWingsScale')/0.1 }]
    });

    this.loader.addAnimation([{
        parent: "allseeingHead",
        object: {
            name: "obj/eyebeam.obj",
        },
        additive: true,
        color: [{
            r: 1, g: 1, b: 1
        }],
        position: [{
            x: 0.0,
            y: -0.425,
            z: 0.00
        }],
        scale: [{ uniform3d: () => Sync.get('Humanoid:HeadBeam') * .73 + (Sync.get('Humanoid:HeadBeam') < 0.01 ? 0 : 1) * Math.abs(Math.sin(getSceneTimeFromStart() * 10)) * .03 }],
        shader: {
            name: ['scenes/intro/laser.fs'],
            fragmentShaderSuffix: `drawLaser();`,
            variable: [
                { name: 'enabled', value: [1.0] },
                { name: 'hueRotate', value: [() => getSceneTimeFromStart()] },
            ]
        },
    }]);

    this.loader.addAnimation([{
        parent: "allseeingHead",
        object: {
            name: "obj/eyebeam.obj",
        },
        additive: true,
        color: [{
            r: 2, g: 2, b: 0
        }],
        position: [{
            x: 0.0,
            y: -0.425,
            z: 0.00
        }],

        scale: [{ uniform3d: () => Sync.get('Humanoid:HeadBeam') * 1.08 + (Sync.get('Humanoid:HeadBeam') < 0.01 ? 0 : 1) * Math.abs(Math.sin(getSceneTimeFromStart() * 10)) * .03 }],
        shader: {
            name: ['scenes/intro/laser.fs'],
            fragmentShaderSuffix: `drawLaser();`,
            variable: [
                { name: 'enabled', value: [1.0] },
                { name: 'hueRotate', value: [() => getSceneTimeFromStart()] },
            ]
        },
    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Head",
        id: "VilleHead",
        object: {
            name: "obj/helloville.obj",
        }
        , position: [{
            x: 0.0,
            y: -.01,
            z: 0
        }]

        , angle: [{

            degreesX: () => Math.sin(getSceneTimeFromStart() * window.beat * 4 * Math.PI * 2) * 70 + 35,

        }]
        , scale: [{ uniform3d: () => .075 * Sync.get('Humanoid:VilleHeadScale') }]
    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Head",
        object: {
            name: "obj/dabomb.obj",
        }
        , position: [{
            x: 0.0,
            y: .09,
            z: 0
        }],
        visible: () => Sync.get('Humanoid:BombHead') > 0.01,
        angle: [{

            degreesY: 0

        }]
        , scale: [{ uniform3d: () => .2 + Sync.get('Humanoid:BombHeadScaleAdd') }]
    }]);
    /*
        this.loader.addAnimation([{
            parent: "humanoid.HandL",
            object: {
                name: "obj/farjan.obj",
            }
            , position: [{
                x: 0,
                y: 0,
                z: 0.0
            }]
            , angle: [{
                degreesY: 125,
                degreesX: () => getSceneTimeFromStart() * 350,
                degreesZ: 90
            }]
            , scale: [{ uniform3d: .05 }]
        }]);
    */
    this.loader.addAnimation([{
        parent: "humanoid.HandL",
        object: null,
        id: "handLRoot"
        , position: [{
            x: 0,
            y: 0.00,
            z: 0,
        }],
    }]);

    this.loader.addAnimation([{
        parent: "humanoid.HandR",
        object: null,
        id: "handRRoot"
        , position: [{
            x: 0,
            y: 0.00,
            z: 0,
        }],
    }]);

    this.loader.addAnimation([{
        parent: "handLRoot",
        object: {
            name: "obj/penta.obj",
        }
        , position: [{
            x: -0.15,
            y: 0.0,
            z: 0.0
        }],
        color: [{
            r: 1,
            g: 0,
            b: 0
        }],
        visible: () => Sync.get('Humanoid:PentaHand') > 0.01
        , angle: [{
            //degreesZ: -90,
            degreesX: () => getSceneTimeFromStart() * 360
        }]
        , scale: [{ uniform3d: .11 }]
    }]);

    this.loader.addAnimation([{
        parent: "handRRoot",
        object: {
            name: "obj/CROSS.obj",
        }
        , position: [{
            x: 0.16,
            y: 0.05,
            z: 0.0
        }],
        color: [{
            r: 0,
            g: 0,
            b: 0
        }],
        visible: () => Sync.get('Humanoid:PentaHand') > 0.01
        , angle: [{
            degreesZ: -90,
            degreesX: () => -getSceneTimeFromStart() * 360
        }]
        , scale: [{ uniform3d: .02 }]
    }]);

    this.loader.addAnimation([{
        parent: "handLRoot",
        id: "ak47L",
        object: {
            name: "obj/obj_ak.obj",
        }
        , position: [{
            x: 0,
            y: 0,
            z: 0.0
        }],
        visible: () => Sync.get('Humanoid:AkHand') > 0.01
        , angle: [{
            degreesZ: -90,
            degreesY: () => Sync.get('Humanoid:AkYRotation')
        }]
        , scale: [{ uniform3d: .11 }]
        , runFunction: (animationDefinition) => {
            ak47LMatrix = animationDefinition.ref.cloneMatrix(true);
        }
    }]);
    muzzleFire("ak47L", 1);

    this.loader.addAnimation([{
        parent: "handRRoot",
        id: "ak47R",
        object: {
            name: "obj/obj_ak.obj",
        }
        , position: [{
            x: 0,
            y: 0,
            z: 0.0
        }],
        visible: () => Sync.get('Humanoid:AkHand') > 0.01
        , angle: [{
            degreesZ: -90,
            degreesY: () => Sync.get('Humanoid:AkYRotationR')
        }]
        , scale: [{ uniform3d: .11 }]
        , runFunction: (animationDefinition) => {
            ak47RMatrix = animationDefinition.ref.cloneMatrix(true);
        }
    }]);
    muzzleFire("ak47R", 2);

    // Eyeboobs
    this.loader.addAnimation([{
        parent: "humanoid.TorsoMid",
        object: null,
        id: "allseeingRoot"
        , position: [{
            x: 0,
            y: 0,
            z: 0,
        }]
    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Leg1R",
        object: null,
        id: "Leg1RRoot"
        , position: [{
            x: 0,
            y: 0,
            z: 0,
        }]
    }]);

    // angel wings

    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/angelwing.obj",
        }
        , position: [{
            x: 0,
            y: 0.2,
            z: -0.1,
        }],
        angle: [{
            degreesX: 90,
        }],
        visible: () => Sync.get('Humanoid:AngelWingsScale') > 0.01
        , scale: [{ uniform3d: () => Sync.get('Humanoid:AngelWingsScale') }]
    }]);
    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/angelwing.obj",
        }
        , position: [{
            x: 0,
            y: 0.2,
            z: -0.1,
        }],
        angle: [{
            degreesY: 180,
            degreesX: -90,
        }],
        visible: () => Sync.get('Humanoid:AngelWingsScale') > 0.01
        , scale: [{ uniform3d: () => Sync.get('Humanoid:AngelWingsScale') }]
    }]);
    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/obj_allseeing.obj",
        }
        , position: [{
            x: 0.05,
            y: () => 0.09 - Math.sin(1.2 + getSceneTimeFromStart() * window.beat * 4 * Math.PI * 2) * .02,
            z: 0.065,
        }],
        angle: [{
            degreesZ: 5,
            degreesX: -9,
            degreesY: () => Math.sin(1.2 + getSceneTimeFromStart() * window.beat * 4 * Math.PI * 2) * 20,
        }],
        visible: () => Sync.get('Humanoid:AllSeeingBoobs') > 0.01
        , scale: [{ uniform3d: () => (.06 + Sync.get('Music:Kick') * .03) * (Sync.get('Humanoid:AllSeeingBoobs')) }],
        color: [{
            r: () => Sync.get('Humanoid:AllSeeingBoobColorR'),
            g: () => Sync.get('Humanoid:AllSeeingBoobColorG'),
            b: () => Sync.get('Humanoid:AllSeeingBoobColorB'),
        }]
    }]);


    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/obj_allseeing.obj",
        }
        , position: [{
            x: -0.05,
            y: () => 0.09 - Math.sin(1.5 + getSceneTimeFromStart() * window.beat * 4 * Math.PI * 2) * .02,
            z: 0.065,
        }],
        angle: [{
            degreesZ: -5,
            degreesX: -9,
            degreesY: () => -Math.sin(1.5 + getSceneTimeFromStart() * window.beat * 4 * Math.PI * 2) * 20
        }],
        visible: () => Sync.get('Humanoid:AllSeeingBoobs') > 0.01
        , scale: [{ uniform3d: () => (.06 + Sync.get('Music:Snare') * .03) * (Sync.get('Humanoid:AllSeeingBoobs')) }],
        color: [{
            r: () => Sync.get('Humanoid:AllSeeingBoobColorR'),
            g: () => Sync.get('Humanoid:AllSeeingBoobColorG'),
            b: () => Sync.get('Humanoid:AllSeeingBoobColorB'),
        }]
    }]);


    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/tv.obj",
        }
        , position: [{
            x: 0,
            y: 0,
            z: 0.06,
        }],
        angle: [{
            degreesY: 180,
            degreesZ: () => 10 * Math.sin(5 * getSceneTimeFromStart())
        }],
        visible: () => Sync.get('Humanoid:StomachTV') > 0.01
        , scale: [{ uniform3d: () => (.05 + Sync.get('Music:Kick') * .03) * (.05 + Sync.get('Humanoid:StomachTV')) }],
        shader: {
            vertexShaderPrefix: `
            uniform float uvyOffset;
            `,
            vertexShaderSuffix: `
                vMapUv.y += uvyOffset;
        `,
            variable: [
                { name: 'uvyOffset', value: [() => Sync.get('Music:PercSeq8Instant') * .125 + 0.01 * Math.sin(getSceneTimeFromStart() * 5)] }
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "humanoid.TorsoLow",
        id: "torsoLowRoot",
        object: null
        , position: [{
            x: 0,
            y: 0.00,
            z: 0.00,
        }],
        angle: [{
            degreesY: () => Sync.get('Humanoid:LonkeroScale') > 0.01 ? Sync.get('Humanoid:AllseeingDirection') * (-getSceneTimeFromStart() * 90) : 0,
        }]

    }]);

    for (let k = 0; k < 2; k++) {
        for (let i = 0; i < 6; i++) {
            const angleRad = (i * 60 + 30) * Math.PI / 180;
            const tiltAmount = 45;
            this.loader.addAnimation([{
                parent: "torsoLowRoot",
                object: {
                    name: "obj/lonkero.obj",
                }
                , position: [{
                    x: 0,
                    y: .050,
                    z: 0.00,
                }],
                angle: [{
                    degreesY: i * 60 + 30,
                    degreesX: 0,
                    degreesZ: () => 70 - 35 * k + 10 * Math.sin(i * 3 + getSceneTimeFromStart() * 10)
                }]
                , scale: [{ uniform3d: () => Sync.get('Humanoid:LonkeroScale') * -.075 }]
                , shader: {
                    vertexShaderPrefix: `
          uniform float time;
        `,
                    vertexShaderSuffix: ` 
          vec3 pos = position;
          
          float distFactor = length(position);
          pos.y = pos.y;
          pos.x = pos.x + distFactor * .1*sin(5.0*time+pos.y*.5);
          pos.z = pos.z + distFactor * .1*cos(4.0*time+pos.y*.45);
          gl_Position = projectionMatrix * modelViewMatrix * vec4(pos, 1.0);
        `
                }
            }]);
        }
    }
    this.loader.addAnimation([{
        parent: "torsoLowRoot",
        object: {
            name: "obj/heart.obj",
        }
        , position: [{
            x: 0,
            y: 0,
            z: 0.07,
        }],
        angle: [{
            degreesZ: 0,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:HeartScale') * .028 }],
        visible: () => Sync.get('Humanoid:HeartScale') > 0.01,
        color: [{
            r: () => 0,
            g: () => 0,
            b: () => 0,
        }],
        material: {
            side: 'BackSide'
        }
    }]);


    this.loader.addAnimation([{
        parent: "torsoLowRoot",
        object: {
            name: "obj/heart.obj",
        }
        , position: [{
            x: 0,
            y: 0,
            z: 0.07,
        }],
        angle: [{
            degreesZ: 0,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:HeartScale') * .025 }],
        visible: () => Sync.get('Humanoid:HeartScale') > 0.01,
        color: [{
            r: () => 1,
            g: () => 0,
            b: () => 0,
        }]
    }]);

    const syringeShader = {
        name: ['scenes/intro/syringe.fs'],
        fragmentShaderSuffix: `drawSyringeFluid();`,
    };

    this.loader.addAnimation([{
        parent: "torsoLowRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe1Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }
        }
        , position: [{
            x: () => -.2 - .2 * Sync.get('Humanoid:SyringeDist'),
            y: () => -.1 * Sync.get('Humanoid:SyringeDist'),
            z: 0.00,
        }],
        angle: [{
            degreesZ: 115,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .1 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.0] },
            ]
        }
    }]);

    this.loader.addAnimation([{
        parent: "torsoLowRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe2Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }
        }
        , position: [{
            x: () => .13 + .2 * Sync.get('Humanoid:SyringeDist2'),
            y: () => -.05 + -.1 * Sync.get('Humanoid:SyringeDist2'),
            z: 0.16,
        }],
        angle: [{
            degreesZ: -40,
            degreesX: 110,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .1 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.1] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "torsoLowRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe3Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false },

            }
        }
        , position: [{
            x: () => .04 + .2 * Sync.get('Humanoid:SyringeDist3'),
            y: () => .13 + -.1 * Sync.get('Humanoid:SyringeDist3'),
            z: 0.16,
        }],
        angle: [{
            degreesZ: -20,
            degreesX: 60,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .08 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.2] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "Leg1RRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe4Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }
        }
        , position: [{
            x: () => .2 * Sync.get('Humanoid:SyringeDist4'),
            y: () => .1 - .1 * Sync.get('Humanoid:SyringeDist4'),
            z: 0.15,
        }],
        angle: [{
            degreesZ: -90,
            degreesY: -90,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .1 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.3] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe5Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }
        }
        , position: [{
            x: () => .15 + .2 * Sync.get('Humanoid:SyringeDist5'),
            y: () => .2 + .1 * Sync.get('Humanoid:SyringeDist5'),
            z: 0.15,
        }],
        angle: [{
            degreesY: - 55,
            degreesZ: -60,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .1 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.4] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe6Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }
        }
        , position: [{
            x: () => -.1 - .2 * Sync.get('Humanoid:SyringeDist6'),
            y: () => .2 + .1 * Sync.get('Humanoid:SyringeDist6'),
            z: -0.15,
        }],
        angle: [{
            degreesY: -90,
            degreesZ: 60,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .1 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.5] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "allseeingRoot",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe7Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }

        }
        , position: [{
            x: () => -.17 - .2 * Sync.get('Humanoid:SyringeDist7'),
            y: () => .13 + .1 * Sync.get('Humanoid:SyringeDist7'),
            z: 0.11,
        }],
        angle: [{
            degreesY: 45,
            degreesZ: 75,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * .1 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.6] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "VilleHead",
        object: {
            name: "obj/syringe.glb",
            animations: {
                "ruisk": { "weight": () => Sync.get('Humanoid:Syringe8Anim'), timeScale: 1, timescale: 5, enabled: true, loop: false }
            }
        }
        , position: [{
            x: () => 1.95 - .2 * Sync.get('Humanoid:SyringeDist8'),
            y: () => 2.5 + 1 * Sync.get('Humanoid:SyringeDist8'),
            z: -2.5,
        }],
        angle: [{
            degreesY: 45,
            degreesZ: -75,
        }]
        , scale: [{ uniform3d: () => Sync.get('Humanoid:SyringeScale') * 1.2 }],
        visible: () => Sync.get('Humanoid:SyringeScale') > 0.01,
        shader: {
            ...syringeShader,
            variable: [
                { name: 'time', value: [() => getSceneTimeFromStart()] },
                { name: 'hue', value: [0.7] },
            ]
        }

    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Leg2R",
        object: {
            name: "obj/rullis.obj",
        }
        , position: [{
            x: 0.0,
            y: 0,
            z: 0
        }]

        , scale: [{ uniform3d: 0.06 }]
        , visible: () => (Sync.get('Humanoid:VilleHeadScale') > 0.01)
    }]);

    this.loader.addAnimation([{
        parent: "humanoid.Leg2L",
        object: {
            name: "obj/rullis.obj",
        }
        , position: [{
            x: 0.0,
            y: 0,
            z: 0
        }]


        , visible: () => (Sync.get('Humanoid:VilleHeadScale') > 0.01),
        scale: [{ uniform3d: 0.06 }]
    }]);
}