Exemple #1
0
Bitmap *Bitmap::Load(const std::string& filename) {
    std::vector<IBitmapCodec *>codecs = IBitmapCodec::GetAllCodecs();
    std::string errMsg;
    for(size_t i = 0; i < codecs.size(); i++) {
        IBitmapCodec *codec = codecs[i];
        if(codec->CanLoad() && codec->CheckExtension(filename)) {
            // give it a try.
            // open error shouldn't be handled here
            StreamHandle str = FileManager::OpenForReading(filename.c_str());
            try {
                return codec->Load(str);
            } catch(const std::exception& ex) {
                errMsg += codec->GetName();
                errMsg += ":\n";
                errMsg += ex.what();
                errMsg += "\n\n";
            }
        }
    }

    if(errMsg.empty()) {
        SPRaise("Bitmap codec not found for filename: %s", filename.c_str());
    } else {
        SPRaise("No bitmap codec could load file successfully: %s\n%s\n",
                filename.c_str(), errMsg.c_str());
    }
}
Exemple #2
0
		virtual void Save(IStream *stream, Bitmap *bmp){
			SPADES_MARK_FUNCTION();

			int err;

			png_t png_s;
			if((err = png_open_write(&png_s, &WriteCallback, stream))){
				SPRaise("Error while png_open_write: %s", png_error_string(err));
			}

			// Create flipped buffer
			std::vector<std::uint8_t> buf(bmp->GetWidth() * bmp->GetHeight() * 4);
			{
				std::uint32_t *pixels = bmp->GetPixels();
				auto width = bmp->GetWidth();
				auto rowLengthBytes = width * sizeof(std::uint8_t) * 4;

				for(long y = bmp->GetHeight() - 1; y >= 0; --y) {
					std::memcpy(&buf[y*rowLengthBytes], pixels, rowLengthBytes);
					pixels += width;
				}
			}
			if((err = png_set_data(&png_s, bmp->GetWidth(), bmp->GetHeight(), 8, PNG_TRUECOLOR_ALPHA, buf.data()))){
				SPRaise("Error while png_set_data: %s", png_error_string(err));
			}
		}
	void ScriptFunction::Load(asIScriptEngine *eng) {
		if(eng != lastEngine) {
			func = NULL;
			lastEngine = eng;
		}
		if(func == NULL){
			asIScriptModule *module = eng->GetModule("Client");
			eng->SetDefaultNamespace("spades");
			module->SetDefaultNamespace("spades");
			if(type.empty()) {
				
				func = eng->GetGlobalFunctionByDecl(decl.c_str());
				if(!func){
					func = module->GetFunctionByDecl(decl.c_str());
				}
				if(!func){
					SPRaise("Script function with signature '%s' not found.", decl.c_str());
				}
			}else{
				asITypeInfo *typ = eng->GetTypeInfoByName(type.c_str());
				if(!typ){
					typ = module->GetTypeInfoByName(type.c_str());
				}
				if(!typ){
					SPRaise("Script type '%s' not found.", type.c_str());
				}
				func = typ->GetMethodByDecl(decl.c_str());
				if(!func){
					SPRaise("Script method of '%s' with signature '%s' not found.",
							type.c_str(), decl.c_str());
				}
			}
		}
	}
Exemple #4
0
			void Run() override {
				try {
					std::unique_ptr<CURL, CURLEasyDeleter> cHandle{curl_easy_init()};
					if (cHandle) {
						size_t (*curlWriteCallback)(void *, size_t, size_t, ServerListQuery *) = [](
						  void *ptr, size_t size, size_t nmemb, ServerListQuery *self) -> size_t {
							size_t numBytes = size * nmemb;
							self->buffer.append(reinterpret_cast<char *>(ptr), numBytes);
							return numBytes;
						};
						curl_easy_setopt(cHandle.get(), CURLOPT_USERAGENT, OpenSpades_VER_STR);
						curl_easy_setopt(cHandle.get(), CURLOPT_URL, cl_serverListUrl.CString());
						curl_easy_setopt(cHandle.get(), CURLOPT_WRITEFUNCTION, curlWriteCallback);
						curl_easy_setopt(cHandle.get(), CURLOPT_WRITEDATA, this);
						if (0 == curl_easy_perform(cHandle.get())) {
							ProcessResponse();
						} else {
							SPRaise("HTTP request error.");
						}
					} else {
						SPRaise("Failed to create cURL object.");
					}
				} catch (std::exception &ex) {
					std::unique_ptr<MainScreenServerList> lst{new MainScreenServerList()};
					lst->message = ex.what();
					ReturnResult(std::move(lst));
				} catch (...) {
					std::unique_ptr<MainScreenServerList> lst{new MainScreenServerList()};
					lst->message = "Unknown error.";
					ReturnResult(std::move(lst));
				}
			}
	void DeflateStream::DeflateEnd() {
		SPADES_MARK_FUNCTION();
		if(mode != CompressModeCompress){
			SPRaise("DeflareEnd called when decompressing");
		}
		if(!valid){
			SPRaise("State is invalid");
		}
		
		char outputBuffer[chunkSize];
		
		zstream.avail_in = 0;
		do{
			zstream.avail_out = chunkSize;
			zstream.next_out = (Bytef*)outputBuffer;
			int ret = deflate(&zstream, Z_FINISH);
			if(ret == Z_STREAM_ERROR) {
				valid = false;
				deflateEnd(&zstream);
				SPRaise("Error while deflating: %s",
						zError(ret));
			}
			
			int got = chunkSize - zstream.avail_out;
			baseStream->Write(outputBuffer, got);
		}while(zstream.avail_out == 0);
		
		deflateEnd(&zstream);
		valid = false;
	}
	void DeflateStream::CompressBuffer() {
		SPADES_MARK_FUNCTION();
		SPAssert(mode == CompressModeCompress);
		char outputBuffer[chunkSize];
		
		if(!valid){
			SPRaise("State is invalid");
		}
		
		zstream.avail_in = (unsigned int) buffer.size();
		zstream.next_in = (Bytef*)buffer.data();
		
		do{
			zstream.avail_out = chunkSize;
			zstream.next_out = (Bytef*)outputBuffer;
			int ret = deflate(&zstream, Z_NO_FLUSH);
			if(ret == Z_STREAM_ERROR) {
				valid = false;
				deflateEnd(&zstream);
				SPRaise("Error while deflating: %s",
						zError(ret));
			}
			
			int got = chunkSize - zstream.avail_out;
			baseStream->Write(outputBuffer, got);
		}while(zstream.avail_out == 0);
		
		SPAssert(zstream.avail_in == 0);
		std::vector<char>().swap(buffer);
	}
Exemple #7
0
Bitmap *Bitmap::Load(IStream *stream) {
    std::vector<IBitmapCodec *>codecs = IBitmapCodec::GetAllCodecs();
    auto pos = stream->GetPosition();
    std::string errMsg;
    for(size_t i = 0; i < codecs.size(); i++) {
        IBitmapCodec *codec = codecs[i];
        if(codec->CanLoad()) {
            // give it a try.
            // open error shouldn't be handled here
            try {
                stream->SetPosition(pos);
                return codec->Load(stream);
            } catch(const std::exception& ex) {
                errMsg += codec->GetName();
                errMsg += ":\n";
                errMsg += ex.what();
                errMsg += "\n\n";
            }
        }
    }

    if(errMsg.empty()) {
        SPRaise("Bitmap codec not found for stream");
    } else {
        SPRaise("No bitmap codec could load file successfully: [stream]\n%s\n",
                errMsg.c_str());
    }
}
Exemple #8
0
		Runner::Runner():
		m_videoWidth(r_videoWidth),
		m_videoHeight(r_videoHeight){
			if(m_videoWidth < 1 || m_videoWidth > 16384)
				SPRaise("Value of r_videoWidth is invalid.");
			if(m_videoHeight < 1 || m_videoHeight > 16384)
				SPRaise("Value of r_videoHeight is invalid.");
		}
Exemple #9
0
	void MemoryStream::WriteByte(int byte) {
		SPADES_MARK_FUNCTION();
		if(canWrite){
			SPRaise("Write prohibited");
		}
		if(position >= length){
			SPRaise("Attempted to write beyond the specified memory range.");
		}else {
			memory[(size_t)(position++)] = (unsigned char)byte;
		}
	}
		virtual SDL_Surface *LoadSdlImage(const std::string &data) {
			StringSdlRWops ops(data);
			int flags = IMG_INIT_PNG | IMG_INIT_JPG;
			int initted = IMG_Init(flags);
			if ((initted & flags) != flags) {
				SPRaise("IMG_Init failed: %s", IMG_GetError());
			}
			auto *s = IMG_Load_RW(ops, 0);
			if (s == nullptr) {
				SPRaise("IMG_Load_RW failed: %s", IMG_GetError());
			}
			return s;
		}
Exemple #11
0
	void MemoryStream::Write(const void *data, size_t bytes) {
		SPADES_MARK_FUNCTION();
		if(canWrite){
			SPRaise("Write prohibited");
		}
		if(position + (uint64_t)bytes > length ||
		   position + (uint64_t)bytes < position){ // integer overflow check
			SPRaise("Attempted to write beyond the specified memory range.");
		}else {
			memcpy(memory + (size_t)position,
				   data,
				   bytes);
		}
	}
	void DeflateStream::WriteByte(int byte){
		SPADES_MARK_FUNCTION();
		if(mode != CompressModeCompress){
			SPRaise("Attempted to write when decompressing");
		}
		if(!valid){
			SPRaise("State is invalid");
		}
		
		if(buffer.size() >= bufferSize){
			CompressBuffer();
		}
		
		buffer.push_back((char)byte);
	}
				IModel *GetResult() {
					if(!error.empty()){
						SPRaise("Error while RegisterImageDispatch:\n%s", error.c_str());
					}else{
						return result;
					}
				}
Exemple #14
0
	void CheckError(void){
		ALenum e;
		e = qalGetError();
		if(e != AL_NO_ERROR) {
			SPRaise("OpenAL error %d: %s", (int)e, DescribeError(e));
		}
	}
Exemple #15
0
	static void *GPA(const char *str)
	{
		if(!alLibrary){
			auto paths = spades::Split(s_alDriver, ";");
			std::string errors;
			for (const std::string &path: paths) {
				auto trimmedPath = spades::TrimSpaces(path);
				try {
					alLibrary = new spades::DynamicLibrary(trimmedPath.c_str());
					if (alLibrary) {
						SPLog("'%s' loaded", trimmedPath.c_str());
						break;
					}
				} catch (const std::exception &ex) {
					errors += trimmedPath;
					errors += ":\n";
					errors += ex.what();
				}
			}
			if (!alLibrary) {
				SPRaise("Failed to load a OpenAL driver.\n%s", errors.c_str());
			}
		}

		if(qalGetProcAddress){
			void *v = qalGetProcAddress(str);
			if(v)
				return v;
		}

		return alLibrary->GetSymbol(str);
	}
		static void RaiseFBStatusError(IGLDevice::Enum status) {
			std::string type;
			switch(status){
				case IGLDevice::FramebufferComplete:
					type = "GL_FRAMEBUFFER_COMPLETE";
					break;
				case IGLDevice::FramebufferUndefined:
					type = "GL_FRAMEBUFFER_UNDEFINED";
					break;
				case IGLDevice::FramebufferIncompleteAttachment:
					type = "GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT";
					break;
				case IGLDevice::				FramebufferIncompleteMissingAttachment:
					type = "GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";
					break;
				case IGLDevice::				FramebufferIncompleteDrawBuffer:
					type = "GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER";
					break;
				case IGLDevice::				FramebufferIncompleteReadBuffer:
					type = "GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER";
					break;
				case IGLDevice::				FramebufferIncompleteMultisample:
					type = "GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE";
					break;
				case IGLDevice::				FramebufferIncompleteLayerTargets:
					type = "GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS";
					break;
				default: // IGLDevice::Enum contains values unrelevant to framebuffer status error causing static analyzer to say something
					type = "Unknown";
			}
			SPRaise("OpenGL Framebuffer completeness check failed: %s",
					type.c_str());
		}
				Bitmap *GetResult() {
					if(!error.empty()){
						SPRaise("Error while CreateImageDispatch:\n%s", error.c_str());
					}else{
						return result;
					}
				}
	DeflateStream::DeflateStream(IStream *stream,
								 CompressMode mode,
								 bool ac) {
		SPADES_MARK_FUNCTION();
		
		this->baseStream = stream;
		this->mode = mode;
		autoClose = ac;
		
		zstream.zalloc = Z_NULL;
		zstream.zfree = Z_NULL;
		zstream.opaque = Z_NULL;
		
		position = 0;
		
		int ret;
		if(mode == CompressModeCompress) {
			ret = deflateInit(&zstream, 5);
		}else if(mode == CompressModeDecompress){
			ret = inflateInit(&zstream);
		}else{
			SPInvalidEnum("mode", mode);
		}
		
		if(ret != Z_OK){
			SPRaise("Failed to initialize zlib deflator/inflator: %s",
					zError(ret));
		}
		
		valid = true;
		reachedEOF = false;
		bufferPos = 0;
		
	}
Exemple #19
0
	void StdStream::WriteByte(int byte) {
		SPADES_MARK_FUNCTION();

		if (fputc(byte, handle) != 0) {
			SPRaise("I/O error.");
		}
	}
Exemple #20
0
	void StdStream::Write(const void *buf, size_t bytes) {
		SPADES_MARK_FUNCTION();

		if (fwrite(buf, 1, bytes, handle) < bytes) {
			SPRaise("I/O error.");
		}
	}
Exemple #21
0
		void Client::TakeMapShot(){
			
			try{
				std::string name = MapShotPath();
				{
					std::unique_ptr<IStream> stream(FileManager::OpenForWriting(name.c_str()));
					try{
						GameMap *map = GetWorld()->GetMap();
						if(map == nullptr){
							SPRaise("No map loaded");
						}
						map->Save(stream.get());
					}catch(...){
						throw;
					}
				}
				
				std::string msg;
				msg = _Tr("Client", "Map saved: {0}", name);
				ShowAlert(msg, AlertType::Notice);
			}catch(const Exception& ex){
				std::string msg;
				msg = _Tr("Client", "Saving map failed: ");
				msg += ex.GetShortMessage();
				ShowAlert(msg, AlertType::Error);
				SPLog("Saving map failed: %s", ex.what());
			}catch(const std::exception& ex){
				std::string msg;
				msg = _Tr("Client", "Saving map failed: ");
				msg += ex.what();
				ShowAlert(msg, AlertType::Error);
				SPLog("Saving map failed: %s", ex.what());
			}
		}
		virtual Bitmap *Load(IStream *stream) {
			SPADES_MARK_FUNCTION();

			// read all
			std::string data = stream->ReadAllBytes();

			auto deleter = [](SDL_Surface *s) { SDL_FreeSurface(s); };

			// copy to buffer
			std::unique_ptr<SDL_Surface, decltype(deleter)> imgraw(LoadSdlImage(data), deleter);
			if (imgraw == nullptr) {
				SPRaise("SDL surface was not loaded.");
			}

			std::unique_ptr<SDL_Surface, decltype(deleter)> img(
			  SDL_ConvertSurfaceFormat(imgraw.get(), SDL_PIXELFORMAT_ABGR8888, 0), deleter);
			if (img == nullptr) {
				SPRaise("SDL surface was loaded, but format conversion failed.");
			}

			const unsigned char *inPixels = (const unsigned char *)img->pixels;
			int width = img->w;
			int height = img->h;
			int pitch = img->pitch;

			Handle<Bitmap> bmp;
			bmp.Set(new Bitmap(width, height), false);
			try {
				unsigned char *outPixels = (unsigned char *)bmp->GetPixels();

				if (pitch == width * 4) {
					// if the pitch matches the requirement of Bitmap,
					// just use it
					memcpy(outPixels, inPixels, pitch * height);
				} else {
					// convert
					for (int y = 0; y < height; y++) {
						memcpy(outPixels, inPixels, width * 4);
						outPixels += width * 4;
						inPixels += pitch;
					}
				}
				return bmp.Unmanage();
			} catch (...) {
				throw;
			}
		}
		GLProgram *GLProgramManager::CreateProgram(const std::string &name) {
			SPADES_MARK_FUNCTION();

			SPLog("Loading GLSL program '%s'", name.c_str());
			std::string text = FileManager::ReadAllBytes(name.c_str());
			std::vector<std::string> lines = SplitIntoLines(text);

			GLProgram *p = new GLProgram(device, name);

			for (size_t i = 0; i < lines.size(); i++) {
				std::string text = TrimSpaces(lines[i]);
				if (text.empty())
					break;

				if (text == "*shadow*") {
					std::vector<GLShader *> shaders =
					  GLShadowShader::RegisterShader(this, settings, false);
					for (size_t i = 0; i < shaders.size(); i++)
						p->Attach(shaders[i]);
					continue;
				} else if (text == "*shadow-lite*") {
					std::vector<GLShader *> shaders =
					  GLShadowShader::RegisterShader(this, settings, false, true);
					for (size_t i = 0; i < shaders.size(); i++)
						p->Attach(shaders[i]);
					continue;
				} else if (text == "*shadow-variance*") {
					std::vector<GLShader *> shaders =
					  GLShadowShader::RegisterShader(this, settings, true);
					for (size_t i = 0; i < shaders.size(); i++)
						p->Attach(shaders[i]);
					continue;
				} else if (text == "*dlight*") {
					std::vector<GLShader *> shaders = GLDynamicLightShader::RegisterShader(this);
					for (size_t i = 0; i < shaders.size(); i++)
						p->Attach(shaders[i]);
					continue;
				} else if (text == "*shadowmap*") {
					std::vector<GLShader *> shaders = GLShadowMapShader::RegisterShader(this);
					for (size_t i = 0; i < shaders.size(); i++)
						p->Attach(shaders[i]);
					continue;
				} else if (text[0] == '*') {
					SPRaise("Unknown special shader: %s", text.c_str());
				} else if (text[0] == '#') {
					continue;
				}
				GLShader *s = CreateShader(text);

				p->Attach(s);
			}

			Stopwatch sw;
			p->Link();
			SPLog("Successfully linked GLSL program '%s' in %.3fms", name.c_str(),
			      sw.GetTime() * 1000.);
			// p->Validate();
			return p;
		}
Exemple #24
0
	void StdStream::SetPosition(uint64_t pos) {
		SPADES_MARK_FUNCTION();

		if (pos > 0x7fffffffULL) {
			SPRaise("Currently StdStream doesn't support 64-bit offset.");
		}
		fseek(handle, (long)pos, SEEK_SET);
	}
	void DeflateStream::Write(const void *data, size_t bytes) {
		SPADES_MARK_FUNCTION();
		if(mode != CompressModeCompress){
			SPRaise("Attempted to write when decompressing");
		}
		if(!valid){
			SPRaise("State is invalid");
		}
		
		if(buffer.size() >= bufferSize){
			CompressBuffer();
		}
		
		const char *dt = reinterpret_cast<const char *>(data);
		buffer.insert(buffer.end(),
					  dt, dt + bytes);
	}
	uint64_t DeflateStream::GetLength() {
		SPADES_MARK_FUNCTION();
		if(mode == CompressModeCompress){
			return position;
		}else{
			SPRaise("Cannot retrieve uncompressed data length");
		}
	}
Exemple #27
0
		void SDLRunner::Run() {
			SPADES_MARK_FUNCTION();
			SDL_Init(SDL_INIT_VIDEO);
			try{
				{
					std::string pkg = PACKAGE_STRING;
#if !NDEBUG
					pkg.append( " DEBUG build" );
#endif
#ifdef OPENSPADES_COMPILER_STR
					pkg.append( " " OPENSPADES_COMPILER_STR );	//add compiler to window title
#endif
					SDL_WM_SetCaption(pkg.c_str(), pkg.c_str());
				}
				
				SDL_Surface *surface;
				
				int sdlFlags = SDL_OPENGL | SDL_DOUBLEBUF;
				if(r_fullscreen)
					sdlFlags |= SDL_FULLSCREEN;
				
				// OpenGL core profile: supported by SDL 1.3 or later
				//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
				//SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 2);
				
				SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
				SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, r_depthBits);
				
				surface = SDL_SetVideoMode(r_videoWidth,
										   r_videoHeight,
										   r_colorBits,
										   sdlFlags);
				if(!surface){
					std::string msg = SDL_GetError();
					SPRaise("Failed to initialize video device: %s", msg.c_str());
				}
				
				
				SDL_WM_GrabInput(SDL_GRAB_ON);
				SDL_EnableUNICODE(1);
				SDL_ShowCursor(0);
				
				{
					SDLGLDevice glDevice(surface);
					Handle<draw::GLRenderer> renderer(new draw::GLRenderer(&glDevice), false);
					audio::ALDevice audio;
					
					RunClientLoop(renderer, &audio);
					
				}
			}catch(...){
				SDL_Quit();
				throw;
			}
			
			SDL_Quit();
		}
Exemple #28
0
	void CheckError(const char *source, const char *fun, int line){
		ALenum e;
		e = qalGetError();
		if(e != AL_NO_ERROR) {
			if(s_alErrorFatal)
				SPRaise("[%s:%d] : %s : OpenAL error %d: %s", source, line, fun, (int)e, DescribeError(e));
			else
				SPLog("[%s:%d] : %s : OpenAL error %d: %s", source, line, fun, (int)e, DescribeError(e));
		}
	}
Exemple #29
0
Bitmap::Bitmap(uint32_t *pixels, int w, int h):
    pixels(pixels), w(w), h(h), autoDelete(false) {
    SPADES_MARK_FUNCTION();

    if(w < 1 || h < 1 || w > 8192 || h > 8192) {
        SPRaise("Invalid dimension: %dx%d", w, h);
    }

    SPAssert(pixels != NULL);
}
Exemple #30
0
		virtual void Save(IStream *stream, Bitmap *bmp){
			SPADES_MARK_FUNCTION();
			
			jpge::params params;
			params.m_quality = core_jpegQuality;
			if(params.m_quality < 1 ||
			   params.m_quality > 100) {
				SPRaise("Invalid core_jpegQuality");
			}
			
			OutputStream outStream(stream);
			jpge::jpeg_encoder encoder;
			
			if(!encoder.init(&outStream, bmp->GetWidth(), bmp->GetHeight(), 3, params)) {
				SPRaise("JPEG encoder initialization failed.");
			}
			
			
			auto *pixels = bmp->GetPixels();
			std::vector<uint8_t> lineBuffer;
			int w = bmp->GetWidth();
			int h = bmp->GetHeight();
			lineBuffer.resize(w * 3);
			for(jpge::uint pass = 0; pass < encoder.get_total_passes(); pass++) {
				for(int y = 0; y < h; y++) {
					auto *pix = pixels + (h - 1 - y) * w;
					for(auto *out = lineBuffer.data(), *end = out + w * 3; out != end;) {
						auto p = *(pix++);
						*(out++) = static_cast<uint8_t>(p);
						*(out++) = static_cast<uint8_t>(p >> 8);
						*(out++) = static_cast<uint8_t>(p >> 16);
					}
					if(!encoder.process_scanline(lineBuffer.data())) {
						SPRaise("JPEG encoder processing failed.");
					}
				}
				if(!encoder.process_scanline(nullptr)) {
					SPRaise("JPEG encoder processing failed.");
				}
			}
			
			encoder.deinit();
		}