#include "python_grp.h" #include "eter_image/GrpDevice.h" #include "eter_image/GrpImageInstance.h" #include "eter_image/GrpExpandedImageInstance.h" #include "eter_resource/ResourceManager.h" #include "eter_ui/PythonWindow.h" #include #include #include #include #include #include #include namespace ava2 { namespace { static uint32_t s_currentColor = 0xFFFFFFFF; static uint32_t s_diffuseColor = 0xFFFFFFFF; static uint32_t s_clearColor = 0xFF000000; static float s_alpha = 1.0f; // --------------------------------------------------------------------- // grp Color & Primitive Rendering // --------------------------------------------------------------------- static PyObject* grp_GenerateColor(PyObject*, PyObject* args) { float r = 0.0f, g = 0.0f, b = 0.0f, a = 1.0f; if (!PyArg_ParseTuple(args, "ffff", &r, &g, &b, &a)) { PyErr_Clear(); int ir = 0, ig = 0, ib = 0, ia = 255; if (PyArg_ParseTuple(args, "iiii", &ir, &ig, &ib, &ia)) { uint32_t color = ((uint32_t)(ia & 0xFF) << 24) | ((uint32_t)(ir & 0xFF) << 16) | ((uint32_t)(ig & 0xFF) << 8) | (uint32_t)(ib & 0xFF); return PyLong_FromUnsignedLong(color); } return PyLong_FromUnsignedLong(0xFFFFFFFF); } uint8_t ur = (uint8_t)std::clamp((int)(r * 255.0f), 0, 255); uint8_t ug = (uint8_t)std::clamp((int)(g * 255.0f), 0, 255); uint8_t ub = (uint8_t)std::clamp((int)(b * 255.0f), 0, 255); uint8_t ua = (uint8_t)std::clamp((int)(a * 255.0f), 0, 255); uint32_t color = ((uint32_t)ua << 24) | ((uint32_t)ur << 16) | ((uint32_t)ug << 8) | (uint32_t)ub; return PyLong_FromUnsignedLong(color); } static PyObject* grp_SetColor(PyObject*, PyObject* args) { unsigned long color = 0; if (PyArg_ParseTuple(args, "k", &color)) { s_currentColor = (uint32_t)color; } else { PyErr_Clear(); int icolor = 0; if (PyArg_ParseTuple(args, "i", &icolor)) { s_currentColor = (uint32_t)icolor; } } Py_RETURN_NONE; } static PyObject* grp_SetAlpha(PyObject*, PyObject* args) { float a = 1.0f; if (PyArg_ParseTuple(args, "f", &a)) { s_alpha = std::clamp(a, 0.0f, 1.0f); uint8_t ua = (uint8_t)(s_alpha * 255.0f); s_currentColor = (s_currentColor & 0x00FFFFFF) | ((uint32_t)ua << 24); } Py_RETURN_NONE; } static PyObject* grp_SetDiffuseColor(PyObject*, PyObject* args) { float r = 1.0f, g = 1.0f, b = 1.0f, a = 1.0f; if (PyArg_ParseTuple(args, "ffff", &r, &g, &b, &a)) { uint8_t ur = (uint8_t)std::clamp((int)(r * 255.0f), 0, 255); uint8_t ug = (uint8_t)std::clamp((int)(g * 255.0f), 0, 255); uint8_t ub = (uint8_t)std::clamp((int)(b * 255.0f), 0, 255); uint8_t ua = (uint8_t)std::clamp((int)(a * 255.0f), 0, 255); s_diffuseColor = ((uint32_t)ua << 24) | ((uint32_t)ur << 16) | ((uint32_t)ug << 8) | (uint32_t)ub; } Py_RETURN_NONE; } static PyObject* grp_SetClearColor(PyObject*, PyObject* args) { float r = 0.0f, g = 0.0f, b = 0.0f; if (PyArg_ParseTuple(args, "fff", &r, &g, &b)) { uint8_t ur = (uint8_t)std::clamp((int)(r * 255.0f), 0, 255); uint8_t ug = (uint8_t)std::clamp((int)(g * 255.0f), 0, 255); uint8_t ub = (uint8_t)std::clamp((int)(b * 255.0f), 0, 255); s_clearColor = 0xFF000000 | ((uint32_t)ur << 16) | ((uint32_t)ug << 8) | (uint32_t)ub; } Py_RETURN_NONE; } static PyObject* grp_RenderBar(PyObject*, PyObject* args) { int x = 0, y = 0, w = 0, h = 0; if (PyArg_ParseTuple(args, "iiii", &x, &y, &w, &h)) { auto* renderer = CGraphicDevice::Instance().GetRenderer(); if (renderer && w > 0 && h > 0) { uint8_t a = (s_currentColor >> 24) & 0xFF; uint8_t r = (s_currentColor >> 16) & 0xFF; uint8_t g = (s_currentColor >> 8) & 0xFF; uint8_t b = s_currentColor & 0xFF; SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, r, g, b, a); SDL_FRect rect{ (float)x, (float)y, (float)w, (float)h }; SDL_RenderFillRect(renderer, &rect); } } Py_RETURN_NONE; } static PyObject* grp_RenderLine(PyObject*, PyObject* args) { int x = 0, y = 0, dx = 0, dy = 0; if (PyArg_ParseTuple(args, "iiii", &x, &y, &dx, &dy)) { auto* renderer = CGraphicDevice::Instance().GetRenderer(); if (renderer) { uint8_t a = (s_currentColor >> 24) & 0xFF; uint8_t r = (s_currentColor >> 16) & 0xFF; uint8_t g = (s_currentColor >> 8) & 0xFF; uint8_t b = s_currentColor & 0xFF; SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, r, g, b, a); SDL_RenderLine(renderer, (float)x, (float)y, (float)(x + dx), (float)(y + dy)); } } Py_RETURN_NONE; } static PyObject* grp_RenderBox(PyObject*, PyObject* args) { int x = 0, y = 0, w = 0, h = 0; if (PyArg_ParseTuple(args, "iiii", &x, &y, &w, &h)) { auto* renderer = CGraphicDevice::Instance().GetRenderer(); if (renderer && w > 0 && h > 0) { uint8_t a = (s_currentColor >> 24) & 0xFF; uint8_t r = (s_currentColor >> 16) & 0xFF; uint8_t g = (s_currentColor >> 8) & 0xFF; uint8_t b = s_currentColor & 0xFF; SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, r, g, b, a); SDL_FRect rect{ (float)x, (float)y, (float)w, (float)h }; SDL_RenderRect(renderer, &rect); } } Py_RETURN_NONE; } static PyObject* grp_RenderRoundBox(PyObject*, PyObject* args) { int x = 0, y = 0, w = 0, h = 0; if (PyArg_ParseTuple(args, "iiii", &x, &y, &w, &h)) { auto* renderer = CGraphicDevice::Instance().GetRenderer(); if (renderer && w > 0 && h > 0) { uint8_t a = (s_currentColor >> 24) & 0xFF; uint8_t r = (s_currentColor >> 16) & 0xFF; uint8_t g = (s_currentColor >> 8) & 0xFF; uint8_t b = s_currentColor & 0xFF; SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); SDL_SetRenderDrawColor(renderer, r, g, b, a); SDL_FRect rect{ (float)x, (float)y, (float)w, (float)h }; SDL_RenderRect(renderer, &rect); } } Py_RETURN_NONE; } static PyObject* grp_RenderGradationBar(PyObject*, PyObject* args) { int x = 0, y = 0, w = 0, h = 0; unsigned long startCol = 0, endCol = 0; if (PyArg_ParseTuple(args, "iiiikk", &x, &y, &w, &h, &startCol, &endCol)) { auto* renderer = CGraphicDevice::Instance().GetRenderer(); if (renderer && w > 0 && h > 0) { uint8_t sa = (startCol >> 24) & 0xFF, sr = (startCol >> 16) & 0xFF, sg = (startCol >> 8) & 0xFF, sb = startCol & 0xFF; uint8_t ea = (endCol >> 24) & 0xFF, er = (endCol >> 16) & 0xFF, eg = (endCol >> 8) & 0xFF, eb = endCol & 0xFF; SDL_FColor c1{ sr/255.0f, sg/255.0f, sb/255.0f, sa/255.0f }; SDL_FColor c2{ er/255.0f, eg/255.0f, eb/255.0f, ea/255.0f }; SDL_Vertex verts[4]; verts[0] = { { (float)x, (float)y }, c1, {0, 0} }; verts[1] = { { (float)(x+w), (float)y }, c1, {0, 0} }; verts[2] = { { (float)(x+w), (float)(y+h) }, c2, {0, 0} }; verts[3] = { { (float)x, (float)(y+h) }, c2, {0, 0} }; int indices[6] = { 0, 1, 2, 0, 2, 3 }; SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND); SDL_RenderGeometry(renderer, nullptr, verts, 4, indices, 6); } } Py_RETURN_NONE; } // --------------------------------------------------------------------- // CTextBar Implementation // --------------------------------------------------------------------- class CTextBar { public: CTextBar(int fontSize, bool isBig) : m_fontSize(fontSize), m_isBig(isBig) {} bool Create(void*, int w, int h) { m_width = w; m_height = h; return true; } void Render(int, int) {} void SetTextColor(int r, int g, int b) { m_textColor = (0xff << 24) | (r << 16) | (g << 8) | b; } void GetTextExtent(const char* text, SIZE* pSize) { if (pSize) { pSize->cx = text ? (int)strlen(text) * (m_isBig ? 8 : 6) : 0; pSize->cy = m_fontSize; } } void TextOut(int, int, const char* text) { if (text) m_text = text; } void ClearBar() { m_text.clear(); } void SetClipRect(RECT r) { m_clipRect = r; } private: int m_fontSize; bool m_isBig; int m_width = 0; int m_height = 0; DWORD m_textColor = 0xffffffff; std::string m_text; RECT m_clipRect{}; }; static uint32_t s_nextTextBarHandle = 1; static std::unordered_map s_textBarHandles; static std::mutex s_textBarMutex; static CTextBar* GetTextBarPointer(uint32_t handle) { std::lock_guard lock(s_textBarMutex); auto it = s_textBarHandles.find(handle); return it == s_textBarHandles.end() ? nullptr : it->second; } static PyObject* grpCreateTextBar(PyObject*, PyObject* poArgs) { int iWidth = 0, iHeight = 0; if (!PyTuple_GetInteger(poArgs, 0, &iWidth) || !PyTuple_GetInteger(poArgs, 1, &iHeight)) return Py_BuildException(); auto* bar = new CTextBar(12, false); bar->Create(nullptr, iWidth, iHeight); std::lock_guard lock(s_textBarMutex); uint32_t h = s_nextTextBarHandle++; s_textBarHandles[h] = bar; return Py_BuildValue("i", h); } static PyObject* grpCreateBigTextBar(PyObject*, PyObject* poArgs) { int iWidth = 0, iHeight = 0, iFontSize = 0; if (!PyTuple_GetInteger(poArgs, 0, &iWidth) || !PyTuple_GetInteger(poArgs, 1, &iHeight) || !PyTuple_GetInteger(poArgs, 2, &iFontSize)) return Py_BuildException(); auto* bar = new CTextBar(iFontSize, true); bar->Create(nullptr, iWidth, iHeight); std::lock_guard lock(s_textBarMutex); uint32_t h = s_nextTextBarHandle++; s_textBarHandles[h] = bar; return Py_BuildValue("i", h); } static PyObject* grpDestroyTextBar(PyObject*, PyObject* poArgs) { int iHandle = 0; if (!PyTuple_GetInteger(poArgs, 0, &iHandle)) return Py_BuildException(); std::lock_guard lock(s_textBarMutex); auto it = s_textBarHandles.find(static_cast(iHandle)); if (it != s_textBarHandles.end()) { delete it->second; s_textBarHandles.erase(it); } return Py_BuildNone(); } static PyObject* grpRenderTextBar(PyObject*, PyObject* poArgs) { int iHandle = 0, ix = 0, iy = 0; if (!PyTuple_GetInteger(poArgs, 0, &iHandle) || !PyTuple_GetInteger(poArgs, 1, &ix) || !PyTuple_GetInteger(poArgs, 2, &iy)) return Py_BuildException(); auto* bar = GetTextBarPointer(static_cast(iHandle)); if (bar) bar->Render(ix, iy); return Py_BuildNone(); } static PyObject* grpTextBarSetTextColor(PyObject*, PyObject* poArgs) { int iHandle = 0, r = 0, g = 0, b = 0; if (!PyTuple_GetInteger(poArgs, 0, &iHandle) || !PyTuple_GetInteger(poArgs, 1, &r) || !PyTuple_GetInteger(poArgs, 2, &g) || !PyTuple_GetInteger(poArgs, 3, &b)) return Py_BuildException(); auto* bar = GetTextBarPointer(static_cast(iHandle)); if (bar) bar->SetTextColor(r, g, b); return Py_BuildNone(); } static PyObject* grpTextBarGetTextExtent(PyObject*, PyObject* poArgs) { int iHandle = 0; char* szText = nullptr; if (!PyTuple_GetInteger(poArgs, 0, &iHandle) || !PyTuple_GetString(poArgs, 1, &szText)) return Py_BuildException(); SIZE size{0, 0}; auto* bar = GetTextBarPointer(static_cast(iHandle)); if (bar) bar->GetTextExtent(szText, &size); return Py_BuildValue("ii", size.cx, size.cy); } static PyObject* grpTextBarTextOut(PyObject*, PyObject* poArgs) { int iHandle = 0, ix = 0, iy = 0; char* szText = nullptr; if (!PyTuple_GetInteger(poArgs, 0, &iHandle) || !PyTuple_GetInteger(poArgs, 1, &ix) || !PyTuple_GetInteger(poArgs, 2, &iy) || !PyTuple_GetString(poArgs, 3, &szText)) return Py_BuildException(); auto* bar = GetTextBarPointer(static_cast(iHandle)); if (bar) bar->TextOut(ix, iy, szText); return Py_BuildNone(); } static PyObject* grpClearTextBar(PyObject*, PyObject* poArgs) { int iHandle = 0; if (!PyTuple_GetInteger(poArgs, 0, &iHandle)) return Py_BuildException(); auto* bar = GetTextBarPointer(static_cast(iHandle)); if (bar) bar->ClearBar(); return Py_BuildNone(); } static PyObject* grpSetTextBarClipRect(PyObject*, PyObject* poArgs) { int iHandle = 0, isx = 0, isy = 0, iex = 0, iey = 0; if (!PyTuple_GetInteger(poArgs, 0, &iHandle) || !PyTuple_GetInteger(poArgs, 1, &isx) || !PyTuple_GetInteger(poArgs, 2, &isy) || !PyTuple_GetInteger(poArgs, 3, &iex) || !PyTuple_GetInteger(poArgs, 4, &iey)) return Py_BuildException(); auto* bar = GetTextBarPointer(static_cast(iHandle)); if (bar) { RECT rect; rect.left = isx; rect.top = isy; rect.right = iex; rect.bottom = iey; bar->SetClipRect(rect); } return Py_BuildNone(); } // --------------------------------------------------------------------- // grp Pipeline / Camera / Transform APIs // --------------------------------------------------------------------- static PyObject* grpCulling(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpInitScreenEffect(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpClearDepthBuffer(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpPushState(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpPopState(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpPushMatrix(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpPopMatrix(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpIdentity(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpTranslate(PyObject*, PyObject* poArgs) { float x = 0.0f, y = 0.0f, z = 0.0f; if (!PyTuple_GetFloat(poArgs, 0, &x) || !PyTuple_GetFloat(poArgs, 1, &y) || !PyTuple_GetFloat(poArgs, 2, &z)) return Py_BuildException("grp.Translate:Wrong coordinates"); return Py_BuildNone(); } static PyObject* grpRotate(PyObject*, PyObject* poArgs) { float Degree = 0.0f, x = 0.0f, y = 0.0f, z = 0.0f; if (!PyTuple_GetFloat(poArgs, 0, &Degree) || !PyTuple_GetFloat(poArgs, 1, &x) || !PyTuple_GetFloat(poArgs, 2, &y) || !PyTuple_GetFloat(poArgs, 3, &z)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetColorRenderState(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpSetAroundCamera(PyObject*, PyObject* poArgs) { float distance = 0.0f, pitch = 0.0f, roll = 0.0f, lookAtZ = 0.0f; if (!PyTuple_GetFloat(poArgs, 0, &distance) || !PyTuple_GetFloat(poArgs, 1, &pitch) || !PyTuple_GetFloat(poArgs, 2, &roll) || !PyTuple_GetFloat(poArgs, 3, &lookAtZ)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetPositionCamera(PyObject*, PyObject* poArgs) { float fx = 0, fy = 0, fz = 0, distance = 0, pitch = 0, roll = 0; if (!PyTuple_GetFloat(poArgs, 0, &fx) || !PyTuple_GetFloat(poArgs, 1, &fy) || !PyTuple_GetFloat(poArgs, 2, &fz) || !PyTuple_GetFloat(poArgs, 3, &distance) || !PyTuple_GetFloat(poArgs, 4, &pitch) || !PyTuple_GetFloat(poArgs, 5, &roll)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetEyeCamera(PyObject*, PyObject* poArgs) { float xEye = 0, yEye = 0, zEye = 0, xCenter = 0, yCenter = 0, zCenter = 0, xUp = 0, yUp = 0, zUp = 0; if (!PyTuple_GetFloat(poArgs, 0, &xEye) || !PyTuple_GetFloat(poArgs, 1, &yEye) || !PyTuple_GetFloat(poArgs, 2, &zEye) || !PyTuple_GetFloat(poArgs, 3, &xCenter) || !PyTuple_GetFloat(poArgs, 4, &yCenter) || !PyTuple_GetFloat(poArgs, 5, &zCenter) || !PyTuple_GetFloat(poArgs, 6, &xUp) || !PyTuple_GetFloat(poArgs, 7, &yUp) || !PyTuple_GetFloat(poArgs, 8, &zUp)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetPerspective(PyObject*, PyObject* poArgs) { float fov = 0, aspect = 0, zNear = 0, zFar = 0; if (!PyTuple_GetFloat(poArgs, 0, &fov) || !PyTuple_GetFloat(poArgs, 1, &aspect) || !PyTuple_GetFloat(poArgs, 2, &zNear) || !PyTuple_GetFloat(poArgs, 3, &zFar)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetOrtho2D(PyObject*, PyObject* poArgs) { float width = 0, height = 0, length = 0; if (!PyTuple_GetFloat(poArgs, 0, &width) || !PyTuple_GetFloat(poArgs, 1, &height) || !PyTuple_GetFloat(poArgs, 2, &length)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetOrtho3D(PyObject*, PyObject* poArgs) { float width = 0, height = 0, zmin = 0, zmax = 0; if (!PyTuple_GetFloat(poArgs, 0, &width) || !PyTuple_GetFloat(poArgs, 1, &height) || !PyTuple_GetFloat(poArgs, 2, &zmin) || !PyTuple_GetFloat(poArgs, 3, &zmax)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpGetCursorPosition3d(PyObject*, PyObject*) { return Py_BuildValue("(fff)", 0.0f, 0.0f, 0.0f); } static PyObject* grpSetCursorPosition(PyObject*, PyObject* poArgs) { int ix = 0, iy = 0; if (!PyTuple_GetInteger(poArgs, 0, &ix) || !PyTuple_GetInteger(poArgs, 1, &iy)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpRenderBox3d(PyObject*, PyObject* poArgs) { float sx = 0, sy = 0, sz = 0, ex = 0, ey = 0, ez = 0; if (!PyTuple_GetFloat(poArgs, 0, &sx) || !PyTuple_GetFloat(poArgs, 1, &sy) || !PyTuple_GetFloat(poArgs, 2, &sz) || !PyTuple_GetFloat(poArgs, 3, &ex) || !PyTuple_GetFloat(poArgs, 4, &ey) || !PyTuple_GetFloat(poArgs, 5, &ez)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpRenderBar3d(PyObject*, PyObject* poArgs) { int sx = 0, sy = 0, sz = 0, ex = 0, ey = 0, ez = 0; if (!PyTuple_GetInteger(poArgs, 0, &sx) || !PyTuple_GetInteger(poArgs, 1, &sy) || !PyTuple_GetInteger(poArgs, 2, &sz) || !PyTuple_GetInteger(poArgs, 3, &ex) || !PyTuple_GetInteger(poArgs, 4, &ey) || !PyTuple_GetInteger(poArgs, 5, &ez)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpRenderCube(PyObject*, PyObject* poArgs) { float sx = 0, sy = 0, sz = 0, ex = 0, ey = 0, ez = 0; if (!PyTuple_GetFloat(poArgs, 0, &sx) || !PyTuple_GetFloat(poArgs, 1, &sy) || !PyTuple_GetFloat(poArgs, 2, &sz) || !PyTuple_GetFloat(poArgs, 3, &ex) || !PyTuple_GetFloat(poArgs, 4, &ey) || !PyTuple_GetFloat(poArgs, 5, &ez)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpRenderDownButton(PyObject*, PyObject* poArgs) { int x = 0, y = 0, width = 0, height = 0; if (!PyTuple_GetInteger(poArgs, 0, &x) || !PyTuple_GetInteger(poArgs, 1, &y) || !PyTuple_GetInteger(poArgs, 2, &width) || !PyTuple_GetInteger(poArgs, 3, &height)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpRenderUpButton(PyObject*, PyObject* poArgs) { int x = 0, y = 0, width = 0, height = 0; if (!PyTuple_GetInteger(poArgs, 0, &x) || !PyTuple_GetInteger(poArgs, 1, &y) || !PyTuple_GetInteger(poArgs, 2, &width) || !PyTuple_GetInteger(poArgs, 3, &height)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpGetAvailableMemory(PyObject*, PyObject*) { return Py_BuildValue("i", 256 * 1024 * 1024); } static PyObject* grpSaveScreenShot(PyObject*, PyObject*) { return Py_BuildValue("(is)", 1, "screenshot.jpg"); } static PyObject* grpSaveScreenShotToPath(PyObject*, PyObject* poArgs) { char* szBasePath = nullptr; if (!PyTuple_GetString(poArgs, 0, &szBasePath)) return Py_BuildException(); return Py_BuildValue("(is)", 1, (std::string(szBasePath ? szBasePath : "") + ".jpg").c_str()); } static PyObject* grpSetGamma(PyObject*, PyObject* poArgs) { float gamma = 0.0f; if (!PyTuple_GetFloat(poArgs, 0, &gamma)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetInterfaceRenderState(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpSetGameRenderState(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpSetViewport(PyObject*, PyObject* poArgs) { float fx = 0, fy = 0, fWidth = 0, fHeight = 0; if (!PyTuple_GetFloat(poArgs, 0, &fx) || !PyTuple_GetFloat(poArgs, 1, &fy) || !PyTuple_GetFloat(poArgs, 2, &fWidth) || !PyTuple_GetFloat(poArgs, 3, &fHeight)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpRestoreViewport(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpSetOmniLight(PyObject*, PyObject*) { return Py_BuildNone(); } static PyObject* grpGetCameraPosition(PyObject*, PyObject*) { return Py_BuildValue("fff", 0.0f, 0.0f, 180.0f); } static PyObject* grpGetTargetPosition(PyObject*, PyObject*) { return Py_BuildValue("fff", 0.0f, 0.0f, 0.0f); } // --------------------------------------------------------------------- // grpImage Implementation // --------------------------------------------------------------------- static bool PyTuple_GetImageInstance(PyObject* poArgs, int pos, CGraphicImageInstance** ppRetImageInstance) { int handle = 0; if (!PyTuple_GetInteger(poArgs, pos, &handle)) return false; if (!handle) return false; *ppRetImageInstance = GrpGetImageInstancePointer(static_cast(handle)); return *ppRetImageInstance != nullptr; } static bool PyTuple_GetExpandedImageInstance(PyObject* poArgs, int pos, CGraphicExpandedImageInstance** ppRetImageInstance) { int handle = 0; if (!PyTuple_GetInteger(poArgs, pos, &handle)) return false; if (!handle) return false; auto* pInstance = GrpGetImageInstancePointer(static_cast(handle)); if (!pInstance || !pInstance->IsType(CGraphicExpandedImageInstance::Type())) return false; *ppRetImageInstance = static_cast(pInstance); return true; } static PyObject* grpImageGenerate(PyObject*, PyObject* poArgs) { char* szFileName = nullptr; if (!PyTuple_GetString(poArgs, 0, &szFileName)) return Py_BadArgument(); if (!szFileName || !*szFileName) return Py_BuildValue("i", 0); auto* pResource = CResourceManager::Instance().GetResourcePointer(szFileName); if (!pResource || !pResource->IsType(CGraphicImage::Type())) return Py_BuildException("Resource is not an image (filename: %s)", szFileName); auto* pImageInstance = CGraphicImageInstance::New(); pImageInstance->SetImagePointer(static_cast(pResource)); if (pImageInstance->IsEmpty()) return Py_BuildException("Cannot load image (filename: %s)", szFileName); return Py_BuildValue("i", GrpRegisterImageInstanceHandle(pImageInstance)); } static PyObject* grpImageGenerateExpanded(PyObject*, PyObject* poArgs) { char* szFileName = nullptr; if (!PyTuple_GetString(poArgs, 0, &szFileName)) return Py_BadArgument(); if (!szFileName || !*szFileName) return Py_BuildValue("i", 0); auto* pResource = CResourceManager::Instance().GetResourcePointer(szFileName); if (!pResource || !pResource->IsType(CGraphicImage::Type())) return Py_BuildException("Resource is not an image (filename: %s)", szFileName); auto* pImageInstance = CGraphicExpandedImageInstance::New(); pImageInstance->SetImagePointer(static_cast(pResource)); if (pImageInstance->IsEmpty()) return Py_BuildException("Cannot load image (filename: %s)", szFileName); return Py_BuildValue("i", GrpRegisterImageInstanceHandle(pImageInstance)); } static PyObject* grpImageGenerateFromHandle(PyObject*, PyObject* poArgs) { int iHandle = 0; if (!PyTuple_GetInteger(poArgs, 0, &iHandle)) return Py_BadArgument(); auto* pImageInstance = CGraphicImageInstance::New(); auto* pImage = GrpGetImagePointer(static_cast(iHandle)); if (pImage) { pImageInstance->SetImagePointer(pImage); } return Py_BuildValue("i", GrpRegisterImageInstanceHandle(pImageInstance)); } static PyObject* grpImageDelete(PyObject*, PyObject* poArgs) { int handle = 0; if (!PyTuple_GetInteger(poArgs, 0, &handle)) return Py_BadArgument(); auto* pInstance = GrpReleaseImageInstanceHandle(static_cast(handle)); if (pInstance) { CGraphicImageInstance::Delete(pInstance); } return Py_BuildNone(); } static PyObject* grpImageDeleteExpanded(PyObject*, PyObject* poArgs) { int handle = 0; if (!PyTuple_GetInteger(poArgs, 0, &handle)) return Py_BadArgument(); auto* pInstance = GrpReleaseImageInstanceHandle(static_cast(handle)); if (pInstance) { if (pInstance->IsType(CGraphicExpandedImageInstance::Type())) { CGraphicExpandedImageInstance::Delete(static_cast(pInstance)); } else { CGraphicImageInstance::Delete(pInstance); } } return Py_BuildNone(); } static PyObject* grpImageSetFileName(PyObject*, PyObject* poArgs) { CGraphicImageInstance* pImageInstance = nullptr; if (!PyTuple_GetImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); char* szFileName = nullptr; if (!PyTuple_GetString(poArgs, 1, &szFileName)) return Py_BadArgument(); auto* pResource = CResourceManager::Instance().GetResourcePointer(szFileName); if (!pResource || !pResource->IsType(CGraphicImage::Type())) return Py_BuildException("Resource is not an image (filename: %s)", szFileName); pImageInstance->SetImagePointer(static_cast(pResource)); return Py_BuildNone(); } static PyObject* grpImageRender(PyObject*, PyObject* poArgs) { CGraphicImageInstance* pImageInstance = nullptr; if (!PyTuple_GetImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); pImageInstance->Render(); return Py_BuildNone(); } static PyObject* grpSetImagePosition(PyObject*, PyObject* poArgs) { CGraphicImageInstance* pImageInstance = nullptr; if (!PyTuple_GetImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); float x = 0.0f, y = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &x) || !PyTuple_GetFloat(poArgs, 2, &y)) return Py_BadArgument(); pImageInstance->SetPosition(x, y); return Py_BuildNone(); } static PyObject* grpSetImageOrigin(PyObject*, PyObject* poArgs) { CGraphicExpandedImageInstance* pImageInstance = nullptr; if (!PyTuple_GetExpandedImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); float x = 0.0f, y = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &x) || !PyTuple_GetFloat(poArgs, 2, &y)) return Py_BadArgument(); pImageInstance->SetOrigin(x, y); return Py_BuildNone(); } static PyObject* grpSetImageRotation(PyObject*, PyObject* poArgs) { CGraphicExpandedImageInstance* pImageInstance = nullptr; if (!PyTuple_GetExpandedImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); float Degree = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &Degree)) return Py_BadArgument(); pImageInstance->SetRotation(Degree); return Py_BuildNone(); } static PyObject* grpSetImageScale(PyObject*, PyObject* poArgs) { CGraphicExpandedImageInstance* pImageInstance = nullptr; if (!PyTuple_GetExpandedImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); float x = 0.0f, y = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &x) || !PyTuple_GetFloat(poArgs, 2, &y)) return Py_BadArgument(); pImageInstance->SetScale(x, y); return Py_BuildNone(); } static PyObject* grpSetRenderingRect(PyObject*, PyObject* poArgs) { CGraphicExpandedImageInstance* pImageInstance = nullptr; if (!PyTuple_GetExpandedImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); float fLeft = 0.0f, fTop = 0.0f, fRight = 0.0f, fBottom = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &fLeft) || !PyTuple_GetFloat(poArgs, 2, &fTop) || !PyTuple_GetFloat(poArgs, 3, &fRight) || !PyTuple_GetFloat(poArgs, 4, &fBottom)) return Py_BadArgument(); pImageInstance->SetRenderingRect(fLeft, fTop, fRight, fBottom); return Py_BuildNone(); } static PyObject* grpSetImageDiffuseColor(PyObject*, PyObject* poArgs) { CGraphicImageInstance* pImageInstance = nullptr; if (!PyTuple_GetImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); float r = 1.0f, g = 1.0f, b = 1.0f, a = 1.0f; if (!PyTuple_GetFloat(poArgs, 1, &r) || !PyTuple_GetFloat(poArgs, 2, &g) || !PyTuple_GetFloat(poArgs, 3, &b) || !PyTuple_GetFloat(poArgs, 4, &a)) return Py_BadArgument(); pImageInstance->SetDiffuseColor(r, g, b, a); return Py_BuildNone(); } static PyObject* grpGetWidth(PyObject*, PyObject* poArgs) { CGraphicImageInstance* pImageInstance = nullptr; if (!PyTuple_GetImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); if (pImageInstance->IsEmpty()) return Py_BuildException("Image is empty"); return Py_BuildValue("i", pImageInstance->GetWidth()); } static PyObject* grpGetHeight(PyObject*, PyObject* poArgs) { CGraphicImageInstance* pImageInstance = nullptr; if (!PyTuple_GetImageInstance(poArgs, 0, &pImageInstance)) return Py_BadArgument(); if (pImageInstance->IsEmpty()) return Py_BuildException("Image is empty"); return Py_BuildValue("i", pImageInstance->GetHeight()); } // --------------------------------------------------------------------- // grpText Implementation // --------------------------------------------------------------------- static uint32_t s_nextTextHandle = 1; static std::unordered_map s_textHandles; static std::mutex s_textHandleMutex; static uint32_t GrpRegisterTextInstanceHandle(UI::CGraphicTextInstance* pInstance) { if (!pInstance) return 0; std::lock_guard lock(s_textHandleMutex); uint32_t handle = s_nextTextHandle++; s_textHandles[handle] = pInstance; return handle; } static UI::CGraphicTextInstance* GrpGetTextInstancePointer(uint32_t handle) { std::lock_guard lock(s_textHandleMutex); auto it = s_textHandles.find(handle); return it == s_textHandles.end() ? nullptr : it->second; } static UI::CGraphicTextInstance* GrpReleaseTextInstanceHandle(uint32_t handle) { std::lock_guard lock(s_textHandleMutex); auto it = s_textHandles.find(handle); if (it == s_textHandles.end()) return nullptr; auto* p = it->second; s_textHandles.erase(it); return p; } static bool PyTuple_GetTextInstance(PyObject* poArgs, int pos, UI::CGraphicTextInstance** ppTextInstance) { int handle = 0; if (!PyTuple_GetInteger(poArgs, pos, &handle)) return false; if (!handle) return false; *ppTextInstance = GrpGetTextInstancePointer(static_cast(handle)); return *ppTextInstance != nullptr; } static PyObject* grpTextGenerate(PyObject*, PyObject*) { auto* pTextInstance = new UI::CGraphicTextInstance(); return Py_BuildValue("i", GrpRegisterTextInstanceHandle(pTextInstance)); } static PyObject* grpTextDestroy(PyObject*, PyObject* poArgs) { int handle = 0; if (!PyTuple_GetInteger(poArgs, 0, &handle)) return Py_BuildException(); auto* pText = GrpReleaseTextInstanceHandle(static_cast(handle)); delete pText; return Py_BuildNone(); } static PyObject* grpTextSetFontName(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); char* szFontName = nullptr; if (!PyTuple_GetString(poArgs, 1, &szFontName)) return Py_BuildException(); pTextInstance->SetFontName(szFontName); return Py_BuildNone(); } static PyObject* grpTextSetFontColor(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); if (2 == PyTuple_Size(poArgs)) { int iColor = 0; if (!PyTuple_GetInteger(poArgs, 1, &iColor)) return Py_BuildException(); pTextInstance->SetFontColor(DWORD(iColor)); } else if (4 == PyTuple_Size(poArgs)) { float fRed = 0.0f, fGreen = 0.0f, fBlue = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &fRed) || !PyTuple_GetFloat(poArgs, 2, &fGreen) || !PyTuple_GetFloat(poArgs, 3, &fBlue)) return Py_BuildException(); pTextInstance->SetColor(fRed, fGreen, fBlue); } else { return Py_BuildException(); } return Py_BuildNone(); } static PyObject* grpTextSetOutLineColor(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); float fRed = 0.0f, fGreen = 0.0f, fBlue = 0.0f, fAlpha = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &fRed) || !PyTuple_GetFloat(poArgs, 2, &fGreen) || !PyTuple_GetFloat(poArgs, 3, &fBlue) || !PyTuple_GetFloat(poArgs, 4, &fAlpha)) return Py_BuildException(); pTextInstance->SetOutLineColor(fRed, fGreen, fBlue, fAlpha); return Py_BuildNone(); } static PyObject* grpTextSetSecret(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); bool bSecret = false; if (!PyTuple_GetBoolean(poArgs, 1, &bSecret)) return Py_BuildException(); pTextInstance->SetSecret(bSecret ? TRUE : FALSE); return Py_BuildNone(); } static PyObject* grpTextOutline(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); bool bOutline = false; if (!PyTuple_GetBoolean(poArgs, 1, &bOutline)) return Py_BuildException(); pTextInstance->SetOutline(bOutline ? TRUE : FALSE); return Py_BuildNone(); } static PyObject* grpTextSetText(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); char* szText = nullptr; if (!PyTuple_GetString(poArgs, 1, &szText)) return Py_BuildException(); pTextInstance->SetText(szText); return Py_BuildNone(); } static PyObject* grpTextGetText(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); return Py_BuildValue("s", pTextInstance->GetText()); } static PyObject* grpTextGetSize(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); int width = 0, height = 0; pTextInstance->GetTextSize(&width, &height); return Py_BuildValue("(i, i)", width, height); } static PyObject* grpTextSetPosition(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); int ix = 0, iy = 0; if (!PyTuple_GetInteger(poArgs, 1, &ix) || !PyTuple_GetInteger(poArgs, 2, &iy)) return Py_BuildException(); pTextInstance->SetPosition((float)ix, (float)iy); return Py_BuildNone(); } static PyObject* grpTextShowCursor(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); pTextInstance->ShowCursor(); return Py_BuildNone(); } static PyObject* grpTextHideCursor(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); pTextInstance->HideCursor(); return Py_BuildNone(); } static PyObject* grpSetHorizontalAlign(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); int iAlign = 0; if (!PyTuple_GetInteger(poArgs, 1, &iAlign)) return Py_BuildException(); pTextInstance->SetHorizonalAlign(iAlign); return Py_BuildNone(); } static PyObject* grpSetVerticalAlign(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); int iAlign = 0; if (!PyTuple_GetInteger(poArgs, 1, &iAlign)) return Py_BuildException(); pTextInstance->SetVerticalAlign(iAlign); return Py_BuildNone(); } static PyObject* grpSetMax(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); int iValue = 0; if (!PyTuple_GetInteger(poArgs, 1, &iValue)) return Py_BuildException(); pTextInstance->SetMax(iValue); return Py_BuildNone(); } static PyObject* grpGetSplitingTextLineCount(PyObject*, PyObject* poArgs) { char* szText = nullptr; if (!PyTuple_GetString(poArgs, 0, &szText)) return Py_BuildException(); int iLineLimitation = 0; if (!PyTuple_GetInteger(poArgs, 1, &iLineLimitation)) return Py_BuildException(); int iPosition = 0; int iLineCount = 0; size_t len = szText ? strlen(szText) : 0; for (size_t i = 0; i < len;) { if ('|' == szText[i]) { i += 1; if (iPosition > 0) ++iLineCount; iPosition = 0; continue; } if (szText[i] & 0x80) { i += 2; iPosition += 2; } else { i += 1; iPosition += 1; } if (iPosition >= iLineLimitation) { ++iLineCount; iPosition = 0; } } if (iPosition > 0) ++iLineCount; return Py_BuildValue("i", iLineCount); } static PyObject* grpGetSplitingTextLine(PyObject*, PyObject* poArgs) { char* szText = nullptr; if (!PyTuple_GetString(poArgs, 0, &szText)) return Py_BuildException(); int iLineLimitation = 0; if (!PyTuple_GetInteger(poArgs, 1, &iLineLimitation)) return Py_BuildException(); int iGettingLine = 0; if (!PyTuple_GetInteger(poArgs, 2, &iGettingLine)) return Py_BuildException(); std::string strLine; int iPosition = 0; int iLineCount = 0; size_t len = szText ? strlen(szText) : 0; for (size_t i = 0; i < len;) { if ('|' == szText[i]) { i += 1; if (iPosition > 0) ++iLineCount; iPosition = 0; continue; } if (szText[i] & 0x80) { if (iLineCount == iGettingLine) strLine.append(szText + i, 2); i += 2; iPosition += 2; } else { if (iLineCount == iGettingLine) strLine += szText[i]; i += 1; iPosition += 1; } if (iPosition >= iLineLimitation) { ++iLineCount; iPosition = 0; } } return Py_BuildValue("s", strLine.c_str()); } static PyObject* grpTextPixelPositionToCharacterPosition(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); int iPixelPosition = 0; if (!PyTuple_GetInteger(poArgs, 1, &iPixelPosition)) return Py_BuildException(); int iCharacterPosition = pTextInstance->PixelPositionToCharacterPosition(iPixelPosition); return Py_BuildValue("i", iCharacterPosition); } static PyObject* grpTextRender(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); pTextInstance->Render(); return Py_BuildNone(); } static PyObject* grpTextUpdate(PyObject*, PyObject* poArgs) { UI::CGraphicTextInstance* pTextInstance = nullptr; if (!PyTuple_GetTextInstance(poArgs, 0, &pTextInstance)) return Py_BuildException(); pTextInstance->Update(); return Py_BuildNone(); } // --------------------------------------------------------------------- // grpThing Implementation // --------------------------------------------------------------------- struct SGraphicThingHolder { std::string fileName; struct Vec3 { float x = 0.0f, y = 0.0f, z = 0.0f; }; Vec3 position{0.0f, 0.0f, 0.0f}; float rotation = 0.0f; Vec3 scale{1.0f, 1.0f, 1.0f}; }; static uint32_t s_nextThingHandle = 1; static std::unordered_map s_thingHandles; static std::mutex s_thingHandleMutex; static bool PyTuple_GetThingInstance(PyObject* poArgs, int pos, SGraphicThingHolder** ppThing) { int handle = 0; if (!PyTuple_GetInteger(poArgs, pos, &handle)) return false; if (!handle) return false; std::lock_guard lock(s_thingHandleMutex); auto it = s_thingHandles.find(static_cast(handle)); if (it == s_thingHandles.end()) return false; *ppThing = it->second; return true; } static PyObject* grpThingGenerate(PyObject*, PyObject* poArgs) { char* szFileName = nullptr; if (!PyTuple_GetString(poArgs, 0, &szFileName)) return Py_BuildException(); if (!szFileName || !*szFileName) return Py_BuildValue("i", 0); auto* holder = new SGraphicThingHolder(); holder->fileName = szFileName; std::lock_guard lock(s_thingHandleMutex); uint32_t handle = s_nextThingHandle++; s_thingHandles[handle] = holder; return Py_BuildValue("i", handle); } static PyObject* grpThingDelete(PyObject*, PyObject* poArgs) { int handle = 0; if (!PyTuple_GetInteger(poArgs, 0, &handle)) return Py_BuildException(); std::lock_guard lock(s_thingHandleMutex); auto it = s_thingHandles.find(static_cast(handle)); if (it != s_thingHandles.end()) { delete it->second; s_thingHandles.erase(it); } return Py_BuildNone(); } static PyObject* grpThingSetFileName(PyObject*, PyObject* poArgs) { SGraphicThingHolder* pThing = nullptr; if (!PyTuple_GetThingInstance(poArgs, 0, &pThing)) return Py_BuildException(); char* szFileName = nullptr; if (!PyTuple_GetString(poArgs, 1, &szFileName)) return Py_BuildException(); pThing->fileName = szFileName ? szFileName : ""; return Py_BuildNone(); } static PyObject* grpThingRender(PyObject*, PyObject* poArgs) { SGraphicThingHolder* pThing = nullptr; if (!PyTuple_GetThingInstance(poArgs, 0, &pThing)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpThingUpdate(PyObject*, PyObject* poArgs) { SGraphicThingHolder* pThing = nullptr; if (!PyTuple_GetThingInstance(poArgs, 0, &pThing)) return Py_BuildException(); return Py_BuildNone(); } static PyObject* grpSetThingPosition(PyObject*, PyObject* poArgs) { SGraphicThingHolder* pThing = nullptr; if (!PyTuple_GetThingInstance(poArgs, 0, &pThing)) return Py_BuildException(); float x = 0.0f, y = 0.0f, z = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &x) || !PyTuple_GetFloat(poArgs, 2, &y) || !PyTuple_GetFloat(poArgs, 3, &z)) return Py_BuildException(); pThing->position = {x, y, z}; return Py_BuildNone(); } static PyObject* grpSetThingRotation(PyObject*, PyObject* poArgs) { SGraphicThingHolder* pThing = nullptr; if (!PyTuple_GetThingInstance(poArgs, 0, &pThing)) return Py_BuildException(); float fDegree = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &fDegree)) return Py_BuildException(); pThing->rotation = fDegree; return Py_BuildNone(); } static PyObject* grpSetThingScale(PyObject*, PyObject* poArgs) { SGraphicThingHolder* pThing = nullptr; if (!PyTuple_GetThingInstance(poArgs, 0, &pThing)) return Py_BuildException(); float x = 0.0f, y = 0.0f, z = 0.0f; if (!PyTuple_GetFloat(poArgs, 1, &x) || !PyTuple_GetFloat(poArgs, 2, &y) || !PyTuple_GetFloat(poArgs, 3, &z)) return Py_BuildException(); pThing->scale = {x, y, z}; return Py_BuildNone(); } } // namespace void initgrp() { static PyMethodDef methods[] = { {"InitScreenEffect", grpInitScreenEffect, METH_VARARGS, nullptr}, {"Culling", grpCulling, METH_VARARGS, nullptr}, {"ClearDepthBuffer", grpClearDepthBuffer, METH_VARARGS, nullptr}, {"Identity", grpIdentity, METH_VARARGS, nullptr}, {"GenerateColor", grp_GenerateColor, METH_VARARGS, nullptr}, {"PopState", grpPopState, METH_VARARGS, nullptr}, {"PushState", grpPushState, METH_VARARGS, nullptr}, {"PushMatrix", grpPushMatrix, METH_VARARGS, nullptr}, {"PopMatrix", grpPopMatrix, METH_VARARGS, nullptr}, {"Translate", grpTranslate, METH_VARARGS, nullptr}, {"Rotate", grpRotate, METH_VARARGS, nullptr}, {"SetColorRenderState", grpSetColorRenderState, METH_VARARGS, nullptr}, {"SetAroundCamera", grpSetAroundCamera, METH_VARARGS, nullptr}, {"SetPositionCamera", grpSetPositionCamera, METH_VARARGS, nullptr}, {"SetEyeCamera", grpSetEyeCamera, METH_VARARGS, nullptr}, {"SetPerspective", grpSetPerspective, METH_VARARGS, nullptr}, {"SetOrtho2d", grpSetOrtho2D, METH_VARARGS, nullptr}, {"SetOrtho3d", grpSetOrtho3D, METH_VARARGS, nullptr}, {"SetColor", grp_SetColor, METH_VARARGS, nullptr}, {"SetAlpha", grp_SetAlpha, METH_VARARGS, nullptr}, {"SetDiffuseColor", grp_SetDiffuseColor, METH_VARARGS, nullptr}, {"SetClearColor", grp_SetClearColor, METH_VARARGS, nullptr}, {"GetCursorPosition3d", grpGetCursorPosition3d, METH_VARARGS, nullptr}, {"SetCursorPosition", grpSetCursorPosition, METH_VARARGS, nullptr}, {"RenderLine", grp_RenderLine, METH_VARARGS, nullptr}, {"RenderBox", grp_RenderBox, METH_VARARGS, nullptr}, {"RenderRoundBox", grp_RenderRoundBox, METH_VARARGS, nullptr}, {"RenderBox3d", grpRenderBox3d, METH_VARARGS, nullptr}, {"RenderBar", grp_RenderBar, METH_VARARGS, nullptr}, {"RenderBar3d", grpRenderBar3d, METH_VARARGS, nullptr}, {"RenderGradationBar", grp_RenderGradationBar, METH_VARARGS, nullptr}, {"RenderCube", grpRenderCube, METH_VARARGS, nullptr}, {"RenderDownButton", grpRenderDownButton, METH_VARARGS, nullptr}, {"RenderUpButton", grpRenderUpButton, METH_VARARGS, nullptr}, {"GetAvailableMemory", grpGetAvailableMemory, METH_VARARGS, nullptr}, {"SaveScreenShot", grpSaveScreenShot, METH_VARARGS, nullptr}, {"SaveScreenShotToPath", grpSaveScreenShotToPath, METH_VARARGS, nullptr}, {"SetGamma", grpSetGamma, METH_VARARGS, nullptr}, {"SetInterfaceRenderState", grpSetInterfaceRenderState, METH_VARARGS, nullptr}, {"SetGameRenderState", grpSetGameRenderState, METH_VARARGS, nullptr}, {"SetViewport", grpSetViewport, METH_VARARGS, nullptr}, {"RestoreViewport", grpRestoreViewport, METH_VARARGS, nullptr}, {"SetOmniLight", grpSetOmniLight, METH_VARARGS, nullptr}, {"GetCameraPosition", grpGetCameraPosition, METH_VARARGS, nullptr}, {"GetTargetPosition", grpGetTargetPosition, METH_VARARGS, nullptr}, {"CreateTextBar", grpCreateTextBar, METH_VARARGS, nullptr}, {"CreateBigTextBar", grpCreateBigTextBar, METH_VARARGS, nullptr}, {"DestroyTextBar", grpDestroyTextBar, METH_VARARGS, nullptr}, {"RenderTextBar", grpRenderTextBar, METH_VARARGS, nullptr}, {"TextBarTextOut", grpTextBarTextOut, METH_VARARGS, nullptr}, {"TextBarSetTextColor", grpTextBarSetTextColor, METH_VARARGS, nullptr}, {"TextBarGetTextExtent", grpTextBarGetTextExtent, METH_VARARGS, nullptr}, {"ClearTextBar", grpClearTextBar, METH_VARARGS, nullptr}, {"SetTextBarClipRect", grpSetTextBarClipRect, METH_VARARGS, nullptr}, {nullptr, nullptr, 0, nullptr} }; Py_InitModule("grp", methods); } void initgrpImage() { static PyMethodDef methods[] = { {"Render", grpImageRender, METH_VARARGS, nullptr}, {"SetPosition", grpSetImagePosition, METH_VARARGS, nullptr}, {"Generate", grpImageGenerate, METH_VARARGS, nullptr}, {"GenerateExpanded", grpImageGenerateExpanded, METH_VARARGS, nullptr}, {"GenerateFromHandle", grpImageGenerateFromHandle, METH_VARARGS, nullptr}, {"Delete", grpImageDelete, METH_VARARGS, nullptr}, {"DeleteExpanded", grpImageDeleteExpanded, METH_VARARGS, nullptr}, {"SetFileName", grpImageSetFileName, METH_VARARGS, nullptr}, {"SetOrigin", grpSetImageOrigin, METH_VARARGS, nullptr}, {"SetRotation", grpSetImageRotation, METH_VARARGS, nullptr}, {"SetScale", grpSetImageScale, METH_VARARGS, nullptr}, {"SetRenderingRect", grpSetRenderingRect, METH_VARARGS, nullptr}, {"SetDiffuseColor", grpSetImageDiffuseColor, METH_VARARGS, nullptr}, {"GetWidth", grpGetWidth, METH_VARARGS, nullptr}, {"GetHeight", grpGetHeight, METH_VARARGS, nullptr}, {nullptr, nullptr, 0, nullptr} }; Py_InitModule("grpImage", methods); } void initgrpText() { static PyMethodDef methods[] = { {"Update", grpTextUpdate, METH_VARARGS, nullptr}, {"Render", grpTextRender, METH_VARARGS, nullptr}, {"Generate", grpTextGenerate, METH_VARARGS, nullptr}, {"Destroy", grpTextDestroy, METH_VARARGS, nullptr}, {"SetFontName", grpTextSetFontName, METH_VARARGS, nullptr}, {"SetFontColor", grpTextSetFontColor, METH_VARARGS, nullptr}, {"SetOutLineColor", grpTextSetOutLineColor, METH_VARARGS, nullptr}, {"SetSecret", grpTextSetSecret, METH_VARARGS, nullptr}, {"SetOutline", grpTextOutline, METH_VARARGS, nullptr}, {"SetText", grpTextSetText, METH_VARARGS, nullptr}, {"GetText", grpTextGetText, METH_VARARGS, nullptr}, {"GetSize", grpTextGetSize, METH_VARARGS, nullptr}, {"SetPosition", grpTextSetPosition, METH_VARARGS, nullptr}, {"ShowCursor", grpTextShowCursor, METH_VARARGS, nullptr}, {"HideCursor", grpTextHideCursor, METH_VARARGS, nullptr}, {"SetHorizontalAlign", grpSetHorizontalAlign, METH_VARARGS, nullptr}, {"SetVerticalAlign", grpSetVerticalAlign, METH_VARARGS, nullptr}, {"SetMax", grpSetMax, METH_VARARGS, nullptr}, {"GetSplitingTextLineCount", grpGetSplitingTextLineCount, METH_VARARGS, nullptr}, {"GetSplitingTextLine", grpGetSplitingTextLine, METH_VARARGS, nullptr}, {"PixelPositionToCharacterPosition", grpTextPixelPositionToCharacterPosition, METH_VARARGS, nullptr}, {nullptr, nullptr, 0, nullptr} }; Py_InitModule("grpText", methods); } void initgrpThing() { static PyMethodDef methods[] = { {"Update", grpThingUpdate, METH_VARARGS, nullptr}, {"Render", grpThingRender, METH_VARARGS, nullptr}, {"SetPosition", grpSetThingPosition, METH_VARARGS, nullptr}, {"Generate", grpThingGenerate, METH_VARARGS, nullptr}, {"Delete", grpThingDelete, METH_VARARGS, nullptr}, {"SetFileName", grpThingSetFileName, METH_VARARGS, nullptr}, {"SetRotation", grpSetThingRotation, METH_VARARGS, nullptr}, {"SetScale", grpSetThingScale, METH_VARARGS, nullptr}, {nullptr, nullptr, 0, nullptr} }; Py_InitModule("grpThing", methods); } } // namespace ava2