【问题标题】:Canvas Rotating Star Field帆布旋转星场
【发布时间】:2015-10-31 14:15:24
【问题描述】:

我正在采用以下方法在屏幕上为星域设置动画,但我被困在下一部分。

JS

var c = document.getElementById('stars'),
    ctx = c.getContext("2d"),
    t = 0; // time

c.width = 300;
c.height = 300;

var w = c.width,
    h = c.height,
    z = c.height,
    v = Math.PI; // angle of vision

(function animate() {

    Math.seedrandom('bg');
    ctx.globalAlpha = 1;

    for (var i = 0; i <= 100; i++) {

        var x = Math.floor(Math.random() * w), // pos x
            y = Math.floor(Math.random() * h), // pos y
            r = Math.random()*2 + 1, // radius
            a = Math.random()*0.5 + 0.5, // alpha

            // linear
            d = (r*a),       // depth
            p = t*d;         // pixels per t

        x = x - p;       // movement
        x = x - w * Math.floor(x / w); // go around when x < 0

        (function draw(x,y) {
            var gradient = ctx.createRadialGradient(x, y, 0, x + r, y + r, r * 2);
            gradient.addColorStop(0, 'rgba(255, 255, 255, ' + a + ')');
            gradient.addColorStop(1, 'rgba(0, 0, 0, 0)');

            ctx.beginPath();
            ctx.arc(x, y, r, 0, 2*Math.PI);
            ctx.fillStyle = gradient;
            ctx.fill();

            return draw;

        })(x, y);

    }

    ctx.restore();
    t += 1;

    requestAnimationFrame(function() {
        ctx.clearRect(0, 0, c.width, c.height);
        animate();
    });
})();

HTML

<canvas id="stars"></canvas>

CSS

canvas {
    background: black;
}

JSFiddle

它现在所做的是使用 delta X 为每颗恒星设置动画,该 delta X 考虑了恒星的不透明度和大小,因此最小的那些看起来移动得更慢。

使用p = t; 让所有星星以相同的速度移动。

问题

我正在寻找一个定义明确的模型,其中速度给出了恒星围绕期望者旋转的错觉,根据旋转中心cX, cY 和角度定义视觉v 可以看到2π的几分之一(如果圆心不是屏幕的中心,那么半径应该至少是最大的部分)。我正在努力寻找一种将余弦应用于恒星运动速度的方法,即使对于旋转为 π 的中心圆也是如此。

这些图表可能会进一步解释我所追求的:

中心圆:

非居中:

不同的视角:

我真的不知道如何前进。我已经伸了个懒腰才到这里。你能帮我做一些第一步吗?

谢谢


更新

我在这段代码上取得了一些进展:

        // linear
        d = (r*a)*z,   // depth
        v = (2*Math.PI)/w,
        p = Math.floor( d * Math.cos( t * v ) );     // pixels per t

    x = x + p;       // movement
    x = x - w * Math.floor(x / w); // go around when x < 0

JSFiddle

其中p 是匀速圆周运动粒子的 x 坐标,v 是角速度,但这会产生钟摆效应。我不知道如何改变这些方程来创造观察者正在转动的错觉。


更新 2:

差不多了。 ##Math freenode 频道的一位用户非常友好地建议了以下计算:

        // linear
        d = (r*a),       // depth
        p = t*d;         // pixels per t

    x = x - p;       // movement
    x = x - w * Math.floor(x / w); // go around when x < 0

    x = (x / w) - 0.5;
    y = (y / h) - 0.5;

    y /= Math.cos(x);

    x = (x + 0.5) * w;
    y = (y + 0.5) * h;

JSFiddle

这在视觉上实现了效果,但在变量方面没有遵循明确定义的模型(它只是“破解”效果)所以我看不到一个直接的方法来做不同的实现(改变中心,视角)。真实模型可能与这个非常相似。


更新 3

根据 Iftah 的回复,我能够使用 Sylvester 将旋转矩阵应用于需要先保存在数组中的星星。现在还确定了每颗星的z 坐标,而半径r 和不透明度a 是从它派生的。代码有很大的不同和更长,所以我没有发布它,但这可能是朝着正确方向迈出的一步。我还不能让它连续旋转。在每帧上使用矩阵运算在性能方面似乎代价高昂。

JSFiddle

【问题讨论】:

  • 把你的星空想象成天空,想象你的观众从窗外看星星。使您的星空大于视口(大于用户窗口)。然后,例如,随着 cY 向下移动,您将显示更多的顶部和更少的底部您的星空。你没有提到 cZ (就像在你的第二个插图中,人们将眼睛压在视口上观看)。当 cZ 接近视口时,您会在各个方向显示更多的星空。星星是如此遥远,以至于它们各自的速度不需要改变——除非你处于曲速!
  • 虽然没有必要在画布上画星星。我认为我们正在寻找的是p = f(d),它使用余弦来模拟 x 在v 的圆圈中的变化。不过,正如您所指出的,有一个 cZ 变量我没有为第一个示例添加,我将添加它。
  • 正确,画布元素是您的视口,它显示了较大的星空的一部分(好像超出了画布“窗口”)。您只需要显示位于 canvas 元素内的星空部分。

标签: javascript graphics html5-canvas game-physics trigonometry


【解决方案1】:

这里有一些伪代码,可以满足您的要求。

Make a bunch of stars not too far but not too close (via rejection sampling)
Set up a projection matrix (defines the camera frustum)
Each frame
    Compute our camera rotation angle
    Make a "view" matrix (repositions the stars to be relative to our view)
    Compose the view and projection matrix into the view-projection matrix
    For each star
        Apply the view-projection matrix to give screen star coordinates
        If the star is behind the camera skip it
        Do some math to give the star a nice seeming 'size'
        Scale the star coordinate to the canvas
        Draw the star with its canvas coordinate and size

我已经实现了上述内容。它使用 gl-matrix Javascript 库来处理一些矩阵数学。这是好东西。 (小提琴是here,或见下文。)

var c = document.getElementById('c');
var n = c.getContext('2d');

// View matrix, defines where you're looking
var viewMtx = mat4.create();

// Projection matrix, defines how the view maps onto the screen
var projMtx = mat4.create();

// Adapted from http://stackoverflow.com/questions/18404890/how-to-build-perspective-projection-matrix-no-api
function ComputeProjMtx(field_of_view, aspect_ratio, near_dist, far_dist, left_handed) {
    // We'll assume input parameters are sane.
    field_of_view = field_of_view * Math.PI / 180.0; // Convert degrees to radians
    var frustum_depth = far_dist - near_dist;
    var one_over_depth = 1 / frustum_depth;
    var e11 = 1.0 / Math.tan(0.5 * field_of_view);
    var e00 = (left_handed ? 1 : -1) * e11 / aspect_ratio;
    var e22 = far_dist * one_over_depth;
    var e32 = (-far_dist * near_dist) * one_over_depth;
    return [
        e00, 0, 0, 0,
        0, e11, 0, 0,
        0, 0, e22, e32,
        0, 0, 1, 0
    ];
}

// Make a view matrix with a simple rotation about the Y axis (up-down axis)
function ComputeViewMtx(angle) {
    angle = angle * Math.PI / 180.0; // Convert degrees to radians
    return [
        Math.cos(angle), 0, Math.sin(angle), 0,
        0, 1, 0, 0,
        -Math.sin(angle), 0, Math.cos(angle), 0,
        0, 0, 0, 1
    ];
}

projMtx = ComputeProjMtx(70, c.width / c.height, 1, 200, true);

var angle = 0;

var viewProjMtx = mat4.create();

var minDist = 100;
var maxDist = 1000;

function Star() {
    var d = 0;
    do {
        // Create random points in a cube.. but not too close.
        this.x = Math.random() * maxDist - (maxDist / 2);
        this.y = Math.random() * maxDist - (maxDist / 2);
        this.z = Math.random() * maxDist - (maxDist / 2);
        var d = this.x * this.x +
                this.y * this.y +
                this.z * this.z;
    } while (
         d > maxDist * maxDist / 4 || d < minDist * minDist
    );
    this.dist = Math.sqrt(d);
}

Star.prototype.AsVector = function() {
    return [this.x, this.y, this.z, 1];
}

var stars = [];
for (var i = 0; i < 5000; i++) stars.push(new Star());

var lastLoop = Date.now();

function loop() {
    
    var now = Date.now();
    var dt = (now - lastLoop) / 1000.0;
    lastLoop = now;
    
    angle += 30.0 * dt;

    viewMtx = ComputeViewMtx(angle);
    
    //console.log('---');
    //console.log(projMtx);
    //console.log(viewMtx);
    
    mat4.multiply(viewProjMtx, projMtx, viewMtx);
    //console.log(viewProjMtx);
    
    n.beginPath();
    n.rect(0, 0, c.width, c.height);
    n.closePath();
    n.fillStyle = '#000';
    n.fill();
    
    n.fillStyle = '#fff';
    
    var v = vec4.create();
    for (var i = 0; i < stars.length; i++) {
        var star = stars[i];
        vec4.transformMat4(v, star.AsVector(), viewProjMtx);
        v[0] /= v[3];
        v[1] /= v[3];
        v[2] /= v[3];
        //v[3] /= v[3];
        
        if (v[3] < 0) continue;

        var x = (v[0] * 0.5 + 0.5) * c.width;
        var y = (v[1] * 0.5 + 0.5) * c.height;
        
        // Compute a visual size...
        // This assumes all stars are the same size.
        // It also doesn't scale with canvas size well -- we'd have to take more into account.
        var s = 300 / star.dist;
        
        
        n.beginPath();
        n.arc(x, y, s, 0, Math.PI * 2);
        //n.rect(x, y, s, s);
        n.closePath();
        n.fill();
    }
    
    window.requestAnimationFrame(loop);
}

loop();
<script src="https://cdnjs.cloudflare.com/ajax/libs/gl-matrix/2.3.1/gl-matrix-min.js"></script>
<canvas id="c" width="500" height="500"></canvas>

一些链接:

更新

这是另一个具有键盘控制的版本。有点好玩。您可以从扫射中看到旋转和视差之间的区别。效果最好的整页。 (小提琴是here 或见下文。)

var c = document.getElementById('c');
var n = c.getContext('2d');

// View matrix, defines where you're looking
var viewMtx = mat4.create();

// Projection matrix, defines how the view maps onto the screen
var projMtx = mat4.create();

// Adapted from http://stackoverflow.com/questions/18404890/how-to-build-perspective-projection-matrix-no-api
function ComputeProjMtx(field_of_view, aspect_ratio, near_dist, far_dist, left_handed) {
    // We'll assume input parameters are sane.
    field_of_view = field_of_view * Math.PI / 180.0; // Convert degrees to radians
    var frustum_depth = far_dist - near_dist;
    var one_over_depth = 1 / frustum_depth;
    var e11 = 1.0 / Math.tan(0.5 * field_of_view);
    var e00 = (left_handed ? 1 : -1) * e11 / aspect_ratio;
    var e22 = far_dist * one_over_depth;
    var e32 = (-far_dist * near_dist) * one_over_depth;
    return [
        e00, 0, 0, 0,
        0, e11, 0, 0,
        0, 0, e22, e32,
        0, 0, 1, 0
    ];
}

// Make a view matrix with a simple rotation about the Y axis (up-down axis)
function ComputeViewMtx(angle) {
    angle = angle * Math.PI / 180.0; // Convert degrees to radians
    return [
        Math.cos(angle), 0, Math.sin(angle), 0,
        0, 1, 0, 0,
        -Math.sin(angle), 0, Math.cos(angle), 0,
        0, 0, -250, 1
    ];
}

projMtx = ComputeProjMtx(70, c.width / c.height, 1, 200, true);

var angle = 0;

var viewProjMtx = mat4.create();

var minDist = 100;
var maxDist = 1000;

function Star() {
    var d = 0;
    do {
        // Create random points in a cube.. but not too close.
        this.x = Math.random() * maxDist - (maxDist / 2);
        this.y = Math.random() * maxDist - (maxDist / 2);
        this.z = Math.random() * maxDist - (maxDist / 2);
        var d = this.x * this.x +
                this.y * this.y +
                this.z * this.z;
    } while (
         d > maxDist * maxDist / 4 || d < minDist * minDist
    );
    this.dist = 100;
}

Star.prototype.AsVector = function() {
    return [this.x, this.y, this.z, 1];
}

var stars = [];
for (var i = 0; i < 5000; i++) stars.push(new Star());

var lastLoop = Date.now();


var dir = {
    up: 0,
    down: 1,
    left: 2,
    right: 3
};

var dirStates = [false, false, false, false];
var shiftKey = false;

var moveSpeed = 100.0;
var turnSpeed = 1.0;

function loop() {
    var now = Date.now();
    var dt = (now - lastLoop) / 1000.0;
    lastLoop = now;
    
    angle += 30.0 * dt;

    //viewMtx = ComputeViewMtx(angle);
    var tf = mat4.create();
    if (dirStates[dir.up]) mat4.translate(tf, tf, [0, 0, moveSpeed * dt]);
    if (dirStates[dir.down]) mat4.translate(tf, tf, [0, 0, -moveSpeed * dt]);
    if (dirStates[dir.left])
        if (shiftKey) mat4.rotate(tf, tf, -turnSpeed * dt, [0, 1, 0]);
        else mat4.translate(tf, tf, [moveSpeed * dt, 0, 0]);
    if (dirStates[dir.right])
        if (shiftKey) mat4.rotate(tf, tf, turnSpeed * dt, [0, 1, 0]);
        else mat4.translate(tf, tf, [-moveSpeed * dt, 0, 0]);
    mat4.multiply(viewMtx, tf, viewMtx);
    
    //console.log('---');
    //console.log(projMtx);
    //console.log(viewMtx);
    
    mat4.multiply(viewProjMtx, projMtx, viewMtx);
    //console.log(viewProjMtx);
    
    n.beginPath();
    n.rect(0, 0, c.width, c.height);
    n.closePath();
    n.fillStyle = '#000';
    n.fill();
    
    n.fillStyle = '#fff';
    
    var v = vec4.create();
    for (var i = 0; i < stars.length; i++) {
        var star = stars[i];
        vec4.transformMat4(v, star.AsVector(), viewProjMtx);
        
        if (v[3] < 0) continue;
        
        var d = Math.sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
        
        v[0] /= v[3];
        v[1] /= v[3];
        v[2] /= v[3];
        //v[3] /= v[3];
        

        var x = (v[0] * 0.5 + 0.5) * c.width;
        var y = (v[1] * 0.5 + 0.5) * c.height;
        
        // Compute a visual size...
        // This assumes all stars are the same size.
        // It also doesn't scale with canvas size well -- we'd have to take more into account.
        var s = 300 / d;
        
        
        n.beginPath();
        n.arc(x, y, s, 0, Math.PI * 2);
        //n.rect(x, y, s, s);
        n.closePath();
        n.fill();
    }
    
    window.requestAnimationFrame(loop);
}

loop();

function keyToDir(evt) {
    var d = -1;
    if (evt.keyCode === 38) d = dir.up
    else if (evt.keyCode === 37) d = dir.left;
    else if (evt.keyCode === 39) d = dir.right;
    else if (evt.keyCode === 40) d = dir.down;
    return d;
}

window.onkeydown = function(evt) {
    var d = keyToDir(evt);
    if (d >= 0) dirStates[d] = true;
    if (evt.keyCode === 16) shiftKey = true;
}

window.onkeyup = function(evt) {
    var d = keyToDir(evt);
    if (d >= 0) dirStates[d] = false;
    if (evt.keyCode === 16) shiftKey = false;
}
<script src="https://cdnjs.cloudflare.com/ajax/libs/gl-matrix/2.3.1/gl-matrix-min.js"></script>
<div>Click in this pane. Use up/down/left/right, hold shift + left/right to rotate.</div>
<canvas id="c" width="500" height="500"></canvas>

更新 2

Alain Jacomet Forte 问:

您推荐的创建通用 3d 的方法是什么?您是否建议在矩阵级别工作,特别是可能针对这种特定场景。

关于矩阵:如果您在任何平台上从头开始编写引擎,那么您最终将不可避免地使用矩阵,因为它们有助于概括基本的 3D 数学。即使您使用 OpenGL/WebGL 或 Direct3D,您最终仍会为更复杂的目的制作视图和投影矩阵以及其他矩阵。 (处理法线贴图、对齐世界对象、蒙皮等...)

关于创建通用 3d 的方法...不要。它会运行得很慢,而且如果没有大量工作,它就不会表现出色。依靠硬件加速库来完成繁重的工作。为特定项目创建有限的 3D 引擎既有趣又具有启发性(例如,我想在我的网页上制作一个很酷的动画),但是当涉及到将像素放在屏幕上以处理任何严肃的事情时,您希望硬件尽可能多地处理它性能目的。

遗憾的是,网络对此还没有很好的标准,但它正在出现在 WebGL 中——学习 WebGL,使用 WebGL。它运行良好,并且在受支持时运行良好。 (但是,你可以摆脱很多 just using CSS 3D transforms and Javascript。)

如果您正在做桌面编程,我强烈推荐通过 SDL 的 OpenGL(我还没有在 SFML 上出售)——它是跨平台的并且得到很好的支持。

如果您正在为手机编程,OpenGL ES 几乎是您唯一的选择(除了狗慢的软件渲染器)。

如果您想完成工作而不是从头开始编写自己的引擎,那么 Web 的事实就是 Three.js(我觉得它有效但平庸)。如果你想要一个完整的游戏引擎,现在有一些免费的选择,主要的商业引擎是 Unity 和 Unreal。 Irrlicht 已经存在很长时间了——虽然从来没有机会使用它,但我听说它很好。

但是,如果您想从头开始制作所有 3D 东西……我总是发现 Quake 中的软件渲染器是如何成为一个很好的案例研究的。其中一些可以在here找到。

【讨论】:

  • 这基本上是 Iftah 所提议的。这是做“3D”事情的标准方式。设置一个世界空间,将项目放在该空间中,并找出它们应该出现在如果该空间中有虚拟摄像头,则显示屏幕。
  • 顺便说一句,这段代码足够通用,可以从任何有利位置查看星星的球体——只需以适当的方式修改视图矩阵以使其发生。简单的方法是使用 gl-matrix 的“查看”功能来设置视图矩阵。
  • 此外,gl-matrix 可用于更轻松地制作投影和查看矩阵 - 但我认为数学可能有助于查看您是否不想使用 gl-matrix。
  • 您能否将小提琴的代码编辑到您的答案中,以便它可以一直存档,the script run here on SO, inline, without fiddle rot
  • @Kaganar 你曾问过如何让代码部分默认折叠——如果你仍然有兴趣这样做,你可以通过在&lt;!-- begin snippet: js hide: false --&gt; 更改帖子中的 sn-p 降价来完成它到&lt;!-- begin snippet: js hide: true --&gt;
【解决方案2】:

您在每帧重置星星 2d 位置,然后移动星星(取决于每颗星星的时间和速度) - 这是实现目标的不好方法。正如您所发现的,当您尝试将此解决方案扩展到更多场景时,它会变得非常复杂。

更好的方法是只设置一次星星的 3d 位置(在初始化时),然后每帧移动一个“相机”(取决于时间)。当您想要渲染 2d 图像时,您可以计算屏幕上的星星位置。屏幕上的位置取决于星星 3d 位置和当前相机位置。 这将允许您移动相机(在任何方向),旋转相机(到任何角度)并渲染正确的星星位置并保持理智。

【讨论】:

  • 能否提供一些代码示例来说明您的提议?这似乎是一个非常大的变化。此外,根据该模型外推,我们可以合理地找到适合我的方程,不是吗? - 我看不出这在代码方面会有什么不同。似乎只是概念上的不同。谢谢
  • 我想我的建议是构建一个小型 3d 引擎,它需要一些(非常少的)线性代数才能优雅地完成。
  • 这是一个有趣的方法。如果您能详细说明,那就太好了。
  • 这是我使用 numeric.js 从您的 cmets 中所做的,并获得 [x,y,z] 向量的点积和围绕 Y 轴的旋转矩阵:jsfiddle.net/u4Lq8fgd,但我对线性代数不是很好,它们在旋转但正在远离!你能帮忙吗?
  • 抱歉现在很忙...我稍后会有空闲时间,大约 4 小时后,然后再试
猜你喜欢
  • 2015-07-01
  • 2012-01-01
  • 2015-07-07
  • 1970-01-01
  • 1970-01-01
  • 1970-01-01
  • 2018-04-05
  • 2019-11-08
  • 1970-01-01
相关资源
最近更新 更多