bool KOrthogonalMap::_loadStream(KIStream &Stream, const std::string &Address) {
if (!Stream.isOpen()) {
Stream.close();
}
if (!Stream.open(Address, IOMode::BIN)) {
KD_FPRINT("can't open stream. address: %s", Address.c_str());
return false;
}
KBinarySerial bserial;
if (!bserial.loadStream(Stream, Address)) {
KD_PRINT("can't load stream");
Stream.close();
return false;
}
std::string format;
bserial >> format;
if (format != "KOMap") {
KD_PRINT("incorrect file format");
Stream.close();
return false;
}
bserial >> _kwidth;
bserial >> _kheight;
bserial >> _ktilewidth;
bserial >> _ktileheight;
bserial >> _ktotalWidthPixels;
bserial >> _ktotalHeightPixels;
bserial >> _krootList;
bserial >> _knodeList;
bserial >> _ktilesetStamp;
bserial >> _klayerNames;
// load composite resources (texture)
auto slist = getCompositeList();
if (!slist.empty()) {
_ktileSet = (KAtlasTextureArray *)(*slist.begin());
} else {
_ktileSet = nullptr;
}
Stream.close();
return true;
}
void KOrthogonalMap::swapTileLayer(U32 TileID, U16 Layer1, U16 Layer2) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
if (Layer1 == Layer2) return;
// layer 1
KOrthoLayer layer1;
bool l1 = getTileLayer(TileID, Layer1, layer1);
removeTileLayer(TileID, Layer1);
// layer 2
KOrthoLayer layer2;
bool l2 = getTileLayer(TileID, Layer2, layer2);
removeTileLayer(TileID, Layer2);
if (l1) {
setTileLayer(TileID, Layer2, layer1);
}
if (l2) {
setTileLayer(TileID, Layer1, layer2);
}
#if defined(KITE_EDITOR)
setScenePtr(TileID, Layer1, layer2.sceneItem);
setScenePtr(TileID, Layer2, layer1.sceneItem);
#endif
}
void KShaderProgram::bindAttribute(U16 Index, const std::string &Name){
if (_kisCreated) {
KD_PRINT("this function is ineffective after binding the shader program");
return;
}
_kattribList.push_back({ Index, Name });
}
bool KOrthogonalMap::_saveStream(KOStream &Stream, const std::string &Address) {
// texture information
KBinarySerial bserial;
bserial << std::string("KOMap");
bserial << _kwidth;
bserial << _kheight;
bserial << _ktilewidth;
bserial << _ktileheight;
bserial << _ktotalWidthPixels;
bserial << _ktotalHeightPixels;
bserial << _krootList;
bserial << _knodeList;
bserial << _ktilesetStamp;
bserial << _klayerNames;
if (!bserial.saveStream(Stream, Address, 0)) {
KD_PRINT("can't save stream.");
Stream.close();
return false;
}
Stream.close();
// save composite list (texture)
std::vector<KResource *> composite;
composite.push_back((KResource *)_ktileSet);
setCompositeList(composite);
return true;
}
void _trace_blk(IBlk * blk, const char * action)
{
char path[F8_MAX_PATH];
*path = 0;
IBlk_path_by_blk(blk, path, sizeof(path));
KD_PRINT(("%s block %s\n", action, path));
}
SIZE KArchiveStream::write(const void *Data, SIZE DataSize) {
if (_kzipIO->writeFile(Data, DataSize, _kcomp)) {
return DataSize;
}
KD_PRINT("archive writing error");
return 0;
}
SIZE KOrthogonalMap::getTileLayerSize(U32 TileID) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return 0;
}
return _krootList[TileID].layerSize;
}
void KGLWindow::open(){
// initialize SDL
Internal::initeSDL();
// destroy currently window
if (_kwindow){
KD_PRINT("this window is currently opened!");
return;
}
// make flags
U32 flag = SDL_WINDOW_OPENGL;
if (_kwinstate.fullscreen) {
_kwinstate.xpos = 0;
_kwinstate.ypos = 0;
flag = flag | SDL_WINDOW_FULLSCREEN;
} else {
if (_kwinstate.resizable) {
flag = flag | SDL_WINDOW_RESIZABLE;
}
}
// OGL version
// opengl 3.3 or greater
if (_kwinstate.oglMajor <= 3) {
_kwinstate.oglMajor = 3;
if (_kwinstate.oglMinor < 3)
_kwinstate.oglMinor = 3;
}
// Set our OpenGL version.
// SDL_GL_CONTEXT_CORE gives us only the newer version, deprecated functions are disabled
DSDL_CALL(SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE));
DSDL_CALL(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, _kwinstate.oglMajor));
DSDL_CALL(SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, _kwinstate.oglMinor));
// optimize for 2D purpose
DSDL_CALL(SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 0));
DSDL_CALL(SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0));
// double buffer
DSDL_CALL(SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1));
// Create our window
DSDL_CALL(_kwindow = SDL_CreateWindow(_kwinstate.title.c_str(), _kwinstate.xpos, _kwinstate.ypos,
_kwinstate.width, _kwinstate.height, flag));
// Create an OpenGL context associated with the window.
DSDL_CALL(_kcontext = SDL_GL_CreateContext(_kwindow));
DSDL_CALL(SDL_GL_SetSwapInterval(_kwinstate.swapInterval));
if (!_kwinstate.showCursor) {
DSDL_CALL(SDL_ShowCursor(SDL_DISABLE));
}
}
U64 ZipIO::_readCompressed(void *Data, U64 DataSize){
if (!_kisopen || !_kready || _kfindex < 0 || _kmode == OpenMode::WRITE)
return 0;
if (mz_zip_reader_extract_to_mem(&_kzarchive, _kfindex, Data, (size_t)DataSize, 0))
return DataSize;
KD_PRINT("reading archive error");
return 0;
}
const KSharedResource &KShaderProgram::getShader(ShaderType Type) {
if (Type == ShaderType::VERTEX) {
return _kvert;
} else if (Type == ShaderType::FRAGMENT) {
return _kfrag;
} else if (Type == ShaderType::GEOMETRY) {
return _kgeom;
}
KD_PRINT("incorrect shader type");
return KSharedResource();
}
I32 ZipIO::setReadOffset(I64 Offset, I32 Origin){
if (!_kisopen || !_kready || _kfindex < 0 || _kmode == OpenMode::WRITE)
return -1;
if (_kisCmprsd)
return -1;
switch (Origin){
case SEEK_SET:
// calibration new offset
if ((U64)Offset > _kfstat.m_uncomp_size)
Offset = _kfstat.m_uncomp_size;
// return current offset to base offset
_kcurOfst -= _kfileCurOfst;
// set new offset
_kcurOfst += Offset;
_kfileCurOfst = Offset;
return 0;
case SEEK_CUR:
// calibration new offset
if ((Offset + _kfileCurOfst) > _kfstat.m_uncomp_size)
Offset = _kfstat.m_uncomp_size - _kfileCurOfst;
// set new offset
_kcurOfst += Offset;
_kfileCurOfst = Offset;
return 0;
case SEEK_END:
// calibration new offset
if ((U64)Offset > _kfstat.m_uncomp_size)
Offset = 0;
// return current offset to base offset
_kcurOfst -= _kfileCurOfst;
// set new offset
_kcurOfst += _kfstat.m_uncomp_size - Offset;
_kfileCurOfst = _kfstat.m_uncomp_size - Offset;
return 0;
default:
break;
}
KD_PRINT("invalid param");
return -1;
}
void KOrthogonalMap::setTileLayer(U32 TileID, U16 LayerIndex, const KOrthoLayer &Layer) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
// find layer if it is already exist otherwise create it
KOrthoNode &nodeRef = insertNode(TileID, LayerIndex);
// reset node with new values
initeNode(nodeRef, TileID, Layer);
}
KRectF32 KOrthogonalMap::getTileDimension(U32 TileID) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return KRectF32();
}
KRectF32 Output;
Output.bottom = (TileID / _kwidth) * _ktileheight;
Output.top = Output.bottom + _ktileheight;
Output.left = (TileID % _kwidth) * _ktilewidth;
Output.right = Output.left + _ktilewidth;
return Output;
}
bool KShaderProgram::setShader(const KSharedResource &Shader){
auto shader = static_cast<const KShader *>(Shader.constGet());
if (shader->getShaderType() == ShaderType::VERTEX) {
_kvert = Shader;
} else if (shader->getShaderType() == ShaderType::FRAGMENT) {
_kfrag = Shader;
} else if (shader->getShaderType() == ShaderType::GEOMETRY) {
_kgeom = Shader;
} else {
KD_PRINT("incorrect shader type.");
return false;
}
return true;
}
U64 ZipIO::_readUncompressed(void *Data, U64 DataSize){
if (!_kisopen || !_kready || _kfindex < 0 || _kmode == OpenMode::WRITE)
return 0;
if (!Data || DataSize == 0)
return 0;
U64 buffSize = MZ_MIN(DataSize, (_kfstat.m_uncomp_size - _kfileCurOfst));
if (_kzarchive.m_pRead(_kzarchive.m_pIO_opaque, _kcurOfst, Data, (size_t)buffSize) == buffSize){
_kcurOfst += buffSize;
_kfileCurOfst += buffSize;
return buffSize;
}
KD_PRINT("reading archive error");
return 0;
}
bool KShaderProgram::bind(){
// create texture only first time
if (!_kisCreated) {
if (!_create()) {
KD_PRINT("can't initialize shader program");
return false;
}
}
if (_klastProgId != _kprogId){
// enable the program
DGL_CALL(glUseProgram(_kprogId));
_klastProgId = _kprogId;
}
return true;
}
void KOrthogonalMap::getTileLayers(U32 TileID, std::vector<KOrthoLayer> &Output) {
Output.clear();
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
Output.reserve(_krootList[TileID].layerSize);
U32 tindex = _krootList[TileID].firstNode;
auto dim = getTileDimension(TileID);
for (SIZE ncounter = 0; ncounter < _krootList[TileID].layerSize; ++ncounter) {
Output.push_back(KOrthoLayer());
initeLayer(_knodeList[tindex], Output.back());
tindex = _knodeList[tindex].nextNode;
}
}
void KOrthogonalMap::removeTileLayer(U32 TileID, U16 LayerIndex) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
// empty tile (there is no layer)
if (_krootList[TileID].layerSize == 0) return;
// iterate over layers
SIZE nodeIndex = _krootList[TileID].firstNode;
SIZE prevNode = nodeIndex;
for (U16 i = 0; i < _krootList[TileID].layerSize; ++i) {
// layer not found
if (_knodeList[nodeIndex].layerIndex > LayerIndex) break;
// layer found
if (_knodeList[nodeIndex].layerIndex == LayerIndex) {
// first node
if (i == 0) {
_krootList[TileID].firstNode = _knodeList[nodeIndex].nextNode;
} else {
_knodeList[prevNode].nextNode = _knodeList[nodeIndex].nextNode;
}
--_krootList[TileID].layerSize;
// swap and remove methode
moveNode(_knodeList.back(), nodeIndex);
_knodeList.pop_back();
break;
}
// store current node
prevNode = nodeIndex;
// move to next node
nodeIndex = _knodeList[nodeIndex].nextNode;
}
}
void KOrthogonalMap::setScenePtr(U32 TileID, U16 LayerIndex, void *Pointer) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
// iterate over nodes
SIZE nodeIndex = _krootList[TileID].firstNode;
for (SIZE i = 0; i < _krootList[TileID].layerSize; ++i) {
// layer found
if (_knodeList[nodeIndex].layerIndex == LayerIndex) {
_knodeList[nodeIndex].sceneItem = Pointer;
return;
}
// layer not found
if (_knodeList[nodeIndex].layerIndex > LayerIndex) break;
// move to next node
nodeIndex = _knodeList[nodeIndex].nextNode;
}
}
void KOrthogonalMap::removeTileLayers(U32 TileID) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return;
}
// iterate over nodes and remove them
auto tempSize = _krootList[TileID].layerSize;
for (SIZE i = 0; i < tempSize; ++i) {
--_krootList[TileID].layerSize;
// swap and remove methode
// swap removed node with last node in the list
moveNode(_knodeList.back(), _krootList[TileID].firstNode);
_knodeList.pop_back();
// move first pointer to next node
_krootList[TileID].firstNode = _knodeList[_krootList[TileID].firstNode].nextNode;
}
// cleanup root
_krootList[TileID].firstNode = 0;
}
bool KOrthogonalMap::getTileLayer(U32 TileID, U16 LayerIndex, KOrthoLayer &Output) {
// check range
if (TileID >= _krootList.size()) {
KD_PRINT("tile id is out of range or tile map is not created yet");
return false;
}
// iterate over nodes
SIZE nodeIndex = _krootList[TileID].firstNode;
for (SIZE i = 0; i < _krootList[TileID].layerSize; ++i) {
// layer found
if (_knodeList[nodeIndex].layerIndex == LayerIndex) {
initeLayer(_knodeList[nodeIndex], Output);
return true;
}
// layer not found
if (_knodeList[nodeIndex].layerIndex > LayerIndex) break;
// move to next node
nodeIndex = _knodeList[nodeIndex].nextNode;
}
return false;
}
