Inportador de modelos OBJ de Blender multi-texturas

[navbuoy]

El otro dia me puse durante la noche, que es cuando mejor programo, por aquello de que no hay muchos ruidos de la calle, coches etc
y hice este codigo en C++ Builder para importar modelos OBJ exportados desde Blender y otros programas el cual carga el modelo OBJ
y tambien la informacion referente a las texturas del archivo MTL asociado, funciona muy bien ya lo veréis si lo probais

de momento dejo en vuestras manos el tema de los includes necesarios (yo los tengo en la carpeta include de Rad Studio en Archivos de Programa (x86)

y recordad que tambien necesita el glew.c agregado al proyecto y los lib de glew32 etc
no esta del todo "saneado" el codigo ya que hay cosas ahi y funciones que estan pero no utilizo, espero que podais analizarlo bien pero asi como esta funciona
por ejemplo la funcion LoadBMPTexture ya no la utiliza sino que usa la de LoadPNGTexture y la de DrawModelWithTexture tampoco la uso sino que uso la de DrawModelWithMultipleTextures

Unit11.h

//---------------------------------------------------------------------------

#ifndef Unit11H
#define Unit11H
//---------------------------------------------------------------------------
#include <System.Classes.hpp>
#include <Vcl.Controls.hpp>
#include <Vcl.StdCtrls.hpp>
#include <Vcl.Forms.hpp>
#include "acPNG.hpp"
#include <Vcl.ExtCtrls.hpp>
//---------------------------------------------------------------------------
class TForm11 : public TForm
{
__published:	// IDE-managed Components
	TImage *Image1;
	TPanel *Panel1;
	void __fastcall FormDestroy(TObject *Sender);
private:	// User declarations
public:		// User declarations
	__fastcall TForm11(TComponent* Owner);
void __fastcall Timer1Timer(TObject *Sender);
void __fastcall InitScene();
void __fastcall DrawScene();
void __fastcall DrawScene_New();
};
//---------------------------------------------------------------------------
extern PACKAGE TForm11 *Form11;
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------

#include <vcl.h>
#include <Vcl.Imaging.pngimage.hpp>

#include <GL/glew.h>

#include <stdio.h>
#include <conio.h>
#include <stdlib.h>


// Incluir GLFW
#include <GL/glfw3.h>

// Incluir GLM
#include <glm/glm.hpp>

using namespace glm;

#include <GL/glut.h>
#include <GL/gl.h>    // OpenGL
#include <GL/glu.h>   // Utilidades de OpenGL

#include <tiny_obj_loader.h>
#include <FreeImage.h> // Para cargar imágenes BMP o JPG

//Estos include puede que no sean del todo necesarios ya que los planeo usar para cuando texturice
#include <iostream>
#include <fstream> // Necesario para std::ifstream
#include <sstream>
#include <vector>  // Necesario para std::vector
#include <algorithm> // Necesario para std::swap
#include <string>

#pragma hdrstop

#include "Unit11.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)
#pragma link "acPNG"
#pragma resource "*.dfm"
TForm11 *Form11;

void InitializeOpenGL(TPanel* Panel);
bool LoadOBJModel(const std::string& filename, const std::string& texturePath);
GLuint LoadBMPTexture(const char* filename);
GLuint LoadTexture(const char* filename);
void CloseOpenGL(void);

void LoadMTL(const std::string& path);
void DrawModelWithMaterials();
void DrawModelWithMultipleTextures();
void InitTextures();
GLuint LoadPNGTexture(const char* filename);

// Variables globales para el manejo del contexto de OpenGL
HDC hdc;
HGLRC hrc;
GLuint textureID, textureID1, textureID2, defaultTextureID;  //esto ya no es necesario, ahora maneja las texturas con InitTextures()
float rotationAngle = 0.0f;
bool inicio = true;
std::vector<GLuint> textureIDs;  // Vector para almacenar las IDs de las texturas

// Crear un objeto TPngImage para cargar la imagen PNG
	TPngImage *pngImage = new TPngImage();


// Variables globales para almacenar el modelo
	tinyobj::attrib_t attrib;
	std::vector<tinyobj::shape_t> shapes;
	std::vector<tinyobj::material_t> materials;
	std::string warn, err;

// Estructura para almacenar el modelo cargado
struct ModelData {
	std::vector<float> vertices;
	std::vector<float> normals;
	std::vector<float> texcoords;
	std::vector<unsigned int> indices;
};

ModelData model;

 // Estructura para almacenar vértices y coordenadas de textura
struct Vertex {
	float x, y, z;
};
struct TexCoord {
	float u, v;
};
std::vector<Vertex> vertices;
std::vector<TexCoord> texCoords;



//---------------------------------------------------------------------------
__fastcall TForm11::TForm11(TComponent* Owner)
	: TForm(Owner)
{
  InitializeOpenGL(Panel1);
  InitScene();

	TTimer *Timer1 = new TTimer(this);
	Timer1->Interval = 16;  // Aproximadamente 60 fps
	Timer1->OnTimer = Timer1Timer;
}
//---------------------------------------------------------------------------

void LoadOBJModel2(const std::string& path, const std::string& path_mtl) {
	bool ret = tinyobj::LoadObj(&attrib, &shapes, &materials, &warn, &err, path.c_str(), path_mtl.c_str());
	if (!ret) {
		ShowMessage("Error al cargar modelo OBJ");
		return;
	}

		if (!warn.empty()) {
		ShowMessage("Error al cargar modelo OBJ:" + AnsiString(warn.c_str()));
		return;
	}

		if (!err.empty()) {
		ShowMessage("Error al cargar modelo OBJ" + AnsiString(err.c_str()));
		return;
	}
	// Procesar vértices y coordenadas de textura
	for (const auto& shape : shapes) {
		for (const auto& index : shape.mesh.indices) {
			Vertex v = { attrib.vertices[3 * index.vertex_index + 0],
						 attrib.vertices[3 * index.vertex_index + 1],
						 attrib.vertices[3 * index.vertex_index + 2] };
			vertices.push_back(v);
			if (!attrib.texcoords.empty()) {
				TexCoord tc = { attrib.texcoords[2 * index.texcoord_index + 0],
								attrib.texcoords[2 * index.texcoord_index + 1] };
				texCoords.push_back(tc);
			}
		}
	}
}




void InitTextures() {
	// Reserva espacio para las texturas (tantas como materiales tenga el modelo)
    textureIDs.resize(materials.size());
    for (size_t i = 0; i < materials.size(); i++) {
        if (!materials[i].diffuse_texname.empty()) {
            // Cargar la textura BMP usando  función LoadPNGTexture
			textureIDs[i] = LoadPNGTexture(materials[i].diffuse_texname.c_str());
			//ShowMessage(materials[i].diffuse_texname.c_str());
            if (textureIDs[i] == 0) {
				ShowMessage("Error loading texture: " + AnsiString(materials[i].diffuse_texname.c_str()));
			}
		}
	}
}


GLuint LoadPNGTexture(const char* filename)
{
  GLuint texID = 0;

  // cargar la imagen PNG
  pngImage->LoadFromFile(filename);

  // Crear un array para los datos de la textura
		unsigned char* data = new unsigned char[pngImage->Width * pngImage->Height * 4]; // RGBA
        // Copiar los datos de la imagen a la textura
		for (int y = 0; y < pngImage->Height; y++) {
			for (int x = 0; x < pngImage->Width; x++) {
				// Asumimos que la imagen está en formato RGBA
               TColor color = pngImage->Pixels[x][pngImage->Height - 1 - y]; // Ajustar el orden de y para la coordenada Y
				data[(y * pngImage->Width + x) * 4 + 0] = GetRValue(color);; // R
				data[(y * pngImage->Width + x) * 4 + 1] = GetGValue(color);; // G
				data[(y * pngImage->Width + x) * 4 + 2] = GetBValue(color);;  // B
				data[(y * pngImage->Width + x) * 4 + 3] = (color >> 24) & 0xFF;  // A
            }
		}

// Generar y enlazar la textura
	glGenTextures(1, &texID);
	glBindTexture(GL_TEXTURE_2D, texID);
	// Establecer los parámetros de la textura
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

	// Cargar la textura en OpenGL
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pngImage->Width, pngImage->Height, 0, GL_RGBA, GL_UNSIGNED_BYTE, data);

    delete[] data;
	return(texID);
}

GLuint LoadBMPTexture(const char* filename) {
	GLuint texID = 0;
	FILE* file = fopen(filename, "rb");
	if (!file) {
		ShowMessage("Error al abrir archivo de textura BMP");
		return(0);
	}
	unsigned char header[54];
	fread(header, sizeof(unsigned char), 54, file);
	int width = *(int*)&header[18];
	int height = *(int*)&header[22];
	int imageSize = *(int*)&header[34];
	unsigned char* data = new unsigned char[imageSize];
	fread(data, sizeof(unsigned char), imageSize, file);
	fclose(file);
// Generar y enlazar la textura
	glGenTextures(1, &texID);
	glBindTexture(GL_TEXTURE_2D, texID);
	// Establecer los parámetros de la textura
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	// Cargar la textura en OpenGL
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_BGR, GL_UNSIGNED_BYTE, data);
	delete[] data;
	return(texID);
}

 void SetupMaterial() {
    // Configura el color ambiental del material
    GLfloat mat_ambient[] = { 0.1f, 0.1f, 0.1f, 1.0f }; // Color ambiental del material
    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
    // Configura el color difuso del material
    GLfloat mat_diffuse[] = { 0.8f, 0.2f, 0.2f, 1.0f }; // Color difuso del material (rojo)
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    // Configura el color especular del material
	GLfloat mat_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // Color especular del material
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    // Define el brillo del material
    GLfloat mat_shininess[] = { 50.0f }; // Aumentar el brillo del material
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
}

void SetupLighting() {
    glEnable(GL_LIGHTING); // Activa el sistema de iluminación
    glEnable(GL_LIGHT0);   // Activa la luz 0
    // Define la posición de la luz
    GLfloat light_position[] = { 0.0f, 10.0f, 5.0f, 1.0f }; // Posición de la luz en coordenadas homogéneas
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);
    // Define el color de la luz ambiental
    GLfloat ambient_light[] = { 0.2f, 0.2f, 0.2f, 1.0f }; // Color suave para la luz ambiental
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient_light);
    // Define el color de la luz difusa
    GLfloat diffuse_light[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // Luz blanca difusa
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse_light);
    // Define el color de la luz especular
    GLfloat specular_light[] = { 1.0f, 1.0f, 1.0f, 1.0f }; // Luz blanca especular
    glLightfv(GL_LIGHT0, GL_SPECULAR, specular_light);
}



void DrawModelWithMultipleTextures() {

glColor3f(1.0f, 1.0f, 1.0f);  // Establece el color a blanco (RGB)

	glEnable(GL_TEXTURE_2D);
	// Recorre todas las formas (shapes) del modelo
for (size_t s = 0; s < shapes.size(); s++) {
    // Obtén el ID del material para esta forma
    int material_id = shapes[s].mesh.material_ids[0];
    // Si el material tiene una textura, usa esa textura
    if (material_id >= 0 && material_id < materials.size()) {
        if (!materials[material_id].diffuse_texname.empty()) {
            glBindTexture(GL_TEXTURE_2D, textureIDs[material_id]);
        } else {
            // Si no hay textura, usa un color base o alguna otra textura por defecto
            glBindTexture(GL_TEXTURE_2D, defaultTextureID);
        }
    }
    // Dibuja los triángulos de esta forma
    glBegin(GL_TRIANGLES);
    for (size_t i = 0; i < shapes[s].mesh.indices.size(); i++) {
        tinyobj::index_t idx = shapes[s].mesh.indices[i];
        // Coordenadas de textura
        if (idx.texcoord_index >= 0) {
            glTexCoord2f(attrib.texcoords[2 * idx.texcoord_index], attrib.texcoords[2 * idx.texcoord_index + 1]);
        }
        // Vértices
        glVertex3f(attrib.vertices[3 * idx.vertex_index + 0],
                   attrib.vertices[3 * idx.vertex_index + 1],
                   attrib.vertices[3 * idx.vertex_index + 2]);
    }
    glEnd();
  }
}


void DrawModelWithTexture(GLuint textureID) {

	glEnable(GL_TEXTURE_2D);
	glBindTexture(GL_TEXTURE_2D, textureID);  // Usa la textura especificada
	glBegin(GL_TRIANGLES);
	for (size_t i = 0; i < vertices.size(); i++) {
		if (i < texCoords.size()) {
			glTexCoord2f(texCoords[i].u, texCoords[i].v);
		}
		glVertex3f(vertices[i].x, vertices[i].y, vertices[i].z);
	}
	glEnd();
	glDisable(GL_TEXTURE_2D);
}



void __fastcall TForm11::InitScene()
{
	// Cargar el modelo y la textura
	LoadOBJModel2(".\\gfx\\models\\casa.obj", ".\\gfx\\models");
	
	// Inicializar y cargar texturas
	InitTextures();

	glEnable(GL_DEPTH_TEST);
	glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

}



void RenderScene() {
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	glLoadIdentity();
	// Configurar la cámara
	gluLookAt(0.0, 0.0, 5.0,  0.0, 0.0, 0.0,  0.0, 1.0, 0.0);
    DrawModelWithMultipleTextures();
    SwapBuffers(hdc);
}




void __fastcall TForm11::DrawScene_New()
{
// Limpiar con fondo transparente
// Establecer el color de fondo
    glClearColor(0.5f, 0.7f, 1.0f, 1.0f); // Cambia esto al color que desees
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Limpia los buffers
    glLoadIdentity();



	// Configurar la matriz de proyección
	   glMatrixMode(GL_PROJECTION);
	   glLoadIdentity();
	   gluPerspective(45.0f, (double)Form11->Panel1->Width / (double)Form11->Panel1->Height, 0.1f, 100.0f); // Ajusta el campo de visión
	   glMatrixMode(GL_MODELVIEW);



	//gluPerspective(45.0f, 800.0f / 600.0f, 1.0f, 100.0f);

	glLoadIdentity();
	gluLookAt(0.0, 0.0, 12.0,   // Cámara
			  0.0, 0.0, 0.0,    // Mirando al centro de la escena
			  0.0, 1.0, 0.0);   // Vector arriba
	// Aplicar rotación
	glRotatef(270.0f, 0.0f, 0.0f, 1.0f);
	glRotatef(30.0f, 0.0f, 1.0f, 0.0f);
		rotationAngle += 0.5f; // Incrementar ángulo para rotar continuamente
	glRotatef(rotationAngle, 1.0f, 0.0f, 0.0f);


		// Dibujar el modelo con la textura
		 DrawModelWithMultipleTextures();


glDisable(GL_TEXTURE_2D); // Desactiva el texturizado

	//Form11->Label1->Caption = "Angulo de Rotacion: 270 Grados";
	//Form11->Label2->Caption = "TextureID: " + FloatToStr(textureID1);

	//ShowMessage("OK");
	//DrawModel_good(); // Llamar a la función que dibuja el modelo

	SwapBuffers(hdc); // Intercambia los buffers para mostrar la escena
	glFlush();
}



//---------------------------------------------------------------------------
void __fastcall TForm11::Timer1Timer(TObject *Sender)
{

	DrawScene_New();  // Dibuja el cubo cada vez que el temporizador se activa
}
//---------------------------------------------------------------------------
 void InitializeOpenGL(TPanel* Panel) {
	hdc = GetDC(Panel->Handle);
   // Crear un contexto de OpenGL temporal

	PIXELFORMATDESCRIPTOR pfd = { sizeof(PIXELFORMATDESCRIPTOR), 1 };
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 32;
	pfd.cDepthBits = 24;
	pfd.iLayerType = PFD_MAIN_PLANE;
	int pixelFormat = ChoosePixelFormat(hdc, &pfd);
	SetPixelFormat(hdc, pixelFormat, &pfd);
	HGLRC tempContext = wglCreateContext(hdc);
	wglMakeCurrent(hdc, tempContext);
	// Inicializar GLEW
	GLenum err = glewInit();
	if (err != GLEW_OK) {
		ShowMessage("Error al inicializar GLEW");
		return;
	}

	wglMakeCurrent(NULL, NULL);
	wglDeleteContext(tempContext);
	HGLRC mainContext = wglCreateContext(hdc);
	wglMakeCurrent(hdc, mainContext);

    // Habilitar mezcla
	  //glEnable(GL_BLEND);
	 //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

     // En tu función de inicialización
//glEnable(GL_LIGHTING);  // Habilitar iluminación
//glEnable(GL_LIGHT0);    // Habilitar la luz 0

//SetupLighting();
//SetupMaterial();
}


void CloseOpenGL(void) {
	wglMakeCurrent(NULL, NULL);
	wglDeleteContext(hrc);
	ReleaseDC(NULL, hdc);
}

//---------------------------------------------------------------------------

void __fastcall TForm11::FormDestroy(TObject *Sender)
{
  CloseOpenGL();
}
//---------------------------------------------------------------------------

[Neftali [Germán.Estévez]]

Gracias por el código.