xlua源码分析（二）lua Call C#的无wrap实现

news2024/11/27 1:16:24

xlua源码分析（二）lua Call C#的无wrap实现

上一节我们主要分析了xlua中C# Call lua的实现思路，本节我们将根据Examples 03_UIEvent，分析lua Call C#的底层实现。例子场景里有一个简单的UI面板，面板中包含一个input field，一个button：

在这里插入图片描述

输入任意文本，点击button，就会打印出输入的内容：

在这里插入图片描述

响应点击事件的代码是在lua层，位于ButtonInteraction.lua.txt这个文件中，lua代码很简单，就是一个简单的函数：

function start()
	print("lua start...")

	self:GetComponent("Button").onClick:AddListener(function()
		print("clicked, you input is '" ..input:GetComponent("InputField").text .."'")
	end)
end

那么C#层从哪里读取到这个文件的呢？可以看到，Button这个GameObject上绑了上一节我们提到过的LuaBehaviour组件，而组件里设置的Lua Script就是这个文件了：

在这里插入图片描述

上一节我们说过，LuaBehaviour组件会在Awake的时候会执行lua代码，获取lua层写的start函数，然后在MonoBehaviour的Start中执行它。在lua层的start函数中，首先可以发现一个self，这个self也是在C#层Awake的时候设置的，对应的就是C#的LuaBehaviour对象。和tolua一样，xlua也会把C#对象当作userdata来处理，每个要push到lua层的C#类型都有唯一的type_id，对应到不同的metatable，用来定义userdata的行为。并且，除了值类型和枚举类型之外，所有push到lua层的C#对象，都会在C#层缓存，这一点也是和tolua一样的，甚至缓存的数据结构也大差不差。

public void Push(RealStatePtr L, object o)
{
    if (needcache && (is_enum ? enumMap.TryGetValue(o, out index) : reverseMap.TryGetValue(o, out index)))
    {
        if (LuaAPI.xlua_tryget_cachedud(L, index, cacheRef) == 1)
        {
            return;
        }
    }

    bool is_first;
    int type_id = getTypeId(L, type, out is_first);

    index = addObject(o, is_valuetype, is_enum);
    LuaAPI.xlua_pushcsobj(L, index, type_id, needcache, cacheRef);
}

xlua_tryget_cachedud函数就是通过C#缓存拿到的index，去lua层的缓存去拿userdata，lua层的缓存与C#不同，它只负责查询，不负责存储，因此是一个value为弱引用的弱表，这一点和tolua也是一样的，xlua在初始化时就会将这个弱表准备好：

LuaAPI.lua_newtable(L);
LuaAPI.lua_newtable(L);
LuaAPI.xlua_pushasciistring(L, "__mode");
LuaAPI.xlua_pushasciistring(L, "v");
LuaAPI.lua_rawset(L, -3);
LuaAPI.lua_setmetatable(L, -2);
cacheRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);

由于这个缓存是弱表，意味着userdata在被真正gc之前，弱表里对应的值有可能已经不存在了。那么xlua_tryget_cachedud这个函数有可能是取不到userdata的：

LUA_API int xlua_tryget_cachedud(lua_State *L, int key, int cache_ref) {
	lua_rawgeti(L, LUA_REGISTRYINDEX, cache_ref);
	lua_rawgeti(L, -1, key);
	if (!lua_isnil(L, -1))
	{
		lua_remove(L, -2);
		return 1;
	}
	lua_pop(L, 2);
	return 0;
}

取不到的话就通过xlua_pushcsobj这个函数新增一个userdata：

static void cacheud(lua_State *L, int key, int cache_ref) {
	lua_rawgeti(L, LUA_REGISTRYINDEX, cache_ref);
	lua_pushvalue(L, -2);
	lua_rawseti(L, -2, key);
	lua_pop(L, 1);
}


LUA_API void xlua_pushcsobj(lua_State *L, int key, int meta_ref, int need_cache, int cache_ref) {
	int* pointer = (int*)lua_newuserdata(L, sizeof(int));
	*pointer = key;
	
	if (need_cache) cacheud(L, key, cache_ref);

    lua_rawgeti(L, LUA_REGISTRYINDEX, meta_ref);

	lua_setmetatable(L, -2);
}

但是，xlua设置userdata metatable的做法和tolua完全不同。xlua使用delay wrap的策略，即只有某个C#类型的对象push到了lua层，才会将这个C#类型的信息，真正地加载到lua层，在此之前，这个metatable并不存在；而tolua默认是在一开始就wrap的，这样的话类型一多，初始化的时间就大大增加，而且根据二八定律，可能绝大部分的类型在一开始压根用不到。

那么，这个delay wrap具体是怎么实现的呢？既然它是在C#对象push到lua层触发的，那么显而易见，在获取这个类的type_id时，就要把C#类的信息加载进来了：

internal int getTypeId(RealStatePtr L, Type type, out bool is_first, LOGLEVEL log_level = LOGLEVEL.WARN)
{
    int type_id;
    if (!typeIdMap.TryGetValue(type, out type_id)) // no reference
    {
        LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);

        if (LuaAPI.lua_isnil(L, -1)) //no meta yet, try to use reflection meta
        {
            LuaAPI.lua_pop(L, 1);

            if (TryDelayWrapLoader(L, alias_type == null ? type : alias_type))
            {
                LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
            }
            else
            {
                throw new Exception("Fatal: can not load metatable of type:" + type);
            }
        }

        typeIdMap.Add(type, type_id);
    }
    return type_id;
}

负责这件事情的函数就是TryDelayWrapLoader。在例子中，由于我们没有生成过类的wrap，默认就会使用反射的方式来注册各种C#方法与成员。具体实现的逻辑比较复杂，主要在ReflectionWrap这个函数中：

public static void ReflectionWrap(RealStatePtr L, Type type, bool privateAccessible)
{
    LuaAPI.lua_checkstack(L, 20);

    int top_enter = LuaAPI.lua_gettop(L);
    ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
    //create obj meta table
    LuaAPI.luaL_getmetatable(L, type.FullName);
    if (LuaAPI.lua_isnil(L, -1))
    {
        LuaAPI.lua_pop(L, 1);
        LuaAPI.luaL_newmetatable(L, type.FullName);
    }
    LuaAPI.lua_pushlightuserdata(L, LuaAPI.xlua_tag());
    LuaAPI.lua_pushnumber(L, 1);
    LuaAPI.lua_rawset(L, -3);
    int obj_meta = LuaAPI.lua_gettop(L);

    LuaAPI.lua_newtable(L);
    int cls_meta = LuaAPI.lua_gettop(L);

    LuaAPI.lua_newtable(L);
    int obj_field = LuaAPI.lua_gettop(L);
    LuaAPI.lua_newtable(L);
    int obj_getter = LuaAPI.lua_gettop(L);
    LuaAPI.lua_newtable(L);
    int obj_setter = LuaAPI.lua_gettop(L);
    LuaAPI.lua_newtable(L);
    int cls_field = LuaAPI.lua_gettop(L);
    //set cls_field to namespace
    SetCSTable(L, type, cls_field);
    //finish set cls_field to namespace
    LuaAPI.lua_newtable(L);
    int cls_getter = LuaAPI.lua_gettop(L);
    LuaAPI.lua_newtable(L);
    int cls_setter = LuaAPI.lua_gettop(L);

    LuaCSFunction item_getter;
    LuaCSFunction item_setter;
    makeReflectionWrap(L, type, cls_field, cls_getter, cls_setter, obj_field, obj_getter, obj_setter, obj_meta,
        out item_getter, out item_setter, privateAccessible ? (BindingFlags.Public | BindingFlags.NonPublic) : BindingFlags.Public);

    // init obj metatable
    LuaAPI.xlua_pushasciistring(L, "__gc");
    LuaAPI.lua_pushstdcallcfunction(L, translator.metaFunctions.GcMeta);
    LuaAPI.lua_rawset(L, obj_meta);

    LuaAPI.xlua_pushasciistring(L, "__tostring");
    LuaAPI.lua_pushstdcallcfunction(L, translator.metaFunctions.ToStringMeta);
    LuaAPI.lua_rawset(L, obj_meta);

    LuaAPI.xlua_pushasciistring(L, "__index");
    LuaAPI.lua_pushvalue(L, obj_field);
    LuaAPI.lua_pushvalue(L, obj_getter);
    translator.PushFixCSFunction(L, item_getter);
    translator.PushAny(L, type.BaseType());
    LuaAPI.xlua_pushasciistring(L, LuaIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    LuaAPI.lua_pushnil(L);
    LuaAPI.gen_obj_indexer(L);
    //store in lua indexs function tables
    LuaAPI.xlua_pushasciistring(L, LuaIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    translator.Push(L, type);
    LuaAPI.lua_pushvalue(L, -3);
    LuaAPI.lua_rawset(L, -3);
    LuaAPI.lua_pop(L, 1);
    LuaAPI.lua_rawset(L, obj_meta); // set __index

    LuaAPI.xlua_pushasciistring(L, "__newindex");
    LuaAPI.lua_pushvalue(L, obj_setter);
    translator.PushFixCSFunction(L, item_setter);
    translator.Push(L, type.BaseType());
    LuaAPI.xlua_pushasciistring(L, LuaNewIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    LuaAPI.lua_pushnil(L);
    LuaAPI.gen_obj_newindexer(L);
    //store in lua newindexs function tables
    LuaAPI.xlua_pushasciistring(L, LuaNewIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    translator.Push(L, type);
    LuaAPI.lua_pushvalue(L, -3);
    LuaAPI.lua_rawset(L, -3);
    LuaAPI.lua_pop(L, 1);
    LuaAPI.lua_rawset(L, obj_meta); // set __newindex
                                    //finish init obj metatable

    LuaAPI.xlua_pushasciistring(L, "UnderlyingSystemType");
    translator.PushAny(L, type);
    LuaAPI.lua_rawset(L, cls_field);

    if (type != null && type.IsEnum())
    {
        LuaAPI.xlua_pushasciistring(L, "__CastFrom");
        translator.PushFixCSFunction(L, genEnumCastFrom(type));
        LuaAPI.lua_rawset(L, cls_field);
    }

    //init class meta
    LuaAPI.xlua_pushasciistring(L, "__index");
    LuaAPI.lua_pushvalue(L, cls_getter);
    LuaAPI.lua_pushvalue(L, cls_field);
    translator.Push(L, type.BaseType());
    LuaAPI.xlua_pushasciistring(L, LuaClassIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    LuaAPI.gen_cls_indexer(L);
    //store in lua indexs function tables
    LuaAPI.xlua_pushasciistring(L, LuaClassIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    translator.Push(L, type);
    LuaAPI.lua_pushvalue(L, -3);
    LuaAPI.lua_rawset(L, -3);
    LuaAPI.lua_pop(L, 1);
    LuaAPI.lua_rawset(L, cls_meta); // set __index 

    LuaAPI.xlua_pushasciistring(L, "__newindex");
    LuaAPI.lua_pushvalue(L, cls_setter);
    translator.Push(L, type.BaseType());
    LuaAPI.xlua_pushasciistring(L, LuaClassNewIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    LuaAPI.gen_cls_newindexer(L);
    //store in lua newindexs function tables
    LuaAPI.xlua_pushasciistring(L, LuaClassNewIndexsFieldName);
    LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
    translator.Push(L, type);
    LuaAPI.lua_pushvalue(L, -3);
    LuaAPI.lua_rawset(L, -3);
    LuaAPI.lua_pop(L, 1);
    LuaAPI.lua_rawset(L, cls_meta); // set __newindex

    LuaCSFunction constructor = typeof(Delegate).IsAssignableFrom(type) ? translator.metaFunctions.DelegateCtor : translator.methodWrapsCache.GetConstructorWrap(type);
    if (constructor == null)
    {
        constructor = (RealStatePtr LL) =>
        {
            return LuaAPI.luaL_error(LL, "No constructor for " + type);
        };
    }

    LuaAPI.xlua_pushasciistring(L, "__call");
    translator.PushFixCSFunction(L, constructor);
    LuaAPI.lua_rawset(L, cls_meta);

    LuaAPI.lua_pushvalue(L, cls_meta);
    LuaAPI.lua_setmetatable(L, cls_field);

    LuaAPI.lua_pop(L, 8);

    System.Diagnostics.Debug.Assert(top_enter == LuaAPI.lua_gettop(L));
}

相比于tolua只使用两个table，xlua使用了若干的table来辅助索引查找C#的方法和成员。从代码中可以看出，cls_meta，cls_field，cls_getter和cls_setter是用直接给类访问用的，比如一些静态的方法与成员，lua层可以通过namespace和类名直接访问。而相应地，obj_meta，obj_field，obj_getter和obj_setter是给userdata访问用的，对应C#层实例方法与成员。从命名中也可看出，field对应的是C#的字段和方法，getter对应的是C#的get属性，setter对应的是set属性，meta就是对外设置的metatable了。cls_meta中包含__index，__newindex，__call这三个元方法，这样lua层就可以通过类名创建一个C#对象；obj_meta中包含__index，__newindex，__gc，__tostring这四个元方法，并且它就是userdata的type_id。__index，__newindex这两个元方法，还会通过registry表，记录对应的type，来进行额外的缓存，这么做的目的主要是为了基类查找，xlua不像tolua一样，嵌套使用多个metatable来实现继承机制。

那么field，getter，setter这三种table是如何跟meta进行关联的呢？xlua使用了一种非常巧妙的机制，以userdata的__index为例，它其实对应着一个函数，这个函数使用包含field，getter，setter这三种table在内，以及其他的一些参数，作为upvalue来引用。

LUA_API int gen_obj_indexer(lua_State *L) {
	lua_pushnil(L);
	lua_pushcclosure(L, obj_indexer, 7);
	return 0;
}

obj_indexer这个函数持有了7个upvalue，是有点多，注释里也标明了每个upvalue的用途：

//upvalue --- [1]: methods, [2]:getters, [3]:csindexer, [4]:base, [5]:indexfuncs, [6]:arrayindexer, [7]:baseindex
//param   --- [1]: obj, [2]: key
LUA_API int obj_indexer(lua_State *L) {	
	if (!lua_isnil(L, lua_upvalueindex(1))) {
		lua_pushvalue(L, 2);
		lua_gettable(L, lua_upvalueindex(1));
		if (!lua_isnil(L, -1)) {//has method
			return 1;
		}
		lua_pop(L, 1);
	}
	
	if (!lua_isnil(L, lua_upvalueindex(2))) {
		lua_pushvalue(L, 2);
		lua_gettable(L, lua_upvalueindex(2));
		if (!lua_isnil(L, -1)) {//has getter
			lua_pushvalue(L, 1);
			lua_call(L, 1, 1);
			return 1;
		}
		lua_pop(L, 1);
	}
	
	
	if (!lua_isnil(L, lua_upvalueindex(6)) && lua_type(L, 2) == LUA_TNUMBER) {
		lua_pushvalue(L, lua_upvalueindex(6));
		lua_pushvalue(L, 1);
		lua_pushvalue(L, 2);
		lua_call(L, 2, 1);
		return 1;
	}
	
	if (!lua_isnil(L, lua_upvalueindex(3))) {
		lua_pushvalue(L, lua_upvalueindex(3));
		lua_pushvalue(L, 1);
		lua_pushvalue(L, 2);
		lua_call(L, 2, 2);
		if (lua_toboolean(L, -2)) {
			return 1;
		}
		lua_pop(L, 2);
	}
	
	if (!lua_isnil(L, lua_upvalueindex(4))) {
		lua_pushvalue(L, lua_upvalueindex(4));
		while(!lua_isnil(L, -1)) {
			lua_pushvalue(L, -1);
			lua_gettable(L, lua_upvalueindex(5));
			if (!lua_isnil(L, -1)) // found
			{
				lua_replace(L, lua_upvalueindex(7)); //baseindex = indexfuncs[base]
				lua_pop(L, 1);
				break;
			}
			lua_pop(L, 1);
			lua_getfield(L, -1, "BaseType");
			lua_remove(L, -2);
		}
		lua_pushnil(L);
		lua_replace(L, lua_upvalueindex(4));//base = nil
	}
	
	if (!lua_isnil(L, lua_upvalueindex(7))) {
		lua_settop(L, 2);
		lua_pushvalue(L, lua_upvalueindex(7));
		lua_insert(L, 1);
		lua_call(L, 2, 1);
		return 1;
	} else {
		return 0;
	}
}

我们着重看一下第4个upvalue的情况，走到这里说明在当前类中没有查找到，例子中的GetComponent方法是在Component类里，在LuaBehaviour类里自然是查找不到的，那么就需要不断地往父类查找。第4个upvalue是当前类的基类类型base type，第5个upvalue就是缓存了当前所有type的__index元方法函数，那么自然而然就要去这个缓存中查找base type的__index元方法，然后把事情直接交给它做就好了，这其实就是一个递归的做法。为了避免下次还要从缓存中查找基类，这里直接把第4个upvalue置为空，然后把基类的__index元方法缓存到第7个upvalue上。

那问题来了，我们之前提到xlua是delay wrap的，在访问C#对象的时候，它的基类信息很可能还没wrap到lua层。所以这里也需要获取一下基类的type_id。在从缓存中获取__index元方法时，代码中使用的是：

lua_gettable(L, lua_upvalueindex(5));

lua_gettable是会触发metatable的，这个缓存table在xlua初始化时就设置了一个metatable：

LuaAPI.lua_newtable(rawL); //metatable of indexs and newindexs functions
LuaAPI.xlua_pushasciistring(rawL, "__index");
LuaAPI.lua_pushstdcallcfunction(rawL, StaticLuaCallbacks.MetaFuncIndex);
LuaAPI.lua_rawset(rawL, -3);

LuaAPI.xlua_pushasciistring(rawL, Utils.LuaIndexsFieldName);
LuaAPI.lua_newtable(rawL);
LuaAPI.lua_pushvalue(rawL, -3);
LuaAPI.lua_setmetatable(rawL, -2);
LuaAPI.lua_rawset(rawL, LuaIndexes.LUA_REGISTRYINDEX);

因此如果基类信息还没wrap，就会触发到C#层的MetaFuncIndex方法：

public static int MetaFuncIndex(RealStatePtr L)
{
    try
    {
        ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
        Type type = translator.FastGetCSObj(L, 2) as Type;
        if (type == null)
        {
            return LuaAPI.luaL_error(L, "#2 param need a System.Type!");
        }
        translator.GetTypeId(L, type);
        LuaAPI.lua_pushvalue(L, 2);
        LuaAPI.lua_rawget(L, 1);
        return 1;
    }
    catch (System.Exception e)
    {
        return LuaAPI.luaL_error(L, "c# exception in MetaFuncIndex:" + e);
    }
}

这个函数首先会从lua层获取当前要wrap的type，生成唯一的type_id，并把类型信息wrap到lua层，然后再使用一次rawget把__index方法放回lua层，这样lua层就可以继续递归查找了。在例子中，想要调用到GetComponent得沿着LuaBehaviour=>MonoBehaviour=>Behaviour=>Component这条链一直查找3次才能找到。

最后，push到lua层的这些C#函数，都是使用PushFixCSFunction这个方法完成的，这个方法把push到lua层的函数统一放到一个list中管理，实际调用时根据list中的索引，触发具体的某个函数：

internal void PushFixCSFunction(RealStatePtr L, LuaCSFunction func)
{
    if (func == null)
    {
        LuaAPI.lua_pushnil(L);
    }
    else
    {
        LuaAPI.xlua_pushinteger(L, fix_cs_functions.Count);
        fix_cs_functions.Add(func);
        LuaAPI.lua_pushstdcallcfunction(L, metaFunctions.FixCSFunctionWraper, 1);
    }
}

static int FixCSFunction(RealStatePtr L)
{
    try
    {
        ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
        int idx = LuaAPI.xlua_tointeger(L, LuaAPI.xlua_upvalueindex(1));
        LuaCSFunction func = (LuaCSFunction)translator.GetFixCSFunction(idx);
        return func(L);
    }
    catch (Exception e)
    {
        return LuaAPI.luaL_error(L, "c# exception in FixCSFunction:" + e);
    }
}

推测这么做的原因可能是为了少一些MonoPInvokeCallback吧：）

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1170468.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

多模态大模型最全综述

多模态大模型最全综述

由微软7位华人研究员撰写--多模态基础模型已经从专用走向通用 它从目前已经完善的和还处于最前沿的两类多模态大模型研究方向出发，全面总结了五个具体研究主题： 视觉理解视觉生成统一视觉模型LLM加持的多模态大模型多模态agent 1、谁适合阅读这份综述&…
阅读更多...
YOLOv8独家原创改进：自研独家创新BSAM注意力 ，基于CBAM升级

YOLOv8独家原创改进：自研独家创新BSAM注意力 ，基于CBAM升级

💡💡💡本文全网首发独家改进：提出新颖的注意力BSAM（BiLevel Spatial Attention Module），创新度极佳，适合科研创新，效果秒杀CBAM，Channel Attention+Spartial Attention升级为新颖的 BiLevel Attention+Spartial Attention 1）作为注意力BSAM使用； 推荐指数：…
阅读更多...
时序预测 | MATLAB实现时间序列ACF和PACF分析

时序预测 | MATLAB实现时间序列ACF和PACF分析

时序预测 | MATLAB实现时间序列ACF和PACF分析 目录 时序预测 | MATLAB实现时间序列ACF和PACF分析基本介绍程序设计参考资料基本介绍 自回归分析是线性回归分析的一种推广，主要是研究一个序列反映的自我因果关系。普通线性回归基于互相关分析，涉及两个以上的变量，一个作为因变…
阅读更多...
Iceberg教程

Iceberg教程

目录 教程来源于尚硅谷1. 简介1.1 概述1.2 特性 2. 存储结构2.1 数据文件(data files)2.2 表快照(Snapshot)2.3 清单列表(Manifest list)2.4 清单文件(Manifest file)2.5 查询流程分析 3. 与Flink集成3.1 环境准备3.1.1 安装Flink3.1.2 启动Sql-Client 3.2 语法 教程来源于尚硅…
阅读更多...
产品经理入门学习（一）：认识产品经理

产品经理入门学习（一）：认识产品经理

参考引用 黑马-产品经理入门基础课程 1. 合格的产品经理 1.1 什么是产品 上述产品的共性：解决某个问题的东西上述产品的区别 有形（上图左）：颜色、形状、质地和尺寸无形（上图右）：脑力劳动成果、…
阅读更多...
Leetcode—101.对称二叉树【简单】

Leetcode—101.对称二叉树【简单】

2023每日刷题（十九） Leetcode—101.对称二叉树 利用Leetcode101.对称二叉树的思想的实现代码 /*** Definition for a binary tree node.* struct TreeNode {* int val;* struct TreeNode *left;* struct TreeNode *right;* };*/ bool isSa…
阅读更多...
华为升腾C92安装win7

华为升腾C92安装win7

华为升腾C92安装win7 不知道什么原因，当初那批C92配置到学校班班通时，安装的是Linux系统。这也造成了我错误地认为C92这个小鸡子太弱了，只能运行Linux还行，无法运行Windows的。 其实错了，我们可以在C92开机时&#xff…
阅读更多...
轻量封装WebGPU渲染系统示例＜15＞- DrawInstance批量绘制(源码)

轻量封装WebGPU渲染系统示例＜15＞- DrawInstance批量绘制(源码)

当前示例源码github地址: https://github.com/vilyLei/voxwebgpu/blob/main/src/voxgpu/sample/DrawInstanceTest.ts 此示例渲染系统实现的特性: 1. 用户态与系统态隔离。 细节请见：引擎系统设计思路 - 用户态与系统态隔离-CSDN博客 2. 高频调用与低频调用隔离。…
阅读更多...
IEEE CAI2024

IEEE CAI2024

投递链接： ​https://ieeecai.org/2024/
阅读更多...
Spring 中 BeanFactory 和 FactoryBean 有何区别？

Spring 中 BeanFactory 和 FactoryBean 有何区别？

这也是 Spring 面试时一道经典的面试问题，今天我们来聊一聊这个话题。 其实从名字上就能看出来个一二，BeanFactory 是 Factory 而 FactoryBean 是一个 Bean，我们先来看下总结： BeanFactory 是 Spring 框架的核心接口之一&#xf…
阅读更多...
Leetcode—110.平衡二叉树【简单】

Leetcode—110.平衡二叉树【简单】

2023每日刷题（十九） Leetcode—110.平衡二叉树 实现代码 /*** Definition for a binary tree node.* struct TreeNode {* int val;* struct TreeNode *left;* struct TreeNode *right;* };*/ int preFunc(struct TreeNode* root) {if(root…
阅读更多...
LeetCode算法心得——路径总和||（dfs+双端队列+链表）

LeetCode算法心得——路径总和||（dfs+双端队列+链表）

大家好，我是晴天学长，简单树的经典题目，是dfs的开端啊，需要的小伙伴可以关注支持一下哦！后续会继续更新的。 1) .路径总和|| 给你二叉树的根节点 root 和一个整数目标和 targetSum ，找出所有 从根节点到叶子…
阅读更多...
蓝牙耳机有什么功能怎么用，蓝牙耳机的用法和功能分享

蓝牙耳机有什么功能怎么用，蓝牙耳机的用法和功能分享

蓝牙耳机最基本的功能就是接听电话，听音乐，兼容其他软件进行无线操作，同时还可以调节音量，播放暂停等功能。不过现如今蓝牙耳机中出现了一个新型的派别——骨传导蓝牙耳机，可以让你在享受音乐的同时，也能保…
阅读更多...
6、QtCharts 悬浮曲线效果

6、QtCharts 悬浮曲线效果

文章目录 效果dialog.hdialog.cpp悬浮槽函数 效果 dialog.h #ifndef DIALOG_H #define DIALOG_H#include <QDialog> #include <QtCharts> #include <QLineSeries> #include <QGraphicsScene> #include <QTimer> #include <QSplineSeries>…
阅读更多...
为什么在DTO中请要使用包装类型

为什么在DTO中请要使用包装类型

Java是一种强类型的面向对象编程语言&#xff0c;它为我们提供了一种特殊的类别&#xff0c;叫做数据传输对象&#xff08;Data Transfer Object&#xff0c;DTO&#xff09;。在本篇文章中&#xff0c;我们将详细讨论为什么在DTO中使用包装类型而非基础类型。 1. 什么是DTO&a…
阅读更多...
电池原理与分类

电池原理与分类

1 电池基础知识 电池目前大量应用于我们的生活中&#xff0c;主要包括3C消费类、动力类、储能类。 图1 电池应用方向 备注&#xff1a;3C指的是计算机(Computer )、通讯&#xff08;Communication&#xff09;消费类电子产品&#xff08;Consumer Electronic&#xff09;三类…
阅读更多...
GPT4做网页，完成度竟然这么高！！！

GPT4做网页，完成度竟然这么高！！！

CHATGPT简介 chatgpt的自我介绍是这样的&#xff1a; 最近一段时间内&#xff0c;chatgpt可谓是数次引发热议&#xff0c;现在&#xff0c;让我们一起来看看&#xff0c;他所制作的网页究竟能到什么地步呢&#xff1f; 提示词 我给了CHATGPT如下的提示词&#xff0c;那么它…
阅读更多...
【一周安全资讯1104】证监会发布《上市公司公告电子化规范》等9项金融行业标准；北京网信办对三家违反数据安全法规企业作出行政处罚

【一周安全资讯1104】证监会发布《上市公司公告电子化规范》等9项金融行业标准；北京网信办对三家违反数据安全法规企业作出行政处罚

要闻速览 1、证监会发布《上市公司公告电子化规范》等9项金融行业标准 2、《网络安全标准实践指南—粤港澳大湾区跨境个人信息保护要求》公开征求意见 3、北京市网信办对三家企业未履行数据安全保护义务作出行政处罚 4、加拿大禁止政府雇员使用微信和卡巴斯基 5、次覆盖“人的…
阅读更多...
CSS解决div行变块 ➕ CSS解决“table中的td文字溢出控制显示字数，显示省略号”的问题

CSS解决div行变块 ➕ CSS解决“table中的td文字溢出控制显示字数，显示省略号”的问题

CSS解决div行变块 ➕ CSS解决“table中的td文字溢出控制显示字数&#xff0c;显示省略号”的问题 1. div变块级设置1.1 先看不设置的效果1.2 再看设置之后的效果 2. 解决 table 中 td 内容过长问题2.1 CSS实现&#xff08;文字溢出控制td显示字数&#xff0c;显示省略号&#x…
阅读更多...
ssm在线互助答疑系统-计算机毕设 附源码 20862

ssm在线互助答疑系统-计算机毕设 附源码 20862

ssm在线互助答疑系统 摘 要 科技进步的飞速发展引起人们日常生活的巨大变化&#xff0c;电子信息技术的飞速发展使得电子信息技术的各个领域的应用水平得到普及和应用。信息时代的到来已成为不可阻挡的时尚潮流&#xff0c;人类发展的历史正进入一个新时代。在现实运用中&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023