Hey look guys my name is China welcome 嗨，大家好，我叫中国，欢迎回到我的游戏引擎系列，最后
back to my game engine series so last 嗨，大家好，我叫中国，欢迎回到我的游戏引擎系列，最后
time we took a look at setting up remake 我们来看一下在项目的构建系统上进行重制的过程
for up on a build system our project 我们来看一下在项目的构建系统上进行重制的过程
generation system make sure you check 生成系统，请确保您已签出该视频（如果尚未下载）
out that video if you haven't already 生成系统，请确保您已签出该视频（如果尚未下载）
and today we're gonna have a good old 今天我们将要进行一次很好的老式计划会议
fashioned kind of planning session in 今天我们将要进行一次很好的老式计划会议
which we plan what we're going to do 我们计划接下来要做什么
next which is going to be to kind of 我们计划接下来要做什么
create an event system for our engine so 为引擎创建一个事件系统，以便我们处理窗口事件
that we can deal with window events that 为引擎创建一个事件系统，以便我们处理窗口事件
we will have to receive questions you 我们将收到您知道窗户被关闭的问题
know the window being closed the window 我们将收到您知道窗户被关闭的问题
being resized input events such as Mouse 调整输入事件的大小，例如每当填充事件时发生键盘事件的Mouse事件
events of keyboard events whenever stuff 调整输入事件的大小，例如每当填充事件时发生键盘事件的Mouse事件
like that happens in our engine we want 像我们引擎中发生的那样，我们希望我们的应用程序能够有所了解
our application to kind of become aware 像我们引擎中发生的那样，我们希望我们的应用程序能够有所了解
of it and have a chance to handle it and 并有机会处理它，而基本上让哈扎尔知道
just basically have hazal be aware that 并有机会处理它，而基本上让哈扎尔知道
things are happening to it so that's 事情正在发生，所以今天就是这样
what today is going to kind of be about 事情正在发生，所以今天就是这样
first of all I just want to thank all 首先，我只想感谢所有制作此系列作品的顾客
the patrons that make this series 首先，我只想感谢所有制作此系列作品的顾客
possible if you guys aren't supporting 如果你们不支持这个系列的话，可以去
the series you can go to 如果你们不支持这个系列的话，可以去
patreon.com/scishow the Cherno you'll patreon.com/scishow切尔​​诺，您也将提前一周获得这些视频
get these videos one week early as well patreon.com/scishow切尔​​诺，您也将提前一周获得这些视频
as access to a private development broth 作为访问私人开发肉汤早午餐的途径，我们将在其中进行一切
brunch in which everything we're going 作为访问私人开发肉汤早午餐的途径，我们将在其中进行一切
to talk about today and many episodes in 谈论今天以及未来的许多情节已经写好了，
the future is already written and 谈论今天以及未来的许多情节已经写好了，
obviously it just helps the board the 显然，这对登上该系列很有帮助，这就是为什么这些视频
series and that's why these videos are 显然，这对登上该系列很有帮助，这就是为什么这些视频
here for everyone else so huge thank you 这里对其他所有人都非常感谢，一如既往地感谢大家，所以活动
to everyone as always okay so event 这里对其他所有人都非常感谢，一如既往地感谢大家，所以活动
systems let's talk about this this is 系统，让我们谈谈这是我最喜欢写的东西之一
one of my favorite things to write just 系统，让我们谈谈这是我最喜欢写的东西之一
because it's it's quite the way it links 因为这是链接在一起的方式，非常令人满意，而且
together is quite satisfying and it's 因为这是链接在一起的方式，非常令人满意，而且
just it's just something that does need 就像过去一样，这确实是需要做的事情
to be done sometime like in the past I 就像过去一样，这确实是需要做的事情
used to maybe write like a whole Windows 以前可能先像整个Windows系统一样编写，然后再处理事件
system first and then deal with events 以前可能先像整个Windows系统一样编写，然后再处理事件
but it's just there's no point in doing 但这完全没有意义，您最好还是参加这次活动
that you might as well get the event 但这完全没有意义，您最好还是参加这次活动
system done so that when you get get to 系统完成，以便当您到达实际编写您的代码的地步时
the point of actually writing your 系统完成，以便当您到达实际编写您的代码的地步时
window you can already kind of dispatch 窗口，您已经可以调度所有事件，而所有事情都将
all your events and everything will just 窗口，您已经可以调度所有事件，而所有事情都将
work and everything is gonna be great 工作，一切都会很棒，因为您可以不用编写它
because kind of you can write it with no 工作，一切都会很棒，因为您可以不用编写它
system an entire renderer without even 系统整个渲染器，甚至根本不处理任何事件，但随后
dealing with events at all but then as 系统整个渲染器，甚至根本不处理任何事件，但随后
soon as you start saying that I want a 当您开始说我想要一台可以使用
camera that I can move around using the 当您开始说我想要一台可以使用
mouse and keyboard or whatever you start 鼠标和键盘或其他类似的东西哦，好吧，您知道要这样做
being like oh well you know to do this 鼠标和键盘或其他类似的东西哦，好吧，您知道要这样做
properly I have to spend like a while 正确地，我现在要花一些时间来编写整个事件系统，所以
now writing a whole event system so 正确地，我现在要花一些时间来编写整个事件系统，所以
we're gonna get all that out of the way 我们将立即解决所有问题，然后
kind of immediately so that would then 我们将立即解决所有问题，然后
when we actually do build up a window we 当我们实际建立一个窗口时，我们可以非常轻松地处理所有事情
can deal with everything really easily 当我们实际建立一个窗口时，我们可以非常轻松地处理所有事情
so I'm gonna go to the drawing board and 所以我要去做画板，看看到底是怎么回事
see exactly how all this is going to 所以我要去做画板，看看到底是怎么回事
together okay so at the moment we have 一起好吧，所以目前我们有一个叫做应用程序的东西
something it's called an application 一起好吧，所以目前我们有一个叫做应用程序的东西
this is that kind of application class 这是那种应用程序类，它确实像我们的中心
which is kind of like our central really 这是那种应用程序类，它确实像我们的中心
class for a lot of things I mean 课堂上有很多事情，我的意思主要是这是一个
primarily this is kind of a 课堂上有很多事情，我的意思主要是这是一个
representation of our actual hazal 代表我们实际的危险应用的重要性
application like in terms of important 代表我们实际的危险应用的重要性
things it contains I mean the run loop 它包含的东西我是说运行循环可能是最大的事情之一
is probably one of the biggest things 它包含的东西我是说运行循环可能是最大的事情之一
which means that essentially it contains 这意味着它实际上包含了使一切保持运行的循环
the loop that keeps everything running 这意味着它实际上包含了使一切保持运行的循环
and keeps updating kind of our game all 并一直在不断更新我们的游戏类型，但这也是中心
the time but also this being the central 并一直在不断更新我们的游戏类型，但这也是中心
kind of hub for things it also needs to 作为事物的枢纽，它还需要能够接收事件，以便
be able to receive events so that 作为事物的枢纽，它还需要能够接收事件，以便
dispatch them eventually to something 最终将它们分派到一个称为第二层的东西
called a layer two all the layers in our 最终将它们分派到一个称为第二层的东西
games now layers are something that 现在的游戏层是我们以后会谈论的话题，所以我
we'll talk about in the future so I 现在的游戏层是我们以后会谈论的话题，所以我
won't mention them too much because 不会过多地提及他们，因为我们将在此单独录制视频，并且
we'll have a separate video on that and 不会过多地提及他们，因为我们将在此单独录制视频，并且
also they're not really a hundred 也不是这种应付能力真正需要的百分之一百
percent required by this cope of what 也不是这种应付能力真正需要的百分之一百
we're gonna be implementing in terms of 我们将根据该事件系统进行实施，因此他们只是
this event system so they're just 我们将根据该事件系统进行实施，因此他们只是
summing for the future but just know 总结未来，但只知道那种应用程序会
that kind of the application will 总结未来，但只知道那种应用程序会
eventually propagate events to layers so 最终将事件传播到层，以便它们可以处理
that they can kind of deal with that 最终将事件传播到层，以便它们可以处理
sort in terms of our application there 根据我们的应用程序排序，我们有一个应用程序需要
we have an application this needs to be 根据我们的应用程序排序，我们有一个应用程序需要
able to receive events so how does all 能够接收事件，因此自从我们
of that work well since both since we're 能够接收事件，因此自从我们
specifically talking about window events 专门讨论窗口事件，让我们来画一些窗口
let's kind of draw a little window klass 专门讨论窗口事件，让我们来画一些窗口
that we might have here and then see how 我们可能会在这里，然后看看该沟通将如何进行，以便
that communication is going to work so 我们可能会在这里，然后看看该沟通将如何进行，以便
our window class is a representation of 我们的窗口类代表了我们实际构成的窗口
our actual window that kind of makes up 我们的窗口类代表了我们实际构成的窗口
our application so this is literally 我们的应用程序，所以从字面上就像您知道Windows的窗口一样
like you know windows kind of window 我们的应用程序，所以从字面上就像您知道Windows的窗口一样
with a Kotaro bar and like you know we 用Kotaro棒，就像您知道的那样，我们可能会喜欢三角形渲染
might have like the triangle rendering 用Kotaro棒，就像您知道的那样，我们可能会喜欢三角形渲染
and all that stuff over here and every 以及这里的所有东西以及每次我们在此窗口中收到事件时
time we receive events in this window 以及这里的所有东西以及每次我们在此窗口中收到事件时
whether it be kind of the fact that a 是否确实有人调整了尺寸，
resize has taken place someone's hit the 是否确实有人调整了尺寸，
close button we have kind of mouse move 关闭按钮，我们有某种鼠标移动事件或其他任何东西
events or whatever and all that stuff 关闭按钮，我们有某种鼠标移动事件或其他任何东西
whenever that stuff happens and you know 每当这些事情发生时，无论何时，您都知道键盘事件
keyboard events whatever all that when 每当这些事情发生时，无论何时，您都知道键盘事件
all that stuff happens our kind of 所有这些事情都会发生在我们的窗口库或win32 API上
windowing library or just the win32 API 所有这些事情都会发生在我们的窗口库或win32 API上
or whatever we're using will receive an 或我们正在使用的任何东西都会收到一个事件，然后一旦该事件发生
event and then once that event happens 或我们正在使用的任何东西都会收到一个事件，然后一旦该事件发生
inside that window class we need a way 在该窗口类中，我们需要一种将其传达回
of communicating that back to 在该窗口类中，我们需要一种将其传达回
application but guess what we don't 应用程序，但是猜猜我们实际上并不想绑定我们的应用程序
actually want to tie our application 应用程序，但是猜猜我们实际上并不想绑定我们的应用程序
to the window class so the winter class 到窗口类，所以冬季类不应该知道我们的应用程序
should not be aware of our application 到窗口类，所以冬季类不应该知道我们的应用程序
class at all the application class kind 所有应用程序类都会创建一个冬天，所以它是
of creates a winter right so it's 所有应用程序类都会创建一个冬天，所以它是
clearly kind of aware of that right but 显然知道这项权利，但我实际上不希望参加冬季班
I don't want the winter class actually 显然知道这项权利，但我实际上不希望参加冬季班
having any knowledge of application 掌握应用程序方面的任何知识，但实际上并不是应该链接的地方
that's not really a link that should 掌握应用程序方面的任何知识，但实际上并不是应该链接的地方
exist so what we need to do actually is 存在，所以我们实际上需要做的是为某种
create some kind of method for kind of 存在，所以我们实际上需要做的是为某种
messaging back all of these events to 将所有这些事件发送回应用程序到应用程序可以
the application to the application can 将所有这些事件发送回应用程序到应用程序可以
kind of deal with them and because the 与它们打交道，并且由于应用程序创建了一个窗口，因此它具有
application creates a window it has the 与它们打交道，并且由于应用程序创建了一个窗口，因此它具有
ability obviously to kind of set up all 很显然，能够建立所有这类消息系统的能力如此之久
of that kind of messaging system so long 很显然，能够建立所有这类消息系统的能力如此之久
story short this is what happens when an 简而言之，这是当我们的实际窗口内发生事件时发生的情况
event occurs inside our actual window 简而言之，这是当我们的实际窗口内发生事件时发生的情况
this window class will receive an event 该窗口类将收到一个事件回调权，然后执行该操作
callback right and then what it has to 该窗口类将收到一个事件回调权，然后执行该操作
do is construct essentially a hazal 要做的是构造一个本质上的危险事件，然后以某种方式传播回去
event and then somehow propagated back 要做的是构造一个本质上的危险事件，然后以某种方式传播回去
to application okay 到应用程序好吧，让我们来谈谈它的细节
so let's talk about the details of that 到应用程序好吧，让我们来谈谈它的细节
so first of all hazel event right what 所以首先淡褐色事件对吧，我们需要什么，我们需要某种
do we need well we need some kind of 所以首先淡褐色事件对吧，我们需要什么，我们需要某种
event class right an event system really 事件类对一个事件系统来说确实正确，其中包含所有必需的详细信息
which contains all the details required 事件类对一个事件系统来说确实正确，其中包含所有必需的详细信息
by an event that has occurred so a mouse 由于发生了一个事件，所以鼠标右键单击我刚刚移动了鼠标，
click right I've just moved my mouse and 由于发生了一个事件，所以鼠标右键单击我刚刚移动了鼠标，
I've clicked it over here what kind of 我在这里单击了它，我们需要什么类型的信息呢？
information do we need well we 我在这里单击了它，我们需要什么类型的信息呢？
definitely need kind of the X&Y position 肯定需要那种点击的X＆Y位置以及哪个按钮
of that click as well as which button 肯定需要那种点击的X＆Y位置以及哪个按钮
was pressed right and then what we can 向右按，然后创建我们可以处理的信息
do with that information is create 向右按，然后创建我们可以处理的信息
something called a mouse button pressed 所谓的鼠标按下事件，我肯定会去
event which I'm definitely going to 所谓的鼠标按下事件，我肯定会去
write out but we create a mouse button 写出来，但我们创建了一个鼠标按钮按下事件，它实际上是
pressed event right which is essentially 写出来，但我们创建了一个鼠标按钮按下事件，它实际上是
just a struct which contains this 只是一个包含此位置和此按钮的结构，一旦我们完成
position and this button and once we've 只是一个包含此位置和此按钮的结构，一旦我们完成
created that which is kind of our own 创建的是我们自己的自定义数据类型，我们需要一种方法来
custom data type we need a way to 创建的是我们自己的自定义数据类型，我们需要一种方法来
actually send that data over to 实际将数据发送到应用程序，以便我们
application so that so we kind of 实际将数据发送到应用程序，以便我们
everything kind of ties back to that 各种联系回到该链接，以及它如何正常运行，我们不希望
link and how it works well we don't want 各种联系回到该链接，以及它如何正常运行，我们不希望
window to actually hold like an 实际上像应用程序点之类的窗口
application point or something like that 实际上像应用程序点之类的窗口
but instead what we want to do is 但实际上我们想要做的是为
essentially give the opportunity for 但实际上我们想要做的是为
this application to provide window with 这个应用程序为窗口提供回调现在这可能是
a callback now this could be something 这个应用程序为窗口提供回调现在这可能是
as simple as just a function pointer in 就像一个函数指针一样简单，实际上我们首先要处理
fact we kind of deal with that first to 就像一个函数指针一样简单，实际上我们首先要处理
begin with and then we can 首先，然后我们可以以更抽象的方式巧妙地处理
more abstract ways of deftly dealing 首先，然后我们可以以更抽象的方式巧妙地处理
with this but essentially what happens 这样，但实际上发生的是当我们从我们的窗口创建一个窗口时
is when we create a window from our 这样，但实际上发生的是当我们从我们的窗口创建一个窗口时
application class we're also going to 我们还将创建应用程序类，还将设置一个
create we're also going to set a 我们还将创建应用程序类，还将设置一个
callback to that window class an event 回调到该窗口类的事件回调，以便每次此窗口
callback so that every time this window 回调到该窗口类的事件回调，以便每次此窗口
gets an event it can check to see if the 得到一个事件，它可以检查回调是否存在
callback is present rights of the 得到一个事件，它可以检查回调是否存在
callback isn't null and if the callback 回调不为null，如果回调不为null，则将调用该回调
isn't null is going to call the callback 回调不为null，如果回调不为null，则将调用该回调
with this event data okay and then since 有了这个事件数据就可以了，然后因为基本上应用程序会有一个
basically application will have a 有了这个事件数据就可以了，然后因为基本上应用程序会有一个
function called on event which might you 在事件上调用的函数，您可能会知道该事件类似事件
know take in something like an event 在事件上调用的函数，您可能会知道该事件类似事件
reference right it's going to call this 参考权，它将从窗口调用此函数，所以窗口
function from window okay so window 参考权，它将从窗口调用此函数，所以窗口
doesn't actually know about application 实际上不了解应用程序，但是如果我们设置了回调窗口，
but if we set a callback window does 实际上不了解应用程序，但是如果我们设置了回调窗口，
know about this function and so window 了解此功能，因此窗口将以这种方式调用此功能
will call this function with this kind 了解此功能，因此窗口将以这种方式调用此功能
of data in a suddenly application which 具有非事件功能和自身事件的突然应用程序中的数据收集
has a non event function and own event 具有非事件功能和自身事件的突然应用程序中的数据收集
method on itself right this will get 本身的方法会变冷
cold 本身的方法会变冷
with all the event data now this is kind 现在有了所有事件数据，这有点像阻塞
of something known as like a blocking 现在有了所有事件数据，这有点像阻塞
event so the reason that kind of is the 事件，之所以如此，是因为你知道我们什么时候做
case is because you know when we do 事件，之所以如此，是因为你知道我们什么时候做
receive that Mouse event that mouse 接收鼠标事件，鼠标按钮按下事件，我们构造它
button pressed event we construct it 接收鼠标事件，鼠标按钮按下事件，我们构造它
probably on the stack right there and 可能在堆栈上，然后我们立即调用此函数
then we immediately call this function 可能在堆栈上，然后我们立即调用此函数
so it's not it kind of you know pauses 所以不是这样，您知道我们在处理所有其他事件时会暂停
all the other events while we deal with 所以不是这样，您知道我们在处理所有其他事件时会暂停
this event and so that's why it's kind 该事件，因此这就是为什么现在将其称为“阻止事件”的原因
of called a blocking event now in the 该事件，因此这就是为什么现在将其称为“阻止事件”的原因
future you could create something like a 将来您可以创建类似缓冲事件系统的系统
buffered event system which basically 将来您可以创建类似缓冲事件系统的系统
says that it kind of you know grabs this 说您有点了解，它将信息队列存储在数据中
information queues it stores the data 说您有点了解，它将信息队列存储在数据中
elsewhere 在其他地方进行其他事件，然后也许
proceeds to other events and then maybe 在其他地方进行其他事件，然后也许
once per frame we kind of go through 每帧一次，我们有点像在这里经历一个事件队列
that queue of events like an event here 每帧一次，我们有点像在这里经历一个事件队列
and we just kind of dispatch and handle 我们只是分派并在那里处理所有这些，而不是这样做
all of them there instead of doing it 我们只是分派并在那里处理所有这些，而不是这样做
immediately upon receiving the event but 收到事件后立即发现，但我发现它没有
I find it as something that doesn't 收到事件后立即发现，但我发现它没有
necessarily need to be implemented 一定需要立即在我们可以使用的引擎中实施
straight away in an engine we can kind 一定需要立即在我们可以使用的引擎中实施
of just deal with this and this is a lot 只是处理这个问题，这要简单得多，所以如果我们这样做，那就是
simpler so if we do kind of that that is 只是处理这个问题，这要简单得多，所以如果我们这样做，那就是
maybe something to explore in the future 当事情变得更多时，也许将来会探索一些事情
when things get a little bit more 当事情变得更多时，也许将来会探索一些事情
complicated and we want a 复杂，我们希望对我的友善有更多的控制权
little bit more control about I'm kind 复杂，我们希望对我的友善有更多的控制权
of you know how our our engine flows and 你们当中的人知道我们的引擎如何运转，而不仅仅是挡住整个边缘，
do not just block the whole edge and 你们当中的人知道我们的引擎如何运转，而不仅仅是挡住整个边缘，
every time in event occurs until it's 每当事件发生时，直到我们的所有事情都完全解决了
been fully handled by everything in our 每当事件发生时，直到我们的所有事情都完全解决了
application so like a Buffett event you 应用程序，就像巴菲特事件一样，您可能最终会成为一个更好的主意
may end up being a better idea in the 应用程序，就像巴菲特事件一样，您可能最终会成为一个更好的主意
future but for now this is totally fine 将来，但是现在这还好，所以现在如果收到它可以
okay so now if it's received that it can 将来，但是现在这还好，所以现在如果收到它可以
kind of dispatch the event to anything 将事件调度到需要它的任何事物，例如，您知道
that requires it so for example you know 将事件调度到需要它的任何事物，例如，您知道
we talked about the layer stack that we 我们讨论了我们早先可以传播的层堆栈
had earlier it can kind of propagate 我们讨论了我们早先可以传播的层堆栈
that event down the layer stack so that 该事件沿层堆栈向下移动，以便所有层都有机会进行
all the layers have a chance to kind of 该事件沿层堆栈向下移动，以便所有层都有机会进行
receive that mouse button press event 接收该鼠标按钮按下事件并进行处理，并可能进一步阻止
and handle it and maybe block further 接收该鼠标按钮按下事件并进行处理，并可能进一步阻止
layers from receiving that event if the 如果需要，则从接收该事件的各个层开始，但仅此而已
need if if need be but that's kind of it 如果需要，则从接收该事件的各个层开始，但仅此而已
you know our application is now about 您知道我们的应用程序现在知道有关发生的事件
aware of an event that's occurred from 您知道我们的应用程序现在知道有关发生的事件
our window just by kind of that function 我们的窗口现在只是那种函数指针，而不是像
pointer now instead of having like a 我们的窗口现在只是那种函数指针，而不是像
function pointer or like an you know STD 函数指针或类似的您知道的STD函数或类似的东西
function or something like that that we 函数指针或类似的您知道的STD函数或类似的东西
set on window you could essentially 设置在窗口上，您实际上可以创建类似事件监听器界面的窗口
create like an event listener interface 设置在窗口上，您实际上可以创建类似事件监听器界面的窗口
called like eye event listener or 被称为像眼睛事件侦听器之类的东西，也许窗口可能有
something and maybe window could have 被称为像眼睛事件侦听器之类的东西，也许窗口可能有
like an array or some kind of like you 像数组或某种类似的东西，您知道容器的眼睛事件侦听器
know container of eye event listeners 像数组或某种类似的东西，您知道容器的眼睛事件侦听器
and then every time an event occurs it 然后，每当事件发生时，它都会经历这种情况
simply goes through that kind of 然后，每当事件发生时，它都会经历这种情况
collection of eye event listeners and 收集眼睛事件侦听器，然后对事件进行调用，这样
then the calls on event right so 收集眼睛事件侦听器，然后对事件进行调用，这样
application itself could end up kind of 应用程序本身最终可能会成为您所知道的眼睛事件侦听器
being you know an eye event listener 应用程序本身最终可能会成为您所知道的眼睛事件侦听器
because it listens to events as would 因为它侦听事件，您会知道所有层，所以，因为
you know all the layers and so because 因为它侦听事件，您会知道所有层，所以，因为
it kind of needs to implement that 有点需要实现该接口
interface 有点需要实现该接口
it would then implement on event and 然后在事件上实现，然后将自身设置为事件
then set itself kind of as an event 然后在事件上实现，然后将自身设置为事件
listener to window which might have you 可能知道事件的窗口的侦听器
know event 可能知道事件的窗口的侦听器
listen you know just like an array of 听你知道，就像他们的阵列或其他任何东西，然后这将
them or whatever and then this would 听你知道，就像他们的阵列或其他任何东西，然后这将
kind of go through all the event 遍历所有事件侦听器并实际调用自己的事件监听器
listeners and actually call their own 遍历所有事件侦听器并实际调用自己的事件监听器
event function so you could do something 事件函数，所以您可以做类似的事情
like that it's a little bit more 事件函数，所以您可以做类似的事情
abstract a little bit more kind of 我猜想有点抽象，更高级
high-level I guess and just having like 我猜想有点抽象，更高级
sed function or like a raw function sed函数或原始函数点或类似的东西，但是那
point or something like that but that sed函数或原始函数点或类似的东西，但是那
kind of gets the job done 完成工作没关系，这些都没关系
it doesn't matter those are kind of all 完成工作没关系，这些都没关系
implementation details so in terms of 实施细节，因此就我们现在实际要做的事情而言
what we actually have to do right now 实施细节，因此就我们现在实际要做的事情而言
then what we need to do before this kind 那么在这种窗口存在之前我们需要做的是
of window even exists is we probably 那么在这种窗口存在之前我们需要做的是
need to make something called 需要制作一个叫做I事件监听器的东西，我们需要制作这个
I event listener we need to make this 需要制作一个叫做I事件监听器的东西，我们需要制作这个
whole kind of event system so we 整个事件系统，所以我们实际上需要创建所有数据
actually need to create all the data we 整个事件系统，所以我们实际上需要创建所有数据
need for events so every type of event 需要事件，所以您知道的每种类型的事件都会像基本事件一样
you know we'll have like a base event 需要事件，所以您知道的每种类型的事件都会像基本事件一样
type and then every type of event of 类型，然后每种类型的事件都会让您知道词干
event will kind of you know stem stem 类型，然后每种类型的事件都会让您知道词干
down from there essentially so we'll 从那里开始，这样我们就可以了解所有有关窗口事件的信息，例如
have all about window events like a 从那里开始，这样我们就可以了解所有有关窗口事件的信息，例如
resize and close will have all of our 调整大小和关闭将按下我们所有输入的高级鼠标按钮
input advanced mouse button pressed 调整大小和关闭将按下我们所有输入的高级鼠标按钮
mouse moved key pressed key released 鼠标移动键按下键释放了这种东西，然后我们可以
that kind of stuff and then we could 鼠标移动键按下键释放了这种东西，然后我们可以
also have actual application events if 如果我们愿意的话，也有实际的应用程序事件，例如应用程序
we wanted to so for example application 如果我们愿意的话，也有实际的应用程序事件，例如应用程序
and these originate from applications so 而这些源于应用程序，所以诸如运行loca通风口之类的东西就对了，等等。
stuff like run loca vents right so on 而这些源于应用程序，所以诸如运行loca通风口之类的东西就对了，等等。
update on tick on render all of those 更新滴答声，渲染所有此类事件，而不仅仅是
kind of events instead of being just 更新滴答声，渲染所有此类事件，而不仅仅是
propagated immediately from the kind of 立即从实际上可能是的应用程序类传播
application class they could actually be 立即从实际上可能是的应用程序类传播
kind of dispatched as events and then 作为事件调度，然后图层可以例如监听
layers could for example listen to on 作为事件调度，然后图层可以例如监听
update or whatever or just just listen 更新或其他任何内容，或者只是听应用程序更新uptick事件而已，
to app update uptick events whatever and 更新或其他任何内容，或者只是听应用程序更新uptick事件而已，
then if they chose them to they could 然后，如果他们选择他们，他们可以在那里处理它，这就是
kind of handle it there so that's this 然后，如果他们选择他们，他们可以在那里处理它，这就是
kind of event system will allow for that 一种事件系统也可以做到这一点，但基本上我要说的是
as well but basically what I'm saying is 一种事件系统也可以做到这一点，但基本上我要说的是
we need to construct all of the kind of 我们需要构造所有类型的事件类，然后我们
event classes that we have and then we 我们需要构造所有类型的事件类，然后我们
also want to have you know certain debug 也希望您也知道某些调试数据，例如
data as well so for example it may be 也希望您也知道某些调试数据，例如
like event names and stuff like that we 诸如事件名称之类的东西，我们也希望您知道事件类别，以便
also want you know event categories so 诸如事件名称之类的东西，我们也希望您知道事件类别，以便
there's a few different things that we 我们需要做一些不同的事情，这种事情变得有点
need to do this kind of becomes a little 我们需要做一些不同的事情，这种事情变得有点
bit more complicated we also want 稍微复杂一点，我们还需要一种称为事件调度程序的东西
something called an event dispatcher 稍微复杂一点，我们还需要一种称为事件调度程序的东西
which basically on this on event class 基本上在这种on事件类上，在这种on事件函数上
on this kind of on event function which 基本上在这种on事件类上，在这种on事件函数上
contains this kind of event reference we 包含此类事件引用，我们希望能够进行这种调度
want to be able to kind of dispatch that 包含此类事件引用，我们希望能够进行这种调度
event to maybe a different function 事件可能基于其类型而具有不同的功能，所以我们可能最终
based on its type so we might end up 事件可能基于其类型而具有不同的功能，所以我们可能最终
having something like an on mouse you 像鼠标一样，您知道移动的功能需要
know moved function which takes 像鼠标一样，您知道移动的功能需要
specifically like a mouse move event or 特别是像鼠标移动事件之类的东西，然后向右转
something like that and then turn right 特别是像鼠标移动事件之类的东西，然后向右转
fast and then kind of what happens is if 快速然后发生的事情是如果此事件类型最终成为鼠标
this event type ends up being a mouse 快速然后发生的事情是如果此事件类型最终成为鼠标
move event then we want to automatically 移动事件，然后我们想自动将其分配给该函数
kind of dispatch it to this function 移动事件，然后我们想自动将其分配给该函数
automatically like without having to do 自动喜欢，而无需执行任何类型的繁重代码或
any kind of really heavy code or 自动喜欢，而无需执行任何类型的繁重代码或
whatever right there in the on event 启用事件功能中的任何内容，即可找出轮胎对
function to find out what the tire pairs 启用事件功能中的任何内容，即可找出轮胎对
and all that so that can be achieved 所有这些，只需创建一种
fairly simply by just creating kind of 所有这些，只需创建一种
an event dispatcher little class which 一个事件调度程序的小类，它只是包装一个事件，然后
is just wraps an event and then just 一个事件调度程序的小类，它只是包装一个事件，然后
figures out its type and dispatches it 找出其类型，并将其分派给给定的函数指针
to a given function pointer if it 找出其类型，并将其分派给给定的函数指针
matches the right type so things like 匹配正确的类型，所以像这样的事情就是我们需要写的
that right that's what we need to write 匹配正确的类型，所以像这样的事情就是我们需要写的
basically 基本上马上就到了，这就是我们接下来要做的
right away and that's what we'll do next 基本上马上就到了，这就是我们接下来要做的
episode now and then from there we'll be 时不时从那一集开始，我们将被困写冬季课程，然后
stuck writing our winter class and then 时不时从那一集开始，我们将被困写冬季课程，然后
you know who hooked that up with the 你知道谁将事件系统与之挂钩
event system 你知道谁将事件系统与之挂钩
and being able to kind of call back to 并能够回调应用程序类，然后提供
the application class and then provide 并能够回调应用程序类，然后提供
all the event details that we actually 我们实际需要的所有活动详细信息，这就是我认为的计划
need so that's the plan I think it 我们实际需要的所有活动详细信息，这就是我认为的计划
sounds pretty good those are kind of our 听起来不错，这些是我们下一步的榛树好吧，这就是
next steps for hazel okay so that's 听起来不错，这些是我们下一步的榛树好吧，这就是
pretty much it that's our whole kind of 实际上，这是我们必须要拥有的整个事件系统
event system that we have to actually 实际上，这是我们必须要拥有的整个事件系统
write along with kind of how we're going 与我们将如何交流所有这些事件的方式一起写bash
to communicate all those events bash 与我们将如何交流所有这些事件的方式一起写bash
application and propagate them to our 应用程序并将它们传播到我们的那种层堆栈中，是的，我喜欢
kind of layer stack yeah I love kind of 应用程序并将它们传播到我们的那种层堆栈中，是的，我喜欢
writing this stuff should be a little 编写这些东西应该会有点有趣，希望我们可以真正挤进去
fun hopefully we can actually squeeze in 编写这些东西应该会有点有趣，希望我们可以真正挤进去
all these event types as well as the 所有这些事件类型以及应用程序和事件列表以及其他内容
application and event lists and stuff 所有这些事件类型以及应用程序和事件列表以及其他内容
all in one episode we'll see next 在一集中我们都会看到下一集可能会很长
episode might end up being quite long 在一集中我们都会看到下一集可能会很长
but yeah I hope you guys kind of enjoy 但是，是的，我希望你们喜欢这些策划视频
these planning videos it's something 但是，是的，我希望你们喜欢这些策划视频
that is the 1% necessary and I think 那是1％的必要条件，我认为这只是在谈论我们在做什么
just kind of talking about what we're 那是1％的必要条件，我认为这只是在谈论我们在做什么
actually going to do instead of just 实际上要做而不是仅仅做某件事真的很重要
kind of doing it is really important 实际上要做而不是仅仅做某件事真的很重要
because remember this series is kind of 因为请记住，这一系列是你们不学习的地方
here for you guys to learn not 因为请记住，这一系列是你们不学习的地方
necessarily to just kind of watch me 一定只是看着我写一个引擎而没有真正说
write an engine without really saying 一定只是看着我写一个引擎而没有真正说
much and just you know kind of not 很多，只是你知道不谈论，因为我喜欢
talking about because what I like to 很多，只是你知道不谈论，因为我喜欢
talk about in this series is why I make 在本系列中谈论的是为什么我要做出自己做出的决定以及
the decisions that I do make and kind of 在本系列中谈论的是为什么我要做出自己做出的决定以及
how all this fits together so that you 所有这些如何组合在一起，以便你们可以了解实际
guys can understand the actual 所有这些如何组合在一起，以便你们可以了解实际
architecture of an engine and all that 引擎的架构以及所有这些东西使您的想法落在下面
stuff anyway leave your thoughts below 引擎的架构以及所有这些东西使您的想法落在下面
as to what I've kind of described here 关于我在设计中所描述的内容，请记住，您知道
in my design keep in mind that you know 关于我在设计中所描述的内容，请记住，您知道
none of this is set in stone if someone 如果有人说，嘿，你应该这样做，这一切都不是一成不变的
says hey you should do it this way you 如果有人说，嘿，你应该这样做，这一切都不是一成不变的
know we can talk about that we can 知道我们可以谈论，我们可以讨论，您知道您可以提交
discuss that you know you can submit 知道我们可以谈论，我们可以讨论，您知道您可以提交
like a pull request or something for 像拉取请求之类的东西，例如，可能还为时过早
example maybe too early to do that 像拉取请求之类的东西，例如，可能还为时过早
nowadays because the repository is quiet 如今，由于存储库很安静，所以您知道平淡无奇
you know bland isn't quite a kind of 如今，由于存储库很安静，所以您知道平淡无奇
bear right now but in the future you 现在忍受，但将来您知道您可以随时提交请求
know you can always submit a pull 现在忍受，但将来您知道您可以随时提交请求
request and we always discussed that 请求，我们一直在讨论，实际上已经有一些
there's actually been a few already that 请求，我们一直在讨论，实际上已经有一些
we've discussed on the github repository 我们已经在github仓库上讨论过Luke将处于不同的模糊状态
Luke will be in the different blur um 我们已经在github仓库上讨论过Luke将处于不同的模糊状态
but yeah we don't always talk about this 但是，是的，我们并不总是谈论这些东西，尤其是在这些设计中
stuff and especially in these design 但是，是的，我们并不总是谈论这些东西，尤其是在这些设计中
sessions it's a good idea you know in a 会议，这是一个好主意，您知道在真正的软件团队中会发生什么
real kind of software team what happens 会议，这是一个好主意，您知道在真正的软件团队中会发生什么
is someone will basically give a little 基本上是有人会像我刚刚做的那样做一些演讲，
presentation like I've just done and 基本上是有人会像我刚刚做的那样做一些演讲，
then we can 然后我们可以围坐在一起，像你一样
sit around in a group and be like you 然后我们可以围坐在一起，像你一样
know trying to poke holes in it and try 知道要在上面戳个洞然后尝试像是的，但是这会发生什么
a bit like yeah but what happens in this 知道要在上面戳个洞然后尝试像是的，但是这会发生什么
scenario what happens in that scenario 在这种情况下会发生什么情况，您可能知道一种更好的方法
you know maybe a better way of doing it 在这种情况下会发生什么情况，您可能知道一种更好的方法
would be this way or have you thought 会是这种方式，还是您考虑过要成为表演者或喜欢客户
about being a performance or like client 会是这种方式，还是您考虑过要成为表演者或喜欢客户
kind of API requirements or just there's 某种API要求或只是需要考虑所有这些东西，所以这就是为什么
all this stuff to consider so that's why 某种API要求或只是需要考虑所有这些东西，所以这就是为什么
these whole design sessions are really 无论如何，这些整个设计会议真的非常重要，希望你们
really important anyway hope you guys 无论如何，这些整个设计会议真的非常重要，希望你们
enjoy this video if you did you can hit 欣赏这段视频，如果您喜欢，可以按“赞”按钮，也可以帮助破坏
the like button you can also help spoil 欣赏这段视频，如果您喜欢，可以按“赞”按钮，也可以帮助破坏
the stories by going to patronymic on 通过对切尔诺啤酒的尺寸进行赞助来讲述故事，您将获得下一个
for size the Cherno you'll get the next 通过对切尔诺啤酒的尺寸进行赞助来讲述故事，您将获得下一个
video already if you're watching this 如果您正在youtube上观看此视频，则该视频已经公开
live on youtube it's public the next 如果您正在youtube上观看此视频，则该视频已经公开
video is actually already out so you can 视频实际上已经播出了，所以您已经可以看到我实施了所有这些操作
already see me implementing all this 视频实际上已经播出了，所以您已经可以看到我实施了所有这些操作
stuff right now if you just go on over 现在的东西，如果您只是继续前往patreon车队，则将切尔诺（Cherno）和
to patreon convoy slash the Cherno and 现在的东西，如果您只是继续前往patreon车队，则将切尔诺（Cherno）和
also you'll I mean for the patrons as 您也将在我的私人开发部门中代表顾客
well in my private development branch 您也将在我的私人开发部门中代表顾客
this whole event system everything I've 整个事件系统我在这里描述的一切都围绕着
described here has been around for like 整个事件系统我在这里描述的一切都围绕着
weeks so you can definitely check that 个星期，因此您绝对可以检查出您是否有兴趣
out if you're interested to kind of 个星期，因此您绝对可以检查出您是否有兴趣
surge ahead in the series and see what's 在本系列中不断前进，看看会发生什么，以及获得全部
coming as well as just kind of get all 在本系列中不断前进，看看会发生什么，以及获得全部
the code to play around with before it 在被解释或发布之前就可以使用的代码
even kind of gets explained or goes live 在被解释或发布之前就可以使用的代码
I hope to see you guys in that in the 我希望在下一个视频中看到你们，我们实际上将开始
next video we're actually gonna start 我希望在下一个视频中看到你们，我们实际上将开始
implementing the stuffs gonna be really 实施这些东西直到再见之前都会非常令人兴奋
exciting until then goodbye 实施这些东西直到再见之前都会非常令人兴奋
[Music] [音乐]你
you [音乐]你
[Music] [音乐]