Hoikas/korman
4
4
Fork 0
mirror of https://github.com/H-uru/korman.git synced 2025-07-14 02:27:36 -04:00
Code Releases Activity

Pure Python korlib

Browse Source 
Yeah, korlib was a bit faster than this implementation, but, honestly,
having a second python module made life more difficult than it needed to
be. This fixes that.
This commit is contained in:
Adam Johnson
2014-07-11 22:33:07 -04:00
parent a2bde5ff28
commit f3b7ae3ad5
8 changed files with 118 additions and 403 deletions
Download Patch File Download Diff File Expand all files Collapse all files

30
korlib/CMakeLists.txt
View File

@ -1,30 +0,0 @@
project(korman)
cmake_minimum_required(VERSION 2.8.9)
find_package(HSPlasma REQUIRED)
find_package(OpenGL REQUIRED)
find_package(PythonLibs REQUIRED)
include_directories(${HSPlasma_INCLUDE_DIRS})
include_directories(${OPENGL_INCLUDE_DIR})
include_directories(${PYTHON_INCLUDE_DIR})
set(korlib_HEADERS
pyMipmap.h
utils.hpp
)
set(korlib_SOURCES
generate_mipmap.cpp
module.cpp
)
add_library(korlib SHARED ${korlib_HEADERS} ${korlib_SOURCES})
target_link_libraries(korlib HSPlasma ${OPENGL_LIBRARIES} ${PYTHON_LIBRARIES})
if(WIN32)
set_target_properties(korlib PROPERTIES SUFFIX ".pyd")
endif(WIN32)
source_group("Header Files" FILES ${korlib_HEADERS})
source_group("Source Files" FILES ${korlib_SOURCES})

210
korlib/generate_mipmap.cpp
View File

@ -1,210 +0,0 @@
/* This file is part of Korman.
*
* Korman 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.
*
* Korman 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 Korman. If not, see <http://www.gnu.org/licenses/>.
*/
#include <algorithm>
#include <cmath>
#include <cstdint>
#include <tuple>
#ifdef _WINDOWS
# define NOMINMAX
# define WIN32_LEAN_AND_MEAN
# include <windows.h>
# define GL_GENERATE_MIPMAP 0x8191
#endif // _WINDOWS
#include <gl/gl.h>
#include <ResManager/plFactory.h>
#include <PRP/Surface/plMipmap.h>
#include <Python.h>
#include "pyMipmap.h"
#include "utils.hpp"
// ========================================================================
class gl_loadimage
{
bool m_weLoadedIt;
bool m_success;
GLint m_genMipMapState;
korlib::pyref m_image;
public:
gl_loadimage(const korlib::pyref& image) : m_success(true), m_image(image)
{
size_t bindcode = korlib::getattr<size_t>(image, "bindcode");
m_weLoadedIt = (bindcode == 0);
if (m_weLoadedIt) {
m_success = (korlib::call_method<size_t>(image, "gl_load") == 0);
bindcode = korlib::getattr<size_t>(image, "bindcode");
}
if (m_success) {
glBindTexture(GL_TEXTURE_2D, bindcode);
}
// We want to gen mipmaps
// GIANTLY GNARLY DISCLAIMER:
// This requires OpenGL 1.4, which is above Windows' "built-in" headers (1.1)
// It was also deprecated in 3.0, and removed in 3.1.
// In other words, we should probably use glGenerateMipmap (3.0) or Blender's scale function
glGetTexParameteriv(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, &m_genMipMapState);
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, GL_TRUE);
}
~gl_loadimage()
{
if (m_success && m_weLoadedIt)
korlib::call_method<size_t>(m_image, "gl_free");
glTexParameteri(GL_TEXTURE_2D, GL_GENERATE_MIPMAP, m_genMipMapState);
}
bool success() const { return m_success; }
};
// ========================================================================
typedef std::tuple<size_t, size_t> imagesize_t;
/** Gets the dimensions of a Blender Image in pixels (WxH) */
static imagesize_t get_image_size(PyObject* image)
{
korlib::pyref size = PyObject_GetAttrString(image, "size");
size_t width = PyLong_AsSize_t(PySequence_GetItem(size, 0));
size_t height = PyLong_AsSize_t(PySequence_GetItem(size, 1));
return std::make_tuple(width, height);
}
static void resize_image(PyObject* image, size_t width, size_t height)
{
korlib::pyref _w = PyLong_FromSize_t(width);
korlib::pyref _h = PyLong_FromSize_t(height);
korlib::pyref callable = korlib::getattr<PyObject*>(image, "scale");
korlib::pyref result = PyObject_CallFunctionObjArgs(callable, _w, _h);
}
// ========================================================================
static void stuff_mip_level(plMipmap* mipmap, size_t level, PyObject* image, bool calcAlpha)
{
// How big is this doggone level?
GLint width, height;
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_WIDTH, &width);
glGetTexLevelParameteriv(GL_TEXTURE_2D, level, GL_TEXTURE_HEIGHT, &height);
print(" Level %d: %dx%d...", level, width, height);
// Grab the stuff from the place and the things
size_t dataSize = width * height * 4;
uint8_t* data = new uint8_t[dataSize]; // optimization: use stack for small images...
glGetTexImage(GL_TEXTURE_2D, level, GL_RGBA, GL_UNSIGNED_BYTE, data);
// Need to calculate alpha?
if (calcAlpha) {
uint8_t* ptr = data;
uint8_t* end = data + dataSize;
while (ptr < end) {
uint8_t r = *ptr++;
uint8_t g = *ptr++;
uint8_t b = *ptr++;
*ptr++ = (r + g + b) / 255;
}
}
// Stuff into plMipmap. Unfortunately, it's not smart enough to just work, so we have to do
// a little bit of TESTing here.
try {
mipmap->CompressImage(level, data, dataSize);
} catch (hsNotImplementedException&) {
mipmap->setLevelData(level, data, dataSize);
}
delete[] data;
}
// ========================================================================
extern "C" PyObject* generate_mipmap(PyObject*, PyObject* args)
{
// Convert some of this Python nonsense to good old C
PyObject* blTexImage = nullptr; // unchecked... better be right
PyObject* pymm = nullptr;
if (PyArg_ParseTuple(args, "OO", &blTexImage, &pymm) && blTexImage && pymm) {
// Since we can't link with PyHSPlasma easily, let's do some roundabout type-checking
korlib::pyref classindex = PyObject_CallMethod(pymm, "ClassIndex", "");
static short mipmap_classindex = plFactory::ClassIndex("plMipmap");
if (PyLong_AsLong(classindex) != mipmap_classindex) {
PyErr_SetString(PyExc_TypeError, "generate_mipmap expects a Blender ImageTexture and a plMipmap");
return nullptr;
}
} else {
PyErr_SetString(PyExc_TypeError, "generate_mipmap expects a Blender ImageTexture and a plMipmap");
return nullptr;
}
// Grab the important stuff
plMipmap* mipmap = ((pyMipmap*)pymm)->fThis;
korlib::pyref blImage = korlib::getattr<PyObject*>(blTexImage, "image");
bool makeMipMap = korlib::getattr<bool>(blTexImage, "use_mipmap");
bool useAlpha = korlib::getattr<bool>(blTexImage, "use_alpha");
bool calcAlpha = korlib::getattr<bool>(blTexImage, "use_calculate_alpha");
// Okay, so, here are the assumptions.
// We assume that the Korman Python code as already created the mipmap's key and named it appropriately
// So, if we're mipmapping nb01StoneSquareCobble.tga -> nb01StoneSquareCobble.dds as the key name
// What we now need to do:
// 1) Make sure this is a POT texture (if not, call scale on the Blender Image)
// 2) Check calcAlpha and all that rubbish--det DXT1/DXT5/uncompressed
// 3) "Create" the plMipmap--this allocates internal buffers and such
// 4) Loop through the levels, going down through the POTs and fill in the pixel data
// The reason we do this in C instead of python is because it's a lot of iterating over a lot of
// floating point data (we have to convert to RGB8888, joy). Should be faster here!
print("Exporting '%s'...", mipmap->getKey()->getName().cstr());
// Step 1: Resize to POT (if needed) -- don't rely on GLU for this because it may not suppport
// NPOT if we're being run on some kind of dinosaur...
imagesize_t dimensions = get_image_size(blImage);
size_t width = pow(2, log2(std::get<0>(dimensions)));
size_t height = pow(2, log2(std::get<1>(dimensions)));
if (std::get<0>(dimensions) != width || std::get<1>(dimensions) != height) {
print("\tImage is not a POT (%dx%d)... resizing to %dx%d", std::get<0>(dimensions),
std::get<1>(dimensions), width, height);
resize_image(blImage, width, height);
}
// Steps 2+3: Translate flags and pass to plMipmap::Create
// TODO: PNG compression for lossless images
uint8_t numLevels = (makeMipMap) ? 0 : 1; // 0 means "you figure it out"
uint8_t compType = (makeMipMap) ? plBitmap::kDirectXCompression : plBitmap::kUncompressed;
bool alphaChannel = useAlpha || calcAlpha;
mipmap->Create(width, height, numLevels, compType, plBitmap::kRGB8888, alphaChannel ? plBitmap::kDXT5 : plBitmap::kDXT1);
// Step 3.9: Load the image into OpenGL
gl_loadimage guard(blImage);
if (!guard.success()) {
PyErr_SetString(PyExc_RuntimeError, "failed to load image into OpenGL");
return nullptr;
}
// Step 4: Now it's a matter of looping through all the levels and exporting the image
for (size_t i = 0; i < mipmap->getNumLevels(); ++i) {
stuff_mip_level(mipmap, i, blImage, calcAlpha);
}
Py_RETURN_NONE;
}

48
korlib/module.cpp
View File

@ -1,48 +0,0 @@
/* This file is part of Korman.
*
* Korman 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.
*
* Korman 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 Korman. If not, see <http://www.gnu.org/licenses/>.
*/
#include <Python.h>
// ========================================================================
extern "C" PyObject* generate_mipmap(PyObject*, PyObject*);
// ========================================================================
static struct PyMethodDef s_korlibMethods[] =
{
{ "generate_mipmap", generate_mipmap, METH_VARARGS, "Generates a new plMipmap from a Blender ImageTexture" },
{ nullptr, nullptr, 0, nullptr },
};
static struct PyModuleDef s_korlibModule = {
PyModuleDef_HEAD_INIT,
"korlib",
NULL,
-1,
s_korlibMethods
};
#define ADD_CONSTANT(module, name) \
PyModule_AddIntConstant(module, #name, korlib::name)
PyMODINIT_FUNC PyInit_korlib()
{
PyObject* module = PyModule_Create(&s_korlibModule);
// Done!
return module;
}

27
korlib/pyMipmap.h
View File

@ -1,27 +0,0 @@
/* This file is part of Korman.
*
* Korman 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.
*
* Korman 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 Korman. If not, see <http://www.gnu.org/licenses/>.
*/
/**
* \file Declarations required to interop with PyHSPlasma's pyMipmap
*/
#include <Python.h>
typedef struct {
PyObject_HEAD
class plMipmap* fThis;
bool fPyOwned;
} pyMipmap;

82
korlib/utils.hpp
View File

@ -1,82 +0,0 @@
/* This file is part of Korman.
*
* Korman 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.
*
* Korman 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 Korman. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef __KORLIB_UTILS_HPP
#define __KORLIB_UTILS_HPP
#include <Python.h>
#define print(fmt, ...) PySys_WriteStdout(" " fmt "\n", __VA_ARGS__)
namespace korlib
{
/** RAII for PyObject pointers */
class pyref
{
PyObject* _ref;
public:
pyref(PyObject* o) : _ref(o) { }
pyref(const pyref& copy) : _ref((PyObject*)copy)
{
Py_INCREF(_ref);
}
~pyref()
{
Py_XDECREF(_ref);
}
operator PyObject*() const { return _ref; }
};
template<typename T>
T call_method(PyObject* o, const char* method);
template<>
size_t call_method(PyObject* o, const char* method)
{
pyref retval = PyObject_CallMethod(o, const_cast<char*>(method), "");
if ((PyObject*)retval)
return PyLong_AsSize_t(retval);
else
return static_cast<size_t>(-1);
}
template<typename T>
T getattr(PyObject* o, const char* name);
template<>
bool getattr(PyObject* o, const char* name)
{
pyref attr = PyObject_GetAttrString(o, name);
return PyLong_AsLong(attr) != 0;
}
template<>
PyObject* getattr(PyObject* o, const char* name)
{
return PyObject_GetAttrString(o, name);
}
template<>
size_t getattr(PyObject* o, const char* name)
{
pyref attr = PyObject_GetAttrString(o, name);
return PyLong_AsSize_t(attr);
}
};
#endif // __KORLIB_UTILS_HPP