asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
virtualx-engine/servers/rendering/storage/variant_converters.h

322 lines
9.9 KiB
C++
Raw Blame History

/**************************************************************************/
/* variant_converters.h */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
#ifndef VARIANT_CONVERTERS_H
#define VARIANT_CONVERTERS_H
#include "core/error/error_macros.h"
#include "core/variant/array.h"
#include "core/variant/variant.h"
#include <initializer_list>
#include <type_traits>
template <typename T>
struct VariantConverterStd140 {
// Generic base template for all Vector2/3/4(i) classes.
static constexpr int Elements = T::AXIS_COUNT;
template <typename P>
static void convert(const T &p_v, P *p_write, bool p_compact) {
for (int i = 0; i < Elements; i++) {
p_write[i] = p_v[i];
}
}
};
template <>
struct VariantConverterStd140<float> {
static constexpr int Elements = 1;
template <typename P>
static void convert(float p_v, P *p_write, bool p_compact) {
p_write[0] = p_v;
}
};
template <>
struct VariantConverterStd140<int32_t> {
static constexpr int Elements = 1;
template <typename P>
static void convert(int32_t p_v, P *p_write, bool p_compact) {
p_write[0] = p_v;
}
};
template <>
struct VariantConverterStd140<uint32_t> {
static constexpr int Elements = 1;
template <typename P>
static void convert(uint32_t p_v, P *p_write, bool p_compact) {
p_write[0] = p_v;
}
};
template <>
struct VariantConverterStd140<Basis> {
static constexpr int Elements = 9;
template <typename P>
static void convert(const Basis &p_v, P *p_write, bool p_compact) {
// Basis can have compact 9 floats or std140 layout 12 floats.
int i = 0;
p_write[i++] = p_v.rows[0][0];
p_write[i++] = p_v.rows[1][0];
p_write[i++] = p_v.rows[2][0];
if (!p_compact) {
p_write[i++] = 0;
}
p_write[i++] = p_v.rows[0][1];
p_write[i++] = p_v.rows[1][1];
p_write[i++] = p_v.rows[2][1];
if (!p_compact) {
p_write[i++] = 0;
}
p_write[i++] = p_v.rows[0][2];
p_write[i++] = p_v.rows[1][2];
p_write[i++] = p_v.rows[2][2];
if (!p_compact) {
p_write[i++] = 0;
}
}
};
template <>
struct VariantConverterStd140<Transform2D> {
static constexpr int Elements = 12;
template <typename P>
static void convert(const Transform2D &p_v, P *p_write, bool p_compact) {
p_write[0] = p_v.columns[0][0];
p_write[1] = p_v.columns[0][1];
p_write[2] = 0;
p_write[3] = 0;
p_write[4] = p_v.columns[1][0];
p_write[5] = p_v.columns[1][1];
p_write[6] = 0;
p_write[7] = 0;
p_write[8] = p_v.columns[2][0];
p_write[9] = p_v.columns[2][1];
p_write[10] = 1;
p_write[11] = 0;
}
};
template <>
struct VariantConverterStd140<Transform3D> {
static constexpr int Elements = 16;
template <typename P>
static void convert(const Transform3D &p_v, P *p_write, bool p_compact) {
p_write[0] = p_v.basis.rows[0][0];
p_write[1] = p_v.basis.rows[1][0];
p_write[2] = p_v.basis.rows[2][0];
p_write[3] = 0;
p_write[4] = p_v.basis.rows[0][1];
p_write[5] = p_v.basis.rows[1][1];
p_write[6] = p_v.basis.rows[2][1];
p_write[7] = 0;
p_write[8] = p_v.basis.rows[0][2];
p_write[9] = p_v.basis.rows[1][2];
p_write[10] = p_v.basis.rows[2][2];
p_write[11] = 0;
p_write[12] = p_v.origin.x;
p_write[13] = p_v.origin.y;
p_write[14] = p_v.origin.z;
p_write[15] = 1;
}
};
template <>
struct VariantConverterStd140<Projection> {
static constexpr int Elements = 16;
template <typename P>
static void convert(const Projection &p_v, P *p_write, bool p_compact) {
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
p_write[i * 4 + j] = p_v.columns[i][j];
}
}
}
};
template <typename T, typename P>
T construct_vector(const std::initializer_list<P> &values) {
T vector{};
int index = 0;
for (P v : values) {
vector[index++] = v;
if (index >= T::AXIS_COUNT) {
break;
}
}
return vector;
}
// Compatibility converter, tries to convert certain Variant types into a Vector2/3/4(i).
template <typename T>
T convert_to_vector(const Variant &p_variant, bool p_linear_color = false) {
const Variant::Type type = p_variant.get_type();
if (type == Variant::QUATERNION) {
Quaternion quat = p_variant;
return construct_vector<T>({ quat.x, quat.y, quat.z, quat.w });
} else if (type == Variant::PLANE) {
Plane p = p_variant;
return construct_vector<T>({ p.normal.x, p.normal.y, p.normal.z, p.d });
} else if (type == Variant::RECT2 || type == Variant::RECT2I) {
Rect2 r = p_variant;
return construct_vector<T>({ r.position.x, r.position.y, r.size.x, r.size.y });
} else if (type == Variant::COLOR) {
Color c = p_variant;
if (p_linear_color) {
c = c.srgb_to_linear();
}
return construct_vector<T>({ c.r, c.g, c.b, c.a });
} else if (p_variant.is_array()) {
const Array &array = p_variant;
const int size = MIN(array.size(), T::AXIS_COUNT);
T vector{};
for (int i = 0; i < size; i++) {
vector[i] = array.get(i);
}
return vector;
}
return p_variant; // Default Variant conversion, covers all Vector2/3/4(i) types.
}
inline bool is_number_array(const Array &p_array) {
const int size = p_array.size();
for (int i = 0; i < size; i++) {
if (!p_array.get(i).is_num()) {
return false;
}
}
return true;
}
inline bool is_convertible_array(Variant::Type type) {
return type == Variant::ARRAY ||
type == Variant::PACKED_VECTOR2_ARRAY ||
type == Variant::PACKED_VECTOR3_ARRAY ||
type == Variant::PACKED_COLOR_ARRAY;
}
template <class, class = void>
struct is_vector_type : std::false_type {};
template <class T>
struct is_vector_type<T, std::void_t<decltype(T::AXIS_COUNT)>> : std::true_type {};
template <typename T, typename P>
void convert_item_std140(const T &p_item, P *p_write, bool p_compact = false) {
VariantConverterStd140<T>::template convert<P>(p_item, p_write, p_compact);
}
template <typename T, typename P>
Vector<P> convert_array_std140(const Variant &p_variant, [[maybe_unused]] bool p_linear_color = false) {
if (is_convertible_array(p_variant.get_type())) {
// Slow path, convert Variant arrays and some packed arrays manually into primitive types.
const Array &array = p_variant;
if (is_number_array(array)) {
// Already flattened and converted (or empty) array, usually coming from saved resources.
return p_variant;
}
const int items = array.size();
constexpr int elements = VariantConverterStd140<T>::Elements;
Vector<P> result;
result.resize(items * elements);
P *write = result.ptrw();
for (int i = 0; i < items; i++) {
const Variant &item = array.get(i);
P *offset = write + (i * elements);
if constexpr (is_vector_type<T>::value) {
const T &vec = convert_to_vector<T>(item, p_linear_color);
convert_item_std140<T, P>(vec, offset, true);
} else {
convert_item_std140<T, P>(item.operator T(), offset, true);
}
}
return result;
} else if (p_variant.is_array()) {
// Fast path, return the packed array directly.
return p_variant;
}
// Not an array type. Usually happens with uninitialized null shader resource parameters.
// Just return an empty array, uniforms will be default initialized later.
return Vector<P>();
}
template <typename T, typename From, typename To>
void write_array_std140(const Vector<From> &p_values, To *p_write, int p_array_size, int p_stride) {
constexpr int elements = VariantConverterStd140<T>::Elements;
const int src_count = p_values.size();
const int dst_count = elements * p_array_size;
const int stride_count = p_stride * p_array_size;
const From *read = p_values.ptr();
const T default_value{};
memset(p_write, 0, sizeof(To) * stride_count);
for (int i = 0, j = 0; i < dst_count; i += elements, j += p_stride) {
if (i + elements - 1 < src_count) {
// Only copy full items with all elements, no partial or missing data.
for (int e = 0; e < elements; e++) {
DEV_ASSERT(j + e < stride_count && i + e < src_count);
p_write[j + e] = read[i + e];
}
} else {
// If not enough source data was passed in, write default values.
convert_item_std140(default_value, p_write + j);
}
}
}
#endif // VARIANT_CONVERTERS_H
Reference in a new issue View git blame Copy permalink