Generate an ASCII Padovan Spiral This is the ASCII version of this challenge. The initial post was separated per request by Martin Ender

Introduction

Similar to the Fibonacci Sequence, the Padovan Sequence (OEIS A000931) is a sequence of numbers that is produced by adding previous terms in the sequence. The initial values are defined as:

P(0) = P(1) = P(2) = 1


The 0th, 1st, and 2nd terms are all 1. The recurrence relation is stated below:

P(n) = P(n - 2) + P(n - 3)


Thus, it yields the following sequence:

1, 1, 1, 2, 2, 3, 4, 5, 7, 9, 12, 16, 21, 28, 37, 49, 65, 86, 114, 151, 200, 265, 351, ...


Using these numbers as side lengths of equilateral triangles yields a nice spiral when you place them all together, much like the Fibonacci Spiral:

  

Image courtesy of Wikipedia



Task

Your task is to write a program that recreates this spiral by ASCII art, with input corresponding to which term. Since a triangle of side length 1 (1 character) is impossible to represent nicely in ASCII, the side lengths have been dilated by a factor of 2. Thus, the triangle of side length 1 is actually represented like so:

 /\
/__\


So, for example, if the input was 5 (the 5th term), the output should be:

   /\
  /  \
 /    \
/______\
\      /\
 \    /__\ 
  \  /\  /
   \/__\/


The first 5 terms were 1, 1, 1, 2, 2, so the triangle had side lengths 2, 2, 2, 4, 4 due to dilation. Another example for input 8:

     __________
   /\          /\
  /  \        /  \
 /    \      /    \
/______\    /      \
\      /\  /        \
 \    /__\/          \
  \  /\  /            \
   \/__\/______________\
    \                  /
     \                /
      \              /
       \            /
        \          /
         \        /
          \      /
           \    /
            \  /
             \/


Rules


You must print the result, and input must be an integer corresponding to term number
Trailing and leading newlines are allowed, trailing spaces after lines are allowed also
Your submission must be able to handle at least up to the 10th term (9)
Your submission must be a full program or function that takes input and prints the result
Rotations of the output are allowed, in 60 degree multiples, but the size of the triangles must remain the same, along with the representation
Going counter-clockwise is also allowed
Standard loopholes are forbidden 


You may assume that input will be >0 and that correct format of input will be given.

Scoring

This is code-golf, so the shortest code in bytes wins. Happy New Years everyone!
Befunge, 871 836 798 bytes

&amp;00p45*:10p20p030p240p050p060p9010gp9110gp1910gp1-91+10gpv
&lt;v-g03+g06*2g041g055_v#!:%6:p06p05+p04g05g06:g04&lt;p*54+292&lt;
-&gt;10g:1\g3+:70p110gv &gt;:5- #v_550g:01-\2*40g+1-30g
/\110:\-g03:\1:g055 _v#!-4:&lt;vp01:-1g01-g03-1\-
^1&lt;v07+1:g07&lt; p08p &lt; &gt;:1-#v_550g:01-\40g+60g+1-30g-50g&gt;v
 _0&gt;p80gp:5-|v1\+66\:p\0\9:$&lt;:p02:+1g02-g03+g06-\g04\1:&lt;
0v|-g00:+1$$&lt;&gt;\p907^&gt;p:!7v&gt;3-#v_550g:30g+:30p1\0\-
1&gt;10g+::0\g3-:70p\0^^07&lt;v&lt;&gt;50#&lt;g::30g+:30p-1-01-\
v &gt;\$0gg&gt; :1+10gg1- #v_^&gt;0g10gg*+\:!2*-70g2+10gv&gt;:#-&gt;#,"_"$#1_:1#&lt;p
+1+g03$_^#`gg011+3:+3&lt;g07\+*2+*`0:-\gg01+5g07:g&lt;&gt;1#,-#*:#8&gt;#4_$#:^#
&gt;55+,p30g40p10gg10g1&gt;#v_
#v:#p0$#8_:$#&lt;g!#@_0^ &gt;
 &gt;&gt;:180gg`&gt;&gt;#|_:2+80gg:!v
3+^g\0p08:&lt;vgg08+2::+3&lt;$_100p1-v&gt;g,\80gg+\80gp:2+90g:!01p\80gp
!#^_80g:1+^&gt;\180gg`+!#^_20g80g`
5*g10!g09p04-1-\0\+g04:gg08:p09&lt;^3`0:gg08+1:::$$_1#!-#\\:,#\&lt;g


Try it online!

As is often the case with Befunge, the trick is coming up with an algorithm that allows us to render the pattern from top to bottom, since it's just not feasible to render it into memory first with the limited space available.

The way this works is by first building up a simple data structure representing the edges needed to draw the spiral. The second stage then parses that structure from top to bottom, rendering the edge fragments required for each line of output.

Using this technique, we can support up to n=15 in the reference implementation before we start having overflow issue in the 8-bit memory cells. Interpreters with a larger cell size should be able to support up to n=25 before running out of the memory.