//=================================================
// 更新
//=================================================
void CDirectSlap::Update( void )
{
D3DXVECTOR3 pos[2] = {
m_pPlayerManager->GetPlayerPos( PLAYER_1 ),
m_pPlayerManager->GetPlayerPos( PLAYER_2 )
};
D3DXVECTOR3 rot[2] = {
m_pPlayerManager->GetPlayerRot( PLAYER_1 ),
m_pPlayerManager->GetPlayerRot( PLAYER_2 )
};
/* ここから個別 */
switch( m_FrameCount )
{
// フレーム別の処理
case 0:
m_pPlayerManager->SetAnimType( m_Player, CPlayer::PLAYER_SLAPPING_RIGHT );
m_pPlayerManager->SetAnimType( m_Enemy, CPlayer::PLAYER_SLAPPING_DAMAGE_RIGHT );
//CEffect::Create( 60, EFFECT_AURA_START, false, pos[m_Player] + TranslateCoord( m_Player, SLAP_EFFECT_AURA_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)SLAP_EFFECT_AURA_SCALE );
m_pPlayerManager->SetAnimSpd( m_Player, DEFFAULT_ANIM_SPD * 0.7f );
m_pPlayerManager->SetAnimSpd( m_Enemy, DEFFAULT_ANIM_SPD * 0.7f );
m_pCameraManager->CameraMoveToCoord(
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( -30.0f, 90.0f, -70.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 30.0f, 90.0f, -70.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 25.0f, 60.0f, 0.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 25.0f, 60.0f, 0.0f ) ),
80 );
break;
case 20:
CEffect::Create( 30, EFFECT_DAGEKI_TYU, false, pos[m_Player] + TranslateCoord( m_Player, SLAP_EFFECT_GRAB_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)SLAP_EFFECT_GRAB_SCALE );
m_pPlayerManager->TakeDamage( m_Enemy, SLAP_DAMAGE1 );
m_pPlayerManager->SetAnimSpd( m_Player, DEFFAULT_ANIM_SPD * 1.0f );
m_pPlayerManager->SetAnimSpd( m_Enemy, DEFFAULT_ANIM_SPD * 1.0f );
break;
case 60:
m_pCameraManager->StartCameraShake( VECTOR3_ZERO, 10.0f, 20, 0 );
m_pPlayerManager->TakeDamage( m_Enemy, SLAP_DAMAGE2 );
m_pPlayerManager->AddTension( m_Player, SLAP_TENSION );
int label = mersenne_twister_int(SOUND_LABEL_SE_SLAP01, SOUND_LABEL_SE_SLAP03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
CEffect::Create( 30, EFFECT_DAGEKI_KYO, false, pos[m_Player] + TranslateCoord( m_Player, SLAP_EFFECT_HIT_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)SLAP_EFFECT_HIT_SCALE );
break;
}
/* ここまで個別 */
CDirect::CheckEnd();
}
void BlotScaledImageSizedEx ( ImageFile *pifDest, ImageFile *pifSrc
, int32_t xd, int32_t yd
, uint32_t wd, uint32_t hd
, int32_t xs, int32_t ys
, uint32_t ws, uint32_t hs
, uint32_t nTransparent
, uint32_t method, ... )
// integer scalar... 0x10000 = 1
{
CDATA *po, *pi;
static uint32_t lock;
uint32_t oo;
uint32_t srcwidth;
int errx, erry;
uint32_t dhd, dwd, dhs, dws;
va_list colors;
va_start( colors, method );
//lprintf( WIDE("Blot enter (%d,%d)"), _wd, _hd );
if( nTransparent > ALPHA_TRANSPARENT_MAX )
{
return;
}
if( !pifSrc || !pifDest
|| !pifSrc->image //|| !pifDest->image
|| !wd || !hd || !ws || !hs )
{
return;
}
if( ( xd > ( pifDest->x + pifDest->width ) )
|| ( yd > ( pifDest->y + pifDest->height ) )
|| ( ( xd + (signed)wd ) < pifDest->x )
|| ( ( yd + (signed)hd ) < pifDest->y ) )
{
return;
}
dhd = hd;
dhs = hs;
dwd = wd;
dws = ws;
// ok - how to figure out how to do this
// need to update the position and width to be within the
// the bounds of pifDest....
//lprintf(" begin scaled output..." );
errx = -(signed)dwd;
erry = -(signed)dhd;
if( xd < pifDest->x )
{
while( xd < pifDest->x )
{
errx += (signed)dws;
while( errx >= 0 )
{
errx -= (signed)dwd;
ws--;
xs++;
}
wd--;
xd++;
}
}
//Log8( WIDE("Blot scaled params: %d %d %d %d / %d %d %d %d "),
// xs, ys, ws, hs, xd, yd, wd, hd );
if( yd < pifDest->y )
{
while( yd < pifDest->y )
{
erry += (signed)dhs;
while( erry >= 0 )
{
erry -= (signed)dhd;
hs--;
ys++;
}
hd--;
yd++;
}
}
//Log8( WIDE("Blot scaled params: %d %d %d %d / %d %d %d %d "),
// xs, ys, ws, hs, xd, yd, wd, hd );
if( ( xd + (signed)wd ) > ( pifDest->x + pifDest->width) )
{
//int newwd = TOFIXED(pifDest->width);
//ws -= ((int64_t)( (int)wd - newwd)* (int64_t)ws )/(int)wd;
wd = ( pifDest->x + pifDest->width ) - xd;
}
//Log8( WIDE("Blot scaled params: %d %d %d %d / %d %d %d %d "),
// xs, ys, ws, hs, xd, yd, wd, hd );
if( ( yd + (signed)hd ) > (pifDest->y + pifDest->height) )
{
//int newhd = TOFIXED(pifDest->height);
//hs -= ((int64_t)( hd - newhd)* hs )/hd;
hd = (pifDest->y + pifDest->height) - yd;
}
if( (int32_t)wd <= 0 ||
(int32_t)hd <= 0 ||
(int32_t)ws <= 0 ||
(int32_t)hs <= 0 )
{
return;
}
//Log9( WIDE("Image locations: %d(%d %d) %d(%d) %d(%d) %d(%d)")
// , xs, FROMFIXED(xs), FIXEDPART(xs)
// , ys, FROMFIXED(ys)
// , xd, FROMFIXED(xd)
// , yd, FROMFIXED(yd) );
#ifdef _INVERT_IMAGE
// set pointer in to the starting x pixel
// on the last line of the image to be copied
pi = IMG_ADDRESS( pifSrc, (xs), (ys) );
po = IMG_ADDRESS( pifDest, (xd), (yd) );
oo = 4*(-((signed)wd) - (pifDest->pwidth) ); // w is how much we can copy...
// adding in multiple of 4 because it's C...
srcwidth = -(4* pifSrc->pwidth);
#else
// set pointer in to the starting x pixel
// on the first line of the image to be copied...
pi = IMG_ADDRESS( pifSrc, (xs), (ys) );
po = IMG_ADDRESS( pifDest, (xd), (yd) );
oo = 4*(pifDest->pwidth - (wd)); // w is how much we can copy...
// adding in multiple of 4 because it's C...
srcwidth = 4* pifSrc->pwidth;
#endif
while( LockedExchange( &lock, 1 ) )
Relinquish();
//Log8( WIDE("Do blot work...%d(%d),%d(%d) %d(%d) %d(%d)")
// , ws, FROMFIXED(ws), hs, FROMFIXED(hs)
// , wd, FROMFIXED(wd), hd, FROMFIXED(hd) );
if( ( pifDest->flags & IF_FLAG_FINAL_RENDER )
&& !( pifDest->flags & IF_FLAG_IN_MEMORY ) )
{
int updated = 0;
Image topmost_parent;
// closed loop to get the top imgae size.
for( topmost_parent = pifSrc; topmost_parent->pParent; topmost_parent = topmost_parent->pParent );
ReloadOpenGlTexture( pifSrc, 0 );
if( !pifSrc->glActiveSurface )
{
lprintf( WIDE( "gl texture hasn't downloaded or went away?" ) );
lock = 0;
return;
}
//lprintf( WIDE( "use regular texture %p (%d,%d)" ), pifSrc, pifSrc->width, pifSrc->height );
{
int glDepth = 1;
VECTOR v1[2], v3[2], v4[2], v2[2];
int v = 0;
double x_size, x_size2, y_size, y_size2;
/*
* only a portion of the image is actually used, the rest is filled with blank space
*
*/
TranslateCoord( pifDest, &xd, &yd );
TranslateCoord( pifSrc, &xs, &ys );
v1[v][0] = xd;
v1[v][1] = yd;
v1[v][2] = 0.0;
v2[v][0] = xd;
v2[v][1] = yd+hd;
v2[v][2] = 0.0;
v3[v][0] = xd+wd;
v3[v][1] = yd+hd;
v3[v][2] = 0.0;
v4[v][0] = xd+wd;
v4[v][1] = yd;
v4[v][2] = 0.0;
x_size = (double) xs/ (double)topmost_parent->width;
x_size2 = (double) (xs+ws)/ (double)topmost_parent->width;
y_size = (double) ys/ (double)topmost_parent->height;
y_size2 = (double) (ys+hs)/ (double)topmost_parent->height;
while( pifDest && pifDest->pParent )
{
glDepth = 0;
if( pifDest->transform )
{
Apply( pifDest->transform, v1[1-v], v1[v] );
Apply( pifDest->transform, v2[1-v], v2[v] );
Apply( pifDest->transform, v3[1-v], v3[v] );
Apply( pifDest->transform, v4[1-v], v4[v] );
v = 1-v;
}
pifDest = pifDest->pParent;
}
if( pifDest->transform )
{
Apply( pifDest->transform, v1[1-v], v1[v] );
Apply( pifDest->transform, v2[1-v], v2[v] );
Apply( pifDest->transform, v3[1-v], v3[v] );
Apply( pifDest->transform, v4[1-v], v4[v] );
v = 1-v;
}
#if 0
if( glDepth )
{
//lprintf( WIDE( "enqable depth..." ) );
glEnable( GL_DEPTH_TEST );
}
else
{
//lprintf( WIDE( "disable depth..." ) );
glDisable( GL_DEPTH_TEST );
}
#endif
glBindTexture(GL_TEXTURE_2D, pifSrc->glActiveSurface); // Select Our Texture
if( method == BLOT_COPY )
glColor4ub( 255,255,255,255 );
else if( method == BLOT_SHADED )
{
CDATA tmp = va_arg( colors, CDATA );
glColor4ubv( (GLubyte*)&tmp );
}
else if( method == BLOT_MULTISHADE )
{
#if !defined( __ANDROID__ )
InitShader();
if( glUseProgram && l.glActiveSurface->shader.multi_shader )
{
int err;
CDATA r = va_arg( colors, CDATA );
CDATA g = va_arg( colors, CDATA );
CDATA b = va_arg( colors, CDATA );
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glUseProgram( l.glActiveSurface->shader.multi_shader );
err = glGetError();
glProgramLocalParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 0, (float)GetRedValue( r )/255.0f, (float)GetGreenValue( r )/255.0f, (float)GetBlueValue( r )/255.0f, (float)GetAlphaValue( r )/255.0f );
err = glGetError();
glProgramLocalParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 1, (float)GetRedValue( g )/255.0f, (float)GetGreenValue( g )/255.0f, (float)GetBlueValue( g )/255.0f, (float)GetAlphaValue( g )/255.0f );
err = glGetError();
glProgramLocalParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 2, (float)GetRedValue( b )/255.0f, (float)GetGreenValue( b )/255.0f, (float)GetBlueValue( b )/255.0f, (float)GetAlphaValue( b )/255.0f );
err = glGetError();
}
else
#endif
{
Image output_image;
CDATA r = va_arg( colors, CDATA );
CDATA g = va_arg( colors, CDATA );
CDATA b = va_arg( colors, CDATA );
output_image = GetShadedImage( pifSrc, r, g, b );
glBindTexture( GL_TEXTURE_2D, output_image->glActiveSurface );
glColor4ub( 255,255,255,255 );
}
}
else if( method == BLOT_INVERTED )
{
#if !defined( __ANDROID__ )
InitShader();
if( l.glActiveSurface->shader.inverse_shader )
{
int err;
//lprintf( WIDE( "HAVE SHADER %d" ), l.glActiveSurface->shader.inverse_shader );
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glUseProgram( l.glActiveSurface->shader.inverse_shader );
err = glGetError();
}
else
#endif
{
Image output_image;
//lprintf( WIDE( "DID NOT HAVE SHADER" ) );
output_image = GetInvertedImage( pifSrc );
glBindTexture( GL_TEXTURE_2D, output_image->glActiveSurface );
glColor4ub( 255,255,255,255 );
}
}
glBegin(GL_TRIANGLE_STRIP);
//glBegin(GL_QUADS);
// Front Face
//glColor4ub( 255,120,32,192 );
scale( v1[v], v1[v], l.scale );
scale( v2[v], v2[v], l.scale );
scale( v3[v], v3[v], l.scale );
scale( v4[v], v4[v], l.scale );
glTexCoord2f(x_size, y_size); glVertex3fv(v1[v]); // Bottom Left Of The Texture and Quad
glTexCoord2f(x_size, y_size2); glVertex3fv(v2[v]); // Bottom Right Of The Texture and Quad
glTexCoord2f(x_size2, y_size); glVertex3fv(v4[v]); // Top Left Of The Texture and Quad
glTexCoord2f(x_size2, y_size2); glVertex3fv(v3[v]); // Top Right Of The Texture and Quad
// Back Face
glEnd();
#if !defined( __ANDROID__ )
if( method == BLOT_MULTISHADE )
{
if( l.glActiveSurface->shader.multi_shader )
{
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
}
else if( method == BLOT_INVERTED )
{
if( l.glActiveSurface->shader.inverse_shader )
{
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
}
#endif
glBindTexture(GL_TEXTURE_2D, 0); // Select Our Texture
}
}
else switch( method )
{
case BLOT_COPY:
if( !nTransparent )
cBlotScaledT0( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth );
else if( nTransparent == 1 )
cBlotScaledT1( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth );
else if( nTransparent & ALPHA_TRANSPARENT )
cBlotScaledTImgA( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, nTransparent&0xFF );
else if( nTransparent & ALPHA_TRANSPARENT_INVERT )
cBlotScaledTImgAI( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, nTransparent&0xFF );
else
cBlotScaledTA( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, nTransparent );
break;
case BLOT_SHADED:
if( !nTransparent )
cBlotScaledShadedT0( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, va_arg( colors, CDATA ) );
else if( nTransparent == 1 )
cBlotScaledShadedT1( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, va_arg( colors, CDATA ) );
else if( nTransparent & ALPHA_TRANSPARENT )
cBlotScaledShadedTImgA( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, nTransparent&0xFF, va_arg( colors, CDATA ) );
else if( nTransparent & ALPHA_TRANSPARENT_INVERT )
cBlotScaledShadedTImgAI( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, nTransparent&0xFF, va_arg( colors, CDATA ) );
else
cBlotScaledShadedTA( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth, nTransparent, va_arg( colors, CDATA ) );
break;
case BLOT_MULTISHADE:
{
CDATA r,g,b;
r = va_arg( colors, CDATA );
g = va_arg( colors, CDATA );
b = va_arg( colors, CDATA );
if( !nTransparent )
cBlotScaledMultiT0( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth
, r, g, b );
else if( nTransparent == 1 )
cBlotScaledMultiT1( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth
, r, g, b );
else if( nTransparent & ALPHA_TRANSPARENT )
cBlotScaledMultiTImgA( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth
, nTransparent & 0xFF
, r, g, b );
else if( nTransparent & ALPHA_TRANSPARENT_INVERT )
cBlotScaledMultiTImgAI( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth
, nTransparent & 0xFF
, r, g, b );
else
cBlotScaledMultiTA( po, pi, errx, erry, wd, hd, dwd, dhd, dws, dhs, oo, srcwidth
, nTransparent
, r, g, b );
}
break;
}
lock = 0;
// Log( WIDE("Blot done") );
}
//=================================================
// 更新
//=================================================
void CDirectShoulder::Update( void )
{
D3DXVECTOR3 pos[2] = {
m_pPlayerManager->GetPlayerPos( PLAYER_1 ),
m_pPlayerManager->GetPlayerPos( PLAYER_2 )
};
D3DXVECTOR3 rot[2] = {
m_pPlayerManager->GetPlayerRot( PLAYER_1 ),
m_pPlayerManager->GetPlayerRot( PLAYER_2 )
};
/* ここから個別 */
switch( m_FrameCount )
{
// フレーム別の処理
case 0:
m_pPlayerManager->SetAnimType( m_Player, CPlayer::PLAYER_FLYING_SHOULDER_ATTACK_LEFT );
//CEffect::Create( 60, EFFECT_AURA_START, false, pos[m_Player] + TranslateCoord( m_Player, SHOULDER_EFFECT_AURA_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)SHOULDER_EFFECT_AURA_SCALE );
m_pCameraManager->CameraMoveToCoord(
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 25.0f, 150.0f, -100.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 25.0f, 300.0f, -200.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 25.0f, 70.0f, 0.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 100.0f, 0.0f, 0.0f ) ),
100 );
break;
case 40:
{
m_pPlayerManager->SetAnimType( m_Enemy, CPlayer::PLAYER_FLYING_SHOULDER_ATTACK_DAMAGE_LEFT );
m_pCameraManager->StartCameraShake( VECTOR3_ZERO, 10.0f, 20, 0 );
m_pPlayerManager->TakeDamage( m_Enemy, SHOULDER_DAMAGE );
m_pPlayerManager->AddTension( m_Player, SHOULDER_TENSION );
int label = mersenne_twister_int(SOUND_LABEL_SE_LARGE_DAMAGE01, SOUND_LABEL_SE_LARGE_DAMAGE03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
CEffect::Create( 30, EFFECT_DAGEKI_KYO, false, pos[m_Player] + TranslateCoord( m_Player, SHOULDER_EFFECT_HIT_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)SHOULDER_EFFECT_HIT_SCALE );
break;
}
case 60:
{
int label = mersenne_twister_int(SOUND_LABEL_SE_DOWN01, SOUND_LABEL_SE_DOWN03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
break;
}
case 70:
{
int label = mersenne_twister_int(SOUND_LABEL_SE_CROWD01, SOUND_LABEL_SE_CROWD03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
label = mersenne_twister_int(SOUND_LABEL_SE_DOWN01, SOUND_LABEL_SE_DOWN03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
m_pPlayerManager->SetAnimSpd( m_Player, 0.0f );
m_pPlayerManager->SetAnimSpd( m_Enemy, 0.0f );
break;
}
}
// バトルフェードスタート
if (m_FrameCount == m_TotalFrame - 15)
{
m_pManager->GetUiManager()->StartBattleFade();
}
/* ここまで個別 */
CDirect::CheckEnd();
}
//=================================================
// 更新
//=================================================
void CDirectStunnerRope::Update( void )
{
D3DXVECTOR3 pos[2] = {
m_pPlayerManager->GetPlayerPos( PLAYER_1 ),
m_pPlayerManager->GetPlayerPos( PLAYER_2 )
};
D3DXVECTOR3 rot[2] = {
m_pPlayerManager->GetPlayerRot( PLAYER_1 ),
m_pPlayerManager->GetPlayerRot( PLAYER_2 )
};
/* ここから個別 */
switch( m_FrameCount )
{
// フレーム別の処理
case 0:
m_pUIManager->StartCutIn( m_Player, CUT_IN_JIJII );
m_pPlayerManager->SetPos( m_Player, pos[m_Player] + TranslateCoord( m_Player, STUNNER_POS1_OFFSET ) );
m_pPlayerManager->SetRot( m_Enemy, rot[m_Enemy] + TranslateCoord( m_Enemy, STUNNER_ROT_OFFSET ) );
m_pPlayerManager->SetPos( m_Enemy, pos[m_Enemy] + TranslateCoord( m_Enemy, STUNNER_POS2_OFFSET ) );
pos[PLAYER_1] = m_pPlayerManager->GetPlayerPos( PLAYER_1 );
pos[PLAYER_2] = m_pPlayerManager->GetPlayerPos( PLAYER_2 );
m_pPlayerManager->SetAnimType( m_Player, CPlayer::PLAYER_STUNNER_RIGHT );
m_pPlayerManager->SetAnimMortionOfTime(m_Player, 15 * DEFFAULT_ANIM_SPD);
m_pPlayerManager->SetAnimType( m_Enemy, CPlayer::PLAYER_STUNNER_DAMAGE_RIGHT );
m_pPlayerManager->SetAnimMortionOfTime(m_Enemy, 15 * DEFFAULT_ANIM_SPD);
m_pPlayerManager->SetAnimSpd( m_Player, 0.0f );
m_pPlayerManager->SetAnimSpd( m_Enemy, 0.0f );
m_pPlayerManager->SetAnimSpd( m_Player, DEFFAULT_ANIM_SPD * 0.7f );
m_pPlayerManager->SetAnimSpd( m_Enemy, DEFFAULT_ANIM_SPD * 0.7f );
//CEffect::Create( 60, EFFECT_AURA_START, false, pos[m_Player] + TranslateCoord( m_Player, STUNNER_EFFECT_AURA_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)STUNNER_EFFECT_AURA_SCALE );
m_pPlayerManager->TakeDamage( m_Enemy, STUNNER_DAMAGE1 );
m_pCameraManager->CameraMoveToCoord(
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 200.0f, 100.0f, -100.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 200.0f, 100.0f, +100.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 0.0f, 70.0f, 0.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 40.0f, 0.0f, 0.0f ) ),
100 );
m_FrameCount = 70;
break;
case 130:
{
m_pPlayerManager->SetAnimSpd(m_Player, DEFFAULT_ANIM_SPD * 1.0f);
m_pPlayerManager->SetAnimSpd(m_Enemy, DEFFAULT_ANIM_SPD * 1.0f);
m_pCameraManager->StartCameraShake(VECTOR3_ZERO, 10.0f, 20, 0);
m_pPlayerManager->TakeDamage(m_Enemy, STUNNER_DAMAGE2);
m_pPlayerManager->AddTension(m_Player, STUNNER_TENSION);
int label = mersenne_twister_int(SOUND_LABEL_SE_LARGE_DAMAGE01, SOUND_LABEL_SE_LARGE_DAMAGE03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
CEffect::Create(30, EFFECT_SHOCK_WAVE, false, pos[m_Player] + TranslateCoord(m_Player, STUNNER_EFFECT_HIT_OFFSET), VECTOR3_ZERO, (D3DXVECTOR3)STUNNER_EFFECT_HIT_SCALE);
}
break;
case 155:
{
int label = mersenne_twister_int(SOUND_LABEL_SE_DOWN01, SOUND_LABEL_SE_DOWN03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
}
break;
case 165:
{
int label = mersenne_twister_int(SOUND_LABEL_SE_CROWD01, SOUND_LABEL_SE_CROWD03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
label = mersenne_twister_int(SOUND_LABEL_SE_DOWN01, SOUND_LABEL_SE_DOWN03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
m_pPlayerManager->SetAnimSpd(m_Player, 0.0f);
//m_pPlayerManager->SetAnimSpd(m_Enemy, 0.0f);
}
break;
case 190:
m_pPlayerManager->SetAnimSpd( m_Player, DEFFAULT_ANIM_SPD );
m_pPlayerManager->SetAnimType(m_Player, CPlayer::PLAYER_APPEAL02, 0.5);
m_pPlayerManager->SetAnimSpd(m_Enemy, 0.0f);
m_pManager->GetCameraManager()->CameraMoveToCoord(pos[m_Player] + TranslateCoord(m_Player, D3DXVECTOR3(200.0f, 100.0f, +100.0f))
, pos[m_Player] + TranslateCoord(m_Player, D3DXVECTOR3(50.0f, 30.0f, 0.0f))
, pos[m_Player] + TranslateCoord(m_Player, D3DXVECTOR3(40.0f, 0.0f, 0.0f))
, pos[m_Player] + TranslateCoord(m_Player, D3DXVECTOR3(0.0f, 80.0f, 0.0f))
, 100);
break;
case 300:
m_pPlayerManager->SetAnimSpd(m_Player, 0.0f);
break;
}
// バトルフェードスタート
if (m_FrameCount == m_TotalFrame - 15)
{
m_pManager->GetUiManager()->StartBattleFade();
}
/* ここまで個別 */
CDirect::CheckEnd();
}
//=================================================
// 更新
//=================================================
void CDirectBackdrop::Update( void )
{
D3DXVECTOR3 pos[2] = {
m_pPlayerManager->GetPlayerPos( PLAYER_1 ),
m_pPlayerManager->GetPlayerPos( PLAYER_2 )
};
D3DXVECTOR3 rot[2] = {
m_pPlayerManager->GetPlayerRot( PLAYER_1 ),
m_pPlayerManager->GetPlayerRot( PLAYER_2 )
};
/* ここから個別 */
switch( m_FrameCount )
{
// フレーム別の処理
case 0:
m_pPlayerManager->SetPos( m_Player, pos[m_Player] + TranslateCoord( m_Player, BACKDROP_POS1_OFFSET ) );
m_pPlayerManager->SetPos( m_Enemy, pos[m_Enemy] + TranslateCoord( m_Enemy, BACKDROP_POS2_OFFSET ) );
m_pPlayerManager->SetAnimType( m_Player, CPlayer::PLAYER_BACKDROP );
m_pPlayerManager->SetAnimType( m_Enemy, CPlayer::PLAYER_BACKDROP_DAMAGE );
//CEffect::Create( 60, EFFECT_AURA_START, false, pos[m_Player] + TranslateCoord( m_Player, BACKDROP_EFFECT_AURA_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)BACKDROP_EFFECT_AURA_SCALE );
m_pPlayerManager->TakeDamage( m_Enemy, BACKDROP_DAMAGE1 );
m_pPlayerManager->SetRot( m_Enemy, rot[m_Enemy] + TranslateCoord( m_Enemy, BACKDROP_ROT_OFFSET ) );
m_pCameraManager->CameraMoveToCoord(
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 0.0f, 100.0f, -100.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( -40.0f, 200.0f, -140.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( 0.0f, 70.0f, 0.0f ) ),
pos[m_Player] + TranslateCoord( m_Player, D3DXVECTOR3( -40.0f, 0.0f, 0.0f ) ),
100 );
break;
case 90:
{
m_pCameraManager->StartCameraShake( VECTOR3_ZERO, 10.0f, 20, 0 );
m_pPlayerManager->TakeDamage( m_Enemy, BACKDROP_DAMAGE2 );
m_pPlayerManager->AddTension( m_Player, BACKDROP_TENSION );
int label = mersenne_twister_int(SOUND_LABEL_SE_LARGE_DAMAGE01, SOUND_LABEL_SE_LARGE_DAMAGE03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
CEffect::Create( 30, EFFECT_SHOCK_WAVE, false, pos[m_Player] + TranslateCoord( m_Player, BACKDROP_EFFECT_SLAM_OFFSET ), VECTOR3_ZERO, (D3DXVECTOR3)BACKDROP_EFFECT_SLAM_SCALE );
break;
}
case 100:
{
int label = mersenne_twister_int(SOUND_LABEL_SE_DOWN01, SOUND_LABEL_SE_DOWN03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
break;
}
case 110:
{
int label = mersenne_twister_int(SOUND_LABEL_SE_CROWD01, SOUND_LABEL_SE_CROWD03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
label = mersenne_twister_int(SOUND_LABEL_SE_DOWN01, SOUND_LABEL_SE_DOWN03);
m_pManager->PlaySoundA((SOUND_LABEL)label);
break;
}
}
// バトルフェードスタート
if (m_FrameCount == m_TotalFrame - 15)
{
m_pManager->GetUiManager()->StartBattleFade();
}
/* ここまで個別 */
CDirect::CheckEnd();
}
/* void do_line(BITMAP *bmp, int x1, y1, x2, y2, int d, void (*proc)())
* Calculates all the points along a line between x1, y1 and x2, y2,
* calling the supplied function for each one. This will be passed a
* copy of the bmp parameter, the x and y position, and a copy of the
* d parameter (so do_line() can be used with putpixel()).
*/
IMAGE_NAMESPACE
#define int S_32
//unsigned long DOALPHA( unsigned long over, unsigned long in, unsigned long a );
#define FIX_SHIFT 18
#define ROUND_ERROR ( ( 1<< ( FIX_SHIFT - 1 ) ) - 1 )
void CPROC do_line( ImageFile *pImage, int x1, int y1
, int x2, int y2, CDATA d )
{
if( pImage->flags & IF_FLAG_FINAL_RENDER )
{
int glDepth = 1;
VECTOR v1[2], v2[2];
VECTOR v3[2], v4[2];
VECTOR slope;
RCOORD tmp;
VECTOR normal;
int v = 0;
TranslateCoord( pImage, (S_32*)&x1, (S_32*)&y1 );
TranslateCoord( pImage, (S_32*)&x2, (S_32*)&y2 );
v1[v][0] = x1;
v1[v][1] = y1;
v1[v][2] = 0.0;
v2[v][0] = x2;
v2[v][1] = y2;
v2[v][2] = 0.0;
sub( slope, v2[v], v1[v] );
normalize( slope );
tmp = slope[0];
slope[0] = -slope[1];
slope[1] = tmp;
addscaled( v1[v], v1[v], slope, -0.5 );
addscaled( v4[v], v1[v], slope, 1.0 );
addscaled( v2[v], v2[v], slope, -0.5 );
addscaled( v3[v], v2[v], slope, 1.0 );
while( pImage && pImage->pParent )
{
glDepth = 0;
if(pImage->transform )
{
Apply( pImage->transform, v1[1-v], v1[v] );
Apply( pImage->transform, v2[1-v], v2[v] );
Apply( pImage->transform, v3[1-v], v3[v] );
Apply( pImage->transform, v4[1-v], v4[v] );
v = 1-v;
}
pImage = pImage->pParent;
}
if( pImage->transform )
{
Apply( pImage->transform, v1[1-v], v1[v] );
Apply( pImage->transform, v2[1-v], v2[v] );
Apply( pImage->transform, v3[1-v], v3[v] );
Apply( pImage->transform, v4[1-v], v4[v] );
v = 1-v;
}
static LPDIRECT3DVERTEXBUFFER9 pQuadVB;
if( !pQuadVB )
g_d3d_device->CreateVertexBuffer(sizeof( D3DVERTEX )*4,
D3DUSAGE_WRITEONLY,
D3DFVF_CUSTOMVERTEX,
D3DPOOL_MANAGED,
&pQuadVB,
NULL);
D3DVERTEX* pData;
//lock buffer (NEW)
pQuadVB->Lock(0,0,(void**)&pData,0);
//lprintf( "line color should be %08x", d );
//copy data to buffer (NEW)
{
pData[0].fX = v1[v][vRight] * l.scale;
pData[0].fY = v1[v][vUp] * l.scale;
pData[0].fZ = v1[v][vForward] * l.scale;
pData[0].dwColor = d;
pData[1].fX = v2[v][vRight] * l.scale;
pData[1].fY = v2[v][vUp] * l.scale;
pData[1].fZ = v2[v][vForward] * l.scale;
pData[1].dwColor = d;
pData[2].fX = v4[v][vRight] * l.scale;
pData[2].fY = v4[v][vUp] * l.scale;
pData[2].fZ = v4[v][vForward] * l.scale;
pData[2].dwColor = d;
pData[3].fX = v3[v][vRight] * l.scale;
pData[3].fY = v3[v][vUp] * l.scale;
pData[3].fZ = v3[v][vForward] * l.scale;
pData[3].dwColor = d;
}
//unlock buffer (NEW)
pQuadVB->Unlock();
g_d3d_device->SetFVF( D3DFVF_CUSTOMVERTEX );
g_d3d_device->SetStreamSource(0,pQuadVB,0,sizeof(D3DVERTEX));
g_d3d_device->DrawPrimitive(D3DPT_TRIANGLESTRIP,0,2);
//pQuadVB->Release();
}
else
{
int err, delx, dely, len, inc;
if( !pImage || !pImage->image ) return;
delx = x2 - x1;
if( delx < 0 )
delx = -delx;
dely = y2 - y1;
if( dely < 0 )
dely = -dely;
if( dely > delx ) // length for y is more than length for x
{
len = dely;
if( y1 > y2 )
{
int tmp = x1;
x1 = x2;
x2 = tmp;
y1 = y2; // x1 is start...
}
if( x2 > x1 )
inc = 1;
else
inc = -1;
err = -(dely / 2);
while( len >= 0 )
{
plot( pImage, x1, y1, d );
y1++;
err += delx;
while( err >= 0 )
{
err -= dely;
x1 += inc;
}
len--;
}
}
else
{
if( !delx ) // 0 length line
return;
len = delx;
if( x1 > x2 )
{
int tmp = y1;
y1 = y2;
y2 = tmp;
x1 = x2; // x1 is start...
}
if( y2 > y1 )
inc = 1;
else
inc = -1;
err = -(delx / 2);
while( len >= 0 )
{
plot( pImage, x1, y1, d );
x1++;
err += dely;
while( err >= 0 )
{
err -= delx;
y1 += inc;
}
len--;
}
}
MarkImageUpdated( pImage );
}
}
//---------------------------------------------------------------------------
// x, y is position
// xs, ys is starting position on source bitmap (x, y is upper left) + xs, ys )
// w, h is height and width of the image to use.
// default behavior is to omit copying 0 pixels for transparency
// overlays....
void BlotImageSizedEx ( ImageFile *pifDest, ImageFile *pifSrc
, int32_t xd, int32_t yd
, int32_t xs, int32_t ys
, uint32_t ws, uint32_t hs
, uint32_t nTransparent
, uint32_t method
, ... )
{
#define BROKEN_CODE
PCDATA po, pi;
//int hd, wd;
uint32_t oo, oi; // treated as an adder... it is unsigned by math, but still results correct offset?
static uint32_t lock;
va_list colors;
va_start( colors, method );
if( nTransparent > ALPHA_TRANSPARENT_MAX )
return;
if( !pifSrc
|| !pifSrc->image
|| !pifDest
//|| !pifDest->image
)
{
// this will happen when mixing modes...
lprintf( WIDE( "sanity check failed %p %p %p" ), pifSrc, pifDest, pifSrc?pifSrc->image:NULL );
return;
}
//lprintf( WIDE( "BlotImageSized %d,%d to %d,%d by %d,%d" ), xs, ys, xd, yd, ws, hs );
{
IMAGE_RECTANGLE r1;
IMAGE_RECTANGLE r2;
IMAGE_RECTANGLE rs;
IMAGE_RECTANGLE rd;
int tmp;
//IMAGE_RECTANGLE r3;
r1.x = xd;
r1.y = yd;
r1.width = ws;
r1.height = hs;
r2.x = pifDest->eff_x;
r2.y = pifDest->eff_y;
tmp = (pifDest->eff_maxx - pifDest->eff_x) + 1;
if( tmp < 0 )
r2.width = 0;
else
r2.width = (IMAGE_SIZE_COORDINATE)tmp;
tmp = (pifDest->eff_maxy - pifDest->eff_y) + 1;
if( tmp < 0 )
r2.height = 0;
else
r2.height = (IMAGE_SIZE_COORDINATE)tmp;
if( !IntersectRectangle( &rd, &r1, &r2 ) )
{
//lprintf( WIDE( "Images do not overlap. %d,%d %d,%d vs %d,%d %d,%d" ), r1.x,r1.y,r1.width,r1.height
// , r2.x,r2.y,r2.width,r2.height);
return;
}
//lprintf( WIDE( "Correcting coordinates by %d,%d" )
// , rd.x - xd
// , rd.y - yd
// );
xs += rd.x - xd;
ys += rd.y - yd;
tmp = rd.x - xd;
if( tmp > 0 && (unsigned)tmp > ws )
ws = 0;
else
{
if( tmp < 0 )
ws += (unsigned)-tmp;
else
ws -= (unsigned)tmp;
}
tmp = rd.y - yd;
if( tmp > 0 && (unsigned)tmp > hs )
hs = 0;
else
{
if( tmp < 0 )
hs += (unsigned)-tmp;
else
hs -= (unsigned)tmp;
}
//lprintf( WIDE( "Resulting dest is %d,%d %d,%d" ), rd.x,rd.y,rd.width,rd.height );
xd = rd.x;
yd = rd.y;
r1.x = xs;
r1.y = ys;
r1.width = ws;
r1.height = hs;
r2.x = pifSrc->eff_x;
r2.y = pifSrc->eff_y;
tmp = (pifSrc->eff_maxx - pifSrc->eff_x) + 1;
if( tmp < 0 )
r2.width = 0;
else
r2.width = (IMAGE_SIZE_COORDINATE)tmp;
tmp = (pifSrc->eff_maxy - pifSrc->eff_y) + 1;
if( tmp < 0 )
r2.height = 0;
else
r2.height = (IMAGE_SIZE_COORDINATE)tmp;
if( !IntersectRectangle( &rs, &r1, &r2 ) )
{
lprintf( WIDE( "Desired Output does not overlap..." ) );
return;
}
//lprintf( WIDE( "Resulting dest is %d,%d %d,%d" ), rs.x,rs.y,rs.width,rs.height );
ws = rs.width<rd.width?rs.width:rd.width;
hs = rs.height<rd.height?rs.height:rd.height;
xs = rs.x;
ys = rs.y;
//lprintf( WIDE( "Resulting rect is %d,%d to %d,%d dim: %d,%d" ), rs.x, rs.y, rd.x, rd.y, rs.width, rs.height );
//lprintf( WIDE( "Resulting rect is %d,%d to %d,%d dim: %d,%d" ), xs, ys, xd, yd, ws, hs );
}
//lprintf( WIDE(WIDE( "Doing image (%d,%d)-(%d,%d) (%d,%d)-(%d,%d)" )), xs, ys, ws, hs, xd, yd, wd, hd );
if( (int32_t)ws <= 0 ||
(int32_t)hs <= 0 /*||
(int32_t)wd <= 0 ||
(int32_t)hd <= 0 */ )
{
lprintf( WIDE( "out of bounds" ) );
return;
}
#ifdef _INVERT_IMAGE
// set pointer in to the starting x pixel
// on the last line of the image to be copied
//pi = IMG_ADDRESS( pifSrc, xs, ys );
//po = IMG_ADDRESS( pifDest, xd, yd );
pi = IMG_ADDRESS( pifSrc, xs, ys );
po = IMG_ADDRESS( pifDest, xd, yd );
//cpg 19 Jan 2007 2>c:\work\sack\src\imglib\blotdirect.c(492) : warning C4146: unary minus operator applied to unsigned type, result still unsigned
//cpg 19 Jan 2007 2>c:\work\sack\src\imglib\blotdirect.c(493) : warning C4146: unary minus operator applied to unsigned type, result still unsigned
oo = 4*-(int)(ws+pifDest->pwidth); // w is how much we can copy...
oi = 4*-(int)(ws+pifSrc->pwidth); // adding remaining width...
#else
// set pointer in to the starting x pixel
// on the first line of the image to be copied...
pi = IMG_ADDRESS( pifSrc, xs, ys );
po = IMG_ADDRESS( pifDest, xd, yd );
oo = 4*(pifDest->pwidth - ws); // w is how much we can copy...
oi = 4*(pifSrc->pwidth - ws); // adding remaining width...
#endif
//lprintf( WIDE("Doing image (%d,%d)-(%d,%d) (%d,%d)-(%d,%d)"), xs, ys, ws, hs, xd, yd, wd, hd );
//oo = 4*(pifDest->pwidth - ws); // w is how much we can copy...
//oi = 4*(pifSrc->pwidth - ws); // adding remaining width...
while( LockedExchange( &lock, 1 ) )
Relinquish();
if( ( pifDest->flags & IF_FLAG_FINAL_RENDER )
&& !( pifDest->flags & IF_FLAG_IN_MEMORY ) )
{
Image topmost_parent;
ReloadOpenGlTexture( pifSrc, 0 );
if( !pifSrc->glActiveSurface )
{
//lprintf( WIDE( "gl texture hasn't updated or went away?" ) );
lock = 0;
return;
}
//lprintf( WIDE( "use regular texture %p (%d,%d)" ), pifSrc, pifSrc->width, pifSrc->height );
//DebugBreak(); g
// closed loop to get the top imgae size.
for( topmost_parent = pifSrc; topmost_parent->pParent; topmost_parent = topmost_parent->pParent );
/*
* only a portion of the image is actually used, the rest is filled with blank space
*
*/
TranslateCoord( pifDest, &xd, &yd );
TranslateCoord( pifSrc, &xs, &ys );
{
int glDepth = 1;
double x_size, x_size2, y_size, y_size2;
VECTOR v1[2], v3[2],v4[2],v2[2];
int v = 0;
v1[v][0] = xd;
v1[v][1] = yd;
v1[v][2] = 0.0;
v2[v][0] = xd;
v2[v][1] = yd+hs;
v2[v][2] = 0.0;
v3[v][0] = xd+ws;
v3[v][1] = yd+hs;
v3[v][2] = 0.0;
v4[v][0] = xd+ws;
v4[v][1] = yd;
v4[v][2] = 0.0;
x_size = (double) xs/ (double)topmost_parent->width;
x_size2 = (double) (xs+ws)/ (double)topmost_parent->width;
y_size = (double) ys/ (double)topmost_parent->height;
y_size2 = (double) (ys+hs)/ (double)topmost_parent->height;
// Front Face
//glColor4ub( 255,120,32,192 );
//lprintf( WIDE( "Texture size is %g,%g to %g,%g" ), x_size, y_size, x_size2, y_size2 );
while( pifDest && pifDest->pParent )
{
glDepth = 0;
if( pifDest->transform )
{
Apply( pifDest->transform, v1[1-v], v1[v] );
Apply( pifDest->transform, v2[1-v], v2[v] );
Apply( pifDest->transform, v3[1-v], v3[v] );
Apply( pifDest->transform, v4[1-v], v4[v] );
v = 1-v;
}
pifDest = pifDest->pParent;
}
if( pifDest->transform )
{
Apply( pifDest->transform, v1[1-v], v1[v] );
Apply( pifDest->transform, v2[1-v], v2[v] );
Apply( pifDest->transform, v3[1-v], v3[v] );
Apply( pifDest->transform, v4[1-v], v4[v] );
v = 1-v;
}
#if 0
if( glDepth )
{
//lprintf( WIDE( "enqable depth..." ) );
glEnable( GL_DEPTH_TEST );
}
else
{
//lprintf( WIDE( "disable depth..." ) );
glDisable( GL_DEPTH_TEST );
}
#endif
glBindTexture(GL_TEXTURE_2D, pifSrc->glActiveSurface); // Select Our Texture
if( method == BLOT_COPY )
glColor4ub( 255,255,255,255 );
else if( method == BLOT_SHADED )
{
CDATA tmp = va_arg( colors, CDATA );
glColor4ubv( (GLubyte*)&tmp );
}
else if( method == BLOT_MULTISHADE )
{
#if !defined( __ANDROID__ )
InitShader();
if( glUseProgram && l.glActiveSurface->shader.multi_shader )
{
int err;
CDATA r = va_arg( colors, CDATA );
CDATA g = va_arg( colors, CDATA );
CDATA b = va_arg( colors, CDATA );
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glUseProgram( l.glActiveSurface->shader.multi_shader );
err = glGetError();
glProgramLocalParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 0, (float)GetRedValue( r )/255.0f, (float)GetGreenValue( r )/255.0f, (float)GetBlueValue( r )/255.0f, (float)GetAlphaValue( r )/255.0f );
err = glGetError();
glProgramLocalParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 1, (float)GetRedValue( g )/255.0f, (float)GetGreenValue( g )/255.0f, (float)GetBlueValue( g )/255.0f, (float)GetAlphaValue( g )/255.0f );
err = glGetError();
glProgramLocalParameter4fARB( GL_FRAGMENT_PROGRAM_ARB, 2, (float)GetRedValue( b )/255.0f, (float)GetGreenValue( b )/255.0f, (float)GetBlueValue( b )/255.0f, (float)GetAlphaValue( b )/255.0f );
err = glGetError();
}
else
#endif
{
Image output_image;
CDATA r = va_arg( colors, CDATA );
CDATA g = va_arg( colors, CDATA );
CDATA b = va_arg( colors, CDATA );
output_image = GetShadedImage( pifSrc, r, g, b );
glBindTexture( GL_TEXTURE_2D, output_image->glActiveSurface );
glColor4ub( 255,255,255,255 );
}
}
else if( method == BLOT_INVERTED )
{
#if !defined( __ANDROID__ )
InitShader();
if( l.glActiveSurface->shader.inverse_shader )
{
int err;
glEnable(GL_FRAGMENT_PROGRAM_ARB);
glUseProgram( l.glActiveSurface->shader.inverse_shader );
err = glGetError();
}
else
#endif
{
Image output_image;
output_image = GetInvertedImage( pifSrc );
glBindTexture( GL_TEXTURE_2D, output_image->glActiveSurface );
glColor4ub( 255,255,255,255 );
}
}
glBegin(GL_TRIANGLE_STRIP);
//glBegin(GL_QUADS);
scale( v1[v], v1[v], l.scale );
scale( v2[v], v2[v], l.scale );
scale( v3[v], v3[v], l.scale );
scale( v4[v], v4[v], l.scale );
glTexCoord2f(x_size, y_size); glVertex3fv(v1[v]); // Bottom Left Of The Texture and Quad
glTexCoord2f(x_size, y_size2); glVertex3fv(v2[v]); // Top Left Of The Texture and Quad
glTexCoord2f(x_size2, y_size); glVertex3fv(v4[v]); // Bottom Right Of The Texture and Quad
glTexCoord2f(x_size2, y_size2); glVertex3fv(v3[v]); // Top Right Of The Texture and Quad
// Back Face
glEnd();
#if !defined( __ANDROID__ )
if( method == BLOT_MULTISHADE )
{
if( l.glActiveSurface->shader.multi_shader )
{
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
}
else if( method == BLOT_INVERTED )
{
if( l.glActiveSurface->shader.inverse_shader )
{
glDisable(GL_FRAGMENT_PROGRAM_ARB);
}
}
#endif
glBindTexture(GL_TEXTURE_2D, 0); // Select Our Texture
}
}
else
{
switch( method )
{
case BLOT_COPY:
if( !nTransparent )
CopyPixelsT0( po, pi, oo, oi, ws, hs );
else if( nTransparent == 1 )
CopyPixelsT1( po, pi, oo, oi, ws, hs );
else if( nTransparent & ALPHA_TRANSPARENT )
CopyPixelsTImgA( po, pi, oo, oi, ws, hs, nTransparent & 0xFF);
else if( nTransparent & ALPHA_TRANSPARENT_INVERT )
CopyPixelsTImgAI( po, pi, oo, oi, ws, hs, nTransparent & 0xFF );
else
CopyPixelsTA( po, pi, oo, oi, ws, hs, nTransparent );
break;
case BLOT_SHADED:
if( !nTransparent )
CopyPixelsShadedT0( po, pi, oo, oi, ws, hs
, va_arg( colors, CDATA ) );
else if( nTransparent == 1 )
CopyPixelsShadedT1( po, pi, oo, oi, ws, hs
, va_arg( colors, CDATA ) );
else if( nTransparent & ALPHA_TRANSPARENT )
CopyPixelsShadedTImgA( po, pi, oo, oi, ws, hs, nTransparent & 0xFF
, va_arg( colors, CDATA ) );
else if( nTransparent & ALPHA_TRANSPARENT_INVERT )
CopyPixelsShadedTImgAI( po, pi, oo, oi, ws, hs, nTransparent & 0xFF
, va_arg( colors, CDATA ) );
else
CopyPixelsShadedTA( po, pi, oo, oi, ws, hs, nTransparent
, va_arg( colors, CDATA ) );
break;
case BLOT_MULTISHADE:
{
CDATA r,g,b;
r = va_arg( colors, CDATA );
g = va_arg( colors, CDATA );
b = va_arg( colors, CDATA );
//lprintf( WIDE( "r g b %08x %08x %08x" ), r,g, b );
if( !nTransparent )
CopyPixelsMultiT0( po, pi, oo, oi, ws, hs
, r, g, b );
else if( nTransparent == 1 )
CopyPixelsMultiT1( po, pi, oo, oi, ws, hs
, r, g, b );
else if( nTransparent & ALPHA_TRANSPARENT )
CopyPixelsMultiTImgA( po, pi, oo, oi, ws, hs, nTransparent & 0xFF
, r, g, b );
else if( nTransparent & ALPHA_TRANSPARENT_INVERT )
CopyPixelsMultiTImgAI( po, pi, oo, oi, ws, hs, nTransparent & 0xFF
, r, g, b );
else
CopyPixelsMultiTA( po, pi, oo, oi, ws, hs, nTransparent
, r, g, b );
}
break;
}
MarkImageUpdated( pifDest );
}
lock = 0;
//lprintf( WIDE( "Image done.." ) );
}
