void CFlashAnimation::RepositionFlashAnimation() { if(m_pFlashPlayer) { IRenderer *pRenderer = gEnv->pRenderer; float fMovieRatio = ((float)m_pFlashPlayer->GetWidth()) / ((float)m_pFlashPlayer->GetHeight()); float fRenderRatio = ((float)pRenderer->GetWidth()) / ((float)pRenderer->GetHeight()); float fWidth = pRenderer->GetWidth(); float fHeight = pRenderer->GetHeight(); float fXPos = 0.0f; float fYPos = 0.0f; float fXOffset = (fWidth - (fMovieRatio * fHeight)); if(fRenderRatio != fMovieRatio && !(m_dock & eFD_Stretch)) { fWidth = fWidth-fXOffset; if (m_dock & eFD_Left) fXPos = 0; else if (m_dock & eFD_Right) fXPos = fXOffset; else if (m_dock & eFD_Center) fXPos = fXOffset * 0.5; } m_pFlashPlayer->SetViewport(int(fXPos),0,int(fWidth),int(fHeight)); } }
void PaintWidget::wheelEvent( QWheelEvent * event ) { IRenderer* renderer = MapData::instance()->renderer(); if ( renderer == NULL ) return; // 15 degrees is a full mousewheel "click" int numDegrees = event->delta() / 8 + m_wheelDelta; int numSteps = numDegrees / 15; m_wheelDelta = numDegrees % 15; // limit zoom int newZoom = m_request.zoom + numSteps; if ( newZoom < 0 ) newZoom = 0; if ( newZoom > m_maxZoom ) newZoom = m_maxZoom; // avoid looping event calls if ( newZoom == m_request.zoom ) return; // zoom in/out on current mouse position m_request.center = renderer->Move( width() / 2 - event->x(), height() / 2 - event->y(), m_request ); m_request.zoom = newZoom; m_request.center = renderer->Move( event->x() - width() / 2, event->y() - height() / 2, m_request ); emit zoomChanged( newZoom ); update(); event->accept(); }
void CameraApplication::CreateCamera() { if (!lastScene_) return; StringVector components; components.Push("Placeable"); components.Push("Camera"); Entity* cameraEntity = lastScene_->CreateEntity(0, components, AttributeChange::LocalOnly, false, false, true); if (!cameraEntity) { LogError("CameraApplication::CreateCamera: failed to create camera entity"); return; } cameraEntity->SetName("FreeLookCamera"); IRenderer* renderer = framework->Renderer(); if (!renderer) { LogError("CameraApplication::CreateCamera: can not assign camera; no renderer assigned"); return; } renderer->SetMainCamera(cameraEntity); TundraLogic* logic = framework->Module<TundraLogic>(); if (logic) logic->SyncManager()->SetObserver(EntityPtr(cameraEntity)); lastCamera_ = cameraEntity; lastScene_->EntityCreated.Connect(this, &CameraApplication::CheckCameraSpawnPos); CheckCameraSpawnPos(lastScene_->EntityByName("FreeLookCameraSpawnPos"), AttributeChange::Default); }
void PaintWidget::mouseMoveEvent( QMouseEvent* event ) { event->accept(); if ( m_fixed || !m_mouseDown ) return; if ( ( event->buttons() & Qt::LeftButton ) == 0 ) return; int minDiff = 7; #ifdef Q_WS_MAEMO_5 minDiff = 15; #endif if ( abs( event->x() - m_startMouseX ) + abs( event->y() - m_startMouseY ) > minDiff ) m_drag = true; if ( !m_drag ) return; IRenderer* renderer = MapData::instance()->renderer(); if ( renderer == NULL ) return; m_request.center = renderer->Move( event->x() - m_lastMouseX, event->y() - m_lastMouseY, m_request ); m_lastMouseX = event->x(); m_lastMouseY = event->y(); setKeepPositionVisible( false ); update(); }
void SkyDomeNode::_VRender(ISceneGraph* graph, chimera::RenderPath& path) { switch(path) { case CM_RENDERPATH_SKY : { if(m_textureHandle->VIsReady()) { m_textureHandle->VUpdate(); //LOG_CRITICAL_ERROR("remember me, this code is untested!, @sky.hlsl"); //tbd::TransformComponent* tc = m_actor->GetComponent<tbd::TransformComponent>(tbd::TransformComponent::COMPONENT_ID).lock().get(); //util::ICamera* cam = graph->GetCamera().get(); //tc->GetTransformation()->SetTranslate(cam->GetEyePos().x, cam->GetEyePos().y, cam->GetEyePos().z); IRenderer* renderer = CmGetApp()->VGetHumanView()->VGetRenderer(); renderer->VPushWorldTransform(*VGetTransformation()); renderer->VSetTexture(eDiffuseColorSampler, m_textureHandle.get()); //chimera::GetContext()->OMSetDepthStencilState(chimera::m_pDepthCmpStencilState, 0); m_pGeometry->VBind(); m_pGeometry->VDraw(); } else { m_textureHandle = std::static_pointer_cast<IDeviceTexture>(CmGetApp()->VGetHumanView()->VGetVRamManager()->VGetHandle(m_TextureRes)); } } break; } }
// ------------------------------------------------------------------------ void CInputDevice::CDebugPressedButtons::DebugRender() { if (g_pInputCVars->i_debugDigitalButtons) { static float deltaY = 15.f; static float startX = 50; static float startY = 400.f; static float fontSize = 1.2f; IRenderer* pRenderer = gEnv->pRenderer; if (pRenderer) { ColorF colDefault(1.f, 1.f, 0.f,1.f); m_textPos2d.x = startX; m_textPos2d.y = startY; pRenderer->Draw2dLabel(m_textPos2d.x, m_textPos2d.y, 1.1f, ColorF(0.f,1.f,0.f,1.f), false, "Controller's Digital Buttons Activity"); m_textPos2d.y+= deltaY; pRenderer->Draw2dLabel(m_textPos2d.x, m_textPos2d.y, 1.1f, ColorF(1.f,1.f,1.f,1.f), false, string().Format("CurrentFrame:[%d]", m_frameCnt)); m_textPos2d.y+= deltaY; for (size_t i=0, kSize=m_history.size(); i< kSize; ++i) { string s = string().Format("[%d] %s [%s]", m_history[i].frame, m_history[i].key.c_str(), m_history[i].state.c_str()); pRenderer->Draw2dLabel(m_textPos2d.x, m_textPos2d.y, fontSize, m_history[i].color, false, s.c_str()); m_textPos2d.y+= deltaY; } ++m_frameCnt; } } }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { switch (event) { case eFE_Initialize: pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); break; case eFE_Update: { ISystem *pSystem = GetISystem(); IRenderer *pRenderer = gEnv->pRenderer; int sysMem = pSystem->GetUsedMemory(); size_t vidMemThisFrame( 0 ); size_t vidMemRecently( 0 ); pRenderer->GetVideoMemoryUsageStats( vidMemThisFrame, vidMemRecently ); int meshMem = 0; pRenderer->EF_Query(EFQ_Alloc_APIMesh, meshMem); ActivateOutput(pActInfo, OUT_SYSMEM, sysMem); // potentially unsafe if we start using >2gb of video memory...? ActivateOutput(pActInfo, OUT_VIDEOMEM_THISFRAME, int(vidMemThisFrame)); ActivateOutput(pActInfo, OUT_VIDEOMEM_RECENTLY, int(vidMemRecently)); ActivateOutput(pActInfo, OUT_MESHMEM, meshMem); } break; } }
void View::ApplyToRenderer( IRenderer& Renderer ) const { XTRACE_FUNCTION; Renderer.SetViewMatrix( GetViewMatrix() ); Renderer.SetProjectionMatrix( GetProjectionMatrix() ); }
void CStereoZoom::PrintDebugOutput() { ICVar* pICVar = gEnv->pConsole->GetCVar("r_StereoScreenDist"); float dist; if ( pICVar != NULL) { dist = pICVar->GetFVal(); } else { dist = -10.f; } pICVar = gEnv->pConsole->GetCVar("r_StereoEyeDist"); float eyedist; if ( pICVar != NULL) { eyedist = pICVar->GetFVal(); } else { eyedist = -10.f; } IRenderer* pRenderer = gEnv->pRenderer; static float color[4] = {1,1,1,1}; float y=50.f, step1=15.f, step2=20.f, size1=1.3f, size2=1.5f; pRenderer->Draw2dLabel(5.0f, y , size2, color, false, "Current PlaneDist: %f", dist); pRenderer->Draw2dLabel(5.0f, y += step1, size2, color, false, "Current EyeDist : %f", eyedist); }
ExecutionResult ShaderSetUniformsCommand::execute(ICommandExecutor* executor) { Scene& scene = *(executor->getScene()); ExecutionResult result = ExecutionSuccessRedraw; // get shader by its ID ShaderMap &shaderMap = scene.m_shaderMap; ShaderMapIterator iter = shaderMap.find(m_shaderid); ShaderMapIterator iterEnd = shaderMap.end(); if (iter != iterEnd) { Shader* shader = (*iter).second; if (shader) { // get uniform descriptions const std::vector<std::string> uniformDesc = m_uniforms; std::vector<std::string>::const_iterator uiterator; for (uiterator=uniformDesc.begin(); uiterator != uniformDesc.end(); ++uiterator) { // parse description string and create uniform object ShaderUniform* uniform = ShaderUniform::createFromStringDescription(*uiterator); if (uniform) { shader->setUniform(*uniform); delete uniform; } else { LOG_ERROR("ShaderSetUniformsCommand", "Failed to parse uniform description"); result = ExecutionFailed; } } } else { // shader not found LOG_ERROR("ShaderSetUniformsCommand", "shader ID " << m_shaderid << " found but object was null"); result = ExecutionFailed; } } else { // shader not found LOG_ERROR("ShaderSetUniformsCommand", "shader ID "<<m_shaderid<<" not found"); result = ExecutionFailed; } if (result == ExecutionSuccessRedraw) { IRenderer* renderer = *((executor->getRendererList())->begin()); renderer->forceCompositionWindowSystem(); } return result; }
void PaintWidget::setDestination(qint16 x, quint16 y) { IRenderer* renderer = MapData::instance()->renderer(); if ( renderer == NULL ) return; UnsignedCoordinate coordinate(renderer->PointToCoordinate(x - width() / 2, y - height() / 2, m_request)); RoutingLogic::instance()->setWaypoint( 0, coordinate ); //0 should be real current waypoint }
void PaintWidget::setSource(qint16 x, quint16 y) { IRenderer* renderer = MapData::instance()->renderer(); if ( renderer == NULL ) return; UnsignedCoordinate coordinate(renderer->PointToCoordinate(x - width() / 2, y - height() / 2, m_request)); RoutingLogic::instance()->setSource( coordinate ); }
virtual void ProcessEvent( EFlowEvent event, SActivationInfo *pActInfo ) { CRY_ASSERT(pActInfo != NULL); switch (event) { case eFE_Initialize: { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, false ); Reset(); } break; case eFE_Activate: { if (IsPortActive(pActInfo, eIN_Start)) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, true ); } if (IsPortActive(pActInfo, eIN_Stop)) { pActInfo->pGraph->SetRegularlyUpdated( pActInfo->myID, false ); } if (IsPortActive(pActInfo, eIN_Reset)) { Reset(); } } break; case eFE_Update: { IRenderer *pRenderer = gEnv->pRenderer; float fFrameTime = gEnv->pTimer->GetFrameTime(); float fFrameRate = gEnv->pTimer->GetFrameRate(); int fFrameId = pRenderer->GetFrameID(false); m_fMinFrameRate = min(fFrameRate, m_fMinFrameRate); m_fMaxFrameRate = max(fFrameRate, m_fMaxFrameRate); m_fSumFrameRate += fFrameRate; ++m_lFrameCounter; ActivateOutput(pActInfo, eOUT_FrameTime, fFrameTime); ActivateOutput(pActInfo, eOUT_FrameRate, fFrameRate); ActivateOutput(pActInfo, eOUT_FrameID, fFrameId); ActivateOutput(pActInfo, eOUT_Min, m_fMinFrameRate); ActivateOutput(pActInfo, eOUT_Max, m_fMaxFrameRate); ActivateOutput(pActInfo, eOUT_Average, (m_fSumFrameRate/m_lFrameCounter)); } break; default: break; } }
void OnUpdate( SActivationInfo* pActInfo ) { const Vec3 positionOffsetLocal = GetPortVec3( pActInfo, PORT_IN_POSITION_OFFSET_LOCAL ); const float maxDistance = max( 0.f, GetPortFloat( pActInfo, PORT_IN_MAX_LENGTH ) ); const CCamera& camera = GetISystem()->GetViewCamera(); const Vec3 cameraDirection = camera.GetViewdir(); const Vec3 cameraPositionWorld = camera.GetPosition(); const Matrix33 cameraOrientation = Matrix33::CreateRotationVDir( cameraDirection ); const Vec3 positionOffsetWorld = cameraOrientation * positionOffsetLocal; const Vec3 rayOriginWorld = cameraPositionWorld + positionOffsetWorld; const Vec3 raySegment = cameraDirection * maxDistance; IPhysicalWorld* pWorld = gEnv->pPhysicalWorld; const int objectTypes = ent_all; const unsigned int raycastFlags = rwi_stop_at_pierceable | rwi_colltype_any; ray_hit hit; const int hitCount = pWorld->RayWorldIntersection( rayOriginWorld, raySegment, objectTypes, raycastFlags, &hit, 1 ); float hitDistance = maxDistance; if ( 0 < hitCount ) { hitDistance = hit.dist; } const float timeDelta = 0.1f; const float smoothTime = max( 0.f, GetPortFloat( pActInfo, PORT_IN_SMOOTH_TIME ) ); SmoothCD( m_smoothedHitDistance, m_hitDistanceChangeRate, timeDelta, hitDistance, smoothTime ); ActivateOutput( pActInfo, PORT_OUT_FOCUS_DISTANCE, m_smoothedHitDistance ); const float focusRangeFactor = max( 0.f, GetPortFloat( pActInfo, PORT_IN_FOCUS_RANGE_FACTOR ) ); const float focusRange = focusRangeFactor * m_smoothedHitDistance; ActivateOutput( pActInfo, PORT_OUT_FOCUS_RANGE, focusRange ); const bool drawDebugInfo = GetPortBool( pActInfo, PORT_IN_DEBUG_ENABLED ); if ( ! drawDebugInfo ) { return; } IRenderer* pRenderer = gEnv->pRenderer; IRenderAuxGeom* pRenderAuxGeom = pRenderer->GetIRenderAuxGeom(); ColorB rayColor = ( 0 < hitCount ) ? ColorB( 255, 255, 0 ) : ColorB( 255, 0, 0 ); pRenderAuxGeom->DrawSphere( hit.pt, 0.1f, rayColor ); pRenderAuxGeom->DrawLine( rayOriginWorld, rayColor, hit.pt, rayColor ); }
void BasicSkin::drawCheckBox(IRenderer &r, const AWidget &cb, bool checked) { IntRect boxBounds = cb.getBounds(); boxBounds.max.x = boxBounds.min.x + boxBounds.height(); boxBounds.pad(-2); static const Color borderColor(0, 0, 0); static const Color fillColor(96, 96, 96); static const Color fillColorPress(128, 128, 128); static const Color uncheckColor(48, 48, 48); if(cb.isPressed()) r.setColor(fillColorPress); else r.setColor(fillColor); r.drawRect(boxBounds.pad(1), true); // Fill if(cb.isFocused()) r.setColor(lightColor); else r.setColor(borderColor); r.drawRect(boxBounds, false); // Border if(checked) r.setColor(lightColor); else r.setColor(uncheckColor); r.drawRect(boxBounds.pad(-3, -4, -4, -3), true); }
void PaintWidget::move(QVariantList list, QVariantList idlist) { if ( m_fixed ) return; if (list.size() == 0) { return; } QMap<int, QPointF> touch_last_pos = touch_current_pos; for (unsigned i = 0; i < list.size(); i++) { touch_current_pos[idlist[i].toInt()] = list[i].value<QPointF>(); } QPointF average = calcAverage(touch_current_pos); QPointF last_average = calcAverage(touch_last_pos); QPointF start_average = calcAverage(touch_start_pos); int minDiff = 7; if ( abs( average.x() - start_average.x() ) + abs( average.y() - start_average.y() ) > minDiff ) m_drag = true; IRenderer* renderer = MapData::instance()->renderer(); if ( renderer == NULL ) return; m_request.center = renderer->Move( average.x() - last_average.x(), average.y() - last_average.y(), m_request ); setKeepPositionVisible( false ); if (touch_current_pos.size() > 1) { QPointF first = *touch_current_pos.begin(); QPointF second = *(touch_current_pos.begin()+1); qreal distance = sqrt(pow(first.x() - second.x(), 2) + pow(first.y() - second.y(), 2)); QPointF first_start = *touch_start_pos.begin(); QPointF second_start = *(touch_start_pos.begin()+1); distance /= sqrt(pow(first_start.x() - second_start.x(), 2) + pow(first_start.y() - second_start.y(), 2)); m_request.center = renderer->Move( width() / 2 - average.x(), height() / 2 - average.y(), m_request ); m_request.zoom = m_startZoom + log2(distance); if ( m_request.zoom > m_maxZoom ) { m_request.zoom = m_maxZoom; } if ( m_request.zoom < 0 ) { m_request.zoom = 0; } m_request.virtualZoom = m_request.zoom - (int) m_request.zoom + 1; m_request.center = renderer->Move( average.x() - width() / 2, average.y() - height() / 2, m_request ); emit zoomChanged( m_request.zoom ); } update(); }
void BasicSkin::drawDragZone(IRenderer & r, const AWidget & dz) { IntRect bounds = dz.getBounds(); static const Color fillColor(64, 64, 64); static const Color fillColorHover(72, 72, 72); r.setColor(dz.isHovered() ? fillColorHover : fillColor); if(dz.isFocused()) r.setColor(Color(96,96,96)); r.drawRect(bounds, true); // Fill }
void Tracer::Render3D() { float startDist = curDistance; float endDist = curDistance + visibleLength; startDist = std::max(startDist, 8.f); endDist = std::min(endDist, length); if (startDist >= endDist || length < 8) { return; } Vector3 pos1 = startPos + dir * startDist; Vector3 pos2 = startPos + dir * endDist; IRenderer *r = client->GetRenderer(); Vector4 col = { colour.x, colour.y, colour.z, 0.01f }; r->SetColorAlphaPremultiplied(col*0.5f); float sizeScale = 1.f; if (player) { sizeScale = sizeScale*sqrt((pos1 - player->GetPosition()).GetLength()); } if (EqualsIgnoringCase(r_renderer, "sw") && (int)opt_tracers == 1) { r->AddSprite(image, pos1, .025f, 0); r->AddSprite(image, (pos1+pos1+pos2)/3.f, .05f, 0); r->AddSprite(image, (pos1+pos2)/2.f, .05f, 0); r->AddSprite(image, (pos1+pos2+pos2)/3.f, .075f, 0); r->AddSprite(image, pos2, .1f, 0); } else if ((int)opt_tracers == 1) { r->AddLongSprite(image, pos1, pos2, 0.005f*sizeScale); } else if ((int)opt_tracers == 2) { ModelRenderParam param; param.matrix = matrix * Matrix4::Scale(0.01f*sizeScale); param.customColor = colour; r->RenderModel(model, param); } //r->AddSprite(image2, pos2, .2f, 0); if (dlight) { DynamicLightParam l; l.origin = (pos1 + pos2)*0.5f; l.radius = 2.f; l.type = DynamicLightTypePoint; l.color = colour; client->flashDlights.push_back(l); } }
void PaintWidget::paintEvent( QPaintEvent* ) { if ( !isVisible() ) return; IRenderer* renderer = MapData::instance()->renderer(); if ( renderer == NULL ) return; if ( m_fixed ){ m_request.center = m_request.position.ToProjectedCoordinate(); if ( GlobalSettings::autoRotation() ) { //gradually change the screen rotation to match the heading double diff = m_request.rotation + m_request.heading; while ( diff <= -180 ) diff += 360; while ( diff >= 180 ) diff -=360; //to filter out noise stop when close enough if ( diff > 0 ) diff = std::max( 0.0, diff - 15 ); if ( diff < 0 ) diff = std::min( 0.0, diff + 15 ); m_request.rotation -= diff / 2; //normalize while ( m_request.rotation < 0 ) m_request.rotation += 360; while ( m_request.rotation >= 360 ) m_request.rotation -= 360; int radius = height() * 0.25; m_request.center = renderer->PointToCoordinate( 0, -radius, m_request ); } else { m_request.rotation = 0; } } else { m_request.rotation = 0; } if (m_keepPositionVisible) m_request.center = m_request.position.ToProjectedCoordinate(); #ifndef SAILFISH QPainter painter( this ); Timer time; renderer->Paint( &painter, m_request ); qDebug() << "Rendering:" << time.elapsed() << "ms"; #endif }
void DlgAtomics::update() { //#if NAU_OPENGL_VERSION >= 420 IRenderer *renderer = RENDERER; std::vector<unsigned int> atValues = renderer->getAtomicCounterValues(); std::map<std::pair<std::string, unsigned int>, std::string>::iterator iter; iter = renderer->m_AtomicLabels.begin(); for (unsigned int i = 0; i < renderer->m_AtomicLabels.size(); ++i, ++iter) { if (m_propertyGrid1->GetProperty(wxString(iter->second.c_str()))) m_propertyGrid1->SetPropertyValue(wxString(iter->second.c_str()),(int)(atValues[i])); } //#endif }
bool Default::beginScene (Core::Slackgine* sg, Core::Camera* cam) { if ( !initialize(sg) ) { return false; } IRenderer* renderer = sg->getRenderer(); renderer->setProgram( m_program ); m_matLookAt = LookatMatrix ( cam->transform().orientation(), cam->transform().translation() ); return this->isOk(); }
NVECTOR2 IGraphicObject::GetBasePosOffset() { IRenderer* pRenderer = GetScene()->GetRenderer(); UINT mainWidth = pRenderer->GetMainBufferWidth(); UINT mainHeight = pRenderer->GetMainBufferHeight(); //Position Offset NVECTOR2 outBaseTopLeftPixel = *m_pBaseScreenSpacePosOffset; //mFunction_ConvertFloatVec2PixelVec(outBaseTopLeftPixel); outBaseTopLeftPixel.x = outBaseTopLeftPixel.x *float(mainWidth) / 2.0f; outBaseTopLeftPixel.y = - outBaseTopLeftPixel.y * float(mainHeight) / 2.0f; return outBaseTopLeftPixel; }
void BasicSkin::drawPushButton(IRenderer &r, const AWidget &btn) { IntRect bounds = btn.getBounds(); static const Color borderColor(0, 0, 0); static const Color borderColorHover(0, 0, 0); static const Color fillColor(96, 96, 96); static const Color fillColorPress(112, 112, 112); if(btn.isPressed()) r.setColor(fillColorPress); else r.setColor(fillColor); r.drawRect(bounds.pad(1), true); // Fill if(btn.isHovered()) { if(btn.isFocused()) r.setColor(lightColor); else r.setColor(borderColorHover); } else { if(btn.isFocused()) r.setColor(lightColor); else r.setColor(borderColor); } r.drawRect(bounds, false); // Border }
void HelpCommand::Execute() { IRenderer *pRenderer = GetEngine()->GetRenderer(); pRenderer->Render("Available commands:\n"); CommandFactory::CommandMap mapCommands = GetEngine()->GetCommandFactory()->GetCommandMap(); CommandFactory::CommandMap::iterator itr; for (itr = mapCommands.begin(); itr != mapCommands.end(); itr++) { std::stringstream s; ICommand *pCommand = itr->second(GetEngine(), ""); s << itr->first << " " << pCommand->GetParamTypes() << " " << pCommand->GetDescription() << "\n"; pRenderer->Render(s.str()); delete pCommand; } }
void CFlashMenuScreen::UpdateRatio() { if(IsLoaded()) { IFlashPlayer* pFlashPlayer = GetFlashPlayer(); IRenderer* pRenderer = gEnv->pRenderer; // Native width/height/ratio float fMovieWidth = (float) pFlashPlayer->GetWidth(); float fMovieHeight = (float) pFlashPlayer->GetHeight(); float fMovieRatio = fMovieWidth / fMovieHeight; // Current renderer width/height/ratio float fRendererWidth = (float) pRenderer->GetWidth(); float fRendererHeight = (float) pRenderer->GetHeight(); float fRendererRatio = fRendererWidth / fRendererHeight; // Compute viewport so that it fits float fViewportX = 0.0f; float fViewportY = 0.0f; float fViewportWidth = 0.0f; float fViewportHeight = 0.0f; /* All the Flash files have been designed either in 4/3 or 16/9 aspect ratios in resolutions such as 1024x768 or 1366x768. Problem is that minimum aspect ratio is NOT 4/3 but 5/4, mainly because of LCD monitors. We need to rescale accordingly in screen resolutions like 1280x1024 so that we use the file in its 4/3 mode. Hence, there is wasted place in both vertical and horizontal areas but this is the only way to fits right. */ if(fRendererRatio >= 4.0f/3.0f) { fViewportHeight = fRendererHeight; fViewportX = (fRendererWidth - (fRendererHeight * fMovieRatio)) * 0.5f; fViewportWidth = fRendererHeight * fMovieRatio; } else { fViewportX = (fRendererWidth - ((fRendererWidth * 3.0f / 4.0f) * fMovieRatio)) * 0.5f; fViewportY = (fRendererHeight - (fRendererWidth * 3.0f / 4.0f)) * 0.5f; fViewportWidth = (fRendererWidth * 3.0f / 4.0f) * fMovieRatio; fViewportHeight = fRendererWidth * 3.0f / 4.0f; } pFlashPlayer->SetViewport((int)fViewportX,(int)fViewportY,(int)fViewportWidth,(int)fViewportHeight); } }
int main(void) { //_CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); Configuration *config = Configuration::getInstance(); config->load("config.cfg"); std::string type = config->getConfiguration("API"); IRenderer* renderer = RendererFactory::makeRenderer(type); renderer->loop(); return 0; }
void CRateOfDeathSimple::DebugDraw() { IRenderer* pRenderer = gEnv->pRenderer; const float color[ 4 ] = { 1, 1, 1, 1 }; float drawPosY = 20; pRenderer->Draw2dLabel( 5, drawPosY, 1.2f, color, false, "Rate of Death '%s'", m_pOwner->GetName() ); drawPosY += 15; m_rateOfDeathTarget.DebugDraw( drawPosY ); drawPosY += 15; pRenderer->Draw2dLabel( 5, drawPosY, 1.2f, color, false, "Can damage? %s", m_canDamageTarget ? "yes" : "no" ); drawPosY += 15; pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Target Offset <%f, %f, %f>", m_targetOffset.x, m_targetOffset.y, m_targetOffset.z ); drawPosY += 15; pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Miss Offset Update [%f/%f] [time left/ update interval]", m_missOffsetNextUpdateSeconds, m_missOffsetIntervalSeconds ); drawPosY += 15; pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Miss Range [%f-%f]", m_missMinRange, m_missMaxRange ); drawPosY += 15; pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Hit Offset Update [%f/%f] [time left/ update interval]", m_hitOffsetNextUpdateSeconds, m_hitOffsetIntervalSeconds ); drawPosY += 15; pRenderer->Draw2dLabel( 10, drawPosY, 1.2f, color, false, "Hit Range [%f-%f]", m_hitMinRange, m_hitMaxRange ); drawPosY += 15; }
void CRateOfDeathHelper_HealthThreshold::DebugDraw( float& drawPosY ) { IRenderer* pRenderer = gEnv->pRenderer; const float color[ 4 ] = { 1, 1, 1, 1 }; pRenderer->Draw2dLabel( 20, drawPosY, 1.2f, color, false, "Stay Alive Time: %f", m_stayAliveTime ); drawPosY += 15; pRenderer->Draw2dLabel( 20, drawPosY, 1.2f, color, false, "Normalized Health: %f", m_normalizedHealth ); drawPosY += 15; pRenderer->Draw2dLabel( 20, drawPosY, 1.2f, color, false, "Normalized Health Threshold: %f", m_normalizedHealthThreshold ); drawPosY += 15; }
void MaterialSortRenderQueue::processQueue (void) { PROFILE ("Process queue"); IRenderer *renderer = RENDERER; std::map <int, std::map<Material*, std::vector<pair_MatGroup_Transform >* >* >::iterator renderQueueIter; renderQueueIter = m_RenderQueue.begin(); for (; renderQueueIter != m_RenderQueue.end(); ++renderQueueIter) { std::map<Material*, std::vector<pair_MatGroup_Transform >* >::iterator materialMapIter; materialMapIter = (*renderQueueIter).second->begin(); for (; materialMapIter != (*renderQueueIter).second->end(); materialMapIter++) { Material *aMat = (*materialMapIter).first; { PROFILE ("Material prepare"); aMat->prepare(); } std::vector<pair_MatGroup_Transform >::iterator matGroupsIter; matGroupsIter = (*materialMapIter).second->begin(); { PROFILE ("Geometry rendering"); for (; matGroupsIter != (*materialMapIter).second->end(); ++matGroupsIter) { bool b = (*matGroupsIter).second->isIdentity(); if (!b) { renderer->pushMatrix(IRenderer::MODEL_MATRIX); renderer->applyTransform(IRenderer::MODEL_MATRIX, *(*matGroupsIter).second); aMat->setUniformValues(); aMat->setUniformBlockValues(); } { PROFILE("Draw"); renderer->drawGroup ((*matGroupsIter).first); } if (!b) renderer->popMatrix(IRenderer::MODEL_MATRIX); } } aMat->restore(); } } }
void Rendering::Update(GameObject* obj) { Camera* camera = obj->GetCamera(); if( camera != 0 && camera->isEnabled() ) { cameras.insert( camera ); camera->containingSet = &cameras; } IRenderer* renderer = obj->GetRenderer(); if( renderer != 0 ) { renderer->ClearLights(); if( renderer->renderableTreeLeaf == 0 ) { renderer->renderableTreeLeaf = renderableTree.Insert(renderer); renderer->containingTree = &renderableTree; } else renderableTree.Update( renderer->renderableTreeLeaf ); } ILight* light = obj->GetLight(); if( light != 0 ) { light->Update(); if( light->GetLightType() != ILight::DIRECTIONAL ) { IPointLight* pointlight = (IPointLight*)light; if( pointlight->lightTreeLeaf == 0 ) { pointlight->lightTreeLeaf = lightTree.Insert(pointlight); pointlight->containingTree = &lightTree; } else lightTree.Update( pointlight->lightTreeLeaf ); } else { IDirectionalLight* directionalLight = (IDirectionalLight*)light; directionalLightList.push_back( directionalLight ); directionalLight->containingList = &directionalLightList; } } }