MATLAB, 92 90 86 84 bytes

n=input('');p=eye(n)+32;A=repmat([fliplr(p),p,''],1,2^n/2);A(:,n+1:n:end)=[];disp(A)

Try it online!

eye creates an identity matrix. If we flip it and concatenate the original i.e. [fliplr(p),p] we get (for n=3):

0 0 1 1 0 0
0 1 0 0 1 0
1 0 0 0 0 1

With repmat(...,1,2^n/2) we repeat this 2^(n-1) times and get

0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0
0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 0 1 0 ...
1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1

From this we just delete the unnecessary columns, with A(:,n+1:n:end)=[];

Python 2, 87 bytes

n=input()
for i in range(n):print''.join(' o'[abs(j%(2*n)-n)==i]for j in range(1,n<<n))

Try it online!

Uses a formula for the coordinates (i,j) that contain a circle, then joins and prints the grid. There's a lot of golf smell here -- ''.join, two nested ranges, for over exec, so there's likely to be improvements.

Charcoal, 14 bytes

ＮλＰ^×λoＦ⁻λ¹‖Ｏ→

Try it online!

Explanation

Ｎλ inputs an integer into λ. Ｐ^ is a multidirectional print (SE and SW) of ×λo (string multiplication of λ with o). Then Ｆ⁻λ¹ runs a for loop λ - 1 times, in which ‖Ｏ→ reflects the whole thing to the right with overlap.

05AB1E, 12 10 bytes

Îj¹FÐvû},À

Uses the CP-1252 encoding. Try it online!

Pyke, 11 bytes

XFd*\o+Q^Vs

Try it here!

 F          -  for i in range(input)
  d*\o+     -     " "*i+"o"
       Q^   -    ^.lpad(input)
         Vs -   repeat len(^): palindromise()
X           - print(reversed(^))

J, 28 bytes

' o'{~[:|:]_1&(}.,A.)|.@=@i.

This is based on the palindrome trick from @muddyfish's solution.

Try it online!

Explanation

This example uses n = 3. Create the identity matrix of order n and reverse the rows.

0 0 1
0 1 0
1 0 0

Drop the last row and append the reverse of itself. Repeat this action n times. Then transpose the result.

0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1

Use those values as indices into the char array [' ', 'o'] and output as a 2d char array.

  o   o   o   o  
 o o o o o o o o 
o   o   o   o   o

Walkthrough of the code

' o'{~[:|:]_1&(}.,A.)|.@=@i.  Input: integer n
                          i.  Form the range [0, 1, ..., n-1]
                        =@    Equality table with itself.
                              Creates an identity matrix of order n
                     |.@      Reverse
          ]                   Get n
           _1&(     )         Repeat n times on x = reversed identity matrix
           _1  }.               Drop the last row
                  A.            Get the permutation at index -1
                                This is the reverse
                 ,              Append them and use it as the new value of x
      [:|:                    Transpose x
' o'{~                        Index into the char array

Pyth, 30 bytes

jC.<V*]+*dtQNh*tQ^2Q*+JUQtP_J^

A program that takes input of an integer and prints the result. Uses a quote mark " instead of o.

Try it online!

How it works

jC.<V*]+*dtQNh*tQ^2Q*+JUQtP_J^    Program. Input: Q
jC.<V*]+*dtQNh*tQ^2Q*+JUQtP_J^QQ  Implicit input fill
      ]                           Yield a one-element list, A
        *dtQ                      cotaining Q-1 spaces
       +    N                     appended with a quote mark.
             h*tQ^2Q              Yield 1+(Q-1)*2^Q
     *                            Repeat A that many times, giving B
                       UQ         Yield [0, 1, 2, ..., Q-1]
                      J           (Store that in J)
                     +   tP_J     Append the reverse of J, discarding the first and last
                                  elements
                    *        ^QQ  Repeat the above Q^Q times, giving C
    V                             Vectorised map. For each pair [a,b] from B and C:
  .<                               Cyclically rotate a left by b characters
 C                                Transpose
j                                 Join on newlines
                                  Implicitly print

Python 2, 115 113 108 98 bytes

lambda n:'\n'.join(map(''.join,zip(*[' '*abs(i)+'o'+~-n*' 'for i in range(-n+1,n-1)*2**~-n])))+'o'

Try it online!

Using range(-n+1,n-1) to create the absolute number of spaces between the bottom and the o to generate

  o
 o
o
 o

and then appending more copies, rotating 90º everything and appending the last o at bottom right

Befunge, 98 91 bytes

This uses a , in place of the o, since that enables us to save a couple of bytes.

&::1>\1-:v
+\:v^*2\<_$\1-2*::!+00p*1
:-1_@v0\-g01:%g00:-1<:\p01
 ,:^ >0g10g--*!3g,:#^_$\55+

Try it online!

Explanation

Given the stage number, n, we start by calculating the following three parameters of the pattern:

jump_count = 2 ^ (n - 1)
jump_len   = (n - 1) * 2
width      = (jump_len * jump_count) + 1

The jump_len is normalised to avoid it being zero for a stage 1 kangaroo with:

jump_len += !jumplen    

We can then output the jump pattern by iterating over the x and y coordinates of the output area, and calculating the appropriate charater to output for each location. The y coordinate counts down from n - 1 to 0, and the x coordinate counts down from width - 1 to 0. We determine whether a dot needs to be shown with the following formula:

jump_off = x % jump_len
show_dot = (jump_off == y) or (jump_off == (jump_len-y))

The show_dot boolean is used as a table index to determine actual character to output at each location. To save on space, we use the start of the last line of source as that table, which is why our o character ends up being a ,.

JavaScript (ES6), 83 bytes

f=
n=>` `.repeat(n).replace(/ /g,"$'o$`-$`o$'-".repeat(1<<n-1)+`
`).replace(/-.?/g,``)

<input type=number min=1 oninput=o.textContent=f(this.value)><pre id=o>

Jelly, 11 bytes

ŒḄ¡ḶUz1Ṛa⁶Y

TryItOnline!

How?

The printable character used is 0.

Builds upon the method of Dennis's answer to his previous question on the subject of kangaroos.

ŒḄ¡ḶUz1Ṛa⁶Y - Main link: n                      e.g. 3
ŒḄ          - bounce, initial implicit range(n) e.g. [1,2,3,2,1]
  ¡         - repeat n times                    e.g. [1,2,3,2,1,2,3,2,1,2,3,2,1,2,3,2,1]
                  i.e. [1,2,3,2,1] bounced to [1,2,3,2,1,2,3,2,1] bounced to [1,2,3,2,1,2,3,2,1,2,3,2,1,2,3,2,1]
   Ḷ        - lowered range (vectorises)        e.g. [[0],[0,1],[0,1,2],[0,1],[0],[0,1],[0,1,2],[0,1],[0],[0,1],[0,1,2],[0,1],[0],[0,1],[0,1,2],[0,1],[0]]
    U       - upend (vectorises)                e.g. [[0],[1,0],[2,1,0],[1,0],[0],[1,0],[2,1,0],[1,0],[0],[1,0],[2,1,0],[1,0],[0],[1,0],[2,1,0],[1,0],[0]]
     z1     - transpose with filler 1
       Ṛ    - ...and reverse                    e.g. [[1,1,0,1,1,1,0,1,1,1,0,1,1,1,0,1,1],
                                                      [1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1],
                                                      [0,1,2,1,0,1,2,1,0,1,2,1,0,1,2,1,0]]
        a⁶  - logical and with space character (all non-zeros become spaces)
          Y - join with line feeds              e.g.    0   0   0   0  
                                                       0 0 0 0 0 0 0 0 
                                                      0   0   0   0   0

Haskell, 100 bytes

k 1="o"
k n|n<-n-1,m<-n*2=unlines[[last$' ':['o'|mod c m`elem`[m-r,r]]|c<-[0..m*2^n]]|r<-[n,n-1..0]]

Try it online! Usage: k 3.

Explanation:

Given a row r, a column c and m = 2(n-1) an o is set if c mod m equals r or m-r. The outermost list comprehension sets the range of r from n-1 to 0, the next one sets the range of c from 0 to m*2^(n-1) and the innermost acts as conditional returning 'o' if the above formula is fulfilled and ' ' otherwise. This yields a list of strings which is turned into a single newline separated string by unlines. For n=1 the function produces a division-by-zero error, so this case is handled explicitly in the first line.

C#, 180 bytes

Wont win this, posting for other C# contestants as something they can beat.

(n)=>{var s=new string[n];int x=0,a=1,j;for(j=0;j<=Math.Pow(2,n)*(n*n-n);j++){int i=j%n;s[n-i-1]+=x%n==i?'o':' ';if(i==n-1){x+=a;a*=x==n-1|x==0?-1:1;}}return string.Join("\n",s);};

complete program:

using System;
public class P
{
    public static void Main()
    {
        Func<int, string> _ = (n) =>
        {
          var s = new string[n];
          int x = 0, a = 1, j;
          for (j = 0; j <= Math.Pow(2, n) * (n * n - n); j++)
          {
              int i = j % n;
              s[n - i - 1] += x % n == i ? 'o' : ' ';

              if (i == n - 1)
              {
                  x += a;
                  a *= x == n - 1 || x == 0 ? -1 : 1;
              }
          }
          return string.Join("\n", s);
        };

        Console.Write(_(4));
        Console.ReadKey();
    }
}

Python 3, 177 bytes

n=5;f=n-1;w=''
for i in range(n):
 s='';a=0;d='\n'
 if i==f:w='';a=-1;d=''
 for _ in range(2**f):
  s+=' '*(f-i)+'o'+' '*(2*i-1)+w+' '*(n-i-2+a)
 print(s,end=d);w='o'
print('o')

Try it online!

J, 58 47 bytes

' o'{&:>~[:(,.}."1)&.>/(2^<:)#<@(|.,.}."1)@=@i.

Saved 11 bytes using the identity matrix idea from @flawr's solution.

Try it online!

A straightforward application of the definition.

Explanation

For n = 3, creates the identity matrix of order n.

1 0 0
0 1 0
0 0 1

Then mirror it to make

0 0 1 0 0
0 1 0 1 0
1 0 0 0 1

Repeat that 2^n-1 times and drop the head of each row on the duplicates

0 0 1 0 0 0 1 0 0 0 1 0 0 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 0 0 1 0 0 0 1 0 0 0 1 0 0 0 1

Use those values as indices into the char array [' ', 'o'] to output a 2d char array

  o   o   o   o  
 o o o o o o o o 
o   o   o   o   o

Perl 6, 104 93 88 bytes

->\n{my @a;@a[$_;$++]="o" for [...] |(n-1,0,n-1)xx 2**n/2;say .join for @a».&{$_//" "}}

Inserts o's into a 2D array, and then prints it.

MATL, 27 bytes

XyPt3LZ)2&Pht4LZ)lGqX"h48*c

Try it out at MATL Online

Python 2, 83 bytes

n=input()-1
for i in range(n+1):s=' '*n+'o'+' '*i;print(s[i:-1]+s[:i:-1])*2**n+s[i]

Try it online!

PHP, 157 bytes

for($i=$n=$argv[1],$r=str_repeat;$i>0;)echo$r($r(' ',$i-1).'o'.$r(' ',2*$n-2*$i-1).($i==$n|$i==1?'':'o').$r(' ',$i-2),2**($n-1)).($i--==1&$n!=1?'o':'')."\n";

Ungolfed:

for($i=$n=$argv[1];$i>0;) {

    // Spacing from beginning of pattern to first 'o'   
    $o  = str_repeat(' ',$i-1); 

    // First 'o' for the ascent
    $o .= 'o'; 

    // Spacing between ascent and descent
    $o .= str_repeat(' ',2*$n-2*$i-1); 

    // Second 'o' for the descent, unless we are at the apex or the bottom
    $o .= ($i==$n|$i==1?'':'o'); 

    // Spacing to the end of the pattern
    $o .= str_repeat(' ',$i-2); 

    // Repeat the pattern 2^(n-1) times
    echo str_repeat($o, 2**($n-1)); 

    // Output final 'o' if we are at the bottom in the last pattern
    echo $i--==1&$n!=1?'o':''; 

    // End of line 
    echo "\n"; 

}