bool NzMesh::IsAnimable() const
{
	#if NAZARA_UTILITY_SAFE
	if (!m_impl)
	{
		NazaraError("Mesh not created");
		return false;
	}
	#endif

	return m_impl->animationType != nzAnimationType_Static;
}

void NzLuaInstance::Compute(nzLuaOperation operation)
{
	#ifdef NAZARA_DEBUG
	if (operation > nzLuaOperation_Max)
	{
		NazaraError("Lua operation out of enum");
		return;
	}
	#endif

	lua_arith(m_state, s_operations[operation]);
}

	void TaskScheduler::SetWorkerCount(unsigned int workerCount)
	{
		#ifdef NAZARA_CORE_SAFE
		if (TaskSchedulerImpl::IsInitialized())
		{
			NazaraError("Worker count cannot be set while initialized");
			return;
		}
		#endif

		s_workerCount = workerCount;
	}

	bool Animation::IsLoopPointInterpolationEnabled() const
	{
		#if NAZARA_UTILITY_SAFE
		if (!m_impl)
		{
			NazaraError("Animation not created");
			return false;
		}
		#endif

		return m_impl->loopPointInterpolation;
	}

	UInt32 Music::GetSampleRate() const
	{
		#if NAZARA_AUDIO_SAFE
		if (!m_impl)
		{
			NazaraError("Music not created");
			return 0;
		}
		#endif

		return m_impl->sampleRate;
	}

	/*!
	* \brief Loads the sound from memory
	* \return true if loading is successful
	*
	* \param data Raw memory
	* \param size Size of the memory
	* \param params Parameters for the sound
	*
	* \remark Produces a NazaraError if loading failed
	*/
	bool Sound::LoadFromMemory(const void* data, std::size_t size, const SoundBufferParams& params)
	{
		SoundBufferRef buffer = SoundBuffer::New();
		if (!buffer->LoadFromMemory(data, size, params))
		{
			NazaraError("Failed to load buffer from memory (" + String::Pointer(data) + ')');
			return false;
		}

		SetBuffer(buffer);
		return true;
	}

	void TaskSchedulerImpl::WaitForTasks()
	{
		#ifdef NAZARA_CORE_SAFE
		if (s_workerCount == 0)
		{
			NazaraError("Task scheduler is not initialized");
			return;
		}
		#endif

		WaitForMultipleObjects(s_workerCount, &s_doneEvents[0], true, INFINITE);
	}

void NzScene::RegisterForUpdate(NzUpdatable* object)
{
	#if NAZARA_GRAPHICS_SAFE
	if (!object)
	{
		NazaraError("Invalid object");
		return;
	}
	#endif

	m_impl->updateList.push_back(object);
}

	void EventImpl::SetMousePosition(int x, int y, const Window& relativeTo)
	{
		HWND handle = reinterpret_cast<HWND>(relativeTo.GetHandle());
		if (handle)
		{
			POINT pos = {x, y};
			ClientToScreen(handle, &pos);
			SetCursorPos(pos.x, pos.y);
		}
		else
			NazaraError("Invalid window handle");
		}

	bool RenderWindow::CopyToImage(AbstractImage* image, const Vector3ui& dstPos) const
	{
		#if NAZARA_RENDERER_SAFE
		if (!m_context)
		{
			NazaraError("Window has not been created");
			return false;
		}
		#endif

		return CopyToImage(image, Rectui(Vector2ui(0U), GetSize()), dstPos);
	}

NzTexture* NzDeferredRenderTechnique::GetGBuffer(unsigned int i) const
{
#if NAZARA_GRAPHICS_SAFE
    if (i >= 3)
    {
        NazaraError("GBuffer texture index out of range (" + NzString::Number(i) + " >= 3)");
        return nullptr;
    }
#endif

    return m_GBuffer[i];
}