int main(int argc, char* argv[]) { // Some parameters for testing int test_w = 800; int test_h = 600; int test_phys_w = 400; int test_phys_h = 300; Graphics *gr = Graphics::Create(test_w, test_h); assert(gr); // Initialization of interface between graphics and physics (GPInterface) gr->InitGPInterface(test_w, test_h, test_phys_w, test_phys_h); gr->AddSprite(32, 17, "./gfx/car1.png"); gr->AddSprite(32, 17, "./gfx/car2.png"); // Variable coordinates of car float cX = 20, cY = 15; float ang = 0; gr->SetSpriteCoordinates(0, cX, cY, ang); gr->SetSpriteCoordinates(1, cX+50, cY, ang); // Event new_event; // printf("%d %d\n", gpi.gr_coordinate_x(cX), gpi.gr_coordinate_y(cY)); while(new_event.running()) { new_event.CheckEvents(); if(new_event.fullscreen()) { gr->FullscreenOn(); } else { gr->FullscreenOff(); } gr->Render(); cX += 0.1; cY += 0.1; ang += 0.01; gr->SetSpriteCoordinates(0, cX, cY, ang); gr->SetSpriteCoordinates(1, cX+50, cY, ang); SDL_Delay(5); } gr->CleanUp(); delete gr; return 0; }
void ResourceEditorPanel::paint (Graphics& g) { g.fillAll (findColour (secondaryBackgroundColourId)); }
void PoleZeroChart::paintContents (Graphics& g) { Colour cPole (0xd0ff0000); Colour cZero (0xd02020ff); Rectangle<int> bounds = getLocalBounds(); short size = short ((jmin (getWidth(), getHeight()) + 2) / 3); // scale the graph down if the pole/zeroes lie outside the unit disc AffineTransform t = AffineTransform::identity; { float margin = 0.2f; if (m_max > 1 + margin) { t = t.scaled (float(1/(m_max-margin)), float(1/(m_max-margin))); } } t = t.scaled (float(size), -float(size)); t = t.translated (float(bounds.getCentreX()), float(bounds.getCentreY())); g.setColour (m_cAxis); { Point<float> p = Point<float>(100000, 0).transformedBy (t); g.drawLine (-p.getX(), p.getY(), p.getX(), p.getY(), 1); } { Point<float> p = Point<float>(0, 100000).transformedBy (t); g.drawLine (p.getX(), -p.getY(), p.getX(), p.getY(), 1); } { Point<float> p0 = Point<float>(-1, -1).transformedBy (t); Point<float> p1 = Point<float>( 1, 1).transformedBy (t); g.drawEllipse (p0.getX(), p0.getY(), p1.getX()-p0.getX(), p1.getY()-p0.getY(), 1); } const float r = 3.5f; for (size_t i = 0; i < m_vpz.size(); ++i) { const Dsp::PoleZeroPair& pzp = m_vpz[i]; if (!pzp.is_nan()) { { Point<float> p (float(pzp.poles.first.real()), float(pzp.poles.first.imag())); p = p.transformedBy (t); g.setColour (cPole); g.drawLine (p.getX()-r, p.getY()-r, p.getX()+r, p.getY()+r); g.drawLine (p.getX()+r, p.getY()-r, p.getX()-r, p.getY()+r); } { Point<float> p (float(pzp.zeros.first.real()), float(pzp.zeros.first.imag())); p = p.transformedBy (t); g.setColour (cZero); g.drawEllipse (p.getX()-r, p.getY()-r, 2*r, 2*r, 1); } if (!pzp.isSinglePole()) { { Point<float> p (float(pzp.poles.second.real()), float(pzp.poles.second.imag())); p = p.transformedBy (t); g.setColour (cPole); g.drawLine (p.getX()-r, p.getY()-r, p.getX()+r, p.getY()+r); g.drawLine (p.getX()+r, p.getY()-r, p.getX()-r, p.getY()+r); } { Point<float> p (float(pzp.zeros.second.real()), float(pzp.zeros.second.imag())); p = p.transformedBy (t); g.setColour (cZero); g.drawEllipse (p.getX()-r, p.getY()-r, 2*r, 2*r, 1); } } } } }
void Urho2DPhysicsRope::CreateScene() { scene_ = new Scene(context_); scene_->CreateComponent<Octree>(); scene_->CreateComponent<DebugRenderer>(); // Create camera node cameraNode_ = scene_->CreateChild("Camera"); // Set camera's position cameraNode_->SetPosition(Vector3(0.0f, 5.0f, -10.0f)); Camera* camera = cameraNode_->CreateComponent<Camera>(); camera->SetOrthographic(true); Graphics* graphics = GetSubsystem<Graphics>(); float width = (float)graphics->GetWidth(); float height = (float)graphics->GetHeight(); camera->SetOrthoSize(Vector2(width, height) * 0.05f); // Create 2D physics world component PhysicsWorld2D* physicsWorld = scene_->CreateComponent<PhysicsWorld2D>(); physicsWorld->SetDrawJoint(true); // Create ground Node* groundNode = scene_->CreateChild("Ground"); // Create 2D rigid body for gound RigidBody2D* groundBody = groundNode->CreateComponent<RigidBody2D>(); // Create edge collider for ground CollisionEdge2D* groundShape = groundNode->CreateComponent<CollisionEdge2D>(); groundShape->SetVertices(Vector2(-40.0f, 0.0f), Vector2(40.0f, 0.0f)); const float y = 15.0f; RigidBody2D* prevBody = groundBody; for (unsigned i = 0; i < NUM_OBJECTS; ++i) { Node* node = scene_->CreateChild("RigidBody"); // Create rigid body RigidBody2D* body = node->CreateComponent<RigidBody2D>(); body->SetBodyType(BT_DYNAMIC); // Create box CollisionBox2D* box = node->CreateComponent<CollisionBox2D>(); // Set friction box->SetFriction(0.2f); // Set mask bits. box->SetMaskBits(0xFFFF & ~0x0002); if (i == NUM_OBJECTS - 1) { node->SetPosition(Vector3(1.0f * i, y, 0.0f)); body->SetAngularDamping(0.4f); box->SetSize(3.0f, 3.0f); box->SetDensity(100.0f); box->SetCategoryBits(0x0002); } else { node->SetPosition(Vector3(0.5f + 1.0f * i, y, 0.0f)); box->SetSize(1.0f, 0.25f); box->SetDensity(20.0f); box->SetCategoryBits(0x0001); } ConstraintRevolute2D* joint = node->CreateComponent<ConstraintRevolute2D>(); joint->SetOtherBody(prevBody); joint->SetAnchor(Vector2(float(i), y)); joint->SetCollideConnected(false); prevBody = body; } ConstraintRope2D* constraintRope = groundNode->CreateComponent<ConstraintRope2D>(); constraintRope->SetOtherBody(prevBody); constraintRope->SetOwnerBodyAnchor(Vector2(0.0f, y)); constraintRope->SetMaxLength(NUM_OBJECTS - 1.0f + 0.01f); }
void Batch::Prepare(View* view, Camera* camera, bool setModelTransform, bool allowDepthWrite) const { if (!vertexShader_ || !pixelShader_) return; Graphics* graphics = view->GetGraphics(); Renderer* renderer = view->GetRenderer(); Node* cameraNode = camera ? camera->GetNode() : 0; Light* light = lightQueue_ ? lightQueue_->light_ : 0; Texture2D* shadowMap = lightQueue_ ? lightQueue_->shadowMap_ : 0; // Set shaders first. The available shader parameters and their register/uniform positions depend on the currently set shaders graphics->SetShaders(vertexShader_, pixelShader_); // Set pass / material-specific renderstates if (pass_ && material_) { BlendMode blend = pass_->GetBlendMode(); // Turn additive blending into subtract if the light is negative if (light && light->IsNegative()) { if (blend == BLEND_ADD) blend = BLEND_SUBTRACT; else if (blend == BLEND_ADDALPHA) blend = BLEND_SUBTRACTALPHA; } graphics->SetBlendMode(blend); bool isShadowPass = pass_->GetIndex() == Technique::shadowPassIndex; CullMode effectiveCullMode = pass_->GetCullMode(); // Get cull mode from material if pass doesn't override it if (effectiveCullMode == MAX_CULLMODES) effectiveCullMode = isShadowPass ? material_->GetShadowCullMode() : material_->GetCullMode(); renderer->SetCullMode(effectiveCullMode, camera); if (!isShadowPass) { const BiasParameters& depthBias = material_->GetDepthBias(); graphics->SetDepthBias(depthBias.constantBias_, depthBias.slopeScaledBias_); } // Use the "least filled" fill mode combined from camera & material graphics->SetFillMode((FillMode)(Max(camera->GetFillMode(), material_->GetFillMode()))); graphics->SetDepthTest(pass_->GetDepthTestMode()); graphics->SetDepthWrite(pass_->GetDepthWrite() && allowDepthWrite); } // Set global (per-frame) shader parameters if (graphics->NeedParameterUpdate(SP_FRAME, (void*)0)) view->SetGlobalShaderParameters(); // Set camera & viewport shader parameters unsigned cameraHash = (unsigned)(size_t)camera; IntRect viewport = graphics->GetViewport(); IntVector2 viewSize = IntVector2(viewport.Width(), viewport.Height()); unsigned viewportHash = (unsigned)(viewSize.x_ | (viewSize.y_ << 16)); if (graphics->NeedParameterUpdate(SP_CAMERA, reinterpret_cast<const void*>(cameraHash + viewportHash))) { view->SetCameraShaderParameters(camera); // During renderpath commands the G-Buffer or viewport texture is assumed to always be viewport-sized view->SetGBufferShaderParameters(viewSize, IntRect(0, 0, viewSize.x_, viewSize.y_)); } // Set model or skinning transforms if (setModelTransform && graphics->NeedParameterUpdate(SP_OBJECT, worldTransform_)) { if (geometryType_ == GEOM_SKINNED) { graphics->SetShaderParameter(VSP_SKINMATRICES, reinterpret_cast<const float*>(worldTransform_), 12 * numWorldTransforms_); } else graphics->SetShaderParameter(VSP_MODEL, *worldTransform_); // Set the orientation for billboards, either from the object itself or from the camera if (geometryType_ == GEOM_BILLBOARD) { if (numWorldTransforms_ > 1) graphics->SetShaderParameter(VSP_BILLBOARDROT, worldTransform_[1].RotationMatrix()); else graphics->SetShaderParameter(VSP_BILLBOARDROT, cameraNode->GetWorldRotation().RotationMatrix()); } } // Set zone-related shader parameters BlendMode blend = graphics->GetBlendMode(); // If the pass is additive, override fog color to black so that shaders do not need a separate additive path bool overrideFogColorToBlack = blend == BLEND_ADD || blend == BLEND_ADDALPHA; unsigned zoneHash = (unsigned)(size_t)zone_; if (overrideFogColorToBlack) zoneHash += 0x80000000; if (zone_ && graphics->NeedParameterUpdate(SP_ZONE, reinterpret_cast<const void*>(zoneHash))) { graphics->SetShaderParameter(VSP_AMBIENTSTARTCOLOR, zone_->GetAmbientStartColor()); graphics->SetShaderParameter(VSP_AMBIENTENDCOLOR, zone_->GetAmbientEndColor().ToVector4() - zone_->GetAmbientStartColor().ToVector4()); const BoundingBox& box = zone_->GetBoundingBox(); Vector3 boxSize = box.Size(); Matrix3x4 adjust(Matrix3x4::IDENTITY); adjust.SetScale(Vector3(1.0f / boxSize.x_, 1.0f / boxSize.y_, 1.0f / boxSize.z_)); adjust.SetTranslation(Vector3(0.5f, 0.5f, 0.5f)); Matrix3x4 zoneTransform = adjust * zone_->GetInverseWorldTransform(); graphics->SetShaderParameter(VSP_ZONE, zoneTransform); graphics->SetShaderParameter(PSP_AMBIENTCOLOR, zone_->GetAmbientColor()); graphics->SetShaderParameter(PSP_FOGCOLOR, overrideFogColorToBlack ? Color::BLACK : zone_->GetFogColor()); float farClip = camera->GetFarClip(); float fogStart = Min(zone_->GetFogStart(), farClip); float fogEnd = Min(zone_->GetFogEnd(), farClip); if (fogStart >= fogEnd * (1.0f - M_LARGE_EPSILON)) fogStart = fogEnd * (1.0f - M_LARGE_EPSILON); float fogRange = Max(fogEnd - fogStart, M_EPSILON); Vector4 fogParams(fogEnd / farClip, farClip / fogRange, 0.0f, 0.0f); Node* zoneNode = zone_->GetNode(); if (zone_->GetHeightFog() && zoneNode) { Vector3 worldFogHeightVec = zoneNode->GetWorldTransform() * Vector3(0.0f, zone_->GetFogHeight(), 0.0f); fogParams.z_ = worldFogHeightVec.y_; fogParams.w_ = zone_->GetFogHeightScale() / Max(zoneNode->GetWorldScale().y_, M_EPSILON); } graphics->SetShaderParameter(PSP_FOGPARAMS, fogParams); } // Set light-related shader parameters if (lightQueue_) { if (light && graphics->NeedParameterUpdate(SP_LIGHT, lightQueue_)) { Node* lightNode = light->GetNode(); float atten = 1.0f / Max(light->GetRange(), M_EPSILON); Vector3 lightDir(lightNode->GetWorldRotation() * Vector3::BACK); Vector4 lightPos(lightNode->GetWorldPosition(), atten); graphics->SetShaderParameter(VSP_LIGHTDIR, lightDir); graphics->SetShaderParameter(VSP_LIGHTPOS, lightPos); if (graphics->HasShaderParameter(VSP_LIGHTMATRICES)) { switch (light->GetLightType()) { case LIGHT_DIRECTIONAL: { Matrix4 shadowMatrices[MAX_CASCADE_SPLITS]; unsigned numSplits = Min(MAX_CASCADE_SPLITS, lightQueue_->shadowSplits_.Size()); for (unsigned i = 0; i < numSplits; ++i) CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer); graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits); } break; case LIGHT_SPOT: { Matrix4 shadowMatrices[2]; CalculateSpotMatrix(shadowMatrices[0], light); bool isShadowed = shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP); if (isShadowed) CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer); graphics->SetShaderParameter(VSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16); } break; case LIGHT_POINT: { Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix()); // HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite // the next parameter #ifdef ATOMIC_OPENGL graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 16); #else graphics->SetShaderParameter(VSP_LIGHTMATRICES, lightVecRot.Data(), 12); #endif } break; } } float fade = 1.0f; float fadeEnd = light->GetDrawDistance(); float fadeStart = light->GetFadeDistance(); // Do fade calculation for light if both fade & draw distance defined if (light->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd) fade = Min(1.0f - (light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f); // Negative lights will use subtract blending, so write absolute RGB values to the shader parameter graphics->SetShaderParameter(PSP_LIGHTCOLOR, Color(light->GetEffectiveColor().Abs(), light->GetEffectiveSpecularIntensity()) * fade); graphics->SetShaderParameter(PSP_LIGHTDIR, lightDir); graphics->SetShaderParameter(PSP_LIGHTPOS, lightPos); if (graphics->HasShaderParameter(PSP_LIGHTMATRICES)) { switch (light->GetLightType()) { case LIGHT_DIRECTIONAL: { Matrix4 shadowMatrices[MAX_CASCADE_SPLITS]; unsigned numSplits = Min(MAX_CASCADE_SPLITS, lightQueue_->shadowSplits_.Size()); for (unsigned i = 0; i < numSplits; ++i) CalculateShadowMatrix(shadowMatrices[i], lightQueue_, i, renderer); graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), 16 * numSplits); } break; case LIGHT_SPOT: { Matrix4 shadowMatrices[2]; CalculateSpotMatrix(shadowMatrices[0], light); bool isShadowed = lightQueue_->shadowMap_ != 0; if (isShadowed) CalculateShadowMatrix(shadowMatrices[1], lightQueue_, 0, renderer); graphics->SetShaderParameter(PSP_LIGHTMATRICES, shadowMatrices[0].Data(), isShadowed ? 32 : 16); } break; case LIGHT_POINT: { Matrix4 lightVecRot(lightNode->GetWorldRotation().RotationMatrix()); // HLSL compiler will pack the parameters as if the matrix is only 3x4, so must be careful to not overwrite // the next parameter #ifdef ATOMIC_OPENGL graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 16); #else graphics->SetShaderParameter(PSP_LIGHTMATRICES, lightVecRot.Data(), 12); #endif } break; } } // Set shadow mapping shader parameters if (shadowMap) { { // Calculate point light shadow sampling offsets (unrolled cube map) unsigned faceWidth = (unsigned)(shadowMap->GetWidth() / 2); unsigned faceHeight = (unsigned)(shadowMap->GetHeight() / 3); float width = (float)shadowMap->GetWidth(); float height = (float)shadowMap->GetHeight(); #ifdef ATOMIC_OPENGL float mulX = (float)(faceWidth - 3) / width; float mulY = (float)(faceHeight - 3) / height; float addX = 1.5f / width; float addY = 1.5f / height; #else float mulX = (float)(faceWidth - 4) / width; float mulY = (float)(faceHeight - 4) / height; float addX = 2.5f / width; float addY = 2.5f / height; #endif // If using 4 shadow samples, offset the position diagonally by half pixel if (renderer->GetShadowQuality() == SHADOWQUALITY_PCF_16BIT || renderer->GetShadowQuality() == SHADOWQUALITY_PCF_24BIT) { addX -= 0.5f / width; addY -= 0.5f / height; } graphics->SetShaderParameter(PSP_SHADOWCUBEADJUST, Vector4(mulX, mulY, addX, addY)); } { // Calculate shadow camera depth parameters for point light shadows and shadow fade parameters for // directional light shadows, stored in the same uniform Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_; float nearClip = shadowCamera->GetNearClip(); float farClip = shadowCamera->GetFarClip(); float q = farClip / (farClip - nearClip); float r = -q * nearClip; const CascadeParameters& parameters = light->GetShadowCascade(); float viewFarClip = camera->GetFarClip(); float shadowRange = parameters.GetShadowRange(); float fadeStart = parameters.fadeStart_ * shadowRange / viewFarClip; float fadeEnd = shadowRange / viewFarClip; float fadeRange = fadeEnd - fadeStart; graphics->SetShaderParameter(PSP_SHADOWDEPTHFADE, Vector4(q, r, fadeStart, 1.0f / fadeRange)); } { float intensity = light->GetShadowIntensity(); float fadeStart = light->GetShadowFadeDistance(); float fadeEnd = light->GetShadowDistance(); if (fadeStart > 0.0f && fadeEnd > 0.0f && fadeEnd > fadeStart) intensity = Lerp(intensity, 1.0f, Clamp((light->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 0.0f, 1.0f)); float pcfValues = (1.0f - intensity); float samples = 1.0f; if (renderer->GetShadowQuality() == SHADOWQUALITY_PCF_16BIT || renderer->GetShadowQuality() == SHADOWQUALITY_PCF_24BIT) samples = 4.0f; graphics->SetShaderParameter(PSP_SHADOWINTENSITY, Vector4(pcfValues / samples, intensity, 0.0f, 0.0f)); } float sizeX = 1.0f / (float)shadowMap->GetWidth(); float sizeY = 1.0f / (float)shadowMap->GetHeight(); graphics->SetShaderParameter(PSP_SHADOWMAPINVSIZE, Vector2(sizeX, sizeY)); Vector4 lightSplits(M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE, M_LARGE_VALUE); if (lightQueue_->shadowSplits_.Size() > 1) lightSplits.x_ = lightQueue_->shadowSplits_[0].farSplit_ / camera->GetFarClip(); if (lightQueue_->shadowSplits_.Size() > 2) lightSplits.y_ = lightQueue_->shadowSplits_[1].farSplit_ / camera->GetFarClip(); if (lightQueue_->shadowSplits_.Size() > 3) lightSplits.z_ = lightQueue_->shadowSplits_[2].farSplit_ / camera->GetFarClip(); graphics->SetShaderParameter(PSP_SHADOWSPLITS, lightSplits); if (graphics->HasShaderParameter(PSP_VSMSHADOWPARAMS)) graphics->SetShaderParameter(PSP_VSMSHADOWPARAMS, renderer->GetVSMShadowParameters()); if (light->GetShadowBias().normalOffset_ > 0.0f) { Vector4 normalOffsetScale(Vector4::ZERO); // Scale normal offset strength with the width of the shadow camera view if (light->GetLightType() != LIGHT_DIRECTIONAL) { Camera* shadowCamera = lightQueue_->shadowSplits_[0].shadowCamera_; normalOffsetScale.x_ = 2.0f * tanf(shadowCamera->GetFov() * M_DEGTORAD * 0.5f) * shadowCamera->GetFarClip(); } else { normalOffsetScale.x_ = lightQueue_->shadowSplits_[0].shadowCamera_->GetOrthoSize(); if (lightQueue_->shadowSplits_.Size() > 1) normalOffsetScale.y_ = lightQueue_->shadowSplits_[1].shadowCamera_->GetOrthoSize(); if (lightQueue_->shadowSplits_.Size() > 2) normalOffsetScale.z_ = lightQueue_->shadowSplits_[2].shadowCamera_->GetOrthoSize(); if (lightQueue_->shadowSplits_.Size() > 3) normalOffsetScale.w_ = lightQueue_->shadowSplits_[3].shadowCamera_->GetOrthoSize(); } normalOffsetScale *= light->GetShadowBias().normalOffset_; #ifdef GL_ES_VERSION_2_0 normalOffsetScale *= renderer->GetMobileNormalOffsetMul(); #endif graphics->SetShaderParameter(VSP_NORMALOFFSETSCALE, normalOffsetScale); graphics->SetShaderParameter(PSP_NORMALOFFSETSCALE, normalOffsetScale); } } } else if (lightQueue_->vertexLights_.Size() && graphics->HasShaderParameter(VSP_VERTEXLIGHTS) && graphics->NeedParameterUpdate(SP_LIGHT, lightQueue_)) { Vector4 vertexLights[MAX_VERTEX_LIGHTS * 3]; const PODVector<Light*>& lights = lightQueue_->vertexLights_; for (unsigned i = 0; i < lights.Size(); ++i) { Light* vertexLight = lights[i]; Node* vertexLightNode = vertexLight->GetNode(); LightType type = vertexLight->GetLightType(); // Attenuation float invRange, cutoff, invCutoff; if (type == LIGHT_DIRECTIONAL) invRange = 0.0f; else invRange = 1.0f / Max(vertexLight->GetRange(), M_EPSILON); if (type == LIGHT_SPOT) { cutoff = Cos(vertexLight->GetFov() * 0.5f); invCutoff = 1.0f / (1.0f - cutoff); } else { cutoff = -1.0f; invCutoff = 1.0f; } // Color float fade = 1.0f; float fadeEnd = vertexLight->GetDrawDistance(); float fadeStart = vertexLight->GetFadeDistance(); // Do fade calculation for light if both fade & draw distance defined if (vertexLight->GetLightType() != LIGHT_DIRECTIONAL && fadeEnd > 0.0f && fadeStart > 0.0f && fadeStart < fadeEnd) fade = Min(1.0f - (vertexLight->GetDistance() - fadeStart) / (fadeEnd - fadeStart), 1.0f); Color color = vertexLight->GetEffectiveColor() * fade; vertexLights[i * 3] = Vector4(color.r_, color.g_, color.b_, invRange); // Direction vertexLights[i * 3 + 1] = Vector4(-(vertexLightNode->GetWorldDirection()), cutoff); // Position vertexLights[i * 3 + 2] = Vector4(vertexLightNode->GetWorldPosition(), invCutoff); } graphics->SetShaderParameter(VSP_VERTEXLIGHTS, vertexLights[0].Data(), lights.Size() * 3 * 4); } } // Set zone texture if necessary #ifndef GL_ES_VERSION_2_0 if (zone_ && graphics->HasTextureUnit(TU_ZONE)) graphics->SetTexture(TU_ZONE, zone_->GetZoneTexture()); #else // On OpenGL ES set the zone texture to the environment unit instead if (zone_ && zone_->GetZoneTexture() && graphics->HasTextureUnit(TU_ENVIRONMENT)) graphics->SetTexture(TU_ENVIRONMENT, zone_->GetZoneTexture()); #endif // Set material-specific shader parameters and textures if (material_) { if (graphics->NeedParameterUpdate(SP_MATERIAL, reinterpret_cast<const void*>(material_->GetShaderParameterHash()))) { const HashMap<StringHash, MaterialShaderParameter>& parameters = material_->GetShaderParameters(); for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = parameters.Begin(); i != parameters.End(); ++i) graphics->SetShaderParameter(i->first_, i->second_.value_); } const HashMap<TextureUnit, SharedPtr<Texture> >& textures = material_->GetTextures(); for (HashMap<TextureUnit, SharedPtr<Texture> >::ConstIterator i = textures.Begin(); i != textures.End(); ++i) { if (graphics->HasTextureUnit(i->first_)) graphics->SetTexture(i->first_, i->second_.Get()); } } // Set light-related textures if (light) { if (shadowMap && graphics->HasTextureUnit(TU_SHADOWMAP)) graphics->SetTexture(TU_SHADOWMAP, shadowMap); if (graphics->HasTextureUnit(TU_LIGHTRAMP)) { Texture* rampTexture = light->GetRampTexture(); if (!rampTexture) rampTexture = renderer->GetDefaultLightRamp(); graphics->SetTexture(TU_LIGHTRAMP, rampTexture); } if (graphics->HasTextureUnit(TU_LIGHTSHAPE)) { Texture* shapeTexture = light->GetShapeTexture(); if (!shapeTexture && light->GetLightType() == LIGHT_SPOT) shapeTexture = renderer->GetDefaultLightSpot(); graphics->SetTexture(TU_LIGHTSHAPE, shapeTexture); } } }
//========================================================================== // Set and Creates Images and UI void APlay::paint(Graphics& g) { g.setFillType(Colours::darkslategrey); g.fillAll(); }
void paint(Graphics &g) { int h = getHeight(); int w = getWidth(); DrawablePath dp; Path p; int mapChX = 5; int mapChW = 160; int arrowX1 = 175; int arrowX2 = 195; int devChX = 200; Colour backgroundColour = findColour(TCATLookAndFeel::tcatListboxBackgroundColourId); Colour outlineColour = findColour(TCATLookAndFeel::tcatListboxOutlineColourId); ColourGradient cg (backgroundColour, m_owner.m_owner.m_out ? (float)arrowX1 : (float)arrowX2, (float)10, outlineColour, m_owner.m_owner.m_out ? (float)arrowX2 : (float)arrowX1, (float)10, true); // draw an outline and arrow if the user's currently dragging something over it.. if (m_dragging) { g.setColour (backgroundColour.contrasting()); g.drawRect (0, 0, w, h, 2); if (m_owner.m_owner.m_out) p.addArrow(Line<float>((float)arrowX1, 10, (float)arrowX2, 10), 5, 10, 5); else p.addArrow(Line<float>((float)arrowX2, 10, (float)arrowX1, 10), 5, 10, 5); g.saveState(); g.setGradientFill(cg); g.fillPath(p); g.restoreState(); } g.setColour (backgroundColour.contrasting()); g.setFont (h * 0.6f); if (m_owner.m_owner.m_out) { if (m_out_map_names[m_row].compare(" -")) { // currently mapped wdm channel name g.drawFittedText (m_out_map_names[m_row], mapChX, 0, mapChW, h, Justification::left, 1); // arrow p.addArrow(Line<float>((float)arrowX1, 10, (float)arrowX2, 10), 5, 10, 5); g.saveState(); g.setGradientFill(cg); g.fillPath(p); g.restoreState(); } if (m_out_ch_names[m_row].compare(String::empty)) { // device channel number g.drawFittedText (String::formatted("%i", m_row+1), devChX, 0, 15, h, Justification::right, 1); // device channel name g.drawFittedText (m_out_ch_names[m_row], devChX+25, 0, w-200, h, Justification::left, 2, 0.5f); } } else { if (m_in_map_names[m_row].compare(" -")) { // currently mapped wdm channel name g.drawFittedText (m_in_map_names[m_row], mapChX, 0, mapChW, h, Justification::left, 1); // gradient arrow p.addArrow(Line<float>((float)arrowX2, 10, (float)arrowX1, 10), 5, 10, 5); g.saveState(); g.setGradientFill(cg); g.fillPath(p); g.restoreState(); } if (m_in_ch_names[m_row].compare(String::empty)) { // device channel number g.drawFittedText (String::formatted("%i", m_row+1), devChX, 0, 15, h, Justification::right, 1); // device channel name g.drawFittedText (m_in_ch_names[m_row], devChX+25, 0, w-200, h, Justification::left, 1); } } }
void VehicleDemo::HandleUpdate(StringHash eventType, VariantMap& eventData) { using namespace Update; float timeStep = eventData[P_TIMESTEP].GetFloat(); Input* input = GetSubsystem<Input>(); if (vehicle_) { UI* ui = GetSubsystem<UI>(); // Get movement controls and assign them to the vehicle component. If UI has a focused element, clear controls if (!ui->GetFocusElement()) { vehicle_->controls_.Set(CTRL_FORWARD, input->GetKeyDown('W')); vehicle_->controls_.Set(CTRL_BACK, input->GetKeyDown('S')); vehicle_->controls_.Set(CTRL_LEFT, input->GetKeyDown('A')); vehicle_->controls_.Set(CTRL_RIGHT, input->GetKeyDown('D')); // Add yaw & pitch from the mouse motion or touch input. Used only for the camera, does not affect motion if (touchEnabled_) { for (unsigned i = 0; i < input->GetNumTouches(); ++i) { TouchState* state = input->GetTouch(i); if (!state->touchedElement_) // Touch on empty space { Camera* camera = cameraNode_->GetComponent<Camera>(); if (!camera) return; Graphics* graphics = GetSubsystem<Graphics>(); vehicle_->controls_.yaw_ += TOUCH_SENSITIVITY * camera->GetFov() / graphics->GetHeight() * state->delta_.x_; vehicle_->controls_.pitch_ += TOUCH_SENSITIVITY * camera->GetFov() / graphics->GetHeight() * state->delta_.y_; } } } else { vehicle_->controls_.yaw_ += (float)input->GetMouseMoveX() * YAW_SENSITIVITY; vehicle_->controls_.pitch_ += (float)input->GetMouseMoveY() * YAW_SENSITIVITY; } // Limit pitch vehicle_->controls_.pitch_ = Clamp(vehicle_->controls_.pitch_, 0.0f, 80.0f); // Check for loading / saving the scene if (input->GetKeyPress(KEY_F5)) { File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/VehicleDemo.xml", FILE_WRITE); scene_->SaveXML(saveFile); } if (input->GetKeyPress(KEY_F7)) { File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/VehicleDemo.xml", FILE_READ); scene_->LoadXML(loadFile); // After loading we have to reacquire the weak pointer to the Vehicle component, as it has been recreated // Simply find the vehicle's scene node by name as there's only one of them Node* vehicleNode = scene_->GetChild("Vehicle", true); if (vehicleNode) vehicle_ = vehicleNode->GetComponent<Vehicle>(); } } else vehicle_->controls_.Set(CTRL_FORWARD | CTRL_BACK | CTRL_LEFT | CTRL_RIGHT, false); } }
void ColourPickerActivity::OnDraw() { Graphics * g = GetGraphics(); //g->clearrect(Position.X-2, Position.Y-2, Size.X+3, Size.Y+3); g->fillrect(Position.X-2, Position.Y-2, Size.X+3, Size.Y+3, 0, 0, 0, currentAlpha); g->drawrect(Position.X, Position.Y, Size.X, Size.Y, 255, 255, 255, 255); g->drawrect(Position.X+4, Position.Y+4, 258, 130, 180, 180, 180, 255); g->drawrect(Position.X+4, Position.Y+4+4+128, 258, 12, 180, 180, 180, 255); int offsetX = Position.X+5; int offsetY = Position.Y+5; //draw color square int lastx = -1, currx = 0; for(int saturation = 0; saturation <= 255; saturation+=2) { for(int hue = 0; hue <= 359; hue++) { currx = clamp_flt(hue, 0, 359)+offsetX; if (currx == lastx) continue; lastx = currx; int cr = 0; int cg = 0; int cb = 0; HSV_to_RGB(hue, 255-saturation, currentValue, &cr, &cg, &cb); g->blendpixel(currx, (saturation/2)+offsetY, cr, cg, cb, currentAlpha); } } //draw brightness bar for(int value = 0; value <= 255; value++) for(int i = 0; i < 10; i++) { int cr = 0; int cg = 0; int cb = 0; HSV_to_RGB(currentHue, currentSaturation, value, &cr, &cg, &cb); g->blendpixel(value+offsetX, i+offsetY+127+5, cr, cg, cb, currentAlpha); } //draw color square pointer int currentHueX = clamp_flt(currentHue, 0, 359); int currentSaturationY = ((255-currentSaturation)/2); g->xor_line(offsetX+currentHueX, offsetY+currentSaturationY-5, offsetX+currentHueX, offsetY+currentSaturationY-1); g->xor_line(offsetX+currentHueX, offsetY+currentSaturationY+1, offsetX+currentHueX, offsetY+currentSaturationY+5); g->xor_line(offsetX+currentHueX-5, offsetY+currentSaturationY, offsetX+currentHueX-1, offsetY+currentSaturationY); g->xor_line(offsetX+currentHueX+1, offsetY+currentSaturationY, offsetX+currentHueX+5, offsetY+currentSaturationY); //draw brightness bar pointer int currentValueX = restrict_flt(currentValue, 0, 254); g->xor_line(offsetX+currentValueX, offsetY+4+128, offsetX+currentValueX, offsetY+13+128); g->xor_line(offsetX+currentValueX+1, offsetY+4+128, offsetX+currentValueX+1, offsetY+13+128); }
void SpikeDisplayCanvas::paint(Graphics& g) { g.fillAll(Colours::darkgrey); }
void MainContentComponent::paint (Graphics& g) { // (Our component is opaque, so we must completely fill the background with a solid colour) g.fillAll (Colours::lightgrey); // You can add your drawing code here! }
void setColour(Colour newColour) { m_graphics->setColour(newColour); }
void setFont(const Font& newFont){ m_graphics->setFont(newFont); }
void fillAll(Colour colourToUse) { m_graphics->fillAll(colourToUse); }
void MyPaint_Mem(HDC my_hdc) { Graphics *mygraphics; mygraphics = new Graphics(my_hdc); mygraphics->SetSmoothingMode(SmoothingModeAntiAlias); Pen *myRectangle_pen; Pen * my_inline_pen; Pen * CurePen; SolidBrush *BlackBrush; myRectangle_pen = new Pen(Color(255,0,255,255)); my_inline_pen = new Pen(Color(255,220,220,220)); REAL dashValues[2] = {5, 5}; //Pen blackPen(Color(255, 0, 0, 0), 5); my_inline_pen->SetDashPattern(dashValues, 2); CurePen = new Pen(Graphic_Color[1],3.0f); PointF pointF(0, 0); BlackBrush =new SolidBrush(Color(255,0,0,0)); mygraphics->FillRectangle(BlackBrush,X_ORIGIN,Y_ORIGIN,X_WIDTH,Y_HIGHT); mygraphics->DrawRectangle(myRectangle_pen,X_ORIGIN,Y_ORIGIN,X_WIDTH,Y_HIGHT); SolidBrush *Static_blackground_Brush; Pen *mystaticRectangle_pen; mystaticRectangle_pen = new Pen(Color(255,0,0,0),2.0f); Static_blackground_Brush =new SolidBrush(Color(255,187,187,187)); mygraphics->FillRectangle(Static_blackground_Brush,0,window_hight - 120,window_width,120); mygraphics->DrawRectangle(mystaticRectangle_pen,2,window_hight - 110,window_width-15,110 -30); SolidBrush time_brush(Color(255, 225, 225, 225)); FontFamily fontFamily(_T("Times New Roman")); Gdiplus::Font time_font(&fontFamily, 18, FontStyleRegular, UnitPixel); for(int i=0;i<x_line_scale;i++) //画网格线 { mygraphics->DrawLine(my_inline_pen,X_ORIGIN+(X_WIDTH/x_line_scale)*(i+1),Y_ORIGIN,X_ORIGIN+(X_WIDTH/x_line_scale)*(i+1),Y_ORIGIN + Y_HIGHT); CString strTime ; wchar_t temp_char[200]; //time_t test = old_early_time; //CTime timeTest(test); time_t test ; CTime timeTest; switch(scale_type) { case _6_min: break; case _1_hour: test = old_early_time + i*600; timeTest = test ; strTime = timeTest.Format("%Y/%m/%d\r\n %H:%M:%S"); pointF.X = X_ORIGIN - 40 + i*(X_WIDTH/x_line_scale); pointF.Y = Y_ORIGIN+Y_HIGHT + 10; mygraphics->DrawString(strTime, -1, &time_font, pointF, &time_brush); //old_early_time break; case _4_hour: break; case _12_hour: break; case _1_day: break; } } SolidBrush unit_brush(Graphic_Color[1]); FontFamily UnitfontFamily(_T("Times New Roman")); Gdiplus::Font unitfont(&UnitfontFamily, 18, FontStyleRegular, UnitPixel); for(int i=0;i<=y_line_scale;i++) //画网格线 { CString Unit_value; if(i!=y_line_scale) mygraphics->DrawLine(my_inline_pen,X_ORIGIN,Y_ORIGIN+(Y_HIGHT/y_line_scale)*(1+i),X_WIDTH + X_ORIGIN,Y_ORIGIN+(Y_HIGHT/y_line_scale)*(1+i)); if(i!=y_line_scale) Unit_value.Format(_T("%d"),(Total_SCALE/y_line_scale)*(y_line_scale-i));// = timeTest.Format("%Y/%m/%d\r\n %H:%M:%S"); else Unit_value.Format(_T("%d"),Min_Scale_value); pointF.X = X_ORIGIN - 30; pointF.Y = Y_ORIGIN+ i*(Y_HIGHT/y_line_scale); mygraphics->DrawString(Unit_value, -1, &unitfont, pointF, &unit_brush); //swprintf_s(temp_char,200,L"%d",i*5); //mygraphics->DrawString(temp_char, -1, &font, pointF, &brush); } for (int i=1;i<=14;i++) { CString temp_item; temp_item.Format(_T("%x"),i); temp_item = temp_item.MakeUpper(); SolidBrush static_item_brush(Graphic_Color[i]); FontFamily UnitfontFamily(_T("Arial Black")); Gdiplus::Font unitfont(&UnitfontFamily, 22, FontStyleRegular, UnitPixel); pointF.X = Static_Num_Rect[i].left; pointF.Y = Static_Num_Rect[i].top; mygraphics->DrawString(temp_item, -1, &unitfont, pointF, &static_item_brush); } CPointItem *first_item=NULL,*second_item=NULL,*third_item=NULL; first_item = m_pFirstItem; //******************************************** //直线 for (int i=0;i<60;i=i+1) { second_item=first_item->GetNext(); if(second_item==NULL) break; CurePen->SetStartCap(LineCapArrowAnchor); CurePen->SetEndCap(LineCapRoundAnchor); mygraphics->DrawLine(CurePen,first_item->GetPoint().x,first_item->GetPoint().y,second_item->GetPoint().x,second_item->GetPoint().y); first_item = second_item; } //******************************************** #if 0 for (int i=0;i<60;i=i+2) //for (int i=0;i<m_monitor_block.index - 1;i=i+2) //画贝塞尔曲线,使得线条平滑;3个点一画; TEST //for (int i=0;i<Total_count-1;i=i+2) //画贝塞尔曲线,使得线条平滑;3个点一画; { second_item=first_item->GetNext(); third_item = second_item->GetNext(); if(second_item==NULL) break; if(third_item == NULL) { first_item = second_item; break; } //mygraphics->DrawCurve(CurePen,, 3, 1.5f); //取3个点给画曲线的GDI函数; Point myPointArray[] = {Point(first_item->GetPoint().x,first_item->GetPoint().y), Point(second_item->GetPoint().x,second_item->GetPoint().y), Point(third_item->GetPoint().x,third_item->GetPoint().y)}; CurePen->SetStartCap(LineCapArrowAnchor); CurePen->SetEndCap(LineCapRoundAnchor); mygraphics->DrawCurve(CurePen,myPointArray, 3, 1.0f); first_item = third_item; } #endif delete CurePen; delete mygraphics; delete myRectangle_pen; delete my_inline_pen; delete BlackBrush; }
void HomeMenu::paint (Graphics& g) { g.fillAll (Colour::fromRGB(49, 49, 49)); }
void MyPaint_Mem(HDC my_hdc) { Graphics *mygraphics; mygraphics = new Graphics(my_hdc); mygraphics->SetSmoothingMode(SmoothingModeAntiAlias); Pen *myRectangle_pen; Pen * my_inline_pen; Pen * CurePen; SolidBrush *BlackBrush; myRectangle_pen = new Pen(Color(255,0,255,255)); my_inline_pen = new Pen(Color(255,0,128,64)); CurePen = new Pen(Color(255,0,255,0)); m_interval = (m_interval++)%5; //让其向左平移; if(runonce < 2) //初始化时画背景图案; { runonce ++; //Image myImage(L"texture.BMP"); //TextureBrush myTextureBrush(&myImage); //RECT newrect_now; //GetWindowRect(myhWnd,&newrect_now); //mygraphics->FillRectangle(&myTextureBrush, 0, 0, newrect_now.right, newrect_now.bottom); SolidBrush brush(Color(255, 0, 0, 255)); FontFamily fontFamily(_T("Times New Roman")); Gdiplus::Font font(&fontFamily, 24, FontStyleRegular, UnitPixel); PointF pointF(40.0f, 600.0f); for(int i=0;i<=20;i=i+2) //增加文字 %; { pointF.Y = 600; pointF.Y = pointF.Y - i*30; wchar_t temp_char[200]; //swprintf_s(temp_char,200,L"%d%%",i*5); swprintf_s(temp_char,200,L"%d",i*5); mygraphics->DrawString(temp_char, -1, &font, pointF, &brush); } pointF.X = 200; pointF.Y = 650; //mygraphics->DrawString(L"CPU 使用率", -1, &font, pointF, &brush); } //BlackBrush =new SolidBrush(Color(255,0,0,0)); BlackBrush =new SolidBrush(Color(255,0,0,0)); mygraphics->FillRectangle(BlackBrush,100,10,1200,600); mygraphics->DrawRectangle(myRectangle_pen,100,10,1200,600); for(int i=0;i<=39;i++) //画网格线 mygraphics->DrawLine(my_inline_pen,100+line_interval*(i+1)-m_interval*6,10,100+line_interval*(i+1)-m_interval*6,610); for(int i=0;i<19;i++) //画网格线 mygraphics->DrawLine(my_inline_pen,100,10+line_interval*(1+i),1300,10+line_interval*(1+i)); #if 0 CPointItem *first_item=NULL,*second_item=NULL; first_item = m_pFirstItem; for (int i=0;i<Total_count-1;i++) { second_item=first_item->GetNext(); if(second_item==NULL) break; //mygraphics->DrawCurve(CurePen,, 3, 1.5f); //Point myPointArray[] = //{Point(first_item->GetPoint().x,first_item->GetPoint().y),Point(second_item->GetPoint().x,second_item->GetPoint().y)}; //mygraphics->DrawCurve(CurePen,myPointArray, 2, 1.0f); //mygraphics->DrawLine(CurePen,first_item->GetPoint().x,first_item->GetPoint().y,second_item->GetPoint().x,second_item->GetPoint().y); first_item = second_item; } #endif #if 1 CPointItem *first_item=NULL,*second_item=NULL,*third_item=NULL; first_item = m_pFirstItem; for (int i=0;i<Total_count-1;i=i+2) //画贝塞尔曲线,使得线条平滑;3个点一画; { second_item=first_item->GetNext(); third_item = second_item->GetNext(); if(second_item==NULL) break; if(third_item == NULL) { first_item = second_item; break; } //mygraphics->DrawCurve(CurePen,, 3, 1.5f); //取3个点给画曲线的GDI函数; Point myPointArray[] = {Point(first_item->GetPoint().x,first_item->GetPoint().y), Point(second_item->GetPoint().x,second_item->GetPoint().y), Point(third_item->GetPoint().x,third_item->GetPoint().y)}; mygraphics->DrawCurve(CurePen,myPointArray, 3, 1.0f); //mygraphics->DrawLine(CurePen,first_item->GetPoint().x,first_item->GetPoint().y,second_item->GetPoint().x,second_item->GetPoint().y); first_item = third_item; } #endif // mygraphics->DrawLine(CurePen,) delete CurePen; delete mygraphics; delete myRectangle_pen; delete my_inline_pen; delete BlackBrush; }
//============================================================================== void Statusbar::paint (Graphics& g) { //[UserPrePaint] Add your own custom painting code here.. //[/UserPrePaint] g.setColour (Colour (0xff181818)); g.fillRoundedRectangle (0.0f, 0.0f, static_cast<float> (getWidth() - 0), static_cast<float> (getHeight() - 0), 10.000f); g.setColour (Colours::white); g.drawRoundedRectangle (0.0f, 0.0f, static_cast<float> (getWidth() - 0), static_cast<float> (getHeight() - 0), 10.000f, 1.000f); g.setColour (Colours::black); g.fillRoundedRectangle (168.0f, 4.0f, static_cast<float> (getWidth() - 336), 16.0f, 10.000f); g.setColour (Colours::white); g.drawRoundedRectangle (168.0f, 4.0f, static_cast<float> (getWidth() - 336), 16.0f, 10.000f, 1.000f); g.setColour (Colours::black); g.fillRoundedRectangle (static_cast<float> (getWidth() - 4 - 160), 4.0f, 160.0f, 16.0f, 10.000f); g.setColour (Colours::white); g.drawRoundedRectangle (static_cast<float> (getWidth() - 4 - 160), 4.0f, 160.0f, 16.0f, 10.000f, 1.000f); g.setColour (Colours::black); g.fillRoundedRectangle (4.0f, 4.0f, 160.0f, 16.0f, 10.000f); g.setColour (Colours::white); g.drawRoundedRectangle (4.0f, 4.0f, 160.0f, 16.0f, 10.000f, 1.000f); //[UserPaint] Add your own custom painting code here.. //[/UserPaint] }
void SurfaceComponent::paint (Graphics& g) { Colour backgroundColour = Config::getInstance ()->getColour (T("mainBackground")); g.fillAll (backgroundColour); }
void mlrVSTLookAndFeel::drawScrollbar (Graphics& g, ScrollBar& bar, int x, int y, int width, int height, bool isScrollbarVertical, int thumbStartPosition, int thumbSize, bool isMouseOver, bool isMouseDown) { g.fillAll (bar.findColour (ScrollBar::backgroundColourId)); g.setColour (bar.findColour (ScrollBar::thumbColourId) .withAlpha ((isMouseOver || isMouseDown) ? 0.4f : 0.15f)); if (thumbSize > 0.0f) { Rectangle<int> thumb; if (isScrollbarVertical) { width -= 2; g.fillRect (x + roundToInt (width * 0.35f), y, roundToInt (width * 0.3f), height); thumb.setBounds (x + 1, thumbStartPosition, width - 2, thumbSize); } else { height -= 2; g.fillRect (x, y + roundToInt (height * 0.35f), width, roundToInt (height * 0.3f)); thumb.setBounds (thumbStartPosition, y + 1, thumbSize, height - 2); } g.setColour (bar.findColour (ScrollBar::thumbColourId) .withAlpha ((isMouseOver || isMouseDown) ? 0.95f : 0.7f)); g.fillRect (thumb); g.setColour (Colours::black.withAlpha ((isMouseOver || isMouseDown) ? 0.4f : 0.25f)); g.drawRect (thumb.getX(), thumb.getY(), thumb.getWidth(), thumb.getHeight()); if (thumbSize > 16) { for (int i = 3; --i >= 0;) { const float linePos = thumbStartPosition + thumbSize / 2 + (i - 1) * 4.0f; g.setColour (Colours::black.withAlpha (0.15f)); if (isScrollbarVertical) { g.drawLine (x + width * 0.2f, linePos, width * 0.8f, linePos); g.setColour (Colours::white.withAlpha (0.15f)); g.drawLine (width * 0.2f, linePos - 1, width * 0.8f, linePos - 1); } else { g.drawLine (linePos, height * 0.2f, linePos, height * 0.8f); g.setColour (Colours::white.withAlpha (0.15f)); g.drawLine (linePos - 1, height * 0.2f, linePos - 1, height * 0.8f); } } } } }
void Window::DoDraw() { OnDraw(); for (int i = 0, sz = Components.size(); i < sz; ++i) if (Components[i]->Visible && ((Components[i] != focusedComponent_ && Components[i] != hoverComponent) || Components[i]->GetParent())) { Point scrpos(Components[i]->Position.X + Position.X, Components[i]->Position.Y + Position.Y); if (AllowExclusiveDrawing) { Components[i]->Draw(scrpos); } else { if (scrpos.X + Components[i]->Size.X >= 0 && scrpos.Y + Components[i]->Size.Y >= 0 && scrpos.X < ui::Engine::Ref().GetWidth() && scrpos.Y < ui::Engine::Ref().GetHeight()) { Components[i]->Draw(scrpos); } } #ifdef DEBUG if (debugMode) { if (focusedComponent_==Components[i]) { ui::Engine::Ref().g->fillrect(Components[i]->Position.X+Position.X, Components[i]->Position.Y+Position.Y, Components[i]->Size.X, Components[i]->Size.Y, 0, 255, 0, 90); } else { ui::Engine::Ref().g->fillrect(Components[i]->Position.X+Position.X, Components[i]->Position.Y+Position.Y, Components[i]->Size.X, Components[i]->Size.Y, 255, 0, 0, 90); } } #endif } // the component the mouse is hovering over and the focused component are always drawn last if (hoverComponent && hoverComponent->Visible && hoverComponent->GetParent() == NULL) { Point scrpos(hoverComponent->Position.X + Position.X, hoverComponent->Position.Y + Position.Y); if ((scrpos.X + hoverComponent->Size.X >= 0 && scrpos.Y + hoverComponent->Size.Y >= 0 && scrpos.X < ui::Engine::Ref().GetWidth() && scrpos.Y < ui::Engine::Ref().GetHeight() ) || AllowExclusiveDrawing) { hoverComponent->Draw(scrpos); } } if (focusedComponent_ && focusedComponent_ != hoverComponent && focusedComponent_->Visible && focusedComponent_->GetParent() == NULL) { Point scrpos(focusedComponent_->Position.X + Position.X, focusedComponent_->Position.Y + Position.Y); if ((scrpos.X + focusedComponent_->Size.X >= 0 && scrpos.Y + focusedComponent_->Size.Y >= 0 && scrpos.X < ui::Engine::Ref().GetWidth() && scrpos.Y < ui::Engine::Ref().GetHeight() ) || AllowExclusiveDrawing) { focusedComponent_->Draw(scrpos); } } #ifdef DEBUG if (debugMode) { if (focusedComponent_) { int xPos = focusedComponent_->Position.X+focusedComponent_->Size.X+5+Position.X; Graphics * g = ui::Engine::Ref().g; char tempString[512]; char tempString2[512]; sprintf(tempString, "Position: L %d, R %d, T: %d, B: %d", focusedComponent_->Position.X, Size.X-(focusedComponent_->Position.X+focusedComponent_->Size.X), focusedComponent_->Position.Y, Size.Y-(focusedComponent_->Position.Y+focusedComponent_->Size.Y)); sprintf(tempString2, "Size: %d, %d", focusedComponent_->Size.X, focusedComponent_->Size.Y); if (Graphics::textwidth(tempString)+xPos > WINDOWW) xPos = WINDOWW-(Graphics::textwidth(tempString)+5); if (Graphics::textwidth(tempString2)+xPos > WINDOWW) xPos = WINDOWW-(Graphics::textwidth(tempString2)+5); g->drawtext(xPos, focusedComponent_->Position.Y+Position.Y+1, tempString, 0, 0, 0, 200); g->drawtext(xPos, focusedComponent_->Position.Y+Position.Y, tempString, 255, 255, 255, 255); g->drawtext(xPos, focusedComponent_->Position.Y+Position.Y+13, tempString2, 0, 0, 0, 200); g->drawtext(xPos, focusedComponent_->Position.Y+Position.Y+12, tempString2, 255, 255, 255, 255); } return; } #endif }
void mlrVSTLookAndFeel::drawMenuBarBackground (Graphics& g, int /*width*/, int /*height*/, bool, MenuBarComponent& menuBar) { g.fillAll(menuBar.findColour (PopupMenu::backgroundColourId)); }
//============================================================================== void MidiSlider::paint (Graphics& g) { g.fillAll(Colours::white); }
void mlrVSTLookAndFeel::drawLinearSlider (Graphics& g, int x, int y, int w, int h, float sliderPos, float minSliderPos, float maxSliderPos, const Slider::SliderStyle style, Slider& slider) { g.fillAll (slider.findColour (Slider::backgroundColourId)); if (style == Slider::LinearBar) { g.setColour (slider.findColour (Slider::thumbColourId)); g.fillRect (x, y, (int) sliderPos - x, h); g.setColour (slider.findColour (Slider::textBoxTextColourId).withMultipliedAlpha (0.5f)); g.drawRect (x, y, (int) sliderPos - x, h); } else if (style == Slider::LinearVertical) { const int height = slider.getBounds().getHeight(); g.setColour (slider.findColour (Slider::thumbColourId)); g.fillRect (x, height - (int)(slider.getValue() * height), w, (int)(slider.getValue() * height)); g.setColour (slider.findColour (Slider::thumbColourId).darker(0.7f)); g.drawRect (x, height - (int)(slider.getValue() * height), w, (int)(slider.getValue() * height)); } else { g.setColour (slider.findColour (Slider::trackColourId) .withMultipliedAlpha (slider.isEnabled() ? 1.0f : 0.3f)); if (slider.isHorizontal()) { g.fillRect (x, y + roundToInt (h * 0.6f), w, roundToInt (h * 0.2f)); } else { g.fillRect (x + roundToInt (w * 0.5f - jmin (3.0f, w * 0.1f)), y, jmin (4, roundToInt (w * 0.2f)), h); } float alpha = 0.35f; if (slider.isEnabled()) alpha = slider.isMouseOverOrDragging() ? 1.0f : 0.7f; const Colour fill (slider.findColour (Slider::thumbColourId).withAlpha (alpha)); const Colour outline (Colours::black.withAlpha (slider.isEnabled() ? 0.7f : 0.35f)); if (style == Slider::TwoValueVertical || style == Slider::ThreeValueVertical) { drawTriangle (g, x + w * 0.5f + jmin (4.0f, w * 0.3f), minSliderPos, x + w * 0.5f - jmin (8.0f, w * 0.4f), minSliderPos - 7.0f, x + w * 0.5f - jmin (8.0f, w * 0.4f), minSliderPos, fill, outline); drawTriangle (g, x + w * 0.5f + jmin (4.0f, w * 0.3f), maxSliderPos, x + w * 0.5f - jmin (8.0f, w * 0.4f), maxSliderPos, x + w * 0.5f - jmin (8.0f, w * 0.4f), maxSliderPos + 7.0f, fill, outline); } else if (style == Slider::TwoValueHorizontal || style == Slider::ThreeValueHorizontal) { drawTriangle (g, minSliderPos, y + h * 0.6f - jmin (4.0f, h * 0.3f), minSliderPos - 7.0f, y + h * 0.9f , minSliderPos, y + h * 0.9f, fill, outline); drawTriangle (g, maxSliderPos, y + h * 0.6f - jmin (4.0f, h * 0.3f), maxSliderPos, y + h * 0.9f, maxSliderPos + 7.0f, y + h * 0.9f, fill, outline); } if (style == Slider::LinearHorizontal || style == Slider::ThreeValueHorizontal) { drawTriangle (g, sliderPos, y + h * 0.9f, sliderPos - 7.0f, y + h * 0.2f, sliderPos + 7.0f, y + h * 0.2f, fill, outline); } else if (style == Slider::LinearVertical || style == Slider::ThreeValueVertical) { drawTriangle (g, x + w * 0.5f - jmin (4.0f, w * 0.3f), sliderPos, x + w * 0.5f + jmin (8.0f, w * 0.4f), sliderPos - 7.0f, x + w * 0.5f + jmin (8.0f, w * 0.4f), sliderPos + 7.0f, fill, outline); } } }
void ResourceEditorPanel::paintRowBackground (Graphics& g, int /*rowNumber*/, int /*width*/, int /*height*/, bool rowIsSelected) { if (rowIsSelected) g.fillAll (findColour (defaultHighlightColourId)); }
bool onFrame(){ gl.clearColor(0,0,0,0); gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT); gl.viewport(0,0, width(), height()); gl.matrixMode(gl.PROJECTION); gl.loadMatrix(Matrix4d::perspective(45, aspect(), 0.1, 100)); gl.matrixMode(gl.MODELVIEW); gl.loadMatrix(Matrix4d::lookAt(Vec3d(0,0,-8), Vec3d(0,0,0), Vec3d(0,1,0))); gl.depthTesting(1); gl.blending(0); material(); light(); angle += 1./8000; gl.pushMatrix(gl.MODELVIEW); //gl.translate(R*cos(i*angPos), R*sin(i*angPos), 0); gl.rotate(angle*113, 0,1,0); gl.rotate(angle* 79, 1,0,0); gl.draw(shapes); gl.popMatrix(); return true; }
void MainContentComponent::paint (Graphics& g) { g.fillAll (Colour (0xffeeddff)); }
void MasterControls::paint(Graphics &g){ g.setColour(Colours::black); g.drawSingleLineText("Master", 0, 110); }
void Game::run() { Graphics graphics; player.reset(new Player(graphics, 4 * 32, 4 * 32)); enemies.emplace_back(new Enemy(graphics, 8 * 32, 4 * 32)); map.reset(map->generateDebugMap(graphics)); Camera camera { Constants::SCREEN_WIDTH, Constants::SCREEN_HEIGHT }; uint32_t previousFrameTime = SDL_GetTicks(); while(true) { uint32_t frameStart = SDL_GetTicks(); SDL_Event e; //This is bad - Consider having something observe the player report on movements? auto pos = player->getPosition(); while (SDL_PollEvent(&e) != 0) { if (e.type == SDL_KEYDOWN){ switch (e.key.keysym.sym) { case SDLK_RIGHT: player->startMovingRight(); break; case SDLK_LEFT: player->startMovingLeft(); break; case SDLK_UP: player->startJump(); break; case SDLK_BACKSPACE: enemies.emplace_back(new Enemy(graphics, 8 * 32, 4 * 32)); break; case SDLK_RETURN: //Considering moving this to the player instead, however, this solution seems ok for now //Might add something that restricts the amount of bullets being fired player->shoot(); projectiles.emplace_back( new Projectile(graphics, pos.x, pos.y, 0.7f * player->get_facing())); break; case SDLK_F12: player->enableDebug(); break; case SDLK_ESCAPE: exit(0); break; } } else if (e.type == SDL_KEYUP){ switch (e.key.keysym.sym) { case SDLK_RIGHT: player->stopMoving(); case SDLK_LEFT: player->stopMoving(); } } } uint32_t currentTime = SDL_GetTicks(); const int timeSpentThisFrame = currentTime - previousFrameTime; update(std::min(timeSpentThisFrame, MAX_FRAME_TIME)); updateCamera(camera); previousFrameTime = currentTime; draw(graphics, camera); uint32_t target_ms = 1000 / FPS; const uint32_t elapsedTime = SDL_GetTicks() - frameStart; if (elapsedTime < target_ms) { //Do nothing - Waste time to reach limit frame rate. SDL_Delay(target_ms - elapsedTime); } graphics.update_FPS(std::to_string(elapsedTime)); }//while }
//------------------------------------------------------------------------------ void StartupPreferences::paintOverChildren(Graphics &g) { //Startup program list. g.setColour(backgroundColour.contrasting().withAlpha(0.1f)); g.drawRect(8, 23, 154, 284, 1); g.setColour(backgroundColour.contrasting().withAlpha(0.3f)); g.drawRect(9, 24, 152, 282, 1); //Startup text. g.setColour(backgroundColour.contrasting().withAlpha(0.1f)); g.drawRect(168, 23, 154, 24, 1); g.setColour(backgroundColour.contrasting().withAlpha(0.3f)); g.drawRect(169, 24, 152, 22, 1); //Startup executable. g.setColour(backgroundColour.contrasting().withAlpha(0.1f)); g.drawRect(168, 75, 154, 24, 1); g.setColour(backgroundColour.contrasting().withAlpha(0.3f)); g.drawRect(169, 76, 152, 22, 1); }