If you love games and want to learn how to make them, then this course will start you down that path. Making games is a creative and technical art form. In this course you will familiarize yourself with the tools and practices of game development. You will get started developing your own videogames using the industry standard game development tools, including the Unity3D game engine and C#. At the end of the course you will have completed three hands-on projects and will be able to leverage an array of game development techniques to create your own basic games. This course is for individuals interested in becoming a game designer, game artist, or game programmer.
Cameras
Loading...
Из курса от партнера Michigan State University
Introduction to Game Development
2864 оценки
Из урока
Intro to Unity3D Development
One of the reasons we use Unity3D is its visual editor which makes creating interactive games accessible to both creative and technical individuals. In this module, you will create your first Unity3D project from start to finish. Using a variety of graphical and audio assets and a library of scripts, you will create a simple model of our solar system. By the end of the module, you should have a good understanding of the Unity3D editor and the workflow for creating games.
Познакомьтесь с преподавателями
Brian WinnAssociate Professor
Media and Information
[MUSIC]
>> In this video, we'll get a better understanding of the different types of
cameras and their uses in Unity.
In some regards a 3D camera can be viewed conceptually like a real camera,
to set up your shot you need to position the camera properly and rotate it so
it's pointing at what you want to see.
But the differences really stop there.
With traditional lens camera light passes though the lens,
projected onto a flat piece of photosensitive film or CCDs.
You can focus the lens for different depth of field effects.
You can also change out the lens for different effects like telephoto,
wide angle, fisheye, and so-forth.
In a game engine, the camera really is just a projection
of the 3D geometry onto a 2D plane of the display.
You can simulate lens effects like focus, lens flare, and fisheye, but
they are processor-intensive to do so.
There's two different types of 3D projections you can create within your
game, perspective and orthographic.
The perspective projection is most like a real camera, or really,
how we see the world.
This is most commonly used in first person and third person games.
Objects that are closer to the camera are larger than the same size
objects that are farther away from the camera.
Orthographic projections do nor really exist in the real world.
The computer maintains the same relative size of the object,
no matter how close or how far away it is from the camera.
Common uses of orthographic cameras include top-down or
isometric views on games.
The view frustum determines what is rendered in the display.
The perspective camera has a pyramid view frustum with a narrow field of view
close to the camera, and a wider field of view farther away from the camera.
As an object moves close to the camera it will appear larger, or closer.
The camera renders everything between the near clipping plane and
the far clipping plane.
If objects move closer than the near clipping plane they are not rendered.
If objects move farther away than the far clipping plane, similarly,
they're not rendered.
The orthographic camera has a rectangular view frustum
with a constant field of view or orthographic size throughout.
Objects, no matter where they are in front of the camera,
will appear the same size relative to other objects.
The same concepts apply in terms of near and far clipping planes
with orthographic cameras as they do with a perspective camera.
Our objectives in our project for this video are to understand some of the camera
settings, make the perspective camera controllable, and
add a mini-map through the use of a second orthographic camera.
So the first thing I want to do is just play around with my main camera a little
bit to further demonstrate some of the concepts we just spoke about.
So let me click on my Main Camera.
You know it is a perspective camera, perspective projection.
And actually, as we look out in our scene,
you can actually see that view frustum sort of visually represented there.
And as I'm playing with things like Field of View here, the default is 60.
Let me just make that wider, you can see how it's effecting the game world,
it's simulating like a fish eye sort of view.
And then if I go the other direction it's like a zooming in, but really it's not
moving the camera, it's just changing the field of view, changing that projection.
So we'll go back to 60, which is the default.
The other thing to look at is the clipping plane, so
the clipping plane is actually set here.
Basically this is saying at 0.3 meters things will no longer be rendered,
and at 1000 meters things will go off the far clipping plane.
1000 is pretty far.
If I bring this back let's say to something like 4,
you can see the clipping plane is just beyond the Earth now.
And if I actually play this, sorry,
just beyond the Sun, I believe the Earth will actually disappear.
Yeah.
You can see it disappear there then it'll reappear on the other side.
[COUGH] So that's going sort of out of the far clipping plane.
And depending on the location of my camera,
if it's too close, the object may come on the inside of the near clipping plane and
then essentially kinda cut through the camera.
And I'm sure everyone has seen that in games today.
So 4 is probably too small.
Let me go ahead and set this at something like 20 meters.
So everything will be likely rendered in my display here.
But that's something that you can always adjust to optimize your project.
If it's rendering too big of a view frustum with objects
way out in the distance, it may affect performance.
So by making that a little bit tighter things will play back better,
depending on the platform that we're playing on.
So really, we didn't really change much there.
I just wanted to kinda show some of those concepts related to
the perspective projection, the field of view and the near and far clipping plane.
So the next thing I wanna do is actually create another camera in my world.
So I'm gonna go ahead and go up to GameObject and create a camera.
And this camera just got created kind of out in my world.
You can see that my game view actually changed, it sort of switched to that new
camera that was just created, which is fine for purposes of example.
My camera isn't really where I wanna have it.
So one thing I could do is actually go to this main camera and see where that is.
And under GameObject, I can select Align View to Selected.
So what that's gonna do is align my scene view to the selected game object,
which in this case is a camera.
So this will show, in essence,
what we were seeing out of the main camera previous.
So now that we have that, let me go to the new camera and select it, and
then go to GameObject > Align With View, so
this is gonna move the GameObject to be aligned with the view.
So in essence it's gonna put this camera really right on top
of the previous camera.
So they're both really right on top of the same spot.
And let me go ahead and rename this camera to, I'm gonna
call it my Minimap Camera, because I'm gonna use this camera to create a minimap.
And let's go ahead and look at some of the properties here.
The first thing is that it also has an audio listener, and really,
you can only have one audio listener turned on at a time in Unity.
And if you have multiple, it will throw a warning message and Unity will
sort of pick one of those audio listeners, which may not be the one you want.
So I"m gonna go ahead and turn off this audio listener.
I could even just remove the audio listener component, but
I'll just turn it off, that's fine.
The other thing I want to do is change the projection.
So rather than a perspective let's go and pick orthographic.
And the orthographic projection you can see my game view just changed.
If I play, for
purposes of example, you can see if I go in a top down view over here.
Let me move to the Sun by hitting F.
But you can see the Earth is of course rotating around the Sun and
the Moon rotating around it.
But down here in the game view, since it's orthographic, the size of the Earth and
the size of the Moon do not change as it's moving around the Sun.
So that's the big difference, the same relative size of the objects
is maintained consistent with the orthographic projection.
So let me go back to the minimap here.
And really what I wanna do is I don't want to have the same view as the main camera.
I actually wanna have a top-down view on my world.
So over here in my scene, I'm in the top view, I can switch in and
out of it, and I can zoom in and zoom out to kinda get the orientation that I want.
I've got my MinimapCamera selected, and
once again, under GameObject, I could say Align With View.
And now, if I press play, you can see I've got top down view on my game world,
the Earth is rotating around the sun there.
So that's what I wanted.
But in reality, I want to have both of my cameras playing at the same time.
And in fact, they are.
They're just sort of layered on top of each other right now, so I'm not really
seeing the main camera because the minimap camera is overlaying that.
And that's really set here as the depth.
So my depth of this camera is zero.
If I go back to my main camera it's -1.
So if I change this, and let's make this a depth of 1,
you can see now it just switched back to the perspective camera cuz the higher
the depth number, that's what's gonna be rendered on top.
But we can leave this at -1, and
go back to the minimap camera, which is a depth of 0.
Because really we want these both to be rendered at the same time.
So the way I'm gonna do that is I'm gonna modify this View Rect property.
So right now the width and the height is 1, which is 100% of the screen.
I'm gonna change this to 0.25 and 0.25.
And you can see down in the corner now of my game view,
I can see that minimap camera.
And then the main area is the main camera.
So if I press play now,
[SOUND] everything is essentially rendered.
But it looks a little funny because I've got the sky box down here, or
really it doesn't look funny it just is hard to see.
So let me modify one other property.
So you can see where it says Clear Flags here and it says Skybox.
You know that's basically saying it's gonna render the Skybox.
Let me switch this to solid color, and now it's on a blue background.
And I can change that color of course by clicking the background and
make it whatever color I want.
I'll keep it as kind of a dark blue.
And now when I press play we can see the sun and
we can see the Earth rotating.
It is a little bit hard to see the Earth,
part of that is the size of my projection maybe is a little bit high.
In essence it's kind of like being zoomed out, so let me change the size and
make it little bit smaller.
Maybe make it 3, and hit play again.
And now it's a little bit easier to see the Sun and the Moon and the Earth.
The last thing that I wanna do is I wanna make my camera controllable.
Not the minimap camera but actually the main camera.
In essence, what I wanna be able to do is I wanna be able to click on the various
planetary bodies, the game objects, and have the camera look at them.
So first, we could do this with scripting.
Anything that's interactive, we often do with scripting.
And we've got two scripts to do this.
We've got a ChangeLookAt and a LookAtTarget.
So, the LookAtTarget is a script that's meant to be placed on the main camera.
So let me go ahead and drag and drop that onto the main camera.
So now it has the LookAtTarget script or component attached to the main camera.
And the ChangeLookAtTarget is
the script that we place on all the game objects that we wanna be able to click on.
So, what this does is it essentially responds to a mouse event,
a mouse down event, on the game object and resets the target of that other script.
So, let's go ahead and put the ChangeLookAt script on the Sun.
Put it on the Earth and even put it on the Moon.
Okay. So if I go back and
look at each of those game objects,
it should now have that ChangeLookAtTarget script or component attached.
So if I go ahead and play again,
[MUSIC]
If I click on the Earth now the main camera,
if I zoom out here a little bit and select the main camera,
you can see the main camera is stationary but it's rotating so
it's constantly looking at whichever game objects I've last clicked on.
So if I click on the Sun, as it comes by here, now I'm looking at the Sun.
It might be a little bit hard to do, but
I can even click on the Moon as it comes by here and get's a little bit bigger.
There's the Earth and there's the Moon.
So now I'm targeting the Moon as it's coming around.
And since I've got two cameras I can even click on the minimap.
So if I click on the Sun on the minimap, that's a quick way to kind of reset
that main camera to be targeting on the Sun once again.
And I can click on the Earth.
It's probably a little hard to click on the Moon since it's so
small within the minimap.
So anyways we've played a little bit with the perspective camera.
We've added an orthographic camera and essentially made that our minimap, and
we've made the main camera control.
In the next video, we'll discuss how to build and deploy our Unity projects.
[MUSIC]
Ознакомьтесь с нашим каталогом
Присоединяйтесь бесплатно и получайте персонализированные рекомендации, обновления и предложения.
Coursera делает лучшее в мире образование доступным каждому, предлагая онлайн-курсы от ведущих университетов и организаций.
© Coursera Inc., 2018 Все права защищены.
