mitchellhansen/conways-game-of-life-gpu
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rewrote the entire thing using my new OpenCL template. Makes small one offs like these reallly simple

Browse Source
This commit is contained in:
MitchellHansen
2017-04-04 05:33:38 -07:00
parent 08fd8b2398
commit 7743321465
27 changed files with 2314 additions and 1375 deletions
Download Patch File Download Diff File Expand all files Collapse all files

149
include/OpenCL.h Normal file
View File

@@ -0,0 +1,149 @@
#pragma once
#include <string>
#include <SFML/Graphics.hpp>
#include <unordered_map>
#include <iostream>
#include "Vector4.hpp"
#include <string.h>
#include <memory>
#ifdef linux
#include <CL/cl.h>
#include <CL/opencl.h>
#include <GL/glx.h>
#elif defined _WIN32
#define CL_USE_DEPRECATED_OPENCL_1_2_APIS
#include <CL/cl_gl.h>
#include <CL/cl.h>
#include <CL/opencl.h>
// Note: windows.h must be included before Gl/GL.h
#include <windows.h>
#include <GL/GL.h>
#elif defined TARGET_OS_MAC
#include <OpenCL/opencl.h>
#endif
class OpenCL {
public:
OpenCL();
~OpenCL();
// command queues are associated with a device and context, so for multi-gpu applications you would need
// multiple command queues
// CONTEXTS
// - An OpenCL context is created with one or more devices. Contexts are used by the OpenCL runtime
// for managing objects such as command - queues, memory, program and kernel objects and for executing
// kernels on one or more devices specified in the context.
// - Contexts cannot be created using more than one platform!
bool init();
bool compile_kernel(std::string kernel_path, std::string kernel_name);
// Create an image buffer from an SF texture. Access Type is the read/write specifier required by OpenCL
bool create_image_buffer_from_texture(std::string buffer_name, sf::Texture* texture, cl_int access_type);
// Have CL create and manage the texture for the image buffer. Access Type is the read/write specifier required by OpenCL
bool create_image_buffer(std::string buffer_name, sf::Vector2i size, sf::Vector2f position, cl_int access_type);
// Create a buffer with CL_MEM_READ_ONLY and CL_MEM_COPY_HOST_PTR
int create_buffer(std::string buffer_name, cl_uint size, void* data);
// Create a buffer with user defined data access flags
int create_buffer(std::string buffer_name, cl_uint size, void* data, cl_mem_flags flags);
int set_kernel_arg(std::string kernel_name, int index, std::string buffer_name);
void run_kernel(std::string kernel_name, sf::Vector2i work_size);
void draw(sf::RenderWindow *window);
class device {
public:
#pragma pack(push, 1)
struct packed_data {
cl_device_type device_type;
cl_uint clock_frequency;
char opencl_version[64];
cl_uint compute_units;
char device_extensions[1024];
char device_name[256];
char platform_name[128];
};
#pragma pack(pop)
device(cl_device_id device_id, cl_platform_id platform_id);
device(const device& d);
void print(std::ostream& stream) const;
void print_packed_data(std::ostream& stream);
cl_device_id getDeviceId() const { return device_id; };
cl_platform_id getPlatformId() const { return platform_id; };
private:
packed_data data;
cl_device_id device_id;
cl_platform_id platform_id;
cl_bool is_little_endian = false;
bool cl_gl_sharing = false;
};
private:
int error = 0;
// The device which we have selected according to certain criteria
cl_platform_id platform_id;
cl_device_id device_id;
// The GL shared context and its subsiquently generated command queue
cl_context context;
cl_command_queue command_queue;
// Maps which contain a mapping from "name" to the host side CL memory object
std::unordered_map<std::string, cl_kernel> kernel_map;
std::unordered_map<std::string, cl_mem> buffer_map;
std::unordered_map<std::string, std::pair<sf::Sprite, std::unique_ptr<sf::Texture>>> image_map;
std::vector<device> device_list;
// Query the hardware on this machine and store the devices
bool aquire_hardware();
// After aquiring hardware, create a shared context using platform specific CL commands
bool create_shared_context();
// Command queues must be created with a valid context
bool create_command_queue();
// Store a cl_mem object in the buffer map <string:name, cl_mem:buffer>
bool store_buffer(cl_mem buffer, std::string buffer_name);
// Using CL release the memory object and remove the KVP associated with the buffer name
bool release_buffer(std::string buffer_name);
bool load_config();
void save_config();
static bool vr_assert(int error_code, std::string function_name);
};

479
include/Vector4.hpp Normal file
View File

@@ -0,0 +1,479 @@
////////////////////////////////////////////////////////////
//
// This is a small addition to the SFML sf::Vector templates which
// adds a sf::Vector4(f, i, u)
//
////////////////////////////////////////////////////////////
//
// SFML - Simple and Fast Multimedia Library
// Copyright (C) 2007-2016 Laurent Gomila (laurent@sfml-dev.org)
//
// This software is provided 'as-is', without any express or implied warranty.
// In no event will the authors be held liable for any damages arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it freely,
// subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented;
// you must not claim that you wrote the original software.
// If you use this software in a product, an acknowledgment
// in the product documentation would be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such,
// and must not be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
////////////////////////////////////////////////////////////
#ifndef SFML_VECTOR4_H
#define SFML_VECTOR4_H
namespace sf {
////////////////////////////////////////////////////////////
/// \brief Utility template class for manipulating
/// 2-dimensional vectors
///
////////////////////////////////////////////////////////////
template <typename T>
class Vector4 {
public:
////////////////////////////////////////////////////////////
/// \brief Default constructor
///
/// Creates a Vector4(0, 0).
///
////////////////////////////////////////////////////////////
Vector4();
////////////////////////////////////////////////////////////
/// \brief Construct the vector from its coordinates
///
/// \param X X coordinate
/// \param Y Y coordinate
///
////////////////////////////////////////////////////////////
Vector4(T X, T Y, T Z, T W);
////////////////////////////////////////////////////////////
/// \brief Construct the vector from another type of vector
///
/// This constructor doesn't replace the copy constructor,
/// it's called only when U != T.
/// A call to this constructor will fail to compile if U
/// is not convertible to T.
///
/// \param vector Vector to convert
///
////////////////////////////////////////////////////////////
template <typename U>
explicit Vector4(const Vector4<U>& vector);
////////////////////////////////////////////////////////////
// Member data
////////////////////////////////////////////////////////////
T x; ///< X coordinate of the vector
T y; ///< Y coordinate of the vector
T z; ///< Z coordinate of the vector
T w; ///< W coordinate of the vector
};
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of unary operator -
///
/// \param right Vector to negate
///
/// \return Memberwise opposite of the vector
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T> operator -(const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator +=
///
/// This operator performs a memberwise addition of both vectors,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T>& operator +=(Vector4<T>& left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator -=
///
/// This operator performs a memberwise subtraction of both vectors,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T>& operator -=(Vector4<T>& left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator +
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Memberwise addition of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T> operator +(const Vector4<T>& left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator -
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return Memberwise subtraction of both vectors
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T> operator -(const Vector4<T>& left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator *
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Memberwise multiplication by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T> operator *(const Vector4<T>& left, T right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator *
///
/// \param left Left operand (a scalar value)
/// \param right Right operand (a vector)
///
/// \return Memberwise multiplication by \a left
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T> operator *(T left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator *=
///
/// This operator performs a memberwise multiplication by \a right,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T>& operator *=(Vector4<T>& left, T right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator /
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Memberwise division by \a right
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T> operator /(const Vector4<T>& left, T right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator /=
///
/// This operator performs a memberwise division by \a right,
/// and assigns the result to \a left.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a scalar value)
///
/// \return Reference to \a left
///
////////////////////////////////////////////////////////////
template <typename T>
Vector4<T>& operator /=(Vector4<T>& left, T right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator ==
///
/// This operator compares strict equality between two vectors.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return True if \a left is equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
bool operator ==(const Vector4<T>& left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
/// \relates Vector4
/// \brief Overload of binary operator !=
///
/// This operator compares strict difference between two vectors.
///
/// \param left Left operand (a vector)
/// \param right Right operand (a vector)
///
/// \return True if \a left is not equal to \a right
///
////////////////////////////////////////////////////////////
template <typename T>
bool operator !=(const Vector4<T>& left, const Vector4<T>& right);
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T>::Vector4() :
x(0),
y(0),
z(0),
w(0){
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T>::Vector4(T X, T Y, T Z, T W) :
x(X),
y(Y),
z(Z),
w(W) {
}
////////////////////////////////////////////////////////////
template <typename T>
template <typename U>
inline Vector4<T>::Vector4(const Vector4<U>& vector) :
x(static_cast<T>(vector.x)),
y(static_cast<T>(vector.y)),
z(static_cast<T>(vector.z)),
w(static_cast<T>(vector.w)) {
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T> operator -(const Vector4<T>& right) {
return Vector4<T>(
-right.x,
-right.y,
-right.z,
-right.w
);
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T>& operator +=(Vector4<T>& left, const Vector4<T>& right) {
left.x += right.x;
left.y += right.y;
left.z += right.z;
left.w += right.w;
return left;
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T>& operator -=(Vector4<T>& left, const Vector4<T>& right) {
left.x -= right.x;
left.y -= right.y;
left.z -= right.z;
left.w -= right.w;
return left;
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T> operator +(const Vector4<T>& left, const Vector4<T>& right) {
return Vector4<T>(
left.x + right.x,
left.y + right.y,
left.z + right.z,
left.w + right.w
);
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T> operator -(const Vector4<T>& left, const Vector4<T>& right) {
return Vector4<T>(
left.x - right.x,
left.y - right.y,
left.z - right.z,
left.w - right.w
);
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T> operator *(const Vector4<T>& left, T right) {
return Vector4<T>(
left.x * right,
left.y * right,
left.z * right,
left.w * right
);
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T> operator *(T left, const Vector4<T>& right) {
return Vector4<T>(
right.x * left,
right.y * left,
right.z * left,
right.w * left
);
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T>& operator *=(Vector4<T>& left, T right) {
left.x *= right;
left.y *= right;
left.z *= right;
left.w *= right;
return left;
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T> operator /(const Vector4<T>& left, T right) {
return Vector4<T>(
left.x / right,
left.y / right,
left.z / right,
left.w / right
);
}
////////////////////////////////////////////////////////////
template <typename T>
inline Vector4<T>& operator /=(Vector4<T>& left, T right) {
left.x /= right;
left.y /= right;
left.z /= right;
left.w /= right;
return left;
}
////////////////////////////////////////////////////////////
template <typename T>
inline bool operator ==(const Vector4<T>& left, const Vector4<T>& right) {
return
(left.x == right.x) &&
(left.y == right.y) &&
(left.z == right.z) &&
(left.w == right.w);;
}
////////////////////////////////////////////////////////////
template <typename T>
inline bool operator !=(const Vector4<T>& left, const Vector4<T>& right) {
return
(left.x != right.x) ||
(left.y != right.y) ||
(left.z != right.z) ||
(left.w != right.w);
}
// Define the most common types
typedef Vector4<int> Vector4i;
typedef Vector4<unsigned int> Vector4u;
typedef Vector4<float> Vector4f;
} // namespace sf
#endif // SFML_Vector4_HPP
////////////////////////////////////////////////////////////
/// \class sf::Vector4
/// \ingroup system
///
/// sf::Vector4 is a simple class that defines a mathematical
/// vector with two coordinates (x and y). It can be used to
/// represent anything that has two dimensions: a size, a point,
/// a velocity, etc.
///
/// The template parameter T is the type of the coordinates. It
/// can be any type that supports arithmetic operations (+, -, /, *)
/// and comparisons (==, !=), for example int or float.
///
/// You generally don't have to care about the templated form (sf::Vector4<T>),
/// the most common specializations have special typedefs:
/// \li sf::Vector4<float> is sf::Vector4f
/// \li sf::Vector4<int> is sf::Vector4i
/// \li sf::Vector4<unsigned int> is sf::Vector4u
///
/// The sf::Vector4 class has a small and simple interface, its x and y members
/// can be accessed directly (there are no accessors like setX(), getX()) and it
/// contains no mathematical function like dot product, cross product, length, etc.
///
/// Usage example:
/// \code
/// sf::Vector4f v1(16.5f, 24.f);
/// v1.x = 18.2f;
/// float y = v1.y;
///
/// sf::Vector4f v2 = v1 * 5.f;
/// sf::Vector4
/// v3 = v1 + v2;
///
/// bool different = (v2 != v3);
/// \endcode
///
/// Note: for 3-dimensional vectors, see sf::Vector3.
///
////////////////////////////////////////////////////////////

159
include/util.hpp Normal file
View File

@@ -0,0 +1,159 @@
#pragma once
#include <SFML/Graphics.hpp>
#include <SFML/Graphics/VertexArray.hpp>
#include "Vector4.hpp"
#include <math.h>
#include <bitset>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <iterator>
#include <list>
#include <algorithm>
const double PI = 3.141592653589793238463;
const float PI_F = 3.14159265358979f;
inline sf::Vector3f SphereToCart(sf::Vector2f i) {
auto r = sf::Vector3f(
(1 * sin(i.y) * cos(i.x)),
(1 * sin(i.y) * sin(i.x)),
(1 * cos(i.y))
);
return r;
};
inline sf::Vector3f SphereToCart(sf::Vector3f i) {
auto r = sf::Vector3f(
(i.x * sin(i.z) * cos(i.y)),
(i.x * sin(i.z) * sin(i.y)),
(i.x * cos(i.z))
);
return r;
};
inline sf::Vector3f CartToSphere(sf::Vector3f in) {
auto r = sf::Vector3f(
sqrt(in.x * in.x + in.y * in.y + in.z * in.z),
atan(in.y / in.x),
atan(sqrt(in.x * in.x + in.y * in.y) / in.z)
);
return r;
};
inline sf::Vector2f CartToNormalizedSphere(sf::Vector3f in) {
auto r = sf::Vector2f(
atan2(sqrt(in.x * in.x + in.y * in.y), in.z),
atan2(in.y, in.x)
);
return r;
}
inline sf::Vector3f FixOrigin(sf::Vector3f base, sf::Vector3f head) {
return head - base;
}
inline sf::Vector3f Normalize(sf::Vector3f in) {
float multiplier = sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
auto r = sf::Vector3f(
in.x / multiplier,
in.y / multiplier,
in.z / multiplier
);
return r;
}
inline float DotProduct(sf::Vector3f a, sf::Vector3f b){
return a.x * b.x + a.y * b.y + a.z * b.z;
}
inline float Magnitude(sf::Vector3f in){
return sqrt(in.x * in.x + in.y * in.y + in.z * in.z);
}
inline float AngleBetweenVectors(sf::Vector3f a, sf::Vector3f b){
return acos(DotProduct(a, b) / (Magnitude(a) * Magnitude(b)));
}
inline float DistanceBetweenPoints(sf::Vector3f a, sf::Vector3f b) {
return sqrt(DotProduct(a, b));
}
inline float DegreesToRadians(float in) {
return static_cast<float>(in * PI / 180.0f);
}
inline float RadiansToDegrees(float in) {
return static_cast<float>(in * 180.0f / PI);
}
inline std::string read_file(std::string file_name){
std::ifstream input_file(file_name);
if (!input_file.is_open()){
std::cout << file_name << " could not be opened" << std::endl;
return "";
}
std::stringstream buf;
buf << input_file.rdbuf();
input_file.close();
return buf.str();
}
inline void PrettyPrintUINT64(uint64_t i, std::stringstream* ss) {
*ss << "[" << std::bitset<15>(i) << "]";
*ss << "[" << std::bitset<1>(i >> 15) << "]";
*ss << "[" << std::bitset<8>(i >> 16) << "]";
*ss << "[" << std::bitset<8>(i >> 24) << "]";
*ss << "[" << std::bitset<32>(i >> 32) << "]";
}
inline void PrettyPrintUINT64(uint64_t i) {
std::cout << "[" << std::bitset<15>(i) << "]";
std::cout << "[" << std::bitset<1>(i >> 15) << "]";
std::cout << "[" << std::bitset<8>(i >> 16) << "]";
std::cout << "[" << std::bitset<8>(i >> 24) << "]";
std::cout << "[" << std::bitset<32>(i >> 32) << "]" << std::endl;
}
inline void DumpLog(std::stringstream* ss, std::string file_name) {
std::ofstream log_file;
log_file.open(file_name);
log_file << ss->str();
log_file.close();
}
#ifdef _MSC_VER
# include <intrin.h>
# define __builtin_popcount _mm_popcnt_u32
# define __builtin_popcountll _mm_popcnt_u64
#endif
inline int count_bits(int32_t v) {
return static_cast<int>(__builtin_popcount(v));
}
inline int count_bits(int64_t v) {
return static_cast<int>(__builtin_popcountll(v));
}