353 lines
14 KiB
C++
353 lines
14 KiB
C++
/* +-------------------------------------------------------+
|
|
____/ \____ /| Open source game framework licensed to freely use, |
|
|
\ / / | copy, and modify, created for dank.game |
|
|
+--\ ^__^ /--+ | |
|
|
| ~/ \~ | | Download at https://open.shampoo.ooo/shampoo/spacebox |
|
|
| ~~~~~~~~~~~~ | +-------------------------------------------------------+
|
|
| SPACE ~~~~~ | /
|
|
| ~~~~~~~ BOX |/
|
|
+-------------*/
|
|
|
|
#pragma once
|
|
|
|
#include <optional>
|
|
#include <functional>
|
|
#include "Model.hpp"
|
|
#include "Switch.hpp"
|
|
#include "math.hpp"
|
|
|
|
namespace sb
|
|
{
|
|
/*!
|
|
* A Pad is an object containing an sb::Plane which can be clicked to launch an arbitrary user function. It can be sized and placed
|
|
* by setting its translation and scale values.
|
|
*
|
|
* Each instance:
|
|
*
|
|
* - Has an sb::Plane or derivative (either a custom one provided, or a default constructed one automatically)
|
|
* - Has an arbitrary response function for when pressed
|
|
* - Can collide with a point (for example, mouse click)
|
|
*
|
|
* Example:
|
|
*
|
|
* glm::vec3 w = glm::mat3({{1, 0, 0}, {0, 1, 0}, {-0.6739, -0.74, 1}}) * glm::mat3({{.1, 0, 0}, {0, .1 * (460.0 / 768.0), 0}, \
|
|
* {0, 0, 1}}) * glm::vec3({-1, -1, 1});
|
|
* std::cout << w << std::endl << glm::translate(glm::vec3{-0.6739, -0.74, 0}) *
|
|
* glm::scale(glm::vec3{.1, .1 * (460.0 / 768.0), 1}) * glm::vec4{-1, -1, 0, 1} << std::endl;
|
|
* Pad p {background.current(), {-0.6739f, -0.74f}, 0.1f, get_display().window_box().aspect(), std::function<void()>()};
|
|
* const std::vector<glm::vec2>& p_position = *p.attributes("position");
|
|
* glm::vec4 final_position = p.transformation() * glm::vec4{p_position[2].x, p_position[2].y, 0, 1};
|
|
* std::cout << p.transformation() << std::endl << final_position << std::endl;
|
|
* assert(final_position == glm::vec4({w.x, w.y, 0, 1}));
|
|
*/
|
|
template<typename ReturnType = void, typename... Arguments>
|
|
class Pad
|
|
{
|
|
|
|
private:
|
|
|
|
using Reaction = std::function<ReturnType(bool, Arguments...)>;
|
|
sb::Switch<ReturnType, Arguments...> connection;
|
|
sb::Plane _plane;
|
|
Box _box;
|
|
int texture_index = 0;
|
|
bool _enabled = true, _visible = true;
|
|
|
|
public:
|
|
|
|
/*!
|
|
* Construct a Pad object with a default constructed sb::Plane.
|
|
*
|
|
* @see Pad(sb::Plane, const glm::vec2&, float, float, Reaction, float)
|
|
*/
|
|
Pad(const glm::vec2& translation = {0.0f, 0.0f}, float scale = 1.0f, float ratio = 1.0f, Reaction on_state_change = Reaction(),
|
|
float rotation = 0.0f) : Pad(sb::Plane(), translation, scale, ratio, on_state_change, rotation) {}
|
|
|
|
/*!
|
|
* Construct a pad object from an sb::Plane, a translation amount, a scale factor, and a reaction function. The translation is
|
|
* relative to (0.0, 0.0), and the scale is relative to the plane object.
|
|
*
|
|
* The reaction function must accept a boolean as its first argument, which will be given the state of the pad object's switch.
|
|
*
|
|
* The plane object will be copied into the pad, so any edits must be made before constructing the pad, unless there is a Pad
|
|
* function that applies the edit, such as Pad::scale(float, float).
|
|
*
|
|
* @param plane plane or plane derivative to represent the pad visually
|
|
* @param translation x, y amount to translate the position
|
|
* @param scale amount to scale both x and y
|
|
* @param ratio ratio to adjust scale of x and y
|
|
* @param on_state_change reaction function which accepts a boolean as its first argument
|
|
* @param rotation angle in radians to rotate the pad
|
|
*/
|
|
Pad(const sb::Plane& plane, glm::vec2 translation = {0.0f, 0.0f}, float scale = 1.0f, float ratio = 1.0f,
|
|
Reaction on_state_change = Reaction(), float rotation = 0.0f) : _plane(plane)
|
|
{
|
|
_box.size({2.0f, 2.0f}, true);
|
|
if (translation != glm::vec2{0.0f, 0.0f})
|
|
{
|
|
this->translate(translation);
|
|
}
|
|
if (scale != 1.0f || ratio != 1.0f)
|
|
{
|
|
this->scale(scale, ratio);
|
|
}
|
|
if (rotation)
|
|
{
|
|
this->rotate(rotation);
|
|
}
|
|
this->on_state_change(on_state_change);
|
|
}
|
|
|
|
/*!
|
|
* Assign a new plane to the pad. The existing plane will be replaced.
|
|
*
|
|
* @param plane plane or plane derivative to represent the pad visually
|
|
*/
|
|
void plane(const sb::Plane& plane)
|
|
{
|
|
_plane = plane;
|
|
}
|
|
|
|
/*!
|
|
* @return Constant reference to the pad's plane object
|
|
*/
|
|
const sb::Plane& plane() const
|
|
{
|
|
return _plane;
|
|
}
|
|
|
|
/*!
|
|
* @return Constant reference to the pad's box object
|
|
*/
|
|
const sb::Box& box() const
|
|
{
|
|
return _box;
|
|
}
|
|
|
|
/*!
|
|
* Rotate the pad around its center by 90 degrees. If a count is given, rotate by 90 degrees that many times, so for example,
|
|
* a count of 3 will be a 270 degree rotation. If the count is negative, rotate -90 degrees.
|
|
*
|
|
* @param count number of 90 degree rotations to make, or use a negative count to rotate -90 degrees
|
|
*/
|
|
void rotate(int count = 1)
|
|
{
|
|
_plane.transform(glm::rotate(count * glm::half_pi<float>(), glm::vec3{0.0f, 0.0f, 1.0f}));
|
|
}
|
|
|
|
/*!
|
|
* Scale using a factor and ratio that will transform the pad in the X and Y dimensions. The ratio determines how much each axis
|
|
* is scaled. If the ratio is above one, the X-axis's scale will be divided by the ratio. If the ratio is below one, the Y-axis's
|
|
* scale will be multiplied by the aspect ratio. If the aspect ratio of the window is given, this will force the pad to display as
|
|
* a square, and the ratio will be relative to the shorter axis.
|
|
*
|
|
* The collision box will be scaled by the same factors.
|
|
*
|
|
* @param factor amount to scale in both x and y directions
|
|
* @param ratio amount to adjust scaling, set to the window aspect ratio to make the pad appear square
|
|
*/
|
|
const glm::mat4& scale(float factor, float ratio = 1.0f)
|
|
{
|
|
glm::vec3 scale { factor, factor, 1.0f };
|
|
if (ratio > 1.0f)
|
|
{
|
|
scale.x /= ratio;
|
|
}
|
|
else if (ratio < 1.0f)
|
|
{
|
|
scale.y *= ratio;
|
|
}
|
|
_box.size({2.0f, 2.0f}, true);
|
|
_box.scale({scale.x, scale.y}, true);
|
|
return _plane.scale(scale);
|
|
}
|
|
|
|
/*!
|
|
* Set the pad's location in the X and Y dimension using a 2D vector. The collision box will be moved by the same translation.
|
|
*
|
|
* @param translation x, y distance to translate the pad
|
|
*/
|
|
const glm::mat4& translate(const glm::vec2& translation)
|
|
{
|
|
_box.center({0.0f, 0.0f});
|
|
_box.move(translation);
|
|
return _plane.translate({translation.x, translation.y, 0.0f});
|
|
}
|
|
|
|
/*!
|
|
* Set the function that will run when a pad object is clicked.
|
|
*
|
|
* This example always keeps the state false and prints "Hello, World!" whenever the pad is clicked,
|
|
*
|
|
* start_button.on_state_change([&](bool state, int count){
|
|
* if (state) {
|
|
* std::ostringstream message;
|
|
* message << "Hello, " << state << " World! " << count;
|
|
* sb::Log::log(message);
|
|
* start_button.press(1);
|
|
* }});
|
|
*
|
|
* @param on_state_change reaction function which accepts a boolean as its first argument
|
|
*/
|
|
void on_state_change(Reaction reaction)
|
|
{
|
|
connection.on_state_change(reaction);
|
|
}
|
|
|
|
/*!
|
|
* Returns true if the point at given NDC coordinates collides with the pad's collision box. This only works properly if the
|
|
* Pad is flat in the z-dimension.
|
|
*
|
|
* @param position x, y NDC coordinates to check for collision
|
|
* @return true if the point is inside Pad::box, false otherwise
|
|
*/
|
|
bool collide(const glm::vec2& position, const glm::mat4& view, const glm::mat4& projection) const
|
|
{
|
|
/* Corners of the box */
|
|
std::vector<glm::vec3> corners;
|
|
|
|
/* Transform each of the corners into NDC coordinates */
|
|
for (const glm::vec2& vertex : {_box.sw(), _box.nw(), _box.ne(), _box.se()})
|
|
{
|
|
corners.push_back(sb::world_to_ndc(vertex, projection * view));
|
|
}
|
|
|
|
/* Create a new box using the NDC bottom-left corner */
|
|
glm::vec2 control = corners[0];
|
|
float width = glm::distance(corners[3], corners[0]);
|
|
float height = glm::distance(corners[1], corners[0]);
|
|
sb::Box transformed {control, {width, height}};
|
|
|
|
/* Collide the NDC box with the caller's coordinates */
|
|
return transformed.collide(position);
|
|
}
|
|
|
|
/*!
|
|
* Set the transformation uniform, bind a texture if any are attached, and draw the vertices. Build the full transformation matrix
|
|
* by combining the Pad object's transformation with the supplied projection and view matrices, and pass it to the shader.
|
|
*
|
|
* @param transformation_uniform transformation uniform ID
|
|
* @param view the view matrix for transforming from world space to camera space
|
|
* @param projection projection matrix for transforming from camera space to clip space
|
|
* @param texture_flag_uniform uniform ID for boolean enabling or disabling texture display
|
|
*/
|
|
void draw(GLuint transformation_uniform, glm::mat4 view, glm::mat4 projection,
|
|
std::optional<GLuint> texture_flag_uniform = std::nullopt)
|
|
{
|
|
if (_visible)
|
|
{
|
|
if (!_plane.textures().empty())
|
|
{
|
|
if (texture_flag_uniform.has_value())
|
|
{
|
|
glUniform1i(texture_flag_uniform.value(), true);
|
|
}
|
|
|
|
/* Determine texture index by checking the state of the pad and the amount of available textures. If there is more
|
|
* than 1 texture, the texture will correspond with the state. */
|
|
if (connection && _plane.textures().size() > 1)
|
|
{
|
|
texture_index = 1;
|
|
}
|
|
else
|
|
{
|
|
texture_index = 0;
|
|
}
|
|
_plane.texture(texture_index).bind();
|
|
}
|
|
else if (texture_flag_uniform.has_value())
|
|
{
|
|
glUniform1i(texture_flag_uniform.value(), false);
|
|
}
|
|
glm::mat4 mvp = projection * view * _plane.transformation();
|
|
glUniformMatrix4fv(transformation_uniform, 1, GL_FALSE, &mvp[0][0]);
|
|
_plane.enable();
|
|
glDrawArrays(GL_TRIANGLES, 0, _plane.attributes("position")->count());
|
|
_plane.disable();
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* Run the reaction function.
|
|
*
|
|
* @param args Arguments to pass to the reaction function
|
|
* @exception std::runtime_error if the pad is currently disabled
|
|
* @return Result of the reaction function if it returns a value, or void otherwise
|
|
*/
|
|
ReturnType press(Arguments... args)
|
|
{
|
|
if (!_enabled)
|
|
{
|
|
throw std::runtime_error(
|
|
"The pad cannot be pressed because it is currently disabled. Please check Pad::enabled before calling Pad::press.");
|
|
}
|
|
else
|
|
{
|
|
return connection.flip(args...);
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* @return the state of the pad
|
|
*/
|
|
bool pressed() const
|
|
{
|
|
return connection;
|
|
}
|
|
|
|
/*!
|
|
* This will not trigger the callback if any is set. To do that, use Pad::press(Arguments...).
|
|
*
|
|
* @param state true or false to set the pad state
|
|
*/
|
|
void state(bool pressed)
|
|
{
|
|
connection = pressed;
|
|
}
|
|
|
|
/*!
|
|
* @return size in bytes of the pad object's plane object
|
|
*/
|
|
std::size_t size() const
|
|
{
|
|
return _plane.size();
|
|
}
|
|
|
|
/*!
|
|
* By default, a pad object is enabled to accept input presses. If the pad is disabled, however, the press function will not
|
|
* be able to be used and will throw an exception. This function can be used both to check the state and to set the state.
|
|
*
|
|
* @param state Set to false to disable, true to enable, or omit to check the current state
|
|
* @return True if button is set to enabled
|
|
*/
|
|
bool enabled(std::optional<bool> state = std::nullopt)
|
|
{
|
|
if (state.has_value())
|
|
{
|
|
_enabled = state.value();
|
|
}
|
|
return _enabled;
|
|
}
|
|
|
|
/*!
|
|
* Use this function to prevent the draw function from running, which will prevent the pad object from being rendered. Note
|
|
* that this does not disable input. To do that, use Pad::enabled(bool)
|
|
*
|
|
* @param state Set to false to prevent the pad from being drawn, set to true to re-enable drawing
|
|
*/
|
|
bool visible(bool state)
|
|
{
|
|
_visible = state;
|
|
return _visible;
|
|
}
|
|
|
|
/*!
|
|
* @return the pad's visibility state
|
|
*/
|
|
bool visible() const
|
|
{
|
|
return _visible;
|
|
}
|
|
};
|
|
}
|