#include "creaturegodot.h"
#include <core/bind/core_bind.h>
#include <core/config/engine.h>
#include <string>
#include <iostream>
#include <fstream>
#include <sstream>

static std::map<std::string, std::shared_ptr<CreatureModule::CreatureAnimation> > global_animations;
static std::map<std::string, std::shared_ptr<CreatureModule::CreatureLoadDataPacket> > global_load_data_packets;

//#define _CREATURE_DEBUG

static bool is_file_exist(const char *fileName)
{
	Ref<_File> file;
	file.instance();
	return file->file_exists(fileName);
}

static std::string GetAnimationToken(const std::string& filename_in, const std::string& name_in)
{
    return filename_in + std::string("_") + name_in;
}

static bool 
LoadDataPacket(const std::string& filename_in)
{
    if(!is_file_exist(filename_in.c_str()))
    {
        return false;
    }
    
    if (global_load_data_packets.count(filename_in) > 0)
    {
        // file already loaded, just return
        return true;
    }
    //////////////////////////////////////////////////////////////////////////
    //Changed!
    //////////////////////////////////////////////////////////////////////////
    std::shared_ptr<CreatureModule::CreatureLoadDataPacket> new_packet =
        std::make_shared<CreatureModule::CreatureLoadDataPacket>();

    // load regular JSON
    Ref<_File> file;
	file.instance();
	if (file->open(filename_in.c_str(), _File::READ) == Error::OK) {
		String data = file->get_as_text();
		std::string text(data.utf8().get_data());
		CreatureModule::LoadCreatureJSONDataFromString(text, *new_packet);
		file->close();
	}    
    global_load_data_packets[filename_in] = new_packet;

    return true;
}

static void load_animation(const std::string& filename_in, const std::string& name_in)
{
    auto cur_token = GetAnimationToken(filename_in, name_in);
    if (global_animations.count(cur_token) > 0)
    {
        // animation already exists, just return
        return;
    }

    auto load_data = global_load_data_packets[filename_in];

    std::shared_ptr<CreatureModule::CreatureAnimation> new_animation =
        std::make_shared<CreatureModule::CreatureAnimation>(*load_data, name_in);

    global_animations[cur_token] = new_animation;
}

static bool add_loaded_animation(CreatureModule::CreatureManager * creature_manager, const std::string& filename_in, const std::string& name_in)
{
    auto cur_token = GetAnimationToken(filename_in, name_in);
    if (global_animations.count(cur_token) > 0)
    {
        creature_manager->AddAnimation(global_animations[cur_token]);
        creature_manager->SetIsPlaying(true);
        creature_manager->SetShouldLoop(true);
        return true;
    }
    else {
#ifdef _CREATURE_DEBUG        
        std::cout << "ERROR! ACreatureActor::AddLoadedAnimation() Animation with filename: " << filename_in << " and name: " << name_in << " not loaded!" << std::endl;
#endif        
    }

    return false;
}

// CreatureGodot
CreatureGodot::CreatureGodot() {
    color=Color(1,1,1);
    rect_cache_dirty=true;
    anim_speed = 2.0f;
    mirror_y = false;
    anim_frame = 0.0f;
    indices_process_mode = INDICES_MODE_NONE;    
    reload_data = false;
    run_morph_targets = false;
}

bool 
CreatureGodot::load_json(const String filename_in)
{
#ifdef _CREATURE_DEBUG        
    std::cout<<"CreatureGodot::load_json() - Loading file: "<<global_path.utf8()<<std::endl;
#endif    
    auto can_load = LoadDataPacket(filename_in.utf8().get_data());
    if(!can_load)
    {
#ifdef _CREATURE_DEBUG        
        std::cout<<"CreatureGodot::load_json() - ERRROR! Could not load file: "<<load_filename<<std::endl;
#endif
        return false;
    }
#ifdef _CREATURE_DEBUG        
    std::cout<<"CreatureGodot::load_json() - Finished loading file: "<<load_filename<<std::endl;
#endif
    auto json_data = global_load_data_packets[filename_in.utf8().get_data()];
    auto cur_creature = std::shared_ptr<CreatureModule::Creature>(new CreatureModule::Creature(*json_data));    
    manager = std::unique_ptr<CreatureModule::CreatureManager> (new CreatureModule::CreatureManager(cur_creature));
    
    auto all_animation_names = manager->GetCreature()->GetAnimationNames();
    auto first_animation_name = all_animation_names[0];
    for (auto& cur_name : all_animation_names)
    {
#ifdef _CREATURE_DEBUG        
        std::cout<<"CreatureGodot::load_json() - Trying to load animation: "<<cur_name<<std::endl;
#endif        
        load_animation(filename_in.utf8().get_data(), cur_name);
        add_loaded_animation(manager.get(), filename_in.utf8().get_data(), cur_name);
#ifdef _CREATURE_DEBUG        
        std::cout<<"CreatureGodot::load_json() - Loaded animation: "<<cur_name<<std::endl;
#endif        
    }
    
    manager->SetActiveAnimationName(first_animation_name);

    if(!Engine::get_singleton()->is_editor_hint())
    {
#ifdef _CREATURE_DEBUG        
        std::cout<<"CreatureGodot::load_json() -Enabling AutoBlending for: "<<filename_in.utf8()<<std::endl;
#endif        
        manager->SetAutoBlending(true);        
    }
    else {
#ifdef _CREATURE_DEBUG        
        std::cout<<"CreatureGodot::load_json() -In Editor, Disabling Autoblending for: "<<filename_in.utf8()<<std::endl;
#endif        
    }
    anim_name = String(first_animation_name.c_str());
    
    return true;
}

bool CreatureGodot::blend_to_animation(String animation_name, float blend_delta)
{
    auto real_anim_name = std::string(animation_name.utf8());
    if(manager->GetAllAnimations().count(real_anim_name) == 0)
    {
#ifdef _CREATURE_DEBUG        
        std::cout<<"CreatureGodot::blend_to_animation() - ERROR! Animation name: "<<real_anim_name<<" does not exist."<<std::endl;
#endif        
        return false;
    }
    
    manager->AutoBlendTo(real_anim_name, blend_delta);
    
    return true;
}

void CreatureGodot::set_skinswap_name(String name_in)
{
    skinswap_name = name_in;
}

void CreatureGodot::set_should_loop(bool flag_in)
{
    manager->SetShouldLoop(flag_in);
}

void 
CreatureGodot::set_anim_speed(float value_in)
{
    anim_speed = value_in;
}

float 
CreatureGodot::get_anim_speed() const{
    return anim_speed;   
}

void CreatureGodot::set_anim_frame(float frame_in)
{
    if(manager)
    {
        anim_frame = frame_in;
        manager->setRunTime(frame_in);
        update_animation(0.0f);
    }
}

float CreatureGodot::get_anim_frame() const
{
    return anim_frame;   
}
    
void CreatureGodot::set_anim_name(String name_in)
{
    if(manager)
    {
        auto retval = blend_to_animation(name_in, 1.0f);
        if(retval)
        {
            update_animation(0.0f);
            anim_name = name_in;            
        }
    }
}

String CreatureGodot::get_anim_name() const
{
    return anim_name;
}

void CreatureGodot::enable_skinswap()
{
    indices_process_mode = INDICES_MODE_SKINSWAP;
}

void CreatureGodot::enable_layerorder()
{
    indices_process_mode = INDICES_MODE_ORDER;    
}

void CreatureGodot::disable_skinswap_or_order()
{
    indices_process_mode = INDICES_MODE_NONE;
}

void CreatureGodot::update_colors()
{
    if(manager)
    {
        if(fill_colors.size() != manager->GetCreature()->GetTotalNumPoints())
        {
            fill_colors.resize(manager->GetCreature()->GetTotalNumPoints());
        }

        auto& regions_map = manager->GetCreature()->GetRenderComposition()->getRegionsMap();
        for (auto& cur_region_pair : regions_map)
        {
            auto cur_region = cur_region_pair.second;
            auto start_pt_index = cur_region->getStartPtIndex();
            auto end_pt_index = cur_region->getEndPtIndex();
            auto cur_alpha = cur_region->getOpacity() / 100.0f;
    		auto cur_red = cur_region->getRed() / 100.0f;
    		auto cur_green = cur_region->getGreen() / 100.0f;
    		auto cur_blue = cur_region->getBlue() / 100.0f;
            // Check for custom color overrides
            if(!custom_region_colors.empty()) {
                auto c_iter = custom_region_colors.find(cur_region->getName());
                if(c_iter != custom_region_colors.end())
                {
                    auto& custom_color = c_iter->second;
                    cur_red = custom_color.r;
                    cur_green = custom_color.g;
                    cur_blue = custom_color.b;
                    cur_alpha = custom_color.a;
                }
            }
            // Write final colors
            for (auto i = start_pt_index; i <= end_pt_index; i++)
            {
                fill_colors.write[i].r = color.r * cur_red * cur_alpha;
                fill_colors.write[i].g = color.g * cur_green * cur_alpha;
                fill_colors.write[i].b = color.b * cur_blue * cur_alpha;
                fill_colors.write[i].a = color.a * cur_alpha;
            }
        }
    }
}

void CreatureGodot::update_animation(float delta)
{
    auto hasEvents = [&]()
    {
        if(metadata)
        {
            if(metadata->hasEvents(manager->GetActiveAnimationName()))
            {
                return true;
            }    
        }

        return false;
    };

    auto processEvents = [&]()
    {
        std::string evt_name = 
        metadata->runEvents(
            manager->GetActiveAnimationName(),
            static_cast<int>(manager->getActualRunTime()));
        if(!evt_name.empty())
        {
            emit_signal("CreatureEvent", String(evt_name.c_str()));
        }
    };

    if(manager)
    {
        auto old_time = manager->getActualRunTime();
        bool has_events = hasEvents();                
        if(has_events)
        {
            processEvents();
        }

		bool morph_targets_valid = false;
		if (run_morph_targets && metadata) {
			morph_targets_valid = metadata->getMorphData().isValid();
		}

        auto real_delta = delta * anim_speed;
		if (morph_targets_valid) {
			metadata->updateMorphStep(manager.get(), real_delta);
		}
		else {
            manager->Update(real_delta);
		}

        if((old_time > manager->getActualRunTime()) && has_events)
        {
            metadata->resetEvents(manager->GetActiveAnimationName());
        }
        
        // resize points, uvs and indices array
        if(reload_data)
        {
            points.resize(manager->GetCreature()->GetTotalNumPoints());
            uvs.resize(points.size());
            indices.resize(manager->GetCreature()->GetTotalNumIndices());
            meta_indices.resize(manager->GetCreature()->GetTotalNumIndices());
            reload_data = false;
        }
        
        // fill in rendering data

        // colors
        update_colors();
        
        // indices/topology
        auto cur_indices = manager->GetCreature()->GetGlobalIndices();
        for(size_t i = 0; i < indices.size(); i++)
        {
            indices.write[i] = cur_indices[i];
        }

        // MetaData indices processing        
        if(indices_process_mode == INDICES_MODE_ORDER)
        {
            process_layerorder(static_cast<int>(manager->getActualRunTime()));
        }
        else if(indices_process_mode == INDICES_MODE_SKINSWAP)
        {
            process_skinswap();
        }
        
        // points and uvs
        auto cur_pts = manager->GetCreature()->GetRenderPts();
        auto cur_uvs = manager->GetCreature()->GetGlobalUvs();
        
        for(size_t i = 0; i < points.size(); i++)
        {
            glm::float32 cur_x = cur_pts[i * 3];
            glm::float32 cur_y = cur_pts[i * 3 + 1];
            points.write[i] = Vector2(cur_x, -cur_y);
            
            glm::float32 cur_u = cur_uvs[i * 2];
            glm::float32 cur_v = cur_uvs[i * 2 + 1];
            uvs.write[i] = Vector2(cur_u, cur_v);

        }
        
        update();
    }
}

Rect2 CreatureGodot::_edit_get_rect() const {


    if (rect_cache_dirty){
        int l =points.size();
        item_rect=Rect2();
        for(int i=0;i<l;i++) {
            Vector2 pos = points[i];
            if (i==0)
                item_rect.position = pos;
            else
                item_rect.expand_to(pos);
        }
        rect_cache_dirty=false;
    }

    return item_rect;
}

void CreatureGodot::set_offset(const Vector2& p_offset) {

    offset=p_offset;
    rect_cache_dirty=true;
    update();
}

Vector2 CreatureGodot::get_offset() const {

    return offset;
}

void CreatureGodot::edit_set_pivot(const Point2& p_pivot) {

    set_offset(p_pivot);
}

Point2 CreatureGodot::edit_get_pivot() const {

    return get_offset();
}
bool CreatureGodot::edit_has_pivot() const {

    return true;
}

void CreatureGodot::_notification(int p_what) {


    switch(p_what) {

        case NOTIFICATION_DRAW: {
            bool use_meta_indices = (indices_process_mode != INDICES_MODE_NONE);
            if((points.size() < 3) || (uvs.size() < 3) || (indices.size() % 3 != 0))
            {
                return;
            }

            if(use_meta_indices && (real_meta_indices.size() % 3 != 0))
            {
                return;
            }
            
            if(manager)
            {
               manager->SetMirrorY(mirror_y);
            }

            
            RenderingServer::get_singleton()->canvas_item_add_triangle_array(
                get_canvas_item(),
                use_meta_indices ? real_meta_indices : indices,
                points,
                fill_colors,
                uvs,
                Vector<int>(),
                Vector<float>(),
                texture.is_valid()?texture->get_rid():RID()
            );

        } break;
    }
}

void CreatureGodot::set_color(Color p_color){

    color=p_color;
    update();
}

Color CreatureGodot::get_color() const{

    return color;
}

void CreatureGodot::set_asset_filename(String filename_in)
{
    auto retval = load_json(filename_in);
    
    if(retval)
    {
        reload_data = true;
        asset_filename = filename_in;
        update_animation(0.1f);     
        rect_cache_dirty = true;   
    }
}

String CreatureGodot::get_asset_filename() const
{
    return asset_filename;
}

void CreatureGodot::set_metadata_filename(String filename_in)
{
#ifdef _CREATURE_DEBUG        
    std::cout<<"CreatureGodot - Loading MetaData: "<<global_path.utf8()<<std::endl;
#endif    

    if(filename_in.empty())
    {
        metadata_filename = "";
        return;
    }

    if(!is_file_exist(filename_in.utf8()))
    {
        return;
    }

	Ref<_File> file;
	file.instance();
    std::string metaStr;
	if (file->open(filename_in.c_str(), _File::READ) == Error::OK) {
		String data = file->get_as_text();
		metaStr = std::string(data.utf8().get_data());
		file->close();
	}    

    metadata_filename = filename_in;
    metadata = std::unique_ptr<CreatureModule::CreatureMetaData>(
        new CreatureModule::CreatureMetaData(metaStr));

    // Load Animated Region Colors
    if(manager)
    {
        metadata->updateRegionColors(manager->GetAllAnimations());
    }
}

String CreatureGodot::get_metadata_filename() const
{
    return metadata_filename;
}

void CreatureGodot::set_texture(const Ref<Texture>& p_texture){

    texture=p_texture;

    /*if (texture.is_valid()) {
        uint32_t flags=texture->get_flags();
        flags&=~Texture::FLAG_REPEAT;
        if (tex_tile)
            flags|=Texture::FLAG_REPEAT;
        texture->set_flags(flags);
    }*/
    update();
}

Ref<Texture> CreatureGodot::get_texture() const{

    return texture;
}

void CreatureGodot::set_mirror_y(bool flag_in)
{
    mirror_y = flag_in;
    update();
}

bool CreatureGodot::get_mirror_y() const
{
    return mirror_y;
}

void CreatureGodot::set_active_item_swap(String region_name, int swap_idx)
{
    if(manager)
    {
        manager->GetCreature()->SetActiveItemSwap(std::string(region_name.utf8()), swap_idx);
    }   
}

void CreatureGodot::remove_active_item_swap(String region_name)
{
    if(manager)
    {
        manager->GetCreature()->RemoveActiveItemSwap(std::string(region_name.utf8()));
    }       
}

void CreatureGodot::set_anchor_points_active(bool flag_in)
{
    if(manager)
    {
        manager->GetCreature()->SetAnchorPointsActive(flag_in);
    }
}

void CreatureGodot::make_point_cache(String animation_name_in, int gap_step)
{
    if(manager)
    {
        manager->MakePointCache(std::string(animation_name_in.utf8()), gap_step);
    }
}

void CreatureGodot::add_skinswap(String name_in, Vector<String> custom_swap)
{
    if(metadata)
    {
        std::unordered_set<std::string> swap_set;
        for(int i = 0; i < custom_swap.size(); i++)
        {
            swap_set.insert(std::string(custom_swap[i].utf8()));
        }

        metadata->addSkinSwap(std::string(name_in.utf8()), swap_set);
    }
}

void CreatureGodot::remove_skinswap(String name_in)
{
    if(metadata)
    {
        metadata->removeSkinSwap(std::string(name_in.utf8()));
    }
}

void CreatureGodot::process_skinswap()
{
    int real_indices_size = 0;
    auto render_composition = manager->GetCreature()->GetRenderComposition();    
    auto retval = metadata->buildSkinSwapIndices(
        std::string(skinswap_name.utf8()),
        render_composition,
        [&](int idx, int value)
        {
            meta_indices.write[idx] = value;
        },
        real_indices_size
    );

    if(retval)
    {
        if(real_meta_indices.size() != real_indices_size)
        {
            real_meta_indices.resize(real_indices_size);            
        }

        for(int i = 0; i < real_indices_size; i++)
        {
            real_meta_indices.write[i] = meta_indices[i];
        }
    }
}

void CreatureGodot::process_layerorder(int time_in)
{
    metadata->updateIndicesAndPoints(
        manager->GetCreature()->GetGlobalIndices(),
        [&](int idx, int value)
        {
            meta_indices.write[idx] = value;            
        },
        manager->GetCreature()->GetTotalNumIndices(),
        manager->GetActiveAnimationName(),
        time_in        
    );

    if(real_meta_indices.size() != meta_indices.size())
    {
        real_meta_indices.resize(meta_indices.size());            
    }

    for(int i = 0; i < real_meta_indices.size(); i++)
    {
        real_meta_indices.write[i] = meta_indices[i];
    }
}

Vector2 
CreatureGodot::get_bone_pos(String bone_name, float slide_factor)
{
    Vector2 ret_pt(0,0);
    
    if(manager)
    {
        auto  render_composition = manager->GetCreature()->GetRenderComposition();
        auto& bones_map = render_composition->getBonesMap();
        
        std::string real_name(bone_name.utf8());
        if(bones_map.count(real_name) == 0)
        {
            return Vector2(0,0);
        }        
        
        auto cur_bone = bones_map[real_name];
        auto pt1 = cur_bone->getWorldStartPt();
        auto pt2 = cur_bone->getWorldEndPt();
        auto rel_vec = (pt2 - pt1) * slide_factor;     
        auto set_vec = pt1 + rel_vec;
        
        // local coords
        ret_pt = Vector2(set_vec.x, set_vec.y);
        
        // transform to world coords
        get_transform().xform(ret_pt);
    }
    
    return ret_pt;
}

Vector<String> CreatureGodot::get_anim_clips() const
{
    Vector<String> ret_names;

    if(manager) {
        const auto& all_anims = manager->GetCreature()->GetAnimationNames();
        for(const auto& cur_name : all_anims)
        {
            ret_names.push_back(String(cur_name.c_str()));
        }        
    }

    return ret_names;
}


void CreatureGodot::set_morph_targets_active(bool flag_in)
{
    run_morph_targets = flag_in;
    if(run_morph_targets)
    {
        manager->SetBlending(false);
    }
}

bool CreatureGodot::get_morph_targets_active() const
{
    return run_morph_targets;
}

void CreatureGodot::set_morph_targets_pt(const Vector2& pt_in, const Vector2& base_pt, float radius)
{
    // transform to local coords
	auto char_base_pos = get_transform().xform_inv(base_pt);
	auto char_pt_pos = get_transform().xform_inv(pt_in);

    if(metadata)
    {
		if (metadata->getMorphData().isValid())
		{
			metadata->computeMorphWeightsWorld(
				glm::vec2(char_pt_pos.x, char_pt_pos.y),
				glm::vec2(char_base_pos.x, char_base_pos.y),
				radius
			);
		}        
    }
}

void CreatureGodot::set_custom_region_color(String region_name, Color color_in)
{
    custom_region_colors[std::string(region_name.utf8().ptr())] = color_in;
}

void CreatureGodot::clear_custom_region_color(String region_name)
{
    auto c_iter = custom_region_colors.find(std::string(region_name.utf8().ptr()));
    if(c_iter != custom_region_colors.end())
    {
        custom_region_colors.erase(c_iter);
    }
}

void CreatureGodot::_bind_methods() {

    ClassDB::bind_method(D_METHOD("set_color","color"),&CreatureGodot::set_color);
    ClassDB::bind_method(D_METHOD("get_color"),&CreatureGodot::get_color);

    ClassDB::bind_method(D_METHOD("set_texture","texture"),&CreatureGodot::set_texture);
    ClassDB::bind_method(D_METHOD("get_texture"),&CreatureGodot::get_texture);

    ClassDB::bind_method(D_METHOD("set_anim_speed","texture"),&CreatureGodot::set_anim_speed);
    ClassDB::bind_method(D_METHOD("get_anim_speed"),&CreatureGodot::get_anim_speed);
    
    ClassDB::bind_method(D_METHOD("set_asset_filename","asset_filename"),&CreatureGodot::set_asset_filename);
    ClassDB::bind_method(D_METHOD("get_asset_filename"),&CreatureGodot::get_asset_filename);

    ClassDB::bind_method(D_METHOD("set_metadata_filename","metadata_filename"),&CreatureGodot::set_metadata_filename);
    ClassDB::bind_method(D_METHOD("get_metadata_filename"),&CreatureGodot::get_metadata_filename);

    ClassDB::bind_method(D_METHOD("set_offset","offset"),&CreatureGodot::set_offset);
    ClassDB::bind_method(D_METHOD("get_offset"),&CreatureGodot::get_offset);

    ClassDB::bind_method(D_METHOD("set_mirror_y","offset"),&CreatureGodot::set_mirror_y);
    ClassDB::bind_method(D_METHOD("get_mirror_y"),&CreatureGodot::get_mirror_y);

    ClassDB::bind_method(D_METHOD("set_anim_frame","offset"),&CreatureGodot::set_anim_frame);
    ClassDB::bind_method(D_METHOD("get_anim_frame"),&CreatureGodot::get_anim_frame);

    ClassDB::bind_method(D_METHOD("set_anim_name","offset"),&CreatureGodot::set_anim_name);
    ClassDB::bind_method(D_METHOD("get_anim_name"),&CreatureGodot::get_anim_name);
    
    ClassDB::bind_method(D_METHOD("load_json"),&CreatureGodot::load_json);
    ClassDB::bind_method(D_METHOD("update_animation","delta"),&CreatureGodot::update_animation);
    ClassDB::bind_method(D_METHOD("blend_to_animation","animation_name","blend_delta"),&CreatureGodot::blend_to_animation);
    ClassDB::bind_method(D_METHOD("set_should_loop","flag_in"),&CreatureGodot::set_should_loop);
    ClassDB::bind_method(D_METHOD("get_anim_clips"),&CreatureGodot::get_anim_clips);
    
    ClassDB::bind_method(D_METHOD("set_skinswap_name","name_in"),&CreatureGodot::set_skinswap_name);
    ClassDB::bind_method(D_METHOD("add_skinswap","name_in","custom_swap"),&CreatureGodot::add_skinswap);
    ClassDB::bind_method(D_METHOD("remove_skinswap","name_in"),&CreatureGodot::remove_skinswap);

    ClassDB::bind_method(D_METHOD("enable_skinswap"),&CreatureGodot::enable_skinswap);
    ClassDB::bind_method(D_METHOD("enable_layerorder"),&CreatureGodot::enable_layerorder);
    ClassDB::bind_method(D_METHOD("disable_skinswap_or_order"),&CreatureGodot::disable_skinswap_or_order);
    
    ClassDB::bind_method(D_METHOD("set_active_item_swap","region_name","swap_idx"),&CreatureGodot::set_active_item_swap);
    ClassDB::bind_method(D_METHOD("remove_active_item_swap","region_name"),&CreatureGodot::remove_active_item_swap);
    
    ClassDB::bind_method(D_METHOD("set_anchor_points_active","flag_in"),&CreatureGodot::set_anchor_points_active);

    ClassDB::bind_method(D_METHOD("set_morph_targets_active","flag_in"),&CreatureGodot::set_morph_targets_active);
    ClassDB::bind_method(D_METHOD("get_morph_targets_active"),&CreatureGodot::get_morph_targets_active);
    ClassDB::bind_method(D_METHOD("set_morph_targets_pt","pt_in","base_pt","radius"),&CreatureGodot::set_morph_targets_pt);
    
    ClassDB::bind_method(D_METHOD("make_point_cache","animation_name_in","gap_step"),&CreatureGodot::make_point_cache);

    ClassDB::bind_method(D_METHOD("get_bone_pos","bone_name","slide_factor"),&CreatureGodot::get_bone_pos);

    ClassDB::bind_method(D_METHOD("set_custom_region_color","region_name","color_in"),&CreatureGodot::set_custom_region_color);
    ClassDB::bind_method(D_METHOD("clear_custom_region_color","region_name"),&CreatureGodot::clear_custom_region_color);

    ADD_PROPERTY( PropertyInfo(Variant::STRING,"anim_name"), "set_anim_name", "get_anim_name");
    ADD_PROPERTY( PropertyInfo(Variant::REAL,"anim_frame"), "set_anim_frame", "get_anim_frame");
    ADD_PROPERTY( PropertyInfo(Variant::REAL,"anim_speed"), "set_anim_speed", "get_anim_speed");
    ADD_PROPERTY( PropertyInfo(Variant::STRING,"asset_filename"), "set_asset_filename", "get_asset_filename");
    ADD_PROPERTY( PropertyInfo(Variant::STRING,"metadata_filename"), "set_metadata_filename", "get_metadata_filename");
    ADD_PROPERTY( PropertyInfo(Variant::BOOL,"mirror_y"), "set_mirror_y", "get_mirror_y");
    ADD_PROPERTY( PropertyInfo(Variant::COLOR,"color"), "set_color", "get_color");
    ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"offset"), "set_offset", "get_offset");
    ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"texture/texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"), "set_texture", "get_texture");
}