Window Size as an uniform.

[arhik]

Currently all window sizes are (500, 500). Its hardcoded somewhere. For that to change we need to change to some shader code. Pass window size as an uniform as window size changes. Window uniform needs to be updated with window Events.

[VarLad]

We have already worked on an option to allow custom passing on window sizes (in WGPUCanvas.jl and WGPUgfx.jl)
We're not sure about what do you mean by shader code, but we're guessing that the object getting "stretched" is undesirable?

Can you better point us in this issue?

[arhik]

Yes. We need to avoid stretching.

[arhik]

Our determineSize call is stretching the drawn surface rather. We need to preserve aspect ratio while scaling. We need to pass window size data to the shader. Perspective Camera might need to be scaled appropriately. Window size data is not passed into the shader for this to happen.

Edit: we need to pass window size as uniform if we would like to update camera projection matrix in shader. Since our camera projection matrix is updated in CPU, setting aspectratio property in camera object would be enough like @ut112002 attempted below.

[ut112002]

Could you point us to the file we should start looking into for the shader stuff.

Will we have to look into other repos as well or WGPUgfx is enough.

[arhik]

Here aspect ratio needs to be set based on window width and height. Also perspective matrix needs to be updated with change in height and width. I am not sure about perspective matrix update. But aspect ratio is good start. We may not have to update shader code. Looks like we can update perspective matrix through aspect ratio and width and height.

WGPUgfx.jl/src/primitives/camera.jl

Line 292 in e751a2e

xS = 2*n/(r-l) # r-l is width

WGPUgfx.jl/src/primitives/camera.jl

Lines 366 to 376 in e751a2e

	shaderSource = quote
	struct $cameraUniform
	eye::Vec3{Float32}
	aspectRatio::Float32
	lookAt::Vec3{Float32}
	fov::Float32
	viewMatrix::Mat4{Float32}
	projMatrix::Mat4{Float32}
	end
	@var Uniform 0 $(binding) camera::$cameraUniform
	end

[arhik]

updating aspect ratio field of camera object directly on event may work out of the box.

[arhik]

r and l variables refer to right and left end of the window in unit sizes; same is the case with t and b referring to top and bottom

[ut112002]

wgpu1.webm

I wrote the code to update the aspect ratio on every resize with

function attachWindowSizeCallback(scene, camera)
	callback = (_, w, h) -> begin
		@info w,h,scene.canvas.size
		camera.aspectRatio *= w/scene.canvas.size[1]
		camera.aspectRatio *= scene.canvas.size[2]/h
		scene.canvas.size = (w,h)
		WGPUCore.determineSize(scene.canvas.context)
	end
	GLFW.SetWindowSizeCallback(scene.canvas.windowRef[], callback)
end

and i ran the tri.jl example , is this desirable ?

[arhik]

looks like aspectratio is preserved. Are you using PollEvents ? Just asking since update is slow.

[arhik]

I really appreciate you. There are many such trivial things that can be improved.

[arhik]

WGPUgfx.jl/src/primitives/camera.jl

Lines 118 to 130 in e751a2e

	Base.setproperty!(camera::Camera, f::Symbol, v) = begin
	setfield!(camera, f, v)
	uniformData = camera.uniformData
	if camera.uniformData != nothing
	if f in propertynames(uniformData)
	setproperty!(uniformData, f, v)
	end
	(viewMatrix, projMatrix) = computeTransform(camera)
	uniformData.viewMatrix = viewMatrix
	uniformData.projMatrix = projMatrix
	updateUniformBuffer(camera)
	end
	end

setting aspectratio is everything to it. The above code clearly updates projection matrix too. This fix will be a good PR. Would you like to make PR with this.

I don't see other issues with this code. But, we might still need to pass window size as uniform since we don't know what users want. So you can raise a separate issue like preserve aspectratio and make a PR. We can keep this open untill shader code is adjusted. Shader code is also trivial. Just define struct like camera in getShaderCode function, and update buffer like camera.

[arhik]

@ut112002 summary: Raise separate issue and make a PR if you would like to. You take your time and submit PR.

Passing window uniform is slightly involved. Right now camera projection matrix is updated on CPU and Camera buffer is set. Another approach would be update camera projection matrix on GPU with change in window height and width. This would mean significant change in camera.jl and other shader code. In cases where we have multiple cameras, CPU version could have an overhead on buffer updates. This argument needs backing with experimentation.