小编Luk*_* B.的帖子

我正在使用六边形瓷砖地图开发一个简单的2D棋盘游戏,我已经阅读了几篇文章(包括gamedev one,每次有关于六边形瓷砖的问题时都会链接)关于如何在屏幕上绘制六边形以及如何管理运动(虽然我以前做过很多).我的主要问题是根据给定的半径找到相邻的瓷砖.

这就是我的地图系统的工作方式:

(0,0) (0,1) (0,2) (0,3) (0,4)
   (1,0) (1,1) (1,2) (1,3) (1,4)
(2,0) (2,1) (2,2) (2,3) (2,4)
   (3,0) (3,1) (3,2) (3,3) (3,4)

等等...

我正在努力的事实是我不能通过使用for(x-range;x+range;x++); for(y-range;y+range;y++);来选择相邻的瓷砖,因为它选择了不需要的瓷砖(在我给出的示例中,选择(1,1)瓷砖并给出1的范围也会给出我是(3,0)瓷砖(我实际需要的是(0,1)(0,2)(1,0)(1,2)(2,1)(2,2)),这是有点与瓷砖相邻(因为数组的结构方式),但它并不是我想要选择的东西.我可以强制它,但这不会很美,可能不会覆盖'选择半径的东西".

有人能指出我在正确的方向吗？

我的场景中有一个3D对象,该对象的片段着色器接收到与屏幕大小相同的纹理.我想从当前片段中获取坐标,并在同一位置找到图像上的颜色信息.这可能吗？有人能指出我正确的方向吗？

为我的h/hpp文件创建标题保护对我来说一直是标准做法,但我想知道,为什么甚至可以两次包含相同的文件？是否存在实际需要不受保护的标头的情况？

我有一个表单可以帮助用户在最后选择一个特定的东西,但是当用户填写第一个选项时,下面的其他选项会改变.像这样的东西:

Type:
{
    t1:{
        Number of X:{
            1:{...}
            2:{...}
        }
        Number of Y:{...}
    }
    t2:{
        Number of X:{
            100:{...}
            200:{...}
        }
        Number of Y:{...}
    }
}

用户在字段Type中有选项t1和t2,当他们选择t1时,字段"Number of X"将填充1和2,如果他们选择t2,字段"Number of X"将填充100和200,依此类推.一些选择取决于多个字段,它不是直接依赖(例如,如果用户选择"Number of X"= 100则Foo为"A",否则,Foo可以是"A","B"或"C",但Foo并不低于"X的数量").

我尝试了一个非常天真的实现,我会在每个字段上设置事件监听器并查看它们的更改,但最终代码开始变得失控,我有一堆$("#foo").change(function(){...});并且它不是非常明显的,听取这个的字段是bar不是fbar.

我也试过JSON(如上例所示),但是有很多重复,树越长,可能性越多,我必须一次又一次地写相同的字段.有时候选择t1会直接改变一个选项,即使它没有直接贬低它,即使它通常完全取决于另一个领域,而且JSON中的重复次数更多.

我该如何处理这个问题？有可读的解决方案吗？只要能够查看代码并理解依赖关系及其影响,代码太多就不是问题所在.

一个代码示例(有点像我现在的代码):

HTML:

<select id="type">
<option value=1>a</option>
<option value=2>b</option>
</select>
<select id="numOfX">
</select>
<select id="numOfY">
</select>

JS:

$("#type").change(function()
{
    if($("#type").val() == 1)
    {
        $("#numOfX").append(new Option(1, "1", false, false));
        $("#numOfX").append(new Option(2, "2", false, false));
    }
    else if($("#type").val() …

我试图在HTML5游戏中使用以下效果:http://somethinghitme.com/projects/metaballs/

但由于它是一个游戏(而不是图形演示),我有更严格的FPS要求,我需要时间来计算物理和其他一些东西,我最大的瓶颈是元球的代码.

以下代码是我在剥离原始代码后获得的性能,它不是很漂亮,但它足以满足我的目的:

ParticleSpawner.prototype.metabilize = function(ctx) {
    var imageData = this._tempCtx.getImageData(0,0,900,675),
    pix = imageData.data;
    this._tempCtx.putImageData(imageData,0,0);

    for (var i = 0, n = pix.length; i <n; i += 4) {
        if(pix[i+3]<210){
            pix[i+3] = 0;
        }
    }

    //ctx.clearRect(0,0,900,675);
    //ctx.drawImage(this._tempCanvas,0,0);
    ctx.putImageData(imageData, 0, 0);
}

我的代码上有另一个循环,我设法通过使用以下链接http://www.fatagnus.com/unrolling-your-loop-for-better-performance-in-javascript/中描述的技术来提高其性能,但是在这上使用相同实际上会降低性能(也许我做错了？)

我还研究了网络工作者,看看我是否可以分割负载(因为代码分别针对每个像素运行)但是我在这个链接上找到的例子http://blogs.msdn.com/b/eternalcoding/archive/2012/09 /20/using-web-workers-to-improve-performance-of-image-manipulation.aspx在使用Web worker时实际运行速度较慢.

我还可以做些什么？有没有办法从循环中删除分支？展开它的另一种方式？或者这是我能做的最好的？

编辑:

这是一些周围的代码:

ParticleSpawner.prototype.drawParticles = function(ctx) {
    this._tempCtx.clearRect(0,0,900,675);

    var iterations = Math.floor(this._particles.getNumChildren() / 8);
    var leftover = this._particles.getNumChildren() % 8;
    var i = 0;

    if(leftover > 0) { …

给出以下代码(http://liveworkspace.org/code/5oact):

class Foo
 {
     public:
         Foo()
         {
             log(__PRETTY_FUNCTION__);
         }
         Foo(const Foo& other)
         {
             log(__PRETTY_FUNCTION__);
         }
         Foo& operator=(const Foo& other)
         {
             log(__PRETTY_FUNCTION__);
             return *this;
         }
         Foo(Foo&& other) noexcept
         {
             log(__PRETTY_FUNCTION__);
         }
         Foo& operator=(Foo&& other) noexcept
         {
             log(__PRETTY_FUNCTION__);
             return *this;
         }
         ~Foo(){}
 };

使用这样的类:

std::vector<Foo> tt;

tt.emplace_back();
tt.emplace_back();
tt.emplace_back();
tt.emplace_back();

我得到以下输出:

Foo::Foo()
Foo::Foo()
Foo::Foo(const Foo&)
Foo::Foo()
Foo::Foo(const Foo&)
Foo::Foo(const Foo&)
Foo::Foo()

如果我删除自定义析构函数,我得到以下输出:

Foo::Foo()
Foo::Foo()
Foo::Foo(Foo&&)
Foo::Foo()
Foo::Foo(Foo&&)
Foo::Foo(Foo&&)
Foo::Foo()

当我声明析构函数时,为什么编译器使用复制构造函数而不是移动？我理解移动操作不能抛出(如果我noexcept从代码中删除,编译器根本不会使用它),但是析构函数与它有什么关系？

考虑一下:

class Vec3
{
    private:
        float n[3];
    public:
        float& x;
        float& y;
        float& z;
        Vec3(float x_, float y_, float z_) : x(n[0]), y(n[1]), z(n[2])
        {
            x = x_;
            y = y_;
            z = z_;
        }
}

我可以肯定这样做:

Vec3 v(1,2,3);
cout<<reinterpret_cast<float*>(&v)[0]<<"\t";
cout<<reinterpret_cast<float*>(&v)[1]<<"\t";
cout<<reinterpret_cast<float*>(&v)[2]<<"\t";

将1 2 3遵循标准的每个编译器/操作系统给我？

我有一个带有std ::指针映射的结构体.我正在尝试执行以下操作:

template <class T>
struct Foo
{
    std::map<std::string, T*> f;
    T& operator[](std::string s)
    {
        return *f[s];
    }
}

然后像这样使用它:

Foo<Bar> f;
f["key"] = new Bar();

但它写的方式,它崩溃了程序.我也尝试过这样:

T* operator[](std::string s)
{
    return f[s];
}

但它没有编译.它说"lvalue required as left operand of assignment"就f["key"] = new Bar()行了.

我希望它很容易,因为我正在尝试返回一个指针而我正在存储一个指针.我的代码出了什么问题？

我正在使用Lua和C++(使用LuaWrapper),我遇到了麻烦.假设我有这些课程:

class Bar{...};
class Foo
{
    ...
    std::map<std::string,Bar*> _barlist;
    ...
    Bar* getBar(std::string key)
    {
        return _barlist[key];
    }
}

class BarDerived1 : public Bar{...}
class BarDerived2 : public Bar{...}

我可以访问Foo和Foo::getBar()从Lua 访问,事实是返回的对象的类型是Bar,我无法访问其BarDerivedX方法.

据我所知,Lua中的Objects/Classes只是MetaTables,其功能分配给键,所以我想知道是否有办法将这些额外的函数从BarDerivedX类复制到Bar对象(甚至可以工作吗？),也是这是最好的方法,或者我应该在让Lua访问之前用C++编译它？