xyz2pov/src/pov_writer.c

#define _FILE_OFFSET_BITS 64

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>

#include "pov_writer.h"
#include "atom_parser.h"

struct bond{
  int i;
  int j;
};

struct linked_bond_list{
  struct bond the_bond;
  struct linked_bond_list *next;
};

void make_bonds(struct coords *, int);

struct linked_bond_list *bl_head;
  
void clean_bonds(void);

void initBondList(void){
  bl_head = NULL;
}

void pov_write(FILE *out_file, struct coords *the_coords, int n_atoms,
               int d_hydrogens, int d_bonds, int d_atoms, int d_vectors){

  int i,j; /*loop counters */
  int skip_atom, skip_bond, test1, test2; /*booleans */
  double dx, dy, dz; /* used in making the bonds */
  
  struct linked_bond_list *current_bond; /*keeps track of the linked list*/

  for(i = 0; i < n_atoms; i++){
    update_types(the_coords[i].name);
  }  
  
  if(d_atoms){
    
    fprintf(out_file,
            "//************************************************************\n"
            "// The list of atoms\n"
            "//************************************************************\n"
            "\n"
            "\n");
    
    for(i = 0; i < n_atoms; i++){
      
      skip_atom = 0;     
      
      if(!d_hydrogens){
        skip_atom = !strcmp("H", the_coords[i].name);
      }
      
      if(!skip_atom){          
        
        fprintf(out_file, 
                "make_%s_atom( %lf, %lf, %lf )\n",
                the_coords[i].name,
                the_coords[i].x,
                the_coords[i].z,
                the_coords[i].y);
      }
    }

    fprintf(out_file,
            "\n"
            "\n");
  }

      
  if (d_vectors) {

    fprintf(out_file,
            "//************************************************************\n"
            "// The list of vectors\n"
            "//************************************************************\n"
            "\n"
            "\n");
    
    for(i = 0; i < n_atoms; i++){
      
      if (the_coords[i].hasVector) {
        fprintf(out_file,
                "make_%s_vector(%lf, %lf, %lf, %lf, %lf, %lf)\n",
                the_coords[i].name,
                the_coords[i].x,
                the_coords[i].z,
                the_coords[i].y,
                the_coords[i].ux,
                the_coords[i].uz,
                the_coords[i].uy);
      }
    }
    
    fprintf(out_file,
            "\n"
            "\n");
  }
      
  if(d_bonds){
    
    fprintf(out_file,
            "//************************************************************\n"
            "// The list of bonds\n"
            "//************************************************************\n"
            "\n"
            "\n");
    
    if( bl_head == NULL ) make_bonds(the_coords, n_atoms);
    
    current_bond = bl_head->next;
    
    while(current_bond != NULL){
      
      skip_bond = 0;
      
      i = current_bond->the_bond.i;
      j = current_bond->the_bond.j;
      
      if(!d_hydrogens){

        test1 = !strcmp("H", the_coords[i].name);
        test2 = !strcmp("H", the_coords[j].name);

        skip_bond = (test1 || test2);
      }

      if(!skip_bond){
        
        dx = (the_coords[j].x - the_coords[i].x) / 2.0;
        dy = (the_coords[j].y - the_coords[i].y) / 2.0;
        dz = (the_coords[j].z - the_coords[i].z) / 2.0;
        
        fprintf(out_file,
               "make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
               the_coords[i].name,
               the_coords[i].x,
               the_coords[i].z,
               the_coords[i].y,
               (the_coords[i].x + dx),
               (the_coords[i].z + dz),
               (the_coords[i].y + dy));
        
        fprintf(out_file,
               "make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
               the_coords[j].name,
               the_coords[j].x,
               the_coords[j].z,
               the_coords[j].y,
               (the_coords[j].x - dx),
               (the_coords[j].z - dz),
               (the_coords[j].y - dy));

        fprintf(out_file, "\n");
      }
      
      current_bond = current_bond->next;
    }
  
    if( regenerateBonds )clean_bonds();
  }
}


void make_bonds(struct coords *the_coords, int n_atoms){
  
  int i, j; /*counters */
  struct linked_bond_list *temp_bond; /*bond place holder */
  
  const double bond_fudge = 1.12; // a fudge factor
  struct atom type_i, type_j; /* holds the atom types */

  int test; /* booleans */
  double dx, dy, dz, dr2, dcv, dcv2; // used to determine bond existence 

  
  bl_head = (struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
  bl_head->next = NULL;

  for(i = 0; i < (n_atoms - 1); i++){
    
    for(j = (i+1); j < n_atoms; j++){
      
      dx = the_coords[j].x - the_coords[i].x;
      dy = the_coords[j].y - the_coords[i].y;
      dz = the_coords[j].z - the_coords[i].z;
      
      dr2 = dx * dx + dy * dy + dz * dz;
      
      test = !findAtomType(the_coords[i].name, &type_i);
      if(test){
        fprintf(stderr, "Atom Type %s, not found!\n",
                the_coords[i].name);
        exit(8);
      }

      test = !findAtomType(the_coords[j].name, &type_j);
      if(test){
        fprintf(stderr, "Atom Type %s, not found!\n",
                the_coords[j].name);
        exit(8);
      }
      
      
      dcv = bond_fudge * (type_i.covalentRadii + type_j.covalentRadii);
      dcv2 = dcv * dcv;

      if(dr2 <= dcv2){
        
        temp_bond = 
          (struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
        
        bl_head->the_bond.i = i;
        bl_head->the_bond.j = j;
        
        temp_bond->next = bl_head;
        bl_head = temp_bond;
      }
    }
  }
}
        

void clean_bonds(){
  struct linked_bond_list *current_bond;
  struct linked_bond_list *next_bond; /* place holders */
  

    current_bond = bl_head->next;

    while(current_bond != NULL){

      next_bond = current_bond->next;
      free(current_bond);
      current_bond = next_bond;
    }
    
    bl_head->next = NULL;
    free( bl_head );
    bl_head = NULL;
}


void make_header_macros(FILE *out_file){

  struct linked_atom *type_list;  // list of all atom types
  struct linked_atom *current_type; // current atom type

  char *name;
  double red, green, blue;
  double radius;
  
  type_list = get_type_list();
  current_type = type_list->next;
  
  while(current_type != NULL){
    
    name = current_type->myAtom.name;
    radius = current_type->myAtom.vanDerWallRadii;
    red = ((double)current_type->myAtom.red) / 255.0;
    green =  ((double)current_type->myAtom.green) / 255.0;
    blue =  ((double)current_type->myAtom.blue) / 255.0;

    
    fprintf(out_file,
            "//****************************************************\n"
            "// DEFINE %s MACROS\n" 
            "//****************************************************\n"
            "\n"
            "#macro make_%s_bond "
            "(end_1x, end_1y, end_1z, end_2x, end_2y, end_2z)\n"
            "\n"
            "  #local x1 = end_1x;\n"
            "  #local y1 = end_1y;\n"
            "  #local z1 = end_1z;\n"
            "  #local x2 = end_2x;\n"
            "  #local y2 = end_2y;\n"
            "  #local z2 = end_2z;\n"
            "\n"
            "  #if(ROTATE)\n"
            "    #local x1_new = rotatePointX + A11 * (x1-rotatePointX) + A12 * (y1-rotatePointY) + A13 * (z1-rotatePointZ);\n"
            "    #local y1_new = rotatePointY + A21 * (x1-rotatePointX) + A22 * (y1-rotatePointY) + A23 * (z1-rotatePointZ);\n"
            "    #local z1_new = rotatePointZ + A31 * (x1-rotatePointX) + A32 * (y1-rotatePointY) + A33 * (z1-rotatePointZ);\n"
            "\n"
            "    #local x2_new = rotatePointX + A11 * (x2-rotatePointX) + A12 * (y2-rotatePointY) + A13 * (z2-rotatePointZ);\n"
            "    #local y2_new = rotatePointY + A21 * (x2-rotatePointX) + A22 * (y2-rotatePointY) + A23 * (z2-rotatePointZ);\n"
            "    #local z2_new = rotatePointZ + A31 * (x2-rotatePointX) + A32 * (y2-rotatePointY) + A33 * (z2-rotatePointZ);\n"
            "\n"
            "  #else\n"
            "    #local x1_new = x1;"
            "    #local y1_new = y1;"
            "    #local z1_new = z1;"
            "\n"
            "    #local x2_new = x2;"
            "    #local y2_new = y2;"
            "    #local z2_new = z2;"
            "\n"
            "  #end\n"
            "\n"
            "  cylinder{\n"
            "    < x1_new, y1_new, z1_new >,\n"
            "    < x2_new, y2_new, z2_new >,\n"
            "    BOND_RADIUS\n"
            "    texture{\n"
            "      pigment{ rgb < %lf, %lf, %lf > }\n"
            "      finish{\n"
            "        ambient .2\n"
            "        diffuse .6\n"
            "        specular 1\n"
            "        roughness .001\n"
            "        metallic\n"
            "      }\n"
            "    }\n"
            "  }\n"
            "#end\n"
            "#macro make_%s_atom "
            "(center_x, center_y, center_z)\n"
                    "\n"
            "  #local x1 = center_x;\n"
            "  #local y1 = center_y;\n"
            "  #local z1 = center_z;\n"
            "\n"
            "  #if(ROTATE)\n"
            "\n"
            "    #local x1_new = rotatePointX + A11 * (x1-rotatePointX) + A12 * (y1-rotatePointY) + A13 * (z1-rotatePointZ);\n"
            "    #local y1_new = rotatePointY + A21 * (x1-rotatePointX) + A22 * (y1-rotatePointY) + A23 * (z1-rotatePointZ);\n"
            "    #local z1_new = rotatePointZ + A31 * (x1-rotatePointX) + A32 * (y1-rotatePointY) + A33 * (z1-rotatePointZ);\n"
            "\n"
            "  #else\n"
            "\n"
            "    #local x1_new = x1;"
            "    #local y1_new = y1;"
            "    #local z1_new = z1;"
            "\n"
            "  #end\n"
            "\n"
            "  sphere{\n"
            "    < x1_new, y1_new, z1_new >,\n"
            "    ATOM_SPHERE_FACTOR * %lf\n"
            "    texture{\n"
            "      pigment{ rgb < %lf, %lf, %lf > }\n"
            "      finish{\n"
            "        ambient .2\n"
            "        diffuse .6\n"
            "        specular 1\n"
            "        roughness .001\n"
            "        metallic\n"
            "      }\n"
            "    }\n"
            "  }\n"
            "#end\n"
            "#macro make_%s_vector "
            "(center_x, center_y, center_z, ux, uy, uz)\n"
            "\n"
            "  #local vx = VECTOR_SCALE * ux;\n"
            "  #local vy = VECTOR_SCALE * uy;\n"
            "  #local vz = VECTOR_SCALE * uz;\n"
            "  #local x1 = center_x - 0.5 * vx;\n"
            "  #local y1 = center_y - 0.5 * vy;\n"
            "  #local z1 = center_z - 0.5 * vz;\n"
            "  #local x2 = center_x + 0.5 * vx;\n"
            "  #local y2 = center_y + 0.5 * vy;\n"
            "  #local z2 = center_z + 0.5 * vz;\n"
            "  #local v2 = vx*vx + vy*vy + vz*vz;\n"
            "  #local vl  = sqrt(v2);\n"
            "  #local x3 = x1 + vx * (1.0 - CONE_FRACTION);\n"
            "  #local y3 = y1 + vy * (1.0 - CONE_FRACTION);\n"
            "  #local z3 = z1 + vz * (1.0 - CONE_FRACTION);\n"
            "\n"
            "  #if(ROTATE)\n"
            "    #local x1_new = rotatePointX + A11 * (x1-rotatePointX) + A12 * (y1-rotatePointY) + A13 * (z1-rotatePointZ);\n"
            "    #local y1_new = rotatePointY + A21 * (x1-rotatePointX) + A22 * (y1-rotatePointY) + A23 * (z1-rotatePointZ);\n"
            "    #local z1_new = rotatePointZ + A31 * (x1-rotatePointX) + A32 * (y1-rotatePointY) + A33 * (z1-rotatePointZ);\n"
            "\n"
            "    #local x2_new = rotatePointX + A11 * (x2-rotatePointX) + A12 * (y2-rotatePointY) + A13 * (z2-rotatePointZ);\n"
            "    #local y2_new = rotatePointY + A21 * (x2-rotatePointX) + A22 * (y2-rotatePointY) + A23 * (z2-rotatePointZ);\n"
            "    #local z2_new = rotatePointZ + A31 * (x2-rotatePointX) + A32 * (y2-rotatePointY) + A33 * (z2-rotatePointZ);\n"
            "\n"
            "    #local x3_new = rotatePointX + A11 * (x3-rotatePointX) + A12 * (y3-rotatePointY) + A13 * (z3-rotatePointZ);\n"
            "    #local y3_new = rotatePointY + A21 * (x3-rotatePointX) + A22 * (y3-rotatePointY) + A23 * (z3-rotatePointZ);\n"
            "    #local z3_new = rotatePointZ + A31 * (x3-rotatePointX) + A32 * (y3-rotatePointY) + A33 * (z3-rotatePointZ);\n"
            "\n"
            "  #else\n"
            "    #local x1_new = x1;"
            "    #local y1_new = y1;"
            "    #local z1_new = z1;"
            "\n"
            "    #local x2_new = x2;"
            "    #local y2_new = y2;"
            "    #local z2_new = z2;"
            "\n"
            "    #local x3_new = x3;"
            "    #local y3_new = y3;"
            "    #local z3_new = z3;"
            "\n"
            "  #end\n"
            "\n"
            "  cylinder{\n"
            "    < x1_new, y1_new, z1_new >,\n"
            "    < x3_new, y3_new, z3_new >,\n"
            "    STICK_RADIUS\n"
            "    texture{\n"
            "      pigment{ rgb < %lf, %lf, %lf > }\n"
            "      finish{\n"
            "        ambient .2\n"
            "        diffuse .6\n"
            "        specular 1\n"
            "        roughness .001\n"
            "        metallic\n"
            "      }\n"
            "    }\n"
            "  }\n"
            "  cone{\n"
            "    < x2_new, y2_new, z2_new >, 0.0\n"
            "    < x3_new, y3_new, z3_new >, CONE_RADIUS\n"
            "    texture{\n"
            "      pigment{ rgb < %lf, %lf, %lf > }\n"
            "      finish{\n"
            "        ambient .2\n"
            "        diffuse .6\n"
            "        specular 1\n"
            "        roughness .001\n"
            "        metallic\n"
            "      }\n"
            "    }\n"
            "  }\n"
            "#end\n"
            "\n"
            "\n",
            name,
            name,
            red, green, blue,
            name,
            radius,
            red, green, blue,
            name,
            red, green, blue,
            red, green, blue);
    
    current_type = current_type->next;
  }
}
Revision:	1095
Committed:	Mon Apr 5 19:34:21 2004 UTC (21 years, 7 months ago) by mmeineke
Content type:	text/plain
File size:	12545 byte(s)
Log Message:	more gcc friendly configure script who knows
#	User	Rev	Content
1	mmeineke	1095	#define _FILE_OFFSET_BITS 64
2
3	mmeineke	60	#include <stdio.h>
4			#include <stdlib.h>
5			#include <string.h>
6			#include <math.h>
7
8			#include "pov_writer.h"
9			#include "atom_parser.h"
10
11			struct bond{
12			int i;
13			int j;
14			};
15
16			struct linked_bond_list{
17			struct bond the_bond;
18			struct linked_bond_list *next;
19			};
20
21			void make_bonds(struct coords *, int);
22
23			struct linked_bond_list *bl_head;
24
25			void clean_bonds(void);
26
27	mmeineke	508	void initBondList(void){
28			bl_head = NULL;
29			}
30	mmeineke	60
31			void pov_write(FILE out_file, struct coords the_coords, int n_atoms,
32	gezelter	864	int d_hydrogens, int d_bonds, int d_atoms, int d_vectors){
33	mmeineke	60
34			int i,j; /loop counters /
35			int skip_atom, skip_bond, test1, test2; /booleans /
36			double dx, dy, dz; /* used in making the bonds */
37
38			struct linked_bond_list current_bond; /keeps track of the linked list*/
39
40			for(i = 0; i < n_atoms; i++){
41			update_types(the_coords[i].name);
42			}
43
44			if(d_atoms){
45
46			fprintf(out_file,
47			"//************************************************************\n"
48			"// The list of atoms\n"
49			"//************************************************************\n"
50			"\n"
51			"\n");
52	gezelter	864
53	mmeineke	60	for(i = 0; i < n_atoms; i++){
54
55	gezelter	864	skip_atom = 0;
56	mmeineke	60
57			if(!d_hydrogens){
58			skip_atom = !strcmp("H", the_coords[i].name);
59			}
60
61	gezelter	864	if(!skip_atom){
62
63	mmeineke	60	fprintf(out_file,
64			"make_%s_atom( %lf, %lf, %lf )\n",
65			the_coords[i].name,
66			the_coords[i].x,
67			the_coords[i].z,
68			the_coords[i].y);
69			}
70			}
71	gezelter	864
72	mmeineke	60	fprintf(out_file,
73			"\n"
74			"\n");
75	gezelter	864	}
76
77
78			if (d_vectors) {
79
80			fprintf(out_file,
81			"//************************************************************\n"
82			"// The list of vectors\n"
83			"//************************************************************\n"
84			"\n"
85			"\n");
86	mmeineke	60
87	gezelter	864	for(i = 0; i < n_atoms; i++){
88
89			if (the_coords[i].hasVector) {
90			fprintf(out_file,
91			"make_%s_vector(%lf, %lf, %lf, %lf, %lf, %lf)\n",
92			the_coords[i].name,
93			the_coords[i].x,
94			the_coords[i].z,
95			the_coords[i].y,
96			the_coords[i].ux,
97			the_coords[i].uz,
98			the_coords[i].uy);
99			}
100			}
101
102			fprintf(out_file,
103			"\n"
104			"\n");
105	mmeineke	60	}
106	gezelter	864
107	mmeineke	60	if(d_bonds){
108
109			fprintf(out_file,
110			"//************************************************************\n"
111			"// The list of bonds\n"
112			"//************************************************************\n"
113			"\n"
114			"\n");
115
116	mmeineke	508	if( bl_head == NULL ) make_bonds(the_coords, n_atoms);
117	mmeineke	60
118			current_bond = bl_head->next;
119
120			while(current_bond != NULL){
121
122			skip_bond = 0;
123
124			i = current_bond->the_bond.i;
125			j = current_bond->the_bond.j;
126
127			if(!d_hydrogens){
128
129			test1 = !strcmp("H", the_coords[i].name);
130			test2 = !strcmp("H", the_coords[j].name);
131
132			skip_bond = (test1 \|\| test2);
133			}
134
135			if(!skip_bond){
136
137			dx = (the_coords[j].x - the_coords[i].x) / 2.0;
138			dy = (the_coords[j].y - the_coords[i].y) / 2.0;
139			dz = (the_coords[j].z - the_coords[i].z) / 2.0;
140
141			fprintf(out_file,
142			"make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
143			the_coords[i].name,
144			the_coords[i].x,
145			the_coords[i].z,
146			the_coords[i].y,
147			(the_coords[i].x + dx),
148			(the_coords[i].z + dz),
149			(the_coords[i].y + dy));
150
151			fprintf(out_file,
152			"make_%s_bond( %lf, %lf, %lf, %lf, %lf, %lf )\n",
153			the_coords[j].name,
154			the_coords[j].x,
155			the_coords[j].z,
156			the_coords[j].y,
157			(the_coords[j].x - dx),
158			(the_coords[j].z - dz),
159			(the_coords[j].y - dy));
160
161			fprintf(out_file, "\n");
162			}
163
164			current_bond = current_bond->next;
165			}
166
167	mmeineke	508	if( regenerateBonds )clean_bonds();
168	mmeineke	60	}
169			}
170
171
172			void make_bonds(struct coords *the_coords, int n_atoms){
173
174			int i, j; /counters /
175			struct linked_bond_list temp_bond; /bond place holder */
176
177			const double bond_fudge = 1.12; // a fudge factor
178			struct atom type_i, type_j; /* holds the atom types */
179
180			int test; /* booleans */
181			double dx, dy, dz, dr2, dcv, dcv2; // used to determine bond existence
182
183
184			bl_head = (struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
185			bl_head->next = NULL;
186
187			for(i = 0; i < (n_atoms - 1); i++){
188
189			for(j = (i+1); j < n_atoms; j++){
190
191			dx = the_coords[j].x - the_coords[i].x;
192			dy = the_coords[j].y - the_coords[i].y;
193			dz = the_coords[j].z - the_coords[i].z;
194
195			dr2 = dx * dx + dy * dy + dz * dz;
196
197			test = !findAtomType(the_coords[i].name, &type_i);
198			if(test){
199			fprintf(stderr, "Atom Type %s, not found!\n",
200			the_coords[i].name);
201			exit(8);
202			}
203
204			test = !findAtomType(the_coords[j].name, &type_j);
205			if(test){
206			fprintf(stderr, "Atom Type %s, not found!\n",
207			the_coords[j].name);
208			exit(8);
209			}
210
211
212			dcv = bond_fudge * (type_i.covalentRadii + type_j.covalentRadii);
213			dcv2 = dcv * dcv;
214
215			if(dr2 <= dcv2){
216
217			temp_bond =
218			(struct linked_bond_list *)malloc(sizeof(struct linked_bond_list));
219
220			bl_head->the_bond.i = i;
221			bl_head->the_bond.j = j;
222
223			temp_bond->next = bl_head;
224			bl_head = temp_bond;
225			}
226			}
227			}
228			}
229
230
231			void clean_bonds(){
232			struct linked_bond_list *current_bond;
233			struct linked_bond_list next_bond; / place holders */
234
235
236			current_bond = bl_head->next;
237
238			while(current_bond != NULL){
239
240			next_bond = current_bond->next;
241			free(current_bond);
242			current_bond = next_bond;
243			}
244
245			bl_head->next = NULL;
246	mmeineke	508	free( bl_head );
247			bl_head = NULL;
248	mmeineke	60	}
249
250
251			void make_header_macros(FILE *out_file){
252
253			struct linked_atom *type_list; // list of all atom types
254			struct linked_atom *current_type; // current atom type
255
256			char *name;
257			double red, green, blue;
258			double radius;
259
260			type_list = get_type_list();
261			current_type = type_list->next;
262
263			while(current_type != NULL){
264
265			name = current_type->myAtom.name;
266			radius = current_type->myAtom.vanDerWallRadii;
267			red = ((double)current_type->myAtom.red) / 255.0;
268			green = ((double)current_type->myAtom.green) / 255.0;
269			blue = ((double)current_type->myAtom.blue) / 255.0;
270
271
272
273			fprintf(out_file,
274			"//****************************************************\n"
275			"// DEFINE %s MACROS\n"
276			"//****************************************************\n"
277			"\n"
278			"#macro make_%s_bond "
279			"(end_1x, end_1y, end_1z, end_2x, end_2y, end_2z)\n"
280			"\n"
281			" #local x1 = end_1x;\n"
282			" #local y1 = end_1y;\n"
283			" #local z1 = end_1z;\n"
284			" #local x2 = end_2x;\n"
285			" #local y2 = end_2y;\n"
286			" #local z2 = end_2z;\n"
287			"\n"
288			" #if(ROTATE)\n"
289	gezelter	868	" #local x1_new = rotatePointX + A11 * (x1-rotatePointX) + A12 * (y1-rotatePointY) + A13 * (z1-rotatePointZ);\n"
290			" #local y1_new = rotatePointY + A21 * (x1-rotatePointX) + A22 * (y1-rotatePointY) + A23 * (z1-rotatePointZ);\n"
291			" #local z1_new = rotatePointZ + A31 * (x1-rotatePointX) + A32 * (y1-rotatePointY) + A33 * (z1-rotatePointZ);\n"
292	mmeineke	60	"\n"
293	gezelter	868	" #local x2_new = rotatePointX + A11 * (x2-rotatePointX) + A12 * (y2-rotatePointY) + A13 * (z2-rotatePointZ);\n"
294			" #local y2_new = rotatePointY + A21 * (x2-rotatePointX) + A22 * (y2-rotatePointY) + A23 * (z2-rotatePointZ);\n"
295			" #local z2_new = rotatePointZ + A31 * (x2-rotatePointX) + A32 * (y2-rotatePointY) + A33 * (z2-rotatePointZ);\n"
296	mmeineke	60	"\n"
297			" #else\n"
298			" #local x1_new = x1;"
299			" #local y1_new = y1;"
300			" #local z1_new = z1;"
301			"\n"
302			" #local x2_new = x2;"
303			" #local y2_new = y2;"
304			" #local z2_new = z2;"
305			"\n"
306			" #end\n"
307			"\n"
308			" cylinder{\n"
309			" < x1_new, y1_new, z1_new >,\n"
310			" < x2_new, y2_new, z2_new >,\n"
311			" BOND_RADIUS\n"
312			" texture{\n"
313			" pigment{ rgb < %lf, %lf, %lf > }\n"
314			" finish{\n"
315			" ambient .2\n"
316			" diffuse .6\n"
317			" specular 1\n"
318			" roughness .001\n"
319			" metallic\n"
320			" }\n"
321			" }\n"
322			" }\n"
323			"#end\n"
324			"#macro make_%s_atom "
325			"(center_x, center_y, center_z)\n"
326			"\n"
327			" #local x1 = center_x;\n"
328			" #local y1 = center_y;\n"
329			" #local z1 = center_z;\n"
330			"\n"
331			" #if(ROTATE)\n"
332			"\n"
333	gezelter	868	" #local x1_new = rotatePointX + A11 * (x1-rotatePointX) + A12 * (y1-rotatePointY) + A13 * (z1-rotatePointZ);\n"
334			" #local y1_new = rotatePointY + A21 * (x1-rotatePointX) + A22 * (y1-rotatePointY) + A23 * (z1-rotatePointZ);\n"
335			" #local z1_new = rotatePointZ + A31 * (x1-rotatePointX) + A32 * (y1-rotatePointY) + A33 * (z1-rotatePointZ);\n"
336	mmeineke	60	"\n"
337			" #else\n"
338			"\n"
339			" #local x1_new = x1;"
340			" #local y1_new = y1;"
341			" #local z1_new = z1;"
342			"\n"
343			" #end\n"
344			"\n"
345			" sphere{\n"
346			" < x1_new, y1_new, z1_new >,\n"
347			" ATOM_SPHERE_FACTOR * %lf\n"
348			" texture{\n"
349			" pigment{ rgb < %lf, %lf, %lf > }\n"
350			" finish{\n"
351			" ambient .2\n"
352			" diffuse .6\n"
353			" specular 1\n"
354			" roughness .001\n"
355			" metallic\n"
356			" }\n"
357			" }\n"
358			" }\n"
359			"#end\n"
360	gezelter	864	"#macro make_%s_vector "
361			"(center_x, center_y, center_z, ux, uy, uz)\n"
362	mmeineke	60	"\n"
363	gezelter	864	" #local vx = VECTOR_SCALE * ux;\n"
364			" #local vy = VECTOR_SCALE * uy;\n"
365			" #local vz = VECTOR_SCALE * uz;\n"
366			" #local x1 = center_x - 0.5 * vx;\n"
367			" #local y1 = center_y - 0.5 * vy;\n"
368			" #local z1 = center_z - 0.5 * vz;\n"
369			" #local x2 = center_x + 0.5 * vx;\n"
370			" #local y2 = center_y + 0.5 * vy;\n"
371			" #local z2 = center_z + 0.5 * vz;\n"
372			" #local v2 = vxvx + vyvy + vz*vz;\n"
373			" #local vl = sqrt(v2);\n"
374			" #local x3 = x1 + vx * (1.0 - CONE_FRACTION);\n"
375			" #local y3 = y1 + vy * (1.0 - CONE_FRACTION);\n"
376			" #local z3 = z1 + vz * (1.0 - CONE_FRACTION);\n"
377			"\n"
378			" #if(ROTATE)\n"
379	gezelter	868	" #local x1_new = rotatePointX + A11 * (x1-rotatePointX) + A12 * (y1-rotatePointY) + A13 * (z1-rotatePointZ);\n"
380			" #local y1_new = rotatePointY + A21 * (x1-rotatePointX) + A22 * (y1-rotatePointY) + A23 * (z1-rotatePointZ);\n"
381			" #local z1_new = rotatePointZ + A31 * (x1-rotatePointX) + A32 * (y1-rotatePointY) + A33 * (z1-rotatePointZ);\n"
382	gezelter	864	"\n"
383	gezelter	868	" #local x2_new = rotatePointX + A11 * (x2-rotatePointX) + A12 * (y2-rotatePointY) + A13 * (z2-rotatePointZ);\n"
384			" #local y2_new = rotatePointY + A21 * (x2-rotatePointX) + A22 * (y2-rotatePointY) + A23 * (z2-rotatePointZ);\n"
385			" #local z2_new = rotatePointZ + A31 * (x2-rotatePointX) + A32 * (y2-rotatePointY) + A33 * (z2-rotatePointZ);\n"
386	gezelter	864	"\n"
387	gezelter	868	" #local x3_new = rotatePointX + A11 * (x3-rotatePointX) + A12 * (y3-rotatePointY) + A13 * (z3-rotatePointZ);\n"
388			" #local y3_new = rotatePointY + A21 * (x3-rotatePointX) + A22 * (y3-rotatePointY) + A23 * (z3-rotatePointZ);\n"
389			" #local z3_new = rotatePointZ + A31 * (x3-rotatePointX) + A32 * (y3-rotatePointY) + A33 * (z3-rotatePointZ);\n"
390	gezelter	864	"\n"
391			" #else\n"
392			" #local x1_new = x1;"
393			" #local y1_new = y1;"
394			" #local z1_new = z1;"
395			"\n"
396			" #local x2_new = x2;"
397			" #local y2_new = y2;"
398			" #local z2_new = z2;"
399			"\n"
400			" #local x3_new = x3;"
401			" #local y3_new = y3;"
402			" #local z3_new = z3;"
403			"\n"
404			" #end\n"
405			"\n"
406			" cylinder{\n"
407			" < x1_new, y1_new, z1_new >,\n"
408			" < x3_new, y3_new, z3_new >,\n"
409			" STICK_RADIUS\n"
410			" texture{\n"
411			" pigment{ rgb < %lf, %lf, %lf > }\n"
412			" finish{\n"
413			" ambient .2\n"
414			" diffuse .6\n"
415			" specular 1\n"
416			" roughness .001\n"
417			" metallic\n"
418			" }\n"
419			" }\n"
420			" }\n"
421			" cone{\n"
422			" < x2_new, y2_new, z2_new >, 0.0\n"
423			" < x3_new, y3_new, z3_new >, CONE_RADIUS\n"
424			" texture{\n"
425			" pigment{ rgb < %lf, %lf, %lf > }\n"
426			" finish{\n"
427			" ambient .2\n"
428			" diffuse .6\n"
429			" specular 1\n"
430			" roughness .001\n"
431			" metallic\n"
432			" }\n"
433			" }\n"
434			" }\n"
435			"#end\n"
436			"\n"
437	mmeineke	60	"\n",
438			name,
439			name,
440			red, green, blue,
441			name,
442			radius,
443	gezelter	864	red, green, blue,
444			name,
445			red, green, blue,
446	mmeineke	60	red, green, blue);
447
448			current_type = current_type->next;
449			}
450			}