From 6d4dbbd5cafce3435ca4c7aae020ba17e5a89b87 Mon Sep 17 00:00:00 2001
From: "Claudius \"keldu\" Holeksa" <mail@keldu.de>
Date: Wed, 15 Apr 2026 19:11:42 +0200
Subject: Dangling changes and added cross product

---
 modules/codec/c++/data.hpp        |  2 --
 modules/codec/c++/math.hpp        | 15 +++++++++++++++
 modules/codec/c++/schema_meta.hpp | 18 +++++++++---------
 3 files changed, 24 insertions(+), 11 deletions(-)

diff --git a/modules/codec/c++/data.hpp b/modules/codec/c++/data.hpp
index 6a796f5..217a53f 100644
--- a/modules/codec/c++/data.hpp
+++ b/modules/codec/c++/data.hpp
@@ -657,9 +657,7 @@ class data<schema::Array<T,Dim>, encode::Native> {
 			uint64_t s = 1;
 
 			for(uint64_t iter = 0; iter < Dim; ++iter){
-
 				auto& dim_iter = dims_.at(data<schema::UInt64>{iter});
-
 				s *= dim_iter.get();
 			}
 
diff --git a/modules/codec/c++/math.hpp b/modules/codec/c++/math.hpp
index 2ce8333..1d627e6 100644
--- a/modules/codec/c++/math.hpp
+++ b/modules/codec/c++/math.hpp
@@ -140,6 +140,21 @@ data<schema::Scalar<T>,Encoding> cross(
 	return cross_prod;
 }
 
+template<typename T, typename Encoding = FORSTIO_DEFAULT_DATA_ENCODING>
+data<schema::Vector<T,2u>,Encoding> cross(
+	const data<schema::Scalar<T>, Encoding> lh,
+	const data<schema::Vector<T,2u>, Encoding> rh
+){
+	data<schema::Vector<T,2u>, Encoding> cross_prod;
+
+	cross_prod.at({{0u}}) = lh.at({}) * rh.at({{1u}}) * -1;
+	cross_prod.at({{1u}}) = lh.at({}) * rh.at({{0u}});
+
+	return cross_prod;
+}
+
+
+
 template<typename T, typename Encoding = FORSTIO_DEFAULT_DATA_ENCODING>
 data<schema::Scalar<T>,Encoding> cos(
 	const data<schema::Scalar<T>,Encoding>& val
diff --git a/modules/codec/c++/schema_meta.hpp b/modules/codec/c++/schema_meta.hpp
index ff66bbb..efa486d 100644
--- a/modules/codec/c++/schema_meta.hpp
+++ b/modules/codec/c++/schema_meta.hpp
@@ -23,8 +23,8 @@ struct meta_schema<schema::Bool> {
 
 template<typename T, uint64_t N>
 struct meta_schema<schema::Primitive<T,N>> {
-	using MetaSchema = schema::Void;
 	using Schema = schema::Primitive<T,N>;
+	using MetaSchema = schema::Void;
 };
 
 template<typename TA, uint64_t NA, typename TB, uint64_t NB> 
@@ -35,38 +35,38 @@ struct meta_schema<schema::MixedPrecision<schema::Primitive<TA,NA>, schema::Prim
 
 template<typename T>
 struct meta_schema<schema::Ref<T>> {
-	using MetaSchema = schema::Void;
 	using Schema = schema::Ref<T>;
+	using MetaSchema = schema::Void;
 };
 
 template<typename Key, typename Value>
 struct meta_schema<schema::Map<Key,Value>> {
-	using MetaSchema = schema::Void;
 	using Schema = schema::Map<Key,Value>;
+	using MetaSchema = schema::Void;
 };	
 
 template<typename... T, string_literal... Lit>
 struct meta_schema<schema::Struct<schema::Member<T,Lit>...>> {
-	using MetaSchema = schema::Struct<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
 	using Schema = schema::Struct<schema::Member<T,Lit>...>;
+	using MetaSchema = schema::Struct<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
 };
 
 template<typename... T, string_literal... Lit>
 struct meta_schema<schema::Union<schema::Member<T,Lit>...>> {
-	using MetaSchema = schema::Union<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
 	using Schema = schema::Union<schema::Member<T,Lit>...>;
+	using MetaSchema = schema::Union<schema::Member<typename meta_schema<T>::MetaSchema,Lit>...>;
 };
 
 template<typename... T>
 struct meta_schema<schema::Tuple<T...>> {
-	using MetaSchema = schema::Tuple<typename meta_schema<T>::MetaSchema...>;
 	using Schema = schema::Tuple<T...>;
+	using MetaSchema = schema::Tuple<typename meta_schema<T>::MetaSchema...>;
 };
 
 template<>
 struct meta_schema<schema::String> {
-	using MetaSchema = schema::UInt64;
 	using Schema = schema::String;
+	using MetaSchema = schema::UInt64;
 };
 
 /**
@@ -75,14 +75,14 @@ struct meta_schema<schema::String> {
 template<typename T, uint64_t Dim>
 struct meta_schema<schema::Array<T,Dim>> {
 	// TODO Technically this should be a FixedArray of the inner meta schema, except when the inner meta schema is Void
-	using MetaSchema = schema::FixedArray<schema::UInt64,Dim>;
 	using Schema = schema::Array<T,Dim>;
+	using MetaSchema = schema::FixedArray<schema::UInt64,Dim>;
 };
 
 template<typename T, uint64_t... Dim>
 struct meta_schema<schema::FixedArray<T,Dim...>> {
 	// TODO Technically this should be a FixedArray of the inner meta schema, except when the inner meta schema is Void
-	using MetaSchema = schema::Void;
 	using Schema = schema::FixedArray<T,Dim...>;
+	using MetaSchema = schema::Void;
 };
 }
-- 
cgit v1.2.3