Rotation and Draw Primitives at Virtual Resolutions using native res?

[therevillsParticipant]

When rotation and drawing primatives (eg Oval) using a virtual resolution there are rotated and draw as the native resolution.

Monkey

Namespace myapp #Import "<std>" #Import "<mojo>" Using std.. Using mojo.. Class MyWindow Extends Window Field x:Int, y:Int, w:Int, h:Int, r:Float Field timer:Timer Field vSize := New Vec2i(320, 200) Method New() Super.New("My Window", 1280, 800, WindowFlags.Resizable) Layout = "letterbox-int" w = 100 h = 60 x = (vSize.x / 2) - (w / 2) y = (vSize.y / 2) - (h / 2) timer = New Timer(60, OnUpdate) End Method OnUpdate() r += 0.001 End Method OnRender( canvas:Canvas ) Override App.RequestRender() canvas.TextureFilteringEnabled = False Local matrix := canvas.Matrix canvas.Matrix = matrix.Translate(x, y).Rotate(r) canvas.DrawOval(0, 0, w, h) canvas.Matrix = matrix End Method OnMeasure:Vec2i() Override Return vSize End End Function Main() New AppInstance New MyWindow App.Run() End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

Namespace myapp   #Import "<std>" #Import "<mojo>"   Using std.. Using mojo..   Class MyWindow Extends Window Field x:Int, y:Int, w:Int, h:Int, r:Float Field timer:Timer Field vSize := New Vec2i(320, 200) Method New() Super.New("My Window", 1280, 800, WindowFlags.Resizable) Layout = "letterbox-int" w = 100 h = 60 x = (vSize.x / 2) - (w / 2) y = (vSize.y / 2) - (h / 2) timer = New Timer(60, OnUpdate) End Method OnUpdate() r += 0.001 End   Method OnRender( canvas:Canvas ) Override App.RequestRender() canvas.TextureFilteringEnabled = False Local matrix := canvas.Matrix canvas.Matrix = matrix.Translate(x, y).Rotate(r) canvas.DrawOval(0, 0, w, h) canvas.Matrix = matrix End Method OnMeasure:Vec2i() Override Return vSize End End   Function Main() New AppInstance New MyWindow App.Run() End

I’ve got around this by rendering to texture, but is there a better way or fix?

Monkey

Namespace myapp #Import "<std>" #Import "<mojo>" Using std.. Using mojo.. Class MyWindow Extends Window Field x:Int, y:Int, w:Int, h:Int, r:Float Field timer:Timer Field vSize := New Vec2i(320, 200) Field gameImage:Image Field gameCanvas:Canvas Method New() Super.New("My Window", 1280, 800, WindowFlags.Resizable) Layout = "letterbox-int" w = 100 h = 60 x = (vSize.x / 2) - (w / 2) y = (vSize.y / 2) - (h / 2) gameImage = New Image(vSize.x, vSize.y, PixelFormat.RGBA8, TextureFlags.Dynamic) gameCanvas = New Canvas(gameImage) timer = New Timer(60, OnUpdate) End Method OnUpdate() r += 0.001 End Method OnRender( canvas:Canvas ) Override App.RequestRender() gameCanvas.Clear(Color.Black) gameCanvas.TextureFilteringEnabled = False Local matrix := gameCanvas.Matrix gameCanvas.Matrix = matrix.Translate(x, y).Rotate(r) gameCanvas.DrawOval(0, 0, w, h) gameCanvas.Matrix = matrix gameCanvas.Flush() canvas.DrawImage(gameImage, 0, 0) End Method OnMeasure:Vec2i() Override Return vSize End End Function Main() New AppInstance New MyWindow App.Run() End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54

Namespace myapp   #Import "<std>" #Import "<mojo>"   Using std.. Using mojo..   Class MyWindow Extends Window Field x:Int, y:Int, w:Int, h:Int, r:Float Field timer:Timer Field vSize := New Vec2i(320, 200) Field gameImage:Image Field gameCanvas:Canvas Method New() Super.New("My Window", 1280, 800, WindowFlags.Resizable) Layout = "letterbox-int" w = 100 h = 60 x = (vSize.x / 2) - (w / 2) y = (vSize.y / 2) - (h / 2) gameImage = New Image(vSize.x, vSize.y, PixelFormat.RGBA8, TextureFlags.Dynamic) gameCanvas = New Canvas(gameImage) timer = New Timer(60, OnUpdate) End Method OnUpdate() r += 0.001 End   Method OnRender( canvas:Canvas ) Override App.RequestRender() gameCanvas.Clear(Color.Black) gameCanvas.TextureFilteringEnabled = False Local matrix := gameCanvas.Matrix gameCanvas.Matrix = matrix.Translate(x, y).Rotate(r) gameCanvas.DrawOval(0, 0, w, h) gameCanvas.Matrix = matrix gameCanvas.Flush() canvas.DrawImage(gameImage, 0, 0) End Method OnMeasure:Vec2i() Override Return vSize End End   Function Main() New AppInstance New MyWindow App.Run() End

[Mark SiblyKeymaster]

Can’t think of anything off hand. Possibly a shader could be used to ‘snap’ vertices, but then you’d end up with a lot of overdraw and it would be likely to be considerably slower.

I think the ‘draw stuff offscreen’ approach is pretty much the way HW expects things to be done these days. I have also recently found a ‘blit framebuffer’ GL extension that should make this even faster in some cases, not that I’ve ever found it to be too slow or anything so far.

[EthernautParticipant]

The current behavior seems correct to me!

Virtual resolution is about relative sizes (and aspect ratio), not about the resolution itself. Doing the two step, “render to texture then draw texture” seems to be the correct path to draw “actual” low res images at a high resolution monitor, I think.

If you really don’t want to deal with it, you can extend the Window class into a window that does the texture rendering “behind the scenes”. You can even switch between low res and high res on the fly while maintaining the framing and size of everything, which is neat!

Cheers!

[Mark SiblyKeymaster]

Actually, my idea is bollocks anyway, it’d just ‘pointilize’ everything.

[coconParticipant]

This render to texture effect is nice for various purposes, such as pixel art etc.

However for the real deal there should be another much better way. Many others have tried to tackle the problem of virtual resolutions, I remember Diddy Framework (previous monkey-x) had quite a cool way to handle virtual resolutions, that handles scaling, nicely.

 

My take on the subject so far is to convert values form a range to another.

Monkey

Namespace myapp #Import "<std>" #Import "<mojo>" Using std.. Using mojo.. Class VirtualResolution Abstract Global Width:Int, Height:Int Function Set(width:Int, height:Int) Width = width Height = height End #rem monkeydoc Convert an X screen value to virtual. #end rem Function GetVirtualX:Float(screenX:Int) Return Remap(screenX, 0, App.ActiveWindow.Width, 0, Width) End #rem monkeydoc Convert a Y screen value to virtual. #end rem Function GetVirtualY:Float(screenY:Int) Return Remap(screenY, 0, App.ActiveWindow.Height, 0, Height) End #rem monkeydoc Convert an X virtual value to screen. #end rem Function GetScreenX:Float(virtualX:Int) Return Remap(virtualX, 0, Width, 0, App.ActiveWindow.Width) End #rem monkeydoc Convert an X virtual value to screen. #end rem Function GetScreenY:Float(virtualY:Int) Return Remap(virtualY, 0, Height, 0, App.ActiveWindow.Height) End #rem monkeydoc Remap a value from a source range to a target range. #end rem Function Remap:Float(value:Float, firstStart:Float, firstStop:Float, secondStart:Float, secondStop:Float) Return secondStart + (secondStop - secondStart) * ((value - firstStart) / (firstStop - firstStart)) End End Class Entity Abstract Global Position := New Vec2f Global TargetPosition := New Vec2f End Class MyWindow Extends Window Method New() Super.New("My Window", 800, 800) VirtualResolution.Set(400, 400) End Method OnRender( canvas:Canvas ) Override ' game update takes place in the virtual resolution If (Mouse.ButtonHit(MouseButton.Left)) ' the user enters some coordinates that will have to be converted into virtual Entity.TargetPosition.X = VirtualResolution.GetVirtualX(Mouse.X) Entity.TargetPosition.Y = VirtualResolution.GetVirtualY(Mouse.Y) End ' the rest is updated normally Entity.Position.X = Lerp(Entity.Position.X, Entity.TargetPosition.X, 0.05) Entity.Position.Y = Lerp(Entity.Position.Y, Entity.TargetPosition.Y, 0.05) ' ------------------------------------------------- ' on game rendering virtual values must be converted to screen values App.RequestRender() ' draw the target If True ' <-- sugar to keep method scope cleaner... 🙂 Local x := VirtualResolution.GetScreenX(Entity.TargetPosition.X) Local y := VirtualResolution.GetScreenY(Entity.TargetPosition.Y) canvas.Color = Color.Red canvas.DrawLine(0, y, Width, y) canvas.DrawLine(x, 0, x, Height) End ' draw the player If True Local x := VirtualResolution.GetScreenX(Entity.Position.X) Local y := VirtualResolution.GetScreenY(Entity.Position.Y) canvas.Color = Color.White canvas.DrawRect(x, y, 10, 10) End ' ------------------------------------------------- ' for fun see how the virtual world behaves Local seeVirtualSpace := True If seeVirtualSpace canvas.Color = Color.White canvas.DrawRect(Entity.Position.X, Entity.Position.Y, 10, 10) canvas.Color = Color.Blue canvas.DrawRect(Entity.TargetPosition.X, Entity.TargetPosition.Y, 5, 5) End ' ------------------------------------------------- End End Function Main() New AppInstance New MyWindow App.Run() End #rem monkeydoc Performs a linear interpolation between two values based on blending value. @param a The original value. @param b The target value. @param blend The blending percentage factor (normalized between 0.0 and 1.0). #end Function Lerp:Float(a:Float, b:Float, blend:Float) Return blend * (b - a) + a End

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131

Namespace myapp   #Import "<std>" #Import "<mojo>"   Using std.. Using mojo..   Class VirtualResolution Abstract Global Width:Int, Height:Int Function Set(width:Int, height:Int) Width = width Height = height End #rem monkeydoc Convert an X screen value to virtual. #end rem   Function GetVirtualX:Float(screenX:Int) Return Remap(screenX, 0, App.ActiveWindow.Width, 0, Width) End #rem monkeydoc Convert a Y screen value to virtual. #end rem Function GetVirtualY:Float(screenY:Int) Return Remap(screenY, 0, App.ActiveWindow.Height, 0, Height) End #rem monkeydoc Convert an X virtual value to screen. #end rem Function GetScreenX:Float(virtualX:Int) Return Remap(virtualX, 0, Width, 0, App.ActiveWindow.Width) End #rem monkeydoc Convert an X virtual value to screen. #end rem Function GetScreenY:Float(virtualY:Int) Return Remap(virtualY, 0, Height, 0, App.ActiveWindow.Height) End #rem monkeydoc Remap a value from a source range to a target range. #end rem Function Remap:Float(value:Float, firstStart:Float, firstStop:Float, secondStart:Float, secondStop:Float) Return secondStart + (secondStop - secondStart) * ((value - firstStart) / (firstStop - firstStart)) End End   Class Entity Abstract Global Position       := New Vec2f Global TargetPosition := New Vec2f End   Class MyWindow Extends Window Method New() Super.New("My Window", 800, 800) VirtualResolution.Set(400, 400) End Method OnRender( canvas:Canvas ) Override ' game update takes place in the virtual resolution If (Mouse.ButtonHit(MouseButton.Left)) ' the user enters some coordinates that will have to be converted into virtual Entity.TargetPosition.X = VirtualResolution.GetVirtualX(Mouse.X) Entity.TargetPosition.Y = VirtualResolution.GetVirtualY(Mouse.Y) End ' the rest is updated normally Entity.Position.X = Lerp(Entity.Position.X, Entity.TargetPosition.X, 0.05) Entity.Position.Y = Lerp(Entity.Position.Y, Entity.TargetPosition.Y, 0.05) ' ------------------------------------------------- ' on game rendering virtual values must be converted to screen values App.RequestRender() ' draw the target If True ' <-- sugar to keep method scope cleaner...   Local x := VirtualResolution.GetScreenX(Entity.TargetPosition.X) Local y := VirtualResolution.GetScreenY(Entity.TargetPosition.Y) canvas.Color = Color.Red canvas.DrawLine(0, y, Width, y) canvas.DrawLine(x, 0, x, Height) End ' draw the player If True Local x := VirtualResolution.GetScreenX(Entity.Position.X) Local y := VirtualResolution.GetScreenY(Entity.Position.Y) canvas.Color = Color.White canvas.DrawRect(x, y, 10, 10) End ' ------------------------------------------------- ' for fun see how the virtual world behaves Local seeVirtualSpace := True If seeVirtualSpace canvas.Color = Color.White canvas.DrawRect(Entity.Position.X, Entity.Position.Y, 10, 10) canvas.Color = Color.Blue canvas.DrawRect(Entity.TargetPosition.X, Entity.TargetPosition.Y, 5, 5) End ' ------------------------------------------------- End End Function Main() New AppInstance New MyWindow App.Run() End   #rem monkeydoc Performs a linear interpolation between two values based on blending value. @param a The original value. @param b The target value. @param blend The blending percentage factor (normalized between 0.0 and 1.0). #end Function Lerp:Float(a:Float, b:Float, blend:Float) Return blend * (b - a) + a End

[Author]

Posts