add ode

1 files changed, 259 insertions, 0 deletions

diff --git a/libs/ode-0.16.1/ode/src/resource_control.cpp b/libs/ode-0.16.1/ode/src/resource_control.cpp
new file mode 100644
index 0000000..29a3d83
--- /dev/null
+++ b/libs/ode-0.16.1/ode/src/resource_control.cpp
@@ -0,0 +1,259 @@
+/*************************************************************************
+ *                                                                       *
+ * Open Dynamics Engine, Copyright (C) 2001,2002 Russell L. Smith.       *
+ * All rights reserved.  Email: russ@q12.org   Web: www.q12.org          *
+ *                                                                       *
+ * This library is free software; you can redistribute it and/or         *
+ * modify it under the terms of EITHER:                                  *
+ *   (1) The GNU Lesser General Public License as published by the Free  *
+ *       Software Foundation; either version 2.1 of the License, or (at  *
+ *       your option) any later version. The text of the GNU Lesser      *
+ *       General Public License is included with this library in the     *
+ *       file LICENSE.TXT.                                               *
+ *   (2) The BSD-style license that is included with this library in     *
+ *       the file LICENSE-BSD.TXT.                                       *
+ *                                                                       *
+ * This library is distributed in the hope that it will be useful,       *
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the files    *
+ * LICENSE.TXT and LICENSE-BSD.TXT for more details.                     *
+ *                                                                       *
+ *************************************************************************/
+
+/*
+ * Resource accounting/preallocation class implementations
+ * Copyright (c) 2017-2019 Oleh Derevenko, odar@eleks.com (change all "a" to "e")
+ */
+
+
+#include <ode/common.h>
+#include <ode/cooperative.h>
+#include "config.h"
+#include "resource_control.h"
+#include "simple_cooperative.h"
+
+
+//////////////////////////////////////////////////////////////////////////
+// dxResourceRequirementDescriptor();
+
+dxResourceRequirementDescriptor::~dxResourceRequirementDescriptor()
+{
+    // Do nothing
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// dxRequiredResourceContainer
+
+dxRequiredResourceContainer::~dxRequiredResourceContainer()
+{
+    freeResources();
+}
+
+
+bool dxRequiredResourceContainer::allocateResources(const dxResourceRequirementDescriptor &requirementDescriptor)
+{
+    bool result = false;
+    
+    bool bufferAllocated = false;
+
+    do
+    {
+        sizeint memorySizeRequirement = requirementDescriptor.getMemorySizeRequirement();
+        
+        if (memorySizeRequirement != 0)
+        {
+            unsigned memoryAlignmentRequirement = requirementDescriptor.getMemoryAlignmentRequirement();
+            void *bufferAllocated = m_memoryAllocation.allocAligned(memorySizeRequirement, memoryAlignmentRequirement);
+            if (bufferAllocated == NULL)
+            {
+                break;
+            }
+        }
+        bufferAllocated = true;
+
+        dxThreadingBase *relatedThreading = requirementDescriptor.getrelatedThreading();
+        dIASSERT(relatedThreading != NULL);
+
+        unsigned simultaneousCallRequirement = requirementDescriptor.getSimultaneousCallRequirement();
+        if (simultaneousCallRequirement != 0)
+        {
+            if (!relatedThreading->PreallocateResourcesForThreadedCalls(simultaneousCallRequirement))
+            {
+                break;
+            }
+        }
+
+        dCallWaitID stockCallWait = NULL;
+
+        if (requirementDescriptor.getIsStockCallWaitRequired())
+        {
+             stockCallWait = relatedThreading->AllocateOrRetrieveStockCallWaitID();
+             if (stockCallWait == NULL)
+             {
+                 break;
+             }
+        }
+
+        m_relatedThreading = relatedThreading;
+    	m_stockCallWait = stockCallWait;
+    
+    	result = true;
+    }
+    while (false);
+
+    if (!result)
+    {
+        if (bufferAllocated)
+        {
+            m_memoryAllocation.freeAllocation();
+        }
+    }
+    
+    return result;
+
+}
+
+void dxRequiredResourceContainer::freeResources()
+{
+    if (m_relatedThreading != NULL)
+    {
+        m_relatedThreading = NULL;
+        m_stockCallWait = NULL;
+        m_memoryAllocation.freeAllocation();
+    }
+    else
+    {
+        dIASSERT(m_stockCallWait == NULL);
+        dIASSERT(m_memoryAllocation.getUserAreaPointer() == NULL);
+    }
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// Public interface functions
+
+static inline 
+dResourceRequirementsID encodeResourceRequirementsID(dxResourceRequirementDescriptor *requirementsDescriptor)
+{
+    return (dResourceRequirementsID)requirementsDescriptor;
+}
+
+
+/*extern ODE_API */
+dResourceRequirementsID dResourceRequirementsCreate(dCooperativeID cooperative)
+{
+    dAASSERT(cooperative != NULL);
+
+    dxSimpleCooperative *cooperativeInstance = decodeCooperativeID(cooperative);
+    dxThreadingBase *threading = cooperativeInstance->getRelatedThreading();
+
+    dxResourceRequirementDescriptor *requirementsDescriptor = new dxResourceRequirementDescriptor(threading);
+    
+    dResourceRequirementsID result = encodeResourceRequirementsID(requirementsDescriptor);
+    return result;
+}
+
+/*extern ODE_API */
+void dResourceRequirementsDestroy(dResourceRequirementsID requirements)
+{
+    dxResourceRequirementDescriptor *requirementsDescriptor = decodeResourceRequirementsID(requirements);
+
+    if (requirementsDescriptor != NULL)
+    {
+        delete requirementsDescriptor;
+    }
+}
+
+
+/*extern ODE_API */
+dResourceRequirementsID dResourceRequirementsClone(/*const */dResourceRequirementsID requirements)
+{
+    dAASSERT(requirements != NULL);
+
+    dxResourceRequirementDescriptor *requirementsDescriptor = decodeResourceRequirementsID(requirements);
+
+    dxResourceRequirementDescriptor *descriptorClone = new dxResourceRequirementDescriptor(*requirementsDescriptor);
+
+    dResourceRequirementsID result = encodeResourceRequirementsID(descriptorClone);
+    return result;
+}
+
+/*extern ODE_API */
+void dResourceRequirementsMergeIn(dResourceRequirementsID summaryRequirements, /*const */dResourceRequirementsID extraRequirements)
+{
+    dAASSERT(summaryRequirements != NULL);
+    dAASSERT(extraRequirements != NULL);
+
+    dxResourceRequirementDescriptor *summaryDescriptor = decodeResourceRequirementsID(summaryRequirements);
+    dxResourceRequirementDescriptor *extraDescriptor = decodeResourceRequirementsID(extraRequirements);
+
+    summaryDescriptor->mergeAnotherDescriptorIn(*extraDescriptor);
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+
+static inline 
+dResourceContainerID encodeResourceContainerID(dxRequiredResourceContainer *containerInstance)
+{
+    return (dResourceContainerID)containerInstance;
+}
+
+
+/*extern ODE_API */
+dResourceContainerID dResourceContainerAcquire(/*const */dResourceRequirementsID requirements)
+{
+    dAASSERT(requirements != NULL);
+
+    dResourceContainerID result = NULL;
+    bool allocationSucceeded = false;
+    
+    dxRequiredResourceContainer *containerInstance;
+    bool containerAllocated = false;
+
+    dxResourceRequirementDescriptor *requirementsInstance = decodeResourceRequirementsID(requirements);
+
+    do
+    {
+        containerInstance = new dxRequiredResourceContainer();
+
+        if (containerInstance == NULL)
+        {
+            break;
+        }
+
+        containerAllocated = true;
+    
+        if (!containerInstance->allocateResources(*requirementsInstance))
+        {
+            break;
+        }
+
+    	result = encodeResourceContainerID(containerInstance);
+        allocationSucceeded = true;
+    }
+    while (false);
+
+    if (!allocationSucceeded)
+    {
+        if (containerAllocated)
+        {
+            delete containerInstance;
+        }
+    }
+    
+    return result;
+}
+
+/*extern ODE_API */
+void dResourceContainerDestroy(dResourceContainerID resources)
+{
+    dxRequiredResourceContainer *containerInstance = decodeResourceContainerID(resources);
+
+    if (containerInstance != NULL)
+    {
+        delete containerInstance;
+    }
+}
+