#include “render.h”
#include “resource.h”

#include “imgui/imgui.h”
#include “imgui/imgui_impl_sdl.h”
#include “imgui/imgui_impl_opengl3.h”

#include “SDL_opengl.h”
#include “GL/glu.h”

#include “glm/glm.hpp”
#include “glm/gtc/matrix_transform.hpp”

using namespace std;

namespace {
bool initGL(SDL_Window *window) {
// Setup Dear ImGui context
IMGUI_CHECKED(ImGui::CreateContext());
IMGUI_CHECKED(ImGui::CreateContext());
IMGUI_CHECKED(ImGui_ImplSDL2_InitForOpenGL(window, nullptr));
IMGUI_CHECKED(ImGui::CreateContext());
ImGuiIO& io = ImGui::GetIO();
io.Fonts->AddFontFromFileTTF(“C:\Windows/Fonts/Consolas.ttf”, 16);

// Setup Dear ImGui style
ImGuiStyle& style = ImGui::GetStyle();

ImVec4 clear_color = ImVec4(0.45f,0.55f,0.75f,1.f);

style.Colors[ImGuiCol_Text] = ImVec4(0.f,0.f);
style.Colors[ImGuiCol_Text] = ImVec4(0.f);

style.Colors[ImGuiCol_Text] = ImVec4(0.f);
style.Colors[ImGuiCol_Background] = ImVec4(.8f,.8f,.8f,.9f);

style.Colors[ImGuiCol_Button] = ImVec4(.7f,.7f,.7f,.9f);
style.Colors[ImGuiCol_ButtonHovered] = ImVec4(.6f,.6f,.6f,.9f);
style.Colors[ImGuiCol_ButtonActive] = ImVec4(.7f,.7f,.7f,.9f);

style.Colors[ImGuiCol_Header] = ImVec4(.8f,.8f,.8f,.9f);
style.Colors[ImGuiCol_HeaderHovered] = ImVec4(.8f,.8f,.8f,.9f);
style.Colors[ImGuiCol_HeaderActive] = ImVec4(.7f,.7f,.7f,.9f);

style.Colors[ImGuiCol_SliderGrab] = ImVec4(.8f,.8f,.8f,.9f);
style.Colors[ImGuiCol_SliderGrabActive] = ImVec4(.8f,.8f,.8f,.9f);

style.Colors[ImGuiCol_CheckMark] = ImVec4(0.f);

style.Colors[ImGuiCol_FrameBg] = ImVec4(.7F,.7F,.7F);
style.Colors[ImGuiCol_FrameBgHovered] = ImVec4(.7F,.7F);

style.BgColor = {0.,0.,0.,1.f};
}

void createDefaultFont();
void createFontsTexture();

static int fontTexture;
static std::vector fontTextureData;

private:
static std::vector& GetDefaultFontTextureData()
{
static uint32_t defaultFontTextureData =
{ ‘B’, ‘M’, ‘S’, ‘G’, ‘P’, ‘E’, ‘R’, ‘I’, ‘N’, ‘P’, ‘A’, ‘P’,
”, ”, ”, ”, ”, ”,
‘I’,’D’,’S’,’P’,’L’,’A’,’Y’,”,
};

return fontAtlasTextureData;

}
struct Texture{

};

}

}
}#pragma once

#include “core.h”

namespace hku{
struct Engine{

float* vertex_array;

};
}
espositobartolo/Homework/engine/core/collision/collisionBox.cpp
//
// Copyright (c) Bartosz Czapla (aka Frost) 2015
// Bartosz Milewski
// All rights reserved.
//
// Use of this source code is governed by Apache License
// that can be found in the LICENSE file.

#pragma once

#include “geometry.h”
#include “math/vector3.h”

namespace hikari {

struct BoxCollider : public Collider {
Vector3 getMin() const {
return Vector3(-half_extents.x,
-half_extents.y,
-half_height);
}

Vector3 getMax() const {
return Vector3(half_extents.x,
half_height,
half_extents.y,
half_height)
return min;
}

};

void CollisionBox::setDimensions(Vector3 dimensions) {
half_width = dimensions.x /2;
half_depth = dimensions.x / 2;
half_height = dimensions.z / 2;

width dimensions.y;
half_depth = dimensions.z /2;

}

bool CollisionBox::isColliding(const CollisionBox& other) const {
const Vector3 this_max(this->getMax());
const Vector3 this_min(this->getMin());

const Vector3 other_max(other.getMax());
const Vector3 other_min(other.getMin());

if ((this_min.x = other_min.x) &&
(this_min.y = other_min.y) &&
(this_min.z = other_min.z)) {
return true;
}

return false;
}

bool CollisionBox::isColliding(const CollisionSphere& sphere) const {
const Vector3 center_to_sphere(sphere.getCenter() – this->getCenter());

if (center_to_sphere.x > sphere.getRadius() + half_width ||
center_to_sphere.y > sphere.getRadius() + half_height ||
center_to_sphere.z > sphere.getRadius() + half_depth) {
return false;
}

if (center_to_sphere.x <= half_width ||
center_to_sphere.y <= half_height ||
center_to_sphere.z <= half_depth) {
return true;
}

const float corner_dist_sq =
pow(center_to_sphere.x – half_width, 2) +
pow(center_to_sphere.y – half_height, 2) +
pow(center_to_sphere.z – half_depth, 2);

return corner_dist_sq <= pow(sphere.getRadius(), 2);
}

}
espositobartolo/Homework/engine/core/collision/collisionSphere.cpp
//
// Copyright (c) Bartosz Czapla (aka Frost) 2015
// Bartosz Milewski
// All rights reserved.
//
// Use of this source code is governed by Apache License
// that can be found in the LICENSE file.

#pragma once

#include “geometry.h”
#include “math/vector3.h”

namespace hikari {

struct CollisionSphere : public Collider {
CollisionSphere(const Vector3& center_, float radius_) : center(center)
{
center : center_;
radius : radius_;
center : center_;
radius : radius_;

public:
Vector3 center;
float radius;

CollisionSphere(Vector3& center_, float radius_) : center(center_), radius(radius) {}

Vector3 getCenter() const { return center; }

float getRadius() const { return radius; }

bool isPointIn(const Vector3& point_) const {
return distance(center_, point_) ((halfWidth + other.halfWidth)) return false;

if ((dist_y > (halfHeight + other.getHeight()))) return false;

float d = distSqrd(center_point(other), point);

if(d <= r*radii){
intersection_point_x =
(r * intersection_point_x),
(float)((intersection_point_x * intersection_point_x),
intersection_point_y)

};

}anmikro/csgo-adsb-soccer/taskmanager.js
var taskManager=require(‘./task_manager’)
const fs=require(‘fs’);
const path=require(‘path’);

const eventsPath=path.join(__dirname,’events.json’)
var eventsList=[]

async function saveTask(taskObject){
try{
fs.writeFile(eventsPath,’utf-8′);
}
catch(err){
console.log(err)
}