Пример #1
0
void PLAYERS::render_hand(TEE_RENDER_INFO *info, vec2 center_pos, vec2 dir, float angle_offset, vec2 post_rot_offset)
{
	// for drawing hand
	//const skin *s = skin_get(skin_id);
	
	float basesize = 10.0f;
	//dir = normalize(hook_pos-pos);

	vec2 hand_pos = center_pos + dir;
	float angle = get_angle(dir);
	if (dir.x < 0)
		angle -= angle_offset;
	else
		angle += angle_offset;

	vec2 dirx = dir;
	vec2 diry(-dir.y,dir.x);

	if (dir.x < 0)
		diry = -diry;

	hand_pos += dirx * post_rot_offset.x;
	hand_pos += diry * post_rot_offset.y;

	//gfx_texture_set(data->images[IMAGE_CHAR_DEFAULT].id);
	gfx_texture_set(info->texture);
	gfx_quads_begin();
	gfx_setcolor(info->color_body.r, info->color_body.g, info->color_body.b, info->color_body.a);

	// two passes
	for (int i = 0; i < 2; i++)
	{
		bool outline = i == 0;

		select_sprite(outline?SPRITE_TEE_HAND_OUTLINE:SPRITE_TEE_HAND, 0, 0, 0);
		gfx_quads_setrotation(angle);
		gfx_quads_draw(hand_pos.x, hand_pos.y, 2*basesize, 2*basesize);
	}

	gfx_quads_setrotation(0);
	gfx_quads_end();
}
Пример #2
0
void PLAYERS::render_player(
	const NETOBJ_CHARACTER *prev_char,
	const NETOBJ_CHARACTER *player_char,
	const NETOBJ_PLAYER_INFO *prev_info,
	const NETOBJ_PLAYER_INFO *player_info
	)
{
	NETOBJ_CHARACTER prev;
	NETOBJ_CHARACTER player;
	prev = *prev_char;
	player = *player_char;

	NETOBJ_PLAYER_INFO info = *player_info;
	TEE_RENDER_INFO render_info = gameclient.clients[info.cid].render_info;

	// check for teamplay modes
	bool new_tick = gameclient.new_tick;

	// check for ninja	
	if ( player.weapon == WEAPON_NINJA ) {
		// change the skin for the player to the ninja
		int skin = gameclient.skins->find("x_ninja");
		
		if (skin != -1) {
			render_info.texture = gameclient.skins->get( skin )->org_texture;
			render_info.color_body = vec4( 1,1,1,1 );
			render_info.color_feet = vec4( 1,1,1,1 );
		}	
	}
	
	// set size
	render_info.size = 64.0f;

	float intratick = client_intratick();
	
	if(player.health < 0) // dont render dead players
		return;

	float angle = mix((float)prev.angle, (float)player.angle, intratick)/256.0f;
	
	//float angle = 0;
	
	// just use the direct input if it's local player we are rendering
	if(info.local && client_state() != CLIENTSTATE_DEMOPLAYBACK)
		angle = get_angle(gameclient.controls->mouse_pos);
	
	// use preditect players if needed
	if(info.local && config.cl_predict && client_state() != CLIENTSTATE_DEMOPLAYBACK)
	{
		if ( gameclient.snap.local_character && ( gameclient.snap.local_character->health >= 0 ) ) {
			// apply predicted results
			gameclient.predicted_char.write(&player);
			gameclient.predicted_prev_char.write(&prev);
			intratick = client_predintratick();
			new_tick = gameclient.new_predicted_tick;
		}
	}
	
	vec2 direction = get_direction((int)(angle*256.0f));
	vec2 position = mix(vec2(prev.x, prev.y), vec2(player.x, player.y), intratick);
	vec2 vel = mix(vec2(prev.vx/256.0f, prev.vy/256.0f), vec2(player.vx/256.0f, player.vy/256.0f), intratick);
	
	gameclient.flow->add(position, vel*100.0f, 10.0f);
	
	render_info.got_airjump = player.jumped&2?0:1;
	
	
	// detect events
	if(new_tick)
	{
		// detect air jump
		if(!render_info.got_airjump && !(prev.jumped&2))
			gameclient.effects->air_jump(position);
	}

	if(prev.health < 0) // Don't flicker from previous position
		position = vec2(player.x, player.y);

	bool stationary = player.vx < 1 && player.vx > -1;
	bool inair = col_check_point(player.x, player.y+16) == 0;
	bool want_other_dir = (player.direction == -1 && vel.x > 0) || (player.direction == 1 && vel.x < 0);

	// evaluate animation
	float walk_time = fmod(position.x, 100.0f)/100.0f;
	ANIMSTATE state;
	state.set(&data->animations[ANIM_BASE], 0);

	if(inair)
		state.add(&data->animations[ANIM_INAIR], 0, 1.0f); // TODO: some sort of time here
	else if(stationary)
		state.add(&data->animations[ANIM_IDLE], 0, 1.0f); // TODO: some sort of time here
	else if(!want_other_dir)
		state.add(&data->animations[ANIM_WALK], walk_time, 1.0f);

	if (player.weapon == WEAPON_HAMMER)
	{
		float ct = (client_prevtick()-player.attacktick)/(float)SERVER_TICK_SPEED + client_ticktime();
		state.add(&data->animations[ANIM_HAMMER_SWING], clamp(ct*5.0f,0.0f,1.0f), 1.0f);
	}
	if (player.weapon == WEAPON_NINJA)
	{
		float ct = (client_prevtick()-player.attacktick)/(float)SERVER_TICK_SPEED + client_ticktime();
		state.add(&data->animations[ANIM_NINJA_SWING], clamp(ct*2.0f,0.0f,1.0f), 1.0f);
	}
	
	// do skidding
	if(!inair && want_other_dir && length(vel*50) > 500.0f)
	{
		static int64 skid_sound_time = 0;
		if(time_get()-skid_sound_time > time_freq()/10)
		{
			gameclient.sounds->play(SOUNDS::CHN_WORLD, SOUND_PLAYER_SKID, 0.25f, position);
			skid_sound_time = time_get();
		}
		
		gameclient.effects->skidtrail(
			position+vec2(-player.direction*6,12),
			vec2(-player.direction*100*length(vel),-50)
		);
	}

	// draw hook
	if (prev.hook_state>0 && player.hook_state>0)
	{
		gfx_texture_set(data->images[IMAGE_GAME].id);
		gfx_quads_begin();
		//gfx_quads_begin();

		vec2 pos = position;
		vec2 hook_pos;
		
		if(player_char->hooked_player != -1)
		{
			if(gameclient.snap.local_info && player_char->hooked_player == gameclient.snap.local_info->cid)
			{
				hook_pos = mix(vec2(gameclient.predicted_prev_char.pos.x, gameclient.predicted_prev_char.pos.y),
					vec2(gameclient.predicted_char.pos.x, gameclient.predicted_char.pos.y), client_predintratick());
			}
			else
				hook_pos = mix(vec2(prev_char->hook_x, prev_char->hook_y), vec2(player_char->hook_x, player_char->hook_y), client_intratick());
		}
		else
			hook_pos = mix(vec2(prev.hook_x, prev.hook_y), vec2(player.hook_x, player.hook_y), intratick);

		float d = distance(pos, hook_pos);
		vec2 dir = normalize(pos-hook_pos);

		gfx_quads_setrotation(get_angle(dir)+pi);

		// render head
		select_sprite(SPRITE_HOOK_HEAD);
		gfx_quads_draw(hook_pos.x, hook_pos.y, 24,16);

		// render chain
		select_sprite(SPRITE_HOOK_CHAIN);
		int i = 0;
		for(float f = 24; f < d && i < 1024; f += 24, i++)
		{
			vec2 p = hook_pos + dir*f;
			gfx_quads_draw(p.x, p.y,24,16);
		}

		gfx_quads_setrotation(0);
		gfx_quads_end();

		render_hand(&render_info, position, normalize(hook_pos-pos), -pi/2, vec2(20, 0));
	}

	// draw gun
	{
		gfx_texture_set(data->images[IMAGE_GAME].id);
		gfx_quads_begin();
		gfx_quads_setrotation(state.attach.angle*pi*2+angle);

		// normal weapons
		int iw = clamp(player.weapon, 0, NUM_WEAPONS-1);
		select_sprite(data->weapons.id[iw].sprite_body, direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);

		vec2 dir = direction;
		float recoil = 0.0f;
		vec2 p;
		if (player.weapon == WEAPON_HAMMER)
		{
			// Static position for hammer
			p = position + vec2(state.attach.x, state.attach.y);
			p.y += data->weapons.id[iw].offsety;
			// if attack is under way, bash stuffs
			if(direction.x < 0)
			{
				gfx_quads_setrotation(-pi/2-state.attach.angle*pi*2);
				p.x -= data->weapons.id[iw].offsetx;
			}
			else
			{
				gfx_quads_setrotation(-pi/2+state.attach.angle*pi*2);
			}
			draw_sprite(p.x, p.y, data->weapons.id[iw].visual_size);
		}
		else if (player.weapon == WEAPON_NINJA)
		{
			p = position;
			p.y += data->weapons.id[iw].offsety;

			if(direction.x < 0)
			{
				gfx_quads_setrotation(-pi/2-state.attach.angle*pi*2);
				p.x -= data->weapons.id[iw].offsetx;
				gameclient.effects->powerupshine(p+vec2(32,0), vec2(32,12));
			}
			else
			{
				gfx_quads_setrotation(-pi/2+state.attach.angle*pi*2);
				gameclient.effects->powerupshine(p-vec2(32,0), vec2(32,12));
			}
			draw_sprite(p.x, p.y, data->weapons.id[iw].visual_size);

			// HADOKEN
			if ((client_tick()-player.attacktick) <= (SERVER_TICK_SPEED / 6) && data->weapons.id[iw].num_sprite_muzzles)
			{
				int itex = rand() % data->weapons.id[iw].num_sprite_muzzles;
				float alpha = 1.0f;
				if (alpha > 0.0f && data->weapons.id[iw].sprite_muzzles[itex])
				{
					vec2 dir = vec2(player_char->x,player_char->y) - vec2(prev_char->x, prev_char->y);
					dir = normalize(dir);
					float hadokenangle = get_angle(dir);
					gfx_quads_setrotation(hadokenangle);
					//float offsety = -data->weapons[iw].muzzleoffsety;
					select_sprite(data->weapons.id[iw].sprite_muzzles[itex], 0);
					vec2 diry(-dir.y,dir.x);
					p = position;
					float offsetx = data->weapons.id[iw].muzzleoffsetx;
					p -= dir * offsetx;
					draw_sprite(p.x, p.y, 160.0f);
				}
			}
		}
		else
		{
			// TODO: should be an animation
			recoil = 0;
			float a = (client_tick()-player.attacktick+intratick)/5.0f;
			if(a < 1)
				recoil = sinf(a*pi);
			p = position + dir * data->weapons.id[iw].offsetx - dir*recoil*10.0f;
			p.y += data->weapons.id[iw].offsety;
			draw_sprite(p.x, p.y, data->weapons.id[iw].visual_size);
		}

		if (player.weapon == WEAPON_GUN || player.weapon == WEAPON_SHOTGUN)
		{
			// check if we're firing stuff
			if(data->weapons.id[iw].num_sprite_muzzles)//prev.attackticks)
			{
				float alpha = 0.0f;
				int phase1tick = (client_tick() - player.attacktick);
				if (phase1tick < (data->weapons.id[iw].muzzleduration + 3))
				{
					float t = ((((float)phase1tick) + intratick)/(float)data->weapons.id[iw].muzzleduration);
					alpha = LERP(2.0, 0.0f, min(1.0f,max(0.0f,t)));
				}

				int itex = rand() % data->weapons.id[iw].num_sprite_muzzles;
				if (alpha > 0.0f && data->weapons.id[iw].sprite_muzzles[itex])
				{
					float offsety = -data->weapons.id[iw].muzzleoffsety;
					select_sprite(data->weapons.id[iw].sprite_muzzles[itex], direction.x < 0 ? SPRITE_FLAG_FLIP_Y : 0);
					if(direction.x < 0)
						offsety = -offsety;

					vec2 diry(-dir.y,dir.x);
					vec2 muzzlepos = p + dir * data->weapons.id[iw].muzzleoffsetx + diry * offsety;

					draw_sprite(muzzlepos.x, muzzlepos.y, data->weapons.id[iw].visual_size);
				}
			}
		}
		gfx_quads_end();

		switch (player.weapon)
		{
			case WEAPON_GUN: render_hand(&render_info, p, direction, -3*pi/4, vec2(-15, 4)); break;
			case WEAPON_SHOTGUN: render_hand(&render_info, p, direction, -pi/2, vec2(-5, 4)); break;
			case WEAPON_GRENADE: render_hand(&render_info, p, direction, -pi/2, vec2(-4, 7)); break;
		}

	}

	// render the "shadow" tee
	if(info.local && config.debug)
	{
		vec2 ghost_position = mix(vec2(prev_char->x, prev_char->y), vec2(player_char->x, player_char->y), client_intratick());
		TEE_RENDER_INFO ghost = render_info;
		ghost.color_body.a = 0.5f;
		ghost.color_feet.a = 0.5f;
		render_tee(&state, &ghost, player.emote, direction, ghost_position); // render ghost
	}

	render_info.size = 64.0f; // force some settings
	render_info.color_body.a = 1.0f;
	render_info.color_feet.a = 1.0f;
	
	render_tee(&state, &render_info, player.emote, direction, position);

	if(player.player_state == PLAYERSTATE_CHATTING)
	{
		gfx_texture_set(data->images[IMAGE_EMOTICONS].id);
		gfx_quads_begin();
		select_sprite(SPRITE_DOTDOT);
		gfx_quads_draw(position.x + 24, position.y - 40, 64,64);
		gfx_quads_end();
	}

	if (gameclient.clients[info.cid].emoticon_start != -1 && gameclient.clients[info.cid].emoticon_start + 2 * client_tickspeed() > client_tick())
	{
		gfx_texture_set(data->images[IMAGE_EMOTICONS].id);
		gfx_quads_begin();

		int since_start = client_tick() - gameclient.clients[info.cid].emoticon_start;
		int from_end = gameclient.clients[info.cid].emoticon_start + 2 * client_tickspeed() - client_tick();

		float a = 1;

		if (from_end < client_tickspeed() / 5)
			a = from_end / (client_tickspeed() / 5.0);

		float h = 1;
		if (since_start < client_tickspeed() / 10)
			h = since_start / (client_tickspeed() / 10.0);

		float wiggle = 0;
		if (since_start < client_tickspeed() / 5)
			wiggle = since_start / (client_tickspeed() / 5.0);

		float wiggle_angle = sin(5*wiggle);

		gfx_quads_setrotation(pi/6*wiggle_angle);

		gfx_setcolor(1.0f,1.0f,1.0f,a);
		// client_datas::emoticon is an offset from the first emoticon
		select_sprite(SPRITE_OOP + gameclient.clients[info.cid].emoticon);
		gfx_quads_draw(position.x, position.y - 23 - 32*h, 64, 64*h);
		gfx_quads_end();
	}
}
Пример #3
0
int CTraQ::CalcNeck( CModel* srcmodel, TSELEM* tsptr, CTraQ* traqptr, RPSELEM* rpsptr, int frameno, int skipflag )
{
	CQuaternion parq;
	parq = ( traqptr + frameno * SKEL_MAX + SKEL_TORSO )->m_totalq;
	CQuaternion invparq;
	parq.inv( &invparq );

	if( skipflag == 3 ){
		( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_q.SetParams( 1.0f, 0.0f, 0.0f, 0.0f );
		( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_totalq = parq;
		return 0;
	}


	D3DXVECTOR3 befLpos, aftLpos, befRpos, aftRpos;
	befLpos = ( rpsptr + 0 * SKEL_MAX + SKEL_LEFT_SHOULDER )->pos;
	aftLpos = ( rpsptr + frameno * SKEL_MAX + SKEL_LEFT_SHOULDER )->pos;
	befRpos = ( rpsptr + 0 * SKEL_MAX + SKEL_RIGHT_SHOULDER )->pos;
	aftRpos = ( rpsptr + frameno * SKEL_MAX + SKEL_RIGHT_SHOULDER )->pos;

	D3DXVECTOR3 paftLpos, paftRpos;
	invparq.Rotate( &paftLpos, aftLpos );
	invparq.Rotate( &paftRpos, aftRpos );

	double radxz;
	D3DXVECTOR3 vDir0, vDir;
	D3DXVECTOR3 dirY( 0.0f, 1.0f, 0.0f );
	D3DXVECTOR3 diffpos;
	diffpos = paftLpos - paftRpos;
	DVec3Normalize( &diffpos, diffpos );

	DVec3Cross( &diffpos, &dirY, &vDir0 );
	DVec3Normalize( &vDir, vDir0 );
	if( vDir.x == 0.0f ){
		if( vDir.z >= 0.0f )
			radxz = 0.0;
		else
			radxz = PAI;
	}else if( vDir.x > 0.0f ){
		radxz = -atanf( vDir.z / vDir.x ) + PAI / 2;
	}else{
		radxz = -atanf( vDir.z / vDir.x ) - PAI / 2;
	}

///////////////
	D3DXVECTOR3 beftor, afttor, befneck, aftneck;
	beftor = ( rpsptr + 0 * SKEL_MAX + SKEL_TORSO )->pos;
	afttor = ( rpsptr + frameno * SKEL_MAX + SKEL_TORSO )->pos;
	befneck = ( rpsptr + 0 * SKEL_MAX + SKEL_NECK )->pos;
	aftneck = ( rpsptr + frameno * SKEL_MAX + SKEL_NECK )->pos;

	D3DXVECTOR3 pafttor, paftneck;
	invparq.Rotate( &pafttor, afttor );
	invparq.Rotate( &paftneck, aftneck );

	D3DXVECTOR3 vecA, vecB;
	vecA = befneck - beftor;
	vecB = paftneck - pafttor;
	D3DXVECTOR3 nvecA, nvecB;
	DVec3Normalize( &nvecA, vecA );
	DVec3Normalize( &nvecB, vecB );
	int ret;
	CQuaternion q2;
	ret = DCalcDiffQ( &nvecA, &nvecB, &q2 );
	_ASSERT( !ret );
	

	CQuaternion za3q;
	D3DXVECTOR3 cureul( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 befeul( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 neckbefeul( 0.0f, 0.0f, 0.0f );
	neckbefeul = ( traqptr + ( frameno - 1 ) * SKEL_MAX + SKEL_NECK )->m_neckbefeul;
	ret = QtoEul( srcmodel, q2, neckbefeul, CAX_INI, 0, &cureul, &za3q );
	_ASSERT( !ret );

	CQuaternion invza3q;
	za3q.inv( &invza3q );

	D3DXVECTOR3 dirx( 1.0f, 0.0f, 0.0f );
	D3DXVECTOR3 diry( 0.0f, 1.0f, 0.0f );
	D3DXVECTOR3 dirz( 0.0f, 0.0f, 1.0f );

	CQuaternion qx2, qy2, qz2, qzx2;
	qx2.SetAxisAndRot( dirx, cureul.x * DEG2PAI );
	qy2.SetAxisAndRot( diry, cureul.y * DEG2PAI );
	qz2.SetAxisAndRot( dirz, cureul.z * DEG2PAI );

	CQuaternion q;
	q = qx2 * qz2;


	D3DXVECTOR3 axis;
	q.Rotate( &axis, diry );
	DVec3Normalize( &axis, axis );
	CQuaternion qxz;
	qxz.SetAxisAndRot( axis, radxz );

	CQuaternion setq;
	if( skipflag & 1 ){
		setq = q;
	}else{
		setq = qxz * q;
	}

/////////////////////
	D3DXVECTOR3 setcureul;
	befeul = ( traqptr + ( frameno - 1 ) * SKEL_MAX + SKEL_NECK )->m_befeul;

	ret = QtoEul( srcmodel, setq, befeul, CAX_INI, 0, &setcureul, &za3q );
	_ASSERT( !ret );


	( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_q = setq;
	( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_totalq = parq * setq;

	( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_neckbefeul = cureul;
	( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_cureul = setcureul;
	( traqptr + frameno * SKEL_MAX + SKEL_NECK )->m_befeul = setcureul;


	return 0;
}
Пример #4
0
int CTraQ::CalcQ( CModel* srcmodel, TSELEM* tsptr, CTraQ* traqptr, RPSELEM* rpsptr, int frameno, int pivotskel, int skelno, int skipflag )
{
	CQuaternion parq;
	parq = ( traqptr + frameno * SKEL_MAX + pivotskel )->m_totalq;
	CQuaternion invparq;
	parq.inv( &invparq );

	if( skipflag != 0 ){
		( traqptr + frameno * SKEL_MAX + skelno )->m_q.SetParams( 1.0f, 0.0f, 0.0f, 0.0f );
		( traqptr + frameno * SKEL_MAX + skelno )->m_totalq = parq;
		return 0;
	}


	D3DXVECTOR3 befpivpos, aftpivpos, befpos, aftpos;
	befpivpos = ( rpsptr + 0 * SKEL_MAX + pivotskel )->pos;
	aftpivpos = ( rpsptr + frameno * SKEL_MAX + pivotskel )->pos;
	befpos = ( rpsptr + 0 * SKEL_MAX + skelno )->pos;
	aftpos = ( rpsptr + frameno * SKEL_MAX + skelno )->pos;

	D3DXVECTOR3 paftpivpos, paftpos;
	invparq.Rotate( &paftpivpos, aftpivpos );
	invparq.Rotate( &paftpos, aftpos );

	D3DXVECTOR3 vec1, vec2;
	vec1 = befpos - befpivpos;
	vec2 = paftpos - paftpivpos;
	D3DXVECTOR3 nvec1, nvec2;
	DVec3Normalize( &nvec1, vec1 );
	DVec3Normalize( &nvec2, vec2 );


	int ret;
	CQuaternion setq;
	ret = DCalcDiffQ( &nvec1, &nvec2, &setq );
	_ASSERT( !ret );
////////////////


	D3DXVECTOR3 cureul( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 befeul( 0.0f, 0.0f, 0.0f );
	befeul = ( traqptr + ( frameno - 1 ) * SKEL_MAX + skelno )->m_befeul;
	CQuaternion za3q;
	ret = QtoEul( srcmodel, setq, befeul, CAX_ZA3, (tsptr + skelno)->jointno, &cureul, &za3q );
	_ASSERT( !ret );

	CQuaternion invza3q;
	za3q.inv( &invza3q );

	float twistdeg;
	if( ( tsptr + skelno )->twistflag == 0 ){

		D3DXVECTOR3 dirx( 1.0f, 0.0f, 0.0f );
		D3DXVECTOR3 diry( 0.0f, 1.0f, 0.0f );
		D3DXVECTOR3 dirz( 0.0f, 0.0f, 1.0f );

		CQuaternion qx, qy, qz;
		qx.SetAxisAndRot( dirx, cureul.x * DEG2PAI );
		qy.SetAxisAndRot( diry, cureul.y * DEG2PAI );
		qz.SetAxisAndRot( dirz, cureul.z * DEG2PAI );
		CQuaternion qxy;
		qxy = qy * qx;


///////////
		
		D3DXVECTOR3 aftdiry;
		qxy.Rotate( &aftdiry, diry );
		DVec3Normalize( &aftdiry, aftdiry );

		double doty;
		DCalcDot( &diry, &aftdiry, &doty );
		double rady;
		rady = acos( doty );

		CQuaternion ya, yb;
		ya.SetAxisAndRot( dirz, rady );
		yb.SetAxisAndRot( dirz, -rady );
		D3DXVECTOR3 afta, aftb;
		ya.Rotate( &afta, diry );
		yb.Rotate( &aftb, diry );
		DVec3Normalize( &afta, afta );
		DVec3Normalize( &aftb, aftb );
		double dotya, dotyb;
		DCalcDot( &aftdiry, &afta, &dotya );
		DCalcDot( &aftdiry, &aftb, &dotyb );
		CQuaternion twistq;
		if( dotya >= dotyb ){
			twistq = ya;
			twistdeg = (float)( rady * PAI2DEG );
		}else{
			twistq = yb;
			twistdeg = (float)( -rady * PAI2DEG );
		}
		
		setq = za3q * qxy * twistq * invza3q;
	}else{
		twistdeg = cureul.z;
	}


	( traqptr + frameno * SKEL_MAX + skelno )->m_q = setq;
	( traqptr + frameno * SKEL_MAX + skelno )->m_totalq = parq * setq;

	( traqptr + frameno * SKEL_MAX + skelno )->m_befeul = cureul;
	( traqptr + frameno * SKEL_MAX + skelno )->m_cureul = D3DXVECTOR3( cureul.x, cureul.y, twistdeg );


	return 0;
}
Пример #5
0
int main(int argc, char* argv[])
{
	// ACL tests
	char* exename = getenv("WINDIR");

	PSID psidOwner;
	PSID psidGroup;
	PACL pDacl;
	PSECURITY_DESCRIPTOR pSecurityDesc;

	DWORD result = GetNamedSecurityInfo(
		exename, // pObjectName
		SE_FILE_OBJECT, // ObjectType
		DACL_SECURITY_INFORMATION | // SecurityInfo
		GROUP_SECURITY_INFORMATION |
		OWNER_SECURITY_INFORMATION,
		&psidOwner, // ppsidOwner,
		&psidGroup, // ppsidGroup,
		&pDacl,     // ppDacl,
		NULL,       // ppSacl,
		&pSecurityDesc // ppSecurityDescriptor
	);
	if (result != ERROR_SUCCESS)
	{
		printf("Error getting security info for '%s': error %d",
			exename, result);
	}
	assert(result == ERROR_SUCCESS);

	char namebuf[1024];
	char domainbuf[1024];
	SID_NAME_USE nametype;
	DWORD namelen = sizeof(namebuf);
	DWORD domainlen = sizeof(domainbuf);

	assert(LookupAccountSid(NULL, psidOwner, namebuf, &namelen,
		domainbuf, &domainlen, &nametype));

	printf("Owner:\n");
	printf("User name:   %s\n", namebuf);
	printf("Domain name: %s\n", domainbuf);
	printf("Name type:   %d\n", nametype);
	printf("\n");

	namelen = sizeof(namebuf);
	domainlen = sizeof(domainbuf);

	assert(LookupAccountSid(NULL, psidGroup, namebuf, &namelen,
		domainbuf, &domainlen, &nametype));

	printf("Group:\n");
	printf("User name:   %s\n", namebuf);
	printf("Domain name: %s\n", domainbuf);
	printf("Name type:   %d\n", nametype);
	printf("\n");

	ULONG numEntries;
	PEXPLICIT_ACCESS pEntries;
	result = GetExplicitEntriesFromAcl
	(
		pDacl,       // pAcl
		&numEntries, // pcCountOfExplicitEntries,
		&pEntries    // pListOfExplicitEntries
	);
	assert(result == ERROR_SUCCESS);

	printf("Found %lu explicit DACL entries for '%s'\n\n",
		(unsigned long)numEntries, exename);

	for (ULONG i = 0; i < numEntries; i++)
	{
		EXPLICIT_ACCESS* pEntry = &(pEntries[i]);
		printf("DACL entry %lu:\n", (unsigned long)i);

		DWORD perms = pEntry->grfAccessPermissions;
		printf("  Access permissions: ", perms);

		#define PRINT_PERM(name) \
		if (perms & name) \
		{ \
			printf(#name " "); \
			perms &= ~name; \
		}

		PRINT_PERM(FILE_ADD_FILE);
		PRINT_PERM(FILE_ADD_SUBDIRECTORY);
		PRINT_PERM(FILE_ALL_ACCESS);
		PRINT_PERM(FILE_APPEND_DATA);
		PRINT_PERM(FILE_CREATE_PIPE_INSTANCE);
		PRINT_PERM(FILE_DELETE_CHILD);
		PRINT_PERM(FILE_EXECUTE);
		PRINT_PERM(FILE_LIST_DIRECTORY);
		PRINT_PERM(FILE_READ_ATTRIBUTES);
		PRINT_PERM(FILE_READ_DATA);
		PRINT_PERM(FILE_READ_EA);
		PRINT_PERM(FILE_TRAVERSE);
		PRINT_PERM(FILE_WRITE_ATTRIBUTES);
		PRINT_PERM(FILE_WRITE_DATA);
		PRINT_PERM(FILE_WRITE_EA);
		PRINT_PERM(STANDARD_RIGHTS_READ);
		PRINT_PERM(STANDARD_RIGHTS_WRITE);
		PRINT_PERM(SYNCHRONIZE);
		PRINT_PERM(DELETE);
		PRINT_PERM(READ_CONTROL);
		PRINT_PERM(WRITE_DAC);
		PRINT_PERM(WRITE_OWNER);
		PRINT_PERM(MAXIMUM_ALLOWED);
		PRINT_PERM(GENERIC_ALL);
		PRINT_PERM(GENERIC_EXECUTE);
		PRINT_PERM(GENERIC_WRITE);
		PRINT_PERM(GENERIC_READ);
		printf("\n");

		if (perms)
		{
			printf("  Bits left over: %08x\n", perms);
		}
		assert(!perms);

		printf("  Access mode: ");
		switch(pEntry->grfAccessMode)
		{
		case NOT_USED_ACCESS:
			printf("NOT_USED_ACCESS\n"); break;
		case GRANT_ACCESS:
			printf("GRANT_ACCESS\n"); break;
		case DENY_ACCESS:
			printf("DENY_ACCESS\n"); break;
		case REVOKE_ACCESS:
			printf("REVOKE_ACCESS\n"); break;
		case SET_AUDIT_SUCCESS:
			printf("SET_AUDIT_SUCCESS\n"); break;
		case SET_AUDIT_FAILURE:
			printf("SET_AUDIT_FAILURE\n"); break;
		default:
			printf("Unknown (%08x)\n", pEntry->grfAccessMode);
		}

		printf("  Trustee: ");
		assert(pEntry->Trustee.pMultipleTrustee == NULL);
		assert(pEntry->Trustee.MultipleTrusteeOperation == NO_MULTIPLE_TRUSTEE);
		switch(pEntry->Trustee.TrusteeForm)
		{
		case TRUSTEE_IS_SID:
			{
				PSID trusteeSid = (PSID)(pEntry->Trustee.ptstrName);

				namelen = sizeof(namebuf);
				domainlen = sizeof(domainbuf);

				assert(LookupAccountSid(NULL, trusteeSid, namebuf, &namelen,
					domainbuf, &domainlen, &nametype));

				printf("SID of %s\\%s (%d)\n", domainbuf, namebuf, nametype);
			}
			break;
		case TRUSTEE_IS_NAME:
			printf("Name\n"); break;
		case TRUSTEE_BAD_FORM:
			printf("Bad form\n"); assert(0);
		case TRUSTEE_IS_OBJECTS_AND_SID:
			printf("Objects and SID\n"); break;
		case TRUSTEE_IS_OBJECTS_AND_NAME:
			printf("Objects and name\n"); break;
		default:
			printf("Unknown form\n"); assert(0);
		}

		printf("  Trustee type: ");
		switch(pEntry->Trustee.TrusteeType)
		{
		case TRUSTEE_IS_UNKNOWN:
			printf("Unknown type.\n"); break;
		case TRUSTEE_IS_USER:
			printf("User\n"); break;
		case TRUSTEE_IS_GROUP:
			printf("Group\n"); break;
		case TRUSTEE_IS_DOMAIN:
			printf("Domain\n"); break;
		case TRUSTEE_IS_ALIAS:
			printf("Alias\n"); break;
		case TRUSTEE_IS_WELL_KNOWN_GROUP:
			printf("Well-known group\n"); break;
		case TRUSTEE_IS_DELETED:
			printf("Deleted account\n"); break;
		case TRUSTEE_IS_INVALID:
			printf("Invalid trustee type\n"); break;
		case TRUSTEE_IS_COMPUTER:
			printf("Computer\n"); break;
		default:
			printf("Unknown type %d\n", pEntry->Trustee.TrusteeType); 
			assert(0);
		}

		printf("\n");
	}

	assert(LocalFree((HLOCAL)pEntries) == 0);
	assert(LocalFree((HLOCAL)pSecurityDesc) == 0);

	chdir("c:\\tmp");
	openfile("test", O_CREAT, 0);
	struct stat ourfs;
	//test our opendir, readdir and closedir
	//functions
	DIR *ourDir = opendir("C:");

	if ( ourDir != NULL )
	{
		struct dirent *info;
		do
		{
			info = readdir(ourDir);
			if (info) printf("File/Dir name is : %s\r\n", info->d_name);
		}
		while (info != NULL);

		closedir(ourDir);
	}
	
	std::string diry("C:\\Projects\\boxbuild\\testfiles\\");
	ourDir = opendir(diry.c_str());
	if ( ourDir != NULL )
	{
		struct dirent *info;
		do
		{
			info = readdir(ourDir);
			if (info == NULL) break;
			std::string file(diry + info->d_name);
			stat(file.c_str(), &ourfs);
			if (info) printf("File/Dir name is : %s\r\n", info->d_name);
		}
		while ( info != NULL );

		closedir(ourDir);

	}

	stat("c:\\windows", &ourfs);
	stat("c:\\autoexec.bat", &ourfs);
	printf("Finished dir read\n");

	//test our getopt function
	char * test_argv[] = 
	{
		"foobar.exe",
		"-qwc",
		"-",
		"-c",
		"fgfgfg",
		"-f",
		"-l",
		"hello",
		"-",
		"force-sync",
		NULL
	};
	int test_argc;
	for (test_argc = 0; test_argv[test_argc]; test_argc++) { }
	const char* opts = "qwc:l:";

	assert(getopt(test_argc, test_argv, opts) == 'q');
	assert(getopt(test_argc, test_argv, opts) == 'w');
	assert(getopt(test_argc, test_argv, opts) == 'c');
	assert(strcmp(optarg, "-") == 0);
	assert(getopt(test_argc, test_argv, opts) == 'c');
	assert(strcmp(optarg, "fgfgfg") == 0);
	assert(getopt(test_argc, test_argv, opts) == '?');
	assert(optopt == 'f');
	assert(getopt(test_argc, test_argv, opts) == 'l');
	assert(strcmp(optarg, "hello") == 0);
	assert(getopt(test_argc, test_argv, opts) == -1);
	// assert(optopt == 0); // no more options
	assert(strcmp(test_argv[optind], "-") == 0);
	assert(strcmp(test_argv[optind+1], "force-sync") == 0);
	//end of getopt test
	
	//now test our statfs funct
	stat("c:\\cert.cer", &ourfs);

	char *timee;
	
	timee = ctime(&ourfs.st_mtime);

	if (S_ISREG(ourfs.st_mode))
	{
		printf("is a normal file\n");
	}
	else
	{
		printf("is a directory?\n");
		exit(1);
	}

	lstat(getenv("WINDIR"), &ourfs);

	if ( S_ISDIR(ourfs.st_mode))
	{
		printf("is a directory\n");
	}
	else
	{
		printf("is a file?\n");
		exit(1);
	}

	//test the syslog functions
	openlog("Box Backup", 0,0);
	//the old ones are the best...
	syslog(LOG_ERR, "Hello World");
	syslog(LOG_ERR, "Value of int is: %i", 6);

	closelog();

	/*
	//first off get the path name for the default 
	char buf[MAX_PATH];
	
	GetModuleFileName(NULL, buf, sizeof(buf));
	std::string buffer(buf);
	std::string conf("-c " + buffer.substr(0,(buffer.find("win32test.exe"))) + "bbackupd.conf");
	//std::string conf( "-c " + buffer.substr(0,(buffer.find("bbackupd.exe"))) + "bbackupd.conf");
	*/

	return 0;
}