Unity3D数学库的几个关键点

Posted 2023-05-13

1) 局部到全局的矩阵变换:
Direct3D ： ChildMatrix * ParentMatrix * ..... * AncestorMatrix)
OpenGL ： (AncestorMarix * ..... * ParentMatrix * ChildMatrix)
Unity3D ： (AncestorMarix * ..... * ParentMatrix * ChildMatrix)
结论：unity3D的局部向全局的变换结合方式是和opengl相同的
四元数的变换结合方式同矩阵
2) 顶点定义的手向性(winding)：
Direct3D ： 左手系/CW
OpenGL ： 右手系/CCW
Unity3D ： 左手系/CW
结论：unity3D的顶点定义的方向是左手定则
3) Matrix4x4的欧拉角结合性是：
[Yaw * Pitch * Roll ]
4)
矩阵变换顶点，unity3D中不要使用*操作符(该操作符用于变换vec4)，而是用TransformPoint函数，否则结果不正确，切记!!
5) unity3中的Quaternion 的 * 操作符用于变换一个顶点，其作用如下:
public static Vector3 QuatTransformPoint(Quaternion qat,Vector3 inV)

Vector3 retVec = inV;
Vector3 vMltA = new Vector3(2.0f * qat.w, 2.0f * qat.w, 2.0f * qat.w);
Vector3 vMltB = new Vector3(2.0f, 2.0f, 2.0f);
Vector3 tmpV = new Vector3(qat.x, qat.y, qat.z);
Vector3 tmpvCP = Vector3.Cross(tmpV, inV);
Vector3 tmpvcpCP = Vector3.Cross(tmpV, tmpvCP);
tmpvCP.x *= vMltA.x; tmpvCP.y *= vMltA.y; tmpvCP.z *= vMltA.z;
tmpvcpCP.x *= vMltB.x; tmpvcpCP.y *= vMltB.y; tmpvcpCP.z *= vMltB.z;
retVec += tmpvCP + tmpvcpCP;
return retVec;

6) mathlib中的quat.transformPoint和unity3D中的quat *
vec3的结果一致，但是欧拉结合的数值有不一样，需要了解研究结果如何
7) 测试 unity3D 中quaternion 相乘后与mathlib中quat相乘后的结果 参考技术A 3D数学库的几个关键点

RequireJS库的定义说明

我开始阅读有关RequireJS的几个教程。在他们中没有一个是“define”关键字为我解释得令人满意。有人可以帮我解决以下问题：

define(
  ["Models/Person", "Utils/random", "jquery"], 
  function (Person, randomUtility, $) {..}
)  

什么是“定义”？是否定义了一个带有数组和内部匿名函数的函数？或者是别的什么？有人能给我更多关于这种定义的信息吗？

另外：谢谢nnnnnn和pradeek的回答。在欧洲，当我发布问题的那天晚上2:30。也许因此我没有意识到这是一个简单的函数调用。

答案

define不是RequireJS特有的，它是AMD specification的一部分。 Burke会注意到RequireJS并没有完全按照AMD的规定实现它，因为AMD并没有真正考虑到浏览器。

define没有匿名功能。 define是一种基于AMD的JavaScript文件可用于加载数据的方法。像RequireJS这样的库让你可以使用它。具体实施可能对您没有价值。因此，我将介绍您提供的那个，因为它是声明模块的最常用方式。

define( [array]，object );

Array是此模块所依赖的模块列表。模块和文件之间存在1对1的关系。您不能在文件中包含多个模块，也不能在一个模块中包含多个文件。

对象是您定义的模块。这可以是任何东西，结构或返回结构的函数。阅读RequireJS上的文档了解更多详情。

如果object是函数，则传递给函数的参数是在第一个define参数中列为依赖项的模块。值得注意的是，当您将函数作为object传递时，它只会运行一次。可以随时访问在此一个实例化上创建的方法或属性，然后可以将列出此模块的其他模块作为依赖项访问。

祝你好运，我建议玩这个，并在事情没有意义的时候阅读文档。 RequireJS文档非常适合作为AMD模块工作方式的快速入门。

另一答案

我发现define定义在require.js的底部附近（我也想知道这个define这个词是什么样的，这就是我要找的答案）：

/**
 * The function that handles definitions of modules. Differs from
 * require() in that a string for the module should be the first argument,
 * and the function to execute after dependencies are loaded should
 * return a value to define the module corresponding to the first argument's
 * name.
 */
define = function (name, deps, callback) {
    var node, context;

    //Allow for anonymous modules
    if (typeof name !== 'string') {
        //Adjust args appropriately
        callback = deps;
        deps = name;
        name = null;
    }

    //This module may not have dependencies
    if (!isArray(deps)) {
        callback = deps;
        deps = null;
    }

    //If no name, and callback is a function, then figure out if it a
    //CommonJS thing with dependencies.
    if (!deps && isFunction(callback)) {
        deps = [];
        //Remove comments from the callback string,
        //look for require calls, and pull them into the dependencies,
        //but only if there are function args.
        if (callback.length) {
            callback
                .toString()
                .replace(commentRegExp, '')
                .replace(cjsRequireRegExp, function (match, dep) {
                    deps.push(dep);
                });

            //May be a CommonJS thing even without require calls, but still
            //could use exports, and module. Avoid doing exports and module
            //work though if it just needs require.
            //REQUIRES the function to expect the CommonJS variables in the
            //order listed below.
            deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
        }
    }

    //If in IE 6-8 and hit an anonymous define() call, do the interactive
    //work.
    if (useInteractive) {
        node = currentlyAddingScript || getInteractiveScript();
        if (node) {
            if (!name) {
                name = node.getAttribute('data-requiremodule');
            }
            context = contexts[node.getAttribute('data-requirecontext')];
        }
    }

    //Always save off evaluating the def call until the script onload handler.
    //This allows multiple modules to be in a file without prematurely
    //tracing dependencies, and allows for anonymous module support,
    //where the module name is not known until the script onload event
    //occurs. If no context, use the global queue, and get it processed
    //in the onscript load callback.
    (context ? context.defQueue : globalDefQueue).push([name, deps, callback]);
};

另一答案

我发现这个页面Why AMD?非常有帮助。总结一下这个页面，AMD规范有助于克服“编写一堆具有隐式依赖关系的脚本标记，您必须手动排序”问题。在执行所需函数之前加载依赖项很有帮助，类似于python等其他编程语言中的import。 AMD还可以防止全局名称空间污染问题。检查"It is an improvement over the web's current "globals and script tags" because"部分。

另一答案

我认为RequireJs API specification总结得很好：

如果模块具有依赖关系，则第一个参数应该是依赖项名称数组，第二个参数应该是定义函数。所有依赖项加载后，将调用该函数来定义模块。该函数应返回定义模块的对象。

他们列出了所有各种语法形式的示例。