mirror of https://github.com/H-uru/korman.git
Adam Johnson
11 years ago
13 changed files with 651 additions and 60 deletions
@ -0,0 +1,30 @@
|
||||
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}) |
@ -0,0 +1,213 @@
|
||||
/* 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 alphaChannel, bool calcAlpha) |
||||
{ |
||||
GLint format = alphaChannel ? GL_RGBA : GL_RGB; |
||||
uint8_t bytesPerPixel = alphaChannel ? 4 : 3; |
||||
|
||||
// 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 * bytesPerPixel; |
||||
uint8_t* data = new uint8_t[dataSize]; // optimization: use stack for small images...
|
||||
glGetTexImage(GL_TEXTURE_2D, level, format, GL_UNSIGNED_BYTE, data); |
||||
|
||||
// Need to calculate alpha?
|
||||
if (alphaChannel && 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., korlib::log2(static_cast<double>(std::get<0>(dimensions)))); |
||||
size_t height = pow(2., korlib::log2(static_cast<double>(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, alphaChannel, calcAlpha); |
||||
} |
||||
|
||||
Py_RETURN_NONE; |
||||
} |
@ -0,0 +1,48 @@
|
||||
/* 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; |
||||
} |
@ -0,0 +1,27 @@
|
||||
/* 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; |
@ -0,0 +1,89 @@
|
||||
/* 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); |
||||
} |
||||
|
||||
/** MSVC++ is not C99 compliant :( */ |
||||
double log2(double v) |
||||
{ |
||||
static double hack = log(2.); |
||||
return log(v) / hack; |
||||
} |
||||
}; |
||||
|
||||
#endif // __KORLIB_UTILS_HPP
|
@ -0,0 +1,130 @@
|
||||
# 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/>. |
||||
|
||||
import bpy |
||||
import korlib |
||||
from PyHSPlasma import * |
||||
import weakref |
||||
|
||||
from . import explosions |
||||
from . import utils |
||||
|
||||
class MaterialConverter: |
||||
_hsbitmaps = {} |
||||
|
||||
def __init__(self, exporter): |
||||
self._exporter = weakref.ref(exporter) |
||||
|
||||
def export_material(self, bo, bm): |
||||
"""Exports a Blender Material as an hsGMaterial""" |
||||
print(" Exporting Material '{}'".format(bm.name)) |
||||
|
||||
hsgmat = self._mgr.add_object(hsGMaterial, name=bm.name, bl=bo) |
||||
self._export_texture_slots(bo, bm, hsgmat) |
||||
|
||||
# Plasma makes several assumptions that every hsGMaterial has at least one layer. If this |
||||
# material had no Textures, we will need to initialize a default layer |
||||
if not hsgmat.layers: |
||||
layer = self._mgr.add_object(plLayer, name="{}_AutoLayer".format(bm.name), bl=bo) |
||||
self._propagate_material_settings(bm, layer) |
||||
hsgmat.addLayer(layer.key) |
||||
|
||||
# Looks like we're done... |
||||
return hsgmat.key |
||||
|
||||
def _export_texture_slots(self, bo, bm, hsgmat): |
||||
for slot in bm.texture_slots: |
||||
if slot is None or not slot.use: |
||||
continue |
||||
|
||||
name = "{}_{}".format(bm.name, slot.name) |
||||
print(" Exporting Plasma Layer '{}'".format(name)) |
||||
layer = self._mgr.add_object(plLayer, name=name, bl=bo) |
||||
self._propagate_material_settings(bm, layer) |
||||
|
||||
# UVW Channel |
||||
for i, uvchan in enumerate(bo.data.tessface_uv_textures): |
||||
if uvchan.name == slot.uv_layer: |
||||
layer.UVWSrc = i |
||||
print(" Using UV Map #{} '{}'".format(i, name)) |
||||
break |
||||
else: |
||||
print(" No UVMap specified... Blindly using the first one, maybe it exists :|") |
||||
|
||||
# General texture flags and such |
||||
texture = slot.texture |
||||
# ... |
||||
|
||||
# Export the specific texture type |
||||
export_fn = "_export_texture_type_{}".format(texture.type.lower()) |
||||
if not hasattr(self, export_fn): |
||||
raise explosions.UnsupportedTextureError(texture, bm) |
||||
getattr(self, export_fn)(bo, hsgmat, layer, texture) |
||||
hsgmat.addLayer(layer.key) |
||||
|
||||
def _export_texture_type_image(self, bo, hsgmat, layer, texture): |
||||
"""Exports a Blender ImageTexture to a plLayer""" |
||||
|
||||
# First, let's apply any relevant flags |
||||
state = layer.state |
||||
if texture.invert_alpha: |
||||
state.blendFlags |= hsGMatState.kBlendInvertAlpha |
||||
|
||||
# Now, let's export the plBitmap |
||||
# If the image is None (no image applied in Blender), we assume this is a plDynamicTextMap |
||||
# Otherwise, we create a plMipmap and call into korlib to export the pixel data |
||||
if texture.image is None: |
||||
bitmap = self.add_object(plDynamicTextMap, name="{}_DynText".format(layer.key.name), bl=bo) |
||||
else: |
||||
# blender likes to create lots of spurious .0000001 objects :/ |
||||
name = texture.image.name |
||||
name = name[:name.find('.')] |
||||
if texture.use_mipmap: |
||||
name = "{}.dds".format(name) |
||||
else: |
||||
name = "{}.bmp".format(name) |
||||
|
||||
if name in self._hsbitmaps: |
||||
# well, that was easy... |
||||
print(" Using '{}'".format(name)) |
||||
layer.texture = self._hsbitmaps[name].key |
||||
return |
||||
else: |
||||
location = self._mgr.get_textures_page(bo) |
||||
bitmap = self._mgr.add_object(plMipmap, name=name, loc=location) |
||||
korlib.generate_mipmap(texture, bitmap) |
||||
|
||||
# Store the created plBitmap and toss onto the layer |
||||
self._hsbitmaps[name] = bitmap |
||||
layer.texture = bitmap.key |
||||
|
||||
@property |
||||
def _mgr(self): |
||||
return self._exporter().mgr |
||||
|
||||
def _propagate_material_settings(self, bm, layer): |
||||
"""Converts settings from the Blender Material to corresponding plLayer settings""" |
||||
state = layer.state |
||||
|
||||
# Shade Flags |
||||
if not bm.use_mist: |
||||
state.shadeFlags |= hsGMatState.kShadeNoFog # Dead in CWE |
||||
state.shadeFlags |= hsGMatState.kShadeReallyNoFog |
||||
|
||||
# Colors |
||||
layer.ambient = utils.color(bpy.context.scene.world.ambient_color) |
||||
layer.preshade = utils.color(bm.diffuse_color) |
||||
layer.runtime = utils.color(bm.diffuse_color) |
||||
layer.specular = utils.color(bm.specular_color) |
Loading…
Reference in new issue