mirror of https://github.com/H-uru/korman.git
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.pull/6/head
8 changed files with 118 additions and 403 deletions
@ -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}) |
||||
@ -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; |
||||
} |
||||
@ -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; |
||||
} |
||||
@ -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; |
||||
@ -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
|
||||
Loading…
Reference in new issue