Duplicating SimCity perspective in MagicaVoxel

Question

I'm building the original SimCity (open-sourced) icons in MagicaVoxel such that rendering them closely resembles the original. However, I'm having trouble understanding exactly what I'm building.

The original graphics have a kind of overhead view, but it isn't quite isometric. I'm not sure what to call this perspective. And, more importantly, I'm unclear how to achieve it in MagicaVoxel with ease.

The best I've been able to do is create the voxel object at the same "resolution" as the original bitmaps. Then, when it comes time to render, I position the voxel space with perspective camera positioned around x:87 y:80 z:105. Isometric and orthographic resist my attempts to make them mimic the source perspective.

Rendering this results in a GIANT image with my graphic occupying a tiny portion of the upper corner, and in the spirit of pixel-perfection this is only approximating the perspective of the original artwork. I feel there must be some better way to achieve what I'm looking for.

The big problem with this approach is that different tiles have different resolutions and keeping everything proportional to one another using a "eyeball it until the angles look right" approach is too hard to maintain consistency from image to image. I should be able to draw any tile and get consistent, uniform render results. But maybe I'm expecting too much?

In strict perspective mode, perspective lines converge to the center.

In isometric and orthographic mode, the buildings flatten out and show no depth

I am not opposed to exporting models into Blender for rendering, if there is a better solution in that application

Update: Using orthographic camera set as shown achieves something approximating the original tile art, but needs to be skewed back into correct square proportions (trying to unskew it in Photoshop resulted in a blurry mess)

Answer 1

You're not getting correct results because the original SimCity uses a Cabinet projection — a subtype of Oblique projection and I doubt MagicaVoxel supports it.

Personally I don't know any software that could render in that projection but I found a tutorial of rendering an oblique projection in the free Blender.

In the tutorial author creates a specific camera setup and a UV-map to distort the orthographic render to cabinet projection. What's happening in the tutorial could be not very straightforward if you don't know Blender but it's easy to follow. Here's the scene with the UV-file included and camera set up for top-down projection instead of side projection like in the tutorial if you want to play with it.

I used the scene it to recreate this reference:

My result (don't mind the geometry/materials, the goal was a proof of concept):

Here's how the scene looks inside the Blender:

Answer 2

This is perhaps not the answer you want to hear, but POV-Ray can render in this projection without any tricks or cheats.

It works by using its orthographic projection, but directly using the up, right, and direction keywords instead of the more common look_at. Doing this gives us a helpful "Parse Warning: Camera vectors are not perpendicular." but of course that is exactly what we want.

I made a randomly generated scene with some exaggerated patterned boxes to show the effect, and using a parallel light source so that the shadows are also projected correctly:

The up and right vectors defines the size of the viewport and should have the same aspect ratio as the output image. As can be seen, the voxels are "pixel perfect" (voxel perfect?) in the XY plane, and every angle is 45°.

(For brevity, the river is not included here. It is left as an exercise to the reader.)

#version 3.7;
global_settings { assumed_gamma 1 radiosity { count 500 error_bound 0.03 } }

camera {
  orthographic
  right x*640/8
  up    z*480/8
  location -100*<1,-2,1> // These two lines (combined with orthographic)
  direction 100*<1,-2,1> //  are the key to the projection
}

light_source {
  100*<-1,2,1> color rgb 1.2
  parallel point_at 0    // Parallel for straight uniform shadows
}

plane {  y, 0 pigment { rgb 1 } }
plane { -y, -300 no_shadow finish { emission 1 } pigment { rgb 1 } }

// Create our little town
#include "stdinc.inc"
#declare S = seed(87);
#macro rndi(a) int(rand(S)*a) #end
#macro Block() Center_Object( union {
    #local c = CHSL2RGB(VRand(S)*<40,.2,.2>+<10,.3,.2>);
    #local T = pigment { cells color_map { [0 color c/5] [1 color c] } }
    #for(b,1,3)
      #local K= 12-<rndi(b),7-b*3-rndi(5)/2,rndi(b)>*2;
      union {
        difference { box {y,K} box {xz,K-xz+y} pigment{T} }
        box { 1,K-1 pigment { rgb .6 } }
        box { -xz,K*xz+1 pigment { rgb <.3,.5,.2> } }
        translate -2*rndi(b*2)*xz rotate y*90*mod(b+int(c.x*100),4)
      }
    #end
  }, xz )
#end
#macro stack(O,N,D) union { object{O} Align_Object(N,D,max_extent(O)+2) } #end
#macro Row() stack( stack( Block(), Block(), -x), Block(), -x ) #end
object { stack( Row(), Row(), -z ) translate <-26,0,-12> }