HTML5 Canvas 相机/视口 - 如何实际做到这一点?

时间：2023-06-22

本文介绍了HTML5 Canvas 相机/视口 - 如何实际做到这一点?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着跟版网的小编来一起学习吧！

问题描述

我确信这已经解决了 1000 次:我有一个 960*560 大小的画布和一个 5000*3000 大小的房间，其中始终只应绘制 960*560，具体取决于球员是.玩家应该始终在中间，但是当靠近边界时 - 应该计算最佳视图).玩家可以使用 WASD 或箭头键完全自由移动.并且所有对象都应该自己移动 - 而不是我移动除了玩家之外的所有东西来创造玩家移动的错觉.

我现在找到了这两个问题:

演示中的工作原理:

我们有一个代表房间的大图像，我们想在画布上只显示视口内的部分.裁剪位置 (sx, sy) 与相机 (xView, yView) 的位置相同，裁剪尺寸与视口 (canvas) 相同，因此 sWidth=canvas.width 和 sHeight=canvas.height.

我们需要注意裁剪尺寸，因为如果裁剪位置或基于位置的裁剪尺寸无效，drawImage 不会在画布上绘制任何内容.这就是为什么我们需要下面的 if 部分.

var sx, sy, dx, dy;变量 sWidth、sHeight、dWidth、dHeight；//裁剪图像的偏移点sx = xView;sy = y 视图；//裁剪图像的尺寸sWidth = context.canvas.width;sHeight = context.canvas.height;//如果裁剪后的图像比画布小，我们需要更改源尺寸if(image.width - sx < sWidth){sWidth = image.width - sx;}if(image.height - sy < sHeight){sHeight = image.height - sy;}//在画布上绘制裁剪图像的位置dx = 0；dy = 0;//将目标与源匹配以不缩放图像d 宽度 = s 宽度；dHeight = sHeight；//绘制裁剪后的图像context.drawImage(图像, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);

<小时>

绘制与视口相关的游戏对象

在编写游戏时，最好将游戏中每个对象的逻辑和渲染分开.所以在演示中我们有 update 和 draw 函数.update 方法更改对象状态，如游戏世界"上的位置、应用物理、动画状态等. draw 方法实际渲染对象并考虑到正确渲染它视口，对象需要知道渲染上下文和视口属性.

请注意，游戏对象会根据游戏世界的位置进行更新.这意味着对象的 (x,y) 位置是世界中的位置.尽管如此，由于视口在变化，因此需要正确渲染对象，并且渲染位置将与世界位置不同.

转换很简单:

物体在世界(房间)中的位置:(x, y)
视口位置:(xView, yView)

渲染位置:(x-xView, y-yView)

这适用于所有类型的坐标，甚至是负坐标.

<小时>

游戏相机

我们的游戏对象有一个单独的更新方法.在 Demo 实现中，相机被视为一个游戏对象，也有一个单独的更新方法.

camera对象持有viewport的左上位置(xView, yView)，要跟随的对象，代表viewport的矩形，代表游戏世界边界的矩形和最小距离在相机开始移动之前玩家可能处于的每个边界(xDeadZone，yDeadZone).我们还定义了相机的自由度(轴).对于顶视图风格的游戏，如 RPG，允许相机在 x(水平)和 y(垂直)轴上移动.

为了让玩家保持在视口的中间，我们将每个轴的 deadZone 设置为与画布的中心会聚.看代码中的follow函数:

<块引用>

camera.follow(播放器, canvas.width/2, canvas.height/2)

注意:请参阅下面的更新部分，因为当地图(房间)的任何尺寸小于画布时，这不会产生预期的行为.

<小时>

世界的极限

由于每个物体，包括相机，都有自己的更新功能，很容易检查游戏世界的边界.只记得将阻止移动的代码放在更新函数的最后.

<小时>

演示

查看完整代码并亲自尝试.代码的大部分部分都有指导您完成的注释.我假设您了解 Javascript 的基础知识以及如何使用原型(有时我使用术语类"来表示原型对象，只是因为它在 Java 等语言中具有类的类似行为).

现场演示

完整代码:

<!DOCTYPE HTML><html><身体><canvas id="gameCanvas" 宽度=400 高度=400/><脚本>//我们的游戏类"、方法"和对象"的包装器窗口.游戏 = {};//类"矩形的包装器(功能() {函数矩形(左，上，宽，高){this.left = 左 ||0;this.top = 顶部 ||0;this.width = 宽度 ||0;this.height = 高度 ||0;this.right = this.left + this.width;this.bottom = this.top + this.height;}Rectangle.prototype.set = function(left, top,/*optional*/width,/*optional*/height) {this.left = 左；this.top = 顶部；this.width = 宽度 ||这个.宽度;this.height = 高度 ||这个.高度this.right = (this.left + this.width);this.bottom = (this.top + this.height);}Rectangle.prototype.within = function(r) {return (r.left <= this.left &&r.right >= this.right &&r.top <= this.top &&r.bottom >= this.bottom);}Rectangle.prototype.overlaps = function(r) {return (this.left < r.right &&r.left  this.wView)this.xView = this.followed.x - (this.wView - this.xDeadZone);else if (this.followed.x - this.xDeadZone < this.xView)this.xView = this.followed.x - this.xDeadZone;}如果(this.axis == AXIS.VERTICAL || this.axis == AXIS.BOTH){//根据跟随的物体位置在垂直轴上移动相机如果(this.followed.y - this.yView + this.yDeadZone > this.hView)this.yView = this.followed.y - (this.hView - this.yDeadZone);else if (this.followed.y - this.yDeadZone < this.yView)this.yView = this.followed.y - this.yDeadZone;}}//更新视口矩形this.viewportRect.set(this.xView, this.yView);//不要让相机离开世界的边界如果(！this.viewportRect.within(this.worldRect)){if (this.viewportRect.left < this.worldRect.left)this.xView = this.worldRect.left;if (this.viewportRect.top < this.worldRect.top)this.yView = this.worldRect.top;if (this.viewportRect.right > this.worldRect.right)this.xView = this.worldRect.right - this.wView;if (this.viewportRect.bottom > this.worldRect.bottom)this.yView = this.worldRect.bottom - this.hView;}}//将类"相机添加到我们的游戏对象Game.Camera = 相机；})();//类"播放器的包装器(功能() {功能播放器(x，y){//(x, y) = 物体中心//注意力://它代表玩家在世界(房间)上的位置，而不是画布位置这个.x = x;这个.y = y;//以每秒像素为单位的移动速度this.speed = 200;//渲染属性this.width = 50;这个.height = 50;}Player.prototype.update = function(step, worldWidth, worldHeight) {//参数 step 是帧之间的时间(以秒为单位)//检查控件并相应地移动播放器如果(Game.controls.left)this.x -= this.speed * step;如果(Game.controls.up)this.y -= this.speed * step;如果(Game.controls.right)this.x += this.speed * step;如果(Game.controls.down)this.y += this.speed * step;//不要让玩家离开世界边界if (this.x - this.width/2 < 0) {this.x = this.width/2;}if (this.y - this.height/2 < 0) {this.y = this.height/2;}if (this.x + this.width/2 > worldWidth) {this.x = worldWidth - this.width/2;}如果(this.y + this.height/2 > worldHeight){this.y = worldHeight - this.height/2;}}Player.prototype.draw = 函数(上下文，xView，yView){//绘制一个简单的矩形作为我们的玩家模型上下文.保存()；context.fillStyle = "黑色";//在绘制之前，我们需要将玩家世界的位置转换为画布位置context.fillRect((this.x - this.width/2) - xView, (this.y - this.height/2) - yView, this.width, this.height);context.restore();}//将class" Player 添加到我们的 Game 对象Game.Player = 玩家；})();//类"映射的包装器(功能() {功能地图(宽度，高度){//地图尺寸this.width = 宽度；this.height = 高度；//贴图纹理this.image = null;}//创建一个程序生成的地图(您可以使用图像代替)Map.prototype.generate = function() {var ctx = document.createElement("canvas").getContext("2d");ctx.canvas.width = this.width;ctx.canvas.height = this.height;var rows = ~~(this.width/44) + 1;var columns = ~~(this.height/44) + 1;变种颜色=红色"；ctx.save();ctx.fillStyle = "红色";for (var x = 0, i = 0; i <行; x += 44, i++) {ctx.beginPath();for (var y = 0, j = 0; j < 列; y += 44, j++) {ctx.rect(x, y, 40, 40);}颜色=(颜色==红色"?蓝色":红色")；ctx.fillStyle = 颜色；ctx.fill();ctx.closePath();}ctx.restore();//将生成的地图存储为此图像纹理this.image = new Image();this.image.src = ctx.canvas.toDataURL("image/png");//清除上下文ctx = null;}//绘制调整到相机的地图Map.prototype.draw = 函数(上下文，xView，yView){//最简单的方法:绘制整个地图，只改变画布中的目标坐标//画布将自行剔除图像(至少在硬件加速环境中没有性能差距 ->)/*context.drawImage(this.image, 0, 0, this.image.width, this.image.height, -xView, -yView, this.image.width, this.image.height);*///教学方式(s"代表源"，d"代表变量名中的目标"):变量 sx、sy、dx、dy；变量 sWidth、sHeight、dWidth、dHeight；//裁剪图像的偏移点sx = xView;sy = y 视图；//裁剪图像的尺寸sWidth = context.canvas.width;sHeight = context.canvas.height;//如果裁剪后的图像比画布小，我们需要更改源尺寸if (this.image.width - sx < sWidth) {sWidth = this.image.width - sx;}if (this.image.height - sy < sHeight) {sHeight = this.image.height - sy;}//在画布上绘制裁剪图像的位置dx = 0；dy = 0;//将目标与源匹配以不缩放图像d 宽度 = s 宽度；dHeight = sHeight；context.drawImage(this.image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);}//添加类"映射到我们的游戏对象Game.Map = 地图；})();//游戏脚本(功能() {//准备我们的游戏画布var canvas = document.getElementById("gameCanvas");var context = canvas.getContext("2d");//游戏设置:变量 FPS = 30;变量间隔 = 1000/FPS；//毫秒var STEP = INTERVAL/1000//秒//设置一个代表房间的对象变房= {宽度:500，身高:300，地图:新 Game.Map(500, 300)};//为房间生成一个大的图像纹理room.map.generate();//设置播放器var player = new Game.Player(50, 50);//旧相机设置.它不适用于小于画布的地图.在此处保持代码停用作为参考./* var camera = new Game.Camera(0, 0, canvas.width, canvas.height, room.width, room.height);*//* camera.follow(player, canvas.width/2, canvas.height/2);*///为相机设置正确的视口大小var vWidth = Math.min(room.width, canvas.width);var vHeight = Math.min(room.height, canvas.height);//设置相机var camera = new Game.Camera(0, 0, vWidth, vHeight, room.width, room.height);camera.follow(player, vWidth/2, vHeight/2);//游戏更新函数变种更新=函数(){player.update(STEP, room.width, room.height);相机.更新()；}//游戏绘制函数var draw = 函数() {//清除整个画布context.clearRect(0, 0, canvas.width, canvas.height);//重绘所有对象room.map.draw(上下文，camera.xView，camera.yView)；player.draw(上下文，camera.xView，camera.yView)；}//游戏循环var gameLoop = 函数() {更新();画();}//<-- 配置播放/暂停功能://使用 setInterval 代替 requestAnimationFrame 以获得更好的跨浏览器支持，//但很容易更改为 requestAnimationFrame polyfill.var runningId = -1;游戏.play = function() {if (runningId == -1) {runningId = setInterval(function() {游戏循环()；}， 间隔);console.log("播放");}}Game.togglePause = function() {if (runningId == -1) {游戏.play();} 别的 {clearInterval(runningId);运行标识 = -1;console.log("暂停");}}//-->})();//<-- 配置游戏控制:游戏控制 = {左:假，向上:错误，正确:错误，下:假，};window.addEventListener("keydown", function(e) {开关(e.keyCode){case 37://左箭头Game.controls.left = true;休息;case 38://向上箭头Game.controls.up = true;休息;case 39://右箭头Game.controls.right = true;休息;case 40://向下箭头Game.controls.down = true;休息;}}， 错误的);window.addEventListener("keyup", function(e) {开关(e.keyCode){case 37://左箭头Game.controls.left = false;休息;case 38://向上箭头Game.controls.up = false;休息;case 39://右箭头Game.controls.right = false;休息;case 40://向下箭头Game.controls.down = false;休息;case 80://按键 P 暂停游戏Game.togglePause();休息;}}， 错误的);//-->//页面加载后开始游戏window.onload = 函数(){游戏.play();}</脚本></身体></html>

更新

如果地图(房间)的宽度和/或高度小于画布，之前的代码将无法正常工作.要解决此问题，请在游戏脚本中按如下方式设置相机:

//为相机设置正确的视口大小var vWidth = Math.min(room.width, canvas.width);var vHeight = Math.min(room.height, canvas.height);var camera = new Game.Camera(0, 0, vWidth, vHeight, room.width, room.height);camera.follow(player, vWidth/2, vHeight/2);

您只需要告诉相机构造函数视口将是地图(房间)或画布之间的最小值.由于我们希望玩家居中并绑定到该视口，camera.follow 函数也必须更新.

<小时>

随时报告任何错误或添加建议.

I'm sure this was solven 1000 times before: I got a canvas in the size of 960*560 and a room in the size of 5000*3000 of which always only 960*560 should be drawn, depending on where the player is. The player should be always in the middle, but when near to borders - then the best view should be calculated). The player can move entirely free with WASD or the arrow keys. And all objects should move themselves - instead of that i move everything else but the player to create the illusion that the player moves.

I now found those two quesitons:

HTML5 - Creating a viewport for canvas works, but only for this type of game, i can't reproduce the code for mine.

Changing the view "center" of an html5 canvas seems to be more promising and also perfomant, but i only understand it for drawing all other objects correctly relative to the player and not how to scroll the canvas viewport relative to the player, which i want to achieve first of course.

My code (simplified - the game logic is seperately):

var canvas = document.getElementById("game");
canvas.tabIndex = 0;
canvas.focus();
var cc = canvas.getContext("2d");

// Define viewports for scrolling inside the canvas

/* Viewport x position */   view_xview = 0;
/* Viewport y position */   view_yview = 0;
/* Viewport width */        view_wview = 960;
/* Viewport height */       view_hview = 560;
/* Sector width */          room_width = 5000;
/* Sector height */         room_height = 3000;

canvas.width = view_wview;
canvas.height = view_hview;

function draw()
{
    clear();
    requestAnimFrame(draw);

    // World's end and viewport
    if (player.x < 20) player.x = 20;
    if (player.y < 20) player.y = 20;
    if (player.x > room_width-20) player.x = room_width-20;
    if (player.y > room_height-20) player.y = room_height-20;

    if (player.x > view_wview/2) ... ?
    if (player.y > view_hview/2) ... ?
}

The way i am trying to get it working feels totally wrong and i don't even know how i am trying it... Any ideas? What do you think about the context.transform-thing?

I hope you understand my description and that someone has an idea. Kind regards

解决方案

LIVE DEMO at jsfiddle.net

This demo illustrates the viewport usage in a real game scenario. Use arrows keys to move the player over the room. The large room is generated on the fly using rectangles and the result is saved into an image.

Notice that the player is always in the middle except when near to borders (as you desire).

Now I'll try to explain the main portions of the code, at least the parts that are more difficult to understand just looking at it.

Using drawImage to draw large images according to viewport position

A variant of the drawImage method has eight new parameters. We can use this method to slice parts of a source image and draw them to the canvas.

drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight)

The first parameter image, just as with the other variants, is either a reference to an image object or a reference to a different canvas element. For the other eight parameters it's best to look at the image below. The first four parameters define the location and size of the slice on the source image. The last four parameters define the position and size on the destination canvas.

Font: https://developer.mozilla.org/en-US/docs/Web/Guide/HTML/Canvas_tutorial/Using_images

How it works in demo:

We have a large image that represents the room and we want to show on canvas only the part within the viewport. The crop position (sx, sy) is the same position of the camera (xView, yView) and the crop dimensions are the same as the viewport(canvas) so sWidth=canvas.width and sHeight=canvas.height.

We need to take care about the crop dimensions because drawImage draws nothing on canvas if the crop position or crop dimensions based on position are invalid. That's why we need the if sections bellow.

var sx, sy, dx, dy;
var sWidth, sHeight, dWidth, dHeight;

// offset point to crop the image
sx = xView;
sy = yView;

// dimensions of cropped image          
sWidth =  context.canvas.width;
sHeight = context.canvas.height;

// if cropped image is smaller than canvas we need to change the source dimensions
if(image.width - sx < sWidth){
    sWidth = image.width - sx;
}
if(image.height - sy < sHeight){
    sHeight = image.height - sy; 
}

// location on canvas to draw the croped image
dx = 0;
dy = 0;
// match destination with source to not scale the image
dWidth = sWidth;
dHeight = sHeight;          

// draw the cropped image
context.drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);

Drawing game objects related to viewport

When writing a game it's a good practice separate the logic and the rendering for each object in game. So in demo we have update and draw functions. The update method changes object status like position on the "game world", apply physics, animation state, etc. The draw method actually render the object and to render it properly considering the viewport, the object need to know the render context and the viewport properties.

Notice that game objects are updated considering the game world's position. That means the (x,y) position of the object is the position in world. Despite of that, since the viewport is changing, objects need to be rendered properly and the render position will be different than world's position.

The conversion is simple:

object position in world(room): (x, y)
viewport position: (xView, yView)

render position: (x-xView, y-yView)

This works for all kind of coordinates, even the negative ones.

Game Camera

Our game objects have a separated update method. In Demo implementation, the camera is treated as a game object and also have a separated update method.

The camera object holds the left top position of viewport (xView, yView), an object to be followed, a rectangle representing the viewport, a rectangle that represents the game world's boundary and the minimal distance of each border that player could be before camera starts move (xDeadZone, yDeadZone). Also we defined the camera's degrees of freedom (axis). For top view style games, like RPG, the camera is allowed to move in both x(horizontal) and y(vertical) axis.

To keep player in the middle of viewport we set the deadZone of each axis to converge with the center of canvas. Look at the follow function in the code:

camera.follow(player, canvas.width/2, canvas.height/2)

Note: See the UPDATE section below as this will not produce the expected behavior when any dimension of the map (room) is smaller than canvas.

World's limits

Since each object, including camera, have its own update function, its easy to check the game world's boundary. Only remember to put the code that block the movement at the final of the update function.

Demonstration

See the full code and try it yourself. Most parts of the code have comments that guide you through. I'll assume that you know the basics of Javascript and how to work with prototypes (sometimes I use the term "class" for a prototype object just because it have a similar behavior of a Class in languages like Java).

LIVE DEMO

Full code:

<!DOCTYPE HTML>
<html>
<body>
<canvas id="gameCanvas" width=400 height=400 />
<script>
// wrapper for our game "classes", "methods" and "objects"
window.Game = {};

// wrapper for "class" Rectangle
(function() {
  function Rectangle(left, top, width, height) {
    this.left = left || 0;
    this.top = top || 0;
    this.width = width || 0;
    this.height = height || 0;
    this.right = this.left + this.width;
    this.bottom = this.top + this.height;
  }

  Rectangle.prototype.set = function(left, top, /*optional*/ width, /*optional*/ height) {
    this.left = left;
    this.top = top;
    this.width = width || this.width;
    this.height = height || this.height
    this.right = (this.left + this.width);
    this.bottom = (this.top + this.height);
  }

  Rectangle.prototype.within = function(r) {
    return (r.left <= this.left &&
      r.right >= this.right &&
      r.top <= this.top &&
      r.bottom >= this.bottom);
  }

  Rectangle.prototype.overlaps = function(r) {
    return (this.left < r.right &&
      r.left < this.right &&
      this.top < r.bottom &&
      r.top < this.bottom);
  }

  // add "class" Rectangle to our Game object
  Game.Rectangle = Rectangle;
})();

// wrapper for "class" Camera (avoid global objects)
(function() {

  // possibles axis to move the camera
  var AXIS = {
    NONE: 1,
    HORIZONTAL: 2,
    VERTICAL: 3,
    BOTH: 4
  };

  // Camera constructor
  function Camera(xView, yView, viewportWidth, viewportHeight, worldWidth, worldHeight) {
    // position of camera (left-top coordinate)
    this.xView = xView || 0;
    this.yView = yView || 0;

    // distance from followed object to border before camera starts move
    this.xDeadZone = 0; // min distance to horizontal borders
    this.yDeadZone = 0; // min distance to vertical borders

    // viewport dimensions
    this.wView = viewportWidth;
    this.hView = viewportHeight;

    // allow camera to move in vertical and horizontal axis
    this.axis = AXIS.BOTH;

    // object that should be followed
    this.followed = null;

    // rectangle that represents the viewport
    this.viewportRect = new Game.Rectangle(this.xView, this.yView, this.wView, this.hView);

    // rectangle that represents the world's boundary (room's boundary)
    this.worldRect = new Game.Rectangle(0, 0, worldWidth, worldHeight);

  }

  // gameObject needs to have "x" and "y" properties (as world(or room) position)
  Camera.prototype.follow = function(gameObject, xDeadZone, yDeadZone) {
    this.followed = gameObject;
    this.xDeadZone = xDeadZone;
    this.yDeadZone = yDeadZone;
  }

  Camera.prototype.update = function() {
    // keep following the player (or other desired object)
    if (this.followed != null) {
      if (this.axis == AXIS.HORIZONTAL || this.axis == AXIS.BOTH) {
        // moves camera on horizontal axis based on followed object position
        if (this.followed.x - this.xView + this.xDeadZone > this.wView)
          this.xView = this.followed.x - (this.wView - this.xDeadZone);
        else if (this.followed.x - this.xDeadZone < this.xView)
          this.xView = this.followed.x - this.xDeadZone;

      }
      if (this.axis == AXIS.VERTICAL || this.axis == AXIS.BOTH) {
        // moves camera on vertical axis based on followed object position
        if (this.followed.y - this.yView + this.yDeadZone > this.hView)
          this.yView = this.followed.y - (this.hView - this.yDeadZone);
        else if (this.followed.y - this.yDeadZone < this.yView)
          this.yView = this.followed.y - this.yDeadZone;
      }

    }

    // update viewportRect
    this.viewportRect.set(this.xView, this.yView);

    // don't let camera leaves the world's boundary
    if (!this.viewportRect.within(this.worldRect)) {
      if (this.viewportRect.left < this.worldRect.left)
        this.xView = this.worldRect.left;
      if (this.viewportRect.top < this.worldRect.top)
        this.yView = this.worldRect.top;
      if (this.viewportRect.right > this.worldRect.right)
        this.xView = this.worldRect.right - this.wView;
      if (this.viewportRect.bottom > this.worldRect.bottom)
        this.yView = this.worldRect.bottom - this.hView;
    }

  }

  // add "class" Camera to our Game object
  Game.Camera = Camera;

})();

// wrapper for "class" Player
(function() {
  function Player(x, y) {
    // (x, y) = center of object
    // ATTENTION:
    // it represents the player position on the world(room), not the canvas position
    this.x = x;
    this.y = y;

    // move speed in pixels per second
    this.speed = 200;

    // render properties
    this.width = 50;
    this.height = 50;
  }

  Player.prototype.update = function(step, worldWidth, worldHeight) {
    // parameter step is the time between frames ( in seconds )

    // check controls and move the player accordingly
    if (Game.controls.left)
      this.x -= this.speed * step;
    if (Game.controls.up)
      this.y -= this.speed * step;
    if (Game.controls.right)
      this.x += this.speed * step;
    if (Game.controls.down)
      this.y += this.speed * step;

    // don't let player leaves the world's boundary
    if (this.x - this.width / 2 < 0) {
      this.x = this.width / 2;
    }
    if (this.y - this.height / 2 < 0) {
      this.y = this.height / 2;
    }
    if (this.x + this.width / 2 > worldWidth) {
      this.x = worldWidth - this.width / 2;
    }
    if (this.y + this.height / 2 > worldHeight) {
      this.y = worldHeight - this.height / 2;
    }
  }

  Player.prototype.draw = function(context, xView, yView) {
    // draw a simple rectangle shape as our player model
    context.save();
    context.fillStyle = "black";
    // before draw we need to convert player world's position to canvas position            
    context.fillRect((this.x - this.width / 2) - xView, (this.y - this.height / 2) - yView, this.width, this.height);
    context.restore();
  }

  // add "class" Player to our Game object
  Game.Player = Player;

})();

// wrapper for "class" Map
(function() {
  function Map(width, height) {
    // map dimensions
    this.width = width;
    this.height = height;

    // map texture
    this.image = null;
  }

  // creates a prodedural generated map (you can use an image instead)
  Map.prototype.generate = function() {
    var ctx = document.createElement("canvas").getContext("2d");
    ctx.canvas.width = this.width;
    ctx.canvas.height = this.height;

    var rows = ~~(this.width / 44) + 1;
    var columns = ~~(this.height / 44) + 1;

    var color = "red";
    ctx.save();
    ctx.fillStyle = "red";
    for (var x = 0, i = 0; i < rows; x += 44, i++) {
      ctx.beginPath();
      for (var y = 0, j = 0; j < columns; y += 44, j++) {
        ctx.rect(x, y, 40, 40);
      }
      color = (color == "red" ? "blue" : "red");
      ctx.fillStyle = color;
      ctx.fill();
      ctx.closePath();
    }
    ctx.restore();

    // store the generate map as this image texture
    this.image = new Image();
    this.image.src = ctx.canvas.toDataURL("image/png");

    // clear context
    ctx = null;
  }

  // draw the map adjusted to camera
  Map.prototype.draw = function(context, xView, yView) {
    // easiest way: draw the entire map changing only the destination coordinate in canvas
    // canvas will cull the image by itself (no performance gaps -> in hardware accelerated environments, at least)
    /*context.drawImage(this.image, 0, 0, this.image.width, this.image.height, -xView, -yView, this.image.width, this.image.height);*/

    // didactic way ( "s" is for "source" and "d" is for "destination" in the variable names):

    var sx, sy, dx, dy;
    var sWidth, sHeight, dWidth, dHeight;

    // offset point to crop the image
    sx = xView;
    sy = yView;

    // dimensions of cropped image          
    sWidth = context.canvas.width;
    sHeight = context.canvas.height;

    // if cropped image is smaller than canvas we need to change the source dimensions
    if (this.image.width - sx < sWidth) {
      sWidth = this.image.width - sx;
    }
    if (this.image.height - sy < sHeight) {
      sHeight = this.image.height - sy;
    }

    // location on canvas to draw the croped image
    dx = 0;
    dy = 0;
    // match destination with source to not scale the image
    dWidth = sWidth;
    dHeight = sHeight;

    context.drawImage(this.image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);
  }

  // add "class" Map to our Game object
  Game.Map = Map;

})();

// Game Script
(function() {
  // prepaire our game canvas
  var canvas = document.getElementById("gameCanvas");
  var context = canvas.getContext("2d");

  // game settings: 
  var FPS = 30;
  var INTERVAL = 1000 / FPS; // milliseconds
  var STEP = INTERVAL / 1000 // seconds

  // setup an object that represents the room
  var room = {
    width: 500,
    height: 300,
    map: new Game.Map(500, 300)
  };

  // generate a large image texture for the room
  room.map.generate();

  // setup player
  var player = new Game.Player(50, 50);

  // Old camera setup. It not works with maps smaller than canvas. Keeping the code deactivated here as reference.
  /* var camera = new Game.Camera(0, 0, canvas.width, canvas.height, room.width, room.height);*/
  /* camera.follow(player, canvas.width / 2, canvas.height / 2); */

  // Set the right viewport size for the camera
  var vWidth = Math.min(room.width, canvas.width);
  var vHeight = Math.min(room.height, canvas.height);

  // Setup the camera
  var camera = new Game.Camera(0, 0, vWidth, vHeight, room.width, room.height);
  camera.follow(player, vWidth / 2, vHeight / 2);

  // Game update function
  var update = function() {
    player.update(STEP, room.width, room.height);
    camera.update();
  }

  // Game draw function
  var draw = function() {
    // clear the entire canvas
    context.clearRect(0, 0, canvas.width, canvas.height);

    // redraw all objects
    room.map.draw(context, camera.xView, camera.yView);
    player.draw(context, camera.xView, camera.yView);
  }

  // Game Loop
  var gameLoop = function() {
    update();
    draw();
  }

  // <-- configure play/pause capabilities:

  // Using setInterval instead of requestAnimationFrame for better cross browser support,
  // but it's easy to change to a requestAnimationFrame polyfill.

  var runningId = -1;

  Game.play = function() {
    if (runningId == -1) {
      runningId = setInterval(function() {
        gameLoop();
      }, INTERVAL);
      console.log("play");
    }
  }

  Game.togglePause = function() {
    if (runningId == -1) {
      Game.play();
    } else {
      clearInterval(runningId);
      runningId = -1;
      console.log("paused");
    }
  }

  // -->

})();

// <-- configure Game controls:

Game.controls = {
  left: false,
  up: false,
  right: false,
  down: false,
};

window.addEventListener("keydown", function(e) {
  switch (e.keyCode) {
    case 37: // left arrow
      Game.controls.left = true;
      break;
    case 38: // up arrow
      Game.controls.up = true;
      break;
    case 39: // right arrow
      Game.controls.right = true;
      break;
    case 40: // down arrow
      Game.controls.down = true;
      break;
  }
}, false);

window.addEventListener("keyup", function(e) {
  switch (e.keyCode) {
    case 37: // left arrow
      Game.controls.left = false;
      break;
    case 38: // up arrow
      Game.controls.up = false;
      break;
    case 39: // right arrow
      Game.controls.right = false;
      break;
    case 40: // down arrow
      Game.controls.down = false;
      break;
    case 80: // key P pauses the game
      Game.togglePause();
      break;
  }
}, false);

// -->

// start the game when page is loaded
window.onload = function() {
  Game.play();
}

</script>
</body>
</html>

UPDATE

If width and/or height of the map (room) is smaller than canvas the previous code will not work properly. To resolve this, in the Game Script make the setup of the camera as followed:

// Set the right viewport size for the camera
var vWidth = Math.min(room.width, canvas.width);
var vHeight = Math.min(room.height, canvas.height);

var camera = new Game.Camera(0, 0, vWidth, vHeight, room.width, room.height);
camera.follow(player, vWidth / 2, vHeight / 2);

You just need to tell the camera constructor that viewport will be the smallest value between map (room) or canvas. And since we want the player centered and bonded to that viewport, the camera.follow function must be update as well.

Feel free to report any errors or to add suggestions.

这篇关于HTML5 Canvas 相机/视口 - 如何实际做到这一点?的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持跟版网！

上一篇：在 JavaScript 中调整 Base-64 图像的大小而不使用画布 下一篇：如何在页面加载时显示正在运行的进度条

layer.open打开的页面关闭时，父页面刷新的方法layer.open打开的页面关闭时，父页面刷新的方法，在layer.open中添加： end: function(){ window.parent.location.reload();//关闭open打开的页面时，刷新父页面 }

HTML5 Canvas 相机/视口 - 如何实际做到这一点?

问题描述

绘制与视口相关的游戏对象

游戏相机

世界的极限

演示

Using drawImage to draw large images according to viewport position

Drawing game objects related to viewport

Game Camera

World's limits

Demonstration

相关文章