Remove client/server features on send/receive

Change-Id: Id054116e37bb1513892ee87b03ba5a5e0e499831

Author: Charles Bournhonesque

src/lib.rs

@@ -713,15 +713,13 @@ pub mod prelude {
                 receive_markers::AppMarkerExt,
                 registry::rule_fns::RuleFns,
                 rules::{AppRuleExt, component::ReplicationMode},
+                send::related_entities::SyncRelatedAppExt,
                 signature::Signature,
             },
             replicon_tick::RepliconTick,
         },
     };
 
-    #[cfg(feature = "server")]
-    pub use super::shared::replication::send::related_entities::SyncRelatedAppExt;
-
     #[cfg(feature = "client")]
     pub use super::client::{
         ClientPlugin, ClientReplicationStats, ClientSystems, Remote, message::ClientMessagePlugin,

src/shared/message/server_message.rs

@@ -1,18 +1,17 @@
-#[cfg(feature = "server")]
 pub(crate) mod message_buffer;
 mod message_queue;
-#[cfg(feature = "server")]
-mod send;
 
 use core::any::TypeId;
 
+use bevy::ptr::Ptr;
 use bevy::{
     ecs::{component::ComponentId, entity::MapEntities},
     prelude::*,
     ptr::PtrMut,
 };
 use bytes::Bytes;
 use log::{debug, error, warn};
+use postcard::experimental::max_size::MaxSize;
 use serde::{Serialize, de::DeserializeOwned};
 
 use super::{
@@ -21,6 +20,7 @@ use super::{
     registry::RemoteMessageRegistry,
 };
 use crate::{postcard_utils, prelude::*};
+use message_buffer::{MessageBuffer, SerializedMessage};
 use message_queue::MessageQueue;
 
 /// An extension trait for [`App`] for creating server messages.
@@ -232,8 +232,7 @@ pub(crate) struct ServerMessage {
     /// ID of `M`.
     type_id: TypeId,
 
-    #[cfg(feature = "server")]
-    send_or_buffer: send::SendOrBufferFn,
+    send_or_buffer: SendOrBufferFn,
     receive: ReceiveFn,
     send_locally: SendLocallyFn,
     reset: ResetFn,
@@ -266,7 +265,6 @@ impl ServerMessage {
             queue_id,
             channel_id,
             type_id: TypeId::of::<M>(),
-            #[cfg(feature = "server")]
             send_or_buffer: Self::send_or_buffer_typed::<M, I>,
             receive: Self::receive_typed::<M, I>,
             send_locally: Self::send_locally_typed::<M>,
@@ -499,6 +497,154 @@ impl ServerMessage {
     }
 }
 
+impl ServerMessage {
+    /// Sends a message to client(s).
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `to_messages` is [`Messages<ToClients<M>>`]
+    /// and this instance was created for `M`.
+    pub(crate) unsafe fn send_or_buffer(
+        &self,
+        ctx: &mut ServerSendCtx,
+        to_messages: &Ptr,
+        server_messages: &mut ServerMessages,
+        clients: &Query<Entity, With<ConnectedClient>>,
+        message_buffer: &mut MessageBuffer,
+    ) {
+        unsafe {
+            (self.send_or_buffer)(
+                self,
+                ctx,
+                to_messages,
+                server_messages,
+                clients,
+                message_buffer,
+            )
+        }
+    }
+
+    /// Typed version of [`Self::send_or_buffer`].
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that `to_messages` is [`Messages<ToClients<M>>`]
+    /// and this instance was created for `M` and `I`.
+    pub(super) unsafe fn send_or_buffer_typed<M: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        to_messages: &Ptr,
+        server_messages: &mut ServerMessages,
+        clients: &Query<Entity, With<ConnectedClient>>,
+        message_buffer: &mut MessageBuffer,
+    ) {
+        let to_messages: &Messages<ToClients<M>> = unsafe { to_messages.deref() };
+        // For server messages we don't track read message because
+        // all of them will always be drained in the local sending system.
+        for ToClients { message, mode } in to_messages.get_cursor().read(to_messages) {
+            debug!("sending message `{}` with `{mode:?}`", ShortName::of::<M>());
+
+            if self.independent {
+                unsafe {
+                    self.send_independent_message::<M, I>(
+                        ctx,
+                        message,
+                        mode,
+                        server_messages,
+                        clients,
+                    )
+                    .expect("independent server message should be serializable");
+                }
+            } else {
+                unsafe {
+                    self.buffer_message::<M, I>(ctx, message, *mode, message_buffer)
+                        .expect("server message should be serializable");
+                }
+            }
+        }
+    }
+
+    /// Sends independent remote message `M` based on a mode.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `M` and `I`.
+    ///
+    /// For regular messages see [`Self::buffer_message`].
+    unsafe fn send_independent_message<M: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &M,
+        mode: &SendMode,
+        server_messages: &mut ServerMessages,
+        clients: &Query<Entity, With<ConnectedClient>>,
+    ) -> Result<()> {
+        let mut message_bytes = Vec::new();
+        unsafe { self.serialize::<M, I>(ctx, message, &mut message_bytes)? }
+        let message_bytes: Bytes = message_bytes.into();
+
+        match *mode {
+            SendMode::Broadcast => {
+                for client in clients {
+                    server_messages.send(client, self.channel_id, message_bytes.clone());
+                }
+            }
+            SendMode::BroadcastExcept(ignored_id) => {
+                for client in clients {
+                    if ignored_id != client.into() {
+                        server_messages.send(client, self.channel_id, message_bytes.clone());
+                    }
+                }
+            }
+            SendMode::Direct(client_id) => {
+                if let ClientId::Client(client) = client_id {
+                    server_messages.send(client, self.channel_id, message_bytes.clone());
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Buffers message `M` based on mode.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `M` and `I`.
+    ///
+    /// For independent messages see [`Self::send_independent_message`].
+    unsafe fn buffer_message<M: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &M,
+        mode: SendMode,
+        message_buffer: &mut MessageBuffer,
+    ) -> Result<()> {
+        let message_bytes = unsafe { self.serialize_with_padding::<M, I>(ctx, message)? };
+        message_buffer.insert(mode, self.channel_id, message_bytes);
+        Ok(())
+    }
+
+    /// Helper for serializing a server message.
+    ///
+    /// Will prepend padding bytes for where the update tick will be inserted to the injected message.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that this instance was created for `M` and `I`.
+    unsafe fn serialize_with_padding<M: Message, I: 'static>(
+        &self,
+        ctx: &mut ServerSendCtx,
+        message: &M,
+    ) -> Result<SerializedMessage> {
+        let mut message_bytes = vec![0; RepliconTick::POSTCARD_MAX_SIZE]; // Padding for the tick.
+        unsafe { self.serialize::<M, I>(ctx, message, &mut message_bytes)? }
+        let message = SerializedMessage::Raw(message_bytes);
+
+        Ok(message)
+    }
+}
+
 /// Signature of server message receiving functions.
 type ReceiveFn = unsafe fn(
     &ServerMessage,
@@ -509,6 +655,16 @@ type ReceiveFn = unsafe fn(
     RepliconTick,
 );
 
+/// Signature of server message sending functions.
+type SendOrBufferFn = unsafe fn(
+    &ServerMessage,
+    &mut ServerSendCtx,
+    &Ptr,
+    &mut ServerMessages,
+    &Query<Entity, With<ConnectedClient>>,
+    &mut MessageBuffer,
+);
+
 /// Signature of server message sending functions.
 type SendLocallyFn = unsafe fn(PtrMut, PtrMut);