Calling a member function in a new thread

Question

This is a class:

#include <thread>
#include <vector>

class A {
  private:
    void render(int, std::vector<std::vector<int>>&) {
        //do stuff
    };

    void renderSegment() {
        int var1 = 1;
        std::vector<std::vector<int>> var2;

        std::thread t(????);
        t.join();
    };
};

Here are some attempts:

std::thread t([this, var1, &var2] {renderSegment(var1, var2);});
std::thread t(renderSegment, var1, std::ref(var2));
std::thread t(&A::renderSegment, var1, std::ref(var2));
std::thread t(&renderSegment, this, var1, std::ref(var2));

I want to call render(var1, var2) in the function renderSegment(). I've look at a couple of questons, like this

Start thread with member function

and this

C++11 multithreading with class member function

but nothing seems to work. Even when it looks like it should work, the compiler tells me that that I'm attempting to reference a deleted function std::thread::thread(const std::thread &).

I'm using C++17 and MVSC, for better or for worse. I haven't enabled any kind of special flags, but I was unable to find any that would explicitly enable multithreading in the program itself (there is one for multithreaded compilation).

How do I make it work?

EDIT: Here is longer, but real code:

Renderer.h

#include <glm/vec2.hpp>
#include <glm/vec3.hpp>

#include <complex>
#include <map>
#include <vector>

class State;

class Renderer {
public:
    void renderScene();
    Renderer(State& state);

private:
    State& m_state;

    void renderMandelbrot(int power);
    double mandelbrot(std::complex<double> c, int power);
    void renderSegment(
        int segmentStart,
        int segmentSize,
        int power,
        std::vector<std::vector<glm::vec3>>& colours);
};

Renderer.cpp

#include "Renderer.h"

#include "State.h"

#include <algorithm>
#include <thread>
#include <time.h>

void Renderer::renderScene() {
    renderMandelbrot(m_state.m_power);
}

Renderer::Renderer(State& state) :
    m_state(state) {

    std::srand(time(NULL));
    m_state.m_threadCount = std::thread::hardware_concurrency();
}

void Renderer::renderMandelbrot(int power) {
    std::vector<std::vector<glm::vec3>> colours;
    colours.resize(m_state.m_height);
    for (int i = 0; i < m_state.m_height; ++i) {
        colours[i].resize(m_state.m_width);
    }

    int segmentSize = m_state.m_height / m_state.m_threadCount;
    int segmentStart = 0;

    std::vector<std::thread> threads;

    for (int k = 0; k < m_state.m_threadCount - 1; ++k, segmentStart += segmentSize) {
        std::thread t = std::thread(&Renderer::renderMandelbrot, this,
            segmentStart,
            segmentStart + segmentSize,
            power,
            std::ref(colours));
        threads.push_back(t);
    }
    std::thread t = std::thread(&Renderer::renderMandelbrot, this,
            segmentStart,
            m_state.m_height,
            power,
            std::ref(colours));
        threads.push_back(t);

    for (auto& thread : threads) {
        thread.join();
    }
}

void Renderer::renderSegment(
    int segmentStart,
    int segmentEnd,
    int power,
    std::vector<std::vector<glm::vec3>>& colours) {

    for (int j = segmentStart; j < segmentEnd; ++j) {
        for (int i = 0; i < m_state.m_width; ++i) {
            colours[j][i] = glm::vec3(1.0f, 1.0f, 1.0f);
        }
    }
}

State is pretty much just a bunch of values, so I omitted the code for it.