instanceProto.tick = function()
    {
        if(this.pack_data)
        {
            //console.log("tick");

            this.pack_renderer.stepTime(1);
            this.dirty = true;
            this.runtime.redraw = true;


            if(this.first_run)
            {
                /*this.first_run = false;
                // Compute Pixel Scaling
                var target_creature = this.creature_manager["target_creature"];
                target_creature["ComputeBoundaryMinMax"]();
                var mesh_size_x = target_creature["boundary_max"][0] - target_creature["boundary_min"][0];
                var mesh_size_y = target_creature["boundary_max"][1] - target_creature["boundary_min"][1];

                this.pixel_scale_x = 1.0 / mesh_size_x;
                this.pixel_scale_y = 1.0 / mesh_size_y;*/

                this.pixel_scale_x = 0.1;
                this.pixel_scale_y = 0.1;
            }

        }
    };



    instanceProto.drawGL = function (glw)
    {
        if(!this.pack_renderer)
            return;

        glw.endBatch();
        var gl = glw.gl;

        //init buffers
        if(!this._vertexBuffer)
        {
            this._vertexBuffer = gl.createBuffer();
            this._indexBuffer = gl.createBuffer();
            this._uvBuffer = gl.createBuffer();

            gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer);
            gl.bufferData(gl.ARRAY_BUFFER, this.verticies, gl.DYNAMIC_DRAW);

            gl.bindBuffer(gl.ARRAY_BUFFER, this._uvBuffer);
            gl.bufferData(gl.ARRAY_BUFFER,  this.uvs, gl.DYNAMIC_DRAW);

        }

        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
        gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, this.indices, gl.DYNAMIC_DRAW);

        //c2 setup
        glw.setTexture(this.webGL_texture);
        glw.setOpacity(this.opacity);

        // save matrix
        mat4.set(glw.matMV, this.saved_mat);

        glw.translate(this.x, this.y);
        glw.rotateZ(this.angle);
        glw.scale(this.width * this.pixel_scale_x * this.xFlip, this.height * this.pixel_scale_y * this.yFlip);
        glw.updateModelView();
        glw.endBatch();

        // update
        if(!this.dirty)
        {

            gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer);
            //gl.bufferSubData(gl.ARRAY_BUFFER, 0, this.verticies);
            gl.vertexAttribPointer(glw.currentShader.locAPos, 2, gl.FLOAT, false, 0, 0);

            // update the uvs
            gl.bindBuffer(gl.ARRAY_BUFFER, this._uvBuffer);
            gl.vertexAttribPointer(glw.currentShader.locATex, 2, gl.FLOAT, false, 0, 0);
        }
        else
        {
            //var target_creature = this.creature_manager["target_creature"];
            var pt_index = 0;
            var uv_index = 0;
            var write_pt_index = 0;

            this.pack_renderer.syncRenderData();


            for(var i = 0; i < this.pack_renderer.render_points.length; i+=2)
            {
                this.verticies[i] = this.pack_renderer.render_points[i];
                this.verticies[i + 1] = -this.pack_renderer.render_points[i + 1];

                this.uvs[i] = this.pack_renderer.render_uvs[i];
                this.uvs[i + 1] = this.pack_renderer.render_uvs[i + 1];
            }


            /*for(var i = 0; i < this.pack_renderer.render_points.length; i++)
            {
                this.verticies[write_pt_index] = this.pack_renderer["render_points"][pt_index];
                this.verticies[write_pt_index + 1] = -this.pack_renderer["render_points"][pt_index + 1];

                this.uvs[uv_index] = this.pack_renderer["render_uvs"][uv_index];
                this.uvs[uv_index + 1] = this.pack_renderer["render_uvs"][uv_index + 1];

                pt_index += 3;
                uv_index += 2;

                write_pt_index += 2;
            }*/


            this.dirty = false;
            gl.bindBuffer(gl.ARRAY_BUFFER, this._vertexBuffer);
            gl.bufferData(gl.ARRAY_BUFFER, this.verticies, gl.DYNAMIC_DRAW);
            gl.vertexAttribPointer(glw.currentShader.locAPos, 2, gl.FLOAT, false, 0, 0);

            // update the uvs
            gl.bindBuffer(gl.ARRAY_BUFFER, this._uvBuffer);
            gl.bufferData(gl.ARRAY_BUFFER, this.uvs, gl.DYNAMIC_DRAW);
            gl.vertexAttribPointer(glw.currentShader.locATex, 2, gl.FLOAT, false, 0, 0);
        }
        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, this._indexBuffer);
        gl.drawElements(gl.TRIANGLES, this.indices.length, gl.UNSIGNED_SHORT, 0);
        //c2 post setup
        // restore c2 index buffer
        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, glw.indexBuffer);

        // swap mat with saved
        var tmp = glw.matMV
        glw.matMV = this.saved_mat;
        this.saved_mat = tmp;

        glw.updateModelView();
    };


    function Acts() {};

    instanceProto.postLoad = function(data){
        this.pack_data = data;
        this.creature_pack = new CreaturePackLoader(data);
        this.pack_renderer = new CreatureHaxeBaseRenderer(this.creature_pack);
        //this.pack_renderer.setActiveAnimation("dance");
        this.pack_renderer.setActiveAnimation("run");


        this.verticies = new Float32Array(this.pack_renderer.render_points.length);
        this.uvs = new Float32Array(this.pack_renderer.render_uvs.length);
        this.yFlip = 1.0;
        this.xFlip = 1.0;

        this.indices = new Uint16Array(this.creature_pack.indices.length);
        for(var i = 0; i < this.indices.length; i++)
        {
            this.indices[i] = this.creature_pack.indices[i];
        }


        this.dirty = true;
    };


    Acts.prototype.loadCreature2dPack = function (file)
    {
        var self = this;
        JSZipUtils.getBinaryContent(file, function(err, data) {
            console.log("creature pack downloaded");
            //console.log(data);
            self.postLoad(data);
        });

    };