How can I print teapot on the screen?

[Kyrie0508]

Body

I am writing code to import obj and apply environmental mapping using opengl. First of all, I succeeded in displaying the skybox texture on the screen using cubemap. However, I failed to apply environmental mapping by loading the obj file in teapot.
This is the Trimesh class that I defined

class TriMesh
{
public:
    int NumVertices;
    int NumTris;

    // buffers for graphics rendering 
    GLuint vao;
    GLuint vbo;
    GLuint ebo; // element buffer object for vertex indices

    std::vector<glm::vec4> vertices;
    std::vector<glm::vec3> normals;
    std::vector<glm::vec2> texCoords;

    glm::vec3 color;
    glm::mat4 modelTransform;

    std::vector<unsigned int> indices;

    // Aux. variables for geometry
    glm::vec3 bboxMin; // the lower left corner of the bounding box 
    glm::vec3 bboxMax; // the upper right corner of the bounding box
    glm::vec3 objCenter; // center point of the object

    TriMesh() : NumVertices(0), NumTris(0) {}
    ~TriMesh() {
	// Free GPU buffers 
	glDeleteBuffers(1, &vbo);
	glDeleteBuffers(1, &ebo);
	glDeleteVertexArrays(1, &vao);
    }

    void clear()
    {
	vertices.clear();
	normals.clear();
	texCoords.clear();
	indices.clear();
    }

    void initGL(GLuint shaderId) {
	if (NumVertices < 1 || NumTris < 1) {
	    std::cout << "Error - create the geometry first!\n";
	    return;
	}

	glGenVertexArrays(1, &vao);
	glGenBuffers(1, &vbo);
	glGenBuffers(1, &ebo);

	glBindVertexArray(vao);
	glBindBuffer(GL_ARRAY_BUFFER, vbo);
	glBufferData(GL_ARRAY_BUFFER,
	    sizeof(glm::vec4) * vertices.size() +
	    sizeof(glm::vec3) * normals.size() +
	    sizeof(glm::vec2) * texCoords.size(),
	    NULL, GL_STATIC_DRAW);

	// Specify an offset to keep track of where we're placing data in our
	//   vertex array buffer.  We'll use the same technique when we
	//   associate the offsets with vertex attribute pointers.
	GLintptr offset = 0;
	glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::vec4) * vertices.size(),
	    vertices.data());
	offset += sizeof(glm::vec4) * vertices.size();

	glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::vec3) * normals.size(),
	    normals.data());
	offset += sizeof(glm::vec3) * normals.size();

	glBufferSubData(GL_ARRAY_BUFFER, offset, sizeof(glm::vec2) * texCoords.size(),
	    texCoords.data());

	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * indices.size(),
	    indices.data(), GL_STATIC_DRAW);

	// link to in variables in the shaders
	offset = 0;
	glEnableVertexAttribArray(0);
	glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset));
	offset += sizeof(glm::vec4) * vertices.size();

	glEnableVertexAttribArray(1);
	glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset));
	offset += sizeof(glm::vec3) * normals.size();

	glEnableVertexAttribArray(2);
	glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(offset));
    std::cout << "VAO ID: " << vao << std::endl;
    std::cout << "VBO ID: " << vbo << std::endl;
    std::cout << "EBO ID: " << ebo << std::endl;
    }

    void render() {
	//set a constant color
	//glUniform3fv(color_loc, 1, glm::value_ptr(color));
	//glUniformMatrix4fv(model, 1, GL_FALSE, glm::value_ptr(modelTransform));

	glBindVertexArray(vao);
	glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    }

    // Create an axis-aligned bounding box of the object
    void buildBoundingBox() {
	if (vertices.empty())
	    return;

	bboxMin = glm::vec3(FLT_MAX, FLT_MAX, FLT_MAX);
	bboxMax = glm::vec3(-FLT_MAX, -FLT_MAX, -FLT_MAX);

	for (size_t i = 0; i < vertices.size(); i++) {
	    for (int k = 0; k < 3; k++) {
		if (vertices[i][k] < bboxMin[k])
		    bboxMin[k] = vertices[i][k];
		if (vertices[i][k] > bboxMax[k])
		    bboxMax[k] = vertices[i][k];
	    }
	}
	objCenter = (bboxMin + bboxMax) * 0.5f;
    }

    // Set the model transformation matrix of the object so that
    // the centroid of the object becomes  the origin and the
    // size of object becomes the order of magnitude of 1 
    // after transformation
    void scaleObjectWithBBox(bool verbose = false) {
	buildBoundingBox();

	// Find the longest side of the bounding box 
	glm::vec3 objScale = bboxMax - bboxMin;

	float maxScale = objScale[0];
	maxScale = (objScale[1] > maxScale) ? objScale[1] : maxScale;
	maxScale = (objScale[2] > maxScale) ? objScale[2] : maxScale;

	if (verbose) {
	    std::cout << "Size of the bounding box = (" <<
		objScale[0] << "," << objScale[1] << "," << objScale[2] << ")\n";
	    std::cout << "Scale applied = " << (1 / maxScale) << "\n";
	    std::cout << "Object center = (" <<
		objCenter[0] << "," << objCenter[1] << "," << objCenter[2] << ")\n";
	}

	// Scale the object by 1/maxScale
	modelTransform = glm::mat4(1.0f);
	modelTransform = glm::scale(modelTransform, glm::vec3(1.0f / maxScale));
	modelTransform = glm::translate(modelTransform, -objCenter);
    }
};

In this class, I wrote what I need for the render of teapot. In addition, I wrote the function to load the obj file as follows.

void loadTeapot(CObjLoader& loader, const char* filepath, TriMesh& mesh) {
    
    if (!loader.Load("teapot_normal_inverted.obj")) {
        std::cerr << "Failed to load OBJ file: teapot_normal_inverted.obj" << std::endl;
        return;
    }


    for (const auto& vertex : loader.vertexes) {
        mesh.vertices.push_back(glm::vec4(vertex, 1.0f)); 
    }

    for (const auto& normal : loader.normals) {
        mesh.normals.push_back(normal);
    }

    for (const auto& texcoord : loader.texcoords) {
        mesh.texCoords.push_back(texcoord); 
    }


    for (const auto& part : loader.parts) {
        for (const auto& face : part.faces) {
            for (int i = 0; i < face.n; ++i) {
                mesh.indices.push_back(face.v[i] - 1); 
            }
        }
    }


    mesh.NumVertices = mesh.vertices.size();
    mesh.NumTris = mesh.indices.size() / 3;

    mesh.buildBoundingBox();
    mesh.scaleObjectWithBBox();

}

However, when I ran the code, I could see the texture of the skybox but not the teapot. In other words, my question is, please let me know what I can modify to show the teapot on the screen. No error messages are currently output in debugging.

Guidelines

• I have read and understood this category's guidelines before making this post.

[pwoltschk]

I see in your render() function, modelTransform matrix upload is commented out.

    void render() {
	//set a constant color
	//glUniform3fv(color_loc, 1, glm::value_ptr(color));
	//glUniformMatrix4fv(model, 1, GL_FALSE, glm::value_ptr(modelTransform));

	glBindVertexArray(vao);
	glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);
    }

[github-actions[bot]]

💬 Your Product Feedback Has Been Submitted 🎉

Thank you for taking the time to share your insights with us! Your feedback is invaluable as we build a better GitHub experience for all our users.

Here's what you can expect moving forward ⏩

• Your input will be carefully reviewed and cataloged by members of our product teams. 
  • Due to the high volume of submissions, we may not always be able to provide individual responses.
  • Rest assured, your feedback will help chart our course for product improvements.
• Other users may engage with your post, sharing their own perspectives or experiences. 
• GitHub staff may reach out for further clarification or insight. 
  • We may 'Answer' your discussion if there is a current solution, workaround, or roadmap/changelog post related to the feedback.

Where to look to see what's shipping 👀

• Read the Changelog for real-time updates on the latest GitHub features, enhancements, and calls for feedback.
• Explore our Product Roadmap, which details upcoming major releases and initiatives.

What you can do in the meantime 💻

• Upvote and comment on other user feedback Discussions that resonate with you.
• Add more information at any point! Useful details include: use cases, relevant labels, desired outcomes, and any accompanying screenshots.

As a member of the GitHub community, your participation is essential. While we can't promise that every suggestion will be implemented, we want to emphasize that your feedback is instrumental in guiding our decisions and priorities.

Thank you once again for your contribution to making GitHub even better! We're grateful for your ongoing support and collaboration in shaping the future of our platform. ⭐