void UModel::PostLoad()
{
Super::PostLoad();
if( FApp::CanEverRender() && !HasAnyFlags(RF_ClassDefaultObject) )
{
UpdateVertices();
}
// If in the editor, initialize each surface to hidden or not depending upon
// whether the poly flag dictates being hidden at editor startup or not
if ( GIsEditor )
{
for ( TArray<FBspSurf>::TIterator SurfIter( Surfs ); SurfIter; ++SurfIter )
{
FBspSurf& CurSurf = *SurfIter;
CurSurf.bHiddenEdTemporary = ( ( CurSurf.PolyFlags & PF_HiddenEd ) != 0 );
CurSurf.bHiddenEdLevel = 0;
}
#if WITH_EDITOR
if (ABrush* Owner = Cast<ABrush>(GetOuter()))
{
OwnerLocationWhenLastBuilt = Owner->GetActorLocation();
OwnerPrepivotWhenLastBuilt = Owner->GetPrePivot();
OwnerScaleWhenLastBuilt = Owner->GetActorScale();
OwnerRotationWhenLastBuilt = -Owner->GetActorRotation();
bCachedOwnerTransformValid = true;
}
#endif
}
}
void UIDirect3D9Window::DrawTexture(D3D9Texture *Texture, QRectF *Dest, QSizeF *Size, bool &PositionChanged)
{
static const float studiorange = 219.0f / 255.0f;
static const float studiooffset = 16.0f / 255.0f;
if (!Texture || !Dest || !m_d3dDevice || !Size)
return;
SetBlend(true);
if (PositionChanged || !Texture->m_verticesUpdated)
{
PositionChanged = false;
UpdateVertices(Texture, Dest, Size);
}
// TODO some basic state tracking
// TODO null pointer checks
D3DXVECTOR4 color;
color.x = m_transforms[m_currentTransformIndex].color;
color.y = m_studioLevels ? studiorange : 1.0f;
color.z = m_studioLevels ? studiooffset : 0.0f;
color.w = m_transforms[m_currentTransformIndex].alpha;
m_defaultShader->m_vertexConstants->SetMatrix(m_d3dDevice, "Projection", m_currentProjection);
m_defaultShader->m_vertexConstants->SetMatrix(m_d3dDevice, "Transform", &m_transforms[m_currentTransformIndex].m);
m_defaultShader->m_pixelConstants->SetVector(m_d3dDevice, "Color", &color);
//uint index = m_defaultShader->m_pixelConstants->GetSamplerIndex("MySampler");
m_d3dDevice->SetTexture(0, (LPDIRECT3DBASETEXTURE9)Texture->m_texture);
m_d3dDevice->SetVertexShader(m_defaultShader->m_vertexShader);
m_d3dDevice->SetPixelShader(m_defaultShader->m_pixelShader);
m_d3dDevice->SetStreamSource(0, Texture->m_vertexBuffer, 0, 5 * sizeof(float));
m_d3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 4);
}
///SS5の場合 SsPartのarrayIndexは、親子順（子は親より先にいない）と
///なっているためそのまま木構造を作らずUpdateを行う
void FSsAnimeDecoder::Update()
{
int32 time = (int32)NowPlatTime;
if(EffectUntreatedDeltaTime < 0.f)
{
ReloadEffects();
EffectUntreatedDeltaTime = NowPlatTime;
}
int32 EffectUpdateTimes = (int32)EffectUntreatedDeltaTime;
int32 EffectBaseTime = time - EffectUpdateTimes + 1;
for(int i = 0; i < PartAnime.Num(); ++i)
{
FSsPart* part = PartAnime[i].Key;
FSsPartAnime* anime = PartAnime[i].Value;
if((part->Type == SsPartType::Effect) && (PartState[i].RefEffect))
{
// エフェクトは1フレーム単位でしか更新しない
// (1フレーム == 0.5フレームずつ2回更新)
if(0 == EffectUpdateTimes)
{
UpdateState(time, part, anime, &PartState[i]);
UpdateMatrix(part, anime, &PartState[i]);
PartState[i].RefEffect->Update(0.f);
}
else
{
for (int32 j = 0; j < (EffectUpdateTimes*2); ++j)
{
UpdateState(EffectBaseTime + j, part, anime, &PartState[i]);
UpdateMatrix(part, anime, &PartState[i]);
PartState[i].RefEffect->Update(
PartState[i].RefEffect->GetFirstUpdated() ? .5f : 0.f
);
}
}
}
else
{
UpdateState(time, part, anime, &PartState[i]);
UpdateMatrix(part, anime, &PartState[i]);
if (part->Type == SsPartType::Instance)
{
UpdateInstance(time, part, anime, &PartState[i]);
UpdateVertices(part, anime, &PartState[i]);
}
}
}
EffectUntreatedDeltaTime -= EffectUpdateTimes;
SortList.Sort();
}
void Drawable2D::OnWorldBoundingBoxUpdate()
{
if (verticesDirty_)
{
UpdateVertices();
boundingBox_.Clear();
for (unsigned i = 0; i < vertices_.Size(); ++i)
boundingBox_.Merge(vertices_[i].position_);
}
worldBoundingBox_ = boundingBox_.Transformed(node_->GetWorldTransform());
}
void UIDirect3D9Window::DrawTexture(D3D9Shader *Shader, D3D9Texture *Texture, QRectF *Dest, QSizeF *Size, bool &PositionChanged)
{
if (!Shader || !Texture || !Dest || !m_d3dDevice || !Size)
return;
if (PositionChanged || !Texture->m_verticesUpdated)
{
PositionChanged = false;
UpdateVertices(Texture, Dest, Size);
}
SetBlend(true);
Shader->m_vertexConstants->SetMatrix(m_d3dDevice, "Projection", m_currentProjection);
Shader->m_vertexConstants->SetMatrix(m_d3dDevice, "Transform", &m_transforms[m_currentTransformIndex].m);
m_d3dDevice->SetTexture(0, (LPDIRECT3DBASETEXTURE9)Texture->m_texture);
m_d3dDevice->SetVertexShader(Shader->m_vertexShader);
m_d3dDevice->SetPixelShader(Shader->m_pixelShader);
m_d3dDevice->SetStreamSource(0, Texture->m_vertexBuffer, 0, 5 * sizeof(float));
m_d3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 4);
}
/* Frustum implementation
//****************************************************************************/
void Frustum::FromCameraMatrix( const Mat4& cm )
{
plLeft.a = cm.e03 + cm.e00;
plLeft.b = cm.e13 + cm.e10;
plLeft.c = cm.e23 + cm.e20;
plLeft.d = cm.e33 + cm.e30;
plRight.a = cm.e03 - cm.e00;
plRight.b = cm.e13 - cm.e10;
plRight.c = cm.e23 - cm.e20;
plRight.d = cm.e33 - cm.e30;
plBottom.a = cm.e03 + cm.e01;
plBottom.b = cm.e13 + cm.e11;
plBottom.c = cm.e23 + cm.e21;
plBottom.d = cm.e33 + cm.e31;
plTop.a = cm.e03 - cm.e01;
plTop.b = cm.e13 - cm.e11;
plTop.c = cm.e23 - cm.e21;
plTop.d = cm.e33 - cm.e31;
plNear.a = cm.e02;
plNear.b = cm.e12;
plNear.c = cm.e22;
plNear.d = cm.e32;
plFar.a = cm.e03 - cm.e02;
plFar.b = cm.e13 - cm.e12;
plFar.c = cm.e23 - cm.e22;
plFar.d = cm.e33 - cm.e32;
plLeft.Normalize();
plRight.Normalize();
plBottom.Normalize();
plTop.Normalize();
plNear.Normalize();
plFar.Normalize();
UpdateVertices();
} // Frustum::FromCameraMatrix
void UModel::PostLoad()
{
Super::PostLoad();
if( FApp::CanEverRender() && !HasAnyFlags(RF_ClassDefaultObject) )
{
UpdateVertices();
}
// If in the editor, initialize each surface to hidden or not depending upon
// whether the poly flag dictates being hidden at editor startup or not
if ( GIsEditor )
{
for ( TArray<FBspSurf>::TIterator SurfIter( Surfs ); SurfIter; ++SurfIter )
{
FBspSurf& CurSurf = *SurfIter;
CurSurf.bHiddenEdTemporary = ( ( CurSurf.PolyFlags & PF_HiddenEd ) != 0 );
CurSurf.bHiddenEdLevel = 0;
}
}
}
void Drawable2D::UpdateGeometry(const FrameInfo& frame)
{
if (verticesDirty_)
UpdateVertices();
if (geometryDirty_ || vertexBuffer_->IsDataLost())
{
unsigned vertexCount = vertices_.Size() / 4 * 6;
if (vertexCount)
{
vertexBuffer_->SetSize(vertexCount, MASK_VERTEX2D);
Vertex2D* dest = reinterpret_cast<Vertex2D*>(vertexBuffer_->Lock(0, vertexCount, true));
if (dest)
{
for (unsigned i = 0; i < vertices_.Size(); i += 4)
{
dest[0] = vertices_[i + 0];
dest[1] = vertices_[i + 1];
dest[2] = vertices_[i + 2];
dest[3] = vertices_[i + 0];
dest[4] = vertices_[i + 2];
dest[5] = vertices_[i + 3];
dest += 6;
}
vertexBuffer_->Unlock();
}
else
LOGERROR("Failed to lock vertex buffer");
}
geometry_->SetDrawRange(TRIANGLE_LIST, 0, 0, 0, vertexCount);
vertexBuffer_->ClearDataLost();
geometryDirty_ = false;
}
}
HRESULT KModelSFXLineGrass::FrameMove()
{
UpdateVertices();
return S_OK;
}
void Rectangle::SetDepth(float depth_) {
depth = depth_;
UpdateVertices();
}
///現在の時間からパーツのアトリビュートの補間値を計算する
void FSsAnimeDecoder::UpdateState( int nowTime , FSsPart* part , FSsPartAnime* anime , FSsPartState* state )
{
//ステートの初期値を設定
state->Init();
state->InheritRates = part->InheritRates;
if ( anime == 0 ){
IdentityMatrix( state->Matrix );
return ;
}
// 親の継承設定を引用する設定の場合、ここで参照先を親のものに変えておく。
if (part->InheritType == SsInheritType::Parent)
{
if ( state->Parent )
{
state->InheritRates = state->Parent->InheritRates;
}
}
bool size_x_key_find = false;
bool size_y_key_find = false;
state->IsVertexTransform = false;
state->IsColorBlend = false;
state->AlphaBlendType = part->AlphaBlendType;
bool hidekey_find = false;
if ( 0 < anime->Attributes.Num() )
{
for(int i = 0; i < anime->Attributes.Num(); ++i)
{
FSsAttribute* attr = &(anime->Attributes[i]);
switch( attr->Tag )
{
case SsAttributeKind::Invalid: ///< 無効値。旧データからの変換時など
break;
case SsAttributeKind::Cell: ///< 参照セル
{
SsGetKeyValue( nowTime , attr , state->CellValue );
state->NoCells = false;
}
break;
case SsAttributeKind::Posx: ///< 位置.X
SsGetKeyValue( nowTime , attr , state->Position.X );
break;
case SsAttributeKind::Posy: ///< 位置.Y
SsGetKeyValue( nowTime , attr , state->Position.Y );
break;
case SsAttributeKind::Posz: ///< 位置.Z
SsGetKeyValue( nowTime , attr , state->Position.Z );
break;
case SsAttributeKind::Rotx: ///< 回転.X
SsGetKeyValue( nowTime , attr , state->Rotation.X );
break;
case SsAttributeKind::Roty: ///< 回転.Y
SsGetKeyValue( nowTime , attr , state->Rotation.Y );
break;
case SsAttributeKind::Rotz: ///< 回転.Z
SsGetKeyValue( nowTime , attr , state->Rotation.Z );
break;
case SsAttributeKind::Sclx: ///< スケール.X
SsGetKeyValue( nowTime , attr , state->Scale.X );
break;
case SsAttributeKind::Scly: ///< スケール.Y
SsGetKeyValue( nowTime , attr , state->Scale.Y );
break;
case SsAttributeKind::Alpha: ///< 不透明度
SsGetKeyValue( nowTime , attr , state->Alpha );
break;
case SsAttributeKind::Prio: ///< 優先度
SsGetKeyValue( nowTime , attr , state->Prio );
break;
case SsAttributeKind::Fliph: ///< 左右反転(セルの原点を軸にする)
SsGetKeyValue( nowTime , attr , state->HFlip );
break;
case SsAttributeKind::Flipv: ///< 上下反転(セルの原点を軸にする)
SsGetKeyValue( nowTime , attr , state->VFlip );
break;
case SsAttributeKind::Hide: ///< 非表示
{
int useTime = SsGetKeyValue( nowTime , attr , state->Hide );
// 非表示キーがないか、先頭の非表示キーより手前の場合は常に非表示にする。
if ( useTime > nowTime )
{
state->Hide = true;
}
// 非表示キーがあり、かつ最初のキーフレームを取得した
else
{
hidekey_find = true;
}
}
break;
case SsAttributeKind::Color: ///< カラーブレンド
SsGetKeyValue( nowTime , attr , state->ColorValue );
state->IsColorBlend = true;
break;
case SsAttributeKind::Vertex: ///< 頂点変形
SsGetKeyValue( nowTime , attr , state->VertexValue );
state->IsVertexTransform = true;
break;
case SsAttributeKind::Pivotx: ///< 原点オフセット.X
SsGetKeyValue( nowTime , attr , state->PivotOffset.X );
break;
case SsAttributeKind::Pivoty: ///< 原点オフセット.Y
SsGetKeyValue( nowTime , attr , state->PivotOffset.Y );
break;
case SsAttributeKind::Anchorx: ///< アンカーポイント.X
SsGetKeyValue( nowTime , attr , state->Anchor.X );
break;
case SsAttributeKind::Anchory: ///< アンカーポイント.Y
SsGetKeyValue( nowTime , attr , state->Anchor.Y );
break;
case SsAttributeKind::Sizex: ///< 表示サイズ.X
SsGetKeyValue( nowTime , attr , state->Size.X );
size_x_key_find = true;
break;
case SsAttributeKind::Sizey: ///< 表示サイズ.Y
SsGetKeyValue( nowTime , attr , state->Size.Y );
size_y_key_find = true;
break;
case SsAttributeKind::Imgfliph: ///< イメージ左右反転(常にイメージの中央を原点とする)
SsGetKeyValue( nowTime , attr , state->ImageFlipH );
break;
case SsAttributeKind::Imgflipv: ///< イメージ上下反転(常にイメージの中央を原点とする)
SsGetKeyValue( nowTime , attr , state->ImageFlipV );
break;
case SsAttributeKind::Uvtx: ///< UVアニメ.移動.X
SsGetKeyValue( nowTime , attr , state->UvTranslate.X );
break;
case SsAttributeKind::Uvty: ///< UVアニメ.移動.Y
SsGetKeyValue( nowTime , attr , state->UvTranslate.Y );
break;
case SsAttributeKind::Uvrz: ///< UVアニメ.回転
SsGetKeyValue( nowTime , attr , state->UvRotation );
break;
case SsAttributeKind::Uvsx: ///< UVアニメ.スケール.X
SsGetKeyValue( nowTime , attr , state->UvScale.X );
break;
case SsAttributeKind::Uvsy: ///< UVアニメ.スケール.Y
SsGetKeyValue( nowTime , attr , state->UvScale.Y );
break;
case SsAttributeKind::Boundr: ///< 当たり判定用の半径
SsGetKeyValue(nowTime, attr, state->BoundingRadius);
break;
case SsAttributeKind::User: ///< Ver.4 互換ユーザーデータ
break;
case SsAttributeKind::Instance: ///インスタンスパラメータ
SsGetKeyValue(nowTime, attr, state->InstanceValue);
break;
}
}
}
// カラー値だけアニメが無いと設定されないので初期値を入れておく。
// alpha はupdateで初期化されるのでOK
// 当たり判定パーツ用のカラー。赤の半透明にする
static const float sColorsForBoundsParts[] = {0.5f, 0.f, 0.f, 1.f};
for (int i = 0; i < (4*4) ; ++i)
{
if (state->NoCells)
state->Colors[i] = sColorsForBoundsParts[i & 3];
else
state->Colors[i] = 1.f;
}
// 継承
if (state->Parent)
{
// α
if (state->Inherits_(SsAttributeKind::Alpha))
{
state->Alpha *= state->Parent->Alpha;
}
// フリップの継承。継承ONだと親に対しての反転になる…ヤヤコシス
if (state->Inherits_(SsAttributeKind::Fliph))
{
state->HFlip = state->Parent->HFlip ^ state->HFlip;
}
if (state->Inherits_(SsAttributeKind::Flipv))
{
state->VFlip = state->Parent->VFlip ^ state->VFlip;
}
// 引き継ぐ場合は親の値をそのまま引き継ぐ
if (state->Inherits_(SsAttributeKind::Hide))
{
state->Hide = state->Parent->Hide;
}
}
// 非表示キーがないか、先頭の非表示キーより手前の場合は常に非表示にする。(継承関係なし)
if (!hidekey_find)
{
state->Hide = true;
}
// 頂点の設定
if ( part->Type == SsPartType::Normal )
{
FSsCell * cell = state->CellValue.Cell;
if (cell && anime)
{
//サイズアトリビュートが指定されていない場合、セルのサイズを設定する
if ( !size_x_key_find ) state->Size.X = cell->Size.X;
if ( !size_y_key_find ) state->Size.Y = cell->Size.Y;
}
UpdateVertices(part , anime , state);
}
if(part->Type == SsPartType::Effect)
{
bool reload = false;
FSsEffectRenderer * effectRender = state->RefEffect;
if(effectRender)
{
if(state->Hide)
{
if(effectRender->GetPlayStatus())
{
effectRender->Stop();
effectRender->Reload();
}
}
else
{
effectRender->SetSeed(GetRandomSeed());
effectRender->SetLoop(false);
effectRender->Play();
}
}
}
}
void CSlideShowPic::Process(unsigned int currentTime, CDirtyRegionList &dirtyregions)
{
if (!m_pImage || !m_bIsLoaded || m_bIsFinished) return ;
color_t alpha = m_alpha;
if (m_iCounter <= m_transistionStart.length)
{ // do start transistion
if (m_transistionStart.type == CROSSFADE)
{ // fade in at 1x speed
alpha = (color_t)((float)m_iCounter / (float)m_transistionStart.length * 255.0f);
}
else if (m_transistionStart.type == FADEIN_FADEOUT)
{ // fade in at 2x speed, then keep solid
alpha = (color_t)((float)m_iCounter / (float)m_transistionStart.length * 255.0f * 2);
if (alpha > 255) alpha = 255;
}
else // m_transistionEffect == TRANSISTION_NONE
{
alpha = 0xFF; // opaque
}
}
bool bPaused = m_bPause | (m_fZoomAmount != 1.0f);
// check if we're doing a temporary effect (such as rotate + zoom)
if (m_transistionTemp.type != TRANSISTION_NONE)
{
bPaused = true;
if (m_iCounter >= m_transistionTemp.start)
{
if (m_iCounter >= m_transistionTemp.start + m_transistionTemp.length)
{ // we're finished this transistion
if (m_transistionTemp.type == TRANSISTION_ZOOM)
{ // correct for any introduced inaccuracies.
int i;
for (i = 0; i < 10; i++)
{
if (fabs(m_fZoomAmount - zoomamount[i]) < 0.01*zoomamount[i])
{
m_fZoomAmount = zoomamount[i];
break;
}
}
m_bNoEffect = (m_fZoomAmount != 1.0f); // turn effect rendering back on.
}
m_transistionTemp.type = TRANSISTION_NONE;
}
else
{
if (m_transistionTemp.type == TRANSISTION_ROTATE)
m_fAngle += m_fTransistionAngle;
if (m_transistionTemp.type == TRANSISTION_ZOOM)
m_fZoomAmount += m_fTransistionZoom;
}
}
}
// now just display
if (!m_bNoEffect && !bPaused)
{
if (m_displayEffect == EFFECT_PANORAMA)
{
m_fPosX += m_fVelocityX;
m_fPosY += m_fVelocityY;
}
else if (m_displayEffect == EFFECT_FLOAT)
{
m_fPosX += m_fVelocityX;
m_fPosY += m_fVelocityY;
float fMoveAmount = g_advancedSettings.m_slideshowPanAmount * m_iTotalFrames * 0.0001f;
if (m_fPosX > fMoveAmount)
{
m_fPosX = fMoveAmount;
m_fVelocityX = -m_fVelocityX;
}
if (m_fPosX < -fMoveAmount)
{
m_fPosX = -fMoveAmount;
m_fVelocityX = -m_fVelocityX;
}
if (m_fPosY > fMoveAmount)
{
m_fPosY = fMoveAmount;
m_fVelocityY = -m_fVelocityY;
}
if (m_fPosY < -fMoveAmount)
{
m_fPosY = -fMoveAmount;
m_fVelocityY = -m_fVelocityY;
}
}
else if (m_displayEffect == EFFECT_ZOOM)
{
m_fPosZ += m_fVelocityZ;
/* if (m_fPosZ > 1.0f + 0.01f*CServiceBroker::GetSettings().GetInt("Slideshow.ZoomAmount"))
{
m_fPosZ = 1.0f + 0.01f * CServiceBroker::GetSettings().GetInt("Slideshow.ZoomAmount");
m_fVelocityZ = -m_fVelocityZ;
}
if (m_fPosZ < 1.0f)
{
m_fPosZ = 1.0f;
m_fVelocityZ = -m_fVelocityZ;
}*/
}
}
if (m_displayEffect != EFFECT_NO_TIMEOUT && bPaused && !m_bTransistionImmediately)
{ // paused - increment the last transistion start time
m_transistionEnd.start++;
}
if (m_iCounter >= m_transistionEnd.start)
{ // do end transistion
// CLog::Log(LOGDEBUG,"Transistioning");
m_bDrawNextImage = true;
if (m_transistionEnd.type == CROSSFADE)
{ // fade out at 1x speed
alpha = 255 - (color_t)((float)(m_iCounter - m_transistionEnd.start) / (float)m_transistionEnd.length * 255.0f);
}
else if (m_transistionEnd.type == FADEIN_FADEOUT)
{ // keep solid, then fade out at 2x speed
alpha = (color_t)((float)(m_transistionEnd.length - m_iCounter + m_transistionEnd.start) / (float)m_transistionEnd.length * 255.0f * 2);
if (alpha > 255) alpha = 255;
}
else // m_transistionEffect == TRANSISTION_NONE
{
alpha = 0xFF; // opaque
}
}
if (alpha != m_alpha)
{
m_alpha = alpha;
m_bIsDirty = true;
}
if (m_displayEffect != EFFECT_NO_TIMEOUT || m_iCounter < m_transistionStart.length || m_iCounter >= m_transistionEnd.start || (m_iCounter >= m_transistionTemp.start && m_iCounter < m_transistionTemp.start + m_transistionTemp.length))
{
/* this really annoying. there's non-stop logging when viewing a pic outside of the slideshow
if (m_displayEffect == EFFECT_NO_TIMEOUT)
CLog::Log(LOGDEBUG, "Incrementing counter (%i) while not in slideshow (startlength=%i,endstart=%i,endlength=%i)", m_iCounter, m_transistionStart.length, m_transistionEnd.start, m_transistionEnd.length);
*/
m_iCounter++;
}
if (m_iCounter > m_transistionEnd.start + m_transistionEnd.length)
m_bIsFinished = true;
RESOLUTION_INFO info = g_graphicsContext.GetResInfo();
// calculate where we should render (and how large it should be)
// calculate aspect ratio correction factor
float fOffsetX = (float)info.Overscan.left;
float fOffsetY = (float)info.Overscan.top;
float fScreenWidth = (float)info.Overscan.right - info.Overscan.left;
float fScreenHeight = (float)info.Overscan.bottom - info.Overscan.top;
float fPixelRatio = info.fPixelRatio;
// Rotate the image as needed
float x[4];
float y[4];
float si = (float)sin(m_fAngle / 180.0f * M_PI);
float co = (float)cos(m_fAngle / 180.0f * M_PI);
x[0] = -m_fWidth * co + m_fHeight * si;
y[0] = -m_fWidth * si - m_fHeight * co;
x[1] = m_fWidth * co + m_fHeight * si;
y[1] = m_fWidth * si - m_fHeight * co;
x[2] = m_fWidth * co - m_fHeight * si;
y[2] = m_fWidth * si + m_fHeight * co;
x[3] = -m_fWidth * co - m_fHeight * si;
y[3] = -m_fWidth * si + m_fHeight * co;
// calculate our scale amounts
float fSourceAR = m_fWidth / m_fHeight;
float fSourceInvAR = 1 / fSourceAR;
float fAR = si * si * (fSourceInvAR - fSourceAR) + fSourceAR;
//float fOutputFrameAR = fAR / fPixelRatio;
float fScaleNorm = fScreenWidth / m_fWidth;
float fScaleInv = fScreenWidth / m_fHeight;
bool bFillScreen = false;
float fComp = 1.0f + 0.01f * g_advancedSettings.m_slideshowBlackBarCompensation;
float fScreenRatio = fScreenWidth / fScreenHeight * fPixelRatio;
// work out if we should be compensating the zoom to minimize blackbars
// we should compute this based on the % of black bars on screen perhaps??
//! @todo change m_displayEffect != EFFECT_NO_TIMEOUT to whether we're running the slideshow
if (m_displayEffect != EFFECT_NO_TIMEOUT && fScreenRatio < fSourceAR * fComp && fSourceAR < fScreenRatio * fComp)
bFillScreen = true;
if ((!bFillScreen && fScreenWidth*fPixelRatio > fScreenHeight*fSourceAR) || (bFillScreen && fScreenWidth*fPixelRatio < fScreenHeight*fSourceAR))
fScaleNorm = fScreenHeight / (m_fHeight * fPixelRatio);
bFillScreen = false;
if (m_displayEffect != EFFECT_NO_TIMEOUT && fScreenRatio < fSourceInvAR * fComp && fSourceInvAR < fScreenRatio * fComp)
bFillScreen = true;
if ((!bFillScreen && fScreenWidth*fPixelRatio > fScreenHeight*fSourceInvAR) || (bFillScreen && fScreenWidth*fPixelRatio < fScreenHeight*fSourceInvAR))
fScaleInv = fScreenHeight / (m_fWidth * fPixelRatio);
float fScale = si * si * (fScaleInv - fScaleNorm) + fScaleNorm;
// scale if we need to due to the effect we're using
if (m_displayEffect == EFFECT_PANORAMA)
{
if (m_fWidth > m_fHeight)
fScale *= m_fWidth / fScreenWidth * fScreenHeight / m_fHeight;
else
fScale *= m_fHeight / fScreenHeight * fScreenWidth / m_fWidth;
}
if (m_displayEffect == EFFECT_FLOAT)
fScale *= (1.0f + g_advancedSettings.m_slideshowPanAmount * m_iTotalFrames * 0.0001f);
if (m_displayEffect == EFFECT_ZOOM)
fScale *= m_fPosZ;
// zoom image
fScale *= m_fZoomAmount;
// calculate the resultant coordinates
for (int i = 0; i < 4; i++)
{
x[i] *= fScale * 0.5f; // as the offsets x[] and y[] are from center
y[i] *= fScale * fPixelRatio * 0.5f;
// center it
x[i] += 0.5f * fScreenWidth + fOffsetX;
y[i] += 0.5f * fScreenHeight + fOffsetY;
}
// shift if we're zooming
if (m_fZoomAmount > 1)
{
float minx = x[0];
float maxx = x[0];
float miny = y[0];
float maxy = y[0];
for (int i = 1; i < 4; i++)
{
if (x[i] < minx) minx = x[i];
if (x[i] > maxx) maxx = x[i];
if (y[i] < miny) miny = y[i];
if (y[i] > maxy) maxy = y[i];
}
float w = maxx - minx;
float h = maxy - miny;
m_bCanMoveHorizontally = (w >= fScreenWidth);
m_bCanMoveVertically = (h >= fScreenHeight);
if (w >= fScreenWidth)
{ // must have no black bars
if (minx + m_fZoomLeft*w > fOffsetX)
m_fZoomLeft = (fOffsetX - minx) / w;
if (maxx + m_fZoomLeft*w < fOffsetX + fScreenWidth)
m_fZoomLeft = (fScreenWidth + fOffsetX - maxx) / w;
for (int i = 0; i < 4; i++)
x[i] += w * m_fZoomLeft;
}
if (h >= fScreenHeight)
{ // must have no black bars
if (miny + m_fZoomTop*h > fOffsetY)
m_fZoomTop = (fOffsetY - miny) / h;
if (maxy + m_fZoomTop*h < fOffsetY + fScreenHeight)
m_fZoomTop = (fScreenHeight + fOffsetY - maxy) / h;
for (int i = 0; i < 4; i++)
y[i] += m_fZoomTop * h;
}
}
// add offset from display effects
for (int i = 0; i < 4; i++)
{
x[i] += m_fPosX * m_fWidth * fScale;
y[i] += m_fPosY * m_fHeight * fScale;
}
UpdateVertices(m_ax, m_ay, x, y, dirtyregions);
// now render the image in the top right corner if we're zooming
if (m_fZoomAmount == 1 || m_bIsComic)
{
const float empty[4] = {0};
UpdateVertices(m_bx, m_by, empty, empty, dirtyregions);
UpdateVertices(m_sx, m_sy, empty, empty, dirtyregions);
UpdateVertices(m_ox, m_oy, empty, empty, dirtyregions);
m_bIsDirty = false;
return;
}
float sx[4], sy[4];
sx[0] = -m_fWidth * co + m_fHeight * si;
sy[0] = -m_fWidth * si - m_fHeight * co;
sx[1] = m_fWidth * co + m_fHeight * si;
sy[1] = m_fWidth * si - m_fHeight * co;
sx[2] = m_fWidth * co - m_fHeight * si;
sy[2] = m_fWidth * si + m_fHeight * co;
sx[3] = -m_fWidth * co - m_fHeight * si;
sy[3] = -m_fWidth * si + m_fHeight * co;
// convert to the appropriate scale
float fSmallArea = fScreenWidth * fScreenHeight / 50;
float fSmallWidth = sqrt(fSmallArea * fAR / fPixelRatio); // fAR*height = width, so total area*far = width*width
float fSmallHeight = fSmallArea / fSmallWidth;
float fSmallX = fOffsetX + fScreenWidth * 0.95f - fSmallWidth * 0.5f;
float fSmallY = fOffsetY + fScreenHeight * 0.05f + fSmallHeight * 0.5f;
fScaleNorm = fSmallWidth / m_fWidth;
fScaleInv = fSmallWidth / m_fHeight;
fScale = si * si * (fScaleInv - fScaleNorm) + fScaleNorm;
for (int i = 0; i < 4; i++)
{
sx[i] *= fScale * 0.5f;
sy[i] *= fScale * fPixelRatio * 0.5f;
}
// calculate a black border
float bx[4];
float by[4];
for (int i = 0; i < 4; i++)
{
if (sx[i] > 0)
bx[i] = sx[i] + 1;
else
bx[i] = sx[i] - 1;
if (sy[i] > 0)
by[i] = sy[i] + 1;
else
by[i] = sy[i] - 1;
sx[i] += fSmallX;
sy[i] += fSmallY;
bx[i] += fSmallX;
by[i] += fSmallY;
}
fSmallX -= fSmallWidth * 0.5f;
fSmallY -= fSmallHeight * 0.5f;
UpdateVertices(m_bx, m_by, bx, by, dirtyregions);
UpdateVertices(m_sx, m_sy, sx, sy, dirtyregions);
// now we must render the wireframe image of the view window
// work out the direction of the top of pic vector
float scale;
if (fabs(x[1] - x[0]) > fabs(x[3] - x[0]))
scale = (sx[1] - sx[0]) / (x[1] - x[0]);
else
scale = (sx[3] - sx[0]) / (x[3] - x[0]);
float ox[4];
float oy[4];
ox[0] = (fOffsetX - x[0]) * scale + sx[0];
oy[0] = (fOffsetY - y[0]) * scale + sy[0];
ox[1] = (fOffsetX + fScreenWidth - x[0]) * scale + sx[0];
oy[1] = (fOffsetY - y[0]) * scale + sy[0];
ox[2] = (fOffsetX + fScreenWidth - x[0]) * scale + sx[0];
oy[2] = (fOffsetY + fScreenHeight - y[0]) * scale + sy[0];
ox[3] = (fOffsetX - x[0]) * scale + sx[0];
oy[3] = (fOffsetY + fScreenHeight - y[0]) * scale + sy[0];
// crop to within the range of our piccy
for (int i = 0; i < 4; i++)
{
if (ox[i] < fSmallX) ox[i] = fSmallX;
if (ox[i] > fSmallX + fSmallWidth) ox[i] = fSmallX + fSmallWidth;
if (oy[i] < fSmallY) oy[i] = fSmallY;
if (oy[i] > fSmallY + fSmallHeight) oy[i] = fSmallY + fSmallHeight;
}
UpdateVertices(m_ox, m_oy, ox, oy, dirtyregions);
m_bIsDirty = false;
}
const Vector<Vertex2D>& Drawable2D::GetVertices()
{
if (verticesDirty_)
UpdateVertices();
return vertices_;
}
void Rectangle::SetPosition(glm::vec2 position_) {
position = position_;
UpdateVertices();
}
HRESULT KModelBelt::Render()
{
SetMatrix();
D3DXMATRIX MatCur = m_Matrix;
g_pd3dDevice->GetTransform( D3DTS_WORLD , &MatCur);
D3DXVECTOR3 A,B;
D3DXVec3TransformCoord(&A,&m_BaseLine.A,&MatCur);
D3DXVec3TransformCoord(&B,&m_BaseLine.B,&MatCur);
m_CurLine.A = A;
m_CurLine.B = B;
if( m_bGotOne ) //初始化飘带
{
InitialBelt(m_CurLine);
m_bGotOne = FALSE;
}
/*
if(!m_bShow) //非运动时飘带的状态
{
SRCLINE LineA = m_SrcLineList.front();
UpdateAtRest(m_CurLine);
UpdateExtend();
LineA = m_SrcLineList.front();
int j = 0;
}
else //运动时飘带的状态
{
AddLine(m_CurLine);
}
*/
// AddLine(m_CurLine);
// UpdateAtRest(m_CurLine);
AddLine(m_CurLine);
if(m_bExtend)
{
UpdateExtend();
}
D3DXMATRIX MatId;
D3DXMatrixIdentity(&MatId);
g_pd3dDevice->SetTransform( D3DTS_WORLD , &MatId);
UpdateVertices();
KModel::SetMaterial(0);
g_pd3dDevice->SetStreamSource( 0, m_lpVBuf,0, sizeof( VFormat::FACES_DIFFUSE_TEXTURE1 ) );
g_pd3dDevice->SetFVF( D3DFVF_Faces_Diffuse_Texture1 );
// g_pd3dDevice->SetRenderState(D3DRS_FILLMODE,D3DFILL_WIREFRAME);
g_pd3dDevice->DrawPrimitive ( D3DPT_TRIANGLESTRIP , 0 , m_nNumFaces);
// SRCLINE LineK = m_vecSrcLine[0];
RestoreMatrix();
return S_OK;
}
void Rectangle::SetHeight(float height_) {
height = height_;
UpdateVertices();
}
// Startup D3D resources
void EditExt::D3DInit()
{
// Get the D3D device used by the runtime
pDevice = (IDirect3DDevice9*)pEditTime->GetDisplayDevice();
if (pDevice == NULL) {
MessageBox(NULL, "No DirectX device available", "3D Cube Error", MB_OK | MB_ICONHAND);
return;
}
// Set up the cube vertices
hr = pDevice->CreateVertexBuffer(sizeof(TLVERTEX) * 36, D3DUSAGE_WRITEONLY, D3DFVF_TLVERTEX, D3DPOOL_MANAGED,
&pVertices, NULL);
if (FAILED(hr)) {
MessageBox(NULL, "Failed to create vertex buffer", "3D Cube Error", MB_OK | MB_ICONHAND);
return;
}
UpdateVertices();
//Here we build our View Matrix, think of it as our camera.
//First we specify that our viewpoint is 8 units back on the Z-axis
eye_vector = D3DXVECTOR3( 0.0f, 0.0f, 8.0f );
//We are looking towards the origin
lookat_vector = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
//The "up" direction is the positive direction on the y-axis
up_vector = D3DXVECTOR3(0.0f,1.0f,0.0f);
D3DXMatrixLookAtLH(&view_matrix,&eye_vector,
&lookat_vector,
&up_vector);
SIZE s;
s.cx = GetSystemMetrics(SM_CXSCREEN);
s.cy = GetSystemMetrics(SM_CYSCREEN);
aspect=((float)s.cx / (float)s.cy);
D3DXMatrixPerspectiveFovLH(&projection_matrix, //Result Matrix
D3DX_PI/4, //Field of View, in radians.
aspect, //Aspect ratio
1.0f, //Near view plane
100.0f ); //Far view plane
D3DXMatrixIdentity(&worldMatrix);
D3DXMatrixIdentity(&rotMatrix);
D3DXMatrixIdentity(&transMatrix);
D3DXMatrixIdentity(&scaleMatrix);
// The vectors used in screen projection
orig.x = 0;
orig.y = 0;
orig.z = 0;
normal.x = 0;
normal.y = 0;
normal.z = 1; // Normal facing the view
CreateZBuffer();
}
void EditExt::EditFace(int face)
{
pEditTime->EditImage(imageHandles[face]);
textures[face] = pEditTime->AddImageAsTexture(imageHandles[face]);
UpdateVertices();
}
HRESULT KModelSFXLineGrass::LoadMesh(LPSTR pFileName)
{
//////////////////////////////////////////////////////////////////////////
LPMOTION pMotion = new MOTION;
m_lpMotion.push_back(pMotion);
pMotion = new _MotionCircle;
m_lpMotion.push_back(pMotion);
DWORD m_dwNumObject = 400;
DWORD Row =0,K =0;
DWORD RowLength = (DWORD) sqrt((float)(m_dwNumObject));
for(DWORD i=0;i<m_dwNumObject;i++)
{
K++;
float X = (rand()%1000)*0.001f*500 - 250;
float Y = (rand()%1000)*0.001f*500 - 250;
if (K>RowLength)
{
Row++;
K=0;
}
X = Row * 100.0f - RowLength*50 + (rand()%1000)*0.001f*50;
Y = K * 100.0f - RowLength*50 + (rand()%1000)*0.001f*50;
float Size = (rand()%1000)*0.001f*5+15;
D3DXVECTOR3 Position = D3DXVECTOR3(X,0,Y);
LPSPRITE pSpr = new SPRITE;
pSpr->Width = Size ;
pSpr->Height = Size;
pSpr->MotionType = 0;
pSpr->Position = Position;
pSpr->Arg[0] = Position.x;
pSpr->Arg[1] = Position.y;
pSpr->Arg[2] = Position.z;
m_lpSprite.push_back(pSpr);
m_nNumFaces = m_nNumLinePerGrass*m_lpSprite.size();
}
CreateVerticesBuffer();
wsprintf(m_szMeshFileName,"Line Grass");
UpdateVertices();
m_dNumMaterial = 1;
m_lpMaterial = new MATERIAL[m_dNumMaterial];
ZeroMemory(m_lpMaterial,sizeof(MATERIAL)*m_dNumMaterial);
DWORD Def_Option = MATERIAL_OPTION_ZBUFFER_TRUE|
MATERIAL_OPTION_FILL_SOLID|
MATERIAL_OPTION_SHADE_GOURAUD|
MATERIAL_OPTION_CULL_CW|
MATERIAL_OPTION_SPECULARENABLE;
for( i=0;i<m_dNumMaterial;i++)
{
m_lpMaterial[i].m_sMaterial9.Diffuse.r = 0.7f ;
m_lpMaterial[i].m_sMaterial9.Diffuse.g = 0.7f ;
m_lpMaterial[i].m_sMaterial9.Diffuse.b = 0.7f ;
m_lpMaterial[i].m_sMaterial9.Diffuse.a = 1.0f ;
m_lpMaterial[i].m_sMaterial9.Ambient = m_lpMaterial[i].m_sMaterial9.Diffuse;
m_lpMaterial[i].m_sMaterial9.Specular = m_lpMaterial[i].m_sMaterial9.Diffuse;
m_lpMaterial[i].m_sMaterial9.Power = 15;
m_lpMaterial[i].m_dOption = Def_Option;
}
TCHAR Name[256];
wsprintf(Name,"%s\\BillBoard.Mtl",g_Def_ModelDirectory);
LoadMaterial(Name);
return S_OK;
}
void Rectangle::SetWidth(float width_) {
width = width_;
UpdateVertices();
}
