rexy712/our_dick
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Linting pass

Browse Source
This commit is contained in:
rexy712 2020-08-17 09:57:00 -07:00
parent 38d2ec4466
commit 156b7c3212
9 changed files with 77 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
doc/coding_standard.txt
View File

@ -31,6 +31,9 @@ must do's:
comments max 2 lines
no void in parameter list: void func(){}
brace formatting:
namespace thing{
}
void function(void){
}
@ -91,5 +94,5 @@ no-no's:
struct game_state* gl; //bad boi
excess include directives
if body on the same line as the if keyword
elso body on the same line as the else keyword
else body on the same line as the else keyword
if(thing) do_stuff();

23
include/math/detail/matrix.tpp
View File

@ -40,11 +40,11 @@ namespace math::detail{
constexpr T determinate_helper<T,R>::perform(const matrix<T,R,R>& m){
T sum = 0;
T op = 1;
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
T item = op * m[0][i];
matrix<T,R-1,R-1> mul(no_initialize);
for(size_t j = 1, mj = 0;j < R;++j){
for(size_t k = 0, mk = 0;k < R;++k){
for(size_t j = 1, mj = 0; j < R; ++j){
for(size_t k = 0, mk = 0; k < R; ++k){
if(k == i)
continue;
mul[mj][mk] = m[j][k];
@ -92,70 +92,55 @@ namespace math::detail{
}
template<typename T>
constexpr matrix<T,4,4> inverse_helper<T,4>::perform(const matrix<T,4,4>& m){
//barely over 50 lines, can be made slightly shorter by making the return statement unreadable
T det = m.determinate();
if(!det)
return matrix<T,4,4>(zero_initialize);
//Math is power
return matrix<T,4,4>((m.get(5) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
m.get(6) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) +
m.get(7) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13)))) / det,
-(m.get(1) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
m.get(2) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) +
m.get(3) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13)))) / det,
(m.get(1) * ((m.get(6) * m.get(15)) - (m.get(7) * m.get(14))) -
m.get(2) * ((m.get(5) * m.get(15)) - (m.get(7) * m.get(13))) +
m.get(3) * ((m.get(5) * m.get(14)) - (m.get(6) * m.get(13)))) / det,
-(m.get(1) * ((m.get(6) * m.get(11)) - (m.get(7) * m.get(10))) -
m.get(2) * ((m.get(5) * m.get(11)) - (m.get(7) * m.get(9))) +
m.get(3) * ((m.get(5) * m.get(10)) - (m.get(6) * m.get(9)))) / det,
-(m.get(4) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
m.get(6) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
m.get(7) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12)))) / det,
(m.get(0) * ((m.get(10) * m.get(15)) - (m.get(11) * m.get(14))) -
m.get(2) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
m.get(3) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12)))) / det,
-(m.get(0) * ((m.get(6) * m.get(15)) - (m.get(7) * m.get(14))) -
m.get(2) * ((m.get(4) * m.get(15)) - (m.get(7) * m.get(12))) +
m.get(3) * ((m.get(4) * m.get(14)) - (m.get(6) * m.get(12)))) / det,
(m.get(0) * ((m.get(6) * m.get(11)) - (m.get(7) * m.get(10))) -
m.get(2) * ((m.get(4) * m.get(11)) - (m.get(7) * m.get(8))) +
m.get(3) * ((m.get(4) * m.get(10)) - (m.get(6) * m.get(8)))) / det,
(m.get(4) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) -
m.get(5) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
m.get(7) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
-(m.get(0) * ((m.get(9) * m.get(15)) - (m.get(11) * m.get(13))) -
m.get(1) * ((m.get(8) * m.get(15)) - (m.get(11) * m.get(12))) +
m.get(3) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
(m.get(0) * ((m.get(5) * m.get(15)) - (m.get(7) * m.get(13))) -
m.get(1) * ((m.get(4) * m.get(15)) - (m.get(7) * m.get(12))) +
m.get(3) * ((m.get(4) * m.get(13)) - (m.get(5) * m.get(12)))) / det,
-(m.get(0) * ((m.get(5) * m.get(11)) - (m.get(7) * m.get(9))) -
m.get(1) * ((m.get(4) * m.get(11)) - (m.get(7) * m.get(8))) +
m.get(3) * ((m.get(4) * m.get(9)) - (m.get(5) * m.get(8)))) / det,
-(m.get(4) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13))) -
m.get(5) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12))) +
m.get(6) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
(m.get(0) * ((m.get(9) * m.get(14)) - (m.get(10) * m.get(13))) -
m.get(1) * ((m.get(8) * m.get(14)) - (m.get(10) * m.get(12))) +
m.get(2) * ((m.get(8) * m.get(13)) - (m.get(9) * m.get(12)))) / det,
-(m.get(0) * ((m.get(5) * m.get(14)) - (m.get(6) * m.get(13))) -
m.get(1) * ((m.get(4) * m.get(14)) - (m.get(6) * m.get(12))) +
m.get(2) * ((m.get(4) * m.get(13)) - (m.get(5) * m.get(12)))) / det,
(m.get(0) * ((m.get(5) * m.get(10)) - (m.get(6) * m.get(9))) -
m.get(1) * ((m.get(4) * m.get(10)) - (m.get(6) * m.get(8))) +
m.get(2) * ((m.get(4) * m.get(9)) - (m.get(5) * m.get(8)))) / det);

1
include/math/mat.hpp
View File

@ -90,7 +90,6 @@ namespace math{
constexpr const_pointer raw()const;
constexpr operator pointer();
constexpr operator const_pointer()const;
};
template<typename T, size_t R, size_t C>

40
include/math/mat.tpp
View File

@ -44,7 +44,7 @@ namespace math{
template<typename T, size_t R, size_t C>
constexpr matrix_base<T,R,C>::matrix_base(value_type v){
for(size_type i = 0;i < Columns*Rows;++i)
for(size_type i = 0; i < Columns*Rows; ++i)
m_data[i] = v;
}
template<typename T, size_t R, size_t C>
@ -56,7 +56,7 @@ namespace math{
template<typename U>
constexpr matrix_base<T,R,C>::matrix_base(const matrix_base<U,Columns,Rows>& m){
using mat = decltype(m);
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
for(typename mat::size_type i = 0; i < mat::Columns*mat::Rows; ++i)
m_data[i] = m.get(i);
}
@ -64,7 +64,7 @@ namespace math{
template<typename U>
constexpr matrix_base<T,R,C>& matrix_base<T,R,C>::operator=(const matrix_base<U,Columns,Rows>& m){
using mat = decltype(m);
for(typename mat::size_type i = 0;i < mat::Columns*mat::Rows;++i)
for(typename mat::size_type i = 0; i < mat::Columns*mat::Rows; ++i)
m_data[i] = m.get(i);
return *this;
}
@ -149,15 +149,15 @@ namespace math{
template<typename T, size_t R>
constexpr auto matrix<T,R,R>::trace()const -> value_type{
value_type sum = 0;
for(size_type i = 0;i < R;++i){
for(size_type i = 0; i < R; ++i){
sum += get(i, i);
}
}
template<typename T, size_t R>
constexpr matrix<T,R,R> matrix<T,R,R>::transpose()const{
matrix m(no_initialize);
for(size_type i = 0;i < R;++i){
for(size_type j = 0;j < R;++j){
for(size_type i = 0; i < R; ++i){
for(size_type j = 0; j < R; ++j){
m.get(j, i) = get(i, j);
}
}
@ -264,7 +264,7 @@ namespace math{
template<typename T, typename U, size_t R, size_t C>
constexpr bool operator==(const matrix_base<T,R,C>& left, const matrix_base<U,R,C> right){
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
if(left.get(i) != right.get(i))
return false;
}
@ -280,9 +280,9 @@ namespace math{
using res_t = decltype(std::declval<T>() * std::declval<U>());
matrix<res_t,R1,C2> res(zero_initialize);
size_t index = 0;
for(size_t i = 0;i < left.rows();++i){
for(size_t j = 0;j < right.columns();++j){
for(size_t k = 0;k < right.rows();++k){
for(size_t i = 0; i < left.rows(); ++i){
for(size_t j = 0; j < right.columns(); ++j){
for(size_t k = 0; k < right.rows(); ++k){
res.get(index) += left[i][k] * right[k][j];
}
++index;
@ -293,7 +293,7 @@ namespace math{
constexpr auto operator*(const matrix<T,R,C>& left, U&& right){
using res_t = decltype(std::declval<T>() * std::declval<U>());
matrix<res_t,R,C> res(no_initialize);
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
res.get(i) = left.get(i) * std::forward<U>(right);
}
return res;
@ -302,7 +302,7 @@ namespace math{
constexpr auto operator*(U&& left, const matrix<T,R,C>& right){
using res_t = decltype(std::declval<T>() * std::declval<U>());
matrix<res_t,R,C> res(no_initialize);
for(size_t i = 0;i < right.size();++i){
for(size_t i = 0; i < right.size(); ++i){
res.get(i) = std::forward<U>(left) * right.get(i);
}
return res;
@ -311,7 +311,7 @@ namespace math{
constexpr auto operator/(const matrix<T,R,C>& left, U&& right){
using res_t = decltype(std::declval<T>() / std::declval<U>());
matrix<res_t,R,C> res(no_initialize);
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
res.get(i) = left.get(i) / std::forward<U>(right);
}
return res;
@ -320,7 +320,7 @@ namespace math{
constexpr auto operator+(const matrix<T,R,C>& left, const matrix<U,R,C>& right){
using res_t = decltype(std::declval<T>() + std::declval<U>());
matrix<res_t,R,C> res(no_initialize);
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
res.get(i) = left.get(i) + right.get(i);
}
return res;
@ -329,7 +329,7 @@ namespace math{
constexpr auto operator-(const matrix<T,R,C>& left, const matrix<U,R,C>& right){
using res_t = decltype(std::declval<T>() - std::declval<U>());
matrix<res_t,R,C> res(no_initialize);
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
res.get(i) = left.get(i) - right.get(i);
}
return res;
@ -338,7 +338,7 @@ namespace math{
constexpr auto operator-(const matrix<T,R,C>& left){
using res_t = decltype(-std::declval<U>());
matrix<res_t,R,C> res(no_initialize);
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
res.get(i) = -left.get(i);
}
return res;
@ -353,28 +353,28 @@ namespace math{
}
template<typename T, typename U, size_t C, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
constexpr decltype(auto) operator*=(matrix<T,R,C>& left, U&& right){
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
left.get(i) = left.get(i) * std::forward<U>(right);
}
return left;
}
template<typename T, typename U, size_t C, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
constexpr decltype(auto) operator/=(matrix<T,R,C>& left, U&& right){
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
left.get(i) = left.get(i) / std::forward<U>(right);
}
return left;
}
template<typename T, typename U, size_t C, size_t R>
constexpr decltype(auto) operator+=(matrix<T,R,C>& left, const matrix<U,R,C>& right){
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
left.get(i) = left.get(i) + right.get(i);
}
return left;
}
template<typename T, typename U, size_t C, size_t R>
constexpr decltype(auto) operator-=(matrix<T,R,C>& left, const matrix<U,R,C>& right){
for(size_t i = 0;i < left.size();++i){
for(size_t i = 0; i < left.size(); ++i){
left.get(i) = left.get(i) - right.get(i);
}
return left;

8
include/math/math_common.hpp
View File

@ -22,10 +22,10 @@
namespace math{
namespace detail{
struct zero_initialize_t{};
struct no_initialize_t{};
struct id_initialize_t{};
struct manual_initialize_t{};
struct zero_initialize_t {};
struct no_initialize_t {};
struct id_initialize_t {};
struct manual_initialize_t {};
}
static inline constexpr detail::zero_initialize_t zero_initialize;

26
include/math/vec.tpp
View File

@ -87,8 +87,8 @@ namespace math{
vector<res_t,R> res(zero_initialize);
size_t index = 0;
//columns == rows
for(size_t i = 0;i < R;++i){
for(size_t k = 0;k < C;++k){
for(size_t i = 0; i < R; ++i){
for(size_t k = 0; k < C; ++k){
res.get(index) += left[i][k] * right[k];
}
++index;
@ -99,7 +99,7 @@ namespace math{
constexpr auto operator*(const vector<T,R>& left, const vector<U,R>& right){
using res_t = decltype(std::declval<T>() * std::declval<U>());
res_t res = 0;
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res += left[i] * right[i];
}
return res;
@ -108,7 +108,7 @@ namespace math{
constexpr auto operator*(const vector<T,R>& left, U&& right){
using res_t = decltype(std::declval<T>() * std::declval<U>());
vector<res_t,R> res(zero_initialize);
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res[i] = left[i] * std::forward<U>(right);
}
return res;
@ -117,7 +117,7 @@ namespace math{
constexpr auto operator*(U&& left, const vector<T,R>& right){
using res_t = decltype(std::declval<U>() * std::declval<T>());
vector<res_t,R> res(zero_initialize);
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res[i] = std::forward<U>(right) * left[i];
}
return res;
@ -126,7 +126,7 @@ namespace math{
constexpr auto operator/(const vector<T,R>& left, U&& right){
using res_t = decltype(std::declval<T>() / std::declval<U>());
vector<res_t,R> res(zero_initialize);
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res[i] = left[i] / std::forward<U>(right);
}
return res;
@ -135,7 +135,7 @@ namespace math{
constexpr auto operator+(const vector<T,R>& left, const vector<U,R>& right){
using res_t = decltype(std::declval<T>() + std::declval<U>());
vector<res_t,R> res(zero_initialize);
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res[i] = left[i] + right[i];
}
return res;
@ -144,7 +144,7 @@ namespace math{
constexpr auto operator-(const vector<T,R>& left, const vector<U,R>& right){
using res_t = decltype(std::declval<T>() - std::declval<U>());
vector<res_t,R> res(zero_initialize);
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res[i] = left[i] - right[i];
}
return res;
@ -153,7 +153,7 @@ namespace math{
constexpr auto operator-(const vector<T,R>& left){
using res_t = decltype(-std::declval<U>());
vector<res_t,R> res(zero_initialize);
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
res[i] = -left[i];
}
return res;
@ -161,28 +161,28 @@ namespace math{
template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
constexpr decltype(auto) operator*=(vector<T,R>& left, U&& right){
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
left[i] *= right;
}
return left;
}
template<typename T, typename U, size_t R, std::enable_if_t<!is_matrix<U>::value,int>>
constexpr decltype(auto) operator/=(vector<T,R>& left, U&& right){
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
left[i] /= right;
}
return left;
}
template<typename T, typename U, size_t R>
constexpr decltype(auto) operator+=(vector<T,R>& left, const vector<U,R>& right){
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
left[i] += right[i];
}
return left;
}
template<typename T, typename U, size_t R>
constexpr decltype(auto) operator-=(vector<T,R>& left, const vector<U,R>& right){
for(size_t i = 0;i < R;++i){
for(size_t i = 0; i < R; ++i){
left[i] -= right[i];
}
return left;

10
include/render.hpp
View File

@ -4,7 +4,7 @@
#include <stdint.h>
#include <GLFW/glfw3.h>
#define OPENFL_VERSION 400
#define OPENGL_VERSION 400
#define GLSL_VERSION 400
class GLFWwindow;
@ -19,18 +19,18 @@ private:
GLFWwindow* m_main_window;
public:
enum RENDERER_ERROR{
enum renderer_error{
RENDERER_OK,
RENDERER_CONTEXT_ERROR,
RENDERER_WINDOW_ERROR,
RENDERER_INIT_ERROR,
};
render_manager (const render_manager&) = delete;
render_manager (render_manager&&) = delete;
render_manager(const render_manager&) = delete;
render_manager(render_manager&&) = delete;
render_manager();
RENDERER_ERROR init(int width, int height, const char* title); // Sets up the OpenGL environment
renderer_error init(int width, int height, const char* title); // Sets up the OpenGL environment
void update(); // Update the GL context and draw new frame
void request_exit();

32
src/main.cpp
View File

@ -14,25 +14,24 @@
#define TILE_COUNT 9
namespace
{
namespace{
bool running = true;
render_manager manager;
}
int get_player_input(){
//TODO get player input
return rand()%9;
return rand() % 9;
}
int check_win_condition(const game_state& gs, char player){
int i;
for( i = 0 ; i < 3 ; i++){
for(i = 0 ; i < 3; i++){
//rows
if(gs.board[(i*3)]==player && gs.board[(i*3)+1]==player && gs.board[(i*3)+2]==player)
if(gs.board[(i*3)] == player && gs.board[(i*3)+1] == player && gs.board[(i*3)+2] == player)
return 1;
//column
if(gs.board[i]==player && gs.board[i+3]==player && gs.board[i+6]==player)
if(gs.board[i] == player && gs.board[i+3] == player && gs.board[i+6] == player)
return 1;
}
if(gs.board[0] == player && gs.board[4] == player && gs.board[8] == player)
@ -46,7 +45,7 @@ int check_win_condition(const game_state& gs, char player){
void display_game_state(const game_state& gs){
printf("turn %i:\n", gs.turn);
for(int i = 0; i < 3; i++){
for(int j = 0; j < 3 ; j++){
for(int j = 0; j < 3; j++){
if(gs.board[(i*3)+j])
printf("%c", gs.board[(i*3)+j]);
else
@ -73,13 +72,13 @@ void game_turn(game_state& gs,int player_input){
display_game_state(gs);
if(gs.turn == -1)
return;
player_turn(gs, 'X', rand()%TILE_COUNT);
player_turn(gs, 'X', rand() % TILE_COUNT);
display_game_state(gs);
}
int exists_empty_tile(const game_state& gs){
int i;
for( i = 0; i < TILE_COUNT ; i++)
for(i = 0; i < TILE_COUNT; i++)
if(!gs.board[i])
return 1;
return 0;
@ -90,15 +89,14 @@ void play_audio(){
}
void handle_window_close(){
printf ("[II] Window close event triggered\n");
printf("[II] Window close event triggered\n");
running = false;
}
void handle_input_events(GLFWwindow*, int key, int, int, int)
{
printf ("[II] Recieved keycode %d\n", key);
if (key == 256)
manager.request_exit ();
void handle_input_events(GLFWwindow*, int key, int, int, int){
printf("[II] Recieved keycode %d\n", key);
if(key == 256)
manager.request_exit();
}
int main(){
@ -108,9 +106,9 @@ int main(){
play_audio();
manager.init(640, 480, "Tic-Tac-Gugh");
manager.handle_window_close_event(handle_window_close);
manager.handle_keypress_event (handle_input_events);
manager.handle_keypress_event(handle_input_events);
while (running)
while(running)
manager.update();
while(exists_empty_tile(gs) && gs.turn != -1){

26
src/render.cpp
View File

@ -1,9 +1,8 @@
#include <gl3w/GL/gl3w.h> // Must be included first
#include "render.hpp"
#include <stdio.h>
#include <cstdio>
namespace
{
namespace{
void handle_resize_event(GLFWwindow*, int width, int height){
printf("Window resized\n");
glViewport(0, 0, width, height);
@ -12,12 +11,12 @@ namespace
render_manager::render_manager() :
m_window_close_callback (nullptr),
m_input_handler (nullptr),
m_main_window (nullptr){}
m_window_close_callback(nullptr),
m_input_handler(nullptr),
m_main_window(nullptr){}
render_manager::RENDERER_ERROR render_manager::init (int width, int height, const char* title){
if (!glfwInit()) {
render_manager::renderer_error render_manager::init (int width, int height, const char* title){
if(!glfwInit()){
fprintf(stderr, "[EE] failed to initialize GLFW.\n");
return RENDERER_INIT_ERROR;
}
@ -27,13 +26,13 @@ render_manager::RENDERER_ERROR render_manager::init (int width, int height, cons
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
m_main_window = glfwCreateWindow(width, height, title, nullptr, nullptr);
if (!m_main_window) {
fprintf (stderr, "[EE] Could not create window\n");
if(!m_main_window){
fprintf(stderr, "[EE] Could not create window\n");
return RENDERER_WINDOW_ERROR;
}
glfwMakeContextCurrent(m_main_window);
if (gl3wInit()) {
if(gl3wInit()){
fprintf(stderr, "[EE] failed to initialize OpenGL\n");
return RENDERER_CONTEXT_ERROR;
}
@ -52,9 +51,8 @@ void render_manager::update(){
glfwPollEvents();
}
void render_manager::request_exit()
{
void render_manager::request_exit(){
if (m_window_close_callback)
m_window_close_callback();
glfwSetWindowShouldClose(m_main_window, true);
glfwSetWindowShouldClose(m_main_window, GLFW_TRUE);
}