Initial commit

engines/tetraedge/te/te_tiled_texture.cpp

@@ -0,0 +1,181 @@
+/* ScummVM - Graphic Adventure Engine
+ *
+ * ScummVM is the legal property of its developers, whose names
+ * are too numerous to list here. Please refer to the COPYRIGHT
+ * file distributed with this source distribution.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ */
+
+#include "tetraedge/tetraedge.h"
+
+#include "tetraedge/te/te_resource_manager.h"
+#include "tetraedge/te/te_tiled_texture.h"
+#include "tetraedge/te/te_tiled_surface.h"
+
+namespace Tetraedge {
+
+TeTiledTexture::TeTiledTexture() : _tileSize(0x800, 0x800), _skipBlank(false) {
+}
+
+bool TeTiledTexture::isLoaded() {
+	return !_tileArray.empty();
+}
+
+
+bool TeTiledTexture::load(const Common::Path &path) {
+	release();
+	TeIntrusivePtr<TeImage> img;
+	TeResourceManager *resmgr = g_engine->getResourceManager();
+	if (resmgr->exists(path)) {
+		img = resmgr->getResourceByName<TeImage>(path);
+	} else {
+		img = new TeImage();
+		TeCore *core = g_engine->getCore();
+		if (!img->load(core->findFile(path)))
+			return false;
+	}
+	load(*img);
+	return true;
+}
+
+bool TeTiledTexture::load(const TeImage &img) {
+	release();
+
+	Common::Array<TeImage> imgArray;
+	imgArray.reserve(4);
+
+	_totalSize._x = img.w;
+	_totalSize._y = img.h;
+	_somethingSize = TeVector2s32(0, 0);
+	const int rows = (int)ceilf((float)_totalSize._x / _tileSize._x);
+	const int cols = (int)ceilf((float)_totalSize._y / _tileSize._y);
+	_tileArray.resize(cols * rows);
+
+	for (int col = 0; col < cols; col++) {
+		for (int row = 0; row < rows; row++) {
+			const TeVector2s32 remainingSize(img.w - _tileSize._x * row, img.h - _tileSize._y * col);
+			TeVector2s32 newTileSize = remainingSize;
+
+			if (_tileSize._x < remainingSize._x) {
+				newTileSize = TeVector2s32(_tileSize._x, remainingSize._y);
+			}
+			if (_tileSize._y < remainingSize._y) {
+				newTileSize = TeVector2s32(remainingSize._x, _tileSize._y);
+			}
+
+			const TeImage *tileimage;
+			if (newTileSize != _totalSize) {
+				TeImage *optimizedimg = optimisedTileImage(imgArray, newTileSize, Common::SharedPtr<TePalette>(), img.format);
+				img.copy(*optimizedimg, TeVector2s32(0, 0), TeVector2s32(_tileSize._x * row, _tileSize._y * col), newTileSize);
+				//optimizedimg->_flipY = img._flipY;
+				Common::String accessName = Common::String::format("%s.Tile%dx%d", img.getAccessName().toString('/').c_str(), row, col);
+				optimizedimg->setAccessName(Common::Path(accessName, '/'));
+				tileimage = optimizedimg;
+			} else {
+				tileimage = &img;
+			}
+
+			Tile *tiledata = tile(TeVector2s32(row, col));
+			if (!_skipBlank || (int)tileimage->countPixelsOfColor(TeColor(0, 0, 0, 0)) != (tileimage->h * tileimage->w)) {
+				tiledata->_texture = Te3DTexture::makeInstance();
+				tiledata->_texture->load(*tileimage);
+				tiledata->_vec2 = TeVector3f32
+						((float)tiledata->_texture->width() / (float)_totalSize._x,
+						 (float)tiledata->_texture->height() / (float)_totalSize._y, 0.0);
+				_somethingSize += TeVector2s32(tiledata->_texture->width(), tiledata->_texture->height());
+			} else {
+				tiledata->_texture.release();
+				tiledata->_vec2 = TeVector3f32(0, 0, 0);
+				_somethingSize = Te3DTexture::optimisedSize(TeVector2s32(tileimage->w, tileimage->h));
+			}
+			tiledata->_vec1 = TeVector3f32(row * ((float)_tileSize._x / _totalSize._x),
+										   col * ((float)_tileSize._y / _totalSize._y), 0.0);
+		}
+	}
+
+	if (cols)
+		_somethingSize._x = _somethingSize._x / cols;
+	if (rows)
+		_somethingSize._y = _somethingSize._y / rows;
+	setAccessName(img.getAccessName().append(".tt"));
+	return true;
+}
+
+bool TeTiledTexture::load(const TeIntrusivePtr<Te3DTexture> &texture) {
+	release();
+	_tileSize._x = texture->width();
+	_tileSize._y = texture->height();
+	_totalSize = _tileSize;
+	_tileArray.resize(1);
+	Tile *tileData = tile(TeVector2s32(0, 0));
+	tileData->_texture = texture;
+	tileData->_vec2 = TeVector3f32(1, 1, 0);
+	tileData->_vec1 = TeVector3f32(0, 0, 0);
+	setAccessName(texture->getAccessName().append(".tt"));
+	return true;
+}
+
+uint32 TeTiledTexture::numberOfColumns() const {
+	return ceilf((float)_totalSize._x / (float)_tileSize._x);
+}
+
+uint32 TeTiledTexture::numberOfRow() const {
+	return ceilf((float)_totalSize._y / (float)_tileSize._y);
+}
+
+/*static*/
+TeImage *TeTiledTexture::optimisedTileImage(Common::Array<TeImage> &images, const TeVector2s32 &size,
+							const Common::SharedPtr<TePalette> &pal, const Graphics::PixelFormat &format) {
+	for (TeImage &image : images) {
+		if (image.w == size._x && image.h == size._y && image.format == format) {
+			return &image;
+		}
+	}
+	images.resize(images.size() + 1);
+	TeImage &newImg = images.back();
+	Common::SharedPtr<TePalette> nullPal;
+	newImg.createImg((uint)size._x, (uint)size._y, nullPal, format);
+	return &newImg;
+}
+
+void TeTiledTexture::release() {
+	_tileArray.clear();
+	_totalSize = TeVector2s32();
+	_somethingSize = TeVector2s32();
+}
+
+TeTiledTexture::Tile *TeTiledTexture::tile(const TeVector2s32 &loc) {
+	int columns = ceilf((float)_totalSize._x / (float)_tileSize._x);
+	uint tileno = columns * loc._y + loc._x;
+	if (tileno >= _tileArray.size())
+		error("Invalid tile %d/%d requested in TeTiledTexture::tile", tileno + 1, _tileArray.size());
+	return &_tileArray[tileno];
+}
+
+void TeTiledTexture::update(const TeImage &image) {
+// TODO: Implement fast path of TeTiledTexture::update
+#if 0
+	if (image.w == _totalSize._x && image.h == _totalSize._y) {
+		// fast path code goes here
+	} else {
+		load(image);
+	}
+#else
+	load(image);
+#endif
+}
+
+} // end namespace Tetraedge