Browse Source

added old working project

master
Anakin 6 years ago
parent
commit
f57614fd2a
  1. 102
      3DViewer/Header/callback.h
  2. 137
      3DViewer/Header/import.h
  3. 162
      3DViewer/Header/setup.h
  4. 4
      3DViewer/Header/shader.h
  5. 31
      3DViewer/Header/texture.h
  6. 135
      3DViewer/Header/tga.h
  7. 12
      3DViewer/Shader/FragmentColorShader.mv2shdr
  8. 14
      3DViewer/Shader/FragmentTextureShader.mv2shdr
  9. 20
      3DViewer/Shader/VertexColorShader.mv2shdr
  10. 20
      3DViewer/Shader/VertexTextureShader.mv2shdr
  11. 111
      3DViewer/Source/shader.cpp
  12. 106
      3DViewer/Source/texture.cpp
  13. BIN
      3DViewer/Textures/10x10H.tga
  14. BIN
      3DViewer/Textures/10x10V.tga
  15. BIN
      3DViewer/Textures/256x256H.tga
  16. BIN
      3DViewer/Textures/4x4H16.tga
  17. BIN
      3DViewer/Textures/dice.tga
  18. BIN
      3DViewer/Textures/texture16.tga
  19. BIN
      3DViewer/Textures/texture24.tga
  20. BIN
      3DViewer/Textures/texture24R.tga
  21. BIN
      3DViewer/Textures/texture32.tga
  22. BIN
      3DViewer/Textures/texture32R.tga
  23. BIN
      3DViewer/Textures/uvtemplate.DDS
  24. BIN
      3DViewer/Textures/uvtemplate.tga
  25. 115
      3DViewer/main.cpp
  26. 8
      MshViewer/Source/OpenGlController.cpp

102
3DViewer/Header/callback.h

@ -0,0 +1,102 @@
#pragma once
#include <iostream>
#include <gl\glew.h>
#include <gl\glfw3.h>
#include "setup.h"
#define GLFW_KEY_PLUS_GER GLFW_KEY_RIGHT_BRACKET
#define GLFW_KEY_MINUS_GER GLFW_KEY_SLASH
struct {
double posX;
double posY;
bool leftHold;
bool middleHold;
bool rightHold;
double speed = 1;
} mouse;
void windowResize(GLFWwindow * window, int width, int height)
{
monitor.witdh = width;
monitor.heigh = height;
glViewport(0, 0, width, height);
}
void mouseButton(GLFWwindow *window, int button, int action, int mod)
{
if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_PRESS)
{
mouse.leftHold = true;
glfwGetCursorPos(window, &mouse.posX, &mouse.posY);
}
else if (button == GLFW_MOUSE_BUTTON_LEFT && action == GLFW_RELEASE)
{
mouse.leftHold = false;
}
if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS)
{
mouse.rightHold = true;
glfwGetCursorPos(window, &mouse.posX, &mouse.posY);
}
else if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_RELEASE)
{
mouse.rightHold = false;
}
}
void mouseMove(GLFWwindow *window, double xpos, double ypos)
{
if (mouse.leftHold)
{
monitor.rotX += static_cast<float>((ypos - mouse.posY) * 0.01 * mouse.speed);
monitor.rotY += static_cast<float>((xpos - mouse.posX) * 0.01 * mouse.speed);
mouse.posX = xpos;
mouse.posY = ypos;
}
if (mouse.rightHold)
{
monitor.transX -= (xpos - mouse.posX) * 0.01 * mouse.speed;
monitor.transY += (ypos - mouse.posY) * 0.01 * mouse.speed;
mouse.posX = xpos;
mouse.posY = ypos;
}
}
void mouseWheel(GLFWwindow *window, double xoffset, double yoffset)
{
monitor.transZ -= yoffset * 0.5 * mouse.speed;
}
void keyPress(GLFWwindow *window, int key, int scancode, int action, int mods)
{
if (action == GLFW_PRESS || action == GLFW_REPEAT)
{
switch (key)
{
case GLFW_KEY_ESCAPE:
glfwSetWindowShouldClose(window, GLFW_TRUE);
break;
case GLFW_KEY_MINUS_GER: case GLFW_KEY_KP_SUBTRACT:
mouse.speed -= 0.1;
if (mouse.speed < 0.1)
mouse.speed = 0;
break;
case GLFW_KEY_PLUS_GER: case GLFW_KEY_KP_ADD:
mouse.speed += 0.1;
break;
case GLFW_KEY_A:
std::cout << mouse.speed << std::endl;
break;
default:
std::cout << key << " " << scancode << std::endl;
break;
}
}
}

137
3DViewer/Header/import.h

@ -0,0 +1,137 @@
#pragma once
#include <vector>
#include <fstream>
#include <Windows.h>
#include <gl\glew.h>
std::vector<GLfloat> loadData()
{
return std::vector<GLfloat>(
{
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
-1.0f, -1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, -1.0f,
1.0f, -1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, -1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, -1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, 1.0f, 1.0f,
-1.0f, 1.0f, 1.0f,
1.0f, -1.0f, 1.0f
}
);
}
std::vector<GLfloat> loadColor()
{
return std::vector<GLfloat>(
{
0.583f, 0.771f, 0.014f,
0.609f, 0.115f, 0.436f,
0.327f, 0.483f, 0.844f,
0.822f, 0.569f, 0.201f,
0.435f, 0.602f, 0.223f,
0.310f, 0.747f, 0.185f,
0.597f, 0.770f, 0.761f,
0.559f, 0.436f, 0.730f,
0.359f, 0.583f, 0.152f,
0.483f, 0.596f, 0.789f,
0.559f, 0.861f, 0.639f,
0.195f, 0.548f, 0.859f,
0.014f, 0.184f, 0.576f,
0.771f, 0.328f, 0.970f,
0.406f, 0.615f, 0.116f,
0.676f, 0.977f, 0.133f,
0.971f, 0.572f, 0.833f,
0.140f, 0.616f, 0.489f,
0.997f, 0.513f, 0.064f,
0.945f, 0.719f, 0.592f,
0.543f, 0.021f, 0.978f,
0.279f, 0.317f, 0.505f,
0.167f, 0.620f, 0.077f,
0.347f, 0.857f, 0.137f,
0.055f, 0.953f, 0.042f,
0.714f, 0.505f, 0.345f,
0.783f, 0.290f, 0.734f,
0.722f, 0.645f, 0.174f,
0.302f, 0.455f, 0.848f,
0.225f, 0.587f, 0.040f,
0.517f, 0.713f, 0.338f,
0.053f, 0.959f, 0.120f,
0.393f, 0.621f, 0.362f,
0.673f, 0.211f, 0.457f,
0.820f, 0.883f, 0.371f,
0.982f, 0.099f, 0.879f
}
);
}
std::vector<GLfloat> loadUV()
{
return std::vector<float>(
{
0.000059f, 1.0f - 0.000004f,
0.000103f, 1.0f - 0.336048f,
0.335973f, 1.0f - 0.335903f,
1.000023f, 1.0f - 0.000013f,
0.667979f, 1.0f - 0.335851f,
0.999958f, 1.0f - 0.336064f,
0.667979f, 1.0f - 0.335851f,
0.336024f, 1.0f - 0.671877f,
0.667969f, 1.0f - 0.671889f,
1.000023f, 1.0f - 0.000013f,
0.668104f, 1.0f - 0.000013f,
0.667979f, 1.0f - 0.335851f,
0.000059f, 1.0f - 0.000004f,
0.335973f, 1.0f - 0.335903f,
0.336098f, 1.0f - 0.000071f,
0.667979f, 1.0f - 0.335851f,
0.335973f, 1.0f - 0.335903f,
0.336024f, 1.0f - 0.671877f,
1.000004f, 1.0f - 0.671847f,
0.999958f, 1.0f - 0.336064f,
0.667979f, 1.0f - 0.335851f,
0.668104f, 1.0f - 0.000013f,
0.335973f, 1.0f - 0.335903f,
0.667979f, 1.0f - 0.335851f,
0.335973f, 1.0f - 0.335903f,
0.668104f, 1.0f - 0.000013f,
0.336098f, 1.0f - 0.000071f,
0.000103f, 1.0f - 0.336048f,
0.000004f, 1.0f - 0.671870f,
0.336024f, 1.0f - 0.671877f,
0.000103f, 1.0f - 0.336048f,
0.336024f, 1.0f - 0.671877f,
0.335973f, 1.0f - 0.335903f,
0.667969f, 1.0f - 0.671889f,
1.000004f, 1.0f - 0.671847f,
0.667979f, 1.0f - 0.335851f
}
);
}

162
3DViewer/Header/setup.h

@ -0,0 +1,162 @@
#pragma once
#include <gl/glew.h>
#include <gl/glfw3.h>
#include <glm\glm.hpp>
#include <glm\gtc\matrix_transform.hpp>
#include <Windows.h>
#include <vector>
#include "shader.h"
#include "import.h"
#include "texture.h"
#define OGL_MAJOR_VERSION 4
#define OGL_MINOR_VERSION 5
#define AA_VALUE 4
#define MAINWINDOW_NAME "MeshViewer 2.0 pre-alpha"
#define VERTEX_SHADER "Shader/VertexTextureShader.mv2shdr"
#define FRAGMENT_SHADER "Shader/FragmentTextureShader.mv2shdr"
#define TEXTURE_NAME "Textures/dice.tga"
struct oglVariables {
GLFWwindow* window; // window
GLuint vertexArrayID; // vertex array
GLuint vertexBufferID; // vertex buffer
GLuint colorBufferID; // color buffer
GLuint samplerID; // sampler handler
GLuint uvBufferID; // uv buffer
GLuint shaderPrgmID; // shader
struct {
GLuint id; // matrix ID
glm::mat4 projection; // projection
glm::mat4 view; // view
glm::mat4 model; // model
glm::mat4 mvp; // mvp
} matrix;
struct {
std::vector<GLfloat> data; // obj data
std::vector<GLfloat> color; // obj color
std::vector<GLfloat> uv; // obj uv
GLuint textureID; // texture data
} object;
};
struct {
float fov = 45.f;
float minView = 0.1f;
float maxView = 100.0f;
int witdh = 640;
int heigh = 480;
float rotX = 0;
float rotY = 0;
float rotZ = 0;
double transX = 0.0;
double transY = 0.0;
double transZ = 5.0;
} monitor;
void setupGLFW()
{
if (!glfwInit())
{
MessageBox(NULL, "Failed to initialize GLFW", "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
exit(0);
}
glfwWindowHint(GLFW_SAMPLES, AA_VALUE); // antialiasing level
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, OGL_MAJOR_VERSION); // OpenGL major version number
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, OGL_MINOR_VERSION); // OpenGL minor verison number
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // something we need for new OGL
}
GLFWwindow* createWindow()
{
GLFWwindow* window = glfwCreateWindow(monitor.witdh, monitor.heigh, MAINWINDOW_NAME, NULL, NULL);
if (window == NULL)
{
char tempMajor[10], tempMinor[10];
_itoa_s(OGL_MAJOR_VERSION, tempMajor, 10, 10);
_itoa_s(OGL_MINOR_VERSION, tempMinor, 10, 10);
MessageBox(NULL,
(std::string("Your GPU does not support OpenGL ") += std::string(tempMajor) += std::string(".") += std::string(tempMinor)).c_str(),
"MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
glfwTerminate();
exit(0);
}
glfwMakeContextCurrent(window);
return window;
}
void setupGLEW()
{
glewExperimental = true;
if (glewInit() != GLEW_OK)
{
MessageBox(NULL, "Failed to initialize GLEW!", "MeshViewer 2.0 Error", MB_OK | MB_ICONERROR);
glfwTerminate();
exit(0);
}
}
void calcMatrices(oglVariables &scene)
{
scene.matrix.projection = glm::perspective(monitor.fov, float(monitor.witdh) / float(monitor.heigh), monitor.minView, monitor.maxView);
scene.matrix.view = glm::lookAt(
glm::vec3(monitor.transX, monitor.transY, monitor.transZ),
glm::vec3(monitor.transX, monitor.transY, monitor.transZ - 1),
glm::vec3(0, 1, 0)
);
scene.matrix.model = glm::mat4(1.0f);
scene.matrix.model = glm::rotate(scene.matrix.model, monitor.rotX, glm::vec3(1, 0, 0));
scene.matrix.model = glm::rotate(scene.matrix.model, monitor.rotY, glm::vec3(0, 1, 0));
scene.matrix.model = glm::rotate(scene.matrix.model, monitor.rotZ, glm::vec3(0, 0, 1));
scene.matrix.mvp = scene.matrix.projection * scene.matrix.view * scene.matrix.model;
}
void initVariables(oglVariables &temp)
{
glGenVertexArrays(1, &(temp.vertexArrayID));
glGenBuffers(1, &temp.vertexBufferID);
glGenBuffers(1, &temp.colorBufferID);
glGenBuffers(1, &temp.uvBufferID);
temp.shaderPrgmID = LoadShaders(VERTEX_SHADER, FRAGMENT_SHADER);
temp.matrix.id = glGetUniformLocation(temp.shaderPrgmID, "MVP");
calcMatrices(temp);
temp.samplerID = glGetUniformLocation(temp.shaderPrgmID, "textureSampler");
temp.object.data = loadData();
temp.object.color = loadColor();
temp.object.uv = loadUV();
glGenTextures(1, &temp.object.textureID);
glBindTexture(GL_TEXTURE_2D, temp.object.textureID);
TextureTGA tempTex(TEXTURE_NAME);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, tempTex.getWidth(), tempTex.getHeight(), 0, GL_BGR, GL_UNSIGNED_BYTE, tempTex.getData().data());
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_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
glGenerateMipmap(GL_TEXTURE_2D);
}
void cleanUp(oglVariables &scene)
{
glDeleteBuffers(1, &scene.uvBufferID);
glDeleteBuffers(1, &scene.colorBufferID);
glDeleteBuffers(1, &scene.vertexBufferID);
glDeleteVertexArrays(1, &scene.vertexArrayID);
glDeleteProgram(scene.shaderPrgmID);
glDeleteTextures(1, &scene.samplerID);
glfwTerminate();
}

4
3DViewer/Header/shader.h

@ -0,0 +1,4 @@
#pragma once
#include <gl\glew.h>
GLuint LoadShaders(const char * vertex_file_path, const char * fragment_file_path);

31
3DViewer/Header/texture.h

@ -0,0 +1,31 @@
#pragma once
#include <vector>
class TextureTGA
{
public:
TextureTGA(const char* filePath);
~TextureTGA();
private:
std::vector<std::uint8_t> vui8Pixels;
bool bCompressed;
std::uint32_t ui32IDLength;
bool bColorTabel;
std::uint32_t ui32PicType;
std::uint32_t ui32PaletteBegin;
std::uint32_t ui32PaletteLength;
std::uint32_t ui32PaletteBpP;
std::uint32_t ui32Width;
std::uint32_t ui32Height;
std::uint32_t ui32Size;
std::uint32_t ui32BpP;
std::uint32_t ui32Attribut;
public:
std::vector<std::uint8_t> getData() const;
bool hasAlpha() const;
std::uint32_t getWidth() const;
std::uint32_t getHeight() const;
};

135
3DViewer/Header/tga.h

@ -0,0 +1,135 @@
#pragma once
#include <vector>
#include <gl\glut.h>
#include <Windows.h>
#include <fstream>
typedef union PixelInfo
{
std::uint32_t Colour;
struct
{
std::uint8_t B, G, R, A;
};
} *PPixelInfo;
class Tga
{
private:
std::vector<std::uint8_t> Pixels;
bool ImageCompressed;
std::uint32_t width, height, size, BitsPerPixel;
public:
Tga(const char* FilePath);
std::vector<std::uint8_t> GetPixels() { return this->Pixels; }
std::uint32_t GetWidth() const { return this->width; }
std::uint32_t GetHeight() const { return this->height; }
bool HasAlphaChannel() { return BitsPerPixel == 32; }
};
Tga::Tga(const char* FilePath)
{
std::fstream hFile(FilePath, std::ios::in | std::ios::binary);
if (!hFile.is_open()) { throw std::invalid_argument("File Not Found."); }
std::uint8_t Header[18] = { 0 };
std::vector<std::uint8_t> ImageData;
static std::uint8_t DeCompressed[12] = { 0x0, 0x0, 0x2, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
static std::uint8_t IsCompressed[12] = { 0x0, 0x0, 0xA, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 };
hFile.read(reinterpret_cast<char*>(&Header), sizeof(Header));
if (!std::memcmp(DeCompressed, &Header, sizeof(DeCompressed)))
{
BitsPerPixel = Header[16];
width = Header[13] * 0xFF + Header[12];
height = Header[15] * 0xFF + Header[14];
size = ((width * BitsPerPixel + 31) / 32) * 4 * height;
if ((BitsPerPixel != 24) && (BitsPerPixel != 32))
{
hFile.close();
throw std::invalid_argument("Invalid File Format. Required: 24 or 32 Bit Image.");
}
ImageData.resize(size);
ImageCompressed = false;
hFile.read(reinterpret_cast<char*>(ImageData.data()), size);
}
else if (!std::memcmp(IsCompressed, &Header, sizeof(IsCompressed)))
{
BitsPerPixel = Header[16];
width = Header[13] * 0xFF + Header[12];
height = Header[15] * 0xFF + Header[14];
size = ((width * BitsPerPixel + 31) / 32) * 4 * height;
if ((BitsPerPixel != 24) && (BitsPerPixel != 32))
{
hFile.close();
throw std::invalid_argument("Invalid File Format. Required: 24 or 32 Bit Image.");
}
PixelInfo Pixel = { 0 };
int CurrentByte = 0;
std::size_t CurrentPixel = 0;
ImageCompressed = true;
std::uint8_t ChunkHeader = { 0 };
int BytesPerPixel = (BitsPerPixel / 8);
ImageData.resize(width * height * sizeof(PixelInfo));
do
{
hFile.read(reinterpret_cast<char*>(&ChunkHeader), sizeof(ChunkHeader));
if (ChunkHeader < 128)
{
++ChunkHeader;
for (int I = 0; I < ChunkHeader; ++I, ++CurrentPixel)
{
hFile.read(reinterpret_cast<char*>(&Pixel), BytesPerPixel);
ImageData[CurrentByte++] = Pixel.B;
ImageData[CurrentByte++] = Pixel.G;
ImageData[CurrentByte++] = Pixel.R;
if (BitsPerPixel > 24) ImageData[CurrentByte++] = Pixel.A;
}
}
else
{
ChunkHeader -= 127;
hFile.read(reinterpret_cast<char*>(&Pixel), BytesPerPixel);
for (int I = 0; I < ChunkHeader; ++I, ++CurrentPixel)
{
ImageData[CurrentByte++] = Pixel.B;
ImageData[CurrentByte++] = Pixel.G;
ImageData[CurrentByte++] = Pixel.R;
if (BitsPerPixel > 24) ImageData[CurrentByte++] = Pixel.A;
}
}
} while (CurrentPixel < (width * height));
}
else
{
hFile.close();
throw std::invalid_argument("Invalid File Format. Required: 24 or 32 Bit TGA File.");
}
//fix color mix
std::uint8_t temp;
unsigned int it = 0;
while (1)
{
temp = ImageData[it];
ImageData[it] = ImageData[it + 2];
ImageData[it + 2] = temp;
BitsPerPixel == 32 ? it += 2 : it += 3;
if (it + 2 >= size)
break;
}
hFile.close();
this->Pixels = ImageData;
}

12
3DViewer/Shader/FragmentColorShader.mv2shdr

@ -0,0 +1,12 @@
#version 450 core
// Input
in vec3 fragmentColor;
// Ouput data
out vec3 color;
void main()
{
color = fragmentColor;
}

14
3DViewer/Shader/FragmentTextureShader.mv2shdr

@ -0,0 +1,14 @@
#version 450 core
// Input
in vec2 UV;
// Ouput data
out vec3 color;
uniform sampler2D textureSampler;
void main()
{
color = texture(textureSampler, UV).rgb;
}

20
3DViewer/Shader/VertexColorShader.mv2shdr

@ -0,0 +1,20 @@
#version 450 core
// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;
layout(location = 1) in vec3 vertexColor;
// Output
out vec3 fragmentColor;
// Values that stay constant for the whole mesh.
uniform mat4 MVP;
void main(){
// Output position of the vertex, in clip space : MVP * position
gl_Position = MVP * vec4(vertexPosition_modelspace,1);
fragmentColor = vertexColor;
}

20
3DViewer/Shader/VertexTextureShader.mv2shdr

@ -0,0 +1,20 @@
#version 450 core
// Input vertex data, different for all executions of this shader.
layout(location = 0) in vec3 vertexPosition_modelspace;
layout(location = 1) in vec2 vertexUV;
// Output
out vec2 UV;
// Values that stay constant for the whole mesh.
uniform mat4 MVP;
void main(){
// Output position of the vertex, in clip space : MVP * position
gl_Position = MVP * vec4(vertexPosition_modelspace,1);
UV = vertexUV;
}

111
3DViewer/Source/shader.cpp

@ -0,0 +1,111 @@
#include <stdio.h>
#include <string>
#include <vector>
#include <iostream>
#include <fstream>
#include <algorithm>
using namespace std;
#include <stdlib.h>
#include <string.h>
#include <GL/glew.h>
#include "shader.h"
GLuint LoadShaders(const char * vertex_file_path, const char * fragment_file_path) {
// Create the shaders
GLuint VertexShaderID = glCreateShader(GL_VERTEX_SHADER);
GLuint FragmentShaderID = glCreateShader(GL_FRAGMENT_SHADER);
// Read the Vertex Shader code from the file
std::string VertexShaderCode;
std::ifstream VertexShaderStream(vertex_file_path, std::ios::in);
if (VertexShaderStream.is_open()) {
std::string Line = "";
while (getline(VertexShaderStream, Line))
VertexShaderCode += "\n" + Line;
VertexShaderStream.close();
}
else {
printf("Impossible to open %s. Are you in the right directory ? Don't forget to read the FAQ !\n", vertex_file_path);
getchar();
return 0;
}
// Read the Fragment Shader code from the file
std::string FragmentShaderCode;
std::ifstream FragmentShaderStream(fragment_file_path, std::ios::in);
if (FragmentShaderStream.is_open()) {
std::string Line = "";
while (getline(FragmentShaderStream, Line))
FragmentShaderCode += "\n" + Line;
FragmentShaderStream.close();
}
GLint Result = GL_FALSE;
int InfoLogLength;
// Compile Vertex Shader
printf("Compiling shader : %s\n", vertex_file_path);
char const * VertexSourcePointer = VertexShaderCode.c_str();
glShaderSource(VertexShaderID, 1, &VertexSourcePointer, NULL);
glCompileShader(VertexShaderID);
// Check Vertex Shader
glGetShaderiv(VertexShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(VertexShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if (InfoLogLength > 0) {
std::vector<char> VertexShaderErrorMessage(InfoLogLength + 1);
glGetShaderInfoLog(VertexShaderID, InfoLogLength, NULL, &VertexShaderErrorMessage[0]);
printf("%s\n", &VertexShaderErrorMessage[0]);
}
// Compile Fragment Shader
printf("Compiling shader : %s\n", fragment_file_path);
char const * FragmentSourcePointer = FragmentShaderCode.c_str();
glShaderSource(FragmentShaderID, 1, &FragmentSourcePointer, NULL);
glCompileShader(FragmentShaderID);
// Check Fragment Shader
glGetShaderiv(FragmentShaderID, GL_COMPILE_STATUS, &Result);
glGetShaderiv(FragmentShaderID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if (InfoLogLength > 0) {
std::vector<char> FragmentShaderErrorMessage(InfoLogLength + 1);
glGetShaderInfoLog(FragmentShaderID, InfoLogLength, NULL, &FragmentShaderErrorMessage[0]);
printf("%s\n", &FragmentShaderErrorMessage[0]);
}
// Link the program
printf("Linking program\n");
GLuint ProgramID = glCreateProgram();
glAttachShader(ProgramID, VertexShaderID);
glAttachShader(ProgramID, FragmentShaderID);
glLinkProgram(ProgramID);
// Check the program
glGetProgramiv(ProgramID, GL_LINK_STATUS, &Result);
glGetProgramiv(ProgramID, GL_INFO_LOG_LENGTH, &InfoLogLength);
if (InfoLogLength > 0) {
std::vector<char> ProgramErrorMessage(InfoLogLength + 1);
glGetProgramInfoLog(ProgramID, InfoLogLength, NULL, &ProgramErrorMessage[0]);
printf("%s\n", &ProgramErrorMessage[0]);
}
glDetachShader(ProgramID, VertexShaderID);
glDetachShader(ProgramID, FragmentShaderID);
glDeleteShader(VertexShaderID);
glDeleteShader(FragmentShaderID);
return ProgramID;
}

106
3DViewer/Source/texture.cpp

@ -0,0 +1,106 @@
#include "texture.h"
#include <iostream>
#include <fstream>
#include <Windows.h>
TextureTGA::TextureTGA(const char * filePath)
{
// open the file
std::fstream fsPicture(filePath, std::ios::in | std::ios::binary);
if (!fsPicture.is_open())
throw std::invalid_argument(std::string("file not found: ") += filePath);
// read in the header
std::uint8_t ui8x18Header[18] = { 0 };
fsPicture.read(reinterpret_cast<char*>(&ui8x18Header), sizeof(ui8x18Header));
// extract all information from header
ui32IDLength = ui8x18Header[0];
bColorTabel = ui8x18Header[1] == 1;
ui32PicType = ui8x18Header[2];
ui32PaletteBegin = ui8x18Header[4] * 0x100 + ui8x18Header[3];
ui32PaletteLength = ui8x18Header[6] * 0x100 + ui8x18Header[5];
ui32PaletteBpP = ui8x18Header[7];
ui32Width = ui8x18Header[13] * 0x100 + ui8x18Header[12];
ui32Height = ui8x18Header[15] * 0x100 + ui8x18Header[14];
ui32BpP = ui8x18Header[16];
ui32Attribut = ui8x18Header[17];
// calculate some more information
ui32Size = ui32Width * ui32Height * ui32BpP/8;
bCompressed = ui32PicType == 9 || ui32PicType == 10;
vui8Pixels.resize(ui32Size);
/* consol output of the header
std::cout << "Header\n"
<< "ID länge: " << ui32IDLength << std::endl
<< "Farbtabelle: " << (int)bColorTabel << std::endl
<< "Bildtype: " << ui32PicType << std::endl
<< "Palletenbegin: " << ui32PaletteBegin << std::endl
<< "Palletenlängen: " << ui32PaletteLength << std::endl
<< "Bits pro Palleteneintrag: " << ui32PaletteBpP << std::endl
<< "Breite: " << ui32Width << std::endl
<< "Höhe: " << ui32Height << std::endl
<< "Bit pro Pixel: " << ui32BpP << std::endl
<< "Bild Attribute: " << ui32Attribut << std::endl;*/
// jump to the data block
fsPicture.seekg(ui32IDLength + ui32PaletteLength, std::ios_base::cur);
// If not compressed 24 or 32 bit
if (ui32PicType == 2 && (ui32BpP == 24 || ui32BpP == 32))
{
fsPicture.read(reinterpret_cast<char*>(vui8Pixels.data()), ui32Size);
}
// else if compressed 24 or 32 bit
else if (ui32PicType == 10 && (ui32BpP == 24 || ui32BpP == 32)) // compressed
{
throw std::invalid_argument("Invaild File Format! Don't compress the image.");
}
// not useable format
else
{
fsPicture.close();
throw std::invalid_argument("Invaild File Format! Required 24 or 31 Bit Image.");
}
//fix color mix
/*std::uint8_t temp;
std::uint32_t it = 0;
while (it + 2 < ui32Size)
{
temp = vui8Pixels[it];
vui8Pixels[it] = vui8Pixels[it + 2];
vui8Pixels[it + 2] = temp;
ui32BpP == 32 ? it += 4 : it += 3;
}*/
fsPicture.close();
}
TextureTGA::~TextureTGA()
{
}
std::vector<std::uint8_t> TextureTGA::getData() const
{
return vui8Pixels;
}
bool TextureTGA::hasAlpha() const
{
return ui32BpP == 32;
}
std::uint32_t TextureTGA::getWidth() const
{
return ui32Width;
}
std::uint32_t TextureTGA::getHeight() const
{
return ui32Height;
}

BIN
3DViewer/Textures/10x10H.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 3.0 KiB

BIN
3DViewer/Textures/10x10V.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 344 B

BIN
3DViewer/Textures/256x256H.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 192 KiB

BIN
3DViewer/Textures/4x4H16.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 76 B

BIN
3DViewer/Textures/dice.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 768 KiB

BIN
3DViewer/Textures/texture16.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 128 KiB

BIN
3DViewer/Textures/texture24.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 192 KiB

BIN
3DViewer/Textures/texture24R.tga

Binary file not shown.

BIN
3DViewer/Textures/texture32.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 256 KiB

BIN
3DViewer/Textures/texture32R.tga

Binary file not shown.

BIN
3DViewer/Textures/uvtemplate.DDS

Binary file not shown.

BIN
3DViewer/Textures/uvtemplate.tga

Binary file not shown.

After

Width:  |  Height:  |  Size: 768 KiB

115
3DViewer/main.cpp

@ -0,0 +1,115 @@
#define _CRT_SECURE_NO_WARNINGS
#ifndef _DEBUG
#pragma comment( linker, "/subsystem:\"windows\" /entry:\"mainCRTStartup\"" )
#endif // DEBUG
#include <GL/glew.h>
#include <glm/gtc/matrix_transform.hpp>
#include "setup.h"
#include "callback.h"
int main(int argc, char** argv)
{
oglVariables scene;
// init everything
setupGLFW();
scene.window = createWindow();
setupGLEW();
initVariables(scene);
glBindVertexArray(scene.vertexArrayID);
// Set callback functions
glfwSetMouseButtonCallback(scene.window, mouseButton);
glfwSetCursorPosCallback(scene.window, mouseMove);
glfwSetWindowSizeCallback(scene.window, windowResize);
glfwSetScrollCallback(scene.window, mouseWheel);
glfwSetKeyCallback(scene.window, keyPress);
// set background color 0,5 0,8 1,0
glClearColor(0.0000f, 0.0000f, 0.4000f, 0.0000f);
// enable z-order
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glEnable(GL_CULL_FACE);
// load object to OGL
glBindBuffer(GL_ARRAY_BUFFER, scene.vertexBufferID);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(scene.object.data) * scene.object.data.size(),
scene.object.data.data(),
GL_STATIC_DRAW
);
/*/ load color to OGL
glBindBuffer(GL_ARRAY_BUFFER, scene.colorBufferID);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(scene.object.color) * scene.object.color.size(),
scene.object.color.data(),
GL_STATIC_DRAW
);*/
// load UV to OGL
glBindBuffer(GL_ARRAY_BUFFER, scene.uvBufferID);
glBufferData(
GL_ARRAY_BUFFER,
sizeof(scene.object.uv) * scene.object.uv.size(),
scene.object.uv.data(),
GL_STATIC_DRAW
);
// Main loop
do {
//processInteraction(scene.window);
calcMatrices(scene);
// clear the scene
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// use shader prgram
glUseProgram(scene.shaderPrgmID);
// tell shader transformation
glUniformMatrix4fv(scene.matrix.id, 1, GL_FALSE, &scene.matrix.mvp[0][0]);
// bind texture in texture unit 0
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, scene.object.textureID);
// tell sampler to use texture unit 0
glUniform1i(scene.samplerID, 0);
// open attribute position
glEnableVertexAttribArray(0);
glBindBuffer(GL_ARRAY_BUFFER, scene.vertexBufferID);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
/*/ open attribute color
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, scene.colorBufferID);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);*/
// open attribute uv
glEnableVertexAttribArray(1);
glBindBuffer(GL_ARRAY_BUFFER, scene.uvBufferID);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 0, 0);
// draw object
glDrawArrays(GL_TRIANGLES, 0, 3*12);
// close attributes
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
glfwSwapBuffers(scene.window);
glfwPollEvents();
}
while (!glfwWindowShouldClose(scene.window));
cleanUp(scene);
return 0;
}

8
MshViewer/Source/OpenGlController.cpp

@ -179,10 +179,6 @@ void OpenGLController::setCallbackFunctions()
glfwSetKeyCallback(pWindow, keyPress);
}
/////////////////////////////////////////////////////////////////////////
// public getter
glm::mat4 OpenGLController::getMVPMatrix()
{
m4x4Projection = glm::perspective(fFOV, float(iWidth) / float(iHeight), fMinView, fMaxView);
@ -199,6 +195,10 @@ glm::mat4 OpenGLController::getMVPMatrix()
return m4x4Projection * m4x4View * m4x4Model;
}
/////////////////////////////////////////////////////////////////////////
// public getter
GLFWwindow * OpenGLController::getWindow() const
{
return pWindow;

Loading…
Cancel
Save