pub_soft/pymol-open-source
3
0
Fork 0
mirror of https://github.com/schrodinger/pymol-open-source.git synced 2026-06-04 20:04:21 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
cpp20
pymol-open-source/layer1/PyMOLObject.cpp
Jarrett Johnson 3248445fcf Replace Scene matrices with glm::mat4
2025-01-04 12:33:44 -05:00

1427 lines
39 KiB
C++
Raw Permalink Blame History

/*
A* -------------------------------------------------------------------
B* This file contains source code for the PyMOL computer program
C* copyright 1998-2000 by Warren Lyford Delano of DeLano Scientific.
D* -------------------------------------------------------------------
E* It is unlawful to modify or remove this copyright notice.
F* -------------------------------------------------------------------
G* Please see the accompanying LICENSE file for further information.
H* -------------------------------------------------------------------
I* Additional authors of this source file include:
-*
-*
-*
Z* -------------------------------------------------------------------
*/
#include"os_python.h"
#include"os_predef.h"
#include"os_gl.h"
#include"os_std.h"
#include"main.h"
#include"PyMOLObject.h"
#include"Color.h"
#include"Ortho.h"
#include"Scene.h"
#include"Util.h"
#include"Ray.h"
#include"PConv.h"
#include"Matrix.h"
#include"MemoryDebug.h"
#include"Movie.h"
#include"View.h"
#include"Err.h"
#include "Feedback.h"
#include"Executive.h"
#include"CGO.h"
#include"Selector.h"
#include"vla.h"
#include"pymol/type_traits.h"
void ObjectPurgeSettings(pymol::CObject * I)
{
I->Setting.reset();
}
void ObjectMotionTrim(pymol::CObject *I, int n_frame)
{
if(I->ViewElem) {
VLASize(I->ViewElem,CViewElem,n_frame);
}
}
int ObjectMotionGetLength(pymol::CObject *I)
{
if(I->ViewElem) {
return VLAGetSize(I->ViewElem);
}
return 0;
}
void ObjectMotionReinterpolate(pymol::CObject *I)
{
float power = SettingGet_f(I->G, nullptr, I->Setting.get(), cSetting_motion_power);
float bias = SettingGet_f(I->G, nullptr, I->Setting.get(), cSetting_motion_bias);
int simple = SettingGet_i(I->G, nullptr, I->Setting.get(), cSetting_motion_simple);
float linear = SettingGet_f(I->G, nullptr, I->Setting.get(), cSetting_motion_linear);
int hand = SettingGet_i(I->G, nullptr, I->Setting.get(), cSetting_motion_hand);
/*
int ObjectMotion(pymol::CObject * I, int action, int first,
int last, float power, float bias,
int simple, float linear, int wrap,
int hand, int window, int cycles, int state, int quiet);
*/
ObjectMotion(I, MViewAction::Reinterpolate, -1, -1, power, bias, simple, linear,
SettingGetGlobal_b(I->G,cSetting_movie_loop) ? 1 : 0,
hand, 5, 1, -1, 1);
}
int ObjectMotionModify(pymol::CObject *I, ViewElemAction action, int index, int count,int target,int freeze,int localize)
{
int ok;
if(I->type == cObjectGroup) { /* propagate */
ok = ExecutiveGroupMotionModify(I->G,I,action,index,count,target,freeze);
} else {
ok = ViewElemModify(I->G, &I->ViewElem,action,index,count,target);
if(ok && I->ViewElem) {
int size = VLAGetSize(I->ViewElem);
int n_frame = MovieGetLength(I->G);
if(n_frame != size) {
/* extend entire movie */
if(!localize)
ExecutiveMotionExtend(I->G,true);
if((!freeze) && SettingGetGlobal_i(I->G,cSetting_movie_auto_interpolate)) {
ExecutiveMotionReinterpolate(I->G);
}
} else if((!freeze) && SettingGetGlobal_i(I->G,cSetting_movie_auto_interpolate)) {
ObjectMotionReinterpolate(I);
}
}
}
return ok;
}
int ObjectGetSpecLevel(pymol::CObject * I, int frame)
{
if(I->ViewElem) {
int size = VLAGetSize(I->ViewElem);
if(frame<0) {
int max_level = 0;
int i;
for(i=0;i<size;i++) {
if(max_level < I->ViewElem[i].specification_level)
max_level = I->ViewElem[i].specification_level;
}
return max_level;
}
if((frame>=0) && (frame<size))
return I->ViewElem[frame].specification_level;
return 0;
}
return -1;
}
void ObjectDrawViewElem(pymol::CObject *I, BlockRect *rect,int frames , CGO *orthoCGO)
{
if(I->ViewElem) {
ViewElemDraw(I->G,I->ViewElem,rect,frames,I->Name, orthoCGO);
}
}
int ObjectMotion(pymol::CObject * I, MViewAction action, int first,
int last, float power, float bias,
int simple, float linear, int wrap,
int hand, int window, int cycles, int state, int quiet)
{
PyMOLGlobals *G = I->G;
if(I->type == cObjectGroup) { /* propagate */
return ExecutiveGroupMotion(G,I,action,first,last, power,bias,simple,linear,
wrap,hand,window,cycles,state,quiet);
} else {
int frame;
int nFrame = MovieGetLength(I->G);
if(wrap<0) {
wrap = SettingGet_b(I->G,NULL, I->Setting.get(), cSetting_movie_loop);
}
if(nFrame < 0)
nFrame = -nFrame;
if(!I->ViewElem) {
I->ViewElem = pymol::vla<CViewElem>(0);
}
if (action == MViewAction::Toggle || action == MViewAction::ToggleInterp) {
frame = first;
if(first < 0)
frame = SceneGetFrame(G);
VLACheck(I->ViewElem, CViewElem, frame);
if (action == MViewAction::Toggle) {
if(I->ViewElem[frame].specification_level>1) {
action = MViewAction::Clear;
} else {
action = MViewAction::Store;
}
} else if(action == MViewAction::ToggleInterp) {
if(I->ViewElem[frame].specification_level>1) {
int frame;
action = MViewAction::Reinterpolate;
for(frame=0;frame<nFrame;frame++) {
if(I->ViewElem[frame].specification_level==1) {
action = MViewAction::Uninterpolate;
break;
}
}
}
else if(I->ViewElem[frame].specification_level>0) {
action = MViewAction::Uninterpolate;
} else {
action = MViewAction::Reinterpolate;
}
}
}
if(action == MViewAction::Smooth) {
int save_last = last;
std::max(0, first);
if(last < 0) {
last = nFrame;
}
if(last >= nFrame) {
last = nFrame - 1;
}
if(first <= last) {
int a;
VLACheck(I->ViewElem, CViewElem, last);
for(a = 0; a < cycles; a++) {
ViewElemSmooth(I->ViewElem + first, I->ViewElem + last, window, wrap);
}
}
if(SettingGet_b(I->G, nullptr, I->Setting.get(), cSetting_movie_auto_interpolate)){
action = MViewAction::Reinterpolate;
last = save_last;
}
}
switch (action) {
case MViewAction::Store:
if(!I->TTTFlag) {
float mn[3], mx[3], orig[3];
if(ExecutiveGetExtent(G, I->Name, mn, mx, true, -1, true)) {
average3f(mn, mx, orig);
ObjectSetTTTOrigin(I, orig);
} else {
initializeTTT44f(I->TTT);
I->TTTFlag = true;
}
}
if(I->ViewElem && I->TTTFlag) {
if(first < 0)
first = SceneGetFrame(G);
if(last < 0)
last = first;
{
int state_tmp=0, state_flag = false;
if(state>=0) {
state_tmp = state;
state_flag = true;
} else if(SettingGetIfDefined_i(G, I->Setting.get(), cSetting_state, &state_tmp)) {
state_flag = true;
state_tmp--;
}
for(frame = first; frame <= last; frame++) {
if((frame >= 0) && (frame < nFrame)) {
VLACheck(I->ViewElem, CViewElem, frame);
if(!quiet) {
PRINTFB(G, FB_Object, FB_Details)
" ObjectMotion: Setting frame %d.\n", frame + 1 ENDFB(G);
}
TTTToViewElem(I->TTT, I->ViewElem + frame);
if(state_flag) {
I->ViewElem[frame].state_flag = state_flag;
I->ViewElem[frame].state = state_tmp;
}
if(power!=0.0F) {
I->ViewElem[frame].power_flag = true;
I->ViewElem[frame].power = power;
}
if(bias > 0.0F) {
I->ViewElem[frame].bias_flag = true;
I->ViewElem[frame].bias = bias;
}
I->ViewElem[frame].specification_level = 2;
}
}
}
}
break;
case MViewAction::Clear:
if(I->ViewElem) {
if(first < 0)
first = SceneGetFrame(G);
if(last < 0)
last = first;
for(frame = first; frame <= last; frame++) {
if((frame >= 0) && (frame < nFrame)) {
VLACheck(I->ViewElem, CViewElem, frame);
ViewElemArrayPurge(G, I->ViewElem + frame, 1);
UtilZeroMem((void *) (I->ViewElem + frame), sizeof(CViewElem));
}
}
}
break;
case MViewAction::Interpolate:
case MViewAction::Reinterpolate:
{
CViewElem *first_view = nullptr, *last_view = nullptr;
int view_found = false;
if(first < 0)
first = 0;
if(first > nFrame) {
first = nFrame - 1;
}
if(last < 0) {
last = nFrame;
if(last) {
if(!wrap)
last--;
else {
int frame = 0;
VLACheck(I->ViewElem, CViewElem, last);
for(frame = 0; frame < last; frame++) {
if(I->ViewElem[frame].specification_level > 1) {
last += frame;
break;
}
}
}
}
} else {
if(last >= nFrame) {
last = nFrame;
if(last && !wrap)
last--;
}
}
VLACheck(I->ViewElem, CViewElem, last);
if(wrap && (last >= nFrame)) {
/* if we're interpolating beyond the last frame, then wrap by
copying early frames to last frames */
int a;
for(a = nFrame; a <= last; a++) {
ViewElemCopy(G, I->ViewElem + a - nFrame, I->ViewElem + a);
}
} else if(!wrap) {
/* if we're not wrapping, then make sure we nuke any stray / old
interpolated frames */
frame = nFrame - 1;
while(frame>=0) {
if(I->ViewElem[frame].specification_level > 1)
break;
else
UtilZeroMem((void *) (I->ViewElem + frame), sizeof(CViewElem));
frame--;
}
}
VLACheck(I->ViewElem, CViewElem, last);
if(!quiet) {
if (action == MViewAction::Interpolate) {
if(last == nFrame) {
PRINTFB(G, FB_Object, FB_Details)
" ObjectMotion: interpolating unspecified frames %d to %d (wrapping).\n",
first + 1, last ENDFB(G);
} else {
PRINTFB(G, FB_Object, FB_Details)
" ObjectMotion: interpolating unspecified frames %d to %d.\n", first + 1,
last + 1 ENDFB(G);
}
} else {
if(last == nFrame) {
PRINTFB(G, FB_Object, FB_Details)
" ObjectMotion: reinterpolating all frames %d to %d (wrapping).\n", first + 1,
last ENDFB(G);
} else {
PRINTFB(G, FB_Object, FB_Details)
" ObjectMotion: reinterpolating all frames %d to %d.\n", first + 1, last + 1
ENDFB(G);
}
}
}
for(frame = first; frame <= last; frame++) {
if(!first_view) {
if(I->ViewElem[frame].specification_level == 2) { /* specified */
first_view = I->ViewElem + frame;
view_found = true;
}
} else {
CViewElem *view;
int interpolate_flag = false;
if(I->ViewElem[frame].specification_level == 2) { /* specified */
last_view = I->ViewElem + frame;
if (action == MViewAction::Interpolate) {
for(view = first_view + 1; view < last_view; view++) {
if(!view->specification_level)
interpolate_flag = true;
}
} else {
interpolate_flag = true;
}
if(interpolate_flag) {
ViewElemInterpolate(G, first_view, last_view,
power, bias, simple, linear, hand, 0.0F);
}
first_view = last_view;
last_view = nullptr;
}
}
}
if(first_view) {
if(wrap && (last >= nFrame)) {
/* if we're interpolating beyond the last frame, then wrap by
copying the last frames back over the early frames */
int a;
for(a = nFrame; a <= last; a++) {
ViewElemCopy(G, I->ViewElem + a, I->ViewElem + a - nFrame);
}
}
}
if((!view_found) && (last>=first) && (first>=0) && (last<=nFrame)) {
UtilZeroMem(I->ViewElem + first, sizeof(CViewElem) * (1 + (last-first)));
}
if(last >= nFrame) { /* now erase temporary views */
ViewElemArrayPurge(G, I->ViewElem + nFrame, (1 + last - nFrame));
UtilZeroMem((void *) (I->ViewElem + nFrame),
sizeof(CViewElem) * (1 + last - nFrame));
}
}
break;
case MViewAction::Reset:
if(I->ViewElem) {
VLAFreeP(I->ViewElem);
}
I->ViewElem = pymol::vla<CViewElem>(0);
break;
case MViewAction::Uninterpolate:
if(I->ViewElem) {
if(first < 0)
first = 0;
if(last < 0) {
last = nFrame - 1;
}
for(frame = first; frame <= last; frame++) {
if((frame >= 0) && (frame <= last)) {
VLACheck(I->ViewElem, CViewElem, frame);
if(I->ViewElem[frame].specification_level < 2) {
ViewElemArrayPurge(G, I->ViewElem + frame, 1);
UtilZeroMem((void *) (I->ViewElem + frame), sizeof(CViewElem));
}
}
}
}
break;
case MViewAction::Purge:
if(I->ViewElem) {
VLAFreeP(I->ViewElem);
}
break;
}
if(I->ViewElem) {
VLASize(I->ViewElem,CViewElem,nFrame);
}
}
return 1;
}
void ObjectAdjustStateRebuildRange(pymol::CObject * I, int *start, int *stop)
{
/* on entry, start and stop should hold the valid range for the object */
int defer_builds_mode =
SettingGet_i(I->G, nullptr, I->Setting.get(), cSetting_defer_builds_mode);
int async_builds = SettingGet_b(I->G, nullptr, I->Setting.get(), cSetting_async_builds);
int max_threads = SettingGet_i(I->G, nullptr, I->Setting.get(), cSetting_max_threads);
int all_states = SettingGet_i(I->G, nullptr, I->Setting.get(), cSetting_all_states);
int dummy;
if (all_states)
return;
if(defer_builds_mode >= 3) {
if(SceneObjectIsActive(I->G, I))
defer_builds_mode = 2;
}
switch (defer_builds_mode) {
case 1: /* defer geometry builds until needed */
case 2: /* defer and destroy continuously for increase memory conservation */
if(SettingGetIfDefined_i(I->G, I->Setting.get(), cSetting_state, &dummy)) {
/* decoupled...so always build all states. Otherwise, geometry
may not be there when we need it... unfortunately, this defeats
the purpose of defer_builds_mode! */
} else {
int min = *start;
int max = *stop;
int global_state = SceneGetState(I->G);
int obj_state = ObjectGetCurrentState(I, false);
*start = obj_state;
if((obj_state != global_state) || (!async_builds) || (max_threads < 1)) {
*stop = *start + 1;
if(*stop > max )
*stop = max;
} else {
int base = (*start / max_threads);
*start = (base) * max_threads;
*stop = (base + 1) * max_threads;
if(*start < min)
*start = min;
if(*start > max)
*start = max;
if(*stop < min)
*stop = min;
if(*stop > max)
*stop = max;
}
if(*start > obj_state)
*start = obj_state;
if(*stop <= obj_state)
*stop = obj_state + 1;
if(*start < 0)
*start = 0;
}
break;
case 3: /* object not active, so do not rebuild anything */
*stop = *start;
break;
}
}
/**
* Replaces invalid characters in the given object name with an underscore,
* or strips them if they are terminal or sequential.
* @param[in,out] name Object name to validate
* @return true if name was modified, false otherwise
*/
bool ObjectMakeValidName(char *name)
{
bool modified = false;
char *p = name, *q;
if(p) {
/* currently legal are A to Z, a to z, 0 to 9, -, _, + */
while(*p) {
switch (*p) {
case '+':
case '-':
case '.':
case '^':
case '_':
break;
default:
if (('A' <= *p && *p <= 'Z') ||
('a' <= *p && *p <= 'z') ||
('0' <= *p && *p <= '9'))
break;
/* must be an ASCII-visible character */
*p = 1; /* placeholder for non-printable */
modified = true;
}
p++;
}
/* eliminate sequential and terminal nonprintables */
p = name;
q = name;
while(*p) {
if(q == name)
while(*p == 1)
p++;
while((*p == 1) && (p[1] == 1))
p++;
*q++ = *p++;
if(!p[-1])
break;
}
*q = 0;
while(q > name) {
if(q[-1] == 1) {
q[-1] = 0;
q--;
} else
break;
}
/* convert invalides to underscore */
p = name;
while(*p) {
if(*p == 1)
*p = '_';
p++;
}
}
return modified;
}
/**
* Replaces invalid characters in `name` with an underscore,
* or strips them if they are terminal or sequential - if `name` equals a reserved
* selection keyword, then also append an underscore.
*
* @param[in,out] name Object name to validate
* @param quiet If false, print warnings if the name gets modified.
*/
void ObjectMakeValidName(PyMOLGlobals * G, char *name, bool quiet)
{
if (ObjectMakeValidName(name) && !quiet) {
PRINTFB(G, FB_Executive, FB_Warnings)
" Warning: Invalid characters in '%s' have been replaced or stripped\n",
name ENDFB(G);
}
if (SelectorNameIsKeyword(G, name)) {
if (!quiet) {
PRINTFB(G, FB_Executive, FB_Warnings)
" Warning: '%s' is a reserved keyword, appending underscore\n", name
ENDFB(G);
}
strcat(name, "_");
return;
}
static bool once_protein = false;
static bool once_nucleic = false;
if (!once_protein && strcmp(name, "protein") == 0) {
once_protein = true;
} else if (!once_nucleic && strcmp(name, "nucleic") == 0) {
once_nucleic = true;
} else {
return;
}
{
// Warn the user if "protein" or "nucleic" are used as names, but
// don't modify the name (yet).
PRINTFB(G, FB_Executive, FB_Warnings)
" Warning: '%s' may become a reserved selection keyword in the future\n", name
ENDFB(G);
}
}
/**
* Get a pointer to an object state.
* @param state State (0-indexed) or -2/-3 for current state
* @return nullptr if state is out of bounds or empty
*/
CObjectState* pymol::CObject::getObjectState(int state)
{
if (state == -2 /* cSelectorUpdateTableCurrentState */ ||
state == -3 /* cSelectorUpdateTableEffectiveStates */) {
state = getCurrentState();
}
if (state < 0 || state >= getNFrame()) {
return nullptr;
}
return _getObjectState(state);
}
/**
* Get the effective state (0-indexed) of an object, based on the `state` and
* `static_singletons` settings. Will not validate the value of the `state`
* setting, it could be `<0` or `>=getNFrame()`.
*/
int pymol::CObject::getCurrentState() const
{
if (getNFrame() == 1 &&
SettingGet<bool>(G, Setting.get(), nullptr, cSetting_static_singletons))
return 0;
return SettingGet<int>(G, Setting.get(), nullptr, cSetting_state) - 1;
}
/**
* Like pymol::CObject::getCurrentState() but will return `-1` if the `all_states`
* setting is set.
*
* Note: Clamps negative values at `-1` (all states). The usefulness of this
* should be questioned, in particular with `ignore_all_states=true` a caller
* is likely to discard all negative values, including -1.
*
* @param ignore_all_states Boolean flag, should be false. You most likely
* should use pymol::CObject::getCurrentState() instead of setting `ignore_all_states`
* to true.
*/
int ObjectGetCurrentState(const pymol::CObject * I, int ignore_all_states)
{
assert("use pymol::CObject::getCurrentState()" && !ignore_all_states);
// the previous implementation (up to PyMOL 1.7.6) ignored
// object-level state=0 (all states)
if (!ignore_all_states &&
SettingGet_b(I->G, I->Setting.get(), nullptr, cSetting_all_states))
return -1;
return std::max(-1, I->getCurrentState());
}
PyObject *ObjectAsPyList(const pymol::CObject * I)
{
PyObject *result = nullptr;
result = PyList_New(14);
PyList_SetItem(result, 0, PyInt_FromLong(I->type));
PyList_SetItem(result, 1, PyString_FromString(I->Name));
PyList_SetItem(result, 2, PyInt_FromLong(I->Color));
PyList_SetItem(result, 3, PyInt_FromLong(I->visRep));
PyList_SetItem(result, 4, PConvFloatArrayToPyList(I->ExtentMin, 3));
PyList_SetItem(result, 5, PConvFloatArrayToPyList(I->ExtentMax, 3));
PyList_SetItem(result, 6, PyInt_FromLong(I->ExtentFlag));
PyList_SetItem(result, 7, PyInt_FromLong(I->TTTFlag));
PyList_SetItem(result, 8, SettingAsPyList(I->Setting.get()));
PyList_SetItem(result, 9, PyInt_FromLong(I->Enabled));
PyList_SetItem(result, 10, PyInt_FromLong(static_cast<long>(I->getRenderContext())));
PyList_SetItem(result, 11, PConvFloatArrayToPyList(I->TTT, 16));
if(I->ViewElem) {
int nFrame = VLAGetSize(I->ViewElem);
PyList_SetItem(result, 12, PyInt_FromLong(nFrame));
PyList_SetItem(result, 13, ViewElemVLAAsPyList(I->G, I->ViewElem, nFrame));
} else {
PyList_SetItem(result, 12, PyInt_FromLong(0));
PyList_SetItem(result, 13, PConvAutoNone(nullptr));
}
return (PConvAutoNone(result));
}
int ObjectFromPyList(PyMOLGlobals * G, PyObject * list, pymol::CObject * I)
{
int ok = true;
int ll = 0;
I->G = G;
if(ok)
ok = (list != nullptr);
if(ok)
ok = PyList_Check(list);
if(ok)
ll = PyList_Size(list);
if(ok)
ok = CPythonVal_PConvPyIntToInt_From_List(G, list, 0, reinterpret_cast<int*>(&I->type));
if(ok)
ok = PConvPyStrToStr(PyList_GetItem(list, 1), I->Name, WordLength);
if(ok)
ok = PConvPyIntToInt(PyList_GetItem(list, 2), &I->Color);
if(ok)
I->Color = ColorConvertOldSessionIndex(G, I->Color);
if(ok) {
PyObject *val = PyList_GetItem(list, 3);
if(PyList_Check(val)) {
ok = PConvPyListToBitmask(val, &I->visRep, cRepCnt);
} else {
ok = PConvPyIntToInt(val, &I->visRep);
}
CPythonVal_Free(val);
}
if(ok)
ok = PConvPyListToFloatArrayInPlaceAutoZero(PyList_GetItem(list, 4), I->ExtentMin, 3);
if(ok)
ok = PConvPyListToFloatArrayInPlaceAutoZero(PyList_GetItem(list, 5), I->ExtentMax, 3);
if(ok)
ok = PConvPyIntToInt(PyList_GetItem(list, 6), &I->ExtentFlag);
if(ok)
ok = PConvPyIntToInt(PyList_GetItem(list, 7), &I->TTTFlag);
if(ok){
CPythonVal *val = CPythonVal_PyList_GetItem(G, list, 8);
I->Setting.reset(SettingNewFromPyList(G, val));
CPythonVal_Free(val);
}
if(ok && (ll > 9))
ok = CPythonVal_PConvPyIntToInt_From_List(G, list, 9, &I->Enabled);
if(ok && (ll > 10)) {
// I->Context removed.
}
if(ok && (ll > 11))
ok = PConvPyListToFloatArrayInPlaceAutoZero(PyList_GetItem(list, 11), I->TTT, 16);
if(ok && (ll > 13)) {
PyObject *tmp;
int nFrame;
VLAFreeP(I->ViewElem);
I->ViewElem = nullptr;
if(ok)
ok = PConvPyIntToInt(PyList_GetItem(list, 12), &nFrame);
if(ok && nFrame) {
tmp = PyList_GetItem(list, 13);
if(tmp && !(tmp == Py_None))
ok = ViewElemVLAFromPyList(G, tmp, &I->ViewElem, nFrame);
}
}
/* TO SUPPORT BACKWARDS COMPATIBILITY...
Always check ll when adding new PyList_GetItem's */
return (ok);
}
int ObjectCopyHeader(pymol::CObject * I, const pymol::CObject * src)
{
int ok = true;
I->G = src->G;
I->type = src->type;
UtilNCopy(I->Name, src->Name, WordLength);
I->Color = src->Color;
I->visRep = src->visRep;
copy3f(src->ExtentMin, I->ExtentMin);
copy3f(src->ExtentMax, I->ExtentMax);
I->ExtentFlag = src->ExtentFlag;
I->TTTFlag = src->TTTFlag;
I->Setting = src->Setting;
I->Enabled = src->Enabled;
{
int a;
for(a = 0; a < 16; a++)
I->TTT[a] = src->TTT[a];
}
I->ViewElem = nullptr; /* to do */
return (ok);
}
/*========================================================================*/
void ObjectCombineTTT(pymol::CObject * I, const float *ttt, int reverse_order, int store)
{
if(I->type == cObjectGroup) {
ExecutiveGroupCombineTTT(I->G, I, ttt, reverse_order,store);
} else {
float cpy[16];
if(!I->TTTFlag) {
I->TTTFlag = true;
initializeTTT44f(cpy);
} else {
UtilCopyMem(cpy, I->TTT, sizeof(float) * 16);
}
if(reverse_order) {
combineTTT44f44f(cpy, ttt, I->TTT);
} else {
combineTTT44f44f(ttt, cpy, I->TTT);
}
if(store<0)
store = SettingGet_i(I->G, I->Setting.get(), nullptr, cSetting_movie_auto_store);
if(store && MovieDefined(I->G)) {
if(!I->ViewElem)
I->ViewElem = pymol::vla<CViewElem>(0);
if(I->ViewElem) { /* update motion path waypoint, if active */
int frame = SceneGetFrame(I->G);
if(frame >= 0) {
VLACheck(I->ViewElem, CViewElem, frame);
TTTToViewElem(I->TTT, I->ViewElem + frame);
I->ViewElem[frame].specification_level = 2;
}
}
}
}
}
/*========================================================================*/
void ObjectTranslateTTT(pymol::CObject * I, const float *v, int store)
{
if(I->type == cObjectGroup) {
ExecutiveGroupTranslateTTT(I->G, I, v, store);
} else {
if(!I->TTTFlag) {
I->TTTFlag = true;
initializeTTT44f(I->TTT);
}
if(v) {
I->TTT[3] += v[0];
I->TTT[7] += v[1];
I->TTT[11] += v[2];
}
if(store<0)
store = SettingGet_i(I->G, I->Setting.get(), nullptr, cSetting_movie_auto_store);
if(store && MovieDefined(I->G)) {
if(!I->ViewElem)
I->ViewElem = pymol::vla<CViewElem>(0);
if(I->ViewElem) { /* update motion path waypoint, if active */
int frame = SceneGetFrame(I->G);
if(frame >= 0) {
VLACheck(I->ViewElem, CViewElem, frame);
TTTToViewElem(I->TTT, I->ViewElem + frame);
I->ViewElem[frame].specification_level = 2;
}
}
}
}
}
/*========================================================================*/
void ObjectSetTTT(pymol::CObject * I, const float *ttt, int state, int store)
{
if(state < 0) {
if(ttt) {
UtilCopyMem(I->TTT, ttt, sizeof(float) * 16);
I->TTTFlag = true;
} else {
I->TTTFlag = false;
return;
}
if(store<0)
store = SettingGet_i(I->G, I->Setting.get(), nullptr, cSetting_movie_auto_store);
if(store && MovieDefined(I->G)) {
if(!I->ViewElem)
I->ViewElem = pymol::vla<CViewElem>(0);
if(I->ViewElem) { /* update motion path waypoint, if active */
int frame = SceneGetFrame(I->G);
if(frame >= 0) {
VLACheck(I->ViewElem, CViewElem, frame);
TTTToViewElem(I->TTT, I->ViewElem + frame);
I->ViewElem[frame].specification_level = 2;
}
}
}
} else {
/* to do */
}
}
/*========================================================================*/
int ObjectGetTTT(pymol::CObject * I, const float **ttt, int state)
{
if(state < 0) {
if(I->TTTFlag) {
*ttt = I->TTT;
return 1;
} else {
*ttt = nullptr;
}
} else {
}
return 0;
}
/*========================================================================*/
void ObjectResetTTT(pymol::CObject * I,int store)
{
I->TTTFlag = false;
if(store<0)
store = SettingGet_i(I->G, I->Setting.get(), nullptr, cSetting_movie_auto_store);
if(store && MovieDefined(I->G)) {
if(!I->ViewElem)
I->ViewElem = pymol::vla<CViewElem>(0);
if(I->ViewElem) { /* update motion path waypoint, if active */
int frame = SceneGetFrame(I->G);
if(frame >= 0) {
identity44f(I->TTT);
VLACheck(I->ViewElem, CViewElem, frame);
TTTToViewElem(I->TTT, I->ViewElem + frame);
I->ViewElem[frame].specification_level = 2;
}
}
}
}
/*========================================================================*/
/**
* Get the combined transformation of TTT and state matrix. State matrix is
* only included if `history=true` or `matrix_mode > 0`.
*
* @param state See pymol::CObject::getObjectState
* @param history Boolean flag
* @param[out] matrix Homogeneous 4x4 matrix
* @return True if `matrix` was populated
*/
int ObjectGetTotalMatrix(pymol::CObject * I, int state, int history, double *matrix)
{
int result = false;
if(I->TTTFlag) {
convertTTTfR44d(I->TTT, matrix);
result = true;
}
if (!history) {
history =
SettingGet<int>(I->G, I->Setting.get(), nullptr, cSetting_matrix_mode) > 0;
}
if (history) {
{
CObjectState* obj_state = I->getObjectState(state);
if (obj_state) {
if(!obj_state->Matrix.empty()) {
const double *state_matrix = obj_state->Matrix.data();
if(result) {
right_multiply44d44d(matrix, state_matrix);
} else {
copy44d(state_matrix, matrix);
}
result = true;
}
}
}
}
return result;
}
/*========================================================================*/
void ObjectPrepareContext(pymol::CObject * I, RenderInfo * info)
{
CRay * ray = info ? info->ray : nullptr;
if(I->ViewElem) {
int frame = SceneGetFrame(I->G);
if(frame >= 0) {
VLACheck(I->ViewElem, CViewElem, frame);
if(I->Grabbed) {
TTTToViewElem(I->TTT, I->ViewElem + frame);
I->ViewElem[frame].specification_level = 2;
} else {
if(I->ViewElem[frame].specification_level) {
TTTFromViewElem(I->TTT, I->ViewElem + frame);
I->TTTFlag = true;
}
if(I->ViewElem[frame].state_flag) {
SettingCheckHandle(I->G, I->Setting);
if(I->Setting) {
/* note: this assumes that the state has already been
calculated and can thus be displayed. How can we
guarantee this to be true? */
SettingSet_i(I->Setting.get(),cSetting_state,I->ViewElem[frame].state + 1);
}
}
}
}
}
if(ray) {
RaySetTTT(ray, I->TTTFlag, I->TTT);
} else {
PyMOLGlobals *G = I->G;
if(G->HaveGUI && G->ValidContext) {
if(I->TTTFlag) {
/* convert the row-major TTT matrix to a column-major OpenGL matrix */
float gl[16], *ttt;
ttt = I->TTT;
gl[0] = ttt[0];
gl[4] = ttt[1];
gl[8] = ttt[2];
gl[12] = ttt[3];
gl[1] = ttt[4];
gl[5] = ttt[5];
gl[9] = ttt[6];
gl[13] = ttt[7];
gl[2] = ttt[8];
gl[6] = ttt[9];
gl[10] = ttt[10];
gl[14] = ttt[11];
gl[3] = 0.0;
gl[7] = 0.0;
gl[11] = 0.0;
gl[15] = 1.0;
auto mvm = SceneGetModelViewMatrixPtr(G);
MatrixMultiplyC44f(gl, mvm);
MatrixTranslateC44f(mvm, ttt[12], ttt[13], ttt[14]);
#ifndef PURE_OPENGL_ES_2
if (ALWAYS_IMMEDIATE_OR(!info->use_shaders)) {
glLoadMatrixf(mvm);
}
#endif
}
}
}
}
/*========================================================================*/
void ObjectSetTTTOrigin(pymol::CObject * I, float *origin)
{
float homo[16];
float *dst;
float post[3];
if(!I->TTTFlag) {
I->TTTFlag = true;
initializeTTT44f(I->TTT);
}
/* convert the existing TTT into a homogenous transformation matrix */
convertTTTfR44f(I->TTT, homo);
/* now reset to the passed-in origin */
transform44f3fas33f3f(homo, origin, post);
homo[3] += post[0];
homo[7] += post[1];
homo[11] += post[2];
dst = homo + 12;
invert3f3f(origin, dst);
copy44f(homo, I->TTT);
}
/*========================================================================*/
pymol::copyable_ptr<CSetting>* pymol::CObject::getSettingHandle(int state)
{
return &Setting;
}
/*========================================================================*/
std::string pymol::CObject::describeElement(int index) const
{
return {};
}
/*========================================================================*/
void ObjectToggleRepVis(pymol::CObject * I, int rep)
{
if((rep >= 0) && (rep < cRepCnt))
I->visRep ^= (1 << rep);
}
/*========================================================================*/
void ObjectSetRepVisMask(pymol::CObject * I, int repmask, int value)
{
switch (value) {
case cVis_HIDE:
I->visRep &= ~repmask;
break;
case cVis_SHOW:
I->visRep |= repmask;
break;
case cVis_AS:
I->visRep = repmask;
break;
case cVis_TOGGLE:
I->visRep ^= repmask;
break;
default:
printf("error: invalid value: %d\n", value);
}
}
/*========================================================================*/
void ObjectSetName(pymol::CObject * I, const char *name)
{
UtilNCopy(I->Name, name, WordLength);
if(SettingGetGlobal_b(I->G, cSetting_validate_object_names))
ObjectMakeValidName(I->G, I->Name);
}
void pymol::CObject::setName(pymol::zstring_view name)
{
ObjectSetName(this, name.data());
}
/*========================================================================*/
pymol::CObject::~CObject()
{
SceneObjectDel(this->G, this, false);
}
/*========================================================================*/
void ObjectUseColor(pymol::CObject * I)
{
PyMOLGlobals *G = I->G;
if(G->HaveGUI && G->ValidContext) {
glColor3fv(ColorGet(I->G, I->Color));
}
}
void ObjectUseColorCGO(CGO *cgo, pymol::CObject * I)
{
PyMOLGlobals *G = I->G;
if(G->HaveGUI && G->ValidContext) {
CGOColorv(cgo, ColorGet(I->G, I->Color));
}
}
/*========================================================================*/
/**
* Render a unit box (dummy representation)
*/
void pymol::CObject::render(RenderInfo * info)
{
if(G->HaveGUI && G->ValidContext) {
#ifdef PURE_OPENGL_ES_2
/* TODO */
#else
glBegin(GL_LINE_LOOP);
glVertex3i(-1, -1, -1);
glVertex3i(-1, -1, 1);
glVertex3i(-1, 1, 1);
glVertex3i(-1, 1, -1);
glVertex3i(1, 1, -1);
glVertex3i(1, 1, 1);
glVertex3i(1, -1, 1);
glVertex3i(1, -1, -1);
glEnd();
glBegin(GL_LINES);
glVertex3i(0, 0, 0);
glVertex3i(1, 0, 0);
glVertex3i(0, 0, 0);
glVertex3i(0, 3, 0);
glVertex3i(0, 0, 0);
glVertex3i(0, 0, 9);
glEnd();
#endif
}
}
/*========================================================================*/
pymol::CObject::CObject(PyMOLGlobals * G) : G(G)
{
OrthoRemoveSplash(G); /* HMM... this seems like an inappropriate sideeffect */
visRep = cRepBitmask & ~(cRepCellBit | cRepExtentBit);
}
/*========================================================================*/
void ObjectStateInit(PyMOLGlobals * G, CObjectState * I)
{
I->G = G;
}
void ObjectStatePurge(CObjectState * I)
{
}
int ObjectStateSetMatrix(CObjectState * I, const double *matrix)
{
int ok = true;
if(matrix) {
I->Matrix.resize(16);
copy44d(matrix, I->Matrix.data());
} else {
I->Matrix.clear();
}
I->InvMatrix.clear();
return ok;
}
void ObjectStateRightCombineMatrixR44d(CObjectState * I, const double *matrix)
{
if(matrix) {
if(I->Matrix.empty()) {
I->Matrix = std::vector<double>(16);
copy44d(matrix, I->Matrix.data());
} else {
right_multiply44d44d(I->Matrix.data(), matrix);
}
}
I->InvMatrix.clear();
}
void ObjectStateLeftCombineMatrixR44d(CObjectState * I, const double *matrix)
{
if(matrix) {
if(I->Matrix.empty()) {
I->Matrix = std::vector<double>(16);
copy44d(matrix, I->Matrix.data());
} else {
left_multiply44d44d(matrix, I->Matrix.data());
}
}
I->InvMatrix.clear();
}
void ObjectStateCombineMatrixTTT(CObjectState * I, const float *matrix)
{
if(matrix) {
if(I->Matrix.empty()) {
I->Matrix = std::vector<double>(16);
convertTTTfR44d(matrix, I->Matrix.data());
} else {
double tmp[16];
convertTTTfR44d(matrix, tmp);
right_multiply44d44d(I->Matrix.data(), tmp);
}
}
I->InvMatrix.clear();
}
double *ObjectStateGetMatrix(CObjectState * I)
{
if(!I->Matrix.empty()) {
return I->Matrix.data();
}
return nullptr;
}
const double* ObjectStateGetMatrix(const CObjectState* I)
{
return I->Matrix.empty() ? nullptr : I->Matrix.data();
}
/**
* Get the Matrix inverse
*/
const double *ObjectStateGetInvMatrix(const CObjectState * self)
{
if (self->Matrix.empty()) {
return nullptr;
}
if (self->InvMatrix.empty()) {
auto I = const_cast<CObjectState*>(self);
I->InvMatrix = std::vector<double>(16);
xx_matrix_invert(I->InvMatrix.data(), I->Matrix.data(), 4);
}
return self->InvMatrix.data();
}
void ObjectStateTransformMatrix(CObjectState * I, const double *matrix)
{
if(I->Matrix.empty()) {
I->Matrix = std::vector<double>(16);
if(!I->Matrix.empty()) {
copy44d(matrix, I->Matrix.data());
}
} else {
right_multiply44d44d(I->Matrix.data(), matrix);
}
I->InvMatrix.clear();
}
int ObjectStatePushAndApplyMatrix(CObjectState * I, RenderInfo * info)
{
PyMOLGlobals *G = I->G;
float matrix[16];
const double *i_matrix = nullptr;
if(!I->Matrix.empty()) {
i_matrix = I->Matrix.data();
}
int result = false;
if(i_matrix) {
if(info->ray) {
float ttt[16], matrix[16], i_matrixf[16];
RayPushTTT(info->ray);
RayGetTTT(info->ray, ttt);
convertTTTfR44f(ttt, matrix);
copy44d44f(i_matrix, i_matrixf);
right_multiply44f44f(matrix, i_matrixf);
RaySetTTT(info->ray, true, matrix);
result = true;
} else if(G->HaveGUI && G->ValidContext) {
matrix[0] = i_matrix[0];
matrix[1] = i_matrix[4];
matrix[2] = i_matrix[8];
matrix[3] = i_matrix[12];
matrix[4] = i_matrix[1];
matrix[5] = i_matrix[5];
matrix[6] = i_matrix[9];
matrix[7] = i_matrix[13];
matrix[8] = i_matrix[2];
matrix[9] = i_matrix[6];
matrix[10] = i_matrix[10];
matrix[11] = i_matrix[14];
matrix[12] = i_matrix[3];
matrix[13] = i_matrix[7];
matrix[14] = i_matrix[11];
matrix[15] = i_matrix[15];
ScenePushModelViewMatrix(G);
auto mvm = SceneGetModelViewMatrixPtr(G);
MatrixMultiplyC44f(matrix, mvm);
#ifndef PURE_OPENGL_ES_2
if (ALWAYS_IMMEDIATE_OR(!info->use_shaders)) {
glLoadMatrixf(mvm);
}
#endif
result = true;
}
}
return result;
}
void ObjectStatePopMatrix(CObjectState * I, RenderInfo * info)
{
PyMOLGlobals *G = I->G;
if(info->ray) {
RayPopTTT(info->ray);
} else if(G->HaveGUI && G->ValidContext) {
ScenePopModelViewMatrix(G, !info->use_shaders);
}
}
void ObjectStateResetMatrix(CObjectState* I)
{
I->Matrix.clear();
I->InvMatrix.clear();
}
PyObject *ObjectStateAsPyList(CObjectState * I)
{
PyObject *result = nullptr;
if(I) {
result = PyList_New(1);
if(!I->Matrix.empty()) {
PyList_SetItem(result, 0, PConvDoubleArrayToPyList(I->Matrix.data(), 16));
} else {
PyList_SetItem(result, 0, PConvAutoNone(Py_None));
}
}
return (PConvAutoNone(result));
}
int ObjectStateFromPyList(PyMOLGlobals * G, PyObject * list, CObjectState * I)
{
PyObject *tmp;
int ok = true;
ObjectStateInit(G, I);
if(list && (list != Py_None)) { /* allow None */
if(ok)
ok = (list != nullptr);
if(ok)
ok = PyList_Check(list);
/* TO SUPPORT BACKWARDS COMPATIBILITY...
Always check ll when adding new PyList_GetItem's */
if(ok) {
tmp = PyList_GetItem(list, 0);
if(tmp != Py_None)
ok = PConvFromPyObject(G, tmp, I->Matrix);
}
}
return (ok);
}
Reference in New Issue View Git Blame Copy Permalink