Game::Game(void(*Exit)())
:Exit(Exit)
{
for(int i = 0; i < 5; ++i)
{
GameObject* go = gof::CreateGameObject("assets/myGameObject.go");
SpriteRenderer* spr = (SpriteRenderer*)go->GetComponent(SPRITE_RENDERER);
spr->SetSprite(engine::SPR::TEST);
go->SetName("PIE!");
go->GetTransform().position = float2(rand() % 100, rand() % 100);
m_objects.push_back(go);
}
COMPONENT_ID list[] = {TEXT_RENDERER, MOVE_COMPONENT};
const int sizeList = sizeof(list) / sizeof(COMPONENT_ID);
GameObject* go = gof::CreateGameObject(list, sizeList);
go->SetName("FPS Counter");
m_objects.push_back(go);
COMPONENT_ID list2[] = {TEXT_RENDERER, TEST};
const int sizeList2 = sizeof(list2) / sizeof(COMPONENT_ID);
go = gof::CreateGameObject(list2, sizeList2);
go->GetTransform().position = float2(0.0f, 10.0f);
go->SetName("FUPS Counter");
m_objects.push_back(go);
}
SpriteRenderer::SpriteRenderer(const SpriteRenderer &other){
this->sprite = other.sprite;
this->position = other.getSpritePosition();
this->scale = other.getSpriteScale();
this->size = other.getSpriteSize();
this->origin = other.origin;
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeSprite::EndRendering(Manager* manager)
{
SpriteRenderer* renderer = manager->GetSpriteRenderer();
if( renderer != NULL )
{
SpriteRenderer::NodeParameter nodeParameter;
nodeParameter.AlphaBlend = AlphaBlend;
nodeParameter.TextureFilter = Texture.FilterType;
nodeParameter.TextureWrap = Texture.WrapType;
nodeParameter.ZTest = Texture.ZTest;
nodeParameter.ZWrite = Texture.ZWrite;
nodeParameter.Billboard = Billboard;
nodeParameter.ColorTextureIndex = SpriteTexture;
nodeParameter.EffectPointer = GetEffect();
renderer->EndRendering( nodeParameter, m_userData );
}
}
void ParticleGenerator::draw(SpriteRenderer& renderer) {
// use additive blending to make particles glow
glBlendFunc( GL_SRC_ALPHA, GL_ONE );
for( Particle particle : particles ) {
//std::cout << "drawing " << std::endl;
if( particle.life > 0.0f ) {
renderer.drawSprite(texture, particle.pos, glm::vec2(particleSize), particle.rotation, particle.color );
}
}
// reset blending mode
glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
}
void PlayerUnit::init() {
this->unitType = UnitType::UNIT_TYPE_ASSASSIN;
this->inputState = InputState::INPUT_STATE_WAIT;
this->touchNearUnit = false;
this->performingSpecial = false;
this->gridNavRef->SetMovementSpeed(MOVE_SPEED);
this->gridNavRef->SetTurnSpeedDegrees(TURN_SPEED_DEG);
this->addSubscriptionToMessageType(MESSAGE_TYPE_NAVIGATION_REACHED_DESTINATION, this->GetTypeId(), false);
this->touchIndicator = new GameObject(ENGINE->GetSceneGraph3D());
SpriteRenderer* spriteRenderer = this->touchIndicator->AddComponent<SpriteRenderer>();
std::vector<std::string> pathsToTextures;
pathsToTextures.push_back(FRAMEWORK->GetFileSystemUtils()->GetDevicePictureResourcesFolderName() + "SD_Touch_Good.png");
pathsToTextures.push_back(FRAMEWORK->GetFileSystemUtils()->GetDevicePictureResourcesFolderName() + "SD_Touch_Bad.png");
spriteRenderer->initPlane(1.0f, 1.0f, "sptshdr", pathsToTextures, PlaneOrigin::Center);
touchIndicator->SetVisible(false);
this->touchIndicator->GetTransform()->Rotate(90.0f inRadians, XAXIS);
this->currentTouchedCell = NULL;
}
void SpriteRenderer::onDuplicate( Component* dst )
{
if( !dst )
return;
Component::onDuplicate( dst );
if( !XeCore::Common::IRtti::isDerived< SpriteRenderer >( dst ) )
return;
SpriteRenderer* c = (SpriteRenderer*)dst;
c->setMaterial( getMaterial() );
c->setMaterialValidation( getMaterialValidation() );
c->setTexture( getTexture() );
c->setSize( getSize() );
c->setOrigin( getOrigin() );
c->setRenderStates( getRenderStates() );
}
//----------------------------------------------------------------------------------
//
//----------------------------------------------------------------------------------
void EffectNodeSprite::Rendering(const Instance& instance, Manager* manager)
{
const InstanceValues& instValues = instance.rendererValues.sprite;
SpriteRenderer* renderer = manager->GetSpriteRenderer();
if( renderer != NULL )
{
SpriteRenderer::NodeParameter nodeParameter;
nodeParameter.AlphaBlend = AlphaBlend;
nodeParameter.TextureFilter = Texture.FilterType;
nodeParameter.TextureWrap = Texture.WrapType;
nodeParameter.ZTest = Texture.ZTest;
nodeParameter.ZWrite = Texture.ZWrite;
nodeParameter.Billboard = Billboard;
nodeParameter.ColorTextureIndex = SpriteTexture;
nodeParameter.EffectPointer = GetEffect();
SpriteRenderer::InstanceParameter instanceParameter;
instValues._color.setValueToArg( instanceParameter.AllColor );
instanceParameter.SRTMatrix43 = instance.GetGlobalMatrix43();
color color_ll = instValues._color;
color color_lr = instValues._color;
color color_ul = instValues._color;
color color_ur = instValues._color;
if( SpriteColor.type == SpriteColorParameter::Default )
{
}
else if( SpriteColor.type == SpriteColorParameter::Fixed )
{
color_ll = color::mul( color_ll, SpriteColor.fixed.ll );
color_lr = color::mul( color_lr, SpriteColor.fixed.lr );
color_ul = color::mul( color_ul, SpriteColor.fixed.ul );
color_ur = color::mul( color_ur, SpriteColor.fixed.ur );
}
float fadeAlpha = GetFadeAlpha( instance );
if( fadeAlpha != 1.0f )
{
color_ll.a = (uint8_t)(color_ll.a * fadeAlpha);
color_lr.a = (uint8_t)(color_lr.a * fadeAlpha);
color_ul.a = (uint8_t)(color_ul.a * fadeAlpha);
color_ur.a = (uint8_t)(color_ur.a * fadeAlpha);
}
color_ll.setValueToArg( instanceParameter.Colors[0] );
color_lr.setValueToArg( instanceParameter.Colors[1] );
color_ul.setValueToArg( instanceParameter.Colors[2] );
color_ur.setValueToArg( instanceParameter.Colors[3] );
if( SpritePosition.type == SpritePosition.Default )
{
instanceParameter.Positions[0].X = -0.5f;
instanceParameter.Positions[0].Y = -0.5f;
instanceParameter.Positions[1].X = 0.5f;
instanceParameter.Positions[1].Y = -0.5f;
instanceParameter.Positions[2].X = -0.5f;
instanceParameter.Positions[2].Y = 0.5f;
instanceParameter.Positions[3].X = 0.5f;
instanceParameter.Positions[3].Y = 0.5f;
}
else if( SpritePosition.type == SpritePosition.Fixed )
{
SpritePosition.fixed.ll.setValueToArg( instanceParameter.Positions[0] );
SpritePosition.fixed.lr.setValueToArg( instanceParameter.Positions[1] );
SpritePosition.fixed.ul.setValueToArg( instanceParameter.Positions[2] );
SpritePosition.fixed.ur.setValueToArg( instanceParameter.Positions[3] );
}
instanceParameter.UV = instance.GetUV();
renderer->Rendering( nodeParameter, instanceParameter, m_userData );
}
}
void PaddleObject::draw( SpriteRenderer& renderer ) {
renderer.drawSprite(animations[animationIndex], pos, size, rotation, color);
}
void GameObject::Draw(SpriteRenderer &renderer)
{
renderer.DrawSprite(this->Sprite, this->Position, this->Size, this->Rotation, this->Color);
}
void Profiler::EndFrame(SpriteRenderer& spriteRenderer, SpriteFont& spriteFont)
{
// If any profile was previously active but wasn't used this frame, it could still
// have outstanding queries that we need to keep running
for(auto iter = profiles.begin(); iter != profiles.end(); iter++)
{
const std::wstring& name = (*iter).first;
ProfileData& profile = (*iter).second;
if(!profile.CPUProfile && !profile.Active && profile.DisjointQuery[0] != nullptr)
{
StartProfile(name);
EndProfile(name);
profile.Active = false;
}
}
currFrame = (currFrame + 1) % QueryLatency;
Float4x4 transform;
transform.SetTranslation(Float3(25.0f, 100.0f, 0.0f));
// Iterate over all of the profiles
for(auto iter = profiles.begin(); iter != profiles.end(); iter++)
{
ProfileData& profile = (*iter).second;
profile.QueryFinished = false;
float time = 0.0f;
if(profile.CPUProfile)
{
time = (profile.EndTime - profile.StartTime) / 1000.0f;
}
else
{
if(profile.DisjointQuery[currFrame] == NULL)
continue;
// Get the query data
uint64 startTime = 0;
while(context->GetData(profile.TimestampStartQuery[currFrame], &startTime, sizeof(startTime), 0) != S_OK);
uint64 endTime = 0;
while(context->GetData(profile.TimestampEndQuery[currFrame], &endTime, sizeof(endTime), 0) != S_OK);
D3D11_QUERY_DATA_TIMESTAMP_DISJOINT disjointData;
while(context->GetData(profile.DisjointQuery[currFrame], &disjointData, sizeof(disjointData), 0) != S_OK);
if(disjointData.Disjoint == false)
{
uint64 delta = endTime - startTime;
float frequency = static_cast<float>(disjointData.Frequency);
time = (delta / frequency) * 1000.0f;
}
}
profile.TimeSamples[profile.CurrSample] = time;
profile.CurrSample = (profile.CurrSample + 1) % ProfileData::FilterSize;
float sum = 0.0f;
for(UINT i = 0; i < ProfileData::FilterSize; ++i)
sum += profile.TimeSamples[i];
time = sum / ProfileData::FilterSize;
if(profile.Active)
{
wstring output = (*iter).first + L": " + ToString(time) + L"ms";
spriteRenderer.RenderText(spriteFont, output.c_str(), transform, Float4(1.0f, 1.0f, 0.0f, 1.0f));
transform._42 += 25.0f;
}
profile.Active = false;
}
}
void GameObject::draw( SpriteRenderer& renderer ) {
renderer.drawSprite( sprite, pos, size, rotation, color );
}
void Line::Draw(SpriteRenderer &renderer) {
// Draw Line
renderer.DrawSprite(this->m_line, this->Pos, this->Size);
}
void Square::Draw(StateManager &manager, SpriteRenderer &renderer, glm::mat4 projection, glm::mat4 view, GLboolean border)
{
renderer.DrawSprite(manager, this->Position, this->Size, this->IsCircle, this->Color1, this->Color2, this->Effet, projection, view, border);
}
