Exemplo n.º 1
0
ResourceManager::ResourceManager()
	: taskPool(nullptr)
	, archive(nullptr)
	, handleManager(nullptr)
	, numResourcesQueuedLoad(0)
	, asynchronousLoading(true)
{
	handleManager = HandleCreateManager( GetResourcesAllocator() );

	if( !gs_ResourcesManager )
		gs_ResourcesManager = this;

	if( !gs_ResourceHandleManager )
		gs_ResourceHandleManager = handleManager;

	ReflectionHandleContext context;
	context.type = ReflectionGetType(Resource);
	context.handles = gs_ResourceHandleManager;
	context.serialize = ResourceHandleSerialize;
	context.deserialize = ResourceHandleFind;
	
	ReflectionHandleContextMap contextMap;
	ReflectionSetHandleContext(&contextMap, context);

	resourceFinishLoadMutex = Allocate(GetResourcesAllocator(), Mutex);
	resourceFinishLoad = Allocate(GetResourcesAllocator(), Condition);
}
Exemplo n.º 2
0
void SelectionPlugin::onUndoOperation( const UndoOperationPtr& operation )
{
	assert( operation != nullptr );

	Class* klass = operation->getType();
	
	if( !ClassInherits(klass, ReflectionGetType(SelectionOperation)) )
		return;

	SelectionOperation* selection = RefCast<SelectionOperation>(operation).get();
	selection->redo();
}
Exemplo n.º 3
0
void InputManager::addDevice( InputDevice* device )
{
	if( !device )
	{
		LogWarn( "Tried to add an invalid input device" );
		return;
	}
	
	devices.push_back( device );

	LogInfo( "Registered a new input device: '%s'",
		EnumGetValueName(ReflectionGetType(InputDeviceType), (int32)device->getType()));
}
Exemplo n.º 4
0
EditorFrame::EditorFrame(const wxString& title)
	: wxFrame(nullptr, wxID_ANY, title)
	, paneCtrl(nullptr)
	, toolbarCtrl(nullptr)
	, statusCtrl(nullptr)
	, notebookCtrl(nullptr)
	, eventManager(nullptr)
	, pluginManager(nullptr)
	, documentManager(nullptr)
	, engine(nullptr)
	, archive(nullptr)
	, input(nullptr)
{
	gs_EditorInstance = this;

	CoreInitialize();

#ifdef EDITOR_OLD_UI
	documentManager = AllocateThis(DocumentManager);
	documentManager->onDocumentAdded.Connect(this, &EditorFrame::onDocumentAdded);
	documentManager->onDocumentRemoved.Connect(this, &EditorFrame::onDocumentRemoved);
	documentManager->onDocumentRenamed.Connect(this, &EditorFrame::onDocumentRenamed);
#endif

	createPlugins();

#ifdef EDITOR_OLD_UI
	createUI();
#endif

	createEngine();
	eventManager = AllocateThis(EventManager);

#ifdef ENABLE_PLUGIN_MONO
	Plugin* monoPlugin = pluginManager->getPluginFromClass( ReflectionGetType(MonoPlugin) );
	pluginManager->enablePlugin(monoPlugin);
#endif

#ifdef EDITOR_OLD_UI
	enablePlugins();
	createToolbar();
	createLastUI();
#endif

	Bind(wxEVT_IDLE, &EditorFrame::OnIdle, this);
	Bind(wxEVT_CLOSE_WINDOW, &EditorFrame::OnClose, this);

    auto projectPlugin = GetPlugin<ProjectPlugin>();
    projectPlugin->createDocument();
}
Exemplo n.º 5
0
void EditorFrame::createPlugins()
{
	pluginManager = AllocateThis(PluginManager);

	// Find and instantiate plugins.
	std::vector<Plugin*> plugins;
	ClassCreateChilds(ReflectionGetType(EditorPlugin), AllocatorGetThis(), plugins);
	
	PluginsSortByPriority(plugins);
	pluginManager->registerPlugins(plugins);

	// Notify plugins that they have been registered.
	for( size_t i = 0; i < plugins.size(); i++ )
	{
		EditorPlugin* plugin = (EditorPlugin*) plugins[i];
		plugin->onPluginRegistered();
	}
}
Exemplo n.º 6
0
void ResourcesPage::initControl()
{
	rootId = AddRoot( "Resources", resGroupIcons[RG(General)] );
	//resGroupIds[RG(General)] = AppendItem(rootId, "General", resGroupIcons[RG(General)]);

	Enum* enuhm = ReflectionGetType(ResourceGroup);
	const EnumValuesMap& values = enuhm->values;
	
	EnumValuesMap::const_iterator it;
	for( it = values.begin(); it != values.end(); it++ )
	{
		ResourceGroup group = (ResourceGroup) it->second;
		resGroupIds[group] = AppendItem(rootId, it->first, resGroupIcons[group]);
	}

	Bind(wxEVT_COMMAND_TREE_SEL_CHANGED, &ResourcesPage::onItemChanged, this);
	Bind(wxEVT_COMMAND_TREE_ITEM_MENU, &ResourcesPage::onTreeItemMenu, this);
	Bind(wxEVT_COMMAND_MENU_SELECTED, &ResourcesPage::onCommandMenuSelected, this);
}
Exemplo n.º 7
0
wxBitmap* ConvertImageToBitmap( Image* image, const Path& fullPath )
{
    if( !image || !image->isLoaded() )
        return nullptr;

    PixelFormat pf = image->getPixelFormat();

    if( pf != PixelFormat::R8G8B8A8 )
    {
        LogDebug("Invalid image format: %s", EnumGetValueName(ReflectionGetType(PixelFormat), (int32)pf));
        return nullptr;
    }

    //wxBitmap* bmp = new wxBitmap;
    //bmp->Create(&image->getBuffer(), wxBITMAP_TYPE_ANY, image->getWidth(), image->getHeight(), 4);

    Stream* stream = StreamCreateFromFile(AllocatorGetHeap(), fullPath, StreamOpenMode::Read);
    if( !stream ) return nullptr;

    std::vector<byte> data;
    StreamRead(stream, data);

    wxMemoryInputStream mem(&data[0], data.size());
    wxImage img(mem);
    img.Rescale(32, 32);

    StreamDestroy(stream);

#if 0
    const wxSize& size = GetSize();
    if( img.GetWidth() > size.GetWidth() || img.GetHeight() > size.GetHeight() )
    {
        img.Rescale( size.GetWidth(), size.GetHeight() );
    }
#endif

    wxBitmap* bmp = new wxBitmap(img);
    return bmp;
}
Exemplo n.º 8
0
Enum* UserMessageHandler::getMessagesEnum()
{
    return ReflectionGetType(UserMessageIds);
}
Exemplo n.º 9
0
void Camera::cull( RenderBlock& block, const Entity* entity )
{
	if( !entity ) return;

	// Try to see if this is a Group-derived node.
	Class* klass = entity->getType();
	
	if( ClassInherits(klass, ReflectionGetType(Group)) )
	{
		const Group* group = (Group*) entity;

		const Array<EntityPtr>& entities = group->getEntities();

		// Cull the children entities recursively.
		for( size_t i = 0; i < entities.size(); i++ )
		{
			const Entity* child = entities[i].get();
			cull( block, child );
		}

		return;
	}

	// If this is a visible.renderable object, then we perform frustum culling
	// and then we push it to a list of things passed later to the renderer.

	//entity->onPreCull();

	if( !entity->isVisible() )
		return;

	const Transform* transform = entity->getTransform().get();
	const BoundingBox& box = transform->getWorldBoundingVolume();

	bool isCulled = !entity->getTag(Tags::NonCulled);
	
	if( frustumCulling && isCulled && !frustum.intersects(box) )
		return;

	#pragma TODO("Fix multiple geometry instancing")

	const Array<GeometryPtr>& geoms = entity->getGeometry();

	for( size_t i = 0; i < geoms.size(); i++ )
	{
		const GeometryPtr& geometry = geoms[i];
		geometry->appendRenderables( block.renderables, transform );
	}

#if 0
	const LightPtr& light = entity->getComponent<Light>();
	
	if( light ) 
	{
		LightState ls;
		ls.light = light.get();
		ls.transform = transform.get();
	
		block.lights.pushBack( ls );
	}
#endif

#ifdef BUILD_DEBUG
	const ComponentMap& components = entity->getComponents();
	for( auto it = components.begin(); it != components.end(); it++ )
	{
		const ComponentPtr& component = it->value;
		component->onPreRender(*this);

		if( !component->isDebugRenderableVisible() )
			continue;

		DebugDrawFlags flags = (DebugDrawFlags) 0;
		component->onDebugDraw(drawer, flags);
	}
#endif
}