vrml_tools.c

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

	return tmp;
}

void *gf_sg_vrml_field_pointer_new(u32 FieldType) 
{
	switch (FieldType) {
	case GF_SG_VRML_SFBOOL: return NewSFBool();
	case GF_SG_VRML_SFFLOAT: return NewSFFloat();
	case GF_SG_VRML_SFDOUBLE: return NewSFDouble();
	case GF_SG_VRML_SFTIME: return NewSFTime();
	case GF_SG_VRML_SFINT32: return NewSFInt32();
	case GF_SG_VRML_SFSTRING: return NewSFString();
	case GF_SG_VRML_SFVEC3F: return NewSFVec3f();
	case GF_SG_VRML_SFVEC2F: return NewSFVec2f();
	case GF_SG_VRML_SFVEC3D: return NewSFVec3d();
	case GF_SG_VRML_SFVEC2D: return NewSFVec2d();
	case GF_SG_VRML_SFCOLOR: return NewSFColor();
	case GF_SG_VRML_SFCOLORRGBA: return NewSFColorRGBA();
	case GF_SG_VRML_SFROTATION: return NewSFRotation();
	case GF_SG_VRML_SFIMAGE: return NewSFImage();
	case GF_SG_VRML_MFBOOL: return NewMFBool();
	case GF_SG_VRML_MFFLOAT: return NewMFFloat();
	case GF_SG_VRML_MFTIME: return NewMFTime();
	case GF_SG_VRML_MFINT32: return NewMFInt32();
	case GF_SG_VRML_MFSTRING: return NewMFString();
	case GF_SG_VRML_MFVEC3F: return NewMFVec3f();
	case GF_SG_VRML_MFVEC2F: return NewMFVec2f();
	case GF_SG_VRML_MFVEC3D: return NewMFVec3d();
	case GF_SG_VRML_MFVEC2D: return NewMFVec2d();
	case GF_SG_VRML_MFCOLOR: return NewMFColor();
	case GF_SG_VRML_MFCOLORRGBA: return NewMFColorRGBA();
	case GF_SG_VRML_MFROTATION: return NewMFRotation();

	//used in commands
	case GF_SG_VRML_SFCOMMANDBUFFER:
		return NewSFCommandBuffer();

	case GF_SG_VRML_SFURL: 
		return NewSFURL();
	case GF_SG_VRML_MFURL:
		return NewMFURL();

	case GF_SG_VRML_SFSCRIPT: 
		return NewSFScript();
	case GF_SG_VRML_MFSCRIPT: 
		return NewMFScript();
	}
	return NULL;
}

void gf_sg_mfint32_del(MFInt32 par) { free(par.vals); }
void gf_sg_mffloat_del(MFFloat par) { free(par.vals); }
void gf_sg_mfdouble_del(MFDouble par) { free(par.vals); }
void gf_sg_mfbool_del(MFBool par) { free(par.vals); }
void gf_sg_mfcolor_del(MFColor par) { free(par.vals); }
void gf_sg_mfcolor_rgba_del(MFColorRGBA par) { free(par.vals); }
void gf_sg_mfrotation_del(MFRotation par) { free(par.vals); }
void gf_sg_mftime_del(MFTime par) { free(par.vals); }
void gf_sg_mfvec2f_del(MFVec2f par) { free(par.vals); }
void gf_sg_mfvec2d_del(MFVec2d par) { free(par.vals); }
void gf_sg_mfvec3f_del(MFVec3f par) { free(par.vals); }
void gf_sg_mfvec3d_del(MFVec3d par) { free(par.vals); }
void gf_sg_mfvec4f_del(MFVec4f par) { free(par.vals); }
void gf_sg_sfimage_del(SFImage im) { free(im.pixels); }
void gf_sg_sfurl_del(SFURL url) { if (url.url) free(url.url); }
void gf_sg_sfstring_del(SFString par) { if (par.buffer) free(par.buffer); }
void gf_sg_sfscript_del(SFScript par) { if (par.script_text) free(par.script_text); }

void gf_sg_mfstring_del(MFString par)
{
	u32 i;
	for (i=0; i<par.count; i++) {
		if (par.vals[i]) free(par.vals[i]);
	}
	free(par.vals);
}


void gf_sg_sfcommand_del(SFCommandBuffer cb)
{
	u32 i;
	for (i=gf_list_count(cb.commandList); i>0; i--) {
		GF_Command *com = (GF_Command *)gf_list_get(cb.commandList, i-1);
		gf_sg_command_del(com);
	}
	gf_list_del(cb.commandList);
	if (cb.buffer) free(cb.buffer);
}

GF_EXPORT
void gf_sg_mfurl_del(MFURL url)
{
	u32 i;
	for (i=0; i<url.count; i++) {
		gf_sg_sfurl_del(url.vals[i]);
	}
	free(url.vals);
}
void gf_sg_mfscript_del(MFScript sc)
{
	u32 i;
	for (i=0; i<sc.count; i++) {
		if (sc.vals[i].script_text) free(sc.vals[i].script_text);
	}
	free(sc.vals);
}


void gf_sg_vrml_field_pointer_del(void *field, u32 FieldType) 
{
	GF_Node *node;

	switch (FieldType) {
	case GF_SG_VRML_SFBOOL: 
	case GF_SG_VRML_SFFLOAT:
	case GF_SG_VRML_SFDOUBLE:
	case GF_SG_VRML_SFTIME: 
	case GF_SG_VRML_SFINT32:
	case GF_SG_VRML_SFVEC3F:
	case GF_SG_VRML_SFVEC3D:
	case GF_SG_VRML_SFVEC2F:
	case GF_SG_VRML_SFVEC2D:
	case GF_SG_VRML_SFCOLOR:
	case GF_SG_VRML_SFCOLORRGBA:
	case GF_SG_VRML_SFROTATION:
		break;
	case GF_SG_VRML_SFSTRING:
		if ( ((SFString *)field)->buffer) free(((SFString *)field)->buffer);
		break;
	case GF_SG_VRML_SFIMAGE:
		gf_sg_sfimage_del(* ((SFImage *)field));
		break;

	case GF_SG_VRML_SFNODE: 
		node = *(GF_Node **) field;
		if (node) gf_node_del(node);
		return;
	case GF_SG_VRML_SFCOMMANDBUFFER:
		gf_sg_sfcommand_del(*(SFCommandBuffer *)field);
		break;
	
	case GF_SG_VRML_MFBOOL:
		gf_sg_mfbool_del( * ((MFBool *) field));
		break;
	case GF_SG_VRML_MFFLOAT: 
		gf_sg_mffloat_del( * ((MFFloat *) field));
		break;
	case GF_SG_VRML_MFDOUBLE: 
		gf_sg_mfdouble_del( * ((MFDouble *) field));
		break;
	case GF_SG_VRML_MFTIME: 
		gf_sg_mftime_del( * ((MFTime *)field));
		break;
	case GF_SG_VRML_MFINT32:
		gf_sg_mfint32_del( * ((MFInt32 *)field));
		break;
	case GF_SG_VRML_MFSTRING:
		gf_sg_mfstring_del( *((MFString *)field));
		break;
	case GF_SG_VRML_MFVEC3F:
		gf_sg_mfvec3f_del( * ((MFVec3f *)field));
		break;
	case GF_SG_VRML_MFVEC2F:
		gf_sg_mfvec2f_del( * ((MFVec2f *)field));
		break;
	case GF_SG_VRML_MFVEC3D:
		gf_sg_mfvec3d_del( * ((MFVec3d *)field));
		break;
	case GF_SG_VRML_MFVEC2D:
		gf_sg_mfvec2d_del( * ((MFVec2d *)field));
		break;
	case GF_SG_VRML_MFCOLOR:
		gf_sg_mfcolor_del( * ((MFColor *)field));
		break;
	case GF_SG_VRML_MFCOLORRGBA:
		gf_sg_mfcolor_rgba_del( * ((MFColorRGBA *)field));
		break;
	case GF_SG_VRML_MFROTATION:
		gf_sg_mfrotation_del( * ((MFRotation *)field));
		break;
	case GF_SG_VRML_SFURL:
		gf_sg_sfurl_del( * ((SFURL *) field));
		break;
	case GF_SG_VRML_MFURL:
		gf_sg_mfurl_del( * ((MFURL *) field));
		break;		
	//used only in proto since this field is created by default for regular nodes
	case GF_SG_VRML_MFNODE: 
		assert(0);
		return;
	case GF_SG_VRML_MFSCRIPT:
		gf_sg_mfscript_del( * ((MFScript *) field));
		break;		

	default:
		assert(0);
		return;
	}
	//free pointer
	free(field);
}


Bool gf_sg_vrml_is_sf_field(u32 FieldType)
{
	switch (FieldType) {
	case GF_SG_VRML_SFBOOL:
	case GF_SG_VRML_SFFLOAT:
	case GF_SG_VRML_SFDOUBLE:
	case GF_SG_VRML_SFTIME:
	case GF_SG_VRML_SFINT32:
	case GF_SG_VRML_SFSTRING:
	case GF_SG_VRML_SFVEC3F:
	case GF_SG_VRML_SFVEC3D:
	case GF_SG_VRML_SFVEC2F:
	case GF_SG_VRML_SFVEC2D:
	case GF_SG_VRML_SFCOLOR:
	case GF_SG_VRML_SFCOLORRGBA:
	case GF_SG_VRML_SFROTATION:
	case GF_SG_VRML_SFIMAGE:
	case GF_SG_VRML_SFNODE:
	case GF_SG_VRML_SFURL:
	case GF_SG_VRML_SFCOMMANDBUFFER:
		return 1;
	default:
		return 0;
	}
}

/*********************************************************************
		MF Fields manipulation (alloc, realloc, GetAt)
*********************************************************************/

//return the size of fixed fields (eg no buffer in the field)
u32 gf_sg_vrml_get_sf_size(u32 FieldType)
{
	switch (FieldType) {
	case GF_SG_VRML_SFBOOL:
	case GF_SG_VRML_MFBOOL:
		return sizeof(SFBool);
	case GF_SG_VRML_SFFLOAT:
	case GF_SG_VRML_MFFLOAT:
		return sizeof(SFFloat);
	case GF_SG_VRML_SFTIME:
	case GF_SG_VRML_MFTIME:
		return sizeof(SFTime);
	case GF_SG_VRML_SFDOUBLE:
	case GF_SG_VRML_MFDOUBLE:
		return sizeof(SFDouble);
	case GF_SG_VRML_SFINT32:
	case GF_SG_VRML_MFINT32:
		return sizeof(SFInt32);
	case GF_SG_VRML_SFVEC3F:
	case GF_SG_VRML_MFVEC3F:
		return 3*sizeof(SFFloat);
	case GF_SG_VRML_SFVEC2F:
	case GF_SG_VRML_MFVEC2F:
		return 2*sizeof(SFFloat);
	case GF_SG_VRML_SFVEC3D:
	case GF_SG_VRML_MFVEC3D:
		return 3*sizeof(SFDouble);
	case GF_SG_VRML_SFCOLOR:
	case GF_SG_VRML_MFCOLOR:
		return 3*sizeof(SFFloat);
	case GF_SG_VRML_SFCOLORRGBA:
	case GF_SG_VRML_MFCOLORRGBA:
		return 4*sizeof(SFFloat);
	case GF_SG_VRML_SFROTATION:
	case GF_SG_VRML_MFROTATION:
		return 4*sizeof(SFFloat);

	//check if that works!!
	case GF_SG_VRML_SFSTRING:
	case GF_SG_VRML_MFSTRING:
		//ptr to char
		return sizeof(SFString);
	case GF_SG_VRML_SFSCRIPT:
	case GF_SG_VRML_MFSCRIPT:
		return sizeof(SFScript);
	case GF_SG_VRML_SFURL:
	case GF_SG_VRML_MFURL:
		return sizeof(SFURL);
	default:
		return 0;
	}
}

u32 gf_sg_vrml_get_sf_type(u32 FieldType)
{
	switch (FieldType) {
	case GF_SG_VRML_SFBOOL:
	case GF_SG_VRML_MFBOOL:
		return GF_SG_VRML_SFBOOL;
	case GF_SG_VRML_SFFLOAT:
	case GF_SG_VRML_MFFLOAT:
		return GF_SG_VRML_SFFLOAT;
	case GF_SG_VRML_SFDOUBLE:
	case GF_SG_VRML_MFDOUBLE:
		return GF_SG_VRML_SFDOUBLE;
	case GF_SG_VRML_SFTIME:
	case GF_SG_VRML_MFTIME:
		return GF_SG_VRML_SFTIME;
	case GF_SG_VRML_SFINT32:
	case GF_SG_VRML_MFINT32:
		return GF_SG_VRML_SFINT32;
	case GF_SG_VRML_SFVEC3F:
	case GF_SG_VRML_MFVEC3F:
		return GF_SG_VRML_SFVEC3F;
	case GF_SG_VRML_SFVEC2F:
	case GF_SG_VRML_MFVEC2F:
		return GF_SG_VRML_SFVEC2F;
	case GF_SG_VRML_SFVEC3D:
	case GF_SG_VRML_MFVEC3D:
		return GF_SG_VRML_SFVEC3D;
	case GF_SG_VRML_SFVEC2D:
	case GF_SG_VRML_MFVEC2D:
		return GF_SG_VRML_SFVEC2D;
	case GF_SG_VRML_SFCOLOR:
	case GF_SG_VRML_MFCOLOR:
		return GF_SG_VRML_SFCOLOR;
	case GF_SG_VRML_SFCOLORRGBA:
	case GF_SG_VRML_MFCOLORRGBA:
		return GF_SG_VRML_SFCOLORRGBA;
	case GF_SG_VRML_SFROTATION:
	case GF_SG_VRML_MFROTATION:
		return GF_SG_VRML_SFROTATION;

	//check if that works!!
	case GF_SG_VRML_SFSTRING:
	case GF_SG_VRML_MFSTRING:
		//ptr to char
		return GF_SG_VRML_SFSTRING;
	case GF_SG_VRML_SFSCRIPT:
	case GF_SG_VRML_MFSCRIPT:
		return GF_SG_VRML_SFSCRIPT;
	case GF_SG_VRML_SFURL:
	case GF_SG_VRML_MFURL:
		return GF_SG_VRML_SFURL;
	case GF_SG_VRML_SFNODE:
	case GF_SG_VRML_MFNODE:
		return GF_SG_VRML_SFNODE;
	default:
		return GF_SG_VRML_UNKNOWN;
	}
}

const char *gf_sg_vrml_get_event_type_name(u32 EventType, Bool forX3D)
{
	switch (EventType) {
	case GF_SG_EVENT_IN: return forX3D ? "inputOnly" : "eventIn";
	case GF_SG_EVENT_FIELD: return forX3D ? "initializeOnly" : "field";
	case GF_SG_EVENT_EXPOSED_FIELD: return forX3D ? "inputOutput" : "exposedField";
	case GF_SG_EVENT_OUT: return forX3D ? "outputOnly" : "eventOut";
	default: return "unknownEvent";
	}
}

const char *gf_sg_vrml_get_field_type_by_name(u32 FieldType)
{

	switch (FieldType) {
	case GF_SG_VRML_SFBOOL: return "SFBool";
	case GF_SG_VRML_SFFLOAT: return "SFFloat";
	case GF_SG_VRML_SFDOUBLE: return "SFDouble";
	case GF_SG_VRML_SFTIME: return "SFTime";
	case GF_SG_VRML_SFINT32: return "SFInt32";
	case GF_SG_VRML_SFSTRING: return "SFString";
	case GF_SG_VRML_SFVEC3F: return "SFVec3f";
	case GF_SG_VRML_SFVEC2F: return "SFVec2f";
	case GF_SG_VRML_SFVEC3D: return "SFVec3d";
	case GF_SG_VRML_SFVEC2D: return "SFVec2d";
	case GF_SG_VRML_SFCOLOR: return "SFColor";
	case GF_SG_VRML_SFCOLORRGBA: return "SFColorRGBA";
	case GF_SG_VRML_SFROTATION: return "SFRotation";
	case GF_SG_VRML_SFIMAGE: return "SFImage";
	case GF_SG_VRML_SFNODE: return "SFNode";
	case GF_SG_VRML_SFVEC4F: return "SFVec4f";
	case GF_SG_VRML_MFBOOL: return "MFBool";
	case GF_SG_VRML_MFFLOAT: return "MFFloat";
	case GF_SG_VRML_MFDOUBLE: return "MFDouble";
	case GF_SG_VRML_MFTIME: return "MFTime";
	case GF_SG_VRML_MFINT32: return "MFInt32";
	case GF_SG_VRML_MFSTRING: return "MFString";
	case GF_SG_VRML_MFVEC3F: return "MFVec3f";
	case GF_SG_VRML_MFVEC2F: return "MFVec2f";
	case GF_SG_VRML_MFVEC3D: return "MFVec3d";
	case GF_SG_VRML_MFVEC2D: return "MFVec2d";
	case GF_SG_VRML_MFCOLOR: return "MFColor";
	case GF_SG_VRML_MFCOLORRGBA: return "MFColorRGBA";
	case GF_SG_VRML_MFROTATION: return "MFRotation";
	case GF_SG_VRML_MFIMAGE: return "MFImage";
	case GF_SG_VRML_MFNODE: return "MFNode";
	case GF_SG_VRML_MFVEC4F: return "MFVec4f";
	case GF_SG_VRML_SFURL: return "SFURL";
	case GF_SG_VRML_MFURL: return "MFURL";
	case GF_SG_VRML_SFCOMMANDBUFFER: return "SFCommandBuffer";
	case GF_SG_VRML_SFSCRIPT: return "SFScript";
	case GF_SG_VRML_MFSCRIPT: return "MFScript";
	default: return "UnknownType";
	}
}

u32 gf_sg_field_type_by_name(char *fieldType)
{
	if (!stricmp(fieldType, "SFBool")) return GF_SG_VRML_SFBOOL;
	else if (!stricmp(fieldType, "SFFloat")) return GF_SG_VRML_SFFLOAT;
	else if (!stricmp(fieldType, "SFDouble")) return GF_SG_VRML_SFDOUBLE;
	else if (!stricmp(fieldType, "SFTime")) return GF_SG_VRML_SFTIME;
	else if (!stricmp(fieldType, "SFInt32")) return GF_SG_VRML_SFINT32;
	else if (!stricmp(fieldType, "SFString")) return GF_SG_VRML_SFSTRING;
	else if (!stricmp(fieldType, "SFVec2f")) return GF_SG_VRML_SFVEC2F;
	else if (!stricmp(fieldType, "SFVec3f")) return GF_SG_VRML_SFVEC3F;
	else if (!stricmp(fieldType, "SFVec2d")) return GF_SG_VRML_SFVEC2D;
	else if (!stricmp(fieldType, "SFVec3d")) return GF_SG_VRML_SFVEC3D;
	else if (!stricmp(fieldType, "SFColor")) return GF_SG_VRML_SFCOLOR;
	else if (!stricmp(fieldType, "SFColorRGBA")) return GF_SG_VRML_SFCOLORRGBA;
	else if (!stricmp(fieldType, "SFRotation")) return GF_SG_VRML_SFROTATION;
	else if (!stricmp(fieldType, "SFImage")) return GF_SG_VRML_SFIMAGE;
	else if (!stricmp(fieldType, "SFNode")) return GF_SG_VRML_SFNODE;

	else if (!stricmp(fieldType, "MFBool")) return GF_SG_VRML_MFBOOL;
	else if (!stricmp(fieldType, "MFFloat")) return GF_SG_VRML_MFFLOAT;
	else if (!stricmp(fieldType, "MFDouble")) return GF_SG_VRML_MFDOUBLE;
	else if (!stricmp(fieldType, "MFTime")) return GF_SG_VRML_MFTIME;
	else if (!stricmp(fieldType, "MFInt32")) return GF_SG_VRML_MFINT32;
	else if (!stricmp(fieldType, "MFString")) return GF_SG_VRML_MFSTRING;
	else if (!stricmp(fieldType, "MFVec2f")) return GF_SG_VRML_MFVEC2F;
	else if (!stricmp(fieldType, "MFVec3f")) return GF_SG_VRML_MFVEC3F;
	else if (!stricmp(fieldType, "MFVec2d")) return GF_SG_VRML_MFVEC2D;
	else if (!stricmp(fieldType, "MFVec3d")) return GF_SG_VRML_MFVEC3D;
	else if (!stricmp(fieldType, "MFColor")) return GF_SG_VRML_MFCOLOR;
	else if (!stricmp(fieldType, "MFColorRGBA")) return GF_SG_VRML_MFCOLORRGBA;
	else if (!stricmp(fieldType, "MFRotation")) return GF_SG_VRML_MFROTATION;
	else if (!stricmp(fieldType, "MFImage")) return GF_SG_VRML_MFIMAGE;
	else if (!stricmp(fieldType, "MFNode")) return GF_SG_VRML_MFNODE;

	return GF_SG_VRML_UNKNOWN;
}

//
//	Insert (+alloc) an MFField with a specified position for insertion and sets the ptr to the 
//	newly created slot
//	!! Doesnt work for MFNodes
//	InsertAt is the 0-based index for the new slot
GF_Err gf_sg_vrml_mf_insert(void *mf, u32 FieldType, void **new_ptr, u32 InsertAt)
{
	char *buffer;
	u32 FieldSize, i, k;
	GenMFField *mffield = (GenMFField *)mf;

	if (gf_sg_vrml_is_sf_field(FieldType)) return GF_BAD_PARAM;
	if (FieldType == GF_SG_VRML_MFNODE) return GF_BAD_PARAM;

	FieldSize = gf_sg_vrml_get_sf_size(FieldType);
	
	//field we can't copy
	if (!FieldSize) return GF_BAD_PARAM;
	
	//first item ever
	if (!mffield->count || !mffield->array) {
		if (mffield->array) free(mffield->array);
		mffield->array = (char*)malloc(sizeof(char)*FieldSize);
		memset(mffield->array, 0, sizeof(char)*FieldSize);
		mffield->count = 1;
		if (new_ptr) *new_ptr = mffield->array;
		return GF_OK;
	}

	//append at the end
	if (InsertAt >= mffield->count) {
		mffield->array = (char*)realloc(mffield->array, sizeof(char)*(1+mffield->count)*FieldSize);
		memset(mffield->array + mffield->count * FieldSize, 0, FieldSize);
		if (new_ptr) *new_ptr = mffield->array + mffield->count * FieldSize;
		mffield->count += 1;
		return GF_OK;
	}
	//alloc 1+itemCount
	buffer = (char*)malloc(sizeof(char)*(1+mffield->count)*FieldSize);

	//insert in the array
	k=0;
	for (i=0; i < mffield->count; i++) {
		if (InsertAt == i) {
			if (new_ptr) {
				*new_ptr = buffer + i*FieldSize;
				memset(*new_ptr, 0, sizeof(char)*FieldSize);
			}
			k = 1;
		}
		memcpy(buffer + (k+i) * FieldSize , mffield->array + i*FieldSize, FieldSize);
	}
	free(mffield->array);
	mffield->array = buffer;
	mffield->count += 1;
	return GF_OK;
}

#define MAX_MFFIELD_ALLOC		5000000
GF_EXPORT
GF_Err gf_sg_vrml_mf_alloc(void *mf, u32 FieldType, u32 NbItems)
{
	u32 FieldSize;
	GenMFField *mffield = (GenMFField *)mf;

	if (gf_sg_vrml_is_sf_field(FieldType)) return GF_BAD_PARAM;
	if (FieldType == GF_SG_VRML_MFNODE) return GF_BAD_PARAM;

	FieldSize = gf_sg_vrml_get_sf_size(FieldType);
	
	//field we can't copy
	if (!FieldSize) return GF_BAD_PARAM;
	if (NbItems>MAX_MFFIELD_ALLOC) return GF_IO_ERR;

	if (mffield->count==NbItems) return GF_OK;
	gf_sg_vrml_mf_reset(mf, FieldType);
	if (NbItems) {
		mffield->array = (char*)malloc(sizeof(char)*FieldSize*NbItems);
		memset(mffield->array, 0, sizeof(char)*FieldSize*NbItems);
	}
	mffield->count = NbItems;
	return GF_OK;
}