Skip to content

Instantly share code, notes, and snippets.

@habibg1232191
Last active May 7, 2024 08:52
Show Gist options
  • Save habibg1232191/8f0ab7abcefb99060a846bbbc895c0b0 to your computer and use it in GitHub Desktop.
Save habibg1232191/8f0ab7abcefb99060a846bbbc895c0b0 to your computer and use it in GitHub Desktop.
#include "Render.h"
#include <sstream>
#include <iostream>
#include <windows.h>
#include <GL\GL.h>
#include <GL\GLU.h>
#include "MyOGL.h"
#include "Camera.h"
#include "Light.h"
#include "Primitives.h"
#include "GUItextRectangle.h"
#define PI 3.14
bool textureMode = true;
bool lightMode = true;
bool textureReplace = true; // (Н) Эта переменная отвечает за смену текстур
//класс для настройки камеры
class CustomCamera : public Camera
{
public:
//дистанция камеры
double camDist;
//углы поворота камеры
double fi1, fi2;
//значния масеры по умолчанию
CustomCamera()
{
camDist = 15;
fi1 = 1;
fi2 = 1;
}
//считает позицию камеры, исходя из углов поворота, вызывается движком
void SetUpCamera()
{
//отвечает за поворот камеры мышкой
lookPoint.setCoords(0, 0, 0);
pos.setCoords(camDist * cos(fi2) * cos(fi1),
camDist * cos(fi2) * sin(fi1),
camDist * sin(fi2));
if (cos(fi2) <= 0)
normal.setCoords(0, 0, -1);
else
normal.setCoords(0, 0, 1);
LookAt();
}
void CustomCamera::LookAt()
{
//функция настройки камеры
gluLookAt(pos.X(), pos.Y(), pos.Z(), lookPoint.X(), lookPoint.Y(), lookPoint.Z(), normal.X(), normal.Y(), normal.Z());
}
} camera; //создаем объект камеры
//Класс для настройки света
class CustomLight : public Light
{
public:
CustomLight()
{
//начальная позиция света
pos = Vector3(1, 1, 3);
}
//рисует сферу и линии под источником света, вызывается движком
void DrawLightGhismo()
{
glDisable(GL_LIGHTING);
glColor3d(0.9, 0.8, 0);
Sphere s;
s.pos = pos;
s.scale = s.scale * 0.08;
s.Show();
if (OpenGL::isKeyPressed('G'))
{
glColor3d(0, 0, 0);
//линия от источника света до окружности
glBegin(GL_LINES);
glVertex3d(pos.X(), pos.Y(), pos.Z());
glVertex3d(pos.X(), pos.Y(), 0);
glEnd();
//рисуем окруность
Circle c;
c.pos.setCoords(pos.X(), pos.Y(), 0);
c.scale = c.scale * 1.5;
c.Show();
}
}
void SetUpLight()
{
GLfloat amb[] = { 0.2, 0.2, 0.2, 0 };
GLfloat dif[] = { 1.0, 1.0, 1.0, 0 };
GLfloat spec[] = { .7, .7, .7, 0 };
GLfloat position[] = { pos.X(), pos.Y(), pos.Z(), 1. };
// параметры источника света
glLightfv(GL_LIGHT0, GL_POSITION, position);
// характеристики излучаемого света
// фоновое освещение (рассеянный свет)
glLightfv(GL_LIGHT0, GL_AMBIENT, amb);
// диффузная составляющая света
glLightfv(GL_LIGHT0, GL_DIFFUSE, dif);
// зеркально отражаемая составляющая света
glLightfv(GL_LIGHT0, GL_SPECULAR, spec);
glEnable(GL_LIGHT0);
}
} light; //создаем источник света
//старые координаты мыши
int mouseX = 0, mouseY = 0;
void mouseEvent(OpenGL* ogl, int mX, int mY)
{
int dx = mouseX - mX;
int dy = mouseY - mY;
mouseX = mX;
mouseY = mY;
//меняем углы камеры при нажатой левой кнопке мыши
if (OpenGL::isKeyPressed(VK_RBUTTON))
{
camera.fi1 += 0.01 * dx;
camera.fi2 += -0.01 * dy;
}
//двигаем свет по плоскости, в точку где мышь
if (OpenGL::isKeyPressed('G') && !OpenGL::isKeyPressed(VK_LBUTTON))
{
LPPOINT POINT = new tagPOINT();
GetCursorPos(POINT);
ScreenToClient(ogl->getHwnd(), POINT);
POINT->y = ogl->getHeight() - POINT->y;
Ray r = camera.getLookRay(POINT->x, POINT->y);
double z = light.pos.Z();
double k = 0, x = 0, y = 0;
if (r.direction.Z() == 0)
k = 0;
else
k = (z - r.origin.Z()) / r.direction.Z();
x = k * r.direction.X() + r.origin.X();
y = k * r.direction.Y() + r.origin.Y();
light.pos = Vector3(x, y, z);
}
if (OpenGL::isKeyPressed('G') && OpenGL::isKeyPressed(VK_LBUTTON))
{
light.pos = light.pos + Vector3(0, 0, 0.02 * dy);
}
}
void mouseWheelEvent(OpenGL* ogl, int delta)
{
if (delta < 0 && camera.camDist <= 1)
return;
if (delta > 0 && camera.camDist >= 100)
return;
camera.camDist += 0.01 * delta;
}
void keyDownEvent(OpenGL* ogl, int key)
{
if (key == 'L')
{
lightMode = !lightMode;
}
if (key == 'T')
{
textureMode = !textureMode;
}
if (key == 'R')
{
camera.fi1 = 1;
camera.fi2 = 1;
camera.camDist = 15;
light.pos = Vector3(1, 1, 3);
}
if (key == 'F')
{
light.pos = camera.pos;
}
if (key == 'E') // (Н) Смена текстуры происходит по этой кнопке
{
textureReplace = !textureReplace;
}
}
void keyUpEvent(OpenGL* ogl, int key)
{
}
GLuint texId;
GLuint texId2; // (Н) Я хз как по другому делать, поэтому я просто скопировал часть кода, ко всем переменным в конце добавил "2", и всё работает
//выполняется перед первым рендером
void initRender(OpenGL* ogl)
{
//настройка текстур
//4 байта на хранение пикселя
glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
//настройка режима наложения текстур
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
//включаем текстуры
glEnable(GL_TEXTURE_2D);
//массив трехбайтных элементов (R G B) (Н) Код брался и копировался отсюда
RGBTRIPLE* texarray;
//массив символов, (высота*ширина*4 4, потомучто выше, мы указали использовать по 4 байта на пиксель текстуры - R G B A)
char* texCharArray;
int texW, texH;
OpenGL::LoadBMP("texture.bmp", &texW, &texH, &texarray); // (Н) Чтоб не мучаться с картинками, я коприовал старую и рисовал на ней
OpenGL::RGBtoChar(texarray, texW, texH, &texCharArray);
//генерируем ИД для текстуры
glGenTextures(1, &texId);
//биндим айдишник, все что будет происходить с текстурой, будте происходить по этому ИД
glBindTexture(GL_TEXTURE_2D, texId);
//загружаем текстуру в видеопямять, в оперативке нам больше она не нужна
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texW, texH, 0, GL_RGBA, GL_UNSIGNED_BYTE, texCharArray);
//отчистка памяти
free(texCharArray);
free(texarray);
//наводим шмон
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_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); // (Н) И досюда
//массив трехбайтных элементов (R G B)
RGBTRIPLE* texarray2;
//массив символов, (высота*ширина*4 4, потомучто выше, мы указали использовать по 4 байта на пиксель текстуры - R G B A)
char* texCharArray2;
int texW2, texH2;
OpenGL::LoadBMP("texture1.bmp", &texW2, &texH2, &texarray2);
OpenGL::RGBtoChar(texarray2, texW2, texH2, &texCharArray2);
//генерируем ИД для текстуры
glGenTextures(1, &texId2);
//биндим айдишник, все что будет происходить с текстурой, будте происходить по этому ИД
glBindTexture(GL_TEXTURE_2D, texId2);
//загружаем текстуру в видеопямять, в оперативке нам больше она не нужна
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texW2, texH2, 0, GL_RGBA, GL_UNSIGNED_BYTE, texCharArray2);
//отчистка памяти
free(texCharArray2);
free(texarray2);
//наводим шмон
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_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//камеру и свет привязываем к "движку"
ogl->mainCamera = &camera;
ogl->mainLight = &light;
// нормализация нормалей : их длины будет равна 1
glEnable(GL_NORMALIZE);
// устранение ступенчатости для линий
glEnable(GL_LINE_SMOOTH);
// задать параметры освещения
// параметр GL_LIGHT_MODEL_TWO_SIDE -
// 0 - лицевые и изнаночные рисуются одинаково(по умолчанию),
// 1 - лицевые и изнаночные обрабатываются разными режимами
// соответственно лицевым и изнаночным свойствам материалов.
// параметр GL_LIGHT_MODEL_AMBIENT - задать фоновое освещение,
// не зависящее от сточников
// по умолчанию (0.2, 0.2, 0.2, 1.0)
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 0);
camera.fi1 = -1.3;
camera.fi2 = 0.8;
}
void crossProduct(double vec1[3], double vec2[3], double result[3]) {
result[0] = vec1[1] * vec2[2] - vec1[2] * vec2[1];
result[1] = vec1[2] * vec2[0] - vec1[0] * vec2[2];
result[2] = vec1[0] * vec2[1] - vec1[1] * vec2[0];
}
// Функция для нормализации вектора
void normalize(double vec[3]) {
double length = std::sqrt(vec[0] * vec[0] + vec[1] * vec[1] + vec[2] * vec[2]);
if (length != 0.0f) {
vec[0] /= length;
vec[1] /= length;
vec[2] /= length;
}
}
// Функция для вычисления нормали по трем векторам
void computeNormal(double vec1[3], double vec2[3], double vec3[3], double normal[3]) {
double vecA[3] = { vec2[0] - vec1[0], vec2[1] - vec1[1], vec2[2] - vec1[2] };
double vecB[3] = { vec3[0] - vec1[0], vec3[1] - vec1[1], vec3[2] - vec1[2] };
crossProduct(vecA, vecB, normal);
normalize(normal);
}
// Функция для вычисления нормали по четырем векторам
void computeQuadNormal(double A[3], const double B[3], double C[3], double D[3], double normal[3]) {
double vec1[3] = { B[0] - A[0], B[1] - A[1], B[2] - A[2] };
double vec2[3] = { D[0] - A[0], D[1] - A[1], D[2] - A[2] };
crossProduct(vec1, vec2, normal);
normalize(normal);
}
//Начало рисования квадратика станкина
double A[] = { 0.0, 0.0, 0.0 };
double B[] = { 7, -3, 0 };
double C[] = { 5, -7, 0 };
double D[] = { 8, -11, 0 };
double E[] = { 2, -13, 0 }; //polukrug dlya 40
double F[] = { 2, -8, 0 }; //polukrug dlya 40
double G[] = { -6, -7, 0 };
double H[] = { 0, -6, 0 };
double A1[] = { 0.0, 0.0, 5 };
double B1[] = { 7, -3, 5 };
double C1[] = { 5, -7, 5 };
double D1[] = { 8, -11, 5 };
double E1[] = { 2, -13, 5 }; //polukrug dlya 40
double F1[] = { 2, -8, 5 }; //polukrug dlya 40
double G1[] = { -6, -7, 5 };
double H1[] = { 0, -6, 5 };
double ED[] = { 4.95, -11.9, 0 }; //polukrug dlya 40
double AB[] = { 4.145, 0, 0 }; //polukrug dlya 40
void drawGreenCylinder()
{
glColor3d(0, 1, 0);
double step = 0.1;
double height = 5;
double radius = PI * 2.0 / 2;
glPushMatrix();
glTranslatef(ED[0], ED[1], ED[2]);
glRotatef(18, 0, 0, 1);
double normal[3];
double Det[] = { 0,0,0 };
double Det1[] = { 0,0,5 };
double N[] = { 0,0,0 };
double Nl;
double x0 = radius * cos(PI);
double y0 = radius * sin(PI);
double tx0 = 0;
double ty0 = 0;
step = 0.0001;
for (double a = -PI; a <= 0; a += step)
{
double x = radius * cos(a);
double y = radius * sin(a);
double tx = tx0 + 1.0 / 8440.0;
double ty = tx0 + 1.0 / 8440.0;
glBegin(GL_QUADS);
Det[0] = { x - (16 + PI * cos((a - 0.0001) * 3.141593)) }; // (Н) Это нахождение нормалей
Det[1] = { y - (2 + PI * 2 * sin((a - 0.0001) * 3.141593)) };
N[0] = { Det[1] * Det1[2] - Det1[1] * Det[2] };
N[1] = { -Det[0] * Det1[2] + Det1[0] * Det[2] };
N[2] = { Det[0] * Det1[1] - Det1[0] * Det[1] };
Nl = sqrt(N[0] * N[0] + N[1] * N[1] + N[2] * N[2]);
N[0] = { N[0] / Nl };
N[1] = { N[1] / Nl };
N[2] = { N[2] / Nl };
glNormal3d(N[0], -N[1], N[2]);
glTexCoord2d(tx0, 0); // (Н) Это пиздец, нигде нет нормального гайда наложения текстуры на выпулкую плоскость
glVertex3d(x0, y0, 0); // (Н) Для работы с текстурами существуют текстурные координаты от 0 до 1. Если мы хотим впихнуть в условный квадрат половину текстуры мы просто вводим дробь
glTexCoord2d(tx, 0); // (Н) Вот здесь это и используется, я, по сути, делю текстуру на 7000 частей, и на каждый квадрат(их 7000 штук) накладываю определённую часть текстуры
glVertex3d(x, y, 0); // (Н) Если что не понятно спрашивайте лично, правда объяснять я не умею :p
glTexCoord2d(ty, 1); // (Н) Если у вас будет текстура с зарисованным правым углом(у меня такая была, лучше края не закрашывать) будут артефакты!!!!!
glVertex3d(x, y, 5);
glTexCoord2d(ty0, 1);
glVertex3d(x0, y0, 5);
glEnd();
x0 = x;
y0 = y;
tx0 = tx;
ty0 = ty;
}
glPopMatrix();
}
void drawPurpleCylinder()
{
glColor3d(0.54, 0, 1);
double step = 0.1;
double height = 5;
double radius = PI * 2.64 / 2;
glPushMatrix();
glTranslatef(AB[0], AB[1], AB[2]);
// glRotatef(-23.19, 0, 0, 1); // x = 7, y = -3
double cut_angle = 2 * PI - 0.8;
const double finalAngle = 3 * PI / 2 + 0.05;
glColor3f(1, 0, 0);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(-AB[0], H[1], 0);
glNormal3d(0, 0, -1);
for (double a = PI; a <= PI * 2; a += step)
{
double px = radius * cos(a);
double py = radius * sin(a);
if (a >= PI && a <= finalAngle)
{
glVertex3f(px, py, 0);
}
}
glVertex3f(radius * cos(finalAngle), radius * sin(finalAngle), 0);
glEnd();
double normal[3];
double Det[] = { 0,0,0 };
double Det1[] = { 0,0,5 };
double N[] = { 0,0,0 };
double Nl;
double x0 = radius * cos(PI);
double y0 = radius * sin(PI);
double tx0 = 0;
double ty0 = 0;
step = 0.0001;
for (double a = PI; a <= cut_angle; a += step) {
double x = radius * cos(a);
double y = radius * sin(a);
double tx = tx0 + 1.0 / 7000.0;
double ty = tx0 + 1.0 / 7000.0;
glBegin(GL_QUADS);
Det[0] = { x - (18 + PI * cos((a - 0.0001) * 3.141593)) }; // (Н) Это нахождение нормалей
Det[1] = { y - (2 + PI * sin((a - 0.0001) * 3.141593)) };
N[0] = { Det[1] * Det1[2] - Det1[1] * Det[2] };
N[1] = { -Det[0] * Det1[2] + Det1[0] * Det[2] };
N[2] = { Det[0] * Det1[1] - Det1[0] * Det[1] };
Nl = sqrt(N[0] * N[0] + N[1] * N[1] + N[2] * N[2]);
N[0] = { N[0] / Nl };
N[1] = { N[1] / Nl };
N[2] = { N[2] / Nl };
glNormal3d(N[0], N[1], N[2]);
glTexCoord2d(tx0, 0); // (Н) Это пиздец, нигде нет нормального гайда наложения текстуры на выпулкую плоскость
glVertex3d(x0, y0, 0); // (Н) Для работы с текстурами существуют текстурные координаты от 0 до 1. Если мы хотим впихнуть в условный квадрат половину текстуры мы просто вводим дробь
glTexCoord2d(tx, 0); // (Н) Вот здесь это и используется, я, по сути, делю текстуру на 7000 частей, и на каждый квадрат(их 7000 штук) накладываю определённую часть текстуры
glVertex3d(x, y, 0); // (Н) Если что не понятно спрашивайте лично, правда объяснять я не умею :p
glTexCoord2d(ty, 1); // (Н) Если у вас будет текстура с зарисованным правым углом(у меня такая была, лучше края не закрашывать) будут артефакты!!!!!
glVertex3d(x, y, 5);
glTexCoord2d(ty0, 1);
glVertex3d(x0, y0, 5);
glEnd();
x0 = x;
y0 = y;
tx0 = tx;
ty0 = ty;
}
glPopMatrix();
}
void Render(OpenGL* ogl)
{
glDisable(GL_TEXTURE_2D);
glDisable(GL_LIGHTING);
glEnable(GL_DEPTH_TEST);
if (textureMode) {
glEnable(GL_TEXTURE_2D);
}
if (textureReplace)
glBindTexture(GL_TEXTURE_2D, texId);
else
glBindTexture(GL_TEXTURE_2D, texId2);
if (lightMode)
glEnable(GL_LIGHTING);
//альфаналожение
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA);
glDisable(GL_BLEND);
//настройка материала
GLfloat amb[] = { 0.2, 0.2, 0.1, 1. };
GLfloat dif[] = { 0.4, 0.65, 0.5, 1. };
GLfloat spec[] = { 0.9, 0.8, 0.3, 1. };
GLfloat sh = 0.1f * 256;
//фоновая
glMaterialfv(GL_FRONT, GL_AMBIENT, amb);
//дифузная
glMaterialfv(GL_FRONT, GL_DIFFUSE, dif);
//зеркальная
glMaterialfv(GL_FRONT, GL_SPECULAR, spec);
//размер блика
glMaterialf(GL_FRONT, GL_SHININESS, sh);
//чтоб было красиво, без квадратиков (сглаживание освещения)
glShadeModel(GL_SMOOTH);
//===================================
//Прогать тут (Н) это обман, пришлось прогать не только тут
glColor3d(0.7, 0.7, 0.7);
double normal[3];
glPushMatrix();
glTranslatef(3.15, -8, 0);
glNormal3d(0, 0, -1);
glBegin(GL_QUADS);
glTexCoord2f(0.881558, 0.981456); glVertex3f(3.824006, 4.992247, 0.000000);
glTexCoord2f(0.227477, 0.928578); glVertex3f(-3.175994, 1.992247, 0.000000);
glTexCoord2f(0.608187, 0.709272); glVertex3f(1.824006, 0.992247, 0.000000);
glTexCoord2f(0.608406, 0.709653); glVertex3f(1.824006, 0.992247, 0.000000);
glEnd();
glNormal3d(0, 0, -1);
glBegin(GL_QUADS);
glTexCoord2f(0.790692, 0.314463); glVertex3f(4.824006, -3.007753, 0.000000);
glTexCoord2f(0.192108, 0.294675); glVertex3f(-1.175994, -5.007753, 0.000000);
glTexCoord2f(0.611395, 0.698107); glVertex3f(1.824006, 0.992247, 0.000000);
glTexCoord2f(0.611365, 0.697107); glVertex3f(1.824006, 0.992247, 0.000000);
glEnd();
glNormal3d(0, 0, -1);
glBegin(GL_QUADS);
glTexCoord2f(0.607310, 0.699514); glVertex3f(1.824006, 0.992247, 0.000000);
glTexCoord2f(0.334842, 0.701850); glVertex3f(-1.175994, -0.007753, 0.000000);
glTexCoord2f(0.194697, 0.294455); glVertex3f(-1.175994, -5.007753, 0.000000);
glTexCoord2f(0.195105, 0.294315); glVertex3f(-1.175994, -5.007753, 0.000000);
glEnd();
glNormal3d(0, 0, -1);
glBegin(GL_QUADS);
glTexCoord2f(-0.285323, 1.022857); glVertex3f(-9.175995, 0.992247, 0.000000);
glTexCoord2f(0.230287, 0.928779); glVertex3f(-3.175994, 1.992247, 0.000000);
glTexCoord2f(-0.606671, 0.702129); glVertex3f(1.824006, 0.992247, 0.000000);
glTexCoord2f(0.606444, 0.701753); glVertex3f(1.824006, 0.992247, 0.000000);
glEnd();
glNormal3d(0, 0, -1);
glBegin(GL_QUADS);
glTexCoord2f(0.609789, 0.703821); glVertex3f(1.824006, 0.992247, 0.000000);
glTexCoord2f(0.337361, 0.709037); glVertex3f(-1.175994, -0.007753, 0.000000);
glTexCoord2f(-0.283799, 1.020082); glVertex3f(-9.175995, 0.992247, 0.000000);
glTexCoord2f(-0.283487, 1.020703); glVertex3f(-9.175995, 0.992247, 0.000000);
glEnd();
glPushMatrix();
glTranslatef(-0.04, 0.14, 0);
glBegin(GL_POLYGON);
glTexCoord2d(0.204103, 0.376327); glVertex3f(-1.252155, -4.628666, 0.000000);
glTexCoord2d(0.198819, 0.319059); glVertex3f(-1.073380, -5.218007, 0.000000);
glTexCoord2d(0.204810, 0.261860); glVertex3f(-0.783066, -5.761147, 0.000000);
glTexCoord2d(0.221844, 0.206929); glVertex3f(-0.392369, -6.237213, 0.000000);
glTexCoord2d(0.249267, 0.156377); glVertex3f(0.083698, -6.627910, 0.000000);
glTexCoord2d(0.286026, 0.112147); glVertex3f(0.626837, -6.918224, 0.000000);
glTexCoord2d(0.330707, 0.075937); glVertex3f(1.216179, -7.096999, 0.000000);
glTexCoord2d(0.381594, 0.049140); glVertex3f(1.829073, -7.157364, 0.000000);
glTexCoord2d(0.436731, 0.032786); glVertex3f(2.441967, -7.096999, 0.000000);
glTexCoord2d(0.493999, 0.027502); glVertex3f(3.031308, -6.918224, 0.000000);
glTexCoord2d(0.551198, 0.033492); glVertex3f(3.574448, -6.627910, 0.000000);
glTexCoord2d(0.606128, 0.050527); glVertex3f(4.050514, -6.237213, 0.000000);
glTexCoord2d(0.656681, 0.077950); glVertex3f(4.441212, -5.761147, 0.000000);
glTexCoord2d(0.700912, 0.114709); glVertex3f(4.731526, -5.218007, 0.000000);
glTexCoord2d(0.737121, 0.159390); glVertex3f(4.910301, -4.628666, 0.000000);
glTexCoord2d(0.763918, 0.210277); glVertex3f(4.970666, -4.015771, 0.000000);
glTexCoord2d(0.780272, 0.265414); glVertex3f(4.910301, -3.402877, 0.000000);
glTexCoord2d(0.785556, 0.322682); glVertex3f(4.731526, -2.813536, 0.000000);
glEnd();
glPopMatrix();
glPopMatrix();
drawGreenCylinder();
drawPurpleCylinder();
glDisable(GL_BLEND);
/*glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(A, A1, B1, B, normal);
glNormal3dv(normal);
glTexCoord2d(0, 0);
glVertex3dv(A);
glTexCoord2d(0, 1);
glVertex3dv(A1);
glTexCoord2d(1, 1);
glVertex3dv(B1);
glTexCoord2d(1, 0);
glVertex3dv(B);
glEnd();*/
glColor3d(0.7, 0.7, 0.7);
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(B, B1, C1, C, normal);
glNormal3dv(normal);
glTexCoord2d(0, 0); // (Н) Это накладывается текстура (x, y) это углы текстуры, пишутся поверх углов квадратов
glVertex3dv(B);
glTexCoord2d(0, 1);
glVertex3dv(B1);
glTexCoord2d(1, 1);
glVertex3dv(C1);
glTexCoord2d(1, 0);
glVertex3dv(C);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(C1, C, D, D1, normal);
glNormal3d(-normal[0], -normal[1], normal[2]); // 2
glTexCoord2d(0, 0);
glVertex3dv(C1);
glTexCoord2d(1, 0);
glVertex3dv(C);
glTexCoord2d(1, 1);
glVertex3dv(D);
glTexCoord2d(0, 1);
glVertex3dv(D1);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(E, E1, F1, F, normal);
glNormal3dv(normal);
glTexCoord2d(0, 0);
glVertex3dv(E);
glTexCoord2d(1, 0);
glVertex3dv(E1);
glTexCoord2d(1, 1);
glVertex3dv(F1);
glTexCoord2d(0, 1);
glVertex3dv(F);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(F, F1, G1, G, normal);
glNormal3dv(normal);
glTexCoord2d(0, 0);
glVertex3dv(F);
glTexCoord2d(0, 1);
glVertex3dv(F1);
glTexCoord2d(1, 1);
glVertex3dv(G1);
glTexCoord2d(1, 0);
glVertex3dv(G);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(G, G1, H1, H, normal);
glNormal3dv(normal);
glTexCoord2d(0, 0);
glVertex3dv(G);
glTexCoord2d(0, 1);
glVertex3dv(G1);
glTexCoord2d(1, 1);
glVertex3dv(H1);
glTexCoord2d(1, 0);
glVertex3dv(H);
glEnd();
glBegin(GL_QUADS);
glColor3f(0.3f, 0.3f, 0.3f);
computeQuadNormal(H, H1, A1, A, normal);
glNormal3dv(normal);
glTexCoord2d(0, 0);
glVertex3dv(H);
glTexCoord2d(0, 1);
glVertex3dv(H1);
glTexCoord2d(1, 1);
glVertex3dv(A1);
glTexCoord2d(1, 0);
glVertex3dv(A);
glEnd();
glEnable(GL_BLEND); // (Н) Здесь строится крышка. Чтоб Альфа наложение хорошо работало, то объект, который должен быть прозрачным(для этого альфа и существует)
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); //Должен строится в последнию очередь, иначе он будет просвечиваться "насквозь", если захотите сами поэксперементируйте
// (Н) Аргументы объяснять не буду, сами найдёте инфу
const double ALPHA = 0.5;
glBegin(GL_TRIANGLES);
computeNormal(B1, H1, C1, normal);
glNormal3d(normal[0], normal[1], 5); // (Н) Это нормаль
glColor4f(0.5f, 0.5f, 0.5f, ALPHA);
glVertex3dv(B1);
glVertex3dv(H1);
glVertex3dv(C1);
glEnd();
glPushMatrix();
glTranslatef(ED[0], ED[1], ED[2]);
glRotatef(18, 0, 0, 1);
double step = 0.1;
double height = 5;
double radius = PI * 2.0 / 2;
height = 5;
radius = PI * 2.0 / 2;
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0, 0, height);
glNormal3d(0, 0, height);
for (double a = -PI; a <= 0; a += step)
{
glVertex3f(radius * cos(a), radius * sin(a), height);
}
glVertex3f(radius * cos(0), radius * sin(0), height);
glEnd();
glBegin(GL_TRIANGLE_FAN);
glVertex3f(0, 0, height);
glNormal3d(0, 0, height);
for (double a = -PI; a <= 0; a += step)
{
glVertex3f(radius * cos(a), radius * sin(a), height);
}
glVertex3f(radius * cos(0), radius * sin(0), height);
glEnd();
glPopMatrix();
glPushMatrix();
glTranslatef(AB[0], AB[1], AB[2]);
// glRotatef(-23.19, 0, 0, 1); // x = 7, y = -3
double cut_angle = 2 * PI - 0.8;
const double finalAngle = 3 * PI / 2 + 0.05;
radius = PI * 2.64 / 2;
glColor4f(0.5f, 0.5f, 0.5f, ALPHA);
glBegin(GL_TRIANGLE_FAN);
glVertex3f(-AB[0], H[1], height);
glNormal3d(0, 0, height);
for (double a = PI; a <= PI * 2; a += step)
{
double px = radius * cos(a);
double py = radius * sin(a);
if (a >= PI && a <= finalAngle)
{
glVertex3f(px, py, height);
}
}
glVertex3f(radius * cos(finalAngle), radius * sin(finalAngle), height);
glEnd();
glPopMatrix();
glBegin(GL_TRIANGLES);
computeNormal(D1, E1, C1, normal);
glNormal3d(normal[0], normal[1], 5);
glColor4f(0.5f, 0.5f, 0.5f, ALPHA);
glVertex3dv(D1);
glVertex3dv(E1);
glVertex3dv(C1);
glEnd();
glBegin(GL_TRIANGLES);
computeNormal(C1, F1, E1, normal);
glNormal3d(normal[0], normal[1], 5);
glColor4f(0.5f, 0.5f, 0.5f, ALPHA);
glVertex3dv(C1);
glVertex3dv(F1);
glVertex3dv(E1);
glEnd();
glBegin(GL_TRIANGLES);
computeNormal(G1, H1, C1, normal);
glNormal3d(normal[0], normal[1], 5);
glColor4f(0.5f, 0.5f, 0.5f, ALPHA);
glVertex3dv(G1);
glVertex3dv(H1);
glVertex3dv(C1);
glEnd();
glBegin(GL_TRIANGLES);
computeNormal(C1, F1, G1, normal);
glNormal3d(normal[0], normal[1], 5);
glColor4f(0.5f, 0.5f, 0.5f, ALPHA);
glVertex3dv(C1);
glVertex3dv(F1);
glVertex3dv(G1);
glEnd();
glDisable(GL_BLEND);
//Круг с текстурой внизу!
/*glBegin(GL_POLYGON); // (Н) Круг с норм текстурой, хз как работает код взял с Overflow
for (double i = 0; i <= 2; i += 0.01)
{
double x = 9 * cos(i * 3.141593);
double y = 9 * sin(i * 3.141593);
double tx = cos(i * 3.141593) * 0.5 + 0.5; // (Н) Для корректного отображения текстуры нужны эти переменные
double ty = sin(i * 3.141593) * 0.5 + 0.5;
glColor3d(0.5f, 0.5f, 0.5f);
glNormal3d(0, 0, 1);
glTexCoord2d(tx, ty); // (Н) Суюда их засовываем и всё норм
glVertex3d(x, y, 0);
}
glEnd();
*/
/*double A2[] = {4,4,4};
double B2[] = { 4,-4,4 };
double C2[] = { -4,-4,4 };
double D2[] = { -4,4,4 };
double A3[] = { 4,4,0.1 };
double B3[] = { 4,-4,0.1 };
double C3[] = { -4,-4,0.1 };
double D3[] = { -4,4,0.1 };
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glBegin(GL_QUADS);
glColor4f(0, 1, 0, 0.5);
glTexCoord2d(0, 0);
glVertex3dv(A2);
glTexCoord2d(0, 1);
glVertex3dv(B2);
glTexCoord2d(1, 1);
glVertex3dv(C2);
glTexCoord2d(1, 0);
glVertex3dv(D2);
glEnd();
glDisable(GL_BLEND);
glBegin(GL_QUADS);
glColor3f(1, 0, 0);
glVertex3dv(A3);
glVertex3dv(B3);
glVertex3dv(C3);
glVertex3dv(D3);
glEnd();*/
//Сообщение вверху экрана
glMatrixMode(GL_PROJECTION); //Делаем активной матрицу проекций.
//(всек матричные операции, будут ее видоизменять.)
glPushMatrix(); //сохраняем текущую матрицу проецирования (которая описывает перспективную проекцию) в стек
glLoadIdentity(); //Загружаем единичную матрицу
glOrtho(0, ogl->getWidth(), 0, ogl->getHeight(), 0, 1); //врубаем режим ортогональной проекции
glMatrixMode(GL_MODELVIEW); //переключаемся на модел-вью матрицу
glPushMatrix(); //сохраняем текущую матрицу в стек (положение камеры, фактически)
glLoadIdentity(); //сбрасываем ее в дефолт
glDisable(GL_LIGHTING);
GuiTextRectangle rec; //классик моего авторства для удобной работы с рендером текста.
rec.setSize(300, 200);
rec.setPosition(10, ogl->getHeight() - 200 - 10);
std::stringstream ss;
ss << "T - вкл/выкл текстур" << std::endl;
ss << "E - Переключение текстур" << std::endl;
ss << "L - вкл/выкл освещение" << std::endl;
ss << "F - Свет из камеры" << std::endl;
ss << "G - двигать свет по горизонтали" << std::endl;
ss << "G+ЛКМ двигать свет по вертекали" << std::endl;
ss << "Коорд. света: (" << light.pos.X() << ", " << light.pos.Y() << ", " << light.pos.Z() << ")" << std::endl;
ss << "Коорд. камеры: (" << camera.pos.X() << ", " << camera.pos.Y() << ", " << camera.pos.Z() << ")" << std::endl;
ss << "Параметры камеры: R=" << camera.camDist << ", fi1=" << camera.fi1 << ", fi2=" << camera.fi2 << std::endl;
ss << "UV-развёртка" << std::endl;
rec.setText(ss.str().c_str());
rec.Draw();
glMatrixMode(GL_PROJECTION); //восстанавливаем матрицы проекции и модел-вью обратьно из стека.
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
glPopMatrix();
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment