Свойство transform

Свойство CSS transform позволяет визуально преобразовать элемент в двухмерном или трехмерном пространстве. С помощью преобразования элементы могут быть перемещены, повернуты и масштабированы в двух или трехмерном пространстве.

Если точнее, свойство transform преобразует систему координат элемента, что приводит к трансформации элемента в пространстве. Оно принимает в качестве значения список функций преобразования (приведены ниже) или значение none. Система координат элемента преобразуется в конечное значение, которое получается путем запуска каждой функции в соответствующую ей матрицу, а затем умножения этих матриц.

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

Матрица преобразования также зависит от значения свойства transform-origin, которое используется для указания исходного положения преобразования.

Система координат

Каждый элемент в CSS имеет систему координат, начало которой размещается в левом верхнем углу элемента.

При применении CSS transform начало системы координат переносится в центр элемента. Это происходит потому, что значение свойства transform-origin, применяемое по умолчанию, равно 50%50. После этого все преобразования применяются к элементу на основании нового положения системы координат.

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

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

Если нужно переместить элемент с помощью CSS text transform в другое положение и повернуть его в новом положении, вы должны сделать это в указанном порядке: переместить, а затем повернуть. Если вы повернете элемент, то повернется его система координат, и перемещение в определенном направлении не приведет к ожидаемому результату.

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

Примечания

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

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

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

Когда элемент преобразуется, значение fixed для свойства background-attachment рассматривается, как значение scroll. Вычисленное значение background-attachment не претерпевает изменений.

Кроме transform-origin при преобразовании могут использоваться свойства perspective и perspective-origin, чтобы задать для сцены глубину, а свойство transform-style - чтобы сохранить определение трехмерного пространства. Это полезно при выполнении вложенных CSS-преобразований. Все эти свойства используются в сочетании друг с другом для создания CSS-преобразования в двух или трех измерениях.

Официальный синтаксис

• Синтаксис:

transform: none | <список преобразований>

• Исходное значение: none
• Применяется к: трансформируемому элементу
• Анимируемо: да

Примечания

<список преобразований> - это список из функций преобразования.

Значения

Можно применить к элементу преобразование, используя одно из следующих значений свойства transform:

• CSS transform rotate ()
• translateX()
• translateY()
• scale()
• scaleX()
• scaleY()
• rotate()
• skew()
• skewX
• skewY
• matrix()
• translateZ
• translate3d()
• scaleZ()
• scale3d()
• rotateX()
• rotateY()
• rotateZ()
• rotate3d()
• matrix3d()
• perspective()

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

Функции 2D-преобразований:

translate()

transform: translate( tx [, ty ]? ); /* Знак вопроса указывает второе значение, которое является необязательным * /

Функция CSS transform translate используется для перемещения элемента по вектору [tx, ty], где tx - смещение по оси х, а ty - смещение по оси у. Если ty не указано, то его значение считается равным нулю, а элемент перемещается только вдоль оси х. Если единицы измерения не указаны, число будет рассматриваться как "пользовательские единицы".

Положительное значение смещения перемещает элемент в направлении оси, а отрицательное значение - в направлении, противоположном направлению оси.

Примеры:

transform: translate(100px); /* перемещает элемент на 100 пикселей по оси x */
transform: translate(-100px); /* перемещает элемент на 100 пикселей по оси x */
transform: translate(50px, 300px); /* перемещает элемент на 50 пикселей вправо и на 300 пикселей вниз */
transform: translate(50%, 10%); /* перемещает элемент на 50% его ширины влево, и на 10% его высоты вниз */
transform: translate(-100%); /* перемещает элемент на -100% влево */
transform: translate(100px, 100px); /* результат приведен на рисунке ниже */

Результат применения к элементу смещения:

translateX()

transform: translateX(tx);

Функция CSS transform translateX() используется, чтобы переместить элемент на заданное расстояние вдоль оси х. Значение tx задается в единицах длины или процентах. Если единицы измерения не указаны, число будет рассматриваться как "пользовательские единицы".

Положительное значение смещения перемещает элемент вдоль направления оси х, а отрицательное значение - в противоположном направлении.

Примеры:

transform: translateX(300px);
transform: translateX(-50%);
transform: translateX(150%);

translateY()

transform: translateY(ty);

Функция translateY() используется для перемещения элемента на заданное расстояние вдоль оси Y. Значение ty задается в единицах длины или процентах. Если единицы измерения не указаны, число будет рассматриваться, как "пользовательские единицы".

Положительное значение смещения перемещает элемент вдоль направления оси y, а отрицательное значение - в противоположном направлении.

Примеры:

transform: translateY(300px);
transform: translateY(-50%);
transform: translateY(150%);

scale()

transform: scale(<number> [, <number>]?); /* Знак вопроса указывает второе значение, которое является необязательным * /

Функция CSS transform scale используется для масштабирования (растягивания или сжатия) элемента путем изменения его размеров в большую или в меньшую сторону. Она принимает в качестве значения одно или два числа без единиц измерения, sx и sy, где sx изменяет размеры элемента по оси х, а sy - по оси у. Если указано только одно значение (sx), второе значение (sy) будет рассматриваться, как равное первому.

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

Если значение больше 0, но меньше 1, то элемент сжимается. Если значение равно нулю, то элемент исчезает. Отрицательные значения допустимы, но они не изменяют размеров элемента. Они задают поворот преобразуемого элемента в определенном направлении.

Примеры:

transform: scale(1, 1); /* элемент остается без изменений */
transform: scale(2, 2); /* элемент выглядит в два раза больше, чем его исходные размеры */
transform: scale(1, 2); /* элемент растягивается по вертикали вдвое от своей исходной высоты, его горизонтальные размеры остаются без изменений. Аналогичный эффект дает применение функции scaleY(2) (см. ниже) */
transform: scale(2, 1); /* элемент растягивается по горизонтали вдвое от своей исходной ширины, его вертикальные размеры остаются без изменений. Аналогичный эффект дает применение функции scaleX(2) (см. ниже) */
transform: scale(3); /* элемент увеличивается в размерах в 3 раза */
transform: scale(0.5); /* элемент сжимается до половины своих исходных размеров */
transform: scale(0); /* элемент исчезает */
transform: scale(-1); /* поворачивает элемент в обоих направлениях */

На следующем рисунке показан результат применения к изображению различных преобразований scale(). Первое слева - изображение без каких-либо преобразований. Второе - результат применения transform: scale(2);, третье - результат применения transform: scale(0.5), а четвертое - результат применения transform: scale(0.5, 1.5);.

Обратите внимание, как изображения накладываются друг на друга, так как преобразование каждого из них не влияет на поток контента вокруг него:

Следующее изображение является результатом применения преобразования CSS transform scale (и его вариаций) с отрицательными значениями:

scaleX()

transform: scaleX(<number>);

Функция scaleX() используется для масштабирования, растягивания или сжатия элемента, делая его больше или меньше, по оси х. Она принимает в качестве значения число sx, которое используется для изменения размера элемента по оси х.

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

Если значение равно 0, то элемент исчезает. Отрицательные значения допустимы, но они не изменяют размеров элемента. Они задают поворот преобразуемого элемента по горизонтали (как будто он поворачивается вокруг оси y).

Примеры:

transform: scaleX(2); /* растягивает элемент вдвое от его исходных размеров по оси x */
transform: scaleX(1); /* элемент остается без изменений */
transform: scaleX(0.25); /* сжимает элемент по оси x до четверти от его исходных размеров */
transform: scaleX(-1); /* поворачивает элемент по оси x */

scaleY()

transform: scaleY(<number>);

Функция CSS transform scaleY() используется для масштабирования, растягивания или сжатия элемента в размерах по оси у. Она принимает в качестве значения число sу, которое используется для изменения размера элемента по оси y.

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

Отрицательные значения допустимы, но они не изменяют размеров элемента. Фактически они задают поворот преобразуемого элемента по вертикали (как будто он поворачивается вокруг оси x).

Примеры:

transform: scaleY(2); /* растягивает элемент вдвое от его исходных размеров по оси y */
transform: scaleY(1); /* элемент остается без изменений */
transform: scaleY(0.25); /* сжимает элемент по оси y до четверти от его исходных размеров */
transform: scaleY(-1); /* поворачивает элемент по оси y */

rotate()

transform: rotate(<угол>);

Функция rotate() используется для вращения элемента в двухмерном пространстве. Элемент поворачивается на угол, который передается функции. Элемент вращается вокруг начала координат, как это определено свойством transform-origin.

Положительное значение задает вращение элемента по часовой стрелке. Отрицательное значение - против часовой стрелки.

Примеры:

transform: rotate(45deg);
transform: rotate(-60deg);
transform: rotate(1.5rad);
transform: rotate(1turn);

На следующем рисунке показан результат применения к изображению положительного, а затем отрицательного значения функции CSS transform rotate. Обратите внимание на то, как изображения накладываются друг на друга, так как преобразование каждого из них не влияет на поток контента вокруг него:

skew()

transform: skew(<угол> [, <угол>]?);

Функция skew() используется для наклона (скоса) элемента. Наклон элемента выглядит, как применение для него эффекта скоса. Функция принимает один или два аргумента: ax и ay. Оба являются значениями углов. Первое значение (ах) скашивает элемент вдоль оси х, а второй аргумент (ау) - вдоль оси у.

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

Функция transform skew CSS присутствовала в ранних версиях спецификации. Она был удалена из нее, но по-прежнему присутствует в некоторых реализациях. *Не используйте ее*. Чтобы скосить элемент в любом направлении, используйте функции skewX() и skewY(), описанные ниже. Также обратите внимание на то, что поведение функции skew() отличается от умножения преобразований skewX() и skewY().

skewX()

transform: skewX(<угол>);

Функция skewX() используется для наклона элемента. Наклон элемента выглядит, как применение для него эффекта скоса. В случае с skewX(), процесс похож на то, если бы мы захватили две противоположные вершины прямоугольника и потянули их в противоположных направлениях вдоль оси x, превращая прямоугольник в параллелограмм.

Функция принимает в качестве значения ax. Элемент скашивается на величину угла. Можно представить себе, что мы растягиваем две противоположные вершины прямоугольника в противоположных направлениях до тех пор, пока внутреннее значение этих углов не достигнет 90 градусов (ах).

Если значение угла положительное, "растягиваются" левый верхний и нижний правый углы прямоугольника. Если значение отрицательное - верхний правый и нижний левый угол. При значении угла в 90 градусов (или -90 градусов) элемент исчезнет. Значение 180 градусов (или -180 градусов) оставит его без изменений.

Примеры:

transform: skewX(30deg);
transform: skewX(-30deg);
transform: skewX(-0.5rad);
transform: skewX(-1turn);
transform: skewX(-90deg);

На приведенном ниже рисунке показан результат применения к изображению skewX() с положительным, а затем с отрицательным углом одной и той же величины:

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

skewY()

transform: skewY(<angle>);

Функция skewY() используется для наклона элемента. Наклон элемента выглядит, как применение для него эффекта скоса. В случае с skewY(), процесс похож на то, если бы мы захватили две противоположные вершины прямоугольника и потянули их в противоположных направлениях вдоль оси y, превращая прямоугольник в параллелограмм.

Функция CSS transform принимает в качестве значения ау. Элемент скашивается на величину угла. Можно представить себе, что мы растягиваем две противоположные вершины прямоугольника в противоположных направлениях до тех пор, пока внутреннее значение этих углов не достигнет 90 градусов – ау.

Если значение угла положительное, "растягиваются" левый верхний и нижний правый угол прямоугольника. Если значение отрицательное - верхний правый и нижний левый. При значении угла 90 градусов (или -90 градусов) элемент исчезнет. Значение 180 градусов (или -180 градусов) оставит его без изменений.

Примеры:

transform: skewY(30deg);
transform: skewY(-30deg);
transform: skewY(-0.5rad);
transform: skewY(-1turn);
transform: skewY(-90deg);

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

Следует помнить, что наклон элемента также искажает его систему координат.

matrix()

transform: matrix( <number> [, <number> ]{5,5} )

Функция matrix() используется для указания двухмерной матрицы преобразования. Она может быть использована для объединения нескольких преобразований в одно. Например, вместо использования двух (или более) функций преобразования (смотрите выше) в одном объявлении, например, следующим образом:

transform: rotate(45deg) translate(24px,25px);

С помощью функции CSStransform matrix можно объединить эти два преобразования в одну матрицу:

transform: matrix(0.7071067811865476, 0.7071067811865475, -0.7071067811865475, 0.7071067811865476, -0.7071067811865426, 34.648232278140824);

Вычислить значения функции matrix3d() будет нелегко. К счастью, Эрик Мейер и Аарон Густафсон создали весьма полезный инструмент, который может выполнить расчеты вместо вас. Все, что нужно сделать, это ввести значения transform, которые вам нужны, и нажать на красную кнопку, чтобы инструмент сгенерировал для вас эквивалентную функцию matrix().

Функции 3D-преобразования:

translateZ()

transform: translateZ(tz);

Функция translateZ() используется для перемещения элемента на заданное расстояние вдоль оси z. Значение tz задается в единицах длины (проценты здесь не допускаются). Если единицы измерения не указаны, число будет рассматриваться, как "пользовательские единицы".

Положительное значение перемещает элемент вдоль положительного направления оси z, а отрицательное значения - в противоположном направлении.

Примеры:

transform: translateZ(300px);
transform: translateZ(-5em);
transform: translateZ(4vh);

translate3d()

transform: translate3d( tx , ty, tz);

Функция translate3d() является трехмерным аналогом функции CSS transform translate. Она используется, чтобы переместить элемент по вектору [tx, ty, tz], где tx - смещение вдоль оси х, ty - смещение вдоль оси у, а tz - смещение вдоль оси z. Значения tx и ty указываются в единицах длины или процентах. Значение tz должно указываться в единицах длины и не может задаваться в процентах. Если единицы измерения не указаны, число будет рассматриваться, как "пользовательские единицы".

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

Примеры:

transform: translate3d(100px, 100px, -200px);
transform: translate3d(50%, -100%, 1em);
transform: translate3d(-100px, -30px, 5vw);

scaleZ()

transform: scaleZ(<число>);

Функция scaleZ() используется для масштабирования элемента в третьем измерении, вдоль оси z. Она принимает в качестве значения число без единиц измерения sz, которое используется для изменения размеров элемента в соответствующем направлении.

Примеры:

transform: scaleZ(2); 
transform: scaleZ(1); /* элемент остается без изменений */
transform: scaleZ(0.25); 
transform: scaleZ(-1);

Формально, scaleZ() масштабирует элемент вдоль оси z. Но фактически, это выглядит наподобие того, как если бы масштабировалась (сжималась / растягивалась) сама ось z, а затем элемент смещался бы вместе с осью после ее масштабирования.

Эффект CSS transform scaleZ более очевиден, когда у вас есть элемент с заданной перспективой, который вращается в трехмерном пространстве или перемещается вдоль оси z.

В первом примере у нас есть два элемента, которые расположены в трехмерном пространстве и перемещаются вдоль оси z с помощью функции translateZ(). Оба перемещаются на одинаковое расстояние. Затем мы масштабируем второй элемент (правый), используя scaleZ(2). На следующем рисунке показан результат применения преобразований, а также разница между этими двумя элементами после масштабирования второго с помощью функции scaleZ.

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

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

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

scale3d()

transform: scale3d(<число>, <число>, <число>);

Функция scale3d() является трехмерным аналогом функции scale(). Она используется для сжатия или растягивания элемента, делая его больше или меньше. Функция принимает в качестве значений три числа без единиц измерения: sx, sy, и sz. Где: sx масштабирует элемент по оси х, sy - по оси у, а sz - по оси z.

Если заданное значение больше 1, элемент растягивается в соответствующих направлениях и будет выглядеть больше. Если значение равно 1, то он остается неизменным (в соответствующих направлениях). Если значение больше 0, но меньше 1, то элемент сжимается.

Если значение равно 0, то элемент исчезает. Отрицательные значения допускаются, но они не масштабируют элемент. На самом деле отрицательные значения sx и sy поворачивают элемент по соответствующей оси.

Примеры:

transform: scale3d(1, 1, 1); /* элемент остается без изменений */
transform: scale3d(2, 2, 2); /* элемент выглядит вдвое больше от его исходных размеров */
transform: scale3d(1, 2, 0); 
transform: scale3d(2, 1, 3);
transform: scale3d(-1, -1, -1);

rotate3d()

transform: rotate3d( <число>, <число>, <число>, <угол> );

Функция rotate3d() является трехмерным аналогом функции CSS transform rotate. Она используется для вращения элемента в трехмерном пространстве. Элемент поворачивается на угол, который передается в качестве четвертого параметра. Первые три параметра определяют направление вращения, и вместе они образуют направление вектора [x, y, z], который используется, чтобы применить вращение в заданном направлении.

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

На следующем рисунке показаны положительные направления вращения (по часовой стрелке) по трем осям:

Первые три параметра rotate3d() указывают направление вектора, вдоль которого будет происходить вращение, а угол - указывает направление: по часовой стрелке по вектору или против часовой стрелки.

Примеры:

transform: rotate3d(1, 1, 2, 45deg);
transform: rotate3d(2, 1, 3, 33deg);
transform: rotate3d(1, 0, 0, 45deg); /* элемент поворачивается по часовой стрелке вокруг оси x на 45 градусов */
transform: rotate3d(0, 1, 0, 45deg); /* элемент поворачивается по часовой стрелке вокруг оси y на 45 градусов */
transform: rotate3d(0, 0, 1, 45deg); /* элемент поворачивается по часовой стрелке вокруг оси z на 45 градусов  */
transform: rotate3d(0, 0, 0, 50deg); /* ПОВОРОТ НЕ ПРИМЕНЯЕТСЯ */

На следующем рисунке показан результат применения к изображению преобразования rotate3d (1, 1, 1, 50deg);:

rotateX()

transform: rotateX(<угол>);

Функция rotateX() используется для вращения элемента вокруг оси х в трехмерном пространстве. Это эквивалентно:

transform: rotate3d(1, 0, 0, <угол>);

где CSS transform rotate3d - это функция преобразования, используемая для вращения элемента в трехмерном пространстве.

Функция принимает в качестве значение угол. Элемент поворачивается на указанное значение вокруг оси х. Если значение положительное, элемент поворачивается по часовой стрелке, если отрицательное элемент - против часовой. Направление по часовой стрелке определяется, если смотреть на ось х с конца (где, как правило, размещается стрелка указателя направления) на начало координат.

Примеры:

transform: rotateX(30deg);
transform: rotateX(-135deg);
transform: rotateX(90deg);

На следующем рисунке показан результат применения к изображению rotateX(50deg) и rotateX(-50deg):

rotateY()

transform: rotateY(<angle>);

Функция rotateY() используется для вращения элемента вокруг оси y в трехмерном пространстве. Это эквивалентно:

transform: rotate3d(0, 1, 0, <angle>);

где rotate3d - это функция преобразования, используемая для вращения элемента в трехмерном пространстве.

Функция принимает в качестве значения угол. Элемент поворачивается на указанное значение вокруг оси у. Если значение положительное, элемент поворачивается по часовой стрелке, если отрицательное - против часовой стрелки

Примеры:

transform: rotateY(30deg);
transform: rotateY(-135deg);
transform: rotateY(90deg);

На следующем рисунке показан результат применения к изображению rotateY(50deg) и rotateY(-50deg):

rotateZ()

преобразование: rotateZ (<угол>);
transform: rotateZ(<угол>);

Функция CSS transform rotateZ() используется для вращения элемента вокруг оси z в трехмерном пространстве. Это эквивалентно:

transform: rotate3d(0, 0, 1, <угол>);

где rotate3d - это функция преобразования, используемая для вращения элемента в трехмерном пространстве.

Элемент поворачивается на указанное значение вокруг оси z. Если значение положительное, элемент поворачивается по часовой стрелке, если - против часовой стрелки.

Примеры:

transform: rotateZ(30deg);
transform: rotateZ(-135deg);
transform: rotateZ(90deg);

На следующем рисунке показан результат применения к изображению rotateZ(50deg) и rotateZ(-50deg):

matrix3d()

transform: matrix3d( <число> [, <число> ]{15,15} );

Функция matrix3d() является трехмерным эквивалентом функции matrix(). matrix3d() используется для объединения преобразований в одну матрицу и описания последовательностей трехмерных преобразований в сетке 4 ; 4.

Например, вместо того, чтобы использовать две (или более) функции преобразования в одном объявлении следующим образом:

transform: rotate3d(1, 0, 1, 45deg) translate3d(24px,25px, 100px);

Можно объединить эти два преобразования в одну матрицу с помощью функции CSS transform matrix3d():

transform: matrix3d(0.8535533905932737, 0.4999999999999999, 0.14644660940672619, 0, -0.4999999999999999, 0.7071067811865476, 0.4999999999999999, 0, 0.14644660940672619, -0.4999999999999999, 0.8535533905932737, 0, 22.62994231491119, -20.3223304703363, 101.3700576850888, 1)

perspective()

transform: perspective(<длина>)

Техническое описание:

Функция perspective() задает матрицу перспективной проекции. Эта матрица масштабирует точки в X и Y, основываясь на их значениях Z, масштабируя точки с положительными значениями Z в направлении от начала координат, а с отрицательными значениями Z - в направлении к началу координат.

Точка на плоскости Z = 0 не изменяются. Значение длины, передаваемое в функцию, определяет расстояние от плоскости Z = 0 до зрителя. Более низкие значения дают более сплюснутую пирамиду и, следовательно, с перспективой эффект становится более выраженным. Например, значение длины 1000 пикселей в перспективе задает небольшие изменения, а значение 200 пикселей - намного большие. Значение глубины должно быть больше 0, в противном случае функция является недействительной:

Другими словами…

Функция CSS transform perspective() используется, чтобы задать глубину элемента, делая элементы, расположенные выше по оси z (ближе к зрителю), выглядящими больше, а элементы, расположенные дальше - выглядящими меньше. Чем меньше значение, тем ближе плоскость z к зрителю и тем больше выражен эффект. Чем выше значение, тем дальше от экрана расположен элемент и тем меньше наблюдаются изменения в перспективе.

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

Перспектива может быть применена с помощью функции perspective() или с помощью свойства perspective. Существует большая разница между этими двумя методами. Я лишь отмечу, что функция perspective() применяется к элементу, который трансформируется в 3D-пространстве, в то время как свойство perspective применяется к элементу, дочерние элементы которого в преобразуется в 3D-пространстве.

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

Например, если нужно повернуть элемент вокруг оси у, используя функцию CSS transform rotateY(), то необходимо указать перспективу, чтобы создать трехмерное пространство для трехмерных преобразований. Иначе вращение будет выглядеть плоским и двухмерным. На следующем рисунке показана разница между изображением, вращаемым в трехмерном пространстве с перспективой, и изображением, вращаемым без перспективы:

Функция perspective() принимает в качестве параметра значение длины. Чем меньше его значение, тем ближе плоскость z от зрителя, и тем более заметен эффект. Чем выше значение, тем дальше элемент от экрана и менее заметен эффект. На следующем рисунке показан результат применения к элементу разных значений perspective():

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

Примечания

Элемент может быть перемещен с помощью свойства CSS position и его связанных свойств. Но лучше перемещать элемент с помощью функции CSS transform translate, потому что она задействует аппаратное ускорение и обеспечивает более высокую производительность. Функция translate3d() также иногда используется, чтобы применить аппаратное ускорение при анимировании элементов в WebKit-браузерах. Это позволяет создать более плавную анимацию.

Примеры

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

div {
    /* общие стили... */
    width: 100px;
    height: 100px;
    background-color: #0099CC;
    /* преобразование */
    transform: translate(80px, 80px) rotate(45deg) scale(1.5, 1.5);
}

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

В этом transform CSS примере к элементу применяется перспектива с помощью функции perspective():

.element {
    /* ... */
    transform: perspective(800px) rotateY(90deg) translateZ(300px);
}

Можно выполнить то же самое преобразование, но вместо того, чтобы применять к элементу перспективу, можно активировать в контейнере 3D-пространство:

.parent {
    /* ... */
    perspective: 800px;
}
.child {
    /* ... */
    transform: rotateY(90deg) translateZ(300px);
}

Интерактивная демо-версия

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

Посмотреть демо

Поддержка браузерами

Ниже приводится таблица поддержки двухмерных CSS-преобразований:

Поддержка 2D-преобразований CSS3

Метод преобразования элемента, включая вращение, масштабирование и т.д., включает поддержку свойства CSS transform, а также свойства transform-origin.

Текущий статус: рабочий проект W3C

Поддерживается со следующих версий:

* - требуется префикс.

Ниже приводится таблица поддержки трехмерных преобразований CSS:

Поддержка 3D-преобразований CSS3

Метод преобразования элемента в трех измерениях с помощью свойства CSS transform включает поддержку свойства perspective для установки перспективы в z-пространстве и свойства backface-visibility для переключения отображения обратной стороны преобразуемого элемента.

Текущий статус: рабочий проект W3C

Поддерживается со следующих версий:

* - требуется префикс.

Вадим Дворниковавтор-переводчик статьи «transform»