我有一个在四元数和欧拉角之间转换的算法.

    public static Vector3 ToEulerAngles(this Quaternion q)
    {
        // Store the Euler angles in radians
        Vector3 pitchYawRoll = new Vector3();

        double sqw = q.W * q.W;
        double sqx = q.X * q.X;
        double sqy = q.Y * q.Y;
        double sqz = q.Z * q.Z;

        // If quaternion is normalised the unit is one, otherwise it is the correction factor
        double unit = sqx + sqy + sqz + sqw;
        double test = q.X * q.Y + q.Z * q.W;

        if …

我想围绕一个基于两个值的比率的数字.

该比率将包括大于或小于原始值的值

ratio = newValue / originalvalue

当newValue> originalValue我可以使用以下方法舍入到最接近的较低因子:

double NearestLowerFactor(float value, double factor)
{
    return Math.Floor(value / factor) * factor;
}

例如:

• 因子= 2
• 比率= 3
• NearestLowerFactor = 2

当newValue <originalValue我希望舍入到该因子的最接近的倒数.

因此,如果因子是2,我想根据1/2的因子进行舍入,即1/2,1/4,1/8,1/16等.

例如:

• originalValue = 8
• newValue = 3
• 比率= 0.375
• NearestLowerFactor = 0.25或1/4.

在这种情况下,我如何舍入到最接近的较低因子？

我已经连载float数组到RepeatedField使用谷歌的协议型缓冲器.

在反序列化数据时,我使用另一个设置类来为我的游戏类以更合适的形式保存信息.静态CreateFrom方法提取并转换数据.

class VoxelTerrainSettings
{
public:
    std::vector<int> indices;
    btAlignedObjectArray<btVector3> vertices;

    VoxelTerrainSettings(void);
    ~VoxelTerrainSettings(void);

    static VoxelTerrainSettings CreateFrom(const VoxelTerrainProtoBuf::VoxelTerrainSettings &settings)
    {
        VoxelTerrainSettings s;

        int numIndices = settings.indices().size();

        s.indices.reserve(numIndices);

        for (int i = 0; i < numIndices; ++i)
        {
            s.indices.push_back(settings.indices().Get(i));
        }

        int numVertices = settings.vertices().size();

        s.vertices.reserve(numVertices);

        int v = 0;

        for (int i = 0; i < numVertices; ++i)
        {
            s.vertices.push_back(btVector3(settings.vertices().Get(v++), settings.vertices().Get(v++), settings.vertices().Get(v++)));
        }

        return s;
    }

    //VoxelTerrain Load();
};

但是,从RepeatedField中提取所有元素的当前方法似乎并不优雅.

我尝试采用更有效的方法,但它们都抛出了范围错误.

std::copy(settings.vertices().begin(), settings.vertices().end(), vv.begin());
std::copy(&settings.vertices().Get(0), &settings.vertices().Get(settings.vertices().size() - 1), &vv[0]); …

在弄清楚我之前的问题的答案后,我发现原因是某种数学怪异.

使用GLM(OpenGL)库我创建如下方向

glm::gtx::quaternion::orientation = 
    glm::gtx::quaternion::angleAxis(pitchAccum, 1.0f, 0.0f, 0.0f) * 
    glm::gtx::quaternion::angleAxis(yawAccum, 0.0f, 1.0f, 0.0f);

现在,如果我从这个方向创建一个矩阵,它不再是列专业,但不知何故成为行主要

    glm::mat4 view = glm::gtx::quaternion::toMat4(orientation); 

换句话说,通过使用行主索引访问矩阵来找到3个坐标轴

view[0][0], view[1][0], view[2][0]  // X axis
view[0][1], view[1][1], view[2][1]  // Y axis
view[0][2], view[1][2], view[2][2]  // Z axis

换句话说,旋转部件的转置.

仍应使用列major设置矩阵的平移部分,以使最终视图矩阵按预期工作.

view[3][0] = -glm::dot(glm::vec3(view[0][0], view[1][0], view[2][0]), position);    // Right
view[3][1] = -glm::dot(glm::vec3(view[0][1], view[1][1], view[2][1]), position);    // Up
view[3][2] = -glm::dot(glm::vec3(view[0][2], view[1][2], view[2][2]), position);    // Forward

当使用方向时,为什么旋转矩阵从主要主要部分翻转到行主要部分(转置？)？

编辑:

// Move forward
if (glfwGetKey('W') == GLFW_PRESS)
{
    //movement += glm::vec3(view[2][0], view[2][1], view[2][2]); …

我有一个智能指针列表，其中每个指针都指向一个单独的实体类。

std::list<std::unique_ptr<Entity>> m_entities;

我希望构造函数能够处理每个指针对 std::list 类的分配，因为它是由类实例化的代码“自动”处理的。然而，如果这个设计很糟糕，那么我会欢迎更好的选择，因为它只对来自 C# 背景的我有意义。

Entity::Entity(Game &game) 
    : m_game(game),             
    m_id(m_game.g_idGenerator->generateNewID())             
{
    m_game.m_entities.push_back(std::unique_ptr<Entity>(this));
}

我使用此方法遇到的主要问题是实体类的生命周期不受实体类管理。

例如，如果我在堆栈上分配一个实体类，它将在离开分配它的方法后调用实体析构函数，并且指针将不再有效。

因此，我考虑了另一种选择：创建智能指针，将实体类分配到堆，然后将指针显式添加到列表中。

std::unique_ptr<Entity> b(new Entity(*this));
m_entities.push_back(b);   // ERROR

这会产生以下错误

error C2664: 'void std::list<_Ty>::push_back(_Ty &&)' : cannot convert parameter 1 from 'std::unique_ptr<_Ty>' to 'std::unique_ptr<_Ty> &&'

将每个指针分配到列表的最佳方法是什么？基于构造函数的版本是否可能？

我目前认为智能指针列表应该处理每个实体类的生命周期，并且在构造函数中分配指针不是一个好的设计选择。在这种情况下，我可能应该创建一个 CreateEntity 方法，将指针添加到列表中，而不是让构造函数处理它。这是否更好？

在阅读了此处、此处和此处（场外）发现的问题后，我考虑了哪种类型的智能指针适合此操作。根据我到目前为止所读到的内容，很难得到准确的答案，因为它们都提供了一些相互矛盾的建议。

我有一个基类,它有一个方法调用AddFruit,它接受一个类的Fruit类并以一般方式处理它.

    public abstract class Foo
    {
        protected List<ProcessedFruit> processedFruit = new List<ProcessedFruit>();

        public void AddFruit(Fruit o)       
        {
            // Process fruit

            processedFruit.Add(o);
        }

        public void Update()
        {
            // Do base class specific stuff here
            OnUpdate();
        }

        protected abstract void OnUpdate();
    }

    public class AppleBar : Foo
    {
        public AppleBar()
            :base(){}

        protected override void OnUpdate() { }
    }

    public class BananaBar : Foo
    {
        public BananaBar()
            :base(){}

        protected override void OnUpdate() { }
    }

任何派生的类都Foo以非一般方式更新,并ProcessedFruit …

以下采用两个8位整数并将它们组合起来生成一个14位整数.

    public static int CombineBytes(int LSB, int MSB)
    {
        int _14bit;

        _14bit = MSB;
        _14bit <<= 7;
        _14bit |= LSB;

        return(_14bit);
    }

与此功能相反的过程是什么？

例如,如果我提供了一个14位整数的函数,我会以最高有效字节和最低有效字节的形式得到两个8位整数？

我有一个在时间't'评估的路径,并根据路径类型返回方向和位置.

时间值受路径类型的影响:

switch (type)
{
    case PathType.Closed:
        time = ToolBox.Wrap(time, StartTime, EndTime);
        break; // Wrap time around the path time to loop

    case PathType.Open:
        time = ToolBox.Min(time, EndTime);
        break; // Clamp the time value to the max path time range

    case PathType.Oscillating:
        break;
}

缺失的环节正在振荡.

我的问题是,在两个值之间振荡的有效方法是什么？

例如(2,7).如果时间达到7,则反转并向下递减至2,一旦达到2,则反转并向7增加.

算法应该知道是否根据原始值增加/减少值,所以如果值为9则知道答案是7 - (Abs(7 - 9).如果值为14,则值已经包围,因此它将导致增加1.

较高的值也会增加或减少该值,具体取决于它包围原始范围的次数.

我希望这是有道理的,因为我发现很难解释.

编辑:

不会以浮点值振荡:

        for (float i = 0; i < 100; i += 0.1f)
        {
            Console.WriteLine("{0} {1}", i, Oscillate(2.5f, 7.5f, i));
        }

    private float Oscillate(float min, float …

我有两个简单的着色器(顶点和片段)

顶点着色器

#version 330 core

//=============================================
//---[Structs/Vertex Data]---------------------
//=============================================

layout(location = 0) in vec3 vertexPosition_modelspace;

//=============================================
//---[Variables]-------------------------------
//=============================================

uniform mat4 projection;
uniform mat4 view;

//=============================================
//---[Vertex Shader]---------------------------
//=============================================

void main()
{
   gl_Position = projection * view * vertexPosition_modelspace;
}

片段着色器

#version 330 core

//=============================================
//---[Output Struct]---------------------------
//=============================================

out vec3 colour;

//=============================================
//---[Fragment Shader]-------------------------
//=============================================

void main()
{
    colour = vec3(1, 0, 0);
}

我正在尝试编译它们,我得到以下错误

错误C0000:语法错误,意外$ undefined,在令牌"undefined"处期待"::"

我相信这可能与我阅读文件的方式有关.以下是顶点着色器文件的示例

std::string VertexShaderCode = FindFileOrThrow(vertex_file_path);
std::ifstream vShaderFile(VertexShaderCode.c_str());
std::stringstream vShaderData;
vShaderData << vShaderFile.rdbuf();
vShaderFile.close();

然后使用编译该文件 …

我正在尝试使用正则表达式来匹配以下两种字符串类型:

Name(p0, p1,...pN)

和:

Name()

我目前正在使用正则表达式:

@"[a-z]+\([^()]+\)"

我能理解:

[a-z]        = Match any character from a to z

我不太确定:

[^()]        ?= Match any character between '(' and ')'

我认为它属于一个组表示为:

\([^()]+\)

但同样,我不确定.

目前,该表达式适用于:

Name(p0, p1,...pN)

但是当括号之间没有逗号分隔的字符时,我无法匹配它.那是:

Name()

为什么第二个表达式失败？

编辑:

从你的答案我已经确定了以下(如果错误,请纠正我):

         +            = ONE or more times
         *            = ZERO or more times
         []           = Groups characters to match or ignore
         ^            = Logical NOT

         [a-z]+       = Match a lowercase letter (ONE or more times) 
         \(           = Match the character '(' …

我想从 Unity 的 C# 脚本中访问精灵的 Pixels To Units 属性。

如果我获得 localScale 或 lossyScale 属性，则需要将它们除以该数字，以便根据其 Pixels To Units 属性可能具有不同值的其他对象进行缩放。

在这种情况下如何正确获取该属性的值或缩放？

我有一个指向基本抽象类(实体)的指针列表

std::list<Entity*> m_entities;

我已经创建了一个用于迭代这个类的typedef

typedef std::list<Entity*>::const_iterator entityIter;

然后我尝试迭代列表中的每个指针

for (entityIter i = m_entities.begin(); i != m_entities.end(); ++i)
{
    const Entity &e = *i;    // ERROR
    e.DoStuff();
}

尝试引用每个指针时出现以下错误

IntelliSense:没有合适的构造函数可以从"Entity*const"转换为"Entity"

我做错了什么？

编辑:

我试过使用std :: shared_ptr

std::list<std::shared_ptr<Entity>> m_entities;

我不能这样添加到列表中

Entity::Entity(Game *game) 
    : m_game(game)                  
{
    m_game->g_idGenerator->generateNewID();

    m_game->m_entities.push_back(this);      // ERROR
}

使用以下内容

m_game->m_entities.push_back(std::shared_ptr<Entity>(this));

给了我这个错误

错误C2664:'void std :: list <_Ty> :: push_back(_Ty &&)':无法将参数1从>'Entity'转换为'std :: tr1 :: shared_ptr <_Ty> &&'

编辑2:

当前代码摘要

for (entityIter i = m_entities.begin(); i != m_entities.end(); ++i)
{
    // *i dereferences the …