Sign change, loop and display with minimal padding

Java 8, 483 480 486 467 bytes

(a,b)->{int f=0,l=b-a+3,z[][]=new int[l][l],y[]=new int[l],i,j,k=0;for(;b-a>=0;k++,a++,b--,f^=1)for(j=0,i=a;i<=b;i++)z[k][j++]=f<1?i:-i;String r="",s;for(i=0;i<l;y[i++]=k)for(j=0,k=1;j<l;k=f>k?f:k)f=(r+z[j++][i]).length();for(i=0;i<l;i++){k=z[i][0];if(i>0&&k==z[i][1]&k==z[i-1][2])break;for(j=0;j<l;){k=z[i][j];s="";for(f=(s+k).length();f++<y[j];s+=" ");f=z[i][++j];if(k==f){r+=(i>0&&z[i-1][1]==z[i][1]?s+0:"")+"\n";j=l;}else r+=s+k+(f==z[i][j+1]?"":",");}}return r;}

Bytes raised due to bug-fix..

Ok, this took A LOT more time (and bytes) than I thought (in Java that is..). This can definitely be golfed some more, probably by using a completely different approach instead of creating an NxN grid-array to fill and then 'strip out' the zeros (with an annoying edge case for the test-case of -1,1, as well as -12,12).

Try it online.

Explanation:

(a,b)->{        // Method with two integer parameters and String return-type
  int f=0,      //  Flag-integer, starting at 0
      l=b-a+3,  //  Size of the NxN matrix,
                //  plus two additional zeros (so we won't go OutOfBounds)
      z[][]=new int[l][l],
                //  Integer-matrix (default filled with zeros)
      y[] = new int[l],
                //  Temp integer-array to store the largest length per column
      i,j,k=0;  //  Index-integers
  for(;b-a>=0   //  Loop as long as `b-a` is not negative yet
      ;         //    After every iteration:
       k++,     //     Increase `k` by 1
       a++,     //     Increase `a` by 1
       b--,     //     Decrease `b` by 1
       f^=1)    //     Toggle the flag-integer `f` (0→1 or 1→0)
    for(j=0,i=a;i<=b;i++)
                //   Inner loop `i` in the range [`a`, `b`]
      z[k][j++]=//    Set all the values in the matrix to:
        f<1?    //     If the flag is 0:
         i      //      Simply use `i`
        :       //     Else (flag is 1):
         -i;    //      Use the negative form of `i` instead
  String r="",  //  The return-String
         s;     //  Temp-String used for the spaces
  for(i=0;i<l;  //  Loop `i` over the rows of the matrix
      ;y[i++]=k)//    After every iteration: Set the max column-width
    for(j=0,k=1;j<l;
                //   Inner loop `j` over the cells of each row
        k=f>k?f:k)
                //     After every iteration: Set `k` to the highest of `k` and `f`
      f=(r+z[j++][i]).length();
                //    Determine current number's width
                //    (NOTE: `f` is no longer the flag, so we re-use it as temp value)
  for(i=0;i<l;i++){
                //  Loop `i` over the rows of the matrix again
    k=z[i][0];  //   Set `k` to the first number of this row
    if(i>0      //   If this isn't the first row
       &&k==z[i][1]&k==z[i-1][2])
                //   and the first number of this row, second number of this row,
                //   AND third number of the previous row all equal (all three are 0)
      break;    //    Stop loop `i`
    for(j=0;j<l;){
                //   Inner loop `j` over the cells of each row
      k=z[i][j];//    Set `k` to the number of the current cell
      s="";     //    Make String `s` empty again
      for(f=(s+k).length();f++<y[j];s+=" ");
                //    Append the correct amount of spaces to `s`,
                //    based on the maximum width of this column, and the current number
      f=z[i][++j];
                //    Go to the next cell, and set `f` to it's value
      if(k==f){ //    If the current number `k` equals the next number `f` (both are 0)
        r+=     //     Append result-String `r` with:
          (i>0  //      If this isn't the first row
           &&z[i-1][1]==z[i][1]?
                //      and the second number of this and the previous rows 
                //      are the same (both are 0):
            s+0 //       Append the appropriate amount of spaces and a '0'
           :    //      Else:
            "") //       Leave `r` the same
          +"\n";//     And append a new-line
         j=l;}  //     And then stop the inner loop `j`
      else      //    Else:
       r+=s     //     Append result-String `r` with the appropriate amount of spaces
          +k    //     and the number 
          +(f==z[i][j+1]?"":",");}}
                //     and a comma if it's not the last number of the row
  return r;}    //  Return the result `r`

Jelly, 25 24 20 bytes

rµḊṖNµÐĿZbȷG€Ỵ€Zj€”,

This is a dyadic link that returns an array of rows.

Try it online!

How it works

rµḊṖNµÐĿZbȷG€Ỵ€Zj€”,  Dyadic link. Arguments: a, b

r                      Range; yield [a, ..., b].
 µ   µÐĿ               Apply the enclosed chain until the results are no longer
                       unique. Return the array of results.
  Ḋ                      Dequeue; remove the first item.
   Ṗ                     Pop; remove the last item.
    N                    Negate; multiply all remaining integers by -1.
       Z               Zip; transpose rows and columns.
        bȷ             Base 1000; map each n to [n].
          G€           Grid each; in each row, pad all integers to the same length,
                       separating the (singleton) rows by linefeeds.
            Ỵ€         Split each result at linefeeds.
              Z        Zip to restore the original layout.
               j€”,    Join each row, separating by commata.

05AB1E, 59 bytes

Once again I'm screwed over by the same bug I wrote a fix for months ago but never pushed...
Golfing should still be possible though.

Ÿ[Ðg1‹#ˆ¦(¨]\\¯vy€g}})J.Bvyð0:S})øvyZs\})U¯vyvyXNèyg-ú}',ý,

Try it online!