HRESULT CDXVADecoderH264::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop) { HRESULT hr = S_FALSE; UINT nSlices = 0; int nSurfaceIndex = -1; int nFieldType = -1; int nSliceType = -1; int nFramePOC = INT_MIN; int nOutPOC = INT_MIN; REFERENCE_TIME rtOutStart = _I64_MIN; CH264Nalu Nalu; UINT nNalOffset = 0; CComPtr<IMediaSample> pSampleToDeliver; CComQIPtr<IMPCDXVA2Sample> pDXVA2Sample; int slice_step = 1; if (FFH264DecodeBuffer(m_pFilter->GetAVCtx(), pDataIn, nSize, &nFramePOC, &nOutPOC, &rtOutStart) == -1) { return S_FALSE; } while (!nSlices && slice_step <= 2) { Nalu.SetBuffer(pDataIn, nSize, slice_step == 1 ? m_nNALLength : 0); while (Nalu.ReadNext()) { switch (Nalu.GetType()) { case NALU_TYPE_SLICE: case NALU_TYPE_IDR: if (m_bUseLongSlice) { m_pSliceLong[nSlices].BSNALunitDataLocation = nNalOffset; m_pSliceLong[nSlices].SliceBytesInBuffer = (UINT)Nalu.GetDataLength() + 3; //.GetRoundedDataLength(); m_pSliceLong[nSlices].slice_id = nSlices; FF264UpdateRefFrameSliceLong(&m_DXVAPicParams, &m_pSliceLong[nSlices], m_pFilter->GetAVCtx()); if (nSlices > 0) { m_pSliceLong[nSlices - 1].NumMbsForSlice = m_pSliceLong[nSlices].NumMbsForSlice = m_pSliceLong[nSlices].first_mb_in_slice - m_pSliceLong[nSlices - 1].first_mb_in_slice; } } nSlices++; nNalOffset += (UINT)(Nalu.GetDataLength() + 3); if (nSlices > MAX_SLICES) { break; } break; } } slice_step++; } if (!nSlices) { return S_FALSE; } m_nMaxWaiting = min(max(m_DXVAPicParams.num_ref_frames, 3), 8); // If parsing fail (probably no PPS/SPS), continue anyway it may arrived later (happen on truncated streams) if (FAILED(FFH264BuildPicParams(&m_DXVAPicParams, &m_DXVAScalingMatrix, &nFieldType, &nSliceType, m_pFilter->GetAVCtx(), m_pFilter->GetPCIVendor()))) { return S_FALSE; } TRACE_H264("CDXVADecoderH264::DecodeFrame() : nFramePOC = %11d, nOutPOC = %11d[%11d], [%d - %d], rtOutStart = [%20I64d]\n", nFramePOC, nOutPOC, m_nOutPOC, m_DXVAPicParams.field_pic_flag, m_DXVAPicParams.RefPicFlag, rtOutStart); // Wait I frame after a flush if (m_bFlushed && !m_DXVAPicParams.IntraPicFlag) { TRACE_H264("CDXVADecoderH264::DecodeFrame() : Flush - wait I frame\n"); m_nBrokenFramesFlag = 0; m_nBrokenFramesFlag_POC = 0; m_nfield_pic_flag = m_DXVAPicParams.field_pic_flag; m_nRefPicFlag = m_DXVAPicParams.RefPicFlag; m_nPrevOutPOC = INT_MIN; return S_FALSE; } /* Disabled, because that causes serious problems. // Some magic code for detecting the incorrect decoding of interlaced frames ... // TODO : necessary to make it better, and preferably on the side of ffmpeg ... if (m_nfield_pic_flag && m_nfield_pic_flag == m_DXVAPicParams.field_pic_flag && m_nRefPicFlag == m_DXVAPicParams.RefPicFlag) { if (m_nPrevOutPOC == m_nOutPOC && m_nOutPOC == INT_MIN) { m_nBrokenFramesFlag_POC++; } m_nBrokenFramesFlag++; } else { m_nBrokenFramesFlag = 0; m_nBrokenFramesFlag_POC = 0; } m_nfield_pic_flag = m_DXVAPicParams.field_pic_flag; m_nRefPicFlag = m_DXVAPicParams.RefPicFlag; m_nPrevOutPOC = m_nOutPOC; if (m_nBrokenFramesFlag > 4) { m_nBrokenFramesFlag = 0; if (m_nBrokenFramesFlag_POC > 1) { TRACE_H264("CDXVADecoderH264::DecodeFrame() : Detected broken frames ... flush data\n"); m_nBrokenFramesFlag_POC = 0; Flush(); return S_FALSE; } } // */ CHECK_HR_TRACE(GetFreeSurfaceIndex(nSurfaceIndex, &pSampleToDeliver, rtStart, rtStop)); FFH264SetCurrentPicture(nSurfaceIndex, &m_DXVAPicParams, m_pFilter->GetAVCtx()); CHECK_HR_TRACE(BeginFrame(nSurfaceIndex, pSampleToDeliver)); m_DXVAPicParams.StatusReportFeedbackNumber++; // Send picture parameters CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_PictureParametersBufferType, sizeof(m_DXVAPicParams), &m_DXVAPicParams)); CHECK_HR_TRACE(Execute()); // Add bitstream, slice control and quantization matrix CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_BitStreamDateBufferType, nSize, pDataIn, &nSize)); if (m_bUseLongSlice) { CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(DXVA_Slice_H264_Long)*nSlices, m_pSliceLong)); } else { CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(DXVA_Slice_H264_Short)*nSlices, m_pSliceShort)); } CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_InverseQuantizationMatrixBufferType, sizeof(DXVA_Qmatrix_H264), (void*)&m_DXVAScalingMatrix)); // Decode bitstream CHECK_HR_TRACE(Execute()); CHECK_HR_TRACE(EndFrame(nSurfaceIndex)); #if defined(_DEBUG) && 0 DisplayStatus(); #endif bool bAdded = AddToStore(nSurfaceIndex, pSampleToDeliver, m_DXVAPicParams.RefPicFlag, rtStart, rtStop, m_DXVAPicParams.field_pic_flag, (FF_FIELD_TYPE)nFieldType, (FF_SLICE_TYPE)nSliceType, nFramePOC); FFH264UpdateRefFramesList(&m_DXVAPicParams, m_pFilter->GetAVCtx()); ClearUnusedRefFrames(); if (bAdded) { hr = DisplayNextFrame(); } if (nOutPOC != INT_MIN) { m_nOutPOC = nOutPOC; m_rtOutStart = rtOutStart; } m_bFlushed = false; return hr; }
// === Public functions HRESULT TDXVADecoderVC1::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop) { HRESULT hr; int nSurfaceIndex; CComPtr<IMediaSample> pSampleToDeliver; int nFieldType, nSliceType; UINT nFrameSize, nSize_Result; m_pCodec->libavcodec->FFVC1UpdatePictureParam(&m_PictureParams, m_pCodec->avctx, &nFieldType, &nSliceType, pDataIn, nSize, &nFrameSize, FALSE, &m_bFrame_repeat_pict); if (m_pCodec->libavcodec->FFIsSkipped(m_pCodec->avctx)) { return S_OK; } // Wait I frame after a flush if (m_bFlushed && ! m_PictureParams.bPicIntra) { return S_FALSE; } hr = GetFreeSurfaceIndex(nSurfaceIndex, &pSampleToDeliver, rtStart, rtStop); if (FAILED(hr)) { ASSERT(hr == VFW_E_NOT_COMMITTED); // Normal when stop playing return hr; } CHECK_HR(BeginFrame(nSurfaceIndex, pSampleToDeliver)); DPRINTF(_l("TDXVADecoderVC1::DecodeFrame - PictureType = %s, rtStart = %I64d Surf=%d\n"), m_pCodec->libavcodec->GetFFMpegPictureType(nSliceType), rtStart, nSurfaceIndex); m_PictureParams.wDecodedPictureIndex = nSurfaceIndex; m_PictureParams.wDeblockedPictureIndex = m_PictureParams.wDecodedPictureIndex; // Manage reference picture list if (!m_PictureParams.bPicBackwardPrediction) { if (m_wRefPictureIndex[0] != NO_REF_FRAME) { RemoveRefFrame(m_wRefPictureIndex[0]); } m_wRefPictureIndex[0] = m_wRefPictureIndex[1]; m_wRefPictureIndex[1] = nSurfaceIndex; } m_PictureParams.wForwardRefPictureIndex = (m_PictureParams.bPicIntra == 0) ? m_wRefPictureIndex[0] : NO_REF_FRAME; m_PictureParams.wBackwardRefPictureIndex = (m_PictureParams.bPicBackwardPrediction == 1) ? m_wRefPictureIndex[1] : NO_REF_FRAME; m_PictureParams.bPic4MVallowed = (m_PictureParams.wBackwardRefPictureIndex == NO_REF_FRAME && m_PictureParams.bPicStructure == 3) ? 1 : 0; m_PictureParams.bPicDeblockConfined |= (m_PictureParams.wBackwardRefPictureIndex == NO_REF_FRAME) ? 0x04 : 0; m_PictureParams.bPicScanMethod++; // Use for status reporting sections 3.8.1 and 3.8.2 DPRINTF(_l("TDXVADecoderVC1::DecodeFrame - Decode frame %i\n"), m_PictureParams.bPicScanMethod); // Send picture params to accelerator CHECK_HR(AddExecuteBuffer(DXVA2_PictureParametersBufferType, sizeof(m_PictureParams), &m_PictureParams)); // Send bitstream to accelerator CHECK_HR(AddExecuteBuffer(DXVA2_BitStreamDateBufferType, nFrameSize ? nFrameSize : nSize, pDataIn, &nSize_Result)); m_SliceInfo.wQuantizerScaleCode = 1; // TODO : 1->31 ??? m_SliceInfo.dwSliceBitsInBuffer = nSize_Result * 8; CHECK_HR(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(m_SliceInfo), &m_SliceInfo)); // Decode frame CHECK_HR(Execute()); CHECK_HR(EndFrame(nSurfaceIndex)); // *************** if (nFrameSize) { // Decoding Second Field m_pCodec->libavcodec->FFVC1UpdatePictureParam(&m_PictureParams, m_pCodec->avctx, NULL, NULL, pDataIn, nSize, NULL, TRUE, &m_bFrame_repeat_pict); CHECK_HR(BeginFrame(nSurfaceIndex, pSampleToDeliver)); DPRINTF(_l("TDXVADecoderVC1::DecodeFrame - PictureType = %s\n"), m_pCodec->libavcodec->GetFFMpegPictureType(nSliceType)); CHECK_HR(AddExecuteBuffer(DXVA2_PictureParametersBufferType, sizeof(m_PictureParams), &m_PictureParams)); // Send bitstream to accelerator CHECK_HR(AddExecuteBuffer(DXVA2_BitStreamDateBufferType, nSize - nFrameSize, pDataIn + nFrameSize, &nSize_Result)); m_SliceInfo.wQuantizerScaleCode = 1; // TODO : 1->31 ??? m_SliceInfo.dwSliceBitsInBuffer = nSize_Result * 8; CHECK_HR(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(m_SliceInfo), &m_SliceInfo)); // Decode frame CHECK_HR(Execute()); CHECK_HR(EndFrame(nSurfaceIndex)); } // *************** #ifdef _DEBUG DisplayStatus(); #endif // Re-order B frames if (m_pCodec->isReorderBFrame()) { if (m_PictureParams.bPicBackwardPrediction == 1) { SwapRT(rtStart, m_rtStartDelayed); SwapRT(rtStop, m_rtStopDelayed); } else { // Save I or P reference time (swap later) if (!m_bFlushed) { if (m_nDelayedSurfaceIndex != -1) { UpdateStore(m_nDelayedSurfaceIndex, m_rtStartDelayed, m_rtStopDelayed); } m_rtStartDelayed = m_rtStopDelayed = _I64_MAX; SwapRT(rtStart, m_rtStartDelayed); SwapRT(rtStop, m_rtStopDelayed); m_nDelayedSurfaceIndex = nSurfaceIndex; } } } AddToStore(nSurfaceIndex, pSampleToDeliver, (m_PictureParams.bPicBackwardPrediction != 1), rtStart, rtStop, false, (FF_FIELD_TYPE)nFieldType, (FF_SLICE_TYPE)nSliceType, 0); m_bFlushed = false; return DisplayNextFrame(); }
// === Public functions HRESULT CDXVADecoderMpeg2::DecodeFrame(BYTE* pDataIn, UINT nSize, REFERENCE_TIME rtStart, REFERENCE_TIME rtStop) { HRESULT hr; int nFieldType; int nSliceType; FFMpeg2DecodeFrame(&m_PictureParams, &m_QMatrixData, m_SliceInfo, &m_nSliceCount, m_pFilter->GetAVCtx(), m_pFilter->GetFrame(), &m_nNextCodecIndex, &nFieldType, &nSliceType, pDataIn, nSize); if (m_PictureParams.bSecondField && !m_bSecondField) { m_bSecondField = true; } // Wait I frame after a flush if (m_bFlushed && (!m_PictureParams.bPicIntra || (m_bSecondField && m_PictureParams.bSecondField))) { TRACE_MPEG2("CDXVADecoderMpeg2::DecodeFrame() : Flush - wait I frame\n"); return S_FALSE; } if (m_bSecondField) { if (!m_PictureParams.bSecondField) { m_rtStart = rtStart; m_rtStop = rtStop; m_pSampleToDeliver = NULL; hr = GetFreeSurfaceIndex(m_nSurfaceIndex, &m_pSampleToDeliver, rtStart, rtStop); if (FAILED(hr)) { ASSERT(hr == VFW_E_NOT_COMMITTED); // Normal when stop playing return hr; } } } else { m_rtStart = rtStart; m_rtStop = rtStop; m_pSampleToDeliver = NULL; hr = GetFreeSurfaceIndex(m_nSurfaceIndex, &m_pSampleToDeliver, rtStart, rtStop); if (FAILED(hr)) { ASSERT(hr == VFW_E_NOT_COMMITTED); // Normal when stop playing return hr; } } if (m_pSampleToDeliver == NULL) { return S_FALSE; } CHECK_HR_TRACE(BeginFrame(m_nSurfaceIndex, m_pSampleToDeliver)); if (m_bSecondField) { if (!m_PictureParams.bSecondField) { UpdatePictureParams(m_nSurfaceIndex); } } else { UpdatePictureParams(m_nSurfaceIndex); } TRACE_MPEG2("CDXVADecoderMpeg2::DecodeFrame() : Surf = %d, PictureType = %d, SecondField = %d, m_nNextCodecIndex = %d, rtStart = [%I64d]\n", m_nSurfaceIndex, nSliceType, m_PictureParams.bSecondField, m_nNextCodecIndex, rtStart); CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_PictureParametersBufferType, sizeof(m_PictureParams), &m_PictureParams)); CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_InverseQuantizationMatrixBufferType, sizeof(m_QMatrixData), &m_QMatrixData)); // Send bitstream to accelerator CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_SliceControlBufferType, sizeof(DXVA_SliceInfo)*m_nSliceCount, &m_SliceInfo)); CHECK_HR_TRACE(AddExecuteBuffer(DXVA2_BitStreamDateBufferType, nSize, pDataIn, &nSize)); // Decode frame CHECK_HR_TRACE(Execute()); CHECK_HR_TRACE(EndFrame(m_nSurfaceIndex)); if (m_bSecondField) { if (m_PictureParams.bSecondField) { AddToStore(m_nSurfaceIndex, m_pSampleToDeliver, (m_PictureParams.bPicBackwardPrediction != 1), m_rtStart, m_rtStop, false, (FF_FIELD_TYPE)nFieldType, (FF_SLICE_TYPE)nSliceType, FFGetCodedPicture(m_pFilter->GetAVCtx())); hr = DisplayNextFrame(); } } else { AddToStore(m_nSurfaceIndex, m_pSampleToDeliver, (m_PictureParams.bPicBackwardPrediction != 1), m_rtStart, m_rtStop, false, (FF_FIELD_TYPE)nFieldType, (FF_SLICE_TYPE)nSliceType, FFGetCodedPicture(m_pFilter->GetAVCtx())); hr = DisplayNextFrame(); } m_bFlushed = false; return hr; }
// Render the scene. void D3D12Multithreading::OnRender() { BeginFrame(); #if SINGLETHREADED for (int i = 0; i < NumContexts; i++) { WorkerThread(reinterpret_cast<LPVOID>(i)); } MidFrame(); EndFrame(); m_commandQueue->ExecuteCommandLists(_countof(m_pCurrentFrameResource->m_batchSubmit), m_pCurrentFrameResource->m_batchSubmit); #else for (int i = 0; i < NumContexts; i++) { SetEvent(m_workerBeginRenderFrame[i]); // Tell each worker to start drawing. } MidFrame(); EndFrame(); WaitForMultipleObjects(NumContexts, m_workerFinishShadowPass, TRUE, INFINITE); // You can execute command lists on any thread. Depending on the work // load, apps can choose between using ExecuteCommandLists on one thread // vs ExecuteCommandList from multiple threads. m_commandQueue->ExecuteCommandLists(NumContexts + 2, m_pCurrentFrameResource->m_batchSubmit); // Submit PRE, MID and shadows. WaitForMultipleObjects(NumContexts, m_workerFinishedRenderFrame, TRUE, INFINITE); // Submit remaining command lists. m_commandQueue->ExecuteCommandLists(_countof(m_pCurrentFrameResource->m_batchSubmit) - NumContexts - 2, m_pCurrentFrameResource->m_batchSubmit + NumContexts + 2); #endif m_cpuTimer.Tick(NULL); if (m_titleCount == TitleThrottle) { WCHAR cpu[64]; swprintf_s(cpu, L"%.4f CPU", m_cpuTime / m_titleCount); SetCustomWindowText(cpu); m_titleCount = 0; m_cpuTime = 0; } else { m_titleCount++; m_cpuTime += m_cpuTimer.GetElapsedSeconds() * 1000; m_cpuTimer.ResetElapsedTime(); } // Present and update the frame index for the next frame. PIXBeginEvent(m_commandQueue.Get(), 0, L"Presenting to screen"); ThrowIfFailed(m_swapChain->Present(0, 0)); PIXEndEvent(m_commandQueue.Get()); m_frameIndex = m_swapChain->GetCurrentBackBufferIndex(); // Signal and increment the fence value. m_pCurrentFrameResource->m_fenceValue = m_fenceValue; ThrowIfFailed(m_commandQueue->Signal(m_fence.Get(), m_fenceValue)); m_fenceValue++; }
void KX_KetsjiEngine::Render() { if(m_usedome){ RenderDome(); return; } KX_Scene* firstscene = *m_scenes.begin(); const RAS_FrameSettings &framesettings = firstscene->GetFramingType(); m_logger->StartLog(tc_rasterizer, m_kxsystem->GetTimeInSeconds(), true); SG_SetActiveStage(SG_STAGE_RENDER); // hiding mouse cursor each frame // (came back when going out of focus and then back in again) if (m_hideCursor) m_canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE); // clear the entire game screen with the border color // only once per frame m_canvas->BeginDraw(); if (m_drawingmode == RAS_IRasterizer::KX_TEXTURED) { m_canvas->SetViewPort(0, 0, m_canvas->GetWidth(), m_canvas->GetHeight()); if (m_overrideFrameColor) { // Do not use the framing bar color set in the Blender scenes m_canvas->ClearColor( m_overrideFrameColorR, m_overrideFrameColorG, m_overrideFrameColorB, 1.0 ); } else { // Use the framing bar color set in the Blender scenes m_canvas->ClearColor( framesettings.BarRed(), framesettings.BarGreen(), framesettings.BarBlue(), 1.0 ); } // clear the -whole- viewport m_canvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER|RAS_ICanvas::DEPTH_BUFFER); } m_rasterizer->SetEye(RAS_IRasterizer::RAS_STEREO_LEFTEYE); // BeginFrame() sets the actual drawing area. You can use a part of the window if (!BeginFrame()) return; KX_SceneList::iterator sceneit; for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); sceneit++) // for each scene, call the proceed functions { KX_Scene* scene = *sceneit; KX_Camera* cam = scene->GetActiveCamera(); // pass the scene's worldsettings to the rasterizer SetWorldSettings(scene->GetWorldInfo()); // this is now done incrementatlly in KX_Scene::CalculateVisibleMeshes //scene->UpdateMeshTransformations(); // shadow buffers RenderShadowBuffers(scene); // Avoid drawing the scene with the active camera twice when it's viewport is enabled if(cam && !cam->GetViewport()) { if (scene->IsClearingZBuffer()) m_rasterizer->ClearDepthBuffer(); m_rendertools->SetAuxilaryClientInfo(scene); // do the rendering RenderFrame(scene, cam); } list<class KX_Camera*>* cameras = scene->GetCameras(); // Draw the scene once for each camera with an enabled viewport list<KX_Camera*>::iterator it = cameras->begin(); while(it != cameras->end()) { if((*it)->GetViewport()) { if (scene->IsClearingZBuffer()) m_rasterizer->ClearDepthBuffer(); m_rendertools->SetAuxilaryClientInfo(scene); // do the rendering RenderFrame(scene, (*it)); } it++; } PostRenderScene(scene); } // only one place that checks for stereo if(m_rasterizer->Stereo()) { m_rasterizer->SetEye(RAS_IRasterizer::RAS_STEREO_RIGHTEYE); if (!BeginFrame()) return; for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); sceneit++) // for each scene, call the proceed functions { KX_Scene* scene = *sceneit; KX_Camera* cam = scene->GetActiveCamera(); // pass the scene's worldsettings to the rasterizer SetWorldSettings(scene->GetWorldInfo()); if (scene->IsClearingZBuffer()) m_rasterizer->ClearDepthBuffer(); //pass the scene, for picking and raycasting (shadows) m_rendertools->SetAuxilaryClientInfo(scene); // do the rendering //RenderFrame(scene); RenderFrame(scene, cam); list<class KX_Camera*>* cameras = scene->GetCameras(); // Draw the scene once for each camera with an enabled viewport list<KX_Camera*>::iterator it = cameras->begin(); while(it != cameras->end()) { if((*it)->GetViewport()) { if (scene->IsClearingZBuffer()) m_rasterizer->ClearDepthBuffer(); m_rendertools->SetAuxilaryClientInfo(scene); // do the rendering RenderFrame(scene, (*it)); } it++; } PostRenderScene(scene); } } // if(m_rasterizer->Stereo()) EndFrame(); }
void KX_KetsjiEngine::RenderDome() { GLuint viewport[4]={0}; glGetIntegerv(GL_VIEWPORT,(GLint *)viewport); m_dome->SetViewPort(viewport); KX_Scene* firstscene = *m_scenes.begin(); const RAS_FrameSettings &framesettings = firstscene->GetFramingType(); m_logger->StartLog(tc_rasterizer, m_kxsystem->GetTimeInSeconds(), true); // hiding mouse cursor each frame // (came back when going out of focus and then back in again) if (m_hideCursor) m_canvas->SetMouseState(RAS_ICanvas::MOUSE_INVISIBLE); // clear the entire game screen with the border color // only once per frame m_canvas->BeginDraw(); // BeginFrame() sets the actual drawing area. You can use a part of the window if (!BeginFrame()) return; KX_SceneList::iterator sceneit; KX_Scene* scene; int n_renders=m_dome->GetNumberRenders();// usually 4 or 6 for (int i=0;i<n_renders;i++){ m_canvas->ClearBuffer(RAS_ICanvas::COLOR_BUFFER|RAS_ICanvas::DEPTH_BUFFER); for (sceneit = m_scenes.begin();sceneit != m_scenes.end(); sceneit++) // for each scene, call the proceed functions { scene = *sceneit; KX_Camera* cam = scene->GetActiveCamera(); m_rendertools->BeginFrame(m_rasterizer); // pass the scene's worldsettings to the rasterizer SetWorldSettings(scene->GetWorldInfo()); // shadow buffers if (i == 0){ RenderShadowBuffers(scene); } // Avoid drawing the scene with the active camera twice when it's viewport is enabled if(cam && !cam->GetViewport()) { if (scene->IsClearingZBuffer()) m_rasterizer->ClearDepthBuffer(); m_rendertools->SetAuxilaryClientInfo(scene); // do the rendering m_dome->RenderDomeFrame(scene,cam, i); //render all the font objects for this scene RenderFonts(scene); } list<class KX_Camera*>* cameras = scene->GetCameras(); // Draw the scene once for each camera with an enabled viewport list<KX_Camera*>::iterator it = cameras->begin(); while(it != cameras->end()) { if((*it)->GetViewport()) { if (scene->IsClearingZBuffer()) m_rasterizer->ClearDepthBuffer(); m_rendertools->SetAuxilaryClientInfo(scene); // do the rendering m_dome->RenderDomeFrame(scene, (*it),i); //render all the font objects for this scene RenderFonts(scene); } it++; } // Part of PostRenderScene() m_rendertools->MotionBlur(m_rasterizer); scene->Render2DFilters(m_canvas); // no RunDrawingCallBacks // no FlushDebugLines } m_dome->BindImages(i); } m_canvas->EndFrame();//XXX do we really need that? m_canvas->SetViewPort(0, 0, m_canvas->GetWidth(), m_canvas->GetHeight()); if (m_overrideFrameColor) //XXX why do we want { // Do not use the framing bar color set in the Blender scenes m_canvas->ClearColor( m_overrideFrameColorR, m_overrideFrameColorG, m_overrideFrameColorB, 1.0 ); } else { // Use the framing bar color set in the Blender scenes m_canvas->ClearColor( framesettings.BarRed(), framesettings.BarGreen(), framesettings.BarBlue(), 1.0 ); } m_dome->Draw(); // Draw Callback for the last scene #ifdef WITH_PYTHON scene->RunDrawingCallbacks(scene->GetPostDrawCB()); #endif EndFrame(); }
int main(int argc, char *argv[]){ # ifdef UNIX static char state[256]; initstate(1997,state,256); # else Exit_wait(1); # endif Set_comment_char(';'); StartTime(); char *cfgfile="Params.dta"; if(argc>1)cfgfile=argv[1]; int no_remove=1; if(argc>2)if(strstr(argv[2],"new"))no_remove=0; Open_param_file(cfgfile); int nions,i; Read_param("Number of ions: %d",&nions); Read_param("Ionisation degree: %d",&i); ion_charge=i; double imass=1.; Set_stop(0); if(Read_param("Ion mass: %lf",&imass)){ printf("Non-symmetric plasma specified!\n"); non_symm=1; } char tmpstr[256]; int sep_cm=0; if(Read_param("Center-of-mass for components: %s",tmpstr)){ if(strstr(tmpstr,"separate")){ printf("Plasma with separated center of masses specified!\n"); sep_cm=1; } } Plasma *TheGas; // allocation of the Gas double bdens, bTv; int bq; int bunch=Read_param("Bunch propagation: %lf, %lf, %d",&bdens,&bTv,&bq); if(bunch>0){ printf("Bunch in plasma specified!\n"); if(bunch!=3){ msg_error("Invalid bunch specification!\n"); exit(1); } bunch=1; bTv=sqrt(3*nions*i*bTv); // converting temperature to velocity TheGas=(Plasma *)new PlasmaBunch(bdens,bTv,bq,nions,i,imass); } else{ TheGas=new Plasma(nions,i,imass); bunch=0; } Plasma &Gas=*TheGas; Gas.non_symm=non_symm; Gas.one_center=1-sep_cm; char dataname[50]; Read_param("Data name: %s",dataname); strncpy(Gas.dataname,dataname,50); char ofile[256], pfile[256]="poten.dat"; strcat(strcpy(pfile,dataname),".pot"); Read_param("Output file: %s",ofile); if(strstr(ofile,"default")){ strcpy(ofile,dataname); strcat(ofile,".eq"); } Read_param("Log file: %s",logfile); if(strstr(logfile,"default")){ strcpy(logfile,dataname); strcat(logfile,".log"); } Parameter *p; int np=InitParameters(&p); double T,Gamma; potspec_t reader; reader.read_spec(cfgfile); Gas.potential=reader.potential; strncpy(Gas.charpot,reader.charpot,50); /* Read_param("Potential: %s",tmpstr); strncpy(Gas.charpot,tmpstr,50); if(strstr(tmpstr,"Kelbg"))Gas.potential=PotentialKELBG; else if(strstr(tmpstr,"Lennard-Johnes"))Gas.potential=PotentialJONES; else if(strstr(tmpstr,"Deutsch"))Gas.potential=PotentialDEUTSCH; else if(strstr(tmpstr,"Erf"))Gas.potential=PotentialERF; else if(strstr(tmpstr,"Cutoff")){ if(!strcmp(tmpstr,"Cutoff1")){ Gas.potential=PotentialCUT1; } else{ Gas.potential=PotentialCUT; Read_param("Cutoff value*: %lf",&E_cut); } } else if(strstr(tmpstr,"ln")){ Gas.potential=PotentialLN; Read_param("Cutoff value*: %lf",&E_cut); } else if(strstr(tmpstr,"table")){ Gas.potential=PotentialTAB; Read_param("Potential table file: %s",tmpstr); Close_param_file(); ReadPotential(tmpstr); Open_param_file(cfgfile); } else serror("Unknown potential type specified!\n"); Read_param("Pauli part: %s",tmpstr); if(strstr(tmpstr,"n"))Pauli_part=0; double Lambda, Lambda_set; Read_param("R0: %s",tmpstr); if(strstr(tmpstr,"default"))Lambda_set=0.; else Lambda_set=atof(tmpstr); double Clam_ep=1.,Clam_ee=1; Read_param("e-e R0 coefficient: %lf",&Clam_ee); Read_param("e-p R0 coefficient: %lf",&Clam_ep); */ int ask=0; Read_param("Dialog: %s",tmpstr); if(strstr(tmpstr,"y"))ask=1; auto_rf=0; Gf=10.; Read_param("Random force strength: %s",tmpstr); if(strstr(tmpstr,"auto"))auto_rf=1; else if(strstr(tmpstr,"fluct"))auto_rf=2; if(!sscanf(tmpstr,"%lf",&Gf) && auto_rf==0)serror("Can't read Random force strength\n"); Read_param("Scale velocities: %s",tmpstr); if(strstr(tmpstr,"y"))scale_vel=1; Read_param("Delta: %lf",&delta); Read_param("Trajectory write interval: %ld",&wr_int); if(wr_int<=0)wr_int=-1; int new_rec=0; long wr_ions=0, wr_enseq=-1; Set_stop(0); if(Read_param("Ions write interval: %ld",&wr_ions)){ new_rec=1; if(!Read_param("Electrons write sequence: %ld",&wr_enseq))wr_enseq=-1; } Set_stop(1); Read_param("Steps to check equillibrium: %ld",&chk_nsteps); Read_param("Steps with random force: %ld",&rf_nsteps); Read_param("Check steps with random force: %ld",&tst_nsteps); Read_param("Steps in equillibrium: %ld",&eq_nsteps); Read_param("Time step in equillibrium: %lf",&eq_dt); Read_param("Time step for random force: %lf",&rf_dt0); char trfile[256]="trajectory"; int wr_tr=0; Set_stop(0); /*int pot_corr=0; if(Read_param("Potential correction: %s",tmpstr)){ if(strstr(tmpstr,"y")){ pot_corr=1; strcat(Gas.charpot," corr."); } }*/ if(Read_param("Total energy stability: %lf",&stab_acc))e_stab=1; if(Read_param("Positive cutoff: %lf",&E_negcut))neg_cut=1; else neg_cut=0; if(!Read_param("Random generator *:>",tmpstr))strcpy(tmpstr,"3"); cList rndlist(tmpstr); int nrepeats=1; if(!Read_param("Repeats: %d",&nrepeats))nrepeats=1; char mdistrfile[256]="r-r.distrib"; double rr_r0=0., rr_r1=-1.; if(Read_param("Write r-r distribution: %s",tmpstr)){ if(strstr(tmpstr,"y")){ write_distr=1; if(!Read_param("r-r file: %s",mdistrfile)||strstr(mdistrfile,"default")){ strcpy(mdistrfile,"%s%d.rr"); } if(Read_param("r-r range: %lf, %lf",&rr_r0,&rr_r1)!=2){ rr_r0=0.; rr_r1=-1.; } } } if(Read_param("Soft step: %s",tmpstr)){ if(strstr(tmpstr,"n"))soft_step=0; } if(Read_param("Soft random force: %s",tmpstr)){ if(strstr(tmpstr,"y")){ rf_sw_off=1; Set_stop(1); Read_param("Switch off steps: %ld",&sw_nsteps); Set_stop(0); } else rf_sw_off=0; } if(Read_param("Relative step: %s",tmpstr)){ if(strstr(tmpstr,"y"))rel_step=1; } if(Read_param("Animation : %s",&tmpstr)){ if(strstr(tmpstr,"y")){ if(!Read_param("Film directory: %s",filmdir)||strstr(filmdir,"default")){ strcpy(filmdir,"film/"); } } } in_cs=-1.; Read_param("Initial cluster size: %lf",&in_cs); int restart=0,load_fried=0; int new_input=0; char inptrj[256]; if(Read_param("Restart: %s",tmpstr)){ if(strstr(tmpstr,"y")){ restart=1; if(Read_param("Load Friedemann: %s",tmpstr)){ if(strstr(tmpstr,"y"))load_fried=1; } if(Read_param("Input from: %s",inptrj))new_input=1; } } long wtype=0; if(Read_param("Trajectory file: %s",&trfile)){ if(strstr(trfile,"default"))strcpy(trfile,"%s%d.r"); Set_stop(1); wr_tr=1; Read_param("In output:>",tmpstr); if(strstr(tmpstr,"vel"))wtype|=VEL; if(strstr(tmpstr,"coord"))wtype|=COORD; if(strstr(tmpstr,"flow"))wtype|=FLOW; Set_stop(0); } else printf("Warning: no trajectory file\n"); int mc_one=0; int mc_diff=0; int auto_adjust=1; double mc_inistep; int no_equilibr=0; Set_stop(1); if(Read_param("Equilibration procedure: %s",tmpstr)){ if(strstr(tmpstr,"monte-carlo")){ Set_stop(1); mc_equil=1; Read_param("One particle MC-step: %s",tmpstr); if(strstr(tmpstr,"y")){ mc_one=1; // rf_dt0/=Gas.n; } Read_paramn(2,"MC step mode and value: %s %lf",tmpstr, &mc_inistep); if(strstr(tmpstr,"auto"))auto_adjust=1; else if(strstr(tmpstr,"stable"))auto_adjust=0; else serror("Unknown MC step mode.\n"); Set_stop(0); mc_diff=0; if(Read_param("MC different temperatures: %s",tmpstr)){ if(strstr(tmpstr,"y")){ if(mc_one)serror("Can use different MC temperatures\n" "only in MC one-particle mode!\n"); mc_diff=1; } } } else{ mc_equil=0; if(strstr(tmpstr,"off"))no_equilibr=1; else if(!strstr(tmpstr,"random-force")){ serror("Unknown equilibration procedure: %s\n",tmpstr); } } } Set_stop(0); mc_calc=0; if(Read_param("Equilibrium calculation: %s",tmpstr)){ if(strstr(tmpstr,"monte-carlo")){ Set_stop(1); mc_calc=1; Read_param("One particle MC-step: %s",tmpstr); if(strstr(tmpstr,"y")){ mc_one=1; // rf_dt0/=Gas.n; } Read_paramn(2,"MC step mode and value: %s %lf",tmpstr, &mc_inistep); if(strstr(tmpstr,"auto"))auto_adjust=1; else if(strstr(tmpstr,"stable"))auto_adjust=0; else serror("Unknown MC step mode.\n"); Set_stop(0); mc_diff=0; if(Read_param("MC different temperatures: %s",tmpstr)){ if(strstr(tmpstr,"y")){ if(mc_one)serror("Can use different MC temperatures\n" "only in MC one-particle mode!\n"); mc_diff=1; } } } } //# ifdef UNIX char out_dirs[250]="./",out_dirl[250]="./"; if(Read_param("Data output directory: %s",out_dirs)){ if(out_dirs[strlen(out_dirs)-1]!='/')strcat(out_dirs,"/"); sprintf(tmpstr,out_dirs,dataname); strcpy(out_dirs,tmpstr); # ifdef UNIX if(mkdir(out_dirs,S_IRWXU|S_IRGRP|S_IROTH)){ if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n", out_dirs,strerror(errno)); } sprintf(tmpstr,"cp %s %s%s.cfg",cfgfile,out_dirs,dataname); //strcat(strcat(tmpstr,dataname),".cfg"); if(system(tmpstr)==-1) printf("\nExec: %s\n",strerror(errno)); # else if(_mkdir(out_dirs)){ if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n", out_dirs,strerror(errno)); } char cfgfilef[_MAX_PATH], out_dirsf[_MAX_PATH]; _fullpath(cfgfilef, cfgfile, _MAX_PATH); _fullpath(out_dirsf, out_dirs, _MAX_PATH); sprintf(tmpstr,"copy %s %s%s.cfg",cfgfilef,out_dirsf,dataname); //strcat(strcat(tmpstr,dataname),".cfg"); if(system(tmpstr)==-1) printf("\nExec: %s\n",strerror(errno)); # endif strcpy(ofile,strcat(strcpy(tmpstr,out_dirs),ofile)); strcpy(mdistrfile,strcat(strcpy(tmpstr,out_dirs),mdistrfile)); strcpy(sfile,strcat(strcpy(tmpstr,out_dirs),sfile)); strcpy(pfile,strcat(strcpy(tmpstr,out_dirs),pfile)); if(wr_film){ strcpy(filmdir,strcat(strcpy(tmpstr,out_dirs),ofile)); # ifdef UNIX if(mkdir(filmdir,S_IRWXU|S_IRGRP|S_IROTH)){ # else if(_mkdir(filmdir)){ # endif if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n", filmdir,strerror(errno) ); } strcat(filmdir,dataname); } } if(Read_param("Process output directory: %s",out_dirl)){ if(out_dirl[strlen(out_dirl)]!='/')strcat(out_dirl,"/"); sprintf(tmpstr,out_dirl,dataname); strcpy(out_dirl,tmpstr); # ifdef UNIX if(mkdir(out_dirl,S_IRWXU|S_IRGRP|S_IROTH)){ # else if(_mkdir(out_dirl)){ # endif if(errno!=EEXIST)serror("Can not create directory: %s.\n%s\n", out_dirl,strerror(errno)); } strcpy(logfile,strcat(strcpy(tmpstr,out_dirl),logfile)); strcpy(trfile,strcat(strcpy(tmpstr,out_dirl),trfile)); } //# endif // UNIX int spwn_trj=0; if(Read_param("Spawn trajectories: %s",tmpstr)){ if(strstr(tmpstr,"y")){ spwn_trj=1; //Read_paramn(1,"Spawn frame: %d",&spwn_frame); no_test=1; // no RF test for equilibrartion } } Gas.stable_ions=0; if(Read_param("Stable ions: %s",tmpstr)){ if(strstr(tmpstr,"y")){ Gas.stable_ions=1; } } int repc_i=0; if(!Read_param("Repeat counter start: %d",&repc_i))repc_i=0; int irescale=0; if(Read_param("Ion velocity rescale: %s",tmpstr)){ if(strstr(tmpstr,"y"))irescale=1; if(strstr(tmpstr,"reset"))irescale=2; } /* int limrescale=0; if(Read_param("Rescale on electron temperature reached: %lf %ld",&limTe,&limstpe)==2){ limrescale=1; limspec=0x2; limrescale_switch(0); } */ int limrescale=0; int inc_mes=0; if(Read_param("Incremental measurement (T0,dT,mes_steps): %lf,%lf,%ld",&incT0,&incdT,&incStp)==3){ inc_mes=1; fixT=incT0; limstpe=1; limstpi=1; } Set_stop(1); Gas.ini_Te=Gas.ini_Ti=1.; // by default equal temperatures Read_param("Initial velocity distribution: %s",tmpstr); if(strstr(tmpstr,"maxwell"))in_distr=MAXWELL; else if(strstr(tmpstr,"max_polak"))in_distr=MAXWELL_P; else if(strstr(tmpstr,"zero")){ if(mc_equil){ in_distr=MAXWELL; printf("Warning: setting 'maxwell' initial vel. distribution for MC!\n"); } else in_distr=ZEROVEL; } else if(strstr(tmpstr,"separate")){ in_distr=SEPARATE; int &ndistr=Gas.idistr; int nr; char relstr[200]; for(i=0;i<2;i++){ if(i==0)nr= Read_param("Electron velocity distribution: %s %lf %s",tmpstr,&Gas.ini_Te,relstr); else{ nr= Read_param("Ion velocity distribution: %s %lf %s",tmpstr,&Gas.ini_Ti,relstr); Gas.edistr=ndistr; } if(nr<2){ serror("Can't read velocity distribution parameters!\n"); } if(nr>=2){ if(strstr(relstr,"abs")){ if(i==0)Gas.rel_Te=0; else Gas.rel_Ti=0; } } if(strstr(tmpstr,"maxwell"))ndistr=MAXWELL; else if(strstr(tmpstr,"max_polak"))ndistr=MAXWELL_P; else if(strstr(tmpstr,"zero"))ndistr=ZEROVEL; else { printf("Warning: unknown distribution '%s', setting to 'zero'\n",tmpstr); ndistr=ZEROVEL; } } } else{ printf("Warning: unknown distribution '%s', setting to 'zero'\n",tmpstr); in_distr=ZEROVEL; } Close_param_file(); Statistics sT(&Gas.T),sEcoul(&Gas.Ecoul),sEpotent(&Gas.Epotent),sQuant(&Gas.Quant), sEtot(&Gas.Etot); Statistics sTi(&Gas.Ti),sTe(&Gas.Te); const int nstat=7; Statistics *stats[nstat]={&sT,&sEcoul,&sEpotent,&sQuant,&sEtot,&sTi,&sTe}; SetTableform(GNU); if(no_remove){ no_remove=CheckData(sfile,ofile,dataname,np,p,ask); } if(restart && !wr_tr && !new_input)serror("No trajectory file specified, cannot restart.\n"); if(restart && new_input && wr_tr) if(!strcmp(trfile,inptrj)) serror("Equal names for input and output trj-files.\n"); FILE *f1; if(!no_remove || no_remove==2){ if(!no_remove)f1=Err_fopen(ofile,"wt"); else f1=Err_fopen(ofile,"at"); BeginFrame(f1,dataname,np,p); fprintf(f1,"%9.9s %9.9s %9.9s %9.9s %9.9s %9.9s %9.9s %9.9s\n", "T","Ecoul","Epotent","Equant","dT","dEcoul","dEpotent","dEquant"); fclose(f1); } double t=0; f1=fopen(logfile,"rt"); if(f1){ if(!restart && !no_remove){ fclose(f1); remove(logfile); } else {// reading 'log' time fseek(f1,0,SEEK_END); long pos=ftell(f1)-4; do{ fseek(f1,pos,SEEK_SET); if(fgetc(f1)=='\n'){ fscanf(f1,"%lf",&t); //printf("new t: %f\n",t); break; } pos--; }while(pos>=0); fclose(f1); } } int ccount=CurrentCount(np,p); WriteStatus(!ccount,sfile,dataname,np,p); do{ //Gamma=get_pc(p[0]); //T=get_pc(p[1]); char ctrfile[256]; sprintf(ctrfile,trfile,dataname,ccount); char ss[100]; sprintf(ss,"%s%d",dataname,ccount); sprintf(distrfile,mdistrfile,dataname,ccount); // StatusLine(str,np,p); //show_status(440,str); long i,n,m,nf=0; //Gas.adjustTG(T,Gamma); AdjustGas(Gas,p,np); T=Gas.par_T; Gamma=Gas.par_Gamma; double me=0.9109534e-30; double qe=1.602e-19; double Kb=1.38e-23; double unit_t=qe*qe/(4*M_PI*8.854e-12)*sqrt(me); // overcoming g++ bug with -O3 double jojo=Kb*T*1.e4; //printf("c2: %e\n",jojo); jojo=jojo*jojo*jojo; jojo=sqrt(jojo); //printf("c21: %e\n",jojo); unit_t/=jojo; //printf("c3:\n"); double unit_h=Kb*T*1e4*unit_t; double h_qwer=1.0545887e-34; reader.calc_lambda(T,Gas.ini_Te,Gas.ini_Ti,Gas.mass); /* if(!non_symm){ if(Lambda_set!=0.0){ Lambda=Lambda_set/unit_l; equal_lambda=0; } else { Lambda=0.179*sqrt(T); equal_lambda=1; } Lambda_pauli=0.179*sqrt(T); //non_symm=0; Lambda_ee=Lambda_pp=Lambda*Clam_ee; if(fabs(Clam_ee-1.)>1e-5)equal_lambda=0; Lambda_ep=Lambda*Clam_ep; } else{ if(Lambda_set!=0.0){ serror("Can not setup lambda for nonsymmetric plasma.\n"); //Lambda=Lambda_set/unit_l; //Lambda_ep=Lambda*Clam_ep; //Lambda_ee=Lambda*Clam_ee; //equal_lambda=0; } else{ if(strstr(Gas.charpot,"Deutsch")){ printf("Setting lambda values for Deutsch potential !!!\n"); Lambda_pauli=h_qwer/(unit_h); Lambda=Lambda_pauli/sqrt(2*M_PI); double m_ee=0.5, m_pp=0.5*Gas.mass, m_ep=Gas.mass/(1.+Gas.mass); Lambda_ee=Lambda/sqrt(m_ee); Lambda_pp=Lambda/sqrt(m_pp); Lambda_ep=Lambda/sqrt(m_ep); } else { //if(strstr(Gas.charpot,"Kelbg")){ printf("Setting lambda values for Kelbg potential !!!\n"); Lambda_pauli=h_qwer/(unit_h); Lambda=Lambda_pauli; double m_ee=0.5, m_pp=0.5*Gas.mass, m_ep=Gas.mass/(1.+Gas.mass); double t_ep=Gas.ini_Te; double t_pp=Gas.ini_Ti; double t_ee=Gas.ini_Te; Lambda_ee=Lambda/sqrt(2*m_ee*t_ee); Lambda_pp=Lambda/sqrt(2*m_pp*t_pp); Lambda_ep=Lambda/sqrt(2*m_ep*t_ep); } } } */ if(rel_step)rf_dtcoeff=1./Gas.Wpe; double kk=(1.602e-19)*(1.602e-19)/(4*M_PI*1.38e-23*T*1e4*8.854e-12); printf("Simulation parameters:\n"); printf("Gamma =%f\n" "L=%f=%12e m\n" "lambda=%f=%12e m\n" "1/Wp=%f\n" "Rd=%f\n",Gamma,Gas.L, Gas.L*kk,reader.Lambda,reader.Lambda*kk,1./Gas.Wpe,RDebye); printf("Density = %1.2e cm^(-3)\n" "T= %f K\n",Gas.par_density*1e19,T*1e4); printf("Time step relations:\n"); printf("dtrf*Wp= %f, dteq*Wp= %f\n", (rel_step ? rf_dt0 : rf_dt0*Gas.Wpe), (rel_step ? eq_dt : eq_dt*Gas.Wpe)); double t_inter=RDebye/sqrt(2*getEmax(Gas)); printf("dtrf/tint= %f, dteq/tint= %f\n", rf_dt0*rf_dtcoeff/t_inter, eq_dt*rf_dtcoeff/t_inter); reader.calc_correction(Gas.par_T); reader.write_pot(pfile, Gas.L); /* //if(ccount==1)t/=Gas.Wpe; if(pot_corr){ //Correction(IONION,Gas.potential,Gas.par_T); Correction(IONELC,Gas.potential,Gas.par_T); Correction(ELCELC,Gas.potential,Gas.par_T); }*/ Statistics rs[nstat]; int repi=0; int repc=repc_i; do{ //through nrepeats printf("\nStarting calculation #%d...\n",repc); flm_count=0; if(repc>0){ repi++; sprintf(tmpstr,"%02d",repc); if(repi>1){ distrfile[strlen(distrfile)-2]=0; ctrfile[strlen(ctrfile)-2]=0; } strcat(distrfile,tmpstr); strcat(ctrfile,tmpstr); } if(write_distr){ DRRee.init(rr_r0,(rr_r1>0 ? rr_r1 : Gas.L/2),400); DRRep.init(rr_r0,(rr_r1>0 ? rr_r1 : Gas.L/2),400); if(non_symm)DRRpp.init(0,(rr_r1>0 ? rr_r1 : Gas.L/2),400); } long ftype=wtype; if(restart){ printf("restarting...\n"); if((mc_equil && spwn_trj) || mc_calc){ mc_equil=-1; MC = new mc_simm(Gas,mc_inistep*Gas.L /*Gas.L/Gas.n*/,0.5, mc_one,mc_diff); if(!MC)serror("Cannot allocate MCsimm\n"); MC->auto_adjust=auto_adjust; } else mc_equil=0; if(!new_input)strcpy(inptrj,ctrfile); if(load_fried){ LoadFriedemann(inptrj,Gas); Gas.dt=eq_dt; if(rel_step)Gas.dt/=Gas.Wpe; if(eq_nsteps<wr_int)eq_nsteps=wr_int; m=wr_int; n=eq_nsteps/m; Gas.ext_force=void_force1; wr_tr=0; ftype=0; } else{ Gas.dt=(rel_step ? eq_dt/Gas.Wpe : eq_dt); Trajectory.Check(inptrj,wtype,Gas,wr_int,wr_ions,wr_enseq,new_input); if(Trajectory.wtype !=0 && !new_input){ Gas.dt=Trajectory.AdjustInterval(Gas.dt); } long stp; if(!new_input){ stp=Trajectory.ReloadGas(Gas,1); t=stp*Trajectory.file_dt(); nf=(long)(t/Gas.dt/wr_int+0.01); } else{ stp=Trajectory.ReloadGas(Gas,0); t=0; nf=0; } printf("t= %f, nf= %ld, %f\n",t,nf,(t/Gas.dt/wr_int)); //serror("Restart is not yet implemented !\n"); Gas.ext_force=void_force1; } //restart=0; } else{ rand_init=rndlist.step(); if(rand_init<0){ rndlist.rewind(); rand_init=rndlist.step(); } strcat(distrfile,"e"); if((mc_equil && (!spwn_trj || (repc==repc_i && spwn_trj))) || mc_calc){ mc_equil=1; MC = new mc_simm(Gas,mc_inistep*Gas.L /*Gas.L/Gas.n*/,0.5, mc_one,mc_diff); if(!MC)serror("Cannot allocate MCsimm\n"); MC->auto_adjust=auto_adjust; } if(!no_equilibr){ if(!spwn_trj || (spwn_trj && repc==repc_i)){ limrescale_switch(0); Equillibrium(t,Gas,stats,nstat); limrescale_switch(limrescale); } } else{ Gas.r0=0.05; Gas.init_config(in_cs,in_distr); } distrfile[strlen(distrfile)-1]=0; // deleting 'e' if(mc_equil){ if(spwn_trj){ Gas.init_vel(in_distr); } else if(!mc_calc){ delete MC; mc_equil=-1; } else mc_equil=1; } Gas.dt=eq_dt; if(rel_step)Gas.dt/=Gas.Wpe; } if(irescale){ if(irescale==1)Gas.ivel_scale(1.); else Gas.init_vel(in_distr); } if(eq_nsteps<wr_int)eq_nsteps=wr_int; if(wr_int>0){ n=eq_nsteps/wr_int; m=wr_int; } else if(eq_nsteps>=500){ n=eq_nsteps/500; m=500; } else{ n=1; m=eq_nsteps; } if(wr_tr && (!restart || new_input || (restart && ftype==0))){ //WriteHeader(ctrfile,wtype,Gas,Gamma,T, ss,m); // initializing PlasmaRec Trajectory.Clear(); Trajectory.Init(ctrfile,wtype,Gas,wr_int,wr_ions,wr_enseq); } if(wr_tr && (restart && ftype==0)){ //WriteStep(ctrfile,wtype,Gas,0); } Statistics statsl[nstat]; Trajectory.valid=wr_tr; // new cycle if(bunch){ PlasmaBunch *pb=(PlasmaBunch *)&Gas; pb->start_bunch(); } for(i=nf;i<n;i++){ double term_c=1.; if(Gas.stable_ions)term_c=(double)Gas.ne/Gas.n; printf("Equilibrium calculation: %f%% complete, T= %f Et=%f\n",(i+1)*100./n,Gas.T,Gas.T*3/2*term_c+Gas.Epotent/Gas.n); if(StopStatus(sfile,3)){ StopStatus(sfile,-1); serror("Program interrupted!\n"); } if(mc_equil && spwn_trj){ mc_equil=1; double ratio=MC->get_ratio(); if(ratio<1e-10)printf("Estimated randomization steps: infinity\n"); else printf("Estimated randomization steps: %d\n",(int)(Gas.n*Gas.L/MC->dc[1]/ratio)); } MoveIt(t,m,m,Gas,stats,statsl,nstat); //if(wr_tr)WriteStep(ctrfile,wtype,Gas,i); if(write_distr)WriteDRR(distrfile); if(wr_film)WriteFilm(filmdir,Gas); } if(bunch){ PlasmaBunch *pb=(PlasmaBunch *)&Gas; pb->stop_bunch(); } if(write_distr)WriteDRR(distrfile); for(i=0;i<nstat;i++)rs[i]+=*(stats[i]); repc++; if(new_input)restart=0; }while(repc<nrepeats); if(spwn_trj)delete MC; f1=Err_fopen(ofile,"at"); MiddleFrame(f1,np,p); int gn=Gas.n; //fprintf(f1,"%9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f\n", // sT.av()*T,sEcoul.av()/gn,sEpotent.av()/gn,sQuant.av()/gn, // sT.dev()*T,sEcoul.dev()/gn,sEpotent.dev()/gn,sQuant.dev()/gn); fprintf(f1,"%9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f %9.4f\n", rs[0].av()*T,rs[1].av()/gn,rs[2].av()/gn,rs[3].av()/gn, rs[0].dev()*T,rs[1].dev()/gn,rs[2].dev()/gn,rs[3].dev()/gn); fclose(f1); ccount=CycleCount(np,p); WriteStatus(!ccount,sfile,dataname,np,p); restart=0; repc=0; }while(ccount); return 0; }
/////////////////////////////////////////////////////////////////////////////////////////////////// /// CelShadeApp::CelShadeD3D /// /// @brief /// Render a cel-shading demo using Direct3D /// @return /// N/A /////////////////////////////////////////////////////////////////////////////////////////////////// void CelShadeApp::CelShadeD3D() { ID3D11DeviceContext* pContext = m_pDxData->pD3D11Context; ID3D11Device* pDevice = m_pDxData->pD3D11Device; D3DX11_IMAGE_LOAD_INFO imageLoadInfo; memset( &imageLoadInfo, 0, sizeof(D3DX11_IMAGE_LOAD_INFO) ); imageLoadInfo.BindFlags = D3D11_BIND_SHADER_RESOURCE; imageLoadInfo.Format = DXGI_FORMAT_R8G8B8A8_UNORM; DxTextureCreateInfo shadeTexInfo; memset(&shadeTexInfo, 0, sizeof(DxTextureCreateInfo)); shadeTexInfo.flags.RenderTarget = TRUE; shadeTexInfo.flags.ShaderInput = TRUE; shadeTexInfo.format = DXGI_FORMAT_R8G8B8A8_UNORM; shadeTexInfo.width = m_screenWidth; shadeTexInfo.height = m_screenHeight; DxTexture* pShadeTex = DxTexture::Create(pDevice, &shadeTexInfo); DxTextureCreateInfo edgeTexInfo; memset(&edgeTexInfo, 0, sizeof(DxTextureCreateInfo)); edgeTexInfo.flags.RenderTarget = TRUE; edgeTexInfo.flags.ShaderInput = TRUE; edgeTexInfo.format = DXGI_FORMAT_R8G8B8A8_UNORM; edgeTexInfo.width = m_screenWidth; edgeTexInfo.height = m_screenHeight; DxTexture* pEdgeTex = DxTexture::Create(pDevice, &edgeTexInfo); // Samplers ///////////////////////////////////////////////////////////////////////////// // SamplerState PointSampler : register(s0); D3D11_SAMPLER_DESC pointSamplerDesc; memset(&pointSamplerDesc, 0, sizeof(D3D11_SAMPLER_DESC)); pointSamplerDesc.Filter = D3D11_FILTER_MIN_MAG_MIP_POINT; pointSamplerDesc.AddressU = D3D11_TEXTURE_ADDRESS_WRAP; pointSamplerDesc.AddressV = D3D11_TEXTURE_ADDRESS_WRAP; pointSamplerDesc.AddressW = D3D11_TEXTURE_ADDRESS_CLAMP; pointSamplerDesc.MinLOD = -FLT_MAX; pointSamplerDesc.MaxLOD = FLT_MAX; pointSamplerDesc.MipLODBias = 0.0f; pointSamplerDesc.MaxAnisotropy = 16; ID3D11SamplerState* pPointSampler = NULL; pDevice->CreateSamplerState(&pointSamplerDesc, &pPointSampler); // UINT numVertices = 0, numIndices = 0; VertexPTN* pVB = NULL; UINT* pIB = NULL; ImportPly("Content/dragon_vrip_res3.ply", numVertices, &pVB, numIndices, &pIB); //ImportPly("Content/bun_zipper_res4.ply", numVertices, &pVB, numIndices, &pIB); DxMeshCreateInfo meshCreateInfo = {0}; meshCreateInfo.indexCount = numIndices; meshCreateInfo.pIndexArray = pIB; meshCreateInfo.indexFormat = DXGI_FORMAT_R32_UINT; meshCreateInfo.pVertexArray = pVB; meshCreateInfo.vertexCount = numVertices; meshCreateInfo.vertexElementSize = sizeof(VertexPTN); DxMesh* pMesh = DxMesh::Create(pDevice, &meshCreateInfo); Plane p; DxMeshCreateInfo planeMeshInfo; memset(&planeMeshInfo, 0, sizeof(planeMeshInfo)); planeMeshInfo.pVertexArray = p.GetVB(); planeMeshInfo.vertexCount = p.NumVertices(); planeMeshInfo.vertexElementSize = sizeof(VertexPTN); DxMesh* pPlaneMesh = DxMesh::Create(pDevice, &planeMeshInfo); Cube c; DxMeshCreateInfo cubeMeshInfo; memset(&cubeMeshInfo, 0, sizeof(cubeMeshInfo)); cubeMeshInfo.pVertexArray = c.GetVB(); cubeMeshInfo.vertexCount = c.NumVertices(); cubeMeshInfo.vertexElementSize = sizeof(VertexPT); DxMesh* pCubeMesh = DxMesh::Create(pDevice, &cubeMeshInfo); D3D11_SUBRESOURCE_DATA cbInitData; memset(&cbInitData, 0, sizeof(D3D11_SUBRESOURCE_DATA)); // Camera Buffer CameraBufferData cameraData; memset(&cameraData, 0, sizeof(CameraBufferData)); DxBufferCreateInfo cameraBufferCreateInfo = {0}; cameraBufferCreateInfo.flags.cpuWriteable = TRUE; cameraBufferCreateInfo.elemSizeBytes = sizeof(CameraBufferData); cameraBufferCreateInfo.pInitialData = &cameraData; DxBuffer* pCameraBuffer = DxBuffer::Create(pDevice, &cameraBufferCreateInfo); // Shaders //////////////////////////////////////////////////////////////////////////////////// m_pPosTexTriVS = DxShader::CreateFromFile(pDevice, "PosTexTri", "Content/shaders/CelShade.hlsl", PosTexVertexDesc, PosTexElements); m_pPosTexNormVS = DxShader::CreateFromFile(pDevice, "PosTexNorm", "Content/shaders/CelShade.hlsl", PosTexNormVertexDesc, PosTexNormElements); m_pCelShadePS = DxShader::CreateFromFile(pDevice, "CelShade", "Content/shaders/CelShade.hlsl"); DxShader* pDetectEdges = DxShader::CreateFromFile(pDevice, "DetectEdges", "Content/shaders/CelShade.hlsl"); DxShader* pApplyTexPS = DxShader::CreateFromFile(pDevice, "ApplyTex", "Content/shaders/CelShade.hlsl"); DxShader* pCubeVS = DxShader::CreateFromFile(pDevice, "PosTex", "Content/shaders/CelShade.hlsl", PosTexVertexDesc, PosTexElements); DxShader* pCubePS = DxShader::CreateFromFile(pDevice, "CubePS", "Content/shaders/CelShade.hlsl"); //////////////////////////////////////////////////////////////////////////////////////// pContext->ClearState(); // SET RENDER STATE FLOAT clearColor[4]; clearColor[0] = 0.2f; clearColor[1] = 0.2f; clearColor[2] = 0.2f; clearColor[3] = 1.0f; D3D11_RASTERIZER_DESC shadeDesc; shadeDesc.FillMode = D3D11_FILL_SOLID; shadeDesc.CullMode = D3D11_CULL_BACK; shadeDesc.FrontCounterClockwise = FALSE; shadeDesc.DepthBias = 0; shadeDesc.DepthBiasClamp = 0.0f; shadeDesc.SlopeScaledDepthBias = 0; shadeDesc.DepthClipEnable = false; shadeDesc.ScissorEnable = false; shadeDesc.MultisampleEnable = false; shadeDesc.AntialiasedLineEnable = false; ID3D11RasterizerState* pShadeRS = NULL; pDevice->CreateRasterizerState(&shadeDesc, &pShadeRS); pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); m_pWindow->Show(); BOOL quit = false; FLOAT yRotationAngle = 0.0f; while (!quit) { ProcessUpdates(); BeginFrame(); CameraBufferData* pCameraData = NULL; // new frame, clear state pContext->ClearState(); pContext->RSSetViewports(1, &m_pDxData->viewport); pContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST); pContext->RSSetState(pShadeRS); pContext->PSSetSamplers(0, 1, &pPointSampler); pContext->OMSetRenderTargets(1, &m_pDxData->pAppRenderTargetView, m_pDxData->pAppDepthStencilTex->GetDepthStencilView()); pContext->ClearRenderTargetView(m_pDxData->pAppRenderTargetView, clearColor); pContext->ClearDepthStencilView(m_pDxData->pAppDepthStencilTex->GetDepthStencilView(), D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0, 0); ///// Draw Mesh /////////////////////////////////////////////////////////////////////////// FLOAT viewRotationY = (GetMousePos().x - (m_screenWidth / 2.0f)) /(m_screenWidth / 2.0f); viewRotationY *= (3.14159f / 4.0f); FLOAT viewRotationZ = (GetMousePos().y - (m_screenHeight / 2.0f)) /(m_screenHeight / 2.0f); viewRotationZ *= (3.14159f / 4.0f); pCameraData = reinterpret_cast<CameraBufferData*>(pCameraBuffer->Map(pContext)); pCameraData->worldMatrix = XMMatrixScaling(25, 25, 25) * XMMatrixRotationY(yRotationAngle) * XMMatrixTranslation(m_pCamera->Position().x, m_pCamera->Position().y, m_pCamera->Position().z) ; // translate world +6 in Z to position camera -9 from world origin pCameraData->viewMatrix = m_pCamera->W2C(); pCameraData->projectionMatrix = m_pCamera->C2S(); pCameraBuffer->Unmap(pContext); pCameraBuffer->BindVS(pContext, 0); pMesh->Bind(pContext); m_pPosTexNormVS->Bind(pContext); m_pCelShadePS->Bind(pContext); pMesh->Draw(pContext); ///// Detect Edges /////////////////////////////////////////////////////////////////////////// ///// Draw Light Position //////////////////////////////////////////////////////////////////// //yRotationAngle = 0; pCameraData = reinterpret_cast<CameraBufferData*>(pCameraBuffer->Map(pContext)); pCameraData->worldMatrix = XMMatrixScaling(1, 1, 1); // XMMatrixRotationY(yRotationAngle); // XMMatrixTranslation(-10, 10, 10); // translate world +6 in Z to position camera -9 from world origin pCameraData->viewMatrix = XMMatrixTranslation(0, 0, 10) * m_pCamera->W2C(); pCameraData->projectionMatrix = m_pCamera->C2S(); pCameraBuffer->Unmap(pContext); pCameraBuffer->BindVS(pContext, 0); pCubeVS->Bind(pContext); pCubePS->Bind(pContext); pCubeMesh->Bind(pContext); pCubeMesh->Draw(pContext); ///// Draw UI //////////////////////////////////////////////////////////////////////////////// ///@todo Consider moving the following UI drawing to Draw2D() m_pUI->Begin(); // Draw UI stuff m_pUI->RenderRect(); m_pUI->RenderText(); m_pUI->End(); /// Blend UI onto final image DrawUI(); m_pDxData->pDXGISwapChain->Present(0,0); EndFrame(); Sleep(50); yRotationAngle += 3.14159f / 60.0f; } // Shader Resource Views pCameraBuffer->Destroy(); // Shaders m_pCelShadePS->Destroy(); m_pCelShadePS = NULL; m_pPosTexTriVS->Destroy(); m_pPosTexTriVS = NULL; m_pPosTexNormVS->Destroy(); m_pPosTexNormVS = NULL; pApplyTexPS->Destroy(); pApplyTexPS = NULL; pPlaneMesh->Destroy(); pPlaneMesh = NULL; // Samplers pPointSampler->Release(); // Rasterizer State pShadeRS->Release(); m_pDxData->pD3D11Context->ClearState(); m_pDxData->pD3D11Context->Flush(); }