is a Python-enhanced molecular graphics tool. It excels at 3D visualization of proteins, small molecules, density, surfaces, and trajectories. It also includes molecular editing, ray tracing, and movies. Open Source version.
| RepNonbonded.cpp (pymol-v2.1.0.tar.bz2) | : | RepNonbonded.cpp (pymol-open-source-2.2.0) |
|---|
| | |
| skipping to change at line 34 | | skipping to change at line 34 |
|---|
| #include"RepNonbonded.h" | | #include"RepNonbonded.h" |
| #include"Color.h" | | #include"Color.h" |
| #include"Scene.h" | | #include"Scene.h" |
| #include"main.h" | | #include"main.h" |
| #include"Setting.h" | | #include"Setting.h" |
| #include"ShaderMgr.h" | | #include"ShaderMgr.h" |
| #include"CGO.h" | | #include"CGO.h" |
| | |
| typedef struct RepNonbonded { | | typedef struct RepNonbonded { |
| Rep R; | | Rep R; |
|
| float *V, *VP; | | CGO *primitiveCGO; |
| Pickable *P; | | |
| int N, NP; | | |
| float Width; | | |
| float Radius; | | |
| CGO *shaderCGO; | | CGO *shaderCGO; |
|
| | bool shaderCGO_has_cylinders; |
| } RepNonbonded; | | } RepNonbonded; |
| | |
| #include"ObjectMolecule.h" | | #include"ObjectMolecule.h" |
| | |
| void RepNonbondedFree(RepNonbonded * I); | | void RepNonbondedFree(RepNonbonded * I); |
| | |
| void RepNonbondedFree(RepNonbonded * I) | | void RepNonbondedFree(RepNonbonded * I) |
| { | | { |
|
| | CGOFree(I->primitiveCGO); |
| CGOFree(I->shaderCGO); | | CGOFree(I->shaderCGO); |
|
| FreeP(I->VP); | | |
| FreeP(I->V); | | |
| RepPurge(&I->R); | | RepPurge(&I->R); |
| OOFreeP(I); | | OOFreeP(I); |
| } | | } |
| | |
| void RepNonbondedRenderImmediate(CoordSet * cs, RenderInfo * info) | | void RepNonbondedRenderImmediate(CoordSet * cs, RenderInfo * info) |
| { | | { |
| PyMOLGlobals *G = cs->State.G; | | PyMOLGlobals *G = cs->State.G; |
| if(info->ray || info->pick || (!(G->HaveGUI && G->ValidContext))) | | if(info->ray || info->pick || (!(G->HaveGUI && G->ValidContext))) |
| return; | | return; |
| else { | | else { |
| | |
| skipping to change at line 114 | | skipping to change at line 110 |
|---|
| | |
| glVertex3f(v0, v1, v2 - nonbonded_size); | | glVertex3f(v0, v1, v2 - nonbonded_size); |
| glVertex3f(v0, v1, v2 + nonbonded_size); | | glVertex3f(v0, v1, v2 + nonbonded_size); |
| } | | } |
| v += 3; | | v += 3; |
| } | | } |
| } | | } |
| glEnd(); | | glEnd(); |
| glEnable(GL_LIGHTING); | | glEnable(GL_LIGHTING); |
| if(!active) | | if(!active) |
|
| cs->Active[cRepNonbonded] = true; | | cs->Active[cRepNonbonded] = false; |
| } | | } |
| } | | } |
| | |
|
| static void RepNonbondedRender(RepNonbonded * I, RenderInfo * info) | | static int RepNonbondedCGOGenerate(RepNonbonded * I, RenderInfo * info) |
| { | | { |
|
| CRay *ray = info->ray; | | |
| Picking **pick = info->pick; | | |
| PyMOLGlobals *G = I->R.G; | | PyMOLGlobals *G = I->R.G; |
|
| float *v = I->V; | | |
| int c = I->N; | | |
| unsigned int i, j; | | |
| Pickable *p; | | |
| float alpha; | | float alpha; |
| int ok = true; | | int ok = true; |
|
| | CGO *convertcgo = NULL; |
| | short nonbonded_as_cylinders ; |
| | short use_shader; |
| | float nonbonded_size = |
| | SettingGet_f(G, I->R.cs->Setting, I->R.obj->Setting, cSetting_nonbonded_size |
| | ); |
| | |
| | nonbonded_as_cylinders = SettingGetGlobal_b(G, cSetting_render_as_cylinders) & |
| | & SettingGetGlobal_b(G, cSetting_nonbonded_as_cylinders); |
| | use_shader = SettingGetGlobal_b(G, cSetting_nonbonded_use_shader) & |
| | SettingGetGlobal_b(G, cSetting_use_shaders); |
| | |
| alpha = | | alpha = |
| SettingGet_f(G, I->R.cs->Setting, I->R.obj->Setting, cSetting_nonbonded_tran
sparency); | | SettingGet_f(G, I->R.cs->Setting, I->R.obj->Setting, cSetting_nonbonded_tran
sparency); |
| alpha = 1.0F - alpha; | | alpha = 1.0F - alpha; |
| if(fabs(alpha - 1.0) < R_SMALL4) | | if(fabs(alpha - 1.0) < R_SMALL4) |
| alpha = 1.0F; | | alpha = 1.0F; |
|
| if(ray) { | | |
| float radius; | | |
| ray->transparentf(1.0F - alpha); | | |
| | |
| if(I->Radius == 0.0F) { | | |
| radius = ray->PixelRadius * I->Width / 2.0F; | | |
| } else { | | |
| radius = I->Radius; | | |
| } | | |
| | |
| v = I->V; | | |
| c = I->N; | | |
| | |
|
| while(ok && c--) { | | if (use_shader){ |
| /* printf("%8.3f %8.3f %8.3f %8.3f %8.3f %8.3f \n",v[3],v[4],v[5],v | | if (ok && I->shaderCGO){ |
| [6],v[7],v[8]); */ | | CGOFree(I->shaderCGO); |
| ok &= ray->sausage3fv(v + 3, v + 6, radius, v, v); | | |
| if (ok) | | |
| ok &= ray->sausage3fv(v + 9, v + 12, radius, v, v); | | |
| if (ok) | | |
| ok &= ray->sausage3fv(v + 15, v + 18, radius, v, v); | | |
| v += 21; | | |
| } | | } |
|
| ray->transparentf(0.0); | | if (ok){ |
| } else if(G->HaveGUI && G->ValidContext) { | | if (nonbonded_as_cylinders){ |
| if(pick) { | | CGO *tmpCGO = CGONew(G); |
| | if (ok) ok &= CGOEnable(tmpCGO, GL_CYLINDER_SHADER); |
| i = (*pick)->src.index; | | if (ok) ok &= CGOSpecial(tmpCGO, CYLINDER_WIDTH_FOR_REPWIRE); |
| | convertcgo = CGOConvertCrossesToCylinderShader(I->primitiveCGO, tmpCGO, |
| v = I->VP; | | nonbonded_size); |
| c = I->NP; | | if (ok) ok &= CGOAppendNoStop(tmpCGO, convertcgo); |
| p = I->R.P; | | if (ok) ok &= CGODisable(tmpCGO, GL_CYLINDER_SHADER); |
| #ifdef PURE_OPENGL_ES_2 | | if (ok) ok &= CGOStop(tmpCGO); |
| #else | | CGOFreeWithoutVBOs(convertcgo); |
| SceneSetupGLPicking(G); | | I->shaderCGO_has_cylinders = true; |
| glBegin(GL_LINES); | | convertcgo = tmpCGO; |
| while(c--) { | | } else { |
| i++; | | bool trilines = SettingGetGlobal_b(G, cSetting_trilines); |
| if(!(*pick)[0].src.bond) { | | CGO *tmpCGO = CGONew(G), *tmp2CGO; |
| /* pass 1 - low order bits */ | | int shader = trilines ? GL_TRILINES_SHADER : GL_LINE_SHADER; |
| glColor3ub((uchar) ((i & 0xF) << 4), (uchar) ((i & 0xF0) | 0x8), | | |
| (uchar) ((i & 0xF00) >> 4)); | | if (ok) ok &= CGOEnable(tmpCGO, shader); |
| VLACheck((*pick), Picking, i); | | if (ok) ok &= CGODisable(tmpCGO, CGO_GL_LIGHTING); |
| p++; | | if (trilines) { |
| (*pick)[i].src = *p; /* copy object and atom info */ | | if (ok) ok &= CGOSpecial(tmpCGO, LINEWIDTH_DYNAMIC_WITH_SCALE); |
| (*pick)[i].context = I->R.context; | | tmp2CGO = CGOConvertCrossesToTrilinesShader(I->primitiveCGO, tmpCGO, n |
| | onbonded_size); |
| } else { | | } else { |
|
| /* pass 2 - high order bits */ | | tmp2CGO = CGOConvertCrossesToLinesShader(I->primitiveCGO, tmpCGO, nonb |
| j = i >> 12; | | onded_size); |
| glColor3ub((uchar) ((j & 0xF) << 4), (uchar) ((j & 0xF0) | 0x8), | | |
| (uchar) ((j & 0xF00) >> 4)); | | |
| } | | } |
|
| | | if (ok) ok &= CGOAppendNoStop(tmpCGO, tmp2CGO); |
| glVertex3fv(v); | | if (ok) ok &= CGODisable(tmpCGO, shader); |
| v += 3; | | if (ok) ok &= CGOStop(tmpCGO); |
| glVertex3fv(v); | | CGOFreeWithoutVBOs(tmp2CGO); |
| v += 3; | | convertcgo = tmpCGO; |
| glVertex3fv(v); | | I->shaderCGO_has_cylinders = false; |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| } | | } |
|
| glEnd(); | | convertcgo->use_shader = true; |
| | } |
| | CHECKOK(ok, convertcgo); |
| | if (!ok || convertcgo){ |
| | CGOFree(I->shaderCGO); |
| | I->shaderCGO = convertcgo; |
| | I->shaderCGO->use_shader = use_shader; |
| | convertcgo = NULL; |
| | } |
| | } else { |
| | // no shaders |
| | convertcgo = CGOCombineBeginEnd(I->shaderCGO, 0); |
| | CGOFree(I->shaderCGO); |
| | I->shaderCGO = convertcgo; |
| | I->shaderCGO->use_shader = use_shader; |
| | convertcgo = NULL; |
| | } |
| | return ok; |
| | } |
| | |
| | static void RepNonbondedRender(RepNonbonded * I, RenderInfo * info) |
| | { |
| | CRay *ray = info->ray; |
| | Picking **pick = info->pick; |
| | PyMOLGlobals *G = I->R.G; |
| | int ok = true; |
| | float alpha = |
| | SettingGet_f(G, I->R.cs->Setting, I->R.obj->Setting, cSetting_nonbonded_tran |
| | sparency); |
| | alpha = 1.0F - alpha; |
| | if(fabs(alpha - 1.0) < R_SMALL4) |
| | alpha = 1.0F; |
| | if(ray) { |
| | #ifndef _PYMOL_NO_RAY |
| | CGORenderRay(I->primitiveCGO, ray, info, NULL, NULL, I->R.cs->Setting, I->R. |
| | cs->Obj->Obj.Setting); |
| | ray->transparentf(0.0); |
| #endif | | #endif |
|
| (*pick)[0].src.index = i; | | } else if(G->HaveGUI && G->ValidContext) { |
| | if(pick) { |
| | CGORenderGLPicking(I->shaderCGO ? I->shaderCGO : I->primitiveCGO, info, &I |
| | ->R.context, I->R.cs->Setting, I->R.obj->Setting); |
| } else { | | } else { |
| /* not pick, but render */ | | /* not pick, but render */ |
|
| short use_shader, generate_shader_cgo = 0; | | bool use_shader = SettingGetGlobal_b(G, cSetting_nonbonded_use_shader) && |
| short nonbonded_as_cylinders ; | | SettingGetGlobal_b(G, cSetting_use_shaders); |
| int nvidia_bugs = SettingGetGlobal_i(G, cSetting_nvidia_bugs); | | if (!use_shader){ |
| use_shader = SettingGetGlobal_b(G, cSetting_nonbonded_use_shader) & | | CGORenderGL(I->primitiveCGO, NULL, NULL, NULL, info, &I->R); |
| SettingGetGlobal_b(G, cSetting_use_shaders); | | return; |
| nonbonded_as_cylinders = SettingGetGlobal_b(G, cSetting_render_as_cylinder | | |
| s) && SettingGetGlobal_b(G, cSetting_nonbonded_as_cylinders); | | |
| if (!use_shader && I->shaderCGO){ | | |
| CGOFree(I->shaderCGO); | | |
| I->shaderCGO = 0; | | |
| } | | } |
|
| | | bool nonbonded_as_cylinders = SettingGetGlobal_b(G, cSetting_render_as_cyl |
| if (I->shaderCGO && (nonbonded_as_cylinders ^ I->shaderCGO->has_draw_cylin | | inders) && SettingGetGlobal_b(G, cSetting_nonbonded_as_cylinders); |
| der_buffers)){ | | if (I->shaderCGO && use_shader != I->shaderCGO->use_shader){ |
| CGOFree(I->shaderCGO); | | CGOFree(I->shaderCGO); |
| I->shaderCGO = 0; | | I->shaderCGO = 0; |
| } | | } |
| | |
|
| if (use_shader){ | | if (I->shaderCGO && (nonbonded_as_cylinders ^ I->shaderCGO_has_cylinders)) |
| if (!I->shaderCGO){ | | { |
| I->shaderCGO = CGONew(G); | | CGOFree(I->shaderCGO); |
| CHECKOK(ok, I->shaderCGO); | | I->shaderCGO = 0; |
| if (ok){ | | |
| I->shaderCGO->use_shader = true; | | |
| generate_shader_cgo = 1; | | |
| } | | |
| } else { | | |
| CShaderPrg *shaderPrg; | | |
| if (nonbonded_as_cylinders){ | | |
| // vertex scale is bound so that cylinders cannot disappear when it g | | |
| ets too low | | |
| float pixel_scale_value = SettingGetGlobal_f(G, cSetting_ray_pixel_sc | | |
| ale); | | |
| if(pixel_scale_value < 0) | | |
| pixel_scale_value = 1.0F; | | |
| shaderPrg = CShaderPrg_Enable_CylinderShader(G); | | |
| if (!shaderPrg) return; | | |
| CShaderPrg_Set1f(shaderPrg, "uni_radius", info->vertex_scale * pixel_ | | |
| scale_value * I->Width/ 2.f); | | |
| } else { | | |
| shaderPrg = CShaderPrg_Enable_DefaultShader(G); | | |
| if (!shaderPrg) return; | | |
| CShaderPrg_SetLightingEnabled(shaderPrg, 0); | | |
| } | | |
| | |
| CGORenderGL(I->shaderCGO, NULL, NULL, NULL, info, &I->R); | | |
| | |
| CShaderPrg_Disable(shaderPrg); | | |
| return; | | |
| } | | |
| } | | } |
| | |
|
| v = I->V; | | if (!I->shaderCGO){ |
| c = I->N; | | I->shaderCGO = CGONew(G); |
| if (ok && generate_shader_cgo){ | | CHECKOK(ok, I->shaderCGO); |
| ok &= CGOLinewidthSpecial(I->shaderCGO, LINEWIDTH_WITH_SCALE); | | if (ok){ |
| if(ok && !info->line_lighting) | | I->shaderCGO->use_shader = use_shader; |
| ok &= CGODisable(I->shaderCGO, GL_LIGHTING); | | |
| if (nonbonded_as_cylinders){ | | |
| if(ok && c) { | | |
| float *origin, axis[3]; | | |
| ok &= CGOResetNormal(I->shaderCGO, true); | | |
| while(ok && c--) { | | |
| if(alpha == 1.0) { | | |
| ok &= CGOColorv(I->shaderCGO, v); | | |
| } else { | | |
| ok &= CGOAlpha(I->shaderCGO, alpha); | | |
| if (ok) | | |
| ok &= CGOColorv(I->shaderCGO, v); | | |
| } | | |
| if (ok){ | | |
| v += 3; | | |
| origin = v; | | |
| v += 3; | | |
| axis[0] = v[0] - origin[0]; | | |
| axis[1] = v[1] - origin[1]; | | |
| axis[2] = v[2] - origin[2]; | | |
| ok &= CGOShaderCylinder(I->shaderCGO, origin, axis, 1.f, 15); | | |
| } | | |
| if (ok){ | | |
| v += 3; | | |
| origin = v; | | |
| v += 3; | | |
| axis[0] = v[0] - origin[0]; | | |
| axis[1] = v[1] - origin[1]; | | |
| axis[2] = v[2] - origin[2]; | | |
| ok &= CGOShaderCylinder(I->shaderCGO, origin, axis, 1.f, 15); | | |
| } | | |
| if (ok){ | | |
| v += 3; | | |
| origin = v; | | |
| v += 3; | | |
| axis[0] = v[0] - origin[0]; | | |
| axis[1] = v[1] - origin[1]; | | |
| axis[2] = v[2] - origin[2]; | | |
| ok &= CGOShaderCylinder(I->shaderCGO, origin, axis, 1.f, 15); | | |
| v += 3; | | |
| } | | |
| } | | |
| } | | |
| } else { | | |
| if(ok && c) { | | |
| ok &= CGOBegin(I->shaderCGO, GL_LINES); | | |
| if (ok) | | |
| ok &= CGOResetNormal(I->shaderCGO, true); | | |
| while(ok && c--) { | | |
| if(alpha == 1.0) { | | |
| ok &= CGOColorv(I->shaderCGO, v); | | |
| } else { | | |
| ok &= CGOAlpha(I->shaderCGO, alpha); | | |
| if (ok) | | |
| ok &= CGOColorv(I->shaderCGO, v); | | |
| } | | |
| v += 3; | | |
| if (ok){ | | |
| ok &= CGOVertexv(I->shaderCGO, v); | | |
| v += 3; | | |
| } | | |
| if (ok){ | | |
| ok &= CGOVertexv(I->shaderCGO, v); | | |
| v += 3; | | |
| } | | |
| if (ok){ | | |
| ok &= CGOVertexv(I->shaderCGO, v); | | |
| v += 3; | | |
| } | | |
| if (ok){ | | |
| ok &= CGOVertexv(I->shaderCGO, v); | | |
| v += 3; | | |
| } | | |
| if (ok){ | | |
| ok &= CGOVertexv(I->shaderCGO, v); | | |
| v += 3; | | |
| } | | |
| if (ok){ | | |
| ok &= CGOVertexv(I->shaderCGO, v); | | |
| v += 3; | | |
| } | | |
| } | | |
| if (ok) | | |
| ok &= CGOEnd(I->shaderCGO); | | |
| } | | |
| } | | |
| if(ok && !info->line_lighting) | | |
| ok &= CGOEnable(I->shaderCGO, GL_LIGHTING); | | |
| } else { | | |
| if(info->width_scale_flag) | | |
| glLineWidth(I->Width * info->width_scale); | | |
| else | | |
| glLineWidth(I->Width); | | |
| | |
| if(SettingGetGlobal_i(G, cSetting_ati_bugs)) { | | |
| glFlush(); /* eliminate ATI artifacts under VISTA */ | | |
| } | | |
| if(c) { | | |
| if(!info->line_lighting) | | |
| glDisable(GL_LIGHTING); | | |
| glBegin(GL_LINES); | | |
| SceneResetNormal(G, true); | | |
| while(c--) { | | |
| if(alpha == 1.0) { | | |
| glColor3fv(v); | | |
| } else { | | |
| glColor4f(v[0], v[1], v[2], alpha); | | |
| } | | |
| v += 3; | | |
| if(nvidia_bugs) { | | |
| glFlush(); | | |
| } | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| glVertex3fv(v); | | |
| v += 3; | | |
| } | | |
| glEnd(); | | |
| glEnable(GL_LIGHTING); | | |
| } | | } |
|
| | ok &= RepNonbondedCGOGenerate(I, info); |
| } | | } |
|
| | | CGORenderGL(I->shaderCGO, NULL, NULL, NULL, info, &I->R); |
| if (use_shader) { | | |
| if (generate_shader_cgo){ | | |
| CGO *convertcgo = NULL; | | |
| if (ok) | | |
| ok &= CGOStop(I->shaderCGO); | | |
| if (ok && I->shaderCGO){ | | |
| convertcgo = CGOCombineBeginEnd(I->shaderCGO, 0); | | |
| CGOFree(I->shaderCGO); | | |
| I->shaderCGO = convertcgo; | | |
| convertcgo = NULL; | | |
| } | | |
| if (ok){ | | |
| if (nonbonded_as_cylinders){ | | |
| convertcgo = CGOOptimizeGLSLCylindersToVBOIndexed(I->shaderCGO, 0); | | |
| } else { | | |
| convertcgo = CGOOptimizeToVBONotIndexed(I->shaderCGO, 0); | | |
| } | | |
| CHECKOK(ok, convertcgo); | | |
| } | | |
| if (!ok || convertcgo){ | | |
| CGOFree(I->shaderCGO); | | |
| I->shaderCGO = convertcgo; | | |
| convertcgo = NULL; | | |
| } | | |
| } | | |
| | |
| if (ok){ | | |
| CShaderPrg *shaderPrg; | | |
| if (nonbonded_as_cylinders){ | | |
| // vertex scale is bound so that cylinders cannot disappear when it g | | |
| ets too low | | |
| float pixel_scale_value = SettingGetGlobal_f(G, cSetting_ray_pixel_sc | | |
| ale); | | |
| if(pixel_scale_value < 0) | | |
| pixel_scale_value = 1.0F; | | |
| shaderPrg = CShaderPrg_Enable_CylinderShader(G); | | |
| if (!shaderPrg) return; | | |
| CShaderPrg_Set1f(shaderPrg, "uni_radius", info->vertex_scale * pixel_ | | |
| scale_value * I->Width/ 2.f); | | |
| } else { | | |
| shaderPrg = CShaderPrg_Enable_DefaultShader(G); | | |
| if (!shaderPrg) return; | | |
| CShaderPrg_SetLightingEnabled(shaderPrg, 0); | | |
| } | | |
| CGORenderGL(I->shaderCGO, NULL, NULL, NULL, info, &I->R); | | |
| CShaderPrg_Disable(shaderPrg); | | |
| } else { | | |
| /* not OK, then destroy RepNonbonded object */ | | |
| I->R.fInvalidate(&I->R, I->R.cs, cRepInvPurge); | | |
| I->R.cs->Active[cRepNonbonded] = false; | | |
| } | | |
| } | | |
| } | | } |
| } | | } |
| } | | } |
| | |
| Rep *RepNonbondedNew(CoordSet * cs, int state) | | Rep *RepNonbondedNew(CoordSet * cs, int state) |
| { | | { |
| PyMOLGlobals *G = cs->State.G; | | PyMOLGlobals *G = cs->State.G; |
|
| ObjectMolecule *obj; | | bool hasNonbondedAtoms = false; |
| int a, a1, c1; | | |
| float nonbonded_size; | | |
| float *v, *v0, *v1; | | |
| int *active; | | |
| AtomInfoType *ai; | | |
| int nAtom = 0; | | |
| float tmpColor[3]; | | |
| OOAlloc(G, RepNonbonded); | | OOAlloc(G, RepNonbonded); |
|
| obj = cs->Obj; | | |
| | |
|
| active = Alloc(int, cs->NIndex); | | ObjectMolecule *obj = cs->Obj; |
| if((obj->RepVisCache & cRepNonbondedBit)) | | |
| for(a = 0; a < cs->NIndex; a++) { | | if((obj->RepVisCache & cRepNonbondedBit)){ |
| ai = obj->AtomInfo + cs->IdxToAtm[a]; | | for(int a = 0; a < cs->NIndex; a++) { |
| active[a] = (!ai->bonded && (ai->visRep & cRepNonbondedBit)); | | AtomInfoType *ai = obj->AtomInfo + cs->IdxToAtm[a]; |
| if(active[a]) { | | if (!ai->bonded && (ai->visRep & cRepNonbondedBit)){ |
| active[a] = (ai->masked) ? -1 : 1; | | hasNonbondedAtoms = true; |
| nAtom++; | | break; |
| } | | } |
| } | | } |
|
| if(!nAtom) { | | } |
| | if(!hasNonbondedAtoms) { |
| OOFreeP(I); | | OOFreeP(I); |
|
| FreeP(active); | | |
| return (NULL); /* skip if no dots are visible */ | | return (NULL); /* skip if no dots are visible */ |
| } | | } |
| | |
|
| nonbonded_size = | | |
| SettingGet_f(G, cs->Setting, obj->Obj.Setting, cSetting_nonbonded_size); | | |
| RepInit(G, &I->R); | | RepInit(G, &I->R); |
| | |
| I->R.fRender = (void (*)(struct Rep *, RenderInfo *)) RepNonbondedRender; | | I->R.fRender = (void (*)(struct Rep *, RenderInfo *)) RepNonbondedRender; |
| I->R.fFree = (void (*)(struct Rep *)) RepNonbondedFree; | | I->R.fFree = (void (*)(struct Rep *)) RepNonbondedFree; |
|
| | | I->R.fRecolor = NULL; |
| I->shaderCGO = NULL; | | I->shaderCGO = NULL; |
|
| I->N = 0; | | |
| I->NP = 0; | | |
| I->V = NULL; | | |
| I->VP = NULL; | | |
| I->R.P = NULL; | | I->R.P = NULL; |
|
| I->R.fRecolor = NULL; | | |
| I->R.obj = (CObject *) (cs->Obj); | | I->R.obj = (CObject *) (cs->Obj); |
| I->R.cs = cs; | | I->R.cs = cs; |
| | |
|
| I->Width = SettingGet_f(G, cs->Setting, obj->Obj.Setting, cSetting_line_width) | | I->primitiveCGO = CGONew(G); |
| ; | | |
| I->Radius = SettingGet_f(G, cs->Setting, obj->Obj.Setting, cSetting_line_radiu | | |
| s); | | |
| I->V = (float *) mmalloc(sizeof(float) * nAtom * 21); | | |
| ErrChkPtr(G, I->V); | | |
| v = I->V; | | |
| for(a = 0; a < cs->NIndex; a++) | | |
| if(active[a]) { | | |
| c1 = (obj->AtomInfo + cs->IdxToAtm[a])->color; | | |
| | |
|
| | CGOSpecialWithArg(I->primitiveCGO, LINE_LIGHTING, 0.f); |
| | CGOSpecial(I->primitiveCGO, LINEWIDTH_FOR_LINES); |
| | CGOBegin(I->primitiveCGO, GL_LINES); // for immediate mode |
| | bool first = true; |
| | float *v1; |
| | int a1, c1; |
| | float tmpColor[3]; |
| | for(int a = 0; a < cs->NIndex; a++){ |
| | a1 = cs->IdxToAtm[a]; |
| | AtomInfoType *ai = obj->AtomInfo + a1; |
| | if(!ai->bonded && (ai->visRep & cRepNonbondedBit)) { |
| | c1 = ai->color; |
| v1 = cs->Coord + 3 * a; | | v1 = cs->Coord + 3 * a; |
|
| | | ColorGetCheckRamped(G, c1, v1, tmpColor, state); |
| if(ColorCheckRamped(G, c1)) { | | if (first || !equal3f(I->primitiveCGO->color, tmpColor)){ |
| ColorGetRamped(G, c1, v1, tmpColor, state); | | CGOColorv(I->primitiveCGO, tmpColor); |
| v0 = tmpColor; | | |
| } else { | | |
| v0 = ColorGet(G, c1); | | |
| } | | } |
|
| | | CGOPickColor(I->primitiveCGO, a1, (ai->masked) ? cPickableNoPick : cPickab |
| *(v++) = *(v0++); | | leAtom); |
| *(v++) = *(v0++); | | CGOVertexCrossv(I->primitiveCGO, v1); |
| *(v++) = *(v0++); | | first = false; |
| | |
| *(v++) = v1[0] - nonbonded_size; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0] + nonbonded_size; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1] - nonbonded_size; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1] + nonbonded_size; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2] - nonbonded_size; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2] + nonbonded_size; | | |
| I->N++; | | |
| } | | } |
|
| I->V = ReallocForSure(I->V, float, (v - I->V)); | | } |
| | CGOEnd(I->primitiveCGO); // for immediate mode |
| /* now create pickable verson */ | | CGOSpecialWithArg(I->primitiveCGO, LINE_LIGHTING, 1.f); |
| | |
| if(SettingGet_f(G, cs->Setting, obj->Obj.Setting, cSetting_pickable)) { | | |
| I->VP = (float *) mmalloc(sizeof(float) * nAtom * 21); | | |
| ErrChkPtr(G, I->VP); | | |
| | |
| I->R.P = Alloc(Pickable, cs->NIndex + 1); | | |
| ErrChkPtr(G, I->R.P); | | |
| | |
| v = I->VP; | | |
| | |
| for(a = 0; a < cs->NIndex; a++) | | |
| if(active[a] > 0) { | | |
| | |
| a1 = cs->IdxToAtm[a]; | | |
| | |
| if(!obj->AtomInfo[a1].masked) { | | |
| I->NP++; | | |
| I->R.P[I->NP].index = a1; | | |
| I->R.P[I->NP].bond = -1; | | |
| v1 = cs->Coord + 3 * a; | | |
| | |
| *(v++) = v1[0] - nonbonded_size; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0] + nonbonded_size; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1] - nonbonded_size; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1] + nonbonded_size; | | |
| *(v++) = v1[2]; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2] - nonbonded_size; | | |
| | |
| *(v++) = v1[0]; | | |
| *(v++) = v1[1]; | | |
| *(v++) = v1[2] + nonbonded_size; | | |
| } | | |
| } | | |
| I->R.P = Realloc(I->R.P, Pickable, I->NP + 1); | | |
| I->R.context.object = (void *) obj; | | I->R.context.object = (void *) obj; |
| I->R.context.state = state; | | I->R.context.state = state; |
|
| I->R.P[0].index = I->NP; | | |
| I->VP = ReallocForSure(I->VP, float, (v - I->VP)); | | |
| } | | |
| FreeP(active); | | |
| return (Rep *) I; | | return (Rep *) I; |
| } | | } |
| | | |
| End of changes. 37 change blocks. |
|---|
| 436 lines changed or deleted | | 149 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 