API Reference#

Native API#

Free functions declared in FlowerEvolver.hpp - the entry points src/bindings/native.cpp exposes to native (non-web) consumers.

Functions

fe::Flower makeFlower(int radius, int numLayers, float P, float bias) noexcept#

makes a flower.

Parameters:

radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias

Returns:

fe::Flower — .toJson() for the genome, .petals.image for the render

std::string make3DFlower(const fe::DNA &dna, int radius, int numLayers, float P, float bias, const std::string &flowerId, const std::string &flowerParams = "")#

Generates a 3D flower model as a glTF string.

Orchestrates the process of generating a stem, processing 2D layer images (finding contours, simplifying), generating 3D petal geometry for each layer, and assembling the final glTF data.

Parameters:

dna – The genetic information used to draw the layers.
radius – Initial radius parameter for fe::Petals constructor.
numLayers – Number of layers parameter for fe::Petals constructor and loop control.
P – P parameter for fe::Petals constructor.
bias – Bias parameter for fe::Petals constructor.
flowerId – A unique string identifier for this flower instance (used in group names).
flowerParams – std::string json fe::FlowerParameters for the 3d flower.

Returns:

A std::string containing the 3D model in GLTF format. Returns empty string on error. (GLTF is a text interchange format either way, so unlike the image functions below there’s no more “native” form to return instead.)

fe::Flower makePetals(int radius, int numLayers, float P, float bias) noexcept#

makes just the petals (no stem).

Parameters:

radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias

Returns:

fe::Flower — .toJson() for the genome, .petals.image for the render

fe::Flower makePetalLayer(int radius, int numLayers, float P, float bias, int layer) noexcept#

makes just the petal layer (no stem).

Parameters:

radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias
layer – int layer layer to paint

Returns:

fe::Flower — .toJson() for the genome, .petals.image for the render

fe::Flower makeStem(int radius, int numLayers, float P, float bias) noexcept#

makes just the stem (no petals).

Parameters:

radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias

Returns:

fe::Flower — .toJson() for the genome, .petals.image for the render

fe::Image drawFlower(const fe::DNA &dna, int radius, int numLayers, float P, float bias)#

renders the given genome.

Parameters:

dna – const fe::DNA& genome to render
radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias

Returns:

fe::Image the rendered image

fe::Image drawPetals(const fe::DNA &dna, int radius, int numLayers, float P, float bias)#

renders the given genome’s petals (no stem).

Parameters:

dna – const fe::DNA& genome to render
radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias

Returns:

fe::Image the rendered image

fe::Image drawPetalLayer(const fe::DNA &dna, int radius, int numLayers, float P, float bias, int layer)#

renders the given genome’s petal layer (no stem).

Parameters:

dna – const fe::DNA& genome to render (needs at least 2 genomes)
radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias
layer – int layer to render

Returns:

fe::Image the rendered image

fe::Flower reproduce(const fe::DNA &dna1, const fe::DNA &dna2, int radius, int numLayers, float P, float bias)#

makes a child from two genomes.

Parameters:

dna1 – const fe::DNA& father’s genome
dna2 – const fe::DNA& mother’s genome
radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias

Returns:

fe::Flower — .toJson() for the genome, .petals.image for the render

fe::Flower mutate(fe::DNA original, int radius, int numLayers, float P, float bias, float addNodeRate, float addConnRate, float removeConnRate, float perturbWeightsRate, float enableRate, float disableRate, float actTypeRate)#

mutates the given genome. original is taken by value and mutated in place internally - the caller’s own copy, if any, is left untouched.

Parameters:

original – fe::DNA genome to mutate
radius – int radius for the flower
numLayers – int how many layers it will have
P – float P parameter it controls how many petals the flower can have.
bias – float bias
addNodeRate – float rate to determine what it mutates
addConnRate – float rate to determine what it mutates
removeConnRate – float rate to determine what it mutates
perturbWeightsRate – float rate to determine what it mutates
enableRate – float rate to determine what it mutates
disableRate – float rate to determine what it mutates
actTypeRate – float rate to determine what it mutates

Returns:

fe::Flower — .toJson() for the genome, .petals.image for the render

fe::Stats getFlowerStats(const std::string &genome, float humidity, int temperature, int altitude, int terrainType)#

gets the flower stats from the DNA[0].

Parameters:

genome – const std::string& stringified flower.json — passed straight through to fe::Stats’s own (pre-existing) string-based constructor, so there’s no parse/round-trip to avoid here like there was in the functions above.
humidity – float 0.0 to 1.0
temperature – int temperature
altitude – int meters above sea
terrainType – int terrain type

Returns:

fe::Stats

fe namespace#

Covers fe::Math, fe::gltf, and fe::resources too.

namespace fe#

Typedefs

using Vec2f = fe::Vector2f #

using Vec2i = fe::Vector2i #

using Vec3f = Vec3<float>#

typedef signed char Int8#

typedef unsigned char Uint8#

typedef signed short Int16#

typedef unsigned short Uint16#

typedef signed int Int32#

typedef unsigned int Uint32#

typedef signed long long Int64#

typedef unsigned long long Uint64#

typedef Rect<int> IntRect#

typedef Rect<float> FloatRect#

typedef Vector2<int> Vector2i#

typedef Vector2<unsigned int> Vector2u#

typedef Vector2<float> Vector2f#

Functions

bool findContourMoore(const std::vector<std::uint8_t> &imageData, int width, int height, int alphaThreshold, std::vector<fe::Vec2i> &contourPoints)#

Finds the outer boundary contour of the first encountered opaque component using the Moore-Neighbor tracing algorithm.

Scans the image to find a starting opaque pixel on a boundary (adjacent to a transparent pixel). Then, traces the boundary clockwise until returning to the start. Only finds one contour.

Parameters:

imageData – Raw RGBA pixel data (row-major).
width – Image width in pixels.
height – Image height in pixels.
alphaThreshold – Alpha value (0-255) above which a pixel is considered opaque.
contourPoints – Output vector where the found contour points (fe::Vec2i) will be stored in clockwise order. The vector is cleared first.

Returns:

true if a contour with at least 3 points was found, false otherwise.

void douglasPeucker(const std::vector<fe::Vec2i> &points, float epsilonSq, std::vector<fe::Vec2i> &result)#

Simplifies a 2D polyline (contour) using the Douglas-Peucker algorithm.

Reduces the number of points in a curve composed of line segments, while keeping the simplified curve within a specified distance (epsilon) of the original.

Parameters:

points – Input vector of 2D integer points representing the original contour.
epsilonSq – The square of the maximum distance (tolerance) allowed between the original curve and the simplified curve. Using squared distance avoids costly square root operations during comparisons.
result – Output vector where the simplified points will be stored. The vector will typically include the first and last points of the input segment. The vector is NOT cleared by this function; points are appended.

void simplifyContour(const std::vector<fe::Vec2i> &points, float epsilon, std::vector<fe::Vec2i> &result)#

Overload for douglasPeucker that handles the initial call and setup.

This version takes the full contour, adds the start and end points, and calls the recursive helper function. Assumes a closed contour, but works on open ones too.

Parameters:

points – Input vector of 2D integer points representing the original contour.
epsilon – The maximum distance (tolerance) allowed. Will be squared internally.
result – Output vector where the simplified points will be stored. Cleared first.

bool generateEllipticalCylinderSegment(fe::gltf::Mesh &meshPart, const fe::Vec3f &bottomCenter, const fe::Vec3f &topCenter, float bottomRadiusX, float bottomRadiusZ, float topRadiusX, float topRadiusZ, int radialSegments, bool addBottomCap = false, bool addTopCap = false, bool generateUVs = true, std::optional<fe::Vec3f> uVecOverride = std::nullopt)#

Generates a single segment of a cylinder with potentially elliptical and tapered cross-sections.

Creates the wall and optionally top/bottom caps. UVs are generated for the wall (V along axis, U wraps). Cap UVs are planar.

Parameters:

meshPart – fe::gltf::Mesh& The mesh part to add geometry to.
bottomCenter – const fe::Vec3f& Center of the bottom elliptical face.
topCenter – const fe::Vec3f& Center of the top elliptical face.
bottomRadiusX – float Radius of the bottom ellipse along its local X-axis (defined by u_vec).
bottomRadiusZ – float Radius of the bottom ellipse along its local Z-axis (defined by v_vec).
topRadiusX – float Radius of the top ellipse along its local X-axis.
topRadiusZ – float Radius of the top ellipse along its local Z-axis.
radialSegments – int Number of segments around the circumference. Must be >= 3.
addBottomCap – bool If true, a bottom cap will be generated.
addTopCap – bool If true, a top cap will be generated.
generateUVs – bool If true, UV coordinates (TEXCOORD_0) will be generated.
uVecOverride – std::optional<fe::Vec3f> Optional: provide a specific u_vec for orientation. If nullopt, it will be calculated.

Returns:

bool True if geometry was successfully generated.

bool generateSegmentedCylinder(fe::gltf::Mesh &meshPart, const std::vector<CylinderSegment> &profilePoints, int radialSegments = 12, bool addBaseCap = false, bool addTipCap = false, bool generateUVs = false)#

Generates a segmented cylinder.

Parameters:

meshPart – fe::gltf::Mesh& The mesh part to add a segmented cylinder to.
profilePoints – const std::vector<CylinderSegment>& A series of nodes defining the center, radii, and orientation along the filament’s length. Must have at least 2 points to form a segment.
radialSegments – int Number of segments around the circumference.
addBaseCap – bool If true, the very first segment gets a bottom cap.
addTipCap – bool If true, the very last segment gets a top cap.
generateUVs – bool If true, generate UVs.

Returns:

bool True if geometry was successfully generated.

bool generateStigma(fe::gltf::Mesh &meshPart, const fe::CylinderSegment &filamentTopNode, const fe::FlowerParameters &params, int radialSegments, bool generateUVs = false)#

Generates the stigma (tip of the pistil) based on the filament’s top dimensions.

Parameters:

meshPart – fe::gltf::Mesh& The mesh part to add stigma geometry to.
filamentTopNode – const fe::CylinderSegment& The last node of the pistil filament, providing the connection point and initial radii for the stigma.
params – const fe::FlowerParameters& General geometry parameters for reference (e.g., for scaling factors).
radialSegments – int Number of segments around the circumference.
generateUVs – bool If true, generate UV coordinates.

Returns:

bool True if geometry was successfully generated.

void generatePistil(fe::gltf::Scene &scene, const fe::Vec3f &position, const fe::FlowerParameters &params, int pistil_filament_mat_idx, int pistil_stigma_max_idx, int pistilID)#

Generates a pistil structure and adds it to a GLTF scene.

Parameters:

scene – A reference to the fe::gltf::Scene data where the generated pistil will be incorporated.
position – A 3D vector that specifies the position within the scene where the pistil should be generated.
params – Geometry parameters that dictate the design details such as shape, size, and resolution of the pistil.
pistil_filament_mat_idx – Material index for the filament, which defines its color and texture properties.
pistil_stigma_max_idx – Material index for the stigma, which determines its visual style.
pistilID – A unique identifier for the pistil instance, useful for tracking or referencing within the scene.

void generateStamen(fe::gltf::Scene &scene, const fe::Vec3f &position, const fe::FlowerParameters &params, int stamen_filament_mat_idx, int stamen_anther_mat_idx, int stamenID)#

Generates a stamen structure and adds it to a GLTF scene.

Parameters:

scene – Reference to the fe::gltf::Scene data where the generated stamen will be added.
position – A 3D vector specifying the position in the scene where the stamen should be generated.
params – Geometry parameters that dictate the size, shape, and resolution of the stamen parts.
stamen_filament_mat_idx – Material index for the filament (the stalk supporting the anther), determining its color and texture.
stamen_anther_mat_idx – Material index for the anther (the pollen-bearing part of the stamen), determining its color and texture.
stamenID – An identifier for the stamen, useful for tracking or referencing this particular instance.

void generateStem(fe::gltf::Scene &scene, const fe::FlowerParameters &params, int stemMaterialIndex)#

Generates vertices, normals, and triangle indices for a cylindrical stem, creating a distinct GltfMeshPart for it.

Creates geometry for a cylinder oriented along the Y-axis, with closed top and bottom caps. Adds the generated GltfMeshPart to the provided GltfSceneData. Stem geometry typically uses a base color material and does not require texture coordinates.

Parameters:

scene – fe::gltf::Scene& The fe::gltf::Scene object to add the new stem mesh part to.
params – const fe::FlowerParameters& The FlowerParameters struct containing stemHeight, stemRadius, and stemSegments.
stemMaterialIndex – int The index of the pre-defined stem material in scene.materials.

void generatePetalLayer(fe::gltf::Scene &scene, const std::vector<fe::Vec2i> &simplifiedContour, const fe::Image &petalLayerTexture, int layerIndex, const fe::Vec3f &position, const fe::FlowerParameters &params)#

Generates vertices, normals, texcoords, and triangle indices for one petal layer, creating a distinct fe::gltf::Mesh for it with its own texture and material.

Creates the geometry based on the simplified contour, fixed inner radii, and other parameters. Adds the generated fe::gltf::Mesh to the provided fe::gltf::Scene.

Parameters:

scene – fe::gltf::Scene& The GltfSceneData object to add the new petal mesh part to.
simplifiedContour – const std::vector<fe::Vec2i>& The vector of 2D points representing the simplified outer shape.
petalLayerTexture – const fe::Image& The raw image data for this specific petal layer’s texture.
layerIndex – int The index of the current layer (used for naming).
position – const fe::Vec3f& The position for this layer before offsets.
params – const fe::FlowerParameters& The FlowerParameters struct containing all petal shape and scale parameters.

inline int dot(const fe::Vec2i &a, const fe::Vec2i &b)#

Dot product for 2D integer vectors.

Parameters:

a – const Vec2f&
b – const Vec2f&

Returns:

int

float pointLineSegmentDistanceSq(const fe::Vec2i &p, const fe::Vec2i &a, const fe::Vec2i &b)#

Calculate the squared perpendicular distance from a point p to the line segment defined by a and b.

Calculate the projection of ap onto ab Parameter t = dot(ap, ab) / lengthSq(ab) This indicates where the projection falls relative to the segment t < 0: Projection is before point a t > 1: Projection is after point b 0 <= t <= 1: Projection is within the segment [a, b]

Parameters:

p – const Vec2f&
a – const Vec2f&
b – const Vec2f&

Returns:

float

template<typename T> inline Vec3<T> operator+(Vec3<T> lhs, const Vec3<T> &rhs) noexcept#

template<typename T> inline Vec3<T> operator-(Vec3<T> lhs, const Vec3<T> &rhs) noexcept#

template<typename T> inline Vec3<T> operator*(Vec3<T> lhs, T scalar) noexcept#

template<typename T> inline Vec3<T> operator*(T scalar, Vec3<T> rhs) noexcept#

template<typename T> inline Vec3<T> operator/(Vec3<T> lhs, T scalar) noexcept#

inline bool isBase64(unsigned char c)#

checks if is a base64 char

Parameters:: c – unsigned char
Returns:: bool

std::string encodeToBase64(const std::vector<std::uint8_t> &data)#

encodes an image to base64

Parameters:: data – std::vector<std::uint8_t>&
Returns:: std::string base64 image

std::vector<std::uint8_t> encodeImageToPngInMemory(const Image &image)#

Encodes raw image data into a PNG byte stream in memory.

Parameters:: image – The Image object containing raw pixel data. expected RBGA
Returns:: A std::vector<std::uint8_t> containing the PNG-encoded data. Returns an empty vector if encoding fails or the input image is invalid.

int getTimesDivisibleBy(int val, int divisor) noexcept#

Determines the number of times a number can be divided by a given divisor until it is <= 1.

Parameters:

val – [in] The number to be divided.
divisor – [in] The divisor applied on each iteration.

Returns:

The count of divisions performed until the value is ≤ 1.

void drawLayer(Petals &petals, EvoAI::Genome &g, int layer, bool applyLayeredRadiusScaling = true) noexcept#

will draw the layer of a petal,

Parameters:

petals – [in] Petals
g – [in] a cppn EvoAI::Genome with 4 inputs 4 outputs
layer – [in] the layer to draw
applyLayeredRadiusScaling – [in] it will divide the radius / 2.0 from petals.numLayers to layer

void draw(Petals::Type t, Petals &petals, EvoAI::Genome &g) noexcept#

will draw what Petals::Type is

Parameters:

t – [in] Petals::Type
petals – [in] Petals
g – [in] a cppn EvoAI::Genome with 4 inputs 4 outputs

class Color#

#include <Color.hpp>

Utility class for manipulating RGBA colors.

fe::Color is a simple color class composed of 4 components:

Red
Green
Blue
Alpha (opacity)

Each component is a public member, an unsigned integer in the range [0, 255]. Thus, colors can be constructed and manipulated very easily:

fe::Color color(255, 0, 0); // red
color.r = 0;                // make it black
color.b = 128;              // make it dark blue

The fourth component of colors, named “alpha”, represents the opacity of the color. A color with an alpha value of 255 will be fully opaque, while an alpha value of 0 will make a color fully transparent, whatever the value of the other components is.

The most common colors are already defined as static variables:

fe::Color black       = fe::Color::Black;
fe::Color white       = fe::Color::White;
fe::Color red         = fe::Color::Red;
fe::Color green       = fe::Color::Green;
fe::Color blue        = fe::Color::Blue;
fe::Color yellow      = fe::Color::Yellow;
fe::Color magenta     = fe::Color::Magenta;
fe::Color cyan        = fe::Color::Cyan;
fe::Color transparent = fe::Color::Transparent;

Colors can also be added and modulated (multiplied) using the overloaded operators + and *.

Public Functions

Color()#

Default constructor.

Constructs an opaque black color. It is equivalent to fe::Color(0, 0, 0, 255).

Color(Uint8 red, Uint8 green, Uint8 blue, Uint8 alpha = 255)#

Construct the color from its 4 RGBA components.

Parameters:

red – Red component (in the range [0, 255])
green – Green component (in the range [0, 255])
blue – Blue component (in the range [0, 255])
alpha – Alpha (opacity) component (in the range [0, 255])

explicit Color(Uint32 color)#

Construct the color from 32-bit unsigned integer.

Parameters:: color – Number containing the RGBA components (in that order)

Uint32 toInteger() const#

Retrieve the color as a 32-bit unsigned integer.

Returns:: Color represented as a 32-bit unsigned integer

Public Members

Uint8 r#: Red component.

Uint8 g#: Green component.

Uint8 b#: Blue component.

Uint8 a#: Alpha (opacity) component.

Public Static Attributes

static const Color Black#: Black predefined color.

static const Color White#: White predefined color.

static const Color Red#: Red predefined color.

static const Color Green#: Green predefined color.

static const Color Blue#: Blue predefined color.

static const Color Yellow#: Yellow predefined color.

static const Color Magenta#: Magenta predefined color.

static const Color Cyan#: Cyan predefined color.

static const Color Transparent#: Transparent (black) predefined color.

bool operator==(const Color &left, const Color &right)#

Overload of the == operator.

This operator compares two colors and check if they are equal.

Parameters:

left – Left operand
right – Right operand

Returns:

True if colors are equal, false if they are different

bool operator!=(const Color &left, const Color &right)#

Overload of the != operator.

This operator compares two colors and check if they are different.

Parameters:

left – Left operand
right – Right operand

Returns:

True if colors are different, false if they are equal

Color operator+(const Color &left, const Color &right)#

Overload of the binary + operator.

This operator returns the component-wise sum of two colors. Components that exceed 255 are clamped to 255.

Parameters:

left – Left operand
right – Right operand

Returns:

Result of left + right

Color operator-(const Color &left, const Color &right)#

Overload of the binary - operator.

This operator returns the component-wise subtraction of two colors. Components below 0 are clamped to 0.

Parameters:

left – Left operand
right – Right operand

Returns:

Result of left - right

Color operator*(const Color &left, const Color &right)#

Overload of the binary * operator.

This operator returns the component-wise multiplication (also called “modulation”) of two colors. Components are then divided by 255 so that the result is still in the range [0, 255].

Parameters:

left – Left operand
right – Right operand

Returns:

Result of left * right

Color &operator+=(Color &left, const Color &right)#

Overload of the binary += operator.

This operator computes the component-wise sum of two colors, and assigns the result to the left operand. Components that exceed 255 are clamped to 255.

Parameters:

left – Left operand
right – Right operand

Returns:

Reference to left

Color &operator-=(Color &left, const Color &right)#

Overload of the binary -= operator.

This operator computes the component-wise subtraction of two colors, and assigns the result to the left operand. Components below 0 are clamped to 0.

Parameters:

left – Left operand
right – Right operand

Returns:

Reference to left

Color &operator*=(Color &left, const Color &right)#

Overload of the binary *= operator.

This operator returns the component-wise multiplication (also called “modulation”) of two colors, and assigns the result to the left operand. Components are then divided by 255 so that the result is still in the range [0, 255].

Parameters:

left – Left operand
right – Right operand

Returns:

Reference to left

struct CylinderSegment#

#include <meshGenerator.hpp>

storage for filament info.

Public Functions

inline CylinderSegment(const fe::Vec3f &cnt, float rdX, float rdZ, std::optional<fe::Vec3f> uVecOrient = std::nullopt) noexcept#

Public Members

fe::Vec3f center#

float radiusX#

float radiusZ#

std::optional<fe::Vec3f> uVecOrientation#

class DNA#

#include <DNA.hpp>

DNA Component.

Public Functions

DNA()#: default constructor

DNA(DNA &&dna)#: move constructor

DNA(const DNA &dna)#: copy constructor

DNA(JsonBox::Object o)#

load a JsonBox::Object containing a DNA

Parameters:: o – [in] JsonBox::Object

JsonBox::Value toJson() const noexcept#

converts to JsonBox::Value

Returns:: JsonBox::Value

DNA(std::vector<EvoAI::Genome> &&g)#

transfer a std::vector of genomes

Parameters:: g – [in] std::vector<EvoAI::Genome>&&

void setFitness(double fit) noexcept#

sets the same fitness for all the genomes in DNA

Parameters:: fit – [in] double fitness

double getFitness() noexcept#

gets fitness from genome[0]

Returns:: double if genomes is empty returns 0.0d

DNA &add(EvoAI::Genome &&g) noexcept#

adds a Genome

Parameters:: g – EvoAI::Genome
Returns:: DNA&

DNA &add(const EvoAI::Genome &g) noexcept#

adds a Genome

Parameters:: g – const EvoAI::Genome&
Returns:: DNA&

bool remove(EvoAI::Genome *g) noexcept#

removes a EvoAI::Genome from DNA.

Parameters:: g – [in] EvoAI::Genome* genome to remove
Returns:: bool true if removed

void mutate(const MutationRates &mr) noexcept#

mutates all genomes

Parameters:: mr – [in] Mutation Rates

std::size_t size() const noexcept#

get number of genomes

Returns:: std::size_t number of genomes

void clear() noexcept#: clears the DNA

~DNA() = default#

void operator=(const DNA &rhs) noexcept#

clears the DNA and copies the other

Parameters:: rhs – [in] const DNA&

void operator=(DNA &&rhs) noexcept#: moves rhs into this.

EvoAI::Genome &operator[](const std::size_t &index) noexcept#

direct access to genomes

Parameters:: index – [in] std::size_t
Returns:: EvoAI::Genome&

const EvoAI::Genome &operator[](const std::size_t &index) const noexcept#

direct access to genomes

Parameters:: index – [in] std::size_t
Returns:: const EvoAI::Genome&

Public Static Functions

static DNA reproduce(DNA &dna1, DNA &dna2)#

makes a new DNA from two others(they need to have the same number of genomes).

Parameters:

dna1 – [in] DNA&
dna2 – [in] DNA&

Throws:

std::runtime_error – if number of genomes are not the same.

Returns:

DNA

static double distance(DNA &dna1, DNA &dna2)#

calculates the distance between DNA(they need to have the same number of genomes).

Parameters:

dna1 – [in] DNA&
dna2 – [in] DNA&

Throws:

std::runtime_error – if number of genomes are not the same.

Returns:

double distance between two DNA

struct Flower#

#include <Flower.hpp>

Flower struct.

Public Functions

Flower()#: default constructor

Flower(const fe::Vector2f &pos, int radius, int numLayers, float P, float bias)#

constructor to use when creating a random flower.

Parameters:

pos – [in] position
radius – [in] radius
numLayers – [in] number of layers
P – [in] P
bias – [in] bias

Flower(const fe::Vector2f &pos, int radius, int numLayers, float P, float bias, const Petals::Type &type)#

constructor to use when creating a random flower.

Parameters:

pos – [in] position
radius – [in] radius
numLayers – [in] number of layers
P – [in] P
bias – [in] bias
type – [in] Petals::Type

Flower(const fe::Vector2f &pos, int radius, int numLayers, float P, float bias, DNA &&dna)#

constructor to use when creating a child flower.

Parameters:

pos – [in] position
radius – [in] radius
numLayers – [in] number of layers
P – [in] P
bias – [in] bias
dna – [in] fe::DNA to use to make this flower

Flower(const fe::Vector2f &pos, int radius, int numLayers, float P, float bias, DNA &&dna, const Petals::Type &type)#

constructor to use when creating a child flower.

Parameters:

pos – [in] position
radius – [in] radius
numLayers – [in] number of layers
P – [in] P
bias – [in] bias
dna – [in] fe::DNA to use to make this flower
type – [in] Petals::Type

Flower(const Flower &rhs) noexcept#: copy constructor

Flower(Flower &&rhs) noexcept#: move constructor

Flower(JsonBox::Object o)#

load a JsonBox::Object with [“Flower”]

Parameters:: o – [in] JsonBox::Object

JsonBox::Value toJson() const noexcept#

converts Flower to JsonBox::Value

Returns:: JsonBox::Value

void operator=(Flower &&rhs) noexcept#

void operator=(const Flower &rhs) noexcept#

Public Members

DNA dna#

Petals petals#

struct FlowerParameters#

#include <FlowerParameters.hpp>

creation parameters for 3d flowers

Public Functions

FlowerParameters() noexcept#: default constructor

FlowerParameters(JsonBox::Object o)#

deserializable constructor

Parameters:: o – JsonBox::Object

JsonBox::Object toJson() const noexcept#

serializes the parameters

Returns:: JsonBox::Object

Public Members

int sex#

bool useNormals#

bool useEmissive#

float stemHeight#

float stemRadius#

int stemSegments#

float pistilStyleHeight#

float pistilStyleRadius#

int pistilStigmaRadialSegments#

float pistilStigmaHeight#

float pistilStigmaMaxWidthFactor#

float pistilStigmaTipNarrowFactor#

int stamenCount#

int stamenFilamentRadialSegments#

float stamenFilamentHeight#

float stamenFilamentRadius#

int stamenAntherRadialSegments#

float stamenAntherHeight#

float petalScaleFactor#

float connectionRadiusPx#

float droopStartRadiusPx#

float peakHeightOffset#

float petalDroopFactor#

float layerVerticalSpacing#

float connectionVerticalOffset#

float contourSimplificationTolerance#

int alphaThreshold#

struct Image#

#include <Image.hpp>

simple Image to replace the one from sfml for emscripten.

Public Functions

Image() noexcept#: default constructor

void create(std::size_t width, std::size_t height, const fe::Color &color) noexcept#

allocates the memory needed for the image

Parameters:

width – std::size_t width of the image
height – std::size_t height of the image
color – default color to set

void setPixel(const fe::Vector2f &pos, const fe::Color &color) noexcept#

sets the pixel color

Parameters:

pos – const fe::Vector2f& position
color – const fe::Color& color

fe::Vector2f getSize() const noexcept#

gets image size

Returns:: fe::Vector2f

void setPixel(std::size_t x, std::size_t y, const fe::Color &color) noexcept#

sets the pixel color

Parameters:

x – std::size_t x position
y – std::size_t y position
color – const fe::Color& color

inline fe::Color getPixel(std::size_t x, std::size_t y) const noexcept#

gets the pixel color

Parameters:

x – std::size_t x position
y – std::size_t y position

Returns:

fe::Color

Public Members

std::vector<std::uint8_t> imageData#

std::size_t mWidth#

std::size_t mHeight#

struct MutationRates#

#include <DNA.hpp>

Mutation Rates.

Public Functions

MutationRates()#

default constructor default values

addNodeRate : 0.2
addConnRate : 0.3
removeConnRate : 0.2
perturbWeightsRate : 0.6
enableRate : 0.35
disableRate : 0.3
actTypeRate : 0.4

MutationRates(float addNodeRate, float addConnRate, float removeConnRate, float perturbWeightsRate, float enableRate, float disableRate, float actTypeRate)#

constructor with all the parameters

Parameters:

addNodeRate – [in] rate to add nodes
addConnRate – [in] rate to add connections
removeConnRate – [in] rate to remove connections
perturbWeightsRate – [in] rate to change weights of a connection
enableRate – [in] rate to enable a dormant gene
disableRate – [in] rate to disable a enabled gene
actTypeRate – [in] rate to change activation function of a neuronGene

MutationRates(JsonBox::Object o)#

load a JsonBox::Object

Parameters:: o – [in] JsonBox::Object

JsonBox::Value toJson() const noexcept#

converts to JsonBox::Value

Returns:: JsonBox::Value

Public Members

float addNodeRate#

float addConnRate#

float removeConnRate#

float perturbWeightsRate#

float enableRate#

float disableRate#

float actTypeRate#

struct Petals#

#include <Petals.hpp>

Petals component.

Petals p(64,3,6.0,1.0);
// genome is a CPPN and has 4 inputs and 4 outputs
draw(Petals::Type::TrunkAndPetals, p, genomes[index]);

Public Types

enum class Type : int#

Type enum for draw function.

Values:

enumerator Trunk#

enumerator Petals#

enumerator TrunkAndPetals#

Public Functions

Petals() noexcept#: Default constructor.

Petals(int r, int nLayers, float P, float bias)#

constructor

Parameters:

r – int radius in pixels
nLayers – int number of Layers
P – float parameter for NN
bias – flat bias for NN

Petals(JsonBox::Object o)#

load JsonBox::Object

Parameters:: o – JsonBox::Object

Petals(const Petals &rhs) noexcept#: copy constructor

Petals(Petals &&rhs) noexcept#: move constructor

JsonBox::Value toJson() const noexcept#

converts the object to JsonBox::Value

Returns:: JsonBox::Value

void operator=(const Petals &rhs) noexcept#

void operator=(Petals &&rhs) noexcept#

Public Members

fe::Image image#

float bias#

float P#

int radius#

int numLayers#

bool hasBloom#

template<typename T> class Rect#

#include <Rect.hpp>

Utility class for manipulating 2D axis aligned rectangles.

A rectangle is defined by its top-left corner and its size. It is a very simple class defined for convenience, so its member variables (left, top, width and height) are public and can be accessed directly, just like the vector classes (Vector2 and Vector3).

To keep things simple, fe::Rect doesn’t define functions to emulate the properties that are not directly members (such as right, bottom, center, etc.), it rather only provides intersection functions.

fe::Rect uses the usual rules for its boundaries:

The left and top edges are included in the rectangle’s area
The right (left + width) and bottom (top + height) edges are excluded from the rectangle’s area

This means that fe::IntRect(0, 0, 1, 1) and fe::IntRect(1, 1, 1, 1) don’t intersect.

fe::Rect is a template and may be used with any numeric type, but for simplicity the instantiations used by SFML are typedef’d:

fe::Rect<int> is fe::IntRect
fe::Rect<float> is fe::FloatRect

So that you don’t have to care about the template syntax.

Usage example:

// Define a rectangle, located at (0, 0) with a size of 20x5
fe::IntRect r1(0, 0, 20, 5);

// Define another rectangle, located at (4, 2) with a size of 18x10
fe::Vector2i position(4, 2);
fe::Vector2i size(18, 10);
fe::IntRect r2(position, size);

// Test intersections with the point (3, 1)
bool b1 = r1.contains(3, 1); // true
bool b2 = r2.contains(3, 1); // false

// Test the intersection between r1 and r2
fe::IntRect result;
bool b3 = r1.intersects(r2, result); // true
// result == (4, 2, 16, 3)

Public Functions

Rect()#

Default constructor.

Creates an empty rectangle (it is equivalent to calling Rect(0, 0, 0, 0)).

Rect(T rectLeft, T rectTop, T rectWidth, T rectHeight)#

Construct the rectangle from its coordinates.

Be careful, the last two parameters are the width and height, not the right and bottom coordinates!

Parameters:

rectLeft – Left coordinate of the rectangle
rectTop – Top coordinate of the rectangle
rectWidth – Width of the rectangle
rectHeight – Height of the rectangle

Rect(const Vector2<T> &position, const Vector2<T> &size)#

Construct the rectangle from position and size.

Be careful, the last parameter is the size, not the bottom-right corner!

Parameters:

position – Position of the top-left corner of the rectangle
size – Size of the rectangle

template<typename U> explicit Rect(const Rect<U> &rectangle)#

Construct the rectangle from another type of rectangle.

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.

Parameters:: rectangle – Rectangle to convert

bool contains(T x, T y) const#

Check if a point is inside the rectangle’s area.

This check is non-inclusive. If the point lies on the edge of the rectangle, this function will return false.

See also

intersects

Parameters:

x – X coordinate of the point to test
y – Y coordinate of the point to test

Returns:

True if the point is inside, false otherwise

bool contains(const Vector2<T> &point) const#

Check if a point is inside the rectangle’s area.

This check is non-inclusive. If the point lies on the edge of the rectangle, this function will return false.

See also

intersects

Parameters:: point – Point to test
Returns:: True if the point is inside, false otherwise

bool intersects(const Rect<T> &rectangle) const#

Check the intersection between two rectangles.

See also

contains

Parameters:: rectangle – Rectangle to test
Returns:: True if rectangles overlap, false otherwise

bool intersects(const Rect<T> &rectangle, Rect<T> &intersection) const#

Check the intersection between two rectangles.

This overload returns the overlapped rectangle in the intersection parameter.

See also

contains

Parameters:

rectangle – Rectangle to test
intersection – Rectangle to be filled with the intersection

Returns:

True if rectangles overlap, false otherwise

fe::Vector2<T> getPosition() const#

Get the position of the rectangle’s top-left corner.

See also

getSize

Returns:: Position of rectangle

fe::Vector2<T> getSize() const#

Get the size of the rectangle.

See also

getPosition

Returns:: Size of rectangle

Public Members

T left#: Left coordinate of the rectangle.

T top#: Top coordinate of the rectangle.

T width#: Width of the rectangle.

T height#: Height of the rectangle.

template<typename T> bool operator==(const Rect<T> &left, const Rect<T> &right)#

Overload of binary operator ==.

This operator compares strict equality between two rectangles.

Parameters:

left – Left operand (a rectangle)
right – Right operand (a rectangle)

Returns:

True if left is equal to right

template<typename T> bool operator!=(const Rect<T> &left, const Rect<T> &right)#

Overload of binary operator !=.

This operator compares strict difference between two rectangles.

Parameters:

left – Left operand (a rectangle)
right – Right operand (a rectangle)

Returns:

True if left is not equal to right

struct Stats#

#include <Stats.hpp>

storage class for stats

Public Types

enum Sex#

enum for Sex

Values:

enumerator Male#

enumerator Female#

enumerator Both#

Public Functions

Stats(const std::string &genome, float humidity, int temperature, int altitude, int terrainType)#

constructor to build stats from the flower genome.

Parameters:

genome – const std::string& stringified flower.json
humidity – float 0.0 to 1.0
temperature – int temperature
altitude – int meters above sea
terrainType – int terrain type

JsonBox::Object toJson() const noexcept#

convert to json

Returns:: JsonBox::Object

Public Members

Sex sex#

int health#

int stamina#

int minTemperature#

int maxTemperature#

int maturationPeriod#

double toxicityRate#

Effects effects#

struct Effects#

#include <Stats.hpp>

storage class for Effects

Public Functions

Effects()#

Public Members

double vitality#

double agility#

double intelligence#

double strength#

double luck#

template<typename T> struct Vec3#

#include <Vec.hpp>

A templated 3D vector class for mathematical and geometric computations.

Provides basic operations for 3D vector manipulation, such as normalization and calculating vector length and length squared. It is templated to support various numerical types, such as float, double, or int.

Template Parameters:: T – The type of the vector components (e.g., float, double, int).

Public Functions

Vec3()#: Default constructor initializes the vector to (0, 0, 0).

Vec3(T x_, T y_, T z_)#

Parameterized constructor initializes the vector with specific values.

Parameters:

x_ – The x-component of the vector.
y_ – The y-component of the vector.
z_ – The z-component of the vector.

void normalize()#

Normalizes the vector to have a magnitude of 1.

If the vector is zero or its magnitude is very small, all components will be set to 0 to avoid division by zero.

T lengthSquared() const#

Computes the squared length of the vector.

Returns:: The squared length of the vector.

T length() const#

Computes the actual length (magnitude) of the vector.

The length is calculated as the square root of the sum of the squares of the components: sqrt(x*x + y*y + z*z).

Returns:: The length of the vector.

T dot(const Vec3<T> &other) const#

Computes the dot product of this vector with another vector.

Parameters:: other – const Vec3<T>& The other vector.
Returns:: The dot product (a scalar value).

Vec3<T> cross(const Vec3<T> &other) const#

Computes the cross product of this vector with another vector.

Parameters:: other – const Vec3<T>& The other vector.
Returns:: A new Vec3<T> representing the cross product (this x other).

Vec3<T> &operator+=(const Vec3<T> &rhs)#

Vec3<T> &operator-=(const Vec3<T> &rhs)#

Vec3<T> &operator*=(T scalar)#

Vec3<T> &operator/=(T scalar)#

Vec3<T> operator-() const#

Public Members

T x#

T y#

T z#

struct Vec4f#

#include <Vec.hpp>

simple vec4 for material colors

Public Functions

inline Vec4f(float _r, float _g, float _b, float _a)#

Public Members

float r = {0.0}#

float g = {0.0}#

float b = {0.0}#

float a = {0.0}#

template<typename T> class Vector2#

#include <Vector2.hpp>

Utility template class for manipulating 2-dimensional vectors.

fe::Vector2 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 (fe::Vector2<T>), the most common specializations have special typedefs:

fe::Vector2<float> is fe::Vector2f
fe::Vector2<int> is fe::Vector2i
fe::Vector2<unsigned int> is fe::Vector2u

The fe::Vector2 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:

fe::Vector2f v1(16.5f, 24.f);
v1.x = 18.2f;
float y = v1.y;

fe::Vector2f v2 = v1 * 5.f;
fe::Vector2f v3;
v3 = v1 + v2;

bool different = (v2 != v3);

Note: for 3-dimensional vectors, see fe::Vector3.

Public Functions

Vector2()#

Default constructor.

Creates a Vector2(0, 0).

Vector2(T X, T Y)#

Construct the vector from its coordinates.

Parameters:

X – X coordinate
Y – Y coordinate

template<typename U> explicit Vector2(const Vector2<U> &vector)#

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.

Parameters:: vector – Vector to convert

Public Members

T x#: X coordinate of the vector.

T y#: Y coordinate of the vector.

template<typename T> Vector2<T> operator-(const Vector2<T> &right)#

Overload of unary operator -.

Parameters:: right – Vector to negate
Returns:: Memberwise opposite of the vector

template<typename T> Vector2<T> &operator+=(Vector2<T> &left, const Vector2<T> &right)#

Overload of binary operator +=.

This operator performs a memberwise addition of both vectors, and assigns the result to left.

Parameters:

left – Left operand (a vector)
right – Right operand (a vector)

Returns:

Reference to left

template<typename T> Vector2<T> &operator-=(Vector2<T> &left, const Vector2<T> &right)#

Overload of binary operator -=.

This operator performs a memberwise subtraction of both vectors, and assigns the result to left.

Parameters:

left – Left operand (a vector)
right – Right operand (a vector)

Returns:

Reference to left

template<typename T> Vector2<T> operator+(const Vector2<T> &left, const Vector2<T> &right)#

Overload of binary operator +.

Parameters:

left – Left operand (a vector)
right – Right operand (a vector)

Returns:

Memberwise addition of both vectors

template<typename T> Vector2<T> operator-(const Vector2<T> &left, const Vector2<T> &right)#

Overload of binary operator -.

Parameters:

left – Left operand (a vector)
right – Right operand (a vector)

Returns:

Memberwise subtraction of both vectors

template<typename T> Vector2<T> operator*(const Vector2<T> &left, T right)#

Overload of binary operator *.

Parameters:

left – Left operand (a vector)
right – Right operand (a scalar value)

Returns:

Memberwise multiplication by right

template<typename T> Vector2<T> operator*(T left, const Vector2<T> &right)#

Overload of binary operator *.

Parameters:

left – Left operand (a scalar value)
right – Right operand (a vector)

Returns:

Memberwise multiplication by left

template<typename T> Vector2<T> &operator*=(Vector2<T> &left, T right)#

Overload of binary operator *=.

This operator performs a memberwise multiplication by right, and assigns the result to left.

Parameters:

left – Left operand (a vector)
right – Right operand (a scalar value)

Returns:

Reference to left

template<typename T> Vector2<T> operator/(const Vector2<T> &left, T right)#

Overload of binary operator /.

Parameters:

left – Left operand (a vector)
right – Right operand (a scalar value)

Returns:

Memberwise division by right

template<typename T> Vector2<T> &operator/=(Vector2<T> &left, T right)#

Overload of binary operator /=.

This operator performs a memberwise division by right, and assigns the result to left.

Parameters:

left – Left operand (a vector)
right – Right operand (a scalar value)

Returns:

Reference to left

template<typename T> bool operator==(const Vector2<T> &left, const Vector2<T> &right)#

Overload of binary operator ==.

This operator compares strict equality between two vectors.

Parameters:

left – Left operand (a vector)
right – Right operand (a vector)

Returns:

True if left is equal to right

template<typename T> bool operator!=(const Vector2<T> &left, const Vector2<T> &right)#

Overload of binary operator !=.

This operator compares strict difference between two vectors.

Parameters:

left – Left operand (a vector)
right – Right operand (a vector)

Returns:

True if left is not equal to right

namespace gltf#

Functions

JsonBox::Array toJsonArray(const fe::Vec3f &vec)#

JsonBox::Array toJsonArray(const fe::Vec4f &vec)#

JsonBox::Value toJson(const fe::gltf::Scene &scene, const fe::FlowerParameters &params)#

converts a fe::gltf::Scene to a glTF 2.0 JSON from the provided scene.

Serializes the scene’s mesh parts, materials, and textures into a glTF asset with embedded Base64 binary data for geometry and images.

Parameters:

scene – const fe::gltf::Scene& The populated fe::gltf::Scene object.
params – const fe::FlowerParameters& The FlowerParameters used for generation (can be used for glTF extras).

Returns:

A JsonBox::Value containing the glTF JSON.

std::string toJsonStr(const JsonBox::Value &json)#

converts a JsonBox::Value to a std::string.

Parameters:: json – const JsonBox::Value&
Returns:: A std::string containing the glTF stringified json.

struct KHR_MaterialsClearcoat#

#include <Material.hpp>

KHR_MaterialsClearcoat extension properties.

Public Members

float clearcoatFactor = 0.0f#

std::optional<int> clearcoatTextureIndex#

float clearcoatRoughnessFactor = 0.0f#

std::optional<int> clearcoatRoughnessTextureIndex#

std::optional<int> clearcoatNormalTextureIndex#

struct KHR_MaterialsEmissiveStrength#

#include <Material.hpp>

KHR_MaterialsEmissiveStrength extension properties.

Public Members

float emissiveStrength = 1.0f#

struct KHR_MaterialsIOR#

#include <Material.hpp>

KHR_MaterialsIOR extension properties.

Public Members

float ior = 1.0f#

struct KHR_MaterialsTransmission#

#include <Material.hpp>

KHR_MaterialsTransmission extension properties.

Public Members

float transmissionFactor = 0.0f#

std::optional<int> transmissionTextureIndex#

struct KHR_MaterialsVolume#

#include <Material.hpp>

KHR_MaterialsVolume extension properties.

Public Members

float thicknessFactor = 0.0f#

std::optional<int> thicknessTextureIndex#

float attenuationDistance = 0.0f#

fe::Vec3f attenuationColor = {1.0f, 1.0f, 1.0f}#

struct Material#

#include <Material.hpp>

Defines material properties for rendering.

Public Functions

Material() = default#: Default constructor.

Public Members

std::string name#

fe::Vec4f baseColorFactor = {1.0f, 1.0f, 1.0f, 1.0f}#

std::optional<int> baseColorTextureIndex#

float metallicFactor = 0.0f#

float roughnessFactor = 0.5f#

std::optional<int> metallicRoughnessTextureIndex#

std::optional<int> normalTextureIndex#

std::optional<float> normalTextureScale = 1.0f#

std::optional<int> occlusionTextureIndex#

std::optional<float> occlusionTextureStrength = 1.0f#

std::optional<int> emissiveTextureIndex#

fe::Vec3f emissiveFactor = {0.0f, 0.0f, 0.0f}#

bool doubleSided = false#

std::string alphaMode = "OPAQUE"#

float alphaCutoff = 0.5f#

std::optional<KHR_MaterialsTransmission> khrMaterialsTransmission#

std::optional<KHR_MaterialsClearcoat> khrMaterialsClearcoat#

std::optional<KHR_MaterialsVolume> khrMaterialsVolume#

std::optional<KHR_MaterialsIOR> khrMaterialsIOR#

std::optional<KHR_MaterialsEmissiveStrength> khrMaterialsEmissiveStrength#

Public Static Functions

static Material createStemMaterial()#

Creates a default stem material.

Returns:: A Material configured for a stem.

static Material createPistilStyleMaterial()#

creates a default Pistil style Material

Returns:: A Material configured for a Pistil style.

static Material createPistilStigmaMaterial(int normal_tex_idx)#

creates a default Pistil stigma material

Parameters:: normal_tex_idx – The index of the normal texture for the Stigma.
Returns:: A Material configured for Pistil Stigma.

static Material createStamenFilamentMaterial()#

creates a default Stamen filament material

Returns:: A Material configured for Stamen Filament.

static Material createStamenAntherMaterial(int normal_tex_idx)#

creates a default Stamen anther material

Parameters:: normal_tex_idx – The index of the normal texture for the Anther.
Returns:: A Material configured for Stamen Anther.

static Material createPetalMaterial(const std::string &petal_name, int texture_idx, int normal_idx, int emissive_idx)#

Creates a default petal material.

Parameters:

petal_name – const std::string& The name for the petal material.
texture_idx – int The index of the base color texture for this petal.
normal_idx – int the index of the normal texture for this petal.
emissive_idx – int the index of the emissive texture for this petal.

Returns:

A Material configured for a petal.

struct Mesh#

#include <Mesh.hpp>

Represents a distinct geometric part of the model.

It contains its own vertices, indices, and a reference to a material. Internally, this will correspond to a glTF mesh with a single glTF primitive.

Public Functions

Mesh() noexcept#: default constructor

Mesh(int meshIndex, const std::string &name) noexcept#

constructor

Parameters:

meshIndex – int index inside the scene
name – const std::string& name for the mesh

unsigned int addVertex(const Vertex &vertex)#

Adds a vertex to this mesh part and updates bounds.

Parameters:: vertex – The fe::gltf::Vertex to add.
Returns:: The 0-based index of the added vertex within this part’s vertices vector.

void addTriangle(unsigned int idx0, unsigned int idx1, unsigned int idx2)#

Adds a triangle to this mesh part. Assumes vertices are already added via addVertex and indices are relative to this part.

Parameters:

idx0 – Index of the first vertex of the triangle.
idx1 – Index of the second vertex of the triangle.
idx2 – Index of the third vertex of the triangle.

Public Members

std::string name#

std::vector<Vertex> vertices#

std::vector<unsigned int> indices#

int materialIndex = -1#

int index = -1#

fe::Vec3f minBounds = {std::numeric_limits<float>::max(), std::numeric_limits<float>::max(), std::numeric_limits<float>::max()}#

fe::Vec3f maxBounds = {std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest(), std::numeric_limits<float>::lowest()}#

bool hasNormals = false#

bool hasTexCoords0 = false#

struct Node#

#include <Node.hpp>

Node.

Public Functions

Node() noexcept#: default constructor

Public Members

std::optional<std::string> name#

std::optional<std::vector<double>> children#

std::optional<JsonBox::Object> extra#

std::optional<double> mesh#

Public Static Functions

static Node makeGroup(const std::string &name, const std::vector<int> &children) noexcept#

it makes a group of nodes

Parameters:

name – const std::string& name for the node group
children – const std::vector<int>&

Returns:

Node

static Node makeNode(const std::string &name, const Mesh &mesh) noexcept#

it adds a mesh node

Parameters:

name – const std::string& name for the mesh node
mesh – const fe::gltf::Mesh& mesh to get the index from.

Returns:

Node

struct Scene#

#include <Scene.hpp>

Top-level data structure for a glTF scene, typically representing a flower model.

Public Functions

explicit Scene(const std::string &id)#

Constructor.

Parameters:: id – The model identifier.

int addTexture(const TextureInfo &textureInfo)#

Adds a texture to the scene’s texture list.

Parameters:: textureInfo – The fe::gltf::textureInfo object describing the texture.
Returns:: The 0-based index of the added texture in the textures vector.

int addMaterial(const Material &material)#

Adds a material to the scene’s material list.

Parameters:: material – The fe::gltf::Material object describing the material.
Returns:: The 0-based index of the added material in the materials vector.

Mesh &addMeshPart(const Mesh &part)#

Adds a mesh part to the scene.

Warning

do not add or create another mesh until you are done with the current one.

Parameters:: part – The fe::gltf::Mesh to add.
Returns:: A reference to the added GltfMeshPart within the meshParts vector. This can be useful if further modifications are needed after adding.

int addNode(const Node &node)#

Adds a node to the scene.

Parameters:: node – const Node&
Returns:: The 0-based index of the added node in the nodes vector.

Mesh &createMeshPart(const std::string &name)#

Creates and adds a new mesh part to the scene, returning a reference to it.

Warning

do not add or create another mesh until you are done with the current one.

Parameters:: name – The name for the new mesh part.
Returns:: A reference to the newly created Mesh.

Public Members

std::string modelId#

std::vector<Mesh> meshParts#: Collection of distinct geometric parts that make up the model. Each Mesh will be exported as a separate glTF mesh and node.

std::vector<TextureInfo> textures#: Collection of textures used by materials in this scene.

std::vector<Material> materials#: Collection of materials used by mesh parts in this scene.

std::vector<Node> nodes#: Collection of nodes to group the meshes.

struct TextureInfo#

#include <TextureInfo.hpp>

Stores information about a texture image to be used in glTF. Can hold raw image data for processing or the final Base64 URI.

Public Functions

TextureInfo(const std::string &tex_name, const std::string &base64_data_uri)#

Constructor for an embedded Base64 texture.

Parameters:

tex_name – The name of the texture.
base64_data_uri – The full “data:image/png;base64,…” string.

Public Members

std::string name#

std::string mimeType = "image/png"#

std::string uri#

Public Static Functions

static TextureInfo createFromImage(const std::string &tex_name, const fe::Image &raw_image)#

Static helper to create fe::gltf::TextureInfo by processing an fe::Image.

Parameters:

tex_name – The name of the texture.
raw_image – The fe::Image object containing raw pixel data.

Returns:

TextureInfo with the URI field populated.

struct Vertex#

#include <Vertex.hpp>

Represents a single vertex with all its geometric attributes for glTF.

Public Functions

Vertex() = default#: Default constructor.

explicit Vertex(const fe::Vec3f &pos)#

Constructor with position.

Parameters:: pos – The vertex position.

Vertex(const fe::Vec3f &pos, const fe::Vec3f &norm, const fe::Vec2f &uv0)#

Constructor with all common attributes.

Parameters:

pos – The vertex position.
norm – The vertex normal.
uv0 – The vertex texture coordinate (TEXCOORD_0).

Vertex(const fe::Vec3f &pos, const std::optional<fe::Vec3f> &norm, const std::optional<fe::Vec2f> &uv0)#

Constructor with all common attributes.

Parameters:

pos – The vertex position.
norm – The vertex normal.
uv0 – The vertex texture coordinate (TEXCOORD_0).

Public Members

fe::Vec3f position#

std::optional<fe::Vec3f> normal#

std::optional<fe::Vec2f> texCoord0#

namespace Math#

Functions

float magnitude(const fe::Vector2f &v) noexcept#

calculates the magnitude of v

Parameters:: v – const fe::Vector2f&
Returns:: float magnitude of v

fe::Vector2f normalize(const fe::Vector2f &v) noexcept#

returns a normalized v

Parameters:: v – [in] vector
Returns:: fe::Vector2f normalized fe::Vector2f v

float angle(const fe::Vector2f &v, const fe::Vector2f &origin = fe::Vector2f(0.f, 0.f)) noexcept#

get the difference between v and origin in radians clockwise direction and -y is 0º degrees

// angle is 281.31º from 0,0 to 5,1 in clockwise direction
auto angle = Math::radiansToDegrees(Math::angle({0,0},{5,1}));
// angle is 101.31º from 5,1 to 0,0 in clockwise direction
angle = Math::radiansToDegrees(Math::angle({5,1},{0,0}));
//

Parameters:

v – [in] fe::Vector2f
origin – [in] fe::Vector2f Origin which of fe::Vector2f v

Returns:

float angle in radians

float directedAngle(const fe::Vector2f &v1, const fe::Vector2f &v2, const fe::Vector2f &origin = fe::Vector2f(0.f, 0.f)) noexcept#

get the difference from v1 and v2 with origin in radians clockwise direction and -y is 0º degrees

// angle is 326.31º degrees from [5,1] to [3,3] with origin [0,0]
auto angle = Math::radiansToDegrees(Math::directedAngle({5,1},{3,3},{0,0}));
// angle is 33.6901º degrees from [3,3] to [5,1] with origin [0,0]
angle = Math::radiansToDegrees(Math::directedAngle({3,3},{5,1},{0,0}));
// vector [5,1] with origin [3,3] is at 315º degrees from [3,3]
angle = Math::radiansToDegrees(Math::directedAngle({5,1},{3,3},{3,3}));

Parameters:

v1 – [in] const fe::Vector2f&
v2 – [in] const fe::Vector2f&
origin – [in] const fe::Vector2f&

Returns:

float angles in radians

constexpr float degreesToRadians(float d) noexcept#

converts to radians

Parameters:: d – [in] float degrees
Returns:: float

constexpr float radiansToDegrees(float r) noexcept#

converts to degrees

Parameters:: r – [in] float radians
Returns:: float

Variables

constexpr double PI = 3.14159265358979323846#: PI.

namespace priv#

Functions

std::vector<double> queryNN(EvoAI::NeuralNetwork &nn, Petals &petals, const fe::Vector2f &pos, int currentRadius, int currentLayer) noexcept#

queries the neural network

Parameters:

nn – [in] EvoAI::NeuralNetwork with 4 inputs 4 outputs
petals – [in] Petals that is being processed
pos – [in] position
currentRadius – [in] current radius
currentLayer – [in] current layer

Returns:

std::vector<double> results

void setColorAndCut(const fe::Vector2f &pos, EvoAI::NeuralNetwork &nn, Petals &petals, int currentRadius, int currentLayer) noexcept#

sets color for every pixel in a line from petals.origin to pos as maximum if no cut is made.

Parameters:

pos – [in] fe::Vector2f& position
nn – [in] EvoAI::NeuralNetwork with 4 inputs and 4 outputs
petals – [in] Petals that is being processed
currentRadius – [in] current radius
currentLayer – [in] current layer

void EightWaySymmetricSetColor(const fe::Vector2f &origin, const fe::Vector2f &r, Petals &petals, EvoAI::NeuralNetwork &nn, int currentRadius, int currentLayer) noexcept#

It will use setColorAndCut to draw a pattern into petals.

Parameters:

origin – [in] center of circle (Flower)
r – [in] max radius
petals – [in] Petals
nn – [in] EvoAI::NeuralNetwork with 4 inputs 4 outputs
currentRadius – [in] current Radius
currentLayer – [in] current Layer

void drawPetals(Petals &petals, EvoAI::NeuralNetwork &nn, int currentRadius, int currentLayer) noexcept#

will draw the flower

Parameters:

petals – [in] Petals
nn – [in] EvoAI::NeuralNetwork with 4 inputs 4 outputs
currentRadius – [in] current Radius
currentLayer – [in] current Layer

void drawTrunk(Petals &petals) noexcept#

will draw a trunk of the flower

Parameters:: petals – [in] Petals

namespace resources#

Variables

const std::string anther_normal_texture = "data:image/png;base64,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"#

const std::string stigma_normal_texture = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAABACAYAAACqaXHeAAABPElEQVR4Xu2cPQ4BYRCG5wsKP1toiDvQrcQNSJQqR1A6idIRNEoFJ1DQrTs4wBZbIOudhFPMUwjtzO58+ebJ+0jXQafeFmaLYdOsNrOkT4Dv8/BtO9WdjlW3PvTNJlUjTPH+kIvqY2vVnZZlu96MzO5lK1QD8vJle9Wdlj014KkGZGpAgFf/P+J5pgao7nRSA/zHNFgDbmqAP/h00gj4qzANNgI3jYCPPmcAZwBnAGcA9wDuAdwDuAewC7ALsAvEWofZBeAB8AB4ADwAJggThAnCBGGCMEGYIEwQJggThAnCBGGCMEGYIBkhMkKBQlJkhMgIkRMkJ0hOkJwgWWGywmSF8QXwBfAF8AVwhnCGcIZwhvAGg2FxvEG8wZ83uJI87RLxI5g8PZY87dJ4mkmfd438Ekyfn0uf978N+AJndyJy0tqtywAAAABJRU5ErkJggg=="#