Merge branch 'master' into networking
This commit is contained in:
commit
2be3549b49
26 changed files with 222 additions and 245 deletions
|
@ -7,6 +7,7 @@ function(setup_target NAME)
|
|||
set_property(TARGET ${NAME} PROPERTY CXX_STANDARD 14)
|
||||
set_property(TARGET ${NAME} PROPERTY CXX_STANDARD_REQUIRED ON)
|
||||
target_compile_options(${NAME} PRIVATE -Wall -Wextra)
|
||||
target_compile_options(${NAME} PRIVATE -fdiagnostics-color=always)
|
||||
target_compile_options(${NAME} PRIVATE $<$<CONFIG:DEBUG>:-ggdb -O2>)
|
||||
target_compile_options(${NAME} PRIVATE $<$<CONFIG:RELEASE>:-O3 -NDEBUG>)
|
||||
endfunction(setup_target)
|
||||
|
|
|
@ -15,6 +15,8 @@ set(GAME_SRC
|
|||
util.cpp
|
||||
game.cpp
|
||||
state/object.cpp
|
||||
state/explosion.cpp
|
||||
state/trace.cpp
|
||||
state/state.cpp
|
||||
state/player.cpp
|
||||
state/planet.cpp
|
||||
|
@ -24,17 +26,15 @@ set(GAME_SRC
|
|||
)
|
||||
|
||||
set(GAME_HEADERS
|
||||
opengl.h
|
||||
glclasses.h
|
||||
vector.h
|
||||
config.h
|
||||
simulation.h
|
||||
renderer.h
|
||||
opengl.hpp
|
||||
glclasses.hpp
|
||||
renderer.hpp
|
||||
)
|
||||
|
||||
include_directories(${CMAKE_CURRENT_BINARY_DIR})
|
||||
include_directories(${CMAKE_CURRENT_SOURCE_DIR})
|
||||
include_directories(${OPENGL_INCLUDE_DIR})
|
||||
include_directories(${CMAKE_SOURCE_DIR}/libs/glm/)
|
||||
|
||||
add_executable(game ${GAME_SRC} ${GAME_HEADERS})
|
||||
setup_target(game)
|
||||
|
|
|
@ -1,2 +0,0 @@
|
|||
#include "config.h"
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
struct Config {
|
||||
int maxPlayers;
|
||||
int numPlanets;
|
||||
int maxSegments;
|
||||
int segmentSteps;
|
||||
int numShots;
|
||||
int fastmode;
|
||||
int fullscreen;
|
||||
int timeout;
|
||||
int margintop;
|
||||
int marginleft;
|
||||
int marginright;
|
||||
int marginbottom;
|
||||
double playerSize;
|
||||
int energy;
|
||||
int realtime;
|
||||
int debug;
|
||||
double battlefieldW;
|
||||
double battlefieldH;
|
||||
int throttle;
|
||||
char* ip;
|
||||
char* message;
|
||||
int pot;
|
||||
int area;
|
||||
};
|
||||
|
||||
class ConfigParser{
|
||||
private:
|
||||
protected:
|
||||
public:
|
||||
};
|
|
@ -32,7 +32,7 @@ bool Game::cycle(float dt)
|
|||
acc -= spawnInterval;
|
||||
|
||||
float a = 2.0 * M_PI * util::randf_0_1();
|
||||
float speed = 0.002;
|
||||
float speed = 0.005;
|
||||
m_state->players[0]->addCommand(new game::ShootCommand(a, speed));
|
||||
}
|
||||
|
||||
|
|
|
@ -1,10 +1,11 @@
|
|||
#pragma once
|
||||
|
||||
#include "opengl.h"
|
||||
#include "renderer.h"
|
||||
#include "opengl.hpp"
|
||||
#include "renderer.hpp"
|
||||
|
||||
#include "game.hpp"
|
||||
|
||||
#include "state/trace.hpp"
|
||||
#include "state/object.hpp"
|
||||
#include "state/missile.hpp"
|
||||
#include "state/player.hpp"
|
||||
|
@ -41,6 +42,10 @@ protected:
|
|||
drawPlanet(planet->position, planet->radius);
|
||||
}
|
||||
|
||||
for (const game::Trace *trace : m_game.state()->traces) {
|
||||
drawTrace(trace);
|
||||
}
|
||||
|
||||
for (const game::Ship *ship : m_game.state()->ships) {
|
||||
drawShip(ship->position);
|
||||
}
|
||||
|
@ -73,9 +78,18 @@ protected:
|
|||
}
|
||||
|
||||
void drawMissile(const glm::vec2 &pos)
|
||||
|
||||
{
|
||||
glm::vec3 color = glm::vec3(1.0, 1.0, 0.3);
|
||||
m_renderer.drawCircle(pos.x, pos.y, 0.005, color.x, color.y, color.z, 5);
|
||||
m_renderer.drawCircle(pos.x, pos.y, 0.01, color.x, color.y, color.z, 6);
|
||||
}
|
||||
|
||||
void drawTrace(const game::Trace *trace)
|
||||
{
|
||||
for (const game::Trace::TracePoint &p : trace->points) {
|
||||
glm::vec3 color = glm::vec3(0.1, 0.3, 1.0) / (1.0f + 500.0f*p.speed);
|
||||
m_renderer.drawCircle(p.position.x, p.position.y, 0.005, color.x, color.y, color.z, 3);
|
||||
}
|
||||
}
|
||||
|
||||
public:
|
|
@ -1,4 +1,4 @@
|
|||
#include "glclasses.h"
|
||||
#include "glclasses.hpp"
|
||||
|
||||
endofthejedi::VAO::VAO() { glGenVertexArrays(1, &m_name); }
|
||||
|
||||
|
|
|
@ -1,11 +1,12 @@
|
|||
#include "opengl.h"
|
||||
#include "opengl.hpp"
|
||||
|
||||
#include <iostream>
|
||||
#include <getopt.h>
|
||||
|
||||
//#include "triangle_window.h"
|
||||
#include "game_window.h"
|
||||
#include "game_window.hpp"
|
||||
#include "options.hpp"
|
||||
|
||||
uint64_t optionsFlags;
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
#include "opengl.h"
|
||||
#include "opengl.hpp"
|
||||
|
||||
#include <iostream>
|
||||
#include <sys/time.h>
|
||||
|
@ -130,7 +130,7 @@ void endofthejedi::GLWindow::loop() {
|
|||
prev = current;
|
||||
if(delta > 0.0) {
|
||||
m_fps = (1000000000.0/delta);
|
||||
std::cout << m_fps << "\n";
|
||||
//std::cout << m_fps << "\n";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -10,7 +10,7 @@
|
|||
|
||||
#define SET_FLAG(x,y) optionsFlags&=(~((1)<<x));optionsFlags|=((y&1)<<x)
|
||||
#define ISSET_FLAG(x) (optionsFlags&((1)<<x))
|
||||
uint64_t optionsFlags;
|
||||
extern uint64_t optionsFlags;
|
||||
|
||||
/*
|
||||
* usage:
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
#include "renderer.h"
|
||||
#include "renderer.hpp"
|
||||
|
||||
endofthejedi::Renderer::Renderer() {
|
||||
|
||||
|
@ -6,13 +6,13 @@ endofthejedi::Renderer::Renderer() {
|
|||
|
||||
endofthejedi::Renderer::~Renderer() {}
|
||||
|
||||
void endofthejedi::Renderer::drawCircle(float x, float y, float radius, float r,
|
||||
float g, float b, int numSides) {
|
||||
glBegin(GL_TRIANGLE_FAN);
|
||||
glVertex2f(x, y); // center of circle
|
||||
for (int i = 0; i <= numSides; i++) {
|
||||
void endofthejedi::Renderer::drawCircle(float x, float y, float radius, float r, float g, float b, int numSides)
|
||||
{
|
||||
glBegin(GL_TRIANGLE_FAN);
|
||||
glColor3f(r,g,b);
|
||||
glVertex2f(x + (radius * cos(i * 2 * M_PI / numSides)), y + (radius * sin(i * 2 * M_PI / numSides)));
|
||||
}
|
||||
glEnd();
|
||||
glVertex2f(x, y); // center of circle
|
||||
for (int i = 0; i <= numSides; i++) {
|
||||
glVertex2f(x + (radius * cos(i * 2 * M_PI / numSides)), y + (radius * sin(i * 2 * M_PI / numSides)));
|
||||
}
|
||||
glEnd();
|
||||
}
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
#include <epoxy/gl.h>
|
||||
#include <epoxy/glx.h>
|
||||
|
||||
#include "glclasses.h"
|
||||
#include "glclasses.hpp"
|
||||
|
||||
namespace endofthejedi {
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
#include "simulation.h"
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include "vector.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
Vec2d position;
|
||||
Vec2d speed;
|
||||
int live;
|
||||
int leftSource;
|
||||
int stale;
|
||||
} SimMissile;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
Vec2d* dot;
|
||||
SimMissile missile;
|
||||
int length;
|
||||
int player;
|
||||
double angle;
|
||||
double velocity;
|
||||
} SimShot;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
SimShot* shot;
|
||||
int currentShot;
|
||||
Vec2d position;
|
||||
double angle;
|
||||
double velocity;
|
||||
double energy;
|
||||
double oldVelocity;
|
||||
int watch;
|
||||
int deaths;
|
||||
int kills;
|
||||
int shots;
|
||||
int active;
|
||||
int valid;
|
||||
int didShoot;
|
||||
int timeout;
|
||||
int timeoutcnt;
|
||||
char name[16];
|
||||
} SimPlayer;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
Vec2d position;
|
||||
double radius;
|
||||
double mass;
|
||||
} SimPlanet;
|
|
@ -1,14 +1,24 @@
|
|||
#include "commands.hpp"
|
||||
|
||||
#include "trace.hpp"
|
||||
|
||||
namespace game {
|
||||
void ShootCommand::apply(Player *player, State *state) const
|
||||
{
|
||||
(void) state;
|
||||
// TODO spawn missile if alive and enough energy
|
||||
//std::cout<<"apply command " << name() << std::endl;
|
||||
|
||||
// TODO: idea
|
||||
// shoot multiple rockets at once or from different positions after
|
||||
// level up / upgrade ...
|
||||
Missile *missile = new Missile(player, player->ship->position, m_angle, m_speed);
|
||||
|
||||
Trace *trace = new Trace(missile);
|
||||
missile->trace = trace;
|
||||
|
||||
player->energy -= m_speed;
|
||||
player->missiles.push_back(new Missile(player->id, player->ship->position, m_angle, m_speed));
|
||||
player->missiles.push_back(missile);
|
||||
|
||||
state->addTrace(trace);
|
||||
}
|
||||
|
||||
bool ShootCommand::allowed(const Player *player, const State *state) const
|
||||
|
|
|
@ -1,17 +1,32 @@
|
|||
#pragma once
|
||||
|
||||
#if 0
|
||||
class Explosion {
|
||||
public:
|
||||
enum class Kind {
|
||||
Normal,
|
||||
MissileWithShip
|
||||
#include <glm/vec2.hpp>
|
||||
|
||||
namespace game {
|
||||
/**
|
||||
* Explosion: just an effect which looks good.
|
||||
*/
|
||||
class Explosion {
|
||||
public:
|
||||
enum class Kind {
|
||||
MissileExplodesInSpace, // missile explode in free space
|
||||
MissileAgainstPlanet, // explosion of missile when it hits a planet
|
||||
MissileAgainstShip // bigger explosion: missile hits a ship which explodes with it
|
||||
};
|
||||
|
||||
Explosion(const glm::vec2 &pos, Kind kind, float maxAge=1.0)
|
||||
: position(pos), kind(kind), age(0.0), maxAge(maxAge)
|
||||
{
|
||||
}
|
||||
|
||||
const Kind kind; // kind of the explosion
|
||||
const glm::vec2 position; // position where it starts
|
||||
float age; // age (in seconsd) of the explosion
|
||||
|
||||
// age (in seconds) when the explosion is not visible
|
||||
// anymore and will disappear afterwards
|
||||
const float maxAge;
|
||||
};
|
||||
}
|
||||
|
||||
glm::vec2 position;
|
||||
|
||||
Explosion(Kind kind);
|
||||
|
||||
public:
|
||||
};
|
||||
#endif
|
||||
|
|
|
@ -4,12 +4,15 @@
|
|||
|
||||
#include "state.hpp"
|
||||
#include "player.hpp"
|
||||
#include "ship.hpp"
|
||||
#include "planet.hpp"
|
||||
#include "trace.hpp"
|
||||
|
||||
#include <glm/gtx/norm.hpp>
|
||||
|
||||
namespace game {
|
||||
Missile::Missile(int playerId, const glm::vec2 &pos, float angle, float speed)
|
||||
: playerId(playerId)
|
||||
Missile::Missile(Player *player, const glm::vec2 &pos, float angle, float speed)
|
||||
: player(player)
|
||||
, position(pos)
|
||||
{
|
||||
velocity = speed * glm::vec2(std::sin(angle), std::cos(angle));
|
||||
|
@ -28,13 +31,13 @@ namespace game {
|
|||
glm::vec2 gravityForce = glm::vec2(0.0, 0.0);
|
||||
|
||||
for (const Player *other : state->players) {
|
||||
if (other->ship != nullptr && other->id != playerId) {
|
||||
if (other->ship != nullptr && other != player) {
|
||||
glm::vec2 diff = other->ship->position - position;
|
||||
float dist = glm::length(diff);
|
||||
if (dist <= other->ship->radius) {
|
||||
// TODO: collect all hits and return the first one only
|
||||
// TODO: find exact hit position!
|
||||
return Missile::Event(position, playerId, other->id);
|
||||
return Missile::Event(position, player->id, other->id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3,13 +3,13 @@
|
|||
#include <glm/vec2.hpp>
|
||||
#include <glm/vec3.hpp>
|
||||
|
||||
#include "state.hpp"
|
||||
|
||||
#include "ship.hpp"
|
||||
#include "planet.hpp"
|
||||
|
||||
namespace game {
|
||||
class State;
|
||||
class Ship;
|
||||
class Planet;
|
||||
class Player;
|
||||
class State;
|
||||
class Trace;
|
||||
|
||||
// missile belongs to a player and optionally fills a trace behind it.
|
||||
// trace then belongs to the player.
|
||||
|
@ -50,19 +50,17 @@ namespace game {
|
|||
int playerIdVictim;
|
||||
};
|
||||
|
||||
// XXX
|
||||
int playerId; // owner won't be hit by own missiles
|
||||
glm::vec2 position;
|
||||
glm::vec2 velocity;
|
||||
//Trace *trace;
|
||||
|
||||
Missile(int playerId, const glm::vec2 &pos, float angle, float speed);
|
||||
|
||||
Missile(Player *player, const glm::vec2 &pos, float angle, float speed);
|
||||
~Missile();
|
||||
|
||||
// try to advance. if something will be hit, return the first hit in
|
||||
// time.
|
||||
Missile::Event advance(const game::State *state, float dt);
|
||||
|
||||
Player *player; // owner won't be hit by own missiles
|
||||
glm::vec2 position;
|
||||
glm::vec2 velocity;
|
||||
Trace *trace;
|
||||
};
|
||||
}
|
||||
|
||||
|
|
|
@ -12,6 +12,7 @@
|
|||
#include "planet.hpp"
|
||||
#include "ship.hpp"
|
||||
#include "commands.hpp"
|
||||
#include "trace.hpp"
|
||||
|
||||
#include "util.hpp"
|
||||
|
||||
|
@ -161,6 +162,11 @@ namespace game {
|
|||
//std::cout<<"missile: " << (long unsigned int) missile << std::endl;
|
||||
const Missile::Event evt = missile->advance(this, dt);
|
||||
|
||||
missile->trace->addPointFromMissile();
|
||||
|
||||
// TODO:
|
||||
// spawn just if the path differs
|
||||
|
||||
if (evt.hit == Missile::HitObject::Nothing) {
|
||||
i++;
|
||||
|
||||
|
@ -259,4 +265,9 @@ namespace game {
|
|||
player->addCommand(cmd);
|
||||
}
|
||||
}
|
||||
|
||||
void State::addTrace(Trace *trace)
|
||||
{
|
||||
traces.push_back(trace);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -8,25 +8,34 @@
|
|||
#include <glm/vec2.hpp>
|
||||
|
||||
namespace game {
|
||||
// forward declarations
|
||||
class Command;
|
||||
class Missile;
|
||||
class Player;
|
||||
class Planet;
|
||||
class Ship;
|
||||
|
||||
// trace of a missile. exists without a missile at player.
|
||||
//class Trace {
|
||||
//public:
|
||||
// std::vector<glm::vec2> points;
|
||||
//};
|
||||
class Trace;
|
||||
|
||||
class State {
|
||||
public:
|
||||
/*************************************************************************/
|
||||
/* State management */
|
||||
/*************************************************************************/
|
||||
|
||||
// called to setup the state (randomize planets, kill
|
||||
// traces/missiles/ships etc.)
|
||||
void init();
|
||||
|
||||
// main method to advance the simulation by the given timestamp in
|
||||
// seconds.
|
||||
void advance(float dt);
|
||||
|
||||
// the (network) layer calling these three functions should keep id's
|
||||
// unique and give one (network) input an id.
|
||||
/*************************************************************************/
|
||||
/* Network / Input */
|
||||
/*************************************************************************/
|
||||
|
||||
// The upper layer (network/renderer) calling these three functions
|
||||
// should keep id's unique and give one (network) input an id.
|
||||
void addPlayer(int playerId);
|
||||
void playerLeft(int playerId);
|
||||
void commandForPlayer(int playerId, Command *cmd);
|
||||
|
@ -34,14 +43,34 @@ namespace game {
|
|||
// lookup. return nullptr on invalid playerId
|
||||
Player *playerForId(int playerId);
|
||||
|
||||
/*************************************************************************/
|
||||
/* Mixed stuff */
|
||||
|
||||
// distance after which missiles get lost in space (and explode)
|
||||
float maxMissileDistance() const { return m_maxMissileDistance; }
|
||||
|
||||
// each ship has the same radius
|
||||
float shipRadius() const { return m_shipRadius; }
|
||||
|
||||
// add a trace to the list of traces.
|
||||
void addTrace(Trace *trace);
|
||||
|
||||
/*************************************************************************/
|
||||
/* Rendering */
|
||||
/*************************************************************************/
|
||||
|
||||
// Game items which should be rendered are here:
|
||||
// (access missiles by iterating over player's missiles attribute)
|
||||
std::vector<Planet*> planets;
|
||||
std::vector<Ship*> ships;
|
||||
std::vector<Player*> players;
|
||||
std::vector<Trace*> traces;
|
||||
|
||||
private:
|
||||
/*************************************************************************/
|
||||
/* Internal */
|
||||
/*************************************************************************/
|
||||
|
||||
void playerKillsPlayer(Player *killer, Player *victim);
|
||||
|
||||
void advancePlayerShipSpawns(float dt);
|
||||
|
|
27
game/state/trace.cpp
Normal file
27
game/state/trace.cpp
Normal file
|
@ -0,0 +1,27 @@
|
|||
#include "trace.hpp"
|
||||
|
||||
#include <glm/gtx/norm.hpp>
|
||||
|
||||
#include "missile.hpp"
|
||||
|
||||
namespace game {
|
||||
Trace::TracePoint::TracePoint(const Missile *missile)
|
||||
: position(missile->position)
|
||||
, speed(glm::length(missile->velocity))
|
||||
{
|
||||
}
|
||||
|
||||
Trace::Trace(const Missile *missile) : missile(missile), fidelityCounter(0)
|
||||
{
|
||||
points.push_back(TracePoint(missile));
|
||||
}
|
||||
|
||||
void Trace::addPointFromMissile(bool forceAdd)
|
||||
{
|
||||
fidelityCounter++;
|
||||
if (forceAdd || fidelityCounter >= 10) {
|
||||
fidelityCounter = 0;
|
||||
points.push_back(TracePoint(missile));
|
||||
}
|
||||
}
|
||||
}
|
45
game/state/trace.hpp
Normal file
45
game/state/trace.hpp
Normal file
|
@ -0,0 +1,45 @@
|
|||
#pragma once
|
||||
|
||||
#include <glm/vec2.hpp>
|
||||
#include <vector>
|
||||
|
||||
namespace game {
|
||||
class Missile;
|
||||
|
||||
/*
|
||||
* Trace of a missile through the space.
|
||||
* Useful for rendering sth. like a smoke trail to follow the rocket.
|
||||
*/
|
||||
class Trace {
|
||||
public:
|
||||
Trace(const Missile *missile);
|
||||
|
||||
// Add the current position of the missile as a new point on the
|
||||
// trace.
|
||||
// Parameters:
|
||||
// forceAdd: set to true to add this point (good for the endpoint of
|
||||
// the missile) in case the fidelityCounter would skip the current position.
|
||||
void addPointFromMissile(bool forceAdd=false);
|
||||
|
||||
// TODO: add extendLastPointToPosition() method for saving points /
|
||||
// optimization later on
|
||||
|
||||
/*
|
||||
* Trace point data to be used when rendering.
|
||||
*/
|
||||
struct TracePoint {
|
||||
TracePoint(const Missile *missile);
|
||||
|
||||
glm::vec2 position;
|
||||
float speed;
|
||||
};
|
||||
|
||||
std::vector<TracePoint> points;
|
||||
const Missile *missile; // missile which creates this path.
|
||||
|
||||
// counter which is incremented each time addPointFromMissile() is called.
|
||||
// when reaching a certain value the point is saved for
|
||||
// optimization.
|
||||
int fidelityCounter;
|
||||
};
|
||||
}
|
|
@ -1,6 +1,6 @@
|
|||
#pragma once
|
||||
|
||||
#include "opengl.h"
|
||||
#include "opengl.hpp"
|
||||
|
||||
class TriangleWindow : public endofthejedi::GLWindow {
|
||||
private:
|
|
@ -1,90 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include <math.h>
|
||||
|
||||
struct Vec2d
|
||||
{
|
||||
double x;
|
||||
double y;
|
||||
|
||||
double length() {
|
||||
return sqrt(x*x + y*y);
|
||||
}
|
||||
double distance(Vec2d other) {
|
||||
Vec2d tmp = (*this - other);
|
||||
return tmp.length();
|
||||
}
|
||||
|
||||
Vec2d & operator+=(const Vec2d& rhs) {
|
||||
x+=rhs.x;
|
||||
y+=rhs.y;
|
||||
return *this;
|
||||
}
|
||||
Vec2d & operator-=(const Vec2d& rhs) {
|
||||
x-=rhs.x;
|
||||
y-=rhs.y;
|
||||
return *this;
|
||||
}
|
||||
Vec2d & operator*=(const double& rhs) {
|
||||
x*=rhs;
|
||||
y*=rhs;
|
||||
return *this;
|
||||
}
|
||||
Vec2d & operator/=(const double& rhs) {
|
||||
x/=rhs;
|
||||
y/=rhs;
|
||||
return *this;
|
||||
}
|
||||
const Vec2d operator+(const Vec2d& rhs) const {
|
||||
Vec2d result = *this;
|
||||
result += rhs;
|
||||
return result;
|
||||
}
|
||||
const Vec2d operator-(const Vec2d& rhs) const {
|
||||
Vec2d result = *this;
|
||||
result -= rhs;
|
||||
return result;
|
||||
}
|
||||
const double operator*(const Vec2d& rhs) const {
|
||||
return (this->x * rhs.x) + (this->y * rhs.y);
|
||||
}
|
||||
const Vec2d operator*(const double& rhs) const {
|
||||
Vec2d result = *this;
|
||||
result *= rhs;
|
||||
return result;
|
||||
}
|
||||
const Vec2d operator/(const double& rhs) const {
|
||||
Vec2d result = *this;
|
||||
result /= rhs;
|
||||
return result;
|
||||
}
|
||||
};
|
||||
/*
|
||||
struct Mat4d {
|
||||
std::array<double, 16> data;
|
||||
|
||||
const Mat4d operator*(const Mat4d& rhs) const {
|
||||
Mat4d result;
|
||||
result[0] = result[0]*rhs[0] + result[1]*result[5] + result[2]*result[9] + result[3]*result[13];
|
||||
result[1] = result[0]*rhs[1] + result[1]*result[6] + result[2]*result[10] + result[3]*result[14];
|
||||
result[2] = result[0]*rhs[2] + result[1]*result[7] + result[2]*result[11] + result[3]*result[15];
|
||||
result[3] = result[0]*rhs[3] + result[1]*result[8] + result[2]*result[12] + result[3]*result[16];
|
||||
|
||||
result[4] = result[4]*rhs[0] + result[5]*result[5] + result[6]*result[9] + result[7]*result[13];
|
||||
result[5] = result[4]*rhs[1] + result[5]*result[6] + result[6]*result[10] + result[7]*result[14];
|
||||
result[6] = result[4]*rhs[2] + result[5]*result[7] + result[6]*result[11] + result[7]*result[15];
|
||||
result[7] = result[4]*rhs[3] + result[5]*result[8] + result[6]*result[12] + result[7]*result[16];
|
||||
|
||||
result[8] = result[8]*rhs[0] + result[9]*result[5] + result[10]*result[9] + result[11]*result[13];
|
||||
result[9] = result[8]*rhs[1] + result[9]*result[6] + result[10]*result[10] + result[11]*result[14];
|
||||
result[10] = result[8]*rhs[2] + result[9]*result[7] + result[10]*result[11] + result[11]*result[15];
|
||||
result[11] = result[8]*rhs[3] + result[9]*result[8] + result[10]*result[12] + result[11]*result[16];
|
||||
|
||||
result[12] = result[12]*rhs[0] + result[13]*result[5] + result[14]*result[9] + result[15]*result[13];
|
||||
result[13] = result[12]*rhs[1] + result[13]*result[6] + result[14]*result[10] + result[15]*result[14];
|
||||
result[14] = result[12]*rhs[2] + result[13]*result[7] + result[14]*result[11] + result[15]*result[15];
|
||||
result[15] = result[12]*rhs[3] + result[13]*result[8] + result[14]*result[12] + result[15]*result[16];
|
||||
return result;
|
||||
}
|
||||
};
|
||||
*/
|
Loading…
Reference in a new issue