camera_server.proto

syntax = "proto3";

package mavsdk.rpc.camera_server;

import "mavsdk_options.proto";

option java_package = "io.mavsdk.camera_server";
option java_outer_classname = "CameraServerProto";

// Provides handling of camera interface
service CameraServerService {
    // Sets the camera information. This must be called as soon as the camera server is created.
    rpc SetInformation(SetInformationRequest) returns(SetInformationResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Sets video streaming settings.
    rpc SetVideoStreaming(SetVideoStreamingRequest) returns(SetVideoStreamingResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Sets image capture in progress status flags. This should be set to true when the camera is busy taking a photo and false when it is done.
    rpc SetInProgress(SetInProgressRequest) returns(SetInProgressResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to image capture requests. Each request received should respond to using RespondTakePhoto.
    rpc SubscribeTakePhoto(SubscribeTakePhotoRequest) returns(stream TakePhotoResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to an image capture request from SubscribeTakePhoto.
    rpc RespondTakePhoto(RespondTakePhotoRequest) returns(RespondTakePhotoResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to start video requests. Each request received should respond to using RespondStartVideo
    rpc SubscribeStartVideo(SubscribeStartVideoRequest) returns(stream StartVideoResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Subscribe to stop video requests. Each request received should respond using StopVideoResponse
    rpc RespondStartVideo(RespondStartVideoRequest) returns(RespondStartVideoResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to stop video requests. Each request received should response to using RespondStopVideo
    rpc SubscribeStopVideo(SubscribeStopVideoRequest) returns(stream StopVideoResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to stop video request from SubscribeStopVideo.
    rpc RespondStopVideo(RespondStopVideoRequest) returns(RespondStopVideoResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to start video streaming requests. Each request received should response to using RespondStartVideoStreaming
    rpc SubscribeStartVideoStreaming(SubscribeStartVideoStreamingRequest) returns(stream StartVideoStreamingResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to start video streaming from SubscribeStartVideoStreaming.
    rpc RespondStartVideoStreaming(RespondStartVideoStreamingRequest) returns(RespondStartVideoStreamingResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to stop video streaming requests. Each request received should response to using RespondStopVideoStreaming
    rpc SubscribeStopVideoStreaming(SubscribeStopVideoStreamingRequest) returns(stream StopVideoStreamingResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to stop video streaming from SubscribeStopVideoStreaming.
    rpc RespondStopVideoStreaming(RespondStopVideoStreamingRequest) returns(RespondStopVideoStreamingResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to set camera mode requests. Each request received should response to using RespondSetMode
    rpc SubscribeSetMode(SubscribeSetModeRequest) returns(stream SetModeResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to set camera mode from SubscribeSetMode.
    rpc RespondSetMode(RespondSetModeRequest) returns(RespondSetModeResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to camera storage information requests. Each request received should response to using RespondStorageInformation
    rpc SubscribeStorageInformation(SubscribeStorageInformationRequest) returns(stream StorageInformationResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to camera storage information from SubscribeStorageInformation.
    rpc RespondStorageInformation(RespondStorageInformationRequest) returns(RespondStorageInformationResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to camera capture status requests. Each request received should response to using RespondCaptureStatus
    rpc SubscribeCaptureStatus(SubscribeCaptureStatusRequest) returns(stream CaptureStatusResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to camera capture status from SubscribeCaptureStatus.
    rpc RespondCaptureStatus(RespondCaptureStatusRequest) returns(RespondCaptureStatusResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to format storage requests. Each request received should response to using RespondFormatStorage
    rpc SubscribeFormatStorage(SubscribeFormatStorageRequest) returns(stream FormatStorageResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to format storage from SubscribeFormatStorage.
    rpc RespondFormatStorage(RespondFormatStorageRequest) returns(RespondFormatStorageResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to reset settings requests. Each request received should response to using RespondResetSettings
    rpc SubscribeResetSettings(SubscribeResetSettingsRequest) returns(stream ResetSettingsResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to reset settings from SubscribeResetSettings.
    rpc RespondResetSettings(RespondResetSettingsRequest) returns(RespondResetSettingsResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to zoom in start command
    rpc SubscribeZoomInStart(SubscribeZoomInStartRequest) returns(stream ZoomInStartResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to zoom in start.
    rpc RespondZoomInStart(RespondZoomInStartRequest) returns(RespondZoomInStartResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to zoom out start command
    rpc SubscribeZoomOutStart(SubscribeZoomOutStartRequest) returns(stream ZoomOutStartResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to zoom out start.
    rpc RespondZoomOutStart(RespondZoomOutStartRequest) returns(RespondZoomOutStartResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to zoom stop command
    rpc SubscribeZoomStop(SubscribeZoomStopRequest) returns(stream ZoomStopResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to zoom stop.
    rpc RespondZoomStop(RespondZoomStopRequest) returns(RespondZoomStopResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to zoom range command
    rpc SubscribeZoomRange(SubscribeZoomRangeRequest) returns(stream ZoomRangeResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to zoom range.
    rpc RespondZoomRange(RespondZoomRangeRequest) returns(RespondZoomRangeResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Set/update the current rectangle tracking status.
    rpc SetTrackingRectangleStatus(SetTrackingRectangleStatusRequest) returns(SetTrackingRectangleStatusResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Set the current tracking status to off.
    rpc SetTrackingOffStatus(SetTrackingOffStatusRequest) returns(SetTrackingOffStatusResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Subscribe to incoming tracking point command.
    rpc SubscribeTrackingPointCommand(SubscribeTrackingPointCommandRequest) returns(stream TrackingPointCommandResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Subscribe to incoming tracking rectangle command.
    rpc SubscribeTrackingRectangleCommand(SubscribeTrackingRectangleCommandRequest) returns(stream TrackingRectangleCommandResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Subscribe to incoming tracking off command.
    rpc SubscribeTrackingOffCommand(SubscribeTrackingOffCommandRequest) returns(stream TrackingOffCommandResponse) { option (mavsdk.options.async_type) = ASYNC; }

    // Respond to an incoming tracking point command.
    rpc RespondTrackingPointCommand(RespondTrackingPointCommandRequest) returns(RespondTrackingPointCommandResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Respond to an incoming tracking rectangle command.
    rpc RespondTrackingRectangleCommand(RespondTrackingRectangleCommandRequest) returns(RespondTrackingRectangleCommandResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Respond to an incoming tracking off command.
    rpc RespondTrackingOffCommand(RespondTrackingOffCommandRequest) returns(RespondTrackingOffCommandResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Set the camera's GPS position.
    rpc SetPosition(SetPositionRequest) returns(SetPositionResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Set the camera's attitude quaternion.
    rpc SetAttitudeQuaternion(SetAttitudeQuaternionRequest) returns(SetAttitudeQuaternionResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Set the camera's zoom factor for CAMERA_FOV_STATUS reporting.
    rpc SetZoomFactor(SetZoomFactorRequest) returns(SetZoomFactorResponse) { option (mavsdk.options.async_type) = SYNC; }

    // Set the field of view explicitly, for cameras that do not report a zoom factor.
    rpc SetFieldOfView(SetFieldOfViewRequest) returns(SetFieldOfViewResponse) { option (mavsdk.options.async_type) = SYNC; }
}


message SetInformationRequest {
    Information information = 1; // information about the camera
}

message SetInformationResponse {
    CameraServerResult camera_server_result = 1;
}

message SetVideoStreamingRequest {
    VideoStreaming video_streaming = 1; // information about the video stream
}

message SetVideoStreamingResponse {
    CameraServerResult camera_server_result = 1;
}

message SetInProgressRequest {
    bool in_progress = 1; // true if capture is in progress or false for idle.
}

message SetInProgressResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeTakePhotoRequest {}
message TakePhotoResponse {
    int32 index = 1;
}

message RespondTakePhotoRequest {
    CameraFeedback take_photo_feedback = 1; // the feedback
    CaptureInfo capture_info = 2; // the capture information
}
message RespondTakePhotoResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeStartVideoRequest {}
message StartVideoResponse {
    int32 stream_id = 1;    // video stream id
}

message RespondStartVideoRequest {
    CameraFeedback start_video_feedback = 1; // the feedback
}
message RespondStartVideoResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeStopVideoRequest {}
message StopVideoResponse {
    int32 stream_id = 1;    // video stream id
}

message RespondStopVideoRequest {
    CameraFeedback stop_video_feedback = 1; // the feedback
}
message RespondStopVideoResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeStartVideoStreamingRequest {}
message StartVideoStreamingResponse {
    int32 stream_id = 1;    // video stream id
}

message RespondStartVideoStreamingRequest {
    CameraFeedback start_video_streaming_feedback = 1; // the feedback
}
message RespondStartVideoStreamingResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeStopVideoStreamingRequest {}
message StopVideoStreamingResponse {
    int32 stream_id = 1;    // video stream id
}

message RespondStopVideoStreamingRequest {
    CameraFeedback stop_video_streaming_feedback = 1; // the feedback
}
message RespondStopVideoStreamingResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeSetModeRequest {}
message SetModeResponse {
    Mode mode = 1;
}

message RespondSetModeRequest {
    CameraFeedback set_mode_feedback = 1; // the feedback
}
message RespondSetModeResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeStorageInformationRequest {}
message StorageInformationResponse {
    int32 storage_id = 1;
}

message RespondStorageInformationRequest {
    CameraFeedback storage_information_feedback = 1; // the feedback
    StorageInformation storage_information = 2; // the storage information
}
message RespondStorageInformationResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeCaptureStatusRequest {}
message CaptureStatusResponse {
    int32 reserved = 1;    // reserved, just make protoc-gen-mavsdk working
}

message RespondCaptureStatusRequest {
    CameraFeedback capture_status_feedback = 1; // the feedback
    CaptureStatus capture_status = 2; // the capture status
}
message RespondCaptureStatusResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeFormatStorageRequest {}
message FormatStorageResponse {
    int32 storage_id = 1;   // the storage id to format
}

message RespondFormatStorageRequest {
    CameraFeedback format_storage_feedback = 1; // the feedback
}
message RespondFormatStorageResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeResetSettingsRequest {}
message ResetSettingsResponse {
    int32 reserved = 1;    // reserved, just make protoc-gen-mavsdk working
}

message RespondResetSettingsRequest {
    CameraFeedback reset_settings_feedback = 1; // the feedback
}
message RespondResetSettingsResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeZoomInStartRequest {}
message ZoomInStartResponse {
    int32 reserved = 1;    // reserved, just make protoc-gen-mavsdk working
}

message RespondZoomInStartRequest {
    CameraFeedback zoom_in_start_feedback = 1; // the feedback
}
message RespondZoomInStartResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeZoomOutStartRequest {}
message ZoomOutStartResponse {
    int32 reserved = 1;    // reserved, just make protoc-gen-mavsdk working
}

message RespondZoomOutStartRequest {
    CameraFeedback zoom_out_start_feedback = 1; // the feedback
}
message RespondZoomOutStartResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeZoomStopRequest {}
message ZoomStopResponse {
    int32 reserved = 1;    // reserved, just make protoc-gen-mavsdk working
}

message RespondZoomStopRequest {
    CameraFeedback zoom_stop_feedback = 1; // the feedback
}
message RespondZoomStopResponse {
    CameraServerResult camera_server_result = 1;
}

message SubscribeZoomRangeRequest {}
message ZoomRangeResponse {
    float factor = 1; // The zoom factor, starting at 1x.
}

message RespondZoomRangeRequest {
    CameraFeedback zoom_range_feedback = 1; // the feedback
}
message RespondZoomRangeResponse {
    CameraServerResult camera_server_result = 1;
}

// Possible feedback results for camera respond command.
enum CameraFeedback {
    CAMERA_FEEDBACK_UNKNOWN = 0; // Unknown
    CAMERA_FEEDBACK_OK = 1; // Ok
    CAMERA_FEEDBACK_BUSY = 2; // Busy
    CAMERA_FEEDBACK_FAILED = 3; // Failed
}

// Type to represent a camera information.
message Information {
    string vendor_name = 1; // Name of the camera vendor
    string model_name = 2; // Name of the camera model
    string firmware_version = 3; // Camera firmware version in major[.minor[.patch[.dev]]] format
    float focal_length_mm = 4; // Focal length
    float horizontal_sensor_size_mm = 5; // Horizontal sensor size
    float vertical_sensor_size_mm = 6; // Vertical sensor size
    uint32 horizontal_resolution_px = 7; // Horizontal image resolution in pixels
    uint32 vertical_resolution_px = 8; // Vertical image resolution in pixels
    uint32 lens_id = 9; // Lens ID
    uint32 definition_file_version = 10; // Camera definition file version (iteration)
    string definition_file_uri = 11; // Camera definition URI (http or mavlink ftp)
    bool image_in_video_mode_supported = 12; // Camera supports taking images while in video mode
    bool video_in_image_mode_supported = 13; // Camera supports recording video while in image mode
}

// Type to represent video streaming settings
message VideoStreaming {
    bool has_rtsp_server = 1; // True if the capture was successful
    string rtsp_uri = 2; // RTSP URI (e.g. rtsp://192.168.1.42:8554/live)
}

// Position type in global coordinates.
message Position {
    double latitude_deg = 1; // Latitude in degrees (range: -90 to +90)
    double longitude_deg = 2; // Longitude in degrees (range: -180 to +180)
    float absolute_altitude_m = 3; // Altitude AMSL (above mean sea level) in metres
    float relative_altitude_m = 4; // Altitude relative to takeoff altitude in metres
}

/*
 * Quaternion type.
 *
 * All rotations and axis systems follow the right-hand rule.
 * The Hamilton quaternion product definition is used.
 * A zero-rotation quaternion is represented by (1,0,0,0).
 * The quaternion could also be written as w + xi + yj + zk.
 *
 * For more info see: https://en.wikipedia.org/wiki/Quaternion
 */
message Quaternion {
    float w = 1; // Quaternion entry 0, also denoted as a
    float x = 2; // Quaternion entry 1, also denoted as b
    float y = 3; // Quaternion entry 2, also denoted as c
    float z = 4; // Quaternion entry 3, also denoted as d
}

// Information about a picture just captured.
message CaptureInfo {
    Position position = 1; // Location where the picture was taken
    Quaternion attitude_quaternion = 2; // Attitude of the camera when the picture was taken (quaternion)
    uint64 time_utc_us = 3; // Timestamp in UTC (since UNIX epoch) in microseconds
    bool is_success = 4; // True if the capture was successful
    int32 index = 5; // Index from TakePhotoResponse
    string file_url = 6; // Download URL of this image
}

// Result type.
message CameraServerResult {
    // Possible results returned for action requests.
    enum Result {
        RESULT_UNKNOWN = 0; // Unknown result
        RESULT_SUCCESS = 1; // Command executed successfully
        RESULT_IN_PROGRESS = 2; // Command in progress
        RESULT_BUSY = 3; // Camera is busy and rejected command
        RESULT_DENIED = 4; // Camera denied the command
        RESULT_ERROR = 5; // An error has occurred while executing the command
        RESULT_TIMEOUT = 6; // Command timed out
        RESULT_WRONG_ARGUMENT = 7; // Command has wrong argument(s)
        RESULT_NO_SYSTEM = 8; // No system connected
    }

    Result result = 1; // Result enum value
    string result_str = 2; // Human-readable English string describing the result
}

// Camera mode type.
enum Mode {
    MODE_UNKNOWN = 0; // Unknown mode
    MODE_PHOTO = 1; // Photo mode
    MODE_VIDEO = 2; // Video mode
}

// Information about the camera storage.
message StorageInformation {
    // Storage status type.
    enum StorageStatus {
        STORAGE_STATUS_NOT_AVAILABLE = 0; // Storage not available
        STORAGE_STATUS_UNFORMATTED = 1; // Storage is not formatted (i.e. has no recognized file system)
        STORAGE_STATUS_FORMATTED = 2; // Storage is formatted (i.e. has recognized a file system)
        STORAGE_STATUS_NOT_SUPPORTED = 3; // Storage status is not supported
    }

    // Storage type.
    enum StorageType {
        STORAGE_TYPE_UNKNOWN = 0; // Storage type unknown
        STORAGE_TYPE_USB_STICK = 1; // Storage type USB stick
        STORAGE_TYPE_SD = 2; // Storage type SD card
        STORAGE_TYPE_MICROSD = 3; // Storage type MicroSD card
        STORAGE_TYPE_HD = 7; // Storage type HD mass storage
        STORAGE_TYPE_OTHER = 254; // Storage type other, not listed
    }

    float used_storage_mib = 1; // Used storage (in MiB)
    float available_storage_mib = 2; // Available storage (in MiB)
    float total_storage_mib = 3; // Total storage (in MiB)

    StorageStatus storage_status = 4; // Storage status

    uint32 storage_id = 5; // Storage ID starting at 1

    StorageType storage_type = 6; // Storage type

    float read_speed_mib_s = 7; // Read speed [MiB/s]
    float write_speed_mib_s = 8; // Write speed [MiB/s]
}

// Capture status
message CaptureStatus {
    // The image status
    enum ImageStatus {
        IMAGE_STATUS_IDLE = 0; // idle
        IMAGE_STATUS_CAPTURE_IN_PROGRESS = 1; // capture in progress
        IMAGE_STATUS_INTERVAL_IDLE = 2; // interval set but idle
        IMAGE_STATUS_INTERVAL_IN_PROGRESS = 3; // interval set and capture in progress)
    }
    // The video status
    enum VideoStatus {
        VIDEO_STATUS_IDLE = 0;  // idle
        VIDEO_STATUS_CAPTURE_IN_PROGRESS = 1;   // capture in progress
    }
    float image_interval_s = 1; // Image capture interval (in s)
    float recording_time_s = 2; // Elapsed time since recording started (in s)
    float available_capacity_mib = 3; // Available storage capacity. (in MiB)
    ImageStatus image_status = 4; // Current status of image capturing
    VideoStatus video_status = 5; // Current status of video capturing
    int32 image_count = 6; // Total number of images captured ('forever', or until reset using MAV_CMD_STORAGE_FORMAT)
}

message SetTrackingPointStatusRequest {
    TrackPoint tracked_point = 1; // The tracked point
}
message SetTrackingPointStatusResponse {}

message SetTrackingRectangleStatusRequest {
    TrackRectangle tracked_rectangle = 1; // The tracked rectangle
}
message SetTrackingRectangleStatusResponse {}

message SetTrackingOffStatusRequest {}
message SetTrackingOffStatusResponse {}

message SubscribeTrackingPointCommandRequest {}
message TrackingPointCommandResponse {
    TrackPoint track_point = 1; // The point to track if a point is to be tracked
}

message SubscribeTrackingRectangleCommandRequest {}
message TrackingRectangleCommandResponse {
    TrackRectangle track_rectangle = 1; // The point to track if a point is to be tracked
}

message SubscribeTrackingOffCommandRequest {}
message TrackingOffCommandResponse {
    int32 dummy = 1; // Unused
}

message RespondTrackingPointCommandRequest {
    CameraFeedback stop_video_feedback = 1; // the feedback
}
message RespondTrackingPointCommandResponse {
    CameraServerResult camera_server_result = 1; // The result of sending the response.
}

message RespondTrackingRectangleCommandRequest {
    CameraFeedback stop_video_feedback = 1; // the feedback
}
message RespondTrackingRectangleCommandResponse {
    CameraServerResult camera_server_result = 1; // The result of sending the response.
}

message RespondTrackingOffCommandRequest {
    CameraFeedback stop_video_feedback = 1; // the feedback
}
message RespondTrackingOffCommandResponse {
    CameraServerResult camera_server_result = 1; // The result of sending the response.
}

message SetPositionRequest {
    Position position = 1; // The camera's current GPS position
}
message SetPositionResponse {
    CameraServerResult camera_server_result = 1;
}

message SetAttitudeQuaternionRequest {
    Quaternion attitude_quaternion = 1; // The camera's current attitude
}
message SetAttitudeQuaternionResponse {
    CameraServerResult camera_server_result = 1;
}

message SetZoomFactorRequest {
    float zoom_factor = 1; // The camera's current zoom factor, starting at 1x.
}
message SetZoomFactorResponse {
    CameraServerResult camera_server_result = 1;
}

message SetFieldOfViewRequest {
    float horizontal_fov_deg = 1; // The camera's current horizontal field of view in degrees
    float vertical_fov_deg = 2; // The camera's current vertical field of view in degrees
}
message SetFieldOfViewResponse {
    CameraServerResult camera_server_result = 1;
}

// Point description type
message TrackPoint {
    float point_x = 1; // Point to track x value (normalized 0..1, 0 is left, 1 is right).
    float point_y = 2; // Point to track y value (normalized 0..1, 0 is top, 1 is bottom).
    float radius = 3; // Point to track y value (normalized 0..1, 0 is top, 1 is bottom).
}

// Rectangle description type
message TrackRectangle {
    float top_left_corner_x = 1; // Top left corner of rectangle x value (normalized 0..1, 0 is left, 1 is right).
    float top_left_corner_y = 2; // Top left corner of rectangle y value (normalized 0..1, 0 is top, 1 is bottom).
    float bottom_right_corner_x = 3; // Bottom right corner of rectangle x value (normalized 0..1, 0 is left, 1 is right).
    float bottom_right_corner_y = 4; // Bottom right corner of rectangle y value (normalized 0..1, 0 is top, 1 is bottom).
}