Как рисовать в браузере красивые вещи

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

Существует множество терминов, с помощью которых описываются визуальные эксперименты на компьютере, такие как dev art, code sketch, demo и интерактивное искусство, но в конечном итоге я выбрал термин программная поэма. Идея поэмы заключается в том, что это должна быть отшлифованная проза, легко передаваемая, краткая и эстетичная.

Это не должна быть незавершенная идея, но законченный фрагмент, который доставляет удовольствие от просмотра. Поэма не является инструментом, ее задача - вызывать эмоции.

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

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

Вам не нужна какая-то сложная философия или математика, чтобы написать программную поэму, только желание увидеть что-то живое и яркое на экране.

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

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

Введение по холстам

Если вкратце, холст по существу представляет собой двухмерный растровый элемент изображения, существующий в DOM, с помощью которого его можно нарисовать.

Рисунок может быть создан либо с помощью 2d-контекста, либо с помощью WebGL-контекста. Контекст является объектом JavaScript, который вы используете, чтобы получить доступ к инструментам рисования. События JavaScript, которые доступны для холста, очень кратки, в отличие от SVG.

Любое возникающее событие относится ко всему элементу в целом, а не какому-нибудь отдельному элементу, нарисованному на холсте, как в обычных элементах изображений. Вот простой пример холста:

var canvas = document.getElementById('example-canvas');
var context = canvas.getContext('2d');

//Рисование синего прямоугольника
context.fillStyle = '#91C0FF';
context.fillRect(
    100, // x
    100, // y
    400, // ширина
    200 // высота
);

//Рисование текста
context.fillStyle = '#333';
context.font = "18px Helvetica, Arial";
context.textAlign = 'center';
context.fillText(
    "The wonderful world of canvas", // text
    300, // x
    200 // y
);

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

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

Приведение элементов в движение

В первом примере прямоугольник просто пробегается один раз через весь экран и остается в виде статического изображения на холсте. Это неплохо, но анимация действительно приносит удовольствие, когда картинка обновляется с частотой 60 кадров в секунду.

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

(Замечание относительно поддержки браузерами: Есть несколько простых polyfills, если вам нужно обеспечить поддержку в старых браузерах):

var canvas = document.getElementById('example-canvas');
var context = canvas.getContext('2d');
var counter = 0;
var rectWidth = 40;
var rectHeight = 40;
var xMovement;
//Помещаем прямоугольник в центр экрана
var y = ( canvas.height / 2 ) - ( rectHeight / 2 );
context.fillStyle = '#91C0FF';
function draw() {
    //Существует более интеллектуальный способ увеличения времени, однако для демонстрации достаточно и этого
    counter++;

    //Ниже приводится крутая математика. Более подробное пояснение приведено ниже по тексту статьи.
    xMovement = Math.sin(counter / 25) * canvas.width * 0.4 + canvas.width / 2 - rectWidth / 2;

    //Очищаем ранее нарисованный результат
    context.clearRect(0, 0, canvas.width, canvas.height);

    //Непосредственно рисуем на холсте
    context.fillRect(
        xMovement,
        y,
        rectWidth,
        rectHeight
    );

    //Запрошенный однажды новый фрейм анимации может вызвать эту функцию снова
    requestAnimationFrame( draw );
}
draw();

Рисование с помощью математики

Теперь будьте внимательны, мы говорили о программировании и рисовании на экране, поэтому я перехожу к математике. Математика - это то, что создает магию, которая потом отображается на экране. Если честно, я всегда любил математику (а вот многие художники нет).

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

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

Обратите внимание, что у нас есть больше переменных, чем просто х в функции sin( x ). Функция, которую я создал - это sin( a * x + b ) * c + d. Поиграйте с ползунками на интерактивном графике, и вы сможете увидеть, как изменение любого из этих значений влияет на график функции.

Теперь я перепишу формулу из предыдущего примера кода и создам другую версию, которую будет легче читать:

var a = 1 / 25, //Делаем так, чтобы колебания графика были намного реже
 x = counter, //Сдвигаем немного график каждый раз, когда вызывается draw()
 b = 0, //Нет необходимости  сдвигать график вверх или вниз
 c = width * 0.4, //Задаем ширину волны немного меньше, чем половина холста
 d = canvas.width / 2 - rectWidth / 2; //Передвигаем прямоугольник в центр
xMovement = Math.sin( a * x + b ) * c + d;

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

Ввод данных пользователем

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

Возможно также подключить дополнительные варианты ввода с помощью плагинов наподобие Leap Motion или Kinect. Используя WebSockets и сервер, вы можете подключить к визуализации свое оборудование.

Подключите микрофон к Web Audio API, и вы сможете управлять пикселями с помощью звука. Вы даже можете создать на базе веб-камеры датчик движения и распугивать виртуальных рыбок (что-то подобное я сделал на Flash пять или около того лет назад).

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

Еще одна вещь, которая здорово помогает при работе с движущимися объектами, это векторы, вместо использования отдельных переменных х и у.

В этих примерах кода, которые я подтянул из Three.js, есть класс Vector2. Намного проще использовать сразу vector.x и vector.y, но этот класс также содержит несколько удобных методов. Для получения более подробной информации вы можете ознакомиться с документацией.

Всемогущая Dot

В этом примере все уже немного сложнее, потому что это взаимодействия с объектами, но оно того стоит. Посмотрите пример кода, в котором вы увидите новый объект Scene, который управляет рисованием на холсте.

Наш новый класс Dot будет работать с этим объектом, чтобы получить доступ к переменным, которые ему будут нужны, например, к контексту холста:

function Dot( x, y, scene ) {

    var speed = 0.5;

    this.color = '#000000';
    this.size = 10;

    this.position = new THREE.Vector2(x,y);
    this.direction = new THREE.Vector2(
        speed * Math.random() - speed / 2,
        speed * Math.random() - speed / 2
    );

    this.scene = scene;

}

Чтобы приступить к разработке конструктора для Dot, настраиваем конфигурацию его поведения и устанавливаем некоторые переменные, которые мы будем использовать. Опять же, с помощью класса векторов Three.js.

При выводе содержимого с частотой 60 кадров в секунду, важно предварительно инициализировать объекты, а не создавать новые во время анимации. Потому что это съедает ресурсы памяти и может привести к прерывистой работе анимации. Кроме того, обратите внимание, как в Dot через ссылку передается копия scene. Это помогает поддерживать чистоту кода:

Dot.prototype = {
    update : function() {
        ...
    },
    draw : function() {
        ...
    }
}

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

Dot.prototype = {
    update : function() {
        ...
    },
    draw : function() {
        ...
    }
}

Я обновляю код рисования из обновленного кода. Таким образом, значительно проще поддерживать код и увеличивать производительность объекта. Точно также в шаблоне проектирования MVC выделяется управление и логика представления. Переменная dt начинает изменяться каждую миллисекунду с момента последнего вызова обновлений.

Название хорошее, короткое и происходит от (не пугайтесь) производных исчислений. Это отделяет перемещение от скорости смены кадров. Таким образом, вы избежите замедления стиля NES, когда все станет слишком сложным. Если нагрузка будет слишком большой, из анимации выпадут некоторые кадры, но скорость останется той же самой:

updatePosition : function() {

    //Это небольшая хитрость для создания переменной вне цикла визуализации
    //Это требует больших затрат ресурса памяти внутри цикла.
    //Переменная доступна только для приведенной ниже функции.

    var moveDistance = new THREE.Vector2();
    //Это собственно функция
    return function( dt ) {

        moveDistance.copy( this.direction );
        moveDistance.multiplyScalar( dt );
        this.position.add( moveDistance );

        //Сохраняем dot в пределах экрана
        this.position.x = (this.position.x + this.scene.canvas.width) % this.scene.canvas.width;
        this.position.y = (this.position.y + this.scene.canvas.height) % this.scene.canvas.height;
    } 

}(), //Обратите внимание, что данная функция выполняется немедленно и возвращает разные функции

Эта функция имеет немного запутанную структуру, но она удобна для визуализации. Она действительно потребляет много памяти. Переменная moveDistance устанавливается один раз и может повторно использоваться в любое время при вызове функции.

Этот вектор используется только, чтобы помочь вычислить новое положение, но не используется за пределами функции. Это первый элемент векторной математики, который мы использовали.

Сейчас вектор направления умножается на каждое изменение во времени, а затем добавляется к позиции. В конце концов, мы производим модульные действия, чтобы сохранить dot в пределах screen:

draw : function(dt) {

    //Для удобства получаем короткое имя переменной
    var ctx = this.scene.context;

    ctx.beginPath();
    ctx.fillStyle = this.color;
    ctx.fillRect(this.position.x, this.position.y, this.size, this.size);
}

Дальше все просто. Получаем копию контекста из объекта scene, а затем рисуем прямоугольник (или что вы хотите). Прямоугольник - это фигура, которую, вероятно, быстрее всего можно нарисовать на экране.

Теперь я добавляю новый Dot через вызов this.dot = new Dot(x, y, this) в конструкторе scene, а затем в методе обновления основного пространства действия добавляю this.dot.update( dt ) и получаю масштабирование точки по всему экрану. (Чтобы увидеть весь код в контексте, посмотрите исходный код к статье).

Это хорошо, что у нас есть небольшая внутренняя конструкция с кодом, но она на самом деле не делает ничего особенно интересного. А вот цикл - это намного интереснее. В объекте рабочего пространства мы создадим новый объект DotManager.

Удобнее, если мы соберем этот функционал в отдельный объект, чтобы код был проще и чище, так как сам процесс у нас все больше усложняется:

var DotManager = function( numberOfDots, scene ) {

    this.dots = [];
    this.numberOfDots = numberOfDots;
    this.scene = scene;

    for(var i=0; i < numberOfDots; i++) {
        this.dots.push( new Dot(
            Math.random() * this.canvas.width,
            Math.random() * this.canvas.height,
            this.scene
        ));
    }

};

DotManager.prototype = {
    update : function( dt ) {
        for(var i=0; i < this.numberOfDots; i++) {
            this.dots[i].update( dt );
        }
    }
};

Теперь вместо того, чтобы создавать и обновлять Dot, мы используем scene, чтобы создавать и обновлять DotManager. Для начала мы создадим 5000 точек:

function Scene() {
    ...
    this.dotManager = new DotManager(5000, this); 
    ...
};

Scene.prototype = {
    ...
    update : function( dt ) {
        this.dotManager.update( dt );
    }
    ...
};

Хорошо, это уже лучше, чем просто одна точка. Сейчас самое время приступить к добавлению кода к методу обновления для одиночной Dot. Все меняется, когда код объекта влияет на каждую точку на экране. Вот когда на вещи начинает действовать магия. Помните функцию синуса? Как насчет того, чтобы добавить сейчас небольшой волновой эффект?

Мы создадим переменную wavePosition для объекта Dot. В финальном процессе рисования мы добавим эту переменную к позиции относительно оси Y:

updateWave : function( dt, time ) {
    this.wavePosition = Math.sin( this.scene.currTime / 500 + this.position.x / this.scene.canvas.width * 4 ) * 20;
}

Небольшое затруднение в одной из строк, код ломается, как ранее функция синуса:

var a = 1 / 500, //Задаем, чтобы волновой эффект происходил немного медленнее
x = this.scene.currTime, //Сдвигаем немного вдоль графика, каждый раз когда вызывается draw()
b = this.position.x / this.scene.canvas.width * 4, // Нет необходимости  сдвигать график вверх или вниз
c = 20, //Задаем ширину волны немного меньше, чем половина холста
d = 0; //Передвигаем прямоугольник в центр
xMovement = Math.sin( a * x + b ) * c + d;

Получилось очень увлекательно ...

Еще одна маленькая фишка. Монохромная палитра выглядит уныло, давайте добавим немного цвета:

var hue = this.position.x / this.scene.canvas.width * 360;
this.color = Utils.hslToFillStyle(hue, 50, 50, 0.5);

Для каждой вновь создаваемой Dot берем ее первоначальную позицию, и устанавливаем для нее оттенок, в зависимости от того, где она расположена по ширине холста. Utils.hslToFillStyle - это небольшая вспомогательная функция, которую я добавил, чтобы превратить некоторые входные переменные в корректно отформатированные строки FillStyle.

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

Взаимодействие с пользователем через мышь

До сих пор у нас не было никакого реального взаимодействия с пользователем:

var Mouse = function( scene ) {
   this.scene = scene;
   this.position = new THREE.Vector2(-10000, -10000);
   $(window).mousemove( this.onMouseMove.bind(this) );
};

Mouse.prototype = {
   onMouseMove : function(e) {
       if(typeof(e.pageX) == "number") {
           this.position.x = e.pageX;
           this.position.y = e.pageY;
       } else {
           this.position.x = -100000;
           this.position.y = -100000;
       }
   }
};

Этот простой объект инкапсулирует логику обновления через действия мыши из рабочей области. Он только обновляет вектор позиции при перемещении мыши. Остальные объекты могут после этого определить положение вектора мыши, если им переданы ссылки на объект.

Одно замечание. Я не рассматриваю здесь случай, когда ширина холста не соответствует один к одному размерам DOM в пикселях, т.е. адаптивно подстраиваемый холст, высокую плотность пикселей (сетчатки) холста, или когда холст не начинается в верхнем левом углу. В этих случаях координаты мыши должны быть соответствующим образом скорректированы:

var Scene = function() {
    ...
    this.mouse = new Mouse( this );
    ...
};

Единственное, что нам осталось сделать, это создать объект мыши внутри рабочей области. Теперь, когда мы ввели взаимодействие с мышью, давайте создадим эффект притягивания к ней точек:

function Dot( x, y, scene ) {
    ...
    this.attractSpeed = 1000 * Math.random() + 500;
    this.attractDistance = (150 * Math.random()) + 180;
    ...
}

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

Поиграйте с этими значениями, чтобы изменить эти эффекты. Теперь займемся методом притягивания точек к мыши. Это немного длинный код с комментариями:

attractMouse : function() {

    //Опять, создаем частные переменные для этого метода
    var vectorToMouse = new THREE.Vector2(),
    vectorToMove = new THREE.Vector2();

    //Это собственно общий метод
    return function(dt) {
        var distanceToMouse, distanceToMove;

        //Получаем вектор, который отображает расстояние по оси x и y от точки до мыши
        //Чтобы узнать больше о том, как работают эти векторы, ознакомьтесь с документацией three.js
        vectorToMouse
          .copy( this.scene.mouse.position )
          .sub( this.position );

        //Получаем расстояние от мыши до вектора
        distanceToMouse = vectorToMouse.length();

        //Используем отдельные скалярные значения, чтобы отрегулировать дистанцию перемещения
        moveLength = dt * (this.attractDistance - distanceToMouse) / this.attractSpeed;

        //Перемещаем точку, только если он притянулась
        if( moveLength > 0 ) {

            //Изменяем размер вектора для мыши на нужную длину перемещения
            vectorToMove
              .copy( vectorToMouse )
              .divideScalar( distanceToMouse )
              .multiplyScalar( moveLength );

            //Продолжаем и добавляем его к текущей позиции сейчас, а не при вызове рисования
            this.position.add(
              vectorToMove
            );
        }
    };
}()

Этот метод может показаться вам сложным, если вы не очень хорошо разбираетесь в векторной математике. Векторы могут помочь в создании визуальных представлений, если вы хотите сделать что-то похожее на след от чашки кофе на листе бумаги.

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

Это делается через вычисление расстояния для перемещения (обычное скалярное число) и затем его умножение на соответствующий вектор (вектор с длиной 1), который направлен от точки к мыши. Да, последнее предложение трудно отнести к простому языку.

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

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

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

Приведенный в этой статье код много раз переписывался, чтобы добиться объектно-ориентированного стиля, который я считаю наиболее подходящим.

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

Применяйте свои холсты, как листы бумаги, на которых вы рисуете карандашом. Найдите интересные идеи, поэкспериментируйте с ними. И не ограничивайте полет фантазии.