#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <SDL2/SDL.h>
#include <SDL_opengles.h>
#include <iostream>
#include <vector>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include "SDL2/SDL.h"
#include "SDL_test_common.h"
#if defined(__IPHONEOS__) || defined(__ANDROID__)
#define HAVE_OPENGLES
#endif
#include "SDL_opengles.h"
#include <iostream>
#include <vector>
#include <fstream>
#include <sstream>
#include <string>
#include <math.h>
#include <stdlib.h>
#include <SDL2/SDL.h>
#include <SDL_opengles.h>
#include "SDL_image.h"
#include <stdio.h>
#include <string.h>
#include <SDL_image.h>
#if defined(__IPHONEOS__) || defined(__ANDROID__)
#define HAVE_OPENGLES
#endif
#include "SDL_opengles.h"
#define PATH "/storage/emulated/0/img.jpg"
GLuint texture[1]; // Changed to have at least one texture slot
SDLTest_CommonState *state;
SDL_Event *event;
SDL_GLContext *context; // No need to have this as a pointer
struct mouse_handle {
int x = 1;
int y = 1;
} mouse;
struct Vertex {
float x, y, z;
};
struct Normal {
float nx, ny, nz;
};
struct TexCoord {
float u, v;
};
std::vector<Vertex>* vertices = nullptr;
std::vector<Normal>* normals = nullptr;
std::vector<TexCoord>* texCoords = nullptr;
void loadObj(const char *filename) {
vertices = new std::vector<Vertex>();
normals = new std::vector<Normal>();
texCoords = new std::vector<TexCoord>();
std::ifstream objFile(filename);
if (!objFile) {
std::cerr << "Unable to open file: " << filename << std::endl;
exit(1);
}
std::vector<Vertex> tempVertices;
std::vector<Normal> tempNormals;
std::vector<TexCoord> tempTexCoords;
std::string line;
while (std::getline(objFile, line)) {
std::istringstream iss(line);
std::string prefix;
iss >> prefix;
if (prefix == "v") {
Vertex vertex;
iss >> vertex.x >> vertex.y >> vertex.z;
tempVertices.push_back(vertex);
} else if (prefix == "vn") {
Normal normal;
iss >> normal.nx >> normal.ny >> normal.nz;
tempNormals.push_back(normal);
}
else if (prefix == "vt") {
TexCoord texCoord;
iss >> texCoord.u >> texCoord.v;
texCoords->push_back(texCoord);
// tempTexCoords.push_back(texCoord);
}
else if (prefix == "f") {
std::vector<int> vIndices, nIndices;
std::string vertexData;
while (iss >> vertexData) {
std::replace(vertexData.begin(), vertexData.end(), '/', ' ');
std::istringstream vertexStream(vertexData);
int vIndex, tIndex, nIndex;
vertexStream >> vIndex >> tIndex >> nIndex;
vIndices.push_back(vIndex);
nIndices.push_back(nIndex);
}
for (size_t i = 1; i < vIndices.size() - 1; i++) {
vertices->push_back(tempVertices[vIndices[0] - 1]);
vertices->push_back(tempVertices[vIndices[i] - 1]);
vertices->push_back(tempVertices[vIndices[i + 1] - 1]);
normals->push_back(tempNormals[nIndices[0] - 1]);
normals->push_back(tempNormals[nIndices[i] - 1]);
normals->push_back(tempNormals[nIndices[i + 1] - 1]);
}
}
}
objFile.close();
}
int LoadGLTextures() {
SDL_Surface *TextureImage = IMG_Load(PATH);
if (!TextureImage) {
std::cerr << "Unable to load texture" << std::endl;
return 0;
}
glGenTextures(1, &texture[1]);
glBindTexture(GL_TEXTURE_2D, texture[1]);
// Determine the texture format (RGB or RGBA)
int mode = (TextureImage->format->BytesPerPixel == 4) ? GL_RGBA : GL_RGB;
// Assuming TextureImage is a structure containing width, height, and image data
glBindTexture(GL_TEXTURE_2D, texture[1]); // Bind the texture object
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, TextureImage->w, TextureImage->h, 0, GL_RGB, GL_UNSIGNED_BYTE,TextureImage->pixels);
// Upload the texture
// glTexImage2D(GL_TEXTURE_2D, 0, mode, TextureImage->w, TextureImage->h, 0, mode, GL_UNSIGNED_BYTE, TextureImage->image);
// Optionally generate mipmaps
glGenerateMipmapOES(GL_TEXTURE_2D);
// Set filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); // Use mipmaps
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
//glEnable(GL_TEXTURE_2D);
SDL_FreeSurface(TextureImage);
return 1;
}
void setPerspective(float fov, float aspect, float znear, float zfar) {
float ymax = znear * tanf(fov * M_PI / 360.0f);
float ymin = -ymax;
float xmin = ymin * aspect;
float xmax = ymax * aspect;
glFrustumf(xmin, xmax, ymin, ymax, znear, zfar);
}
void cleanup() {
delete vertices;
delete normals;
delete texCoords;
}
void renderScene() {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
setPerspective(60.0f, 1.0f, 0.1f, 80.0f); // Adjusted FOV and aspect ratio
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Apply transformations here
glTranslatef(0.0f, 0.0f, 0.0f); // Move the object back
glScalef(1.0f, 1.0f, 1.0f); // Scale the object
glRotatef(mouse.x % 360, 0.0f, 1.0f, 0.0f); // Rotate around Y-axis
glRotatef(mouse.y % 360, 1.0f, 0.0f, 0.0f); // Rotate around X-axis
// Lighting setup
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
GLfloat light_position[] = {0.0f, 1.0f, 1.0f, 0.0f};
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
// Vertex and normal array setup
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3, GL_FLOAT, sizeof(Vertex), vertices->data());
glEnableClientState(GL_NORMAL_ARRAY);
glNormalPointer(GL_FLOAT, sizeof(Normal), normals->data());
// Texture array setup
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, texture[1]);
glGenTextures(1, &texture[1]);
glBindTexture(GL_TEXTURE_2D, texture[1]); glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glTexCoordPointer(2, GL_FLOAT, sizeof(TexCoord), texCoords->data());
//TexCoord(texCoords->data());
// Render the object
glDrawArrays(GL_TRIANGLES, 0, vertices->size());
// Cleanup states
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
glDisableClientState(GL_TEXTURE_COORD_ARRAY);
// Swap buffers to display the scene
SDL_GL_SwapWindow(state->windows[0]);
}
int main(int argc, char *argv[]) {
if (!(IMG_Init(IMG_INIT_JPG) & IMG_INIT_JPG)) {
std::cerr << "IMG_Init failed: " << IMG_GetError() << std::endl;
return 0;
}
SDL_DisplayMode mode;
state = SDLTest_CommonCreateState(argv, SDL_INIT_EVERYTHING);
SDLTest_CommonInit(state);
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 1);
bool sdlmainloop = true;
bool running = true;
LoadGLTextures();
loadObj("/sdcard/sphere.obj"); // Wczytanie pliku OBJ na początku
SDL_GL_CreateContext(*state->windows);
while (running) {
SDL_Event event;
while (SDL_PollEvent(&event)) {
if (event.type == SDL_QUIT) {
running = false;
}
if (event.type == SDL_MOUSEMOTION) {
mouse.x = event.motion.x;
mouse.y = event.motion.y;
}
//
// Render the scene
renderScene();
// SDL_GL_SwapWindow(*state->windows);
}
}
cleanup();
// Cleanup
SDL_GL_DeleteContext(context);
SDLTest_CommonQuit(state);
return 0;
}
No comments:
Post a Comment