unity强力配置插件-Luban使用(一)加载保存

这篇具有很好参考价值的文章主要介绍了unity强力配置插件-Luban使用(一)加载保存。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。


前言

Luban是一种配置工具,生成c#等各种语言的代码,支持导出成bytes或json等多种格式,且能检查数据错误。unity只是其中支持的一种引擎,可以想象其功能非常强大。
不但如此,在使用的时候非常简单、方便,支持类型丰富,初学者也能迅速掌握。
插件地址
本系列版本为[classic版],注意选对版本进行示例下载和文档阅读。
unity强力配置插件-Luban使用(一)加载保存


一、安装

以下使用参照官方文档步骤,非初学者可直接跳过看官方文档即可,也可直接参考b站大佬的教学视频。
1、下载如下示例,找到LubanLib示例文件复制到unity项目Assets里即可(不要求和示例一样的Assets根目录)
示例
unity强力配置插件-Luban使用(一)加载保存
2、在项目的根目录新建,找到下载示例将如下三个文件移进去,MiniTemplate改为Config(别的也行)
unity强力配置插件-Luban使用(一)加载保存
unity强力配置插件-Luban使用(一)加载保存
3、编辑移过来的.bat文件,至于命名自己决定,规则如下:

dotnet %Luban.ClientServer.dll%
-j cfg ^
-- ^
--define_file <__root__.xml 定义文件的路径> ^
--input_data_dir <配置数据根目录(Datas)的路径> ^
--output_code_dir <生成的代码文件的路径> ^
--output_data_dir <导出的数据文件的路径> ^
--service all ^
--gen_types "code_cs_unity_json,data_json"

示例(本人项目基础类目录Assets/Scripts/Game/Base):

set WORKSPACE=..
 
set GEN_CLIENT=%WORKSPACE%\Luban\Tools\Luban.ClientServer\Luban.ClientServer.exe
set CONF_ROOT=%WORKSPACE%\Luban\Config
 
%GEN_CLIENT% -j cfg --^
 -d %CONF_ROOT%\Defines\__root__.xml ^
 --input_data_dir %CONF_ROOT%\Datas ^
 --output_code_dir %WORKSPACE%/Assets/Scripts/Game/Base ^
 --output_data_dir ..\Assets\StreamingAssets ^
 --gen_types code_cs_unity_json,data_json ^
 -s all 
 
pause

二、使用

1、运行.bat文件(如有jenkins就配置该文件即可)

using SimpleJSON;
using System.IO;
...
void xx(){
    //加载配置表
    var tables = new cfg.Tables(file => JSON.Parse(File.ReadAllText(Application.streamingAssetsPath + "/" + file + ".json")));
    //使用配置表
    cfg.item.Item itemInfo = tables.TbItem.Get(10000);
    Debug.Log(itemInfo.ToString());
   	// 支持 operator []用法
	Debug.Log(tables.TbBaseObject[10000].Id);

}

2、删除并修改unity项目的Luban/Config/Datas文件夹里的表格为自己项目的表格,即可快速食用
unity强力配置插件-Luban使用(一)加载保存

三、单表加载

细心的朋友可能发现了,上文中的默认加载方式是将表统一加载进游戏。如果有特殊需求想要将表分开加载就得自行修改,本来想改动一下,结果发现有大佬(明天不吃鱼)已经写了相关文章就直接贴这里了。
如果想改加载方式,直接修改DataManager中的ReadData和GetVOData方法改成自己的就行。
下面是我改的脚本,仅供参考:

  readonly Dictionary<string, object> tables = new Dictionary<string, object>();

        public T GetVOData<T>(string fileName,string language = "cn") where T : IVOFun, new()
        {
            var path = Application.streamingAssetsPath +"/" + language + "/" + fileName + ".json";
            if (tables.ContainsKey(fileName))
            {
                return (T)tables[fileName];
            }
            else
            {
                var data = new T();

                if (File.Exists(path)) {
                    //创建一个StreamReader,用来读取流
                    using StreamReader sr = new StreamReader(path);
                    //将读取到的流赋值给jsonStr
                    string text = sr.ReadToEnd();
                    data._LoadData(text);
                    tables.Add(fileName, data);
                }
                else
                {
                    Debug.LogError("存档文件不存在");
                }
                return data;
            }
        }

四、单表保存

比细心的朋友更细的朋友可能发现了,只有加载功能,要是项目需要保存数据还得自己写吗?事实上,这类打表工具一般是给策划使用记录游戏数据、关卡数据,方便程序使用和热更。现在不少游戏需要随机生成地形、npc等自己存储下来的需求,储存下来后可能就代表了一个存档,如果还要自己写就太不美了。
如果是网络项目或者定制项目请使用带orm的数据库,轻量级的就像SQLite这种就ok。
我们想到可以自行添加修改保存json的方法,奈何自己对scriban模板引擎不太熟悉,使用示例来偷懒下。
1、示例工程Unity_Editor_json
找到目录下的EditorText移动到工程
unity强力配置插件-Luban使用(一)加载保存
2、替换文件
unity强力配置插件-Luban使用(一)加载保存
3、给tables添加接口,并修改IVOFun添加保存方法

public interface IVOFun
{
    void _LoadData(string data);
    void _SaveData(string file);
}
public interface EditorBeanBase
{
    public void LoadJson(JSONObject json);
    public void SaveJson(JSONObject json);
}

4、修改bean文件的命名空间、保存方法

using Bright.Serialization;
using System.Collections.Generic;
using SimpleJSON;

{{
    name = x.name
    parent_def_type = x.parent_def_type
    parent = x.parent
    hierarchy_fields = x.hierarchy_fields
    fields = x.fields
    export_fields = x.export_fields
    hierarchy_export_fields = x.hierarchy_export_fields
}}

{{cs_start_name_space_grace x.namespace_with_top_module}} 

{{~if x.comment != '' ~}}
/// <summary>
/// {{x.escape_comment}}
/// </summary>
{{~end~}}
public {{x.cs_class_modifier}} partial class {{name}} : {{if parent_def_type}} {{parent}} {{else}} EditorBeanBase {{end}}
{
    public {{name}}()
    {
        {{~ for field in fields ~}}
        {{~if (cs_editor_need_init field.ctype) && !field.ctype.is_nullable ~}}
            {{field.convention_name}} = {{cs_editor_init_value field.ctype}};
        {{~end~}}
        {{~end~}}
    }

    {{~if !x.is_abstract_type~}}
    public {{if parent_def_type}}override{{end}} void LoadJson(JSONObject _json)
    {
        {{~ for field in hierarchy_fields ~}}
        { 
            var _fieldJson = _json["{{field.name}}"];
            if (_fieldJson != null)
            {
                {{cs_unity_editor_json_load '_fieldJson' field.convention_name field.ctype}}
            }
        }
        
        {{~end~}}
    }

    public {{if parent_def_type}}override{{end}} void SaveJson(JSONObject _json)
    {
        {{~if parent~}}
        _json["{{x.json_type_name_key}}"] = "{{x.full_name}}";
        {{~end~}}
        {{~ for field in hierarchy_fields ~}}
            {{~if field.ctype.is_nullable}}
        if ({{field.convention_name}} != null)
        {
            {{cs_unity_editor_json_save '_json' field.name field.convention_name field.ctype}}
        }
            {{~else~}}
        {
                {{~if (cs_is_editor_raw_nullable field.ctype)}}
            if ({{field.convention_name}} == null) { throw new System.ArgumentNullException(); }
                {{~end~}}
            {{cs_unity_editor_json_save '_json' field.name field.convention_name field.ctype}}
        }
            {{~end~}}
        {{~end~}}
    }
    {{~else~}}
     public abstract void LoadJson(JSONObject _json);
     public abstract void SaveJson(JSONObject _json);
    {{~end~}}

    public static {{name}} LoadJson{{name}}(JSONNode _json)
    {
    {{~if x.is_abstract_type~}}
        string type = _json["{{x.json_type_name_key}}"];
        {{name}} obj;
        switch (type)
        {
        {{~for child in x.hierarchy_not_abstract_children~}}
            {{~if child.namespace == x.namespace && x.namespace != '' ~}}
            case "{{child.full_name}}":   
            {{~end~}}
            case "{{cs_impl_data_type child x}}":obj = new {{child.full_name}}(); break;
        {{~end~}}
            default: throw new SerializationException();
        }
    {{~else~}}
        {{name}} obj = new {{x.full_name}}();
    {{~end~}}
        obj.LoadJson((JSONObject)_json);
        return obj;
    }
        
    public static void SaveJson{{name}}({{name}} _obj, JSONNode _json)
    {
    {{~if x.is_abstract_type~}}
        _json["{{x.json_type_name_key}}"] = _obj.GetType().Name;
    {{~end~}}
        _obj.SaveJson((JSONObject)_json);
    }

    {{~ for field in fields ~}}
{{~if field.comment != '' ~}}
    /// <summary>
    /// {{field.escape_comment}}
    /// </summary>
{{~end~}}
    public {{cs_editor_define_type field.ctype}} {{field.convention_name}} { get; set; }

    {{~end~}}


    public {{x.cs_method_modifier}} void Resolve(Dictionary<string, object> _tables)
    {
        {{~if parent_def_type~}}
        base.Resolve(_tables);
        {{~end~}}
        {{~ for field in export_fields ~}}
        {{~if field.gen_ref~}}
        {{cs_ref_validator_resolve field}}
        {{~else if field.has_recursive_ref~}}
        {{cs_recursive_resolve field '_tables'}}
        {{~end~}}
        {{~end~}}
        PostResolve();
    }

    public {{x.cs_method_modifier}} void TranslateText(System.Func<string, string, string> translator)
    {
        {{~if parent_def_type~}}
        base.TranslateText(translator);
        {{~end~}}
        {{~ for field in export_fields ~}}

        {{~end~}}
    }


    public override string ToString()
    {
        return "{{full_name}}{ "
    {{~ for field in hierarchy_export_fields ~}}
        + "{{field.convention_name}}:" + {{cs_to_string field.convention_name field.ctype}} + ","
    {{~end~}}
        + "}";
    }
    
    partial void PostInit();
    partial void PostResolve();
}

{{cs_end_name_space_grace x.namespace_with_editor_top_module}}

4、使用以下代码保存,把现有的表格进行单独保存,如果要实现存档功能把表格存在同一个文件下即可

TbBaseObject tables = new TbBaseObject();
string fileA2 = Application.streamingAssetsPath + "/a2.json";
tables._SaveData(fileA2);

注意:这里使用Editor参考修改自己的模板后,文件属性的生成格式进行了改变,部分属性(long?)格式没法用了。我这里项目不需要特殊的属性倒是没啥影响,有能力的就别替换editor模板直接进行修改吧。
还有模板的TranslateText不能使用了,进行了屏蔽,大家可以把三个模板里面的TranslateText方法全删掉。当然本地化方面有了加载单表的方法,需要切换语言的时候进行切换json即可。

下面是修改过后的三个模板:
bean.tql

using Bright.Serialization;
using System.Collections.Generic;
using SimpleJSON;

{{
    name = x.name
    parent_def_type = x.parent_def_type
    parent = x.parent
    hierarchy_fields = x.hierarchy_fields
    fields = x.fields
    export_fields = x.export_fields
    hierarchy_export_fields = x.hierarchy_export_fields
}}

{{cs_start_name_space_grace x.namespace_with_top_module}} 

{{~if x.comment != '' ~}}
/// <summary>
/// {{x.escape_comment}}
/// </summary>
{{~end~}}
public {{x.cs_class_modifier}} partial class {{name}} : {{if parent_def_type}} {{parent}} {{else}} EditorBeanBase {{end}}
{
    public {{name}}()
    {
        {{~ for field in fields ~}}
        {{~if (cs_editor_need_init field.ctype) && !field.ctype.is_nullable ~}}
            {{field.convention_name}} = {{cs_editor_init_value field.ctype}};
        {{~end~}}
        {{~end~}}
    }

    {{~if !x.is_abstract_type || parent_def_type ~}}
    public void LoadJson(JSONObject _json)
    {
        {{~ for field in hierarchy_fields ~}}
        { 
            var _fieldJson = _json["{{field.name}}"];
            if (_fieldJson != null)
            {
                {{cs_unity_editor_json_load '_fieldJson' field.convention_name field.ctype}}
            }
        }
        
        {{~end~}}
    }

    public void SaveJson(JSONObject _json)
    {
        {{~if parent~}}
        _json["{{x.json_type_name_key}}"] = "{{x.full_name}}";
        {{~end~}}
        {{~ for field in hierarchy_fields ~}}
            {{~if field.ctype.is_nullable}}
        if ({{field.convention_name}} != null)
        {
            {{cs_unity_editor_json_save '_json' field.name field.convention_name field.ctype}}
        }
            {{~else~}}
        {
                {{~if (cs_is_editor_raw_nullable field.ctype)}}
            if ({{field.convention_name}} == null) { throw new System.ArgumentNullException(); }
                {{~end~}}
            {{cs_unity_editor_json_save '_json' field.name field.convention_name field.ctype}}
        }
            {{~end~}}
        {{~end~}}
    }
    {{~end~}}

    public static {{name}} LoadJson{{name}}(JSONNode _json)
    {
    {{~if x.is_abstract_type~}}
        string type = _json["{{x.json_type_name_key}}"];
        {{name}} obj;
        switch (type)
        {
        {{~for child in x.hierarchy_not_abstract_children~}}
            {{~if child.namespace == x.namespace && x.namespace != '' ~}}
            case "{{child.full_name}}":   
            {{~end~}}
            case "{{cs_impl_data_type child x}}":obj = new {{child.full_name}}(); break;
        {{~end~}}
            default: throw new SerializationException();
        }
    {{~else~}}
        {{name}} obj = new {{x.full_name}}();
    {{~end~}}
        obj.LoadJson((JSONObject)_json);
        return obj;
    }
        
    public static void SaveJson{{name}}({{name}} _obj, JSONNode _json)
    {
    {{~if x.is_abstract_type~}}
        _json["{{x.json_type_name_key}}"] = _obj.GetType().Name;
    {{~end~}}
        _obj.SaveJson((JSONObject)_json);
    }

    {{~ for field in fields ~}}
{{~if field.comment != '' ~}}
    /// <summary>
    /// {{field.escape_comment}}
    /// </summary>
{{~end~}}
    public {{cs_editor_define_type field.ctype}} {{field.convention_name}} { get; set; }

    {{~end~}}


    public {{x.cs_method_modifier}} void Resolve(Dictionary<string, object> _tables)
    {
        {{~if parent_def_type~}}
        base.Resolve(_tables);
        {{~end~}}
        {{~ for field in export_fields ~}}
        {{~if field.gen_ref~}}
        {{cs_ref_validator_resolve field}}
        {{~else if field.has_recursive_ref~}}
        {{cs_recursive_resolve field '_tables'}}
        {{~end~}}
        {{~end~}}
        PostResolve();
    }

    public override string ToString()
    {
        return "{{full_name}}{ "
    {{~ for field in hierarchy_export_fields ~}}
        + "{{field.convention_name}}:" + {{cs_to_string field.convention_name field.ctype}} + ","
    {{~end~}}
        + "}";
    }
    
    partial void PostInit();
    partial void PostResolve();
}

{{cs_end_name_space_grace x.namespace_with_editor_top_module}}

table.tql

using Bright.Serialization;
using System.Collections.Generic;
using SimpleJSON;

{{ 
    name = x.name
    key_type = x.key_ttype
    key_type1 =  x.key_ttype1
    key_type2 =  x.key_ttype2
    value_type =  x.value_ttype
}}

{{cs_start_name_space_grace x.namespace_with_top_module}} 

{{~if x.comment != '' ~}}
/// <summary>
/// {{x.escape_comment}}
/// </summary>
{{~end~}}
public sealed partial class {{name}} : IVOFun
{
    {{~if x.is_map_table ~}}
    private readonly Dictionary<{{cs_define_type key_type}}, {{cs_define_type value_type}}> _dataMap;
    private readonly List<{{cs_define_type value_type}}> _dataList;
    
    public {{name}}()
    {
        _dataMap = new Dictionary<{{cs_define_type key_type}}, {{cs_define_type value_type}}>();
        _dataList = new List<{{cs_define_type value_type}}>();
    }

    public Dictionary<{{cs_define_type key_type}}, {{cs_define_type value_type}}> DataMap => _dataMap;
    public List<{{cs_define_type value_type}}> DataList => _dataList;

{{~if value_type.is_dynamic~}}
    public T GetOrDefaultAs<T>({{cs_define_type key_type}} key) where T : {{cs_define_type value_type}} => _dataMap.TryGetValue(key, out var v) ? (T)v : null;
    public T GetAs<T>({{cs_define_type key_type}} key) where T : {{cs_define_type value_type}} => (T)_dataMap[key];
{{~end~}}
    public {{cs_define_type value_type}} GetOrDefault({{cs_define_type key_type}} key) => _dataMap.TryGetValue(key, out var v) ? v : null;
    public {{cs_define_type value_type}} Get({{cs_define_type key_type}} key) => _dataMap[key];
    public {{cs_define_type value_type}} this[{{cs_define_type key_type}} key] => _dataMap[key];

    public void Resolve(Dictionary<string, object> _tables)
    {
        foreach(var v in _dataList)
        {
            v.Resolve(_tables);
        }
        PostResolve();
    }
        {{~else if x.is_list_table ~}}
    private readonly List<{{cs_define_type value_type}}> _dataList;
    
    {{~if x.is_union_index~}}
    private {{cs_table_union_map_type_name x}} _dataMapUnion;
    {{~else if !x.index_list.empty?~}}
    {{~for idx in x.index_list~}}
    private Dictionary<{{cs_define_type idx.type}}, {{cs_define_type value_type}}> _dataMap_{{idx.index_field.name}};
    {{~end~}}
    {{~end~}}

    public {{name}}(JSONNode _json)
    {
        _dataList = new List<{{cs_define_type value_type}}>();
        
        foreach(JSONNode _row in _json.Children)
        {
            var _v = {{cs_define_type value_type}}.Deserialize{{value_type.bean.name}}(_row);
            _dataList.Add(_v);
        }
    {{~if x.is_union_index~}}
        _dataMapUnion = new {{cs_table_union_map_type_name x}}();
        foreach(var _v in _dataList)
        {
            _dataMapUnion.Add(({{cs_table_key_list x "_v"}}), _v);
        }
    {{~else if !x.index_list.empty?~}}
    {{~for idx in x.index_list~}}
        _dataMap_{{idx.index_field.name}} = new Dictionary<{{cs_define_type idx.type}}, {{cs_define_type value_type}}>();
    {{~end~}}
    foreach(var _v in _dataList)
    {
    {{~for idx in x.index_list~}}
        _dataMap_{{idx.index_field.name}}.Add(_v.{{idx.index_field.convention_name}}, _v);
    {{~end~}}
    }
    {{~end~}}
        PostInit();
    }

    public List<{{cs_define_type value_type}}> DataList => _dataList;

    {{~if x.is_union_index~}}
    public {{cs_define_type value_type}} Get({{cs_table_get_param_def_list x}}) => _dataMapUnion.TryGetValue(({{cs_table_get_param_name_list x}}), out {{cs_define_type value_type}} __v) ? __v : null;
    {{~else if !x.index_list.empty? ~}}
        {{~for idx in x.index_list~}}
    public {{cs_define_type value_type}} GetBy{{idx.index_field.convention_name}}({{cs_define_type idx.type}} key) => _dataMap_{{idx.index_field.name}}.TryGetValue(key, out {{cs_define_type value_type}} __v) ? __v : null;
        {{~end~}}
    {{~end~}}

    public void Resolve(Dictionary<string, object> _tables)
    {
        foreach(var v in _dataList)
        {
            v.Resolve(_tables);
        }
        PostResolve();
    }

    {{~else~}}

     private readonly {{cs_define_type value_type}} _data;

    public {{name}}(JSONNode _json)
    {
        if(!_json.IsArray)
        {
            throw new SerializationException();
        }
        if (_json.Count != 1) throw new SerializationException("table mode=one, but size != 1");
        _data = {{cs_define_type value_type}}.Deserialize{{value_type.bean.name}}(_json[0]);
        PostInit();
    }

    {{~ for field in value_type.bean.hierarchy_export_fields ~}}
{{~if field.comment != '' ~}}
    /// <summary>
    /// {{field.escape_comment}}
    /// </summary>
{{~end~}}
     public {{cs_define_type field.ctype}} {{field.convention_name}} => _data.{{field.convention_name}};
    {{~end~}}

    public void Resolve(Dictionary<string, object> _tables)
    {
        _data.Resolve(_tables);
        PostResolve();
    }
    {{~end~}}
    
    public void _LoadData(string data)
    {
        JSONNode _json = JSON.Parse(data);
        foreach(JSONNode _row in _json.Children)
        {
            var _v = {{cs_define_type value_type}}.LoadJson{{value_type.bean.name}}(_row);
            _dataList.Add(_v);
            _dataMap.Add(_v.{{x.index_field.convention_name}}, _v);
        }
        PostInit();
    }

     public void _SaveData(string file)
    {            
        JSONArray jsons = new JSONArray();
        foreach (var v in _dataList) {
            JSONObject json = new JSONObject();
            v.SaveJson(json);
            jsons.Add(json);
        }
        System.IO.File.WriteAllText(file, jsons.ToString(), System.Text.Encoding.UTF8);
    }

    partial void PostInit();
    partial void PostResolve();
}

{{cs_end_name_space_grace x.namespace_with_top_module}}

tables.tql

using Bright.Serialization;
using SimpleJSON;
{{
    name = x.name
    namespace = x.namespace
    tables = x.tables
}}

{{cs_start_name_space_grace x.namespace}} 

//所有V0对象必须继承该接口
//在数据加载时调用 LoadData(外部读取的源数据)
public interface IVOFun
{
    void _LoadData(string data);
    void _SaveData(string file);
}


public interface EditorBeanBase
{
    public void LoadJson(JSONObject json);
    public void SaveJson(JSONObject json);
}

public sealed partial class {{name}}
{
    {{~for table in tables ~}}
{{~if table.comment != '' ~}}
    /// <summary>
    /// {{table.escape_comment}}
    /// </summary>
{{~end~}}
    public {{table.full_name}} {{table.name}} {get; }
    {{~end~}}

    public {{name}}(System.Func<string, JSONNode> loader){ }
    
    partial void PostInit();
    partial void PostResolve();
}

{{cs_end_name_space_grace x.namespace}}

五、思路(额外扩展)

顺便说下个人的项目思路,仅供参考。这里比较麻烦的就是考虑了多语言切换,第一个最简单的办法就是限制只能游戏开始界面切换语言,切换的时候只要刷新界面语言或者重新加载界面即可;第二个就是在游戏中切换语言的时候,将基础数据表格重新加载,游戏中各种对应文本也进行切换。
很明显我做的是pc端游戏,而且考虑到现在切换语言这种东西已经默认在开始界面设置了,毕竟随时切换的那种费时费力还不讨好。

void LoadData(string language) {
   if ("第一次加载")
   {
       //加载表格
       var terrain = DataManager.Instance.GetVOData<TbBaseTerrain>("xxx", language);
       var character = DataManager.Instance.GetVOData<TbBaseCharacter>("xxx", language);
       var story = DataManager.Instance.GetVOData<TbBaseStory>("xxx", language);
       //通过基础数据进行世界生成
       //...
       //保存存档到TbWorld、tbCharacter等表;
       //表格内存的基本上都是基本类型的Id,比如人物存的是 人物类型Id、人物名称、人物经历Id的集合、人物的关系Id的集合
       //...
   }
   else {
       //加载表格
       var v = DataManager.Instance.GetVOData<TbBaseTerrain>("xxx", language);
       var character = DataManager.Instance.GetVOData<TbBasecharacter>("xxx", language);
       var story = DataManager.Instance.GetVOData<TbBaseStory>("xxx", language);
       //加载TbWorld、tbCharacter等表
       //...
       //将真正的(某种语言)游戏数据整合
       //...
   }
}

总结

老项目一般都用py写的打表工具,有诸多限制(一般只能是普通的数据类型,支持list、数值,如果有复杂的结构得靠多个表格堆)。Luban很好的解决了不少潜在的问题,使用中也比较稳定,欢迎大家一起使用。
吐槽下csdn保存文章,之前写的有点不全面——于是我进行了小修改,但是登录过期了导致重新登录后没保存上,又重新整了一遍。
2023.5.5:修复bean.tpl多态bean的加载保存问题。原因:使用继承后,父类为抽象类因为is_abstract_type的判断会丢失LoadJson文章来源地址https://www.toymoban.com/news/detail-444874.html

到了这里,关于unity强力配置插件-Luban使用(一)加载保存的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • UEditor富文本编辑器上传图片打不开,提示“后端配置项没有正常加载,上传插件不能正常使用”

    1、安装 npm install vue-ueditor-wrap 2、下载所需资源 这一步在解决报错的时候会用到 👉👉👉👉👉 UEditor资源下载链接 上面的打不开请从下面链接下载项目 ueditor-download: vue项目中集成ueditor的UE资源 3、下载完成后将文件夹放到public文件夹下 4、 配置ueditor.config.js,并且在main.j

    2024年02月13日
    浏览(68)
  • 【Unity】 Unity PackageManager通过git url 加载插件失败问题

    我在测试dolby 的unity demo 的时候,遇到加载package 失败的问题。 [Package Manager Window] Cannot perform upm operation: Unable to add package [https://github.com/focus-creative-games/hybridclr_unity.git]: 网上查解决办法, 使用下面的改变系统环境变量还是没有效果。 Unity 通过url 下载插件失败 最后尝试自己

    2024年04月15日
    浏览(35)
  • 【Unity】基于GLTFUtility插件加载gltf格式数据

    https://github.com/Siccity/GLTFUtility gltf格式数据插件直接拖放至asset下即可 将UI组件挂载到脚本参数。 参考上文第二节,补充相关代码。 测试数据:食人花动画模型 注意,这个插件不支持EXT_texture_webp拓展。 如果glb格式数据加载出现报错 JsonReaderException: Unexpected character encountered

    2024年02月15日
    浏览(38)
  • Qt中的配置文件:实现个性化应用程序配置与保存加载

    在现代软件开发中,用户对于应用程序的个性化配置和设置变得越来越重要。为了满足用户需求并提供更好的用户体验,开发人员常常需要实现一种机制,以便在每次启动应用程序时能够记住用户上次的配置。这样用户就可以方便地恢复到他们熟悉的环境,无需重新进行所有

    2024年02月11日
    浏览(51)
  • 迈德威视MindVision相机配置文件的保存与加载/相机参数移植

    我们会遇到这样的情况,在一台电脑上(如我们自己的笔记本)安装了MindVision相机的驱动软件,想要使用MindVision相机成像。在我们搭建的成像环境下,假设想要对螺栓进行成像,我们可能调试出了一套合适的相机参数,包括曝光、增益等,然后在此基础上采集图像、进行后续

    2024年02月15日
    浏览(98)
  • unity开放世界解决方案-World Streamer 2加载插件(一)

    我原来想做开放世界独立游戏,是不是很大胆?整个游戏完全是开放世界,就这个游戏,就完全是这个独立游戏(团队就我一个人)。 我最早和朋友说的时候,就是做独立游戏,做开放世界独立游戏,所有朋友啊都很兴奋,宫崎英高、小岛秀夫、默神啊他们啊都很兴奋,一直

    2024年02月11日
    浏览(42)
  • 使用Python保存和加载 字典 变量

    使用Python保存和加载 字典 变量node_message

    2024年02月14日
    浏览(37)
  • (十)人工智能应用--深度学习原理与实战--模型的保存与加载使用

    目的:将训练好的模型保存为文件,下次使用时直接加载即可,不必重复建模训练。 神经网络模型训练好之后,可以保存为文件以持久存储,这样下次使用时就不重新建模训练,直接加载就可以。TensorfLow提供了灵活的模型保存方案,既可以同时保存网络结构和权重(即保存全模

    2024年02月13日
    浏览(54)
  • unity3d:asset store上C#代码热重载插件,不需要重运行,重新加载更新后函数

    https://assetstore.unity.com/packages/tools/utilities/hot-reload-edit-code-without-compiling-250972?clickref=1011lwHg8abvutm_source=partnerizeutm_medium=affiliateutm_campaign=unity_affiliate#description ●方法1:通过导航到Unity菜单栏中的“窗口”打开热重装窗口,然后选择“热重装”。 ●方法2:使用快捷键组合“Alt+Shift

    2024年02月02日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包