{

VisualModel() {}

VisualModel (const sm::vec<float> _offset) { this->viewmatrix.translate (_offset); }

//! destroy gl buffers in the deconstructor

virtual ~VisualModel() // clang gives -Wdelete-non-abstract-non-virtual-dtor without virtual

{

// Explicitly clear owned VisualTextModels

this->texts.clear();

if (this->vbos != nullptr) {

GladGLContext* glfn = mplot::VisualResources<glver>::i().get_glfn (this->parentVis);

if (glfn) {

glfn->DeleteBuffers (this->numVBO, this->vbos.get());

glfn->DeleteVertexArrays (1, &this->vao);

}

}

}

//! Common code to call after the vertices have been set up. GL has to have been initialised.

void postVertexInit()

{

if (this->parentVis == std::numeric_limits<std::uint32_t>::max()) {

throw std::runtime_error ("parentVis is unset");

}

GladGLContext* glfn = mplot::VisualResources<glver>::i().get_glfn (this->parentVis);

// Do gl memory allocation of vertex array once only

if (this->vbos == nullptr) {

// Create vertex array object

glfn->GenVertexArrays (1, &this->vao); // Safe for OpenGL 4.4-

}

glfn->BindVertexArray (this->vao);

// Create the vertex buffer objects (once only)

if (this->vbos == nullptr) {

this->vbos = std::make_unique<std::uint32_t[]>(this->numVBO);

glfn->GenBuffers (this->numVBO, this->vbos.get()); // OpenGL 4.4- safe

}

// Set up the indices buffer - bind and buffer the data in this->indices

glfn->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, this->vbos[this->idxVBO]);

std::size_t sz = this->indices.size() * sizeof(std::uint32_t);

glfn->BufferData (GL_ELEMENT_ARRAY_BUFFER, sz, this->indices.data(), GL_STATIC_DRAW);

// Binds data from the "C++ world" to the OpenGL shader world for

// "position", "normalin" and "color"

// (bind, buffer and set vertex array object attribute)

this->setupVBO (this->vbos[this->posnVBO], this->vertexPositions, visgl::posnLoc);

this->setupVBO (this->vbos[this->normVBO], this->vertexNormals, visgl::normLoc);

this->setupVBO (this->vbos[this->colVBO], this->vertexColors, visgl::colLoc);

// Unbind only the vertex array (not the buffers, that causes GL_INVALID_ENUM errors)

glfn->BindVertexArray(0); // carefully unbind and rebind

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn);

if (this->flags.test (vm_bools::instanced)) {

// Here, we cause the SSBOs to be intialized if they haven't already, and we reserve

// some space in the SSBOs for *this model*

this->instance_start = mplot::VisualResources<glver>::i().init_instance_ssbo (this->parentVis, this->max_instances);

if (this->instance_start == std::numeric_limits<std::uint32_t>::max()) {

throw std::runtime_error ("Failed to reserve space in SSBO");

}

}

/*

if (this->flags.test (vm_bools::compute_bb)) {

if (this->vbos_bb == nullptr) { glfn->GenVertexArrays (1, &this->vao_bb); }

glfn->BindVertexArray (this->vao_bb);

// Create the vertex buffer objects (once only)

if (this->vbos_bb == nullptr) {

this->vbos_bb = std::make_unique<std::uint32_t[]>(this->numVBO);

glfn->GenBuffers (this->numVBO, this->vbos_bb.get());

}

// Set up the indices buffer - bind and buffer the data in this->indices

glfn->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, this->vbos_bb[this->idxVBO]);

std::size_t sz = this->indices_bb.size() * sizeof(std::uint32_t);

glfn->BufferData (GL_ELEMENT_ARRAY_BUFFER, sz, this->indices_bb.data(), GL_STATIC_DRAW);

// Binds data from the "C++ world" to the OpenGL shader world for

// "position", "normalin" and "color"

// (bind, buffer and set vertex array object attribute)

this->setupVBO (this->vbos_bb[this->posnVBO], this->vpos_bb, visgl::posnLoc);

this->setupVBO (this->vbos_bb[this->normVBO], this->vnorm_bb, visgl::normLoc);

this->setupVBO (this->vbos_bb[this->colVBO], this->vcol_bb, visgl::colLoc);

// Unbind only the vertex array (not the buffers, that causes GL_INVALID_ENUM errors)

glfn->BindVertexArray(0); // carefully unbind and rebind

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn);

}

this->flags.set (vm_bools::postVertexInitRequired, false);

}

//! Initialize vertex buffer objects and vertex array object. Empty for 'text only' VisualModels.

virtual void initializeVertices() {};

/*!

std::unique_ptr<mplot::VisualTextModel<glver>> makeVisualTextModel(const mplot::TextFeatures& tfeatures)

{

// No longer really worth having, as there is only the make_unique call

auto tmup = std::make_unique<mplot::VisualTextModel<glver>> (tfeatures);

tmup->set_parent (this->parentVis);

return tmup;

}

/*!

mplot::TextGeometry addLabel (const std::string& _text,

const sm::vec<float, 3>& _toffset,

const mplot::TextFeatures& tfeatures = mplot::TextFeatures())

{

if (mplot::VisualResources<glver>::i().get_tprog (this->parentVis) == 0) {

throw std::runtime_error ("No text shader prog. Did your VisualModel-derived class set it up?");

}

mplot::VisualResources<glver>::i().setContext (this->parentVis); // For VisualTextModel

auto tmup = this->makeVisualTextModel (tfeatures);

if (tfeatures.centre_horz == true) {

mplot::TextGeometry tg = tmup->getTextGeometry(_text);

sm::vec<float, 3> centred_locn = _toffset;

centred_locn[0] -= tg.half_width();

tmup->setupText (_text, centred_locn + this->viewmatrix.translation(), tfeatures.colour);

} else {

tmup->setupText (_text, _toffset + this->viewmatrix.translation(), tfeatures.colour);

}

this->texts.push_back (std::move(tmup));

// As this is a setup function, release the context

mplot::VisualResources<glver>::i().releaseContext();

return this->texts.back()->getTextGeometry();

}

/*!

mplot::TextGeometry addLabel (const std::string& _text,

const sm::vec<float, 3>& _toffset,

mplot::VisualTextModel<glver>*& tm,

const mplot::TextFeatures& tfeatures = mplot::TextFeatures())

{

if (mplot::VisualResources<glver>::i().get_tprog (this->parentVis) == 0) {

throw std::runtime_error ("No text shader prog. Did your VisualModel-derived class set it up?");

}

mplot::VisualResources<glver>::i().setContext (this->parentVis); // For VisualTextModel

auto tmup = this->makeVisualTextModel (tfeatures);

if (tfeatures.centre_horz == true) {

mplot::TextGeometry tg = tmup->getTextGeometry(_text);

sm::vec<float, 3> centred_locn = _toffset;

centred_locn[0] -= tg.half_width();

tmup->setupText (_text, centred_locn + this->viewmatrix.translation(), tfeatures.colour);

} else {

tmup->setupText (_text, _toffset + this->viewmatrix.translation(), tfeatures.colour);

}

this->texts.push_back (std::move(tmup));

tm = this->texts.back().get();

// As this is a setup function, release the context

mplot::VisualResources<glver>::i().releaseContext();

return this->texts.back()->getTextGeometry();

}

void setSceneMatrixTexts (const sm::mat<float, 4>& sv)

{

auto ti = this->texts.begin();

while (ti != this->texts.end()) { (*ti)->setSceneMatrix (sv); ti++; }

}

void setSceneTranslationTexts (const sm::vec<float>& v0)

{

auto ti = this->texts.begin();

while (ti != this->texts.end()) { (*ti)->setSceneTranslation (v0); ti++; }

}

void setViewRotationTexts (const sm::quaternion<float>& r)

{

// When rotating a model that contains texts, we need to rotate the scene

// for the texts and also inverse-rotate the view of the texts.

auto ti = this->texts.begin();

while (ti != this->texts.end()) {

// Rotate the scene. Note this won't work if the VisualModel has a

// translation away from the origin.

(*ti)->setSceneRotation (r); // Need this to rotate about _offset. BUT the

// translation is already there in the text,

// but in the MODEL view.

// Rotate the view of the text an opposite amount, to keep it facing forwards

(*ti)->setViewRotation (r.invert());

ti++;

}

}

void addViewRotationTexts (const sm::quaternion<float>& r)

{

auto ti = this->texts.begin();

while (ti != this->texts.end()) { (*ti)->addViewRotation (r); ti++; }

}

//! Process vertices and find the bounding box

void update_bb()

{

if (this->flags.test (vm_bools::compute_bb) == false) { return; }

if (this->vertexPositions.size() % 3 != 0) {

throw std::runtime_error ("VisualModelBase: vertexPositions size is not divisible by 3");

}

this->bb.search_init();

for (std::size_t i = 0; i < this->vertexPositions.size(); i += 3) {

this->bb.update (sm::vec<float>{ vertexPositions[i], vertexPositions[i+1], vertexPositions[i+2] });

}

// Construct the half-extent axis vectors, too.

const sm::vec<float> bb_ext = this->bb.span() / 2.0f;

this->bb_x = { bb_ext[0], 0, 0 }; // i.e. bb_ext[0] * sm::vec<>::ux();

this->bb_y = { 0, bb_ext[1], 0 };

this->bb_z = { 0, 0, bb_ext[2] };

// After finding the bounding box, make up the vertices to display it:

this->computeBoundingBox();

}

/*!

void reinit_buffers()

{

GladGLContext* glfn = mplot::VisualResources<glver>::i().get_glfn (this->parentVis);

mplot::VisualResources<glver>::i().setContext (this->parentVis);

if (this->flags.test (vm_bools::postVertexInitRequired) == true) { this->postVertexInit(); }

// Now re-set up the VBOs

glfn->BindVertexArray (this->vao); // carefully unbind and rebind

glfn->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, this->vbos[this->idxVBO]); // carefully unbind and rebind

std::size_t sz = this->indices.size() * sizeof(std::uint32_t);

glfn->BufferData (GL_ELEMENT_ARRAY_BUFFER, sz, this->indices.data(), GL_STATIC_DRAW);

this->setupVBO (this->vbos[this->posnVBO], this->vertexPositions, visgl::posnLoc);

this->setupVBO (this->vbos[this->normVBO], this->vertexNormals, visgl::normLoc);

this->setupVBO (this->vbos[this->colVBO], this->vertexColors, visgl::colLoc);

glfn->BindVertexArray(0); // carefully unbind and rebind

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn); // carefully unbind and rebind

// Optional bounding box

if (this->flags.test (vm_bools::compute_bb)) {

glfn->BindVertexArray (this->vao_bb);

glfn->BindBuffer (GL_ELEMENT_ARRAY_BUFFER, this->vbos_bb[this->idxVBO]);

std::size_t sz = this->indices_bb.size() * sizeof(std::uint32_t);

glfn->BufferData (GL_ELEMENT_ARRAY_BUFFER, sz, this->indices_bb.data(), GL_STATIC_DRAW);

this->setupVBO (this->vbos_bb[this->posnVBO], this->vpos_bb, visgl::posnLoc);

this->setupVBO (this->vbos_bb[this->normVBO], this->vnorm_bb, visgl::normLoc);

this->setupVBO (this->vbos_bb[this->colVBO], this->vcol_bb, visgl::colLoc);

glfn->BindVertexArray(0);

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn);

}

}

//! reinit ONLY vertexColors buffer

void reinit_colour_buffer()

{

mplot::VisualResources<glver>::i().setContext (this->parentVis);

if (this->flags.test (vm_bools::postVertexInitRequired) == true) { this->postVertexInit(); }

GladGLContext* glfn = mplot::VisualResources<glver>::i().get_glfn (this->parentVis);

// Now re-set up the VBOs

glfn->BindVertexArray (this->vao); // carefully unbind and rebind

this->setupVBO (this->vbos[this->colVBO], this->vertexColors, visgl::colLoc);

glfn->BindVertexArray(0); // carefully unbind and rebind

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn);

}

void clearTexts() { this->texts.clear(); }

//! Clear out the model, *including text models*

void clear()

{

this->vertexPositions.clear();

this->vertexNormals.clear();

this->vertexColors.clear();

this->indices.clear();

this->clearTexts();

this->idx = 0u;

// Clear bounding box

this->vpos_bb.clear();

this->vnorm_bb.clear();

this->vcol_bb.clear();

this->indices_bb.clear();

this->idx_bb = 0u;

this->reinit_buffers();

}

//! Re-create the model - called after updating data

void reinit()

{

mplot::VisualResources<glver>::i().setContext (this->parentVis);

// Fixme: Better not to clear, then repeatedly pushback here:

this->vertexPositions.clear();

this->vertexNormals.clear();

this->vertexColors.clear();

this->indices.clear();

// Clear any bounding box too

this->vpos_bb.clear();

this->vnorm_bb.clear();

this->vcol_bb.clear();

this->indices_bb.clear();

this->idx_bb = 0u;

// NB: Do NOT call clearTexts() here! We're only updating the model itself.

this->idx = 0u;

this->initializeVertices();

// Add additional meshgroups

for (auto mg : this->extra_meshgroups) { this->computeMeshgroup (mg); }

this->update_bb();

this->reinit_buffers();

}

/*!

void reinit_with_clearTexts()

{

mplot::VisualResources<glver>::i().setContext (this->parentVis);

this->vertexPositions.clear();

this->vertexNormals.clear();

this->vertexColors.clear();

this->indices.clear();

this->clearTexts();

this->idx = 0u;

// Clear any bounding box too

this->vpos_bb.clear();

this->vnorm_bb.clear();

this->vcol_bb.clear();

this->indices_bb.clear();

this->idx_bb = 0u;

this->initializeVertices();

for (auto mg : this->extra_meshgroups) { this->computeMeshgroup (mg); }

this->update_bb();

this->reinit_buffers();

}

void reserve_vertices (std::size_t n_vertices)

{

this->vertexPositions.reserve (3u * n_vertices);

this->vertexNormals.reserve (3u * n_vertices);

this->vertexColors.reserve (3u * n_vertices);

this->indices.reserve (6u * n_vertices);

}

// Make a hash of vertexPositions, etc as an identifier for this model. The hash identifies

// the model's mesh geometry for NavMesh and so the vertexColors are not important.

std::size_t hash() const

{

std::size_t h = 17;

for (std::size_t i = 0u; i < this->vertexPositions.size(); ++i) {

h = (h << 5) - 1 + std::hash<float>{}(this->vertexPositions[i]);

}

for (std::size_t i = 0u; i < this->vertexNormals.size(); ++i) {

h = (h << 5) - 1 + std::hash<float>{}(this->vertexNormals[i]);

}

for (std::size_t i = 0u; i < this->indices.size(); ++i) {

h = (h << 5) - 1 + std::hash<std::uint32_t>{}(this->indices[i]);

}

return h;

}

// Get a single position from vertexPositions, using the index into the vector<vec>

// interpretation of vertexPositions

sm::vec<float, 3> get_position (const std::uint32_t vec_idx) const

{

auto vp = reinterpret_cast<const std::vector<sm::vec<float, 3>>*>(&this->vertexPositions);

return (*vp)[vec_idx];

}

// Get a single normal from vertexNormals, using the index into the vector<vec>

// interpretation of vertexNormals

sm::vec<float, 3> get_normal (const std::uint32_t vec_idx) const

{

auto vn = reinterpret_cast<const std::vector<sm::vec<float, 3>>*>(&this->vertexNormals);

return (*vn)[vec_idx];

}

// Get the area of the triangle whose start index is vec_idx

float get_area (const std::uint32_t vec_idx0, const std::uint32_t vec_idx1, const std::uint32_t vec_idx2) const

{

auto vp = reinterpret_cast<const std::vector<sm::vec<float, 3>>*>(&this->vertexPositions);

auto t0 = (*vp)[vec_idx0];

auto t1 = (*vp)[vec_idx1];

auto t2 = (*vp)[vec_idx2];

return sm::geometry::tri_area (t0, t1, t2);

}

/**

// Our navigation mesh data struct

std::unique_ptr<mplot::NavMesh> navmesh;

void build_navmesh()

{

constexpr bool debug_mn = false;

if constexpr (debug_mn) { std::cout << __func__ << " called" << std::endl; }

if (!this->navmesh) { return; }

// Copy the bounding box

navmesh->bb = this->bb;

// Treat vertexPositions as a vector of vec:

auto vp = reinterpret_cast<const std::vector<sm::vec<float, 3>>*>(&this->vertexPositions);

std::uint32_t vps = vp->size();

std::unordered_map<sm::vec<float, 3>, std::set<std::uint32_t>, sm::vec<float, 3>::hash> equiv_v;

std::uint32_t i = 0;

for (auto p : *vp) { equiv_v[p].insert (i++); }

std::map<std::uint32_t, std::set<std::uint32_t>> equiv;

for (auto e : equiv_v) { equiv[*e.second.begin()] = e.second; }

if constexpr (debug_mn) {

for (auto e : equiv) {

std::cout << "build_navmesh: equiv[" << e.first << "] = ";

for (auto idx : e.second) { std::cout << idx << ","; }

std::cout << std::endl;

}

std::cout << "build_navmesh: Populated equiv which has " << equiv.size() << " vvecs" << std::endl;

}

// Make inverse of equiv to translate from original (indices, vertexPositions) index to

// new topographic mesh index

sm::vvec<std::uint32_t> navmesh_idx (vps, 0);

std::uint32_t vcount = 0;

i = 0;

for (auto eqs : equiv) {

vcount += eqs.second.size();

for (auto ev : eqs.second) {

if constexpr (debug_mn) {

std::cout << "build_navmesh: set navmesh_idx[" << ev << "] = " << i << std::endl;

}

navmesh_idx[ev] = i;

}

++i;

}

if constexpr (debug_mn) { std::cout << "build_navmesh: Created equiv inverse" << std::endl; }

if (vcount != vps) {

std::cout << "build_navmesh: WARNING: Vertex count from equiv is " << vcount

<< " which should (but does not) equal " << vps << std::endl;

}

// Can now populate vertex, a vector of coordinates, if required, or simply access (*vp)

// as needed using equiv.first

navmesh->vertex.resize (equiv.size(), mesh::vertex{});

i = 0;

for (auto eq : equiv) {

navmesh->vertex[i++] = { (*vp)[eq.first], std::numeric_limits<std::uint32_t>::max() };

}

// We're turing a triangle mesh into a navmesh. Don't know what to do if there are stray vertices.

if (this->indices.size() % 3u != 0u) {

throw std::runtime_error ("Uh oh, indices size not divisible by 3!!!! Call the cops!");

}

// Lastly, generate edges. For which we require use of indices, which is expressed in

// terms of the old indices. That lookup is navmesh_idx.

for (std::uint32_t i = 0; i < this->indices.size(); i += 3) {

// Add three halfedges for the triangle

const std::uint32_t hesz = navmesh->halfedge.size();

const std::uint32_t he0 = hesz;

const std::uint32_t he1 = hesz + 1;

const std::uint32_t he2 = hesz + 2;

if constexpr (debug_mn) {

std::cout << "setting halfedge["<< he0 << "] to { {"

<< navmesh_idx[indices[i]] << ", " << navmesh_idx[indices[i + 1]]

<< "}, nullptr, " << he1 << ", " << he2 << " }" << std::endl;

std::cout << "setting halfedge[" << he1 << "] to { {"

<< navmesh_idx[indices[i + 1]] << ", " << navmesh_idx[indices[i + 2]]

<< "}, nullptr, " << he2 << ", " << he0 << " }" << std::endl;

std::cout << "setting halfedge[" << he2 << "] to { {"

<< navmesh_idx[indices[i + 2]] << ", " << navmesh_idx[indices[i]]

<< "}, nullptr, " << he0 << ", " << he1 << " }" << std::endl;

}

navmesh->halfedge.resize (hesz + 3, {});

// Now, could also try to identify LINES

navmesh->halfedge[he0] = { {navmesh_idx[indices[i ]], navmesh_idx[indices[i + 1]]}, std::numeric_limits<std::uint32_t>::max(), he1, he2, 0u };

navmesh->halfedge[he1] = { {navmesh_idx[indices[i + 1]], navmesh_idx[indices[i + 2]]}, std::numeric_limits<std::uint32_t>::max(), he2, he0, 0u };

navmesh->halfedge[he2] = { {navmesh_idx[indices[i + 2]], navmesh_idx[indices[i ]]}, std::numeric_limits<std::uint32_t>::max(), he0, he1, 0u };

if constexpr (debug_mn) {

std::cout << "halfedge["<< hesz << "] contains: vi:"

<< navmesh->halfedge[hesz].vi

<< ", twin:" << navmesh->halfedge[hesz].twin

<< ", next:" << navmesh->halfedge[hesz].next

<< ", prev:" << navmesh->halfedge[hesz].prev << std::endl;

}

// A face contains just the first half edge index

mesh::face<> t = { he0 };

// The normal vector for this triangle could be obtained from the mesh normals, but

// we can't trust them (though they're easy to get, as we're dealing with indices

// already). However, use this to ensure that our triangle indices order is in

// agreement with mesh normal as far as direction goes.

sm::vec<float> tn = this->get_normal (indices[i]) + this->get_normal (indices[i + 1]) + this->get_normal (indices[i + 2]) ;

tn.renormalize();

// Compute trinorm as well and compare with the one from the mesh - perhaps it's

// different? We really want the right normal.

const sm::vec<float>& tv0 = navmesh->vertex[navmesh_idx[indices[i]]].p;

const sm::vec<float>& tv1 = navmesh->vertex[navmesh_idx[indices[i + 1]]].p;

const sm::vec<float>& tv2 = navmesh->vertex[navmesh_idx[indices[i + 2]]].p;

sm::vec<float> nx = (tv1 - tv0);

sm::vec<float> ny = (tv2 - tv0);

sm::vec<float> n = nx.cross (ny);

n.renormalize();

// Check rotational sense of triangles

if (n.dot (tn) < 0.0f) {

std::cout << "Swap order of triangle with he " << he0 << std::endl;

// Swap first and last half edge

navmesh->halfedge[he0].vi.rotate();

navmesh->halfedge[he1].vi.rotate();

navmesh->halfedge[he2].vi.rotate();

}

navmesh->triangles.push_back (t);

}

if constexpr (debug_mn) {

std::cout << "build_navmesh: Created triangles (" << navmesh->halfedge.size() << " halfedges)" << std::endl;

}

navmesh->compute_neighbour_relations(); // finds the halfedge twins

}

/*!

void make_navmesh (std::string navmesh_dir = "")

{

if (this->navmesh) { return; } // already made it

if (this->flags.test (vm_bools::compute_bb) == false) {

throw std::runtime_error ("make_navmesh requires compute_bb flag to be true");

}

this->update_bb();

// Create a new navmesh

this->navmesh = std::make_unique<mplot::NavMesh>();

// Have we got a pre-computed navmesh file for the halfedge twin relationships?

std::uint64_t h = this->hash();

if (navmesh_dir.empty()) {

navmesh_dir = mplot::tools::getTmpPath();

} else {

if (navmesh_dir.back() != '/') { navmesh_dir += "/"; }

}

std::string filename = navmesh_dir + std::string("navmesh_") + std::to_string (h);

std::string filename_pre_boundary = filename + ".pre";

constexpr bool just_mark = true;

if (mplot::tools::fileExists (filename)) {

this->navmesh->load (filename);

std::cout << "Full test...\n";

this->navmesh->test();

} else if (mplot::tools::fileExists (filename_pre_boundary)) {

std::cout << "Pre-boundary navmesh\n";

this->navmesh->load (filename_pre_boundary);

this->navmesh->add_boundary_halfedges();

this->navmesh->test (just_mark);

this->navmesh->save (filename);

} else {

std::cout << "Building NavMesh to save into file " << filename << std::endl;

this->build_navmesh();

this->navmesh->save (filename_pre_boundary);

this->navmesh->add_boundary_halfedges();

this->navmesh->test (just_mark);

this->navmesh->save (filename);

}

}

/**

/*!

void finalize()

{

mplot::VisualResources<glver>::i().setContext (this->parentVis); // need context? yes for text.

this->initializeVertices();

for (auto mg : this->extra_meshgroups) { this->computeMeshgroup (mg); }

this->update_bb();

this->flags.set (vm_bools::postVertexInitRequired, true);

// Release context after creating and finalizing this VisualModel. On Visual::render(),

// context will be re-acquired.

mplot::VisualResources<glver>::i().releaseContext();

}

static constexpr bool debug_render = false;

//! Render the VisualModel. Note that it is assumed that the OpenGL context has been

//! obtained by the parent Visual::render call.

virtual void render() // not final

{

if (this->hidden() == true) { return; }

// Execute post-vertex init at render, as GL should be available.

if (this->flags.test (vm_bools::postVertexInitRequired) == true) { this->postVertexInit(); }

std::int32_t prev_shader = 0;

GladGLContext* glfn = mplot::VisualResources<glver>::i().get_glfn (this->parentVis);

glfn->GetIntegerv (GL_CURRENT_PROGRAM, &prev_shader);

// Ensure the correct program is in play for this VisualModel

std::uint32_t gprog = mplot::VisualResources<glver>::i().get_gprog (this->parentVis);

glfn->UseProgram (gprog);

if (!this->indices.empty()) {

// glPolygonMode is OpenGL only and not supported on GL ES

if constexpr (mplot::gl::version::gles (glver) == false) {

// Enable/disable wireframe mode per-model on each render call

if (this->flags.test (vm_bools::wireframe)) {

glfn->PolygonMode (GL_FRONT_AND_BACK, GL_LINE);

} else {

glfn->PolygonMode (GL_FRONT_AND_BACK, GL_FILL);

}

}

// It is only necessary to bind the vertex array object before rendering

// (not the vertex buffer objects)

glfn->BindVertexArray (this->vao);

// Pass this->float to GLSL so the model can have an alpha value.

std::int32_t loc_a = glfn->GetUniformLocation (gprog, static_cast<const char*>("alpha"));

if (loc_a != -1) { glfn->Uniform1f (loc_a, this->alpha); }

std::int32_t loc_gr = glfn->GetUniformLocation (gprog, static_cast<const char*>("greyscale"));

if (loc_gr != -1) { glfn->Uniform1i (loc_gr, (this->flags.test (vm_bools::greyscale) ? 1 : 0)); }

std::int32_t loc_gam = glfn->GetUniformLocation (gprog, static_cast<const char*>("gamma"));

if (loc_gam != -1) { glfn->Uniform1f (loc_gam, this->gamma); }

// The scene-view matrix

std::int32_t loc_v = glfn->GetUniformLocation (gprog, static_cast<const char*>("v_matrix"));

if (loc_v != -1) { glfn->UniformMatrix4fv (loc_v, 1, GL_FALSE, this->scenematrix.arr.data()); }

// the model-view matrix

std::int32_t loc_m = glfn->GetUniformLocation (gprog, static_cast<const char*>("m_matrix"));

if (loc_m != -1) { glfn->UniformMatrix4fv (loc_m, 1, GL_FALSE, this->viewmatrix.arr.data()); }

// the instance scaling matrix (applied to all instances)

std::int32_t loc_s = glfn->GetUniformLocation (gprog, static_cast<const char*>("s_matrix"));

if (loc_s != -1) { glfn->UniformMatrix4fv (loc_s, 1, GL_FALSE, this->instscale.arr.data()); }

if constexpr (debug_render) {

std::cout << "VisualModel::render: scenematrix:\n" << this->scenematrix << std::endl;

std::cout << "VisualModel::render: model viewmatrix:\n" << this->viewmatrix << std::endl;

}

// Draw the triangles

std::int32_t loc_is = glfn->GetUniformLocation (gprog, static_cast<const char*>("instance_start"));

std::int32_t loc_ic = glfn->GetUniformLocation (gprog, static_cast<const char*>("instance_count"));

std::int32_t loc_ipc = glfn->GetUniformLocation (gprog, static_cast<const char*>("instparam_count"));

if (this->flags.test (vm_bools::instanced)) {

if (loc_is != -1) { glfn->Uniform1i (loc_is, this->instance_start); }

if (loc_ic != -1) { glfn->Uniform1i (loc_ic, this->instance_count); }

if (loc_ipc != -1) { glfn->Uniform1i (loc_ipc, this->instparam_count); }

glfn->DrawElementsInstanced (GL_TRIANGLES, static_cast<std::uint32_t>(this->indices.size()), GL_UNSIGNED_INT, 0, this->instance_count);

} else {

if (loc_is != -1) { glfn->Uniform1i (loc_is, -1); }

if (loc_ic != -1) { glfn->Uniform1i (loc_ic, -1); }

glfn->DrawElements (GL_TRIANGLES, static_cast<std::uint32_t>(this->indices.size()), GL_UNSIGNED_INT, 0);

}

// Unbind the VAO

glfn->BindVertexArray(0);

// Do the bounding box optionally

if (this->flags.test (vm_bools::compute_bb) && this->flags.test (vm_bools::show_bb) && !this->indices_bb.empty()) {

glfn->BindVertexArray (this->vao_bb);

glfn->DrawElements (GL_TRIANGLES, static_cast<std::uint32_t>(this->indices_bb.size()), GL_UNSIGNED_INT, 0);

glfn->BindVertexArray(0);

}

}

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn);

// Now render any VisualTextModels

if constexpr (mplot::gl::version::gles (glver) == false) {

glfn->PolygonMode (GL_FRONT_AND_BACK, GL_FILL);

}

auto ti = this->texts.begin();

while (ti != this->texts.end()) { (*ti)->render(); ti++; }

glfn->UseProgram (prev_shader);

mplot::gl::Util::checkError (__FILE__, __LINE__, glfn);

}

//! Setter for the viewmatrix

void setViewMatrix (const sm::mat<float, 4>& mv) { this->viewmatrix = mv; }

//! And a getter

sm::mat<float, 4> getViewMatrix() const { return this->viewmatrix; }

//! Pre or post-multiply

void postmultViewMatrix (const sm::mat<float, 4>& m) { this->viewmatrix = this->viewmatrix * m; }

void premultViewMatrix (const sm::mat<float, 4>& m) { this->viewmatrix = m * this->viewmatrix; }

void scaleViewMatrix (const float by) { this->viewmatrix.scale (by); }

//! When setting the scene matrix, also have to set the text's scene matrices.

void setSceneMatrix (const sm::mat<float, 4>& sv)

{

this->scenematrix = sv;

this->setSceneMatrixTexts (sv);

}

//! Set a translation into the scene and into any child texts

template <std::size_t N = 3> requires (N == 3) || (N == 4)

void setSceneTranslation (const sm::vec<float, N>& v0)

{

this->scenematrix.set_identity();

this->scenematrix.translate (v0);

if constexpr (N == 4) {

this->setSceneTranslationTexts (v0.less_one_dim());

} else {

this->setSceneTranslationTexts (v0);

}

}

//! Set a translation (only) into the scene view matrix

template <std::size_t N = 3> requires (N == 3) || (N == 4)

void addSceneTranslation (const sm::vec<float, N>& v0) { this->scenematrix.pretranslate (v0); }

//! Set a rotation (only) into the scene view matrix

void setSceneRotation (const sm::quaternion<float>& r)

{

this->scenematrix.set_identity();

this->scenematrix.rotate (r);

}

//! Add a rotation to the scene view matrix

void addSceneRotation (const sm::quaternion<float>& r) { this->scenematrix.rotate (r); }

//! Set a translation to the model view matrix

template <std::size_t N = 3> requires (N == 3) || (N == 4)

void setViewTranslation (const sm::vec<float, N>& v0)

{

this->viewmatrix.set_identity();

this->viewmatrix.translate (v0);

}

//! Add a translation to the model view matrix

template <std::size_t N = 3> requires (N == 3) || (N == 4)

void addViewTranslation (const sm::vec<float, N>& v0) { this->viewmatrix.pretranslate (v0); }

//! Set a rotation (only) into the view, but keep texts fixed

void setViewRotationFixTexts (const sm::quaternion<float>& r)

{

sm::vec<> os = this->viewmatrix.translation();

this->viewmatrix.set_identity();

this->viewmatrix.translate (os);

this->viewmatrix.rotate (r);

}

//! Set a rotation (only) into the view

void setViewRotation (const sm::quaternion<float>& r)

{

sm::vec<> os = this->viewmatrix.translation();

this->viewmatrix.set_identity();

this->viewmatrix.translate (os);

this->viewmatrix.rotate (r);

this->setViewRotationTexts (r);

}

//! Apply a further rotation to the model view matrix

void addViewRotation (const sm::quaternion<float>& r)

{

this->viewmatrix.rotate (r);

this->addViewRotationTexts (r);

}

//! Apply a further rotation to the model view matrix, but keep texts fixed

void addViewRotationFixTexts (const sm::quaternion<float>& r)

{

this->viewmatrix.rotate (r);

}

// The alpha attribute accessors

void setAlpha (const float _a) { this->alpha = _a; }

float getAlpha() const { return this->alpha; }

void incAlpha()

{

this->alpha += 0.1f;

this->alpha = this->alpha > 1.0f ? 1.0f : this->alpha;

}

void decAlpha()

{

this->alpha -= 0.1f;

this->alpha = this->alpha < 0.0f ? 0.0f : this->alpha;

}

void setGamma (const float _g) { this->gamma = _g; }

float getGamma () const { return this->gamma; }

// The hide attribute accessors

void setHide (const bool _h = true) { this->flags.set (vm_bools::hide, _h); }

void toggleHide() { this->flags.flip (vm_bools::hide); }

bool hidden() const { return this->flags.test (vm_bools::hide); }

/*

//! Get model translation in a json-friendly string

std::string translation_str() { return this->viewmatrix.translation().str_mat(); }

//! A getter for the viewmatrix translation of the origin (would be same as viewmatrix.translation)

sm::vec<float> get_viewmatrix_origin() const

{

return (this->viewmatrix * sm::vec<float, 3>{0,0,0}).less_one_dim();

}

//! The centre of mass of the bounding box may not be the VisualModel's origin

sm::vec<float> get_viewmatrix_bb_centre() const

{

return (this->viewmatrix * this->bb.mid()).less_one_dim();

}

//! Apply the viewmatrix to the model's bounding box and return it. You probably don't want

//! this, instead, get_viewmatrix_obb gets the oriented bounding box, and with that you can

//! collision detect with the separarating axis theorem.

sm::interval<sm::vec<float>> get_viewmatrix_modelbb() const

{

sm::interval<sm::vec<float>> vmbb;

vmbb.min = (this->viewmatrix * this->bb.min).less_one_dim();

vmbb.max = (this->viewmatrix * this->bb.max).less_one_dim();

return vmbb;

}

/*!

sm::mat<float, 3, 4> get_viewmatrix_obb (const sm::mat<float, 4>& _viewmatrix) const

{

const sm::vec<float> bb_centre = this->bb.mid();

const sm::vec<float> obb_x_end = (_viewmatrix * (bb_centre + this->bb_x)).less_one_dim();

const sm::vec<float> obb_y_end = (_viewmatrix * (bb_centre + this->bb_y)).less_one_dim();

const sm::vec<float> obb_z_end = (_viewmatrix * (bb_centre + this->bb_z)).less_one_dim();

const sm::vec<float> obb_centre = (_viewmatrix * bb_centre).less_one_dim();

sm::mat<float, 3, 4> obb;

obb.set_col (0, obb_centre);

obb.set_col (1, obb_x_end - obb_centre);

obb.set_col (2, obb_y_end - obb_centre);

obb.set_col (3, obb_z_end - obb_centre);

return obb;

}

/*!

sm::mat<float, 3, 4> get_viewmatrix_obb() const { return this->get_viewmatrix_obb (this->viewmatrix); }

/*!