List where pinballs would exit a grid of bumpers from different entrance points
JavaScript (ES6),  218 215 213  212 bytes
Takes input as (w,h,o) where \$o\$ is an object whose keys are the coordinates of the bumpers in 'x,y' format and whose values are either '/' or '\'.

(w,h,o)=&gt;(A=[...Array(w+h&lt;&lt;1)].map((_,n)=&gt;(p=n-w)&lt;0?[n,-1,3]:p&lt;h?[w,p]:(p-=w)&lt;h?[h+~p,h,1]:[-1,2*h+~p,2])).map(g=([x,y,d])=&gt;A.every(([X,Y])=&gt;X-x|Y-y&amp;&amp;++i,(c=o[[x+=~-d%2,y+=~-~-d%2]])?d^=c&lt;{}||3:i=0)?g([x,y,d]):i)

Try it online!
Commented
We first create an array \$A[\:]\$ of tuples \$[x, y, d]\$ where \$(x, y)\$ is the starting position along the borders of the playfield and \$d\$ is the initial direction.
( A = [...Array(w + h &lt;&lt; 1)]  // create an array A[] of (w + h) * 2 items
  .map((_, n) =&gt;              // for each item at position n in A[]:
    (p = n - w) &lt; 0 ?         //   set p = n - w; if this is the bottom side:
      [n, -1, 3]              //     start at (n, -1) in direction 3
    :                         //   else:
      p &lt; h ?                 //     if this is the right side:
        [w, p]                //       start at (w, p) in direction 0 (implicit)
      :                       //     else:
        (p -= w) &lt; h ?        //       subtract w from p; if this is the top side:
          [h + ~p, h, 1]      //         start at (h + ~p, h) in direction 1
        :                     //       else (left side):
          [-1, 2 * h + ~p, 2] //         start at (-1, 2 * h + ~p) in direction 2
  )                           // end of map()
)                             //

We then simulate the trajectory of the ball, starting at each position defined above, until it reaches another starting position.
.map(g = ([x, y, d]) =&gt;       // for each tuple [x, y, d] in A[]:
  A.every(([X, Y]) =&gt;         //   for each tuple [X, Y] in A[]:
    X - x | Y - y             //     break if (x, y) = (X, Y)
    &amp;&amp; ++i,                   //     otherwise, increment i
    ( c =                     //     define c as
        o[[                   //       the bumper character at
          x += ~-d % 2,       //         (x, y), once updated according to d
          y += ~-~-d % 2      //         (0 = West, 1 = South, 2 = East, 3 = North)
        ]]                    //
    ) ?                       //     if c is set:
      d ^= c &lt; {} || 3        //       XOR d with 1 (for '/') or 3 (for '\')
    :                         //     else:
      i = 0                   //       initialize i to 0
  ) ?                         //   end of every(); if truthy:
    g([x, y, d])              //     do a recursive call to move the ball further
  :                           //   else:
    i                         //     we've reached a starting position: yield i
)                             // end of map()