'mapped' -> 'buffer_cpu_address'

src/gpu/gpu_dx12/gpu_dx12_core.c

@@ -1535,7 +1535,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
     }
   }
 
-  if (should_map && !resource->mapped)
+  if (should_map && !resource->buffer_cpu_address)
   {
     D3D12_RANGE zero_read_range = Zi;
     D3D12_RANGE *read_range_arg = &zero_read_range;
@@ -1544,7 +1544,7 @@ G_BaseDescriptorIndex G_PushMemory(G_CommandListHandle cl_handle, G_ArenaHandle
       // Specify NULL read range to signal to D3D12 that any part of address range may be read by CPU
       read_range_arg = 0;
     }
-    HRESULT hr = ID3D12Resource_Map(resource->d3d_resource, 0, read_range_arg, &resource->mapped);
+    HRESULT hr = ID3D12Resource_Map(resource->d3d_resource, 0, read_range_arg, &resource->buffer_cpu_address);
     if (!SUCCEEDED(hr))
     {
       // TODO: Don't panic
@@ -1907,7 +1907,7 @@ i32 G_CountMips(G_TextureRef texture)
 void *G_CpuPointerFromBuffer(G_BufferRef buffer)
 {
   G_D12_Resource *resource = G_D12_ResourceFromBufferRef(buffer);
-  void *result = resource->mapped;
+  void *result = resource->buffer_cpu_address;
   return result;
 }
 

src/gpu/gpu_dx12/gpu_dx12_core.h

@@ -78,12 +78,12 @@ Struct(G_D12_Resource)
   // D3D12 resource
   D3D12_RESOURCE_DESC1 d3d_desc;
   ID3D12Resource *d3d_resource;
-  void *mapped;
 
   struct G_D12_Descriptor *gpu_descriptor;
 
   // Buffer info
   D3D12_GPU_VIRTUAL_ADDRESS buffer_gpu_address;
+  void *buffer_cpu_address;
   u64 buffer_element_offset;
   u64 buffer_element_stride;
   u64 buffer_element_count;

src/meta/meta.c

@@ -164,12 +164,14 @@ M_EmbedObj M_Embed(String store_name, String dir_path)
     BB_WriteUBits(&bbw, entries_count, 64);
 
     // Reserve entries space
-    u64 entry_size = 0
+    u64 entry_size = (
+      0
       + 8  // Store hash
       + 8  // Name start
       + 8  // Name end
       + 8  // Data start
-      + 8; // Data end
+      + 8  // Data end
+    );
     u8 *entries_start = BB_GetWrittenRaw(&bbw) + BB_GetNumBytesWritten(&bbw);
     u64 entries_size = entry_size * entries_count;
     String entries_str = STRING(entries_size, entries_start);

src/pp/pp.h

@@ -121,7 +121,7 @@ Struct(P_Ent)
 
   //- Client data
 
-  i64 local_observation_ns;
+  i64 observation_time_ns;
   b32 has_observed;
 
   //- Build data

src/pp/pp_vis/pp_vis_core.c

@@ -1895,56 +1895,54 @@ void V_TickForever(WaveLaneCtx *lane)
     //////////////////////////////
     //- Observe entities
 
+    for (P_Ent *ent = P_FirstEnt(local_frame); !P_IsEntNil(ent); ent = P_NextEnt(ent))
     {
-      for (P_Ent *ent = P_FirstEnt(local_frame); !P_IsEntNil(ent); ent = P_NextEnt(ent))
+      P_EntKey key = ent->key;
+      i64 expiration_ns = P_ObservationLifetimeNs;
+      i64 observation_time_ns = 0;
       {
-        P_EntKey key = ent->key;
+        V_ObservationBin *bin = &V.observation_bins[key.v % countof(V.observation_bins)];
-        i64 expiration_ns = P_ObservationLifetimeNs;
+        V_Observation *obs = bin->first;
-        i64 observation_time_ns = 0;
+        for (; obs; obs = obs->next)
         {
-          V_ObservationBin *bin = &V.observation_bins[key.v % countof(V.observation_bins)];
+          if (obs->key == key.v)
-          V_Observation *obs = bin->first;
-          for (; obs; obs = obs->next)
           {
-            if (obs->key == key.v)
+            break;
-            {
-              break;
-            }
           }
-          if (obs)
+        }
+        if (obs)
+        {
+          if (obs->time_ns + expiration_ns > frame->time_ns)
           {
-            if (obs->time_ns + expiration_ns > frame->time_ns)
+            // Re-observe matching expired observation
-            {
+            DllQueueRemove(V.first_observation, V.last_observation, obs);
-              // Re-observe expired observation
+            DllQueuePush(V.first_observation, V.last_observation, obs);
-              DllQueueRemove(V.first_observation, V.last_observation, obs);
+            obs->time_ns = frame->time_ns;
-              DllQueuePush(V.first_observation, V.last_observation, obs);
+          }
-              obs->time_ns = frame->time_ns;
+        }
-            }
+        else
+        {
+          if (V.first_observation && V.first_observation->time_ns + expiration_ns <= frame->time_ns)
+          {
+            // Remove expired observation for reuse
+            obs = V.first_observation;
+            V_ObservationBin *old_bin = &V.observation_bins[obs->key % countof(V.observation_bins)];
+            DllQueueRemove(V.first_observation, V.last_observation, obs);
+            DllQueueRemoveNP(old_bin->first, old_bin->last, obs, next_in_bin, prev_in_bin);
           }
           else
           {
-            if (V.first_observation && V.first_observation->time_ns + expiration_ns <= frame->time_ns)
+            obs = PushStruct(perm, V_Observation);
-            {
-              // Remove expired observation for reuse
-              obs = V.first_observation;
-              V_ObservationBin *old_bin = &V.observation_bins[obs->key % countof(V.observation_bins)];
-              DllQueueRemove(V.first_observation, V.last_observation, obs);
-              DllQueueRemoveNP(old_bin->first, old_bin->last, obs, next_in_bin, prev_in_bin);
-            }
-            else
-            {
-              obs = PushStruct(perm, V_Observation);
-            }
-            obs->key = key.v;
-            obs->time_ns = frame->time_ns;
-            DllQueuePush(V.first_observation, V.last_observation, obs);
-            DllQueuePushNP(bin->first, bin->last, obs, next_in_bin, prev_in_bin);
           }
-          observation_time_ns = obs->time_ns;
+          obs->key = key.v;
+          obs->time_ns = frame->time_ns;
+          DllQueuePush(V.first_observation, V.last_observation, obs);
+          DllQueuePushNP(bin->first, bin->last, obs, next_in_bin, prev_in_bin);
         }
-        ent->local_observation_ns = observation_time_ns;
+        observation_time_ns = obs->time_ns;
-        ent->has_observed = observation_time_ns == frame->time_ns;
       }
+      ent->observation_time_ns = observation_time_ns;
+      ent->has_observed = observation_time_ns < frame->time_ns;
     }