//------------------------------------------------------------------------
void CScan::StartFire()
{
if (!m_pWeapon->IsBusy())
{
if(m_pWeapon->GetOwnerActor())
{
// add the flash animation part here
IEntity *pEntity = m_pWeapon->GetEntity();
if(pEntity)
{
IEntityRenderProxy* pRenderProxy((IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
IMaterial* pMtl(pRenderProxy->GetRenderMaterial(0));
if (pMtl)
{
pMtl = pMtl->GetSafeSubMtl(2);
if (pMtl)
{
const SShaderItem& shaderItem(pMtl->GetShaderItem());
if (shaderItem.m_pShaderResources && shaderItem.m_pShaderResources->GetTexture(0))
{
SEfResTexture* pTex(shaderItem.m_pShaderResources->GetTexture(0));
if (pTex->m_Sampler.m_pDynTexSource)
{
IFlashPlayer* pFlashPlayer(0);
IDynTextureSource::EDynTextureSource type(IDynTextureSource::DTS_I_FLASHPLAYER);
pTex->m_Sampler.m_pDynTexSource->GetDynTextureSource((void*&)pFlashPlayer, type);
if (pFlashPlayer && type == IDynTextureSource::DTS_I_FLASHPLAYER)
{
pFlashPlayer->Invoke0("startScan");
}
}
}
}
}
}
}
SAFE_HUD_FUNC(SetRadarScanningEffect(true));
m_scanning=true;
m_delayTimer=m_scanparams.delay;
m_durationTimer=m_scanparams.duration;
m_tagEntitiesDelay=m_scanparams.tagDelay;
m_pWeapon->SetBusy(true);
}
m_pWeapon->PlayAction(m_scanactions.spin_up, 0, false, CItem::eIPAF_Default|CItem::eIPAF_CleanBlending);
m_pWeapon->RequestStartFire();
m_pWeapon->RequireUpdate(eIUS_FireMode);
}
}
//------------------------------------------------------------------------
void CScan::StopFire()
{
if (!m_scanning)
return;
IEntity *pEntity = m_pWeapon->GetEntity();
if(pEntity)
{
IEntityRenderProxy* pRenderProxy((IEntityRenderProxy*)pEntity->GetProxy(ENTITY_PROXY_RENDER));
if (pRenderProxy)
{
IMaterial* pMtl(pRenderProxy->GetRenderMaterial(0));
if (pMtl)
{
pMtl = pMtl->GetSafeSubMtl(2);
if (pMtl)
{
const SShaderItem& shaderItem(pMtl->GetShaderItem());
if (shaderItem.m_pShaderResources && shaderItem.m_pShaderResources->GetTexture(0))
{
SEfResTexture* pTex(shaderItem.m_pShaderResources->GetTexture(0));
if (pTex->m_Sampler.m_pDynTexSource)
{
IFlashPlayer* pFlashPlayer(0);
IDynTextureSource::EDynTextureSource type(IDynTextureSource::DTS_I_FLASHPLAYER);
pTex->m_Sampler.m_pDynTexSource->GetDynTextureSource((void*&)pFlashPlayer, type);
if (pFlashPlayer && type == IDynTextureSource::DTS_I_FLASHPLAYER)
{
pFlashPlayer->Invoke0("cancelScan");
}
}
}
}
}
}
}
SAFE_HUD_FUNC(SetRadarScanningEffect(false));
m_pWeapon->PlayAction(m_scanactions.spin_down, 0, false, CItem::eIPAF_Default|CItem::eIPAF_CleanBlending);
m_scanning=false;
m_pWeapon->SetBusy(false);
m_pWeapon->RequestStopFire();
if (m_scanLoopId != INVALID_SOUNDID)
{
m_pWeapon->StopSound(m_scanLoopId);
m_scanLoopId = INVALID_SOUNDID;
}
}
GLTexturePtr GPUFilter::calcBlurKernelTex(float stdDev, float opacity, bool bUseFloat)
const
{
AVG_ASSERT(opacity != -1);
int kernelWidth;
float* pKernel;
if (stdDev == 0) {
kernelWidth = 1;
pKernel = new float[1];
pKernel[0] = float(opacity);
} else {
float tempCoeffs[1024];
int i=0;
float coeff;
do {
coeff = float(exp(-i*i/(2*stdDev*stdDev))/sqrt(2*PI*stdDev*stdDev))
*float(opacity);
tempCoeffs[i] = coeff;
i++;
} while (coeff > 0.003 && i < 1024);
if (i > 1) {
int kernelCenter = i - 2;
kernelWidth = kernelCenter*2+1;
pKernel = new float[kernelWidth];
float sum = 0;
for (int i = 0; i <= kernelCenter; ++i) {
pKernel[kernelCenter+i] = tempCoeffs[i];
sum += tempCoeffs[i];
if (i != 0) {
pKernel[kernelCenter-i] = tempCoeffs[i];
sum += tempCoeffs[i];
}
}
// Make sure the sum of coefficients is opacity despite the inaccuracies
// introduced by using a kernel of finite size.
for (int i = 0; i < kernelWidth; ++i) {
pKernel[i] *= float(opacity)/sum;
}
} else {
// Blur is so wide that all pixels would be black at 8-bit precision
kernelWidth = 1;
pKernel = new float[1];
pKernel[0] = 0.;
}
}
// dumpKernel(kernelWidth, pKernel);
IntPoint size(kernelWidth, 1);
PixelFormat pf;
if (bUseFloat) {
pf = R32G32B32A32F;
} else {
pf = I8;
}
GLTexturePtr pTex(new GLTexture(size, pf));
PBOPtr pFilterKernelPBO(new PBO(IntPoint(1024, 1), pf, GL_STREAM_DRAW));
pFilterKernelPBO->activate();
void * pPBOPixels = glproc::MapBuffer(GL_PIXEL_UNPACK_BUFFER_EXT, GL_WRITE_ONLY);
GLContext::getCurrent()->checkError("GPUFilter::calcBlurKernelTex MapBuffer()");
if (bUseFloat) {
float * pCurFloat = (float*)pPBOPixels;
for (int i = 0; i < kernelWidth; ++i) {
for (int j = 0; j < 4; ++j) {
*pCurFloat = pKernel[i];
++pCurFloat;
}
}
} else {
unsigned char * pCurPixel = (unsigned char *)pPBOPixels;
for (int i = 0; i < kernelWidth; ++i) {
*pCurPixel = (unsigned char)(pKernel[i]*255+0.5);
++pCurPixel;
}
}
glproc::UnmapBuffer(GL_PIXEL_UNPACK_BUFFER_EXT);
GLContext::getCurrent()->checkError("GPUFilter::calcBlurKernelTex UnmapBuffer()");
pFilterKernelPBO->moveToTexture(*pTex);
delete[] pKernel;
return pTex;
}
void
BasicLayer::onActive(uint64_t t)
{
BaseLayer::onActive(t);
mPool.reset( new helios::Pool(10) );
std::vector<helios::Vertex> verts;
std::vector<uint32_t> ind;
std::vector<helios::s::Material> mats;
std::vector<helios::s::Joint> joints;
std::string b_folder = helios::SceneManager::Inst().GetResourceFolder();
std::string file = b_folder + "/zombie02.h3dmesh";
int retval = helios::LoadH3DMESH::Load(file, verts, ind, mats, joints );
if(retval < 0)
{
return;
}
{
int vbo = mRender->GenerateVBO(&verts[0], sizeof(helios::Vertex), sizeof(helios::Vertex) * verts.size());
int ibo = mRender->GenerateIBO(&ind[0], ind.size());
BasicEntity* e = new BasicEntity(this, glm::vec3(0.f,0.f,0.f), vbo, ibo);
helios::RenderableComponent* rc = (helios::RenderableComponent*)e->GetComponent(helios::e::kComponentRenderable)[0];
helios::SkeletonComponent * sc = (helios::SkeletonComponent*)e->GetComponent(helios::e::kComponentSkeleton)[0];
for( auto it = mats.begin() ; it != mats.end() ; ++it)
{
helios::s::MaterialGroup m ((*it));
auto tex = std::string(it->texturename);
if(mTextures.find(tex) == mTextures.end())
{
std::shared_ptr<helios::Texture> pTex(new helios::Texture(b_folder + tex));
mTextures[tex] = pTex;
}
m.tex = mTextures[tex]->id();
m.ibo = ibo;
rc->AddMaterialGroup(m);
}
for ( auto it = joints.begin() ; it != joints.end() ; ++it)
{
sc->AddJoint((*it));
}
sc->SetDefaultAnimation(173,210, 30.f);
sc->LoadAnimationMap(b_folder + "/zombie02.json");
mEntities.push_back(std::shared_ptr<helios::IEntity>(e));
}
{
helios::Vertex v [4] ;
unsigned short minS = 0;
unsigned short maxS = 0xFFFF;
unsigned short minT = 0;
unsigned short maxT = 0xFFFF;
v [0] = helios::Vertex( glm::vec4(0.f,0.f,0.f,1.f), minS,maxT );
v [1] = helios::Vertex( glm::vec4(50.f,0.f,0.f,1.f), maxS,maxT );
v [2] = helios::Vertex( glm::vec4(0.f,0.f,50.f,1.f), minS,minT );
v [3] = helios::Vertex( glm::vec4(50.f,0.f,50.f,1.f), maxS,minT );
for ( int i = 0 ; i < 4 ; ++i )
{
v[i].r = 200;
v[i].g = 170;
v[i].b = 40;
}
int vbo = mRender->GenerateVBO(&v[0], sizeof(helios::Vertex), sizeof(helios::Vertex) * 4);
uint32_t indices [6] = { 2 , 1 , 0, 2, 3, 1 } ;
int ibo = mRender->GenerateIBO(indices, 6);
CubeEntity* e = new CubeEntity(this, glm::vec3(-25.f,0.f,-25.f), vbo, ibo );
helios::s::MaterialGroup mg ;
mg.ibo = ibo;
mg.index_start = 0;
mg.index_end = 6;
mg.tex = 0;
auto rc = static_cast<helios::RenderableComponent*>(e->GetComponent(helios::e::kComponentRenderable)[0]);
rc->AddMaterialGroup(mg);
mEntities.push_back(std::shared_ptr<helios::IEntity>(e));
}
{
CameraEntity * e = new CameraEntity(this,glm::vec3(0.,25.,50.), glm::vec3(0.,0.,5.), glm::vec3(0.,-0.5,-1.), glm::vec3(0.,1.,0.));
mEntities.push_back(std::shared_ptr<helios::IEntity>(e));
}
}
