Programming
335

Awesome C++ Project Idea






  30-Apr-2021 23:33:55



Awesome C++ Project 😍

Code 

main.cpp

/*
*
* RAYTRACING 2
*
* Autor: Dino1729
*
* 9. february, 2021.
*
* Inspired by HillsoftCode:
* https://www.youtube.com/playlist?list=PLAqGIYgEAxrUO6ODA0pnLkM2UOijerFPv
*/
#include <iostream>
#include <cstdlib>
#include <ctime>
#include "screen.h"
#include "camera.h"
#include "shape.h"
const float PI = 3.141592f;
float clamp(float f, float min, float max)
{
if (f < min) return min;
if (f > max) return max;
return f;
}
class Light
{
public:
void push_back(vec3 source, float intensity)
{
this->source.push_back(source);
this->intensity.push_back(intensity);
n++;
}
float enlighten(const Intersection& intersection, Shape* scene) const
{
float light = 0.0f;
for (int i = 0; i < n; i++)
{
Ray toLight(intersection.point(), (source[i] - intersection.point()).normalized());
float diffused = 0.0f;
if (!scene->doesIntersect(toLight))
diffused += intensity[i]*intersection.shape->getBrightness() * toLight.direction * intersection.normal;
if (diffused >= 0.0f)
light += diffused;
}
return light;
}
private:
std::vector<vec3> source;
std::vector<float> intensity;
int n = 0;
};
float RayTrace(Ray ray, Shape* scene, const Light& lights, int depth = 4)
{
//escape
if (depth == 0)
return 0.0f;
Intersection intersection(ray);
if (scene->doesIntersect(ray))
{
scene->intersect(intersection);
//diffusion
float diffused = lights.enlighten(intersection, scene);
//reflection
vec3 reflectedVec = ray.direction - 2 * (ray.direction * intersection.normal) * intersection.normal;
float reflected = RayTrace(Ray(intersection.point(), reflectedVec), scene, lights, depth-1);
float k = intersection.shape->getReflection();
float result = k * reflected + (1 - k) * diffused;
return clamp(result, 0.0f, 1.0f);
}
else
{
return 0.0f;
}
}
float random(float min, float max)
{
return min + static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / (max - min)));;
}
int main()
{
srand(static_cast <unsigned> (time(0)));
Screen scr;
Camera camera
(
25.0f * PI / 180.0f,
(float)WIDTH / (float)HEIGHT
);
vec3 position = vec3(-10.0f, 0.0f, 2.5f);
float alfa = 0.0f, beta = 0.0f;
camera.setPosition(vec3(0.0f, 0.0f, 0.0f));
camera.setDirection(alfa, beta);
float intensity = 1.5f;
float brightness = 1.5f;
float reflection = 0.3f;
//LIGHT
Light lights;
lights.push_back(vec3(+0.0f, +1000.0f, 1002.5f), intensity);
ShapeSet scene;
//FLOOR
Plane floor(
vec3(0.0f, 0.0f, 0.0f),
vec3(0.0f, 0.0f, 1.0f)
);
floor.setBrightness(2.0f);
floor.setReflection(0.7f);
scene.push_back(&floor);
//SPHERES
const int n = 10;
Sphere spheres[n];
for (int i = 0; i < n; i++)
{
float x = random(-5.0f, 5.0f);
float y = random(-5.0f, 5.0f);
float z = random(+0.4f, 1.5f);
spheres[i] = Sphere(vec3(x,y,z),z);
spheres[i].setBrightness(brightness);
spheres[i].setReflection(reflection);
scene.push_back(&spheres[i]);
}
//MAIN LOOP
while (true)
{
HANDLE hInput;
DWORD prev_mode;
hInput = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(hInput, &prev_mode);
SetConsoleMode(hInput, prev_mode & ENABLE_EXTENDED_FLAGS);
//KEYBOARD INPUT
if (GetKeyState(0x57) & 0x8000) position += 8 * (1.0f / 60.0f) * camera.getForward(); //W
if (GetKeyState(0x41) & 0x8000) position -= 8 * (1.0f / 60.0f) * camera.getRight(); //A
if (GetKeyState(0x53) & 0x8000) position -= 8 * (1.0f / 60.0f) * camera.getForward(); //S
if (GetKeyState(0x44) & 0x8000) position += 8 * (1.0f / 60.0f) * camera.getRight(); //D
if (GetKeyState(VK_SHIFT) & 0x8000) position.z -= 8 * (1.0f / 60.0f);
if (GetKeyState(VK_SPACE) & 0x8000) position.z += 8 * (1.0f / 60.0f);
//CAMERA MOVEMENT
if (GetKeyState(VK_UP) & 0x8000) beta += 1.0f / 120.0f * (2.0f * PI);
if (GetKeyState(VK_LEFT) & 0x8000) alfa -= 1.0f / 120.0f * (2.0f * PI);
if (GetKeyState(VK_DOWN) & 0x8000) beta -= 1.0f / 120.0f * (2.0f * PI);
if (GetKeyState(VK_RIGHT) & 0x8000) alfa += 1.0f / 120.0f * (2.0f * PI);
if (GetKeyState(VK_ESCAPE) & 0x8000)
{
//EXIT THE PROGRAM
//...
return 0;
}
camera.setPosition(position);
camera.setDirection(alfa, beta);
//RAY TRACING
for (int x = 0; x < WIDTH; x++)
{
for (int y = 0; y < HEIGHT; y++)
{
vec2 screenCoord((2.0f * x) / WIDTH - 1.0f, -(2.0f * y) / HEIGHT + 1.0f);
Ray ray = camera.makeRay(screenCoord);
float brightness = 0.5;
brightness = RayTrace(ray, &scene, lights);
scr.DrawPoint(y, x, (byte)(brightness * 255));
}
}
//DRAWING
scr.Draw();
}
return 0;
}


Ray.h

#pragma once
#include "vec3.h"
#define RAY_T_MIN 0.0001f
#define RAY_T_MAX 10000000.0f
struct Ray
{
vec3 origin;
vec3 direction;
float tMax;
Ray() :tMax(RAY_T_MAX) {};
Ray(vec3 origin, vec3 direction, float tMax = RAY_T_MAX) :origin(origin), direction(direction), tMax(tMax) {}
vec3 point(float t) const { return origin + t * direction; }

};


Detail 👇🏻

Github : https://github.com/DinoZ1729/Ray-2 



DISCUSSION
Nothing comment here :(
Login for comment and discussion.
Login Here
Sponsored

Oppss... No sponsors yet

Popular Posts
Complete Basic Course in Kali...
Djie sam soe Djie sam soe
Linux
10195
2
Top

Gps Tracker Seccodeid Free Too...
Djie sam soe Djie sam soe
General
7248
167
Top

Free Proxy List
Sandidi Sandidi
Networking
3064
3
Top

Mass Reverse IP Unlimited
ImamWawe ImamWawe
Tools Hacking
2361
12
Top

Report McAfee Antivirus Hurrri...
Indrasp Indrasp
Windows
1702
93
Top

Related Post

Youtube Video

Subscribe