//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ServerImplemented::AcceptAsync( void* data )
{
ServerImplemented* server = (ServerImplemented*)data;
while(true)
{
SOCKADDR_IN socketAddrIn;
int32_t Size = sizeof(SOCKADDR_IN);
EfkSocket socket_ = ::accept(
server->m_socket,
(SOCKADDR*)(&socketAddrIn),
(SOCKLEN*)(&Size) );
if ( server->m_socket == InvalidSocket || socket_ == InvalidSocket )
{
break;
}
/* 接続追加 */
server->AddClient( new InternalClient( socket_, server ) );
EffekseerPrintDebug("Server : AcceptClient\n");
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeImplemented::LoadRendererParameter(unsigned char*& pos, Setting* setting)
{
int32_t type = 0;
memcpy( &type, pos, sizeof(int) );
pos += sizeof(int);
assert( type == GetType() );
EffekseerPrintDebug("Renderer : None\n");
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void ClientImplemented::Stop()
{
if( !m_running ) return;
Socket::Shutsown( m_socket );
Socket::Close( m_socket );
m_running = false;
EffekseerPrintDebug("Client : Stop\n");
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
bool ServerImplemented::Start( uint16_t port )
{
if( m_running )
{
Stop();
}
int32_t returnCode;
sockaddr_in sockAddr = { AF_INET };
/* ソケット生成 */
EfkSocket socket_ = Socket::GenSocket();
if ( socket_ == InvalidSocket )
{
return false;
}
/* 接続用データ生成 */
memset( &sockAddr, 0, sizeof(SOCKADDR_IN));
sockAddr.sin_family = AF_INET;
sockAddr.sin_port = htons( port );
/* 関連付け */
returnCode = ::bind( socket_, (sockaddr*)&sockAddr, sizeof(sockaddr_in) );
if ( returnCode == SocketError )
{
if ( socket_ != InvalidSocket )
{
Socket::Close( socket_ );
}
return false;
}
/* 接続 */
if ( !Socket::Listen( socket_, 30 ) )
{
if ( socket_ != InvalidSocket )
{
Socket::Close( socket_ );
}
return false;
}
m_running = true;
m_socket = socket_;
m_port = port;
m_thread.Create( AcceptAsync, this );
EffekseerPrintDebug("Server : Start\n");
return true;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeModel::LoadRendererParameter(unsigned char*& pos, Setting* setting)
{
int32_t type = 0;
memcpy( &type, pos, sizeof(int) );
pos += sizeof(int);
assert( type == GetType() );
EffekseerPrintDebug("Renderer : Model\n");
int32_t size = 0;
AlphaBlend = Texture.AlphaBlend;
if( m_effect->GetVersion() >= 7 )
{
float Magnification;
memcpy( &Magnification, pos, sizeof(float) );
pos += sizeof(float);
}
memcpy( &ModelIndex, pos, sizeof(int) );
pos += sizeof(int);
memcpy( &NormalTextureIndex, pos, sizeof(int) );
pos += sizeof(int);
EffekseerPrintDebug("NormalTextureIndex : %d\n", NormalTextureIndex );
int32_t lighting;
memcpy( &lighting, pos, sizeof(int) );
pos += sizeof(int);
Lighting = lighting > 0;
memcpy( &Culling, pos, sizeof(int) );
pos += sizeof(int);
AllColor.load( pos, m_effect->GetVersion() );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
EffectNodeImplemented* EffectNodeImplemented::Create(Effect* effect, EffectNode* parent, unsigned char*& pos)
{
EffectNodeImplemented* effectnode = NULL;
int node_type = 0;
memcpy( &node_type, pos, sizeof(int) );
if( node_type == EFFECT_NODE_TYPE_ROOT )
{
EffekseerPrintDebug("* Create : EffectNodeRoot\n");
effectnode = new EffectNodeRoot( effect, pos );
}
else if( node_type == EFFECT_NODE_TYPE_NONE )
{
EffekseerPrintDebug("* Create : EffectNodeNone\n");
effectnode = new EffectNodeImplemented(effect, pos);
}
else if( node_type == EFFECT_NODE_TYPE_SPRITE )
{
EffekseerPrintDebug("* Create : EffectNodeSprite\n");
effectnode = new EffectNodeSprite( effect, pos );
}
else if( node_type == EFFECT_NODE_TYPE_RIBBON )
{
EffekseerPrintDebug("* Create : EffectNodeRibbon\n");
effectnode = new EffectNodeRibbon( effect, pos );
}
else if( node_type == EFFECT_NODE_TYPE_RING )
{
EffekseerPrintDebug("* Create : EffectNodeRing\n");
effectnode = new EffectNodeRing( effect, pos );
}
else if( node_type == EFFECT_NODE_TYPE_MODEL )
{
EffekseerPrintDebug("* Create : EffectNodeModel\n");
effectnode = new EffectNodeModel( effect, pos );
}
else if( node_type == EFFECT_NODE_TYPE_TRACK )
{
EffekseerPrintDebug("* Create : EffectNodeTrack\n");
effectnode = new EffectNodeTrack( effect, pos );
}
else
{
assert(0);
}
effectnode->LoadParameter( pos, parent, effect->GetSetting());
return effectnode;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
bool ClientImplemented::Start( char* host, uint16_t port )
{
if( m_running ) return false;
SOCKADDR_IN sockAddr;
HOSTENT* hostEntry= NULL;
/* ソケット生成 */
EfkSocket socket_ = Socket::GenSocket();
if ( socket_ == InvalidSocket )
{
if ( socket_ != InvalidSocket ) Socket::Close( socket_ );
return false;
}
/* ホスト情報取得 */
hostEntry = GetHostEntry( host );
if ( hostEntry == NULL )
{
if ( socket_ != InvalidSocket ) Socket::Close( socket_ );
return false;
}
/* 接続用データ生成 */
memset( &sockAddr, 0, sizeof(SOCKADDR_IN) );
sockAddr.sin_family = AF_INET;
sockAddr.sin_port = htons( port );
sockAddr.sin_addr = *(IN_ADDR*)(hostEntry->h_addr_list[0]);
/* 接続 */
int32_t ret = ::connect( socket_, (SOCKADDR*)(&sockAddr), sizeof(SOCKADDR_IN) );
if ( ret == SocketError )
{
if ( socket_ != InvalidSocket ) Socket::Close( socket_ );
return false;
}
m_socket = socket_;
m_port = port;
m_running = true;
m_threadRecv.Create( RecvAsync, this );
EffekseerPrintDebug("Client : Start\n");
return true;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeTrack::LoadRendererParameter(unsigned char*& pos, Setting* setting)
{
int32_t type = 0;
memcpy( &type, pos, sizeof(int) );
pos += sizeof(int);
assert( type == GetType() );
EffekseerPrintDebug("Renderer : Track\n");
int32_t size = 0;
LoadValues( TrackSizeFor, pos );
LoadValues( TrackSizeMiddle, pos );
LoadValues( TrackSizeBack, pos );
TrackColorLeft.load( pos, m_effect->GetVersion() );
TrackColorLeftMiddle.load( pos, m_effect->GetVersion() );
TrackColorCenter.load( pos, m_effect->GetVersion() );
TrackColorCenterMiddle.load( pos, m_effect->GetVersion() );
TrackColorRight.load( pos, m_effect->GetVersion() );
TrackColorRightMiddle.load( pos, m_effect->GetVersion() );
AlphaBlend = Texture.AlphaBlend;
TrackTexture = Texture.ColorTextureIndex;
EffekseerPrintDebug("TrackColorLeft : %d\n", TrackColorLeft.type );
EffekseerPrintDebug("TrackColorLeftMiddle : %d\n", TrackColorLeftMiddle.type );
EffekseerPrintDebug("TrackColorCenter : %d\n", TrackColorCenter.type );
EffekseerPrintDebug("TrackColorCenterMiddle : %d\n", TrackColorCenterMiddle.type );
EffekseerPrintDebug("TrackColorRight : %d\n", TrackColorRight.type );
EffekseerPrintDebug("TrackColorRightMiddle : %d\n", TrackColorRightMiddle.type );
// 右手系左手系変換
if (setting->GetCoordinateSystem() == CoordinateSystem::LH)
{
}
/* 位置拡大処理 */
if( m_effect->GetVersion() >= 8 )
{
TrackSizeFor.fixed.size *= m_effect->GetMaginification();
TrackSizeMiddle.fixed.size *= m_effect->GetMaginification();
TrackSizeBack.fixed.size *= m_effect->GetMaginification();
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
ManagerImplemented::ManagerImplemented( int instance_max, bool autoFlip )
: m_reference ( 1 )
, m_autoFlip ( autoFlip )
, m_NextHandle ( 0 )
, m_instance_max ( instance_max )
, m_setting ( NULL )
, m_sequenceNumber ( 0 )
, m_cullingWorld (NULL)
, m_culled(false)
, m_MallocFunc(NULL)
, m_FreeFunc(NULL)
, m_randFunc(NULL)
, m_randMax(0)
, m_spriteRenderer(NULL)
, m_ribbonRenderer(NULL)
, m_ringRenderer(NULL)
, m_modelRenderer(NULL)
, m_trackRenderer(NULL)
, m_soundPlayer(NULL)
{
m_setting = Setting::Create();
SetMallocFunc( Malloc );
SetFreeFunc( Free );
SetRandFunc( Rand );
SetRandMax( RAND_MAX );
m_renderingDrawSets.reserve( 64 );
m_reserved_instances_buffer = new uint8_t[ sizeof(Instance) * m_instance_max ];
for( int i = 0; i < m_instance_max; i++ )
{
Instance* instances = (Instance*)m_reserved_instances_buffer;
m_reserved_instances.push( &instances[i] );
}
m_setting->SetEffectLoader(new DefaultEffectLoader());
EffekseerPrintDebug("*** Create : Manager\n");
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeSprite::LoadRendererParameter(unsigned char*& pos, Setting* setting)
{
int32_t type = 0;
memcpy(&type, pos, sizeof(int));
pos += sizeof(int);
assert(type == GetType());
EffekseerPrintDebug("Renderer : Sprite\n");
int32_t size = 0;
memcpy(&RenderingOrder, pos, sizeof(int));
pos += sizeof(int);
if (m_effect->GetVersion() >= 3)
{
AlphaBlend = Texture.AlphaBlend;
}
else
{
memcpy(&AlphaBlend, pos, sizeof(int));
pos += sizeof(int);
}
memcpy(&Billboard, pos, sizeof(int));
pos += sizeof(int);
SpriteAllColor.load(pos, m_effect->GetVersion());
EffekseerPrintDebug("SpriteColorAllType : %d\n", SpriteAllColor.type);
memcpy(&SpriteColor.type, pos, sizeof(int));
pos += sizeof(int);
EffekseerPrintDebug("SpriteColorType : %d\n", SpriteColor.type);
if (SpriteColor.type == SpriteColor.Default)
{
}
else if (SpriteColor.type == SpriteColor.Fixed)
{
memcpy(&SpriteColor.fixed, pos, sizeof(SpriteColor.fixed));
pos += sizeof(SpriteColor.fixed);
}
memcpy(&SpritePosition.type, pos, sizeof(int));
pos += sizeof(int);
EffekseerPrintDebug("SpritePosition : %d\n", SpritePosition.type);
if (SpritePosition.type == SpritePosition.Default)
{
if (m_effect->GetVersion() >= 8)
{
memcpy(&SpritePosition.fixed, pos, sizeof(SpritePosition.fixed));
pos += sizeof(SpritePosition.fixed);
SpritePosition.type = SpritePosition.Fixed;
}
}
else if (SpritePosition.type == SpritePosition.Fixed)
{
memcpy(&SpritePosition.fixed, pos, sizeof(SpritePosition.fixed));
pos += sizeof(SpritePosition.fixed);
}
if (m_effect->GetVersion() >= 3)
{
SpriteTexture = Texture.ColorTextureIndex;
}
else
{
memcpy(&SpriteTexture, pos, sizeof(int));
pos += sizeof(int);
}
// 右手系左手系変換
if (setting->GetCoordinateSystem() == COORDINATE_SYSTEM_LH)
{
}
/* 位置拡大処理 */
if (m_effect->GetVersion() >= 8)
{
if (SpritePosition.type == SpritePosition.Default)
{
}
else if (SpritePosition.type == SpritePosition.Fixed)
{
SpritePosition.fixed.ll *= m_effect->GetMaginification();
SpritePosition.fixed.lr *= m_effect->GetMaginification();
SpritePosition.fixed.ul *= m_effect->GetMaginification();
SpritePosition.fixed.ur *= m_effect->GetMaginification();
}
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectImplemented::Load( void* pData, int size, float mag, const EFK_CHAR* materialPath )
{
EffekseerPrintDebug("** Create : Effect\n");
uint8_t* pos = (uint8_t*)pData;
// EFKS
int head = 0;
memcpy( &head, pos, sizeof(int) );
if( memcmp( &head, "SKFE", 4 ) != 0 ) return;
pos += sizeof( int );
memcpy( &m_version, pos, sizeof(int) );
pos += sizeof(int);
// 画像
memcpy( &m_ImageCount, pos, sizeof(int) );
pos += sizeof(int);
if( m_ImageCount > 0 )
{
m_ImagePaths = new EFK_CHAR*[ m_ImageCount ];
m_pImages = new void*[ m_ImageCount ];
for( int i = 0; i < m_ImageCount; i++ )
{
int length = 0;
memcpy( &length, pos, sizeof(int) );
pos += sizeof(int);
m_ImagePaths[i] = new EFK_CHAR[ length ];
memcpy( m_ImagePaths[i], pos, length * sizeof(EFK_CHAR) );
pos += length * sizeof(EFK_CHAR);
m_pImages[i] = NULL;
}
}
if (m_version >= 9)
{
// 画像
memcpy(&m_normalImageCount, pos, sizeof(int));
pos += sizeof(int);
if (m_normalImageCount > 0)
{
m_normalImagePaths = new EFK_CHAR*[m_normalImageCount];
m_normalImages = new void*[m_normalImageCount];
for (int i = 0; i < m_normalImageCount; i++)
{
int length = 0;
memcpy(&length, pos, sizeof(int));
pos += sizeof(int);
m_normalImagePaths[i] = new EFK_CHAR[length];
memcpy(m_normalImagePaths[i], pos, length * sizeof(EFK_CHAR));
pos += length * sizeof(EFK_CHAR);
m_normalImages[i] = NULL;
}
}
// 画像
memcpy(&m_distortionImageCount, pos, sizeof(int));
pos += sizeof(int);
if (m_distortionImageCount > 0)
{
m_distortionImagePaths = new EFK_CHAR*[m_distortionImageCount];
m_distortionImages = new void*[m_distortionImageCount];
for (int i = 0; i < m_distortionImageCount; i++)
{
int length = 0;
memcpy(&length, pos, sizeof(int));
pos += sizeof(int);
m_distortionImagePaths[i] = new EFK_CHAR[length];
memcpy(m_distortionImagePaths[i], pos, length * sizeof(EFK_CHAR));
pos += length * sizeof(EFK_CHAR);
m_distortionImages[i] = NULL;
}
}
}
if( m_version >= 1 )
{
// ウェーブ
memcpy( &m_WaveCount, pos, sizeof(int) );
pos += sizeof(int);
if( m_WaveCount > 0 )
{
m_WavePaths = new EFK_CHAR*[ m_WaveCount ];
m_pWaves = new void*[ m_WaveCount ];
for( int i = 0; i < m_WaveCount; i++ )
{
int length = 0;
memcpy( &length, pos, sizeof(int) );
pos += sizeof(int);
m_WavePaths[i] = new EFK_CHAR[ length ];
memcpy( m_WavePaths[i], pos, length * sizeof(EFK_CHAR) );
pos += length * sizeof(EFK_CHAR);
m_pWaves[i] = NULL;
}
}
}
if( m_version >= 6 )
{
/* モデル */
memcpy( &m_modelCount, pos, sizeof(int) );
pos += sizeof(int);
if( m_modelCount > 0 )
{
m_modelPaths = new EFK_CHAR*[ m_modelCount ];
m_pModels = new void*[ m_modelCount ];
for( int i = 0; i < m_modelCount; i++ )
{
int length = 0;
memcpy( &length, pos, sizeof(int) );
pos += sizeof(int);
m_modelPaths[i] = new EFK_CHAR[ length ];
memcpy( m_modelPaths[i], pos, length * sizeof(EFK_CHAR) );
pos += length * sizeof(EFK_CHAR);
m_pModels[i] = NULL;
}
}
}
// 拡大率
if( m_version >= 2 )
{
memcpy( &m_maginification, pos, sizeof(float) );
pos += sizeof(float);
m_maginification *= mag;
m_maginificationExternal = mag;
}
// カリング
if( m_version >= 9 )
{
memcpy( &(Culling.Shape), pos, sizeof(int32_t) );
pos += sizeof(int32_t);
if(Culling.Shape == CullingShape::Sphere)
{
memcpy( &(Culling.Sphere.Radius), pos, sizeof(float) );
pos += sizeof(float);
memcpy( &(Culling.Location.X), pos, sizeof(float) );
pos += sizeof(float);
memcpy( &(Culling.Location.Y), pos, sizeof(float) );
pos += sizeof(float);
memcpy( &(Culling.Location.Z), pos, sizeof(float) );
pos += sizeof(float);
}
}
// ノード
m_pRoot = EffectNode::Create( this, NULL, pos );
// リロード用にmaterialPathを記録しておく
if (materialPath) m_materialPath = materialPath;
ReloadResources( materialPath );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeRing::LoadRendererParameter(unsigned char*& pos, Setting* setting)
{
int32_t type = 0;
memcpy( &type, pos, sizeof(int) );
pos += sizeof(int);
assert( type == GetType() );
EffekseerPrintDebug("Renderer : Ring\n");
int32_t size = 0;
memcpy( &RenderingOrder, pos, sizeof(int) );
pos += sizeof(int);
if( m_effect->GetVersion() >= 3)
{
AlphaBlend = RendererCommon.AlphaBlend;
}
else
{
memcpy( &AlphaBlend, pos, sizeof(int) );
pos += sizeof(int);
}
memcpy( &Billboard, pos, sizeof(int) );
pos += sizeof(int);
memcpy( &VertexCount, pos, sizeof(int) );
pos += sizeof(int);
LoadSingleParameter( pos, ViewingAngle );
LoadLocationParameter( pos, OuterLocation );
LoadLocationParameter( pos, InnerLocation );
LoadSingleParameter( pos, CenterRatio );
LoadColorParameter( pos, OuterColor);
LoadColorParameter( pos, CenterColor);
LoadColorParameter( pos, InnerColor);
if( m_effect->GetVersion() >= 3)
{
RingTexture = RendererCommon.ColorTextureIndex;
}
else
{
memcpy( &RingTexture, pos, sizeof(int) );
pos += sizeof(int);
}
// 右手系左手系変換
if (setting->GetCoordinateSystem() == CoordinateSystem::LH)
{
if( OuterLocation.type == RingLocationParameter::Fixed )
{
OuterLocation.fixed.location.y *= -1;
}
else if( OuterLocation.type == RingLocationParameter::PVA )
{
OuterLocation.pva.location.min.y *= -1;
OuterLocation.pva.location.max.y *= -1;
OuterLocation.pva.velocity.min.y *= -1;
OuterLocation.pva.velocity.max.y *= -1;
OuterLocation.pva.acceleration.min.y *= -1;
OuterLocation.pva.acceleration.max.y *= -1;
}
else if( OuterLocation.type == RingLocationParameter::Easing )
{
OuterLocation.easing.start.min.y *= -1;
OuterLocation.easing.start.max.y *= -1;
OuterLocation.easing.end.min.y *= -1;
OuterLocation.easing.end.max.y *= -1;
}
if( InnerLocation.type == RingLocationParameter::Fixed )
{
InnerLocation.fixed.location.y *= -1;
}
else if( InnerLocation.type == RingLocationParameter::PVA )
{
InnerLocation.pva.location.min.y *= -1;
InnerLocation.pva.location.max.y *= -1;
InnerLocation.pva.velocity.min.y *= -1;
InnerLocation.pva.velocity.max.y *= -1;
InnerLocation.pva.acceleration.min.y *= -1;
InnerLocation.pva.acceleration.max.y *= -1;
}
else if( InnerLocation.type == RingLocationParameter::Easing )
{
InnerLocation.easing.start.min.y *= -1;
InnerLocation.easing.start.max.y *= -1;
InnerLocation.easing.end.min.y *= -1;
InnerLocation.easing.end.max.y *= -1;
}
}
/* 位置拡大処理 */
if( m_effect->GetVersion() >= 8 )
{
if( OuterLocation.type == RingLocationParameter::Fixed )
{
OuterLocation.fixed.location *= m_effect->GetMaginification();
}
else if( OuterLocation.type == RingLocationParameter::PVA )
{
OuterLocation.pva.location.min *= m_effect->GetMaginification();
OuterLocation.pva.location.max *= m_effect->GetMaginification();
OuterLocation.pva.velocity.min *= m_effect->GetMaginification();
OuterLocation.pva.velocity.max *= m_effect->GetMaginification();
OuterLocation.pva.acceleration.min *= m_effect->GetMaginification();
OuterLocation.pva.acceleration.max *= m_effect->GetMaginification();
}
else if( OuterLocation.type == RingLocationParameter::Easing )
{
OuterLocation.easing.start.min *= m_effect->GetMaginification();
OuterLocation.easing.start.max *= m_effect->GetMaginification();
OuterLocation.easing.end.min *= m_effect->GetMaginification();
OuterLocation.easing.end.max *= m_effect->GetMaginification();
}
if( InnerLocation.type == RingLocationParameter::Fixed )
{
InnerLocation.fixed.location *= m_effect->GetMaginification();
}
else if( InnerLocation.type == RingLocationParameter::PVA )
{
InnerLocation.pva.location.min *= m_effect->GetMaginification();
InnerLocation.pva.location.max *= m_effect->GetMaginification();
InnerLocation.pva.velocity.min *= m_effect->GetMaginification();
InnerLocation.pva.velocity.max *= m_effect->GetMaginification();
InnerLocation.pva.acceleration.min *= m_effect->GetMaginification();
InnerLocation.pva.acceleration.max *= m_effect->GetMaginification();
}
else if( InnerLocation.type == RingLocationParameter::Easing )
{
InnerLocation.easing.start.min *= m_effect->GetMaginification();
InnerLocation.easing.start.max *= m_effect->GetMaginification();
InnerLocation.easing.end.min *= m_effect->GetMaginification();
InnerLocation.easing.end.max *= m_effect->GetMaginification();
}
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeRibbon::LoadRendererParameter(unsigned char*& pos, Setting* setting)
{
int32_t type = 0;
memcpy( &type, pos, sizeof(int) );
pos += sizeof(int);
assert( type == GetType() );
EffekseerPrintDebug("Renderer : Ribbon\n");
int32_t size = 0;
if( m_effect->GetVersion() >= 3)
{
AlphaBlend = Texture.AlphaBlend;
}
else
{
memcpy( &AlphaBlend, pos, sizeof(int) );
pos += sizeof(int);
}
memcpy( &ViewpointDependent, pos, sizeof(int) );
pos += sizeof(int);
memcpy( &RibbonAllColor.type, pos, sizeof(int) );
pos += sizeof(int);
EffekseerPrintDebug("RibbonColorAllType : %d\n", RibbonAllColor.type );
if( RibbonAllColor.type == RibbonAllColorParameter::Fixed )
{
memcpy( &RibbonAllColor.fixed, pos, sizeof(RibbonAllColor.fixed) );
pos += sizeof(RibbonAllColor.fixed);
}
else if( RibbonAllColor.type == RibbonAllColorParameter::Random )
{
RibbonAllColor.random.all.load( m_effect->GetVersion(), pos );
}
else if( RibbonAllColor.type == RibbonAllColorParameter::Easing )
{
RibbonAllColor.easing.all.load( m_effect->GetVersion(), pos );
}
memcpy( &RibbonColor.type, pos, sizeof(int) );
pos += sizeof(int);
EffekseerPrintDebug("RibbonColorType : %d\n", RibbonColor.type );
if( RibbonColor.type == RibbonColor.Default )
{
}
else if( RibbonColor.type == RibbonColor.Fixed )
{
memcpy( &RibbonColor.fixed, pos, sizeof(RibbonColor.fixed) );
pos += sizeof(RibbonColor.fixed);
}
memcpy( &RibbonPosition.type, pos, sizeof(int) );
pos += sizeof(int);
EffekseerPrintDebug("RibbonPosition : %d\n", RibbonPosition.type );
if( RibbonPosition.type == RibbonPosition.Default )
{
if( m_effect->GetVersion() >= 8 )
{
memcpy( &RibbonPosition.fixed, pos, sizeof(RibbonPosition.fixed) );
pos += sizeof(RibbonPosition.fixed);
RibbonPosition.type = RibbonPosition.Fixed;
}
}
else if( RibbonPosition.type == RibbonPosition.Fixed )
{
memcpy( &RibbonPosition.fixed, pos, sizeof(RibbonPosition.fixed) );
pos += sizeof(RibbonPosition.fixed);
}
if( m_effect->GetVersion() >= 3)
{
RibbonTexture = Texture.ColorTextureIndex;
}
else
{
memcpy( &RibbonTexture, pos, sizeof(int) );
pos += sizeof(int);
}
// 右手系左手系変換
if( setting->GetCoordinateSystem() == COORDINATE_SYSTEM_LH )
{
}
/* 位置拡大処理 */
if( m_effect->GetVersion() >= 8 )
{
if( RibbonPosition.type == RibbonPosition.Default )
{
}
else if( RibbonPosition.type == RibbonPosition.Fixed )
{
RibbonPosition.fixed.l *= m_effect->GetMaginification();
RibbonPosition.fixed.r *= m_effect->GetMaginification();
}
}
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeImplemented::LoadParameter(unsigned char*& pos, EffectNode* parent, Setting* setting)
{
int size = 0;
int node_type = 0;
memcpy( &node_type, pos, sizeof(int) );
pos += sizeof(int);
if( node_type == -1 )
{
TranslationType = ParameterTranslationType_None;
LocationAbs.type = LocationAbsParameter::None;
RotationType = ParameterRotationType_None;
ScalingType = ParameterScalingType_None;
CommonValues.MaxGeneration = 1;
GenerationLocation.EffectsRotation = 0;
GenerationLocation.type = ParameterGenerationLocation::TYPE_POINT;
GenerationLocation.point.location.reset();
}
else
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
if (m_effect->GetVersion() >= 9)
{
assert(size == sizeof(ParameterCommonValues));
memcpy(&CommonValues, pos, size);
pos += size;
}
else
{
assert(size == sizeof(ParameterCommonValues_8));
ParameterCommonValues_8 param_8;
memcpy(¶m_8, pos, size);
pos += size;
CommonValues.MaxGeneration = param_8.MaxGeneration;
CommonValues.TranslationBindType = param_8.TranslationBindType;
CommonValues.RotationBindType = param_8.RotationBindType;
CommonValues.ScalingBindType = param_8.ScalingBindType;
CommonValues.RemoveWhenLifeIsExtinct = param_8.RemoveWhenLifeIsExtinct;
CommonValues.RemoveWhenParentIsRemoved = param_8.RemoveWhenParentIsRemoved;
CommonValues.RemoveWhenChildrenIsExtinct = param_8.RemoveWhenChildrenIsExtinct;
CommonValues.life = param_8.life;
CommonValues.GenerationTime.max = param_8.GenerationTime;
CommonValues.GenerationTime.min = param_8.GenerationTime;
CommonValues.GenerationTimeOffset.max = param_8.GenerationTimeOffset;
CommonValues.GenerationTimeOffset.min = param_8.GenerationTimeOffset;
}
memcpy( &TranslationType, pos, sizeof(int) );
pos += sizeof(int);
if( TranslationType == ParameterTranslationType_Fixed )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterTranslationFixed) );
memcpy( &TranslationFixed, pos, size );
pos += size;
// 無効化
if( TranslationFixed.Position.X == 0.0f &&
TranslationFixed.Position.Y == 0.0f &&
TranslationFixed.Position.Z == 0.0f )
{
TranslationType = ParameterTranslationType_None;
EffekseerPrintDebug("LocationType Change None\n");
}
}
else if( TranslationType == ParameterTranslationType_PVA )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterTranslationPVA) );
memcpy( &TranslationPVA, pos, size );
pos += size;
}
else if( TranslationType == ParameterTranslationType_Easing )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(easing_vector3d) );
memcpy( &TranslationEasing, pos, size );
pos += size;
}
else if( TranslationType == ParameterTranslationType_FCurve )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
TranslationFCurve = new FCurveVector3D();
pos += TranslationFCurve->Load( pos, m_effect->GetVersion() );
}
/* 位置拡大処理 */
if( m_effect->GetVersion() >= 8 )
{
if( TranslationType == ParameterTranslationType_Fixed )
{
TranslationFixed.Position *= m_effect->GetMaginification();
}
else if( TranslationType == ParameterTranslationType_PVA )
{
TranslationPVA.location.min *= m_effect->GetMaginification();
TranslationPVA.location.max *= m_effect->GetMaginification();
TranslationPVA.velocity.min *= m_effect->GetMaginification();
TranslationPVA.velocity.max *= m_effect->GetMaginification();
TranslationPVA.acceleration.min *= m_effect->GetMaginification();
TranslationPVA.acceleration.max *= m_effect->GetMaginification();
}
else if( TranslationType == ParameterTranslationType_Easing )
{
TranslationEasing.start.min *= m_effect->GetMaginification();
TranslationEasing.start.max *= m_effect->GetMaginification();
TranslationEasing.end.min *= m_effect->GetMaginification();
TranslationEasing.end.max *= m_effect->GetMaginification();
}
else if( TranslationType == ParameterTranslationType_FCurve )
{
TranslationFCurve->X.Maginify( m_effect->GetMaginification() );
TranslationFCurve->Y.Maginify( m_effect->GetMaginification() );
TranslationFCurve->Z.Maginify( m_effect->GetMaginification() );
}
}
memcpy( &LocationAbs.type, pos, sizeof(int) );
pos += sizeof(int);
// Calc attraction forces
if( LocationAbs.type == LocationAbsParameter::None )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == 0 );
memcpy( &LocationAbs.none, pos, size );
pos += size;
}
else if( LocationAbs.type == LocationAbsParameter::Gravity )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(vector3d) );
memcpy( &LocationAbs.gravity, pos, size );
pos += size;
}
else if( LocationAbs.type == LocationAbsParameter::AttractiveForce )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(LocationAbs.attractiveForce) );
memcpy( &LocationAbs.attractiveForce, pos, size );
pos += size;
}
// Magnify attraction forces
if( m_effect->GetVersion() >= 8 )
{
if( LocationAbs.type == LocationAbsParameter::None )
{
}
else if( LocationAbs.type == LocationAbsParameter::Gravity )
{
LocationAbs.gravity *= m_effect->GetMaginification();
}
}
memcpy( &RotationType, pos, sizeof(int) );
pos += sizeof(int);
EffekseerPrintDebug("RotationType %d\n", RotationType);
if( RotationType == ParameterRotationType_Fixed )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterRotationFixed) );
memcpy( &RotationFixed, pos, size );
pos += size;
// 無効化
if( RotationFixed.Position.X == 0.0f &&
RotationFixed.Position.Y == 0.0f &&
RotationFixed.Position.Z == 0.0f )
{
RotationType = ParameterRotationType_None;
EffekseerPrintDebug("RotationType Change None\n");
}
}
else if( RotationType == ParameterRotationType_PVA )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterRotationPVA) );
memcpy( &RotationPVA, pos, size );
pos += size;
}
else if( RotationType == ParameterRotationType_Easing )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(easing_vector3d) );
memcpy( &RotationEasing, pos, size );
pos += size;
}
else if( RotationType == ParameterRotationType_AxisPVA )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterRotationAxisPVA) );
memcpy( &RotationAxisPVA, pos, size );
pos += size;
}
else if( RotationType == ParameterRotationType_AxisEasing )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterRotationAxisEasing) );
memcpy( &RotationAxisEasing, pos, size );
pos += size;
}
else if( RotationType == ParameterRotationType_FCurve )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
RotationFCurve = new FCurveVector3D();
pos += RotationFCurve->Load( pos, m_effect->GetVersion() );
}
memcpy( &ScalingType, pos, sizeof(int) );
pos += sizeof(int);
EffekseerPrintDebug("ScalingType %d\n", ScalingType);
if( ScalingType == ParameterScalingType_Fixed )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterScalingFixed) );
memcpy( &ScalingFixed, pos, size );
pos += size;
// 無効化
if( ScalingFixed.Position.X == 1.0f &&
ScalingFixed.Position.Y == 1.0f &&
ScalingFixed.Position.Z == 1.0f)
{
ScalingType = ParameterScalingType_None;
EffekseerPrintDebug("ScalingType Change None\n");
}
}
else if( ScalingType == ParameterScalingType_PVA )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterScalingPVA) );
memcpy( &ScalingPVA, pos, size );
pos += size;
}
else if( ScalingType == ParameterScalingType_Easing )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(easing_vector3d) );
memcpy( &ScalingEasing, pos, size );
pos += size;
}
else if( ScalingType == ParameterScalingType_SinglePVA )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(ParameterScalingSinglePVA) );
memcpy( &ScalingSinglePVA, pos, size );
pos += size;
}
else if( ScalingType == ParameterScalingType_SingleEasing )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
assert( size == sizeof(easing_float) );
memcpy( &ScalingSingleEasing, pos, size );
pos += size;
}
else if( ScalingType == ParameterScalingType_FCurve )
{
memcpy( &size, pos, sizeof(int) );
pos += sizeof(int);
ScalingFCurve = new FCurveVector3D();
pos += ScalingFCurve->Load( pos, m_effect->GetVersion() );
ScalingFCurve->X.SetDefaultValue( 1.0f );
ScalingFCurve->Y.SetDefaultValue( 1.0f );
ScalingFCurve->Z.SetDefaultValue( 1.0f );
}
/* 生成位置 */
GenerationLocation.load( pos );
/* 生成位置拡大処理*/
if( m_effect->GetVersion() >= 8
/* && (this->CommonValues.ScalingBindType == BindType_NotBind || parent->GetType() == EFFECT_NODE_TYPE_ROOT)*/ )
{
if( GenerationLocation.type == ParameterGenerationLocation::TYPE_POINT )
{
GenerationLocation.point.location.min *= m_effect->GetMaginification();
GenerationLocation.point.location.max *= m_effect->GetMaginification();
}
else if( GenerationLocation.type == ParameterGenerationLocation::TYPE_SPHERE )
{
GenerationLocation.sphere.radius.min *= m_effect->GetMaginification();
GenerationLocation.sphere.radius.max *= m_effect->GetMaginification();
}
else if( GenerationLocation.type == ParameterGenerationLocation::TYPE_CIRCLE )
{
GenerationLocation.circle.radius.min *= m_effect->GetMaginification();
GenerationLocation.circle.radius.max *= m_effect->GetMaginification();
}
}
// 右手系左手系変換
if( setting->GetCoordinateSystem() == CoordinateSystem::LH )
{
// Translation
if( TranslationType == ParameterTranslationType_Fixed )
{
TranslationFixed.Position.Z *= -1.0f;
}
else if( TranslationType == ParameterTranslationType_PVA )
{
TranslationPVA.location.max.z *= -1.0f;
TranslationPVA.location.min.z *= -1.0f;
TranslationPVA.velocity.max.z *= -1.0f;
TranslationPVA.velocity.min.z *= -1.0f;
TranslationPVA.acceleration.max.z *= -1.0f;
TranslationPVA.acceleration.min.z *= -1.0f;
}
else if( TranslationType == ParameterTranslationType_Easing )
{
TranslationEasing.start.max.z *= -1.0f;
TranslationEasing.start.min.z *= -1.0f;
TranslationEasing.end.max.z *= -1.0f;
TranslationEasing.end.min.z *= -1.0f;
}
// Rotation
if( RotationType == ParameterRotationType_Fixed )
{
RotationFixed.Position.X *= -1.0f;
RotationFixed.Position.Y *= -1.0f;
}
else if( RotationType == ParameterRotationType_PVA )
{
RotationPVA.rotation.max.x *= -1.0f;
RotationPVA.rotation.min.x *= -1.0f;
RotationPVA.rotation.max.y *= -1.0f;
RotationPVA.rotation.min.y *= -1.0f;
RotationPVA.velocity.max.x *= -1.0f;
RotationPVA.velocity.min.x *= -1.0f;
RotationPVA.velocity.max.y *= -1.0f;
RotationPVA.velocity.min.y *= -1.0f;
RotationPVA.acceleration.max.x *= -1.0f;
RotationPVA.acceleration.min.x *= -1.0f;
RotationPVA.acceleration.max.y *= -1.0f;
RotationPVA.acceleration.min.y *= -1.0f;
}
else if( RotationType == ParameterRotationType_Easing )
{
RotationEasing.start.max.x *= -1.0f;
RotationEasing.start.min.x *= -1.0f;
RotationEasing.start.max.y *= -1.0f;
RotationEasing.start.min.y *= -1.0f;
RotationEasing.end.max.x *= -1.0f;
RotationEasing.end.min.x *= -1.0f;
RotationEasing.end.max.y *= -1.0f;
RotationEasing.end.min.y *= -1.0f;
}
else if( RotationType == ParameterRotationType_AxisPVA )
{
RotationAxisPVA.axis.max.z *= -1.0f;
RotationAxisPVA.axis.min.z *= -1.0f;
}
else if( RotationType == ParameterRotationType_AxisEasing )
{
RotationAxisEasing.axis.max.z *= -1.0f;
RotationAxisEasing.axis.min.z *= -1.0f;
}
else if( RotationType == ParameterRotationType_FCurve )
{
RotationFCurve->X.ChangeCoordinate();
RotationFCurve->Y.ChangeCoordinate();
}
// GenerationLocation
if( GenerationLocation.type == ParameterGenerationLocation::TYPE_POINT )
{
}
else if( GenerationLocation.type == ParameterGenerationLocation::TYPE_SPHERE )
{
GenerationLocation.sphere.rotation_x.max *= -1.0f;
GenerationLocation.sphere.rotation_x.min *= -1.0f;
GenerationLocation.sphere.rotation_y.max *= -1.0f;
GenerationLocation.sphere.rotation_y.min *= -1.0f;
}
}
if( m_effect->GetVersion() >= 3)
{
Texture.load( pos, m_effect->GetVersion() );
// 拡大処理
Texture.DistortionIntensity *= m_effect->GetMaginification();
}
else
{
Texture.reset();
}
LoadRendererParameter( pos, m_effect->GetSetting() );
if( m_effect->GetVersion() >= 1)
{
// サウンド
memcpy( &SoundType, pos, sizeof(int) );
pos += sizeof(int);
if( SoundType == ParameterSoundType_Use )
{
memcpy( &Sound.WaveId, pos, sizeof(int32_t) );
pos += sizeof(int32_t);
memcpy( &Sound.Volume, pos, sizeof(random_float) );
pos += sizeof(random_float);
memcpy( &Sound.Pitch, pos, sizeof(random_float) );
pos += sizeof(random_float);
memcpy( &Sound.PanType, pos, sizeof(ParameterSoundPanType) );
pos += sizeof(ParameterSoundPanType);
memcpy( &Sound.Pan, pos, sizeof(random_float) );
pos += sizeof(random_float);
memcpy( &Sound.Distance, pos, sizeof(float) );
pos += sizeof(float);
memcpy( &Sound.Delay, pos, sizeof(random_int) );
pos += sizeof(random_int);
}
}
}
// ノード
int nodeCount = 0;
memcpy( &nodeCount, pos, sizeof(int) );
pos += sizeof( int );
EffekseerPrintDebug("ChildrenCount : %d\n", nodeCount );
m_Nodes.resize( nodeCount );
for( size_t i = 0; i < m_Nodes.size(); i++ )
{
m_Nodes[i] = EffectNodeImplemented::Create(m_effect, this, pos);
}
}