geofeatures.h

#ifndef __FEATURES_H__
#define __FEATURES_H__
 
#include <godot_cpp/classes/curve3d.hpp>
#include <godot_cpp/classes/global_constants.hpp>
 
#include <godot_cpp/core/binder_common.hpp>
 
#include "Feature.h"
#include "LineFeature.h"
#include "PointFeature.h"
#include "PolygonFeature.h"
#include "defines.h"
 
namespace godot {
 
// Wrapper for any georeferenced feature from GDAL.
class EXPORT GeoFeature : public Resource {
    GDCLASS(GeoFeature, Resource)
 
  protected:
    static void _bind_methods();
 
  public:
    GeoFeature() = default;
    virtual ~GeoFeature() = default;
 
    String get_attribute(String name) const;
    void set_attribute(String name, String value);
 
    int get_id() const;
 
    Dictionary get_attributes() const;
 
    void set_gdal_feature(std::shared_ptr<Feature> gdal_feature);
 
    void set_deleted(bool is_deleted);
 
    bool intersects_with(Ref<GeoFeature> other);
 
  protected:
    std::shared_ptr<Feature> gdal_feature;
};
 
// Wrapper for a PointFeature from the VectorExtractor.
class EXPORT GeoPoint : public GeoFeature {
    GDCLASS(GeoPoint, GeoFeature)
 
  protected:
    static void _bind_methods();
 
  public:
    GeoPoint() = default;
    ~GeoPoint() = default;
 
    Vector3 get_float_offset_vector3(double offset_x, double offset_y, double offset_z);
    Vector3 get_offset_vector3(int offset_x, int offset_y, int offset_z);
    void set_float_offset_vector3(Vector3 vector, double offset_x, double offset_y, double offset_z);
    void set_offset_vector3(Vector3 vector, int offset_x, int offset_y, int offset_z);
 
    Vector3 get_vector3();
    void set_vector3(Vector3 vector);
};
 
// Wrapper for a LineFeature from the VectorExtractor.
class EXPORT GeoLine : public GeoFeature {
    GDCLASS(GeoLine, GeoFeature)
 
  protected:
    static void _bind_methods();
 
  public:
    GeoLine() = default;
    ~GeoLine() = default;
 
    Ref<Curve3D> get_float_offset_curve3d(double offset_x, double offset_y, double offset_z);
    Ref<Curve3D> get_offset_curve3d(int offset_x, int offset_y, int offset_z);
    void set_float_offset_curve3d(Ref<Curve3D> curve, double offset_x, double offset_y, double offset_z);
    void set_offset_curve3d(Ref<Curve3D> curve, int offset_x, int offset_y, int offset_z);
 
    Ref<Curve3D> get_curve3d();
    void set_curve3d(Ref<Curve3D> curve);
 
    void add_point(Vector3 point);
};
 
// Wrapper for a PolygonFeature from the VectorExtractor.
class EXPORT GeoPolygon : public GeoFeature {
    GDCLASS(GeoPolygon, GeoFeature)
 
  protected:
    static void _bind_methods();
 
  public:
    GeoPolygon() = default;
    ~GeoPolygon() = default;
 
    PackedVector2Array get_outer_vertices();
 
    PackedVector2Array get_float_offset_outer_vertices(double offset_x, double offset_y);
    PackedVector2Array get_offset_outer_vertices(int offset_x, int offset_y);
 
    void set_outer_vertices(PackedVector2Array vertices);
 
    void set_float_offset_outer_vertices(double offset_x, double offset_y, PackedVector2Array vertices);
    void set_offset_outer_vertices(int offset_x, int offset_y, PackedVector2Array vertices);
 
    Array get_holes();
    Array get_float_offset_holes(double offset_x, double offset_y);
    Array get_offset_holes(int offset_x, int offset_y);
    void add_hole(PackedVector2Array hole);
};
 
} // namespace godot
 
#endif // __FEATURES_H__