VRMLOUT.C

Go to the documentation of this file.

/* --
OpenFX version 2.0 - Modelling, Animation and Rendering Package
Copyright (C) 2000 - 2007 OpenFX Development Team
-- */

/* File VRMLOUT.C DLL  */

#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <setjmp.h>
#include <windows.h>
#if __HELP_WS__
#include "..\help_ws\include\htmlhelp.h"
#endif

#include "struct.h"
#include "dstruct.h"

#include "vrmlout.h"

#if __X__MIPS__
BOOL WINAPI _CRT_INIT(HINSTANCE ,DWORD , LPVOID );
#endif

static HWND      hParent;
static HINSTANCE hThisInstance;

#define DOS386
#define _X__FAR
#define PI  3.1415926

#ifndef min
#define min(a,b)  ( ((a) < (b)) ? (a) : (b) )
#endif
#ifndef max
#define max(a,b)  ( ((a) > (b)) ? (a) : (b) )
#endif

#define UNIT         32768L
#define UNIT2        65536L
#define MINUNIT       2048L     // was 1024 trying larger to prevent error
#define MAXUNIT    4194304L     //1073741824L
#define PI2            PI/2
/* definition of flags and identifiers*/
#define DESELECTED       0
#define SELECTED         1
#define HIDDEN           2
#define INEDITOR         6
#define FAIL            -1

#define VECSUB(a,b,c)   { c[0]=a[0]-b[0]; c[1]=a[1]-b[1]; c[2]=a[2]-b[2];}
#define VECSUM(a,b,c)   { c[0]=a[0]+b[0]; c[1]=a[1]+b[1]; c[2]=a[2]+b[2];}
#define VECSCALE(a,b,c) { c[0]=(a)*b[0]; c[1]=(a)*b[1]; c[2]=(a)*b[2];}
#define DOT(a,b)        ( (a[0]*b[0]) + (a[1]*b[1]) + (a[2]*b[2]) )
#define CROSS(v1,v2,r)  { \
                          r[0] = (v1[1]*v2[2]) - (v2[1]*v1[2]);  \
                          r[1] = (v1[2]*v2[0]) - (v1[0]*v2[2]);  \
                          r[2] = (v1[0]*v2[1]) - (v2[0]*v1[1]);  \
                         }


typedef unsigned char COLOUR[3];

typedef struct tagMapVRML {
 char name[15];
 unsigned char dr,dg,db;
} MapVRML;

static MapVRML *mapVRMLlist=NULL;
static long   mapVRMLcount;
static face   **faces=NULL;
static long *faceid=NULL;
static long *facemarker=NULL;
static long lrulerx,lrulery,lrulerz;
static double ruler;
static long indent=0;
static long digits=3;
static BOOL bIndent=TRUE,bPrefix=TRUE,bNormals=FALSE;
static char map_path[256]="../maps/";
static char globalfile[256]="";

static BOOL WriteDataToRegistry(char *keyname){
 HKEY hkey;
 DWORD result;
 DWORD dw;
 if(RegCreateKeyEx(HKEY_LOCAL_MACHINE,keyname,0,NULL,
                   REG_OPTION_NON_VOLATILE,
                   KEY_ALL_ACCESS,NULL,&hkey,&result) != ERROR_SUCCESS)
   return FALSE;
 RegSetValueEx(hkey,"map_prefix",0,REG_SZ,map_path,strlen(map_path)+1);
 RegSetValueEx(hkey,"model_file",0,REG_SZ,globalfile,strlen(globalfile)+1);
 dw=(DWORD)bPrefix;
 RegSetValueEx(hkey,"use_map_prefix",0,REG_DWORD,(LPBYTE)(&dw),sizeof(DWORD));
 dw=(DWORD)digits;
 RegSetValueEx(hkey,"digits",0,REG_DWORD,(LPBYTE)(&dw),sizeof(DWORD));
 dw=(DWORD)bIndent;
 RegSetValueEx(hkey,"indent",0,REG_DWORD,(LPBYTE)(&dw),sizeof(DWORD));
 dw=(DWORD)bNormals;
 RegSetValueEx(hkey,"normals",0,REG_DWORD,(LPBYTE)(&dw),sizeof(DWORD));
 RegCloseKey(hkey);
 return TRUE;
}

static BOOL ReadDataFromRegistry(char *keyname){
 HKEY hkey;
 DWORD result;
 DWORD len,type,dw;
 char  str[256];
 if(RegOpenKeyEx(HKEY_LOCAL_MACHINE,keyname,0,KEY_ALL_ACCESS,&hkey)
   != ERROR_SUCCESS)return FALSE;
 len=256;
 if(RegQueryValueEx(hkey,"map_prefix",NULL,&type,str,&len)
    == ERROR_SUCCESS)strcpy(map_path,str);
 len=256;
 if(RegQueryValueEx(hkey,"model_file",NULL,&type,str,&len)
    == ERROR_SUCCESS)strcpy(globalfile,str);
 len=sizeof(DWORD);
 if(RegQueryValueEx(hkey,"use_map_prefix",NULL,&type,(LPBYTE)(&dw),&len)
    == ERROR_SUCCESS)bPrefix=(BOOL)dw;
 len=sizeof(DWORD);
 if(RegQueryValueEx(hkey,"indent",NULL,&type,(LPBYTE)(&dw),&len)
    == ERROR_SUCCESS)bIndent=(BOOL)dw;
 len=sizeof(DWORD);
 if(RegQueryValueEx(hkey,"digits",NULL,&type,(LPBYTE)(&dw),&len)
    == ERROR_SUCCESS)digits=(long)dw;
 if(RegQueryValueEx(hkey,"normals",NULL,&type,(LPBYTE)(&dw),&len)
    == ERROR_SUCCESS)bNormals=(BOOL)dw;
 len=sizeof(DWORD);
 RegCloseKey(hkey);
 return TRUE;
}

static char *FileOnly(char *file){
 char *t;
 t=strrchr(file,'\\');
 if(t == NULL)return file;
 return (t+1);
}

static void Id(FILE *f){
 int i;
 if(!bIndent)return;
 if(indent > 0)for(i=0;i<indent;i++)fprintf(f,"  ");
}

static void AddToColourList(COLOUR **L, long *n, face *Fp,
                            unsigned R, unsigned G, unsigned B,long ic){
 COLOUR *N,*O;
 long i,k;
 k = *n;
 O = *L;
 for(i=0;i<k;i++){
   if(O[i][0] == R && O[i][1] == G && O[i][2] == B){
//     Fp->pad=(unsigned char)i;
     facemarker[ic]=(long)i;
     return; // found
   }
 }
 N=(COLOUR *)X__Realloc(O,(k+1)*sizeof(COLOUR));
 if(N == NULL)return;  // fail
 N[k][0]=R; N[k][1]=G; N[k][2]=B;
 //Fp->pad=(unsigned char)k;
 facemarker[ic]=(unsigned char)k;
 k++;
 *n = k;
 *L = N;
 return;
}
static void GetFaceVector(face *fp, vector n){
 vector v20,v10;
 VECSUB((double)(MainVp+(fp->V[2]))->xyz,(double)(MainVp+(fp->V[0]))->xyz,v20)
 VECSUB((double)(MainVp+(fp->V[1]))->xyz,(double)(MainVp+(fp->V[0]))->xyz,v10)
 CROSS(v10,v20,n)
 oNormalize(n);
 return;
}

void CreateVRMLfile(FILE *dxfp){
 char layer[]={"MODEL"},cl[128],format[64],format1[64];
 long fp,vp;
 vertex *Vp;
 face   *Fp;
 skel   *sp;
 long i,id1,id2,id3,nColourList=0,ic;
 unsigned short nv,nf,j;
 unsigned char cR,cG,cB;
 float x,y,z;
 BOOL bColour=FALSE,bMapped=FALSE;
 COLOUR *ColourList=NULL;
 vector n,*NormalList=NULL;
 long mapid;
 mapVRMLlist=NULL;
 mapVRMLcount=0;
 sprintf(format,"%%.%ldf %%.%ldf %%.%ldf",digits,digits,digits);
 sprintf(format1,"%%.%ldf %%.%ldf",digits,digits);

 sp=MainSp; for(;;){ /* sp will be null for vertices not on any node */
   if(sp != NULL)strcpy(cl,sp->name);
   else          strcpy(cl,layer);
   vp=0; nv=0; while(vp < Nvert){
     Vp=(MainVp+vp);
     if(Vp->status == SELECTED && Vp->sp == sp){
       Vp->status=INEDITOR;
       nv++;
     }
     vp++;
   }
   bColour=FALSE; bMapped=FALSE; nColourList=0; ColourList=NULL; mapid=0;
   nf=0; fp=0; ic=0; while(fp < Nface){
     Fp=(MainFp+fp);
     if((MainVp+Fp->V[0])->status == INEDITOR &&
        (MainVp+Fp->V[1])->status == INEDITOR &&
        (MainVp+Fp->V[2])->status == INEDITOR){
       if(Fp->imagemap >= 0){ // mapped
         if(!bMapped)mapid=(long)Fp->imagemap;
         bMapped=TRUE;
       }
       // make color and material list
       if(nf == 0){
         cR=Fp->color[0]; cG=Fp->color[1]; cB=Fp->color[2];
         ColourList=(COLOUR *)X__Malloc(sizeof(COLOUR));
         if(ColourList != NULL){
           ColourList[0][0]=cR;
           ColourList[0][1]=cG;
           ColourList[0][2]=cB;
           nColourList++;
           facemarker[ic]=0;
           //Fp->pad=0;
         }
       }
       else{
         cR=Fp->color[0]; cG=Fp->color[1]; cB=Fp->color[2];
         AddToColourList(&ColourList,&nColourList,Fp,cR,cG,cB,ic);
       }
       nf++;
     }
     ic++; fp++;
   }

   if(!bMapped)bColour=TRUE;

   if(nf > 0){ /* only write if there are any faces */
     if(bNormals &&
        (NormalList=(vector *)X__Malloc(nv*sizeof(vector))) != NULL)
       bNormals=TRUE;
     // write-ROOT header  - Shape
     Id(dxfp); fprintf(dxfp,"DEF SFX-%s-ROOT Transform {\n",cl);  indent++;
     Id(dxfp); fprintf(dxfp,"translation 0 0 0\n");
     Id(dxfp); fprintf(dxfp,"children [\n"); indent++;
     Id(dxfp); fprintf(dxfp,"Shape {\n"); indent++;
     // write appearance
     Id(dxfp); fprintf(dxfp,"appearance Appearance {\n"); indent++;
     Id(dxfp); fprintf(dxfp,"material Material {\n"); indent++;
     // if all one color then set
     if(nColourList == 1){
       Id(dxfp); fprintf(dxfp,"diffuseColor %.2lf %.2lf %.2lf\n",
         (double)ColourList[0][0]/255.0,
         (double)ColourList[0][1]/255.0,
         (double)ColourList[0][2]/255.0);
     }
     else{
       Id(dxfp); fprintf(dxfp,"diffuseColor 1 1 1\n");
     }
     Id(dxfp); fprintf(dxfp,"shininess 0.5\n");
     Id(dxfp); fprintf(dxfp,"transparency 0\n");
     indent--;
     Id(dxfp); fprintf(dxfp,"}\n");  // material

     // mapping if present
     if(bMapped){
      Id(dxfp); fprintf(dxfp,"texture ImageTexture {\n"); indent++;
      Id(dxfp);
      if(bPrefix)fprintf(dxfp,"url \"%s",map_path);
      else       fprintf(dxfp,"url \"");
      if(nImaps > 0 && mapid < nImaps && iMap[mapid].S != NULL){
       fprintf(dxfp,"%s\"\n",FileOnly(iMap[mapid].S));
      }
      else{
       fprintf(dxfp,"unnamed.jpg\"\n");
      }
      indent--; Id(dxfp); fprintf(dxfp,"}\n");
     }

     indent--;
     Id(dxfp); fprintf(dxfp,"}\n");      // end appearance

     // write geometry header
     Id(dxfp); fprintf(dxfp,"geometry DEF SFX-%s-FACES IndexedFaceSet {\n",cl);  indent++;
     Id(dxfp); fprintf(dxfp,"ccw TRUE\n");
     Id(dxfp); fprintf(dxfp,"solid FALSE\n");
     // if there is a colour list
     if(nColourList > 1 && bColour){
       Id(dxfp); fprintf(dxfp,"colorPerVertex FALSE\n");
       Id(dxfp); fprintf(dxfp,"color Color { color [\n"); indent++;
       Id(dxfp);
       for(i=0;i<nColourList;i++){
         fprintf(dxfp,"%.2lf %.2lf %.2lf",
           (double)ColourList[i][0]/255.0,
           (double)ColourList[i][1]/255.0,
           (double)ColourList[i][2]/255.0);
         if(i == nColourList-1)fprintf(dxfp,"]\n");
         else{
           if((i+1)%3 == 0){
             fprintf(dxfp,",\n");
             Id(dxfp);
           }
           else fprintf(dxfp,", ");
         }
       }
       indent--;
       Id(dxfp); fprintf(dxfp,"}\n");
     }

     Id(dxfp); fprintf(dxfp,"coord DEF SFX-%s-COORD Coordinate { point [\n",cl);  indent++;
     Id(dxfp);
     i=0; vp=0; while(vp < Nvert){
       Vp=(MainVp+vp);
       if(Vp->status == INEDITOR){  // write vertices
         x=(float)(Vp->xyz[0]-lrulerx)/(float)ruler;
         y=(float)(Vp->xyz[1]-lrulery)/(float)ruler;
         z=(float)(Vp->xyz[2]-lrulerz)/(float)ruler;
//         x=((double)(Vp->xyz[0]))/((double)UNIT);
//         y=((double)(Vp->xyz[1]))/((double)UNIT);
//         z=((double)(Vp->xyz[2]))/((double)UNIT);
         if(bNormals){
           NormalList[i][0]=0.0;
           NormalList[i][1]=0.0;
           NormalList[i][2]=0.0;
         }
         fprintf(dxfp,format,x,z,-y);
         Vp->id = i++;
         if(i == nv)fprintf(dxfp,"]\n");
         else{
           if(i%3 == 0){
             fprintf(dxfp,",\n");
             Id(dxfp);
           }
           else fprintf(dxfp,", ");
         }
       }
       else Vp->id = 65535;
       vp++;
     }
     indent--;
     Id(dxfp); fprintf(dxfp,"}\n");       // coordinates

     // write facet index information
     Id(dxfp); fprintf(dxfp,"coordIndex [\n");  indent++;
     Id(dxfp);
     fp=0; j=0; while(fp < Nface){  // write faces
       Fp=(MainFp+fp);
       if((MainVp+Fp->V[0])->status == INEDITOR &&
          (MainVp+Fp->V[1])->status == INEDITOR &&
          (MainVp+Fp->V[2])->status == INEDITOR){
         id1=(unsigned short)((MainVp+Fp->V[0])->id);
         id2=(unsigned short)((MainVp+Fp->V[1])->id);
         id3=(unsigned short)((MainVp+Fp->V[2])->id);
         fprintf(dxfp,"%ld, %ld, %ld, -1",id1,id2,id3);
         faceid[fp] = (long)(j++);
         if(j == nf)fprintf(dxfp,"]\n");
         else{
           if(j%3 == 0){
             fprintf(dxfp,",\n");
             Id(dxfp);
           }
           else fprintf(dxfp,", ");
         }
         if(bNormals){
           if(1){ //(Fp->attrib & 0x80) == 0x80){
             GetFaceVector(Fp,n);
             VECSUM(n,NormalList[id1],NormalList[id1])
             VECSUM(n,NormalList[id2],NormalList[id2])
             VECSUM(n,NormalList[id3],NormalList[id3])
           }
         }
       }
       fp++;
     }
     indent--;    // coordIndex

     if(bNormals){
       Id(dxfp); fprintf(dxfp,"normal Normal { vector [\n",cl);  indent++;
       Id(dxfp);
       i=0; vp=0; while(vp < Nvert){
         Vp=(MainVp+vp);
         if(Vp->status == INEDITOR){  // write vertices
           if(oNormalize(NormalList[i]) == FAIL){
             x=y=0.0; z=1.0;
           }
           else{
             x=NormalList[i][0];
             y=NormalList[i][1];
             z=NormalList[i][2];
           }
           fprintf(dxfp,format,x,z,-y);
           i++;
           if(i == nv)fprintf(dxfp,"]\n");
           else{
             if(i%3 == 0){
               fprintf(dxfp,",\n");
               Id(dxfp);
             }
             else fprintf(dxfp,", ");
           }
         }
         vp++;
       }
       indent--;
       Id(dxfp); fprintf(dxfp,"}\n");

       Id(dxfp); fprintf(dxfp,"normalPerVertex TRUE\n");
       Id(dxfp); fprintf(dxfp,"normalIndex [\n");  indent++;
       Id(dxfp);
       fp=0; j=0; while(fp < Nface){  // write faces
         Fp=(MainFp+fp);
         if((MainVp+Fp->V[0])->status == INEDITOR &&
            (MainVp+Fp->V[1])->status == INEDITOR &&
            (MainVp+Fp->V[2])->status == INEDITOR){
           if(! Fp->bSmooth){
             id1=id2=id3=(unsigned short)((MainVp+Fp->V[0])->id);
           }
           else{
             id1=(unsigned short)((MainVp+Fp->V[0])->id);
             id2=(unsigned short)((MainVp+Fp->V[1])->id);
             id3=(unsigned short)((MainVp+Fp->V[2])->id);
           }
           fprintf(dxfp,"%ld, %ld, %ld, -1",id1,id2,id3);
           j++;
           if(j == nf)fprintf(dxfp,"]\n");
           else{
             if(j%3 == 0){
               fprintf(dxfp,",\n");
               Id(dxfp);
             }
             else fprintf(dxfp,", ");
           }
         }
         fp++;
       }
       indent--;    // normalIndex
     }

     // write any color index information
     if(nColourList > 1 && bColour){
       Id(dxfp); fprintf(dxfp,"colorIndex[\n");  indent++;
       Id(dxfp);
       fp=0; j=0; while(fp < Nface){  // write faces
         Fp=(MainFp+fp);
         if((MainVp+Fp->V[0])->status == INEDITOR &&
            (MainVp+Fp->V[1])->status == INEDITOR &&
            (MainVp+Fp->V[2])->status == INEDITOR){
           //id1=(long)(Fp->pad);
           id1=(long)facemarker[fp];
           fprintf(dxfp,"%ld",id1);
           j++;
           if(j == nf)fprintf(dxfp,"]\n");
           else{
             if(j%9 == 0){
               fprintf(dxfp,",\n");
               Id(dxfp);
             }
             else fprintf(dxfp,", ");
           }
         }
         fp++;
       }
       indent--;
     }  // colour index

     if(bMapped){  // write any texture coordinates and indices
       Id(dxfp); fprintf(dxfp,"texCoord DEF SFX-%s-TEXCOORD TextureCoordinate { point [\n",cl);  indent++;
       Id(dxfp);
       i=0; vp=0; while(vp < Nvert){
         Vp=(MainVp+vp);
         if(Vp->status == INEDITOR){  // write vertices
           fprintf(dxfp,format1,(float)Vp->x,(float)Vp->y);
           Vp->id = i++;
           if(i == nv)fprintf(dxfp,"]\n");
           else{
             if(i%4 == 0){
               fprintf(dxfp,",\n");
               Id(dxfp);
             }
             else fprintf(dxfp,", ");
           }
         }
         else Vp->id = 65535;
         vp++;
       }
       indent--;
       Id(dxfp); fprintf(dxfp,"}\n");      // tex coord
       Id(dxfp); fprintf(dxfp,"texCoordIndex [\n");  indent++;
       Id(dxfp);
       fp=0; j=0; while(fp < Nface){  // write faces tex coordinate index
         Fp=(MainFp+fp);
         if((MainVp+Fp->V[0])->status == INEDITOR &&
            (MainVp+Fp->V[1])->status == INEDITOR &&
            (MainVp+Fp->V[2])->status == INEDITOR){
           id1=(unsigned short)((MainVp+Fp->V[0])->id);
           id2=(unsigned short)((MainVp+Fp->V[1])->id);
           id3=(unsigned short)((MainVp+Fp->V[2])->id);
           fprintf(dxfp,"%ld, %ld, %ld, -1",id1,id2,id3);
           faceid[fp] = (long)(j++);
           if(j == nf)fprintf(dxfp,"]\n");
           else{
             if(j%3 == 0){
               fprintf(dxfp,",\n");
               Id(dxfp);
             }
             else fprintf(dxfp,", ");
           }
         }
         fp++;
       }
       indent--;    // texcoordIndex
     }

     indent--;
     Id(dxfp); fprintf(dxfp,"}\n"); indent--;    // geometry
     // write root tailer
     Id(dxfp); fprintf(dxfp,"}\n"); indent--;    // shape
     Id(dxfp); fprintf(dxfp,"]\n"); indent--;    // children
     Id(dxfp); fprintf(dxfp,"}\n");              // transform
     if(bNormals && NormalList != NULL)X__Free(NormalList);
   }
   vp=0; while(vp < Nvert){ /* reset status */
     Vp=(MainVp+vp);
     if(Vp->status == INEDITOR)Vp->status=SELECTED;
     vp++;
   }
   if(ColourList != NULL)X__Free(ColourList);
   ColourList=NULL; nColourList=0;
   if(sp == NULL)break;
   sp=sp->last;
 }  /* end of for(;;) */

}

#if __WATCOMC__
int APIENTRY LibMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#else
BOOL WINAPI DllMain(HANDLE hDLL, DWORD dwReason, LPVOID lpReserved){
#endif
  switch (dwReason) {
    case DLL_PROCESS_ATTACH: {
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      hThisInstance=hDLL;
      break;
    }
    case DLL_PROCESS_DETACH:
#if __X__MIPS__
      if(!_CRT_INIT(hDLL,dwReason,lpReserved))return(int)FALSE;
#endif
      break;
  }
  return TRUE;
}

static PSTR FileInPath(PSTR pstrPath){
 PSTR pstr;
 pstr = pstrPath + strlen(pstrPath);
 while (pstr > pstrPath) {
     pstr = (AnsiPrev(pstrPath, pstr));
     if (*pstr == '\\' || *pstr == ':' || *pstr == '/') {
         pstr = (AnsiNext(pstr));
         break;
     }
 }
 return pstr;
}

static unsigned CALLBACK NameHookProc(HWND hwnd,UINT msg,
                              WPARAM wparam,LPARAM lparam){
 BOOL err;
 switch( msg ) {
   case WM_INITDIALOG:
     if(bPrefix)SendDlgItemMessage(hwnd,DLG_VRML_USEPREFIX,BM_SETCHECK,1,0);
     if(bIndent)SendDlgItemMessage(hwnd,DLG_VRML_INDENTATION,BM_SETCHECK,1,0);
     if(bNormals)SendDlgItemMessage(hwnd,DLG_VRML_NORMALS,BM_SETCHECK,1,0);
     SetDlgItemInt(hwnd,DLG_VRML_DIGITS,digits,FALSE);
     SetDlgItemText(hwnd,DLG_VRML_PREFIX,map_path);
//     CentreDlgOnS(GetParent(hwnd));
     return FALSE;
   case WM_COMMAND:
     switch(LOWORD(wparam)){
       case IDOK:{
          goto JUMPHERE;
         }
         break;
       case  DLG_VRML_HELP:{
            char lname[256],res_str1[256],res_str2[256];
            GetModuleFileName(hThisInstance,lname,225);
            *FileInPath(lname) = '\0';
            strcat(lname,"help\\");
            strcpy(res_str1,lname);
#if !__HELP_WS__
            strcat(res_str1,"ani_help.chm");
            ShellExecute(hwnd,NULL,res_str1,
                         NULL,lname,SW_SHOW);
#else
            {
             HH_WINTYPE hhwin;
             memset(&hhwin,0,sizeof(HH_WINTYPE));
             hhwin.cbStruct=sizeof(HH_WINTYPE);
             hhwin.nShowState=SW_SHOW;
             hhwin.pszType="MyHelp";
             LoadString(hThisInstance,IDX_VRML_STRING2,lname,255);
             hhwin.pszCaption=lname;
             hhwin.fsValidMembers = HHWIN_PARAM_SHOWSTATE |
                                    HHWIN_PARAM_PROPERTIES|
                                    HHWIN_PARAM_CUR_TAB|
                                    HHWIN_PARAM_EXPANSION|
                                    HHWIN_PARAM_RECT;
             hhwin.rcWindowPos.top=0;
             hhwin.rcWindowPos.left=0;
             hhwin.rcWindowPos.right=500;
             hhwin.rcWindowPos.bottom=500;
             hhwin.nShowState=SW_SHOW;
             strcat(res_str1,"ani_help.chm");
             hhwin.fNotExpanded = TRUE;
             hhwin.fsWinProperties = HHWIN_PROP_TRI_PANE|HHWIN_PROP_TAB_SEARCH;
             hhwin.curNavType=HHWIN_NAVTYPE_TOC;
             strcpy(res_str2,res_str1);
             strcat(res_str2,"::toc.hhc");
             hhwin.pszToc=res_str2;
             strcat(res_str1,"::/vrml_exporter.htm");
             HtmlHelp(hwnd,NULL,HH_SET_WIN_TYPE,(DWORD)&hhwin);
             HtmlHelp(hwnd,">MyHelp",HH_DISPLAY_TOPIC,(DWORD)res_str1);
           }
#endif
         }
         break;
       default: break;
     }
     break;
   case WM_NOTIFY:{
       LPOFNOTIFY lp=(LPOFNOTIFY)lparam;
       if(lp->hdr.code == CDN_FILEOK){
         JUMPHERE:
         if(SendDlgItemMessage(hwnd,DLG_VRML_USEPREFIX,BM_GETCHECK,0,0))
              bPrefix=TRUE;
         else bPrefix=FALSE;
         if(SendDlgItemMessage(hwnd,DLG_VRML_INDENTATION,BM_GETCHECK,0,0))
              bIndent=TRUE;
         else bIndent=FALSE;
         if(SendDlgItemMessage(hwnd,DLG_VRML_NORMALS,BM_GETCHECK,0,0))
              bNormals=TRUE;
         else bNormals=FALSE;
         digits=GetDlgItemInt(hwnd,DLG_VRML_DIGITS,&err,FALSE);
         if(digits < 0)digits=0;
         GetDlgItemText(hwnd,DLG_VRML_PREFIX,map_path,255);
       }
     }
     break;
   default: break;
 }
 return FALSE;
}

static BOOL LocalSelectFileName(char *szfile, char *szfilter,
                           HWND parent, HINSTANCE hInst){
 int i;
 OPENFILENAME ofn;
 char szFilter[80],title[256];
 DWORD version;
 strcpy(szFilter,szfilter);
 i=0; while(szFilter[i] != '\0'){
   if(szFilter[i] == '|')szFilter[i]='\0'; i++;
 }
 memset(&ofn,0,sizeof(OPENFILENAME));
 ofn.lStructSize=sizeof(OPENFILENAME);
 ofn.hwndOwner=parent;
 ofn.lpstrFilter=szFilter;
 ofn.nFilterIndex=0;
 ofn.lpstrFile=szfile;
 ofn.nMaxFile=255;
 ofn.lpstrFileTitle=NULL;
 ofn.nMaxFileTitle=0;
 ofn.lpstrInitialDir=NULL;
 LoadString(hThisInstance,IDX_VRML_STRING1,title,255);
 ofn.lpstrTitle=title;
 ofn.hInstance=hInst;
 ofn.lpfnHook=NameHookProc;
 version=GetVersion();
 ofn.Flags=OFN_HIDEREADONLY|OFN_PATHMUSTEXIST|
           OFN_ENABLEHOOK|OFN_ENABLETEMPLATE|OFN_NONETWORKBUTTON;
 if(LOBYTE(LOWORD(version)) >= 4){
   ofn.lpTemplateName=MAKEINTRESOURCE(DLG_VRML);
   ofn.Flags |= OFN_EXPLORER;
 }
 else{
   ofn.lpTemplateName=MAKEINTRESOURCE(DLG_OLDVRML);
 }
 return GetOpenFileName(&ofn);
}

long _Export
 (HWND parent_window, char *filename,X__STRUCTURE *lpevi){
 char localfile[256];
 FILE *dxfp;
 lpEVI=lpevi;
 ReadDataFromRegistry("SOFTWARE\\OPENFX\\VRML");
 strcpy(localfile,globalfile);
 if(filename == NULL){
   if(!LocalSelectFileName(localfile,
                           "VRML files (*.WRL)|*.wrl",
                           parent_window,hThisInstance))return 0;

 }
 else strcpy(localfile,filename);
 strcpy(globalfile,localfile);
 WriteDataToRegistry("SOFTWARE\\OPENFX\\VRML");
 AppendFileExtension(localfile,".wrl");
 if(NvertSelect == 0 || Nface == 0){
   MessageBox(parent_window,"Too few vertices or faces selected",NULL,MB_OK);
   return 0;
 }
 lrulerx= (*(lpEVI->orulerx));
 lrulery= (*(lpEVI->orulery));
 lrulerz= (*(lpEVI->orulerz));
 ruler  = (*(lpEVI->ruler));
 if((dxfp=fopen(localfile,"w")) != NULL){
   if((faceid=(long *)X__Malloc(Nface*sizeof(long))) != NULL){
     if((facemarker=(long *)X__Malloc(Nface*sizeof(long))) != NULL){
       fprintf(dxfp,"#VRML V2.0 utf8\n\n# Produced by OpenFX 2000\n\n");
       CreateVRMLfile(dxfp);
       X__Free(facemarker);
     }
     else MessageBox(NULL,"No memory",NULL,MB_OK);
     X__Free(faceid);
   }
   else MessageBox(NULL,"No memory",NULL,MB_OK);
   fclose(dxfp);
 }
 else{
   MessageBox(parent_window,"File open Error",NULL,MB_OK);
 }
 if(mapVRMLlist != NULL)X__Free(mapVRMLlist);
 return 1;
}

BOOL _Xmodeler
 (HWND parent_window,HWND info_window,X__STRUCTURE *lpevi){
 return _Export(parent_window,NULL,lpevi);
}