Clear State, what is that, and why is it useful

Swapchain section should be explained well, since resources need to be disposed and recreated

HelloD3D11 is using ComPtr, explain why they make sense and RawPointer is not used, link to ComPtr in msdn

HelloWindow fix HelloWindowApplication markdown H2s to H3s (proper indentation in table of contents)

• Use ID3DBlob instead of ID3D10Blob
• Add PostBuild to copy deps to $(OutDir) see 2-HelloFroge

float/double will become float32_t and float64_t

Start a new chapter in 1-1-getting-started which introduces the changes we see and go with in the future like pipeline/pipelinefactory/graphicsdevice/vertextype and so forth and provide a guide what to change/add/remove exactly

Shaders could not be loaded, because they are being loaded relative from the $(OutDir). However the default working directory is the project directory and not OutDir :(

This needs to be manually set

Did we actually decide? I think we have, DirectXTex wasn't it :)

We rely on DirectXTex for now, explain it a bit

Construct a Mermaid diagram to show the various pipelines/stages

SetPrivateData + Show/Use provided macro for all the devicechilds and why naming things is useful

HelloWindow provide screenshot of window, massag into .md

We should probably merge these two, since they don't make sense to be separated

Do we want to add srgb as early as possible? to avoid nanokatze complaining about the wrong colorspace triangle :P

Jkr suggests that the elements should be explained in more detail

DepthBuffer
DSV
DepthStencilState

We dont mention at all where to put assets

HelloD3D11 Introduce whole code in .md similar to 1-1-1 HelloWindow

Make dear imgui available after 1-3-2-LoadingMeshes

Show how to load a model using assimp, which we are probably going to abstract away already, and not show raw at first

Probably a preview of the froge temple with the lazer eyes and whatnot

HelloD3D11 Examine sections of d3d11 relevance like we did with glfw in HelloWindow

Instead of one big ass Main.cpp,

break it into a simple Application class, same should be applied to future chapters

in onw or two sentences, and difference to __uuid(...) and link to msdn

Rename PipelineSettings to PipelineDescriptor

Hi,

This is more like a "feature request" instead of a "issue": (I think creating a discussion thread is a better choice)

I was thinking about starting to write the articles about linear transformations and coordinate systems. I'd like using LaTeX since it is TON easier for me to write mathematical formulas and articles with it. Is this possible?

I might try using Markdown, but I'm not sure if stuff is going to look as good as in latex. I'm also not really familiar with it.

Thanks.

HelloWindow provide links to repo for HelloWindow

At the moment DeviceContext has SetViewport, that should be moved to PipelineSettings Pipeline

Or should we just shed light on the new things, since we should be smart enough to see whats new by now?

So just introduce what's new into markdown

class HelloTriangleApplication should be in HelloTriangleApplication.cpp/hpp

Explain coordinate systems

Explain the goal of this legendary master piece

How to debug your graphics, show RenderDoc, 1 or two screenshots, showing our debug names etc... refer to official docs and its getting-started + that wizard thingy to troubleshoot black screen :P

The current README is empty and doesn't explain anything for people who stumble upon this project. Let's come up with some text and possibly a bit of pics which explain this project in a few inviting words :)

Shaders can be compiled from file using D3D11Compile... but also from Visual Studio itself, that should be showed,

Learning how your IDE works and what it provides is a useful thing

Introduction

Getting Started

• What D3D11 and GPU APIs actually do
• Cram a picture in here of the DX11 graphics pipeline to show where we are, and what we need
• GLFW window (HelloWindow) with link to HelloWin32Window (but no going through what it all means)
• D3D11 initialization, Raw Pointers vs ComPtr (HelloComApplication) and (HelloD3D11)
• Swapchain creation, clearing and resizing the screen
• Hello Triangle
  • Shaders
    • Show how they can be compiled with VS?
    • Explain how to compile from code (D3D11CompileFromFile...)
  • InputLayout
  • VertexBuffer
  • Explain vertex/indexbuffers, primitivetopology, shaders (overview) and RasterizerStates\

Debug and how to help yourself

• ClearState and explain why this is useful
• Debug Layer/Debug Device
• Naming things
• RenderDoc
• NvOptimusEnablement/AmdWhateverPerformance for laptop users

Model Loading

• Loading Textures (HelloFroge) (that means introducing an image library)
• Loading Meshes
• Loading Materials/Textures
• DepthStencilTexture+DSV
• DepthStencilState
• IndexBuffer
• Math
  • Coordinate Systems
  • Shader support for -> (Would be cool if we we could apply terminology to shaders too and have easy ways of conversion between those... @NeuRE is using something like that in their engine... clipToWorld, clipToView, worldToView etc imoh that makes things easier to grasp
• Constant Buffers
• A camera to admire froge

Does it make sense to come up with some sort of "Scene" VkGuide also mentions that and it makes sense imho (this could lead to advanced articles to either how to use ecs like entt, or whatever)

Explain why Debugging in graphics programming is useful and most of the time necessary, especially when starting out :GP:

That means introducing Input as well.

We will take the stuff which is in HelloWindow still (Input/Keyboard/Mouse)

Explain different camera models? not just perspective/ortho view, but also first/thirdperson stuff? flycam etc

Explain coordinate systems

.editorconfig should enable common code style/formatting settings.

Consense was that we derive it from the currently existing HelloFroge project

(obviously if need be we change it)

it's a hassle keeping a mix of string and wstring in things, you'll keep running into situations where you have your string variable but it wants a wstring or vice versa later. keeping one of the two and converting seems way more convenient (and vouch for string for utf8)

example conversion utility:

std::wstring ToWideString(const std::string& string)
{
    std::wstring newString(string.size()*sizeof(wchar_t), '\0');
    size_t numCharsConverted = 0;
    mbstowcs_s(&numCharsConverted, newString.data(), newString.size(), string.data(), string.size());
    newString.resize(numCharsConverted-1);
    return newString;
}

What needs to be installed, how to enable,
Where to find information, DebugDevice & InfoQueue & DXCPL

All that tbd, we should VC like last time

Basics

• Colors
• Blending (BlendState)
• Dear Imgui? (it might make sense to manipulate light position/color later why not introduce dear imgui here, we could manipulate the color of the 3 corners of the HelloTriangle to see it in action and also how interpolation by the PS affects the outcome
• Gamma Correction
• Blinn-Phong with hardcoded directional light
• Blinn-Phong materials and lights
• Normal Mapping
• Lights from CPU
  • Point
  • Spot
  • Directional
  • Light Geometry (I think we should use them from the start, for point/spot lights)
  • Debug Lights
• RenderTargets (aka Framebuffers, we need them for Shadows and Defered and whatnot)
  • We could also introduce Framebuffer scaling, like modern games provide a way too (render to 50% of screen res etc) (Quake Chanmpions, Path of Exile on top of my head)
• Shadows
  • Implement basic shadow
  • Fixup with bias, front face culling, PCF
  • Point Light Cubes?
  • Cascade Shadow maps
  • Variance Shadow Maps?
• Frustum Culling?
• Forward+ ... (steal from 3dgep?)
• Deferred Shading
  • Tightly Packed GBuffer?
  • Classical Deferred
  • Tiled/Clustered ... (we could steal from 3dgep? but implement it using our "framework")

PBR

• Rendering equation and basic theory
• Used BRDFs
• Physically based lighting
• IBL with SH

Techniques

• Compute Shaders
• Text Rendering
  • SDF Bitmap fonts? (using compute to generate the font bitmap)
• Particles
• Skeletal Animation
• SSAO
• SSR
• Frustum Culling
• Sky + Clouds
• Reflection probes
• GI
  • Voxel Cone Tracing (see 3dgep?)

Post-processing

• HDR + Tonemapping
• Better camera + Bloom
• Depth of Field
• TAA
• Motion Blur
• Lens flare

Hello Windo, explain why we chose GLFW, maybe link to HelloWin32Window in that section instead of #45