www.pudn.com > 3DEDITOR.rar > OBJECT.H

#include "tree.h" 
#include "ChunkFile.h" 
struct mapping 
{ 
	char filename[256]; 
	short int type,amount,options; 
	float filtering; 
	float u_scale,v_scale,u_offset,v_offset; 
	float rotation; 
	int piclibindx; 
}; 
 
class material 
{ 
public: 
	float refraction; 
	float reflection; 
	float ambient[4]; 
	float diffuse[4]; 
	float specular[4]; 
	float shininess; 
	float shininess_strength; 
	float transparency; 
	float transparency_falloff; 
	float reflect_blur; 
	short int material_type; 
	float self_illum; 
 
	char name[256]; 
 
	struct mapping  
		map_texture1,map_texture2, 
		map_opacity,map_bump,map_specular, 
		map_shininess,map_selfillum,map_reflection; 
 
	material() 
	{ 
		memset(this,0,sizeof(material)); 
		refraction=1; 
	} 
}; 
 
class ray 
{ 
public: 
	int depth; 
	vector ro,rd,at; 
}; 
 
class light 
{ 
public: 
	char name[256]; 
	int type; 
	vector color,pos,target,dir; 
	float hotspot,falloff; 
}; 
 
class facelist 
{ 
public: 
	void *face; 
	facelist *next; 
	facelist() { next=0; } 
	~facelist() { if (next) delete next; } 
}; 
 
class ctlist 
{ 
public: 
	unsigned short nfv,mat1,mat2; 
	char i1,i2; 
	float weight; 
	float dtx[2]; 
	vector d; 
	int vert1,vert2, 
		vert3,vert4, 
		face1,face2, 
		face3,face4, 
		face5,face6; 
 
	int *fv; 
	ctlist *next,*prev; 
 
	ctlist() {  next=0; prev=0; fv=0; nfv=0; }; 
	~ctlist() { if (next) delete next; if (fv) delete fv; }; 
}; 
 
class vtlist 
{ 
public: 
	vector pos; 
	vector normal; 
	float tx[2]; 
	int flag; 
	facelist *faces; 
 
	bool esta_na_borda(); 
	int num_faces(); 
 
	vtlist() { faces=0; }; 
	~vtlist() { if (faces) delete faces; }; 
}; 
 
class ftlist : public tree_elem 
{ 
public: 
	vector normal; 
	ftlist *lf[3]; 
	vtlist *lv[3]; 
	int flag; 
	unsigned short material,group; 
 
	virtual void get_bbox(boundbox *b); 
	virtual void get_center(vector *center); 
	virtual void get_normal(vector *n); 
	virtual int ray_intersect(vector& ro,vector& rd,vector& ip,float& dist); 
	int is_inside(vector& ip); 
	void compute_nuv(int tx,vector& IntPoint,vector& N,float& tx_u, float& tx_v); 
	void compute_dudv(vector& ip,float u,float v,vector &dU, vector &dV); 
}; 
  
class element 
{ 
public: 
	int elem, ncoef, cur_ncoef,  
		nf, nv, nrf, nrv; 
	ctlist *coef, *cur_coef; 
 
	element() 
	{ 
		cur_ncoef=-1; 
		cur_coef=0; 
		coef=0;  
		ncoef=0; 
	} 
}; 
 
class object  
{ 
public: 
	char name[256]; 
 
	vtlist **vt; 
	ftlist **ft; 
	 
	int nv, nf, nrf, nrv, nelem; 
	element *elem; 
 
	int cur_ncoef,ncoef,textcoord; 
 
	double smoothang; 
	vector bbox1,bbox2; 
 
	object *next; 
 
	void Serialize(ChunkFile& ar, bool); 
	void check_links(); 
	void check_edges(); 
	void reset(); 
	void compute_normals(); 
	void build_edge_tree(); 
	void fix_normals(); 
	void fix_node_normal(ftlist *node); 
	int find_face_edge(int f,int i,int& g,int& j); 
	void change_index(int i, int j); 
	void Implode(); 
	void Explode(); 
	void DelDupFace(); 
	void DelDupVert(); 
	void DelInvFace(); 
	void DelFace(ftlist **f); 
	float FindNextEdge(int group,int& f1,int& i1,int &f2,int& i2); 
	void CompactHoles(); 
	void CompressEdge(float weight,int f1,int i1,int f2,int i2); 
	void Compress(); 
	void rebuild_normals(int v1); 
	int AddCoef(int e); 
	int DelCoef(int e); 
	int AddCoef(); 
	int DelCoef(); 
	void ApagaVertNaAresta(); 
	bool EstaNaAresta(float *, float *, float *); 
	void juntaface(ftlist *, int, int); 
	void compute_bbox(); 
	void invert_normal(ftlist *node); 
	void invert_node_normal(ftlist *node); 
	void count_node(ftlist *node,int e); 
	void count_elements(); 
 
	object()  
		{  
		vt=0; ft=0; 
		nv=0; nf=0; 
		nrf=0; nrv=0; 
		elem=0; nelem=0; 
		next=0;  
		smoothang=0.5; 
		textcoord=false; 
		}; 
	~object() { reset(); if (next) delete next; }; 
}; 
 
class scene 
{ 
public: 
	int nmatlib, nmatlib_ant; 
	material *matlib; 
 
	int ncamlib, ncamlib_ant; 
	camera *camlib; 
	 
	int npiclib; 
	picture *piclib; 
	 
	int nobj, nobj_ant; 
	object *obj0; 
 
	int nlights, nlights_ant,headlight,shadows,backface,textinterp,fog; 
	light *lightlib; 
	vector amblight,headlightpos,background; 
 
	int inuse,maxdepth,minfaces, 
		startwinsize,raysonly; 
 
	float bboxdiag; 
	vector bbox1,bbox2,bboxC; 
 
	int nf,nv,ncoef,cur_ncoef,last_mat; 
 
	octree_node *oc; 
	 
	int find_image(char *name); 
	void load_images(); 
	void ComputeBBoxes(void); 
	int import(char *file,CListCtrl *lb); 
	int export(char *file); 
	void reset(); 
	int AddCoef(); 
	int DelCoef(); 
 
	void build_octree(int min,int depth); 
	int should_antialiase(picture *p,int x,int y,int factor); 
	void compute_color(ftlist *ft,vector& ip,vector& n,vector& view,float u,float v,vector& color); 
	void SelectMaterial(material *mat,int texture); 
	void calc_uv(float &, float &, struct mapping *); 
	void shoot_ray(ray *r,vector& color); 
	void trace_ray(camera *cam,picture *p,int x,int y,int ray_depth,vector& color); 
	picture *ray_trace(camera *cam,int& sx,int& sy,int ray_depth,int maxdepth,int minfaces,int antialiase,int antialiase_factor); 
 
	scene()  
		{ 
		oc=0; 
		fog=0; 
		lightlib=0; 
		nlights=0; 
		inuse=0; 
		nobj=0; 
		obj0=0; 
		matlib=0; 
		ncamlib=0; 
		camlib=0; 
		npiclib=0; 
		piclib=0; 
		matlib=new material; 
		nmatlib=1; 
		memset(&matlib[0],0,sizeof(material)); 
		matlib[0].refraction=1; 
		strcpy(matlib[0].name,"Default"); 
		matlib[0].diffuse[0]=matlib[0].diffuse[1]=matlib[0].diffuse[2]=(float)0.8; 
		matlib[0].ambient[0]=matlib[0].ambient[1]=matlib[0].ambient[2]=(float)0.3; 
		matlib[0].specular[0]=matlib[0].specular[1]=matlib[0].specular[2]=(float)1.0; 
		amblight.Vec((float)0.3,(float)0.3,(float)0.3); 
		headlight=1; 
		background.Vec(0,0,0); 
		textinterp=0; 
		backface=1; 
		} 
	 
	~scene() 
		{ 
		reset(); 
		} 
}; 
 
int operator ==(ftlist &f1, ftlist &f2);