//------------------------------------------------------------- //------------------------------------------------------------- void Entity::AddComponent(const ComponentSPtr& in_component) { CS_ASSERT(in_component != nullptr, "Cannot add null component"); CS_ASSERT(in_component->GetEntity() == nullptr, "Component cannot be attached to more than 1 entity at a time."); m_components.push_back(in_component); in_component->SetEntity(this); in_component->OnAddedToEntity(); if(GetScene() != nullptr) { in_component->OnAddedToScene(); if (m_appActive == true) { in_component->OnResume(); if (m_appForegrounded == true) { in_component->OnForeground(); } } } }
//------------------------------------------------------------------------------ void GLMesh::BuildMesh(const u8* vertexData, u32 vertexDataSize, const u8* indexData, u32 indexDataSize) noexcept { CS_ASSERT(vertexDataSize > 0 && vertexData, "Cannot build mesh with empty data"); glGenBuffers(1, &m_vertexBufferHandle); CS_ASSERT(m_vertexBufferHandle != 0, "Invalid vertex buffer."); if(indexData) { glGenBuffers(1, &m_indexBufferHandle); CS_ASSERT(m_indexBufferHandle != 0, "Invalid index buffer."); } glBindBuffer(GL_ARRAY_BUFFER, m_vertexBufferHandle); glBufferData(GL_ARRAY_BUFFER, vertexDataSize, vertexData, GL_STATIC_DRAW); if(indexData) { glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_indexBufferHandle); glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexDataSize, indexData, GL_STATIC_DRAW); } CS_ASSERT_NOGLERROR("An OpenGL error occurred while creating GLMesh."); }
//---------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------- void StandardDrawable::Draw(Rendering::CanvasRenderer* in_renderer, const Core::Matrix3& in_transform, const Core::Vector2& in_absSize, const Core::Colour& in_absColour) { CS_ASSERT(m_texture != nullptr, "StandardDrawable cannot draw without texture"); //When textures are packed into an atlas their alpha space is cropped. This functionality restores the alpha space by resizing and offsetting the box. Core::Vector2 offsetTL ( (-m_atlasFrame.m_originalSize.x * 0.5f) + (m_atlasFrame.m_croppedSize.x * 0.5f) + m_atlasFrame.m_offset.x, (m_atlasFrame.m_originalSize.y * 0.5f) - (m_atlasFrame.m_croppedSize.y * 0.5f) - m_atlasFrame.m_offset.y ); offsetTL = in_absSize/m_atlasFrame.m_originalSize * offsetTL; Core::Vector2 size = in_absSize/m_atlasFrame.m_originalSize * m_atlasFrame.m_croppedSize; in_renderer->DrawBox(in_transform, size, offsetTL, m_texture, m_atlasFrame.m_uvs, in_absColour * m_colour, Rendering::AlignmentAnchor::k_middleCentre); }
SndSysSpeexSoundStream::SndSysSpeexSoundStream (csRef<SndSysSpeexSoundData> pData, csSndSysSoundFormat *pRenderFormat, int Mode3D) : SndSysBasicStream(pRenderFormat, Mode3D), m_pSoundData(pData), header(0) { // Allocate an advance buffer m_pCyclicBuffer = new SoundCyclicBuffer ( (m_RenderFormat.Bits/8 * m_RenderFormat.Channels) * (m_RenderFormat.Freq * SPEEX_BUFFER_LENGTH_MULTIPLIER / SPEEX_BUFFER_LENGTH_DIVISOR)); CS_ASSERT(m_pCyclicBuffer!=0); // Initialize speex stream. ResetPosition(false); }
csStringBase &csStringBase::Overwrite (size_t iPos, const csStringBase &iStr) { CS_ASSERT (iPos <= Size); if (GetData() == 0 || iPos == Size) return Append (iStr); size_t const sl = iStr.Length (); size_t const NewSize = iPos + sl; ExpandIfNeeded (NewSize); char* p = GetDataMutable(); // GLOBAL NOTE *2* memcpy (p + iPos, iStr.GetData (), sl + 1); // GLOBAL NOTE *1* Size = NewSize; return *this; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ Test::Test(const TestDesc& in_desc, const PassDelegate& in_passDelegate, const FailDelegate& in_failDelegate) noexcept : m_desc(in_desc), m_passDelegate(in_passDelegate), m_failDelegate(in_failDelegate) { CS_ASSERT(m_passDelegate, "A valid pass delegate must be supplied."); CS_ASSERT(m_failDelegate, "A valid fail delegate must be supplied."); m_taskScheduler = CS::Application::Get()->GetTaskScheduler(); m_timerEventConnection = m_timer.OpenConnection(in_desc.GetTimeoutSeconds(), [=]() { std::unique_lock<std::mutex> lock(m_mutex); if (m_active) { m_active = false; m_timer.Stop(); m_timerEventConnection.reset(); m_failDelegate("Timed out."); } }); m_timer.Start(); }
//------------------------------------------------------------------------------ bool BinaryInputStream::Read(u8* buffer, u64 length) noexcept { CS_ASSERT(IsValid(), "Trying to use an invalid FileStream."); if(m_fileStream.eof()) { return false; } //Ensure that we never overrun the file stream const auto currentPosition = GetReadPosition(); const auto maxValidLength = std::min(m_length - currentPosition, length); if(maxValidLength == 0) { return true; } m_fileStream.read(reinterpret_cast<s8*>(buffer), maxValidLength); CS_ASSERT(!m_fileStream.fail(), "Unexpected error occured in filestream"); return true; }
csStringBase &csStringBase::PadLeft (size_t iNewSize, char iChar) { if (iNewSize > Size) { ExpandIfNeeded (iNewSize); char* p = GetDataMutable(); // GLOBAL NOTE *2* CS_ASSERT(p != 0); const size_t toInsert = iNewSize - Size; memmove (p + toInsert, p, Size + 1); // GLOBAL NOTE *1* for (size_t x = 0; x < toInsert; x++) p [x] = iChar; Size = iNewSize; } return *this; }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ EntityUPtr PrimitiveEntityFactory::CreateBox(const Colour& in_colour, const Vector3& in_size) { CS_ASSERT(Application::Get()->GetTaskScheduler()->IsMainThread(), "Entities must be created on the main thread."); ModelCSPtr mesh = m_primitiveModelFactory->CreateBox(in_size); MaterialCSPtr material = CreateStaticBlinnColourMaterial(in_colour); StaticModelComponentSPtr meshComponent = m_renderComponentFactory->CreateStaticModelComponent(mesh, material); meshComponent->SetShadowCastingEnabled(true); auto entity = Entity::Create(); entity->SetName(ToString(m_entityCount++) + "-Box"); entity->AddComponent(meshComponent); return entity; }
//------------------------------------------------------------- //------------------------------------------------------------- void Entity::RemoveEntity(Entity* in_child) { CS_ASSERT(in_child != nullptr, "Cannot remove null child"); CS_ASSERT(in_child->GetParent() == this, "Cannot remove entity that is not a child of this"); SharedEntityList::iterator it = std::find_if(m_children.begin(), m_children.end(), [in_child](const EntitySPtr& in_entity) { return in_entity.get() == in_child; }); if(it != m_children.end()) { m_transform.RemoveChildTransform(&in_child->GetTransform()); if(m_scene != nullptr) { m_scene->Remove(in_child); } in_child->m_parent = nullptr; std::swap(m_children.back(), *it); m_children.pop_back(); } }
//------------------------------------------------ //------------------------------------------------ void PointerSystem::OnInit() { m_screen = ChilliSource::Application::Get()->GetSystem<ChilliSource::Screen>(); CS_ASSERT(m_screen != nullptr, "Cannot find system required by PointerSystem: Screen."); m_mouseButtonConnection = SFMLWindow::Get()->GetMouseButtonEvent().OpenConnection(ChilliSource::MakeDelegate(this, &PointerSystem::OnMouseButtonEvent)); m_mouseMovedConnection = SFMLWindow::Get()->GetMouseMovedEvent().OpenConnection(ChilliSource::MakeDelegate(this, &PointerSystem::OnMouseMoved)); m_mouseWheelConnection = SFMLWindow::Get()->GetMouseWheelEvent().OpenConnection(ChilliSource::MakeDelegate(this, &PointerSystem::OnMouseWheeled)); //create the mouse pointer ChilliSource::Integer2 mousePosi = SFMLWindow::Get()->GetMousePosition(); ChilliSource::Vector2 mousePos((f32)mousePosi.x, m_screen->GetResolution().y - (f32)mousePosi.y); m_pointerId = AddPointerCreateEvent(mousePos); }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ CSReporter::CSReporter(const Catch::ReporterConfig& in_config) noexcept : StreamingReporterBase(in_config) { CS_ASSERT(!m_config->includeSuccessfulResults(), "CSReporter doesn't support reporting successful results."); CS_ASSERT(!m_config->warnAboutMissingAssertions(), "CSReporter doesn't support warning about missing assertions."); CS_ASSERT(!m_config->showInvisibles(), "CSReporter doesn't support showing invisibles."); CS_ASSERT(!m_config->showDurations(), "CSReporter doesn't support showing durations."); CS_ASSERT(!m_config->useColour(), "CSReporter doesn't support coloured output."); CS_ASSERT(!m_config->shouldDebugBreak(), "CSReporter doesn't support debug break."); }
psMovementManager::psMovementManager(iEventNameRegistry* eventname_reg, psControlManager* controls) { CS_ASSERT(eventname_reg); event_frame = csevFrame(eventname_reg); event_mousemove = csevMouseMove(eventname_reg,0); actor = NULL; this->controls = controls; ready = false; psengine->GetMsgHandler()->Subscribe(this,MSGTYPE_MOVEINFO); psengine->GetMsgHandler()->Subscribe(this,MSGTYPE_MOVELOCK); psengine->GetMsgHandler()->Subscribe(this,MSGTYPE_MOVEMOD); defaultmode = NULL; actormode = NULL; onGround = true; locked = false; activeMoves = 0; autoMove = false; toggleRun = false; mouseAutoMove = false; mouseLook = false; mouseLookCanAct = false; mouseZoom = false; mouseMove = false; sneaking = false; runToMarkerID = 0; lastDist = 0.0f; runToDiff = csVector3(0.0f); lastDeltaX = 0.0f; lastDeltaY = 0.0f; sensY = 1.0f; sensX = 1.0f; invertedMouse = true; activeModType = psMoveModMsg::NONE; forward = NULL; backward = NULL; run = NULL; walk = NULL; kbdRotate = 0; }
// Note: isalpha(int c), toupper(int c), tolower(int c), isspace(int c) // If c is not an unsigned char value, or EOF, the behaviour of these functions // is undefined. csStringBase &csStringBase::RTrim() { if (Size > 0) { char const* const p = GetData(); CS_ASSERT(p != 0); const char* c; for (c = p + Size - 1; c != p; c--) if (!isspace ((unsigned char)*c)) break; size_t i = c - p; if (i < Size - 1) Truncate(i + 1); } return *this; }
csStringBase &csStringBase::Insert (size_t iPos, const char* str) { CS_ASSERT(iPos <= Size); if (GetData() == 0 || iPos == Size) return Append (str); size_t const sl = strlen (str); size_t const NewSize = sl + Size; ExpandIfNeeded (NewSize); char* p = GetDataMutable(); // GLOBAL NOTE *2* memmove (p + iPos + sl, p + iPos, Size - iPos + 1); // GLOBAL NOTE *1* memcpy (p + iPos, str, sl); Size = NewSize; return *this; }
//------------------------------------------------------------------------------------ //------------------------------------------------------------------------------------ void ResourcePool::AddProvider(ResourceProvider* in_provider) { CS_ASSERT(in_provider != nullptr, "Cannot add null resource provider to pool"); auto itDescriptor = m_descriptors.find(in_provider->GetResourceType()); if(itDescriptor == m_descriptors.end()) { PoolDesc desc; desc.m_providers.push_back(in_provider); m_descriptors.insert(std::make_pair(in_provider->GetResourceType(), desc)); } else { itDescriptor->second.m_providers.push_back(in_provider); } }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ std::string CreateSTDStringFromJString(jstring in_jString) { if (in_jString == nullptr) { return ""; } auto environment = JavaVirtualMachine::Get()->GetJNIEnvironment(); const char * cString = environment->GetStringUTFChars(in_jString, JNI_FALSE); CS_ASSERT(cString != nullptr, "String returned from GetStringUTFChars() cannot be null."); std::string output = std::string(cString); environment->ReleaseStringUTFChars(in_jString, cString); return output; }
//------------------------------------------------------- //------------------------------------------------------- void TextEntry::Deactivate() { CS_ASSERT(ChilliSource::Application::Get()->GetTaskScheduler()->IsMainThread(), "Cannot deactivate system text entry outside of main thread."); if (m_enabled == true) { m_textEntryJI->Deactivate(); m_enabled = false; if(m_textInputDeactivatedDelegate != nullptr) { auto delegate = m_textInputDeactivatedDelegate; m_textInputDeactivatedDelegate = nullptr; delegate(); } } }
bool dbRecord::Execute(uint32 uid) { SetID(uid); CS_ASSERT_MSG("Error: wrong number of expected fields", index == count); if(!prepared) Prepare(); psStopWatch timer; timer.Start(); CS_ASSERT(count != index); csStringArray paramStrings; const char *paramValues[index]; for(unsigned int i = 0; i < index; i++) { csString value; switch(temp[i].type) { case SQL_TYPE_FLOAT: value.Format("%f", temp[i].fValue); break; case SQL_TYPE_INT: value.Format("%i", temp[i].iValue); break; case SQL_TYPE_STRING: value = temp[i].sValue; break; case SQL_TYPE_NULL: break; } paramStrings.Push(value); paramValues[i] = paramStrings.Get(i); } PGresult *res = PQexecPrepared(conn, stmt.GetData(), index, paramValues, NULL, NULL,0); bool result = (res && PQresultStatus(res) != PGRES_FATAL_ERROR); if(result && timer.Stop() > 1000) { csString status; status.Format("SQL query in file %s line %d, has taken %u time to process.\n", file, line, timer.Stop()); if(logcsv) logcsv->Write(CSV_STATUS, status); } return result; }
bool Client::IsAllowedToAttack(gemObject * target, bool inform) { csString msg; int type = GetTargetType(target); if (type == TARGET_NONE) msg = "You must select a target to attack."; else if (type & TARGET_ITEM) msg = "You can't attack an inanimate object."; else if (type & TARGET_DEAD) msg = "%s is already dead."; else if (type & TARGET_FOE) { gemActor* foe = target->GetActorPtr(); gemActor* attacker = GetActor(); CS_ASSERT(foe != NULL); // Since this is a foe it should have a actor. gemActor* lastAttacker = NULL; if (target->HasKillStealProtection() && !foe->CanBeAttackedBy(attacker, &lastAttacker)) { if (lastAttacker) { msg.Format("You must be grouped with %s to attack %s.", lastAttacker->GetName(), foe->GetName()); } else { msg = "You are not allowed to attack right now."; } } } else if (type & TARGET_FRIEND) msg = "You cannot attack %s."; else if (type & TARGET_SELF) msg = "You cannot attack yourself."; if (!msg.IsEmpty()) { if (inform) { psserver->SendSystemError(clientnum, msg, target? target->GetName(): ""); } return false; } return true; }
bool pawsShortcutWindow::OnFingering(csString string, psControl::Device device, uint button, uint32 mods) { pawsFingeringWindow* fingWnd = dynamic_cast<pawsFingeringWindow*>(PawsManager::GetSingleton().FindWidget("FingeringWindow")); if (fingWnd == NULL || !fingWnd->IsVisible()) return true; csString editedCmd; editedCmd.Format("Shortcut %d",edit+1); bool changed = false; if (string == NO_BIND) // Removing trigger { psengine->GetCharControl()->RemapTrigger(editedCmd,psControl::NONE,0,0); changed = true; } else // Changing trigger { changed = psengine->GetCharControl()->RemapTrigger(editedCmd,device,button,mods); } if (changed) { shortcutText->SetText(GetTriggerText(edit)); return true; // Hide fingering window } else // Map already exists { const psControl* other = psengine->GetCharControl()->GetMappedTrigger(device,button,mods); CS_ASSERT(other); csString name = GetDisplayName(other->name); if (name.IsEmpty()) //then not cleaned up properly from deleting a shortcut { name = other->name; //use its numeric name } else { name.AppendFmt(" (%s)", other->name.GetDataSafe()); } fingWnd->SetCollisionInfo(name); return false; } }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ std::string CreateSTDStringFromJByteArray(jbyteArray in_array, u32 in_length) { if (in_array == nullptr || in_length == 0) { return ""; } auto environment = JavaVirtualMachine::Get()->GetJNIEnvironment(); jbyte* bytes = environment->GetByteArrayElements(in_array, JNI_FALSE); CS_ASSERT(bytes != nullptr, "Bytes returned by GetByteArrayElements() cannot be null."); std::string strOutput((const char*)bytes, in_length); environment->ReleaseByteArrayElements(in_array, bytes, 0); return strOutput; }
void csMeshGenerator::SelfDestruct () { if (GetSector ()) { size_t c = GetSector ()->GetMeshGeneratorCount (); while (c > 0) { c--; if (GetSector ()->GetMeshGenerator (c) == (iMeshGenerator*)this) { GetSector ()->RemoveMeshGenerator (c); return; } } CS_ASSERT (false); } }
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------ VListLayoutDef::VListLayoutDef(const Json::Value& in_json) { const char k_typeKey[] = "Type"; const char k_numCellsKey[] = "NumCells"; const char k_relativeMarginsKey[] = "RelMargins"; const char k_absoluteMarginsKey[] = "AbsMargins"; const char k_relativeSpacingKey[] = "RelSpacing"; const char k_absoluteSpacingKey[] = "AbsSpacing"; for(auto it = in_json.begin(); it != in_json.end(); ++it) { CS_ASSERT((*it).isString() == true, "All properties in a Layout Description must be a string: " + std::string(it.memberName())); std::string key = it.memberName(); std::string value = (*it).asString(); if (key == k_relativeMarginsKey) { m_relativeMargins = Core::ParseVector4(value); } else if (key == k_absoluteMarginsKey) { m_absoluteMargins = Core::ParseVector4(value); } else if (key == k_numCellsKey) { m_numCells = Core::ParseU32(value); } else if (key == k_relativeSpacingKey) { m_relativeSpacing = Core::ParseF32(value); } else if (key == k_absoluteSpacingKey) { m_absoluteSpacing = Core::ParseF32(value); } else if (key == k_typeKey) { //ignore } else { CS_LOG_FATAL("Invalid property found in a List layout description: " + key); } } }
//------------------------------------------- //------------------------------------------- void ParticleSystem::RemoveParticleComponent(ParticleComponent* in_particle) { CS_ASSERT(in_particle != nullptr, "Cannot remove null particle"); u32 numParticles = m_particleComponents.size(); for(u32 i=0; i<numParticles; ++i) { if(m_particleComponents[i] == in_particle) { //Swap and pop m_particleComponents[i]->SetOwningSystem(nullptr); m_particleComponents[i] = m_particleComponents.back(); m_particleComponents.pop_back(); return; } } }
//----------------------------------------------------- void BackButtonSystem::OnDeviceButtonPressed(const CS::DeviceButtonSystem::DeviceButton& buttonPressed) noexcept { if (buttonPressed == CS::DeviceButtonSystem::DeviceButton::k_backButton) { auto stateManager = CS::Application::Get()->GetStateManager(); CS_ASSERT(stateManager, "No state manager active."); if (stateManager->GetNumStates() > 1) { stateManager->Pop(); } else { CS::Application::Get()->Quit(); } } }
//------------------------------------------------------------------------------ GLuint GLTextureUnitManager::BindAdditional(const ChilliSource::RenderTexture* texture) noexcept { GLuint textureIndex = GetNextAvailableUnit(); m_boundTextures.push_back(texture); auto glTexture = static_cast<GLTexture*>(texture->GetExtraData()); CS_ASSERT(glTexture, "Cannot bind a texture which hasn't been loaded."); glActiveTexture(GL_TEXTURE0 + textureIndex); glBindTexture(GL_TEXTURE_2D, glTexture->GetHandle()); glActiveTexture(GL_TEXTURE0); CS_ASSERT_NOGLERROR("An OpenGL error occurred while binding an additional texture."); return textureIndex; }
csRef<iDocument> ParseString(const csString & str, bool notify) { csRef<iDocumentSystem> xml; xml.AttachNew(new csTinyDocumentSystem); CS_ASSERT(xml != NULL); csRef<iDocument> doc = xml->CreateDocument(); const char* error = doc->Parse(str); if (error) { if (notify) { Error3("Error in XML: %s\nString was: %s", error, str.GetDataSafe()); } return NULL; } return doc; }
//---------------------------------------------------- //---------------------------------------------------- void ToCSV(const std::vector<std::string>& in_values, std::string& out_csv) { if(in_values.empty()) return; CS_ASSERT(in_values.size() < static_cast<std::size_t>(std::numeric_limits<u32>::max()), "Too many CSV items. It cannot exceed " + Core::ToString(std::numeric_limits<u32>::max()) + "."); u32 numVals = static_cast<u32>(in_values.size()) - 1; for(u32 i=0; i<numVals; ++i) { out_csv += in_values[i]; out_csv += ","; } //Add the last one without a following comma out_csv += in_values[numVals]; }
csStringBase &csStringBase::Append (const char *iStr, size_t iCount) { /* Since "" is not the same as 0, make an empty string if a non-null empty string is appended to a 0 string. */ if (iStr == 0 || ((iCount == 0) && (Size != 0))) return *this; if (iCount == (size_t)-1) iCount = strlen (iStr); size_t const NewSize = Size + iCount; ExpandIfNeeded (NewSize); char* p = GetDataMutable(); // GLOBAL NOTE *2* CS_ASSERT(p != 0); memcpy (p + Size, iStr, iCount); Size = NewSize; p [Size] = '\0'; return *this; }