Sign up to save your podcasts
Or
Share 003: Escaping Widget inheritance in Unreal with WidgetExtensions
Share to email
Share to Facebook
Share to X
Share to email
Share to Facebook
Share to X
Or
003: Escaping Widget inheritance in Unreal with WidgetExtensions
Generated by NotebookLM using 40 sources, including some software design spec sheets for new features. It's about the MVVM plugin for Unreal, written to assist a XAML UI engineer in upskilling in Unreal UMG.
Here's the prompt I fed NotebookLM to generate this:
Generate a podcast episode outline and conversational prompt for a general-audience, technically curious listener.
Format
Two speakers:
Expert: senior Unreal UI engineer who’s calm, precise, and explains concepts with simple analogies.
Learner: competent developer who’s been duplicating UI behaviour across widgets and is frustrated by inheritance limits.
Tone: friendly, nerdy, practical. No arguing. No hype.
Length target: 15–25 minutes.
Scenario
The Learner has been building a UI library and keeps re-implementing the same “preview/mock data” and lifecycle glue in multiple widget types. They tried to solve it with base classes, but hit the wall: some widgets don’t share ancestry (e.g., user widgets vs buttons). They discovered Unreal’s MVVM plugin and noticed it uses a thing called a widget extension (via UUserWidgetExtension, with UMVVMView as an example). They want to know if this is the right pattern to avoid inheritance sprawl.
Goals for the episode
Explain the problem: why “big base class” inheritance breaks down in UI libraries.
Introduce the concept: what widget extensions are in Unreal (composition over inheritance) and how the MVVM plugin uses them.
Clarify the constraints: extensions attach to user widgets, not every primitive widget type; what that means in practice.
Give a practical mental model using non-Unreal comparisons:
“attached behaviours” (WPF/Blend style),
“components” (Actor-Component style),
“mixins” (conceptually, but not literally).
Walk through a high-level implementation plan for a custom extension:
purpose (e.g., “design-time mock view-model instantiation”),
lifecycle hooks and when they run (editor vs runtime),
how a widget finds/uses the extension.
Cover 2–3 “gotchas” without deep rabbit holes:
initialization order / “too late to add” issues,
editor hot reload quirks,
how to keep extensions small and focused to avoid a new monolith.
Outcome: Learner leaves with a clear decision tree:
when to use an extension,
when to wrap primitives in a user widget,
when to use a plain helper object instead.
This episode includes AI-generated content.
Here's the prompt I fed NotebookLM to generate this:
Generate a podcast episode outline and conversational prompt for a general-audience, technically curious listener.
Format
Two speakers:
Expert: senior Unreal UI engineer who’s calm, precise, and explains concepts with simple analogies.
Learner: competent developer who’s been duplicating UI behaviour across widgets and is frustrated by inheritance limits.
Tone: friendly, nerdy, practical. No arguing. No hype.
Length target: 15–25 minutes.
Scenario
The Learner has been building a UI library and keeps re-implementing the same “preview/mock data” and lifecycle glue in multiple widget types. They tried to solve it with base classes, but hit the wall: some widgets don’t share ancestry (e.g., user widgets vs buttons). They discovered Unreal’s MVVM plugin and noticed it uses a thing called a widget extension (via UUserWidgetExtension, with UMVVMView as an example). They want to know if this is the right pattern to avoid inheritance sprawl.
Goals for the episode
Explain the problem: why “big base class” inheritance breaks down in UI libraries.
Introduce the concept: what widget extensions are in Unreal (composition over inheritance) and how the MVVM plugin uses them.
Clarify the constraints: extensions attach to user widgets, not every primitive widget type; what that means in practice.
Give a practical mental model using non-Unreal comparisons:
“attached behaviours” (WPF/Blend style),
“components” (Actor-Component style),
“mixins” (conceptually, but not literally).
Walk through a high-level implementation plan for a custom extension:
purpose (e.g., “design-time mock view-model instantiation”),
lifecycle hooks and when they run (editor vs runtime),
how a widget finds/uses the extension.
Cover 2–3 “gotchas” without deep rabbit holes:
initialization order / “too late to add” issues,
editor hot reload quirks,
how to keep extensions small and focused to avoid a new monolith.
Outcome: Learner leaves with a clear decision tree:
when to use an extension,
when to wrap primitives in a user widget,
when to use a plain helper object instead.
This episode includes AI-generated content.
View all episodes
By News ReDownloadGenerated by NotebookLM using 40 sources, including some software design spec sheets for new features. It's about the MVVM plugin for Unreal, written to assist a XAML UI engineer in upskilling in Unreal UMG.
Here's the prompt I fed NotebookLM to generate this:
Generate a podcast episode outline and conversational prompt for a general-audience, technically curious listener.
Format
Two speakers:
Expert: senior Unreal UI engineer who’s calm, precise, and explains concepts with simple analogies.
Learner: competent developer who’s been duplicating UI behaviour across widgets and is frustrated by inheritance limits.
Tone: friendly, nerdy, practical. No arguing. No hype.
Length target: 15–25 minutes.
Scenario
The Learner has been building a UI library and keeps re-implementing the same “preview/mock data” and lifecycle glue in multiple widget types. They tried to solve it with base classes, but hit the wall: some widgets don’t share ancestry (e.g., user widgets vs buttons). They discovered Unreal’s MVVM plugin and noticed it uses a thing called a widget extension (via UUserWidgetExtension, with UMVVMView as an example). They want to know if this is the right pattern to avoid inheritance sprawl.
Goals for the episode
Explain the problem: why “big base class” inheritance breaks down in UI libraries.
Introduce the concept: what widget extensions are in Unreal (composition over inheritance) and how the MVVM plugin uses them.
Clarify the constraints: extensions attach to user widgets, not every primitive widget type; what that means in practice.
Give a practical mental model using non-Unreal comparisons:
“attached behaviours” (WPF/Blend style),
“components” (Actor-Component style),
“mixins” (conceptually, but not literally).
Walk through a high-level implementation plan for a custom extension:
purpose (e.g., “design-time mock view-model instantiation”),
lifecycle hooks and when they run (editor vs runtime),
how a widget finds/uses the extension.
Cover 2–3 “gotchas” without deep rabbit holes:
initialization order / “too late to add” issues,
editor hot reload quirks,
how to keep extensions small and focused to avoid a new monolith.
Outcome: Learner leaves with a clear decision tree:
when to use an extension,
when to wrap primitives in a user widget,
when to use a plain helper object instead.
This episode includes AI-generated content.
Here's the prompt I fed NotebookLM to generate this:
Generate a podcast episode outline and conversational prompt for a general-audience, technically curious listener.
Format
Two speakers:
Expert: senior Unreal UI engineer who’s calm, precise, and explains concepts with simple analogies.
Learner: competent developer who’s been duplicating UI behaviour across widgets and is frustrated by inheritance limits.
Tone: friendly, nerdy, practical. No arguing. No hype.
Length target: 15–25 minutes.
Scenario
The Learner has been building a UI library and keeps re-implementing the same “preview/mock data” and lifecycle glue in multiple widget types. They tried to solve it with base classes, but hit the wall: some widgets don’t share ancestry (e.g., user widgets vs buttons). They discovered Unreal’s MVVM plugin and noticed it uses a thing called a widget extension (via UUserWidgetExtension, with UMVVMView as an example). They want to know if this is the right pattern to avoid inheritance sprawl.
Goals for the episode
Explain the problem: why “big base class” inheritance breaks down in UI libraries.
Introduce the concept: what widget extensions are in Unreal (composition over inheritance) and how the MVVM plugin uses them.
Clarify the constraints: extensions attach to user widgets, not every primitive widget type; what that means in practice.
Give a practical mental model using non-Unreal comparisons:
“attached behaviours” (WPF/Blend style),
“components” (Actor-Component style),
“mixins” (conceptually, but not literally).
Walk through a high-level implementation plan for a custom extension:
purpose (e.g., “design-time mock view-model instantiation”),
lifecycle hooks and when they run (editor vs runtime),
how a widget finds/uses the extension.
Cover 2–3 “gotchas” without deep rabbit holes:
initialization order / “too late to add” issues,
editor hot reload quirks,
how to keep extensions small and focused to avoid a new monolith.
Outcome: Learner leaves with a clear decision tree:
when to use an extension,
when to wrap primitives in a user widget,
when to use a plain helper object instead.
This episode includes AI-generated content.