Unity как изменить разрешение камеры

Switch to Scripting

CamerasA component which creates an image of a particular viewpoint in your scene. The output is either drawn to the screen or captured as a texture. More info
See in Glossary are the devices that capture and display the world to the player. By customizing and manipulating cameras, you can make the presentation of your game truly unique. You can have an unlimited number of cameras in a sceneA Scene contains the environments and menus of your game. Think of each unique Scene file as a unique level. In each Scene, you place your environments, obstacles, and decorations, essentially designing and building your game in pieces. More info
See in Glossary. They can be set to render in any order, at any place on the screen, or only certain parts of the screen.

Camera Inspector reference

Unity displays different properties in the Camera InspectorA Unity window that displays information about the currently selected GameObject, asset or project settings, allowing you to inspect and edit the values. More info
See in Glossary depending on the render pipelineA series of operations that take the contents of a Scene, and displays them on a screen. Unity lets you choose from pre-built render pipelines, or write your own. More info
See in Glossary that your Project uses.

• If your Project uses the Universal Render Pipeline (URP), see the URP package documentation microsite.
• If your Project uses the High Definition Render Pipeline (HDRP), see the HDRP package documentation microsite.
• If your Project uses the Built-in Render Pipeline, Unity displays the following properties:

Property:	Function:
Clear Flags	Determines which parts of the screen will be cleared. This is handy when using multiple Cameras to draw different game elements.
Background	The color applied to the remaining screen after all elements in view have been drawn and there is no skyboxA special type of Material used to represent skies. Usually six-sided. More info See in Glossary.
Culling MaskAllows you to include or omit objects to be rendered by a Camera, by Layer. See in Glossary	Includes or omits layers of objects to be rendered by the Camera. Assigns layers to your objects in the Inspector.
Projection	Toggles the camera’s capability to simulate perspective.
Perspective	Camera will render objects with perspective intact.
Orthographic	Camera will render objects uniformly, with no sense of perspective. NOTE: Deferred rendering is not supported in Orthographic mode. Forward renderingA rendering path that renders each object in one or more passes, depending on lights that affect the object. Lights themselves are also treated differently by Forward Rendering, depending on their settings and intensity. More info See in Glossary is always used.
Size (when Orthographic is selected)	The viewportThe user’s visible area of an app on their screen. See in Glossary size of the Camera when set to Orthographic.
FOV Axis (when Perspective is selected)	Field of view axis.
Horizontal	The Camera uses a horizontal field of view axis.
Vertical	The Camera uses a vertical field of view axis.
Field of view (when Perspective is selected)	The Camera’s view angle, measured in degrees along the axis specified in the FOV Axis drop-down.
Physical Camera	Tick this box to enable the Physical Camera properties for this camera. When the Physical Camera properties are enabled, Unity calculates the Field of View using the properties that simulate real-world camera attributes: Focal Length, Sensor Size, and Lens Shift. Physical Camera properties are not visible in the Inspector until you tick this box.
Focal Length	Set the distance, in millimeters, between the camera sensor and the camera lens. Lower values result in a wider Field of View, and vice versa. When you change this value, Unity automatically updates the Field of View property accordingly.
Sensor Type	Specify the real-world camera format you want the camera to simulate. Choose the desired format from the list. When you choose a camera format, Unity sets the the Sensor Size > X and Y properties to the correct values automatically. If you change the Sensor Size values manually, Unity automatically sets this property to Custom.
Sensor Size	Set the size, in millimeters, of the camera sensor. Unity sets the X and Y values automatically when you choose the Sensor Type. You can enter custom values if needed.
X	The width of the sensor.
Y	The height of the sensor.
Lens Shift	Shift the lens horizontally or vertically from center. Values are multiples of the sensor size; for example, a shift of 0.5 along the X axis offsets the sensor by half its horizontal size. You can use lens shifts to correct distortion that occurs when the camera is at an angle to the subject (for example, converging parallel lines). Shift the lens along either axis to make the camera frustum oblique.
X	The horizontal sensor offset.
Y	The vertical sensor offset.
Gate Fit	Options for changing the size of the resolution gate (size/aspect ratio of the game view) relative to the film gate (size/aspect ratio of the Physical Camera sensor). For further information about resolution gate and film gate, see documentation on Physical Cameras.
Vertical	Fits the resolution gate to the height of the film gate. If the sensor aspect ratio is larger than the game view aspect ratio, Unity crops the rendered image at the sides. If the sensor aspect ratio is smaller than the game view aspect ratio, Unity overscans the rendered image at the sides. When you choose this setting, changing the sensor width (Sensor Size > X property) has no effect on the rendered image.
Horizontal	Fits the resolution gate to the width of the film gate. If the sensor aspect ratio is larger than the game view aspect ratio, Unity overscans the rendered image on the top and bottom. If the sensor aspect ratio is smaller than the game view aspect ratio, Unity crops the rendered image on the top and bottom. When you choose this setting, changing the sensor height (Sensor Size > Y property) has no effect on the rendered image.
Fill	Fits the resolution gate to either the width or height of the film gate, whichever is smaller. This crops the rendered image.
Overscan	Fits the resolution gate to either the width or height of the film gate, whichever is larger. This overscans the rendered image.
None	Ignores the resolution gate and uses the film gate only. This stretches the rendered image to fit the game view aspect ratioThe relationship of an image’s proportional dimensions, such as its width and height. See in Glossary.
Clipping Planes	Distances from the camera to start and stop rendering.
Near	The closest point relative to the camera that drawing will occur.
Far	The furthest point relative to the camera that drawing will occur.
Viewport Rect	Four values that indicate where on the screen this camera view will be drawn. Measured in Viewport Coordinates (values 0–1).
X	The beginning horizontal position that the camera view will be drawn.
Y	The beginning vertical position that the camera view will be drawn.
W (Width)	Width of the camera output on the screen.
H (Height)	Height of the camera output on the screen.
Depth	The camera’s position in the draw order. Cameras with a larger value will be drawn on top of cameras with a smaller value.
Rendering PathThe technique that a render pipeline uses to render graphics. Choosing a different rendering path affects how lighting and shading are calculated. Some rendering paths are more suited to different platforms and hardware than others. More info See in Glossary	Options for defining what rendering methods will be used by the camera.
Use Player Settings	This camera will use whichever Rendering Path is set in the Player SettingsSettings that let you set various player-specific options for the final game built by Unity. More info See in Glossary.
Vertex Lit	All objects rendered by this camera will be rendered as Vertex-Lit objects.
Forward	All objects will be rendered with one pass per material.
Deferred Lighting	All objects will be drawn once without lighting, then lighting of all objects will be rendered together at the end of the render queue. NOTE: If the camera’s projection mode is set to Orthographic, this value is overridden, and the camera will always use Forward rendering.
Target Texture	Reference to a Render TextureA special type of Texture that is created and updated at runtime. To use them, first create a new Render Texture and designate one of your Cameras to render into it. Then you can use the Render Texture in a Material just like a regular Texture. More info See in Glossary that will contain the output of the Camera view. Setting this reference will disable this Camera’s capability to render to the screen.
Occlusion CullingA that disables rendering of objects when they are not currently seen by the camera because they are obscured (occluded) by other objects. More info See in Glossary	Enables Occlusion Culling for this camera. Occlusion Culling means that objects that are hidden behind other objects are not rendered, for example if they are behind walls. See Occlusion Culling for details.
Allow HDR	Enables High Dynamic Range rendering for this camera. See High Dynamic Range Rendering for details.
Allow MSAA	Enables multi sample antialiasingA technique for decreasing artifacts, like jagged lines (jaggies), in images to make them appear smoother. More info See in Glossary for this camera.
Allow Dynamic Resolution	Enables Dynamic Resolution rendering for this camera. See Dynamic ResolutionA Camera setting that allows you to dynamically scale individual render targets, to reduce workload on the GPU. More info See in Glossary for details.
Target Display	Defines which external device to render to. Between 1 and 8.

Details

Cameras are essential for displaying your game to the player. They can be customized, scripted, or parented to achieve just about any kind of effect imaginable. For a puzzle game, you might keep the Camera static for a full view of the puzzle. For a first-person shooter, you would parent the Camera to the player character, and place it at the character’s eye level. For a racing game, you’d probably have the Camera follow your player’s vehicle.

You can create multiple Cameras and assign each one to a different Depth. Cameras are drawn from low Depth to high Depth. In other words, a Camera with a Depth of 2 will be drawn on top of a Camera with a depth of 1. You can adjust the values of the Normalized View Port Rectangle property to resize and position the Camera’s view onscreen. This can create multiple mini-views like missile cams, map views, rear-view mirrors, etc.

Render path

Unity supports different rendering paths. You should choose which one you use depending on your game content and target platform / hardware. Different rendering paths have different features and performance characteristics that mostly affect lights and shadows.
The rendering path used by your Project is chosen in the Player settings. Additionally, you can override it for each Camera.

For more information on rendering paths, check the rendering paths page.

Clear Flags

Each Camera stores color and depth information when it renders its view. The portions of the screen that are not drawn in are empty, and will display the skybox by default. When you are using multiple Cameras, each one stores its own color and depth information in buffers, accumulating more data as each Camera renders. As any particular Camera in your scene renders its view, you can set the Clear Flags to clear different collections of the buffer information. To do this, choose one of the following four options:

Skybox

This is the default setting. Any empty portions of the screen will display the current Camera’s skybox. If the current Camera has no skybox set, it will default to the skybox chosen in the Lighting Window (menu: Window > Rendering > Lighting). It will then fall back to the Background Color. Alternatively a Skybox component can be added to the camera.

Solid color

Any empty portions of the screen will display the current Camera’s Background Color.

Depth only

If you want to draw a player’s gun without letting it get clipped inside the environment, set one Camera at Depth 0 to draw the environment, and another Camera at Depth 1 to draw the weapon alone. Set the weapon Camera’s Clear Flags to depth only. This will keep the graphical display of the environment on the screen, but discard all information about where each object exists in 3-D space. When the gun is drawn, the opaque parts will completely cover anything drawn, regardless of how close the gun is to the wall.

Don’t clear

This mode does not clear either the color or the depth bufferA memory store that holds the z-value depth of each pixel in an image, where the z-value is the depth for each rendered pixel from the projection plane. More info
See in Glossary. The result is that each frame is drawn over the next, resulting in a smear-looking effect. This isn’t typically used in games, and would more likely be used with a custom shaderA program that runs on the GPU. More info
See in Glossary.

Note that on some GPUs (mostly mobile GPUs), not clearing the screen might result in the contents of it being undefined in the next frame. On some systems, the screen may contain the previous frame image, a solid black screen, or random colored pixelsThe smallest unit in a computer image. Pixel size depends on your screen resolution. Pixel lighting is calculated at every screen pixel. More info
See in Glossary.

Clip Planes

The Near and Far Clip Plane properties determine where the Camera’s view begins and ends. The planes are laid out perpendicular to the Camera’s direction and are measured from its position. The Near plane is the closest location that will be rendered, and the Far plane is the furthest.

The clipping planes also determine how depth buffer precision is distributed over the scene. In general, to get better precision you should move the Near plane as far as possible.

Note that the near and far clip planes together with the planes defined by the field of view of the camera describe what is popularly known as the camera frustum. Unity ensures that when rendering your objects those which are completely outside of this frustum are not displayed. This is called Frustum Culling. Frustum Culling happens irrespective of whether you use Occlusion Culling in your game.

For performance reasons, you might want to cull small objects earlier. For example, small rocks and debris could be made invisible at much smaller distance than large buildings. To do that, put small objects into a separate layer and set up per-layer cull distances using Camera.layerCullDistances script function.

Culling Mask

The Culling Mask is used for selectively rendering groups of objects using Layers. More information on using layers can be found here.

Normalized Viewport Rectangles

Normalized Viewport Rectangle is specifically for defining a certain portion of the screen that the current camera view will be drawn upon. You can put a map view in the lower-right hand corner of the screen, or a missile-tip view in the upper-left corner. With a bit of design work, you can use Viewport Rectangle to create some unique behaviors.

It’s easy to create a two-player split screen effect using Normalized Viewport Rectangle. After you have created your two cameras, change both camera’s H values to be 0.5 then set player one’s Y value to 0.5, and player two’s Y value to 0. This will make player one’s camera display from halfway up the screen to the top, and player two’s camera start at the bottom and stop halfway up the screen.

Orthographic

Marking a Camera as Orthographic removes all perspective from the Camera’s view. This is mostly useful for making isometric or 2D games.

Note that fog is rendered uniformly in orthographic camera mode and may therefore not appear as expected. This is because the Z coordinate of the post-perspective space is used for the fog “depth”. This is not strictly accurate for an orthographic camera but it is used for its performance benefits during rendering.

Render Texture

This will place the camera’s view onto a TextureAn image used when rendering a GameObject, Sprite, or UI element. Textures are often applied to the surface of a mesh to give it visual detail. More info
See in Glossary that can then be applied to another object. This makes it easy to create sports arena video monitors, surveillance cameras, reflections etc.

Target display

A camera has up to 8 target display settings. The camera can be controlled to render to one of up to 8 monitors. This is supported only on PC, Mac and Linux. In Game View the chosen display in the Camera Inspector will be shown.

---

• 2018–10–05 Page amended
  
• Physical Camera options added in Unity 2018.2
• Gate Fit options added in Unity 2018.3

• Spaces
  • Default
  • Help Room
  • META
  • Moderators
• • Topics
  • Questions
  • Users
  • Badges

• Home /

0

I have a 2D game that takes place on a single screen. The game background is a 1920 x 1080 image. I want to adjust the orthograhpic camera’s viewport so that it precisely encapsulates the game space. Then I can adjust the screen resolution and it will always take up the entire screen. How can I do t$$anonymous$$s?

You can change the viewport on your Camera component. I may misunderstand the question, but why not just stretch the background to always fit the screen resolution?

So the entire gameplay space takes place on a 1920 x 1080 image. So the background is the whole game. I figured out a few things about scaling the camera, so I’ve set the height to 5.4, since by textures are imported at 1/100 scale. But the left and right sides of the camera view extend beyond the texture. I guess I am just a bit confused as to how to adjust the camera so that it only sees the image and nothing more. That way I can stretch that image if necessary into any screen. Or do you just not have such fine control over the camera? In fact maybe I should make the game objects adjust their positions based on resolution, that way there is never stretching.

1 Reply

·
Add your reply

• Sort: 

0

Answer by Neschume888 · Jun 17, 2016 at 04:08 PM

I did it like t$$anonymous$$s.

I got a 1920×1080 background image. Added it as UI image. Set both main camera and image at positions 0,0,0. Select canvas in $$anonymous$$erarchy. Go to «Canvas» in inspector. Select «Render Mode» as «Screen Space — Camera» Drag your Main Camera from $$anonymous$$erarchy to «Render Camera» under Canvas’ inspector (Under Canvas again) Go to Canvas Scaler (Script) in inspector of Canvas. Select «Scale With Screen Size». Set Match to 0.5, and referance resolution as 1920×1080.

Done. It’s been a long time but i hope t$$anonymous$$s was helpful.

Thanks. And yes we released the game about a year ago lol.

Your answer

Welcome to Unity Answers

If you’re new to Unity Answers, please check our User Guide to help you navigate through our website and refer to our FAQ for more information.

Before posting, make sure to check out our Knowledge Base for commonly asked Unity questions.

Check our Moderator Guidelines if you’re a new moderator and want to work together in an effort to improve Unity Answers and support our users.

Follow this Question

Related Questions

КамерыКомпонент, который создает изображение определенной точки обзора в вашей сцене. Вывод либо рисуется на экране, либо фиксируется в виде текстуры. Подробнее
См. в Словарь устройства, которые захватывают и отображают мир игроку. Настраивая камеры и управляя ими, вы можете сделать презентацию своей игры по-настоящему уникальной. У вас может быть неограниченное количество камер в сценеСцена содержит окружение и меню вашей игры. Думайте о каждом уникальном файле сцены как об уникальном уровне. В каждой сцене вы размещаете свое окружение, препятствия и декорации, по сути проектируя и создавая свою игру по частям. Подробнее
См. в Словарь. Их можно настроить для отображения в любом порядке, в любом месте экрана или только в определенных частях экрана.

Справочник по инспектору камеры

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

• Если в вашем проекте используется универсальный конвейер рендеринга (URP), см. микросайт документации пакета URP.
• Если в вашем проекте используется конвейер рендеринга высокого разрешения (HDRP), см. Микросайт документации пакета HDRP.
• Если в вашем проекте используется встроенный конвейер рендеринга, Unity отображает следующие свойства:

Свойства:	Функции:
Clear Flags	Определяет, какие части экрана будут очищены. Это удобно при использовании нескольких камер для отрисовки разных игровых элементов.
Background	Цвет, применяемый к оставшемуся экрану после того, как все элементы в поле зрения были нарисованы и отсутствует небобоксСпециальный тип материала, используемый для представляют небеса. Обычно шестигранник.More info See in Словарь.
Culling MaskПозволяет включать или опускать объекты, отображаемые камерой, по слоям. See in Словарь	Включает или пропускает слои объектов, которые должны быть отображены камерой. Назначает слои вашим объектам в Инспекторе.
Projection	Переключает способность камеры имитировать перспективу.
Perspective	Камера будет отображать объекты с неповрежденной перспективой.
Orthographic	Камера будет отображать объекты равномерно, без ощущения перспективы. ПРИМЕЧАНИЕ. Отложенный рендеринг не поддерживается в ортогональном режиме. Прямой рендерингПуть рендеринга, при котором каждый объект визуализируется за один или несколько проходов, в зависимости от освещения, воздействующего на объект. Сами источники света также обрабатываются Forward Rendering по-разному, в зависимости от их настроек и интенсивности. Подробнее Всегда используется См. в Словарь.
Size (when Orthographic is selected)	область просмотравидимая пользователем область приложения на экране. Просмотр в размере Словарь камеры, если установлено Орфографическое.
FOV Axis (when Perspective is selected)	Ось поля зрения.
Horizontal	Камера использует горизонтальную ось поля зрения.
Vertical	Камера использует вертикальную ось поля зрения.
Field of view (when Perspective is selected)	Угол обзора камеры, измеренный в градусах вдоль оси, указанной в раскрывающемся списке Ось поля зрения.
Physical Camera	Установите этот флажок, чтобы включить свойства Физическая камера для этой камеры. Когда включены свойства физической камеры, Unity вычисляет поле зрения, используя свойства, имитирующие атрибуты реальной камеры: фокусное расстояние, размер сенсора. и Сдвиг объектива. Свойства физической камеры не отображаются в Инспекторе, пока вы не установите этот флажок.
Focal Length	Установите расстояние в миллиметрах между датчиком камеры и объективом камеры. Меньшие значения приводят к более широкому полю обзора и наоборот. При изменении этого значения Unity автоматически обновляет свойство Field of View соответствующим образом.
Sensor Type	Укажите реальный формат камеры, которую вы хотите имитировать. Выберите нужный формат из списка. При выборе формата камеры Unity автоматически устанавливает для свойств Размер сенсора > X и Y правильные значения. Если вы измените значения Размер сенсора вручную, Unity автоматически установит для этого свойства значение Пользовательский.
Sensor Size	Установите размер сенсора камеры в миллиметрах. Unity устанавливает значения X и Y автоматически, когда вы выбираете Тип датчика. При необходимости вы можете ввести собственные значения.
X	Ширина датчика.
Y	Высота датчика.
Lens Shift	Сместите объектив по горизонтали или вертикали от центра. Значения кратны размеру сенсора; например, смещение на 0,5 по оси X смещает датчик на половину его горизонтального размера. Сдвиг объектива можно использовать для исправления искажений, возникающих, когда камера находится под углом к объекту (например, сходящиеся параллельные линии). Сдвиньте объектив вдоль любой из осей, чтобы сделать усеченную камеру наклонной.
X	The horizontal sensor offset.
Y	The vertical sensor offset.
Gate Fit	Параметры для изменения размера ворота разрешения (соотношение размера/соотношения изображения в игре) относительно отверстия пленки (соотношение размера/соотношения сенсора физической камеры). Для получения дополнительной информации о воротах разрешения и пленки см. документацию по физическим камерам.
Vertical	Подгоняет ворота разрешения по высоте пленочных ворот. Если соотношение сторон сенсора больше, чем соотношение сторон игрового экрана, Unity обрезает обработанное изображение по бокам. Если соотношение сторон сенсора меньше, чем соотношение сторон игрового экрана, Unity пересканирует визуализированное изображение по бокам. При выборе этого параметра изменение ширины сенсора (Размер сенсора > Свойство X) не влияет на визуализируемое изображение.
Horizontal	Подгоняет ворота разрешения к ширине пленочных ворот. Если соотношение сторон сенсора больше, чем соотношение сторон игрового экрана, Unity закрывает отображаемое изображение сверху и снизу. Если соотношение сторон сенсора меньше, чем соотношение сторон игрового экрана, Unity обрезает обработанное изображение сверху и снизу. При выборе этого параметра изменение высоты сенсора (свойство Sensor Size > Y) не влияет на визуализируемое изображение.
Fill	Соответствует ширине или высоте пленочного затвора, в зависимости от того, что меньше. Это обрезает визуализированное изображение.
Overscan	Соответствует ширине или высоте ворот пленки, в зависимости от того, что больше. Это пересканирует визуализированное изображение.
None	Игнорирует ворота разрешения и использует только пленочные ворота. Это растягивает отображаемое изображение, чтобы оно соответствовало игровому представлению соотношение сторонсоотношение пропорциональных размеров изображения, таких как его ширина и высота. See in Словарь.
Clipping Planes	Расстояния от камеры для запуска и остановки рендеринга.
Near	Ближайшая точка относительно камеры, в которой будет происходить рисование.
Far	Самая дальняя точка относительно камеры, в которой будет происходить рисование.
Viewport Rect	Четыре значения, которые указывают, где на экране будет отображаться этот вид камеры. Измеряется в координатах видового экрана (значения 0–1).
X	Начальная горизонтальная позиция, в которой будет отображаться вид камеры.
Y	Начальная вертикальная позиция, в которой будет отображаться вид камеры.
W (Width)	Ширина вывода камеры на экран.
H (Height)	Высота выхода камеры на экран.
Depth	Положение камеры в порядке прорисовки. Камеры с большим значением будут отображаться поверх камер с меньшим значением.
Rendering PathТехника, которую Unity использует для рендеринга графики. Выбор другого пути влияет на производительность вашей игры и на то, как рассчитываются освещение и затенение. Некоторые пути больше подходят для разных платформ и оборудования, чем другие. More info See in Словарь	Параметры для определения того, какие методы рендеринга будут использоваться камерой..
Use Player Settings	Эта камера будет использовать тот путь рендеринга, который установлен в настройках игроканастройках, которые позволяют вам установить различные параметры финальной игры для конкретных игроков. создано Юнити. More info See in Словарь.
Vertex Lit	Все объекты, визуализируемые этой камерой, будут отображаться как объекты Vertex-Lit.
Forward	Все объекты будут визуализированы с одним проходом для каждого материала..
Deferred Lighting	Все объекты будут отрисованы один раз без освещения, затем освещение всех объектов будет отрисовано вместе в конце очереди рендеринга. ПРИМЕЧАНИЕ. Если режим проецирования камеры установлен на «Орфографический», это значение переопределяется, и камера всегда будет использовать рендеринг «Вперед».
Target Texture	Ссылка на рендеринг-текстуруспециальный тип текстуры, который создается и обновляется во время выполнения. Чтобы использовать их, сначала создайте новую текстуру рендеринга и назначьте одну из ваших камер для рендеринга в нее. Затем вы можете использовать Render Texture в материале, как обычную текстуру. Подробнее См. в Словарь, который будет содержать выходные данные камеры. Установка этой ссылки отключит возможность этой камеры отображать изображение на экране..
Occlusion CullingФункция, которая отключает визуализацию объектов, когда они в данный момент не видны камере, поскольку они скрыты (окклюзированы) другими объектами. Подробнее См. в Словарь	Включает отсечение окклюзии для этой камеры. Occlusion Culling означает, что объекты, скрытые за другими объектами, не визуализируются, например, если они находятся за стенами. Подробнее см. в разделе Отсечение окклюзии..
Allow HDR	Включает рендеринг High Dynamic Range для этой камеры. Дополнительные сведения см. в разделе Визуализация с расширенным динамическим диапазоном.
Allow MSAA	Включает мультивыборочное сглаживаниеметод уменьшения артефактов, таких как зубчатые линии (неровности), на изображениях, чтобы сделать их более гладкими. More info See in Словарь для этой камеры.
Allow Dynamic Resolution	Включает рендеринг с динамическим разрешением для этой камеры. См. раздел Динамическое разрешениеНастройка камеры, позволяющая динамически масштабировать отдельные цели рендеринга, чтобы снизить нагрузку на GPU. More info See in Словарь for details.
Target Display	Определяет, на какое внешнее устройство выполнять рендеринг. Между 1 и 8.

Details

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

Вы можете создать несколько камер и назначить каждой из них разную глубину. Камеры прорисовываются от низкой Глубины к высокой Глубине. Другими словами, камера с глубиной, равной 2, будет отображаться поверх камеры с глубиной, равной 1. Вы можете настроить значения нормализованного прямоугольника порта просмотра. для изменения размера и положения камеры на экране. Это может создать несколько мини-просмотров, таких как ракетные камеры, виды карты, зеркала заднего вида и т. д.

Путь рендеринга

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

Дополнительную информацию о путях рендеринга см. на странице пути рендеринга.

Очистить флажки

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

Скайбокс

Это настройка по умолчанию. Любые пустые части экрана будут отображать скайбокс текущей камеры. Если для текущей камеры не установлен скайбокс, по умолчанию будет использоваться скайбокс, выбранный в Окне освещения (меню: Окно > ВизуализацияПроцесс вывода графики на экран (или в текстуру рендеринга). По умолчанию основная камера в Unity выполняет рендеринг. его представление на экране. Подробнее
См. в разделе Словарь > Освещение). Затем он вернется к цвету фона. В качестве альтернативы к камере можно добавить компонент Skybox. Если вы хотите создать новый Skybox, вы можете использовать это руководство.

Сплошной цвет

Во всех пустых частях экрана будет отображаться Цвет фона текущей камеры.

Только глубина

Если вы хотите нарисовать оружие игрока, не позволяя ему попасть в окружение, установите для одной камеры значение Глубина 0, чтобы нарисовать окружение, а для другой камеры — Глубина. 1, чтобы вытащить оружие в одиночку. Установите для параметра Очистить флаги камеры оружия значение только глубина. Это сохранит графическое отображение среды на экране, но отбросит всю информацию о том, где находится каждый объект в трехмерном пространстве. Когда пистолет вытащен, непрозрачные части полностью закроют все, что нарисовано, независимо от того, насколько близко пистолет находится к стене.

Не очищать

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

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

Обрезать плоскости

Свойства Near и Far Clip Plane определяют, где начинается и заканчивается обзор камеры. Плоскости располагаются перпендикулярно направлению камеры и измеряются от ее положения. Ближняя плоскость — это ближайшее место, которое будет визуализировано, а дальняя плоскость — самое дальнее.

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

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

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

Маска отбраковки

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

Нормализованные прямоугольники области просмотра

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

Эффект разделения экрана для двух игроков легко создать с помощью Normalized Viewport Rectangle. После того, как вы создали две камеры, измените значения H обеих камер на 0,5, затем установите значение Y первого игрока на 0,5, а значение Y второго игрока на 0. Это сделает отображение камеры первого игрока с середины экрана вверх, и Камера второго игрока начинается снизу и останавливается на полпути вверх по экрану.

Орфографический

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

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

Визуализировать текстуру

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

Целевой дисплей

Камера имеет до 8 целевых настроек отображения. Камерой можно управлять для рендеринга на один из 8 мониторов. Это поддерживается только на ПК, Mac и Linux. В Game View будет показан выбранный дисплей в Camera Inspector.

---

• В Unity 2018.2 добавлены параметры физической камеры
• Параметры Gate Fit добавлены в Unity 2018.3

В общем, пока что остановился на том, что просто растягиваю фон в зависимости от текущего разрешения экрана:

Так мой фон объект с текстурой, а не UI пришлось выяснять зависимость, потому что тут обычная пропорция даёт неправильный результат, если текущее разрешение экрана меньше того, под которое игра разрабатывалась, в моём случае 1024:768. Как оказалось, изменять высоту не имеет смысла, Unity делает всегда одинаковой, поэтому по высоте подгонять не имеет смысла.

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

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

Но почему-то оно возвращает какое-то именно одно расширение, вместо текущего. Причём ставишь, то разрешение которое выдаёт (1280:768) и даже на нём чёрные полосы (небольшие). И ещё одна странность, я ставлю 60 Гц, а оно мне вообще 75 выдаёт. Это после компиляции игры так. А в редакторе изменяю разрешение на рабочем столе и запускаю и работает правильно. Что не так пока не пойму.
Но ставлю своё:

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

В свое время, в начале разработки двухмерной игры на Unity3d, мне пришлось перерыть кучу документации, сайтов, проштудировать answers.unity3d.com и forum.unity3d.com на тему: как сделать 2d-игру на этом 3d-движке. Самыми первыми вопросами были: как правильно настроить камеру, как сделать 2d-спрайт так, чтобы он отображал текстуру «пиксель в пиксель». На то время уже существовал SpriteManager (далее – SM) и даже SM2 с его мощной поддержкой редактора. Судьба сложилась так, что я не мог его тогда купить, да и пробной версии не было. В итоге, мне пришлось самому написать несколько полезных скриптов для реализации 2d на Unity3d. О том, как это сделать, пойдет речь в этой статье.

«

Источники информации

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

• Unity3d.com – официальный сайт движка. Здесь полезными будут странички:
  • Unity User Manual – официальное руководство пользователя. Начинать изучать здесь.
  • Unity Reference Manual – более углубленное изучение.
  • Scripting Reference – здесь все по библиотеке Unity3d для всех трех поддерживаемых языков (Boo, JavaScript и C#).
  • Unity Resources – здесь можно найти видео-руководства, примеры, презентации.
  • Unity Answers – здесь ответят на ваши вопросы, либо можно найти готовый ответ. Часто пользовался этим ресурсом.
  • Unity Community — форум.
• Unity3d по-русски — сайт разработчиков под Unity3d на русском языке. Если у вас неважно с английским, здесь есть руководства на русском, а на форуме можно получить ответы на интересующие вопросы.
• Unity3d Wiki – очень полезный ресурс. Здесь множество рекомендаций, бесплатных полезных скриптов.

Также после установки Unity3d на вашем компьютере появятся локальные версии руководств и видео. При первом запуске их можно будет выбрать из окна приветствия или найти в меню Help.

Что понадобится

Версия используемого движка – 3.3, весь код написан на C# и будет работать на всех лицензиях Unity. Достаточно скачать бесплатную версию Unity. В комплекте идет MonoDevelop – бесплатная среда для разработки на .NET (на случай, если у вас нет Visual Studio). Среда легко настраивается «под себя», в ней есть все, что необходимо для разработки, поддерживает такие удобные функции, как автодополнение, шаблоны подстановки кода и многое другое. Сам я пользуюсь Visual Studio в связке с Resharper – так удобнее. Редактор Unity поддерживает обе среды.

Условия использования кода

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

Условие только одно: при использовании кода (в том числе модифицированного) в коммерческом проекте необходимо указать ссылку на автора (т.е. fischer — меня).

Код примера, используемого в статье, можно скачать отсюда.

Настройка камеры

Для начала создайте пустую сцену без объектов. Удалите объект MainCamera, добавленный по умолчанию.

Нужно настроить камеру так, чтобы она стала «пригодна» для 2d. В Unity под камерой понимается класс Camera. Для того, чтобы ее использовать, нужно:

1. Создать пустой объект (GameObject -> Create Empty).
2. Выбрать его и добавить ему компонент Camera (Component -> Rendering -> Camera).

Изначально камера перпендикулярна плоскости XOY и направлена вдоль оси Z в положительном направлении. В дальнейшем для простоты спрайты будут лежать в плоскости XOY и по направлению к камере, так что поместите камеру в центр координат и отдалите ее по оси Z на необходимое расстояние в отрицательное полупространство (скажем, в точку [0, 0, -100]).

Для 2d-графики положение спрайтов в пространстве не важно. На много важнее, как спрайты друг друга перекрывают. Камера поддерживает два режима (вида проекции): перспективный (Perspective) и ортогональный (Orthographic). Первый используется во всех 3d-играх: объекты, расположенные дальше от камеры, выглядят меньше. Это почти то, как мы видим наш мир. Нам нужен второй режим, Orthographic – объекты всегда рисуются реального размера и перекрывают друг друга в зависимости от расстояния до камеры. Идеальный режим камеры для 2d и изометрии. В окне Inspector в компоненте Camera вновь созданного объекта в поле Projection выберите Orthographic. При этом некоторые параметры (соответствующие Perspective-режиму) пропадут, но появится параметр Size – размер ортогональной камеры.

Теперь настроим камеру так, чтобы каждый пиксель на экране соответствовал одной единице (unit) пространства в Unity. В дальнейшем это будет удобно при перемещении спрайтов и задании их размеров в пикселях. Для этого размер ортогональной камеры (параметр Size) должен равняться половине высоты экрана в пикселях. Например, если это экран iPhone 3G в портретном режиме, разрешение экрана которого 320×480, то Size = h/2 = 480/2 = 240.

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

using UnityEngine; 
[ExecuteInEditMode]
[RequireComponent(typeof(Camera))] 
internal class Ortho2dCamera : MonoBehaviour
{
  [SerializeField] private bool uniform = true;
  [SerializeField] private bool autoSetUniform = false;

  private void Awake()
  {
    camera.orthographic = true;

    if (uniform)
      SetUniform();
  } 
  private void LateUpdate()
  {
    if (autoSetUniform && uniform)
      SetUniform();
  } 
  private void SetUniform()
  {
    float orthographicSize = camera.pixelHeight/2;
    if (orthographicSize != camera.orthographicSize)
      camera.orthographicSize = orthographicSize;
  }
}

Если добавить этот скрипт на любой игровой объект (GameObject), то:

1. Автоматически этому объекту добавится компонент Camera. За это отвечает атрибут RequireComponent.
2. Выполнится функция Awake. За это отвечает атрибут ExecuteInEditMode, который заставляет выполняться скрипты прямо в редакторе.
3. В результате вызова этой функции камера станет ортогональной.
4. Ее размер будет установлен таким, чтобы один пиксель на экране соответствовал одной единице Unity (вызов функции SetUniform). Это будет выполняться автоматически для любого экрана.

Теперь камера должна выглядеть так:

Улучшения

1. Если размер экрана может меняться во время выполнения (поворот экрана смартфона, смена разрешения пользователем), неплохо бы автоматически менять размер камеры. Это можно делать в функции LateUpdate.
2. Если освещение использоваться не будет (как и бывает в большинстве 2d-игр), рекомендую в настройках проекта (File->Build Settings->Player Settings->Other Settings) установить параметр Rendering Path в значение Vertex Lit. Это самый простой способ отрисовки объектов (каждый объект за один шаг для всех источников света), поддерживаемый большинством устройств. В моем случае для iOS-устройств это дало скачок в производительности. То же самое можно сделать для конкретной камеры. По умолчанию камера используют значение из Player Settings.

Спрайт

Спрайт — прямоугольник с наложенной на него текстурой. Договоримся, что он по умолчанию будет расположен в плоскости XOY. Тогда за взаимное расположение спрайтов (слои) будет отвечать координата Z.

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

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

  [SerializeField] private Vector2 size = Vector2.one;
  [SerializeField] private Vector2 zero = Vector2.one / 2;
  [SerializeField] private Rect textureCoords = Rect.MinMaxRect(0, 0, 1, 1);
  [SerializeField] private bool pixelCorrect = true;

Расшифруем их:

• zero – положение нулевой точки спрайта относительно его нижнего левого угла. Измеряется в долях спрайта, т.е. (0.5, 0.5) – это центр спрайта. Нужен для правильного смещения спрайта в не зависимости от того, как он расположен на текстуре.
  Подсказка: чтобы в редакторе увидеть на спрайте оси поворота/перемещения именно в нулевой точке, а не в центре (по умолчанию), необходимо на элементе управления Transform Gizmo Toggles панели инструментов выбрать Pivot.

  

• textureCoords – текстурные координаты. Представляют собой координаты левого верхнего угла и размеры области на текстуре. Измеряются так же, как в OpenGL – в долях текстуры. Для каждой текстуры настраивается параметр, обозначающий будут ли координаты обрезаться при выходе из отрезка [0, 1], или текстура будет повторяться (параметр импорта текстуры Wrap Mode).
• pixelCorrect – булева величина, означает будет ли спрайт отображаться «пиксель в пиксель», чтобы каждому пикселю на спрайте соответствовал пиксель на экране.

Для отображения прямоугольника будем использовать объект класса Mesh. В самом простом случае он инициализируется:

1. списком вершин,
2. списком индексов вершин, составляющих вершины треугольников, из которых состоит прямоугольник,
3. списком соответствующих вершинам текстурных координат.

Учитывая параметры спрайта указанные выше, объект класса Mesh будем создавать так:

  private static Mesh CreateMesh(Vector2 size, Vector2 zero, Rect textureCoords)
  {
    var vertices = new[]
                       {
                         new Vector3(0, 0, 0),          // 1 ___  2
                         new Vector3(0, size.y, 0),     //   |  |
                         new Vector3(size.x, size.y, 0),//   |  |
                         new Vector3(size.x, 0, 0)      // 0 ---- 3
                       };

    Vector3 shift = Vector2.Scale(zero, size);
    for (int i = 0; i < vertices.Length; i++)
    {
      vertices[i] -= shift;
    }

    var uv = new[]
        {
          new Vector2(textureCoords.xMin, 1 - textureCoords.yMax),
          new Vector2(textureCoords.xMin, 1 - textureCoords.yMin),
          new Vector2(textureCoords.xMax, 1 - textureCoords.yMin),
          new Vector2(textureCoords.xMax, 1 - textureCoords.yMax)
        };

    var triangles = new[]
      {
        0, 1, 2,
        0, 2, 3
      };

    return new Mesh { vertices = vertices, uv = uv, triangles = triangles };
  }

Чтобы нарисовать меш, понадобятся компоненты MeshRenderer и MeshFilter. Первый компонент содержит ссылки на материалы текстур для спрайта. Второй из них содержит объект MeshFilter.mesh, который он и рисует. Для изменения спрайта нужно, соответственно, изменять этот объект. Сам спрайт реализуется через компонент SampleSprite. Для того чтобы у спрайта эти два компонента были всегда, добавим ему соответствующие атрибуты RequireComponent:

using UnityEngine;  
[ExecuteInEditMode]
[AddComponentMenu("Sprites/Sample Sprite")]
[RequireComponent (typeof(MeshFilter))]
[RequireComponent (typeof(MeshRenderer))]
public class SampleSprite : MonoBehaviour
{
 …
}

Атрибут AddComponentMenu добавляет в меню Component редактора пункт Sprites->Sample Sprite. Используя его можно добавить к любому объекту Unity наш компонент SampleSprite.

Для того чтобы можно было видеть спрайт во время редактирования, атрибут ExecuteInEditMode позволяет вызывать функции Awake и Start класса SampleSprite прямо в редакторе. Внутри этих функций создается меш:

  private MeshFilter meshFilter;
  private MeshRenderer meshRenderer;

  #region Unity messages

  // Use this for initialization
  private void Awake()
  {
    meshFilter = GetComponent<MeshFilter>();
    meshRenderer = GetComponent<MeshRenderer>();
  }

  private void Start()
  {
    // NOTE: initializing mesh here because our camera is initialized in Awake()
    InitializeMesh();
  }

  #endregion

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

  private void InitializeMesh()
  {
    Camera cam = Camera.main;
    if (pixelCorrect && cam != null)
    {
      float ratio = cam.pixelHeight / (2 * cam.orthographicSize);
      size.x = NonNormalizedTextureCoords.width * ratio;
      size.y = NonNormalizedTextureCoords.height * ratio;
    }
    meshFilter.mesh = CreateMesh(size, zero, textureCoords);
  }

NonNormalizedTextureCoords – текстурные координаты в пикселях. Определяются через нормализованные текстурные координаты (параметр спрайта) и размер самой текстуры TextureSize:

  private Rect NonNormalizedTextureCoords
  {
    get
    {
      Rect coords = textureCoords;
      Vector2 texSize = TextureSize;
      if (texSize != Vector2.zero)
      {
        coords.xMin *= texSize.x;
        coords.xMax *= texSize.x;
        coords.yMin *= texSize.y;
        coords.yMax *= texSize.y;
      }
      return coords;
    }
  }

  private Vector2 TextureSize
  {
    get
    {
      if (meshRenderer == null)
        return Vector2.zero;
      Material mat = meshRenderer.sharedMaterial;
      if (mat == null)
        return Vector2.zero;
      Texture tex = mat.mainTexture;
      if (tex == null)
        return Vector2.zero;
      return new Vector2(tex.width, tex.height);
    }
  }

Заметьте, что меш инициализируется в функции Start, потому что при его инициализации используется информация из камеры, а она инициализируется нами в Awake, т.е. в Start такая информация уже доступна для других объектов (в Unity сначала вызываются все Awake, затем все Start, но порядок вызова одной и той же функции для различных объектов не определён). Так же в этом примере используется Camera.main — главная камера на сцене. Т.е. наша камера должна быть помечена тегом MainCamera.

В принципе, на этом этапе со спрайтом уже можно работать. Для этого к любому объекту нужно прикрепить компонент SampleSprite (например, через меню Component или перетянув на него файл скрипта). Автоматически к нему добавятся компоненты MeshFilter и MeshRenderer. Теперь если перетянуть на этот объект материал текстуры (или текстуру, а материал создастся автоматически), и настроить параметры, то можно будет увидеть готовое 2d-изображение.

Настройка параметров текстуры

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

1. чтобы движение спрайта было плавным, чтобы при изменении размеров спрайт выглядел сглаженным, необходимо параметр экспорта текстуры Filter Mode установить в Bilinear или Trilinear);
2. установите Texture Type в значение GUI;
3. не забудьте убрать компрессию, установив значение параметра Format в Truecolor.

Освещение

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

1. В версии 3.3 есть группа шейдеров Unlit с отключенным освещением. Для спрайтов с прозрачностью подойдет шейдер Unlit->Transparent, для заднего фона Unlit->Texture.
2. В старых версиях Unity можно использовать шейдер Transparent->Diffuse. Но тогда надо не забыть в Edit->Render Settings проставить Ambient Light в белый, чтобы все спрайты были натурального цвета. Иначе они будут затемненными, потому что по умолчанию в качестве Ambient Light стоит оттенок серого.
3. Можно написать свой шейдер, в котором освещение будет отключено. О том, как это сделать, можно посмотреть в официальном пособии по шейдерам Unity.

Использование возможностей редактора

Unity позволяет расширить возможности редактора. Для этого используются, например:

1. Тег EditorOnly.
2. Создание редакторов игровых объектов в Инспекторе Компонентов путем наследования от класса Editor.
3. Создание окон редактора путем наследования от класса EditorWindow.

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

using UnityEditor;
using UnityEngine;

[CustomEditor(typeof(SampleSprite))]
public class SampleSpriteEditor : Editor
{
  public override void OnInspectorGUI()
  {
    Target.Size = EditorGUILayout.Vector2Field("Size", Target.Size);
    Target.Zero = EditorGUILayout.Vector2Field("Zero Point", Target.Zero);
    Target.TextureCoords = EditorGUILayout.RectField("Texture Coordinates", Target.TextureCoords);
    Target.PixelCorrect = EditorGUILayout.Toggle("Pixel Correct", Target.PixelCorrect);

    if (GUI.changed)
    {
      Target.UpdateMesh();
      EditorUtility.SetDirty(target);
    }
  }

  private SampleSprite Target
  {
    get { return target as SampleSprite; }
  }

  [MenuItem("Sprites/Create/Sample")]
  private static void CreateSprite()
  {
    var gameObject = new GameObject("New Sample Sprite");
    gameObject.AddComponent<SampleSprite>();
    Selection.activeObject = gameObject;
  }
}

Внимание: все скрипты, связанные с редактором, должны располагаться в папке Assets/Editor.

Атрибут CustomEditor говорит о том, что данный класс будет использован в Инспекторе Компонентов как редактор для класса-компонента SampleSprite. Свойство Target введено для удобства обращения к полям редактируемого объекта, т.к. выдаваемый по умолчанию объект target имеет тип Object. В переопределенной функции OnInspectorGUI задается список параметров компонента SampleSprite, отображаемых в Инспекторе. Если хоть один из этих параметров изменится (GUI.changed), спрайт обновится, и мы увидим результат изменения на экране, а также сохранятся измененные параметры спрайта (EditorUtility.SetDirty).

Редактируемые параметры добавим в класс SampleSprite и сделаем их условно-компилируемыми (чтобы этот код не попал в конечный продукт, а работал только в редакторе):

#if UNITY_EDITOR

  public Vector2 Size
  {
    get { return size; }
    set { size = value; }
  }

  public Vector2 Zero
  {
    get { return Vector2.Scale(zero, size); }
    set
    {
      if (size.x != 0 && size.y != 0)
      {
        zero = new Vector2(value.x / size.x, value.y / size.y);
      }
    }
  }

  public Rect TextureCoords
  {
    get { return NonNormalizedTextureCoords; }
    set
    {
      textureCoords = value;
      Vector2 texSize = TextureSize;
      if (texSize != Vector2.zero)
      {
        textureCoords.xMin /= texSize.x;
        textureCoords.xMax /= texSize.x;
        textureCoords.yMin /= texSize.y;
        textureCoords.yMax /= texSize.y;
      }
    }
  }

  public bool PixelCorrect
  {
    get { return pixelCorrect; }
    set { pixelCorrect = value; }
  }

  public void UpdateMesh()
  {
    InitializeMesh();
  }

#endif

В данном случае параметр Zero измеряется в тех же единицах, что и size, а TextureCoords – в пикселях текстуры.

Оптимизация, улучшения и прочее

Уменьшение числа Draw Calls

Есть несколько способов это сделать.

1. Static batching. Если объект никогда не изменяется, то его можно пометить как статический (галочка Static в Инспекторе). Все такие объекты будут объединены в один большой и будут рисоваться за один Draw Call. К сожалению, функция static batching доступна только в Pro-версии Unity.
2. Dynamic batching. Если несколько объектов используют один и тот же материал, Unity перед отрисовкой объединяет их в один, и все они будут рисоваться за один Draw Call. Для достижения этого эффекта текстуры необходимо объединять в атлас – одну большую текстуру. Используйте атласы – они позволяют сократить как количество Draw Call (за счет dynamic batching), так и объем памяти, занимаемой текстурами (что очень актуально для мобильных платформ).
   Подсказка: включение/отключение видов batching для некоторых платформ осуществляется в File->Build Settings->Player Settings.
3. Менеджер спрайтов. Одна из реализаций – SpriteManager. Спрайт добавляется в менеджер спрайтов, который использует одну текстуру-атлас (в компоненте MeshRenderer), и создает для спрайтов меш (в компоненте MeshFilter), состоящий из множества прямоугольников, по одному для каждого спрайта (к этой реализации автор прикрутил удобство редактора и получил SM2). Также улучшить менеджер спрайтов можно за счет задания спрайту ссылки на используемый материал, все материалы хранить в компоненте MeshRenderer менеджера спрайтов, а меш рисовать как совокупность более маленьких мешей (по одному на материал), пользуясь возможностями Mesh.CombineMeshes, Mesh.SetTriangles, Mesh.GetTriangles, Mesh.subMeshCount. Это позволит не заводить для каждого материала по менеджеру спрайтов.

Некоторые улучшения кода

1. Конечно, лучше избавится от постоянного вызова функции CreateMesh, который приводит к созданию нового меша (в данном случае это несущественно, т.к. все происходит в редакторе, а в реальном приложении спрайт будет создаваться один раз и больше не будет меняться). Вместо этого достаточно изменять параметры Mesh.vertices, Mesh.uv, Mesh.triangles. Не забывайте вызвать mesh.RecalculateBounds(), если был изменен массив вершин vertices. Если же изменен массив triangles, то эта функция вызовется автоматически.
2. Вместо Camera.main лучше задавать камеру как параметр скрипта.

Как делать анимации

Как делать полноценные спрайтовые анимации можно посмотреть на примере SpriteManager.
В нашей игре Papa Penguin спрайтовых анимаций не было. Вместо этого, например, пингвин скреплялся из частей по нулевым точкам спрайтов, а движение этих частей осуществлялось с помощью компонента Animation. Этого вполне хватило. В Unity это очень мощный инструмент. В анимацию, например, можно вставлять даже вызовы функций из скриптов.

2d-физика

К любому спрайту можно прикрепить компонент типа Collider: Component->Physics->BoxCollider для объектов прямоугольной формы и Component->Physics->SphereCollider для объектов сферической формы. Эти компоненты можно использовать в двух целях:

1. Сделать объект триггером (флажок Is Trigger).
2. Позволить объекту подвергаться физическим воздействиям. Для этого к объекту можно дополнительно прикрепить компонент Component->Physics->Rigidbody.

С помощью Rigidbody можно ограничить физику объекта двумя измерениями: в компоненте есть параметр Constraints. Нужно ограничить перемещение объекта по оси Z, поставив галочку на Rigidbody-> Constraints->Freeze Position->Z, и ограничить поворот по осям X и Y (Freeze Rotation->X и Freeze Rotation->Y).

Физика Unity3d предлагает также другие богатые возможности: силы, приложенные к определенным точкам объекта, гравитация, точки соединения (Fixed Joint, Spring Joint). Используя все это, можно создать неплохую игру, основанную на физике.

Альтернативы

1. EZSprite – простая платная система для создания 2d-анимаций в Unity (на момент написания статьи плагин стоил $35).
2. SpriteManager – система классов для создания спрайтовых анимаций. Поддерживает отрисовку спрайтов за один Draw Call, менеджер спрайтов, анимации и атласы. Довольно неудобен в настройке, но если бюджет ограничен, вполне пригоден для использования.
3. SM2 (Sprite Manager 2) – платный менеджер спрайтов с поддержкой редактора. Поддерживает множество полезных функций в дополнение к бесплатной версии: создание атласов, использование возможностей редактора для выделения области текстуры, автоматического создания анимаций и многое другое. Если не хочется реализовывать спрайты вручную, то SM2, на мой взгляд – самый лучший выбор. Стоит $150 с 60-дневной возможностью вернуть деньги назад, если не понравится.
4. RageSpline, $50. Этот плагин не совсем спрайтовый, а скорее векторный. Плагин обладает множеством интересных возможностей:
   • создание 2d-мешей и линий на основе кривых Безье;
   • контуры объектов различной ширины;
   • заливка одним цветом/градиент;
   • текстурированные объекты;
   • и многое другое.

Заключение

Всего того, о чем я написал, вполне хватит для написания своей 2d-системы и последующего ее использования при создании двухмерной игры. Трехмерность движка и поддержка физики предлагает нам новые богатые возможности, а высокая скорость разработки на Unity (что является большим плюсом движка) позволит сократить затраты.

P.S. Кому интересно, почитайте мои предыдущие посты: Игра за два дня и Как сделать промо-ролик игры малыми силами. Следующая моя статья будет про оптимизацию в Unity. При разработке игр под Unity я не раз сталкивался с необходимостью оптимизации и хочу с вами поделиться своим опытом в этом деле.