自学教程：C++ FIX2FLT函数代码示例

char *storage_serialize_sf(void *ptr, u32 fieldType){	char szVal[50];	switch (fieldType) {	case GF_SG_VRML_SFBOOL:		sprintf(szVal, "%d", *((SFBool *)ptr) ? 1 : 0);		return gf_strdup(szVal);	case GF_SG_VRML_SFINT32:		sprintf(szVal, "%d",  *((SFInt32 *)ptr) );		return gf_strdup(szVal);	case GF_SG_VRML_SFTIME:		sprintf(szVal, "%g", *((SFTime *)ptr) );		return gf_strdup(szVal);	case GF_SG_VRML_SFFLOAT:		sprintf(szVal, "%g", FIX2FLT( *((SFFloat *)ptr) ) );		return gf_strdup(szVal);	case GF_SG_VRML_SFVEC2F:		sprintf(szVal, "%g %g", FIX2FLT( ((SFVec2f *)ptr)->x), FIX2FLT( ((SFVec2f *)ptr)->y) );		return gf_strdup(szVal);	case GF_SG_VRML_SFVEC3F:		sprintf(szVal, "%g %g %g", FIX2FLT( ((SFVec3f *)ptr)->x), FIX2FLT( ((SFVec3f *)ptr)->y) , FIX2FLT( ((SFVec3f *)ptr)->z) );		return gf_strdup(szVal);	case GF_SG_VRML_SFSTRING:		return gf_strdup( ((SFString *)ptr)->buffer ? ((SFString *)ptr)->buffer : "");	default:		break;	}	return NULL;}

void C_DECL A_LeafCheck(mobj_t *actor){    int                 n;    actor->special1++;    if(actor->special1 >= 20)    {        P_MobjChangeState(actor, S_NULL);        return;    }    if(P_Random() > 64)    {        if(FEQUAL(actor->mom[MX], 0) && FEQUAL(actor->mom[MY], 0))        {            P_ThrustMobj(actor, actor->target->angle,                         FIX2FLT(P_Random() << 9) + 1);        }        return;    }    P_MobjChangeState(actor, S_LEAF1_8);    n = P_Random();    actor->mom[MZ] = FIX2FLT(n << 9) + 1;    P_ThrustMobj(actor, actor->target->angle, FIX2FLT(P_Random() << 9) + 2);    actor->flags |= MF_MISSILE;}

static void camera_frustum_from_matrix(GF_Camera *cam, GF_Matrix *mx){	u32 i;	cam->planes[FRUS_LEFT_PLANE].normal.x = mx->m[3] + mx->m[0];	cam->planes[FRUS_LEFT_PLANE].normal.y = mx->m[7] + mx->m[4];	cam->planes[FRUS_LEFT_PLANE].normal.z = mx->m[11] + mx->m[8];	cam->planes[FRUS_LEFT_PLANE].d = mx->m[15] + mx->m[12];	cam->planes[FRUS_RIGHT_PLANE].normal.x = mx->m[3] - mx->m[0];	cam->planes[FRUS_RIGHT_PLANE].normal.y = mx->m[7] - mx->m[4];	cam->planes[FRUS_RIGHT_PLANE].normal.z = mx->m[11] - mx->m[8];	cam->planes[FRUS_RIGHT_PLANE].d = mx->m[15] - mx->m[12];	cam->planes[FRUS_BOTTOM_PLANE].normal.x = mx->m[3] + mx->m[1];	cam->planes[FRUS_BOTTOM_PLANE].normal.y = mx->m[7] + mx->m[5];	cam->planes[FRUS_BOTTOM_PLANE].normal.z = mx->m[11] + mx->m[9];	cam->planes[FRUS_BOTTOM_PLANE].d = mx->m[15] + mx->m[13];	cam->planes[FRUS_TOP_PLANE].normal.x = mx->m[3] - mx->m[1];	cam->planes[FRUS_TOP_PLANE].normal.y = mx->m[7] - mx->m[5];	cam->planes[FRUS_TOP_PLANE].normal.z = mx->m[11] - mx->m[9];	cam->planes[FRUS_TOP_PLANE].d = mx->m[15] - mx->m[13];	cam->planes[FRUS_FAR_PLANE].normal.x = mx->m[3] - mx->m[2];	cam->planes[FRUS_FAR_PLANE].normal.y = mx->m[7] - mx->m[6];	cam->planes[FRUS_FAR_PLANE].normal.z = mx->m[11] - mx->m[10];	cam->planes[FRUS_FAR_PLANE].d = mx->m[15] - mx->m[14];	cam->planes[FRUS_NEAR_PLANE].normal.x = mx->m[3] + mx->m[2];	cam->planes[FRUS_NEAR_PLANE].normal.y = mx->m[7] + mx->m[6];	cam->planes[FRUS_NEAR_PLANE].normal.z = mx->m[11] + mx->m[10];	cam->planes[FRUS_NEAR_PLANE].d = mx->m[15] + mx->m[14];	for (i=0; i<6; ++i) {#ifdef GPAC_FIXED_POINT		/*after some testing, it's just safer to move back to float here, the smallest drift will		result in completely wrong culling...*/		Float vx, vy, vz, nor;		vx = FIX2FLT(cam->planes[i].normal.x);		vy = FIX2FLT(cam->planes[i].normal.y);		vz = FIX2FLT(cam->planes[i].normal.z);		nor = (Float) sqrt(vx*vx + vy*vy + vz*vz);		vx /= nor;		vy /= nor;		vz /= nor;		cam->planes[i].d = FLT2FIX (FIX2FLT(cam->planes[i].d) / nor);		cam->planes[i].normal.x = FLT2FIX(vx);		cam->planes[i].normal.y = FLT2FIX(vy);		cam->planes[i].normal.z = FLT2FIX(vz);#else		Float len = (Float)(1.0f / gf_vec_len(cam->planes[i].normal));		cam->planes[i].normal = gf_vec_scale(cam->planes[i].normal, len);		cam->planes[i].d *= len;#endif		/*compute p-vertex idx*/		cam->p_idx[i] = gf_plane_get_p_vertex_idx(&cam->planes[i]);	}}

	/**	 * Debug print	 */	void print ( void )	{		lprintfln( "{%f, %f, %f}",				   FIX2FLT( m_x ),				   FIX2FLT( m_y ),				   FIX2FLT( m_z ) );	}

void C_DECL A_FogMove(mobj_t* actor){    coord_t speed = (coord_t) actor->args[0];    uint an;    if(!(actor->args[4]))        return;    if(actor->args[3]-- <= 0)    {        P_MobjChangeStateNoAction(actor, P_GetState(actor->type, SN_DEATH));        return;    }    // Move the fog slightly/slowly up and down. Some fog patches are supposed    // to move higher and some are supposed to stay close to the ground.    // Unlike in the original Hexen, the move is done by applying momentum    // to the cloud so that the movement is smooth.    if((actor->args[3] % 4) == 0)    {        uint weaveindex = actor->special2;        actor->mom[VZ] = FLOATBOBOFFSET(weaveindex) / TICSPERSEC;        actor->special2 = (weaveindex + 1) & 63;    }    an = actor->angle >> ANGLETOFINESHIFT;    actor->mom[MX] = speed * FIX2FLT(finecosine[an]);    actor->mom[MY] = speed * FIX2FLT(finesine[an]);}

static void c2d_gl_fill_alpha(void *cbk, u32 x, u32 y, u32 run_h_len, GF_Color color, u8 alpha){#if defined(GPAC_USE_OGL_ES)	GLfloat line[4];	line[0] = FIX2FLT(x);	line[1] = FIX2FLT(y);	line[2] = FIX2FLT(x+run_h_len);	line[3] = line[1];	glEnable(GL_BLEND);	glColor4ub(GF_COL_R(color), GF_COL_G(color), GF_COL_B(color), (u8) alpha);	glVertexPointer(2, GL_FLOAT, 0, line);	glEnableClientState(GL_VERTEX_ARRAY);	glDrawArrays(GL_LINES, 0, 2);	glDisableClientState(GL_VERTEX_ARRAY);	glDisable(GL_BLEND);#else	glEnable(GL_BLEND);	glColor4ub(GF_COL_R(color), GF_COL_G(color), GF_COL_B(color), (u8) alpha);	glBegin(GL_LINES);	glVertex2i(x,y);	glVertex2i(x+run_h_len,y);	glEnd();	glDisable(GL_BLEND);#endif}

void C_DECL A_PotteryExplode(mobj_t* actor){    int i, maxBits = (P_Random() & 3) + 3;    mobj_t* potteryBit;    for(i = 0; i < maxBits; ++i)    {        if((potteryBit = P_SpawnMobj(MT_POTTERYBIT1, actor->origin, P_Random() << 24, 0)))        {            P_MobjChangeState(potteryBit, P_GetState(potteryBit->type, SN_SPAWN) + (P_Random() % 5));            potteryBit->mom[MZ] = FIX2FLT(((P_Random() & 7) + 5) * (3 * FRACUNIT / 4));            potteryBit->mom[MX] = FIX2FLT((P_Random() - P_Random()) << 10);            potteryBit->mom[MY] = FIX2FLT((P_Random() - P_Random()) << 10);        }    }    S_StartSound(SFX_POTTERY_EXPLODE, potteryBit);    if(actor->args[0])    {        // Spawn an item.        if(!G_Ruleset_NoMonsters() ||                !(MOBJINFO[TranslateThingType[actor->args[0]]].                  flags & MF_COUNTKILL))        {            // Only spawn monsters if not -nomonsters.            P_SpawnMobj(TranslateThingType[actor->args[0]], actor->origin,                        actor->angle, 0);        }    }    P_MobjRemove(actor, false);}

void C_DECL A_LeafSpawn(mobj_t* actor){    coord_t pos[3];    mobj_t* mo;    int i;    for(i = (P_Random() & 3) + 1; i; i--)    {        pos[VX] = actor->origin[VX];        pos[VY] = actor->origin[VY];        pos[VZ] = actor->origin[VZ];        pos[VX] += FIX2FLT((P_Random() - P_Random()) << 14);        pos[VY] += FIX2FLT((P_Random() - P_Random()) << 14);        pos[VZ] += FIX2FLT(P_Random() << 14);        /// @todo  We should not be using the original indices to determine        ///         the mobjtype. Use a local table instead.        if((mo = P_SpawnMobj(MT_LEAF1 + (P_Random() & 1), pos,                             actor->angle, 0)))        {            P_ThrustMobj(mo, actor->angle, FIX2FLT(P_Random() << 9) + 3);            mo->target = actor;            mo->special1 = 0;        }    }}

static void swf_svg_print_color(SWFReader *read, u32 ARGB){	SFColor val;	val.red = INT2FIX((ARGB>>16)&0xFF) / 255*100;	val.green = INT2FIX((ARGB>>8)&0xFF) / 255*100;	val.blue = INT2FIX((ARGB)&0xFF) / 255*100;	swf_svg_print(read, "rgb(%g%%,%g%%,%g%%)", FIX2FLT(val.red), FIX2FLT(val.green), FIX2FLT(val.blue));}

void BE_WriteSFFloat(GF_BifsEncoder *codec, Fixed val, GF_BitStream *bs, char *com){	if (codec->ActiveQP && codec->ActiveQP->useEfficientCoding) {		gf_bifs_enc_mantissa_float(codec, val, bs);	} else {		gf_bs_write_float(bs, FIX2FLT(val));		GF_LOG(GF_LOG_DEBUG, GF_LOG_CODING, ("[BIFS] SFFloat/t/t32/t/t%g/t/t%s/n", FIX2FLT(val), com ? com : "") );	}}

	void print ( void )	{		for ( int i = 0; i < 4; i++ )			printf( "{%f, %f, %f, %f}",					FIX2FLT( m_matrix[i][0] ),					FIX2FLT( m_matrix[i][1] ),					FIX2FLT( m_matrix[i][2] ),					FIX2FLT( m_matrix[i][3] ) );	}

static Bool gf_cache_remove_entry(GF_Compositor *compositor, GF_Node *node, GroupingNode2D *group){	u32 bytes_remove = 0;	GF_List *cache_candidates = compositor->cached_groups;	/*auto mode*/	if (!group) {		group = gf_list_get(cache_candidates, 0);		if (!group) return 0;		/*remove entry*/		gf_list_rem(cache_candidates, 0);		node = NULL;	} else {		/*remove entry if present*/		if (gf_list_del_item(cache_candidates, group)<0)			return 0;	}	/*disable the caching flag of the group if it was marked as such*/	if(group->flags & GROUP_IS_CACHABLE) {		group->flags &= ~GROUP_IS_CACHABLE;		/*the discarded bytes*/		bytes_remove = group->cached_size;	}	/*indicates cache destruction for next frame*/	if (group->cache && (group->flags & GROUP_IS_CACHED)) {		group->flags &= ~GROUP_IS_CACHED;		/*the discarded bytes*/		bytes_remove = group->cached_size;	}	if (bytes_remove == 0) return 0;	assert(compositor->video_cache_current_size >= bytes_remove);	compositor->video_cache_current_size -= bytes_remove;	GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("[CACHE] Removing cache %s:/t Objects: %d/tSlope: %g/tBytes: %d/tTime: %d/n",										gf_node_get_log_name(node),										group->nb_objects,										FIX2FLT(group->priority),										group->cached_size,										FIX2FLT(group->traverse_time)));	GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("[CACHE] Status (B): Max: %d/tUsed: %d/tNb Groups: %d/n",								compositor->video_cache_max_size,								compositor->video_cache_current_size,								gf_list_count(compositor->cached_groups)								));	return 1;}

/** * Get a pointer to the value of a variable. Added for 64-bit support. */void *G_GetVariable(int id){    static float bob[2];    switch(id)    {    case DD_GAME_NAME:        return GAMENAMETEXT;    case DD_GAME_NICENAME:        return GAME_NICENAME;    case DD_GAME_ID:        return GAMENAMETEXT " " GAME_VERSION_TEXT;    case DD_GAME_MODE:        return gameModeString;    case DD_GAME_CONFIG:        return gameConfigString;    case DD_VERSION_SHORT:        return GAME_VERSION_TEXT;    case DD_VERSION_LONG:        return GAME_VERSION_TEXTLONG "/n" GAME_DETAILS;    case DD_ACTION_LINK:        return actionlinks;    case DD_XGFUNC_LINK:        return xgClasses;    case DD_PSPRITE_BOB_X:        bob[VX] = 1 + (cfg.bobWeapon * players[CONSOLEPLAYER].bob) *            FIX2FLT(finecosine[(128 * mapTime) & FINEMASK]);        return &bob[VX];    case DD_PSPRITE_BOB_Y:        bob[VY] = 32 + (cfg.bobWeapon * players[CONSOLEPLAYER].bob) *            FIX2FLT(finesine[(128 * mapTime) & FINEMASK & (FINEANGLES / 2 - 1)]);        return &bob[VY];    default:        break;    }    // ID not recognized, return NULL.    return 0;}

static void swf_svg_print_shape_record_to_path_d(SWFReader *read, SWFShapeRec *srec){	u32     pt_idx;	u32     i;	pt_idx = 0;	for (i=0; i<srec->path->nbType; i++) {		switch (srec->path->types[i]) {		/*moveTo*/		case 0:			swf_svg_print(read, "M%g,%g", FIX2FLT(srec->path->pts[pt_idx].x), FIX2FLT(srec->path->pts[pt_idx].y));			pt_idx++;			break;		/*lineTo*/		case 1:			swf_svg_print(read, "L%g,%g", FIX2FLT(srec->path->pts[pt_idx].x), FIX2FLT(srec->path->pts[pt_idx].y));			pt_idx++;			break;		/*curveTo*/		case 2:			swf_svg_print(read, "Q%g,%g", FIX2FLT(srec->path->pts[pt_idx].x), FIX2FLT(srec->path->pts[pt_idx].y));			pt_idx++;			swf_svg_print(read, ",%g,%g", FIX2FLT(srec->path->pts[pt_idx].x), FIX2FLT(srec->path->pts[pt_idx].y));			pt_idx++;			break;		}	}}

static GF_Err gdip_set_vertex_center (GF_STENCIL _this, Fixed cx, Fixed cy, u32 color){	GpStatus ret;	GPSTEN();	CHECK_RET(GF_STENCIL_VERTEX_GRADIENT);	if (!_sten->pRadial) return GF_BAD_PARAM;	_sten->center.X = FIX2FLT(cx);	_sten->center.Y = FIX2FLT(cy);	ret = GdipSetPathGradientCenterPoint(_sten->pRadial, &_sten->center);	ret = GdipSetPathGradientCenterColor(_sten->pRadial, (ARGB) color);	return GF_OK;}

void C_DECL A_Quake(mobj_t* actor){    angle_t angle;    player_t* player;    mobj_t* victim;    int richters = actor->args[0];    int playnum;    coord_t dist;    if(actor->args[1]-- > 0)    {        for(playnum = 0; playnum < MAXPLAYERS; ++playnum)        {            player = &players[playnum];            if(!players[playnum].plr->inGame)                continue;            victim = player->plr->mo;            dist =  M_ApproxDistance(actor->origin[VX] - victim->origin[VX],                                     actor->origin[VY] - victim->origin[VY]);            dist = FIX2FLT(FLT2FIX(dist) >> (FRACBITS + 6));            // Tested in tile units (64 pixels).            if(dist < FIX2FLT(actor->args[3])) // In tremor radius.            {                localQuakeHappening[playnum] = richters;                players[playnum].update |= PSF_LOCAL_QUAKE;            }            // Check if in damage radius.            if(dist < FIX2FLT(actor->args[2]) &&                    victim->origin[VZ] <= victim->floorZ)            {                if(P_Random() < 50)                {                    P_DamageMobj(victim, NULL, NULL, HITDICE(1), false);                }                // Thrust player around.                angle = victim->angle + ANGLE_1 * P_Random();                P_ThrustMobj(victim, angle, FIX2FLT(richters << (FRACBITS - 1)));            }        }    }    else    {        for(playnum = 0; playnum < MAXPLAYERS; playnum++)

static char *audiobuffer_fetch_frame(void *callback, u32 *size, u32 audio_delay_ms){	u32 blockAlign;	AudioBufferStack *st = (AudioBufferStack *) gf_node_get_private( ((GF_AudioInput *) callback)->owner);	M_AudioBuffer *ab = (M_AudioBuffer*)st->output.owner;	if (!st->is_init) return NULL;	if (!st->buffer) {		st->done = 0;		st->buffer_size = (u32) ceil(FIX2FLT(ab->length) * st->output.input_ifce.bps*st->output.input_ifce.samplerate*st->output.input_ifce.chan/8);		blockAlign = gf_mixer_get_block_align(st->am);		/*BLOCK ALIGN*/		while (st->buffer_size%blockAlign) st->buffer_size++;		st->buffer = (char*)gf_malloc(sizeof(char) * st->buffer_size);		memset(st->buffer, 0, sizeof(char) * st->buffer_size);		st->read_pos = st->write_pos = 0;	}	if (st->done) return NULL;	/*even if not active, fill the buffer*/	if (st->write_pos < st->buffer_size) {		u32 written;		while (1) {			/*just try to completely fill it*/			written = gf_mixer_get_output(st->am, st->buffer + st->write_pos, st->buffer_size - st->write_pos, 0);			if (!written) break;			st->write_pos += written;			assert(st->write_pos<=st->buffer_size);		}	}	/*not playing*/	if (! ab->isActive) return NULL;	*size = st->write_pos - st->read_pos;	return st->buffer + st->read_pos;}

/*guarentee the tr_state->candidate has the lowest delta value*/static void group_cache_insert_entry(GF_Node *node, GroupingNode2D *group, GF_TraverseState *tr_state){	u32 i, count;	GF_List *cache_candidates = tr_state->visual->compositor->cached_groups;	GroupingNode2D *current;	current = NULL;	count = gf_list_count(cache_candidates);	for (i=0; i<count; i++) {		current = gf_list_get(cache_candidates, i);		/*if entry's priority is higher than our group, insert our group here*/		if (current->priority >= group->priority) {			gf_list_insert(cache_candidates, group, i);			break;		}	}	if (i==count)		gf_list_add(cache_candidates, group);	tr_state->visual->compositor->video_cache_current_size += group->cached_size;	/*log the information*/	GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("[CACHE]/tAdding object %s/tObjects: %d/tSlope: %g/tSize: %d/tTime: %d/n",								gf_node_get_log_name(node),								group->nb_objects,								FIX2FLT(group->priority),								group->cached_size,								group->traverse_time));	GF_LOG(GF_LOG_DEBUG, GF_LOG_CACHE, ("[CACHE] Status (KB): Max: %d/tUsed: %d/tNb Groups: %d/n",								tr_state->visual->compositor->video_cache_max_size,								tr_state->visual->compositor->video_cache_current_size,								gf_list_count(tr_state->visual->compositor->cached_groups)								));}

static int SV_ReadPlat(plat_t *plat){/* Original Heretic format:typedef struct {    thinker_t   thinker;        // was 12 bytes    Sector     *sector;    fixed_t     speed;    fixed_t     low;    fixed_t     high;    int         wait;    int         count;    platstate_e     status;         // was 32bit int    platstate_e     oldStatus;      // was 32bit int    boolean     crush;    int         tag;    plattype_e  type;           // was 32bit int} v13_plat_t;*/    byte temp[SIZEOF_V13_THINKER_T];    // Padding at the start (an old thinker_t struct)    Reader_Read(svReader, &temp, SIZEOF_V13_THINKER_T);    // Start of used data members.    // A 32bit pointer to sector, serialized.    plat->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));    if(!plat->sector)        Con_Error("tc_plat: bad sector number/n");    plat->speed = FIX2FLT(Reader_ReadInt32(svReader));    plat->low = FIX2FLT(Reader_ReadInt32(svReader));    plat->high = FIX2FLT(Reader_ReadInt32(svReader));    plat->wait = Reader_ReadInt32(svReader);    plat->count = Reader_ReadInt32(svReader);    plat->state = Reader_ReadInt32(svReader);    plat->oldState = Reader_ReadInt32(svReader);    plat->crush = Reader_ReadInt32(svReader);    plat->tag = Reader_ReadInt32(svReader);    plat->type = Reader_ReadInt32(svReader);    plat->thinker.function = T_PlatRaise;    if(!(temp + V13_THINKER_T_FUNC_OFFSET))        Thinker_SetStasis(&plat->thinker, true);    P_ToXSector(plat->sector)->specialData = T_PlatRaise;    return true; // Add this thinker.}

void C_DECL A_LeafThrust(mobj_t *actor){    if(P_Random() > 96)    {        return;    }    actor->mom[MZ] += FIX2FLT(P_Random() << 9) + 1;}

static GF_Err gdip_set_linear_gradient (GF_STENCIL _this, Fixed start_x, Fixed start_y, Fixed end_x, Fixed end_y){	GPSTEN();	CHECK_RET(GF_STENCIL_LINEAR_GRADIENT);	if (_sten->pLinear) GdipDeleteBrush(_sten->pLinear);	_sten->start.X = FIX2FLT(start_x);	_sten->start.Y = FIX2FLT(start_y);	_sten->end.X = FIX2FLT(end_x);	_sten->end.Y = FIX2FLT(end_y);	GdipCreateLineBrush(&_sten->start, &_sten->end, 0xFF000000, 0xFFFFFFFF, WrapModeTile, &_sten->pLinear);	if (!_sten->pLinearMat) GdipCreateMatrix(&_sten->pLinearMat);	GdipGetLineTransform(_sten->pLinear, _sten->pLinearMat);	_sten->needs_rebuild = GF_TRUE;	return GF_OK;}

static int SV_ReadFloor(floor_t *floor){/* Original Heretic format:typedef struct {    thinker_t   thinker;        // was 12 bytes    floortype_e type;           // was 32bit int    boolean     crush;    Sector     *sector;    int         direction;    int         newspecial;    short       texture;    fixed_t     floordestheight;    fixed_t     speed;} v13_floormove_t;*/    Uri *newTextureUrn;    // Padding at the start (an old thinker_t struct)    Reader_Read(svReader, NULL, SIZEOF_V13_THINKER_T);    // Start of used data members.    floor->type = Reader_ReadInt32(svReader);    floor->crush = Reader_ReadInt32(svReader);    // A 32bit pointer to sector, serialized.    floor->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));    if(!floor->sector)        Con_Error("tc_floor: bad sector number/n");    floor->state = (int) Reader_ReadInt32(svReader);    floor->newSpecial = Reader_ReadInt32(svReader);    newTextureUrn = readTextureUrn(svReader, "Flats");    floor->material = DD_MaterialForTextureUri(newTextureUrn);    Uri_Delete(newTextureUrn);    floor->floorDestHeight = FIX2FLT(Reader_ReadInt32(svReader));    floor->speed = FIX2FLT(Reader_ReadInt32(svReader));    floor->thinker.function = T_MoveFloor;    P_ToXSector(floor->sector)->specialData = T_MoveFloor;    return true; // Add this thinker.}

void P_AnimateSurfaces(void){	int     i;	line_t *line;	// Update scrolling textures	for(i = 0; i < numlinespecials; i++)	{		line = linespeciallist[i];		switch (line->special)		{		case 100:				// Scroll_Texture_Left			sides[line->sidenum[0]].textureoffset += line->arg1 << 10;			break;		case 101:				// Scroll_Texture_Right			sides[line->sidenum[0]].textureoffset -= line->arg1 << 10;			break;		case 102:				// Scroll_Texture_Up			sides[line->sidenum[0]].rowoffset += line->arg1 << 10;			break;		case 103:				// Scroll_Texture_Down			sides[line->sidenum[0]].rowoffset -= line->arg1 << 10;			break;		}	}	// Update sky column offsets	Sky1ColumnOffset += Sky1ScrollDelta;	Sky2ColumnOffset += Sky2ScrollDelta;	Rend_SkyParams(1, DD_OFFSET, FIX2FLT(Sky1ColumnOffset));	Rend_SkyParams(0, DD_OFFSET, FIX2FLT(Sky2ColumnOffset));	if(LevelHasLightning)	{		if(!NextLightningFlash || LightningFlash)		{			P_LightningFlash();		}		else		{			NextLightningFlash--;		}	}}

static int SV_ReadCeiling(ceiling_t *ceiling){/* Original Heretic format:typedef struct {    thinker_t thinker; ///< 12 bytes    ceilingtype_e type; ///< 32bit int    Sector* sector;    fixed_t bottomheight, topheight;    fixed_t speed;    boolean crush;    int direction; /// 1= up, 0= waiting, -1= down    int tag'    int olddirection;} v13_ceiling_t;*/    byte temp[SIZEOF_V13_THINKER_T];    // Padding at the start (an old thinker_t struct)    Reader_Read(svReader, &temp, SIZEOF_V13_THINKER_T);    // Start of used data members.    ceiling->type = Reader_ReadInt32(svReader);    // A 32bit pointer to sector, serialized.    ceiling->sector = P_ToPtr(DMU_SECTOR, Reader_ReadInt32(svReader));    if(!ceiling->sector)        Con_Error("tc_ceiling: bad sector number/n");    ceiling->bottomHeight = FIX2FLT(Reader_ReadInt32(svReader));    ceiling->topHeight    = FIX2FLT(Reader_ReadInt32(svReader));    ceiling->speed        = FIX2FLT(Reader_ReadInt32(svReader));    ceiling->crush        = Reader_ReadInt32(svReader);    ceiling->state        = (Reader_ReadInt32(svReader) == -1? CS_DOWN : CS_UP);    ceiling->tag          = Reader_ReadInt32(svReader);    ceiling->oldState     = (Reader_ReadInt32(svReader) == -1? CS_DOWN : CS_UP);    ceiling->thinker.function = T_MoveCeiling;    if(!(temp + V13_THINKER_T_FUNC_OFFSET))        Thinker_SetStasis(&ceiling->thinker, true);    P_ToXSector(ceiling->sector)->specialData = T_MoveCeiling;    return true; // Add this thinker.}

static GF_Err gdip_get_font_info(GF_FontReader *dr, char **font_name, s32 *em_size, s32 *ascent, s32 *descent, s32 *underline, s32 *line_spacing, s32 *max_advance_h, s32 *max_advance_v){	UINT16 val, em;	FontPriv *ctx = (FontPriv *)dr->udta;	*font_name = NULL;	*em_size = *ascent = *descent = *line_spacing = *max_advance_h = *max_advance_v = 0;	if (!ctx->font) return GF_BAD_PARAM;	GdipGetEmHeight(ctx->font, ctx->font_style, &em);	*em_size = (s32) em;	GdipGetCellAscent(ctx->font, ctx->font_style, &val);	ctx->ascent = (Float) val;	*ascent = (s32) val;	GdipGetCellDescent(ctx->font, ctx->font_style, &val);	*descent = (s32) val; *descent *= -1;	ctx->descent = -1 * (Float) val;	*underline = *descent / 2;	GdipGetLineSpacing(ctx->font, ctx->font_style, &val);	*line_spacing = (s32) val;	*max_advance_v = *ascent - *descent;	unsigned short test_str[4];	Fixed w, h, w2;	ctx->em_size = (Float) *em_size;	test_str[0] = (unsigned short) '_';	test_str[1] = (unsigned short) '/0';	gdip_get_text_size(dr, test_str, &w, &h);	ctx->underscore_width = FIX2FLT(w);	test_str[0] = (unsigned short) '_';	test_str[1] = (unsigned short) ' ';	test_str[2] = (unsigned short) '_';	test_str[3] = (unsigned short) '/0';	gdip_get_text_size(dr, test_str, &w2, &h);	ctx->whitespace_width = FIX2FLT(w2 - 2*w);	*max_advance_h = (s32) MAX(ctx->underscore_width, ctx->whitespace_width);	return GF_OK;}