Ejemplo n.º 1
0
WError WImage::Load(std::string filename, bool bDynamic) {
	// check if file exists
	FILE* fp;
	fopen_s(&fp, filename.c_str(), "r");
	if (fp)
		fclose(fp);
	else
		return WError(W_FILENOTFOUND);

	int n = 4, w, h;
	unsigned char *data;
	if (stbi_info(filename.c_str(), &w, &h, &n) == 0)
		return WError(W_INVALIDFILEFORMAT);
	data = stbi_load(filename.c_str(), &w, &h, &n, 0);
	if (!data)
		return WError(W_INVALIDFILEFORMAT);

	// convert from 8-bit char components to 32-bit float components
	float* pixels = new float[w*h*n];
	for (int i = 0; i < w*h*n; i++) {
		float f = (float)data[i] / (float)(unsigned char)(-1);
		pixels[i] = f;
	}
	free(data);

	WError err = CreateFromPixelsArray(pixels, w, h, bDynamic, n);
	delete[] pixels;

	return err;
}
Ejemplo n.º 2
0
WError WMaterial::Bind(WRenderTarget* rt, unsigned int num_vertex_buffers) {
	if (!Valid())
		return WError(W_NOTVALID);

	VkDevice device = m_app->GetVulkanDevice();
	VkCommandBuffer renderCmdBuffer = rt->GetCommnadBuffer();
	if (!renderCmdBuffer)
		return WError(W_NORENDERTARGET);

	int curDSIndex = 0;
	for (int i = 0; i < m_sampler_info.size(); i++) {
		W_BOUND_RESOURCE* info = m_sampler_info[i].sampler_info;
		if (m_sampler_info[i].img && m_sampler_info[i].img->Valid()) {
			m_sampler_info[i].descriptor.imageView = m_sampler_info[i].img->GetView();

			VkWriteDescriptorSet writeDescriptorSet = {};
			writeDescriptorSet.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
			writeDescriptorSet.dstSet = m_descriptorSet;
			writeDescriptorSet.descriptorCount = 1;
			writeDescriptorSet.descriptorType = VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
			writeDescriptorSet.pImageInfo = &m_sampler_info[i].descriptor;
			writeDescriptorSet.dstBinding = info->binding_index;

			m_writeDescriptorSets[curDSIndex++] = writeDescriptorSet;
		}
	}
	if (curDSIndex)
		vkUpdateDescriptorSets(device, curDSIndex, m_writeDescriptorSets.data(), 0, NULL);

	vkCmdBindDescriptorSets(renderCmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *m_effect->GetPipelineLayout(), 0, 1, &m_descriptorSet, 0, NULL);

	return m_effect->Bind(rt, num_vertex_buffers);
}
Ejemplo n.º 3
0
WSockets::WSockets()
{
	if (!(m_RefCount++)) {
		if (WSAStartup(0x0101, &m_wsaData))
			throw WError(SOCKETS_CANT_INITIALIZE);
		if (m_wsaData.wVersion != 0x0101)
			throw WError(SOCKETS_WRONG_VERSION);
	}
}
Ejemplo n.º 4
0
WError WMaterial::SaveToStream(WFile* file, std::ostream& outputStream) {
	if (!Valid())
		return WError(W_NOTVALID);

	VkDevice device = m_app->GetVulkanDevice();

	// write the UBO data
	uint tmp = m_uniformBuffers.size();
	outputStream.write((char*)&tmp, sizeof(tmp));
	for (uint i = 0; i < m_uniformBuffers.size(); i++) {
		UNIFORM_BUFFER_INFO* UBO = &m_uniformBuffers[i];
		outputStream.write((char*)&UBO->descriptor.range, sizeof(UBO->descriptor.range));
		void* data;
		VkResult vkRes = vkMapMemory(device, m_uniformBuffers[i].memory, 0, UBO->descriptor.range, 0, (void **)&data);
		if (vkRes)
			return WError(W_UNABLETOMAPBUFFER);
		outputStream.write((char*)data, UBO->descriptor.range);
		vkUnmapMemory(device, m_uniformBuffers[0].memory);
	}

	// write the texture data
	tmp = m_sampler_info.size();
	outputStream.write((char*)&tmp, sizeof(tmp));
	std::streampos texturesOffset = outputStream.tellp();
	for (uint i = 0; i < m_sampler_info.size(); i++) {
		SAMPLER_INFO* SI = &m_sampler_info[i];
		tmp = 0;
		outputStream.write((char*)&tmp, sizeof(tmp));
		outputStream.write((char*)&SI->sampler_info->binding_index, sizeof(SI->sampler_info->binding_index));
	}
	outputStream.write((char*)&tmp, sizeof(tmp)); // effect id
	_MarkFileEnd(file, outputStream.tellp());

	// save dependencies
	for (uint i = 0; i < m_sampler_info.size(); i++) {
		SAMPLER_INFO* SI = &m_sampler_info[i];
		if (SI->img) {
			WError err = file->SaveAsset(SI->img, &tmp);
			if (!err)
				return err;
			outputStream.seekp(texturesOffset + std::streamoff(i * (2 * sizeof(uint))));
			outputStream.write((char*)&tmp, sizeof(tmp));
		}
	}
	WError err = file->SaveAsset(m_effect, &tmp);
	if (!err)
		return err;
	outputStream.seekp(texturesOffset + std::streamoff(m_sampler_info.size() * (2 * sizeof(uint))));
	outputStream.write((char*)&tmp, sizeof(tmp));

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 5
0
WError WImage::MapPixels(void** const pixels, bool bReadOnly) {
	if (!Valid() || !m_stagingMemory)
		return WError(W_NOTVALID);

	VkDevice device = m_app->GetVulkanDevice();

	m_readOnlyMap = bReadOnly;

	VkResult err = vkMapMemory(device, m_stagingMemory, 0, m_mapSize, 0, pixels);
	if (err)
		return WError(W_NOTVALID);

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 6
0
 Image::AutoPtr ImageFactory::open(const std::wstring& wpath)
 {
     BasicIo::AutoPtr io(new FileIo(wpath));
     Image::AutoPtr image = open(io); // may throw
     if (image.get() == 0) throw WError(11, wpath);
     return image;
 }
Ejemplo n.º 7
0
WError WImageManager::Load() {
	m_checker_image = new WImage(m_app);
	int size = 256;
	int comp_size = 4;
	int check_size = 16;
	float* pixels = new float[size * size * comp_size];
	for (int y = 0; y < size; y++) {
		for (int x = 0; x < size; x++) {
			int col = ((y/ check_size) + ((x/ check_size) % 2)) % 2;
			float fCol = col == 0 ? 0.1f : 1.0f;
			if (comp_size > 0)
				pixels[(y*size + x) * comp_size + 0] = fCol;
			if (comp_size > 1)
				pixels[(y*size + x) * comp_size + 1] = fCol;
			if (comp_size > 2)
				pixels[(y*size + x) * comp_size + 2] = fCol;
			if (comp_size > 3)
				pixels[(y*size + x) * comp_size + 3] = 1;
		}
	}
	WError werr = m_checker_image->CreateFromPixelsArray(pixels, size, size, false, comp_size);
	delete[] pixels;
	if (!werr) {
		W_SAFE_REMOVEREF(m_checker_image);
		return werr;
	}

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 8
0
 DataBuf readFile(const std::wstring& wpath)
 {
     FileIo file(wpath);
     if (file.open("rb") != 0) {
         throw WError(10, wpath, "rb", strError().c_str());
     }
     struct _stat st;
     if (0 != ::_wstat(wpath.c_str(), &st)) {
         throw WError(2, wpath, strError().c_str(), "::_wstat");
     }
     DataBuf buf(st.st_size);
     long len = file.read(buf.pData_, buf.size_);
     if (len != buf.size_) {
         throw WError(2, wpath, strError().c_str(), "FileIo::read");
     }
     return buf;
 }
Ejemplo n.º 9
0
 long writeFile(const DataBuf& buf, const std::wstring& wpath)
 {
     FileIo file(wpath);
     if (file.open("wb") != 0) {
         throw WError(10, wpath, "wb", strError().c_str());
     }
     return file.write(buf.pData_, buf.size_);
 }
Ejemplo n.º 10
0
WError WSound::SaveToWS(std::string filename) const {
	if (Valid() && m_dataV.size()) //only attempt to save if the sound is valid and there is something to save
	{
		//open the file for writing
		fstream file;
		file.open(filename, ios::out | ios::binary);

		if (!file.is_open())
			return WError(W_FILENOTFOUND);

		float temp[3];

		//write pitch & volume
		alGetSourcef(m_source, AL_PITCH, &temp[0]);
		alGetSourcef(m_source, AL_GAIN, &temp[1]);
		file.write((char*)temp, 2 * sizeof(float));

		//write position & direction
		alGetSource3f(m_source, AL_POSITION, &temp[0], &temp[1], &temp[2]);
		file.write((char*)temp, 3 * sizeof(float));
		alGetSource3f(m_source, AL_DIRECTION, &temp[0], &temp[1], &temp[2]);
		file.write((char*)temp, 3 * sizeof(float));

		char numBuffers = m_dataV.size();
		file.write((char*)&numBuffers, 1);
		for (uint i = 0; i < numBuffers; i++) {
			file.write((char*)&m_dataV[i].buffer, 4); //buffer index
			file.write((char*)&m_dataV[i].format, sizeof ALenum); //buffer format
			alGetBufferf(m_buffers[m_dataV[i].buffer], AL_FREQUENCY, &temp[0]);
			file.write((char*)&temp[0], 4); //frequency
			file.write((char*)&m_dataV[i].dataSize, 4); //size of data
			file.write((char*)&m_dataV[i].data, m_dataV[i].dataSize); //data
		}

		file.close();
	}
	else
		return WError(W_NOTVALID);

	return WError(W_SUCCEEDED);

}
Ejemplo n.º 11
0
void WTcp::Abort(WERROR_CODE Error)
{
	m_LastError = WSAGetLastError();	// save error before doing anything else
//
// Assume we're being called during construction; when we throw the exception,
// our destructor will NOT be called, so clean up resources explicitly first.
//
	closesocket(m_ListenSock);
	closesocket(m_ConnectSock);
	throw WError(Error, m_LastError);
}
Ejemplo n.º 12
0
WError WMaterial::SetInstancingTexture(WImage* img) {
	if (!Valid())
		return WError(W_NOTVALID);

	unsigned int binding_index = -1;
	for (int i = 0; i < m_effect->m_shaders.size() && binding_index == -1; i++) {
		if (m_effect->m_shaders[i]->m_desc.type == W_VERTEX_SHADER)
			binding_index = m_effect->m_shaders[i]->m_desc.instancing_texture_index;
	}
	return SetTexture(binding_index, img);
}
Ejemplo n.º 13
0
WError WSound::LoadFromWS(basic_filebuf<char>* buff, uint pos, bool bSaveData) {
	//use the given stream
	fstream file;
	if (!buff)
		return WError(W_INVALIDPARAM);
	file.set_rdbuf(buff);
	file.seekg(pos);

	float temp[3];

	//read pitch & volume
	file.read((char*)temp, 2 * sizeof(float));
	alSourcef(m_source, AL_PITCH, temp[0]);
	alSourcef(m_source, AL_GAIN, temp[1]);

	//read position & direction
	file.read((char*)temp, 3 * sizeof(float));
	alSource3f(m_source, AL_POSITION, temp[0], temp[1], temp[2]);
	file.read((char*)temp, 3 * sizeof(float));
	alSource3f(m_source, AL_DIRECTION, temp[0], temp[1], temp[2]);

	char numBuffers = 0;
	file.read((char*)&numBuffers, 1);
	for (uint i = 0; i < numBuffers; i++) {
		__SAVEDATA data;
		file.read((char*)&data.buffer, 4); //buffer index
		file.read((char*)&data.format, sizeof ALenum); //buffer format
		file.read((char*)&temp[0], 4); //frequency
		file.read((char*)&data.dataSize, 4); //size of data
		data.data = W_SAFE_ALLOC(data.dataSize);
		file.read((char*)&data.data, m_dataV[i].dataSize); //data

		WError err = LoadFromMemory(data.buffer, data.data, data.dataSize, data.format, temp[0], bSaveData);

		W_SAFE_FREE(data.data);

		return WError(err);
	}

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 14
0
WError WSound::LoadFromMemory(uint buffer, void* data, size_t dataSize, ALenum format, uint frequency, bool bSaveData) {
	if (!m_bCheck(true)) return WError(W_ERRORUNK);

	alBufferData(m_buffers[buffer], format, data, dataSize, frequency);

	// Attach buffer to source
	alSourcei(m_source, AL_BUFFER, m_buffers[buffer]);

	//save data if required
	if (bSaveData) {
		__SAVEDATA saveData;
		saveData.buffer = buffer;
		saveData.dataSize = dataSize;
		saveData.format = format;
		saveData.data = W_SAFE_ALLOC(dataSize);
		memcpy(saveData.data, data, dataSize);
		m_dataV.push_back(saveData);
	}

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 15
0
WError WSound::LoadFromWS(std::string filename, bool bSaveData) {
	fstream file;
	file.open(filename, ios::in | ios::binary);
	if (file.fail())
		return WError(W_FILENOTFOUND);

	float temp[3];

	//read pitch & volume
	file.read((char*)temp, 2 * sizeof(float));
	alSourcef(m_source, AL_PITCH, temp[0]);
	alSourcef(m_source, AL_GAIN, temp[1]);

	//read position & direction
	file.read((char*)temp, 3 * sizeof(float));
	alSource3f(m_source, AL_POSITION, temp[0], temp[1], temp[2]);
	file.read((char*)temp, 3 * sizeof(float));
	alSource3f(m_source, AL_DIRECTION, temp[0], temp[1], temp[2]);

	char numBuffers = 0;
	file.read((char*)&numBuffers, 1);
	for (uint i = 0; i < numBuffers; i++) {
		__SAVEDATA data;
		file.read((char*)&data.buffer, 4); //buffer index
		file.read((char*)&data.format, sizeof ALenum); //buffer format
		file.read((char*)&temp[0], 4); //frequency
		file.read((char*)&data.dataSize, 4); //size of data
		data.data = W_SAFE_ALLOC(data.dataSize);
		file.read((char*)&data.data, m_dataV[i].dataSize); //data

		LoadFromMemory(data.buffer, data.data, data.dataSize, data.format, temp[0], bSaveData);

		W_SAFE_FREE(data.data);
	}

	file.close();

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 16
0
WError WSound::SaveToWS(basic_filebuf<char>* buff, uint pos) const {
	if (Valid() && m_dataV.size()) //only attempt to save if the sound is valid and there is something to save
	{
		//use the given stream
		fstream file;
		if (!buff)
			return WError(W_INVALIDPARAM);
		file.set_rdbuf(buff);
		file.seekp(pos);

		float temp[3];

		//write pitch & volume
		alGetSourcef(m_source, AL_PITCH, &temp[0]);
		alGetSourcef(m_source, AL_GAIN, &temp[1]);
		file.write((char*)temp, 2 * sizeof(float));

		//write position & direction
		alGetSource3f(m_source, AL_POSITION, &temp[0], &temp[1], &temp[2]);
		file.write((char*)temp, 3 * sizeof(float));
		alGetSource3f(m_source, AL_DIRECTION, &temp[0], &temp[1], &temp[2]);
		file.write((char*)temp, 3 * sizeof(float));

		char numBuffers = m_dataV.size();
		file.write((char*)&numBuffers, 1);
		for (uint i = 0; i < numBuffers; i++) {
			file.write((char*)&m_dataV[i].buffer, 4); //buffer index
			file.write((char*)&m_dataV[i].format, sizeof ALenum); //buffer format
			alGetBufferf(m_buffers[m_dataV[i].buffer], AL_FREQUENCY, &temp[0]);
			file.write((char*)&temp[0], 4); //frequency
			file.write((char*)&m_dataV[i].dataSize, 4); //size of data
			file.write((char*)&m_dataV[i].data, m_dataV[i].dataSize); //data
		}
	}
	else
		return WError(W_NOTVALID);

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 17
0
WError WImage::CopyFrom(WImage* const image) {
	if (!image || !image->Valid() || !image->m_stagingBuffer)
		return WError(W_INVALIDPARAM);

	void* pixels;
	WError res = image->MapPixels(&pixels, true);
	if (!res)
		return res;
	res = CreateFromPixelsArray(pixels, image->m_width, image->m_height, true,
								image->m_numComponents, image->m_format, image->m_componentSize);
	image->UnmapPixels();

	return res;
}
Ejemplo n.º 18
0
 Image::AutoPtr ImageFactory::create(int type,
                                     const std::wstring& wpath)
 {
     std::auto_ptr<FileIo> fileIo(new FileIo(wpath));
     // Create or overwrite the file, then close it
     if (fileIo->open("w+b") != 0) {
         throw WError(10, wpath, "w+b", strError().c_str());
     }
     fileIo->close();
     BasicIo::AutoPtr io(fileIo);
     Image::AutoPtr image = create(type, io);
     if (image.get() == 0) throw Error(13, type);
     return image;
 }
Ejemplo n.º 19
0
    BasicIo::AutoPtr FileIo::temporary() const
    {
        BasicIo::AutoPtr basicIo;

        Impl::StructStat buf;
        int ret = p_->stat(buf);
#if defined WIN32 && !defined __CYGWIN__
        DWORD nlink = p_->winNumberOfLinks();
#else
        nlink_t nlink = buf.st_nlink;
#endif

        // If file is > 1MB and doesn't have hard links then use a file, otherwise
        // use a memory buffer. I.e., files with hard links always use a memory
        // buffer, which is a workaround to ensure that the links don't get broken.
        if (ret != 0 || (buf.st_size > 1048576 && nlink == 1)) {
            pid_t pid = ::getpid();
            std::auto_ptr<FileIo> fileIo;
#ifdef EXV_UNICODE_PATH
            if (p_->wpMode_ == Impl::wpUnicode) {
                std::wstring tmpname = wpath() + s2ws(toString(pid));
                fileIo = std::auto_ptr<FileIo>(new FileIo(tmpname));
            }
            else
#endif
            {
                std::string tmpname = path() + toString(pid);
                fileIo = std::auto_ptr<FileIo>(new FileIo(tmpname));
            }
            if (fileIo->open("w+b") != 0) {
#ifdef EXV_UNICODE_PATH
                if (p_->wpMode_ == Impl::wpUnicode) {
                    throw WError(10, wpath(), "w+b", strError().c_str());
                }
                else
#endif
                {
                    throw Error(10, path(), "w+b", strError());
                }
            }
            fileIo->p_->copyXattrFrom(*this);
            basicIo = fileIo;
        }
        else {
            basicIo.reset(new MemIo);
        }

        return basicIo;
    }
Ejemplo n.º 20
0
WError WMaterial::SetVariableData(const char* varName, void* data, int len) {
	VkDevice device = m_app->GetVulkanDevice();
	bool isFound = false;
	for (int i = 0; i < m_uniformBuffers.size(); i++) {
		W_BOUND_RESOURCE* info = m_uniformBuffers[i].ubo_info;
		for (int j = 0; j < info->variables.size(); j++) {
			if (strcmp(info->variables[j].name.c_str(), varName) == 0) {
				size_t varsize = info->variables[j].GetSize();
				size_t offset = info->OffsetAtVariable(j);
				if (varsize < len)
					return WError(W_INVALIDPARAM);
				uint8_t *pData;
				VkResult vkRes = vkMapMemory(device, m_uniformBuffers[i].memory, offset, len, 0, (void **)&pData);
				if (vkRes)
					return WError(W_UNABLETOMAPBUFFER);
				memcpy(pData, data, len);
				vkUnmapMemory(device, m_uniformBuffers[0].memory);

				isFound = true;
			}
		}
	}
	return WError(isFound ? W_SUCCEEDED : W_INVALIDPARAM);
}
Ejemplo n.º 21
0
WTcp::WTcp(LPCSTR HostName, DWORD Port, LPCSTR ServerIP, bool UsingReadEvent, EXCEPTION_HANDLER Handler)
{
	m_AmServer = (HostName == NULL);	// null host name means we're a server
	m_ListenSock = INVALID_SOCKET;
	m_ConnectSock = INVALID_SOCKET;
	memset(&m_RemoteAddr, 0, sizeof(SOCKADDR_IN));
	m_Port = Port;
	m_LastError = 0;
	m_ExceptionHandler = Handler;
	m_ConnectionHandler = NULL;
	m_ConnectionHandlerArg = NULL;
	m_AmConnected = FALSE;
	m_ReadEvent.Create(NULL, TRUE, FALSE, NULL, "WTcp Read");	// manual reset
	m_ReadDoneEvent.Create(NULL, FALSE, FALSE, NULL, "WTcp Done");
	if (m_ReadEvent == NULL || m_ReadDoneEvent == NULL)
		throw WError(TCP_CANT_CREATE_EVENT);
//
// If we're a server, create a listening socket; if we're a client, connect to
// the specified server.
//
	if (m_AmServer)
		Listen(ServerIP);
	else {
		if (Port != UINT_MAX)	// if not in GetConnection
			Connect(HostName);
	}
//
// If we're a server, or we're a client that's using event-driven reads, launch
// the receive thread.  Servers ALWAYS use event-driven reads.
//
	if (m_AmServer || UsingReadEvent) {
		m_ReceiveThread.Create(NULL, 0, ReceiveThread, this, 0, NULL, "WTcp Receive");
		if (m_ReceiveThread == NULL)
			throw WError(TCP_CANT_LAUNCH_THREAD);
	}
}
Ejemplo n.º 22
0
WError WCore::Init(int width, int height) {
	WError err = WindowComponent->Initialize(width, height);
	if (!err)
		return err;

	/* Create Vulkan instance */
	VkApplicationInfo appInfo = {};
	appInfo.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	appInfo.pApplicationName = (const char*)engineParams["appName"];
	appInfo.pEngineName = "Wasabi";
	appInfo.apiVersion = VK_API_VERSION_1_0;

	std::vector<const char*> enabledExtensions = { VK_KHR_SURFACE_EXTENSION_NAME };

	// Enable surface extensions depending on os
#if defined(_WIN32)
	enabledExtensions.push_back(VK_KHR_WIN32_SURFACE_EXTENSION_NAME);
#elif defined(__linux__)
	enabledExtensions.push_back(VK_KHR_XCB_SURFACE_EXTENSION_NAME);
#endif

	VkInstanceCreateInfo instanceCreateInfo = {};
	instanceCreateInfo.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	instanceCreateInfo.pNext = NULL;
	instanceCreateInfo.pApplicationInfo = &appInfo;
	if (enabledExtensions.size() > 0) {
		instanceCreateInfo.enabledExtensionCount = (uint32_t)enabledExtensions.size();
		instanceCreateInfo.ppEnabledExtensionNames = enabledExtensions.data();
	}

	VkResult r = vkCreateInstance(&instanceCreateInfo, nullptr, &vkInstance);
	if (r != VK_SUCCESS)
		return WError(W_FAILEDTOCREATEINSTANCE);

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 23
0
WError WImage::SaveToStream(WFile* file, std::ostream& outputStream) {
	if (!Valid())
		return WError(W_NOTVALID);

	outputStream.write((char*)&m_width, sizeof(m_width));
	outputStream.write((char*)&m_height, sizeof(m_height));
	outputStream.write((char*)&m_numComponents, sizeof(m_numComponents));
	outputStream.write((char*)&m_componentSize, sizeof(m_componentSize));
	outputStream.write((char*)&m_format, sizeof(m_format));

	void* pixels;
	WError err = MapPixels(&pixels, true);
	if (err) {
		outputStream.write((char*)pixels, m_width * m_height * m_numComponents * m_componentSize);
		UnmapPixels();
	}

	return err;
}
Ejemplo n.º 24
0
WTcp::~WTcp()
{
//
// Close all sockets.  Any sockets function that's blocked on one of these
// sockets will immediately unblock, and return an error.
//
	closesocket(m_ListenSock);
	closesocket(m_ConnectSock);
	m_ReadDoneEvent.Set();	// in case receive thread is blocked on this
//
// If the receive thread was launched, kill it.  It should exit immediately,
// because we've closed both sockets and set m_ReadDoneEvent.  If it fails to
// exit in a reasonable amount of time, throw an error.
//
	if (m_ReceiveThread != NULL) {
		if (WaitForSingleObject(m_ReceiveThread, THREAD_EXIT_TIMEOUT) != WAIT_OBJECT_0)
			throw WError(TCP_CANT_KILL_THREAD);
		m_ReceiveThread.Close();
	}
}
Ejemplo n.º 25
0
WError WImage::LoadFromStream(WFile* file, std::istream& inputStream) {
	bool bDynamic = false;
	unsigned int width, height, numComponents, componentSize;
	VkFormat format;

	inputStream.read((char*)&width, sizeof(m_width));
	inputStream.read((char*)&height, sizeof(m_height));
	inputStream.read((char*)&numComponents, sizeof(m_numComponents));
	inputStream.read((char*)&componentSize, sizeof(m_componentSize));
	inputStream.read((char*)&format, sizeof(m_format));

	unsigned int dataSize = width * height * numComponents * componentSize;
	void* pixels = W_SAFE_ALLOC(dataSize);
	if (!pixels)
		return WError(W_OUTOFMEMORY);
	inputStream.read((char*)pixels, dataSize);
	WError err = CreateFromPixelsArray(pixels, width, height, bDynamic, numComponents, format, componentSize);
	W_SAFE_FREE(pixels);
	return err;
}
Ejemplo n.º 26
0
WError WMaterial::SetTexture(int binding_index, WImage* img) {
	VkDevice device = m_app->GetVulkanDevice();
	bool isFound = false;
	for (int i = 0; i < m_sampler_info.size(); i++) {
		W_BOUND_RESOURCE* info = m_sampler_info[i].sampler_info;
		if (info->binding_index == binding_index) {
			if (m_sampler_info[i].img)
				W_SAFE_REMOVEREF(m_sampler_info[i].img);
			if (img) {
				m_sampler_info[i].img = img;
				img->AddReference();
			} else {
				m_sampler_info[i].img = m_app->ImageManager->GetDefaultImage();
				m_app->ImageManager->GetDefaultImage()->AddReference();
			}

			isFound = true;
		}
	}
	return WError(isFound ? W_SUCCEEDED : W_INVALIDPARAM);
}
Ejemplo n.º 27
0
WError WImage::CreateFromPixelsArray(
	void*			pixels,
	unsigned int	width,
	unsigned int	height,
	bool			bDynamic,
	unsigned int	num_components,
	VkFormat		fmt,
	size_t			comp_size) {

	VkDevice device = m_app->GetVulkanDevice();
	VkResult err;
	VkMemoryAllocateInfo memAllocInfo = vkTools::initializers::memoryAllocateInfo();
	VkMemoryRequirements memReqs = {};
	VkBufferImageCopy bufferCopyRegion = {};
	VkImageCreateInfo imageCreateInfo = vkTools::initializers::imageCreateInfo();
	VkBufferCreateInfo bufferCreateInfo = vkTools::initializers::bufferCreateInfo();
	uint8_t *data;

	VkFormat format = fmt;
	if (fmt == VK_FORMAT_UNDEFINED) {
		switch (num_components) {
		case 1: format = VK_FORMAT_R32_SFLOAT; break;
		case 2: format = VK_FORMAT_R32G32_SFLOAT; break;
		case 3: format = VK_FORMAT_R32G32B32_SFLOAT; break;
		case 4: format = VK_FORMAT_R32G32B32A32_SFLOAT; break;
		default:
			return WError(W_INVALIDPARAM);
		}
		comp_size = 4;
	}

	_DestroyResources();

	// Create a host-visible staging buffer that contains the raw image data
	bufferCreateInfo.size = width * height * num_components * comp_size;
	// This buffer is used as a transfer source for the buffer copy
	bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
	bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;

	err = vkCreateBuffer(device, &bufferCreateInfo, nullptr, &m_stagingBuffer);
	if (err) {
		_DestroyResources();
		return WError(W_OUTOFMEMORY);
	}

	// Get memory requirements for the staging buffer (alignment, memory type bits)
	vkGetBufferMemoryRequirements(device, m_stagingBuffer, &memReqs);

	memAllocInfo.allocationSize = memReqs.size;
	// Get memory type index for a host visible buffer
	m_app->GetMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, &memAllocInfo.memoryTypeIndex);

	err = vkAllocateMemory(device, &memAllocInfo, nullptr, &m_stagingMemory);
	if (err) {
		vkDestroyBuffer(device, m_stagingBuffer, nullptr);
		_DestroyResources();
		return WError(W_OUTOFMEMORY);
	}
	err = vkBindBufferMemory(device, m_stagingBuffer, m_stagingMemory, 0);
	if (err) goto free_buffers;

	// Copy texture data into staging buffer
	if (pixels) {
		err = vkMapMemory(device, m_stagingMemory, 0, memReqs.size, 0, (void **)&data);
		if (err) goto free_buffers;
		memcpy(data, pixels, bufferCreateInfo.size);
		vkUnmapMemory(device, m_stagingMemory);
	}

	// Create optimal tiled target image
	imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
	imageCreateInfo.format = format;
	imageCreateInfo.mipLevels = 1; // TODO: USE m_app->engineParams["numGeneratedMips"]
	imageCreateInfo.arrayLayers = 1;
	imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
	imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
	imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
	imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
	imageCreateInfo.extent = { width, height, 1 };
	imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;

	err = vkCreateImage(device, &imageCreateInfo, nullptr, &m_image);
	if (err) goto free_buffers;

	vkGetImageMemoryRequirements(device, m_image, &memReqs);

	memAllocInfo.allocationSize = memReqs.size;

	m_app->GetMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT,
						 &memAllocInfo.memoryTypeIndex);
	err = vkAllocateMemory(device, &memAllocInfo, nullptr, &m_deviceMemory);
	if (err) goto free_buffers;
	err = vkBindImageMemory(device, m_image, m_deviceMemory, 0);
	if (err) goto free_buffers;

	// Setup buffer copy regions for each mip level
	bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	bufferCopyRegion.imageSubresource.mipLevel = 0;
	bufferCopyRegion.imageSubresource.baseArrayLayer = 0;
	bufferCopyRegion.imageSubresource.layerCount = 1;
	bufferCopyRegion.imageExtent.width = width;
	bufferCopyRegion.imageExtent.height = height;
	bufferCopyRegion.imageExtent.depth = 1;
	bufferCopyRegion.bufferOffset = 0;

	err = m_app->BeginCommandBuffer();
	if (err) goto free_buffers;

	// Image barrier for optimal image (target)
	// Optimal image will be used as destination for the copy
	vkTools::setImageLayout(
		m_app->GetCommandBuffer(),
		m_image,
		VK_IMAGE_ASPECT_COLOR_BIT,
		VK_IMAGE_LAYOUT_PREINITIALIZED,
		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL);

	// Copy mip levels from staging buffer
	vkCmdCopyBufferToImage(
		m_app->GetCommandBuffer(),
		m_stagingBuffer,
		m_image,
		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		1,
		&bufferCopyRegion
	);

	// Change texture image layout to shader read after all mip levels have been copied
	vkTools::setImageLayout(
		m_app->GetCommandBuffer(),
		m_image,
		VK_IMAGE_ASPECT_COLOR_BIT,
		VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
		VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);

	err = m_app->EndCommandBuffer();
	if (err) goto free_buffers;

free_buffers:
	// Clean up staging resources
	if (err || !bDynamic) {
		vkFreeMemory(device, m_stagingMemory, nullptr);
		vkDestroyBuffer(device, m_stagingBuffer, nullptr);
		m_stagingMemory = VK_NULL_HANDLE;
		m_stagingBuffer = VK_NULL_HANDLE;
	}

	if (err) {
		_DestroyResources();
		return WError(W_OUTOFMEMORY);
	}

	// Create image view
	// Textures are not directly accessed by the shaders and
	// are abstracted by image views containing additional
	// information and sub resource ranges
	VkImageViewCreateInfo view = vkTools::initializers::imageViewCreateInfo();
	view.image = VK_NULL_HANDLE;
	view.viewType = VK_IMAGE_VIEW_TYPE_2D;
	view.format = format;
	view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
	view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
	view.subresourceRange.baseMipLevel = 0;
	view.subresourceRange.baseArrayLayer = 0;
	view.subresourceRange.layerCount = 1;
	// Linear tiling usually won't support mip maps
	// Only set mip map count if optimal tiling is used
	view.subresourceRange.levelCount = 1; // mips
	view.image = m_image;
	err = vkCreateImageView(device, &view, nullptr, &m_view);
	if (err) {
		_DestroyResources();
		return WError(W_UNABLETOCREATEIMAGE);
	}

	m_width = width;
	m_height = height;
	m_numComponents = num_components;
	m_componentSize = comp_size;
	m_mapSize = bufferCreateInfo.size;
	m_format = format;

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 28
0
WError WSound::LoadWAV(std::string Filename, uint buffer, bool bSaveData) {
	if (!m_bCheck(true)) return WError(W_ERRORUNK);

	fstream file(Filename, ios::in | ios::binary);
	if (!file.is_open())
		return WError(W_FILENOTFOUND);

	ALenum format;
	uint dataSize;
	uint freq;

	bool bLittleEndian = true;
	char buffer4Bytes[4] = { 0 };
	char buffer2Bytes[2] = { 0 };

	//frequency at offset 24 (4 bytes long)
	file.seekg(0);
	file.read(buffer4Bytes, 4);
	if (buffer4Bytes[3] == 'F') //RIFF
		bLittleEndian = true;
	else if (buffer4Bytes[3] == 'X') //RIFX
		bLittleEndian = false;
	else
		return WError(W_INVALIDFILEFORMAT);

	//frequency at offset 24 (4 bytes long)
	file.seekg(24);
	file.read(buffer4Bytes, 4);
	freq = BytesTo<__int32>((BYTE*)buffer4Bytes, bLittleEndian);

	//data size at offset 22 (2 bytes long)
	file.seekg(22);
	file.read(buffer2Bytes, 2);
	uint numChannels = BytesTo<__int16>((BYTE*)buffer2Bytes, bLittleEndian);

	//bits per sample at offset 34 (2 bytes long)
	file.seekg(34);
	file.read(buffer2Bytes, 2);
	uint bps = BytesTo<__int16>((BYTE*)buffer2Bytes, bLittleEndian);

	if (numChannels == 1)
		format = bps == 8 ? AL_FORMAT_MONO8 : AL_FORMAT_MONO16;
	else if (numChannels == 2)
		format = bps == 8 ? AL_FORMAT_STEREO8 : AL_FORMAT_STEREO16;
	else {
		file.close();
		return WError(W_INVALIDFILEFORMAT);
	}

	//find "data" word
	int offset = 36;
	while (offset < 260) {
		file.seekg(offset);
		file.read(buffer4Bytes, 4);
		if (buffer4Bytes[0] == 'd' && buffer4Bytes[1] == 'a' &&
			buffer4Bytes[2] == 't' && buffer4Bytes[3] == 'a') {
			offset += 4;
			break;
		}
		offset++;
	}
	if (offset == 60) {
		file.close();
		return WError(W_INVALIDFILEFORMAT);
	}

	//data size at offset (4 bytes long)
	file.seekg(offset);
	file.read(buffer4Bytes, 4);
	dataSize = BytesTo<__int32>((BYTE*)buffer4Bytes, bLittleEndian);

	//data at offset+4 (dataSize bytes long)
	file.seekg(offset + 4);
	void* data = W_SAFE_ALLOC(dataSize);
	file.read((char*)data, dataSize);

	//set buffer data
	alBufferData(m_buffers[buffer], format, data, dataSize, freq);
	if (alGetError() != AL_NO_ERROR)
		return WError(W_INVALIDFILEFORMAT);

	//release read bytes
	if (!bSaveData) {
		W_SAFE_FREE(data);
	}
	else {
		__SAVEDATA saveData;
		saveData.buffer = buffer;
		saveData.dataSize = dataSize;
		saveData.format = format;
		saveData.data = W_SAFE_ALLOC(dataSize);
		memcpy(saveData.data, data, dataSize);
		m_dataV.push_back(saveData);
	}

	file.close();

	// Attach buffer to source
	alSourcei(m_source, AL_BUFFER, m_buffers[buffer]);

	m_valid = true;

	return WError(W_SUCCEEDED);
}
Ejemplo n.º 29
0
WError Wasabi::Resize(int width, int height) {
	return WError(W_SUCCEEDED);
}
Ejemplo n.º 30
0
WError Wasabi::StartEngine(int width, int height) {
	WError err = WindowComponent->Initialize(width, height);
	if (!err)
		return err;

	/* Create vulkan instance */
	vkInstance = CreateVKInstance((const char*)engineParams["appName"], "Wasabi");
	if (!vkInstance)
		return WError(W_FAILEDTOCREATEINSTANCE);


	/*// Physical device
	uint32_t gpuCount = 0;
	// Get number of available physical devices
	err = vkEnumeratePhysicalDevices(instance, &gpuCount, nullptr);
	assert(!err);
	assert(gpuCount > 0);
	// Enumerate devices
	std::vector<VkPhysicalDevice> physicalDevices(gpuCount);
	err = vkEnumeratePhysicalDevices(instance, &gpuCount, physicalDevices.data());
	if (err) {
		vkTools::exitFatal("Could not enumerate phyiscal devices : \n" + vkTools::errorString(err), "Fatal error");
	}

	// Note :
	// This example will always use the first physical device reported,
	// change the vector index if you have multiple Vulkan devices installed
	// and want to use another one
	physicalDevice = physicalDevices[0];

	// Find a queue that supports graphics operations
	uint32_t graphicsQueueIndex = 0;
	uint32_t queueCount;
	vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, NULL);
	assert(queueCount >= 1);

	std::vector<VkQueueFamilyProperties> queueProps;
	queueProps.resize(queueCount);
	vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &queueCount, queueProps.data());

	for (graphicsQueueIndex = 0; graphicsQueueIndex < queueCount; graphicsQueueIndex++) {
		if (queueProps[graphicsQueueIndex].queueFlags & VK_QUEUE_GRAPHICS_BIT)
			break;
	}
	assert(graphicsQueueIndex < queueCount);

	// Vulkan device
	std::array<float, 1> queuePriorities = { 0.0f };
	VkDeviceQueueCreateInfo queueCreateInfo = {};
	queueCreateInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	queueCreateInfo.queueFamilyIndex = graphicsQueueIndex;
	queueCreateInfo.queueCount = 1;
	queueCreateInfo.pQueuePriorities = queuePriorities.data();

	err = createDevice(queueCreateInfo, enableValidation);
	assert(!err);

	// Store properties (including limits) and features of the phyiscal device
	// So examples can check against them and see if a feature is actually supported
	vkGetPhysicalDeviceProperties(physicalDevice, &deviceProperties);
	vkGetPhysicalDeviceFeatures(physicalDevice, &deviceFeatures);

#if defined(__ANDROID__)
	LOGD(deviceProperties.deviceName);
#endif

	// Gather physical device memory properties
	vkGetPhysicalDeviceMemoryProperties(physicalDevice, &deviceMemoryProperties);

	// Get the graphics queue
	vkGetDeviceQueue(device, graphicsQueueIndex, 0, &queue);

	// Find a suitable depth format
	VkBool32 validDepthFormat = vkTools::getSupportedDepthFormat(physicalDevice, &depthFormat);
	assert(validDepthFormat);

	swapChain.connect(instance, physicalDevice, device);

	// Create synchronization objects
	VkSemaphoreCreateInfo semaphoreCreateInfo = vkTools::initializers::semaphoreCreateInfo();
	// Create a semaphore used to synchronize image presentation
	// Ensures that the image is displayed before we start submitting new commands to the queu
	err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.presentComplete);
	assert(!err);
	// Create a semaphore used to synchronize command submission
	// Ensures that the image is not presented until all commands have been sumbitted and executed
	err = vkCreateSemaphore(device, &semaphoreCreateInfo, nullptr, &semaphores.renderComplete);
	assert(!err);

	// Set up submit info structure
	// Semaphores will stay the same during application lifetime
	// Command buffer submission info is set by each example
	submitInfo = vkTools::initializers::submitInfo();
	submitInfo.pWaitDstStageMask = &submitPipelineStages;
	submitInfo.waitSemaphoreCount = 1;
	submitInfo.pWaitSemaphores = &semaphores.presentComplete;
	submitInfo.signalSemaphoreCount = 1;
	submitInfo.pSignalSemaphores = &semaphores.renderComplete;*/

	return WError(W_SUCCEEDED);
}