Renderer::Renderer(const Desc & desc) : RendererHelper<1>("PerlinNoiseOceanRenderer", "PerlinNoiseOceanWireFrameRenderer", Renderer::ERenderPass::Deferred_Pass) , mHeightMapCS(nullptr) , mCubeMapTexture(Engine::GetInstance()->GetTextureManager()->LoadTextureCubeMap(desc.mSkyboxCubeMapTextureFilename)) , mOceanColorTexture(Engine::GetInstance()->GetTextureManager()->LoadTexture2D("medias/textures/OceanColor256.tif", GL_REPEAT, GL_REPEAT)) //, mOceanColorTexture(Engine::GetInstance()->GetTextureManager()->GetDefaultTexture2D()) , mHeightMapTextureSize(desc.mHeightMapTextureSize) , mMapSize(desc.mMapWidth, desc.mMapDepth) , mPatchCount(desc.mMapWidth / 64, desc.mMapDepth / 64) , mMapCount(0) , mDrawNormalShader("TerrainDrawNormals") { PRINT_BEGIN_SECTION; PRINT_MESSAGE("Initialize PerlinNoiseOceanRenderer....."); const glm::vec3 vertices[] = { glm::vec3(0.0f, 0.0f, 0.0f), glm::vec3(1.0f, 0.0f, 0.0f), glm::vec3(0.0f, 0.0f, 1.0f), glm::vec3(1.0f, 0.0f, 1.0f) }; //setup vao and vbo stuff CreateBuffers(); glBindVertexArray(mVaoID); glBindBuffer(GL_ARRAY_BUFFER, mVboIDs[VertexArrayBufferIndex]); glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); GL_CHECK_ERRORS; glEnableVertexAttribArray(Shader::POSITION_ATTRIBUTE); glVertexAttribPointer(Shader::POSITION_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0); GL_CHECK_ERRORS; glPatchParameteri(GL_PATCH_VERTICES, 4); glBindVertexArray(0); GL_CHECK_ERRORS; mMapCount = (GLint)desc.mMaps.size(); PerMapData * modelMatrixBuffer = new PerMapData[mMapCount]; for (int i = 0; i < mMapCount; ++i) { modelMatrixBuffer[i].mModelDQ = desc.mMaps[i].mModelDQ; } mModelMatrixBuffer.CreateResource(GL_STATIC_DRAW, GL_RGBA32F, (mMapCount * sizeof(PerMapData)), modelMatrixBuffer); LoadShaders(desc); mIsInitialized = true; PRINT_MESSAGE(".....PerlinNoiseOceanRenderer initialized!"); PRINT_END_SECTION; }
void Renderer::LoadHeightMapComputeShader(const Desc & desc) { PRINT_MESSAGE("Initialize Perlin Noise Ocean Renderer (Height Map Compute) Shaders : ....."); mHeightMapCS = new HeightMapCS(); glm::vec2 scale = glm::vec2((GLfloat)mHeightMapTextureSize.x / (GLfloat)mMapSize.x, (GLfloat)mHeightMapTextureSize.y / (GLfloat)mMapSize.y); mHeightMapCS->LoadShader(desc.mWaveProps, mHeightMapTextureSize, scale); Engine::GetInstance()->AttachComputeShader(mHeightMapCS); PRINT_MESSAGE(".....done."); }
void Renderer::LoadWireFrameShader(const Desc & /*desc*/) { PRINT_MESSAGE("Initialize Perlin Noise Ocean Renderer (Wire Frame) Shaders : ....."); const char * uniformNames[] = { "u_PatchCount", "u_MapSize", "u_HeightMapTextureSize", "u_MaxAmplitude", "u_HeightMapSampler", "u_PerMapDataSampler", }; //setup shader mWireFrameShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/HeightFieldOcean.vs.glsl"); mWireFrameShader.LoadFromFile(GL_TESS_CONTROL_SHADER, "shaders/HeightFieldOcean.tcs.glsl"); mWireFrameShader.LoadFromFile(GL_TESS_EVALUATION_SHADER, "shaders/PerlinNoiseOcean.tes.glsl"); //mWireFrameShader.LoadFromFile(GL_GEOMETRY_SHADER, "shaders/HeightFieldOcean.gs.glsl"); mWireFrameShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/HeightFieldOcean.wireframe.fs.glsl"); mWireFrameShader.CreateAndLinkProgram(); mWireFrameShader.Use(); mWireFrameShader.AddUniforms(uniformNames, 6); //pass values of constant uniforms at initialization glUniform2iv(mWireFrameShader.GetUniform(u_PatchCount), 1, glm::value_ptr(mPatchCount)); GL_CHECK_ERRORS; glUniform2iv(mWireFrameShader.GetUniform(u_MapSize), 1, glm::value_ptr(mMapSize)); GL_CHECK_ERRORS; glUniform2iv(mShader.GetUniform(u_HeightMapTextureSize), 1, glm::value_ptr(mHeightMapTextureSize)); GL_CHECK_ERRORS; glUniform1f(mShader.GetUniform(u_MaxAmplitude), mHeightMapCS->GetMaxAmplitude()); GL_CHECK_ERRORS; glUniform1i(mWireFrameShader.GetUniform(u_HeightMapSampler), 0); GL_CHECK_ERRORS; glUniform1i(mWireFrameShader.GetUniform(u_PerMapDataSampler), 1); GL_CHECK_ERRORS; //GetWavePropertyUniformIndex(mWireFrameShader, mWireFrameShaderWaveProps); mWireFrameShader.SetupFrameDataBlockBinding(); mWireFrameShader.UnUse(); GL_CHECK_ERRORS; PRINT_MESSAGE(".....done."); }
void update_rotation(Db_Object db, int league_id){ char query[DEFAULT_QUERY_LENGTH]; const char* SELECT_CURRENT_STARTERS = "select t_rotation.team_id,position from t_rotation join t_team on t_rotation.team_id = t_team.team_id where next_starter = 1 AND league_id = %d and t_team.active = 1;"; int query_len = sprintf(query,SELECT_CURRENT_STARTERS,league_id); native_result* result = db->execute_query_result(db->conn,query,query_len); native_row row; Array_List list = Array_List_create(sizeof(Key_Value)); while(row = db->fetch_row(result)){ int team_id = db->get_column_int(row,0); int position = db->get_column_int(row,1); PRINT_MESSAGE(1,"team_id: %d starter: %d\n",team_id,position); Key_Value starter = malloc(sizeof(struct key_value)); starter->key = (void*)team_id; starter->value = (void*)position; PRINT_MESSAGE(1,"starter,key: %d, starter.value: %d\n",starter->key,starter->value); Array_List_add(list,starter); } if(list->length>8){ exit(1); } db->free_result(result); const char* RESET_NEXT_STARTER = "Update t_rotation set next_starter = 0 where team_id = %d; update t_lineup set bat_order=0, position=0 where team_id=%d and position=1;"; const char* SELECT_NEW_STARTER = "select player_id from t_rotation where team_id = %d and position = %d;"; const char* UPDATE_ROTATION = "update t_rotation set next_starter = 1 where team_id = %d and position = %d; update t_lineup set position =1, bat_order=9 where player_id=%d;"; int i; for(i=0;i<list->length;i++){ int team_id = (int)((Key_Value)gget(list,i))->key; int position = (int)((Key_Value)gget(list,i))->value; position = (position%5) + 1; query_len = sprintf(query,RESET_NEXT_STARTER,team_id,team_id); db->execute_query(db->conn,query,query_len); int query_len = sprintf(query,SELECT_NEW_STARTER,team_id,position); result = db->execute_query_result(db->conn,query,query_len); row = db->fetch_row(result); int new_starter_id = db->get_column_int(row,0); db->free_result(result); query_len = sprintf(query,UPDATE_ROTATION,team_id,position,new_starter_id); db->execute_query(db->conn,query,query_len); } Array_List_free(list,1); }
void ContinuousBuild::OnFileSaved(wxCommandEvent& e) { e.Skip(); PRINT_MESSAGE(wxT("ContinuousBuild::OnFileSaved\n")); // Dont build while the main build is in progress if (m_buildInProgress) { PRINT_MESSAGE(wxT("Build already in progress, skipping\n")); return; } ContinousBuildConf conf; m_mgr->GetConfigTool()->ReadObject(wxT("ContinousBuildConf"), &conf); if (conf.GetEnabled()) { wxString *fileName = (wxString*) e.GetClientData(); if(fileName) DoBuild(*fileName); } else { PRINT_MESSAGE(wxT("ContinuousBuild is disabled\n")); } }
int main(int argc, char **argv){ int seed = 0; int c; int option_index = 0; double HITTER_MODIFIER= 1.0; double PITCHER_MODIFIER= 1.0; double AB_EXPONENT = 1.0; static struct option long_options[] = { {"seed",required_argument,0,'s'}, LONG_OPTIONS_STRUCT, {0,0,0,0} }; if(argc < 2){ print_usage(); exit(1); } int home_id = atoi(argv[1]); int away_id = atoi(argv[2]); while(1){ c = getopt_long(argc,argv,"s:h:p:x:",long_options,&option_index); if(c == -1){ break; } switch(c){ LONG_OPTIONS_CASE case 's': seed = atoi(optarg); break; case '?': printf("????\n"); break; default: printf("default\n"); break; } } Db_Object db = db_connect(CONFIG_FILE); PRINT_MESSAGE(1,"home: %d away: %d hit: %lf pitch: %lf ab_exp: %lf\n",home_id,away_id,HITTER_MODIFIER,PITCHER_MODIFIER,AB_EXPONENT); sim_game(db,1,home_id,away_id,HITTER_MODIFIER,PITCHER_MODIFIER,AB_EXPONENT,NULL); db->close_connection(db->conn); free(db); return 0; }
void TRendererError::printMessage() { std::string strCaption; PRINT_MESSAGE(m_message.c_str(), formatError(strCaption, m_code, m_severity)); }
void HeightMapCS::LoadShader(const WavePropertyList & waveProps, const glm::vec2 & textureSize, const glm::vec2 & scale) { PRINT_MESSAGE("Initialize Deep Ocean Renderer (Height Map Compute) Shaders : ....."); mTextureSize = textureSize; mWaveCount = (GLint)waveProps.size(); assert(mWaveCount > 0); GLsizei wavePropsBufferItemCount = mWaveCount * __waveparams_count__; GLsizei wavePropsBufferSize = wavePropsBufferItemCount * sizeof(GLfloat); glBindBuffer(GL_SHADER_STORAGE_BUFFER, mBufferIds[WavePropsBufferIndex]); glBufferData(GL_SHADER_STORAGE_BUFFER, wavePropsBufferSize, nullptr, GL_STATIC_DRAW); GL_CHECK_ERRORS; { GLfloat * wavePropsBuffer = (GLfloat *)glMapBuffer(GL_SHADER_STORAGE_BUFFER, GL_WRITE_ONLY); GL_CHECK_ERRORS; for (int i = 0; i < mWaveCount; ++i) { const WaveProperty & src = waveProps[i]; wavePropsBuffer[WaveParams_Amplitude] = src.mAmplitude; wavePropsBuffer[WaveParams_DirectionX] = src.mDirection.x; wavePropsBuffer[WaveParams_DirectionY] = src.mDirection.z; wavePropsBuffer[WaveParams_W] = src.GetFrequency(); wavePropsBuffer[WaveParams_Phase] = src.GetPhase(); wavePropsBuffer[WaveParams_Steepness] = src.mSteepness; wavePropsBuffer += __waveparams_count__; } glUnmapBuffer(GL_SHADER_STORAGE_BUFFER); GL_CHECK_ERRORS; } glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0); glGenTextures(1, &mHeightMapTextureId); glBindTexture(GL_TEXTURE_2D, mHeightMapTextureId); TextureManager::CreateTexStorage2D(GL_TEXTURE_2D, mTextureSize.x, mTextureSize.y, nullptr, false, GL_NEAREST, GL_NEAREST, GL_REPEAT, GL_REPEAT, mPrecomputeNormals ? GL_RGBA16F : GL_R16F, GL_RED, GL_FLOAT); glBindTexture(GL_TEXTURE_2D, 0); // --------------------------------------- std::vector<std::string> shaderSources; if (mPrecomputeNormals) { shaderSources.push_back("#define PRECOMPUTE_NORMAL\n"); } std::string csSource; Shader::MergeFile(csSource, "shaders/DeepOcean.hmap.cs.glsl"); shaderSources.push_back(csSource); mShader.LoadFromString(GL_COMPUTE_SHADER, shaderSources, Shader::EInclude::ComputeShadersCommon); mShader.CreateAndLinkProgram(); mShader.Use(); const char * uniformNames[__hmap_cs_uniforms_count__] = { "u_WaveCount", "u_TextureSize", "u_Scale", "u_Time", }; mShader.AddUniforms(uniformNames, __hmap_cs_uniforms_count__); glUniform1i(mShader.GetUniform(u_WaveCount), mWaveCount); GL_CHECK_ERRORS; glUniform2iv(mShader.GetUniform(u_TextureSize), 1, glm::value_ptr(mTextureSize)); GL_CHECK_ERRORS; glUniform2fv(mShader.GetUniform(u_Scale), 1, glm::value_ptr(scale)); GL_CHECK_ERRORS; mShader.UnUse(); PRINT_MESSAGE("Height map texture id : %li", mHeightMapTextureId); PRINT_MESSAGE("Wave props buffer id : %li", mBufferIds[WavePropsBufferIndex]); mIsInitialized = true; PRINT_MESSAGE(".....done."); }
GridRenderer::GridRenderer(int width, int depth) : RendererHelper<1>("GridRenderer", "GridWireFrameRenderer", Forward_Pass) { PRINT_BEGIN_SECTION; PRINT_MESSAGE("Initialize GridRenderer....."); const char * uniformNames[__uniforms_count__] = { "vGridSize" }; //setup shader mShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/grid.vs.glsl"); mShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/grid.forward.fs.glsl"); mShader.CreateAndLinkProgram(); mShader.Use(); mShader.AddUniforms(uniformNames, __uniforms_count__); //pass values of constant uniforms at initialization glUniform2f(mShader.GetUniform(vGridSize), (float)width, (float)depth); mShader.SetupFrameDataBlockBinding(); mShader.UnUse(); GL_CHECK_ERRORS; m_vertexCount = ((width + 1) + (depth + 1)) * 2; glm::vec3* vertices = new glm::vec3[m_vertexCount]; int count = 0; int width_2 = width/2; int depth_2 = depth/2; int i=0 ; for (i = -width_2; i <= width_2; i++) { vertices[count++] = glm::vec3(i, -0.1f, -depth_2); vertices[count++] = glm::vec3(i, -0.1f, depth_2); } for (i = -depth_2; i <= depth_2; i++) { vertices[count++] = glm::vec3(-width_2, -0.1f, i); vertices[count++] = glm::vec3(width_2, -0.1f, i); } //setup vao and vbo stuff CreateBuffers(); glBindVertexArray(mVaoID); glBindBuffer (GL_ARRAY_BUFFER, mVboIDs[0]); glBufferData(GL_ARRAY_BUFFER, ((width + 1) + (depth + 1)) * 2 * sizeof(glm::vec3), &vertices[0], GL_STATIC_DRAW); GL_CHECK_ERRORS; glEnableVertexAttribArray(Shader::POSITION_ATTRIBUTE); glVertexAttribPointer(Shader::POSITION_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 0, 0); GL_CHECK_ERRORS; glBindVertexArray(0); GL_CHECK_ERRORS; delete [] vertices; mIsInitialized = true; PRINT_MESSAGE(".....GridRenderer initialized!"); PRINT_END_SECTION; }
void SkyboxRenderer::Initialize() { PRINT_BEGIN_SECTION; PRINT_MESSAGE("Initialize SkyboxRenderer....."); const char * uniformNames[__uniforms_count__] = { "u_SkyboxCubeMapSampler" }; //setup shader mShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/skybox.vs.glsl"); mShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/skybox.forward.fs.glsl"); //std::vector<std::string> shaderFilenames(2); //shaderFilenames[0] = "shaders/DeferredShadingCommon.incl.glsl"; //shaderFilenames[1] = "shaders/skybox.deferred.fs.glsl"; //mShader.LoadFromFile(GL_FRAGMENT_SHADER, shaderFilenames); mShader.CreateAndLinkProgram(); mShader.Use(); mShader.AddUniforms(uniformNames, __uniforms_count__); glUniform1i(mShader.GetUniform(u_SkyboxCubeMapSampler), 0); GL_CHECK_ERRORS; mShader.SetupFrameDataBlockBinding(); mShader.UnUse(); GL_CHECK_ERRORS; //setup shader mWireFrameShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/skybox.vs.glsl"); mWireFrameShader.LoadFromFile(GL_FRAGMENT_SHADER, "shaders/skybox.wireframe.fs.glsl"); mWireFrameShader.CreateAndLinkProgram(); mWireFrameShader.Use(); mWireFrameShader.SetupFrameDataBlockBinding(); mWireFrameShader.UnUse(); GL_CHECK_ERRORS; GLfloat skyboxVertices[] = { // Positions -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, -1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f }; //setup vao and vbo stuff CreateBuffers(); glBindVertexArray(mVaoID); glBindBuffer(GL_ARRAY_BUFFER, mVboIDs[0]); glBufferData(GL_ARRAY_BUFFER, sizeof(skyboxVertices), skyboxVertices, GL_STATIC_DRAW); GL_CHECK_ERRORS; glEnableVertexAttribArray(Shader::POSITION_ATTRIBUTE); glVertexAttribPointer(Shader::POSITION_ATTRIBUTE, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), 0); GL_CHECK_ERRORS; glBindVertexArray(0); GL_CHECK_ERRORS; mIsInitialized = true; PRINT_MESSAGE(".....SkyboxRenderer initialized!"); PRINT_END_SECTION; }
void Renderer::LoadMainShader(const Desc & desc) { PRINT_MESSAGE("Initialize Perlin Noise Ocean Renderer Shaders : ....."); const char * uniformNames[__uniforms_count__] = { "u_PatchCount", "u_MapSize", "u_HeightMapTextureSize", "u_MaxAmplitude", "u_HeightMapSampler", "u_PerMapDataSampler", "u_SkyboxCubeMapSampler", "u_textureSampler", "u_NormalMapSampler", }; //setup shader mShader.LoadFromFile(GL_VERTEX_SHADER, "shaders/HeightFieldOcean.vs.glsl"); mShader.LoadFromFile(GL_TESS_CONTROL_SHADER, "shaders/HeightFieldOcean.tcs.glsl"); if(desc.mNormalMode==ENormalMode::PerVertexNormal) { std::vector<std::string> shaderSources; shaderSources.push_back("#define PER_VERTEX_NORMAL\n"); std::string csSource; Shader::MergeFile(csSource, "shaders/PerlinNoiseOcean.tes.glsl"); shaderSources.push_back(csSource); mShader.LoadFromString(GL_TESS_EVALUATION_SHADER, shaderSources); } else { mShader.LoadFromFile(GL_TESS_EVALUATION_SHADER, "shaders/PerlinNoiseOcean.tes.glsl"); } //mShader.LoadFromFile(GL_GEOMETRY_SHADER, "shaders/HeightFieldOcean.gs.glsl"); std::vector<std::string> lightFsGlsl(2); PRINT_MESSAGE("Loading shader file : shaders/DeferredShadingCommon.incl.glsl"); Shader::MergeFile(lightFsGlsl[0], "shaders/DeferredShadingCommon.incl.glsl"); PRINT_MESSAGE("Loading shader file : shaders/HeightFieldOcean.deferred.fs.glsl"); if (desc.mNormalMode == ENormalMode::PerPixelNormal) { std::string csSource("#define PER_PIXEL_NORMAL\n"); Shader::MergeFile(csSource, "shaders/HeightFieldOcean.deferred.fs.glsl"); lightFsGlsl[1] = csSource; } else { Shader::MergeFile(lightFsGlsl[1], "shaders/HeightFieldOcean.deferred.fs.glsl"); } mShader.LoadFromString(GL_FRAGMENT_SHADER, lightFsGlsl); mShader.CreateAndLinkProgram(); mShader.Use(); mShader.AddUniforms(uniformNames, __uniforms_count__); //pass values of constant uniforms at initialization glUniform2iv(mShader.GetUniform(u_PatchCount), 1, glm::value_ptr(mPatchCount)); GL_CHECK_ERRORS; glUniform2iv(mShader.GetUniform(u_MapSize), 1, glm::value_ptr(mMapSize)); GL_CHECK_ERRORS; glUniform2iv(mShader.GetUniform(u_HeightMapTextureSize), 1, glm::value_ptr(mHeightMapTextureSize)); GL_CHECK_ERRORS; glUniform1f(mShader.GetUniform(u_MaxAmplitude), mHeightMapCS->GetMaxAmplitude()); GL_CHECK_ERRORS; glUniform1i(mShader.GetUniform(u_HeightMapSampler), 0); GL_CHECK_ERRORS; glUniform1i(mShader.GetUniform(u_PerMapDataSampler), 1); GL_CHECK_ERRORS; glUniform1i(mShader.GetUniform(u_SkyboxCubeMapSampler), 2); GL_CHECK_ERRORS; glUniform1i(mShader.GetUniform(u_textureSampler), 3); GL_CHECK_ERRORS; glUniform1i(mWireFrameShader.GetUniform(u_NormalMapSampler), 4); GL_CHECK_ERRORS; mShader.SetupFrameDataBlockBinding(); mShader.UnUse(); GL_CHECK_ERRORS; PRINT_MESSAGE(".....done."); }
int FP_Analysis(struct TASK_SET t,int REPORTING) { int i; float sum=0.0; float WRT=0.0; //Worst Case Response Time int FAILED_RT=0; //This flag is set if the response time analysis fails if(REPORTING==REPORT_ON) printf(PRINT_MESSAGE("FIXED PRIORITY")); if(basic_schedulability_test(t)==-U_GREATER_1) { if(REPORTING==REPORT_ON) { printf("Satisfaction of necessary condition : [%s]\n",FAILED); printf("Schedulability : [%s]\n",NOT_SCHEDULABLE); } return -U_GREATER_1; } for(i=0;i<t.total_tasks;i++) { if(effective_utilization(t,i)==SUCCESS) { if(REPORTING==REPORT_ON) printf("Task %d UB TEST \t : [%s]\n",t.task[i].id,PASSED); } else { if(REPORTING==REPORT_ON) printf("Task %d UB TEST :[%s]\n",t.task[i].id,FAILED); if((WRT=RT_Test(i,t))>0.0) { if(REPORTING==REPORT_ON) { printf("RT_Test Task %d : [%s]\n",t.task[i].id,PASSED); printf("WRT(%d) : %f\n",t.task[i].id,WRT); } } else { if(REPORTING==REPORT_ON) printf("RT_Test Task %d : [%s]\n",t.task[i].id,FAILED); FAILED_RT=1; //we simply set the flag since we want to pinpoint exactly which tasks fail } //At this point unschedulability is confirmed. For efficiency you //may want to directly return } } if(!FAILED_RT) { if(REPORTING==REPORT_ON) { printf("Response Time Analysis : [%s]\n",PASSED); printf("Schedulability (RM/DM) : [%s]\n",SCHEDULABLE); } return SUCCESS; } else { if(REPORTING==REPORT_ON) { printf("Response Time Analysis : [%s]\n",FAILED); printf("Schedulability (RM/DM) : [%s]\n",NOT_SCHEDULABLE); } return -FAILURE; } }
void ContinuousBuild::DoBuild(const wxString& fileName) { PRINT_MESSAGE(wxT("DoBuild\n")); // Make sure a workspace is opened if (!m_mgr->IsWorkspaceOpen()) { PRINT_MESSAGE(wxT("No workspace opened!\n")); return; } // Filter non source files FileExtManager::FileType type = FileExtManager::GetType(fileName); switch(type) { case FileExtManager::TypeSourceC: case FileExtManager::TypeSourceCpp: case FileExtManager::TypeResource: break; default: { PRINT_MESSAGE(wxT("Non source file\n")); return; } } wxString projectName = m_mgr->GetProjectNameByFile(fileName); if(projectName.IsEmpty()) { PRINT_MESSAGE(wxT("Project name is empty\n")); return; } wxString errMsg; ProjectPtr project = m_mgr->GetSolution()->FindProjectByName(projectName, errMsg); if(!project){ PRINT_MESSAGE(wxT("Could not find project for file\n")); return; } // get the selected configuration to be build BuildConfigPtr bldConf = m_mgr->GetSolution()->GetProjBuildConf( project->GetName(), wxEmptyString ); if ( !bldConf ) { PRINT_MESSAGE(wxT("Failed to locate build configuration\n")); return; } BuilderPtr builder = m_mgr->GetBuildManager()->GetBuilder( wxT( "GNU makefile for g++/gcc" ) ); if(!builder){ PRINT_MESSAGE(wxT("Failed to located builder\n")); return; } // Only normal file builds are supported if(bldConf->IsCustomBuild()){ PRINT_MESSAGE(wxT("Build is custom. Skipping\n")); return; } // get the single file command to use wxString cmd = builder->GetSingleFileCmd(projectName, bldConf->GetName(), fileName); WrapInShell(cmd); if( m_buildProcess.IsBusy() ) { // add the build to the queue if (m_files.Index(fileName) == wxNOT_FOUND) { m_files.Add(fileName); // update the UI m_view->AddFile(fileName); } return; } PRINT_MESSAGE(wxString::Format(wxT("cmd:%s\n"), cmd.c_str())); if(!m_buildProcess.Execute(cmd, fileName, project->GetFileName().GetPath(), this)) return; // Set some messages m_mgr->SetStatusMessage(wxString::Format(wxT("Compiling %s..."), wxFileName(fileName).GetFullName().c_str()), 0); // Add this file to the UI queue m_view->AddFile(fileName); }