R, 56 54 43 36 30 bytes

x=!!sequence(2:scan())-1;x%o%x

Try it online!

Takes input one above $n$ (so returns 3x3 matrix for $n = 4$).
Returns a matrix of $1s$ (foreground), and $0s$ (background) with an extra row/column of zeroes in front.

Thanks to digEmAll for -7 bytes.

MATL, 14 10 bytes

:"@:Fv]g&*

This answer uses 1 for the blocks and 0 for the background

Try it at MATL Online

Explanation

     % Implicitly grab the input as an integer, N

     %   STACK: { 3 }

:    % Create an array from 1...N

     %   STACK: { [1, 2, 3] }

"    % For each element M in this array

  @: % Create an array from 1...M

     %   STACK (for 1st iteration): { [1] }

     %   STACK (for 2nd iteration): { [1; 0], [1, 2] }

     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0], [1, 2, 3] }

  F  % Push a zero to the stack

     %   STACK (for 1st iteration): { [1], 0 }

     %   STACK (for 2nd iteration): { [1; 0], [1, 2], 0 }

     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0], [1, 2, 3], 0 }

  v  % Vertically concatenate everything on the stack

     %   STACK (for 1st iteration): { [1; 0] }

     %   STACK (for 2nd iteration): { [1; 0; 1; 2; 0] }

     %   STACK (for 3rd iteration): { [1; 0; 1; 2; 0; 1; 2; 3; 0] }

] 

g    % Convert everything to be boolean (turns all non-zeros to 1)

     %   STACK: { [1; 0; 1; 1; 0; 1; 1; 1; 0] }

&*   % Perform element-wise multiplication to expand this array out into the 2D grid

     % Implicitly display the result

Jelly, 8 bytes

1ẋⱮj0ȧþ`

Try it online!

Haskell, 49 bytes

f n=map=<<flip(map.max)$[0^i|x<-[1..n],i<-[0..x]]

Try it online!

Generates a pattern like [1,0,1,0,0,1,0,0,0,...], then makes a 2D by taking the min of pairs. The pointfree weirdness saves 2 bytes over the more readable:

f n|l<-do x<-[1..n];0:(1<$[1..x])=[[a*b|a<-l]|b<-l]

Try it online!

JavaScript (ES6),  73 72  69 bytes

Returns a string made of 1's, spaces and line feeds.

n=>(g=s=>n-->0?g(s+`${p+=1} `):s[~n]?(+s[~n]?s:'')+`

`+g(s):'')(p='')

Try it online!

JavaScript (ES7),  87 83  82 bytes

Saved 3 bytes thanks to @dzaima

Returns a binary matrix, which is built cell by cell.

n=>[...Array(n*(n+3)/2)].map((_,y,a)=>a.map(h=(z,x)=>(17+8*x)**.5%1&&(z||h(1,y))))

Try it online!

How?

The width $w$ of the matrix is given by:

$$w=T_n+n-1={n+1choose 2}+n-1=frac{n(n + 3)}{2}-1$$

(NB: As allowed by the challenge rules, we output a matrix of width $w+1$ instead.)

Similarly, the cell located at $(X,Y)$ is empty if the following quadratic admits an integer root for either $k=X$ or $k=Y$:

$$frac{x(x+3)}{2}-1-k=0\
x^2+3x-2-2k=0
$$

whose determinant is:

$$Delta=9-4(-2-2k)=17+8k$$

APL (Dyalog Unicode), 12 10 12 bytes^SBCS

∘.×⍨∊,,⎕⍴1

Try it online!

Edit: -2 bytes from ngn. +2 bytes because the previous answers were invalid (with idea thanks to ngn and dzaima).

Explanation

∘.×⍨∊,,⎕⍴1



         ⎕    Take input.

           ⍴1  An array of 1s of length our input. Example: 1 1 1

       0,      Prepend a 0. Example: 0 1 1 1

     ,        Take all the prefixes and concatenate them. Example: 0  0 1  0 1 1  0 1 1 1

    ∊          Flatten the list. Example: 0 0 1 0 1 1 0 1 1 1

∘.×⍨           Turn the above list into a multiplication table of 0s and 1s

               by multiplying the list with itself.

The output should look like:

0 0 0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0 0 0

0 0 1 0 1 1 0 1 1 1

0 0 0 0 0 0 0 0 0 0

0 0 1 0 1 1 0 1 1 1

0 0 1 0 1 1 0 1 1 1

0 0 0 0 0 0 0 0 0 0

0 0 1 0 1 1 0 1 1 1

0 0 1 0 1 1 0 1 1 1

0 0 1 0 1 1 0 1 1 1

Wolfram Language (Mathematica), 41 bytes

a#&/@(a=Flatten@Array[{0,1~Table~#}&,#])&

Try it online!

Python 2, 67 bytes

s='';n=input()

while n:s='#'*n+' '+s;n-=1

for c in s:print(c>' ')*s

Try it online!

Prints blank lines for empty lines, which the challenge allows.

Same length (with input one above n):

r=range(input())

for n in r:print(' '.join(i*'#'for i in r)+'n')*n

Try it online!

J, 17 bytes

[:*/~2=/[:I.2+i.

Try it online!

Haskell, 69 68 bytes

(a#b)0=

(a#b)n=(a#b)(n-1)++b:(a<$[1..n])

f n=((1#0)n#(0<$(1#0)n))n

Returns a matrix of numbers.

Try it online!

Variants of f with the same byte count:

f n=((#)<*>(0<$)$(1#0)n)n

f n|l<-(1#0)n=(l#(0<$l))n

APL+WIN, 29 bytes

m/⍉(m←¯1↓∊(⍳n),¨¯1)/(n,n←⎕)⍴1

Explanation:

(n,n←⎕)⍴1 prompt for integer n and create a nxn matrix of 1s



(m←¯1↓∊(⍳n) replicate the columns by 1,2,.....n and insert 0s between each replication



m/⍉ repeat replication and 0 insertion for the rows from above 

Example:

⎕:

3

1 0 1 1 0 1 1 1

0 0 0 0 0 0 0 0

1 0 1 1 0 1 1 1

1 0 1 1 0 1 1 1

0 0 0 0 0 0 0 0

1 0 1 1 0 1 1 1

1 0 1 1 0 1 1 1

1 0 1 1 0 1 1 1

Jelly, 7 bytes

‘RÄṬ|þ`

Try it online!

Outputs a digit matrix, using $0$ for the rectangles and $1$ for the padding between them. The TIO link contains a footer which formats a digit matrix in a human-readable way by lining up the rows and columns.

Explanation

‘RÄṬ|þ`

 R       Take a range from 1 to

‘          {the input} plus 1

  Ä      Cumulative sum; produces the first {input}+1 triangular numbers

   Ṭ     Produce an array with 1s at those indexes, 0s at other indexes

     þ   Create a table of {the array}

      `    with itself

    |      using bitwise OR

The number at cell $(x,y)$ of the resulting table will be $1$ if either $x$ or $y$ is a triangular number, or $0$ otherwise (because bitwise OR works like logical OR on 0 and 1). (We use R, range from 1, because Jelly uses 1-based indexing, so we don't have to worry about column 0 being incorrectly full of 0s; we have to add 1 to the input because the array produced by Ṭ stops at the largest element given in the input, so we need to draw a line on the right-hand side and the bottom.) The gaps between triangular numbers are the consecutive integers, so the rectangular blocks formed by the gaps between the lines end up as the sizes requested by the question; and the use of an OR operation (in this case, bitwise) allows the lines to cross each other correctly.

Charcoal, 18 bytes

≔⪫ＥＮ×#⊕ι θＥθ⭆θ⌊⟦ιλ

Try it online! Link is to verbose version of code. Explanation:

   Ｎ                Input number

  Ｅ                 Map over implicit range

       ι            Current value

      ⊕             Incremented

    ×               Repetitions of

     #              Literal `#`

 ⪫                  Join with spaces

≔        θ          Assign to variable

           θ        Retrieve variable

          Ｅ         Map over characters

             θ      Retrieve variable

            ⭆      Replace characters with

              ⌊     Minimum of

               ⟦    List of

                ι   Row character

                 λ  Column character

                    Implicitly print each row on its own line

Perl 6, 35 bytes

{[~](("

"~[~] *xx$_)xx$_)>>.say}

Try it online!

Anonymous code block that takes a number and prints the multiplication table with *s and a leading newline.

Mouse-2002, 79 bytes

Abusing Mouse's macros to repeat functionality.

?1+n:#P,n,j,k,b#P,j,y,k,#P,n,i,' ,#P,i,x,35;;;;$P0 2%:(1%.2%.-^4%3%!'2%.1+2%:)@

Try it online!