Remove useless code

engine/Sound.cpp

@@ -1,121 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#include "Sound.h"
-#include "SoundResource.h"
-#include "Vector3.h"
-#include "Quaternion.h"
-#include "Device.h"
-#include "Unit.h"
-
-namespace crown
-{
-
-//-----------------------------------------------------------------------------
-void Sound::create(SoundResource* sr, int32_t node, const Vector3& /*pos*/, const Quaternion& /*rot*/)
-{
-	SoundRenderer* s = device()->sound_renderer();
-
-	m_buffer = sr->m_id;
-	m_source = s->create_sound_source();
-	s->bind_buffer(m_buffer, m_source);
-
-	m_node = node;
-}
-
-//-----------------------------------------------------------------------------
-void Sound::destroy()
-{
-	device()->sound_renderer()->destroy_sound_source(m_source);
-}
-
-//-----------------------------------------------------------------------------
-Vector3	Sound::local_position() const
-{
-	return m_local_pose.translation();
-}
-
-//-----------------------------------------------------------------------------
-Quaternion Sound::local_rotation() const
-{
-	return m_local_pose.to_quaternion();
-}
-
-//-----------------------------------------------------------------------------
-Matrix4x4 Sound::local_pose() const
-{
-	return m_local_pose;
-}
-
-//-----------------------------------------------------------------------------
-Vector3	Sound::world_position() const
-{
-	return m_world_pose.translation();
-}
-
-//-----------------------------------------------------------------------------
-Quaternion Sound::world_rotation() const
-{
-	return m_world_pose.to_quaternion();
-}
-
-//-----------------------------------------------------------------------------
-Matrix4x4 Sound::world_pose() const
-{
-	return m_world_pose;
-}
-
-//-----------------------------------------------------------------------------
-void Sound::set_local_position(Unit* unit, const Vector3& pos)
-{
-	m_local_pose.set_translation(pos);
-
-	unit->set_local_position(pos, m_node);
-
-}
-
-//-----------------------------------------------------------------------------
-void Sound::set_local_rotation(Unit* unit, const Quaternion& rot)
-{
-	Matrix4x4& local_pose = m_local_pose;
-
-	Vector3 local_translation = local_pose.translation();
-	local_pose = rot.to_matrix4x4();
-	local_pose.set_translation(local_translation);
-
-	unit->set_local_rotation(rot, m_node);
-}
-
-//-----------------------------------------------------------------------------
-void Sound::set_local_pose(Unit* unit, const Matrix4x4& pose)
-{
-	m_local_pose = pose;
-
-	unit->set_local_pose(pose, m_node);
-}
-
-
-} // namespace crown

engine/Sound.h

@@ -1,72 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "SoundRenderer.h"
-#include "Matrix4x4.h"
-
-namespace crown
-{
-
-struct SoundResource;
-struct Vector3;
-struct Quaternion;
-struct Unit;
-
-struct Sound
-{
-	void			create(SoundResource* sr, int32_t node, const Vector3& pos, const Quaternion& dir);
-	void			destroy();
-
-	Vector3			local_position() const;
-	Quaternion		local_rotation() const;
-	Matrix4x4		local_pose() const;
-
-	Vector3			world_position() const;
-	Quaternion		world_rotation() const;
-	Matrix4x4		world_pose() const;
-
-	void			set_local_position(Unit* unit, const Vector3& pos);
-	void			set_local_rotation(Unit* unit, const Quaternion& rot);
-	void			set_local_pose(Unit* unit, const Matrix4x4& pose);
-
-public:
-
-	uint32_t		m_node;
-	Matrix4x4		m_local_pose;
-	Matrix4x4		m_world_pose;
-
-	float			m_volume;
-	float			m_range;
-	bool			m_loop : 1;
-	bool			m_playing : 1;
-
-	SoundBufferId	m_buffer;
-	SoundSourceId	m_source;
-};
-
-} // namespace crown

engine/SoundWorld.cpp

@@ -1,97 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#include "SoundWorld.h"
-#include "Device.h"
-#include "SoundRenderer.h"
-#include "ResourceManager.h"
-
-namespace crown
-{
-
-//-----------------------------------------------------------------------------
-SoundWorld::SoundWorld()
-	: m_sounds_pool(default_allocator(), MAX_SOUNDS, sizeof(Sound))
-	, m_sounds(default_allocator())
-{
-	device()->sound_renderer()->set_listener(Vector3::ZERO, Vector3(1, 0, 0), Vector3(0, 1, 0), Vector3(1, 0, 0));
-}
-
-//-----------------------------------------------------------------------------
-SoundWorld::~SoundWorld()
-{
-}
-
-//-----------------------------------------------------------------------------
-SoundId	SoundWorld::create_sound(ResourceId id, int32_t node, const Vector3& pos, const Quaternion& rot)
-{
-	SoundResource* sr = (SoundResource*) device()->resource_manager()->data(id);
-
-	Sound* sound = (Sound*) m_sounds_pool.allocate(sizeof(Sound));
-
-	const SoundId sound_id = m_sounds.create(sound);
-	sound->create(sr, node, pos, rot);
-
-	return sound_id;
-}
-
-//-----------------------------------------------------------------------------
-void SoundWorld::destroy_sound(SoundId /*id*/)
-{
-	// Stub
-}
-
-//-----------------------------------------------------------------------------
-Sound* SoundWorld::lookup_sound(SoundId id)
-{
-	CE_ASSERT(m_sounds.has(id), "Sound does not exits");
-
-	return m_sounds.lookup(id);
-}
-
-//-----------------------------------------------------------------------------
-void SoundWorld::update(float /*dt*/)
-{
-	List<Sound*>& sounds = m_sounds.m_objects; 
-	for (uint32_t i = 0; i < sounds.size(); i++)
-	{
-		Sound* sound = sounds[i];
-
-		device()->sound_renderer()->set_sound_loop(sound->m_source, sound->m_loop);
-		device()->sound_renderer()->set_sound_gain(sound->m_source, sound->m_volume);
-		device()->sound_renderer()->set_sound_max_distance(sound->m_source, sound->m_range);
-		device()->sound_renderer()->set_sound_position(sound->m_source, sound->m_world_pose.translation());
-
-		if (!sound->m_playing)
-		{
-			device()->sound_renderer()->play_sound(sound->m_source);
-			sound->m_playing = true;
-		}
-	}
-}
-
-
-} // namespace crown

engine/SoundWorld.h

@@ -1,63 +0,0 @@
-/*
-Copyright (c) 2013 Daniele Bartolini, Michele Rossi
-Copyright (c) 2012 Daniele Bartolini, Simone Boscaratto
-
-Permission is hereby granted, free of charge, to any person
-obtaining a copy of this software and associated documentation
-files (the "Software"), to deal in the Software without
-restriction, including without limitation the rights to use,
-copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the
-Software is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
-OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
-WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-OTHER DEALINGS IN THE SOFTWARE.
-*/
-
-#pragma once
-
-#include "IdArray.h"
-#include "IdTable.h"
-#include "Sound.h"
-#include "List.h"
-#include "Vector3.h"
-#include "Quaternion.h"
-#include "PoolAllocator.h"
-#include "Resource.h"
-
-#define MAX_SOUNDS 64
-
-namespace crown
-{
-
-typedef Id SoundId;
-
-class SoundWorld
-{
-public:
-				SoundWorld();
-				~SoundWorld();
-
-	SoundId		create_sound(ResourceId id, int32_t node = -1, const Vector3& pos = Vector3::ZERO, const Quaternion& rot = Quaternion::IDENTITY);
-	void		destroy_sound(SoundId id);
-	Sound*		lookup_sound(SoundId id);
-
-	void		update(float dt);
-
-private:
-
-	PoolAllocator					m_sounds_pool;
-	IdArray<MAX_SOUNDS, Sound*>		m_sounds;
-};
-
-} // namespace crown

engine/resource/SoundResource.h

@@ -52,7 +52,6 @@ const uint32_t SOUND_VERSION = 1;
 //-----------------------------------------------------------------------------
 struct SoundHeader
 {
-	SoundBufferId	sb;
 	uint32_t		version;	// Sound file version
 	uint32_t		size;
 	uint32_t		sample_rate;
@@ -84,12 +83,6 @@ public:
 	//-----------------------------------------------------------------------------
 	static void online(void* resource)
 	{
-		CE_ASSERT_NOT_NULL(resource);
-
-		SoundResource* sr = (SoundResource*)resource;
-		SoundHeader* h = (SoundHeader*) sr;
-
-		h->sb = device()->sound_renderer()->create_sound_buffer((void*)sr->data(), sr->size(), sr->sample_rate(), sr->channels(), sr->bits_ps());
 	}
 
 	//-----------------------------------------------------------------------------
@@ -102,10 +95,6 @@ public:
 	//-----------------------------------------------------------------------------
 	static void offline(void* resource)
 	{
-		CE_ASSERT_NOT_NULL(resource);
-
-		SoundHeader* s = (SoundHeader*) resource;
-		device()->sound_renderer()->destroy_sound_buffer(s->sb);
 	}
 
 public:
@@ -150,11 +139,6 @@ public:
 		return ((char*) this) + sizeof(SoundHeader);
 	}
 
-	SoundBufferId sound_buffer() const
-	{
-		return ((SoundHeader*) this)->sb;
-	}
-
 private:
 
 	// Disable construction

engine/world/World.cpp

@@ -39,7 +39,6 @@ namespace crown
 World::World()
 	: m_unit_pool(default_allocator(), MAX_UNITS, sizeof(Unit), CE_ALIGNOF(Unit))
 	, m_camera_pool(default_allocator(), MAX_CAMERAS, sizeof(Camera), CE_ALIGNOF(Camera))
-	, m_unit_to_sound(default_allocator())
 {
 	m_id.id = INVALID_ID;
 }
@@ -188,97 +187,41 @@ void World::destroy_camera(CameraId id)
 //-----------------------------------------------------------------------------
 SoundId World::play_sound(const char* name, const bool loop, const float volume, const Vector3& pos, const float range)
 {
-	SoundResource* sr = (SoundResource*)device()->resource_manager()->lookup(SOUND_EXTENSION, name);
-	return play_sound(sr, loop, volume, pos, range);
 }
 
 //-----------------------------------------------------------------------------
 SoundId World::play_sound(SoundResource* sr, bool loop, float volume, const Vector3& pos, float range)
 {
-	SoundRenderer* renderer = device()->sound_renderer();
-	const SoundSourceId source = renderer->create_sound_source();
-
-	Sound s;
-	s.buffer = sr->sound_buffer();
-	s.source = source;
-	s.world = Matrix4x4(Quaternion::IDENTITY, pos);
-	s.volume = volume;
-	s.range = range;
-	s.loop = loop;
-	s.playing = false;
-
-	SoundId id = m_sounds.create(s);
-
-	renderer->bind_buffer(s.buffer, s.source);
-	renderer->set_sound_loop(s.source, s.loop);
-	renderer->set_sound_gain(s.source, s.volume);
-	renderer->set_sound_max_distance(s.source, s.range);
-	renderer->set_sound_position(s.source, s.world.translation());
-	renderer->play_sound(s.source);
-
-	return id;
 }
 
 //-----------------------------------------------------------------------------
 void World::stop_sound(SoundId id)
 {
-	CE_ASSERT(m_sounds.has(id), "Sound does not exists");
-
-	const Sound& s = m_sounds.lookup(id);
-	SoundRenderer* sr = device()->sound_renderer();
-
-	sr->pause_sound(s.source);
-	sr->unbind_buffer(s.source);
-	sr->destroy_sound_source(s.source);
-
-	m_sounds.destroy(id);
 }
 
 //-----------------------------------------------------------------------------
 void World::link_sound(SoundId id, Unit* unit, int32_t node)
 {
-	//CE_ASSERT(m_units.has(unit), "Unit does not exists");
-	CE_ASSERT(m_sounds.has(id), "Sound does not exists");
-
-	UnitToSound uts;
-	uts.sound = id;
-	uts.unit = unit->m_id;
-	uts.node = node;
-
-	m_unit_to_sound.push_back(uts);
 }
 
 //-----------------------------------------------------------------------------
 void World::set_listener(const Vector3& pos, const Vector3& vel, const Vector3& or_up, const Vector3& or_at)
 {
-	device()->sound_renderer()->set_listener(pos, vel, or_up, or_at);
 }
 
 //-----------------------------------------------------------------------------
 void World::set_sound_position(SoundId id, const Vector3& pos)
 {
-	CE_ASSERT(m_sounds.has(id), "Sound does not exists");
-
-	Sound& sound = m_sounds.lookup(id);
-	sound.world = Matrix4x4(Quaternion::IDENTITY, pos);
 }
 
 //-----------------------------------------------------------------------------
 void World::set_sound_range(SoundId id, const float range)
 {
-	CE_ASSERT(m_sounds.has(id), "Sound does not exists");
-
-	Sound& sound = m_sounds.lookup(id);
-	sound.range = range;
 }
 
 //-----------------------------------------------------------------------------
 void World::set_sound_volume(SoundId id, const float vol)
 {
-	CE_ASSERT(m_sounds.has(id), "Sound does not exists");
-
-	Sound& sound = m_sounds.lookup(id);
-	sound.volume = vol;
 }
 
 //-----------------------------------------------------------------------------

engine/world/World.h

@@ -45,30 +45,10 @@ namespace crown
 {
 
 #define MAX_UNITS 65000
-#define	MAX_SOUNDS 64
 #define MAX_CAMERAS 16
 
 typedef Id SoundId;
 
-struct Sound
-{
-	SoundBufferId buffer;
-	SoundSourceId source;
-	
-	Matrix4x4 world;
-	float volume;
-	float range;
-	bool loop : 1;
-	bool playing : 1;
-};
-
-struct UnitToSound
-{
-	UnitId unit;
-	SoundId sound;
-	int32_t node;
-};
-
 struct Mesh;
 struct Sprite;
 struct Actor;
@@ -128,10 +108,6 @@ private:
 
 	IdArray<MAX_UNITS, Unit*>			m_units;
 	IdArray<MAX_CAMERAS, Camera*>		m_cameras;
-	IdArray<MAX_SOUNDS, Sound> 			m_sounds;
-
-	// Connections
-	List<UnitToSound>					m_unit_to_sound;
 
 	SceneGraphManager					m_scenegraph_manager;
 	RenderWorld							m_render_world;