1


 
 
 

МЕХЗАВОД | Сайтостроение для начинающих

Информация о пользователе

Привет, Гость! Войдите или зарегистрируйтесь.



CANVAS шаг за шагом: Основы

Сообщений 1 страница 5 из 5

1

CANVAS шаг за шагом: Основы

   

    Основы
    Изображения
    Понг
    Пятнашки

Если верить англо-русскому словарю, то можно узнать что canvas переводится как холст, а если верить википедии, то можно узнать что тег canvas, это элемент HTML 5, который предназначен для создания растрового изображения при помощи JavaScript. Тому как создать это растровое изображение и будет посвящен мой небольшой текст. Прежде чем начинать пробовать свои силы в этом не легком деле рекомендуется уже иметь базовые знания о том что такое HTML и с чем едят JavaScript.

Предварительная «настройка» нашего холста

У нашего подопытного тега есть всего два атрибута — height и width, высота и ширина соответственно, по умолчанию размер холста 150х300 пикселей.
Стоит отметить что canvas создает область фиксированного размера содержимым которого управляют контексты.
Элементарный пример:

<!doctype html>
<html>
<head>
    <title>canvasExample</title>
        <meta charset='utf-8' />
</head>
<body>
    <canvas height='320' width='480' id='example'>Обновите браузер</canvas>
    <script>
    var example = document.getElementById("example"),
        ctx     = example.getContext('2d');
    ctx.fillRect(0, 0, example.width, example.height);
    </script>
</body>
</html>

Если сохранить эти несчастные 13 строк в файл и открыть его браузером, то можно будет увидеть область с чёрным прямоугольником, так вот это и есть тот самый холст, на котором нарисован прямоугольник размеры которого равны размерам canvas'а.

Прямоугольники

Самой элементарной фигурой которую можно рисовать является прямоугольник. Предусмотрено три функции для отрисовки прямоугольников.

strokeRect(x, y, ширина, высота) // Рисует прямоугольник
fillRect(x, y, ширина, высота)   // Рисует закрашенный прямоугольник
clearRect(x, y, ширина, высота)  // Очищает область на холсте размер с прямоугольник заданного размера

Пример иллюстрирующий работу этих функций:

<!doctype html>
<html>
    <head>
        <title>rectExample</title>
        <meta charset='utf-8' />
    </head>
    <body>
        <canvas id='example'>Обновите браузер</canvas>
        <script>
            var example = document.getElementById("example"),
        ctx     = example.getContext('2d');
            example.width  = 640;
            example.height = 480;
            ctx.strokeRect(15, 15, 266, 266);
            ctx.strokeRect(18, 18, 260, 260);
            ctx.fillRect(20, 20, 256, 256);
            for (i = 0; i < 8; i += 2)
                for (j = 0; j < 8; j += 2) {
                    ctx.clearRect(20 + i * 32, 20 + j * 32, 32, 32);
                    ctx.clearRect(20 + (i + 1) * 32, 20 + (j + 1) * 32, 32, 32);
                }
        </script>
    </body>
</html>

А теперь краткий построчный разбор:
в строках 10 и 11 мы изменили размер холста — чтоб бы задуманное нами изображение полностью отобразилось,
в строках 12 и 13 мы нарисовали два не закрашенных прямоугольника которые будут символизировать своеобразную рамку нашей «шахматной доски»,
в строке 14 отрисовываем закрашенный прямоугольник размеры которого бы позволил вместить в себе 64 квадрата с шириной стороны 32 пикселя,
в строках с 15 по 19 у нас работает два цикла которые очищают на чёрном прямоугольнике квадратные области в таком порядке что бы в итоге полученное изображение было похоже на шахматную доску

Линии и дуги

Рисование фигур составленных из линий выполняется последовательно в несколько шагов:

beginPath()
closePath()
stroke()
fill()

beginPath используется что бы «начать» серию действий описывающих отрисовку фигуры. Каждый новый вызов этого метода сбрасывает все действия предыдущего и начинает «рисовать» занова.
closePath является не обязательным действием и по сути оно пытается завершить рисование проведя линию от текущей позиции к позиции с которой начали рисовать.
Завершающий шаг это вызовом метода stroke или fill. Собственно первый обводит фигуру линиями, а второй заливает фигуру сплошным цветом.
Те кто когда-то на школьных 486х в былые годы рисовал в бейсике домик, забор и деревце по задумке учителя тот сразу поймёт часть ниже. Итак, существуют такие методы как,

moveTo(x, y) // перемещает "курсор" в позицию x, y и делает её текущей
lineTo(x, y) // ведёт линию из текущей позиции в указанную, и делает в последствии указанную текущей
arc(x, y, radius, startAngle, endAngle, anticlockwise) // рисование дуги, где x и y центр окружности, далее начальный и конечный угол, последний параметр указывает направление

Пример ниже показывает действие всего описанного выше:

<!doctype html>
<html>
<head>
    <title>pathExample</title>
    <meta charset='utf-8' />
</head>
<body>
    <canvas id='example'>Обновите браузер</canvas>
    <script>
    var example = document.getElementById("example"),
        ctx     = example.getContext('2d');
    example.height = 480;
    example.width  = 640;
    ctx.beginPath();
    ctx.arc(80, 100, 56, 3/4 * Math.PI, 1/4 * Math.PI, true);
    ctx.fill(); // *14
    ctx.moveTo(40, 140);
    ctx.lineTo(20, 40);
    ctx.lineTo(60, 100);
    ctx.lineTo(80, 20);
    ctx.lineTo(100, 100);
    ctx.lineTo(140, 40);
    ctx.lineTo(120, 140);
    ctx.stroke(); // *22
    </script>
</body>
</html>

В строке 14 заливается цветом дуга, в строке 22 обводится контур нашей короны.

Кривые Бернштейна-Безье

Что такое кривые Безье я думаю лучше объяснит Википедия.
Нам доступно две функции, для построения кубической кривой Бизье и квадратичной, соотвестствено:

quadraticCurveTo(Px, Py, x, y)
bezierCurveTo(P1x, P1y, P2x, P2y, x, y)

x и y это точки в которые необходимо перейти, а координаты P(Px, Py) в квадратичной кривой это дополнительные точки которые используются для построения кривой. В кубическо кривой соответственно две дополнительные точки.
Пример двух кривых:

<!doctype html>
<html>
<head>
    <title>curveExample</title>
    <meta charset='utf-8' />
</head>
<body>
    <canvas id='example'>Обновите браузер</canvas>
    <script>
    var example = document.getElementById("example"),
        ctx     = example.getContext('2d');
    example.height = 480;
    example.width  = 640;
    ctx.beginPath();
    ctx.moveTo(10, 15);
    ctx.bezierCurveTo(75, 55, 175, 20, 250, 15);
    ctx.moveTo(10, 15);
    ctx.quadraticCurveTo(100, 100, 250, 15);
    ctx.stroke();
    </script>
</body>
</html>

Добавим цвета

Что бы наше изображение было не только двух цветов, а любого цвета предусмотрено, два свойства

fillStyle = color   // определяет цвет заливки
strokeStyle = color // цвет линий цвет задается точно так же как и css, на примере все четыре способа задания цвета

Цвет задается точно так же как и css, на примере все четыре способа задания цвета

// все четыре строки задают оранжевый цвет заливки
ctx.fillStyle = "orange";
ctx.fillStyle = "#FFA500";
ctx.fillStyle = "rgb(255,165,0)";
ctx.fillStyle = "rgba(255,165,0,1)"

Аналогично задаётся и цвет для линий.
Возьмём пример с шахматной доской и добавим в него немного цвета:

<!doctype html>
<html>
<head>
    <title>rectExample</title>
    <meta charset='utf-8' />
</head>
<body>
    <canvas id='example'>Обновите браузер</canvas>
    <script>
    var example = document.getElementById("example"),
        ctx     = example.getContext('2d');
    example.height = 480;
    example.width  = 640;
    ctx.strokeStyle = '#B70A02'; // меняем цвет рамки
    ctx.strokeRect(15, 15, 266, 266);
    ctx.strokeRect(18, 18, 260, 260);
    ctx.fillStyle = '#AF5200'; // меняем цвет клеток
    ctx.fillRect(20, 20, 256, 256);
    for (i = 0; i < 8; i += 2)
        for (j = 0; j < 8; j += 2) {
        ctx.clearRect(20 + i * 32, 20 + j * 32, 32, 32);
        ctx.clearRect(20 + (i + 1) * 32, 20 + (j + 1) * 32, 32, 32);
        }
    </script>
</body>
</html>

Задача

Что бы усвоить информацию и закрепить прочитанное на практике я всегда ставлю перед собой не большую цель которая бы одновременно охватывала всё прочитанное и одновременно процесс достижения которой было бы интересен мне самому. В данном случае я попытаюсь отрисовать уровень одной из моих самых любимых в детстве игр. Собственно за не имением времени — добавлять жизнь на него я не буду, а сделаю максимально понятный код охватывающий практически всё то что сегодня здесь описал.
Я воспроизвел один из уровней игры BattleCity известную у нас как Танчики, а вот и ссылка на pastebin на случай если не будет откликаться дропбокс.
На последок комментарий по примеру. В спецификациях картинки которую может выдавать Денди разрешение экрана должно быть 256×240 пикселей.
Поле боя в общеизвестнных Танчиках размером 13х13 больших блоков. Каждый из которых нарисован 4мя повторяющимися спрайтами (коих по общему подсчёту выходит на карте 26х26=676). Итак прикинем как было в оригинале по пикселам и как это правильно масштабировать. Если поделить 240 на 26 то выйдет что целая часть от деления будет 8. Получается что размерность текстуры была 8х8 пиксела т.е. размер поля боя 208х208, а большого блока 16х16. Ширина должна быть 256 пикселов. Сейчас вычислим размер правого столбца с дополнительной информацией и размер полей сверху/снизу. Справа если присмотреться ширина составляет размерность в два блока, итого 2*16=32. У нас уже 32+208=240 слева поле 16, а снизу и сверху соответственно так же по 16 пикселов. Собственно в моём примере размерность большого блока заключена в переменной cellSize, собственно все вычисления делаются иходя из её размеров. Можете по экспериментировать и поменять её значение, настоятельно рекомендую делать его кратным степеням двойки (16, 32, 64, 128...), если хотите чтоб всё выглядело так как на старом добром денди то устанавливайте её значение равным 16. Хотя и при любых других значениях всё выглядит нормально. Если то как я пишу понравится кому-то кроме меня, то напишу продолжение, а то что в нём будет пока утаю

2

HTML5 CANVAS шаг за шагом: Изображения

Продолжение статьи про рисование на холсте, в которой мы научимся использовать изображения. Естественно рисовать на холсте примитивами очень не удобно и требует определённых трудозатрат, и результат иногода явно хромает качеством. Поэтому естественно в canvas api предусмотрено взаимодействие с изображениями. Добавление изображения условно можно разделить на два шага: создание JavaScript объекта Image, а второй и заключительный шаг это отрисовка изображения на холсте при помощи функции drawImage. Рассмотрим оба шага подробнее.

Создание нового графического объекта:

var img = new Image();  // Создание нового объекта изображения
img.src = 'image.png';  // Путь к изображению которое необходимо нанести на холст

Кстати в качестве источника изображения, можно указать вот такую строку в которой изображение и описанно:

img.src = 'data:image/gif;base64,R0lGODlhDAAMAOYAANPe5Pz//4KkutDb4szY3/b+/5u5z/3//3KWrfn//8rk8naasYGkuszY4Mbg8qG+0dzv9tXg5sTg8t/o7vP8/4iqv9ft9NPe5qfD1Mfc56O/0YKlu+Lr8M3Z4JCwxuj2/Of0+eDz9+rw9Z68z8/n8sHe8sbT3Ju6zuDv96nE1Onw9Nbh6cvX39Hq89Hq8u77/srW3tbh54Kku8ba56TD1u37/vL8/vL8/9ft9ebu8+Ps8bzM1Ymsw7XR4Nnj6Yanvsnj8qrI2Or2/NTf5tvl68vY3+r3/HqdtNji6OXt8eDz+dLc477c7bDO3t7n7d7v9s3Z4dbs9N/y98Pd6PX+/8/b4f7//+Hp7tDo8vv//+fu84GjunKWro6uxHqctOfu9P///wAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACH5BAAAAAAALAAAAAAMAAwAAAeEgCJfg4RfWlo5KlpgjI2OOklWBwcBAVmXCQlXHAUFVBkGBjMUNzZOEy81IF2sXUZCH0QrDyhPGzICAkohUj4XHhoQKQsLGDgWUTFIJxUjUy0uWNIkQxE9W9gMDD9BCgpLAEBNXl5H5F40DlUDEkxc71wICDwlDQBQHQ0EBEUsJjswBgQCADs=';

1. drawImage

Теперь мы перейдём к рисованию изображения на холсте. Для этого существует функция drawImage.

drawImage(image, x, y) // Где x и y это координаты левого верхнего угла изображения, а первый параметр это изображение

Стоит отметить что загрузка изображения происходит сразу после присвоения объекту источника изображения, и если оно не загрузится полностью к моменту вызова функции отрисовки, то оно попросту не будет нарисовано на холсте. Для избежания этой ситуации используется такая конструкция:

var img = new Image();      // Новый объект
  img.onload = function() { // Событие которое будет исполнено в момент когда изображение будет загружено
    /*
  Какие-либо действия
*/
}
img.src = 'myImage.png';    // Путь к изображению

Вот мы наверное и дошли до момента когда можно рассмотреть элементарный пример:

<!doctype html>
<html>
  <meta charset='utf-8'>
  <head>
    <title>imgExample</title>
  </head>
  <body>
    <canvas id='example'>Обновите браузер</canvas>
    <script>
      var example = document.getElementById("example"),
        ctx       = example.getContext('2d'), // Контекст
        pic       = new Image();              // "Создаём" изображение
      pic.src    = 'http://habrahabr.ru/i/nocopypast.png';  // Источник изображения, позаимствовано на хабре
      pic.onload = function() {    // Событие onLoad, ждём момента пока загрузится изображение
        ctx.drawImage(pic, 0, 0);  // Рисуем изображение от точки с координатами 0, 0
      }
    </script>
  </body>
</html>

Ссылка на фидл с примерами для этой стать.

2. Тянем-потянем

Но если бы всё ограничивалось простым рисованием изображением, то отдельную статью можно было бы не писать, а ограничиться подпунктом «Изображения» в предыдущем посте. Итак теперь мы попытаемся масштабировать изображение и для этого существует ещё один способ вызова функции drawImage:

drawImage(image, x, y, width, height)  //  параметры width, height меняют ширину и высоту изображения

Возьмём предыдущий пример и внесём в drawImage некоторые изменения:

ctx.drawImage(pic, 0, 0, 300, 150);

Ссылка на фидл с примерами для этой стать.

3. Рисуем фрагмент изображения

Третий вызов drawImage с восемью параметрами, выглядит приблизительно так:

drawImage(image, sx, sy, sWidth, sHeight, dx, dy, dWidth, dHeight);
// Первый параметр указывает на изображение
// sx, sy, sWidth, sHeight указывают параметры фрагмента на изображение-источнике
// dx, dy, dWidth, dHeight ответственны за координаты отрисовки фрагмента на холсте

Возьмём всё тот же пример и подкорректируем функцию drawImage в третий раз:

ctx.drawImage(pic, 25, 42, 85, 55, 0, 0, 170, 110);

Ссылка на фидл с примерами для этой стать.

4. Задача

Теперь осталось закрепить всё пройденное на практическом примере. Как и в том примере это будет небольшая карта, только не из какой-то существовавшей игры, а придуманной нами. Для того что бы он нормально работал нам необходимо будет создать в любом графическом редакторе изображение составленное из фрагментов которые нам будут нужны что бы нарисовать дорожку, домик и полянку. Вообще фрагменты карты называются тайлами, а файл в котором они все собраны в одно изображение называется тайлсетом. Вот это изображение я нарисовал собственноручно в программе Pinta под Ubuntu.
http://s7.uploads.ru/t/nPv5e.png

Итак, размерность будет 8 на 8 квадратных блоков шириной 32 пиксела. На карте нам необходимо будет изобразить домик и дорожку. Элементы домика нарисованы ручками, можно сказать каждый кирпичик. Траву и песок делалось путём заливки облости соответствующим цветом и добавки шума. Всё конечно представленно очень примитивно, но показательно.
Рассмотрим с пинцетом такой кусок кода как var map = [[{x:1, y: 4}… значения x и y указывают какой элемент из картинки брать. Т.е. если исходный рисунок разбить на квадрат 32×32 то станет понятней.
И форэкзампл:

<!doctype html>
<html>
<meta charset='utf-8'>
  <head>
    <title>imgExample</title>
  </head>
    <body>
      <canvas id='example'>Обновите браузер</canvas>
    <script>
        var example = document.getElementById('example'), // Задаём контекст
          ctx       = example.getContext('2d'),           // Контекст холста
          cellSize  = 32,                                 // Размер одной ячейки на карте
          pic       = new Image(),                        // "Создаём" изображение
          map       =                                     // Карта уровня двумерным массивом
          [
            [{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4}], // 1ый ряд
            [{x:1,y:4},{x:1,y:1},{x:2,y:1},{x:3,y:1},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4}], // 2ый ряд
            [{x:1,y:4},{x:1,y:2},{x:2,y:2},{x:3,y:2},{x:1,y:4},{x:1,y:3},{x:1,y:3},{x:1,y:3}], // 3ый ряд
            [{x:1,y:4},{x:3,y:4},{x:2,y:3},{x:3,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 4ый ряд
            [{x:1,y:4},{x:3,y:4},{x:2,y:4},{x:3,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 5ый ряд
            [{x:1,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 6ый ряд
            [{x:1,y:4},{x:1,y:4},{x:1,y:3},{x:1,y:3},{x:1,y:3},{x:1,y:3},{x:1,y:4},{x:1,y:4}], // 7ый ряд
            [{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4},{x:1,y:4}]  // 8ый ряд
          ]; // Первая и вторая координата (x и y соответственно) задают фрагмент в исходном изображении
        // Размер холста равный 8х8 клеток
        example.width  = 8 * cellSize;
        example.height = 8 * cellSize;
        pic.src = 'https://habrastorage.org/getpro/habr/post_images/e85/727/cb1/e85727cb1a88099325eaf5b243d4c41f.png';
        pic.onload = function() {  // Событие onLoad, ждём момента пока загрузится изображение
          for (var j = 0 ; j < 8; j ++)
            for (var i = 0; i < 8; i ++)
              // перебираем все значения массива 'карта' и в зависимости от координат вырисовываем нужный нам фрагмент
              ctx.drawImage(pic, (map[i][j].x-1)*cellSize, (map[i][j].y-1)*cellSize, 32, 32, j*cellSize, i*cellSize, 32, 32);
        }
    </script>
  </body>
</html>

Ссылка

Отредактировано викНик (2018-10-01 20:07:00)

3

Руководство по Canvas

Ссылка

4

Введение в Canvas

В этой статье мы познакомим вас c новым элементом HTML5 - canvas, который позволяет рисовать различные объекты и отображать в самых современных браузерах. Прочитав данный урок, вы узнаете, как получить доступ к элементу canvas, рисовать фигуры, изменять цвета, и стирать объекты. Приобретайте путёвку в современный мир Web технологий.

Я надеюсь, вам понравится эта серия уроков. Она рассчитана на тех, кто имеет какой-то опыт работы в JavaScript, и совсем ничего не знает насчёт элемента canvas. Если вы новичок в JavaScript, не переживайте, вы приобретёте некоторые знания, прочитав данную статью.
Знакомимся с элементом Canvas
Использовать элемент canvas очень просто

Когда вы слышите слово canvas, то вы сразу же думаете о новом HTML5 элементе с одноимённым названием. Технически, это только половина всей правды, но давайте не будем сейчас говорить об этом. Элемент canvas - это нововведение для всех браузеров.

Для того чтобы воспользоваться элементом canvas, необходимо просто создать соответствующий HTML тег, а затем определить ширину и высоту.
1
<canvas width="500" height="500">
2
    <!-- Insert fallback content here -->
3
</canvas>

Но это конечно же далеко не всё. Код, написанный выше поместит на вашу страницу canvas с прозрачным фоном. Внимание: контент внутри тега canvas будет отображён только в том случае, если ваш браузер является устаревшим и не поддерживает данную функциональность.
Поддержка
Этот элемент только для самых современных браузеров

Должен отметить, что самые современные браузеры поддерживают данный элемент, даже последний Internet Explorer.

    Internet Explorer (9.0+)
    Safari (3.0+)
    Firefox (3.0+)
    Chrome (3.0+)
    Opera (10.0+)
    iOS (1.0+)
    Android (1.0+)

К слову сказать, вы можете активировать данный элемент и в ранних версиях Internet Explorer при помощи данного плагина – Explorer Canvas.
Размеры элемента Canvas

В примере, расположенном выше вы уже увидели как применять атрибуты ширины и высоты: width и height. Используя CSS, вы также можете контролировать размеры canvas, как и других HTML элементов. И это вполне логично. Однако так как canvas использует в своём функционале так называемый двумерный контекст, то при применении CSS к размерам холста, приведёт к тому, что все внутренние элементы будут искажены.
Немного о двумерном контексте

Немного выше я сказал, что элемент canvas - это только половина всей истории. Вторая половина - это как раз и есть двумерный контекст, который по сути позволяет вам видеть и всю мощь функционала данного элемента.

Давайте расставим всё на свои места: когда мы используем элемент canvas, то фактически он не помещается на страницу. Вместо него вы получаете рисунок, который формируется в двумерном контексте, а доступ к этому рисунку осуществляется как раз через элемент canvas благодаря JavaScript API. В принципе кому-то эта информация может показаться лишней, однако лишние знания вам не повредят.
Система координат

Если вы когда-либо работали с языками, имеющими дело с 2d графикой (такими как ActionScript, Processing, и т.д.), тогда вы знаете всё о системах координат, основанных на движении. Двумерный контекст в элементе canvas ничем не отличается от перечисленных систем. Он использует стандартную систему координат Cartesian, с начальной точкой (0, 0), расположенной с левой верхней стороны. Движение вправо будет увеличивать значение объекта по оси x, в то время как движение вниз, будет увеличивать значения точек объекта по оси y. Всё довольно примитивно.

Одна единица данной системы координат равняется одному пикселю вашего экрана (в большинстве случаев).
http://s8.uploads.ru/t/mKrV4.jpg

Получение доступа к двумерному контексту

Для того чтобы получить доступ к двумерному контексту, вам понадобится применить JavaScript API. В данном случае, вам потребуется функция getContext. Пример:
01
<!DOCTYPE html>
02

03
<html>
04
    <head>
05
        <title>Canvas from scratch</title>
06
        <meta charset="utf-8">
07

08
        <script src="http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"></script>
09

10
        <script>
11
            $(document).ready(function() {
12
                var canvas = document.getElementById("myCanvas");
13
                var ctx = canvas.getContext("2d");
14
            });
15
        </script>
16
    </head>
17

18
    <body>
19
        <canvas id="myCanvas" width="500" height="500">
20
            <!-- Insert fallback content here -->
21
        </canvas>
22
    </body>
23
</html>

Заметьте: в этом примере мы применяем jQuery, но только после того, как страница полностью загрузится. Для этих целей вы можете в полной мере пользоваться вашим любимым JavaScript фрэймворком или поместить скрипт в конец документа.

В результате вызова метода getContext, переменная ctx теперь будет ссылаться на двумерный контекст. Это означает, что теперь при помощи этой переменной вы можете начать рисовать фигуры на элементе canvas. Круто, да?!
Рисуем квадраты

Теперь, когда у нас есть доступ к двумерному контексту, вы можете смело начинать пользоваться всеми функциями вышеупомянутого API. Одной из самых часто используемых функций является fillRect, которая создаёт квадраты чёрного цвета (по умолчанию).

Добавьте следующий код, используя переменную ctx, о которой мы говорили перед этим:
1
ctx.fillRect(50, 50, 100, 100);

Этот код нарисует чёрный квадрат в левой верхней стороне холста. Примерно вот так вот:
http://sh.uploads.ru/t/E9yqK.jpg

Поздравляю! Вы только что нарисовали вашу первую фигуру в HTML5 элементе canvas. Каковы ощущения?

Заметьте: вы скорее всего уже смекнули, что на самом деле для рисования квадрата используется JavaScript. Это происходит потому, что в функциональности элемента canvas не предусматривается подобного метода (для рисования квадрата). На самом деле квадрат - это тот же самый прямоугольник, у которого все стороны равны.

В методе fillRect может быть прописано 4 параметра:

    Первый - это позиция по оси x;
    Второй - это позиция по оси y;
    Третий - это параметр, отвечающий за ширину;
    Четвёртый - это высота.

Если расписать прототип метода в псевдокоде, то он будет выглядеть следующим образом:
1
ctx.fillRect(x, y, width, height);

Хорошая новость заключается в том, что вы не ограничены в функционале, касающемся заливки. Уточню. Вы можете рисовать прямоугольник с прозрачной заливкой и цветной рамкой.Для этого в JavaScript API предусмотрена специальная функция strokeRect:
1
ctx.strokeRect(50, 50, 100, 100);

Данная функция принимает такой же набор аргументов, как и fillRect. В результате вы получите ещё один квадрат:
http://s5.uploads.ru/t/gGYUm.jpg

Просто. Элегантно. И ещё раз просто! Теперь вы поняли принцип, по которому работает элемент canvas. Все остальные методы подобны этим двум. Их использовать так же просто. Если вам кажется это чем-то примитивным, то не переживайте. Все эти элементы в совокупности могут творить чудеса.
Рисование по схеме

Помимо прямоугольников (которые могут быть нарисованы одним методом из API), вы так же можете рисовать фигуры по собственной схеме. Благодаря схемам вы можете создавать прямые или изогнутые линии, а так же более сложные фигуры.

Чтобы создать полноценную схему, вам необходимо будет воспользоваться следующими методами из API:

    beginPath: начало схемы;
    moveTo: метод для создания точки;
    lineTo: рисует линию от точки до точки, которые были созданы методом moveTo, или до точки от прошлой линии, нарисованной методом lineTo;
    closePath: завершить схему.
    fill: заполнить фигуру цветом.
    stroke: создать контур.

Попробуйте следующий пример:
1
ctx.beginPath();
2
ctx.moveTo(50, 50);
3
ctx.lineTo(50, 250);
4
ctx.lineTo(250, 250);
5
ctx.closePath();
6
ctx.fill();

Данный код нарисует треугольник чёрного цвета:
http://s5.uploads.ru/t/aUFYQ.jpg

Те же самые принципы вы можете использовать для рисования фигур, которые вам понадобятся. В следующем уроке, посвящённом данной теме, мы поговорим о более продвинутом рисовании фигур, таких как овалы, кривая Безье и др.

Стоит сказать об этом именно сейчас: рисование по схеме применяется для создания более сложных фигур чем прямоугольники.
Изменение цветов

Итак, всё что мы рисовали до сих пор, будь то прямоугольник или треугольник, окрашивалось в чёрный цвет. Круто! Однако, существует множество функций в JavaScript API, которые позволят вам с лёгкостью изменить цвет фигуры, которую вы рисуете. Вашему вниманию представляю fillStyle и strokeStyle.

Объявлять тут в принципе нечего, поэтому давайте сразу же применим их на практике:
1
ctx.fillStyle = "rgb(255, 0, 0)";
2
ctx.fillRect(50, 50, 100, 100);

Данный код окрасит квадрат в красный цвет:
http://s3.uploads.ru/t/B3eRD.jpg

Или вы можете изменить цвет рамки квадрата:
1
ctx.strokeStyle = "rgb(255, 0, 0)";
2
ctx.strokeRect(50, 50, 100, 100);

Вот вы и научились применять данные методы:
http://s8.uploads.ru/t/gALfv.jpg

Методы fillStyle и strokeStyle удобны тем, что они используют те же цвета, что и в привычном вам CSS. Это значит, что вы можете использовать RGB, RGBA, HSA, специальные слова (“red”) и шестнадцатеричные значения.

Сразу стоит отметить, что изменение цвета не приводит к преобразованию уже существующего содержания элемента canvas. К примеру, если вы нарисовали черный прямоугольник, затем создали наполнитель для красного цвета, а потом нарисовали ещё один прямоугольник, то первая фигура останется чёрной.
Изменение толщины линий

Теперь плавно перейдём от изменения цветов к изменению значения толщины линий. Для данного функционала существует ещё один метод из JavaScript API - lineWidth.

Можете добавить данный код в прошлый пример:
1
ctx.lineWidth = 20;
2
ctx.strokeStyle = "rgb(255, 0, 0)";
3
ctx.strokeRect(50, 50, 100, 100);

И вот какой у вас получится результат:
http://sh.uploads.ru/t/CYf9I.jpg

Такой же принцип вы можете применить со схемами. К примеру, вы можете изменить пример с треугольником:
1
ctx.lineWidth = 20;
2
ctx.beginPath();
3
ctx.moveTo(50, 50);
4
ctx.lineTo(50, 250);
5
ctx.lineTo(250, 250);
6
ctx.closePath();
7
ctx.stroke();

И вот что у вас получится:
http://sg.uploads.ru/t/RalFY.jpg

Также в JavaScript API, существует ещё метод, который позволят вам изменить вид линий. К примеру, lineCap изменяет вид отображения конца линии, а lineJoin изменят отображение углов. Более подробную информацию вы можете найти в спецификации.
Стираем объекты из Canvas

Последняя вещь, которую я хочу вам сегодня показать – это стирание объектов. Вы уже знаете, как нарисовать фигуру. Теперь пришло время узнать как от неё избавиться :)

В принципе тут всё так же просто; вам нужно всего-навсего воспользоваться очередным методом из JavaScript API. Этот метод называется clearRect. Его задача заключается в том, чтобы сделать каждый указанный пиксель полностью прозрачным.

В этом примере на canvas 500px в ширину и 500px в высоту. Для очищения всей площади, вам необходимо сделать следующее:
1
ctx.fillRect(50, 50, 100, 100);
2
ctx.clearRect(0, 0, 500, 500);

В этом примере скорее всего не нужно подтверждать работу кода скриншотом, так как вы ничего не увидите. Квадрат действительно был нарисован, а затем мгновенно стёрт.

Заметьте: аргументы для метода clearRect точно такие же, как и для fillRect; x, y, ширина и высота.

Если вы не определились с высотой и шириной, то можете писать и так:
1
ctx.clearRect(0, 0, canvas.width, canvas.height);
Стирание небольших фрагментов

Для того чтобы стереть небольшой фрагмент, вам не обязательно зачищать всю площадь элемента canvas. Вы без проблем можете стереть необходимую вам область. Представьте, что у вас нарисовано 2 квадрата, один из которых вы хотите стереть:
1
ctx.fillRect(50, 50, 100, 100);
2
ctx.fillStyle = "rgb(255, 0, 0)";
3
ctx.fillRect(200, 50, 100, 100);

На данный момент картина такая:
http://sh.uploads.ru/t/CIWt6.jpg

Вы без проблем можете стереть черный квадрат, а красный оставить на месте при помощи метода clearRect:
1
ctx.clearRect(50, 50, 100, 100);   

Заметьте, что данные должны совпадать с теми, что вы указывали при создании элемента. На самом деле данный метод просто изменяет прозрачность каждого пискеля:
http://s5.uploads.ru/t/IKFRt.jpg

Довольно-таки просто, не так ли? Вы нечасто будете стирать элементы при рисовании, однако эти знания понадобятся вам, когда мы будем учиться делать анимацию.
Идём в ногу со временем
Canvas прост в использовании и изучении

Надеюсь, вы убедились в том, что canvas - это очень перспективный элемент веб страницы. Он позволяет создавать вам изображения, используя чистый код без никаких плагинов. Он прост в использовании и изучении, и на самом деле в умелых руках может превратиться во что-то очень оригинальное.

В следующей статье, мы рассмотрим некоторые продвинутые техники работы с элементом canvas, такими как рисование овалов, кривых линий и других вещей. Если этого будет недостаточно, то в дальнейшем мы расскажем вам, как трансформировать объекты (поворачивать, уменьшать, увеличивать), как работать с изображениями, а так же поработаем с анимацией. Вам будет очень интересно, можете поверить мне на слово.

А сейчас, я надеюсь, вы получили много полезной информации, которая позволит вам получить общее представление об canvas. Данный элемент - это фантастическая технология, которая позволит вам реализовать все фантазии, которые хранятся у вас в голове.

Ссылка

5

10 крутых примеров работы HTML5 Canvas

Ссылка



создать форум