void HardwareController::createNewHardwareMappingEvent(int channel_number, std::unordered_map<string, string>& settings)
{
string trigger = settings["trigger"];
HardwareMappingEvent event;
event.compare_operator = HardwareMappingEvent::Change;
if (trigger.startswith("<"))
{
event.compare_operator = HardwareMappingEvent::Decrease;
trigger = trigger.substr(1).strip();
}
if (trigger.startswith(">"))
{
event.compare_operator = HardwareMappingEvent::Increase;
trigger = trigger.substr(1).strip();
}
event.trigger_variable = trigger;
event.channel_nr = channel_number;
event.runtime = settings["runtime"].toFloat();
event.triggered = false;
event.previous_value = 0.0;
event.effect = createEffect(settings);
if (event.effect)
{
LOG(DEBUG) << "New hardware event: " << event.channel_nr << ":" << event.trigger_variable << " " << event.compare_operator;
events.push_back(event);
}
}
void Screen::initD3D()
{
//do all D3D initialization
if (!createSCandDevice())
{
_badInit = true;
return;
}
createRT();
createVP();
createDS();
createSM();
createSSAO();
createEffect();
parseEffect();
createVL();
//create the light
light = new AMLight(D3DXVECTOR3(0.0f, 0.0f, -1.0f));
//set up the physics engine
physics.setup(30, settings.getGravityMul());
_pDebug = new AMPhysicsDebug(d3ddev, effectTech);
//only wireframe supported for physics debug
_pDebug->setDebugMode(AMPhysicsDebug::DBG_DrawWireframe);
physics.getWorld()->setDebugDrawer(_pDebug);
}
void ShadowMapRenderer::Init()
{
createEffect();
createGaussianBlurQuadVB();
createRendertargetDepthStencil();
createTextures();
}
void Tree::init(const char* filename, ID3D11Device* g_device, ID3D11DeviceContext* g_context)
{
Mesh::init(filename, g_device, g_context);
_leaves.init("", g_device, g_context);
//////////////////////////
bFire = false;
m_numSubsets = 1;
//////////////////////////
createEffect("../Desert_Island/shaders/tree.fxo", g_device);
fx_m_World = getFX()->GetVariableByName("m_World")->AsMatrix();
fx_m_WorldViewProj = getFX()->GetVariableByName("m_WorldViewProj")->AsMatrix();
fx_m_L_ViewProj = getFX()->GetVariableByName("m_L_ViewProj")->AsMatrix();
fx_tex_shadow_map = getFX()->GetVariableByName("tex_shadow_map")->AsShaderResource();
fx_lights = getFX()->GetVariableByName("lights");
fx_num_lights = getFX()->GetVariableByName("num_lights")->AsScalar();
fx_pEye = getFX()->GetVariableByName("pEye")->AsVector();
fx_bShadowed = getFX()->GetVariableByName("bShadowed")->AsScalar();
fx_bUsePCSS = getFX()->GetVariableByName("bUsePCSS")->AsScalar();
///////////
HRESULT hr = D3DX11CreateShaderResourceViewFromFile(g_dev(), L"../Desert_island/media/tree_heightmap.jpg", 0, 0, &srv_heightmap, 0);
if (FAILED(hr))
MessageBoxA(0, "Error creating tree heightmap srv", 0, 0);
///////////
// Input layout - Vertex IA
D3D11_INPUT_ELEMENT_DESC vertex_layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TANGENT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEX_COORDS", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
D3DX11_PASS_DESC passDesc;
ID3DX11EffectTechnique* tech = getFX()->GetTechniqueByIndex(0);
tech->GetPassByIndex(0)->GetDesc(&passDesc);
hr = createInputLayout(g_dev(), vertex_layout, 4, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize);
if (FAILED(hr))
MessageBoxA(0, "Error creating tree IA", 0, 0);
}
void Form::setNode(Node* node)
{
// If the user wants a custom node then we need to create a 3D quad
if (node && node != _node)
{
// Set this Form up to be 3D by initializing a quad.
float x2 = _bounds.width;
float y2 = _bounds.height;
float vertices[] =
{
0, y2, 0, 0, _v1,
0, 0, 0, 0, 0,
x2, y2, 0, _u2, _v1,
x2, 0, 0, _u2, 0
};
VertexFormat::Element elements[] =
{
VertexFormat::Element(VertexFormat::POSITION, 3),
VertexFormat::Element(VertexFormat::TEXCOORD0, 2)
};
Mesh* mesh = Mesh::createMesh(VertexFormat(elements, 2), 4, false);
GP_ASSERT(mesh);
mesh->setPrimitiveType(Mesh::TRIANGLE_STRIP);
mesh->setVertexData(vertices, 0, 4);
_nodeQuad = Model::create(mesh);
SAFE_RELEASE(mesh);
GP_ASSERT(_nodeQuad);
// Create the effect and material
Effect* effect = createEffect();
GP_ASSERT(effect);
_nodeMaterial = Material::create(effect);
GP_ASSERT(_nodeMaterial);
_nodeQuad->setMaterial(_nodeMaterial);
_nodeMaterial->release();
node->setModel(_nodeQuad);
_nodeQuad->release();
// Bind the WorldViewProjection matrix.
_nodeMaterial->setParameterAutoBinding("u_worldViewProjectionMatrix", RenderState::WORLD_VIEW_PROJECTION_MATRIX);
// Bind the texture from the framebuffer and set the texture to clamp
Texture::Sampler* sampler = Texture::Sampler::create(_frameBuffer->getRenderTarget()->getTexture());
GP_ASSERT(sampler);
sampler->setWrapMode(Texture::CLAMP, Texture::CLAMP);
_nodeMaterial->getParameter("u_texture")->setValue(sampler);
sampler->release();
RenderState::StateBlock* rsBlock = _nodeMaterial->getStateBlock();
rsBlock->setDepthWrite(true);
rsBlock->setBlend(true);
rsBlock->setBlendSrc(RenderState::BLEND_SRC_ALPHA);
rsBlock->setBlendDst(RenderState::BLEND_ONE_MINUS_SRC_ALPHA);
}
_node = node;
}
SkyBox::SkyBox()
:mVertexBuffer(NULL)
,mIndexBuffer(NULL)
,mCubeTex(NULL)
{
if(!effect)
createEffect();
build();
}
//-----------------------------------------------------------------------
void EffectObject::createRenderInstance(System* system)
{
assert(system);
PlacementObject::createRenderInstance(system);
if (!mEffectName.empty())
{
createEffect();
}
}
bool EffectBaseTest::init()
{
if(TestCase::init())
{
LayerColor *background = LayerColor::create( Color4B(32,128,32,255) );
this->addChild(background,-20);
if(isRectEffect())
{
Size visibleSize = Director::getInstance()->getVisibleSize();
Rect gridRect = Rect(visibleSize.width * 0.2,
visibleSize.height * 0.2,
visibleSize.width * 0.6,
visibleSize.height * 0.6);
_gridNodeTarget = NodeGrid::create(gridRect);
}
else
{
_gridNodeTarget = NodeGrid::create();
}
addChild(_gridNodeTarget, 0);
_gridNodeTarget->runAction(createEffect(3));
auto bg = Sprite::create(s_back3);
_gridNodeTarget->addChild(bg, 0);
bg->setPosition(VisibleRect::center());
auto grossini = Sprite::create(s_pathSister2);
_gridNodeTarget->addChild(grossini, 1);
grossini->setPosition(VisibleRect::left().x+VisibleRect::getVisibleRect().size.width/3,VisibleRect::center().y);
auto sc = ScaleBy::create(2, 5);
auto sc_back = sc->reverse();
grossini->runAction( RepeatForever::create(Sequence::create(sc, sc_back, nullptr) ) );
auto tamara = Sprite::create(s_pathSister1);
_gridNodeTarget->addChild(tamara, 1);
tamara->setPosition(VisibleRect::left().x+2*VisibleRect::getVisibleRect().size.width/3,VisibleRect::center().y);
auto sc2 = ScaleBy::create(2, 5);
auto sc2_back = sc2->reverse();
tamara->runAction( RepeatForever::create(Sequence::create(sc2, sc2_back, nullptr)) );
schedule( CC_SCHEDULE_SELECTOR(EffectBaseTest::checkAnim) );
return true;
}
return false;
}
bool
ShaderD3D11::create()
{
free();
std::string includeStream;
if (IShader::includeFilePathName().length() > 0)
if (std::unique_ptr<typename DataStream> fileStream =
std::unique_ptr<typename DataStream>(AssetManager::assetManager()->openStream(IShader::includeFilePathName())))
{
size_t fileSize = fileStream->size();
char* buffer = new char[fileSize + 1];
memset(buffer, 0, fileSize + 1);
fileStream->read(buffer, fileSize);
includeStream = buffer;
delete[] buffer;
}
std::string shaderStream;
if (std::unique_ptr<typename DataStream> fileStream =
std::unique_ptr<typename DataStream>(AssetManager::assetManager()->openStream(IShader::filePathName())))
{
size_t fileSize = fileStream->size();
char* buffer = new char[fileSize + 1];
memset(buffer, 0, fileSize + 1);
fileStream->read(buffer, fileSize);
shaderStream = buffer;
delete[] buffer;
}
setShaderStream((includeStream+shaderStream).c_str());
if (createEffect ())
{
D3DX11_EFFECT_DESC desc;
if (SUCCEEDED (_effect->effect()->GetDesc (&desc)))
{
enumerateTechniques (desc, _verbose);
enumerateVariables (desc, _verbose);
passVariables();
return true;
}
}
return false;
}
//-----------------------------------------------------------------------
void EffectObject::setEffectName( const Ogre::String &name )
{
if (mEffectName != name)
{
if (mEffect)
{
destroyEffect();
}
mEffectName = name;
if (!mEffectName.empty())
{
createEffect();
}
}
}
void MonsterBehaviorPattern::update(float delta) {
if (GameData::getInstance()->getIsInTutorial() == false) {
timer += delta;
}
if (maxTimer < timer) {
timer = 0;
decisionBehavior();
}
if (!isOneAnimationAttack && attackTimer < timer) {
isOneAnimationAttack = true;
attackToHero();
}
if (!isOneAttackEffect && attackTimer < timer) {
isOneAttackEffect = true;
createEffect();
}
}
void HardwareController::createNewHardwareMappingState(int channel_number, std::unordered_map<string, string>& settings)
{
string condition = settings["condition"];
HardwareMappingState state;
state.variable = condition;
state.compare_operator = HardwareMappingState::Greater;
state.compare_value = 0.0;
state.channel_nr = channel_number;
for(HardwareMappingState::EOperator compare_operator : {HardwareMappingState::Less, HardwareMappingState::Greater, HardwareMappingState::Equal, HardwareMappingState::NotEqual})
{
string compare_string = "<";
switch(compare_operator)
{
case HardwareMappingState::Less: compare_string = "<"; break;
case HardwareMappingState::Greater: compare_string = ">"; break;
case HardwareMappingState::Equal: compare_string = "=="; break;
case HardwareMappingState::NotEqual: compare_string = "!="; break;
}
if (condition.find(compare_string) > -1)
{
state.variable = condition.substr(0, condition.find(compare_string)).strip();
state.compare_operator = compare_operator;
state.compare_value = condition.substr(condition.find(compare_string) + 1).strip().toFloat();
}
}
state.effect = createEffect(settings);
if (state.effect)
{
LOG(DEBUG) << "New hardware state: " << state.channel_nr << ":" << state.variable << " " << state.compare_operator << " " << state.compare_value;
states.push_back(state);
}
}
/*!
Invoked when a firing action is finished.
Turns hit effects on, checks whether someone was hit, etc.
*/
void CcfQmlBaseScenario::firingActionFinished(int index, qreal targetX, qreal targetY) {
QObject *unit = mUnits.at(index);
if (unit->getInt("currentOrder") != -1) {
// TODO: remove use of effect for smoke and attack - and optimise it away.
QObject *effect = createEffect(mZoomArea);
if (effect == 0)
return;
mEffects.append(effect);
QString scheduledOperation;
unit->metaObject()->invokeMethod(unit, "operation", Qt::DirectConnection, Q_RETURN_ARG(QString, scheduledOperation));
if (scheduledOperation == "Attack") {
effect->set("animationString", "gun_fire");
// Check, whether a unit was hit.
QObject *hitee = 0;
hitee = unitAt(targetX, targetY);
if ((hitee != 0)
&& (hitee->property("unitIndex").isValid() == true)
&& (hitee->property("unitType").isValid() == true)) {
invoke(hitee, "hit", Q_ARG(QObject *, unit), Q_ARG(qreal, targetX), Q_ARG(qreal, targetY));
}
HRESULT MyApp::buildFX()
{
if (!createEffect((PATH_SHADERS+string("vs_alien.fxo")).c_str(), &m_fxAlienVS))
MessageBoxA(0, "Error creating AlienVS effect", 0, 0);
if (!createEffect((PATH_SHADERS+string("gs_alien.fxo")).c_str(), &m_fxAlienGS))
MessageBoxA(0, "Error creating AlienGS effect", 0, 0);
if (!createEffect((PATH_SHADERS+string("explosion.fxo")).c_str(), &m_fxExplosion))
MessageBoxA(0, "Error creating Explosion effect", 0, 0);
if (!createEffect((PATH_SHADERS+string("implicit.fxo")).c_str(), &m_fxImplicit))
MessageBoxA(0, "Error creating Implicit effect", 0, 0);
if (!createEffect((PATH_SHADERS+string("quads.fxo")).c_str(), &m_fxQuads))
MessageBoxA(0, "Error creating quads effect", 0, 0);
if (!createEffect((PATH_SHADERS+string("dynamicTerrain.fxo")).c_str(), &m_fxDynamicTerrain))
MessageBoxA(0, "Error creating dynamic terrain effect", 0, 0);
// Vertex Input Layout
D3D11_INPUT_ELEMENT_DESC layout[] = {
{ "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "NORMAL", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TANGENT", 0, DXGI_FORMAT_R32G32B32A32_FLOAT, 0, 24, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "TEX_COORDS", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 36, D3D11_INPUT_PER_VERTEX_DATA, 0 }
};
D3DX11_PASS_DESC passDesc;
ID3DX11EffectTechnique* tech;
tech = m_fxAlienVS->GetTechniqueByIndex(0);
HRESULT hr = tech->GetPassByIndex(0)->GetDesc(&passDesc);
hr = _dxDev->CreateInputLayout(layout, 4, passDesc.pIAInputSignature, passDesc.IAInputSignatureSize, &_inputLayout);
if (FAILED(hr))
MessageBoxA(0, "Error creating input layout", 0, 0);
return S_OK;
}
ActionInterval* getAction()
{
auto pEffect = createEffect(actionIdx, 3);
return pEffect;
}
ActionInterval* getAction()
{
ActionInterval* pEffect = createEffect(0, 0.25f);
return pEffect;
}
void HardwareController::handleConfig(string section, std::unordered_map<string, string> settings)
{
if (section == "[hardware]")
{
HardwareOutputDevice* device = nullptr;
if (settings["device"] == "")
LOG(ERROR) << "No device definition in [hardware] section";
else if (settings["device"] == "DMX512SerialDevice")
device = new DMX512SerialDevice();
else if (settings["device"] == "EnttecDMXProDevice")
device = new EnttecDMXProDevice();
else if (settings["device"] == "VirtualOutputDevice")
device = new VirtualOutputDevice();
if (device)
{
if (!device->configure(settings))
{
LOG(ERROR) << "Failed to configure device: " << settings["device"];
delete device;
}else{
LOG(INFO) << "New hardware device: " << settings["device"] << " with: " << device->getChannelCount() << " channels";
devices.push_back(device);
}
}
}else if(section == "[channel]")
{
if (settings["channel"] == "" || settings["name"] == "")
LOG(ERROR) << "Incorrect properties in [channel] section";
else{
channel_mapping[settings["name"]] = settings["channel"].toInt();
LOG(INFO) << "Channel #" << settings["channel"] << ": " << settings["name"];
}
}else if(section == "[channels]")
{
for(std::pair<string, string> item : settings)
{
channel_mapping[item.first] = item.second.toInt();
LOG(INFO) << "Channel #" << item.second << ": " << item.first;
}
}else if(section == "[state]")
{
string condition = settings["condition"];
HardwareMappingState state;
state.variable = condition;
state.compare_operator = HardwareMappingState::Greater;
state.compare_value = 0.0;
state.channel_nr = -1;
if (channel_mapping.find(settings["target"]) != channel_mapping.end())
state.channel_nr = channel_mapping[settings["target"]];
for(HardwareMappingState::EOperator compare_operator : {HardwareMappingState::Less, HardwareMappingState::Greater, HardwareMappingState::Equal, HardwareMappingState::NotEqual})
{
string compare_string = "<";
switch(compare_operator)
{
case HardwareMappingState::Less: compare_string = "<"; break;
case HardwareMappingState::Greater: compare_string = ">"; break;
case HardwareMappingState::Equal: compare_string = "=="; break;
case HardwareMappingState::NotEqual: compare_string = "!="; break;
}
if (condition.find(compare_string) > -1)
{
state.variable = condition.substr(0, condition.find(compare_string)).strip();
state.compare_operator = compare_operator;
state.compare_value = condition.substr(condition.find(compare_string) + 1).strip().toFloat();
}
}
if (state.channel_nr < 0)
{
LOG(ERROR) << "Unknown target channel in hardware.ini: " << settings["target"];
}else{
state.effect = createEffect(settings);
if (state.effect)
{
LOG(DEBUG) << "New hardware state: " << state.channel_nr << ":" << state.variable << " " << state.compare_operator << " " << state.compare_value;
states.push_back(state);
}
}
}else if(section == "[event]")
{
string trigger = settings["trigger"];
HardwareMappingEvent event;
event.compare_operator = HardwareMappingEvent::Change;
if (trigger.startswith("<"))
{
event.compare_operator = HardwareMappingEvent::Decrease;
trigger = trigger.substr(1).strip();
}
if (trigger.startswith(">"))
{
event.compare_operator = HardwareMappingEvent::Increase;
trigger = trigger.substr(1).strip();
}
event.trigger_variable = trigger;
event.channel_nr = -1;
event.runtime = settings["runtime"].toFloat();
event.triggered = false;
event.previous_value = 0.0;
if (channel_mapping.find(settings["target"]) != channel_mapping.end())
event.channel_nr = channel_mapping[settings["target"]];
if (event.channel_nr < 0)
{
LOG(ERROR) << "Unknown target channel in hardware.ini: " << settings["target"];
}else{
event.effect = createEffect(settings);
if (event.effect)
{
LOG(DEBUG) << "New hardware event: " << event.channel_nr << ":" << event.trigger_variable << " " << event.compare_operator;
events.push_back(event);
}
}
}else{
LOG(ERROR) << "Unknown section in hardware.ini: " << section;
}
}
/**
* Game update function
* @param pStream the packet stream to write state data to (if playing multiplayer)
*/
void Game::update(PacketStream* pStream) {
//cout << "update" << endl;
// timer
g_timeNow = s3eTimerGetMs();
g_deltaTime = float( (g_timeNow - g_prevTime) * 0.001 );
// Time since last packet was sent
timeSinceLastSend += g_timeNow - g_prevTime;
g_prevTime = g_timeNow;
if(mStage == Constants::INGAME) {
for(int i = 0; i < bufferSize; i++) {
mMessageReceived[i] = 0;
mMessageSent[i] = 0;
}
if(mPlayer->getHealth() <= 0) {
mPlayer->loadCheckpoint = true;
mPlayer->mPos = CIwSVec2(mCheckpoint.x, mCheckpoint.y);
// Create respawn effect
CIwSVec2 screenCentre = CIwSVec2((int16)Iw2DGetSurfaceWidth() >> 1, (int16)Iw2DGetSurfaceHeight() >> 1);
CIwSVec2 pos = screenCentre + (CIwSVec2(int16(mCheckpoint.x*8), -int16(mCheckpoint.y*8)));
createEffect(CIwSVec2(pos.x, pos.y), 10, "Images/respawn.png", 1.0f);
}
if(mSpawnPickup == true) {
mLevel->createPickup(mPickupSpawnType, mPickupSpawnPoint.x, mPickupSpawnPoint.y);
mSpawnPickup = false;
}
if(!mPaused) {
mTimeTaken += g_deltaTime;
}
// Sync clients if multiplayer
if(mMultiplayer) {
// Packet rate modification
if(timeSinceLastSend >= 1000/30) {
pStream->writeInt(Constants::UPDATE);
// Dead reckoning
if( abs(mDRPlayer->getBody()->GetPosition().Length() - mPlayer->getBody()->GetPosition().Length()) >= 1 ) {
pStream->writeInt(Constants::DRUPDATE);
mPlayer->serialize(pStream);
mRDXVel = mPlayer->getBody()->GetLinearVelocity().x;
mDRPlayer->getBody()->SetTransform(mPlayer->getBody()->GetPosition(), 0.0f);
mDRPlayer->getBody()->SetLinearVelocity(b2Vec2(mRDXVel, mPlayer->getBody()->GetLinearVelocity().y));
}
else {
pStream->writeInt(Constants::UPDATE);
}
if(mHost) {
// Serialize level
mLevel->serialize(pStream);
}
pStream->writeChar('\0');
pStream->toCharArray(mMessageSent);
mMessageSent[strlen(mMessageSent)-1] = '\0';
//cout << "SENDING: " << mMessageSent << endl;
// Send data
s3eSocketSendTo(mSock, mMessageSent, strlen(mMessageSent), 0, &mDest_addr);
timeSinceLastSend = 0;
}
// Recieve data
mBytesRecieved = s3eSocketRecvFrom(mSock, mMessageReceived, sizeof(mMessageReceived), 0, &mDest_addr);
if(mBytesRecieved != -1) {
cout << "RECIEVING: " << mMessageReceived << endl;
pStream->fromCharArray(mMessageReceived);
int type;
pStream->readInt(type);
while (type) {
cout << "checking message types" << endl;
if(type == Constants::UPDATE) {
int updateType;
pStream->readInt(updateType);
if(updateType == Constants::DRUPDATE) {
mOtherPlayer->deserialize(pStream);
mRecRDXVel = mOtherPlayer->getBody()->GetLinearVelocity().x;
}
else {
if(!mHost) {
// Deserialize the level
mLevel->deserialize(pStream);
}
}
}
else if(type == Constants::DESTROY) {
int id;
pStream->readInt(id);
mLevel->killEnemy(id);
}
else if(type == Constants::DESTROYPICKUP) {
int id;
pStream->readInt(id);
mLevel->destroyPickup(id);
}
else if(type == Constants::CREATEPICKUP) {
int type, x, y, id;
pStream->readInt(type);
pStream->readInt(id); // Clients sends -1
pStream->readInt(x);
pStream->readInt(y);
mLevel->createPickup(type, x, y);
if(mHost) {
// Send create to peer
// Send Id of created pickup
PacketStream s;
s.writeInt(Constants::CREATEPICKUP);
s.writeInt(mLevel->getPickups().back()->getID());
s.writeInt(type);
s.writeFloat(x);
s.writeFloat(y);
s.writeChar('\0');
char message[10];
s.toCharArray(message);
message[strlen(message)-1] = '\0';
s3eSocketSendTo(mSock, message, strlen(message), 0, &mDest_addr);
}
else {
// Set id of pickup if client if client
mLevel->getPickups().back()->setID(id);
}
}
else if(type == Constants::CREATECRATE) {
int type, id;
float x, y;
//pStream->readInt(id);
pStream->readInt(type);
pStream->readFloat(x);
pStream->readFloat(y);
if(mHost) {
mLevel->createCrate(type, x, y);
crateSpawned = true;
PacketStream s;
s.writeInt(Constants::CREATECRATE);
//s.writeInt(mLevel->getCrates().back()->getID());
s.writeInt(type);
s.writeFloat(x);
s.writeFloat(y);
s.writeChar('\0');
char message[10];
s.toCharArray(message);
message[strlen(message)-1] = '\0';
//s3eSocketSendTo(mSock, message, strlen(message), 0, mDest_addr);
}
else {
mLevel->createCrate(type, x, y);
//mLevel->getCrates().back()->setID(id);
crateSpawned = true;
}
}
else if(type == Constants::TOGGLEPLATFORM) {
int id;
pStream->readInt(id);
mLevel->getActivatablePlatforms().at(id)->toggle();
}
else if(type == Constants::ACTION) {
int action;
pStream->readInt(action);
//Punch
if(action == 0) {
// Play punch animation
mOtherPlayer->punch();
vector<Enemy*> enemies = mLevel->getEnemies();
b2Body* player = mOtherPlayer->getBody();
for(int i = 0; i < enemies.size(); i++) {
if( abs((enemies.at(i)->getBody()->GetPosition() - player->GetPosition()).Length()) <= 10) {
short direction = 1;
if(enemies.at(i)->getBody()->GetPosition().x < player->GetPosition().x) {
direction = -1;
}
b2Vec2 force = b2Vec2(50000*direction, 0);
enemies.at(i)->getBody()->ApplyForce(force, enemies.at(i)->getBody()->GetWorldCenter());
enemies.at(i)->ApplyDamage(mOtherPlayer->getMeleeStr());
CIwSVec2 screenCentre = CIwSVec2((int16)Iw2DGetSurfaceWidth() >> 1, (int16)Iw2DGetSurfaceHeight() >> 1);
b2Transform t = enemies.at(i)->getBody()->GetTransform();
CIwSVec2 pos = screenCentre + (CIwSVec2(int16(t.p.x*8), -int16(t.p.y*8)));
createEffect(pos, 8 , "Images/blood.png", 1.0f);
}
}
}
//Kick
else if(action == 1) {
CCIntervalAction* getAction()
{
CCIntervalAction* pEffect = createEffect(actionIdx, 3);
return pEffect;
}
void StateBuffTrigger::execute(StateBase* parent)
{
auto battle = getBattleInfo();
if (this->stage != 1) {
BatSeqBuffTrigger* tg = new BatSeqBuffTrigger;
tg->buffId = buff->bid;
tg->petUid = buff->belongs.owner;
battle->pushSeq(shared_ptr<ISeq>(tg));
}
shared_ptr<FireBuff> fireInfo(new FireBuff);
assign(fireInfo.get(), buff, buff->keyBuff, 0);
fireInfo->parent = nullptr;
fireInfo->origin = battle->topSkill() != nullptr ? battle->topSkill().get() : nullptr;
battle->pushSkill(fireInfo);
for (auto subsk : buff->keyBuff->subs) {
fireInfo->targets = battle->getTargets(fireInfo->origin, buff->belongs.owner, subsk->target, subsk->parent.lock()->target);
for (int i=0; i<fireInfo->targets.size(); i++) {
if (this->stage == subsk->triggerStage) {
int dstuid = fireInfo->targets[i];
if (getBattleInfo()->allPets[dstuid]->isBating) {
assign(fireInfo.get(), buff, subsk.get(), dstuid);
createEffect(2, subsk->subEffId)->execute();
}
}
}
battle->checkDead(fireInfo->targets);
}
// 以次计算触发的每个效果
vector<Buff*> triggerSubBuff;
for (auto sub : buff->keyBuff->subs)
{
if (stage == sub->triggerStage) {
for (auto arg : sub->triggerParams) {
if (createTriggerCondi(buff->belongs.owner, sub->triggerCondi, arg)->isTrigger(stage, fireInfo->origin)) {
triggerSubBuff.push_back(sub.get());
break;
}
}
}
}
//
for (auto& it : triggerSubBuff)
{
assign(fireInfo.get(), buff, it, 0);
fireInfo->targets = battle->getTargets(fireInfo->origin, buff->belongs.owner, it->target, it->parent.lock()->target);
for (int i=0; i<fireInfo->targets.size(); i++) {
int dstuid = fireInfo->targets[i];
if (getBattleInfo()->allPets[dstuid]->isBating) {
assign(fireInfo.get(), buff, it, dstuid);
createEffect(2, it->subEffId)->execute();
}
}
}
battle->popSkill();
exitState();
}
bool MyApp::initialise(HINSTANCE hInstance, int cmdShow)
{
if (!DxApp::initialise(hInstance, cmdShow, 1024, 768))
return false;
// Build FXs
if (FAILED(buildFX())) {
MessageBox(hWnd(), L"Cannot create effects", L"Error", MB_OK|MB_ICONERROR);
return false;
}
// Build Geometry
if (FAILED(buildGeometry())) {
MessageBox(hWnd(), L"Cannot create geometry", L"Error", MB_OK|MB_ICONERROR);
return false;
}
// Textures
HRESULT hr = D3DX11CreateShaderResourceViewFromFileA(_dxDev, (PATH_MEDIA+string("noise_texture.jpg")).c_str(), 0, 0, &m_srvRandom, 0);
if (FAILED(hr)) {
MessageBoxA(0, "Error loading random texture", 0, 0);
return false;
}
// flags for heightmap texture
D3DX11_IMAGE_LOAD_INFO loadInfo;
loadInfo.Width = D3DX11_DEFAULT;
loadInfo.Height = D3DX11_DEFAULT;
loadInfo.Depth = D3DX11_DEFAULT;
loadInfo.FirstMipLevel = D3DX11_DEFAULT;
loadInfo.MipLevels = D3DX11_DEFAULT;
loadInfo.Usage = (D3D11_USAGE)D3DX11_DEFAULT;
loadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE | D3D11_BIND_RENDER_TARGET; //D3DX11_DEFAULT;
loadInfo.CpuAccessFlags = loadInfo.MiscFlags = D3DX11_DEFAULT;
loadInfo.Format = DXGI_FORMAT_R32G32B32A32_FLOAT ;
loadInfo.Filter = D3DX11_DEFAULT;
loadInfo.MipFilter = D3DX11_DEFAULT;
loadInfo.pSrcInfo = NULL;
hr = D3DX11CreateShaderResourceViewFromFileA(_dxDev, (PATH_MEDIA+string("heightmap.jpg")).c_str(), &loadInfo, 0, &m_srvTerrainHmap, 0);
if (FAILED(hr)) {
MessageBoxA(0, "Error loading terrain heightmap", 0, 0);
return false;
}
hr = D3DX11CreateShaderResourceViewFromFileA(_dxDev, (PATH_MEDIA+string("normalmap.bmp")).c_str(), 0, 0, &m_srvTerrainNmap, 0);
if (FAILED(hr)) {
MessageBoxA(0, "Error loading terrain normalmap", 0, 0);
return false;
}
hr = D3DX11CreateShaderResourceViewFromFileA(_dxDev, (PATH_MEDIA+string("space_ship.jpg")).c_str(), 0, 0, &m_srvSpaceship, 0);
if (FAILED(hr)) {
MessageBoxA(0, "Error loading spaceship texture", 0, 0);
return false;
}
// Dynamic terrain
ID3D11Resource* resHmap = 0;
m_srvTerrainHmap->GetResource(&resHmap);
D3D11_RENDER_TARGET_VIEW_DESC rtd;
rtd.Format = DXGI_FORMAT_R32G32B32A32_FLOAT ;
rtd.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtd.Texture2D.MipSlice = 0;
hr = _dxDev->CreateRenderTargetView(resHmap, &rtd, &m_rtvDynamicHmap);
if (FAILED(hr)) {
MessageBoxA(0, "Error creating hmap rtv", 0, 0);
return false;
}
////////////////////////////////////
//rs_Wireframe
D3D11_RASTERIZER_DESC rsd;
ZeroMemory(&rsd, sizeof(rsd));
rsd.FillMode = D3D11_FILL_WIREFRAME;
rsd.CullMode = D3D11_CULL_BACK;
rsd.DepthClipEnable = true;
hr = _dxDev->CreateRasterizerState(&rsd, &rs_Wireframe);
if (FAILED(hr))
MessageBoxA(0, "error creating rs Wireframe", 0, 0);
// Camera
m_camera.setProjection(0.7f, width()/(float)height(), 1.0f, 500.0f);
m_camera.setPosVector(0.0f, 30.0f, 0.0f);
m_camera.setRightVector(1.0f, 0.0f, 0.0f);
m_camera.setUpVector(0.0f, 1.0f, 0.0f);
m_camera.setLookVector(0.0f, 0.0f, 1.0f);
// myAlien
myAlien.setPos(0,5,0);
myAlien.type = AlienTypes::GS_ALIEN;
myAlien.mesh = alienMesh;
// Textures/Views for Implicit surfaces
if (!createImplicitResources())
return false;
// Tessellation - control point(s) buffer
//____ check for DX11 support__
if (dx11Support())
{
// Single control point vertex buffer
D3D11_BUFFER_DESC bdsc;
bdsc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bdsc.CPUAccessFlags = 0;
bdsc.MiscFlags = 0;
bdsc.StructureByteStride = 0;
bdsc.Usage = D3D11_USAGE_IMMUTABLE;
#ifdef _TESS_INDEX_BUFFER
// Version 2 : 6 vertices - W/ Index Buffer
const int numVertices = 6;
Vertex ctrl_point[numVertices];
bdsc.ByteWidth = sizeof(Vertex)*numVertices;
ZeroMemory(ctrl_point, sizeof(Vertex)*numVertices);
ctrl_point[0].position = XMFLOAT3( 0.0f, 1.0f, 0.0f); // top
ctrl_point[1].position = XMFLOAT3(-1.0f, 0.0f, 1.0f); // 1 ------> 2 (+,+)
ctrl_point[2].position = XMFLOAT3( 1.0f, 0.0f, 1.0f); //
ctrl_point[3].position = XMFLOAT3(-1.0f, 0.0f, -1.0f); //
ctrl_point[4].position = XMFLOAT3( 1.0f, 0.0f, -1.0f); // (-,-) 3 ------> 4
ctrl_point[5].position = XMFLOAT3( 0.0f, -1.0f, 0.0f); // bottom
UINT indices[24];
// top-front
indices[0] = 0; indices[1] = 4; indices[2] = 3;
// top-right
indices[3] = 0; indices[4] = 2; indices[5] = 4;
// top-left
indices[6] = 0; indices[7] = 3; indices[8] = 1;
// top-back
indices[9] = 0; indices[10] = 1; indices[11] = 2;
// bottom-front
indices[12] = 5; indices[13] = 3; indices[14] = 4;
// bottom-right
indices[15] = 5; indices[16] = 4; indices[17] = 2;
// bottom-left
indices[18] = 5; indices[19] = 1; indices[20] = 3;
// bottom-back
indices[21] = 5; indices[22] = 2; indices[23] = 1;
D3D11_BUFFER_DESC idsc;
idsc.BindFlags = D3D11_BIND_INDEX_BUFFER;
idsc.CPUAccessFlags = 0;
idsc.MiscFlags = 0;
idsc.StructureByteStride = 0;
idsc.Usage = D3D11_USAGE_IMMUTABLE;
idsc.ByteWidth = sizeof(UINT) * 24;
D3D11_SUBRESOURCE_DATA ibdata;
ibdata.pSysMem = indices;
ibdata.SysMemPitch = ibdata.SysMemSlicePitch = 0;
// create index buffer
hr = _dxDev->CreateBuffer(&idsc, &ibdata, &m_ibControlPoints);
#else
// Version 1 : 24 vertices - No Index Buffer
const int numVertices = 3*8; // triangle list - 8 triangles
Vertex ctrl_point[numVertices];
bdsc.ByteWidth = sizeof(Vertex) * numVertices; // three control points
ZeroMemory(ctrl_point, sizeof(Vertex)*numVertices); // octahedron
// CW
// top - front
ctrl_point[0].position = XMFLOAT3( 0.0f, 1.0f, 0.0f);
ctrl_point[1].position = XMFLOAT3( 1.0f, 0.0f, -1.0f);
ctrl_point[2].position = XMFLOAT3(-1.0f, 0.0f, -1.0f);
// top - right
ctrl_point[3].position = XMFLOAT3( 0.0f, 1.0f, 0.0f);
ctrl_point[4].position = XMFLOAT3( 1.0f, 0.0f, 1.0f);
ctrl_point[5].position = XMFLOAT3( 1.0f, 0.0f, -1.0f);
// top - left
ctrl_point[6].position = XMFLOAT3( 0.0f, 1.0f, 0.0f);
ctrl_point[7].position = XMFLOAT3(-1.0f, 0.0f, -1.0f);
ctrl_point[8].position = XMFLOAT3( -1.0f, 0.0f, 1.0f);
// top - back
ctrl_point[9].position = XMFLOAT3( 0.0f, 1.0f, 0.0f);
ctrl_point[10].position = XMFLOAT3(-1.0f, 0.0f, 1.0f);
ctrl_point[11].position = XMFLOAT3( 1.0f, 0.0f, 1.0f);
// bottom - front
ctrl_point[12].position = XMFLOAT3( 0.0f, -1.0f, 0.0f);
ctrl_point[13].position = XMFLOAT3(-1.0f, 0.0f, -1.0f);
ctrl_point[14].position = XMFLOAT3( 1.0f, 0.0f, -1.0f);
// bottom - right
ctrl_point[15].position = XMFLOAT3( 0.0f, -1.0f, 0.0f);
ctrl_point[16].position = XMFLOAT3( 1.0f, 0.0f, -1.0f);
ctrl_point[17].position = XMFLOAT3( 1.0f, 0.0f, 1.0f);
// bottom - left
ctrl_point[18].position = XMFLOAT3( 0.0f, -1.0f, 0.0f);
ctrl_point[19].position = XMFLOAT3(-1.0f, 0.0f, 1.0f);
ctrl_point[20].position = XMFLOAT3(-1.0f, 0.0f, -1.0f);
// bottom - back
ctrl_point[21].position = XMFLOAT3( 0.0f, -1.0f, 0.0f);
ctrl_point[22].position = XMFLOAT3( 1.0f, 0.0f, 1.0f);
ctrl_point[23].position = XMFLOAT3(-1.0f, 0.0f, 1.0f);
#endif
D3D11_SUBRESOURCE_DATA bdata;
bdata.pSysMem = ctrl_point;
bdata.SysMemPitch = bdata.SysMemSlicePitch = 0;
hr = _dxDev->CreateBuffer(&bdsc, &bdata, &m_vbControlPoints);
if (FAILED(hr)) {
MessageBoxA(0, "Error creating control points buffer", 0, 0);
return false;
}
// Bezier surface effect
if (!createEffect((PATH_SHADERS+string("tessBezierSurface.fxo")).c_str(), &m_fxTessBezierSurface))
MessageBoxA(0, "Error creating bezSurface effect", 0, 0);
// PSP surface effect
if (!createEffect((PATH_SHADERS+string("tessPSPSurface.fxo")).c_str(), &m_fxTessPSPSurface))
MessageBoxA(0, "Error creating pspSurface effect", 0, 0);
// Sphere effect
if (!createEffect((PATH_SHADERS+string("tessSphere.fxo")).c_str(), &m_fxTessSphere))
MessageBoxA(0, "Error creating tessSphere effect", 0, 0);
// Mesh effect
if (!createEffect((PATH_SHADERS+string("tessMesh.fxo")).c_str(), &m_fxTessMesh))
MessageBoxA(0, "Error creating tessMesh effect", 0, 0);
// Terrain effect
if (!createEffect((PATH_SHADERS+string("tessTerrain.fxo")).c_str(), &m_fxTessTerrain))
MessageBoxA(0, "Error creating tessMesh effect", 0, 0);
///____SINGLE_________
ZeroMemory(&bdsc, sizeof(bdsc));
bdsc.BindFlags = D3D11_BIND_VERTEX_BUFFER;
bdsc.ByteWidth = sizeof(Vertex);
bdsc.Usage = D3D11_USAGE_IMMUTABLE;
Vertex vSingle[1];
ZeroMemory(&vSingle, sizeof(vSingle));
ZeroMemory(&bdata, sizeof(bdata));
bdata.pSysMem = vSingle;
hr = _dxDev->CreateBuffer(&bdsc, &bdata, &m_vbSingle);
if (FAILED(hr)) MessageBoxA(0, "Error creating single VB", 0, 0);
if (!createEffect((PATH_SHADERS+string("tessSingle.fxo")).c_str(), &m_fxTessSingle))
MessageBoxA(0, "Error creating tessSingle effect", 0, 0);
//_____________________
}
mySphere.tessFactor = 5;
mySphere.radius = 10.0f;
setupScene();
// GUI
TwInit(TW_DIRECT3D11, _dxDev);
TwWindowSize(width(), height());
TwBar* myBar;
myBar = TwNewBar("myBar");
TwAddButton(myBar, "Play", callback_Play, (void*)this, 0);
TwAddButton(myBar, "Explode", callback_Explode, (void*)this, 0);
// __________GS Alien
TwAddVarRW(myBar, "Thorn length", TW_TYPE_FLOAT, &glb_fThornLength, "group=GS_Alien min=0.0 max=1.0 step=0.05");
// __________Selected Tessellated Object
// Partitioning
TwEnumVal twTessPartitioning[] = { { TessPartitioning::FRAC_EVEN, "Frac. Even" }, { TessPartitioning::FRAC_ODD, "Frac. Odd" },
{ TessPartitioning::INTEGER, "Integer" }, { TessPartitioning::POW2 , "Pow2" } };
TwType twTessPartition;
twTessPartition = TwDefineEnum("TessPartitioning", twTessPartitioning, 4);
TwAddVarRW(myBar, "Partitioning Method", twTessPartition, &glb_selectedTessPartitioning, "group=Tessellated_Objects");
// Wireframe
TwAddVarRW(myBar, "Wireframe", TW_TYPE_BOOL8, &glb_tessWireframe, "group=Tessellated_Objects");
// Inside Factor
TwAddVarRW(myBar, "Inside Factor", TW_TYPE_FLOAT, &glb_insideTess, "group=Tessellated_Objects min=1 max=64 step=1");
// Edge Factor
TwAddVarRW(myBar, "Edge Factor", TW_TYPE_FLOAT, &glb_edgeTess, "group=Tessellated_Objects min=1 max=64 step=1");
// Common inside/edge factor
TwAddVarRW(myBar, "Common Factor", TW_TYPE_FLOAT, &glb_SingleTessFactor, "group=Tessellated_Objects min=1 max=64 step=1");
TwAddVarRW(myBar, "Single Factor", TW_TYPE_BOOL8, &glb_bSingleTessFactor, "");
/////////////////////
TwAddVarRW(myBar, "Terrain Height", TW_TYPE_FLOAT, &glb_terrainHeight, "group=Terrain min=0.0 max=1.0 step=0.05");
TwAddVarRW(myBar, "Patches Dimension", TW_TYPE_INT32, &glb_terrainPatchDim, "group=Terrain min=1 max=10 step=1");
TwAddVarRW(myBar, "Min Tess. Factor", TW_TYPE_FLOAT, &glb_terrainMinTessFactor, "group=Terrain min=1 max=63 step=1");
TwAddVarRW(myBar, "Max Tess. Factor", TW_TYPE_FLOAT, &glb_terrainMaxTessFactor, "group=Terrain min=1 max=63 step=1");
TwAddVarRW(myBar, "Min View Dist", TW_TYPE_FLOAT, &glb_terrainMinViewDist, "group=Terrain min=0.0 max=300.0 step=1.05");
TwAddVarRW(myBar, "Max View Dist", TW_TYPE_FLOAT, &glb_terrainMaxViewDist, "group=Terrain min=0.0 max=300.0 step=1.05");
TwAddVarRW(myBar, "Debug View", TW_TYPE_BOOL8, &glb_bTerrainDebugView, "group=Terrain");
// Terrain Editing
TwAddVarRW(myBar, "Power", TW_TYPE_BOOL8, &glb_bOn, "group=Terrain_Edit");
TwAddVarRW(myBar, "Additive", TW_TYPE_BOOL8, &glb_bAdditive, "group=Terrain_Edit");
TwAddVarRW(myBar, "Range", TW_TYPE_FLOAT, &glb_Range, "group=Terrain_Edit min=0.0 max=1.0 step=0.05");
// Light
TwAddVarRW(myBar, "Light Direction", TW_TYPE_DIR3F, &glb_lightDir, "");
TwAddVarRW(myBar, "Light Color", TW_TYPE_COLOR4F, &glb_lightColor, "");
// Implicit Depth
TwAddVarRW(myBar, "Implicit Depth", TW_TYPE_INT32, &glb_iImplicitDepth, "group=Implicit min=1 max=3");
TwAddVarRW(myBar, "Wireframe Mode", TW_TYPE_BOOL8, &glb_bWireframe, "");
TwAddVarRW(myBar, "Sphere From Mesh", TW_TYPE_BOOL8, &glb_bSphereMesh, "");
return true;
}
