In this video, I'm going to look at using polymorphism on object oriented programming to make our application development simpler.

I'm going to demonstrate that through the use of a simple computer aided design like application.

But you may have noticed I'm not in my usual programming place.

Well, it shouldn't be a very surprised you that I'm actually full time employees.

And sometimes my job requires me to go out on the road and stay in delightful hotels such as this one.

Nobody ever said programming was glamorous.

I'm traveling around with work like this has completely ruined my YouTube schedule for the year.

So those of you expecting to see on update to the top down city based car crime game Well, I might take something on at the end of this video if I've got a couple of minutes to spare.

However, that's been delayed a week.

So this video, I thought, be useful to do something to enhance sort of the c++ basics, and we'll look at polymorphism a very useful technique.

Now I thought to be different.

Instead of using games to demonstrate polymorphism, I'm going to create a small application, a very simple can't package.

So here I've got a matrix of dots which the cursor can clamp to when we can see we've got some axes on the middle of these axes represents 00 in our world.

Now, if I press a particular key, I could start to draw a shape and we'll see to little red dots that allow me to manipulate the shape so that we've got to box on here.

I can draw some lines just for them around all over the place.

At the moment on, we can draw circles to see the radius is a line surrounding by circle shape.

There's some other nice features.

Two I can zoom in and pan around.

Now, of course, we've done panning and zooming before, so I won't go into too much detail about how I do that in this video.

And I can also place my cursor over any of the red dots and tweak the shakes positions.

Oh yeah, before I forget, there's one more shape to this is a multiple construction shape that gives us a spine.

We can define curvature very nice, and you might be thinking, Well, what's this got to do with polymorphism?

well, it's difficult to graphically show polymorphism, but here all of these shapes are effectively the same object to the code underneath.

Of course, the shapes a unique in that they are circles and squares and lines and SP lines.

But the code that will handle these shapes doesn't really know about that.

And it doesn't care either, which means making our application can be quite a simple process because instead of trying to handle all of these different shapes, uniquely will let polymorphism do it for us.

Now, some of you not familiar yet with polymorphism may already be thinking of ways to handle this.

We could have lots of objects for all the different types of shape on our applications that interrogates those objects one by one, depending on how it should be manipulated or drawn to the screen.

Perhaps another solution is to create one type of object, which is all of the objects and the object itself in self determined what to do in a given scenario.

Approaches like this are valid, but they can be a bit messy on we may as well use the tools C++ provides for us to do this on dhe the primary tool and what this video is, that is.

Polymorphism will engineer our code in such a way that the compiler can decide at runtime which methods to call, what shapes to draw and how things should look.

Now I will start by saying that Polymorphism is not a beginner topic, although the way I'm going to show it in this video, we're really only going to start looking at it that the most top level, object oriented programming and polymorphism is a really rich and detailed topic in its own right.

But you can achieve quite powerful things just by knowing the very basics for this video, I'm going to assume you do know a little bit about classes already on the low Polymorphism does exist in lots of different languages.

I'm going to be specifically looking at C plus plus.

Let's stop with a simple class in this case called A and A has a function called Do Something.

What's the Do?

Something Function does depends entirely on what Class A is.

Now I'm going to assume that we have a set of structures in our program that's all quite similar in nature.

I they have a lot of commonality between them, so I'm going to try and package that commonality up in class A to turn it into a base class.

This, of course, means Aiken derive from my base class, More classes.

In this instance, Class B Class B inherits all of the methods and attributes from class A, assuming that it can do to whatever access specifies we've determined are on those properties off class A.

But let's for now assume that everything is public and easily accessible.

If I create an object of type B and call the do something function, then that do something function is defined by the base class, eh?

I can, of course, override the do something function by simply redefining it in class B.

Now, if I create an object of type B and call the do something function, it will call this one instead.

And it goes without saying that if I create an object of type A and call to do something function, it will call this one.

Perhaps I have another derived class.

Class C.

Well, exactly the same thing applies.

This too, could have its own do something function.

So far, so good.

Nothing out of the ordinary.

But we started this with a particular caveat on We said that these classes that derive from Class A were in some way similar on we created Class A as a base class to encapsulate the common functionality between the two divide classes on in applications.

It's useful to group things that are similar together.

And so how can we do this if I create an object of type Class?

A.

It is very clearly defined, was big of type A.

Likewise, if I create an object of Type B, it is very clearly defined as being an object of tight be.

It is not an object of type A, even though be inherits from a it is defined as being be naturally.

The same also applies to an object of Type C.

When we want to group things that a similar in C++, we have several ways of doing this.

One approach is, of course, to use an array.

But whenever we specify an array, all of the elements of the array of the same type, perhaps we could use a vector.

But again the same problem applies.

We have to nominate a type for our vector in front.

Any of the standard containers will have the same restriction.

The convenient thing to do is to hint to the compiler that B and C are in fact derived from a on that our vector.

Honore only stores elements off type A.

Well, this is quite nice, and we're almost there.

But if I wanted to use a specific element of our vector of Type A and call our do something function as we saw before, it's going to call the do something function defined by Class A.

We've still not got the flexibility implied to look at the divide classes.

That's because all of our objects have Type A.

Instead, I'm going to do something that appears a little strange.

I'm going to create an object of type Class A.

But I'm not just going to create an object.

I'm going to create a pointer to the object.

So this means now when I'm creating a new object, I need to use the new key word or smart point to equivalent.

But now I can do something a bit special because B and C were derived from a on All I'm storing is a pointer to where a might reside in memory.

I can actually create a new object B and of course I can do exactly the same for my Class C type.

So now when I create my vector toe, hold my similar objects together, I'll make it hold some pointers to Class A and threw some smoke and mirrors implemented by the C++ compiler.

What we are implying here is that if classes B or C override a method in class A, then if we were to call such a method in this case, our do something method that it will call the appropriate method related to the class that was constructed.

And that's quite a complex and powerful thing.

I can now store in a single container, a group of similar objects that all have unique functionality but a common interface in effect, we have allowed the base class A to morph into multiple subclass is a polymorphism.

We have eliminated the need to manually check what the type of each object is on.

Dhe perform.

The required functionality were requesting at that point in time, but it's not quite a simpler is.

I've just made it out to be we need to hint to the compiler which functions were likely to be overriding.

Here is a very simple class definition for type A.

We can see I've got the void do something method.

That's the one we've been trying to override with our sub classes.

If hours before, we just directly called the do something method on the object stored in our vector, regardless of whether that object was of type B or C, it would still call the do something method related to class A.

We need to tell the compiler that do something is a candidate to be overwritten by a base class on.

We can do that with the virtual keyword.

This hints to the compiler that I may be overwritten if I'm not overridden than any call to the do something function will naturally be implemented by the base class, eh?

Whatever code is written here, so if it is overwritten, it'll executes the overwritten code.

But if no override is provided, it will execute this default code and this one last philosophical thing to think about it, it may be the case that class A on its own doesn't make sense.

The sense only comes into it.

Once something has been derived from Class A i e.

We've created classes B and C, in which case Class A is really just an interface to its sub classes on its own.

It can't do anything useful on We'll see an example of that in this video.

Well, instead of providing some default code that doesn't do anything and to force the programmer to provide an implementation when anything derives from this class, we can tell the compiler that this class is an abstract encapsulation by defining our virtual method here as being pure, and you can't create an instance oven abstract class.

So if anybody now tries to create an instance of Type A, it will fail and throw an error to the programmer because no implementation of this function exists, even though something potentially can call it.

And so this is a very powerful and useful way off wrapping up your program structure.

Now I appreciate to some of you this may all seem incredibly alien, but don't worry.

I think the example code that's coming up really shows the power of this in a nice way.

So let's briefly take a look at the class structure for the cat program.

I demonstrated at the start.

I have a base structure called s shape and from that basic structure, I derive unique classes that represents the shapes that I have.

So a line, a box, a circle on a curve.

All of these things are indeed shapes, so it's very useful to recognize them as a singular shape.

But they look differently.

So I want each of these classes lined, box circling curve to be responsible for drawing itself.

So they will all have a method draw which draws it to the screen.

So it seems that draw is a great method to be phone into the base class.

The shapes are fundamentally defined by nodes.

Points in two D.

Space on the curve is but the oddball one here as it's defined by three points in space.

So all of my shapes are also going to have a common vector off type s node.

A simple structure on our node will contain the X and Y position of its location in space on a pointer to its parent.

And this is so when we select a node later on, we can immediately get access to what shape is it connected to a valid thing to shout out here would be.

But damn it, we're talking about object oriented programming.

Why are we not using classes?

Well, classes and strokes to the C++ compiler are absolutely identical, except for one thing.

And that is the default access method for a stroke.

All properties and methods.

Well, they're public.

And for a class, they're all private.

And so it really doesn't matter unless you're an object oriented programming enthusiast.

Naturally, I'm going to start by using a skeleton OLC pixel game engine program.

And if you've not heard of the pixel game engine, it's a very simple technology that I've created that allows you to draw things to the screen quite quickly and simply.

And I'm going to construct a pixel game engine quite a high definition.

One unusually.

This case is going to be 1600 pixels by 960 pixels, and there's going to be a 1 to 1 relationship between pixel game, engine pixels and screen pixels.

I have my traditional on user create an unused update functions on right now.

All on usurped it does is grab the mouse coordinates on the screen and stores them as a floating 10.2 d vector you saw in the preview at the start of the video that we can pan and zoom around the screen on.

I've already got a video.

It's just about this topic, so I'm not going to go into very much detail here.

In fact, I'm just going to bring that coded Onda converted to use our new vector type that we added in the last video.

I've also added a couple of other features to the pixel game engine, including the ability to draw dashed lines which will will see a little later on on that long last mouse wheel support.

The first thing I'm going to do is set this up to enable the panning and zooming and drawing of the axis in the world on.

None of this is new stuff.

In fact, I've done a video precisely about this topic, which you can click in the little Linka both but to facilitate panning and zooming, we need to store some world transformation variables on for this video.

I will be going quite quickly through this.

I've created numeric vectors that stole the position of the offset on DTH e start pound location.

We also need a variable toe handle the scale for the world transformation.

Finally, I'm adding a variable called grid on.

This is the spacing in world space between points that we're going to see on the screen, so all of my points are going to be one apart now.

Panning and zooming is all about transforming things from world space to screen space.

So the first functional at directly copied from the panning and zooming video and modified to suit the new floating point vector type is world to screen that takes in a vector in world space and gives me to screen coordinates as an output.

We also want the inverse of that screen toe world.

I'm going to set the default offset for our panning parameters to be the middle off this screen width and height.

So that puts 00 in world space in the middle of the screen.

Everything else is now calculated per frame in on user update.

Once I've got the mouse cord, it I'm going to enable zooming by scrolling the wheel but panning by holding down the mouse wheel and moving the mouse so I want to be sensitive to the mouse wheel being pressed, and that's going to store the start pan location.