text stringlengths 1 24.5M |
|---|
#include "FtpDataChannel.hpp"
#include "Engine/Log.hpp"
#include "Ftp.hpp"
namespace acid {
FtpDataChannel::FtpDataChannel(Ftp &owner) :
ftp(owner) {
}
FtpResponse FtpDataChannel::Open(Mode mode) {
// Open a data connection in active mode (we connect to the server).
auto response = ftp.SendCommand("PASV");
if (... |
#pragma once
#include "Network/Tcp/TcpSocket.hpp"
namespace acid {
class Ftp;
class FtpResponse;
/**
* @brief Utility class for exchanging datas with the server on the data channel.
*/
class ACID_EXPORT FtpDataChannel {
public:
/**
* @brief Enumeration of transfer modes.
*/
enum class Mode {
/// Binary mod... |
#include "FtpResponse.hpp"
namespace acid {
FtpResponse::FtpResponse(Status code, std::string message) :
status(code),
message(std::move(message)) {
}
bool FtpResponse::IsOk() const {
return static_cast<uint32_t>(status) < 400;
}
}
|
#pragma once
#include <string>
#include "Export.hpp"
namespace acid {
/**
* @brief Define a FTP response.
*/
class ACID_EXPORT FtpResponse {
public:
/**
* @brief Status codes possibly returned by a FTP response.
*/
enum class Status {
// 1xx: the requested action is being initiated, expect another reply be... |
#include "FtpResponseDirectory.hpp"
namespace acid {
FtpResponseDirectory::FtpResponseDirectory(const FtpResponse &response) :
FtpResponse(response) {
if (IsOk()) {
// Extract the directory from the server response
auto begin = GetFullMessage().find('"', 0);
auto end = GetFullMessage().find('"', begin + 1);
... |
#pragma once
#include "FtpResponse.hpp"
namespace acid {
/**
* @brief Specialization of FTP response returning a directory.
*/
class ACID_EXPORT FtpResponseDirectory : public FtpResponse {
public:
/**
* Default constructor.
* @param response Source response.
*/
FtpResponseDirectory(const FtpResponse &respon... |
#include "FtpResponseListing.hpp"
namespace acid {
FtpResponseListing::FtpResponseListing(const FtpResponse &response, const std::string &data) :
FtpResponse(response) {
if (IsOk()) {
// Fill the array of strings
std::string::size_type lastPos = 0;
for (auto pos = data.find("\r\n"); pos != std::string::npos; ... |
#pragma once
#include <vector>
#include "FtpResponse.hpp"
namespace acid {
/**
* @brief Specialization of FTP response returning a filename listing.
*/
class ACID_EXPORT FtpResponseListing : public FtpResponse {
public:
/**
* Default constructor.
* @param response Source response.
* @param data Data contain... |
#include "Http.hpp"
#include "Engine/Log.hpp"
#include "Utils/String.hpp"
namespace acid {
Http::Http() {
}
Http::Http(const std::string &host, uint16_t port) :
port(port) {
SetHost(host, port);
}
void Http::SetHost(const std::string &host, uint16_t port) {
// Check the protocol.
if (String::Lowercase(host.subs... |
#pragma once
#include "Network/Tcp/TcpSocket.hpp"
#include "Network/IpAddress.hpp"
#include "HttpRequest.hpp"
#include "HttpResponse.hpp"
namespace acid {
/**
* @brief A very simple HTTP client that allows you to communicate with a web server.
* You can retrieve web pages, send data to an interactive resource,
* d... |
#include "HttpRequest.hpp"
#include "Utils/String.hpp"
namespace acid {
HttpRequest::HttpRequest(const std::string &uri, Method method, const std::string &body) :
method(method),
majorVersion(1),
minorVersion(0) {
SetUri(uri);
SetBody(body);
}
void HttpRequest::SetField(const std::string &field, const std::stri... |
#pragma once
#include <string>
#include <map>
#include "Export.hpp"
namespace acid {
/**
* @brief Defines a HTTP request.
*/
class ACID_EXPORT HttpRequest {
friend class Http;
public:
/**
* @brief Enumerate the available HTTP methods for a request, https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods.
*... |
#include "HttpResponse.hpp"
#include <limits>
#include "Utils/String.hpp"
namespace acid {
HttpResponse::HttpResponse() :
status(Status::ConnectionFailed),
majorVersion(0),
minorVersion(0) {
}
std::string HttpResponse::GetField(const std::string &field) const {
auto it = fields.find(String::Lowercase(field));
... |
#pragma once
#include <string>
#include <map>
#include "Export.hpp"
namespace acid {
/**
* @brief Defines a HTTP response.
*/
class ACID_EXPORT HttpResponse {
friend class Http;
public:
/**
* Enumerate all the valid status codes for a response.
*/
enum class Status {
/// Most common code returned when ope... |
#include "TcpListener.hpp"
#ifdef ACID_BUILD_WINDOWS
#include <WinSock2.h>
#else
#include <netinet/in.h>
#endif
#include "Engine/Log.hpp"
#include "TcpSocket.hpp"
namespace acid {
TcpListener::TcpListener() :
Socket(Type::Tcp) {
}
uint16_t TcpListener::GetLocalPort() const {
if (GetHandle() != InvalidSocketHandle... |
#pragma once
#include "Network/Socket.hpp"
#include "Network/IpAddress.hpp"
namespace acid {
class TcpSocket;
/**
* @brief A listener socket is a special type of socket that listens to a given port
* and waits for connections on that port. This is all it can do.
*
* When a new connection is received, you must ca... |
#include "TcpSocket.hpp"
#include <cstring>
#ifdef ACID_BUILD_WINDOWS
#include <WinSock2.h>
#else
#include <sys/select.h>
#include <netinet/in.h>
#endif
#include "Engine/Log.hpp"
#include "Network/IpAddress.hpp"
#include "Network/Packet.hpp"
#ifdef _MSC_VER
#pragma warning(disable: 4127) // "conditional expression i... |
#pragma once
#include <vector>
#include "Maths/Time.hpp"
#include "Network/Socket.hpp"
namespace acid {
class IpAddress;
class Packet;
/**
* @brief TCP is a connected protocol, which means that a TCP socket can only communicate with
* the host it is connected to. It can't send or receive anything if it is not con... |
#include "UdpSocket.hpp"
#ifdef ACID_BUILD_WINDOWS
#include <WinSock2.h>
#else
#include <netinet/in.h>
#endif
#include "Engine/Log.hpp"
#include "Network/IpAddress.hpp"
#include "Network/Packet.hpp"
namespace acid {
static const uint32_t MAX_DATAGRAM_SIZE = 65507;
UdpSocket::UdpSocket() :
Socket(Type::Udp),
buffe... |
#pragma once
#include <vector>
#include "Network/Socket.hpp"
#include "Network/IpAddress.hpp"
namespace acid {
class Packet;
/**
* @brief A UDP socket is a connectionless socket. Instead of connecting once to a remote host,
* like TCP sockets, it can send to and receive from any host at any time.
*
* It is a da... |
#include "Particle.hpp"
#include "Scenes/Scenes.hpp"
namespace acid {
constexpr static float FADE_TIME = 1.0f;
Particle::Particle(std::shared_ptr<ParticleType> particleType, const Vector3f &position, const Vector3f &velocity, float lifeLength, float stageCycles,
float rotation, float scale, float gravityEffect) :
... |
#pragma once
#include "Maths/Vector2.hpp"
#include "Maths/Vector3.hpp"
#include "ParticleType.hpp"
namespace acid {
/**
* @brief A instance of a particle type.
*/
class ACID_EXPORT Particle final {
friend class ParticleType;
public:
/**
* Creates a new particle object.
* @param particleType The particle ty... |
#include "Particles.hpp"
#include "Scenes/Scenes.hpp"
namespace acid {
Particles::Particles() {
}
void Particles::Update() {
if (Scenes::Get()->GetScene()->IsPaused()) return;
for (auto it = particles.begin(); it != particles.end();) {
for (auto it1 = (*it).second.begin(); it1 != (*it).second.end();) {
(*it1... |
#pragma once
#include "Scenes/System.hpp"
#include "Particle.hpp"
namespace acid {
/**
* @brief A manager that manages particles.
*/
class ACID_EXPORT Particles : public System {
public:
using ParticlesContainer = std::map<std::shared_ptr<ParticleType>, std::vector<Particle>>;
Particles();
void Update() overri... |
#include "ParticlesSubrender.hpp"
#include "Scenes/Scenes.hpp"
#include "Models/Vertex3d.hpp"
#include "Particles.hpp"
namespace acid {
ParticlesSubrender::ParticlesSubrender(const Pipeline::Stage &pipelineStage) :
Subrender(pipelineStage),
pipeline(pipelineStage, {"Shaders/Particles/Particle.vert", "Shaders/Partic... |
#pragma once
#include "Graphics/Subrender.hpp"
#include "Graphics/Buffers/UniformHandler.hpp"
#include "Graphics/Pipelines/PipelineGraphics.hpp"
namespace acid {
class ACID_EXPORT ParticlesSubrender : public Subrender {
public:
explicit ParticlesSubrender(const Pipeline::Stage &pipelineStage);
void Render(const Co... |
#include "ParticleSystem.hpp"
#include "Maths/Maths.hpp"
#include "Maths/Transform.hpp"
#include "Scenes/Entity.hpp"
#include "Particles.hpp"
#include "Scenes/Scenes.hpp"
namespace acid {
ParticleSystem::ParticleSystem(std::vector<std::shared_ptr<ParticleType>> types, std::vector<std::unique_ptr<Emitter>> &&emitters,... |
#pragma once
#include "Maths/Vector3.hpp"
#include "Maths/ElapsedTime.hpp"
#include "Scenes/Component.hpp"
#include "Emitters/Emitter.hpp"
#include "Particle.hpp"
#include "ParticleType.hpp"
namespace acid {
/**
* @brief A system of particles.
*/
class ACID_EXPORT ParticleSystem : public Component::Registrar<Par... |
#include "ParticleType.hpp"
#include "Resources/Resources.hpp"
#include "Maths/Maths.hpp"
#include "Models/Shapes/RectangleModel.hpp"
#include "Scenes/Scenes.hpp"
#include "Particle.hpp"
namespace acid {
static const uint32_t MAX_INSTANCES = 1024;
//static const uint32_t INSTANCE_STEPS = 128;
static const float FRUST... |
#pragma once
#include "Maths/Colour.hpp"
#include "Maths/Matrix4.hpp"
#include "Maths/Vector4.hpp"
#include "Maths/Vector3.hpp"
#include "Models/Model.hpp"
#include "Graphics/Buffers/InstanceBuffer.hpp"
#include "Graphics/Descriptors/DescriptorsHandler.hpp"
#include "Graphics/Pipelines/PipelineGraphics.hpp"
#include "... |
#include "CircleEmitter.hpp"
#include "Scenes/Entity.hpp"
namespace acid {
CircleEmitter::CircleEmitter(float radius, const Vector3f &heading) :
radius(radius),
heading(heading.Normalize()) {
}
Vector3f CircleEmitter::GeneratePosition() const {
Vector3f direction;
do {
auto randomVector = RandomUnitVector();
... |
#pragma once
#include "Emitter.hpp"
namespace acid {
class ACID_EXPORT CircleEmitter : public Emitter::Registrar<CircleEmitter> {
inline static const bool Registered = Register("circle");
public:
explicit CircleEmitter(float radius = 1.0f, const Vector3f &heading = Vector3f::Up);
Vector3f GeneratePosition() co... |
#pragma once
#include "Utils/StreamFactory.hpp"
#include "Maths/Vector3.hpp"
namespace acid {
/**
* @brief Component interface that defines a emitter volume.
*/
class ACID_EXPORT Emitter : public StreamFactory<Emitter> {
public:
virtual ~Emitter() = default;
/**
* Creates a new objects position.
* @return Th... |
#include "LineEmitter.hpp"
#include "Maths/Maths.hpp"
#include "Scenes/Entity.hpp"
namespace acid {
LineEmitter::LineEmitter(float length, const Vector3f &axis) :
length(length),
axis(axis.Normalize()) {
}
Vector3f LineEmitter::GeneratePosition() const {
return axis * length * Maths::Random(-0.5f, 0.5f);
}
const... |
#pragma once
#include "Emitter.hpp"
namespace acid {
class ACID_EXPORT LineEmitter : public Emitter::Registrar<LineEmitter> {
inline static const bool Registered = Register("line");
public:
explicit LineEmitter(float length = 1.0f, const Vector3f &axis = Vector3f::Right);
Vector3f GeneratePosition() const over... |
#include "PointEmitter.hpp"
#include "Scenes/Entity.hpp"
namespace acid {
PointEmitter::PointEmitter() {
}
Vector3f PointEmitter::GeneratePosition() const {
return point;
}
const Node &operator>>(const Node &node, PointEmitter &emitter) {
node["point"].Get(emitter.point);
return node;
}
Node &operator<<(Node... |
#pragma once
#include "Emitter.hpp"
namespace acid {
class ACID_EXPORT PointEmitter : public Emitter::Registrar<PointEmitter> {
inline static const bool Registered = Register("point");
public:
PointEmitter();
Vector3f GeneratePosition() const override;
const Vector3f &GetPoint() const { return point; }
void... |
#include "SphereEmitter.hpp"
#include "Maths/Maths.hpp"
#include "Maths/Vector2.hpp"
namespace acid {
SphereEmitter::SphereEmitter(float radius) :
radius(radius) {
}
Vector3f SphereEmitter::GeneratePosition() const {
auto a = Maths::Random(0.0f, 1.0f);
auto b = Maths::Random(0.0f, 1.0f);
if (a > b)
std::swap(a... |
#pragma once
#include "Emitter.hpp"
namespace acid {
class ACID_EXPORT SphereEmitter : public Emitter::Registrar<SphereEmitter> {
inline static const bool Registered = Register("sphere");
public:
explicit SphereEmitter(float radius = 1.0f);
Vector3f GeneratePosition() const override;
float GetRadius() const ... |
#include "CollisionObject.hpp"
#include <BulletCollision/CollisionShapes/btCompoundShape.h>
#include <BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h>
#include "Colliders/Collider.hpp"
namespace acid {
CollisionObject::CollisionObject(std::vector<std::unique_ptr<Collider>> &&colliders, float mass, float friction, c... |
#pragma once
#include "Utils/NonCopyable.hpp"
#include "Colliders/Collider.hpp"
#include "Force.hpp"
class btTransform;
class btCollisionShape;
class btCollisionObject;
namespace acid {
class Frustum;
/**
* @brief Represents a object in a scene effected by physics.
*/
class ACID_EXPORT CollisionObject : public vi... |
#include "Force.hpp"
namespace acid {
Force::Force(const Vector3f &force, const Vector3f &position) :
force(force),
neverExpires(true),
position(position) {
}
Force::Force(const Vector3f &force, const Time &time, const Vector3f &position) :
force(force),
neverExpires(false),
timeLeft(time),
position(position) ... |
#pragma once
#include "Maths/Vector3.hpp"
#include "Maths/Time.hpp"
namespace acid {
/**
* @brief Represents a force that is attached to a {@link Rigidbody}.
*/
class ACID_EXPORT Force {
public:
/**
* Creates a new force that never times-out.
* @param force The vector of the force is applied.
* @param positi... |
#include "Frustum.hpp"
namespace acid {
void Frustum::Update(const Matrix4 &view, const Matrix4 &projection) {
std::array<float, 16> clip;
clip[0] = view[0][0] * projection[0][0] + view[0][1] * projection[1][0] + view[0][2] * projection[2][0] + view[0][3] * projection[3][0];
clip[1] = view[0][0] * projection[0][1]... |
#pragma once
#include <array>
#include "Maths/Matrix4.hpp"
namespace acid {
/**
* @brief Represents the region of space in the modeled world that may appear on the screen.
*/
class ACID_EXPORT Frustum {
public:
Frustum() = default;
/**
* Updates a frustum from the view and projection matrix.
* @param view T... |
#include "KinematicCharacter.hpp"
#include <BulletCollision/CollisionDispatch/btGhostObject.h>
#include <BulletCollision/CollisionShapes/btCompoundShape.h>
#include <BulletSoftBody/btSoftRigidDynamicsWorld.h>
#include <BulletDynamics/Character/btKinematicCharacterController.h>
#include "Maths/Transform.hpp"
#include "... |
#pragma once
#include "Maths/Vector3.hpp"
#include "Scenes/Component.hpp"
#include "Colliders/Collider.hpp"
#include "CollisionObject.hpp"
class btPairCachingGhostObject;
class btKinematicCharacterController;
namespace acid {
/**
* @brief Represents a kinematic character controller.
*/
class ACID_EXPORT KinematicC... |
#include "Physics.hpp"
#include <iterator>
#include <BulletCollision/BroadphaseCollision/btBroadphaseInterface.h>
#include <BulletCollision/BroadphaseCollision/btDbvtBroadphase.h>
#include <BulletCollision/CollisionDispatch/btCollisionDispatcher.h>
#include <BulletCollision/CollisionDispatch/btCollisionObject.h>
#inc... |
#pragma once
#include <set>
#include <memory>
#include "Maths/Vector3.hpp"
#include "Scenes/System.hpp"
class btCollisionObject;
class btCollisionConfiguration;
class btBroadphaseInterface;
class btCollisionDispatcher;
class btConstraintSolver;
class btDiscreteDynamicsWorld;
namespace acid {
class Entity;
class Col... |
#include "Ray.hpp"
namespace acid {
Ray::Ray(bool useMouse, const Vector2f &screenStart) :
useMouse(useMouse),
screenStart(screenStart) {
}
void Ray::Update(const Vector3f ¤tPosition, const Vector2f &mousePosition, const Matrix4 &viewMatrix, const Matrix4 &projectionMatrix) {
origin = currentPosition;
if (... |
#pragma once
#include "Maths/Matrix4.hpp"
#include "Maths/Vector2.hpp"
#include "Maths/Vector3.hpp"
#include "Maths/Vector4.hpp"
namespace acid {
/**
* @brief Class that represents a 3 dimensional ray.
*/
class ACID_EXPORT Ray {
public:
/**
* Creates a new ray.
* @param useMouse If the ray will use the mouse c... |
#include "Rigidbody.hpp"
#include <BulletCollision/CollisionShapes/btCollisionShape.h>
#include <BulletCollision/CollisionShapes/btCompoundShape.h>
#include <BulletDynamics/Dynamics/btDiscreteDynamicsWorld.h>
#include <BulletDynamics/Dynamics/btRigidBody.h>
#include <LinearMath/btDefaultMotionState.h>
#include "Maths/... |
#pragma once
#include "Maths/Vector3.hpp"
#include "Scenes/Component.hpp"
#include "CollisionObject.hpp"
struct btDefaultMotionState;
class btRigidBody;
namespace acid {
/**
* @brief Represents a object in a scene effected by physics.
*/
class ACID_EXPORT Rigidbody : public Component::Registrar<Rigidbody>, publ... |
#include "CapsuleCollider.hpp"
#include <BulletCollision/CollisionShapes/btCapsuleShape.h>
namespace acid {
CapsuleCollider::CapsuleCollider(float radius, float height, const Transform &localTransform) :
//Collider(localTransform),
shape(std::make_unique<btCapsuleShape>(radius, height)),
radius(radius),
height(he... |
#pragma once
#include "Collider.hpp"
class btCapsuleShape;
namespace acid {
class ACID_EXPORT CapsuleCollider : public Collider::Registrar<CapsuleCollider> {
inline static const bool Registered = Register("capsule");
public:
explicit CapsuleCollider(float radius = 0.5f, float height = 1.0f, const Transform &localT... |
#include "Collider.hpp"
#include <BulletCollision/CollisionShapes/btCollisionShape.h>
#include "Maths/Transform.hpp"
namespace acid {
Collider::Collider(const Transform &localTransform) :
localTransform(localTransform) {
}
void Collider::SetLocalTransform(const Transform &localTransform) {
this->localTransform = l... |
#pragma once
#include <rocket.hpp>
#include "Maths/Transform.hpp"
#include "Maths/Quaternion.hpp"
#include "Utils/StreamFactory.hpp"
class btCollisionShape;
class btVector3;
class btQuaternion;
class btTransform;
namespace acid {
/**
* @brief Class that represents a physics shape.
*/
class ACID_EXPORT Collider : ... |
#include "ConeCollider.hpp"
#include <BulletCollision/CollisionShapes/btConeShape.h>
namespace acid {
ConeCollider::ConeCollider(float radius, float height, const Transform &localTransform) :
//Collider(localTransform),
shape(std::make_unique<btConeShape>(radius, height)),
radius(radius),
height(height) {
this->... |
#pragma once
#include "Collider.hpp"
class btConeShape;
namespace acid {
class ACID_EXPORT ConeCollider : public Collider::Registrar<ConeCollider> {
inline static const bool Registered = Register("cone");
public:
explicit ConeCollider(float radius = 1.0f, float height = 1.0f, const Transform &localTransform = {});... |
#include "ConvexHullCollider.hpp"
#include <BulletCollision/CollisionShapes/btConvexHullShape.h>
#include "Meshes/Mesh.hpp"
namespace acid {
ConvexHullCollider::ConvexHullCollider(const std::vector<float> &pointCloud, const Transform &localTransform) /*:
Collider(localTransform)*/ {
this->localTransform = localTran... |
#pragma once
#include "Models/Model.hpp"
#include "Collider.hpp"
class btConvexHullShape;
namespace acid {
class ACID_EXPORT ConvexHullCollider : public Collider::Registrar<ConvexHullCollider> {
inline static const bool Registered = Register("convexHull");
public:
explicit ConvexHullCollider(const std::vector<floa... |
#include "CubeCollider.hpp"
#include <BulletCollision/CollisionShapes/btBoxShape.h>
namespace acid {
CubeCollider::CubeCollider(const Vector3f &extents, const Transform &localTransform) :
//Collider(localTransform),
shape(std::make_unique<btBoxShape>(Convert(extents / 2.0f))),
extents(extents) {
this->localTransf... |
#pragma once
#include "Collider.hpp"
class btBoxShape;
namespace acid {
class ACID_EXPORT CubeCollider : public Collider::Registrar<CubeCollider> {
inline static const bool Registered = Register("cube");
public:
explicit CubeCollider(const Vector3f &extents = Vector3f(1.0f), const Transform &localTransform = {});
... |
#include "CylinderCollider.hpp"
#include <BulletCollision/CollisionShapes/btCylinderShape.h>
namespace acid {
CylinderCollider::CylinderCollider(float radius, float height, const Transform &localTransform) :
//Collider(localTransform),
shape(std::make_unique<btCylinderShape>(btVector3(radius, height / 2.0f, radius)... |
#pragma once
#include "Collider.hpp"
class btCylinderShape;
namespace acid {
class ACID_EXPORT CylinderCollider : public Collider::Registrar<CylinderCollider> {
inline static const bool Registered = Register("cylinder");
public:
explicit CylinderCollider(float radius = 1.0f, float height = 1.0f, const Transform &l... |
#include "HeightfieldCollider.hpp"
#include <BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h>
namespace acid {
HeightfieldCollider::HeightfieldCollider(int32_t heightStickWidth, int32_t heightStickLength, const void *heightfieldData, float minHeight,
float maxHeight, bool flipQuadEdges, const Transform &... |
#pragma once
#include "Collider.hpp"
class btHeightfieldTerrainShape;
namespace acid {
class ACID_EXPORT HeightfieldCollider : public Collider::Registrar<HeightfieldCollider> {
inline static const bool Registered = Register("heightfield");
public:
explicit HeightfieldCollider(int32_t heightStickWidth = 100, int32_... |
#include "SphereCollider.hpp"
#include <BulletCollision/CollisionShapes/btSphereShape.h>
namespace acid {
SphereCollider::SphereCollider(float radius, const Transform &localTransform) :
//Collider(localTransform),
shape(std::make_unique<btSphereShape>(radius)),
radius(radius) {
this->localTransform = localTransfo... |
#pragma once
#include "Collider.hpp"
class btSphereShape;
namespace acid {
class ACID_EXPORT SphereCollider : public Collider::Registrar<SphereCollider> {
inline static const bool Registered = Register("sphere");
public:
explicit SphereCollider(float radius = 0.5f, const Transform &localTransform = {});
~SphereCo... |
#include "Post/PostFilter.hpp"
namespace acid {
PostFilter::PostFilter(const Pipeline::Stage &pipelineStage, const std::vector<std::filesystem::path> &shaderStages, const std::vector<Shader::Define> &defines) :
Subrender(pipelineStage),
pipeline(pipelineStage, shaderStages, {}, defines, PipelineGraphics::Mode::Polyg... |
#pragma once
#include "Graphics/Subrender.hpp"
#include "Graphics/Graphics.hpp"
#include "Graphics/Descriptors/DescriptorsHandler.hpp"
#include "Graphics/Pipelines/PipelineGraphics.hpp"
namespace acid {
/**
* @brief Represents a post effect pipeline.
*/
class ACID_EXPORT PostFilter : public Subrender {
public:
/**... |
#pragma once
#include "Graphics/Subrender.hpp"
namespace acid {
/**
* @brief Represents a system of post effects.
*/
class ACID_EXPORT PostPipeline : public Subrender {
public:
/**
* Creates a new post pipeline.
* @param pipelineStage The pipelines graphics stage.
*/
explicit PostPipeline(const Pipeline::St... |
#include "DeferredSubrender.hpp"
#include "Files/File.hpp"
#include "Files/Json/Json.hpp"
#include "Lights/Light.hpp"
#include "Models/Vertex3d.hpp"
#include "Shadows/Shadows.hpp"
#include "Resources/Resources.hpp"
#include "Graphics/Pipelines/PipelineCompute.hpp"
#include "Graphics/Graphics.hpp"
#include "Scenes/Scen... |
#pragma once
#include "Utils/Future.hpp"
#include "Lights/Fog.hpp"
#include "Maths/Vector3.hpp"
#include "Graphics/Subrender.hpp"
#include "Graphics/Descriptors/DescriptorsHandler.hpp"
#include "Graphics/Buffers/UniformHandler.hpp"
#include "Graphics/Images/ImageCube.hpp"
#include "Graphics/Pipelines/PipelineGraphics.... |
#include "BlitFilter.hpp"
namespace acid {
BlitFilter::BlitFilter(const Pipeline::Stage &pipelineStage) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Blit.frag"}) {
}
void BlitFilter::Render(const CommandBuffer &commandBuffer) {
// Updates descriptors.
descriptorSet.Push("samplerColour", ... |
#pragma once
#include <Post/PostFilter.hpp>
namespace acid {
class ACID_EXPORT BlitFilter : public PostFilter {
public:
explicit BlitFilter(const Pipeline::Stage &pipelineStage);
void Render(const CommandBuffer &commandBuffer) override;
};
}
|
#include "BlurFilter.hpp"
#include "Graphics/Graphics.hpp"
namespace acid {
BlurFilter::BlurFilter(const Pipeline::Stage &pipelineStage, const Vector2f &direction, Type type) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Blur.frag"}, GetDefines(type)),
type(type),
direction(direction) {
}... |
#pragma once
#include "Maths/Vector2.hpp"
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT BlurFilter : public PostFilter {
public:
enum class Type {
_5 = 5,
_9 = 9,
_13 = 13
};
explicit BlurFilter(const Pipeline::Stage &pipelineStage, const Vector2f &direction, Type type = Type::_9);
voi... |
#include "CrtFilter.hpp"
#include "Graphics/Graphics.hpp"
namespace acid {
CrtFilter::CrtFilter(const Pipeline::Stage &pipelineStage, const Colour &screenColour, float curveAmountX, float curveAmountY, float scanLineSize,
float scanIntensity) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/C... |
#pragma once
#include "Maths/Colour.hpp"
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT CrtFilter : public PostFilter {
public:
explicit CrtFilter(const Pipeline::Stage &pipelineStage, const Colour &screenColour = Colour(0.5f, 1.0f, 0.5f), float curveAmountX = 0.1f,
float curveAmountY = 0.1f, fl... |
#include "DarkenFilter.hpp"
namespace acid {
DarkenFilter::DarkenFilter(const Pipeline::Stage &pipelineStage, float factor) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Darken.frag"}),
factor(factor) {
}
void DarkenFilter::Render(const CommandBuffer &commandBuffer) {
// Updates uniforms.... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT DarkenFilter : public PostFilter {
public:
explicit DarkenFilter(const Pipeline::Stage &pipelineStage, float factor = 0.5f);
void Render(const CommandBuffer &commandBuffer) override;
float GetFactor() const { return factor; }
void Se... |
#include "DefaultFilter.hpp"
namespace acid {
DefaultFilter::DefaultFilter(const Pipeline::Stage &pipelineStage, bool lastFilter) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Default.frag"}),
lastFilter(lastFilter) {
}
void DefaultFilter::Render(const CommandBuffer &commandBuffer) {
// U... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT DefaultFilter : public PostFilter {
public:
explicit DefaultFilter(const Pipeline::Stage &pipelineStage, bool lastFilter = false);
void Render(const CommandBuffer &commandBuffer) override;
private:
bool lastFilter;
};
}
|
#include "DofFilter.hpp"
#include "Graphics/Graphics.hpp"
#include "Scenes/Scenes.hpp"
namespace acid {
DofFilter::DofFilter(const Pipeline::Stage &pipelineStage, BlurPipeline *pipelineBlur, float focusPoint, float nearField, float nearTransition,
float farField, float farTransition) :
PostFilter(pipelineStage, {"S... |
#pragma once
#include "Post/PostFilter.hpp"
#include "Post/Pipelines/BlurPipeline.hpp"
namespace acid {
class ACID_EXPORT DofFilter : public PostFilter {
public:
explicit DofFilter(const Pipeline::Stage &pipelineStage, BlurPipeline *pipelineBlur, float focusPoint = 8.24f, float nearField = 0.3f,
float nearTransiti... |
#include "EmbossFilter.hpp"
namespace acid {
EmbossFilter::EmbossFilter(const Pipeline::Stage &pipelineStage) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Emboss.frag"}) {
}
void EmbossFilter::Render(const CommandBuffer &commandBuffer) {
// Updates descriptors.
PushConditional("writeColo... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT EmbossFilter : public PostFilter {
public:
explicit EmbossFilter(const Pipeline::Stage &pipelineStage);
void Render(const CommandBuffer &commandBuffer) override;
};
}
|
#include "FxaaFilter.hpp"
namespace acid {
FxaaFilter::FxaaFilter(const Pipeline::Stage &pipelineStage, float spanMax) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Fxaa.frag"}),
spanMax(spanMax) {
}
void FxaaFilter::Render(const CommandBuffer &commandBuffer) {
// Updates uniforms.
pushS... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT FxaaFilter : public PostFilter {
public:
explicit FxaaFilter(const Pipeline::Stage &pipelineStage, float spanMax = 8.0f);
void Render(const CommandBuffer &commandBuffer) override;
float GetSpanMax() const { return spanMax; }
void Set... |
#include "GrainFilter.hpp"
namespace acid {
GrainFilter::GrainFilter(const Pipeline::Stage &pipelineStage, float strength) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Grain.frag"}),
strength(strength) {
}
void GrainFilter::Render(const CommandBuffer &commandBuffer) {
// Updates uniforms... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT GrainFilter : public PostFilter {
public:
explicit GrainFilter(const Pipeline::Stage &pipelineStage, float strength = 2.3f);
void Render(const CommandBuffer &commandBuffer) override;
float GetStrength() const { return strength; }
voi... |
#include "GreyFilter.hpp"
namespace acid {
GreyFilter::GreyFilter(const Pipeline::Stage &pipelineStage) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Grey.frag"}) {
}
void GreyFilter::Render(const CommandBuffer &commandBuffer) {
// Updates descriptors.
PushConditional("writeColour", "samp... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT GreyFilter : public PostFilter {
public:
explicit GreyFilter(const Pipeline::Stage &pipelineStage);
void Render(const CommandBuffer &commandBuffer) override;
};
}
|
#include "LensflareFilter.hpp"
#include "Scenes/Scenes.hpp"
namespace acid {
LensflareFilter::LensflareFilter(const Pipeline::Stage &pipelineStage) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Lensflare.frag"}) {
}
void LensflareFilter::Render(const CommandBuffer &commandBuffer) {
// Upd... |
#pragma once
#include "Maths/Vector3.hpp"
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT LensflareFilter : public PostFilter {
public:
explicit LensflareFilter(const Pipeline::Stage &pipelineStage);
void Render(const CommandBuffer &commandBuffer) override;
const Vector3f &GetSunPosition() cons... |
#include "NegativeFilter.hpp"
namespace acid {
NegativeFilter::NegativeFilter(const Pipeline::Stage &pipelineStage) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Negative.frag"}) {
}
void NegativeFilter::Render(const CommandBuffer &commandBuffer) {
// Updates descriptors.
PushConditional(... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT NegativeFilter : public PostFilter {
public:
explicit NegativeFilter(const Pipeline::Stage &pipelineStage);
void Render(const CommandBuffer &commandBuffer) override;
};
}
|
#include "PixelFilter.hpp"
namespace acid {
PixelFilter::PixelFilter(const Pipeline::Stage &pipelineStage, float pixelSize) :
PostFilter(pipelineStage, {"Shaders/Post/Default.vert", "Shaders/Post/Pixel.frag"}),
pixelSize(pixelSize) {
}
void PixelFilter::Render(const CommandBuffer &commandBuffer) {
// Updates unifo... |
#pragma once
#include "Post/PostFilter.hpp"
namespace acid {
class ACID_EXPORT PixelFilter : public PostFilter {
public:
explicit PixelFilter(const Pipeline::Stage &pipelineStage, float pixelSize = 2.0f);
void Render(const CommandBuffer &commandBuffer) override;
float GetPixelSize() const { return pixelSize; }
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.