Subversion Repository Public Repository

Divide-Framework

This repository has no backups
This repository's network speed is throttled to 100KB/sec

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include "Headers/VisualSensor.h"

#include "AI/Headers/AIEntity.h"
#include "Core/Math/Headers/Transform.h"
#include "Graphs/Headers/SceneGraphNode.h"
#include "Dynamics/Entities/Units/Headers/NPC.h"

namespace Divide {
using namespace AI;

VisualSensor::VisualSensor(AIEntity* const parentEntity) : Sensor(parentEntity, VISUAL_SENSOR) 
{
}

VisualSensor::~VisualSensor()
{
	for (NodeContainerMap::value_type& container : _nodeContainerMap) {
		container.second.clear();
	}
	_nodeContainerMap.clear();
	_nodePositionsMap.clear();
}

void VisualSensor::followSceneGraphNode(U32 containerID, SceneGraphNode* const node) {
    DIVIDE_ASSERT(node != nullptr, "VisualSensor error: Invalid node specified for follow function");
	NodeContainerMap::iterator container = _nodeContainerMap.find(containerID);

    if (container != _nodeContainerMap.end()) {
        NodeContainer::const_iterator nodeEntry = container->second.find(node->getGUID());
        if (nodeEntry == container->second.end()) {
            hashAlg::emplace(container->second, node->getGUID(), node);
			node->registerDeletionCallback(DELEGATE_BIND(&VisualSensor::unfollowSceneGraphNode,
                                                         this,
                                                         containerID, 
                                                         node->getGUID()));
        } else {
            ERROR_FN("VisualSensor: Added the same node to follow twice!");
        }
    } else {
        NodeContainer& newContainer = _nodeContainerMap[containerID];
        hashAlg::emplace(newContainer, node->getGUID(), node);
		node->registerDeletionCallback(DELEGATE_BIND(&VisualSensor::unfollowSceneGraphNode, 
                                                     this, 
                                                     containerID, 
                                                     node->getGUID() ) );
    }

    NodePositions& positions = _nodePositionsMap[containerID];
    hashAlg::emplace(positions, node->getGUID(), node->getComponent<PhysicsComponent>()->getPosition());
}

void VisualSensor::unfollowSceneGraphNode(U32 containerID, U64 nodeGUID) {
    DIVIDE_ASSERT(nodeGUID != 0, "VisualSensor error: Invalid node GUID specified for unfollow function");
	NodeContainerMap::iterator container = _nodeContainerMap.find(containerID);
    if (container != _nodeContainerMap.end()) {
        NodeContainer::iterator nodeEntry = container->second.find(nodeGUID);
        if (nodeEntry != container->second.end()) {
            container->second.erase(nodeEntry);
        } else {
            ERROR_FN("VisualSensor: Specified node does not exist in specified container!");
        }
    } else {
        ERROR_FN("VisualSensor: Invalid container specified for unfollow!");
    }
}


void VisualSensor::update( const U64 deltaTime ) {
    for (const NodeContainerMap::value_type& container : _nodeContainerMap ) {
        NodePositions& positions = _nodePositionsMap[container.first];
        for (const NodeContainer::value_type& entry : container.second ) {
            positions[entry.first] = entry.second->getComponent<PhysicsComponent>()->getPosition();
        }
    }
}

SceneGraphNode* const VisualSensor::getClosestNode(U32 containerID) {
    NodeContainerMap::iterator container = _nodeContainerMap.find(containerID);
    if ( container != _nodeContainerMap.end() ) {
        NodePositions& positions = _nodePositionsMap[container->first];
        NPC* const unit = _parentEntity->getUnitRef();
        if ( unit ) {
            const vec3<F32>& currentPosition = unit->getCurrentPosition();
            U64 currentNearest = 0;
            U32 currentDistanceSq = 0;
            for (const NodePositions::value_type& entry : positions ) {
                U32 temp = currentPosition.distanceSquared( entry.second );
                if ( temp < currentDistanceSq ) {
                    currentDistanceSq = temp;
                    currentNearest = entry.first;
                }
            }
            if ( currentNearest != 0 ) {
                NodeContainer::const_iterator nodeEntry = container->second.find( currentNearest );
                if ( nodeEntry != container->second.end() ) {
                    return nodeEntry->second;
                }
            }
        }
    }
    return nullptr;
}

F32 VisualSensor::getDistanceToNodeSq(U32 containerID, U64 nodeGUID) {
    DIVIDE_ASSERT(nodeGUID != 0, "VisualSensor error: Invalid node GUID specified for distance request");
    NPC* const unit = _parentEntity->getUnitRef();
    if (unit) {
        return unit->getCurrentPosition().distanceSquared(getNodePosition(containerID, nodeGUID));          
    }

    return std::numeric_limits<F32>::max();
}

vec3<F32> VisualSensor::getNodePosition(U32 containerID, U64 nodeGUID) {
    DIVIDE_ASSERT(nodeGUID != 0, "VisualSensor error: Invalid node GUID specified for position request");
	NodeContainerMap::iterator container = _nodeContainerMap.find(containerID);
    if (container != _nodeContainerMap.end()) {
        NodePositions& positions = _nodePositionsMap[container->first];
        NodePositions::iterator it = positions.find(nodeGUID);
        if (it != positions.end()) {
            return it->second;          
        }
    }

    return vec3<F32>(std::numeric_limits<F32>::max());
}

}; //namespace Divide

Commits for Divide-Framework/trunk/Source Code/AI/Sensors/VisualSensor.cpp

Diff revisions: vs.
Revision Author Commited Message
331 Diff Diff IonutCava picture IonutCava Sat 06 Dec, 2014 20:53:45 +0000

[Ionut]
- Limited line length to 132 characters to improve readability and diff-comparisons
- Refactored memory allocation/deallocation functions
- Fixed a few compatibility issues with HashMap.h
- Fixed a bug in GPU Skinning shaders (cast a float to int)

326 Diff Diff IonutCava picture IonutCava Tue 30 Sep, 2014 21:11:32 +0000

[Ionut]
- Fixed more memory leaks
- Simplified Task interface and timing System
- Improved compatibility between Boost, STL and EASTL with random combinations of vectors, strings and maps
- Simplified Light class by removing the “slot” member
- Random optimizations

325 Diff Diff IonutCava picture IonutCava Wed 17 Sep, 2014 20:06:13 +0000

[Ionut]
- Reworked transform system:
— Parent transform chain system moved from Transform class to the PhysicsComponent
— PhysicsComponent now returns all transform values needed both global and local (still needs heavy optimization and caching)

- Reworked SceneGraph node management:
— Proper ref counting of SceneNodes and proper removing of resource (ResourceCache is now empty on destruction, as it should be)
— Removed parent transform tracking as that’s the PhysicsComponent’s responsibility
— Only nodes loaded via the ResourceCache are allowed to be added to the SceneGraph (added proper loaders for Impostors, Sky, etc)

- Optimized some of the math classes (mat4, mat3)

324 Diff Diff IonutCava picture IonutCava Sun 14 Sep, 2014 14:01:39 +0000

[Ionut]
- New memory management system (no custom allocators in this commit)
— Memory tracer to detect memory leaks on shutdown (from: https://www.relisoft.com/book/tech/9new.html)
— SAFE_DELETE_XYZ are now inline template functions not macros
— ASSERTION system now supports logging and message boxes and continue on error configurable for each build type
— Fixed a lot of memory leaks detected by the new system (some still remain)

- Added SRGB support (part 1)
— Albedo textures are loaded as SRGB (make sure resources are SRGB)
— Shaders output gamma corrected colors
— Moved terrain textures back to 2 array system (albedo and normal maps, albedo maps using a SRGB sampler)

- Sky is now loaded via the ResourceCache system
- Added include safeguards in shader atoms

321 Diff Diff IonutCava picture IonutCava Wed 03 Sep, 2014 22:05:15 +0000

[Ionut]
- Added support (and enabled by default) for the EASTL library (http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2271.html / https://github.com/paulhodge/EASTL)
— Strings, vectors and hash_maps can be combined from EASTL, STL and Boost (not all combinations work. e.g. EASTL strings with STL/Boost containers due to the lack of a proper hash function)

320 Diff Diff IonutCava picture IonutCava Sun 31 Aug, 2014 21:45:33 +0000

[Ionut]
- More AI work (entity captures flag and returns it to base)

319 Diff Diff IonutCava picture IonutCava Sat 30 Aug, 2014 21:37:57 +0000

[Ionut]
- Performance tweaks based on profiling data

318 Diff Diff IonutCava picture IonutCava Sat 30 Aug, 2014 17:35:53 +0000

[Ionut]
- Wrapped the entire code in a “Divide” namespace
- VertexBuffers now call “shrink_to_fit” on all internal data storage
- Improved some vector performance by preferring “emplace_back” instead of “push_back” + proepr usage of reserve / resize
- Wrapped OIS specific types and classes in Divide::Input namespace
- Added the messageBox.layout file (forgot it in the previous few commits)

314 Diff Diff IonutCava picture IonutCava Sun 24 Aug, 2014 19:54:33 +0000

[Ionut]
- More AI work
- Added some needed audio dlls

313 IonutCava picture IonutCava Sat 23 Aug, 2014 23:46:25 +0000

[Ionut]
- Added a messageBox gui element. Simple title/message hide/show System
- Added a working memory system to the WarSceneAISceneImpl class and a few memory facts for testing
- Reworked AI sensor system