int Player::openSong(std::string songName) { //close current song if there is currently one loaded if (m_songLoaded) { (void) ErrorCheck(m_channel->stop()); (void) ErrorCheck(m_song->release()); } //Open the song as a stream m_result = m_system->createStream(songName.c_str(), FMOD_DEFAULT, 0, &m_song); m_error = ErrorCheck(m_result); if (!m_error) { //assign a channel to the song and play it upon open m_result = m_system->playSound(m_song, NULL, false, &m_channel); m_error = ErrorCheck(m_result); } //check for errors and return accordingly if (m_error) { m_songLoaded = false; return OPEN_FAILURE; } else { m_channel->setLoopCount(0); m_songLoaded = true; return OPEN_SUCCESS; } }
void FMOD_System::CreateSounds( const SoundFilenameMap& soundFilenames ) { auto isPresent = [=]( const std::string& key ) -> bool { return ( soundFilenames.find( key ) != soundFilenames.end() ) ? true : false; }; if( isPresent( "bgmusic" ) ) { ErrorCheck( system->createStream( soundFilenames.at("bgmusic").c_str(), FMOD_LOOP_NORMAL | FMOD_CREATESTREAM, nullptr, &bgmusic ) ); bgmusic->setDefaults( 44100, 0.025f, 0.f, 128 ); } if( isPresent( "jet" ) ) { ErrorCheck( system->createSound( soundFilenames.at( "jet" ).c_str(), FMOD_3D, nullptr, &jet ) ); jet->setDefaults( 44100, 0.75f, 0.f, 128 ); } if( isPresent( "vent" ) ) { ErrorCheck( system->createSound( soundFilenames.at( "vent" ).c_str(), FMOD_3D | FMOD_LOOP_NORMAL, nullptr, &ventSound ) ); ventSound->setDefaults( 44100, 0.3f, 0.f, 128 ); } if( isPresent( "collision" ) ) { ErrorCheck( system->createSound( soundFilenames.at( "collision" ).c_str(), FMOD_3D, nullptr, &collision ) ); collision->setDefaults( 44100, 5.f, 0.f, 128 ); } if( isPresent( "roll" ) ) { ErrorCheck( system->createSound( soundFilenames.at( "roll" ).c_str(), FMOD_3D, nullptr, &roll ) ); roll->setDefaults( 44100, 2.f, 0.f, 128 ); } }
// This function prompts user to input searchInt based on search type int GetSearchInt(int& choice) { int searchInt; // IN & OUT & CALC - int to searched, input // by user searchInt = 0; // Initialize searchInt to 0 // Will prompt user to input searchInt based on menu choice switch(choice) { case YEARSEARCH: cout << "\nWhich year are you looking for? "; searchInt = ErrorCheck(1878, 3000); cout << "\nSearching for the year " << searchInt << endl; break; case RATINGSEARCH: cout << "\nWhich rating are you looking for? "; searchInt = ErrorCheck(0, 9); cout << "\nSearching for the rating " << searchInt << endl; break; default: cout << "\nYou shouldn't have done that.\n"; break; } // Returns int to be searched return searchInt; }
bool AudioSystem::Load2DSound(const string& filepath, FMOD::Sound** sound){ FMOD_RESULT result = m_system->createSound(filepath.c_str(), FMOD_2D, 0, &*sound); if (!ErrorCheck(result)) return false; result = (*sound)->setMode(FMOD_LOOP_OFF); if (!ErrorCheck(result)) return false; return true; }
void Renderer::createBuffer(VkDeviceSize size, VkBufferUsageFlags usage, VkMemoryPropertyFlags memory_properties, VkBuffer & buffer, VkDeviceMemory & buffer_memory) { VkBufferCreateInfo buffer_create_info{}; buffer_create_info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO; buffer_create_info.size = size; buffer_create_info.usage = usage; buffer_create_info.sharingMode = VK_SHARING_MODE_EXCLUSIVE; ErrorCheck(vkCreateBuffer(_device, &buffer_create_info, nullptr, &buffer)); VkMemoryRequirements mem_requirements{}; vkGetBufferMemoryRequirements(_device, buffer, &mem_requirements); uint32_t type_filter = mem_requirements.memoryTypeBits; uint32_t memory_type; for (uint32_t i = 0; i < _gpu_memory_properties.memoryTypeCount; i++) { if ((type_filter & (1 << i)) && (_gpu_memory_properties.memoryTypes[i].propertyFlags & memory_properties) == memory_properties) { memory_type = i; break; } } VkMemoryAllocateInfo memory_allocate_info{}; memory_allocate_info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO; memory_allocate_info.allocationSize = mem_requirements.size; memory_allocate_info.memoryTypeIndex = memory_type; ErrorCheck(vkAllocateMemory(_device, &memory_allocate_info, nullptr, &buffer_memory)); ErrorCheck(vkBindBufferMemory(_device, buffer, buffer_memory, 0)); }
int SoundManager::Play3D(string Name, SoundType Type, XMFLOAT3 Position, bool Loop) { if(!Exists(Name)) { DebugScreen::GetInstance()->AddLogMessage("Sound: \"" + Name + "\" does not exist.", Red); return -1; } if(Loop) gSoundIterator->second.second->setMode(FMOD_LOOP_NORMAL); ErrorCheck(gSystem->playSound(FMOD_CHANNEL_FREE, gSoundIterator->second.second, true, &gChannel)); ErrorCheck(gChannel->setPaused(false)); switch(Type) { case Song: gChannel->setVolume( gMusicVolume * gMasterVolume ); break; case SFX: gChannel->setVolume( gEffectVolume * gMasterVolume ); break; } FMOD_VECTOR tVelocity = {0, 0, 0}; gResult = gChannel->set3DAttributes(&gListenerPosition, &tVelocity); ErrorCheck(gResult); gPlayingSounds->push_back(new PlayingSound(PSIndex( gUniqueIndex, Name ), PSEntry( Type, gChannel ))); ++gUniqueIndex; return gUniqueIndex - 1; }
void Window::_InitSwapchainImages() { _swapchain_images.resize( _swapchain_image_count ); _swapchain_image_views.resize( _swapchain_image_count ); ErrorCheck( vkGetSwapchainImagesKHR( _renderer->GetVulkanDevice(), _swapchain, &_swapchain_image_count, _swapchain_images.data() ) ); for( uint32_t i=0; i < _swapchain_image_count; ++i ) { VkImageViewCreateInfo image_view_create_info {}; image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO; image_view_create_info.image = _swapchain_images[ i ]; image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D; image_view_create_info.format = _surface_format.format; image_view_create_info.components.r = VK_COMPONENT_SWIZZLE_IDENTITY; image_view_create_info.components.g = VK_COMPONENT_SWIZZLE_IDENTITY; image_view_create_info.components.b = VK_COMPONENT_SWIZZLE_IDENTITY; image_view_create_info.components.a = VK_COMPONENT_SWIZZLE_IDENTITY; image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; image_view_create_info.subresourceRange.baseMipLevel = 0; image_view_create_info.subresourceRange.levelCount = 1; image_view_create_info.subresourceRange.baseArrayLayer = 0; image_view_create_info.subresourceRange.layerCount = 1; ErrorCheck( vkCreateImageView( _renderer->GetVulkanDevice(), &image_view_create_info, nullptr, &_swapchain_image_views[ i ] ) ); } }
/*********************************************************************** * * Function: sync_MergeFromPilot_fast * * Summary: er, fast merge from Palm to desktop * * Parameters: None * * Returns: 0 if success, nonzero otherwise * ***********************************************************************/ static int sync_MergeFromPilot_fast(SyncHandler * sh, int dbhandle, RecordModifier rec_mod) { int result = 0; PilotRecord *precord = sync_NewPilotRecord(DLP_BUF_SIZE); DesktopRecord *drecord = NULL; RecordQueue rq = { 0, NULL }; pi_buffer_t *recbuf = pi_buffer_new(DLP_BUF_SIZE); while (dlp_ReadNextModifiedRec(sh->sd, dbhandle, recbuf, &precord->recID, NULL, &precord->flags, &precord->catID) >= 0) { int count = rq.count; precord->len = recbuf->used; if (precord->len > DLP_BUF_SIZE) precord->len = DLP_BUF_SIZE; memcpy(precord->buffer, recbuf->data, precord->len); ErrorCheck(sh->Match(sh, precord, &drecord)); ErrorCheck(sync_record (sh, dbhandle, drecord, precord, &rq, rec_mod)); if (drecord && rq.count == count) ErrorCheck(sh->FreeMatch(sh, drecord)); } pi_buffer_free(recbuf); sync_FreePilotRecord(precord); result = sync_MergeFromPilot_process(sh, dbhandle, &rq, rec_mod); return result; }
void AudioSystem::Play3DSound(FMOD::Sound* sound, const FMOD_VECTOR& position, FMOD::Channel** channel){ FMOD_RESULT result = m_system->playSound(FMOD_CHANNEL_FREE, sound, true, &*channel); ErrorCheck(result); result = (*channel)->set3DAttributes(&position, 0); ErrorCheck(result); result = (*channel)->setPaused(false); ErrorCheck(result); }
AudioClip::AudioClip(const string& filename, bool streamed) : m_channel(0), m_playing(false), m_paused(false), m_looping(false), m_volume(1.0f) { if (!streamed) ErrorCheck(Audio::AudioSystem().createSound(filename.c_str(), FMOD_DEFAULT, 0, &m_sound)); else ErrorCheck(Audio::AudioSystem().createStream(filename.c_str(), FMOD_DEFAULT, 0, &m_sound)); }
void AudioSystem::Shut(){ if (m_system != nullptr){ FMOD_RESULT result; result = m_system->close(); ErrorCheck(result); result = m_system->release(); ErrorCheck(result); } }
void Summerface::AddWindow (const std::string& aName, SummerfaceWindow_Ptr aWindow) { ErrorCheck(aWindow, "Summerface::AddWindow: Window is not a valid pointer. [Name: %s]", aName.c_str()); ErrorCheck(Windows.find(aName) == Windows.end(), "Summerface::AddWindow: Window with name is already present. [Name: %s]", aName.c_str()); Windows[aName] = aWindow; aWindow->SetInterface(shared_from_this(), aName); ActiveWindow = aName; }
bool AudioSystem::Load3DSound(const string& filepath, FMOD::Sound** sound){ FMOD_RESULT result = m_system->createSound(filepath.c_str(), FMOD_3D, 0, &*sound); if (!ErrorCheck(result)) return false; result = (*sound)->set3DMinMaxDistance(0.5f * m_distance_factor, 8.0f * m_distance_factor); if (!ErrorCheck(result)) return false; result = (*sound)->setMode(FMOD_LOOP_OFF); if (!ErrorCheck(result)) return false; return true; }
bool AudioFMOD::Load(FMOD::Studio::Bank*& bank, const std::string & path) { Trace("Loading '" + path + "'"); // Load the bank into the sound system if (!ErrorCheck(System->loadBankFile(path.c_str(), FMOD_STUDIO_LOAD_BANK_NORMAL, &bank))) return false; // Now that the bank is finished loading, load its sample data ErrorCheck(bank->loadSampleData()); return true; }
void AudioFMOD::Initialize() { Trace("Initializing Low Level and Studio system objects... "); // Create the Low Level System ErrorCheck(FMOD::System_Create(&System.LowLevel)); // Create the Studio System ErrorCheck(System->create(&System.Studio)); // Set FMOD low level studio pointer ErrorCheck(System->getLowLevelSystem(&System.LowLevel)); // Initialize it unsigned maxChannels = 36; ErrorCheck(System->initialize(maxChannels, FMOD_STUDIO_INIT_NORMAL, FMOD_INIT_NORMAL, nullptr)); }
void Renderer::_EndSingleTimeCommands(VkCommandPool pool, VkCommandBuffer commandBuffer) { ErrorCheck(vkEndCommandBuffer(commandBuffer)); VkSubmitInfo submit_info {}; submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO; submit_info.commandBufferCount = 1; submit_info.pCommandBuffers = &commandBuffer; ErrorCheck(vkQueueSubmit(_queue, 1, &submit_info, VK_NULL_HANDLE)); ErrorCheck(vkQueueWaitIdle(_queue)); vkFreeCommandBuffers(_device, pool, 1, &commandBuffer); }
void Window::_InitSwapchain() { // This code is old and the fixed one is below // if( _swapchain_image_count > _surface_capabilities.maxImageCount ) _swapchain_image_count = _surface_capabilities.maxImageCount; // if( _swapchain_image_count < _surface_capabilities.minImageCount + 1 ) _swapchain_image_count = _surface_capabilities.minImageCount + 1; // The code above will work just fine in our tutorials and likely on every possible implementation of vulkan as well // so this change isn't that important. Just to be absolutely sure we don't go over or below the given limits we should check this a // little bit different though. maxImageCount can actually be zero in which case the amount of swapchain images do not have an // upper limit other than available memory. It's also possible that the swapchain image amount is locked to a certain // value on certain systems. The code below takes into consideration both of these possibilities. if( _swapchain_image_count < _surface_capabilities.minImageCount + 1 ) _swapchain_image_count = _surface_capabilities.minImageCount + 1; if( _surface_capabilities.maxImageCount > 0 ) { if( _swapchain_image_count > _surface_capabilities.maxImageCount ) _swapchain_image_count = _surface_capabilities.maxImageCount; } VkPresentModeKHR present_mode = VK_PRESENT_MODE_FIFO_KHR; { uint32_t present_mode_count = 0; ErrorCheck( vkGetPhysicalDeviceSurfacePresentModesKHR( _renderer->GetVulkanPhysicalDevice(), _surface, &present_mode_count, nullptr ) ); std::vector<VkPresentModeKHR> present_mode_list( present_mode_count ); ErrorCheck( vkGetPhysicalDeviceSurfacePresentModesKHR( _renderer->GetVulkanPhysicalDevice(), _surface, &present_mode_count, present_mode_list.data() ) ); for( auto m : present_mode_list ) { if( m == VK_PRESENT_MODE_MAILBOX_KHR ) present_mode = m; } } VkSwapchainCreateInfoKHR swapchain_create_info {}; swapchain_create_info.sType = VK_STRUCTURE_TYPE_SWAPCHAIN_CREATE_INFO_KHR; swapchain_create_info.surface = _surface; swapchain_create_info.minImageCount = _swapchain_image_count; swapchain_create_info.imageFormat = _surface_format.format; swapchain_create_info.imageColorSpace = _surface_format.colorSpace; swapchain_create_info.imageExtent.width = _surface_size_x; swapchain_create_info.imageExtent.height = _surface_size_y; swapchain_create_info.imageArrayLayers = 1; swapchain_create_info.imageUsage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT; swapchain_create_info.imageSharingMode = VK_SHARING_MODE_EXCLUSIVE; swapchain_create_info.queueFamilyIndexCount = 0; swapchain_create_info.pQueueFamilyIndices = nullptr; swapchain_create_info.preTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; swapchain_create_info.compositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR; swapchain_create_info.presentMode = present_mode; swapchain_create_info.clipped = VK_TRUE; swapchain_create_info.oldSwapchain = VK_NULL_HANDLE; ErrorCheck( vkCreateSwapchainKHR( _renderer->GetVulkanDevice(), &swapchain_create_info, nullptr, &_swapchain ) ); ErrorCheck( vkGetSwapchainImagesKHR( _renderer->GetVulkanDevice(), _swapchain, &_swapchain_image_count, nullptr ) ); }
void OpenCLBase::GetPlatformInfo(cl_platform_id id) { // size_t length; cl_int errorCode; errorCode = clGetPlatformInfo(id, CL_PLATFORM_PROFILE, 0, NULL, &length); ErrorCheck("clGetPlatformInfo", errorCode); char* param = reinterpret_cast<char*>(malloc(length * sizeof(char))); errorCode = clGetPlatformInfo(id, CL_PLATFORM_PROFILE, length, param, NULL); ErrorCheck("clGetPlatformInfo", errorCode); cout << param << endl; free(param); }
void Renderer::_InitRenderPass() { VkAttachmentDescription color_attachment {}; color_attachment.format = _window->getSurfaceFormat().format; color_attachment.samples = VK_SAMPLE_COUNT_1_BIT; color_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; color_attachment.storeOp = VK_ATTACHMENT_STORE_OP_STORE; color_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; color_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; color_attachment.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED; color_attachment.finalLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR; VkAttachmentDescription depth_attachment {}; depth_attachment.format = findSupportedFormat( { VK_FORMAT_D32_SFLOAT, VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT }, VK_IMAGE_TILING_OPTIMAL, VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT ); depth_attachment.samples = VK_SAMPLE_COUNT_1_BIT; depth_attachment.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR; depth_attachment.storeOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; depth_attachment.stencilLoadOp = VK_ATTACHMENT_LOAD_OP_DONT_CARE; depth_attachment.stencilStoreOp = VK_ATTACHMENT_STORE_OP_DONT_CARE; depth_attachment.initialLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; depth_attachment.finalLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; VkAttachmentReference color_attachment_reference {}; color_attachment_reference.attachment = 0; color_attachment_reference.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL; VkAttachmentReference depth_attachment_reference {}; depth_attachment_reference.attachment = 1; depth_attachment_reference.layout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL; VkSubpassDescription subpass{}; subpass.pipelineBindPoint = VK_PIPELINE_BIND_POINT_GRAPHICS; subpass.colorAttachmentCount = 1; subpass.pColorAttachments = &color_attachment_reference; subpass.pDepthStencilAttachment = &depth_attachment_reference; VkSubpassDependency dependency {}; dependency.srcSubpass = VK_SUBPASS_EXTERNAL; dependency.dstSubpass = 0; dependency.srcStageMask = VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT; dependency.srcAccessMask = VK_ACCESS_MEMORY_READ_BIT; dependency.dstStageMask = VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT; dependency.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT; std::array<VkAttachmentDescription, 2> attachments = { color_attachment, depth_attachment }; VkRenderPassCreateInfo render_pass_create_info {}; render_pass_create_info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO; render_pass_create_info.attachmentCount = (uint32_t)attachments.size(); render_pass_create_info.pAttachments = attachments.data(); render_pass_create_info.subpassCount = 1; render_pass_create_info.pSubpasses = &subpass; render_pass_create_info.dependencyCount = 1; render_pass_create_info.pDependencies = &dependency; ErrorCheck(vkCreateRenderPass(_device, &render_pass_create_info, nullptr, &_render_pass)); }
void SoundManager::Stop(int Index) { for(int i = gPlayingSounds->size() - 1; i >= 0; --i) { PlayingSound* tSound = gPlayingSounds->at(i); bool tPlaying = false; if ( tSound->first.first == Index) { PSEntry tEntry = tSound->second; ErrorCheck( tEntry.second->isPlaying( &tPlaying ) ); if(tPlaying) { gPlayingSounds->erase(gPlayingSounds->begin() + i); tEntry.second->stop(); delete tSound; return; } else { gPlayingSounds->erase(gPlayingSounds->begin() + i); } } } DebugScreen::GetInstance()->AddLogMessage("Sound: Trying to stop index " + to_string((long double)Index) + ", but it is not playing.", Red); }
void SoundManager::Stop(string Name) { if(!Exists(Name)) { DebugScreen::GetInstance()->AddLogMessage("Sound: \"" + Name + "\" does not exist.", Red); return; } for(int i = gPlayingSounds->size() - 1; i >= 0; --i) { PlayingSound* tSound = gPlayingSounds->at(i); bool tPlaying = false; if ( tSound->first.second == Name) { PSEntry tEntry = tSound->second; ErrorCheck( tEntry.second->isPlaying( &tPlaying ) ); if(tPlaying) { gPlayingSounds->erase(gPlayingSounds->begin() + i); tEntry.second->stop(); delete tSound; return; } else { gPlayingSounds->erase(gPlayingSounds->begin() + i); } } } DebugScreen::GetInstance()->AddLogMessage("Sound: Trying to stop \"" + Name + "\", but it is not playing.", Red); }
// Start playing a song FMOD::Channel *Song::Start(bool paused) { // Channel volume will be set to 1.0f (max) automatically ErrorCheck(engine->FMOD()->playSound(FMOD_CHANNEL_FREE, resource.get(), true, &channel)); // Add to channel group (for master volume) if (channelGroup) channel->setChannelGroup(channelGroup); // Songs repeat forever by default channel->setLoopCount(-1); channel->setMode(FMOD_LOOP_NORMAL); // Flush buffer to ensure loop logic is executed channel->setPosition(0, FMOD_TIMEUNIT_MS); // Set paused or not as applicable if (!paused) channel->setPaused(paused); // Cancel any fade that was previously applied fade = false; return channel; }
// Per-frame sound system update void SimpleFMOD::Update() { ErrorCheck(system->update()); for (auto &r : updateableResources) r->Update(); }
void AudioSystem::UpdatePosition(float x, float y, float z){ m_position.x = x; m_position.y = y; m_position.z = z; FMOD_RESULT result = m_system->set3DListenerAttributes(0, &m_position, 0, 0, 0); ErrorCheck(result); }
void SoundManager::Init( ) { //FMOD 초기화 //FMOD 함수는 모두 결과값을 리턴한다. 따라서 에러체크가 가능하다. r = System_Create( &m_pFmod ); ErrorCheck( r ); r = m_pFmod->init( MAX_SOUND_COUNT, FMOD_INIT_NORMAL, NULL ); ErrorCheck( r ); m_volume = 0.5f; for (int i = 0; i < MAX_SOUND_COUNT; i++) { m_pCh[i]->setVolume( m_volume ); } }
/* FUNCTION: Packetize DATE: 11/30/2015 REVISIONS: v2 - adjusted checksum DESIGNER: Thomas & Allen & Dylan PROGRAMMER: Thomas & Allen & Dylan INTERFACE: void Packetize(CHAR *buf, CHAR *packet) CHAR *buf : raw character to read from CHAR *packet : character array to store the packet in RETURNS: void NOTES: packet should be large enough to hold a packet (516 bytes) Performs the checksum calculations */ void Packetize(CHAR *buf, CHAR *packet) { int i, j=4; DWORD sum = 0; for (i = 0; i < 512; i++) { packet[i] = 0; } packet[0] = SOH; //TODO: make this check which sync bit to write packet[1] = SYNC_0; // zero the 2 checksum bytes packet[2] = 0; packet[3] = 0; // copy until end of file (character read is 0 or 512 bytes read) for (i = 0; buf[i] != 0 && i < DATALENGTH;) { packet[j++] = buf[i++]; } // insert EOT if it's not a full packet if (i < 512) { packet[j] = EOT; } // calculate checksum for (i = 0; i < j; i++) { sum += packet[i]; } // retrieve the most significant byte and convert to char // packet[2] = sum & 0xff; packet[2] = (sum & 0x0000ff00) /256; // repeat for least significant byte packet[3] = (sum & 0x000000ff); // check the packet locally for errors OutputDebugString(ErrorCheck(packet) ? "Checksum reversed\n" : "Checksum failed\n"); }
void ae3d::GfxDevice::SetRenderTarget( RenderTexture* target, unsigned cubeMapFace ) { if (target != nullptr && target->GetFBO() == GfxDeviceGlobal::cachedFBO && cubeMapFace == 0) { return; } if (target == nullptr && GfxDeviceGlobal::cachedFBO == GfxDeviceGlobal::systemFBO) { return; } const GLuint fbo = target != nullptr ? target->GetFBO() : GfxDeviceGlobal::systemFBO; glBindFramebuffer( GL_FRAMEBUFFER, fbo ); GfxDeviceGlobal::cachedFBO = fbo; if (target && target->IsCube()) { const unsigned glCubeMapFace = GL_TEXTURE_CUBE_MAP_POSITIVE_X + cubeMapFace; System::Assert( glCubeMapFace >= GL_TEXTURE_CUBE_MAP_POSITIVE_X && glCubeMapFace <= GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, "Invalid cube map face." ); glFramebufferTexture2D( GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, glCubeMapFace, target->GetID(), 0 ); } if (target != nullptr) { glViewport( 0, 0, target->GetWidth(), target->GetHeight() ); } else { ae3d::System::Assert( GfxDeviceGlobal::backBufferWidth > 0, "invalid backbuffer dimension" ); glViewport( 0, 0, GfxDeviceGlobal::backBufferWidth, GfxDeviceGlobal::backBufferHeight ); } ErrorCheckFBO(); ErrorCheck( "SetRenderTarget end" ); }
// -------------------- // NodeHarnessWin implementation NodeHarnessWin::NodeHarnessWin(BRect frame, const char *title) : BWindow(frame, title, B_TITLED_WINDOW, B_NOT_RESIZABLE | B_ASYNCHRONOUS_CONTROLS), mToneNode(NULL), mIsConnected(false), mIsRunning(false) { // build the UI BRect r(10, 10, 100, 40); mConnectButton = new BButton(r, "Connect", "Connect", new BMessage(BUTTON_CONNECT)); mConnectButton->SetEnabled(true); AddChild(mConnectButton); r.OffsetBy(0, 40); mStartButton = new BButton(r, "Start", "Start", new BMessage(BUTTON_START)); mStartButton->SetEnabled(false); AddChild(mStartButton); r.OffsetBy(0, 40); mStopButton = new BButton(r, "Stop", "Stop", new BMessage(BUTTON_STOP)); mStopButton->SetEnabled(false); AddChild(mStopButton); // e.moon 2jun99: create the node BMediaRoster* roster = BMediaRoster::Roster(); mToneNode = new ToneProducer(); status_t err = roster->RegisterNode(mToneNode); ErrorCheck(err, "unable to register ToneProducer node!\n"); // make sure the Media Roster knows that we're using the node roster->GetNodeFor(mToneNode->Node().node, &mConnection.producer); }
//------------------------------------------------------------------------------------------------- UnpinnedCopyEngine::UnpinnedCopyEngine(hsa_agent_t hsaAgent, hsa_agent_t cpuAgent, size_t bufferSize, int numBuffers, bool isLargeBar, int thresholdH2DDirectStaging, int thresholdH2DStagingPinInPlace, int thresholdD2H) : _hsaAgent(hsaAgent), _cpuAgent(cpuAgent), _bufferSize(bufferSize), _numBuffers(numBuffers > _max_buffers ? _max_buffers : numBuffers), _isLargeBar(isLargeBar), _hipH2DTransferThresholdDirectOrStaging(thresholdH2DDirectStaging), _hipH2DTransferThresholdStagingOrPininplace(thresholdH2DStagingPinInPlace), _hipD2HTransferThreshold(thresholdD2H) { hsa_amd_memory_pool_t sys_pool; hsa_status_t err = hsa_amd_agent_iterate_memory_pools(_cpuAgent, findGlobalPool, &sys_pool); // Generate a packed C-style array of agents, for use below with hsa_amd_agents_allow_access std::vector<hsa_agent_t> agents; err = hsa_iterate_agents(&find_gpu, &agents); ErrorCheck(err); hsa_agent_t * agentBlock = new hsa_agent_t[agents.size()]; int i=0; for (auto iter=agents.begin(); iter!= agents.end(); iter++) { agentBlock[i++] = *iter; assert (i<=agents.size()); }; ErrorCheck(err); for (int i=0; i<_numBuffers; i++) { // TODO - experiment with alignment here. err = hsa_amd_memory_pool_allocate(sys_pool, _bufferSize, 0, (void**)(&_pinnedStagingBuffer[i])); ErrorCheck(err); if ((err != HSA_STATUS_SUCCESS) || (_pinnedStagingBuffer[i] == NULL)) { THROW_ERROR(hipErrorMemoryAllocation, err); } // Allow access from every agent: // This is used in peer-to-peer copies, since we use the buffers to copy from different agents. // TODO - may want to review this algorithm for NUMA locality - it might be faster to use staging buffer closer to devices? err = hsa_amd_agents_allow_access(agents.size(), agentBlock, NULL, _pinnedStagingBuffer[i]); ErrorCheck(err); hsa_signal_create(0, 0, NULL, &_completionSignal[i]); hsa_signal_create(0, 0, NULL, &_completionSignal2[i]); } };
void Window::_InitOSSurface() { VkXcbSurfaceCreateInfoKHR create_info {}; create_info.sType = VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR; create_info.connection = _xcb_connection; create_info.window = _xcb_window; ErrorCheck( vkCreateXcbSurfaceKHR( _renderer->GetVulkanInstance(), &create_info, nullptr, &_surface ) ); }