ТПКС_Лаб1(семестр2)

МИНИСТЕРТСВО ОБРАЗОВАНИЯ И НАУКИ УКРАИНЫ

ХАРЬКОВСКИЙ НАЦИОНАЛЬНЫЙ УНИВЕРСИТЕТ РАДИОЭЛЕКТРОНИКИ

Кафедра КИТАМ

ОТЧЁТ

по лабораторной работе №1

по дисциплине «Технологии программирования компьютерных систем»

Выполнил: Проверил:

ст. гр. АКТСІу-17-1 ассистент каф. КИТАМ

Черкашин В.А. Гурин Д. В.

Харьков 2019

1 ПОСТРОЕНИЕ 3D МОДЕЛЕЙ РОБОТОВ

1. Цель: Построить 3D – модель робота с помощью средств OpenGL.

2. Ход работы

#include <glad/glad.h>

#include <GLFW/glfw3.h>

#include <glm/glm.hpp>

#include <glm/gtc/matrix_transform.hpp>

#include <glm/gtc/type_ptr.hpp>

#include <shader_m.h>

#include <camera.h>

#include <assimp/Importer.hpp>

#include <assimp/scene.h>

#include <assimp/postprocess.h>

#include <SOIL/SOIL.h>

#include <iostream>

using namespace std;

void framebuffer_size_callback(GLFWwindow* window, int width, int height);

void mouse_callback(GLFWwindow* window, double xpos, double ypos);

void scroll_callback(GLFWwindow* window, double xoffset, double yoffset);

void processInput(GLFWwindow* window);

const unsigned int SCR_WIDTH = 800;

const unsigned int SCR_HEIGHT = 600;

Camera camera(glm::vec3(0.0f, 0.0f, 3.0f));

float lastX = SCR_WIDTH / 2.0f;

float lastY = SCR_HEIGHT / 2.0f;

bool firstMouse = true;

float deltaTime = 0.0f;

float lastFrame = 0.0f;

int main()

{

glfwInit();

glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);

glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);

glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

#ifdef __APPLE__

glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

#endif

GLFWwindow* window = glfwCreateWindow(SCR_WIDTH, SCR_HEIGHT, "LearnOpenGL", NULL, NULL);

if (window == NULL)

{

std::cout << "Failed to create GLFW window" << std::endl;

glfwTerminate();

return -1;

}

glfwMakeContextCurrent(window);

glfwSetFramebufferSizeCallback(window, framebuffer_size_callback);

glfwSetCursorPosCallback(window, mouse_callback);

glfwSetScrollCallback(window, scroll_callback);

glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress))

{

std::cout << "Failed to initialize GLAD" << std::endl;

return -1;

}

glEnable(GL_DEPTH_TEST);

Shader ourShader("7.4.camera.vs", "7.4.camera.fs");

Assimp::Importer importer;

const aiScene* scene = importer.ReadFile("models/robotic_arm.obj", aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_CalcTangentSpace);

if (!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode)

{

cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << endl;

return 0;

}

vector<float> vertices;

for (unsigned int i = 0; i < scene->mNumMeshes; i++)

{

for (unsigned int j = 0; j < scene->mMeshes[i]->mNumVertices; j++) {

vertices.push_back(scene->mMeshes[i]->mVertices[j].x);

vertices.push_back(scene->mMeshes[i]->mVertices[j].y);

vertices.push_back(scene->mMeshes[i]->mVertices[j].z);

vertices.push_back(0.0f);

vertices.push_back(0.0f);

}

}

unsigned int VBO, VAO;

glGenVertexArrays(1, &VAO);

glGenBuffers(1, &VBO);

glBindVertexArray(VAO);

glBindBuffer(GL_ARRAY_BUFFER, VBO);

glBufferData(GL_ARRAY_BUFFER, vertices.size() * sizeof(float), &vertices[0], GL_STATIC_DRAW);

glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);

glEnableVertexAttribArray(0);

glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (float*)(2 * sizeof(float)));

glEnableVertexAttribArray(1);

glBindBuffer(GL_ARRAY_BUFFER, 0);

glBindVertexArray(0);

GLuint texture1;

glGenTextures(1, &texture1);

glBindTexture(GL_TEXTURE_2D, texture1);

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);

int width, height;

unsigned char* image = SOIL_load_image("container.jpg", &width, &height, 0, SOIL_LOAD_RGB);

glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, image);

glGenerateMipmap(GL_TEXTURE_2D);

SOIL_free_image_data(image);

glBindTexture(GL_TEXTURE_2D, 0);

while (!glfwWindowShouldClose(window))

{

float currentFrame = glfwGetTime();

deltaTime = currentFrame - lastFrame;

lastFrame = currentFrame;

processInput(window);

glClearColor(0.2f, 0.3f, 0.3f, 1.0f);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

ourShader.use();

glActiveTexture(GL_TEXTURE0);

glBindTexture(GL_TEXTURE_2D, texture1);

glUniform1i(glGetUniformLocation(ourShader.ID, "ourTexture;"), 1);

glm::mat4 projection = glm::perspective(glm::radians(camera.Zoom), (float)SCR_WIDTH / (float)SCR_HEIGHT, 0.1f, 100.0f);

glm::mat4 view = camera.GetViewMatrix();

ourShader.setMat4("projection", projection);

ourShader.setMat4("view", view);

glm::mat4 model = glm::mat4(1.0f);

model = glm::translate(model, glm::vec3(0.0f, 0.0f, 0.0f));

model = glm::scale(model, glm::vec3(0.001f, 0.001f, 0.001f));

ourShader.setMat4("model", model);

glBindVertexArray(VAO);

glDrawArrays(GL_TRIANGLES, 0, vertices.size());

glfwSwapBuffers(window);

glfwPollEvents();

}

glfwTerminate();

return 0;

}

void processInput(GLFWwindow * window)

{

if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)

glfwSetWindowShouldClose(window, true);

if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)

camera.ProcessKeyboard(FORWARD, deltaTime);

if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)

camera.ProcessKeyboard(BACKWARD, deltaTime);

if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)

camera.ProcessKeyboard(LEFT, deltaTime);

if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)

camera.ProcessKeyboard(RIGHT, deltaTime);

}

void framebuffer_size_callback(GLFWwindow * window, int width, int height)

{

glViewport(0, 0, width, height);

}

void mouse_callback(GLFWwindow * window, double xpos, double ypos)

{

if (firstMouse)

{

lastX = xpos;

lastY = ypos;

firstMouse = false;

}

float xoffset = xpos - lastX;

float yoffset = lastY - ypos;

lastX = xpos;

lastY = ypos;

camera.ProcessMouseMovement(xoffset, yoffset);

}

void scroll_callback(GLFWwindow * window, double xoffset, double yoffset)

{

camera.ProcessMouseScroll(yoffset);

}

#version 330 core

in vec2 TexCoord;

out vec4 color;

uniform sampler2D ourTexture;

void main()

{

color = texture(ourTexture, TexCoord);

}

Фрагментный шейдер

#version 330 core

layout (location = 0) in vec3 aPos;

layout (location = 1) in vec2 texCoord;

uniform mat4 model;

uniform mat4 view;

uniform mat4 projection;

out vec2 TexCoord;

void main()

{

TexCoord = texCoord;

gl_Position = projection * view * model * vec4(aPos, 1.0f);

}

Вершинный шейдер

ВЫВОДЫ

В ходе выполнения лабораторной работы была построена 3D модель промышленного робота средствами OpenGL 3.3. Для этого были рассмотрены следующие библиотеки

1. Glad

2. GLFW

3. Glm

4. SOIL

Были написаны вершинный и фрагментный шейдер для вывода робота на экран.

Рис 1.1 – Результат работы программы.